@contrail/cli 1.0.39 → 1.0.40

package/src/workflow-template-definitions/workflow-template-definition-deployer.ts

@@ -0,0 +1,182 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { App, AppDeclaration, WorkflowDefinition, WorkflowTemplate } from '../interfaces';
+import { getInstalledApps, getWorkflowTemplateDefinitionsForApp } from '../api/apps';
+import { createWorkflowTemplate } from '../api/event-workflow-templates';
+import { createWorkflowTemplateDefinition, updateWorkflowTemplateDefinition as apiUpdateWorkflowTemplateDefinition } from '../api/event-workflow-template-definition';
+import { getActionDeclarationIdentifier, getActionsForApp } from '../apps/deploy-app/actions-deployer';
+
+export class WorkflowTemplateDefinitionDeployer {
+
+  async cliInstallWorkflowTemplateDefinitions() {
+    const installedApps = await getInstalledApps();
+    if (!installedApps.length) {
+      console.log('%s \nNo apps are currently installed. You must install an app before installing its associated workflow template definitions.', chalk.red.bold('WORKFLOW DEFINITION'));
+      return;
+    }
+
+    let answers = await inquirer.prompt([{
+      type: 'list',
+      name: 'appIdentifier',
+      message: 'Which app\'s workflow would you like to install?',
+      choices: installedApps.map(x => x.app.identifier)
+    }]);
+    const app = installedApps.find(x => x.app.identifier === answers.appIdentifier).app;
+    const workflowTemplateDefinitions = await getWorkflowTemplateDefinitionsForApp({ appId: app.id });
+    for (const definition of workflowTemplateDefinitions) {
+      console.log(chalk.yellow.bold(`- ${definition.name}`));
+    }
+    answers = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'shouldInstall',
+      message: 'Confirmation: would you like to install these workflows? (yes)',
+      default: true,
+    }]);
+
+    if (!answers.shouldInstall) {
+      console.log('%s      Canceling installing workflows template definitions.', chalk.yellow.bold('WORKFLOW DEFINITION TEMPLATE'));
+      return;
+    }
+
+    await this.installWorkflowTemplateDefinitions(workflowTemplateDefinitions);
+  }
+
+  async installWorkflowTemplateDefinitions(workflowTemplateDefinitions: WorkflowTemplate[]) {
+
+    const answers = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'makeActive',
+      message: 'Should the workflows be active ?(yes)',
+      default: true,
+    }]);
+    const makeActive = answers.makeActive;
+    for (const definition of workflowTemplateDefinitions) {
+      const newObject: WorkflowTemplate = {
+        name: definition.name,
+        triggerKey: definition.triggerKey,
+        workflowDefinition: definition.workflowDefinition,
+        isActive: makeActive,
+        supportingAppId: definition.supportingAppId,
+      };
+      await createWorkflowTemplate(newObject);
+    }
+    console.log('%s \nInstalled workflows', chalk.green.bold('WORKFLOW DEFINITION'));
+  }
+
+  async listWorkflowTemplateDefinitions() {
+    const installedApps = await getInstalledApps();
+    const workflowTemplateDefinitions = [];
+    for (const appOrg of installedApps) {
+      workflowTemplateDefinitions.push(...await (await getWorkflowTemplateDefinitionsForApp({ appId: appOrg.appId })).map(
+        x => {
+          return {
+            appName: appOrg.app.name,
+            workflowName: x.name,
+          };
+        }
+      ));
+    }
+    console.log('(app name) workflow name');
+    console.log('------------------------');
+    console.log(chalk.green.bold(workflowTemplateDefinitions.map(x => `(${x.appName}) ${x.workflowName} `).join('\n')));
+  }
+
+  async deployWorkflowTemplateDefinitions(appDeclaration: AppDeclaration, app: App) {
+
+    // FETCH ALL WORKFLOWS FROM THE API.
+    const existingWorkflows = await getWorkflowTemplateDefinitionsForApp({ appId: app.id });
+
+    // UPSERT / DELETE BASED ON WORKFLOW IDENTIFIER
+    console.log('%s \tDeploying workflow definitions.', chalk.yellow.bold('WORKFLOW DEFINITION'));
+
+    if (appDeclaration.workflows) {
+      const localWorkflows = Object.keys(appDeclaration.workflows);
+      if (localWorkflows?.length > 0) {
+        for (const workflowKey of localWorkflows) {
+          await this.deployWorkflow(
+            workflowKey, appDeclaration.workflows[workflowKey] as WorkflowDefinition,
+            app,
+            existingWorkflows,
+          );
+        }
+      }
+    }
+  }
+
+  async deployWorkflow(workflowKey: string, workflow: WorkflowDefinition, app: App, existingWorkflows: Array<any>) {
+    console.log(`%s \tDeploying workflow definitions: ${workflowKey}`, chalk.yellow.bold('WORKFLOW DEFINITION'));
+
+    const identifier = this.getWorkflowDeclarationIdentifier(workflowKey, app);
+    const existingDefinition = existingWorkflows.find(ad => ad.identifier === identifier);
+
+    if (existingDefinition) {
+      return await this.updateWorkflowTemplateDefinition(existingDefinition, workflow, app);
+    }
+    return await this.createNewWorkflowDefinition(workflowKey, workflow, app);
+  }
+
+  private async createNewWorkflowDefinition(workflowKey: string, workflowDeclaration: WorkflowDefinition, app: App) {
+    await this.populateActionIds(workflowDeclaration, app);
+    const newObject: WorkflowDefinition = {
+      identifier: this.getWorkflowDeclarationIdentifier(workflowKey, app),
+      name: workflowDeclaration.name,
+      ownerKey: `app:${app.id}`,
+      triggerKey: workflowDeclaration.triggerKey,
+      workflowDefinition: workflowDeclaration.workflowDefinition,
+      public: workflowDeclaration.public,
+      isActive: workflowDeclaration.isActive,
+      messageGroupId: workflowDeclaration.messageGroupId,
+      parallelWorkerCount: workflowDeclaration.parallelWorkerCount,
+    };
+
+    const workflowTemplate = await createWorkflowTemplateDefinition(newObject);
+
+    console.log(`%s      Created new workflow definition definitions: ${workflowKey}`, chalk.yellow.bold('WORKFLOW DEFINITION'));
+
+    return workflowTemplate;
+  }
+
+  private async populateActionIds(workflowDefinition: WorkflowDefinition, app: App) {
+    const availableAppActions = await getActionsForApp(app);
+    if (!workflowDefinition.workflowDefinition?.paths) {
+      return;
+    }
+    for (const path of workflowDefinition.workflowDefinition.paths) {
+      if (!path?.actionDefinitionConfigs) {
+        continue;
+      }
+      for (const actionConfiguration of path.actionDefinitionConfigs) {
+        const actionKey = actionConfiguration.action;
+        const action = availableAppActions.find(
+          action => action.identifier === getActionDeclarationIdentifier(actionKey, app)
+        );
+        if (!action) {
+          throw new Error(`Could not find action ${actionKey} declared in workflow definition ${workflowDefinition.name}`);
+        }
+        actionConfiguration.id = action.id;
+      }
+    }
+  }
+
+  private async updateWorkflowTemplateDefinition(existingWorkflowDefinition: WorkflowDefinition, workflowDefinition: WorkflowDefinition, app: App) {
+    await this.populateActionIds(workflowDefinition, app);
+    const updates = Object.assign(new Object(), {
+      name: workflowDefinition.name,
+      triggerKey: workflowDefinition.triggerKey,
+      workflowDefinition: workflowDefinition.workflowDefinition,
+      messageGroupId: workflowDefinition.messageGroupId,
+      parallelWorkerCount: workflowDefinition.parallelWorkerCount,
+    });
+
+    const updatedWorkflowDefinition = await apiUpdateWorkflowTemplateDefinition({ id: existingWorkflowDefinition.id, updates });
+
+    console.log(`%s      Updated existing workflow definition: ${updatedWorkflowDefinition.identifier}`, chalk.yellow.bold('WORKFLOW DEFINITION'));
+
+    return updatedWorkflowDefinition;
+  }
+
+  getWorkflowDeclarationIdentifier(actionKey, app: App) {
+    return app.identifier + ':' + actionKey;
+  }
+
+}

