@zohodesk/library-platform 1.1.3 → 1.1.6-temp-1

package/es/platform/sdk-behaviour/adapters/controllers/InitializeController.js

@@ -0,0 +1,19 @@
+import { AbstractController } from "./AbstractController";
+export class InitializeController extends AbstractController {
+  handle(_ref) {
+    let {
+      state
+    } = _ref;
+    const {
+      service
+    } = this;
+    const instanceName = state.properties.instanceName;
+    const {
+      createResourceInstanceUseCase
+    } = service;
+    createResourceInstanceUseCase.execute({
+      instanceName
+    });
+  }
+
+}

package/es/platform/sdk-behaviour/adapters/controllers/SyncStateWithResourceController.js

@@ -0,0 +1,24 @@
+import { AbstractController } from "./AbstractController";
+export class SyncStateWithResourceController extends AbstractController {
+  handle(_ref) {
+    let {
+      state,
+      dispatch,
+      updateState
+    } = _ref;
+    const {
+      service
+    } = this;
+    const instanceName = state.properties.instanceName;
+    const {
+      syncStateWithResourceUseCase
+    } = service;
+    syncStateWithResourceUseCase.execute({
+      instanceName,
+      state,
+      dispatch,
+      updateState: updateState
+    });
+  }
+
+}

package/es/platform/sdk-behaviour/adapters/gateways/Repository.js

@@ -0,0 +1,25 @@
+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 { BehaviourResourceConnector } from "../../domain/entities/BehaviourResourceConnector";
+export class Repository {
+  constructor() {
+    _defineProperty(this, "resourceNames", void 0);
+
+    _defineProperty(this, "resourceManager", void 0);
+  }
+
+  init(resourceNames, resourceManager) {
+    this.resourceNames = resourceNames;
+    this.resourceManager = resourceManager;
+  }
+
+  getBehaviourResourceConnector() {
+    const {
+      resourceNames,
+      resourceManager
+    } = this;
+    const behaviourResourceConnector = new BehaviourResourceConnector(resourceNames, resourceManager);
+    return behaviourResourceConnector;
+  }
+
+}

package/es/platform/sdk-behaviour/adapters/gateways/ResourceManagerGateWay.js

@@ -0,0 +1,43 @@
+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; }
+
+export class ResourceManagerGateWay {
+  constructor() {
+    _defineProperty(this, "sdkRegistry", void 0);
+  }
+
+  init(sdkRegistry) {
+    this.sdkRegistry = sdkRegistry;
+  }
+
+  createResourceInstance(resourceName, instanceName) {
+    this.sdkRegistry.createResourceInstance({
+      resourceName,
+      instanceName
+    });
+  }
+
+  destructResourceInstance(resourceName, instanceName) {
+    this.sdkRegistry.destructResourceInstance({
+      resourceName,
+      instanceName
+    });
+  }
+
+  syncStateWithResource(_ref) {
+    let {
+      resourceName,
+      instanceName,
+      state,
+      dispatch,
+      updateState
+    } = _ref;
+    this.sdkRegistry.syncStateWithResource({
+      resourceName,
+      instanceName,
+      state,
+      dispatch,
+      updateState
+    });
+  }
+
+}

package/es/platform/sdk-behaviour/adapters/gateways/Service.js

@@ -0,0 +1,19 @@
+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 { CreateResourceInstanceUseCase } from "../../applications/usecases/CreateResourceInstanceUseCase";
+import { DestructResourceInstanceUseCase } from "../../applications/usecases/DestructResourceInstanceUseCase";
+import { SyncStateWithResourceUseCase } from "../../applications/usecases/SyncStateWithResourceUseCase";
+export class Service {
+  constructor(dependencies) {
+    _defineProperty(this, "createResourceInstanceUseCase", void 0);
+
+    _defineProperty(this, "destructResourceInstanceUseCase", void 0);
+
+    _defineProperty(this, "syncStateWithResourceUseCase", void 0);
+
+    this.createResourceInstanceUseCase = new CreateResourceInstanceUseCase(dependencies);
+    this.destructResourceInstanceUseCase = new DestructResourceInstanceUseCase(dependencies);
+    this.syncStateWithResourceUseCase = new SyncStateWithResourceUseCase(dependencies);
+  }
+
+}

package/es/platform/sdk-behaviour/applications/AbstractUseCase.js

