Volunteer Certificates

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

async function listAllCertificates() {
  const certs = [];
  let url = 'https://api.vomo.org/v1/certificates';

  while (url) {
    const response = await fetch(url, {
      headers: { Authorization: `Bearer ${token}` },
    });
    if (!response.ok) throw new Error(`Failed: ${response.status}`);

    const page = await response.json();
    certs.push(...page.data);
    url = page.links.next;
  }

  return certs;
}

class CertificateCache {
  constructor({ token, ttlMs = 60 * 60 * 1000 }) {
    this.token = token;
    this.ttlMs = ttlMs;
    this.cached = null;
    this.cachedAt = 0;
  }

  async getAll() {
    if (this.cached && Date.now() - this.cachedAt < this.ttlMs) {
      return this.cached;
    }

    this.cached = await listAllCertificates();
    this.cachedAt = Date.now();
    return this.cached;
  }

  async getById(id) {
    const all = await this.getAll();
    return all.find((c) => c.id === id) ?? null;
  }

  async getByName(name) {
    const all = await this.getAll();
    return all.find((c) => c.name.toLowerCase() === name.toLowerCase()) ?? null;
  }
}

async function displayProjectRequirements(projectId) {
  const project = await getProjectDetail(projectId);
  const certCache = new CertificateCache({ token });

  const requirements = [];
  for (const certRef of project.certificates ?? []) {
    const cert = await certCache.getById(certRef.id);
    if (cert) {
      requirements.push({
        name: cert.name,
        description: cert.requirement,
        validForMonths: cert.expiration_in_months,
      });
    }
  }

  return requirements;
}

async function findUsersWithExpiringCertificates(daysUntilExpiration = 30) {
  // Note: This pattern requires the User detail to expose earned certificates with dates.
  // The exact format isn't documented in the spec — confirm against live data.

  const allUsers = await paginate('https://api.vomo.org/v1/users');
  const certCache = new CertificateCache({ token });
  const expiringPerUser = [];

  for (const userSummary of allUsers) {
    const user = await getUserDetail(userSummary.id);
    const earnedCerts = user.earned_certificates ?? []; // confirm field name from live API

    for (const earned of earnedCerts) {
      const cert = await certCache.getById(earned.certificate_id);
      if (!cert?.expiration_in_months) continue;

      const earnedDate = new Date(earned.earned_at);
      const expirationDate = new Date(earnedDate);
      expirationDate.setMonth(expirationDate.getMonth() + cert.expiration_in_months);

      const daysUntilExp = (expirationDate - Date.now()) / (24 * 60 * 60 * 1000);

      if (daysUntilExp <= daysUntilExpiration && daysUntilExp > 0) {
        expiringPerUser.push({
          user,
          certificate: cert,
          expirationDate,
          daysUntilExpiration: Math.round(daysUntilExp),
        });
      }
    }
  }

  return expiringPerUser;
}

async function syncCertificatesToComplianceSystem(customerId) {
  const lastSync = await getCheckpoint(customerId, 'certificate_sync');
  const certs = await listAllCertificates();

  for (const cert of certs) {
    const updatedAt = new Date(cert.updated_at);
    if (updatedAt > lastSync) {
      await complianceSystem.upsertCertification({
        externalId: `vomo-cert-${cert.id}`,
        name: cert.name,
        description: cert.requirement,
        validityMonths: cert.expiration_in_months,
        lastUpdated: updatedAt,
      });
    }
  }

  await advanceCheckpoint(customerId, 'certificate_sync', new Date());
}

class VomoCertificates {
  constructor({ token, ttlMs = 60 * 60 * 1000 }) {
    this.token = token;
    this.baseUrl = 'https://api.vomo.org/v1';
    this.ttlMs = ttlMs;
    this.cache = null;
    this.cachedAt = 0;
  }

  async list() {
    const certs = [];
    let url = `${this.baseUrl}/certificates`;

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

  async getCached() {
    if (this.cache && Date.now() - this.cachedAt < this.ttlMs) {
      return this.cache;
    }
    this.cache = await this.list();
    this.cachedAt = Date.now();
    return this.cache;
  }

  async getById(certificateId) {
    const all = await this.getCached();
    return all.find((c) => c.id === certificateId) ?? null;
  }

  async getByName(name) {
    const all = await this.getCached();
    return all.find((c) => c.name.toLowerCase() === name.toLowerCase()) ?? null;
  }

  computeExpiration(certificate, earnedDate) {
    if (!certificate.expirationInMonths) return null; // No expiration
    const expirationDate = new Date(earnedDate);
    expirationDate.setMonth(expirationDate.getMonth() + certificate.expirationInMonths);
    return expirationDate;
  }

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

  _parseCertificate(raw) {
    return {
      id: raw.id,
      name: raw.name,
      requirement: raw.requirement ?? '',
      slug: raw.slug, // Treat as UUID per example, not the misleading enum
      expirationInMonths: raw.expiration_in_months ?? null,
      creatorId: raw.creator_id,
      organizationId: raw.organization_id,
      createdAt: new Date(raw.created_at),
      updatedAt: new Date(raw.updated_at),
    };
  }
}