@zohodesk/library-platform 1.1.7-exp.2 → 1.1.8-exp.1

package/es/platform/components/form-connected/frameworks/EventHandlersFactory.js

@@ -1,12 +1,14 @@
 import SmartFormConstants from "../../../../cc/form-connected/Constants";
 import FormSdkFactory from "./FormSdkFactory";
 import FormConstants from "../../../../cc/form/Constants";
-import { ZFORM_FIELD_VALUE_CHANGED } from "../../../../bc/zform/Symbol";
+import { ZFORM_FIELD_BLURRED, ZFORM_FIELD_VALUE_CHANGED, ZFORM_SUBMIT_SUCCESS, ZFORM_SUBMIT_VALIDATION_FAILURE } from "../../../../bc/zform/Symbol";
 import { platformSDK } from "../../../sdk/frameworks/Sdk";
 const {
   SMART_FORM_FIELD_FOCUSED,
   SMART_FORM_FIELD_BLURRED,
-  SMART_FORM_FIELD_VALUE_CHANGED
+  SMART_FORM_FIELD_VALUE_CHANGED,
+  SMART_FORM_SUBMIT_SUCCESS,
+  SMART_FORM_SUBMIT_FAILURE
 } = SmartFormConstants; // function createHandlerWithSdk(handler) {
 //   return input => {
 //     const { state, dispatch } = input;
@@ -36,62 +38,32 @@ export default class EventHandlersFactory {
     }));
   }
 
+  static createEventMappedHandler(eventName) {
+    return _ref => {
+      let {
+        action,
+        dispatch
+      } = _ref;
+      dispatch({
+        type: eventName,
+        payload: action.payload
+      });
+    };
+  }
+
+  static getEventMappedHandlers() {
+    return {
+      [FormConstants.FORM_FIELD_FOCUSED]: EventHandlersFactory.createEventMappedHandler(SMART_FORM_FIELD_FOCUSED),
+      [ZFORM_FIELD_BLURRED]: EventHandlersFactory.createEventMappedHandler(SMART_FORM_FIELD_BLURRED),
+      [ZFORM_SUBMIT_SUCCESS]: EventHandlersFactory.createEventMappedHandler(SMART_FORM_SUBMIT_SUCCESS),
+      [ZFORM_SUBMIT_VALIDATION_FAILURE]: EventHandlersFactory.createEventMappedHandler(SMART_FORM_SUBMIT_FAILURE),
+      [ZFORM_FIELD_VALUE_CHANGED]: EventHandlersFactory.createEventMappedHandler(SMART_FORM_FIELD_VALUE_CHANGED)
+    };
+  }
+
   static create(eventHandlers) {
     const wrapped = EventHandlersFactory.createWrapped(eventHandlers);
-    return {
-      [FormConstants.FORM_FIELD_FOCUSED]: _ref => {
-        let {
-          action,
-          dispatch
-        } = _ref;
-        const {
-          sectionId,
-          fieldName
-        } = action.payload;
-        dispatch({
-          type: SMART_FORM_FIELD_FOCUSED,
-          payload: {
-            sectionId,
-            fieldName
-          }
-        });
-      },
-      [FormConstants.FORM_FIELD_BLURRED]: _ref2 => {
-        let {
-          action,
-          dispatch
-        } = _ref2;
-        const {
-          sectionId,
-          fieldName
-        } = action.payload;
-        dispatch({
-          type: SMART_FORM_FIELD_BLURRED,
-          payload: {
-            sectionId,
-            fieldName
-          }
-        });
-      },
-      [ZFORM_FIELD_VALUE_CHANGED]: _ref3 => {
-        let {
-          action,
-          dispatch
-        } = _ref3;
-        const {
-          sectionId,
-          fieldName,
-          value
-        } = action.payload;
-        dispatch({
-          type: SMART_FORM_FIELD_VALUE_CHANGED,
-          payload: {
-            sectionId,
-            fieldName,
-            value
-          }
-        });
-      },
+    return { ...EventHandlersFactory.getEventMappedHandlers(),
       ...wrapped
     };
   }

package/es/platform/components/form-connected/frameworks/FormConnectedFactory.js

@@ -7,7 +7,6 @@ import defaultDataSource from "../../../data-source";
 import DataBrokerBehaviourFactory from "../../../zdata-source/frameworks/DataBrokerBehaviourFactory";
 import FormTranslator from "../../../zform/adapters/presenter/FormTranslator";
 import ZFormBehaviourFactory from "../../../zform/frameworks/ui/ZFormBehaviourFactory";
-import FieldValidationBehaviourFactory from "../../../../library/behaviours/field-validation/frameworks/ui/FieldValidationBehaviourFactory";
 import EventHandlersfactory from "./EventHandlersFactory";
 import SdkBehaviourFactory from "../../../sdk-behaviour/frameworks/SdkBehaviourFactory";
 import ResourceNamesEnum from "../../../../bc/sdk/ResourceNamesEnum";
@@ -32,7 +31,6 @@ export default class FormConnectedFactory {
   static create(_ref) {
     let {
       name,
-      customValidators,
       dataSource,
       eventHandlers = {},
       View = FormConnectedView
@@ -48,9 +46,7 @@ export default class FormConnectedFactory {
       transformState: FormTranslator.transformState,
       behaviours: [SdkBehaviourFactory.create([ResourceNamesEnum.SMART_FORM]), ClientActionsBehaviourFactory.create({
         getClientActions: _dataSource.httpTemplates.getClientActions
-      }), ZHttpBehaviourFactory.create(), DataBrokerBehaviourFactory.create(), RecordBehaviourFactory.create(_dataSource.httpTemplates), FieldValidationBehaviourFactory.create(), ZFormBehaviourFactory.create({
-        customValidators
-      })]
+      }), ZHttpBehaviourFactory.create(), DataBrokerBehaviourFactory.create(), RecordBehaviourFactory.create(_dataSource.httpTemplates), ZFormBehaviourFactory.create()]
     });
   }
 