@@ -0,0 +1,6 @@
+export default class AbstractUseCase {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+
+}

package/es/platform/sdk-behaviour/applications/interfaces/UsecaseDependencies.js

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

package/es/platform/sdk-behaviour/applications/interfaces/gateways/IRepository.js

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

package/es/platform/sdk-behaviour/applications/interfaces/gateways/IResourceManagerGateWay.js

@@ -0,0 +1,3 @@
+import { StateInterface, DispatchFunction, UpdateState } from "../../../../sdk/domain/entities/interfaces/StateInterface"; //
+
+export { StateInterface, DispatchFunction, UpdateState };

package/es/platform/sdk-behaviour/applications/interfaces/gateways/IService.js

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

package/es/platform/sdk-behaviour/applications/interfaces/input/CreateResourceInstanceUseCaseInputModel.js

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

package/es/platform/sdk-behaviour/applications/interfaces/input/DestructResourceInstanceUseCaseInputModel.js

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

package/es/platform/sdk-behaviour/applications/interfaces/input/SyncStateWithResourceUseCaseInputModel.js

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

package/es/platform/sdk-behaviour/applications/usecases/CreateResourceInstanceUseCase.js

@@ -0,0 +1,14 @@
+import AbstractUseCase from "../AbstractUseCase";
+export class CreateResourceInstanceUseCase extends AbstractUseCase {
+  execute(_ref) {
+    let {
+      instanceName
+    } = _ref;
+    const {
+      repository
+    } = this.dependencies;
+    const behaviourResourceConnector = repository.getBehaviourResourceConnector();
+    behaviourResourceConnector.createResourceInstances(instanceName);
+  }
+
+}

package/es/platform/sdk-behaviour/applications/usecases/DestructResourceInstanceUseCase.js

@@ -0,0 +1,14 @@
+import AbstractUseCase from "../AbstractUseCase";
+export class DestructResourceInstanceUseCase extends AbstractUseCase {
+  execute(_ref) {
+    let {
+      instanceName
+    } = _ref;
+    const {
+      repository
+    } = this.dependencies;
+    const behaviourResourceConnector = repository.getBehaviourResourceConnector();
+    behaviourResourceConnector.destructResourceInstances(instanceName);
+  }
+
+}

package/es/platform/sdk-behaviour/applications/usecases/SyncStateWithResourceUseCase.js

@@ -0,0 +1,22 @@
+import AbstractUseCase from "../AbstractUseCase";
+export class SyncStateWithResourceUseCase extends AbstractUseCase {
+  execute(_ref) {
+    let {
+      instanceName,
+      state,
+      dispatch,
+      updateState
+    } = _ref;
+    const {
+      repository
+    } = this.dependencies;
+    const behaviourResourceConnector = repository.getBehaviourResourceConnector();
+    behaviourResourceConnector.syncStateWithResources({
+      instanceName,
+      state,
+      dispatch,
+      updateState
+    });
+  }
+
+}

package/es/platform/sdk-behaviour/domain/entities/BehaviourResourceConnector.js

@@ -0,0 +1,49 @@
+export class BehaviourResourceConnector {
+  constructor(resourceNames, resourceManager) {
+    this.resourceNames = resourceNames;
+    this.resourceManager = resourceManager;
+  }
+
+  createResourceInstances(instanceName) {
+    const {
+      resourceNames,
+      resourceManager
+    } = this;
+    resourceNames.forEach(resourceName => {
+      resourceManager.createResourceInstance(resourceName, instanceName);
+    });
+  }
+
+  destructResourceInstances(instanceName) {
+    const {
+      resourceNames,
+      resourceManager
+    } = this;
+    resourceNames.forEach(resourceName => {
+      resourceManager.destructResourceInstance(resourceName, instanceName);
+    });
+  }
+
+  syncStateWithResources(_ref) {
+    let {
+      instanceName,
+      state,
+      dispatch,
+      updateState
+    } = _ref;
+    const {
+      resourceNames,
+      resourceManager
+    } = this;
+    resourceNames.forEach(resourceName => {
+      resourceManager.syncStateWithResource({
+        resourceName,
+        instanceName,
+        state,
+        dispatch,
+        updateState
+      });
+    });
+  }
+
+}

package/es/platform/sdk-behaviour/domain/entities/interfaces/IBehaviourResourceConnector.js

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

