remote apex parser

src/commands/omnistudio/migration/migrate.ts

@@ -19,8 +19,10 @@ import { ResultsBuilder } from '../../../utils/resultsbuilder';
 import { CardMigrationTool } from '../../../migration/flexcard';
 import { OmniScriptExportType, OmniScriptMigrationTool } from '../../../migration/omniscript';
 import { Logger } from '../../../utils/logger';
+import { RemoteActionMigration } from '../../../migration/remoteActionParser';
 import OmnistudioRelatedObjectMigrationFacade from './OmnistudioRelatedObjectMigrationFacade';
 
+
 // Initialize Messages with the current plugin directory
 Messages.importMessagesDirectory(__dirname);
 
@@ -50,7 +52,7 @@ export default class Migrate extends OmniStudioBaseCommand {
       required: false,
     }),
   };
-
+  private remoteActionMigration: RemoteActionMigration;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   public async run(): Promise<any> {
     const namespace = (this.flags.namespace || 'vlocity_ins') as string;
@@ -63,8 +65,15 @@ export default class Migrate extends OmniStudioBaseCommand {
     // this.org is guaranteed because requiresUsername=true, as opposed to supportsUsername
     const conn = this.org.getConnection();
     conn.setApiVersion(apiVersion);
-
-    // Let's time every step
+    this.remoteActionMigration = new RemoteActionMigration(
+      namespace,
+      conn,
+      this.logger,
+      messages,
+      this.ux,
+      allVersions
+    );
+    await this.remoteActionMigration.migrateApexClasses();
     DebugTimer.getInstance().start();
 
     // Register the migration objects

src/mappings/Element.ts

@@ -7,6 +7,7 @@ const mappings = {
   OmniScriptId__c: 'OmniProcessId',
   Order__c: 'SequenceNumber',
   ParentElementId__c: 'ParentElementId',
+  PropertySet: 'PropertySet',
   PropertySet__c: 'PropertySetConfig',
   SearchKey__c: 'EmbeddedOmniScriptKey',
   Type__c: 'Type',

src/mappings/OmniProcess.ts

@@ -0,0 +1,42 @@
+// OmniProcess.ts
+
+const OmniProcessMappings = {
+  CreatedById: 'CreatedById',
+  CreatedDate: 'CreatedDate',
+  CustomHtmlTemplates: 'CustomHtmlTemplates__c',
+  CustomJavaScript: 'CustomJavaScript__c',
+  Description: 'Description',
+  DesignerCustomizationType: 'DesignerCustomizationType__c',
+  ElementTypeComponentMapping: 'ElementTypeComponentMapping__c',
+  Id: 'Id',
+  IsActive: 'IsActive',
+  IsDeleted: 'IsDeleted',
+  IsIntegrationProcedure: 'IsIntegrationProcedure__c',
+  IsMetadataCacheDisabled: 'IsMetadataCacheDisabled__c',
+  IsOmniScriptEmbeddable: 'IsOmniScriptEmbeddable__c',
+  IsTestProcedure: 'IsTestProcedure__c',
+  IsWebCompEnabled: 'IsWebCompEnabled__c',
+  Language: 'Language',
+  LastModifiedById: 'LastModifiedById',
+  LastModifiedDate: 'LastModifiedDate',
+  LastPreviewPage: 'LastPreviewPage__c',
+  LastReferencedDate: 'LastReferencedDate',
+  LastViewedDate: 'LastViewedDate',
+  Name: 'Name',
+  Namespace: 'NamespacePrefix',
+  OmniProcessKey: 'OmniProcessKey__c',
+  OmniProcessType: 'OmniProcessType__c',
+  OverrideKey: 'OverrideKey__c',
+  OwnerId: 'OwnerId',
+  PropertySetConfig: 'PropertySetConfig__c',
+  RequiredPermission: 'RequiredPermission__c',
+  ResponseCacheType: 'ResponseCacheType__c',
+  SubType: 'SubType__c',
+  SystemModstamp: 'SystemModstamp',
+  Type: 'Type__c',
+  UniqueName: 'UniqueName__c',
+  VersionNumber: 'VersionNumber__c',
+  WebComponentKey: 'WebComponentKey__c',
+};
+
+export default OmniProcessMappings;

src/migration/omniscript.ts

@@ -371,7 +371,7 @@ export class OmniScriptMigrationTool extends BaseMigrationTool implements Migrat
   }
 
   // Get All OmniScript__c records i.e All IP & OS
-  private async getAllOmniScripts(): Promise<AnyJson[]> {
+  public async getAllOmniScripts(): Promise<AnyJson[]> {
     DebugTimer.getInstance().lap('Query OmniScripts');
     this.logger.info('allVersions : ' + this.allVersions);
     const filters = new Map<string, any>();
@@ -398,30 +398,73 @@ export class OmniScriptMigrationTool extends BaseMigrationTool implements Migrat
       );
     } else {
       filters.set(this.namespacePrefix + 'IsActive__c', true);
-      return await QueryTools.queryWithFilter(
+      const queryResult = await QueryTools.queryWithFilter(
         this.connection,
         this.namespace,
         OmniScriptMigrationTool.OMNISCRIPT_NAME,
         this.getOmniScriptFields(),
         filters
       );
+      return queryResult;
     }
   }
 
   // Get All Elements w.r.t OmniScript__c i.e Elements tagged to passed in IP/OS
-  private async getAllElementsForOmniScript(recordId: string): Promise<AnyJson[]> {
+  public async getAllElementsForOmniScript(recordId: string): Promise<AnyJson[]> {
     // Query all Elements for an OmniScript
     const filters = new Map<string, any>();
     filters.set(this.namespacePrefix + 'OmniScriptId__c', recordId);
 
     // const queryFilterStr = ` Where ${this.namespacePrefix}OmniScriptId__c = '${omniScriptData.keys().next().value}'`;
-    return await QueryTools.queryWithFilter(
+    const queryResult = await QueryTools.queryWithFilter(
       this.connection,
       this.namespace,
       OmniScriptMigrationTool.ELEMENT_NAME,
       this.getElementFields(),
       filters
     );
+    return queryResult;
+  }
+
+  public async getElementsForAllOmniScripts(): Promise<AnyJson[]> {
+    try {
+      // Fetch all OmniScript records
+      const omniscripts = await this.getAllOmniScripts();
+
+      // Extract all OmniScript IDs
+      const omniScriptIds = omniscripts.map((os) => os['Id']);
+
+      if (omniScriptIds.length === 0) {
+        this.logger.warn('No OmniScripts found.');
+        return [];
+      }
+
+      // Fetch all corresponding Element records based on OmniScript IDs
+      const elements = await this.getElementsByOmniScriptIds(omniScriptIds);
+
+      this.logger.info(`Fetched ${elements.length} elements for ${omniScriptIds.length} OmniScripts.`);
+
+      return elements;
+    } catch (error) {
+      this.logger.error('Error fetching elements for all OmniScripts:', error);
+      throw error;
+    }
+  }
+
+  // Helper method to get elements by a list of OmniScript IDs
+  private async getElementsByOmniScriptIds(omniScriptIds: string[]): Promise<AnyJson[]> {
+    const filters = new Map<string, any>();
+    filters.set(`${this.namespacePrefix}OmniScriptId__c`, omniScriptIds);
+
+    const queryResult = await QueryTools.queryWithFilter(
+      this.connection,
+      this.namespace,
+      OmniScriptMigrationTool.ELEMENT_NAME,
+      this.getElementFields(),
+      filters
+    );
+
+    return queryResult;
   }
 
   // Get All Compiled Definitions w.r.t OmniScript__c i.e Definitions tagged to passed in IP/OS

src/migration/remoteActionParser.ts

@@ -0,0 +1,119 @@
+/* eslint-disable */
+import OmniProcessMappings from '../mappings/OmniProcess';
+import ElementImports from '../mappings/Element';
+import { OmniScriptMigrationTool, OmniScriptExportType } from './omniscript';
+import { Logger } from '@salesforce/core';
+export class RemoteActionMigration {
+  static readonly OMNIPROCESS_NAME = 'OmniProcess__c';
+  static readonly OMNIREMOTEACTION_NAME = 'OmniRemoteAction';
+  private omniScriptMigrationTool: OmniScriptMigrationTool;
+
+  getName(): string {
+    return 'OmniProcessMigrationTool';
+  }
+
+  getRecordName(record: string) {
+    return record['Name'];
+  }
+
+  constructor(
+    private namespace: string,
+    private conn: any,
+    private logger: Logger,
+    private messages: any,
+    private ux: any,
+    private allVersions: boolean
+  ) {
+    // Initialize OmniScriptMigrationTool
+    this.omniScriptMigrationTool = new OmniScriptMigrationTool(
+      OmniScriptExportType.OS,
+      this.namespace,
+      this.conn,
+      this.logger,
+      this.messages,
+      this.ux,
+      this.allVersions
+    );
+  }
+  /**
+   *
+   * @returns
+   */
+  public async migrateApexClasses() {
+    try {
+      const allOS = await this.omniScriptMigrationTool.getAllOmniScripts();
+      if (allOS.length === 0) {
+        this.logger.info('No OmniScripts found.');
+        return;
+      }
+
+      // Filter OmniScripts of type 'os' or 'ip'
+      const relevantOS = allOS.filter((osRecord) => {
+        let typeConst = this.namespace + '__' + OmniProcessMappings.OmniProcessType;
+        return osRecord[typeConst] === 'OmniScript' || osRecord[typeConst] === 'Integration Procedure';
+      });
+
+      if (relevantOS.length === 0) {
+        this.logger.info('No relevant OmniScripts found.');
+        return;
+      }
+
+      // Fetch elements for all relevant OmniScripts concurrently using Promise.all
+      const fetchElementsPromises = relevantOS.map(async (osRecord) => {
+        const omniScriptId = osRecord['Id'];
+        let processNameField = OmniProcessMappings.Name;
+        const processName = osRecord[processNameField];
+        try {
+          const elements = await this.omniScriptMigrationTool.getAllElementsForOmniScript(omniScriptId);
+          return {
+            omniScriptId,
+            processName,
+            typeConst: osRecord[this.namespace + '__' + OmniProcessMappings.OmniProcessType],
+            elements,
+          };
+        } catch (error) {
+          this.logger.error(`Error fetching elements for OmniScript ID: ${omniScriptId}`, error);
+          return null;
+        }
+      });
+
+      const fetchedData = await Promise.all(fetchElementsPromises);
+      // Process the fetched elements
+      fetchedData.forEach((osData) => {
+        if (!osData || osData.elements.length === 0) {
+          this.logger.info(`No elements found for OmniScript ID: ${osData?.omniScriptId}`);
+          return;
+        }
+
+        osData.elements.forEach((element) => {
+          const elementTypeConst = this.namespace + '__' + ElementImports.Type__c + '__c';
+          const propertyTypeConst = this.namespace + '__' + ElementImports.PropertySet + '__c';
+          if (element[elementTypeConst] === 'Remote Action') {
+            try {
+              let propertySet = JSON.parse(element[propertyTypeConst]);
+              let extractedData = [];
+
+              if (propertySet.remoteClass && propertySet.remoteMethod) {
+                // Construct the object with the required fields
+                let extractedItem = {
+                  type: osData.typeConst,
+                  omniProcessId: osData.omniScriptId,
+                  name: osData.processName,
+                  remoteClass: propertySet.remoteClass,
+                  remoteMethod: propertySet.remoteMethod,
+                };
+                extractedData.push(extractedItem);
+                console.log('extracted data ::::', extractedData);
+                // You can handle the extracted data here (e.g., log it, store it, etc.)
+              }
+            } catch (error) {
+              this.logger.error(`Error parsing property set JSON for element: ${osData.omniScriptId}`, error);
+            }
+          }
+        });
+      });
+    } catch (error) {
+      this.logger.error('Error during migration:', error);
+    }
+  }
+}

src/utils/lwcparser/htmlParser/HTMLParser.ts

@@ -1,6 +1,10 @@
 /* eslint-disable @typescript-eslint/explicit-member-accessibility */
 /* eslint-disable @typescript-eslint/restrict-template-expressions */
 /* eslint-disable @typescript-eslint/member-ordering */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable no-console */
 import * as fs from 'fs';
 import * as cheerio from 'cheerio';