@zohodesk/library-platform 1.0.1 → 1.0.2-exp.4

package/es/platform/client-actions/translators/condition-resolver/field-evaluators/GetResolvedContextFieldValue.js

@@ -0,0 +1,8 @@
+export function getResolvedContextFieldValue(context, field) {
+  if (field.includes(".")) {
+    let value = field.split(".").reduce((obj, key) => obj && obj[key], context);
+    return value;
+  }
+
+  return context[field];
+}

package/es/platform/client-actions/translators/condition-resolver/field-evaluators/index.js

@@ -0,0 +1,58 @@
+import { evalIsEmpty } from "./EvalIsEmpty";
+import { evalEmptyString } from "./EvalEmptyString";
+import { evalEndsWith } from "./EvalEndsWith";
+import { evalEquals } from "./EvalEquals";
+import { evalGreaterThan } from "./EvalGreaterThan";
+import { evalGreaterThanOrEquals } from "./EvalGreaterThanOrEquals";
+import { evalIn } from "./EvalIn";
+import { evalLike } from "./EvalLike";
+import { evalLessThan } from "./EvalLessThan";
+import { evalLessThanOrEquals } from "./EvalLessThanOrEquals";
+import { EvalIsNotEmpty } from "./EvalIsNotEmpty";
+import { evalNotEquals } from "./EvalNotEquals";
+import { evalNotLike } from "./EvalNotLike";
+import { evalStartsWith } from "./EvalStartsWith";
+const opers = {
+  'ISEMPTY': evalIsEmpty,
+  'EMPTYSTRING': evalEmptyString,
+  'ENDSWITH': evalEndsWith,
+  '=': evalEquals,
+  '>': evalGreaterThan,
+  '>=': evalGreaterThanOrEquals,
+  'IN': evalIn,
+  'LIKE': evalLike,
+  '<': evalLessThan,
+  '<=': evalLessThanOrEquals,
+  'ISNOTEMPTY': EvalIsNotEmpty,
+  '!=': evalNotEquals,
+  'NOT LIKE': evalNotLike,
+  'STARTSWITH': evalStartsWith
+};
+const platformOpers = {
+  '=': opers['='],
+  'is': opers['='],
+  'starts with': opers['STARTSWITH'],
+  'ends with': opers['ENDSWITH'],
+  'contains': opers['LIKE'],
+  "doesn't contain": opers['NOT LIKE'],
+  "is empty": opers["ISEMPTY"],
+  "is not empty": opers["ISNOTEMPTY"],
+  '<': opers['<'],
+  '>': opers['>'],
+  '<=': opers['<='],
+  '>=': opers['>='],
+  '<>': opers['!='],
+  'in': opers["IN"]
+};
+export function evaluateConditionsFields(conditions, context) {
+  return conditions.map(_ref => {
+    let {
+      fieldName,
+      condition,
+      value
+    } = _ref;
+    const resolvedValue = value.join(',');
+    if (fieldName == null && value == null || value.length == 0) return true;
+    return platformOpers[condition](fieldName, resolvedValue, context);
+  });
+}

package/es/platform/client-actions/translators/condition-resolver/index.js

@@ -0,0 +1,33 @@
+import { patternValidate } from "./pattern-evaluator/PatternValidator";
+import { evaluateConditionsFields } from "./field-evaluators";
+import { evaluateExpression, parse } from "./pattern-evaluator";
+export class ConditionResolver {
+  static evaluateCondition(condition, context, id) {
+    const {
+      fields = [],
+      pattern = ''
+    } = condition;
+
+    if (fields.length > 0 && pattern.length > 0) {
+      const {
+        isValid,
+        errorMessage,
+        pattern: validatedPattern
+      } = patternValidate(pattern, fields.length);
+
+      if (!isValid) {
+        console.error(`Error in client action id ${id} -  condition pattern`, errorMessage);
+        return false;
+      }
+
+      const resolvedFields = evaluateConditionsFields(fields, context);
+      const transformedPattern = validatedPattern.replace(/and/g, '&&').replace(/or/g, '||');
+      const ast = parse(transformedPattern);
+      const isValidCondition = evaluateExpression(ast, resolvedFields);
+      return isValidCondition;
+    }
+
+    return true;
+  }
+
+}

