Read a Project's Schedule

curl https://api.vomo.org/v1/projects/789 \
  -H "Authorization: Bearer $VOMO_API_TOKEN"

async function getNextShiftForProject(projectId) {
  const project = await getProjectDetail(projectId);
  return project?.next_date ?? null;
}

// Usage
const next = await getNextShiftForProject(789);
if (next) {
  console.log(`Next shift: ${next.starts_at} (${next.participant_count} volunteers signed up)`);
}

curl https://api.vomo.org/v1/projects/today \
  -H "Authorization: Bearer $VOMO_API_TOKEN"

async function getTodayGroupedByProject() {
  const response = await fetch(
    'https://api.vomo.org/v1/projects/today',
    { headers: { Authorization: `Bearer ${token}` } }
  );
  const today = await response.json();

  // Each happening doesn't include the Project name directly — to display nicely,
  // call GET /projects/date/{id} per Happening to get the project_name
  const enriched = await Promise.all(
    today.data.map(async (happening) => {
      const date = await getProjectDate(happening.id);
      return {
        ...happening,
        projectName: date?.data?.project_name,
        projectId: date?.data?.project_id,
      };
    })
  );

  // Group by Project
  const byProject = new Map();
  for (const item of enriched) {
    if (!byProject.has(item.projectId)) {
      byProject.set(item.projectId, {
        projectName: item.projectName,
        projectId: item.projectId,
        shifts: [],
      });
    }
    byProject.get(item.projectId).shifts.push({
      id: item.id,
      starts_at: item.starts_at,
      ends_at: item.ends_at,
      participant_count: item.participant_count,
    });
  }

  return Array.from(byProject.values());
}

class TodayCache {
  constructor({ ttlMs = 5 * 60 * 1000 }) {
    this.ttlMs = ttlMs;
    this.dateDetailCache = new Map(); // dateId → { detail, cachedAt }
  }

  async getDateDetail(dateId) {
    const cached = this.dateDetailCache.get(dateId);
    if (cached && Date.now() - cached.cachedAt < this.ttlMs) {
      return cached.detail;
    }

    const detail = await getProjectDate(dateId);
    this.dateDetailCache.set(dateId, { detail, cachedAt: Date.now() });
    return detail;
  }
}

async function findProjectsWithCapacity(maxParticipants = 50) {
  // 1. Get upcoming, active Projects
  const now = new Date().toISOString();
  const futureCutoff = new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString();

  const params = new URLSearchParams({
    active: 'true',
    published: 'true',
    dates_after: now,
    dates_before: futureCutoff,
  });

  const upcomingProjects = await paginate(
    `https://api.vomo.org/v1/projects?${params}`
  );

  // 2. For each Project, check the next Date's capacity
  const available = [];
  for (const projectSummary of upcomingProjects) {
    const project = await getProjectDetail(projectSummary.id);
    const next = project?.next_date;

    if (next && next.participant_count < maxParticipants) {
      available.push({
        project,
        nextShift: next,
        availableSpots: maxParticipants - next.participant_count,
      });
    }
  }

  return available;
}

async function findShiftsWithCapacity(projectId, openSlotsNeeded) {
  const project = await getProjectDetail(projectId);
  const maxCapacity = 50; // From elsewhere — maybe configured per Project

  return (project?.all_dates ?? [])
    .filter((d) => maxCapacity - d.participant_count >= openSlotsNeeded)
    .filter((d) => new Date(d.starts_at) > new Date()); // Future only
}

curl https://api.vomo.org/v1/projects/date/1011 \
  -H "Authorization: Bearer $VOMO_API_TOKEN"

