Users & Volunteers

curl "https://api.vomo.org/v1/users?page=1&name_like=wayne" \
  -H "Authorization: Bearer $VOMO_API_TOKEN"

async function recentlyActiveUsers(sinceDate) {
  const params = new URLSearchParams({
    updated_after: sinceDate.toISOString(),
  });
  let url = `https://api.vomo.org/v1/users?${params}`;

  const users = [];
  while (url) {
    const page = await fetchPage(url);
    users.push(...page.data);
    url = page.links.next;
  }
  return users;
}

async function newUsersForMonth(year, month) {
  const start = new Date(year, month - 1, 1);
  const end = new Date(year, month, 1);

  const params = new URLSearchParams({
    created_after: start.toISOString(),
    created_before: end.toISOString(),
  });

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

async function findUserByEmail(email) {
  const params = new URLSearchParams({ email_like: email });
  const response = await fetch(
    `https://api.vomo.org/v1/users?${params}`,
    { headers: { Authorization: `Bearer ${token}` } }
  );
  const page = await response.json();

  return page.data.find((u) => u.email?.toLowerCase() === email.toLowerCase()) ?? null;
}

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

const { user, created } = await upsertUser({
  email: 'bruce@wayne.example',
  firstName: 'Bruce',
  lastName: 'Wayne',
});

if (created) {
  console.log(`Created new user: ${user.id}`);
  await sendWelcomeEmail(user);
} else {
  console.log(`Updated existing user: ${user.id}`);
  // No welcome email — user already exists
}

try {
  await upsertUser(userData);
} catch (err) {
  if (err.status === 422) {
    const fieldErrors = err.body?.errors ?? {};
    Object.entries(fieldErrors).forEach(([field, messages]) => {
      console.error(`${field}: ${messages.join(', ')}`);
    });
    return;
  }
  throw err;
}

async function syncVolunteerFromExternal(externalRecord) {
  const result = await upsertUser({
    email: externalRecord.emailAddress,
    firstName: externalRecord.firstName,
    lastName: externalRecord.lastName,
    phone: externalRecord.phoneNumber,
    birthday: externalRecord.dateOfBirth,
    role: mapRole(externalRecord.role),
  });

  await externalDb.recordSync({
    externalId: externalRecord.id,
    vomoUserId: result.user.id,
    syncedAt: new Date(),
    operation: result.created ? 'create' : 'update',
  });

  return result;
}

async function importVolunteers(roster) {
  const client = new ThrottledVomoClient({ token, requestsPerSecond: 3 });
  const results = [];

  for (const record of roster) {
    try {
      const result = await client.upsertUser(record);
      results.push({ status: 'ok', record, result });
    } catch (err) {
      results.push({ status: 'failed', record, error: err.message });
    }
  }

  const created = results.filter((r) => r.status === 'ok' && r.result.created).length;
  const updated = results.filter((r) => r.status === 'ok' && !r.result.created).length;
  const failed = results.filter((r) => r.status === 'failed').length;

  console.log(`Import complete: ${created} created, ${updated} updated, ${failed} failed`);
  return results;
}

async function findOrCreateUser(email, defaults = {}) {
  // Try to find first
  const existing = await findUserByEmail(email);
  if (existing) return { user: existing, created: false };

  // Not found — create
  const result = await upsertUser({ email, ...defaults });
  return result;
}

async function totalHoursForUser(userId) {
  const user = await getUserDetail(userId);
  return user.participations.reduce(
    (sum, p) => sum + (parseFloat(p.hours) || 0),
    0
  );
}

// partner_db.user_mappings table
// columns: external_id, vomo_user_id, email_at_sync, last_synced_at

async function getVomoUserForExternal(externalId) {
  const mapping = await partnerDb.userMappings.findByExternalId(externalId);
  return mapping?.vomoUserId ?? null;
}

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

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

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

    return allUsers;
  }

  async getById(userId) {
    const response = await this._fetch(`${this.baseUrl}/users/${userId}`);

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

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

  async upsert(userData) {
    const response = await this._fetch(`${this.baseUrl}/users`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        first_name: userData.firstName,
        last_name: userData.lastName,
        email: userData.email,
        phone: userData.phone,
        birthday: userData.birthday,
        gender: userData.gender,
        role: userData.role,
      }),
    });

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

    const created = response.status === 201;
    const result = await response.json();
    return { user: this._parseUser(result.data), created };
  }

  async findByEmail(email) {
    const params = new URLSearchParams({ email_like: email });
    const url = `${this.baseUrl}/users?${params}`;
    const response = await this._fetch(url);
    const page = await response.json();

    return page.data
      .map(this._parseUser)
      .find((u) => u.email?.toLowerCase() === email.toLowerCase()) ?? null;
  }

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

  _parseUser(raw) {
    return {
      id: raw.id,
      firstName: raw.first_name,
      lastName: raw.last_name,
      fullName: raw.full_name,
      email: raw.email,
      phone: raw.phone ?? null,
      address: raw.address ?? null,
      birthday: raw.birthday ? new Date(raw.birthday) : null,
      gender: raw.gender ?? null,
      createdAt: new Date(raw.created_at),
      updatedAt: new Date(raw.updated_at),
      userStatus: raw.user_status,
      membershipStatus: raw.membership_status,
      membershipRole: raw.membership_role,
    };
  }

  _parseUserDetail(raw) {
    return {
      ...this._parseUser(raw),
      participations: (raw.participations ?? []).map(this._parseParticipation),
      profileFieldValues: (raw.profile_field_values ?? []).map(this._parseFieldValue),
    };
  }

  _parseParticipation(raw) {
    return {
      guests: raw.guests ?? 0,
      checkedInAt: raw.checked_in_at ? new Date(raw.checked_in_at) : null,
      checkedOutAt: raw.checked_out_at ? new Date(raw.checked_out_at) : null,
      signedUpAt: raw.signed_up_at ? new Date(raw.signed_up_at) : null,
      hours: typeof raw.hours === 'string' ? parseFloat(raw.hours) : raw.hours,
      verified: raw.verified ?? false,
      role: raw.role ?? null,
      projectId: raw.project_id ? parseInt(raw.project_id, 10) : null,
      projectDateId: raw.project_date_id ? parseInt(raw.project_date_id, 10) : null,
    };
  }

  _parseFieldValue(raw) {
    return {
      fieldId: raw.field_id,
      fieldLabel: raw.field_label,
      value: raw.value,
    };
  }
}