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

package/es/desk-frameworks/table-connected/frameworks/ListSdkFactory.js

@@ -1,4 +1,6 @@
+import { LIST_SELECTION_DESELECT_ITEM, LIST_SELECTION_SELECT_ITEM } from "../../../bc/list-selection/Constants";
 import { ZLIST_DELETE_RECORD, ZLIST_DELETE_RECORDS, ZLIST_RECORD_UPDATE } from "../../../bc/zlist/Constants";
+import { RECORD_LOCAL_MULTIPLE_DELETE, RECORD_LOCAL_UPDATE } from "../../../bc/zrecord/Constants";
 /* eslint-disable max-lines-per-function */
 
 export default class ListSdkFactory {
@@ -21,25 +23,84 @@ export default class ListSdkFactory {
           return (_state$behaviours2 = state.behaviours) === null || _state$behaviours2 === void 0 ? void 0 : (_state$behaviours2$zr = _state$behaviours2.zrecord.records) === null || _state$behaviours2$zr === void 0 ? void 0 : _state$behaviours2$zr.find(r => r.id === recordId);
         },
 
+        getContext(variableName) {
+          var _state$properties;
+
+          const {
+            departmentId,
+            viewId,
+            moduleName
+          } = state.properties;
+          const {
+            servicePrefix,
+            ...context
+          } = (_state$properties = state.properties) === null || _state$properties === void 0 ? void 0 : _state$properties.context;
+          const updatedContext = { ...context,
+            departmentId,
+            viewId,
+            moduleName
+          };
+          return variableName ? context === null || context === void 0 ? void 0 : context[variableName] : updatedContext;
+        },
+
         deleteRecord(recordId) {
+          let output = {
+            data: [{
+              id: recordId,
+              Success: true,
+              error: null
+            }]
+          };
           dispatch({
             type: ZLIST_DELETE_RECORD,
             payload: {
               recordId
             }
           });
+          return output;
         },
 
+        // deleteRecords(recordIds) {
+        //   dispatch({
+        //     type: ZLIST_DELETE_RECORDS,
+        //     payload: {
+        //       recordIds
+        //     }
+        //   });
+        // },
         deleteRecords(recordIds) {
+          let shouldFetch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+          let output = {
+            data: []
+          };
+          let DELETE_ACTION = shouldFetch ? ZLIST_DELETE_RECORDS : RECORD_LOCAL_MULTIPLE_DELETE;
           dispatch({
-            type: ZLIST_DELETE_RECORDS,
+            type: DELETE_ACTION,
             payload: {
               recordIds
             }
           });
+
+          for (let recordId of recordIds) {
+            let recordUpdateDetail = {
+              id: recordId,
+              Success: true,
+              error: null
+            };
+            output.data.push(recordUpdateDetail);
+          }
+
+          return output;
         },
 
         updateRecord(recordId, record) {
+          let output = {
+            results: [{
+              id: recordId,
+              Success: true,
+              error: null
+            }]
+          };
           dispatch({
             type: ZLIST_RECORD_UPDATE,
             payload: {
@@ -47,8 +108,63 @@ export default class ListSdkFactory {
               record
             }
           });
-        }
+          return output;
+        },
 
+        updateRecords(recordsMap) {
+          let shouldFetch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+          let output = {
+            results: []
+          };
+          let UPDATE_ACTION = shouldFetch ? ZLIST_RECORD_UPDATE : RECORD_LOCAL_UPDATE;
+
+          for (let record of recordsMap) {
+            dispatch({
+              type: UPDATE_ACTION,
+              payload: {
+                recordId: record.id,
+                record: record
+              }
+            });
+            let recordUpdateDetail = {
+              id: record.id,
+              Success: true,
+              error: null
+            };
+            output.results.push(recordUpdateDetail);
+          }
+
+          return output;
+        },
+
+        selectRecords: ids => {
+          dispatch({
+            type: LIST_SELECTION_SELECT_ITEM,
+            payload: {
+              ids
+            }
+          });
+        },
+        deselectRecords: ids => {
+          dispatch({
+            type: LIST_SELECTION_DESELECT_ITEM,
+            payload: {
+              ids
+            }
+          });
+        },
+        selectAllRecords: () => {
+          dispatch({
+            type: LIST_SELECTION_SELECT_ITEM,
+            payload: {}
+          });
+        },
+        deselectAllRecords: () => {
+          dispatch({
+            type: LIST_SELECTION_DESELECT_ITEM,
+            payload: {}
+          });
+        }
       }
     };
   }

package/es/desk-frameworks/table-connected/frameworks/TableConnectedFactory.js

@@ -7,26 +7,46 @@ import ZListBehaviourFactory from "../../../platform/zlist/frameworks/ZListBehav
 import RecordBehaviourFactory from "../../../platform/zrecord/frameworks/RecordBehaviourFactory";
 import EventHandlersFactory from "./EventHandlersFactory";
 import TableConnectedView from "./TableConnectedView";
