@memberjunction/actions-apollo 2.111.0 → 2.112.0

package/dist/accounts.d.ts

@@ -1,8 +1,8 @@
-import { BaseAction } from "@memberjunction/actions";
-import { Metadata, UserInfo } from "@memberjunction/core";
-import { AxiosResponse } from "axios";
-import { ProcessSingleDomainParams, TechnologyMap } from "./generic/apollo.types";
-import { ActionResultSimple, RunActionParams } from "@memberjunction/actions-base";
+import { BaseAction } from '@memberjunction/actions';
+import { Metadata, UserInfo } from '@memberjunction/global';
+import { AxiosResponse } from 'axios';
+import { ProcessSingleDomainParams, TechnologyMap } from './generic/apollo.types';
+import { ActionResultSimple, RunActionParams } from '@memberjunction/actions-base';
 /**
  * Action that enriches account records using Apollo.io's organization and people data
  *

package/dist/accounts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../src/accounts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAGrD,OAAO,EAAmC,QAAQ,EAAW,QAAQ,EAAgB,MAAM,sBAAsB,CAAC;AAClH,OAAc,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAC7C,OAAO,EAAoJ,yBAAyB,EAAoF,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACtT,OAAO,EAAe,kBAAkB,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAchG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qBACa,8BAA+B,SAAQ,UAAU;IAC1D;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAkE;IAEhG;;;;;;;;;;;OAWG;cACa,iBAAiB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA4BvF;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAc7B;;;;;OAKG;IACH,OAAO,CAAC,4BAA4B;IAoDpC;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAKxB;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAc9B;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAetB;;;;;;;;OAQG;YACW,wBAAwB;IAoDtC;;;;;;;;OAQG;YACW,oBAAoB;IA6BlC;;;;;;;;;;OAUG;cACa,mBAAmB,CAAC,MAAM,EAAE,yBAAyB,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IAWlK;;;;;;;;;;OAUG;YACW,kBAAkB;IA2ChC;;;;;;;;;;OAUG;YACW,iCAAiC;IAoC/C;;;;;;;;;OASG;YACW,8BAA8B;IAsB5C;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;IAMxB;;;;;;;;;;;OAWG;cACa,8BAA8B,CAAC,MAAM,EAAE,yBAAyB,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IAiEnM;;;;;;;;;OASG;YACW,+BAA+B;IAwC7C;;;;;;;;;OASG;YACW,uBAAuB;IAoCrC;;;;;;;;;;;;OAYG;YACW,qBAAqB;IAkEnC;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;IAgBxB;;;;;;;;;;;;OAYG;YACW,sBAAsB;IAmCpC;;;;;;;OAOG;IACH,OAAO,CAAC,mBAAmB;IAgB3B;;;;;;;;;;;OAWG;YACW,kBAAkB;IA6DhC;;;;;;;;;;OAUG;YACW,gDAAgD;IA+D9D;;;;;;OAMG;IACH,SAAS,CAAC,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAQlD;;;;;;OAMG;IACH,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAOjD;;;;;;OAMG;IACH,SAAS,CAAC,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAOjD;;;;;;;;;;;OAWG;cACa,cAAc,CAAC,MAAM,EAAE,KAAK,GAAG,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,GAAE,MAAU,GAAG,OAAO,CAAC,aAAa,CAAC;IAoCnJ;;;;;;OAMG;YACW,OAAO;CAGxB;AAED;;;GAGG;AACH,wBAAgB,kCAAkC,SAEjD"}
+{"version":3,"file":"accounts.d.ts","sourceRoot":"","sources":["../src/accounts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAGrD,OAAO,EAAmC,QAAQ,EAAW,QAAQ,EAAgB,MAAM,wBAAwB,CAAC;AACpH,OAAc,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAC7C,OAAO,EAML,yBAAyB,EAIzB,aAAa,EACd,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAe,kBAAkB,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAchG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qBACa,8BAA+B,SAAQ,UAAU;IAC5D;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAkE;IAEhG;;;;;;;;;;;OAWG;cACa,iBAAiB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA4BvF;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAc7B;;;;;OAKG;IACH,OAAO,CAAC,4BAA4B;IA6DpC;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAKxB;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAc9B;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAetB;;;;;;;;OAQG;YACW,wBAAwB;IAuDtC;;;;;;;;OAQG;YACW,oBAAoB;IA6BlC;;;;;;;;;;OAUG;cACa,mBAAmB,CACjC,MAAM,EAAE,yBAAyB,EACjC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,QAAQ,GACpB,OAAO,CAAC,OAAO,CAAC;IAWnB;;;;;;;;;;OAUG;YACW,kBAAkB;IAmDhC;;;;;;;;;;OAUG;YACW,iCAAiC;IAoC/C;;;;;;;;;OASG;YACW,8BAA8B;IAsB5C;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;IAMxB;;;;;;;;;;;OAWG;cACa,8BAA8B,CAC5C,MAAM,EAAE,yBAAyB,EACjC,SAAS,EAAE,MAAM,GAAG,MAAM,EAC1B,YAAY,EAAE,aAAa,EAAE,EAC7B,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,QAAQ,GACpB,OAAO,CAAC,OAAO,CAAC;IAqEnB;;;;;;;;;OASG;YACW,+BAA+B;IAgD7C;;;;;;;;;OASG;YACW,uBAAuB;IAuCrC;;;;;;;;;;;;OAYG;YACW,qBAAqB;IAyEnC;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;IAgBxB;;;;;;;;;;;;OAYG;YACW,sBAAsB;IA6CpC;;;;;;;OAOG;IACH,OAAO,CAAC,mBAAmB;IAgB3B;;;;;;;;;;;OAWG;YACW,kBAAkB;IA2EhC;;;;;;;;;;OAUG;YACW,gDAAgD;IA4E9D;;;;;;OAMG;IACH,SAAS,CAAC,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAQlD;;;;;;OAMG;IACH,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAOjD;;;;;;OAMG;IACH,SAAS,CAAC,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAOjD;;;;;;;;;;;OAWG;cACa,cAAc,CAC5B,MAAM,EAAE,KAAK,GAAG,MAAM,EACtB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,GAAG,EACX,aAAa,GAAE,MAAU,GACxB,OAAO,CAAC,aAAa,CAAC;IAgCzB;;;;;;OAMG;YACW,OAAO;CAGtB;AAED;;;GAGG;AACH,wBAAgB,kCAAkC,SAEjD"}

package/dist/accounts.js

@@ -36,7 +36,7 @@ exports.LoadApolloAccountsEnrichmentAction = exports.ApolloEnrichmentAccountsAct
 const actions_1 = require("@memberjunction/actions");
 const global_1 = require("@memberjunction/global");
 const Config = __importStar(require("./config"));
-const core_1 = require("@memberjunction/core");
+const global_2 = require("@memberjunction/global");
 const axios_1 = __importDefault(require("axios"));
 /**
  * Action that enriches account records using Apollo.io's organization and people data
@@ -118,11 +118,11 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
             return await this.processAllAccountRecords(actionParams, params.ContextUser, 1);
         }
         catch (error) {
-            (0, core_1.LogError)('Unexpected error in ApolloAccountsEnrichmentAction', undefined, error);
+            (0, global_2.LogError)('Unexpected error in ApolloAccountsEnrichmentAction', undefined, error);
             return {
                 Success: false,
                 Message: `Unexpected error: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                ResultCode: "FAILED"
+                ResultCode: 'FAILED',
             };
         }
     }
@@ -137,8 +137,8 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
                 error: {
                     Success: false,
                     Message: 'Apollo.io API key not found in configuration',
-                    ResultCode: "CONFIGURATION_ERROR"
-                }
+                    ResultCode: 'CONFIGURATION_ERROR',
+                },
             };
         }
         return { success: true };
@@ -157,8 +157,8 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
                 error: {
                     Success: false,
                     Message: 'Missing required parameter: AccountEntityFieldMappings',
-                    ResultCode: "VALIDATION_ERROR"
-                }
+                    ResultCode: 'VALIDATION_ERROR',
+                },
             };
         }
         let accountEntityFields;
@@ -174,8 +174,8 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
                 error: {
                     Success: false,
                     Message: 'Invalid AccountEntityFieldMappings parameter: must be valid JSON or object',
-                    ResultCode: "VALIDATION_ERROR"
-                }
+                    ResultCode: 'VALIDATION_ERROR',
+                },
             };
         }
         // Extract optional parameters
@@ -190,8 +190,8 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
                 accountTechnologyEntityFields,
                 technologyCategoryEntityFields,
                 contactEntityFields,
-                contactEducationHistoryEntityFields
-            }
+                contactEducationHistoryEntityFields,
+            },
         };
     }
     /**
@@ -201,7 +201,7 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
      * @returns The parameter if found, null otherwise
      */
     getRequiredParam(params, paramName) {
-        const param = params.Params.find(p => p.Name === paramName);
+        const param = params.Params.find((p) => p.Name === paramName);
         return param || null;
     }
     /**
@@ -211,7 +211,7 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
      * @returns Parsed object of type T or null if not provided/invalid
      */
     parseOptionalJSONParam(params, paramName) {
-        const param = params.Params.find(p => p.Name === paramName);
+        const param = params.Params.find((p) => p.Name === paramName);
         if (!param || !param.Value) {
             return null;
         }
@@ -219,7 +219,7 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
             return this.parseJSONParam(param.Value) || null;
         }
         catch (error) {
-            (0, core_1.LogError)(`Error parsing ${paramName}`, undefined, error);
+            (0, global_2.LogError)(`Error parsing ${paramName}`, undefined, error);
             return null;
         }
     }
