@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v1/sevenrooms/src/functions/seekaAppWebhook.ts

@@ -0,0 +1,255 @@
+import * as winston from 'winston';
+
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+import {
+    SeekaActivityAcceptedWebhookPayload, SeekaAppInstalledWebhookPayload,
+    SeekaAppInstallSettingsUpdatedWebhookPayload, SeekaAppUninstalledWebhookPayload,
+    SeekaWebhookCallType, SeekaWebhookPayload,
+    throwOnInvalidWebhookSignature
+} from '@seeka-labs/sdk-apps-server';
+
+import { getSeekaBrowserPlugin } from '../lib/browser';
+
+import { childLogger, webhookLogger } from '../lib/logging';
+import { startServices } from '../lib/services';
+import {
+    createOrUpdateInstallation, deleteInstallation, SeekaAppInstallState, SevenRoomsAppInstallSettings, tryGetInstallation
+} from '../lib/state/seeka/installations';
+
+import type { Logger } from 'winston';
+import { getSevenRoomsAuthToken, SevenRoomsAuthToken } from '../lib/sevenrooms/auth';
+import { handleChargePushRules } from '../lib/sevenrooms/charges';
+import { handleClientPushRules } from '../lib/sevenrooms/clients';
+import { hasSevenRoomsServerSideSettings } from '../lib/sevenrooms/helpers';
+import { listSevenRoomsVenues, SevenRoomsVenue } from '../lib/sevenrooms/venues';
+
+app.http('seekaAppWebhook', {
+    methods: ['POST'],
+    authLevel: 'anonymous',
+    route: 'webhook/seeka/app',
+    handler: seekaAppWebhook
+});
+
+export async function seekaAppWebhook(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    const bodyStr = (await req.text()) as string;
+    if (!bodyStr) {
+        return {
+            status: 400,
+            jsonBody: { error: "Body missing. Ensure body is present and either specify the Content-Length request header OR set Transfer-Encoding request header to 'chunked'" }
+        }
+    }
+
+    const body = JSON.parse(bodyStr) as SeekaWebhookPayload;
+
+    let logger = webhookLogger(body, context);
+    logger.profile('http.seeka.webhook.app')
+    logger.verbose('Received webhook from Seeka', { body });
+
+    // Handle probe
+    if (body.type === SeekaWebhookCallType.Probe) {
+        return {
+            status: 204
+        }
+    }
+
+    // Validate webhook
+    try {
+        throwOnInvalidWebhookSignature(process.env.SEEKA_APP_SECRET as string, req.headers, bodyStr);
+        logger.debug('Webhook signature validated', { body });
+    }
+    catch {
+        logger.warn('Webhook signature invalid', { body });
+        return {
+            status: 401,
+            jsonBody: { error: "Webhook call invalid" }
+        }
+    }
+
+    if (body.isTest) {
+        // This is a test webhook call
+        return {
+            status: 204
+        }
+    }
+
+    await startServices(logger);
+
+    // Check if the webhook is for an app we have installed
+    let installation: SeekaAppInstallState | null = null;
+    if (body.type != SeekaWebhookCallType.AppInstalled) {
+        installation = await tryGetInstallation((body as SeekaAppInstalledWebhookPayload).context?.applicationInstallId as string, false, logger);
+        if (installation == null) {
+            logger.warn('Webhook call cannot be processed as the installation ID is not known by this app', { body });
+
+            return {
+                status: 422,
+                jsonBody: { error: "App not installed" }
+            }
+        }
+
+        logger = childLogger({
+            venueId: installation.installationSettings?.connection?.sevenRoomsVenueId,
+            venueGroupId: installation.installationSettings?.connection?.sevenRoomsVenueGroupId
+        }, installation, logger)
+    }
+
+    // Do something
+    let errorMessage: string | null = null;
+    try {
+        switch (body.type) {
+            case SeekaWebhookCallType.AppInstalled:
+                {
+                    errorMessage = await onInstallation(body as SeekaAppInstalledWebhookPayload, logger);
+                    break;
+                }
+            case SeekaWebhookCallType.AppInstallSettingsUpdated:
+                {
+                    errorMessage = await onInstallationSettingsUpdate(body as SeekaAppInstallSettingsUpdatedWebhookPayload, logger);
+                    break;
+                }
+            case SeekaWebhookCallType.AppUninstalled:
+                {
+                    if (!body.isTest) {
+                        const payload = body as SeekaAppUninstalledWebhookPayload;
+                        await deleteInstallation(payload.context?.applicationInstallId as string, logger)
+                    }
+                    break;
+                }
+            case SeekaWebhookCallType.BrowserSdkPlugin: {
+                const plugin = await getSeekaBrowserPlugin(installation as SeekaAppInstallState, logger);
+
+                logger.profile('http.seeka.webhook.app')
+                return {
+                    status: 200,
+                    body: JSON.stringify(plugin),
+                    headers: {
+                        'Content-Type': 'application/json'
+                    }
+                }
+            }
+            case SeekaWebhookCallType.ActivityAccepted: {
+                if (hasSevenRoomsServerSideSettings(installation.installationSettings)) {
+                    const payload = body as SeekaActivityAcceptedWebhookPayload;
+
+                    // Push clients and charges to SevenRooms
+                    const sevenRoomsClientId = await handleClientPushRules(payload.content, installation, logger);
+
+                    // Push charges to SevenRooms
+                    await handleChargePushRules(payload.content, sevenRoomsClientId, installation, logger);
+                }
+                break;
+            }
+        }
+    }
+    catch (err) {
+        logger.error('Failed to handle webhook', { ex: winston.exceptions.getAllInfo(err) });
+        return {
+            status: 500,
+            jsonBody: { error: "Request failed" }
+        }
+    }
+    finally {
+        logger.profile('http.seeka.webhook.app')
+        logger.verbose('Seeka webhook handled');
+    }
+
+    if (errorMessage) {
+        logger.warn('Failed to handle webhook', { error: errorMessage });
+        return {
+            status: 400
+        }
+    }
+    else {
+        return {
+            status: 204
+        }
+    }
+}
+
+const onInstallation = async (payload: SeekaAppInstalledWebhookPayload, logger: Logger): Promise<string | null> => {
+    if (payload.isTest) return;
+
+    const installSettings = payload.content?.installationSettings as SevenRoomsAppInstallSettings;
+
+    const info = await validateSevenRoomsInstallSettings(installSettings, logger);
+    if (info.errorMessage) return info.errorMessage;
+
+    const installation = await createOrUpdateInstallation({
+        ...payload.context,
+        installationState: {
+            grantedPermissions: payload.content?.grantedPermissions || [],
+            sevenRoomsToken: info.sevenRoomsToken,
+            sevenRoomsVenue: {
+                currencyCode: info.sevenRoomsVenue?.currency_code
+            }
+        },
+        applicationInstallId: payload.context?.applicationInstallId as string,
+        organisationBrandId: payload.context?.organisationBrandId as string,
+        organisationId: payload.context?.organisationId as string,
+        installedAt: new Date().toISOString(),
+        installationSettings: payload.content?.installationSettings || {}
+    }, logger)
+
+    return null;
+}
+
+
+const validateSevenRoomsInstallSettings = async (installSettings: SevenRoomsAppInstallSettings, logger: Logger): Promise<{ sevenRoomsToken?: SevenRoomsAuthToken, errorMessage?: string, sevenRoomsVenue?: SevenRoomsVenue }> => {
+    const hasServerSideSettings = hasSevenRoomsServerSideSettings(installSettings);
+
+    let sevenRoomsToken: SevenRoomsAuthToken | undefined = undefined;
+    let venue: SevenRoomsVenue | undefined = undefined;
+    if (hasServerSideSettings) {
+        // Check sevenRooms clientId and secret
+        if (!installSettings?.connection.sevenRoomsClientId || !installSettings?.connection.sevenRoomsClientSecret) {
+            return { errorMessage: 'Missing client ID and/or client secret' };
+        }
+
+        if (!installSettings.connection.sevenRoomsVenueGroupId || !installSettings.connection.sevenRoomsVenueId) {
+            return { errorMessage: 'Missing venue group ID and/or venue ID' };
+        }
+
+        sevenRoomsToken = await getSevenRoomsAuthToken(installSettings, logger);
+        const venues = await listSevenRoomsVenues(installSettings, sevenRoomsToken, logger);
+        if (venues.length === 0) {
+            return { sevenRoomsToken, errorMessage: 'No venues found for the provided credentials' };
+        }
+
+        // Validate venue group ID
+        const venueGroup = venues.find(v => v.venue_group_id === installSettings.connection.sevenRoomsVenueGroupId);
+        if (!venueGroup) {
+            return { sevenRoomsToken, errorMessage: 'Venue group ID provided does not match client credentials' };
+        }
+
+        // Validate venue ID
+        venue = venues.find(v => v.id === installSettings.connection.sevenRoomsVenueId && v.venue_group_id === installSettings.connection.sevenRoomsVenueGroupId);
+        if (!venue) {
+            return { sevenRoomsToken, errorMessage: 'Venue ID provided does not match client credentials' };
+        }
+    }
+
+    return { sevenRoomsToken, sevenRoomsVenue: venue };
+}
+
+const onInstallationSettingsUpdate = async (payload: SeekaAppInstallSettingsUpdatedWebhookPayload, logger: Logger): Promise<string | null> => {
+    if (payload.isTest) return;
+
+    const existingInstallation = await tryGetInstallation(payload.context?.applicationInstallId as string, true, logger) as SeekaAppInstallState;
+
+    const newSettings = payload.content?.installationSettings as SevenRoomsAppInstallSettings;
+    const info = await validateSevenRoomsInstallSettings(newSettings, logger);
+    if (info.errorMessage) return info.errorMessage;
+
+    const installation = await createOrUpdateInstallation({
+        ...existingInstallation,
+        installationState: {
+            ...existingInstallation.installationState,
+            grantedPermissions: payload.content?.grantedPermissions || [],
+            sevenRoomsToken: info.sevenRoomsToken,
+            sevenRoomsVenue: {
+                currencyCode: info.sevenRoomsVenue?.currency_code
+            }
+        },
+        installationSettings: newSettings || {},
+    }, logger)
+}

