@zohodesk/library-platform 1.0.0 → 1.0.2-exp.3

package/es/platform/client-actions/components/row-actions-renderer/frameworks/ui/RowActionsRendererView.js

@@ -0,0 +1,25 @@
+import React from 'react';
+import Flex from '@zohodesk/layout/es/Flex/Flex';
+import DynamicActionComponent from "../../../dynamic-component/frameworks/ui/DynamicActionComponent";
+
+function RowActionsRendererView(_ref, ref) {
+  let {
+    state
+  } = _ref;
+  const {
+    actions
+  } = state.properties;
+  return /*#__PURE__*/React.createElement(Flex, {
+    ref: ref,
+    $ui_displayMode: "inline",
+    $ui_alignItems: "center"
+  }, actions.map((action, index) => {
+    return /*#__PURE__*/React.createElement(DynamicActionComponent, {
+      action: action,
+      key: index
+    });
+  }));
+}
+
+;
+export default RowActionsRendererView;

package/es/platform/client-actions/template-resolver/index.js

@@ -0,0 +1,44 @@
+export default class TemplateResolver {
+  static getPathValue(path, obj) {
+    return path.split('.').reduce(function (prev, curr) {
+      return prev !== undefined ? prev[curr] : undefined;
+    }, obj);
+  }
+
+  static replaceContextVariables(inputString, replacementObj) {
+    return inputString.replace(/{{(.*?)}}/g, (match, key) => {
+      let value = this.getPathValue(key.trim(), replacementObj);
+
+      if (Array.isArray(value) || value instanceof Object) {
+        return JSON.stringify(value);
+      }
+
+      return value !== undefined ? value.toString() : match;
+    });
+  }
+
+  static isOnlyContextVariables(inputString) {
+    return /^{{(.*?)}}$/.test(inputString);
+  }
+
+  static replaceContextVariablesInObject(properties, replacementObj) {
+    const replaced = {};
+    Object.entries(properties).forEach(_ref => {
+      let [key, value] = _ref;
+
+      if (typeof value === 'string' && this.isOnlyContextVariables(value)) {
+        const path = value.replace(/{{(.*?)}}/g, '$1');
+        const pathValue = this.getPathValue(path, replacementObj);
+        replaced[key] = pathValue !== undefined ? pathValue : `{{${path}}}`;
+      } else if (typeof value === 'string' && value.includes('{{')) {
+        replaced[key] = this.replaceContextVariables(value, replacementObj);
+      } else if (typeof value === 'object' && value !== null) {
+        replaced[key] = this.replaceContextVariablesInObject(value, replacementObj);
+      } else {
+        replaced[key] = value;
+      }
+    });
+    return Array.isArray(properties) ? Object.values(replaced) : replaced;
+  }
+
+}

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/data-broker/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/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/http-template/getAvailableFields.js

@@ -1,6 +1,6 @@
 let getAvailableFields = {
   name: "availableFields",
-  api: "/api/v1/views/availableFields",
+  api: "/{{servicePrefix}}/{{orgName}}/api/v1/views/availableFields",
   parameters: `{
         "departmentId":"{{departmentId}}",
         "module":"{{moduleName}}"

package/es/platform/data-broker/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/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/http-template/getSelectedFields.js

@@ -1,6 +1,6 @@
 let getSelectedFields = {
   name: "selectedFields",
-  api: "/api/v1/views/{{viewId}}/selectedFields",
+  api: "/{{servicePrefix}}/{{orgName}}/api/v1/views/{{viewId}}/selectedFields",
   parameters: `{
         "departmentId":"{{departmentId}}"
     }`,

package/es/platform/data-broker/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/index.js

@@ -4,7 +4,7 @@ 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 = {
@@ -13,9 +13,9 @@ let record = {
     [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, () => {});

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

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

package/es/platform/zdata-broker/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 DataBrokerFactory from "../../applications/entities-factory/DataBrokerFactory";
 export default class Repository {
   constructor() {
     _defineProperty(this, "state", void 0);