package/es/platform/client-actions/translators/condition-resolver/pattern-evaluator/PatternValidator.js

@@ -0,0 +1,86 @@
+/* eslint-disable max-lines-per-function */
+export function patternValidate() {
+  let patternString = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  let conditionsLength = arguments.length > 1 ? arguments[1] : undefined;
+
+  if (!patternString.trim()) {
+    return {
+      errorMessage: 'Pattern cannot be empty',
+      isValid: false
+    };
+  }
+
+  const isValid = true;
+  const patternStr = patternString.replace(/\s+/g, '');
+  const openBracketsLen = (patternStr.match(/\(/gi) || []).length;
+  const closeBractsLen = (patternStr.match(/\)/gi) || []).length;
+
+  if (openBracketsLen !== closeBractsLen) {
+    return {
+      errorMessage: 'Pattern brackets do not match',
+      isValid: false
+    };
+  }
+
+  let brackStr = patternStr.replace(/#/g, '~');
+  brackStr = patternStr.replace(/(and|or)/g, '#');
+
+  if (brackStr.indexOf('(#') !== -1 || brackStr.indexOf('#)') !== -1) {
+    return {
+      errorMessage: 'Invalid brackets surrounding condition operator(s).',
+      isValid: false
+    };
+  }
+
+  if (brackStr.indexOf('()') !== -1) {
+    return {
+      errorMessage: 'Pattern brackets do not match',
+      isValid: false
+    };
+  }
+
+  const matchedNumbers = patternStr.match(/[0-9]+/g);
+  const patternNumbers = matchedNumbers ? matchedNumbers : [];
+  const patternNumbersLen = patternNumbers.length;
+
+  for (let i = 0; i < patternNumbersLen; i++) {
+    const currentNumber = parseInt(patternNumbers[i]);
+
+    if (currentNumber !== i + 1) {
+      return {
+        errorMessage: 'Please check the conditions number in the pattern.',
+        isValid: false
+      };
+    }
+  }
+
+  const patternEmpty = brackStr.replace(/[()]/g, '#').replace(/[0-9]+/g, '#').replace(/#/g, '');
+
+  if (patternEmpty && patternEmpty.length >= 1) {
+    return {
+      errorMessage: 'Invalid content in this pattern',
+      isValid: false
+    };
+  }
+
+  const andOrCount = (patternStr.match(/(and|or)/gi) || []).length;
+
+  if (conditionsLength - 1 !== andOrCount) {
+    return {
+      errorMessage: 'Number of conditions in this pattern do not match with the conditions entered',
+      isValid: false
+    };
+  }
+
+  if (patternNumbersLen !== conditionsLength) {
+    return {
+      errorMessage: 'Number of conditions in this pattern do not match with the conditions given.',
+      isValid: false
+    };
+  }
+
+  return {
+    isValid,
+    pattern: patternStr
+  };
+}

package/es/platform/client-actions/translators/condition-resolver/pattern-evaluator/index.js

@@ -0,0 +1,96 @@
+/* eslint-disable max-lines-per-function */
+import jsep from 'jsep';
+const binops = {
+  '||': function (a, b) {
+    return a || b;
+  },
+  '&&': function (a, b) {
+    return a && b;
+  }
+};
+const unops = {
+  '-': function (a) {
+    return -a;
+  },
+  '+': function (a) {
+    return +a;
+  },
+  '~': function (a) {
+    return ~a;
+  },
+  '!': function (a) {
+    return !a;
+  }
+};
+
+function evaluateArray(list, context) {
+  return list.map(function (v) {
+    return evaluate(v, context);
+  });
+}
+
+function evaluateMember(node, context) {
+  const object = evaluate(node.object, context);
+
+  if (node.computed) {
+    return [object, object[evaluate(node.property, context)]];
+  } else {
+    return [object, object[node.property.name]];
+  }
+}
+
+function evaluate(node, context) {
+  switch (node.type) {
+    case 'ArrayExpression':
+      return evaluateArray(node.elements, context);
+
+    case 'BinaryExpression':
+      return binops[node.operator](evaluate(node.left, context), evaluate(node.right, context));
+
+    case 'CallExpression':
+      let caller, fn, assign;
+
+      if (node.callee.type === 'MemberExpression') {
+        assign = evaluateMember(node.callee, context);
+        caller = assign[0];
+        fn = assign[1];
+      } else {
+        fn = evaluate(node.callee, context);
+      }
+
+      if (typeof fn !== 'function') {
+        return undefined;
+      }
+
+      return fn.apply(caller, evaluateArray(node.arguments, context));
+
+    case 'ConditionalExpression':
+      return evaluate(node.test, context) ? evaluate(node.consequent, context) : evaluate(node.alternate, context);
+
+    case 'Literal':
+      return context[node.value - 1];
+
+    case 'LogicalExpression':
+      if (node.operator === '||') {
+        return evaluate(node.left, context) || evaluate(node.right, context);
+      } else if (node.operator === '&&') {
+        return evaluate(node.left, context) && evaluate(node.right, context);
+      }
+
+      return binops[node.operator](evaluate(node.left, context), evaluate(node.right, context));
+
+    case 'MemberExpression':
+      return evaluateMember(node, context)[1];
+
+    case 'ThisExpression':
+      return context;
+
+    case 'UnaryExpression':
+      return unops[node.operator](evaluate(node.argument, context));
+
+    default:
+      return undefined;
+  }
+}
+
+export { jsep as parse, evaluate as evaluateExpression };

package/es/platform/client-actions/translators/context-resolver/index.js

@@ -0,0 +1,54 @@
+import TemplateResolver from "../../template-resolver";
+export class ActionContextResolver {
+  constructor() {}
+
+  static resolveContextInEventMappingPayload(eventMapping, context) {
+    return { ...eventMapping,
+      payloadValueMapping: TemplateResolver.replaceContextVariablesInObject(eventMapping.payloadValueMappingMeta, context)
+    };
+  }
+
+  static resolveConditionValueContext(condition, templateContext) {
+    const {
+      fields = [],
+      pattern
+    } = condition;
+    const resolvedFields = fields.map(field => {
+      const resolvedValue = TemplateResolver.replaceContextVariables(field.value.join(","), templateContext);
+      return { ...field,
+        value: resolvedValue.split(",")
+      };
+    });
+    return { ...condition,
+      pattern,
+      fields: resolvedFields
+    };
+  }
+
+  static resolveContextInProperties(properties, templateContext) {
+    return TemplateResolver.replaceContextVariablesInObject(properties, templateContext);
+  }
+
+  static resolveAction(action, context) {
+    const eventMappings = action.uiComponentMapping.eventMappings;
+    const conditions = action.conditionsMeta;
+    const resolvedEventMappings = eventMappings.map(eventMapping => this.resolveContextInEventMappingPayload(eventMapping, context));
+    const resolvedProperty = this.resolveContextInProperties(action.uiComponentMapping.propertiesValueMappingMeta, context);
+    const resolveConditionValues = this.resolveConditionValueContext(conditions, context);
+    return { ...action,
+      conditions: resolveConditionValues,
+      uiComponentMapping: { ...action.uiComponentMapping,
+        propertiesValueMapping: resolvedProperty,
+        eventMappings: resolvedEventMappings
+      }
+    };
+  }
+
+  static resolveActions(actions, context) {
+    const replacementContext = {
+      "@context": context
+    };
+    return actions ? actions.map(action => this.resolveAction(action, replacementContext)) : [];
+  }
+
+}

package/es/platform/{data-broker → data-source}/http-template/deleteRecord.js

@@ -1,6 +1,6 @@
 const deleteRecord = {
   name: 'records',
-  api: '/api/v1/{{moduleName}}/moveToTrash',
+  api: '/{{servicePrefix}}/{{orgName}}/api/v1/{{moduleName}}/moveToTrash',
   parameters: `{}`,
   type: 'POST',
   transformer: data => data,

package/es/platform/{data-broker → data-source}/http-template/deleteRecords.js

@@ -1,6 +1,6 @@
 const deleteRecords = {
   name: 'records',
-  api: '/api/v1/{{moduleName}}/moveToTrash',
+  api: '/{{servicePrefix}}/{{orgName}}/api/v1/{{moduleName}}/moveToTrash',
   parameters: `{}`,
   type: 'POST',
   transformer: data => data,

package/es/platform/{data-broker → data-source}/http-template/getAvailableFields.js

@@ -1,18 +1,18 @@
 let getAvailableFields = {
-  name: "availableFields",
-  api: "/api/v1/views/availableFields",
+  name: 'availableFields',
+  api: '/{{servicePrefix}}/{{orgName}}/api/v1/views/availableFields',
   parameters: `{
         "departmentId":"{{departmentId}}",
         "module":"{{moduleName}}"
     }`,
-  type: "GET",
+  type: 'GET',
   transformer: res => res.fields,
   properties: {
     moduleName: {
       required: true,
       typeMetadata: {
         schema: {
-          type: "string"
+          type: 'string'
         }
       }
     },
@@ -20,7 +20,7 @@ let getAvailableFields = {
       required: true,
       typeMetadata: {
         schema: {
-          type: "string"
+          type: 'string'
         }
       }
     }

package/es/platform/data-source/http-template/getClientActions.js

@@ -0,0 +1,23 @@
+let getClientActions = {
+  name: 'uiActions',
+  api: '/{{servicePrefix}}/{{orgName}}/api/v1/clientActions',
+  parameters: `{
+        "from":{{from}},
+        "limit":{{limit}},
+        "library": "{{library}}",
+        "module": "{{moduleName}}"
+    }`,
+  type: 'GET',
+  transformer: data => data,
+  properties: {
+    modelName: {
+      required: true,
+      typeMetadata: {
+        schema: {
+          type: 'string'
+        }
+      }
+    }
+  }
+};
+export default getClientActions;

package/es/platform/{data-broker → data-source}/http-template/getRecords.js

@@ -1,6 +1,6 @@
 let getRecords = {
   name: 'records',
-  api: '/api/v1/{{moduleName}}',
+  api: '/{{servicePrefix}}/{{orgName}}/api/v1/{{moduleName}}',
   parameters: `{
         "viewId":"{{viewId}}",
         "from":{{from}},

package/es/platform/{data-broker → data-source}/http-template/getSelectedFields.js

@@ -1,17 +1,17 @@
 let getSelectedFields = {
-  name: "selectedFields",
-  api: "/api/v1/views/{{viewId}}/selectedFields",
+  name: 'selectedFields',
+  api: '/{{servicePrefix}}/{{orgName}}/api/v1/views/{{viewId}}/selectedFields',
   parameters: `{
         "departmentId":"{{departmentId}}"
     }`,
-  type: "GET",
+  type: 'GET',
   transformer: res => res.fields,
   properties: {
     viewId: {
       required: true,
       typeMetadata: {
         schema: {
-          type: "string"
+          type: 'string'
         }
       }
     },
@@ -20,7 +20,7 @@ let getSelectedFields = {
       defaultValue: 1,
       typeMetadata: {
         schema: {
-          type: "number"
+          type: 'number'
         }
       }
     }

package/es/platform/{data-broker → data-source}/http-template/updateRecord.js

@@ -1,6 +1,6 @@
 const updateRecord = {
   name: 'records',
-  api: '/api/v1/{{moduleName}}/{{recordId}}',
+  api: '/{{servicePrefix}}/{{orgName}}/api/v1/{{moduleName}}/{{recordId}}',
   parameters: `{}`,
   type: 'PATCH',
   transformer: data => data,

package/es/platform/{data-broker → data-source}/index.js

@@ -4,19 +4,19 @@ import updateRecord from "./http-template/updateRecord";
 import deleteRecords from "./http-template/deleteRecords";
 import getAvailableFields from "./http-template/getAvailableFields";
 import getSelectedFields from "./http-template/getSelectedFields";
-import getUIActions from "./http-template/getUIActions";
+import getClientActions from "./http-template/getClientActions";
 import { RecordApiActionName } from "../../bc/zrecord/Constants";
 import deleteRecord from "./http-template/deleteRecord";
-let record = {
+let dataSource = {
   httpTemplates: {
     [RecordApiActionName.GET_RECORDS]: getRecords,
     [RecordApiActionName.UPDATE_RECORD]: updateRecord,
     [RecordApiActionName.DELETE_RECORDS]: deleteRecords,
     [RecordApiActionName.DELETE_RECORD]: deleteRecord,
+    [RecordApiActionName.GET_CLIENTACTIONS]: getClientActions,
     getAvailableFields,
-    getSelectedFields,
-    getUIActions
+    getSelectedFields
   }
 };
-export default record; // let ticketsRecordSerice = createRecord(tickets, () => {});
+export default dataSource; // let ticketsRecordSerice = createRecord(tickets, () => {});
 // export default ticketsRecordSerice;

package/es/platform/{data-broker → data-source}/utils/transformer/CreateCf.js

@@ -1,7 +1,7 @@
 // REVIEW: Function never used
 function createCf(item, key) {
   return Object.keys(item).reduce((res, next) => {
-    if ([key, "id", "createdTime"].includes(next)) {
+    if ([key, 'id', 'createdTime'].includes(next)) {
       return res;
     } else {
       res[next] = item[next];

package/es/platform/zdata-source/adapters/controllers/AbstractController.js

@@ -0,0 +1,8 @@
+export default class AbstractController {
+  constructor(service) {
+    this.service = service;
+    this.service = service;
+    this.handle = this.handle.bind(this);
+  }
+
+}

package/es/platform/{zdata-broker/adapters/controllers/ActionExecutorController.js → zdata-source/adapters/controllers/DataSourceExecutorController.js}

@@ -1,5 +1,5 @@
 import AbstractController from "./AbstractController";
-export default class ActionExecutorController extends AbstractController {
+export default class DataSourceExecutorController extends AbstractController {
   handle(event) {
     const {
       state,

package/es/platform/{zdata-broker → zdata-source}/adapters/gateways/Repository.js

@@ -1,6 +1,6 @@
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-import DataBrokerFactory from "../../usecases/entities-factory/DataBrokerFactory";
+import DataSourceFactory from "../../applications/entities-factory/DataSourceFactory";
 export default class Repository {
   constructor() {
     _defineProperty(this, "state", void 0);
@@ -10,14 +10,14 @@ export default class Repository {
     this.state = state;
   }
 
-  getDataBrokerEntity(templateHelpers) {
+  getDataSourceEntity(templateHelpers) {
     const {
-      dataBroker
+      dataSource
     } = this.state.behaviours;
     const {
       apiTemplates
-    } = dataBroker;
-    const recordManager = DataBrokerFactory.create(apiTemplates, templateHelpers);
+    } = dataSource;
+    const recordManager = DataSourceFactory.create(apiTemplates, templateHelpers);
     return recordManager;
   }
 

package/es/platform/{zdata-broker → zdata-source}/adapters/gateways/Service.js

@@ -1,10 +1,10 @@
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-import RegisterUseCase from "../../usecases/interactors/RegisterUseCase";
-import ExecuteActionUseCase from "../../usecases/interactors/ExecuteActionUseCase";
-import FailureUseCase from "../../usecases/interactors/FailureUseCase";
-import SuccessUseCase from "../../usecases/interactors/SuccessUseCase";
-import NoContentUseCase from "../../usecases/interactors/NoContentUseCase";
+import RegisterUseCase from "../../applications/usecases/RegisterUseCase";
+import ExecuteActionUseCase from "../../applications/usecases/ExecuteActionUseCase";
+import FailureUseCase from "../../applications/usecases/FailureUseCase";
+import SuccessUseCase from "../../applications/usecases/SuccessUseCase";
+import NoContentUseCase from "../../applications/usecases/NoContentUseCase";
 export default class Service {
   constructor(dependencies) {
     _defineProperty(this, "registerUseCase", void 0);

package/es/platform/{zdata-broker → zdata-source}/adapters/gateways/TemplateHelpers.js

@@ -17,6 +17,27 @@ export default class TemplateHelpers {
     });
   }
 
+  isOnlyTemplateVariables(inputString) {
+    return /^{{(.*?)}}$/.test(inputString);
+  }
+
+  replaceTemplateVariablesInObject(properties, replacementObj) {
+    const replaced = {};
+    Object.entries(properties).forEach(_ref => {
+      let [key, value] = _ref;
+
+      if (typeof value === 'string' && this.isOnlyTemplateVariables(value)) {
+        const path = value.replace(/{{(.*?)}}/g, '$1');
+        replaced[key] = this.getPathValue(path, replacementObj);
+      } else if (typeof value === 'string' && value.includes('{{')) {
+        replaced[key] = this.replaceTemplateVariables(value, replacementObj);
+      } else {
+        replaced[key] = value;
+      }
+    });
+    return replaced;
+  }
+
   objectToQueryString(obj) {
     return Object.keys(obj).map(key => encodeURIComponent(key) + '=' + encodeURIComponent(obj[key])).join('&');
   }

package/es/platform/{zdata-broker → zdata-source}/adapters/presenters/Presenter.js

@@ -12,10 +12,10 @@ export default class Presenter {
     this.state = state;
   }
 
-  updateBehaviourState(dataBrokerBehaviourState) {
+  updateBehaviourState(dataSourceBehaviourState) {
     this.state = { ...this.state,
       behaviours: { ...this.state.behaviours,
-        dataBroker: dataBrokerBehaviourState
+        dataSource: dataSourceBehaviourState
       }
     };
     this.updateState(this.state);
@@ -23,10 +23,10 @@ export default class Presenter {
 
   updateAPITemplates(apiTemplates) {
     const {
-      dataBroker
+      dataSource
     } = this.state.behaviours;
     this.updateBehaviourState({
-      apiTemplates: { ...(dataBroker === null || dataBroker === void 0 ? void 0 : dataBroker.apiTemplates),
+      apiTemplates: { ...(dataSource === null || dataSource === void 0 ? void 0 : dataSource.apiTemplates),
         ...apiTemplates
       }
     });

package/es/platform/{zdata-broker/usecases → zdata-source/applications}/entities-factory/APITemplatesFactory.js

@@ -1,5 +1,5 @@
-import APITemplate from "../../entities/APITemplate";
-import APITemplates from "../../entities/APITemplates";
+import APITemplate from "../../domain/entities/APITemplate";
+import APITemplates from "../../domain/entities/APITemplates";
 export default class APITemplatesFactory {
   static create(httpTemplates, templateHelpers) {
     const apiTemplatesMap = new Map();

package/es/platform/{zdata-broker/usecases/entities-factory/DataBrokerFactory.js → zdata-source/applications/entities-factory/DataSourceFactory.js}

@@ -1,10 +1,9 @@
 import APITemplatesFactory from "./APITemplatesFactory";
-import DataBroker from "../../entities/DataBroker";
-export default class DataBrokerFactory {
+import DataSource from "../../domain/entities/DataSource";
+export default class DataSourceFactory {
   static create(httpTemplates, templateHelpers) {
     const apiTemplates = APITemplatesFactory.create(httpTemplates, templateHelpers);
-    const dataBroker = new DataBroker(apiTemplates);
-    return dataBroker;
+    return new DataSource(apiTemplates);
   }
 
 }

package/es/platform/zdata-source/applications/interfaces/gateways/ITemplateHelpers.js

@@ -0,0 +1 @@
+export { ITemplateHelpers } from "../../../domain/entities/interfaces/ITemplateHelpers";

package/es/platform/{zdata-broker/usecases/interactors → zdata-source/applications/usecases}/ExecuteActionUseCase.js

@@ -12,9 +12,9 @@ class ExecuteActionUseCase extends AbstractUseCase {
       metaData,
       actionName
     } = input;
-    const dataBroker = repository.getDataBrokerEntity(templateHelpers);
-    const apiDetails = dataBroker.getApiDetails(actionName, props);
-    dispatch(dataBroker.createFetchEvent(apiDetails, metaData));
+    const dataSource = repository.getDataSourceEntity(templateHelpers);
+    const apiDetails = dataSource.getApiDetails(actionName, props);
+    dispatch(dataSource.createFetchEvent(apiDetails, metaData));
   }
 
 }