Campaigns

function parseCampaign(raw) {
  return {
    id: raw.id,
    name: raw.campaign_name,  // Map to a normalized 'name' field
    description: raw.description,
    url: raw.url,
    organization: raw.organization,
    organizationSlug: raw.organization_slug,
    authorId: raw.author_id,
    logoUrl: raw.logo_url,
    createdAt: new Date(raw.created_at),
    updatedAt: new Date(raw.updated_at),
  };
}

curl "https://api.vomo.org/v1/campaigns?name_like=outreach" \
  -H "Authorization: Bearer $VOMO_API_TOKEN"

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

async function campaignsForOrgs(orgSlugs) {
  const params = new URLSearchParams({ org_slug: orgSlugs.join(',') });
  return paginate(`https://api.vomo.org/v1/campaigns?${params}`);
}

async function recentCampaigns(sinceDate) {
  const params = new URLSearchParams({
    created_after: sinceDate.toISOString(),
  });
  return paginate(`https://api.vomo.org/v1/campaigns?${params}`);
}

async function findCampaignsLike(searchTerm) {
  const params = new URLSearchParams({ name_like: searchTerm });
  const response = await fetch(
    `https://api.vomo.org/v1/campaigns?${params}`,
    { headers: { Authorization: `Bearer ${token}` } }
  );
  const page = await response.json();
  return page.data;
}

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

async function getCampaign(campaignId) {
  const response = await fetch(
    `https://api.vomo.org/v1/campaigns/${campaignId}`,
    { 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 parseCampaign(result.data);
}

async function projectsInCampaign(campaignId) {
  const allProjects = await paginate('https://api.vomo.org/v1/projects');
  return allProjects.filter((p) =>
    (p.campaigns ?? []).some((c) => c.id === campaignId)
  );
}

async function uniqueVolunteersInCampaign(campaignId) {
  const projects = await projectsInCampaign(campaignId);
  const userIds = new Set();

  for (const project of projects) {
    const projectDetail = await getProjectDetail(project.id);
    // Walk all dates of this project; collect unique user IDs from participations
    for (const projectDate of projectDetail.all_dates ?? []) {
      const dateDetail = await getProjectDate(projectDate.id);
      for (const participant of dateDetail.participants ?? []) {
        userIds.add(participant.user_id);
      }
    }
  }

  return userIds.size;
}

async function buildCampaignDashboard(campaignId) {
  const campaign = await getCampaign(campaignId);
  if (!campaign) return null;

  const projects = await projectsInCampaign(campaignId);

  const activeProjects = projects.filter((p) => /* check active status */).length;
  const totalParticipations = await countParticipationsForProjects(projects);
  const uniqueVolunteers = await uniqueVolunteersInCampaign(campaignId);

  return {
    name: campaign.name,
    description: campaign.description,
    url: campaign.url,
    logoUrl: campaign.logoUrl,
    organization: campaign.organization,
    metrics: {
      totalProjects: projects.length,
      activeProjects,
      totalParticipations,
      uniqueVolunteers,
    },
    daysActive: daysSince(campaign.createdAt),
  };
}

async function compareCampaigns(campaignIds) {
  const results = await Promise.all(
    campaignIds.map(async (id) => {
      const campaign = await getCampaign(id);
      const projects = await projectsInCampaign(id);
      return {
        campaign,
        projectCount: projects.length,
      };
    })
  );

  return results.map((r) => ({
    id: r.campaign.id,
    name: r.campaign.name,
    projectCount: r.projectCount,
  }));
}

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

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

  let url = `https://api.vomo.org/v1/campaigns?${params}`;
  while (url) {
    const page = await fetchPage(url);
    for (const campaign of page.data) {
      await externalSystem.upsertCampaign({
        externalId: `vomo-campaign-${campaign.id}`,
        name: campaign.campaign_name,
        description: campaign.description,
        organizationSlug: campaign.organization_slug,
        updatedAt: new Date(campaign.updated_at),
      });
    }
    url = page.links.next;
  }

  await advanceCheckpoint(customerId);
}

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

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

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

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

  async forOrg(orgSlug, additionalFilters = {}) {
    return this.list({ org_slug: orgSlug, ...additionalFilters });
  }

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

  _parseCampaign(raw) {
    return {
      id: raw.id,
      name: raw.campaign_name,  // Normalize to 'name'
      description: raw.description ?? '',
      url: raw.url,
      organization: raw.organization,
      organizationSlug: raw.organization_slug,
      authorId: raw.author_id,
      logoUrl: raw.logo_url ?? null,
      createdAt: new Date(raw.created_at),
      updatedAt: new Date(raw.updated_at),
    };
  }
}