package/es/platform/sdk-behaviour/domain/entities/interfaces/IResourceManagerProxy.js

@@ -0,0 +1,2 @@
+import { StateInterface, DispatchFunction, UpdateState } from "../../../../sdk/domain/entities/interfaces/StateInterface";
+export { StateInterface, DispatchFunction, UpdateState };

package/es/platform/sdk-behaviour/frameworks/EventHandlerFactory.js

@@ -0,0 +1,29 @@
+import LifeCycleEvents from "../../../cc/component/LifeCycleEventsEnum";
+import { Repository } from "../adapters/gateways/Repository";
+import { Service } from "../adapters/gateways/Service";
+import { InitializeController } from "../adapters/controllers/InitializeController";
+import { DestructController } from "../adapters/controllers/DestructController";
+import { SyncStateWithResourceController } from "../adapters/controllers/SyncStateWithResourceController";
+import { ResourceManagerGateWay } from "../adapters/gateways/ResourceManagerGateWay";
+import { sdkRegistry } from "../../sdk/frameworks/SdkRegistry";
+
+class EventHandlerFactory {
+  static create(resourceNames) {
+    const resourceManager = new ResourceManagerGateWay();
+    resourceManager.init(sdkRegistry);
+    const repository = new Repository();
+    repository.init(resourceNames, resourceManager);
+    const dependencies = {
+      repository
+    };
+    const service = new Service(dependencies);
+    return {
+      [LifeCycleEvents.MOUNT]: new InitializeController(service).handle,
+      [LifeCycleEvents.STATE_UPDATED]: new SyncStateWithResourceController(service).handle,
+      [LifeCycleEvents.UN_MOUNT]: new DestructController(service).handle
+    };
+  }
+
+}
+
+export default EventHandlerFactory;

package/es/platform/sdk-behaviour/frameworks/SdkBehaviourFactory.js

@@ -0,0 +1,16 @@
+import SdkProperties from "../../../bc/sdk/Properties";
+import EventHandlerFactory from "./EventHandlerFactory";
+
+class SdkBehaviourFactory {
+  static create(resourceNames) {
+    return {
+      name: 'sdkBehaviour',
+      setInitialState: () => ({}),
+      eventHandlers: EventHandlerFactory.create(resourceNames),
+      properties: SdkProperties
+    };
+  }
+
+}
+
+export default SdkBehaviourFactory;

package/es/platform/zdata-source/domain/entities/DataSource.js