package/dist/ai-context/internal/examples/v1/sevenrooms/src/functions/sevenRoomsWebhook.ts

@@ -0,0 +1,202 @@
+
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+
+import { forOwn, groupBy } from 'lodash';
+import * as winston from 'winston';
+import { queueNames, triggerBackgroundJob } from '../lib/jobs';
+import { childLogger } from '../lib/logging';
+import { startServices } from '../lib/services';
+import { extractVenueIds } from '../lib/sevenrooms/helpers';
+import { SevenRoomsWebhookPayload } from '../lib/sevenrooms/models';
+import { SevenRoomsReservation } from '../lib/sevenrooms/reservations';
+import { SeekaAppInstallState, tryGetInstallation, tryGetInstallationMappingFromVenue } from '../lib/state/seeka/installations';
+import { SevenRoomsWebhookPayloadQueueItem } from './handleSevenRoomsWebhookQueueItem';
+
+app.http('sevenRoomsWebhook', {
+    methods: ['POST'],
+    authLevel: 'function',
+    route: 'webhook/sevenrooms',
+    handler: sevenRoomsWebhook
+});
+
+export async function sevenRoomsWebhook(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    let logger = childLogger({ requestId: context.invocationId, url: req.url });
+    const bodyStr = (await req.text()) as string;
+    if (!bodyStr) {
+        return {
+            status: 400,
+            jsonBody: { error: "Body missing. Ensure body is present and either specify the Content-Length request header OR set Transfer-Encoding request header to 'chunked'" }
+        }
+    }
+
+    const body = JSON.parse(bodyStr) as SevenRoomsWebhookPayload<unknown>[];
+    logger.profile('http.sevenrooms.webhook.app')
+
+    const headers = req.headers.entries();
+    const headersObj = {};
+    for (const [key, value] of headers) {
+        headersObj[key] = value;
+    }
+
+    logger.debug('Received webhook from SevenRooms', { body, headers: headersObj });
+
+    // Get seeka app install Id
+    // const seekaAppInstallId = req.headers.get('x-seeka-app-install-id');
+    // if (!seekaAppInstallId) {
+    //     logger.error('Missing Seeka app install Id header');
+    //     return {
+    //         status: 400,
+    //         jsonBody: { error: "Missing x-seeka-app-install-id header" }
+    //     }
+    // }
+    // logger = childLogger({ requestId: context.invocationId, url: req.url, seekaAppInstallId });
+    await startServices(logger);
+
+    // Check if the webhook is for an app we have installed
+    // const installation = await tryGetInstallation(seekaAppInstallId, false, logger);
+    // if (installation == null) {
+    //     logger.warn('Webhook call cannot be processed as the installation ID is not known by this app', { body });
+
+    //     return {
+    //         status: 422,
+    //         jsonBody: { error: "App not installed" }
+    //     }
+    // }
+
+
+    const venueIdToInstallationCache = new Map<string, SeekaAppInstallState>();
+    const getLoggerAndInstallation = async (venueId: string, venueGroupId: string, logger: winston.Logger): Promise<{ logger: winston.Logger, installation?: SeekaAppInstallState }> => {
+        let thisLogger = childLogger({ requestId: context.invocationId, url: req.url, venueId, venueGroupId });
+
+        const key = `${venueGroupId}:${venueId}`;
+        let installation: SeekaAppInstallState;
+        if (venueIdToInstallationCache.has(key)) {
+            installation = venueIdToInstallationCache.get(key);
+        }
+        else {
+            const installationMapping = await tryGetInstallationMappingFromVenue(venueGroupId, venueId, false, logger);
+            if (!installationMapping) {
+                thisLogger.warn('No installation found for venue', { venueId, venueGroupId });
+                return {
+                    logger: thisLogger
+                }
+            }
+            else {
+                thisLogger.verbose('Installation found for venue', { venueId, venueGroupId, appInstallId: installationMapping.appInstallId });
+            }
+
+            installation = await tryGetInstallation(installationMapping.appInstallId, true, logger);
+            venueIdToInstallationCache.set(key, installation);
+        }
+
+        thisLogger = childLogger({ requestId: context.invocationId, url: req.url }, installation, thisLogger);
+
+        return {
+            logger: thisLogger,
+            installation
+        }
+    }
+
+    try {
+        // Handle each webhook, group by venue ID and venue group id
+        forOwn(groupBy(body, (e) => (e.entity as any)?.venue_group_id || '' as string), async (webhooks, venueGroupId) => {
+            if (!venueGroupId) {
+                logger.warn('Missing venueGroupId in webhook. Not handling', { webhooks });
+                return;
+            }
+            // const venueIds = extractVenueIds(webhooks, logger)
+            // if (!venueId) {
+            //     logger.warn('Missing venueId in webhook. Not handling', { webhooks });
+            //     return;
+            // }
+            logger.debug('Handling webhooks for venue group', { venueGroupId, webhooks: webhooks.map(e => e.event_type) });
+
+            // Handle reservation webhooks (venue scoped)
+            forOwn(groupBy(webhooks.filter(e => e.entity_type === 'reservation'), (e) => (e.entity as any)?.venue_id), async (webhooksByVenue, venueId) => {
+                const loggerAndInstallation = await getLoggerAndInstallation(venueId, venueGroupId, logger);
+                const installation = loggerAndInstallation.installation;
+                if (installation == null) {
+                    logger.verbose('Not handling reservation webhook as installation not found', { venueId, venueGroupId, webhooksByVenue })
+                    return;
+                }
+
+                const thisLogger = loggerAndInstallation.logger;
+
+                for (const webhook of webhooksByVenue) {
+                    const reservationWebhook = webhook as SevenRoomsWebhookPayload<SevenRoomsReservation>;
+                    const reservation = reservationWebhook.entity;
+                    const venueGroupId = reservation.venue_group_id;
+                    if (!venueId) {
+                        logger.warn('Missing venueId in reservation webhook. Not handling', { reservation });
+                        continue;
+                    }
+
+                    // Push to queue to handle webhook
+                    thisLogger.debug('Pushing webhook to queue', { webhook, venueId, eventType: webhook.event_type, entityType: webhook.entity_type });
+                    await triggerBackgroundJob(queueNames.handleSevenRoomsWebhookQueueItem, {
+                        causationId: context.invocationId,
+                        correlationId: context.invocationId,
+                        applicationInstallId: installation.applicationInstallId,
+                        organisationBrandId: installation.organisationBrandId,
+                        organisationId: installation.organisationId,
+                        webhook: webhook,
+                        venueGroupId,
+                        venueId
+                    } as SevenRoomsWebhookPayloadQueueItem, logger)
+                }
+            })
+
+            // Handle client webhooks (no venue scope)
+            webhooks.filter(e => e.entity_type === 'client').forEach(async (webhook) => {
+                extractVenueIds(webhook, logger).forEach(async (venueId) => {
+                    if (!venueId) {
+                        logger.warn('Missing venueId in client webhook. Not handling', { webhook });
+                        return;
+                    }
+
+                    const loggerAndInstallation = await getLoggerAndInstallation(venueId, venueGroupId, logger);
+                    const installation = loggerAndInstallation.installation;
+                    if (installation == null) {
+                        logger.verbose('Not handling client webhook as installation not found', { venueId, venueGroupId, webhook })
+                        return;
+                    }
+
+                    const thisLogger = loggerAndInstallation.logger;
+
+                    thisLogger.debug('Handling client webhook', { eventType: webhook.event_type, entityType: webhook.entity_type });
+
+                    await triggerBackgroundJob(queueNames.handleSevenRoomsWebhookQueueItem, {
+                        causationId: context.invocationId,
+                        correlationId: context.invocationId,
+                        applicationInstallId: installation.applicationInstallId,
+                        organisationBrandId: installation.organisationBrandId,
+                        organisationId: installation.organisationId,
+                        webhook: webhook,
+                        venueGroupId,
+                        venueId
+                    } as SevenRoomsWebhookPayloadQueueItem, logger)
+                })
+            })
+
+            // Unhandled webhook types
+            webhooks.filter(e => e.entity_type !== 'reservation' && e.entity_type !== 'client').forEach((webhook) => {
+                logger.warn('Not handling SevenRooms webhook payload as entity_type is unknown', { entityType: webhook.entity_type, eventType: webhook.event_type, webhook });
+            });
+        })
+    }
+    catch (err) {
+        logger.error('Failed to handle webhook', { ex: winston.exceptions.getAllInfo(err) });
+        return {
+            status: 500,
+            jsonBody: { error: "Request failed" }
+        }
+    }
+    finally {
+        logger.profile('http.sevenrooms.webhook')
+        logger.verbose('SevenRooms webhook handled');
+    }
+
+    return {
+        status: 204
+    }
+}

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

