Merge pull request #248 from salesforcecli/u/abhinavkumar2/apex_parser_fix

U/abhinavkumar2/apex parser fix

Author: AbhinavKumar-sf

src/commands/omnistudio/migration/OmnistudioRelatedObjectMigrationFacade.ts

@@ -34,13 +34,22 @@ export default class OmnistudioRelatedObjectMigrationFacade {
     this.allversions = allversions;
     this.org = org;
   }
+  public static intializeProject(projectPath?: string): string {
+    if (projectPath) {
+      sfProject.create(defaultProjectName, projectPath);
+      return projectPath + '/' + defaultProjectName;
+    } else {
+      sfProject.create(defaultProjectName);
+      return process.cwd() + '/' + defaultProjectName;
+    }
+  }
   public migrateAll(migrationResult: MigratedObject[], relatedObjects: string[]): any {
     // Start the debug timer
     DebugTimer.getInstance().start();
 
     // Declare an array of MigrationTool
     const migrationTools: RelatedObjectsMigrate[] = [];
-    const projectDirectory: string = this.intializeProject();
+    const projectDirectory: string = OmnistudioRelatedObjectMigrationFacade.intializeProject();
     const debugTimer = DebugTimer.getInstance();
     debugTimer.start();
     // Initialize migration tools based on the relatedObjects parameter
@@ -60,6 +69,7 @@ export default class OmnistudioRelatedObjectMigrationFacade {
         migrationTool.migrateRelatedObjects(null, null);
       } catch (Error) {
         // Log the error
+        Logger.ux.error(Error.message);
         Logger.logger.error(Error.message);
         return { migrationResult };
       }
@@ -90,13 +100,4 @@ export default class OmnistudioRelatedObjectMigrationFacade {
     // Return an instance of ApexClassMigrationTool when implemented
     return new ApexMigration(projectPath, this.namespace, this.org);
   }
-  private intializeProject(projectPath?: string): string {
-    if (projectPath) {
-      sfProject.create(defaultProjectName, projectPath);
-      return projectPath + '/' + defaultProjectName;
-    } else {
-      sfProject.create(defaultProjectName);
-      return process.cwd() + '/' + defaultProjectName;
-    }
-  }
 }

src/migration/related/ApexMigration.ts

@@ -1,16 +1,40 @@
 import * as fs from 'fs';
-// import { RetrieveResult } from '@salesforce/source-deploy-retrieve';
-// import { sfcclicommand } from '../../utils/sfcli/commands/sfclicommand';
 import * as shell from 'shelljs';
 import { Org } from '@salesforce/core';
-import { ApexASTParser, MethodCall } from '../../utils/apex/parser/apexparser';
+import {
+  ApexASTParser,
+  InsertAfterTokenUpdate,
+  InterfaceImplements,
+  MethodCall,
+  MethodParameter,
+  ParameterType,
+  RangeTokenUpdate,
+  SingleTokenUpdate,
+  TokenUpdater,
+} from '../../utils/apex/parser/apexparser';
 import { MigrationResult, RelatedObjectsMigrate } from '../interfaces';
 import { sfProject } from '../../utils/sfcli/project/sfProject';
 import { fileutil, File } from '../../utils/file/fileutil';
+import { Logger } from '../../utils/logger';
 import { BaseRelatedObjectMigration } from './BaseRealtedObjectMigration';
+
 const APEXCLASS = 'Apexclass';
 const APEX_CLASS_PATH = '/force-app/main/default/classes';
