@zohodesk/library-platform 1.1.1 → 1.1.2-exp.0

package/es/platform/data-source/http-template/getClientActions.js

@@ -4,7 +4,7 @@ let getClientActions = {
   parameters: `{
         "from":{{from}},
         "limit":{{limit}},
-        "library": "{{library}}",
+        "component": "{{component}}",
         "module": "{{moduleName}}"
     }`,
   type: 'GET',

package/es/platform/data-source/http-template/updateSelectedFields.js

@@ -0,0 +1,28 @@
+const updateSelectedFields = {
+  name: 'selectedFields',
+  api: '/{{servicePrefix}}/{{orgName}}/api/v1/views/{{viewId}}/selectedFields',
+  parameters: `{}`,
+  type: 'PUT',
+  requestBody: '{"fields": {{fields}}}',
+  transformer: res => res.fields,
+  properties: {
+    viewId: {
+      required: true,
+      typeMetadata: {
+        schema: {
+          type: 'string'
+        }
+      }
+    },
+    departmentId: {
+      required: true,
+      defaultValue: 1,
+      typeMetadata: {
+        schema: {
+          type: 'number'
+        }
+      }
+    }
+  }
+};
+export default updateSelectedFields;

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

@@ -7,15 +7,29 @@ import getSelectedFields from "./http-template/getSelectedFields";
 import getClientActions from "./http-template/getClientActions";
 import { RecordApiActionName } from "../../bc/zrecord/Constants";
 import deleteRecord from "./http-template/deleteRecord";
+import fetchMyLayouts from "./http-template/fetchMyFormLayout";
+import fetchMyForm from "./http-template/fetchMyForm";
+import fetchLayoutRules from "./http-template/fetchLayoutRules";
+import fetchDependencyMappings from "./http-template/fetchDependencyMappings";
+import fetchValidationRules from "./http-template/fetchValidationRules";
+import createRecord from "./http-template/createRecord";
+import updateSelectedFields from "./http-template/updateSelectedFields";
 let dataSource = {
   httpTemplates: {
     [RecordApiActionName.GET_RECORDS]: getRecords,
     [RecordApiActionName.UPDATE_RECORD]: updateRecord,
     [RecordApiActionName.DELETE_RECORDS]: deleteRecords,
     [RecordApiActionName.DELETE_RECORD]: deleteRecord,
+    [RecordApiActionName.CREATE_RECORD]: createRecord,
     [RecordApiActionName.GET_CLIENTACTIONS]: getClientActions,
     getAvailableFields,
-    getSelectedFields
+    getSelectedFields,
+    updateSelectedFields,
+    fetchMyLayouts,
+    fetchMyForm,
+    fetchLayoutRules,
+    fetchDependencyMappings,
+    fetchValidationRules
   }
 };
 export default dataSource; // let ticketsRecordSerice = createRecord(tickets, () => {});

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

@@ -67,12 +67,13 @@ class APITemplate {
     };
 
     if (this.getResponseInTemplate) {
-      apiDetails.getResponse = () => {
+      apiDetails.getResponse = headers => {
         const payload = JSON.parse(this.getPayloadString(obj));
         const params = JSON.parse(this.getParameter(obj));
         return this.getResponseInTemplate({
           payload,
-          params
+          params,
+          headers
         });
       };
     }

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

@@ -61,7 +61,7 @@ class FieldManager {
     const {
       apiName
     } = metaData;
-    return apiName === 'availableFields' || apiName === 'selectedFields';
+    return apiName === 'availableFields' || apiName === 'selectedFields' || apiName === FieldApiName.UPDATE_SELECTED_FIELDS;
   }
 
   startFetching(apiName) {
@@ -85,6 +85,8 @@ class FieldManager {
       this.fields = data;
     } else if (apiName === FieldApiName.SELECTED_FIELDS) {
       this.selectedFields = data;
+    } else if (apiName === FieldApiName.UPDATE_SELECTED_FIELDS) {
+      this.selectedFields = data;
     }
   }
 

package/es/platform/zfield/domain/entities/interfaces/FieldApiName.js

@@ -1,6 +1,7 @@
 var FieldApiName = /*#__PURE__*/function (FieldApiName) {
   FieldApiName["AVAILABLE_FIELDS"] = "availableFields";
   FieldApiName["SELECTED_FIELDS"] = "selectedFields";
+  FieldApiName["UPDATE_SELECTED_FIELDS"] = "updateSelectedFields";
   return FieldApiName;
 }(FieldApiName || {});
 

package/es/platform/zfield/frameworks/ZFieldBehaviourFactory.js

@@ -4,7 +4,12 @@ class ZFieldBehaviourFactory {
   static create(apiTemplates) {
     return {
       name: 'zfield',
-      setInitialState: () => ({}),
+      setInitialState: () => ({
+        fields: [],
+        selectedFields: [],
+        isFieldsFetching: false,
+        isSelectedFieldsFetching: false
+      }),
       eventHandlers: ActionHandlerFactory.create(apiTemplates),
       properties: {}
     };

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

@@ -0,0 +1,10 @@
+class AbstractController {
+  constructor(service) {
+    this.service = service;
+    this.handle = this.handle.bind(this);
+  } // TODO: Add event type
+
+
+}
+
+export default AbstractController;

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

@@ -0,0 +1,23 @@
+import AbstractController from "./AbstractController";
+
+class DependenciesController extends AbstractController {
+  handle(event) {
+    const {
+      dependenciesSuccessUseCase
+    } = this.service;
+    let {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    dependenciesSuccessUseCase.updateDependency(state, updateState);
+    dependenciesSuccessUseCase.execute({
+      dispatch,
+      dependencies: action.payload.response ? action.payload.response.data : []
+    });
+  }
+
+}
+
+export default DependenciesController;

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

@@ -0,0 +1,20 @@
+import AbstractController from "./AbstractController";
+
+class DependenciesRequestController extends AbstractController {
+  handle(event) {
+    const {
+      dependenciesRequestUseCase
+    } = this.service;
+    let {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    dependenciesRequestUseCase.updateDependency(state, updateState);
+    dependenciesRequestUseCase.execute();
+  }
+
+}
+
+export default DependenciesRequestController;

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

@@ -0,0 +1,23 @@
+import AbstractController from "./AbstractController";
+
+class FieldValueChangeController extends AbstractController {
+  handle(event) {
+    const {
+      fieldValueChangeRequestUseCase
+    } = this.service;
+    let {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    fieldValueChangeRequestUseCase.updateDependency(state, updateState);
+    fieldValueChangeRequestUseCase.execute({
+      fieldName: action.payload.fieldName,
+      newValue: action.payload.newValue
+    });
+  }
+
+}
+
+export default FieldValueChangeController;

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

@@ -0,0 +1,22 @@
+import AbstractController from "./AbstractController";
+
+class FormSubmitController extends AbstractController {
+  handle(event) {
+    const {
+      formSubmitUseCase
+    } = this.service;
+    let {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    formSubmitUseCase.updateDependency(state, updateState);
+    formSubmitUseCase.execute({
+      dispatch
+    });
+  }
+
+}
+
+export default FormSubmitController;

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

@@ -0,0 +1,28 @@
+import AbstractController from "./AbstractController";
+
+class InitializeController extends AbstractController {
+  handle(event) {
+    const {
+      initializeUseCase
+    } = this.service;
+    let {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    const {
+      moduleName,
+      departmentId
+    } = state.properties;
+    initializeUseCase.updateDependency(state, updateState);
+    initializeUseCase.execute({
+      dispatch,
+      moduleName,
+      departmentId
+    });
+  }
+
+}
+
+export default InitializeController;

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

@@ -0,0 +1,20 @@
+import AbstractController from "./AbstractController";
+
+class LayoutRulesRequestController extends AbstractController {
+  handle(event) {
+    const {
+      layoutRulesRequestUseCase
+    } = this.service;
+    let {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    layoutRulesRequestUseCase.updateDependency(state, updateState);
+    layoutRulesRequestUseCase.execute();
+  }
+
+}
+
+export default LayoutRulesRequestController;

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

@@ -0,0 +1,22 @@
+import AbstractController from "./AbstractController";
+
+class LayoutRulesSuccessController extends AbstractController {
+  handle(event) {
+    const {
+      layoutRulesSuccessUseCase
+    } = this.service;
+    let {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    layoutRulesSuccessUseCase.updateDependency(state, updateState);
+    layoutRulesSuccessUseCase.execute({
+      layoutRules: action.payload.response.data
+    });
+  }
+
+}
+
+export default LayoutRulesSuccessController;

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

@@ -0,0 +1,20 @@
+import AbstractController from "./AbstractController";
+
+class MyFormRequestController extends AbstractController {
+  handle(event) {
+    const {
+      myFormRequestUseCase
+    } = this.service;
+    let {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    myFormRequestUseCase.updateDependency(state, updateState);
+    myFormRequestUseCase.execute();
+  }
+
+}
+
+export default MyFormRequestController;

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

@@ -0,0 +1,23 @@
+import AbstractController from "./AbstractController";
+
+class MyFormSuccessController extends AbstractController {
+  handle(event) {
+    const {
+      myFormSuccessUseCase
+    } = this.service;
+    let {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    myFormSuccessUseCase.updateDependency(state, updateState);
+    myFormSuccessUseCase.execute({
+      dispatch,
+      myForm: action.payload.response
+    });
+  }
+
+}
+
+export default MyFormSuccessController;

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

@@ -0,0 +1,29 @@
+import AbstractController from "./AbstractController";
+
+class MyLayoutSuccessController extends AbstractController {
+  handle(event) {
+    const {
+      myLayoutSuccessUseCase
+    } = this.service;
+    let {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    const {
+      disableValidationRule,
+      disableLayoutRule
+    } = state.properties;
+    myLayoutSuccessUseCase.updateDependency(state, updateState);
+    myLayoutSuccessUseCase.execute({
+      dispatch,
+      layouts: action.payload.response.data,
+      disableValidationRule,
+      disableLayoutRule
+    });
+  }
+
+}
+
+export default MyLayoutSuccessController;

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

@@ -0,0 +1,22 @@
+import AbstractController from "./AbstractController";
+
+class SetFieldErrorMessageController extends AbstractController {
+  handle(event) {
+    const {
+      setFieldErrorMessageUseCase
+    } = this.service;
+    const {
+      state,
+      updateState,
+      action
+    } = event;
+    setFieldErrorMessageUseCase.updateDependency(state, updateState);
+    setFieldErrorMessageUseCase.execute({
+      fieldApiName: action.payload.fieldApiName,
+      errorMessage: action.payload.errorMessage
+    });
+  }
+
+}
+
+export default SetFieldErrorMessageController;

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

@@ -0,0 +1,22 @@
+import AbstractController from "./AbstractController";
+
+class ValidateErrorMessageController extends AbstractController {
+  handle(event) {
+    const {
+      validateErrorMessageUseCase
+    } = this.service;
+    let {
+      state,
+      action,
+      updateState,
+      dispatch
+    } = event;
+    validateErrorMessageUseCase.updateDependency(state, updateState);
+    validateErrorMessageUseCase.execute({
+      dispatch
+    });
+  }
+
+}
+
+export default ValidateErrorMessageController;

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

@@ -0,0 +1,23 @@
+import AbstractController from "./AbstractController";
+
+class ValidateFieldRequestController extends AbstractController {
+  handle(event) {
+    const {
+      validateFieldRequestUseCase
+    } = this.service;
+    let {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    validateFieldRequestUseCase.updateDependency(state, updateState);
+    validateFieldRequestUseCase.execute({
+      fieldName: action.payload.fieldName,
+      dispatch
+    });
+  }
+
+}
+
+export default ValidateFieldRequestController;

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

@@ -0,0 +1,20 @@
+import AbstractController from "./AbstractController";
+
+class ValidationRulesRequestController extends AbstractController {
+  handle(event) {
+    const {
+      validationRulesRequestUseCase
+    } = this.service;
+    let {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    validationRulesRequestUseCase.updateDependency(state, updateState);
+    validationRulesRequestUseCase.execute();
+  }
+
+}
+
+export default ValidationRulesRequestController;

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

@@ -0,0 +1,23 @@
+import AbstractController from "./AbstractController";
+
+class ValidationRulesSuccessController extends AbstractController {
+  handle(event) {
+    const {
+      validationRulesSuccessUseCase
+    } = this.service;
+    let {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    validationRulesSuccessUseCase.updateDependency(state, updateState);
+    validationRulesSuccessUseCase.execute({
+      dispatch,
+      validationRules: action.payload.response.data
+    });
+  }
+
+}
+
+export default ValidationRulesSuccessController;

package/es/platform/zform/adapters/gateway/FormRepository.js

@@ -0,0 +1,79 @@
+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 ZValidationRule from "../../domain/ZValidationRule";
+import ZForm from "../../domain/ZForm";
+import ZSection from "../../domain/ZSection";
+import ZField from "../../domain/ZField";
+import ZLayoutRule from "../../domain/ZLayoutRule";
+import ZDependencyMapping from "../../domain/ZDependencyMapping";
+
+class FormRepository {
+  constructor() {
+    _defineProperty(this, "state", void 0);
+  }
+
+  init(state) {
+    this.state = state;
+  }
+
+  getFormEntity() {
+    const {
+      moduleName,
+      departmentId,
+      context
+    } = this.state.properties;
+    let {
+      zform
+    } = this.state.behaviours;
+    let {
+      validationRules = [],
+      sections = [],
+      layoutRules = [],
+      dependencyMappings = []
+    } = zform;
+    let validationRuleEntities = validationRules.map(rule => {
+      return new ZValidationRule(rule);
+    });
+    let layoutRulesEntities = layoutRules.map(rule => {
+      return new ZLayoutRule(rule);
+    });
+    let sectionEntities = sections.map(section => {
+      let fields = section.fields.map(field => {
+        return new ZField(field);
+      });
+      let sectionWithFields = { ...section,
+        fields
+      };
+      return new ZSection(sectionWithFields);
+    });
+    let dependencyMappingsEntities = dependencyMappings.map(dependencyMapping => {
+      return new ZDependencyMapping(dependencyMapping);
+    });
+    let zformEntitiy = new ZForm({
+      modifiedTime: zform.modifiedTime,
+      isStandardLayout: zform.isStandardLayout,
+      hasLogo: zform.hasLogo,
+      departmentId: zform.isMyFormFetching ? departmentId : zform.departmentId,
+      module: zform.isMyFormFetching ? moduleName : zform.module,
+      layoutDisplayName: zform.layoutDisplayName,
+      layoutDesc: zform.layoutDesc,
+      isDefaultLayout: zform.isDefaultLayout,
+      sections: sectionEntities,
+      validationRules: validationRuleEntities,
+      dependencyMappings: dependencyMappingsEntities,
+      layoutRules: layoutRulesEntities,
+      context,
+      isMyFormFetching: zform.isMyFormFetching,
+      isDependencyFetching: zform.isDependencyFetching,
+      isLayoutRulesFetching: zform.isLayoutRulesFetching,
+      isValidationRulesFetching: zform.isValidationRulesFetching
+    });
+    return zformEntitiy; // new ZField()
+    // new ZSection()
+    // new ZForm()
+    // return this.state.behaviours.zform;
+  }
+
+}
+
+export default FormRepository;

package/es/platform/zform/adapters/gateway/Service.js

@@ -0,0 +1,68 @@
+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 FormSubmitUseCase from "../../applications/usecases/FormSubmitUseCase";
+import InitializeUseCase from "../../applications/usecases/InitializeUseCase";
+import MyLayoutSuccessUseCase from "../../applications/usecases/MyLayoutSuccessUseCase";
+import MyFormSuccessUseCase from "../../applications/usecases/MyFormSuccessUseCase";
+import DependenciesSuccessUseCase from "../../applications/usecases/DependenciesSuccessUseCase";
+import MyFormRequestUseCase from "../../applications/usecases/MyFormRequestUseCase";
+import LayoutRulesRequestUseCase from "../../applications/usecases/LayoutRulesRequestUseCase";
+import LayoutRulesSuccessUseCase from "../../applications/usecases/LayoutRulesSuccessUseCase";
+import ValidationRulesRequestUseCase from "../../applications/usecases/ValidationRulesRequestUseCase";
+import ValidationRulesSuccessUseCase from "../../applications/usecases/ValidationRulesSuccessUseCase";
+import FieldValueChangeRequestUseCase from "../../applications/usecases/FieldValueChangeRequestUseCase";
+import ValidateFieldRequestUseCase from "../../applications/usecases/ValidateFieldRequestUseCase";
+import SetFieldErrorMessageUseCase from "../../applications/usecases/SetFieldErrorMessageUseCase";
+import ValidateErrorMessageUseCase from "../../applications/usecases/ValidateErrorMessageUseCase";
+
+class Service {
+  constructor(dependencies) {
+    _defineProperty(this, "formSubmitUseCase", void 0);
+
+    _defineProperty(this, "initializeUseCase", void 0);
+
+    _defineProperty(this, "myLayoutSuccessUseCase", void 0);
+
+    _defineProperty(this, "myFormSuccessUseCase", void 0);
+
+    _defineProperty(this, "myFormRequestUseCase", void 0);
+
+    _defineProperty(this, "dependenciesRequestUseCase", void 0);
+
+    _defineProperty(this, "dependenciesSuccessUseCase", void 0);
+
+    _defineProperty(this, "layoutRulesRequestUseCase", void 0);
+
+    _defineProperty(this, "layoutRulesSuccessUseCase", void 0);
+
+    _defineProperty(this, "validationRulesRequestUseCase", void 0);
+
+    _defineProperty(this, "validationRulesSuccessUseCase", void 0);
+
+    _defineProperty(this, "fieldValueChangeRequestUseCase", void 0);
+
+    _defineProperty(this, "validateFieldRequestUseCase", void 0);
+
+    _defineProperty(this, "setFieldErrorMessageUseCase", void 0);
+
+    _defineProperty(this, "validateErrorMessageUseCase", void 0);
+
+    this.formSubmitUseCase = new FormSubmitUseCase(dependencies);
+    this.initializeUseCase = new InitializeUseCase(dependencies);
+    this.myLayoutSuccessUseCase = new MyLayoutSuccessUseCase(dependencies);
+    this.myFormSuccessUseCase = new MyFormSuccessUseCase(dependencies);
+    this.dependenciesSuccessUseCase = new DependenciesSuccessUseCase(dependencies);
+    this.myFormRequestUseCase = new MyFormRequestUseCase(dependencies);
+    this.layoutRulesRequestUseCase = new LayoutRulesRequestUseCase(dependencies);
+    this.layoutRulesSuccessUseCase = new LayoutRulesSuccessUseCase(dependencies);
+    this.validationRulesRequestUseCase = new ValidationRulesRequestUseCase(dependencies);
+    this.validationRulesSuccessUseCase = new ValidationRulesSuccessUseCase(dependencies);
+    this.fieldValueChangeRequestUseCase = new FieldValueChangeRequestUseCase(dependencies);
+    this.validateFieldRequestUseCase = new ValidateFieldRequestUseCase(dependencies);
+    this.setFieldErrorMessageUseCase = new SetFieldErrorMessageUseCase(dependencies);
+    this.validateErrorMessageUseCase = new ValidateErrorMessageUseCase(dependencies);
+  }
+
+}
+
+export default Service;

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

@@ -0,0 +1,24 @@
+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 default class FormPresenter {
+  constructor() {
+    _defineProperty(this, "updateState", void 0);
+
+    _defineProperty(this, "state", void 0);
+  }
+
+  updateDependencies(state, updateState) {
+    this.state = state;
+    this.updateState = updateState;
+  }
+
+  updateFormResponse(outputModel) {
+    let newState = { ...this.state,
+      behaviours: { ...this.state.behaviours,
+        zform: outputModel
+      }
+    };
+    this.updateState(newState);
+  }
+
+}