Combine Volunteer Data with CRM+ Data

class VomoToJoinedStoreCollector {
  constructor({ customerId, token, joinedStore }) {
    this.customerId = customerId;
    this.token = token;
    this.joinedStore = joinedStore;
    this.client = new ThrottledVomoClient({ token, requestsPerSecond: 3 });
  }

  async poll() {
    const lastSync = await this.joinedStore.getVomoCheckpoint(this.customerId);
    const params = new URLSearchParams({ updated_after: lastSync.toISOString() });

    let url = `https://api.vomo.org/v1/users?${params}`;
    let latestSeen = lastSync;

    while (url) {
      const response = await this.client.fetch(url);
      if (!response.ok) throw new Error(`Poll failed: ${response.status}`);

      const page = await response.json();
      for (const user of page.data) {
        await this._upsertJoinedFromVomo(user);

        const u = new Date(user.updated_at);
        if (u > latestSeen) latestSeen = u;
      }

      url = page.links.next;
    }

    await this.joinedStore.setVomoCheckpoint(this.customerId, latestSeen);
  }

  async _upsertJoinedFromVomo(vomoUser) {
    const normalizedEmail = vomoUser.email?.toLowerCase().trim();
    if (!normalizedEmail) return; // Can't join without email

    // Find the partner-side joined record (or create)
    const existing = await this.joinedStore.findByEmail(this.customerId, normalizedEmail);
    const partnerId = existing?.partner_person_id ?? generatePartnerPersonId();

    await this.joinedStore.upsert({
      customer_id: this.customerId,
      partner_person_id: partnerId,
      email: normalizedEmail,
      vomo_user_id: vomoUser.id,
      vomo_first_name: vomoUser.first_name,
      vomo_last_name: vomoUser.last_name,
      vomo_phone: vomoUser.phone,
      vomo_user_status: vomoUser.user_status,
      vomo_membership_role: vomoUser.membership_role,
      vomo_updated_at: new Date(vomoUser.updated_at),
      vomo_last_synced_at: new Date(),
      has_vomo: true,
    });
  }
}

class CrmToJoinedStoreCollector {
  constructor({ customerId, token, joinedStore }) {
    this.customerId = customerId;
    this.token = token;
    this.joinedStore = joinedStore;
  }

  async poll() {
    const lastSync = await this.joinedStore.getCrmCheckpoint(this.customerId);

    // CRM+ uses /api/Contact/Query with PascalCase
    const response = await fetch('https://api.virtuoussoftware.com/api/Contact/Query', {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${this.token}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        Skip: 0,
        Take: 100,
        Groups: [
          {
            Conditions: [
              {
                Parameter: 'ModifiedDateTimeUtc',
                Operator: 'GreaterThan',
                Value: lastSync.toISOString(),
              },
            ],
          },
        ],
        SortBy: 'ModifiedDateTimeUtc',
      }),
    });

    const result = await response.json();
    let latestSeen = lastSync;

    for (const contact of result.list ?? []) {
      await this._upsertJoinedFromCrm(contact);
      const u = new Date(contact.ModifiedDateTimeUtc);
      if (u > latestSeen) latestSeen = u;
    }

    // Continue paginating with Skip/Take...

    await this.joinedStore.setCrmCheckpoint(this.customerId, latestSeen);
  }

  async _upsertJoinedFromCrm(crmContact) {
    // CRM+ Contact has individuals; pull primary email
    const primaryEmail = this._getPrimaryEmail(crmContact);
    if (!primaryEmail) return;

    const normalizedEmail = primaryEmail.toLowerCase().trim();

    const existing = await this.joinedStore.findByEmail(this.customerId, normalizedEmail);
    const partnerId = existing?.partner_person_id ?? generatePartnerPersonId();

    await this.joinedStore.upsert({
      customer_id: this.customerId,
      partner_person_id: partnerId,
      email: normalizedEmail,
      crm_contact_id: crmContact.Id,
      crm_first_name: this._getPrimaryFirstName(crmContact),
      crm_last_name: this._getPrimaryLastName(crmContact),
      crm_phone: this._getPrimaryPhone(crmContact),
      crm_donor_lifetime_amount: crmContact.LifetimeGivingAmount ?? 0,
      crm_last_gift_date: crmContact.LastGiftDate ? new Date(crmContact.LastGiftDate) : null,
      crm_updated_at: new Date(crmContact.ModifiedDateTimeUtc),
      crm_last_synced_at: new Date(),
      has_crm: true,
    });
  }

  _getPrimaryEmail(contact) {
    const primary = contact.ContactIndividuals?.find((ci) => ci.IsPrimary);
    if (!primary?.ContactMethods) return null;

    const emailMethod = primary.ContactMethods.find(
      (cm) => cm.Type === 'Home Email' || cm.Type === 'Work Email'
    );
    return emailMethod?.Value ?? null;
  }

  _getPrimaryFirstName(contact) {
    const primary = contact.ContactIndividuals?.find((ci) => ci.IsPrimary);
    return primary?.FirstName ?? null;
  }

  _getPrimaryLastName(contact) {
    const primary = contact.ContactIndividuals?.find((ci) => ci.IsPrimary);
    return primary?.LastName ?? null;
  }

  _getPrimaryPhone(contact) {
    const primary = contact.ContactIndividuals?.find((ci) => ci.IsPrimary);
    const phoneMethod = primary?.ContactMethods?.find(
      (cm) => cm.Type === 'Home Phone' || cm.Type === 'Mobile Phone'
    );
    return phoneMethod?.Value ?? null;
  }
}