@@ -253,8 +253,8 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
      * @returns Promise indicating overall success/failure of the batch
      */
     async processAllAccountRecords(actionParams, contextUser, executionCount = 1) {
-        const md = new core_1.Metadata();
-        const rv = new core_1.RunView();
+        const md = new global_2.Metadata();
+        const rv = new global_2.RunView();
         // Initial query to get accounts to process
         const runViewResult = await rv.RunView({
             EntityName: actionParams.accountEntityFields.EntityName,
@@ -264,32 +264,32 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
             return {
                 Success: false,
                 Message: runViewResult.ErrorMessage,
-                ResultCode: "FAILED"
+                ResultCode: 'FAILED',
             };
         }
         const results = runViewResult.Results;
         const resultLength = results.length;
         if (resultLength === 0) {
-            (0, core_1.LogStatus)('+++ Completed domain enrichment, no records left to process.');
+            (0, global_2.LogStatus)('+++ Completed domain enrichment, no records left to process.');
             return {
                 Success: true,
-                Message: "ApolloAccountsEnrichment executed successfully.",
-                ResultCode: "SUCCESS"
+                Message: 'ApolloAccountsEnrichment executed successfully.',
+                ResultCode: 'SUCCESS',
             };
         }
         // Check execution limit to prevent infinite recursion
         if (executionCount >= 5) {
-            (0, core_1.LogStatus)(`+++ Reached maximum execution limit (${executionCount}), stopping to prevent infinite recursion.`);
+            (0, global_2.LogStatus)(`+++ Reached maximum execution limit (${executionCount}), stopping to prevent infinite recursion.`);
             return {
                 Success: true,
                 Message: `ApolloAccountsEnrichment stopped after ${executionCount} executions to prevent infinite recursion. ${resultLength} records may remain unprocessed.`,
-                ResultCode: "SUCCESS"
+                ResultCode: 'SUCCESS',
             };
         }
         // Process accounts in concurrent groups
         await this.processAccountGroups(results, actionParams, md, contextUser);
         // Check if there are more records to process by running the query again
-        (0, core_1.LogStatus)(`--- Checking for remaining records... (execution ${executionCount + 1}/5)`);
+        (0, global_2.LogStatus)(`--- Checking for remaining records... (execution ${executionCount + 1}/5)`);
         return await this.processAllAccountRecords(actionParams, contextUser, executionCount + 1);
     }
     /**
@@ -311,7 +311,7 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
                 AccountTechnologyEntity: actionParams.accountTechnologyEntityFields || null,
                 TechnologyCategoryEntity: actionParams.technologyCategoryEntityFields || null,
                 ContactEntity: actionParams.contactEntityFields || null,
-                ContactEducationHistoryEntity: actionParams.contactEducationHistoryEntityFields || null
+                ContactEducationHistoryEntity: actionParams.contactEducationHistoryEntityFields || null,
             };
             const task = this.ProcessSingleDomain(processParams, index, resultLength, md, contextUser);
             tasks.push(task);
@@ -356,11 +356,11 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
             const record = params.Record;
             const orgQueryString = {
                 api_key: Config.ApolloAPIKey,
-                domain: record[params.AccountEntity.DomainField]
+                domain: record[params.AccountEntity.DomainField],
             };
             const headers = {
                 'Cache-Control': 'no-cache',
-                'Content-Type': 'application/json'
+                'Content-Type': 'application/json',
             };
             // Get the organization enrichment data
             const orgResponse = await this.WrapApolloCall('get', 'organizations/enrich', null, { params: orgQueryString, headers: headers });
@@ -373,18 +373,20 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
                 bSuccess = await this.updateAccountWithOrganizationData(result.organization, params, record, md, currentUser);
                 if (params.AccountTechnologyEntity && bSuccess) {
                     const accountID = record[params.AccountEntity.AccountIDField];
-                    bSuccess = bSuccess && await this.CreateAccountTechnologyRecords(params, accountID, result.organization.current_technologies, md, currentUser);
+                    bSuccess =
+                        bSuccess &&
+                            (await this.CreateAccountTechnologyRecords(params, accountID, result.organization.current_technologies, md, currentUser));
                 }
             }
             else {
                 // No match found, but still update enriched timestamp
-                (0, core_1.LogStatus)(`  > No matches found for this domain: ${params.Record[params.AccountEntity.DomainField]}`);
+                (0, global_2.LogStatus)(`  > No matches found for this domain: ${params.Record[params.AccountEntity.DomainField]}`);
                 bSuccess = await this.updateAccountEnrichedTimestamp(params, record, md, currentUser);
             }
             return bSuccess;
         }
         catch (error) {
-            (0, core_1.LogError)('Error enriching organization', undefined, error);
+            (0, global_2.LogError)('Error enriching organization', undefined, error);
             return false;
         }
     }
@@ -401,7 +403,7 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
      */
     async updateAccountWithOrganizationData(organization, params, record, md, currentUser) {
         try {
-            const accountEntity = await md.GetEntityObject(params.AccountEntity.EntityName, core_1.CompositeKey.FromID(record.ID), currentUser);
+            const accountEntity = await md.GetEntityObject(params.AccountEntity.EntityName, global_2.CompositeKey.FromID(record.ID), currentUser);
             // Set organization data fields
             this.setFieldIfExists(accountEntity, params.AccountEntity.AddressField, organization.street_address);
             this.setFieldIfExists(accountEntity, params.AccountEntity.CityField, organization.city);
@@ -417,12 +419,12 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
             this.setFieldIfExists(accountEntity, params.AccountEntity.EnrichedAtField, new Date());
             const saveResult = await accountEntity.Save();
             if (!saveResult) {
-                (0, core_1.LogError)('Error updating account record with enriched data', undefined, accountEntity.LatestResult);
+                (0, global_2.LogError)('Error updating account record with enriched data', undefined, accountEntity.LatestResult);
             }
             return saveResult;
         }
         catch (error) {
-            (0, core_1.LogError)('Error updating account with organization data', undefined, error);
+            (0, global_2.LogError)('Error updating account with organization data', undefined, error);
             return false;
         }
     }
@@ -438,16 +440,16 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
      */
     async updateAccountEnrichedTimestamp(params, record, md, currentUser) {
         try {
-            const accountEntity = await md.GetEntityObject('Accounts', core_1.CompositeKey.FromID(record.ID), currentUser);
+            const accountEntity = await md.GetEntityObject('Accounts', global_2.CompositeKey.FromID(record.ID), currentUser);
             accountEntity.Set(params.AccountEntity.EnrichedAtField, new Date());
             const saveResult = await accountEntity.Save();
             if (!saveResult) {
-                (0, core_1.LogError)('Error updating account record with enriched timestamp', undefined, accountEntity.LatestResult);
+                (0, global_2.LogError)('Error updating account record with enriched timestamp', undefined, accountEntity.LatestResult);
             }
             return saveResult;
         }
         catch (error) {
-            (0, core_1.LogError)('Error updating account enriched timestamp', undefined, error);
+            (0, global_2.LogError)('Error updating account enriched timestamp', undefined, error);
             return false;
         }
     }
@@ -484,13 +486,13 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
             let bSuccess = true;
             const ATEntity = params.AccountTechnologyEntity;
             if (ATEntity.TechnologyIDField && ATEntity.TechnologyField && ATEntity.CategoryField) {
-                const rv = new core_1.RunView();
+                const rv = new global_2.RunView();
                 const runViewResult = await rv.RunView({
                     EntityName: ATEntity.EntityName,
-                    ExtraFilter: `${ATEntity.AccountIDField} = ${accountID}`
+                    ExtraFilter: `${ATEntity.AccountIDField} = ${accountID}`,
                 }, currentUser);
                 if (!runViewResult.Success) {
-                    (0, core_1.LogError)('Error querying for existing Account Technologies', undefined, runViewResult.ErrorMessage);
+                    (0, global_2.LogError)('Error querying for existing Account Technologies', undefined, runViewResult.ErrorMessage);
                     return false;
                 }
                 // Process each technology
@@ -504,7 +506,7 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
                         at.NewRecord();
                         at.Set(ATEntity.AccountIDField, accountID);
                         at.Set(ATEntity.TechnologyIDField, await this.getOrCreateTechnologyId(technology.name, categoryId, md, currentUser));
-                        bSuccess = bSuccess && await at.Save();
+                        bSuccess = bSuccess && (await at.Save());
                     }
                     else {
                         existingRow.matchFound = true;
@@ -513,11 +515,11 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
                 // Mark unmatched technologies as ended
                 for (const record of runViewResult.Results) {
                     if (!record.matchFound) {
-                        const entity = await md.GetEntityObject(ATEntity.EntityName, core_1.CompositeKey.FromID(record.ID), currentUser);
+                        const entity = await md.GetEntityObject(ATEntity.EntityName, global_2.CompositeKey.FromID(record.ID), currentUser);
                         entity.Set(ATEntity.EndedUseAtField, new Date());
                         const saveResult = await entity.Save();
                         if (!saveResult) {
-                            (0, core_1.LogError)('Error updating Account Technology record', undefined, entity.LatestResult);
+                            (0, global_2.LogError)('Error updating Account Technology record', undefined, entity.LatestResult);
                         }
                         bSuccess = bSuccess && saveResult;
                     }
@@ -526,7 +528,7 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
             return bSuccess;
         }
         catch (error) {
-            (0, core_1.LogError)('Error creating account technology records', undefined, error);
+            (0, global_2.LogError)('Error creating account technology records', undefined, error);
             return false;
         }
     }
@@ -546,13 +548,13 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
             return 0;
         }
         try {
-            const rv = new core_1.RunView();
+            const rv = new global_2.RunView();
             const runViewResult = await rv.RunView({
                 EntityName: TCEntity.EntityName,
-                ExtraFilter: `${TCEntity.NameField} = '${this.EscapeSingleQuotes(categoryName)}'`
+                ExtraFilter: `${TCEntity.NameField} = '${this.EscapeSingleQuotes(categoryName)}'`,
             }, currentUser);
             if (!runViewResult.Success) {
-                (0, core_1.LogError)('Error querying for existing Technology Categories', undefined, runViewResult.ErrorMessage);
+                (0, global_2.LogError)('Error querying for existing Technology Categories', undefined, runViewResult.ErrorMessage);
                 return 0;
             }
             if (runViewResult.Results.length > 0) {
@@ -564,13 +566,13 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
             entity.Set(TCEntity.NameField, categoryName);
             const saveResult = await entity.Save();
             if (!saveResult) {
-                (0, core_1.LogError)('Error creating new Technology Category record', undefined, entity.LatestResult);
+                (0, global_2.LogError)('Error creating new Technology Category record', undefined, entity.LatestResult);
                 return 0;
             }
             return entity.Get(TCEntity.IDField);
         }
         catch (error) {
-            (0, core_1.LogError)('Error getting or creating technology category', undefined, error);
+            (0, global_2.LogError)('Error getting or creating technology category', undefined, error);
             return 0;
         }
     }
