AxisCare API & Webhook Reference

const AXC = {
  site: process.env.AXISCARE_SITE || '13131',
  token: process.env.AXISCARE_TOKEN,
  version: '2023-10-01',
  get base() { return `https://${this.site}.axiscare.com/api`; },
  get headers() {
    return {
      'Authorization': `Bearer ${this.token}`,
      'X-AxisCare-Api-Version': this.version,
      'Content-Type': 'application/json',
    };
  },
};

async function fetchAllPages(endpoint, params = {}) {
  const all = [];
  let cursor = null;

  do {
    const url = new URL(`${AXC.base}${endpoint}`);
    Object.entries(params).forEach(([k, v]) => url.searchParams.set(k, v));
    if (cursor) url.searchParams.set('startAfterId', cursor);

    const res = await fetch(url, { headers: AXC.headers });
    if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);

    const json = await res.json();
    const items = Array.isArray(json) ? json : json.data || [];
    all.push(...items);

    // Determine next cursor
    cursor = json.nextPageToken || (items.length ? items[items.length - 1].id : null);
  } while (cursor);

  return all;
}

async function axcFetch(path, options = {}, retries = 3) {
  const url = `${AXC.base}${path}`;
  for (let i = 0; i < retries; i++) {
    try {
      const res = await fetch(url, {
        ...options,
        headers: { ...AXC.headers, ...options.headers },
      });
      if (res.status === 429) {
        await new Promise(r => setTimeout(r, 2000 * (i + 1)));
        continue;
      }
      return res;
    } catch (err) {
      if (i === retries - 1) throw err;
      await new Promise(r => setTimeout(r, 1000 * (i + 1)));
    }
  }
}

const express = require('express');
const app = express();
app.use(express.json());

app.post('/webhooks/axiscare', (req, res) => {
  const { event, data, siteNumber } = req.body;
  const webhookId = req.headers['x-webhook-id'];

  console.log(`[Webhook] ${event} site=${siteNumber} id=${webhookId}`);

  // Process by event type
  switch (event) {
    case 'scheduling.visit.clockedIn':
      handleClockIn(data);
      break;
    case 'scheduling.visit.remove':
      handleVisitRemoved(data);
      break;
    case 'client.updated':
      handleClientUpdate(data);
      break;
    default:
      console.log(`Unhandled event: ${event}`);
  }

  // Respond quickly (within 5s)
  res.status(200).json({ received: true });
});

const VALID_EVV_METHODS = ['GPS', 'Telephony'];

function checkEVVCompliance(visit) {
  const needsEVV = visit.serviceCode?.startsWith('BA');
  if (!needsEVV) return { required: false, compliant: true };

  const checks = {
    clockedIn: !!visit.clockInTime,
    clockedOut: !!visit.clockOutTime,
    validClockInMethod: VALID_EVV_METHODS.includes(visit.clockInMethod),
    validClockOutMethod: VALID_EVV_METHODS.includes(visit.clockOutMethod),
  };

  return {
    required: true,
    compliant: Object.values(checks).every(Boolean),
    checks,
  };
}

async function findAvailableCaregivers(date, startTime, endTime) {
  // 1. Get all active caregivers
  const caregivers = await fetchAllPages('/caregivers', { statuses: 'Active' });

  // 2. Get visits for the date
  const visits = await fetchAllPages('/visits', {
    startDate: date,
    endDate: date,
  });

  // 3. Find caregivers without overlapping visits
  const busyIds = new Set(
    visits
      .filter(v => v.startTime < endTime && v.endTime > startTime)
      .map(v => v.caregiverId)
  );

  return caregivers.filter(c => !busyIds.has(c.id));
}