@zohodesk/library-platform 1.1.9-exp.1 → 1.1.10

package/es/bc/field-validation/Constants.js

@@ -0,0 +1,4 @@
+export const VALIDATE_FIELD = 'FIELD_VALIDATION#VALIDATE_FIELD';
+export const FIELD_VALIDATION_RESULT = 'FIELD_VALIDATION#FIELD_VALIDATION_RESULT';
+export const VALIDATE_FIELDS = 'FIELD_VALIDATION#VALIDATE_FIELDS';
+export const VALIDATE_FIELDS_RESULT = 'FIELD_VALIDATION#VALIDATE_FIELDS_RESULT';

package/es/bc/field-validation/EventHandlers.js

@@ -0,0 +1 @@
+import { VALIDATE_FIELD } from "./Constants";

package/es/bc/field-validation/Events.js

@@ -0,0 +1,106 @@
+import { VALIDATE_FIELD, FIELD_VALIDATION_RESULT, VALIDATE_FIELDS, VALIDATE_FIELDS_RESULT } from "./Constants";
+const fieldMeta = {
+  type: 'object',
+  properties: {
+    name: {
+      type: 'string'
+    },
+    type: {
+      type: 'string'
+    },
+    value: {
+      type: 'any'
+    }
+  }
+};
+const Events = [{
+  type: VALIDATE_FIELD,
+  payload: {
+    fields: {
+      required: true,
+      typeMetadata: {
+        schema: {
+          type: 'array',
+          items: fieldMeta
+        }
+      }
+    }
+  }
+}, {
+  type: FIELD_VALIDATION_RESULT,
+  payload: {
+    validationResult: {
+      required: true,
+      typeMetadata: {
+        schema: {
+          type: 'object',
+          properties: {
+            isValid: {
+              type: 'boolean'
+            },
+            message: {
+              type: 'string'
+            }
+          }
+        }
+      }
+    },
+    field: {
+      required: true,
+      typeMetadata: {
+        schema: fieldMeta
+      }
+    }
+  }
+}, {
+  type: VALIDATE_FIELDS,
+  payload: {
+    fields: {
+      required: true,
+      typeMetadata: {
+        schema: fieldMeta
+      }
+    },
+    value: {
+      required: true,
+      typeMetadata: {
+        schema: {
+          type: 'any'
+        }
+      }
+    }
+  }
+}, {
+  type: VALIDATE_FIELDS_RESULT,
+  payload: {
+    validationResults: {
+      required: true,
+      typeMetadata: {
+        schema: {
+          type: 'Array',
+          items: {
+            type: 'object',
+            properties: {
+              isValid: {
+                type: 'boolean'
+              },
+              message: {
+                type: 'string'
+              }
+            }
+          }
+        }
+      }
+    },
+    fields: {
+      required: true,
+      typeMetadata: {
+        schema: {
+          type: 'array',
+          items: fieldMeta
+        }
+      }
+    }
+  }
+}];
+export default Events;

package/es/bc/field-validation/FieldTypes.js

@@ -0,0 +1,20 @@
+var FieldTypes = /*#__PURE__*/function (FieldTypes) {
+  FieldTypes["TextBox"] = "Text";
+  FieldTypes["Email"] = "Email";
+  FieldTypes["Decimal"] = "Decimal";
+  FieldTypes["Integer"] = "Integer";
+  FieldTypes["Phone"] = "Phone";
+  FieldTypes["Date"] = "Date";
+  FieldTypes["DateTime"] = "DateTime";
+  FieldTypes["Boolean"] = "Boolean";
+  FieldTypes["MultiSelect"] = "MultiSelect";
+  FieldTypes["Picklist"] = "Picklist";
+  FieldTypes["Percent"] = "Percent";
+  FieldTypes["Currency"] = "Currency";
+  FieldTypes["URL"] = "URL";
+  FieldTypes["LookUp"] = "LookUp";
+  FieldTypes["TextArea"] = "TextArea";
+  return FieldTypes;
+}(FieldTypes || {});
+
+export default FieldTypes;

package/es/bc/field-validation/Properties.js

@@ -0,0 +1,11 @@
+export default {
+  validations: {
+    required: false,
+    defaultValue: {},
+    typeMetadata: {
+      schema: {
+        type: 'object'
+      }
+    }
+  }
+};

package/es/bc/field-validation/index.js

@@ -0,0 +1,5 @@
+import Properties from "./Properties";
+import * as Constants from "./Constants";
+import Events from "./Events";
+import EventHandlers from "./EventHandlers";
+export { Properties, Constants, Events, EventHandlers };

