@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v2/navitas/app/server/src/lib/salesforce/journeys/index.ts

@@ -0,0 +1,192 @@
+import { ActivityPayload, SeekaAppHelper, TrackingActivityNames, TrackingEventSourceOriginType } from "@seeka-labs/sdk-apps-server";
+import { Logger } from "winston";
+import { NavitasJourneyState } from "../../state/navitas/journey";
+import { salesforceLeadToContentItem } from "../leads";
+import { SalesforceLeadStages, SalesforceOpportunityStages } from "../models";
+import { salesforceOpporunityToContentItem } from "../opportunities";
+
+// DONE - When lead status = New or changes to Reopened, Attempted or Contacted, track as ‘SQL’ event
+// DONE - When lead status changes from "New" to Nurturing or = Nurturing, track as ‘Nurture’ event
+// DONE - When lead status = Lost, track as ‘Lost_Lead’
+// DONE - When a lead transitions from "New" to Nurturing or Lost or Application Stage = Application Cancelled to Lead status = Qualified, track as ‘Qualified_Lead’ event
+// DONE - When a lead status or application stage changes to ‘Offer Pending’, track as ‘Offer Pending’ event
+// DONE - When application stage = New, track as ‘Application’ event
+// DONE - When Application Stage = Application Cancelled, track as ‘Cancelled_Application’
+// DONE - When application stage changes from New to Qualified, track as’ Qualified_Application’ event
+// DONE - When application stage changes to Offer made, track as ‘Offer_Made’ event
+// DONE - When application stage changes to ‘Enrolled’ event
+
+export const handleJourneyStageTransition = async (journey: NavitasJourneyState, source: 'lead' | 'opportunity', seekaProfileId: string, helper: SeekaAppHelper, logger: Logger): Promise<void> => {
+    switch (source) {
+        case 'lead':
+            await handleLeadStageTransition(journey, seekaProfileId, helper, logger);
+            break;
+        case 'opportunity':
+            await handleOpportunityStageTransition(journey, seekaProfileId, helper, logger);
+            break;
+        default:
+            throw new Error('Unknown source - ' + source);
+    }
+}
+
+const trackActivityForStageTransition = async (activity: ActivityPayload, journey: NavitasJourneyState, seekaProfileId: string, source: 'lead' | 'opportunity', helper: SeekaAppHelper, logger: Logger): Promise<void> => {
+    logger.info('Tracking activity for journey stage transition',
+        {
+            source,
+            activityName: activity.activityName,
+            activityNameCustom: activity.activityNameCustom,
+            payload: activity,
+            journeyId: journey.journeyId,
+            whoId: journey.whoId,
+            leadId: journey.leadId,
+            opportunityId: journey.opportunityId,
+            Activity_ActivityIdentifier: activity.activityId,
+            previousStage: source === 'lead' ? journey.leadPreviousStage?.salesforceStage : journey.opportunityPreviousStage?.salesforceStage,
+            newStage: source === 'lead' ? journey.leadCurrentStage?.salesforceStage : journey.opportunityCurrentStage?.salesforceStage,
+            leadCurrentStage: journey.leadCurrentStage?.salesforceStage,
+            leadPreviousStage: journey.leadPreviousStage?.salesforceStage,
+            opportunityCurrentStage: journey.opportunityCurrentStage?.salesforceStage,
+            opportunityPreviousStage: journey.opportunityPreviousStage?.salesforceStage,
+            OperationName: 'Navitas pipeline'
+        });
+
+    await helper.api.trackActivityForProfileId({
+        ...activity,
+        properties: {
+            ...activity.properties,
+            opportunityId: activity.properties?.opportunityId || journey.opportunityId || journey.lead?.ConvertedOpportunityId || journey.opportunity?.Id,
+            journeyId: journey.journeyId,
+            leadId: activity.properties?.leadId || journey.leadId || journey.lead?.Id,
+            leadContactId: activity.properties?.leadContactId || journey.lead?.ConvertedContactId || journey.opportunity?.ContactId,
+            contactId: activity.properties?.contactId || journey.contactId || journey.opportunity?.ContactId || journey.lead?.ConvertedContactId,
+            whoId: journey.whoId
+        }
+    }, seekaProfileId as string, {
+        origin: TrackingEventSourceOriginType.Server,
+        // loc: sourceUrl || undefined
+    })
+}
+
+const handleLeadStageTransition = async (journey: NavitasJourneyState, seekaProfileId: string, helper: SeekaAppHelper, logger: Logger): Promise<void> => {
+    const previousStage = journey.leadPreviousStage;
+    const currentStage = journey.leadCurrentStage;
+    const contentItem = salesforceLeadToContentItem(journey.lead);
+
+    // 3L: When lead status changes from "New" to Nurturing or = Nurturing, track as ‘Nurture’ event
+    if (previousStage.friendlyName === SalesforceLeadStages.New.friendlyName && currentStage.friendlyName === SalesforceLeadStages.Nurturing.friendlyName) {
+        await trackActivityForStageTransition({
+            activityName: TrackingActivityNames.Custom,
+            activityNameCustom: 'MQL',
+            contentItem,
+            activityId: `sfjourney-${journey.journeyId}-${currentStage.friendlyName}-mql`,
+        }, journey, seekaProfileId, 'lead', helper, logger);
+        return;
+    }
+
+    // 1L: When lead status = New or changes to Reopened, Attempted or Contacted, track as ‘SQL’ event
+    if (currentStage.friendlyName === SalesforceLeadStages.Reopened.friendlyName ||
+        currentStage.friendlyName === SalesforceLeadStages.Attempted.friendlyName ||
+        currentStage.friendlyName === SalesforceLeadStages.Contacted.friendlyName) {
+        await trackActivityForStageTransition({
+            activityName: TrackingActivityNames.Custom,
+            activityNameCustom: 'Engaged',
+            contentItem,
+            activityId: `sfjourney-${journey.journeyId}-${currentStage.friendlyName}-engaged`,
+        }, journey, seekaProfileId, 'lead', helper, logger);
+        return;
+    }
+
+    // 4L: When lead status = Lost, track as ‘Lost_Lead’
+    if (currentStage.friendlyName === SalesforceLeadStages.Lost.friendlyName) {
+        await trackActivityForStageTransition({
+            activityName: TrackingActivityNames.Custom,
+            activityNameCustom: 'Lost',
+            contentItem,
+            activityId: `sfjourney-${journey.journeyId}-${currentStage.friendlyName}-lost`,
+        }, journey, seekaProfileId, 'lead', helper, logger);
+        return;
+    }
+
+    // 5L: When lead status = Invalid Contact Info, track as 'Invalid'
+    if (currentStage.friendlyName === SalesforceLeadStages.InvalidContactInfo.friendlyName) {
+        await trackActivityForStageTransition({
+            activityName: TrackingActivityNames.Custom,
+            activityNameCustom: 'Invalid',
+            contentItem,
+            activityId: `sfjourney-${journey.journeyId}-${currentStage.friendlyName}-invalid`,
+        }, journey, seekaProfileId, 'lead', helper, logger);
+        return;
+    }
+
+    // 2L: When a lead transitions from "New" to Nurturing or Lost
+    if (currentStage.friendlyName === SalesforceLeadStages.Qualified.friendlyName) {
+        await trackActivityForStageTransition({
+            activityName: TrackingActivityNames.Custom,
+            activityNameCustom: 'QualifiedLead',
+            contentItem,
+            activityId: `sfjourney-${journey.journeyId}-${currentStage.friendlyName}-qualifiedlead`,
+        }, journey, seekaProfileId, 'lead', helper, logger);
+        return;
+    }
+}
+
+const handleOpportunityStageTransition = async (journey: NavitasJourneyState, seekaProfileId: string, helper: SeekaAppHelper, logger: Logger): Promise<void> => {
+    const previousStage = journey.opportunityPreviousStage;
+    const currentStage = journey.opportunityCurrentStage;
+    const contentItem = salesforceOpporunityToContentItem(journey.opportunity);
+
+    // 1P: When application stage = New, track as ‘Application’ event
+    if (currentStage.friendlyName === SalesforceOpportunityStages.New.friendlyName) {
+        await trackActivityForStageTransition({
+            activityName: TrackingActivityNames.Custom,
+            activityNameCustom: 'SubmitApplication',
+            contentItem,
+            activityId: `sfjourney-${journey.journeyId}-${currentStage.friendlyName}-submitapplication`,
+        }, journey, seekaProfileId, 'opportunity', helper, logger);
+        return;
+    }
+
+    // 5P: When Application Stage = Application Cancelled, track as ‘Cancelled_Application’
+    if (currentStage.friendlyName === SalesforceOpportunityStages.ApplicationCancelled.friendlyName) {
+        await trackActivityForStageTransition({
+            activityName: TrackingActivityNames.Custom,
+            activityNameCustom: 'CancelledApplication',
+            contentItem,
+            activityId: `sfjourney-${journey.journeyId}-${currentStage.friendlyName}-cancelledapp`,
+        }, journey, seekaProfileId, 'opportunity', helper, logger);
+        return;
+    }
+
+    // 2P: When application stage changes from New to Qualified, track as’ Qualified_Application’ event
+    if (currentStage.friendlyName === SalesforceOpportunityStages.Qualified.friendlyName) {
+        await trackActivityForStageTransition({
+            activityName: TrackingActivityNames.Custom,
+            activityNameCustom: 'QualifiedApplication',
+            contentItem,
+            activityId: `sfjourney-${journey.journeyId}-${currentStage.friendlyName}-qualifiedapp`,
+        }, journey, seekaProfileId, 'opportunity', helper, logger);
+        return;
+    }
+
+    // 4P: When application stage changes to Offer made, track as ‘Offer_Made’ event
+    if (previousStage.friendlyName === SalesforceOpportunityStages.OfferMade.friendlyName) {
+        await trackActivityForStageTransition({
+            activityName: TrackingActivityNames.Custom,
+            activityNameCustom: 'ProposalAccepted',
+            contentItem,
+            activityId: `sfjourney-${journey.journeyId}-${currentStage.friendlyName}-proposalaccept`,
+        }, journey, seekaProfileId, 'opportunity', helper, logger);
+        return;
+    }
+
+    // 3P: When application stage changes to ‘Enrolled’ event
+    if (previousStage.friendlyName === SalesforceOpportunityStages.Enrolled.friendlyName) {
+        await trackActivityForStageTransition({
+            activityName: TrackingActivityNames.Custom,
+            activityNameCustom: 'UserAdopted',
+            contentItem,
+            activityId: `sfjourney-${journey.journeyId}-${currentStage.friendlyName}-useradopted`,
+        }, journey, seekaProfileId, 'opportunity', helper, logger);
+        return;
+    }
+}