-import defaultDataBroker from "../../../platform/data-broker";
-import DataBrokerBehaviourFactory from "../../../platform/zdata-broker/frameworks/DataBrokerBehaviourFactory";
+import defaultDataSource from "../../../platform/data-source";
+import DataSourceBehaviourFactory from "../../../platform/zdata-source/frameworks/DataBrokerBehaviourFactory";
+import ClientActionsBehaviourFactory from "../../../platform/client-actions/behaviour/zclient-actions/frameworks/ClientActionsBehaviourFactory";
+import LocalStorageBehaviourFactory from "../../../library/behaviours/local-storage/frameworks/LocalStorageBehaviourFactory";
+import TableColumnResizerBehaviorFactory from "../../../library/behaviours/table-column-resizer/frameworks/TableColumnResizerBehaviorFactory";
+import ListItemSelectionBehaviourFactory from "../../../library/behaviours/list-selection/frameworks/ListItemSelectionBehaviourFactory";
 export default class TableConnectedFactory {
   static create(_ref) {
+    var _dataSource2;
+
     let {
       name,
-      dataBroker = defaultDataBroker,
+      dataBroker,
+      dataSource,
       eventHandlers = {},
       View = TableConnectedView
     } = _ref;
+
+    if (dataBroker) {
+      console.warn('Desk Platform Warning: dataBroker is deprecated, use dataSource instead');
+      dataSource = dataBroker;
+    }
+
+    const _dataSource = { ...dataSource,
+      httpTemplates: { ...defaultDataSource.httpTemplates,
+        ...((_dataSource2 = dataSource) === null || _dataSource2 === void 0 ? void 0 : _dataSource2.httpTemplates)
+      }
+    };
     return createCustomComponent({
       name: name,
       View: View,
       properties: Properties,
       eventHandlers: EventHandlersFactory.create(eventHandlers),
       transformState: TableTranslator.transformState,
-      behaviours: [ZHttpBehaviourFactory.create(), DataBrokerBehaviourFactory.create(), RecordBehaviourFactory.create(dataBroker.httpTemplates), ZFieldBehaviourFactory.create({
-        availableFields: dataBroker.httpTemplates.getAvailableFields,
-        selectedFields: dataBroker.httpTemplates.getSelectedFields
-      }), ZListBehaviourFactory.create()]
+      behaviours: [TableColumnResizerBehaviorFactory.create(), LocalStorageBehaviourFactory.create(), ZHttpBehaviourFactory.create(), DataSourceBehaviourFactory.create(), RecordBehaviourFactory.create(_dataSource.httpTemplates), ClientActionsBehaviourFactory.create({
+        getClientActions: _dataSource.httpTemplates.getClientActions
+      }), ZFieldBehaviourFactory.create({
+        availableFields: _dataSource.httpTemplates.getAvailableFields,
+        selectedFields: _dataSource.httpTemplates.getSelectedFields
+      }), ZListBehaviourFactory.create(), ListItemSelectionBehaviourFactory.create()]
     });
   }
 

package/es/desk-frameworks/table-connected/frameworks/TableConnectedView.js

@@ -9,27 +9,37 @@ function View(_ref, ref) {
   const {
     isLoading,
     data = [],
-    hasRowActions,
+    rowActionsConfig,
+    rowCursor,
+    selection,
     properties,
     emptyStateUiType
   } = state;
-  return /*#__PURE__*/React.createElement("div", {
-    style: {
-      height: '100%',
-      width: '100%'
-    },
-    ref: ref
-  }, /*#__PURE__*/React.createElement(TableList, {
+  const {
+    resizerState
+  } = state;
+  const {
+    preferences,
+    selectionConfig
+  } = properties;
+  const {
+    autoColumnSizing
+  } = preferences || {};
+  return /*#__PURE__*/React.createElement(TableList, {
     data: data,
-    hasRowActions: hasRowActions,
-    isFlexibleColumns: properties.isFlexibleColumns,
+    rowCursor: rowCursor,
+    resizerState: resizerState,
+    getRef: ref,
+    isFlexibleColumns: autoColumnSizing,
+    rowActionsConfig: rowActionsConfig,
     isLoading: isLoading,
     emptyStateUiType: emptyStateUiType,
-    selectionConfig: properties.selectionConfig
-  }));
+    selection: selection,
+    selectionConfig: selectionConfig
+  });
 }
 
 export default View;
 View.propTypes = {
-  state: PropTypes.string
+  state: PropTypes.object
 };

package/es/index.js

@@ -4,7 +4,6 @@ import * as _BC from "./bc";
 export { _BC as BC };
 export { TableConnectedFactory } from "./desk-frameworks";
 export { ComponentRegistry, createCustomComponent } from "./library";
-import * as _TableFieldComponents from "./library/dot/legacy-to-new-arch/table-field-components";
-export { _TableFieldComponents as TableFieldComponents };
+export { default as TableFieldComponents } from "./library/dot/legacy-to-new-arch/table-field-components";
 import * as _Components from "./library/dot/legacy-to-new-arch";
 export { _Components as Components };

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

@@ -0,0 +1,9 @@
+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;