@@ -0,0 +1,68 @@
+import winston, { Logger } from 'winston';
+import fs from 'fs';
+import path from 'path';
+import util from 'util';
+import { SeekaBrowserSdkPluginWebhookResponse, getActivityName } from '@seeka-labs/sdk-apps-server'
+import {
+    SeekaAppInstallState
+} from '../state/seeka/installations';
+import type { ISevenRoomsBrowserSdkPluginConfig } from '../models';
+import { forOwn } from 'lodash';
+
+const fileExistsAsync = util.promisify(fs.exists);
+const readFileAsync = util.promisify(fs.readFile);
+
+export async function getSeekaBrowserPlugin(installation: SeekaAppInstallState, logger: Logger): Promise<SeekaBrowserSdkPluginWebhookResponse> {
+    logger.profile('http.seeka.browser.plugin')
+
+    let content: string | undefined;
+    let init: string | undefined;
+
+    try {
+        logger.verbose('Handling request for browser plugin content');
+        // const browserPluginPath = '../browser/seeka-app-sevenrooms.min.js';
+        const browserPluginPath = path.resolve('./dist/src/browser/seeka-app-sevenrooms.min.js');
+        if (await fileExistsAsync(browserPluginPath)) {
+            // Content of the script. This should not change per installation it should be the same for all installations            
+            content = await readFileAsync(browserPluginPath, 'utf8');
+
+
+
+            // Configuration for the plugin. This can be different per installation
+            const pluginConfig = {
+                events: {},
+                // sevenRoomsVenueGroupId: installation.installationSettings.connection.sevenRoomsVenueGroupId,
+                // sevenRoomsVenueId: installation.installationSettings.connection.sevenRoomsVenueId,
+                currencyCode: installation.installationState?.sevenRoomsVenue?.currencyCode,
+                appId: process.env.SEEKA_APP_ID,
+                appInstallId: installation.applicationInstallId,
+                appUrl: process.env.SELF_HOST_BASEURL
+            } as ISevenRoomsBrowserSdkPluginConfig;
+
+            forOwn(installation.installationSettings.events, (value, key) => {
+                pluginConfig.events[key] = {
+                    activityName: value,
+                    standardName: getActivityName(value)
+                }
+            })
+
+            init = `SevenRoomsConvergeSdkPlugin(${JSON.stringify(pluginConfig)})`;
+        }
+        else {
+            logger.error('Browser plugin content not found', { path: browserPluginPath });
+        }
+    }
+    catch (err) {
+        logger.error('Failed to handle request for browser plugin content', { ex: winston.exceptions.getAllInfo(err) });
+    }
+    finally {
+        logger.profile('http.seeka.browser.plugin')
+        logger.verbose('Request for browser plugin content handled');
+    }
+
+    if (!content || !init) {
+        throw new Error('Failed to handle request for browser plugin content')
+    }
+
+    return { content, init: init }
+}

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