package/dist/ai-context/internal/examples/v2/navitas/app/server/src/lib/salesforce/leads/index.ts

@@ -0,0 +1,177 @@
+import { ContentItemActivityTrackingEventMetadata, PersonIdentifiers, PlaceAddress, SeekaAppHelper, TrackingEventSourceOriginType } from "@seeka-labs/sdk-apps-server";
+import { Logger } from "winston";
+import * as packageJson from '../../../../package.json';
+import { createOrUpdateJourney, getJourneyIdFromLead, handleContactMerge, tryGetJourney } from "../../state/navitas/journey";
+import { SeekaAppInstallState } from "../../state/seeka/installations";
+import { handleJourneyStageTransition } from "../journeys";
+import { SalesforceLeadWebhookPayloadObject, getWhoId, lookupLeadStage } from "../models";
+
+export const handleSalesforceLeadWebhook = async (leadPayload: SalesforceLeadWebhookPayloadObject, installation: SeekaAppInstallState, logger: Logger): Promise<void> => {
+    if (!leadPayload) {
+        logger.error('No lead object found in Salesforce webhook payload');
+        return;
+    }
+
+    let thisLogger = logger.child({ leadId: leadPayload.Id });
+    thisLogger.info('Handling Salesforce Lead webhook', { leadPayload });
+
+    const leadId = leadPayload.Id;
+    if (!leadId) {
+        thisLogger.error('No lead id found in Salesforce webhook payload');
+        return;
+    }
+
+    // Create seeka API helper
+    const { name, version } = packageJson;
+    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);
+
+    let seekaProfileId = leadPayload.SeekaProfileId__c || null;
+    let whoId = getWhoId(leadPayload.ConvertedContactId, leadPayload.Id, thisLogger);
+    thisLogger = thisLogger.child({ whoId });
+    const seekaProfile = salesforceLeadToSeekaProfile(leadPayload, whoId);
+    if (!seekaProfileId) {
+        thisLogger.warn('No Seeka profile ID found in Salesforce lead, creating Seeka profile', { leadId, leadPayload });
+        seekaProfileId = await helper.api.mergeIdentity(seekaProfile, {
+            origin: TrackingEventSourceOriginType.Server
+        })
+        thisLogger = thisLogger.child({ Person_PersonId: seekaProfileId });
+        thisLogger.info('Created Seeka profile for Salesforce lead', { leadId, seekaProfileId });
+    }
+    else {
+        thisLogger = thisLogger.child({ Person_PersonId: seekaProfileId });
+
+        seekaProfile.seekaPId = seekaProfileId;
+        await helper.api.mergeIdentity(seekaProfile, {
+            origin: TrackingEventSourceOriginType.Server
+        })
+
+        thisLogger.info('Used existing Seeka profile ID for Salesforce lead and updated Seeka profile', { leadId, seekaProfileId });
+    }
+
+    const leadPayloadStage = lookupLeadStage(leadPayload.Status);
+    const journeyId = getJourneyIdFromLead(leadPayload, thisLogger);
+    thisLogger = thisLogger.child({ journeyId });
+    let journey = await tryGetJourney(journeyId, false, thisLogger);
+    let created = false;
+    if (!whoId && journey && journey.whoId) {
+        thisLogger.warn('No whoID found on webhook payload but exists on journey')
+        whoId = journey.whoId;
+        thisLogger = thisLogger.child({ whoId });
+    }
+    if (!journey) {
+        // Create journey in state
+        journey = await createOrUpdateJourney({
+            journeyId,
+            leadId,
+            lead: leadPayload,
+            whoId,
+            contactId: leadPayload.ConvertedContactId,
+            opportunityId: undefined,
+            leadPreviousStage: undefined,
+            leadCurrentStage: leadPayloadStage,
+            opportunityPreviousStage: undefined,
+            opportunityCurrentStage: undefined,
+            seekaPersonId: [seekaProfileId]
+        }, true, false, thisLogger);
+        created = true;
+    }
+    const previousStage = { ...journey.leadCurrentStage };
+    if (!created) {
+        // Update lead
+        if (journey.whoId && whoId && journey.whoId !== whoId) {
+            thisLogger.warn('Updating WhoId on journey', { prev: journey.whoId, updated: whoId })
+        }
+
+        const oldContactId = journey.contactId;
+        journey = await createOrUpdateJourney({
+            ...journey,
+            whoId: whoId || journey.whoId,
+            lead: leadPayload,
+            contactId: leadPayload.ConvertedContactId || journey.contactId,
+            leadPreviousStage: previousStage,
+            leadCurrentStage: leadPayloadStage,
+            seekaPersonId: [...(journey.seekaPersonId || []), seekaProfileId].filter(Boolean)
+        }, true, false, thisLogger);
+
+        await handleContactMerge(oldContactId, leadPayload.ConvertedContactId, whoId || journey.whoId, 'lead', leadPayload.Id, installation, thisLogger)
+    }
+    thisLogger = thisLogger.child({ 'Person_PersonId': seekaProfileId, 'Person_BrowserId': journey.seekaPersonId, leadId: journey.leadId, opportunityId: journey.opportunityId });
+
+    if (previousStage.friendlyName !== leadPayloadStage.friendlyName) {
+        thisLogger.info('Lead stage transitioned', { leadId, previousStage: previousStage, currentStage: leadPayloadStage });
+        await handleJourneyStageTransition(journey, 'lead', seekaProfileId, helper, thisLogger);
+    }
+    else {
+        thisLogger.debug('Lead stage did not transition', { leadId, currentStage: leadPayloadStage });
+    }
+}
+
+export const salesforceLeadToContentItem = (lead: SalesforceLeadWebhookPayloadObject): ContentItemActivityTrackingEventMetadata | undefined => {
+    const contentItem: ContentItemActivityTrackingEventMetadata = {};
+    let populated = false;
+
+    if (lead.Program_Full_Name__c) {
+        contentItem.contentName = lead.Program_Full_Name__c;
+        populated = true;
+    }
+    if (lead.SAEProgram__c) {
+        contentItem.identifiers = [lead.SAEProgram__c];
+        populated = true;
+    }
+    if (lead.SO_Main_Discipline__c) {
+        contentItem.categoryName = lead.SO_Main_Discipline__c;
+        populated = true;
+    }
+
+    if (populated) {
+        return contentItem;
+    }
+
+    return undefined;
+}
+
+const salesforceLeadToSeekaProfile = (lead: SalesforceLeadWebhookPayloadObject, whoId: string | null): PersonIdentifiers => {
+    const seekaProfile: PersonIdentifiers = {
+        firstName: lead.FirstName ? [lead.FirstName] : [],
+        lastName: lead.LastName ? [lead.LastName] : [],
+        email: lead.Email ? [lead.Email] : [],
+        phone: [],
+        // facebook: {
+        //     lead: leadPayload.leadSource?.toLowerCase() === 'facebook' && leadPayload.lead_Number__c ? [leadPayload.lead_Number__c] : []
+        // }
+    };
+    if (lead.Phone) {
+        seekaProfile.phone.push(lead.Phone);
+    }
+    if (lead.MobilePhone && lead.MobilePhone !== lead.Phone) {
+        seekaProfile.phone.push(lead.MobilePhone);
+    }
+    const address: PlaceAddress = {};
+    let hasAddress = false;
+    if (lead.Country) {
+        address.country = lead.Country;
+        hasAddress = true;
+    }
+    if (lead.State) {
+        address.stateCode = lead.State;
+        hasAddress = true;
+    }
+    if (lead.PostalCode) {
+        address.postcode = lead.PostalCode;
+        hasAddress = true;
+    }
+    if (hasAddress) {
+        seekaProfile.address = [address];
+    }
+
+    // External ID
+    if (whoId) {
+        seekaProfile.eid = [whoId];
+    }
+
+    return seekaProfile;
+}