@@ -586,13 +588,13 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
      */
     async getOrCreateTechnologyId(name, categoryId, md, currentUser) {
         try {
-            const rv = new core_1.RunView();
+            const rv = new global_2.RunView();
             const runViewResult = await rv.RunView({
                 EntityName: 'Technologies',
-                ExtraFilter: `Name = '${this.EscapeSingleQuotes(name)}' AND CategoryID = ${categoryId}`
+                ExtraFilter: `Name = '${this.EscapeSingleQuotes(name)}' AND CategoryID = ${categoryId}`,
             }, currentUser);
             if (!runViewResult.Success) {
-                (0, core_1.LogError)('Error querying for existing Technologies', undefined, runViewResult.ErrorMessage);
+                (0, global_2.LogError)('Error querying for existing Technologies', undefined, runViewResult.ErrorMessage);
                 return 0;
             }
             if (runViewResult.Results.length > 0) {
@@ -605,13 +607,13 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
             technologyEntity.Set('CategoryID', categoryId);
             const saveResult = await technologyEntity.Save();
             if (!saveResult) {
-                (0, core_1.LogError)('Error creating new Technology record', undefined, technologyEntity.LatestResult);
+                (0, global_2.LogError)('Error creating new Technology record', undefined, technologyEntity.LatestResult);
                 return 0;
             }
             return technologyEntity.Get('ID');
         }
         catch (error) {
-            (0, core_1.LogError)('Error getting or creating technology', undefined, error);
+            (0, global_2.LogError)('Error getting or creating technology', undefined, error);
             return 0;
         }
     }
@@ -637,21 +639,21 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
                 api_key: Config.ApolloAPIKey,
                 reveal_personal_emails: true,
                 q_organization_domains: domain,
-                page: 1
+                page: 1,
             };
             const headers = {
                 'Cache-Control': 'no-cache',
-                'Content-Type': 'application/json'
+                'Content-Type': 'application/json',
             };
             const response = await this.WrapApolloCall('post', 'mixed_people/search', APIparams, { headers: headers });
             if (!response || response.status !== 200) {
-                (0, core_1.LogError)(`Error fetching data from Apollo.io: ${response?.statusText}`);
+                (0, global_2.LogError)(`Error fetching data from Apollo.io: ${response?.statusText}`);
                 return false;
             }
             const data = response.data;
             const allPeople = data.people;
             // Fetch additional pages