@@ -0,0 +1,69 @@
+import { QueueClient } from '@azure/storage-queue';
+import type { Logger } from 'winston';
+
+export interface BackgroundJobRequestContext {
+    organisationId?: string;
+    organisationBrandId?: string;
+    applicationInstallId?: string;
+    causationId: string
+    correlationId: string
+}
+
+export const queueNames = {
+    handleSevenRoomsWebhookQueueItem: 'handle-sevenrooms-webhook'
+}
+
+export const triggerBackgroundJob = async (queueName: string, context: BackgroundJobRequestContext, logger: Logger): Promise<void> => {
+    const queueClient = new QueueClient(process.env.AzureWebJobsStorage as string, queueName);
+    return triggerBackgroundJobWithQueue(queueClient, context, logger);
+}
+
+const serialiseQueuePayload = (payload: unknown): string => {
+    const jsonString = JSON.stringify(payload)
+    return Buffer.from(jsonString).toString('base64')
+}
+
+export const deserialiseQueuePayload = <TPayload>(payload: string): TPayload => {
+    const jsonString = Buffer.from(payload, 'base64').toString()
+    return JSON.parse(jsonString) as TPayload;
+}
+
+export const triggerBackgroundJobWithQueue = async (queueClient: QueueClient, context: BackgroundJobRequestContext, logger: Logger): Promise<void> => {
+    const body = {
+        ...context
+    }
+    const bodyStr = serialiseQueuePayload(body);
+
+    const response = await queueClient.sendMessage(bodyStr);
+
+    if (response.errorCode) {
+        const { requestId, date, errorCode } = response;
+        logger.error("Failed to trigger background job", { body, requestId, date, errorCode })
+        throw new Error(`Failed to trigger background job: ${response.errorCode}`);
+    }
+    else {
+        logger.debug("Background job triggered", { body, messageId: response.messageId, context })
+    }
+}
+
+
+export const sendQueueMessageToPoisonQueue = async (queueName: string, context: BackgroundJobRequestContext, logger: Logger): Promise<void> => {
+    const body = {
+        ...context
+    }
+    const bodyStr = serialiseQueuePayload(body);
+
+    // https://learn.microsoft.com/en-us/azure/azure-functions/functions-bindings-storage-queue-trigger?tabs=python-v2%2Cisolated-process%2Cnodejs-v4%2Cextensionv5&pivots=programming-language-typescript#poison-messages
+    const queueClient = new QueueClient(process.env.AzureWebJobsStorage as string, `${queueName}-poison`);
+
+    const response = await queueClient.sendMessage(bodyStr, { messageTimeToLive: -1 });
+
+    if (response.errorCode) {
+        const { requestId, date, errorCode } = response;
+        logger.error("Failed to push to poison queue", { body, requestId, date, errorCode })
+        throw new Error(`Failed to push to poison queue: ${response.errorCode}`);
+    }
+    else {
+        logger.verbose("Message pushed to poison queue", { body, messageId: response.messageId, context })
+    }
+}