package/es/platform/components/form-connected/frameworks/FormConnectedView.js

@@ -9,6 +9,7 @@ function View(_ref, ref) {
   const {
     isLoading,
     sections = [],
+    rightPanel,
     isHeaderEnabled,
     isFooterEnabled,
     headerLeftActions,
@@ -25,7 +26,8 @@ function View(_ref, ref) {
     headerLeftActions: headerLeftActions,
     headerRightActions: headerRightActions,
     footerLeftActions: footerLeftActions,
-    footerRightActions: footerRightActions
+    footerRightActions: footerRightActions,
+    rightPanel: rightPanel
   });
 }
 

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

@@ -1,6 +1,6 @@
 const deleteRecords = {
   name: 'records',
-  api: '/{{servicePrefix}}/{{orgName}}/api/v1/{{moduleName}}/moveToTrash',
+  api: '/{{servicePrefix}}/{{orgName}}/api/v1/records/deleteMany',
   parameters: `{}`,
   type: 'POST',
   transformer: data => data,

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

@@ -1,10 +1,11 @@
 // Assuming GetTemplate interface is similar to PatchTemplate
+import { transFormValidationRules } from "../utils/validation-rules/TransFormValidationRules";
 const fetchValidationRules = {
   name: 'fetchValidationRules',
   api: '/{{servicePrefix}}/{{orgName}}/api/v1/layouts/{{layoutId}}/validationRules',
   parameters: `{"activeRulesOnly":{{activeRulesOnly}}}`,
   type: 'GET',
-  transformer: data => data,
+  transformer: transFormValidationRules,
   properties: {
     layoutId: {
       required: true,

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

@@ -0,0 +1,28 @@
+const moveToTrash = {
+  name: 'records',
+  api: '/{{servicePrefix}}/{{orgName}}/api/v1/{{moduleName}}/moveToTrash',
+  parameters: `{}`,
+  type: 'POST',
+  transformer: data => data,
+  requestBody: '{ "recordIds": {{recordIds}} }',
+  // REVIEW: Is `entityIds` applicable to all modules? To be confirmed with backend team
+  properties: {
+    moduleName: {
+      required: true,
+      typeMetadata: {
+        schema: {
+          type: 'string'
+        }
+      }
+    },
+    recordIds: {
+      required: true,
+      typeMetadata: {
+        schema: {
+          type: 'array'
+        }
+      }
+    }
+  }
+};
+export default moveToTrash;

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

@@ -8,6 +8,7 @@ import getClientActions from "./http-template/getClientActions";
 import reOrderRecord from "./http-template/reOrderRecord";
 import { RecordApiActionName } from "../../bc/zrecord/Constants";
 import deleteRecord from "./http-template/deleteRecord";
+import moveToTrash from "./http-template/moveToTrash";
 import fetchMyLayouts from "./http-template/fetchMyFormLayout";
 import fetchMyForm from "./http-template/fetchMyForm";
 import fetchLayoutRules from "./http-template/fetchLayoutRules";
@@ -19,6 +20,7 @@ let dataSource = {
   httpTemplates: {
     [RecordApiActionName.GET_RECORDS]: getRecords,
     [RecordApiActionName.UPDATE_RECORD]: updateRecord,
+    [RecordApiActionName.MOVE_TO_TRASH]: moveToTrash,
     [RecordApiActionName.DELETE_RECORDS]: deleteRecords,
     [RecordApiActionName.DELETE_RECORD]: deleteRecord,
     [RecordApiActionName.CREATE_RECORD]: createRecord,

package/es/platform/data-source/utils/validation-rules/FieldConditions.js

@@ -0,0 +1,167 @@
+import { BooleanValidationConditions, TextValidationConditions } from "../../../zform/domain/interfaces/ValidationConditions";
+import { i18NProviderUtils } from '@zohodesk/i18n';
+import { ValidationEvents } from "../../../zform/domain/interfaces/IZForm";
+export function MandatoryCondition(field) {
+  const {
+    apiName,
+    i18NLabel,
+    isMandatory
+  } = field;
+  const mandatoryCondition = {
+    name: 'Field - Cannot be empty',
+    executeOn: [ValidationEvents.blur],
+    pattern: '1',
+    conditions: [{
+      condition: TextValidationConditions.IsEmpty,
+      // ["${NOTEMPTY}"]
+      fieldName: apiName,
+      value: ['${EMPTY}']
+    }],
+    actions: {
+      alert: i18NProviderUtils.getI18NValue('crm.field.empty.check', [i18NLabel])
+    }
+  };
+  return isMandatory ? mandatoryCondition : null;
+}
+export function BooleanMandatoryCondition(field) {
+  const {
+    apiName,
+    i18NLabel,
+    isMandatory
+  } = field;
+  const mandatoryCondition = {
+    name: 'Boolean Field - Cannot be empty',
+    executeOn: [ValidationEvents.blur],
+    pattern: '1',
+    conditions: [{
+      condition: BooleanValidationConditions.Is,
+      fieldName: apiName,
+      value: ['false']
+    }],
+    actions: {
+      alert: i18NProviderUtils.getI18NValue('crm.field.empty.check', [i18NLabel])
+    }
+  };
+  return isMandatory ? mandatoryCondition : null;
+}
+export function MaxLengthCondition(field) {
+  const {
+    apiName,
+    i18NLabel,
+    maxLength
+  } = field;
+  const maxLengthCondition = {
+    name: 'Field - Max Length Exceeded',
+    executeOn: [ValidationEvents.blur],
+    pattern: '1',
+    conditions: [{
+      condition: TextValidationConditions.IsNot,
+      fieldName: apiName,
+      value: [`maxLength:/(${btoa(`.{0,${maxLength}}`)})/`]
+    }],
+    actions: {
+      alert: i18NProviderUtils.getI18NValue('support.form.more.than.max.length', [i18NLabel, maxLength])
+    }
+  };
+  return maxLength ? maxLengthCondition : null;
+}
+export function CustomMaxLengthCondition(field) {
+  const {
+    maxLength
+  } = field;
+  const maxLengthCondition = {
+    executeOn: [ValidationEvents.blur],
+    validator: {
+      scriptId: 'maxLengthValidation'
+    }
+  };
+  return maxLength ? maxLengthCondition : null;
+}
+export function EmailCondition() {
+  return {
+    executeOn: [ValidationEvents.blur],
+    validator: {
+      scriptId: 'emailValidation'
+    }
+  };
+}
+export function PhoneCondition() {
+  return {
+    executeOn: [ValidationEvents.blur],
+    validator: {
+      scriptId: 'phoneValidation'
+    }
+  };
+}
+export function NumberCondition() {
+  return {
+    executeOn: [ValidationEvents.blur],
+    validator: {
+      scriptId: 'numberValidation'
+    }
+  };
+}
+export function DecimalCondition() {
+  return {
+    executeOn: [ValidationEvents.blur],
+    validator: {
+      scriptId: 'decimalValidation'
+    }
+  };
+}
+export function DecimalPlacesCondition(field) {
+  const {
+    decimalPlaces
+  } = field;
+  const decimalPlacesCondition = {
+    executeOn: [ValidationEvents.blur],
+    validator: {
+      scriptId: 'decimalPlacesValidation'
+    }
+  };
+  return decimalPlaces ? decimalPlacesCondition : null;
+}
+export function DateCondition() {
+  return {
+    executeOn: [ValidationEvents.blur],
+    validator: {
+      scriptId: 'dateValidation'
+    }
+  };
+}
+export function CustomMandatoryCondition(field) {
+  const {
+    isMandatory
+  } = field;
+  const mandatoryCondition = {
+    executeOn: [ValidationEvents.blur],
+    validator: {
+      scriptId: 'customMandatoryValidation'
+    }
+  };
+  return isMandatory ? mandatoryCondition : null;
+}
+export function PicklistMandatoryCondition(field) {
+  const {
+    isMandatory
+  } = field;
+  const mandatoryCondition = {
+    executeOn: [ValidationEvents.blur],
+    validator: {
+      scriptId: 'picklistMandatoryValidation'
+    }
+  };
+  return isMandatory ? mandatoryCondition : null;
+}
+export function MultiSelectMandatoryCondition(field) {
+  const {
+    isMandatory
+  } = field;
+  const mandatoryCondition = {
+    executeOn: [ValidationEvents.blur],
+    validator: {
+      scriptId: 'multiSelectMandatoryValidation'
+    }
+  };
+  return isMandatory ? mandatoryCondition : null;
+}

package/es/platform/data-source/utils/validation-rules/TransFormValidationRules.js

@@ -0,0 +1,93 @@
+import { BooleanMandatoryCondition, CustomMandatoryCondition, CustomMaxLengthCondition, DateCondition, DecimalCondition, DecimalPlacesCondition, EmailCondition, MandatoryCondition, MaxLengthCondition, MultiSelectMandatoryCondition, NumberCondition, PhoneCondition, PicklistMandatoryCondition } from "./FieldConditions";
+export function transFormValidationRules(validationRulesRes, _ref) {
+  let {
+    fields
+  } = _ref;
+  const validationRules = validationRulesRes.data;
+  const fieldValidationRules = fields.map(getBasicValidationRulesForField);
+  return {
+    data: [...fieldValidationRules, ...validationRules]
+  };
+}
+const map = {
+  Text: TextFieldConditions,
+  Textarea: TextFieldConditions,
+  Email: EmailFieldConditions,
+  URL: URLFieldConditions,
+  Phone: PhoneFieldConditions,
+  Boolean: BooleanFieldConditions,
+  Number: NumberFieldConditions,
+  Percent: PercentFieldConditions,
+  Currency: CurrencyFieldConditions,
+  Decimal: DecimalFieldConditions,
+  Date: DateFieldConditions,
+  DateTime: DateTimeFieldConditions,
+  Picklist: PicklistFieldConditions,
+  Multiselect: MultiSelectFieldConditions
+};
+export function getBasicValidationRulesForField(field) {
+  const {
+    apiName,
+    type
+  } = field;
+  const getFieldConditions = map[type];
+  return {
+    fieldName: apiName,
+    id: `vr_${apiName}_1`,
+    layoutId: '',
+    status: 'ACTIVE',
+    fieldConditions: getFieldConditions(field).filter(Boolean)
+  };
+}
+
+function TextFieldConditions(field) {
+  return [MandatoryCondition(field), MaxLengthCondition(field)];
+}
+
+function EmailFieldConditions(field) {
+  return [MandatoryCondition(field), MaxLengthCondition(field), EmailCondition()];
+}
+
+function URLFieldConditions(field) {
+  return [MandatoryCondition(field), MaxLengthCondition(field)];
+}
+
+function PhoneFieldConditions(field) {
+  return [MandatoryCondition(field), MaxLengthCondition(field), PhoneCondition()];
+}
+
+function BooleanFieldConditions(field) {
+  return [BooleanMandatoryCondition(field)];
+}
+
+function NumberFieldConditions(field) {
+  return [CustomMandatoryCondition(field), CustomMaxLengthCondition(field), NumberCondition()];
+}
+
+function DecimalFieldConditions(field) {
+  return [CustomMandatoryCondition(field), CustomMaxLengthCondition(field), DecimalCondition(), DecimalPlacesCondition(field)];
+}
+
+function CurrencyFieldConditions(field) {
+  return [CustomMandatoryCondition(field), CustomMaxLengthCondition(field), DecimalCondition(), DecimalPlacesCondition(field)];
+}
+
+function PercentFieldConditions(field) {
+  return [CustomMandatoryCondition(field), CustomMaxLengthCondition(field), DecimalCondition(), DecimalPlacesCondition(field)];
+}
+
+function DateFieldConditions(field) {
+  return [CustomMandatoryCondition(field), DateCondition()];
+}
+
+function DateTimeFieldConditions(field) {
+  return [CustomMandatoryCondition(field), DateCondition()];
+}
+
+function PicklistFieldConditions(field) {
+  return [PicklistMandatoryCondition(field)];
+}
+
+function MultiSelectFieldConditions(field) {
+  return [MultiSelectMandatoryCondition(field)];
+}

package/es/platform/zdata-source/applications/usecases/SuccessUseCase.js

@@ -18,7 +18,7 @@ class SuccessUseCase extends AbstractUseCase {
 
     if (dataSource.isMetaHasDataSourceSignature(metaData)) {
       const transformer = dataSource.getTransformer(actionName);
-      const transformedResponse = transformer(response);
+      const transformedResponse = transformer(response, metaData.transformerArg);
       const events = dataSource.createSuccessEvents(transformedResponse, metaData);
       events.forEach(action => {
         dispatch(action);

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

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

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

@@ -5,16 +5,22 @@ class MyFormSuccessController extends AbstractController {
     const {
       myFormSuccessUseCase
     } = this.service;
-    let {
+    const {
       state,
       updateState,
       action,
       dispatch
     } = event;
+    const {
+      disableValidationRule,
+      disableLayoutRule
+    } = state.properties;
     myFormSuccessUseCase.updateDependency(state, updateState);
     myFormSuccessUseCase.execute({
       dispatch,
-      myForm: action.payload.response
+      myForm: action.payload.response,
+      disableValidationRule,
+      disableLayoutRule
     });
   }
 

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

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

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

@@ -3,17 +3,22 @@ import AbstractController from "./AbstractController";
 class ValidateFieldRequestController extends AbstractController {
   handle(event) {
     const {
-      validateFieldRequestUseCase
+      validateFieldUseCase
     } = this.service;
-    let {
+    const {
       state,
       updateState,
       action,
       dispatch
     } = event;
-    validateFieldRequestUseCase.updateDependency(state, updateState);
-    validateFieldRequestUseCase.execute({
-      fieldName: action.payload.fieldName,
+    const {
+      fieldName,
+      eventName
+    } = action.payload;
+    validateFieldUseCase.updateDependency(state, updateState);
+    validateFieldUseCase.execute({
+      fieldName,
+      eventName,
       dispatch
     });
   }

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

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

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

@@ -5,11 +5,9 @@ class ValidationRulesRequestController extends AbstractController {
     const {
       validationRulesRequestUseCase
     } = this.service;
-    let {
+    const {
       state,
-      updateState,
-      action,
-      dispatch
+      updateState
     } = event;
     validationRulesRequestUseCase.updateDependency(state, updateState);
     validationRulesRequestUseCase.execute();

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

@@ -5,15 +5,13 @@ class ValidationRulesSuccessController extends AbstractController {
     const {
       validationRulesSuccessUseCase
     } = this.service;
-    let {
+    const {
       state,
       updateState,
-      action,
-      dispatch
+      action
     } = event;
     validationRulesSuccessUseCase.updateDependency(state, updateState);
     validationRulesSuccessUseCase.execute({
-      dispatch,
       validationRules: action.payload.response.data
     });
   }