-            for (let i = 1; i < data.pagination.total_pages && i < (Config.MaxPeopleToEnrichPerOrg / 10); i++) {
+            for (let i = 1; i < data.pagination.total_pages && i < Config.MaxPeopleToEnrichPerOrg / 10; i++) {
                 APIparams.page = i + 1;
                 const nextResponse = await this.WrapApolloCall('post', 'mixed_people/search', APIparams, { headers: headers });
                 if (nextResponse.status !== 200) {
@@ -662,7 +664,7 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
                 allPeople.push(...nextResult.people);
             }
             if (allPeople.length === 0) {
-                (0, core_1.LogStatus)(`No people found for this domain: ${domain}`);
+                (0, global_2.LogStatus)(`No people found for this domain: ${domain}`);
                 return true;
             }
             // Process all people
@@ -672,12 +674,12 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
                 if (this.shouldSkipPerson(person, domain)) {
                     continue;
                 }
-                bSuccess = bSuccess && await this.createAndEnrichContact(params, accountID, person, md, currentUser, i, allPeople.length);
+                bSuccess = bSuccess && (await this.createAndEnrichContact(params, accountID, person, md, currentUser, i, allPeople.length));
             }
             return bSuccess;
         }
         catch (error) {
-            (0, core_1.LogError)('Error creating and enriching people', undefined, error);
+            (0, global_2.LogError)('Error creating and enriching people', undefined, error);
             return false;
         }
     }