const FIELD_AUTHORITY = {
  email: 'vomo',           // VOMO upsert by email — VOMO is canonical
  first_name: 'vomo',
  last_name: 'vomo',
  phone: 'crm',            // CRM+ phone is typically curated for donor outreach
  // ...
};

async function getDisplayValue(joinedRecord, fieldName) {
  const authority = FIELD_AUTHORITY[fieldName];
  const vomoValue = joinedRecord[`vomo_${fieldName}`];
  const crmValue = joinedRecord[`crm_${fieldName}`];

  if (authority === 'vomo') return vomoValue ?? crmValue;
  if (authority === 'crm') return crmValue ?? vomoValue;

  // No authority set — prefer more-recent
  if (joinedRecord.vomo_last_synced_at > joinedRecord.crm_last_synced_at) {
    return vomoValue ?? crmValue;
  }
  return crmValue ?? vomoValue;
}

async function detectConflicts(customerId) {
  const persons = await joinedStore.getAllWithBothSides(customerId);
  const conflicts = [];

  for (const p of persons) {
    if (p.vomo_last_name && p.crm_last_name && p.vomo_last_name !== p.crm_last_name) {
      conflicts.push({
        partner_person_id: p.partner_person_id,
        field: 'last_name',
        vomo_value: p.vomo_last_name,
        crm_value: p.crm_last_name,
      });
    }
    // ... other field checks ...
  }

  if (conflicts.length > 0) {
    await externalSystem.publishConflictsForReview(customerId, conflicts);
  }

  return conflicts;
}

async function detectPossibleSamePerson(customerId) {
  // Look for pairs where VOMO user ID matches but emails differ from CRM contact
  // OR where CRM contact ID matches across split records
  const orphans = await joinedStore.getOrphans(customerId);
  // ... matching logic ...
}

async function mergePersons(customerId, primaryId, mergeIntoId) {
  // Move all data from mergeIntoId to primaryId
  await db.query(`
    UPDATE participations SET partner_person_id = $1 WHERE partner_person_id = $2;
  `, [primaryId, mergeIntoId]);
  // ... merge other related data ...

  // Delete the duplicate joined record
  await db.query(`
    DELETE FROM joined_persons WHERE customer_id = $1 AND partner_person_id = $2;
  `, [customerId, mergeIntoId]);

  // Audit the merge
  await db.insert('person_merges', {
    customer_id: customerId,
    primary_id: primaryId,
    merged_id: mergeIntoId,
    reason: 'email_change_split',
    merged_at: new Date(),
  });
}

async function dailyCrossApiReconciliation(customerId) {
  const yesterday = startOfDayUTC(daysAgo(1));

  // 1. Re-pull yesterday's VOMO changes (already in joined store, but verify)
  const vomoYesterday = await listVomoUsersUpdatedAfter(customerId, yesterday);
  for (const user of vomoYesterday) {
    const joined = await joinedStore.findByEmail(customerId, user.email.toLowerCase());
    if (!joined) {
      // Unexpected — yesterday's VOMO user is missing from joined store
      await alertOps({
        severity: 'medium',
        customerId,
        type: 'vomo_user_missing_from_joined',
        vomoUserId: user.id,
      });
    } else if (new Date(joined.vomo_last_synced_at) < new Date(user.updated_at)) {
      // Joined record is stale — re-sync
      await reSyncVomoUserToJoined(customerId, user);
    }
  }

  // 2. Same for CRM+ side
  const crmYesterday = await listCrmContactsModifiedAfter(customerId, yesterday);
  // ... similar logic ...

  // 3. Detect orphan VOMO users (in VOMO but not joined to CRM+)
  // 4. Detect orphan CRM+ contacts (in CRM+ but not joined to VOMO)
  // These aren't bugs — they're real-world separations. But track them for reporting.
}

async function callBothApis(customerId, vomoOperation, crmOperation) {
  const vomoToken = await credentials.getVomoToken(customerId);
  const crmToken = await credentials.getCrmToken(customerId);

  // Make these calls independently — different services, different tokens
  const [vomoResult, crmResult] = await Promise.all([
    vomoOperation(vomoToken),
    crmOperation(crmToken),
  ]);

  return { vomoResult, crmResult };
}