@zohodesk/library-platform 1.1.0-exp.2 → 1.1.1

package/es/platform/client-actions/translators/client-actions-translator/index.js

@@ -0,0 +1,29 @@
+import { ActionContextResolver } from "../context-resolver";
+import { ConditionResolver } from "../condition-resolver";
+export default class ClientActionsTranslator {
+  constructor() {}
+
+  static transformToActionViewModel(action) {
+    return {
+      id: action.id,
+      component: action.uiComponentMapping.component,
+      properties: action.uiComponentMapping.propertiesValueMapping,
+      eventMappings: action.uiComponentMapping.eventMappings.map(eventMapping => {
+        return {
+          sourceEvent: eventMapping.sourceEvent,
+          id: eventMapping.id,
+          targetEvent: eventMapping.targetEvent,
+          payload: eventMapping.payloadValueMapping
+        };
+      })
+    };
+  }
+
+  static transform(actions, context) {
+    const resolvedActions = ActionContextResolver.resolveActions(actions, context);
+    const evaluatedActions = resolvedActions.filter(action => ConditionResolver.evaluateCondition(action.conditions, context, action.id));
+    const finalTransformedActions = evaluatedActions.map(action => this.transformToActionViewModel(action));
+    return finalTransformedActions;
+  }
+
+}

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

@@ -0,0 +1,4 @@
+import { getResolvedContextFieldValue } from "./GetResolvedContextFieldValue";
+export function evalEmptyString(field, value, context) {
+  return getResolvedContextFieldValue(context, field) === '' || getResolvedContextFieldValue(context, field) === null;
+}

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

@@ -0,0 +1,4 @@
+import { getResolvedContextFieldValue } from "./GetResolvedContextFieldValue";
+export function evalEndsWith(field, value, context) {
+  return String(getResolvedContextFieldValue(context, field)).endsWith(String(value));
+}

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

@@ -0,0 +1,4 @@
+import { getResolvedContextFieldValue } from "./GetResolvedContextFieldValue";
+export function evalEquals(field, value, context) {
+  return String(getResolvedContextFieldValue(context, field)) === String(value);
+}

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

@@ -0,0 +1,4 @@
+import { getResolvedContextFieldValue } from "./GetResolvedContextFieldValue";
+export function evalGreaterThan(field, value, context) {
+  return getResolvedContextFieldValue(context, field) > value;
+}

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

@@ -0,0 +1,4 @@
+import { getResolvedContextFieldValue } from "./GetResolvedContextFieldValue";
+export function evalGreaterThanOrEquals(field, value, context) {
+  return getResolvedContextFieldValue(context, field) >= value;
+}

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

@@ -0,0 +1,4 @@
+import { evalEquals } from "./EvalEquals";
+export function evalIn(field, value, context) {
+  return String(value).split(',').some(val => evalEquals(field, val, context));
+}

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

@@ -0,0 +1,4 @@
+import { evalEmptyString } from "./EvalEmptyString";
+export function evalIsEmpty(field, value, context) {
+  return evalEmptyString(field, value, context);
+}

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

@@ -0,0 +1,4 @@
+import { evalIsEmpty } from "./EvalIsEmpty";
+export function EvalIsNotEmpty(field, value, context) {
+  return !evalIsEmpty(field, value, context);
+}

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

@@ -0,0 +1,4 @@
+import { getResolvedContextFieldValue } from "./GetResolvedContextFieldValue";
+export function evalLessThan(field, value, context) {
+  return getResolvedContextFieldValue(context, field) < value;
+}

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

@@ -0,0 +1,4 @@
+import { getResolvedContextFieldValue } from "./GetResolvedContextFieldValue";
+export function evalLessThanOrEquals(field, value, context) {
+  return getResolvedContextFieldValue(context, field) <= value;
+}

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

@@ -0,0 +1,4 @@
+import { getResolvedContextFieldValue } from "./GetResolvedContextFieldValue";
+export function evalLike(field, value, context) {
+  return String(getResolvedContextFieldValue(context, field)).includes(String(value));
+}

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

@@ -0,0 +1,4 @@
+import { evalEquals } from "./EvalEquals";
+export function evalNotEquals(field, value, context) {
+  return !evalEquals(field, value, context);
+}

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

@@ -0,0 +1,4 @@
+import { evalLike } from "./EvalLike";
+export function evalNotLike(field, value, context) {
+  return !evalLike(field, value, context);
+}

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

@@ -0,0 +1,4 @@
+import { getResolvedContextFieldValue } from "./GetResolvedContextFieldValue";
+export function evalStartsWith(field, value, context) {
+  return String(getResolvedContextFieldValue(context, field)).startsWith(String(value));
+}

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/client-actions/translators/interfaces/IContext.js

@@ -0,0 +1 @@
+export {};

package/es/platform/client-actions/translators/interfaces/IState.js

@@ -0,0 +1 @@
+export {};

package/es/platform/data-source/dbc/index.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,18 +1,18 @@
 let getAvailableFields = {
-  name: "availableFields",
-  api: "/{{servicePrefix}}/{{orgName}}/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-broker → data-source}/http-template/getClientActions.js

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

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

@@ -1,17 +1,17 @@
 let getSelectedFields = {
-  name: "selectedFields",
-  api: "/{{servicePrefix}}/{{orgName}}/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}/index.js

@@ -7,7 +7,7 @@ import getSelectedFields from "./http-template/getSelectedFields";
 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,
@@ -18,5 +18,5 @@ let record = {
     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-broker/adapters/controllers/DataBrokerExecutorController.js → zdata-source/adapters/controllers/DataSourceExecutorController.js}

@@ -1,5 +1,5 @@
 import AbstractController from "./AbstractController";
-export default class DataBrokerExecutorController 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 "../../applications/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/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/applications/entities-factory/DataBrokerFactory.js → zdata-source/applications/entities-factory/DataSourceFactory.js}

@@ -1,10 +1,9 @@
 import APITemplatesFactory from "./APITemplatesFactory";
-import DataBroker from "../../domain/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/InputDependencies.js

@@ -0,0 +1 @@
+export {};