@@ -692,12 +694,12 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
     shouldSkipPerson(person, domain) {
         // Check for missing required data
         if (!person.last_name || !person.email || person.email.split('@')[1] !== domain) {
-            (0, core_1.LogStatus)(`Skipping person: ${person.first_name} ${person.last_name} because email is missing or does not match domain`);
+            (0, global_2.LogStatus)(`Skipping person: ${person.first_name} ${person.last_name} because email is missing or does not match domain`);
             return true;
         }
         // Check for excluded titles
         if (this.IsExcludedTitle(person.title)) {
-            (0, core_1.LogStatus)(`Skipping person: ${person.first_name} ${person.last_name} because title is excluded`);
+            (0, global_2.LogStatus)(`Skipping person: ${person.first_name} ${person.last_name} because title is excluded`);
             return true;
         }
         return false;
@@ -721,7 +723,7 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
             return false;
         }
         try {
-            (0, core_1.LogStatus)(`Enriching contact for person: ${person.first_name} ${person.last_name}, accountID: ${accountID} (${sequence} of ${total})`);
+            (0, global_2.LogStatus)(`Enriching contact for person: ${person.first_name} ${person.last_name}, accountID: ${accountID} (${sequence} of ${total})`);
             const contact = await this.getOrCreateContact(params, accountID, person, md, currentUser);
             if (!contact) {
                 return false;
@@ -730,17 +732,17 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
             this.updateContactFields(contact, person, CEntity);
             const saveResult = await contact.Save();
             if (!saveResult) {
-                (0, core_1.LogError)('Error updating contact record with enriched data', undefined, contact.LatestResult);
+                (0, global_2.LogError)('Error updating contact record with enriched data', undefined, contact.LatestResult);
                 return false;
             }
             // Update employment and education history if configured
             if (params.ContactEducationHistoryEntity) {
-                return await this.createUpdateContactEmploymentAndEducationHistory(params, contact.Get("ID"), person, md, currentUser);
+                return await this.createUpdateContactEmploymentAndEducationHistory(params, contact.Get('ID'), person, md, currentUser);
             }
             return true;
         }
         catch (error) {
-            (0, core_1.LogError)('Error creating and enriching contact', undefined, error);
+            (0, global_2.LogError)('Error creating and enriching contact', undefined, error);
             return false;
         }
     }