@@ -76,21 +76,27 @@ export default class DataSource {
     const {
       actionName
     } = fullMetaData;
-    const {
-      type,
-      metaData
-    } = fullMetaData[DATA_SOURCE_FAILURE];
     const actions = [];
-    type && actions.push({
-      type,
-      metaData,
-      payload: {
-        error
-      }
-    });
+    let failureMetaData = {};
+
+    if (fullMetaData[DATA_SOURCE_FAILURE]) {
+      const {
+        type,
+        metaData
+      } = fullMetaData[DATA_SOURCE_FAILURE];
+      failureMetaData = metaData;
+      type && actions.push({
+        type,
+        metaData: failureMetaData,
+        payload: {
+          error
+        }
+      });
+    }
+
     actions.push({
       type: DATA_SOURCE_EXECUTE_FAILED,
-      metaData,
+      metaData: failureMetaData,
       payload: {
         actionName,
         error

package/es/platform/zfield/domain/entities/fields-manager/FieldsManager.js

@@ -1,7 +1,7 @@
 import { FIELD_FETCH_FAILURE, FIELD_FETCH_NO_CONTENT, FIELD_FETCH_SUCCESS } from "../../../../../bc/zfield/Constants";
 import FieldApiName from "../interfaces/FieldApiName";
 import { DATA_SOURCE_EXECUTE } from "../../../../../bc/zdata-source/Constants";
-import { DATA_SOURCE_SUCCESS } from "../../../../../bc/zdata-source/Symbols";
+import { DATA_SOURCE_FAILURE, DATA_SOURCE_SUCCESS } from "../../../../../bc/zdata-source/Symbols";
 
 class FieldManager {
   constructor(fields, selectedFields, isFieldsFetching, isSelectedFieldsFetching) {
@@ -52,6 +52,12 @@ class FieldManager {
           metaData: {
             apiName
           }
+        },
+        [DATA_SOURCE_FAILURE]: {
+          metaData: {
+            apiName,
+            actionName: apiName
+          }
         }
       }
     };

package/es/platform/zform/adapters/controllers/FieldValueChangeController.js

@@ -5,16 +5,23 @@ class FieldValueChangeController extends AbstractController {
     const {
       fieldValueChangeRequestUseCase
     } = this.service;
-    let {
+    const {
       state,
       updateState,
       action,
       dispatch
     } = event;
+    const {
+      fieldName,
+      value,
+      sectionId
+    } = action.payload;
     fieldValueChangeRequestUseCase.updateDependency(state, updateState);
     fieldValueChangeRequestUseCase.execute({
-      fieldName: action.payload.fieldName,
-      newValue: action.payload.newValue
+      fieldName,
+      newValue: value,
+      sectionId,
+      dispatch
     });
   }
 

package/es/platform/zform/adapters/presenter/FormTranslator.js

@@ -1,181 +1,47 @@
-let fieldTypeToUIType = {
-  Text: 'TextBox',
-  Textarea: 'TextArea',
-  Boolean: 'Checkbox',
-  URL: 'Url',
-  Picklist: 'PickList',
-  AutoNumber: 'TextBox',
-  Number: 'Number',
-  Decimal: 'Decimal',
-  Email: 'Email',
-  Phone: 'Phone',
-  Currency: 'Currency',
-  Percent: 'Percentage',
-  Date: 'Date',
-  DateTime: 'DateTime',
-  Multiselect: 'MultiSelect',
-  LookUp: 'TextBox'
-};
-const ePHIFields = {
-  Text: true,
-  Textarea: true,
-  URL: true,
-  Picklist: true,
-  Number: true,
-  Decimal: true,
-  Email: false,
-  Phone: true,
-  Currency: false,
-  Percent: true,
-  AutoNumber: false,
-  Date: false,
-  DateTime: false,
-  Multiselect: false,
-  Boolean: false,
-  LookUp: false
-};
+import SectionTranslator from "./translators/SectionTranslator";
 export default class FormTranslator {
   static transformState(state) {
-    let uiMapping = state.properties.uiMapping;
+    const {
+      componentMapping,
+      context
+    } = state.properties;
+    const {
+      zform
+    } = state.behaviours;
+    const {
+      isMyFormFetching,
+      isDependencyFetching,
+      isLayoutRulesFetching,
+      isValidationRulesFetching,
+      sections
+    } = zform;
+    const isLoading = isMyFormFetching || isDependencyFetching || isLayoutRulesFetching || isValidationRulesFetching;
 
-    if (state.behaviours.zform.isMyFormFetching || state.behaviours.zform.isDependencyFetching || state.behaviours.zform.isLayoutRulesFetching || state.behaviours.zform.isValidationRulesFetching) {
+    if (isLoading) {
       return { ...state,
         viewModel: {
           isLoading: true
         }
       };
-    } else {
-      let sections = state.behaviours.zform.sections.map(section => {
-        return {
-          type: uiMapping.sections[section.id],
-          id: section.id + '',
-          title: section.i18NLabel,
-          description: '',
-          //section.description,
-          isVisible: section.visibility,
-          fields: section.fields.map(field => {
-            let type = uiMapping.fields[field.apiName] || fieldTypeToUIType[field.type];
-
-            if (field.type == 'DateTime' || field.type == 'Date') {
-              let value = field.value;
-              return {
-                id: field.id,
-                label: field.i18NLabel,
-                type,
-                value: value || '',
-                //state.behaviours.zform.values[field.apiName],
-                name: field.apiName,
-                // placeholder: field.i18NLabel,//field.placeholder,
-                required: field.isMandatory,
-                isVisible: field.visibility
-              };
-            } else if (field.type == 'Picklist') {
-              let value = field.value;
-              let errorMessage = field.errorMessage || '';
-              return {
-                id: field.id,
-                label: field.i18NLabel,
-                options: field.pickListValues.map(picklistValue => {
-                  return {
-                    value: picklistValue.value,
-                    label: picklistValue.value
-                  };
-                }),
-                type,
-                subType: field.subType.toLowerCase(),
-                value: value || '',
-                //state.behaviours.zform.values[field.apiName],
-                name: field.apiName,
-                // placeholder: field.i18NLabel,//field.placeholder,
-                required: field.isMandatory,
-                isVisible: field.visibility,
-                errorMessage
-              };
-            } else if (field.type == 'Multiselect') {
-              let value = field.value;
-              let errorMessage = field.errorMessage || '';
-              return {
-                id: field.id,
-                label: field.i18NLabel,
-                options: field.pickListValues ? field.pickListValues.map(picklistValue => {
-                  return {
-                    value: picklistValue.value,
-                    label: picklistValue.value
-                  };
-                }) : [],
-                type,
-                subType: field.subType,
-                value: value || [],
-                //state.behaviours.zform.values[field.apiName],
-                name: field.apiName,
-                // placeholder: field.i18NLabel,//field.placeholder,
-                required: field.isMandatory,
-                isVisible: field.visibility,
-                errorMessage
-              };
-            } else if (field.type == 'Boolean') {
-              let value = field.value;
-              return {
-                id: field.id,
-                label: field.i18NLabel,
-                type,
-                value: value || false,
-                name: field.apiName,
-                // placeholder: field.i18NLabel,//field.placeholder,
-                required: field.isMandatory,
-                isVisible: field.visibility
-              };
-            } else if (field.type == 'Text') {
-              let value = field.value;
-              let errorMessage = field.errorMessage || '';
-              return {
-                type,
-                value: value || '',
-                //state.behaviours.zform.values[field.apiName],
-                name: field.apiName,
-                id: field.id,
-                label: field.i18NLabel,
-                tooltip: '',
-                //field.tooltip,
-                ePHI: false,
-                //field.ePHI,
-                placeholder: field.i18NLabel,
-                //field.placeholder,
-                required: field.isMandatory,
-                isVisible: field.visibility,
-                errorMessage
-              };
-            } else {
-              let value = field.value;
-              let errorMessage = field.errorMessage || '';
-              const fieldModified = {
-                type,
-                value: value || '',
-                //state.behaviours.zform.values[field.apiName],
-                name: field.apiName,
-                id: field.id,
-                label: field.i18NLabel,
-                tooltip: '',
-                //field.tooltip,
-                placeholder: field.i18NLabel,
-                //field.placeholder,
-                required: field.isMandatory,
-                isVisible: field.visibility,
-                errorMessage
-              };
-
-              if (ePHIFields[field.type]) {
-                fieldModified.ePHI = true;
-              }
+    }
 
-              return fieldModified;
-            }
-          })
-        };
-      });
+    if (isLoading) {
+      return { ...state,
+        viewModel: {
+          isLoading: true
+        }
+      };
+    } else {
       return { ...state,
         viewModel: {
-          sections,
+          sections: sections.map(section => {
+            const sectionViewModel = SectionTranslator({
+              section,
+              componentMapping,
+              context
+            });
+            return sectionViewModel;
+          }),
           isLoading: false
         }
       };

package/es/platform/zform/adapters/presenter/translators/SectionTranslator.js

@@ -0,0 +1,41 @@
+import { DefaultFormSectionUIType, fieldTypeToUIType } from "../../../../../cc/fields/field/FormDefaultUIType";
+import * as FieldTranslators from "./fields";
+
+function SectionTranslator(_ref) {
+  let {
+    section,
+    componentMapping,
+    context
+  } = _ref;
+  const mapping = componentMapping.sections[section.name];
+  const defaultViewModel = {
+    type: mapping !== null && mapping !== void 0 && mapping.UIComponentName ? mapping.UIComponentName : DefaultFormSectionUIType,
+    id: section.id + '',
+    name: section.name,
+    title: section.i18NLabel,
+    description: section.description,
+    isCollapsed: section.isCollapsed,
+    isVisible: section.isVisible,
+    fields: section.fields.map(field => {
+      var _componentMapping$fie;
+
+      const fieldTranslator = FieldTranslators[field.type];
+      const type = (componentMapping === null || componentMapping === void 0 ? void 0 : (_componentMapping$fie = componentMapping.fields) === null || _componentMapping$fie === void 0 ? void 0 : _componentMapping$fie[field.apiName]) || fieldTypeToUIType[field.type];
+      return fieldTranslator({
+        field,
+        type
+      });
+    })
+  };
+
+  if (mapping !== null && mapping !== void 0 && mapping.translator) {
+    return mapping.translator({
+      section: defaultViewModel,
+      context
+    });
+  }
+
+  return defaultViewModel;
+}
+
+export default SectionTranslator;