@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v1/sevenrooms/src/lib/sevenrooms/clients/index.ts

@@ -0,0 +1,505 @@
+import { Logger } from "winston";
+import { SevenRoomsWebhookPayload, SevenRoomsClient, getSevenRoomsApiHost } from "../models";
+import { SeekaAppInstallState, SevenRoomsAppInstallSettings } from "../../../lib/state/seeka/installations";
+import { ConsentInfo, PersonIdentifiers, PlaceAddress, PrivacyConsentType, SeekaActivityAcceptedWebhookContent, SeekaAppHelper, TrackingEventSourceOriginType, isValidSeekaProfileId, matchActivityPipelineFilters } from "@seeka-labs/sdk-apps-server";
+import { name, version } from '../../../../package.json';
+import { SevenRoomsAuthToken, getOrCreateSevenRoomsAuthToken } from "../auth";
+import { last } from 'lodash'
+import { sanitiseSevenRoomsPhoneNumber } from "../helpers";
+
+export const handleSevenRoomsClientWebhook = async (payload: SevenRoomsWebhookPayload<SevenRoomsClient>, venueId: string, installation: SeekaAppInstallState, logger: Logger) => {
+    // const clientPushRules = installation.installationSettings?.clients?.pushClientToSevenRoomsRules || [];
+    const consentEnabled = installation.installationSettings?.advanced?.maintainMarketingConsent === true;
+    // const handleClientWebhooks = clientPushRules.length > 0 || consentEnabled;
+
+    const thisLogger = logger.child({
+        sevenRoomsExternalUserId: payload.entity.external_user_id,
+        sevenRoomsClientId: payload.entity.id
+    })
+
+    const seekaProfile = sevenRoomsClientToSeekaIdentity(payload.entity, venueId, consentEnabled, thisLogger);
+    if (seekaProfile) {
+        thisLogger.info('Pushing SevenRooms client to Seeka', { seekaProfile });
+
+        const helper = SeekaAppHelper.create(process.env['SEEKA_APP_SECRET'] as string, {
+            organisationId: installation.organisationId as string,
+            applicationInstallId: installation.applicationInstallId as string,
+            applicationId: process.env['SEEKA_APP_ID'] as string,
+        }, { name, version }, installation.installationState.grantedPermissions, thisLogger);
+
+        const existingSeekaPersonId = seekaProfile.seekaPId;
+        const personId = await helper.api.mergeIdentity(seekaProfile, {
+            origin: TrackingEventSourceOriginType.Server
+        });
+
+        if (!existingSeekaPersonId && installation.installationSettings.advanced.allowUseOfSevenRoomsExternalId) {
+            // Update SevenRooms client with the Seeka person ID
+            const sevenRoomsToken = await getOrCreateSevenRoomsAuthToken(installation, thisLogger);
+
+            await updateSevenRoomsClient(payload.entity.id, { external_user_id: personId }, installation.installationSettings, sevenRoomsToken, thisLogger);
+        }
+    }
+}
+
+export const handleClientPushRules = async (activity: SeekaActivityAcceptedWebhookContent, installation: SeekaAppInstallState, logger: Logger): Promise<string | null> => {
+    const rules = installation.installationSettings?.clients?.pushClientToSevenRoomsRules || [];
+    if (rules.length === 0) return;
+
+    const thisLogger = logger.child({
+        'Person_PersonId': activity.identifiers.seekaPId,
+        'Activity_ActivityName': activity.activity.activityName,
+        'Activity_ActivityNameCustom': activity.activity.activityNameCustom,
+        'Reason': 'ClientPushRules'
+    })
+
+    thisLogger.verbose('Checking activity against client push rules', { activity, rules });
+
+    const matched = matchActivityPipelineFilters(activity, rules, thisLogger);
+    let clientId: string | null = null;
+    if (matched.length === 0) {
+        thisLogger.verbose('No client push rules matched activity', { activity, rules });
+        return;
+    }
+
+    const sevenRoomsToken = await getOrCreateSevenRoomsAuthToken(installation, thisLogger);
+    thisLogger.verbose('Matched client push rules, pushing clients to SevenRooms', { matched });
+
+    // Push client to SevenRooms
+    const existingClients = await findSevenRoomsClients(activity.identifiers.email, activity.identifiers.phone, [activity.identifiers.seekaPId, ...(activity.identifiers.seekaBId ?? [])], installation.installationSettings, sevenRoomsToken, thisLogger);
+    if (existingClients.length > 1) {
+        thisLogger.error('Found multiple clients in SevenRooms, not processing client push rules', {
+            clients: existingClients,
+            email: activity.identifiers.email,
+            phone: activity.identifiers.phone,
+            externalId: [activity.identifiers.seekaPId, ...(activity.identifiers.seekaBId ?? [])]
+        });
+    }
+    else if (existingClients.length === 1) {
+        // Update client external ID if empty
+        const existingClient = existingClients[0];
+        if (installation.installationSettings.advanced.allowUseOfSevenRoomsExternalId && !existingClient.external_user_id) {
+            const updated = await updateSevenRoomsClient(existingClient.id, {
+                external_user_id: activity.identifiers.seekaPId
+            }, installation.installationSettings, sevenRoomsToken, thisLogger)
+            clientId = updated.client_id;
+        }
+        else {
+            clientId = existingClient.id;
+        }
+    }
+    else {
+        // Create client
+        const client = seekaIdentityToSevenRoomsClient(activity.identifiers, installation.installationSettings.connection.sevenRoomsVenueId, true, installation.installationSettings.advanced.allowUseOfSevenRoomsExternalId, thisLogger);
+        if (client) {
+            if (client.marketing_opt_in || client.venue_marketing_opt_in) {
+                const createdOkay = await createSevenRoomsClient(client, installation.installationSettings, sevenRoomsToken, thisLogger);
+                if (createdOkay) {
+                    const created = await findSevenRoomsClient(client.email, client.phone_number, client.external_user_id, installation.installationSettings, sevenRoomsToken, thisLogger);
+                    if (created.length === 1) {
+                        clientId = created[0].id;
+                    }
+                    else if (created.length > 1) {
+                        thisLogger.error('Found multiple clients in SevenRooms after creating', { clients: created });
+                    }
+                    else {
+                        thisLogger.error('Failed to find created client in SevenRooms', { client });
+                    }
+                }
+            }
+            else {
+                thisLogger.verbose('Skipping SevenRooms client create as marketing opt-in is not set', { client });
+            }
+        }
+    }
+
+    return clientId;
+}
+
+export const seekaIdentityToSevenRoomsClient = (identity: PersonIdentifiers, venueId: string | undefined, setConsent: boolean, allowExternalId: boolean, logger: Logger): SevenRoomsClient | null => {
+    const client: SevenRoomsClient = {}
+    if (identity.seekaPId && allowExternalId) {
+        client.external_user_id = identity.seekaPId;
+    }
+    if (identity.firstName && identity.firstName.length > 0) {
+        client.first_name = last(identity.firstName);
+    }
+    if (identity.lastName && identity.lastName.length > 0) {
+        client.last_name = last(identity.lastName);
+    }
+
+    // Email
+    if (identity.email && identity.email.length > 0) {
+        if (identity.email.length === 1) {
+            client.email = identity.email[0];
+        }
+        else if (identity.email.length > 1) {
+            client.email = identity.email[0];
+            client.email_alt = identity.email[1];
+        }
+    }
+
+    // Phone
+    if (identity.phone && identity.phone.length > 0) {
+        if (identity.phone.length === 1) {
+            client.phone_number = identity.phone[0];
+            if (identity.address && identity.address.length > 0) {
+                client.phone_number_locale = last(identity.address).countryCode;
+            }
+        }
+        else if (identity.phone.length > 1) {
+            client.phone_number = identity.phone[0];
+            client.phone_number_alt = identity.phone[1];
+            if (identity.address && identity.address.length > 0) {
+                client.phone_number_locale = last(identity.address).countryCode;
+                client.phone_number_alt_locale = last(identity.address).countryCode;
+            }
+        }
+    }
+
+    // Address
+    if (identity.address && identity.address.length > 0) {
+        const address = last(identity.address);
+        if (address.addressLine1) {
+            client.address = address.addressLine1;
+        }
+        if (address.addressLine2) {
+            client.address_2 = address.addressLine2;
+        }
+        if (address.locality) {
+            client.city = address.locality;
+        }
+        if (address.state) {
+            client.state = address.state || address.stateCode;
+        }
+        if (address.postcode) {
+            client.postal_code = address.postcode;
+        }
+        if (address.country) {
+            client.country = address.country || address.countryCode;
+        }
+
+        if (client.phone_number) {
+            client.phone_number_locale = address.countryCode;
+        }
+        if (client.phone_number_alt) {
+            client.phone_number_alt_locale = address.countryCode;
+        }
+    }
+
+    // Consent
+    if (setConsent && identity.consent && identity.consent.marketing && (identity.consent.marketing.email)) {
+        const consent = identity.consent.marketing.email;
+
+        if (venueId) {
+            client.venue_id = venueId;
+
+            if (consent.consentGrantedAt) {
+                client.venue_marketing_opt_in = true;
+            }
+            else if (consent.consentNotGrantedAt) {
+                client.venue_marketing_opt_in = false;
+            }
+        }
+        else {
+            if (consent.consentGrantedAt) {
+                client.venue_group_marketing_opt_in = true;
+            }
+            else if (consent.consentNotGrantedAt) {
+                client.venue_group_marketing_opt_in = false;
+            }
+        }
+    }
+
+    return client;
+}
+
+export const createSevenRoomsClient = async (client: SevenRoomsClient, installSettings: SevenRoomsAppInstallSettings, sevenRoomsToken: SevenRoomsAuthToken, logger: Logger): Promise<boolean> => {
+    if (!client.email || !client.phone_number || !client.first_name || !client.last_name) {
+        logger.warn('Missing required fields to create client in SevenRooms', { client });
+        return false;
+    }
+
+    const response = await fetch(`https://${getSevenRoomsApiHost(installSettings)}/2_4/clients`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `${sevenRoomsToken.token}`,
+            'Content-Type': 'application/x-www-form-urlencoded'
+        },
+        body: new URLSearchParams(client as any)
+    });
+
+    if (!response.ok) {
+        logger.error(`Failed to update client in SevenRooms: ${response.statusText}`, { res: await response.text(), status: response.status, client });
+        throw new Error(`Failed to update client in SevenRooms: ${response.statusText}`);
+    }
+    else {
+        logger.info('Created client in SevenRooms', { client, responseText: await response.text() })
+        return true;
+
+        // SevenRooms doesnt return response payload
+        // return (await response.json())?.data;
+    }
+}
+
+export const updateSevenRoomsClient = async (clientId: string, client: SevenRoomsClient, installSettings: SevenRoomsAppInstallSettings, sevenRoomsToken: SevenRoomsAuthToken, logger: Logger): Promise<{ client_id: string, client_reference_code: string }> => {
+    const url = `https://${getSevenRoomsApiHost(installSettings)}/2_4/clients/${clientId}`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Authorization': `${sevenRoomsToken.token}`,
+            'Content-Type': 'application/x-www-form-urlencoded'
+        },
+        body: new URLSearchParams(client as any)
+    });
+
+    if (!response.ok) {
+        logger.error(`Failed to update client in SevenRooms: ${response.statusText}`, { res: await response.text(), status: response.status, url, client });
+        throw new Error(`Failed to update client in SevenRooms: ${response.statusText}`);
+    }
+    else {
+        logger.info('Updated client in SevenRooms', { sevenRoomsClientId: clientId, client })
+        return (await response.json())?.data;
+    }
+}
+
+
+export const findSevenRoomsClient = async (email: string | undefined, phone: string | undefined, externalUserId: string | undefined, installSettings: SevenRoomsAppInstallSettings, sevenRoomsToken: SevenRoomsAuthToken, logger: Logger): Promise<SevenRoomsClient[]> => {
+    const params = {
+        venue_group_id: installSettings.connection.sevenRoomsVenueGroupId,
+        limit: '10',
+        sort_order: 'last_updated_descending'
+    };
+    if (externalUserId) {
+        params['external_user_id'] = externalUserId;
+    }
+    if (email) {
+        params['email'] = email;
+    }
+    if (phone) {
+        params['phone'] = phone;
+    }
+    if (email && phone) {
+        params['contact_type'] = 'has_email_or_phone';
+    }
+    else if (email) {
+        params['contact_type'] = 'has_email';
+    }
+    else if (phone) {
+        params['contact_type'] = 'has_phone';
+    }
+
+    const url = `https://${getSevenRoomsApiHost(installSettings)}/2_4/clients?` + new URLSearchParams(params).toString();
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            'Authorization': `${sevenRoomsToken.token}`
+        }
+    });
+
+    // TODO: handle multiple pages
+    if (response.ok) {
+        const res = await response.json();
+
+        // SevenRooms API is returning sometimes with array elements as empty {} 
+        return (res?.data?.results as SevenRoomsClient[]).filter(e => e.id);
+    }
+    else {
+        logger.error(`Failed to get clients from SevenRooms: ${response.statusText}`, { res: await response.text(), status: response.status, url });
+        throw new Error(`Failed to get clients from SevenRooms: ${response.statusText}`);
+    }
+}
+
+export const findSevenRoomsClients = async (email: string[] | undefined, phone: string[] | undefined, externalUserId: string[] | undefined, installSettings: SevenRoomsAppInstallSettings, sevenRoomsToken: SevenRoomsAuthToken, logger: Logger): Promise<SevenRoomsClient[]> => {
+    const clients: SevenRoomsClient[] = [];
+
+    if (installSettings.advanced.allowUseOfSevenRoomsExternalId && externalUserId) {
+        for (const e of externalUserId) {
+            if (!e) continue;
+            const results = await findSevenRoomsClient(undefined, undefined, e, installSettings, sevenRoomsToken, logger);
+            clients.push(...results);
+        }
+        if (clients.length > 0) return clients;
+    }
+
+    if (email) {
+        for (const e of email) {
+            if (!e) continue;
+            const results = await findSevenRoomsClient(e, undefined, undefined, installSettings, sevenRoomsToken, logger);
+            clients.push(...results);
+        }
+    }
+    if (phone) {
+        for (const p of phone) {
+            if (!p) continue;
+            const results = await findSevenRoomsClient(undefined, p, undefined, installSettings, sevenRoomsToken, logger);
+            results.forEach((r) => {
+                if (clients.findIndex(c => c.id === r.id) === -1) {
+                    clients.push(r);
+                }
+            })
+        }
+    }
+    return clients;
+}
+
+const sevenRoomsClientToSeekaIdentity = (client: SevenRoomsClient, venueId: string, setConsent: boolean, logger: Logger): PersonIdentifiers | null => {
+    const id = {
+        email: [],
+        phone: [],
+        address: [],
+        consent: {
+            marketing: {}
+        },
+        traits: {}
+    } as PersonIdentifiers;
+
+    let thisLogger = logger.child({});
+
+    // Set existing person ID based on Sevenrooms client  
+    if (client.external_user_id) {
+        const hasExistingSeekaProfile = isValidSeekaProfileId(client.external_user_id);
+        if (hasExistingSeekaProfile) {
+            id.seekaPId = client.external_user_id;
+
+            thisLogger = logger.child({
+                'Person_PersonId': id.seekaPId
+            })
+        }
+        else {
+            thisLogger.warn('External user ID on SevenRooms client is not a valid Seeka profile ID', { client });
+        }
+    }
+
+    const address: PlaceAddress = {};
+    let addressPopulated;
+
+    // Address
+    if (client.address) {
+        address.addressLine1 = client.address;
+        addressPopulated = true;
+    }
+    if (client.address_2) {
+        address.addressLine2 = client.address_2;
+        addressPopulated = true;
+    }
+    if (client.city) {
+        address.locality = client.city;
+        addressPopulated = true;
+    }
+    if (client.state) {
+        address.state = client.state;
+        addressPopulated = true;
+    }
+    if (client.postal_code) {
+        address.postcode = client.postal_code;
+        addressPopulated = true;
+    }
+    if (client.country) {
+        address.country = client.country;
+        addressPopulated = true;
+    }
+    if (addressPopulated) {
+        id.address.push(address);
+    }
+
+    // Other details
+    let populated = false;
+    const additionalLocales: string[] = [];
+    if (client.email) {
+        id.email.push(client.email)
+        populated = true;
+    }
+    if (client.email_alt) {
+        id.email.push(client.email_alt)
+        populated = true;
+    }
+    if (client.phone_number_alt) {
+        const sanitisedAltPhone = sanitiseSevenRoomsPhoneNumber(client.phone_number_alt);
+        if (sanitisedAltPhone) {
+            id.phone.push(sanitisedAltPhone)
+            populated = true;
+            if (client.phone_number_alt_locale && (address.country !== client.phone_number_alt_locale)) {
+                additionalLocales.push(client.phone_number_alt_locale);
+            }
+        }
+    }
+    if (client.phone_number) {
+        const sanitisedPhone = sanitiseSevenRoomsPhoneNumber(client.phone_number);
+        if (sanitisedPhone) {
+            id.phone.push(sanitisedPhone)
+            populated = true;
+            if (client.phone_number_locale && (address.country !== client.phone_number_locale) && additionalLocales.indexOf(client.phone_number_locale) === -1) {
+                additionalLocales.push(client.phone_number_locale);
+            }
+        }
+    }
+    if (client.first_name) {
+        id.firstName = [client.first_name];
+    }
+    if (client.last_name) {
+        id.lastName = [client.last_name];
+    }
+    // if (client.gender) {
+    //     id.gender = [client.gender];
+    // }
+    id.traits['sevenrooms_client_id'] = client.id;
+    if (additionalLocales.length > 0) {
+        additionalLocales.forEach((locale) => {
+            id.address.push({ countryCode: locale })
+        })
+    }
+
+    // DOB - no year on SevenRooms client
+    // if(client.birthday_day && client.birthday_month && client.bir)
+
+    // Consent
+    if (setConsent) {
+        let consent: ConsentInfo | null = null;
+        const venueStats = client.venue_stats[venueId];
+        if (venueStats) {
+            thisLogger.verbose('Using venue stats for consent')
+            // Use venue consent
+            if (venueStats.venue_marketing_opt_in === true && venueStats.venue_marketing_opt_in_ts) {
+                consent = {
+                    consentGrantedAt: new Date(venueStats.venue_marketing_opt_in_ts),
+                    consentGrantedSourceName: 'SevenRoomsVenue',
+                    type: PrivacyConsentType.Explicit,
+                }
+            }
+            else if (venueStats.venue_marketing_opt_in === false && venueStats.venue_marketing_opt_out_ts) {
+                consent = {
+                    consentNotGrantedAt: new Date(venueStats.venue_marketing_opt_out_ts),
+                    consentNotGrantedSourceName: 'SevenRoomsVenue',
+                    type: PrivacyConsentType.Explicit,
+                }
+            }
+        }
+        else {
+            // Use venue group consent
+            thisLogger.verbose('Using venue group for consent')
+            if ((client.marketing_opt_in === true || client.marketing_opt_in === false) && client.marketing_opt_in_ts) {
+                if (client.marketing_opt_in === true) {
+                    consent = {
+                        consentGrantedAt: new Date(client.marketing_opt_in_ts),
+                        consentGrantedSourceName: 'SevenRoomsVenueGroup',
+                        type: PrivacyConsentType.Explicit,
+                    }
+                }
+                else {
+                    consent = {
+                        consentNotGrantedAt: new Date(client.marketing_opt_in_ts),
+                        consentNotGrantedSourceName: 'SevenRoomsVenueGroup',
+                        type: PrivacyConsentType.Explicit,
+                    }
+                }
+            }
+        }
+
+        if (consent) {
+            thisLogger.verbose('Setting consent', { consent })
+            id.consent.marketing.email = consent;
+        }
+    }
+
+    return populated ? id : null;
+}