@@ -783,28 +785,28 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
             return null;
         }
         try {
-            const rv = new core_1.RunView();
+            const rv = new global_2.RunView();
             // Check if contact exists with different account
             const conflictResult = await rv.RunView({
                 EntityName: CEntity.EntityName,
-                ExtraFilter: `${CEntity.EmailField} = '${this.EscapeSingleQuotes(person.email)}' AND ${CEntity.AccountIDField} <> ${accountID}`
+                ExtraFilter: `${CEntity.EmailField} = '${this.EscapeSingleQuotes(person.email)}' AND ${CEntity.AccountIDField} <> ${accountID}`,
             }, currentUser);
             if (!conflictResult.Success) {
-                (0, core_1.LogError)('Error querying for existing Contacts', undefined, conflictResult.ErrorMessage);
+                (0, global_2.LogError)('Error querying for existing Contacts', undefined, conflictResult.ErrorMessage);
                 return null;
             }
             if (conflictResult.Results.length > 0) {
                 const existing = conflictResult.Results[0];
-                (0, core_1.LogError)(`*** SKIPPING new contact record for ${person.first_name} ${person.last_name} because they are already associated with AccountID: ${existing.AccountID} - ContactID: ${existing.ID}`);
+                (0, global_2.LogError)(`*** SKIPPING new contact record for ${person.first_name} ${person.last_name} because they are already associated with AccountID: ${existing.AccountID} - ContactID: ${existing.ID}`);
                 return null;
             }
             // Check if contact exists for this account
             const existingResult = await rv.RunView({
                 EntityName: CEntity.EntityName,
-                ExtraFilter: `(${CEntity.EmailField} = '${this.EscapeSingleQuotes(person.email)}' OR (${CEntity.FirstNameField} = '${this.EscapeSingleQuotes(person.first_name)}' AND ${CEntity.LastNameField} = '${this.EscapeSingleQuotes(person.last_name)}')) AND ${CEntity.AccountIDField} = ${accountID}`
+                ExtraFilter: `(${CEntity.EmailField} = '${this.EscapeSingleQuotes(person.email)}' OR (${CEntity.FirstNameField} = '${this.EscapeSingleQuotes(person.first_name)}' AND ${CEntity.LastNameField} = '${this.EscapeSingleQuotes(person.last_name)}')) AND ${CEntity.AccountIDField} = ${accountID}`,
             }, currentUser);
             if (!existingResult.Success) {
-                (0, core_1.LogError)('Error querying for existing Contacts', undefined, existingResult.ErrorMessage);
+                (0, global_2.LogError)('Error querying for existing Contacts', undefined, existingResult.ErrorMessage);
                 return null;
             }
             let contactEntity = null;
@@ -815,7 +817,7 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
             }
             else {
                 // Create new contact
-                (0, core_1.LogStatus)(`   > Creating new contact record for ${person.first_name} ${person.last_name}`);
+                (0, global_2.LogStatus)(`   > Creating new contact record for ${person.first_name} ${person.last_name}`);
                 contactEntity = await md.GetEntityObject(CEntity.EntityName, currentUser);
                 contactEntity.NewRecord();
                 contactEntity.Set(CEntity.EmailField, person.email);
@@ -826,7 +828,7 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
             return contactEntity;
         }
         catch (error) {
-            (0, core_1.LogError)('Error getting or creating contact', undefined, error);
+            (0, global_2.LogError)('Error getting or creating contact', undefined, error);
             return null;
         }
     }
