@seeka-labs/cli-apps 3.7.0 → 3.8.2

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

@@ -0,0 +1,106 @@
+import * as winston from 'winston';
+
+import { InvocationContext } from '@azure/functions';
+import { SeqTransport } from '@datalust/winston-seq';
+
+import * as packageJson from '../../../package.json';
+
+import type {
+    SeekaWebhookPayload, SeekaWebhookPayloadOfSeekaAppWebhookContext
+} from '@seeka-labs/sdk-apps-server';
+import { BackgroundJobRequestContext } from '../jobs';
+import { SeekaAppInstallState } from '../state/seeka/installations';
+
+const loggerTransports: winston.transport[] = [
+    new winston.transports.Console({
+        level: process.env.LOGGING_LEVEL,
+        format: winston.format.combine(
+            winston.format.errors({ stack: true }),
+            winston.format.cli(),
+            winston.format.splat(),
+        ),
+        handleExceptions: true,
+        handleRejections: true,
+    }),
+]
+if (process.env.LOGGING_SEQ_SERVERURL) {
+    loggerTransports.push(
+        new SeqTransport({
+            level: process.env.LOGGING_LEVEL,
+            serverUrl: process.env.LOGGING_SEQ_SERVERURL,
+            apiKey: process.env.LOGGING_SEQ_APIKEY,
+            onError: ((e) => { console.error('Failed to configure Seq logging transport', e) }),
+            format: winston.format.combine(
+                winston.format.errors({ stack: true }),
+                winston.format.json(),
+            ),
+            handleExceptions: true,
+            handleRejections: true,
+        })
+    )
+}
+
+const defaultMeta = {
+    seekaAppId: process.env.SEEKA_APP_ID,
+    Hosting_Provider: 'azure',
+    Release_Version: `v${packageJson.version.split('-')[0]}`,
+    Hosting_Region: process.env.REGION_NAME,
+    Service_Instance_Id: process.env.WEBSITE_ROLE_INSTANCE_ID,
+    AzureFunctions_FunctionName: process.env.WEBSITE_SITE_NAME,
+    Service: `app/${packageJson.name}`,
+};
+
+export const logger = winston.createLogger({
+    level: process.env.LOGGING_LEVEL,
+    defaultMeta: {
+        ...defaultMeta
+    },
+    transports: loggerTransports,
+    exitOnError: false,
+});
+
+export const childLogger = (meta: object | null, installation?: SeekaAppInstallState, l: winston.Logger = logger) => l.child({
+    ...defaultMeta, ...meta, ...(installation ? {
+        seekaAppInstallId: installation.applicationInstallId,
+        seekaAppInstallOrganisationBrandId: installation.organisationBrandId,
+        seekaAppInstallOrganisationId: installation.organisationId
+    } : {})
+});
+
+export const webhookLogger = (payload: SeekaWebhookPayload, functionContext: InvocationContext) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const meta: any = {
+        ...defaultMeta,
+        seekaWebhookType: payload.type,
+        seekaWebhookIsTest: payload.isTest,
+        RequestId: payload.requestId,
+        AzureFunctions_InvocationId: functionContext.invocationId,
+        CausationId: payload.causationId,
+        CorrelationId: payload.causationId,
+    }
+
+    const context = (payload as SeekaWebhookPayloadOfSeekaAppWebhookContext).context;
+    if (context) {
+        meta.seekaAppInstallId = context.applicationInstallId;
+        meta.seekaAppInstallOrganisationBrandId = context.organisationBrandId;
+        meta.seekaAppInstallOrganisationId = context.organisationId;
+    }
+
+    return childLogger(meta)
+}
+
+export const backgroundJobLogger = (jobName: string, jobContext: BackgroundJobRequestContext | undefined, functionContext: InvocationContext) => {
+    const meta: object = {
+        jobContext,
+        jobName,
+        AzureFunctions_InvocationId: functionContext.invocationId,
+        CausationId: jobContext?.causationId,
+        CorrelationId: jobContext?.causationId,
+        seekaAppInstallId: jobContext?.applicationInstallId,
+        seekaAppInstallOrganisationBrandId: jobContext?.organisationBrandId,
+        seekaAppInstallOrganisationId: jobContext?.organisationId,
+        ...defaultMeta
+    }
+
+    return childLogger(meta)
+}

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

@@ -0,0 +1,17 @@
+import { TrackingActivityNames } from "@seeka-labs/sdk-apps-server"
+import { SevenRoomsAppInstallEventSettingsTyped } from "../state/seeka/models"
+
+export interface ISevenRoomsBrowserSdkPluginConfig {
+    events: SevenRoomsAppInstallEventSettingsTyped<ActivityNameInfo>
+    // sevenRoomsVenueId: string
+    // sevenRoomsVenueGroupId: string
+    currencyCode: string
+    appId: string
+    appInstallId: string
+    appUrl: string
+}
+
+export interface ActivityNameInfo {
+    standardName: TrackingActivityNames
+    activityName: string
+}

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