function parseProjectDateParticipants(raw) {
  return (raw.participants ?? []).map((p) => ({
    userId: p.id,
    email: p.email,
    guests: p.guests ?? 0,
    checkedInAt: p.checked_in_at ? new Date(p.checked_in_at) : null,
    checkedOutAt: p.checked_out_at ? new Date(p.checked_out_at) : null,
    signedUpAt: p.signed_up_at ? new Date(p.signed_up_at) : null,
    // hours: spec says integer but live returns string fractional value
    hours: typeof p.hours === 'string' ? parseFloat(p.hours) : (p.hours ?? 0),
    verified: p.verified === 1 || p.verified === true,
    role: p.role ?? 'Volunteer',
    projectId: p.project_id,
    projectDateId: p.project_date_id,
  }));
}

async function generateProjectIcal(projectId) {
  const project = await getProjectDetail(projectId);
  if (!project) throw new Error(`Project ${projectId} not found`);

  const events = (project.all_dates ?? []).map((date) => ({
    uid: `vomo-project-date-${date.id}@vomo.org`,
    summary: project.name,
    description: project.description,
    location: project.address?.formatted_address ?? '',
    start: new Date(date.starts_at),
    end: new Date(date.ends_at),
    url: project.url,
  }));

  return buildIcalString(events);
}

function buildIcalString(events) {
  const lines = [
    'BEGIN:VCALENDAR',
    'VERSION:2.0',
    'PRODID:-//Volunteer Integration//EN',
  ];

  for (const event of events) {
    lines.push('BEGIN:VEVENT');
    lines.push(`UID:${event.uid}`);
    lines.push(`SUMMARY:${escapeIcal(event.summary)}`);
    lines.push(`DESCRIPTION:${escapeIcal(event.description)}`);
    lines.push(`LOCATION:${escapeIcal(event.location)}`);
    lines.push(`DTSTART:${formatIcalDate(event.start)}`);
    lines.push(`DTEND:${formatIcalDate(event.end)}`);
    if (event.url) lines.push(`URL:${event.url}`);
    lines.push('END:VEVENT');
  }

  lines.push('END:VCALENDAR');
  return lines.join('\r\n');
}

function formatIcalDate(date) {
  return date.toISOString().replace(/[-:.]/g, '').replace('000Z', 'Z');
}

function escapeIcal(s) {
  return (s ?? '').replace(/[\\,;]/g, '\\$&').replace(/\n/g, '\\n');
}

async function getAllUpcomingShifts(maxDaysOut = 14) {
  const now = new Date();
  const cutoff = new Date(now.getTime() + maxDaysOut * 24 * 60 * 60 * 1000);

  // 1. Get Projects with dates in the window
  const params = new URLSearchParams({
    active: 'true',
    published: 'true',
    dates_after: now.toISOString(),
    dates_before: cutoff.toISOString(),
  });

  const projects = await paginate(`https://api.vomo.org/v1/projects?${params}`);

  // 2. For each Project, fetch detail to get all_dates (parallelizable)
  const allShifts = [];
  for (const projectSummary of projects) {
    const project = await getProjectDetail(projectSummary.id);
    const futureShifts = (project?.all_dates ?? []).filter((d) => {
      const dStart = new Date(d.starts_at);
      return dStart >= now && dStart <= cutoff;
    });

    for (const shift of futureShifts) {
      allShifts.push({
        projectId: project.id,
        projectName: project.name,
        shiftId: shift.id,
        startsAt: new Date(shift.starts_at),
        endsAt: new Date(shift.ends_at),
        participantCount: shift.participant_count,
      });
    }
  }

  // 3. Sort chronologically
  return allShifts.sort((a, b) => a.startsAt - b.startsAt);
}

async function getAllUpcomingShiftsCached(customerId, maxDaysOut = 14) {
  const cacheKey = `upcoming_shifts_${customerId}_${maxDaysOut}`;
  const cached = await cache.get(cacheKey);
  if (cached && Date.now() - cached.fetchedAt < 5 * 60 * 1000) {
    return cached.shifts;
  }

  const shifts = await getAllUpcomingShifts(maxDaysOut);
  await cache.set(cacheKey, { shifts, fetchedAt: Date.now() });
  return shifts;
}