Projects & Project Dates

curl "https://api.vomo.org/v1/projects?page=1&active=true&published=true" \
  -H "Authorization: Bearer $VOMO_API_TOKEN"

async function activePublishedProjects() {
  const params = new URLSearchParams({
    active: 'true',
    published: 'true',
  });

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

async function upcomingProjects() {
  const now = new Date();
  const thirtyDaysOut = new Date(now.getTime() + 30 * 24 * 60 * 60 * 1000);

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

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

async function projectsForChildOrg(orgSlug) {
  const params = new URLSearchParams({ org_slug: orgSlug });
  return paginate(`https://api.vomo.org/v1/projects?${params}`);
}

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

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

  if (response.status === 404) return null;
  if (!response.ok) throw new Error(`Failed: ${response.status}`);

  const result = await response.json();
  return parseProjectDetail(result.data);
}

curl -X POST https://api.vomo.org/v1/projects \
  -H "Authorization: Bearer $VOMO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Saturday Food Bank Volunteer Shift",
    "description": "Sort donated food, pack boxes for delivery",
    "address": {
      "street": "123 Charity Lane",
      "city": "Gotham",
      "state": "NJ",
      "postal_code": "10001"
    },
    "age_limit": 16,
    "allow_guests": true,
    "draft": false
  }'

curl -X PUT https://api.vomo.org/v1/projects/789 \
  -H "Authorization: Bearer $VOMO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Saturday Food Bank Volunteer Shift",
    "description": "Updated description with new details",
    "age_limit": 18,
    /* ... all other fields ... */
  }'

async function updateProjectDescription(projectId, newDescription) {
  // 1. Fetch current state
  const current = await getProjectDetail(projectId);
  if (!current) throw new Error('Project not found');

  // 2. Apply changes
  const updated = {
    ...current,
    description: newDescription,
  };

  // 3. PUT the full record
  const response = await fetch(
    `https://api.vomo.org/v1/projects/${projectId}`,
    {
      method: 'PUT',
      headers: {
        Authorization: `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(updated),
    }
  );

  if (!response.ok) throw new Error(`Update failed: ${response.status}`);
  return response.json();
}

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

  if (response.status === 404) return null;
  if (!response.ok) throw new Error(`Failed: ${response.status}`);

  return response.json();
}

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

  return today.data.map((happening) => ({
    id: happening.id,
    timeWindow: `${formatTime(happening.starts_at)}–${formatTime(happening.ends_at)}`,
    participantCount: happening.participant_count,
  }));
}

async function getProjectSchedule(projectId) {
  const project = await getProjectDetail(projectId);
  return project?.all_dates ?? [];
}

async function findProjectsWithCapacity(maxParticipants = 50) {
  const upcoming = await upcomingProjects();
  const withDetail = await Promise.all(
    upcoming.map((p) => getProjectDetail(p.id))
  );

  return withDetail.filter((p) => {
    const next = p?.next_date;
    return next && next.participant_count < maxParticipants;
  });
}

async function syncProjectsToExternal(customerId) {
  const lastSync = await getCheckpoint(customerId);

  const params = new URLSearchParams({
    updated_after: lastSync.toISOString(),
  });

  let url = `https://api.vomo.org/v1/projects?${params}`;
  while (url) {
    const page = await fetchPage(url);
    for (const project of page.data) {
      await externalSystem.upsertProject({
        externalId: `vomo-project-${project.id}`,
        name: project.name,
        organizationId: project.organization_id,
        updatedAt: new Date(project.updated_at),
      });
    }
    url = page.links.next;
  }

  await advanceCheckpoint(customerId);
}

class VomoProjects {
  constructor({ token }) {
    this.token = token;
    this.baseUrl = 'https://api.vomo.org/v1';
  }

  async list(filters = {}) {
    const params = new URLSearchParams(filters);
    const projects = [];
    let url = `${this.baseUrl}/projects?${params}`;

    while (url) {
      const response = await this._fetch(url);
      const page = await response.json();
      projects.push(...page.data.map(this._parseProject));
      url = page.links.next;
    }
    return projects;
  }

  async getById(projectId) {
    const response = await this._fetch(`${this.baseUrl}/projects/${projectId}`);
    if (response.status === 404) return null;
    if (!response.ok) throw new Error(`Failed: ${response.status}`);
    const result = await response.json();
    return this._parseProjectDetail(result.data);
  }

  async getToday() {
    const response = await this._fetch(`${this.baseUrl}/projects/today`);
    const result = await response.json();
    return result.data.map(this._parseHappening);
  }

  async getDateById(projectDateId) {
    const response = await this._fetch(
      `${this.baseUrl}/projects/date/${projectDateId}`
    );
    if (response.status === 404) return null;
    if (!response.ok) throw new Error(`Failed: ${response.status}`);
    return response.json();
  }

  async create(projectData) {
    const response = await this._fetch(`${this.baseUrl}/projects`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(projectData),
    });
    if (!response.ok) throw new Error(`Create failed: ${response.status}`);
    return response.json();
  }

  async update(projectId, projectData) {
    const response = await this._fetch(`${this.baseUrl}/projects/${projectId}`, {
      method: 'PUT',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(projectData),
    });
    if (!response.ok) throw new Error(`Update failed: ${response.status}`);
    return response.json();
  }

  _fetch(url, options = {}) {
    return fetch(url, {
      ...options,
      headers: {
        Authorization: `Bearer ${this.token}`,
        Accept: 'application/json',
        ...options.headers,
      },
    });
  }

  _parseProject(raw) {
    return {
      id: raw.id,
      name: raw.name, // Prefer name over project_name (audit #42)
      description: raw.description,
      url: raw.url,
      organization: raw.organization,
      organizationId: raw.organization_id,
      organizationSlug: raw.organization_slug,
      createdAt: new Date(raw.created_at),
      updatedAt: new Date(raw.updated_at),
      publishedAt: raw.published_at ? new Date(raw.published_at) : null,
      address: raw.address, // May be array or object — see audit #43
      campaigns: raw.campaigns ?? [],
      owners: raw.owners ?? [],
    };
  }

  _parseProjectDetail(raw) {
    return {
      ...this._parseProject(raw),
      pointPerson: raw.point_person ?? null,
      details: raw.details ?? '',
      allowGuests: raw.allow_guests ?? false,
      ageLimit: raw.age_limit ?? null,
      participantApprovalRequired: raw.participant_approval_required ?? false,
      backgroundCheckRequired: raw.background_check_required ?? false,
      draft: raw.draft ?? false,
      privacy: raw.privacy ?? 'PUBLIC',
      allDates: raw.all_dates ?? [],
      nextDate: raw.next_date ?? null,
    };
  }

  _parseHappening(raw) {
    return {
      id: raw.id,
      startsAt: new Date(raw.starts_at),
      endsAt: new Date(raw.ends_at),
      participantCount: raw.participant_count ?? 0,
    };
  }
}