@@ -0,0 +1,41 @@
+import winston, { Logger } from 'winston';
+
+import { connect, disconnect, isConnected } from '../state/redis';
+
+export const startServices = async (logger: Logger) => {
+    logger.debug(`Trying to connect to Redis - ${process.env.REDIS_CONNECTION_HOST}`)
+    try {
+        if (isConnected()) {
+            logger.verbose(`Redis already connected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+        else {
+            logger.profile('service.redis.connect')
+            await connect();
+            logger.profile('service.redis.connect')
+            logger.debug(`Redis connected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+    }
+    catch (err) {
+        logger.error(`Failed to connect to Redis - ${process.env.REDIS_CONNECTION_HOST}`, { ex: winston.exceptions.getAllInfo(err) })
+        throw err;
+    }
+}
+
+export const stopServices = async (logger: Logger) => {
+    logger.debug(`Trying to disconnect from Redis - ${process.env.REDIS_CONNECTION_HOST}`)
+    try {
+        if (isConnected() === false) {
+            logger.verbose(`Redis already disconnected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+        else {
+            logger.profile('service.redis.disconnect')
+            await disconnect();
+            logger.profile('service.redis.disconnect')
+            logger.verbose(`Redis disconnected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+    }
+    catch (err) {
+        logger.error(`Failed to disconnect from Redis - ${process.env.REDIS_CONNECTION_HOST}`, { ex: winston.exceptions.getAllInfo(err) })
+        throw err;
+    }
+}

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

@@ -0,0 +1,70 @@
+import fetch from 'node-fetch'
+import { Logger } from 'winston';
+import { SeekaAppInstallState, SevenRoomsAppInstallSettings, createOrUpdateInstallation, tryGetInstallation } from '../../state/seeka/installations';
+import { getSevenRoomsApiHost } from '../models';
+
+export const getSevenRoomsAuthToken = async (installationSettings: SevenRoomsAppInstallSettings, logger: Logger): Promise<SevenRoomsAuthToken> => {
+    const url = `https://${getSevenRoomsApiHost(installationSettings)}/2_4/auth`;
+
+    const details = {
+        'client_id': installationSettings.connection.sevenRoomsClientId,
+        'client_secret': installationSettings.connection.sevenRoomsClientSecret
+    };
+
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded'
+        },
+        body: new URLSearchParams(details)
+    })
+
+    if (response.ok) {
+        const data = (await response.json())?.data;
+        return {
+            token: data.token,
+            token_expiration_datetime: data.token_expiration_datetime
+        }
+    }
+    else {
+        logger.error(`Failed to get auth token from SevenRooms: ${response.statusText}`, { res: await response.text(), status: response.status });
+        throw new Error(`Failed to get auth token from SevenRooms: ${response.statusText}`);
+    }
+}
+
+export const getOrCreateSevenRoomsAuthToken = async (installation: SeekaAppInstallState, logger: Logger): Promise<SevenRoomsAuthToken> => {
+    // Check if the token on the install state is still valid
+    if (installation.installationState.sevenRoomsToken) {
+        const now = new Date();
+        const expiration = new Date(installation.installationState.sevenRoomsToken.token_expiration_datetime);
+        if (expiration > now) {
+            logger.verbose('SevenRooms token is still valid');
+            return installation.installationState.sevenRoomsToken;
+        }
+        else {
+            logger.verbose('SevenRooms token has expired, getting new token');
+        }
+    }
+
+    const token = await getSevenRoomsAuthToken(installation.installationSettings, logger);
+
+    // Update the installation with the new token
+    if (token.token != installation.installationState.sevenRoomsToken.token) {
+        installation = await tryGetInstallation(installation.applicationInstallId, true, logger);
+        await createOrUpdateInstallation({
+            ...installation,
+            installationState: {
+                ...installation.installationState,
+                sevenRoomsToken: token
+            }
+        }, logger);
+        logger.verbose('Updated installation state with new SevenRooms token');
+    }
+
+    return token;
+}
+
+export interface SevenRoomsAuthToken {
+    token: string
+    token_expiration_datetime: string
+}

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

@@ -0,0 +1,202 @@
+import { Logger } from "winston";
+import { SeekaAppInstallState, SevenRoomsAppInstallSettings } from "../../state/seeka/installations";
+import { SeekaActivityAcceptedWebhookContent, WebsiteEventActivityAppsPayload, matchActivityPipelineFilters } from "@seeka-labs/sdk-apps-server";
+import { SevenRoomsAuthToken, getOrCreateSevenRoomsAuthToken } from "../auth";
+import { getSevenRoomsApiHost } from "../models";
+import { SevenRoomsReservation, findSevenRoomsReservations, getReservationDateByActivity } from "../reservations";
+import { findSevenRoomsClients } from "../clients";
+import { DateTime } from 'luxon';
+
+export const handleChargePushRules = async (activity: SeekaActivityAcceptedWebhookContent, forSevenRoomsClientId: string | undefined, installation: SeekaAppInstallState, logger: Logger) => {
+    const rules = installation.installationSettings?.charges?.pushChargesToSevenRoomsRules || [];
+    if (rules.length === 0) return;
+
+    let thisLogger = logger.child({
+        sevenRoomsClientId: forSevenRoomsClientId,
+        'Person_PersonId': activity.identifiers.seekaPId,
+        'Activity_ActivityName': activity.activity.activityName,
+        'Activity_ActivityNameCustom': activity.activity.activityNameCustom,
+        'Reason': 'ChargePushRules'
+    })
+    thisLogger.verbose('Checking activity against charge push rules', { activity, rules });
+    const matched = matchActivityPipelineFilters(activity, rules, thisLogger);
+    if (matched.length === 0) {
+        thisLogger.verbose('No charge push rules matched activity', { activity, rules });
+        return;
+    }
+
+    const sevenRoomsToken = await getOrCreateSevenRoomsAuthToken(installation, thisLogger);
+    let sevenRoomsClientIds: string[] = [];
+    if (forSevenRoomsClientId) {
+        sevenRoomsClientIds.push(forSevenRoomsClientId);
+    }
+
+    if (sevenRoomsClientIds.length === 0) {
+        thisLogger.debug('No SevenRooms client ID provided to charge rules, trying to find client');
+
+        const externalIds = [activity.identifiers.seekaPId, ...(activity.identifiers.seekaBId ?? [])];
+        const existingClients = await findSevenRoomsClients(activity.identifiers.email, activity.identifiers.phone, externalIds, installation.installationSettings, sevenRoomsToken, thisLogger);
+        if (existingClients.length > 1) {
+            sevenRoomsClientIds = existingClients.map(c => c.id).filter(Boolean);
+            thisLogger = thisLogger.child({ sevenRoomsClientId: sevenRoomsClientIds })
+            thisLogger.warn('Found multiple clients in SevenRooms to allocate charges to', {
+                email: activity.identifiers.email,
+                phone: activity.identifiers.phone,
+                externalIds: externalIds,
+                clients: existingClients,
+            });
+        }
+        else if (existingClients.length === 1) {
+            const existingClient = existingClients[0];
+            sevenRoomsClientIds = [existingClient.id];
+            thisLogger = thisLogger.child({ sevenRoomsClientId: sevenRoomsClientIds })
+            thisLogger.debug('Found single client in SevenRooms to allocate charges to', { client: existingClient, activity });
+        }
+        else {
+            // No client found
+            thisLogger.debug('No client found in SevenRooms to allocate charges to, not creating client as there will be no reservation to assign the charge to');
+            return;
+            // const newClient = seekaIdentityToSevenRoomsClient(activity.identifiers, installation.installationSettings.connection.sevenRoomsVenueId, true, installation.installationSettings.advanced.allowUseOfSevenRoomsExternalId, logger);
+            // if (newClient) {
+            //     const created = await createSevenRoomsClient(newClient, installation.installationSettings, sevenRoomsToken, thisLogger);
+            //     if (created) {
+            //         sevenRoomsClientId = created.client_id;
+            //         thisLogger = thisLogger.child({ sevenRoomsClientId })
+            //     }
+            //     else {
+            //         thisLogger.error('Failed to create client in SevenRooms for client charge push rules', { newClient });
+            //         return;
+            //     }
+            // }
+            // else {
+            //     thisLogger.error('Failed to convert Seeka indentity to SevenRooms client for client charge push rules', { activity });
+            //     return;
+            // }
+        }
+    }
+
+    thisLogger.verbose('Matched charge push rules and SevenRooms client, pushing charges to SevenRooms', { matched });
+
+    // Find reservations
+    const reservationDate = getReservationDateByActivity(activity, thisLogger);
+    const reservationDateLuxon = DateTime.fromJSDate(reservationDate);
+    const fromDate = reservationDateLuxon.minus({ days: 1 });
+    const toDate = reservationDateLuxon.plus({ days: 1 });
+
+    // Find reservations across all clients
+    const matchedReservations: SevenRoomsReservation[] = [];
+    sevenRoomsClientIds.forEach(async (sevenRoomsClientId) => {
+        const reservations = await findSevenRoomsReservations(sevenRoomsClientId, fromDate, toDate, installation.installationSettings, sevenRoomsToken, thisLogger);
+        let reservation: SevenRoomsReservation | undefined;
+        if (!reservations || reservations.length === 0) {
+            thisLogger.warn('No reservations found for activity, not creating charge', { activity, sevenRoomsClientId, reservationDate, fromDate, toDate });
+            return;
+        }
+        else if (reservations.length > 1) {
+            thisLogger.warn('Multiple reservations found for activity, picking earliest booking time for the one to allocate charge to', { reservations, activity, sevenRoomsClientId, reservationDate, fromDate, toDate });
+            reservation = reservations.sort((a, b) => new Date(b.real_datetime_of_slot).getTime() - new Date(a.real_datetime_of_slot).getTime())[0];
+        }
+        else {
+            thisLogger.verbose('Found reservation for activity', { reservation: reservations[0], activity, sevenRoomsClientId, reservationDate, fromDate, toDate });
+            reservation = reservations[0];
+        }
+        if (reservation) {
+            matchedReservations.push(reservation);
+            thisLogger.verbose('Found reservation for activity', { reservation, activity, sevenRoomsClientId, reservationDate, fromDate, toDate });
+        }
+    })
+
+    if (matchedReservations.length === 1) {
+        // Create charge
+        const reservation = matchedReservations[0];
+        const charge = seekaActivityToSevenRoomsCharge(activity.activity, installation, thisLogger);
+        if (charge) {
+            await createSevenRoomsCharge(reservation.id, charge, installation.installationSettings, sevenRoomsToken, thisLogger);
+        }
+    }
+    else if (matchedReservations.length > 1) {
+        thisLogger.warn('Multiple reservations found for activity, not creating charge', { activity, matchedReservations });
+    }
+    else {
+        thisLogger.verbose('No reservations found for activity, not creating charge', { activity, matchedReservations });
+    }
+}
+
+const seekaActivityToSevenRoomsCharge = (activity: WebsiteEventActivityAppsPayload, installation: SeekaAppInstallState, logger: Logger): SevenRoomsChargeCreatePayload | null => {
+    const charge = {
+        venue_id: installation.installationSettings.connection.sevenRoomsVenueId,
+    } as SevenRoomsChargeCreatePayload;
+
+    if (activity.commerce) {
+        if (activity.commerce.totalPrice) {
+            if (activity.commerce.totalLineItemsPrice) {
+                charge.subtotal = activity.commerce.totalLineItemsPrice;
+                charge.total = activity.commerce.totalPrice;
+            }
+            else {
+                charge.subtotal = activity.commerce.totalPrice;
+            }
+
+            if (activity.commerce.totalTax) {
+                charge.tax = activity.commerce.totalTax;
+            }
+
+            if (activity.commerce.orderNumber) {
+                charge.transaction_id = activity.commerce.orderNumber;
+            }
+            else if (activity.commerce.orderIdentifier) {
+                charge.transaction_id = activity.commerce.orderIdentifier;
+            }
+            else if (activity.commerce.checkoutIdentifier) {
+                charge.transaction_id = activity.commerce.checkoutIdentifier;
+            }
+            else {
+                logger.warn('No transaction ID found in activity, using activity ID', { activity });
+                charge.transaction_id = activity.activityId;
+            }
+        }
+    }
+
+    if (!charge.subtotal) {
+        return null;
+    }
+
+    return charge;
+}
+
+const createSevenRoomsCharge = async (reservationId: string, charge: SevenRoomsChargeCreatePayload, installSettings: SevenRoomsAppInstallSettings, sevenRoomsToken: SevenRoomsAuthToken, logger: Logger): Promise<{ invoice_id: string, reference_id: string }> => {
+    const url = `https://${getSevenRoomsApiHost(installSettings)}/2_4/reservations/${reservationId}/add_charge`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Authorization': `${sevenRoomsToken.token}`,
+            'Content-Type': 'application/x-www-form-urlencoded'
+        },
+        body: new URLSearchParams(charge as any)
+    });
+
+    if (!response.ok) {
+        const responseText = await response.text() || '';
+        const alreadyRecorded = responseText.includes('You have already recorded this transaction');
+        if (alreadyRecorded) {
+            logger.warn(`Charge already recorded in SevenRooms`, { charge, reservationId, responseText });
+        }
+        else {
+            logger.error(`Failed to create charge in SevenRooms: ${response.statusText}`, { res: await response.text(), status: response.status, charge, url });
+            throw new Error(`Failed to create charge in SevenRooms: ${response.statusText}`);
+        }
+    }
+    else {
+        const result = (await response.json())?.data;
+        logger.info('Created charge in SevenRooms', { charge, reservationId, result });
+        return result;
+    }
+}
+
+interface SevenRoomsChargeCreatePayload {
+    transaction_id: string;
+    venue_id: string;
+    subtotal: number;
+    total: number;
+    tax: number;
+}