package/es/cc/ephi-tag/Properties.js

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

package/es/cc/ephi-tag/index.js

@@ -0,0 +1 @@
+export { default as EPHITagProperties } from "./Properties";

package/es/cc/info-icon/Properties.js

@@ -0,0 +1,10 @@
+export default {
+  tooltip: {
+    required: true,
+    typeMetadata: {
+      schema: {
+        type: 'string'
+      }
+    }
+  }
+};

package/es/cc/info-icon/index.js

@@ -0,0 +1 @@
+export { default as InfoIconProperties } from "./Properties";

package/es/{platform/app-context-behaviour → library/behaviours/field-validation}/adapters/controllers/AbstractController.js

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

package/es/library/behaviours/field-validation/adapters/controllers/ValidateFieldController.js

@@ -0,0 +1,32 @@
+import AbstractController from "./AbstractController";
+
+class ValidateFieldController extends AbstractController {
+  handle(event) {
+    const {
+      validateFieldUseCase
+    } = this.service;
+    const {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    const {
+      field,
+      value
+    } = action.payload;
+    const {
+      metadata
+    } = action;
+    validateFieldUseCase.updateDependencies(state, updateState);
+    validateFieldUseCase.execute({
+      field,
+      value,
+      dispatch,
+      metadata
+    });
+  }
+
+}
+
+export default ValidateFieldController;

package/es/library/behaviours/field-validation/adapters/controllers/ValidateFieldsController.js

@@ -0,0 +1,31 @@
+import AbstractController from "./AbstractController";
+
+class ValidateFieldsController extends AbstractController {
+  handle(event) {
+    const {
+      validateFieldsUseCase
+    } = this.service;
+    const {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    const {
+      fields,
+      value
+    } = action.payload;
+    const {
+      metadata
+    } = action;
+    validateFieldsUseCase.updateDependencies(state, updateState);
+    validateFieldsUseCase.execute({
+      fields,
+      dispatch,
+      metadata
+    });
+  }
+
+}
+
+export default ValidateFieldsController;

package/es/library/behaviours/field-validation/adapters/gateway/Repository.js

@@ -0,0 +1,23 @@
+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 FieldValidation from "../../domain/FieldValidation";
+export default class Repository {
+  constructor() {
+    _defineProperty(this, "state", void 0);
+  }
+
+  init(state) {
+    this.state = state;
+  }
+
+  getFieldValidationEntity() {
+    const {
+      properties
+    } = this.state;
+    const {
+      validations: validationsMap
+    } = properties;
+    return new FieldValidation(validationsMap);
+  }
+
+}

package/es/library/behaviours/field-validation/adapters/gateway/Service.js

@@ -0,0 +1,18 @@
+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 ValidateField from "../../applications/usecases/ValidateField";
+import ValidateFields from "../../applications/usecases/ValidateFields";
+
+class Service {
+  constructor(dependencies) {
+    _defineProperty(this, "validateFieldUseCase", void 0);
+
+    _defineProperty(this, "validateFieldsUseCase", void 0);
+
+    this.validateFieldUseCase = new ValidateField(dependencies);
+    this.validateFieldsUseCase = new ValidateFields(dependencies);
+  }
+
+}
+
+export default Service;

package/es/library/behaviours/field-validation/applications/interfaces/input/FieldData.js

@@ -0,0 +1,17 @@
+var FieldTypes = /*#__PURE__*/function (FieldTypes) {
+  FieldTypes["TextBox"] = "Text";
+  FieldTypes["Email"] = "Email";
+  FieldTypes["Decimal"] = "Decimal";
+  FieldTypes["Integer"] = "Integer";
+  FieldTypes["Phone"] = "Phone";
+  FieldTypes["Date"] = "Date";
+  FieldTypes["DateTime"] = "DateTime";
+  FieldTypes["Boolean"] = "Boolean";
+  FieldTypes["MultiSelect"] = "MultiSelect";
+  FieldTypes["Picklist"] = "Picklist";
+  FieldTypes["Percent"] = "Percent";
+  FieldTypes["Currency"] = "Currency";
+  FieldTypes["URL"] = "URL";
+  FieldTypes["TextArea"] = "TextArea";
+  return FieldTypes;
+}(FieldTypes || {});

package/es/library/behaviours/field-validation/applications/usecases/AbstractUseCase.js

@@ -0,0 +1,15 @@
+class AbstractUseCase {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+
+  updateDependencies(state, updateState) {
+    const {
+      repository
+    } = this.dependencies;
+    repository.init(state);
+  }
+
+}
+
+export default AbstractUseCase;

package/es/library/behaviours/field-validation/applications/usecases/ValidateField.js

@@ -0,0 +1,29 @@
+import { FIELD_VALIDATION_RESULT } from "../../../../../bc/field-validation/Constants";
+import AbstractUseCase from "./AbstractUseCase";
+
+class ValidateField extends AbstractUseCase {
+  execute(input) {
+    const {
+      field,
+      value,
+      dispatch,
+      metadata
+    } = input;
+    const {
+      repository
+    } = this.dependencies;
+    const fieldValidation = repository.getFieldValidationEntity();
+    const validationResult = fieldValidation.validateField(field, value);
+    dispatch({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult,
+        field
+      },
+      metadata
+    });
+  }
+
+}
+
+export default ValidateField;

package/es/library/behaviours/field-validation/applications/usecases/ValidateFields.js

@@ -0,0 +1,28 @@
+import { VALIDATE_FIELDS_RESULT } from "../../../../../bc/field-validation/Constants";
+import AbstractUseCase from "./AbstractUseCase";
+
+class ValidateFields extends AbstractUseCase {
+  execute(input) {
+    const {
+      fields,
+      dispatch,
+      metadata
+    } = input;
+    const {
+      repository
+    } = this.dependencies;
+    const fieldValidation = repository.getFieldValidationEntity();
+    const validationResults = fieldValidation.validateFields(fields);
+    dispatch({
+      type: VALIDATE_FIELDS_RESULT,
+      payload: {
+        validationResults,
+        fields
+      },
+      metadata
+    });
+  }
+
+}
+
+export default ValidateFields;

package/es/library/behaviours/field-validation/domain/FieldValidation.js

@@ -0,0 +1,94 @@
+import FieldTypes from "./interfaces/FieldTypes";
+import TextBoxValidation from "./field-vise-validations/TextBoxValidation";
+import TextAreaValidation from "./field-vise-validations/TextAreaValidation";
+import EmailValidation from "./field-vise-validations/EmailValidation";
+import CurrencyValidation from "./field-vise-validations/CurrencyValidation";
+import DecimalValidation from "./field-vise-validations/DecimalValidation";
+import BooleanValidation from "./field-vise-validations/BooleanValidation";
+import DateTimeValidation from "./field-vise-validations/DateTimeValidation";
+import DateValidation from "./field-vise-validations/DateValidation";
+import IntegerValidation from "./field-vise-validations/IntegerValidation";
+import MultiSelectValidation from "./field-vise-validations/MultiSelectValidation";
+import PercentValidation from "./field-vise-validations/PercentValidation";
+import PicklistValidation from "./field-vise-validations/PicklistValidation";
+import URLValidation from "./field-vise-validations/URLValidation";
+import PhoneValidation from "./field-vise-validations/PhoneValidation";
+import LookUpValidation from "./field-vise-validations/LookUpValidation";
+const fieldValidationMap = {
+  [FieldTypes.TextBox]: new TextBoxValidation(),
+  [FieldTypes.TextArea]: new TextAreaValidation(),
+  [FieldTypes.Email]: new EmailValidation(),
+  [FieldTypes.Currency]: new CurrencyValidation(),
+  [FieldTypes.Decimal]: new DecimalValidation(),
+  [FieldTypes.Integer]: new IntegerValidation(),
+  [FieldTypes.Phone]: new PhoneValidation(),
+  [FieldTypes.Date]: new DateValidation(),
+  [FieldTypes.DateTime]: new DateTimeValidation(),
+  [FieldTypes.Boolean]: new BooleanValidation(),
+  [FieldTypes.MultiSelect]: new MultiSelectValidation(),
+  [FieldTypes.Picklist]: new PicklistValidation(),
+  [FieldTypes.LookUp]: new LookUpValidation(),
+  [FieldTypes.Percent]: new PercentValidation(),
+  [FieldTypes.URL]: new URLValidation()
+};
+
+class FieldValidation {
+  constructor(validationsMap) {
+    this.validationsMap = validationsMap;
+  }
+
+  validateField(field, value) {
+    const validations = this.getFieldValidations(field);
+    return this.run(validations, value);
+  }
+
+  validateFields(fields) {
+    return fields.map(field => {
+      const validations = this.getFieldValidations(field);
+      return this.run(validations, field.value);
+    });
+  }
+
+  getFieldValidations(field) {
+    const {
+      type: fieldType
+    } = field;
+    const validator = fieldValidationMap[fieldType];
+
+    if (validator) {
+      return validator.getFieldValidations(field);
+    }
+
+    return [];
+  }
+
+  run(validations, value) {
+    const {
+      validationsMap
+    } = this;
+    const validationResults = validations.map(_ref => {
+      let {
+        methodName,
+        config
+      } = _ref;
+      return validationsMap[methodName](value, config);
+    });
+    return this.getValidationResult(validationResults);
+  }
+
+  getValidationResult(validationResults) {
+    let validationResult = {
+      isValid: true,
+      message: ''
+    };
+    validationResults.forEach(result => {
+      if (!result.isValid && validationResult.isValid) {
+        validationResult = result;
+      }
+    });
+    return validationResult;
+  }
+
+}
+
+export default FieldValidation;

package/es/library/behaviours/field-validation/domain/field-vise-validations/BooleanValidation.js

@@ -0,0 +1,28 @@
+import ValidationsEnum from "../interfaces/ValidationsEnum";
+
+class BooleanValidation {
+  getFieldValidations(field) {
+    const {
+      required
+    } = field;
+    const validations = [];
+    validations.push({
+      methodName: ValidationsEnum.boolean,
+      config: {}
+    });
+
+    if (required) {
+      validations.push({
+        methodName: ValidationsEnum.mandatory,
+        config: {
+          type: field.type
+        }
+      });
+    }
+
+    return validations;
+  }
+
+}
+
+export default BooleanValidation;

package/es/library/behaviours/field-validation/domain/field-vise-validations/CurrencyValidation.js

@@ -0,0 +1,49 @@
+import ValidationsEnum from "../interfaces/ValidationsEnum";
+
+class CurrencyValidation {
+  getFieldValidations(field) {
+    const {
+      required,
+      maxLength,
+      decimalPlaces
+    } = field;
+    const validations = [];
+
+    if (maxLength) {
+      validations.push({
+        methodName: ValidationsEnum.maxLength,
+        config: {
+          maxLength
+        }
+      });
+    }
+
+    if (decimalPlaces) {
+      validations.push({
+        methodName: ValidationsEnum.decimalPlaces,
+        config: {
+          decimalPlaces
+        }
+      });
+    }
+
+    validations.push({
+      methodName: ValidationsEnum.decimal,
+      config: {}
+    });
+
+    if (required) {
+      validations.push({
+        methodName: ValidationsEnum.mandatory,
+        config: {
+          type: field.type
+        }
+      });
+    }
+
+    return validations;
+  }
+
+}
+
+export default CurrencyValidation;

package/es/library/behaviours/field-validation/domain/field-vise-validations/DateTimeValidation.js

@@ -0,0 +1,24 @@
+import ValidationsEnum from "../interfaces/ValidationsEnum";
+
+class DateTimeValidation {
+  getFieldValidations(field) {
+    const validations = [];
+    const {
+      required
+    } = field;
+
+    if (required) {
+      validations.push({
+        methodName: ValidationsEnum.mandatory,
+        config: {
+          type: field.type
+        }
+      });
+    }
+
+    return validations;
+  }
+
+}
+
+export default DateTimeValidation;

package/es/library/behaviours/field-validation/domain/field-vise-validations/DateValidation.js

@@ -0,0 +1,24 @@
+import ValidationsEnum from "../interfaces/ValidationsEnum";
+
+class DateValidation {
+  getFieldValidations(field) {
+    const validations = [];
+    const {
+      required
+    } = field;
+
+    if (required) {
+      validations.push({
+        methodName: ValidationsEnum.mandatory,
+        config: {
+          type: field.type
+        }
+      });
+    }
+
+    return validations;
+  }
+
+}
+
+export default DateValidation;

package/es/library/behaviours/field-validation/domain/field-vise-validations/DecimalValidation.js

@@ -0,0 +1,49 @@
+import ValidationsEnum from "../interfaces/ValidationsEnum";
+
+class DecimalValidation {
+  getFieldValidations(field) {
+    const {
+      required,
+      maxLength,
+      decimalPlaces
+    } = field;
+    const validations = [];
+
+    if (maxLength) {
+      validations.push({
+        methodName: ValidationsEnum.maxLength,
+        config: {
+          maxLength
+        }
+      });
+    }
+
+    if (decimalPlaces) {
+      validations.push({
+        methodName: ValidationsEnum.decimalPlaces,
+        config: {
+          decimalPlaces
+        }
+      });
+    }
+
+    validations.push({
+      methodName: ValidationsEnum.decimal,
+      config: {}
+    });
+
+    if (required) {
+      validations.push({
+        methodName: ValidationsEnum.mandatory,
+        config: {
+          type: field.type
+        }
+      });
+    }
+
+    return validations;
+  }
+
+}
+
+export default DecimalValidation;