package/dist/ai-context/internal/examples/v1/sevenrooms/src/lib/sevenrooms/helpers.ts

@@ -0,0 +1,38 @@
+import { Logger } from 'winston';
+import { SevenRoomsWebhookPayload } from './models'
+import { SevenRoomsAppInstallSettings } from '../state/seeka/installations';
+
+export const extractVenueIds = (webhook: SevenRoomsWebhookPayload<unknown>, logger: Logger): string[] => {
+    // For reservations
+    if ((webhook.entity as any)?.venue_id) return [(webhook.entity as any)?.venue_id];
+
+    // For clients, check the updated fields to see if a venue_stats was updated for a specific venue_id
+    const ids: string[] = [];
+    if (webhook.entity_type === 'client') {
+        const updatedFields = webhook.updates || [];
+        const venueStats = updatedFields.find((f) => f.field === 'venue_stats');
+        if (venueStats && venueStats.previous) {
+            const keys = Object.keys(venueStats.previous);
+            const key = keys && keys.length > 0 ? keys[0] : null;
+            if (key) {
+                const stats = venueStats.previous[key];
+                if (stats.venue_id) {
+                    logger.verbose('Found venue_id in client webhook', { venueId: stats.venue_id })
+                    ids.push(stats.venue_id);
+                }
+            }
+        }
+    }
+
+    return ids;
+}
+
+export const sanitiseSevenRoomsPhoneNumber = (phoneNumber: string): string | null => {
+    if (!phoneNumber) return null;
+
+    return phoneNumber.replace(/-/g, '').replace(/\+/g, '');
+}
+
+export const hasSevenRoomsServerSideSettings = (installSettings: SevenRoomsAppInstallSettings): boolean => {
+    return Boolean(installSettings?.connection?.sevenRoomsClientId || installSettings?.connection?.sevenRoomsClientSecret || installSettings?.connection?.sevenRoomsVenueGroupId || installSettings?.connection?.sevenRoomsVenueId);
+}