package/src/{workflows/workflow-template-deployer.ts → workflow-templates/local-workflow-template-deployer.ts}

@@ -1,12 +1,13 @@
-import { Entities } from '@contrail/sdk';
 import chalk from 'chalk';
+import { getEventWorkflowActionDefinition } from '../api/event-workflow-action-definition';
+import { createWorkflowTemplate, deleteWorkflowTemplate, getExistingWorkflowTemplates, updateWorkflowTemplate as apiUpdateWorkflowTemplate } from '../api/event-workflow-templates';
 import { WorkflowTemplate, WorkflowTemplateDeclaration } from '../interfaces';
 
-export class WorkflowTemplateDeployer {
+export class LocalWorkflowTemplateDeployer {
   async deployWorkflows(wtDeclaration: WorkflowTemplateDeclaration) {
 
     // FETCH ALL WORKFLOWS FROM THE API.
-    const existingWorkflows = await this.getExistingWorkflowTemplates();
+    const existingWorkflows = await getExistingWorkflowTemplates();
 
     // UPSERT / DELETE BASED ON WORKFLOW TEMPLATES IDENTIFIER
     console.log('%s \tDeploying workflow templates.', chalk.yellow.bold('WORKFLOW TEMPLATES'));
@@ -20,12 +21,6 @@ export class WorkflowTemplateDeployer {
     }
   }
 
-  async getExistingWorkflowTemplates() {
-    return await new Entities().get({
-      entityName: 'event-workflow-template'
-    });
-  }
-
   async deployWorkflowTemplate(workflowKey: string, workflow: WorkflowTemplate, existingWorkflows: Array<any>) {
     console.log(`%s \tDeploying workflow: ${workflowKey}`, chalk.yellow.bold('WORKFLOW TEMPLATES'));
 
@@ -51,11 +46,7 @@ export class WorkflowTemplateDeployer {
       parallelWorkerCount: workflowTemplate.parallelWorkerCount,
     };
 
-    const newWorkflowTemplate = await new Entities().create({
-      entityName: 'event-workflow-template',
-      object: newObject,
-    });
-
+    const newWorkflowTemplate = await createWorkflowTemplate(newObject);
     console.log(`%s      Created new workflow definition: ${workflowKey}`, chalk.yellow.bold('WORKFLOW TEMPLATES'));
 
     return newWorkflowTemplate;
@@ -92,11 +83,7 @@ export class WorkflowTemplateDeployer {
       workflowDefinition: workflowTemplate.workflowDefinition
     });
 
-    const updatedWorkflowTemplate = await new Entities().update({
-      entityName: 'event-workflow-template',
-      id: existingWorkflowTemplate.id,
-      object: updates,
-    });
+    const updatedWorkflowTemplate = await apiUpdateWorkflowTemplate({id: existingWorkflowTemplate.id, updates});
 
     console.log(`%s      Updated existing workflow template: ${updatedWorkflowTemplate.identifier}`, chalk.yellow.bold('WORKFLOW TEMPLATES'));
 
@@ -105,7 +92,7 @@ export class WorkflowTemplateDeployer {
 
   public async deleteWorkflowTemplates(wtDeclaration: WorkflowTemplateDeclaration) {
     // FETCH ALL WORKFLOWS FROM THE API.
-    const existingWorkflows = await this.getExistingWorkflowTemplates();
+    const existingWorkflows = await getExistingWorkflowTemplates();
 
     // UPSERT / DELETE BASED ON WORKFLOW TEMPLATES IDENTIFIER
     console.log('%s \tDELETING workflow templates.', chalk.yellow.bold('WORKFLOW TEMPLATES'));
@@ -116,7 +103,7 @@ export class WorkflowTemplateDeployer {
 
       if (existingTemplate) {
         try {
-          await this.deleteWorkflowTemplate(identifier);
+          await deleteWorkflowTemplate(identifier);
         } catch (e) {
           console.log('%s \tFAILED to delete workflow template %s.', chalk.red.bold('WORKFLOW TEMPLATES'), identifier);
         }
@@ -127,19 +114,6 @@ export class WorkflowTemplateDeployer {
     }
 
   }
-
-  private async deleteWorkflowTemplate(identifier: string) {
-    return await new Entities().delete({
-      entityName: 'event-workflow-template',
-      id: identifier,
-    });
-  }
-
-  public async listExistingWorkflowTemplates() {
-    const templates =  await this.getExistingWorkflowTemplates();
-    console.log(templates);
-    return templates;
-  }
 }
 
 export function getWorkflowTemplateIdentifier(workflowKey: string) {
@@ -147,9 +121,6 @@ export function getWorkflowTemplateIdentifier(workflowKey: string) {
 }
 
 export async function getActionByIdentifier(identifier: string) {
-  const result = await new Entities().get({
-    entityName: 'event-workflow-action-definition',
-    criteria: { identifier },
-  });
+  const result = await getEventWorkflowActionDefinition({identifier});
   return result.length > 0? result[0]: {};
 }

package/src/{workflows/workflowCommands.ts → workflow-templates/workflow-template-commands.ts}

@@ -5,9 +5,15 @@ import { authUser } from '../auth/login';
 import { WorkflowTemplateDeclaration } from '../interfaces';
 import { getSeparatorByPlatform } from '../common';
 const yaml = require('js-yaml');
+import { LocalWorkflowTemplateDeployer } from './local-workflow-template-deployer';
 import { WorkflowTemplateDeployer } from './workflow-template-deployer';
 
-export async function deleteWorkflowTemplate() {
+export async function deleteWorkflowTemplates() {
+  await authUser();
+  await new WorkflowTemplateDeployer().deleteWorkflowTemplates();
+}
+
+export async function localDeleteWorkflowTemplate() {
   let wtDeclaration: WorkflowTemplateDeclaration;
   try {
     wtDeclaration = loadTemplateConfig();
@@ -18,10 +24,10 @@ export async function deleteWorkflowTemplate() {
   }
 
   await authUser();
-  await new WorkflowTemplateDeployer().deleteWorkflowTemplates(wtDeclaration);
+  await new LocalWorkflowTemplateDeployer().deleteWorkflowTemplates(wtDeclaration);
 }
 
-export async function deployWorkflowTemplate() {
+export async function localDeployWorkflowTemplate() {
   let wtDeclaration: WorkflowTemplateDeclaration;
   try {
     wtDeclaration = loadTemplateConfig();
@@ -32,7 +38,7 @@ export async function deployWorkflowTemplate() {
   }
 
   await authUser();
-  await new WorkflowTemplateDeployer().deployWorkflows(wtDeclaration);
+  await new LocalWorkflowTemplateDeployer().deployWorkflows(wtDeclaration);
 }
 
 export async function listWorkflowTemplate() {

package/src/workflow-templates/workflow-template-deployer.ts

@@ -0,0 +1,29 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { deleteWorkflowTemplate as apiDeleteWorkflowTemplate } from '../api/event-workflow-templates';
+import { getExistingWorkflowTemplates } from '../api/event-workflow-templates';
+
+export class WorkflowTemplateDeployer {
+
+  async deleteWorkflowTemplates() {
+
+    // FETCH ALL WORKFLOWS FROM THE API.
+    const existingWorkflows = await getExistingWorkflowTemplates();
+    const answers = await inquirer.prompt([{
+      type: 'checkbox',
+      name: 'wfTemplatesToDelete',
+      message: 'Which templates would you like to delete (one or more)?',
+      choices: existingWorkflows.map(x => { return { value: x.id, name: `(${x.createdOn}) ${x.name}` }; })
+    }]);
+    for (const idToDelete of answers.wfTemplatesToDelete) {
+      await apiDeleteWorkflowTemplate(idToDelete);
+    }
+    console.log('%s \tDeleted workflow templates!', chalk.green.bold('WORKFLOW TEMPLATES'));
+  }
+
+  public async listExistingWorkflowTemplates() {
+    const templates = await getExistingWorkflowTemplates();
+    console.log(templates);
+    return templates;
+  }
+}

package/src/apps/app-api.ts

@@ -1,66 +0,0 @@
-import { Entities } from '@contrail/sdk';
-import { Auth } from '../auth/auth';
-
-export async function getAppVersions(app) {
-  return await new Entities().get({
-    entityName: 'app-version',
-    criteria: {
-      appId: app.id
-    }
-  });
-}
-
-export async function upgradeAppVersion(appOrg, appVersionId) {
-  return await new Entities().update({
-    entityName: 'app-org',
-    id: appOrg.id,
-    object: {
-      appVersionId: appVersionId
-    }
-  });
-}
-
-export async function deleteAppOrg(appOrgId: string) {
-  return await new Entities().delete({
-    entityName: 'app-org',
-    id: appOrgId
-  });
-}
-
-export async function getInstalledApps() {
-  return await new Entities().get({
-    entityName: 'app-org',
-    relations: ['app']
-  });
-}
-
-export async function installAppToOrg(app, configProperties) {
-  return await new Entities().create({
-    entityName: 'app-org',
-    object: {
-      appId: app.id,
-      appConfig: configProperties
-    }
-  });
-}
-
-export async function getAvailableApps() {
-  const orgId = Auth.config.orgId;
-  const apps = [];
-  apps.push(...await new Entities().get({
-    entityName: 'app',
-    criteria: {
-      orgId,
-      private: true,
-    },
-  }));
-  apps.push(...await new Entities().get({
-    entityName: 'app',
-    criteria: {
-      orgId,
-      private: false,
-    },
-  }));
-
-  return apps;
-}

package/src/apps/deploy-app/workflow-definition-deployer.ts

@@ -1,118 +0,0 @@
-import { Entities } from '@contrail/sdk';
-import chalk from 'chalk';
-import { App, AppDeclaration, WorkflowDefinition } from '../../interfaces';
-import { getActionDeclarationIdentifier, getActionsForApp } from './actions-deployer';
-
-export class WorkflowDefinitionDeployer {
-  async deployWorkflowDefinitions(appDeclaration: AppDeclaration, app: App) {
-
-    // FETCH ALL WORKFLOWS FROM THE API.
-    const existingWorkflows = await this.getWorkflowDefinitionsForApp(app);
-
-    // UPSERT / DELETE BASED ON WORKFLOW IDENTIFIER
-    console.log('%s \tDeploying workflow definitions.', chalk.yellow.bold('WORKFLOW DEFINITION'));
-
-    if (appDeclaration.workflows) {
-      const localWorkflows = Object.keys(appDeclaration.workflows);
-      if (localWorkflows?.length > 0) {
-        for (const workflowKey of localWorkflows) {
-          await this.deployWorkflow(
-            workflowKey, appDeclaration.workflows[workflowKey] as WorkflowDefinition,
-            app,
-            existingWorkflows,
-          );
-        }
-      }
-    }
-  }
-
-  async getWorkflowDefinitionsForApp(app: App) {
-    return await new Entities().get({
-      entityName: 'event-workflow-template-definition',
-      criteria: { ownerKey: `app:${app.id}` },
-    });
-  }
-
-  async deployWorkflow(workflowKey: string, workflow: WorkflowDefinition, app: App, existingWorkflows: Array<any>) {
-    console.log(`%s \tDeploying workflow definitions: ${workflowKey}`, chalk.yellow.bold('WORKFLOW DEFINITION'));
-
-    const identifier = this.getWorkflowDeclarationIdentifier(workflowKey, app);
-    const existingDefinition = existingWorkflows.find(ad => ad.identifier === identifier);
-
-    if (existingDefinition) {
-      return await this.updateWorkflowDefinition(existingDefinition, workflow, app);
-    }
-    return await this.createNewWorkflowDefinition(workflowKey, workflow, app);
-  }
-
-  private async createNewWorkflowDefinition(workflowKey: string, workflowDeclaration: WorkflowDefinition, app: App) {
-    await this.populateActionIds(workflowDeclaration, app);
-    const newObject: WorkflowDefinition = {
-      identifier: this.getWorkflowDeclarationIdentifier(workflowKey, app),
-      name: workflowDeclaration.name,
-      ownerKey: `app:${app.id}`,
-      triggerKey: workflowDeclaration.triggerKey,
-      workflowDefinition: workflowDeclaration.workflowDefinition,
-      public: workflowDeclaration.public,
-      isActive: workflowDeclaration.isActive,
-      messageGroupId: workflowDeclaration.messageGroupId,
-      parallelWorkerCount: workflowDeclaration.parallelWorkerCount,
-    };
-
-    const workflowTemplate = await new Entities().create({
-      entityName: 'event-workflow-template-definition',
-      object: newObject,
-    });
-
-    console.log(`%s      Created new workflow definition definitions: ${workflowKey}`, chalk.yellow.bold('WORKFLOW DEFINITION'));
-
-    return workflowTemplate;
-  }
-
-  private async populateActionIds(workflowDefinition: WorkflowDefinition, app: App) {
-    const availableAppActions = await getActionsForApp(app);
-    if (!workflowDefinition.workflowDefinition?.paths) {
-      return;
-    }
-    for (const path of workflowDefinition.workflowDefinition.paths) {
-      if (!path?.actionDefinitionConfigs) {
-        continue;
-      }
-      for (const actionConfiguration of path.actionDefinitionConfigs) {
-        const actionKey = actionConfiguration.action;
-        const action = availableAppActions.find(
-          action => action.identifier === getActionDeclarationIdentifier(actionKey, app)
-        );
-        if (!action) {
-          throw new Error(`Could not find action ${actionKey} declared in workflow definition ${workflowDefinition.name}`);
-        }
-        actionConfiguration.id = action.id;
-      }
-    }
-  }
-
-  private async updateWorkflowDefinition(existingWorkflowDefinition: WorkflowDefinition, workflowDefinition: WorkflowDefinition, app: App) {
-    await this.populateActionIds(workflowDefinition, app);
-    const updates = Object.assign(new Object(), {
-      name: workflowDefinition.name,
-      triggerKey: workflowDefinition.triggerKey,
-      workflowDefinition: workflowDefinition.workflowDefinition,
-      messageGroupId: workflowDefinition.messageGroupId,
-      parallelWorkerCount: workflowDefinition.parallelWorkerCount,
-    });
-
-    const updatedWorkflowDefinition = await new Entities().update({
-      entityName: 'event-workflow-template-definition',
-      id: existingWorkflowDefinition.id,
-      object: updates,
-    });
-
-    console.log(`%s      Updated existing workflow definition: ${updatedWorkflowDefinition.identifier}`, chalk.yellow.bold('WORKFLOW DEFINITION'));
-
-    return updatedWorkflowDefinition;
-  }
-
-  getWorkflowDeclarationIdentifier(actionKey, app: App) {
-    return app.identifier + ':' + actionKey;
-  }
-}

package/tslint.json

@@ -1,57 +0,0 @@
-{
-  "defaultSeverity": "error",
-  "extends": [
-    "tslint:recommended"
-  ],
-  "jsRules": {
-    "no-unused-expression": true
-  },
-  "rules": {
-    "eofline": false,
-    "quotemark": [
-      true,
-      "single"
-    ],
-    "no-shadowed-variable": false,
-    "indent": false,
-    "member-access": [
-      false
-    ],
-    "no-string-literal": false,
-    "ordered-imports": [
-      false
-    ],
-    "max-line-length": [
-      false,
-      150
-    ],
-    "member-ordering": [
-      false
-    ],
-    "curly": false,
-    "interface-name": [
-      false
-    ],
-    "array-type": [
-      false
-    ],
-    "no-empty-interface": false,
-    "no-empty": false,
-    "arrow-parens": false,
-    "object-literal-sort-keys": false,
-    "no-unused-expression": false,
-    "max-classes-per-file": [
-      false
-    ],
-    "variable-name": [
-      false
-    ],
-    "one-line": [
-      false
-    ],
-    "one-variable-per-declaration": [
-      false
-    ]
-  },
-  "rulesDirectory": []
-}