package/dist/ai-context/internal/examples/v2/navitas/app/server/src/lib/salesforce/models/index.ts

@@ -0,0 +1,179 @@
+import { Logger } from "winston"
+import { BackgroundJobRequestContext } from "../../jobs"
+
+export const SalesforceLeadStages = {
+    New: { friendlyName: 'new', salesforceStage: 'New' },
+    Nurturing: { friendlyName: 'nurturing', salesforceStage: 'Nurturing' },
+    Attempted: { friendlyName: 'attempted', salesforceStage: 'Attempted' },
+    Qualified: { friendlyName: 'qualified', salesforceStage: 'Qualified' },
+    Contacted: { friendlyName: 'contacted', salesforceStage: 'Contacted' },
+    OfferPending: { friendlyName: 'offerPending', salesforceStage: 'Offer Pending' },
+    InvalidContactInfo: { friendlyName: 'invalidContactInfo', salesforceStage: 'Invalid Contact Info' },
+    Lost: { friendlyName: 'lost', salesforceStage: 'Lost' },
+    Reopened: { friendlyName: 'reopened', salesforceStage: 'Reopened' },
+    Converted: { friendlyName: 'converted', salesforceStage: 'Converted' }
+}
+
+export const SalesforceOpportunityStages = {
+    New: { friendlyName: 'new', salesforceStage: 'New' },
+    Qualified: { friendlyName: 'qualified', salesforceStage: 'Qualified' },
+    OfferPending: { friendlyName: 'offerPending', salesforceStage: 'Offer Pending' },
+    OfferMade: { friendlyName: 'offerMade', salesforceStage: 'Offer Made' },
+    Enrolled: { friendlyName: 'enrolled', salesforceStage: 'Enrolled' },
+    ApplicationCancelled: { friendlyName: 'applicationCancelled', salesforceStage: 'Application Cancelled' },
+}
+
+export interface SalesforceLeadStageLookup {
+    salesforceStage: string
+    friendlyName: string
+}
+
+export interface SalesforceJourneyStageLookup {
+    salesforceStage: string
+    friendlyName: string
+}
+export interface SalesforceOpportunityStageLookup {
+    salesforceStage: string
+    friendlyName: string
+}
+
+export const lookupLeadStage = (stage: string): SalesforceLeadStageLookup => {
+    const stageLowercase = stage.toLowerCase();
+    for (const key in SalesforceLeadStages) {
+        if (SalesforceLeadStages[key].salesforceStage.toLowerCase() === stageLowercase) {
+            return SalesforceLeadStages[key];
+        }
+    }
+    throw new Error(`Unknown lead stage: ${stage}`);
+}
+
+export const lookupOpportunityStage = (stage: string): SalesforceOpportunityStageLookup => {
+    const stageLowercase = stage.toLowerCase();
+    for (const key in SalesforceOpportunityStages) {
+        if (SalesforceOpportunityStages[key].salesforceStage.toLowerCase() === stageLowercase) {
+            return SalesforceOpportunityStages[key];
+        }
+    }
+    throw new Error(`Unknown opportunity stage: ${stage}`);
+}
+
+export interface SalesforceWebhookPayloadQueueItem<TPayloadObject> extends BackgroundJobRequestContext<SalesforceWebhookPayload<TPayloadObject>> {
+
+}
+
+export interface SalesforceWebhookPayload<TObject> {
+    Body: SalesforceWebhookPayloadBody<TObject>
+    "xmlns:soapenv": string
+    "xmlns:xsd": string
+    "xmlns:xsi": string
+}
+
+export interface SalesforceWebhookPayloadBody<TObject> {
+    notifications: SalesforceWebhookPayloadNotifications<TObject>
+}
+
+export interface SalesforceWebhookPayloadNotifications<TObject> {
+    ActionId: string
+    EnterpriseUrl: string
+    Notification: SalesforceWebhookPayloadNotification<TObject> | SalesforceWebhookPayloadNotification<TObject>[]
+    OrganizationId: string
+    PartnerUrl: string
+    SessionId: SalesforceWebhookPayloadSessionId
+    xmlns: string
+}
+
+export interface SalesforceWebhookPayloadNotification<TObject> {
+    Id: string
+    sObject: TObject
+}
+
+export interface SalesforceEnrolmentFormWebhookPayloadObject extends SalesforceWebhookPayloadObject {
+    Citizenship__c: string, // 'Yes, Australian/New Zealand Citizen or PR',  
+    Contact_ID__c: string, // '003Po00000qlMbtIAE',  
+    Discipline__c: string, // 'Games',  
+    Form_Email__c: string, // 'bootnoah007@gmail.com',  
+    Form_First_Name__c: string, // 'Noah',  
+    Form_Last_Name__c: string, // 'Boutros',  
+    Form_Type__c: string, // 'Application',  
+    Id: string, // 'a2lPo000005KXeTIAW',  
+    IP_Address__c: string, // '120.150.134.192',  
+    LastModifiedDate: string, // '2025-05-22T03:36:45.000Z',  
+    Lead_Contact_Id__c: string, // '003Po00000qlMbtIAE',  
+    Lead_ID__c: string, // '00QPo00000fUiNNMA0',  
+    Program_Name__c: string, // 'BACHELOR OF GAMES DEVELOPMENT',  
+    Residential_Address_Counrt__c: string, // 'Australia',  
+    Residential_Address_Post_Code__c: string, // '2448',  
+    Residential_Address_State_AUS__c: string, // 'NSW',  
+    SeekaProfileId__c: string, // 'sk.1.1747110366482.3947866376',
+}
+
+
+export interface SalesforceOpportunityWebhookPayloadObject extends SalesforceWebhookPayloadObject {
+    // Full name of person and program - eg John Smith - ACAP Melbourne - SEP 2024
+    Name?: string
+
+    // id of the opportunity created after lead is converted
+    ConvertedOpportunityId?: string
+
+    // Id of the associated contact record
+    ContactId?: string
+
+    AccountEmail__c?: string
+
+    Program_Discipline__c?: string
+    Program_Full_Name__c?: string
+    Prospect_Type__c?: string
+    SAEProgram__c?: string
+
+    SO_Account_Mobile__c?: string
+    SO_Account_Phone__c?: string
+    Account_Seeka_Profile_Id__c?: string
+
+    StageName?: string
+
+    Id: string
+}
+
+export interface SalesforceLeadWebhookPayloadObject extends SalesforceWebhookPayloadObject {
+    Country?: string
+    Email?: string
+    FirstName?: string
+    LastName?: string
+
+    // id of the opportunity created after lead is converted
+    ConvertedOpportunityId?: string
+
+    // id of the contact created after lead is converted
+    ConvertedContactId?: string
+
+    Id: string
+    MobilePhone?: string
+    Phone?: string
+    PostalCode?: string
+    Program_Full_Name__c?: string
+    Prospect_Type__c?: string
+    SAEProgram__c?: string
+    SO_Main_Discipline__c?: string
+    SeekaProfileId__c?: string
+    State?: string
+    Status: string
+}
+
+export interface SalesforceWebhookPayloadObject {
+    Id: string
+    type: 'sf:Lead' | 'sf:Opportunity' | string
+    SystemModstamp: string
+    "xmlns:sf": string
+}
+export interface SalesforceWebhookPayloadSessionId {
+    nil: boolean
+}
+
+export const getWhoId = (contactId: string | undefined | null, leadId: string | undefined | null, logger: Logger): string | null => {
+    if (!contactId && !leadId) {
+        logger.warn("Failed to get WhoID");
+        return null;
+    }
+
+    return contactId || leadId;
+}