+const CALLABLE = 'Callable';
+const VLOCITY_OPEN_INTERFACE2 = 'VlocityOpenInterface2';
+const VLOCITY_OPEN_INTERFACE = 'VlocityOpenInterface';
+
 export class ApexMigration extends BaseRelatedObjectMigration implements RelatedObjectsMigrate {
+  private readonly callableInterface: InterfaceImplements;
+  private readonly vlocityOpenInterface2: InterfaceImplements;
+  private readonly vlocityOpenInterface: InterfaceImplements;
+  private updatedNamespace = this.namespace;
+  public constructor(projectPath: string, namespace: string, org: Org) {
+    super(projectPath, namespace, org);
+    this.callableInterface = new InterfaceImplements(CALLABLE, this.namespace);
+    this.vlocityOpenInterface2 = new InterfaceImplements(VLOCITY_OPEN_INTERFACE2, this.namespace);
+    this.vlocityOpenInterface = new InterfaceImplements(VLOCITY_OPEN_INTERFACE, this.namespace);
+  }
   public identifyObjects(migrationResults: MigrationResult[]): Promise<JSON[]> {
     throw new Error('Method not implemented.');
   }
@@ -32,23 +56,98 @@ export class ApexMigration extends BaseRelatedObjectMigration implements Related
     files = fileutil.readFilesSync(dir);
     for (const file of files) {
       if (file.ext !== '.cls') continue;
-      this.processApexFile(file);
+      try {
+        this.processApexFile(file);
+      } catch (err) {
+        Logger.logger.error(`Error processing ${file.name}`);
+        Logger.logger.error(err);
+      }
     }
     return files;
   }
 
   public processApexFile(file: File): void {
     const fileContent = fs.readFileSync(file.location, 'utf8');
-    const interfaces = new Set<string>(['VlocityOpenInterface', 'VlocityOpenInterface2', 'Callable']);
+    const interfaces: InterfaceImplements[] = [];
+    interfaces.push(this.vlocityOpenInterface, this.vlocityOpenInterface2, this.callableInterface);
     const methodCalls = new Set<MethodCall>();
-    methodCalls.add(new MethodCall('process', 'DRGlobal', this.namespace));
-    methodCalls.add(new MethodCall('processObjectsJSON', 'DRGlobal', this.namespace));
+    const drNameParameter = new MethodParameter(2, ParameterType.DR_NAME);
+    const ipNameParameter = new MethodParameter(1, ParameterType.IP_NAME);
+    methodCalls.add(new MethodCall('DRGlobal', 'process', this.namespace, drNameParameter));
+    methodCalls.add(new MethodCall('DRGlobal', 'processObjectsJSON', this.namespace, drNameParameter));
+    methodCalls.add(new MethodCall('DRGlobal', 'processString', this.namespace, drNameParameter));
+    methodCalls.add(new MethodCall('DRGlobal', 'processFromApex', this.namespace, drNameParameter));
+    methodCalls.add(
+      new MethodCall('IntegrationProcedureService', 'runIntegrationService', this.namespace, ipNameParameter)
+    );
     const parser = new ApexASTParser(fileContent, interfaces, methodCalls, this.namespace);
     parser.parse();
-    this.processApexFileforDRCalls(file, fileContent);
+    const tokenUpdates: TokenUpdater[] = [];
+    const tokenUpdatesForRemoteCalls = this.processApexFileForRemotecalls(file, parser);
+    const tokeUpdatesForMethodCalls = this.processApexFileForMethodCalls(file, parser);
+    const updateMessages: string[] = [];
+
+    if (tokenUpdatesForRemoteCalls && tokenUpdatesForRemoteCalls.length > 0) {
+      tokenUpdates.push(...tokenUpdatesForRemoteCalls);
+      updateMessages.push('File has been updated to allow remote calls from the Omnistudio components');
+    }
+    if (tokeUpdatesForMethodCalls && tokeUpdatesForMethodCalls.length > 0) {
+      updateMessages.push('File has been updated to allow calls to Omnistudio components');
+      tokenUpdates.push(...tokeUpdatesForMethodCalls);
+    }
+    if (tokenUpdates && tokenUpdates.length > 0) {
+      fs.writeFileSync(file.location, parser.rewrite(tokenUpdates));
+    }
+    const warningMessage: string[] = this.processNonReplacableMethodCalls(file, parser);
+    Logger.logger.warn(warningMessage);
   }
-  public processApexFileforDRCalls(file: File, fileContent: string): void {
-    // fileContent = fileContent.replace(this.namespace + '.', 'omnistudio.');
-    fs.writeFileSync(file.location, fileContent, 'utf-8');
+
+  private processApexFileForRemotecalls(file: File, parser: ApexASTParser): TokenUpdater[] {
+    const implementsInterface = parser.implementsInterfaces;
+    const tokenUpdates: TokenUpdater[] = [];
+    if (implementsInterface.has(this.callableInterface)) {
+      Logger.logger.info('file ${file.name} already implements callable no changes will be applied');
+    } else if (implementsInterface.has(this.vlocityOpenInterface2)) {
+      const tokens = implementsInterface.get(this.vlocityOpenInterface2);
+      tokenUpdates.push(new RangeTokenUpdate(CALLABLE, tokens[0], tokens[1]));
+      tokenUpdates.push(new InsertAfterTokenUpdate(this.callMethodBody(), parser.classDeclaration));
+    } else if (implementsInterface.has(this.vlocityOpenInterface)) {
+      Logger.logger.error('file ${file.name} implements VlocityOpenInterface please implement Callable');
+    }
+    return tokenUpdates;
+  }
+
+  private processApexFileForMethodCalls(file: File, parser: ApexASTParser): TokenUpdater[] {
+    const namespaceChanges = parser.namespaceChanges;
+    const tokenUpdates: TokenUpdater[] = [];
+    if (namespaceChanges && namespaceChanges.has(this.namespace)) {
+      for (const tokenChange of namespaceChanges.get(this.namespace))
+        tokenUpdates.push(new SingleTokenUpdate(this.updatedNamespace, tokenChange));
+    }
+    return tokenUpdates;
+  }
+
+  private processNonReplacableMethodCalls(file: File, parser: ApexASTParser): string[] {
+    const methodCalls = parser.nonReplacableMethodParameters;
+    const messages: string[] = [];
+    if (methodCalls.length === 0) return messages;
+    for (const methodCall of methodCalls) {
+      messages.push(
+        `${file.name} has method call ${methodCall.className} ${methodCall.methodName} for which bundleName could have been updated please check and replace with new value if updated.`
+      );
+    }
+    return messages;
+  }
+  private callMethodBody(): string {
+    return `
+            public Object call(String action, Map<String,Object> args)
+            {
+                Map<String,Object> inputMap = (Map<String,Object>)args.get('input');
+                Map<String,Object> outMap = (Map<String,Object>)args.get('output');
+                Map<String,Object> options = (Map<String,Object>)args.get('options');
+
+                return invokeMethod(action, inputMap, outMap, options);
+            }
+    `;
   }
 }