@@ -848,21 +850,21 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
         }
         try {
             let bSuccess = true;
-            const rv = new core_1.RunView();
+            const rv = new global_2.RunView();
             for (const history of person.employment_history) {
                 if (history.degree && history.degree.length > 0) {
                     const EHRunViewResult = await rv.RunView({
                         EntityName: CEntity.EntityName,
-                        ExtraFilter: `${CEntity.ContactIDField} = ${contactID} AND ${CEntity.InstitutionField} = '${this.EscapeSingleQuotes(history.organization_name)}' AND ${CEntity.DegreeField} = '${this.EscapeSingleQuotes(history.degree)}'`
+                        ExtraFilter: `${CEntity.ContactIDField} = ${contactID} AND ${CEntity.InstitutionField} = '${this.EscapeSingleQuotes(history.organization_name)}' AND ${CEntity.DegreeField} = '${this.EscapeSingleQuotes(history.degree)}'`,
                     }, currentUser);
                     if (!EHRunViewResult.Success) {
-                        (0, core_1.LogError)('Error querying for existing Employment History', undefined, EHRunViewResult.ErrorMessage);
+                        (0, global_2.LogError)('Error querying for existing Employment History', undefined, EHRunViewResult.ErrorMessage);
                         bSuccess = false;
                         continue;
                     }
                     let historyEntity = null;
                     if (EHRunViewResult.Results.length > 0) {
-                        historyEntity = await md.GetEntityObject(CEntity.EntityName, core_1.CompositeKey.FromID(EHRunViewResult.Results[0].ID), currentUser);
+                        historyEntity = await md.GetEntityObject(CEntity.EntityName, global_2.CompositeKey.FromID(EHRunViewResult.Results[0].ID), currentUser);
                     }
                     else {
                         historyEntity = await md.GetEntityObject(CEntity.EntityName, currentUser);
@@ -882,7 +884,7 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
                     historyEntity.Set(CEntity.IsCurrentField, history.current);
                     const saveResult = await historyEntity.Save();
                     if (!saveResult) {
-                        (0, core_1.LogError)('Error saving Employment History record', undefined, historyEntity.LatestResult);
+                        (0, global_2.LogError)('Error saving Employment History record', undefined, historyEntity.LatestResult);
                         bSuccess = false;
                     }
                 }
@@ -890,7 +892,7 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
             return bSuccess;
         }
         catch (error) {
-            (0, core_1.LogError)('Error creating/updating contact employment and education history', undefined, error);
+            (0, global_2.LogError)('Error creating/updating contact employment and education history', undefined, error);
             return false;
         }
     }
@@ -952,7 +954,7 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
             let response = method === 'get' ? await axios_1.default.get(url, config) : await axios_1.default.post(url, data, config);
             if (response.status === 429) {
                 if (retryAttempts > 0) {
-                    (0, core_1.LogStatus)('   >>> Too many requests to Apollo.io API, waiting 1 minute and trying again...');
+                    (0, global_2.LogStatus)('   >>> Too many requests to Apollo.io API, waiting 1 minute and trying again...');
                     await this.Timeout(60000); // wait 1 minute
                     return await this.WrapApolloCall(method, endpoint, data, config, retryAttempts - 1);
                 }
@@ -966,7 +968,7 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
             // axios could throw an exception for a 429 instead of a response, so we need to handle that here
             if (apolloError && apolloError.response && apolloError.response.status === 429) {
                 if (retryAttempts > 0) {
-                    (0, core_1.LogStatus)('   >>> Too many requests to Apollo.io API, waiting 1 minute and trying again...');
+                    (0, global_2.LogStatus)('   >>> Too many requests to Apollo.io API, waiting 1 minute and trying again...');
                     await this.Timeout(60000); // wait 1 minute
                     return await this.WrapApolloCall(method, endpoint, data, config, retryAttempts - 1);
                 }
@@ -987,12 +989,12 @@ let ApolloEnrichmentAccountsAction = class ApolloEnrichmentAccountsAction extend
      * @returns Promise that resolves after the specified delay
      */
     async Timeout(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
+        return new Promise((resolve) => setTimeout(resolve, ms));
     }
 };
 exports.ApolloEnrichmentAccountsAction = ApolloEnrichmentAccountsAction;
 exports.ApolloEnrichmentAccountsAction = ApolloEnrichmentAccountsAction = __decorate([
-    (0, global_1.RegisterClass)(actions_1.BaseAction, "ApolloEnrichmentAccountsAction")
+    (0, global_1.RegisterClass)(actions_1.BaseAction, 'ApolloEnrichmentAccountsAction')
 ], ApolloEnrichmentAccountsAction);
 /**
  * Loader function to ensure the ApolloEnrichmentAccountsAction class is included in the bundle