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

package/es/platform/components/table-connected/adapters/resources/SmartTableResource.js

@@ -0,0 +1,326 @@
+import { AbstractResource } from "../../../../sdk/application/interfaces/gateways/AbstractResource";
+import ZListRepository from "../../../../zlist/adapters/gateways/Repository";
+import ZListSortBy from "../../../../zlist/adapters/gateways/SortBy";
+import ZListPresenters from "../../../../zlist/adapters/presenters/Presenters";
+import ZRecordRepository from "../../../../zrecord/adapters/gateways/Repository";
+import ZRecordPresenter from "../../../../zrecord/adapters/presenters/Presenter";
+import ListSelectRepository from "../../../../../library/behaviours/list-selection/adapters/gateways/Repository";
+import ListSelectPresenter from "../../../../../library/behaviours/list-selection/adapters/presenters/Presenter";
+import ListSelectSelectUsecase from "../../../../../library/behaviours/list-selection/applications/usecases/Select";
+import ListSelectDeselectUsecase from "../../../../../library/behaviours/list-selection/applications/usecases/Deselect";
+import GetMultipleRecordUseCase from "../../../../zrecord/applications/usecases/GetMultipleRecordUseCase";
+import GetSingleRecordUseCase from "../../../../zrecord/applications/usecases/GetSingleRecordUseCase";
+import DeleteSingleRecordUseCase from "../../../../zlist/applications/usecases/DeleteSingleRecordUseCase";
+import DeleteMultipleRecordUseCase from "../../../../zlist/applications/usecases/DeleteMultipleRecordUseCase";
+import RecordUpdateUseCase from "../../../../zlist/applications/usecases/RecordUpdateUseCase";
+import UpdateMultipleRecordUseCase from "../../../../zlist/applications/usecases/UpdateMultipleRecordUseCase";
+import GetContextUseCase from "../../../../zlist/applications/usecases/GetContextUseCase";
+import ReOrderUseCase from "../../../../zlist/applications/usecases/ReOrderUseCase";
+import { SdkContracts } from "../../../../../cc/table-connected/SdkContract";
+import Validator from "../../../../../library/custom-component/frameworks/json-schema-validator/Validator";
+import ErrorPrinter from "./ErrorPrinter";
+export class SmartTableResource extends AbstractResource {
+  initialize() {}
+
+  destroy() {}
+
+  safeValidateInput(meta, input) {
+    try {
+      const result = Validator.validate(meta, input);
+      return result;
+    } catch (error) {
+      return {
+        isValid: false,
+        errors: [{
+          dataPath: '',
+          keyword: 'internal',
+          message: 'invalid schema'
+        }]
+      };
+    }
+  }
+
+  validateInput(methodName, input, meta) {
+    const {
+      isValid,
+      errors
+    } = this.safeValidateInput(meta, input);
+
+    if (!isValid) {
+      const title = `%c Invalid sdk input for %c${methodName}`;
+      const styles = ['color: red; font-weight: bold;', 'color: #FF6F61; font-weight: bold;'];
+      ErrorPrinter.displaySchemaErrors({
+        msg: title,
+        styles
+      }, errors, '');
+      throw {
+        code: 'ValidationError',
+        message: `Invalid input for ${methodName}`,
+        details: {
+          methodName,
+          errors
+        }
+      };
+    }
+  }
+
+  getRecordDependencies() {
+    const dependencies = {
+      repository: new ZRecordRepository(),
+      presenter: new ZRecordPresenter()
+    };
+    return dependencies;
+  }
+
+  getListDependencies() {
+    const dependencies = {
+      repository: new ZListRepository(),
+      presenter: new ZListPresenters(),
+      sortBy: new ZListSortBy()
+    };
+    return dependencies;
+  }
+
+  getListSelectDependencies() {
+    const dependencies = {
+      repository: new ListSelectRepository(),
+      presenter: new ListSelectPresenter()
+    };
+    return dependencies;
+  }
+
+  createUseCase(dependencies, UseCaseClass) {
+    var _usecase$updateDepend, _usecase$updateDepend2;
+
+    const {
+      state,
+      updateState
+    } = this.dependencies;
+    const usecase = new UseCaseClass(dependencies);
+    (_usecase$updateDepend = usecase.updateDependency) === null || _usecase$updateDepend === void 0 ? void 0 : _usecase$updateDepend.call(usecase, state, updateState);
+    (_usecase$updateDepend2 = usecase.updateDependencies) === null || _usecase$updateDepend2 === void 0 ? void 0 : _usecase$updateDepend2.call(usecase, state, updateState);
+    return usecase;
+  }
+
+  createCallback() {
+    let temp = null;
+    return {
+      setData: data => {
+        temp = data;
+      },
+      getData: () => temp
+    };
+  }
+
+  getRecords() {
+    const {
+      getData,
+      setData
+    } = this.createCallback();
+    const dependencies = this.getRecordDependencies();
+    const usecase = this.createUseCase(dependencies, GetMultipleRecordUseCase);
+    usecase.execute({
+      callback: setData
+    });
+    return getData();
+  }
+
+  getRecord(recordId) {
+    this.validateInput('getRecord', {
+      recordId
+    }, SdkContracts.getRecordInputMeta);
+    const {
+      getData,
+      setData
+    } = this.createCallback();
+    const dependencies = this.getRecordDependencies();
+    const usecase = this.createUseCase(dependencies, GetSingleRecordUseCase);
+    usecase.execute({
+      recordId,
+      callback: setData
+    });
+    return getData();
+  }
+
+  getContext(variableName) {
+    this.validateInput('getContext', {
+      variableName
+    }, SdkContracts.getContextInputMeta);
+    const {
+      getData,
+      setData
+    } = this.createCallback();
+    const dependencies = this.getListDependencies();
+    const usecase = this.createUseCase(dependencies, GetContextUseCase);
+    usecase.execute({
+      variableName,
+      callback: setData
+    });
+    return getData();
+  }
+
+  deleteRecord(recordId) {
+    this.validateInput('deleteRecord', {
+      recordId
+    }, SdkContracts.deleteRecordInputMeta);
+    const {
+      dispatch
+    } = this.dependencies;
+    const {
+      getData,
+      setData
+    } = this.createCallback();
+    const dependencies = this.getListDependencies();
+    const usecase = this.createUseCase(dependencies, DeleteSingleRecordUseCase);
+    usecase.execute({
+      recordId,
+      dispatch,
+      callback: setData
+    });
+    return getData();
+  }
+
+  deleteRecords(recordIds) {
+    let shouldFetch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    this.validateInput('deleteRecords', {
+      recordIds,
+      shouldFetch
+    }, SdkContracts.deleteRecordsInputMeta);
+    const {
+      dispatch
+    } = this.dependencies;
+    const {
+      getData,
+      setData
+    } = this.createCallback();
+    const dependencies = this.getListDependencies();
+    const usecase = this.createUseCase(dependencies, DeleteMultipleRecordUseCase);
+    usecase.execute({
+      recordIds,
+      dispatch,
+      callback: setData,
+      shouldFetch
+    });
+    return getData();
+  }
+
+  updateRecord(recordId, record) {
+    let shouldFetch = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    this.validateInput('updateRecord', {
+      recordId,
+      record,
+      shouldFetch
+    }, SdkContracts.updateRecordInputMeta);
+    const {
+      dispatch
+    } = this.dependencies;
+    const {
+      getData,
+      setData
+    } = this.createCallback();
+    const dependencies = this.getListDependencies();
+    const usecase = this.createUseCase(dependencies, RecordUpdateUseCase);
+    usecase.execute({
+      recordId,
+      dispatch,
+      callback: setData,
+      record,
+      shouldFetch
+    });
+    return getData();
+  }
+
+  updateRecords(recordsMap) {
+    let shouldFetch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    this.validateInput('updateRecords', {
+      recordsMap,
+      shouldFetch
+    }, SdkContracts.updateRecordsInputMeta);
+    const {
+      dispatch
+    } = this.dependencies;
+    const {
+      getData,
+      setData
+    } = this.createCallback();
+    const dependencies = this.getListDependencies();
+    const usecase = this.createUseCase(dependencies, UpdateMultipleRecordUseCase);
+    usecase.execute({
+      recordsMap,
+      dispatch,
+      callback: setData,
+      shouldFetch
+    });
+    return getData();
+  }
+
+  selectRecords(ids) {
+    this.validateInput('selectRecords', {
+      ids
+    }, SdkContracts.selectRecordsInputMeta);
+    const {
+      dispatch
+    } = this.dependencies;
+    const dependencies = this.getListSelectDependencies();
+    const usecase = this.createUseCase(dependencies, ListSelectSelectUsecase);
+    usecase.execute({
+      ids,
+      dispatch
+    });
+  }
+
+  deselectRecords(ids) {
+    this.validateInput('deselectRecords', {
+      ids
+    }, SdkContracts.deselectRecordsInputMeta);
+    const {
+      dispatch
+    } = this.dependencies;
+    const dependencies = this.getListSelectDependencies();
+    const usecase = this.createUseCase(dependencies, ListSelectDeselectUsecase);
+    usecase.execute({
+      ids,
+      dispatch
+    });
+  }
+
+  selectAllRecords() {
+    const {
+      dispatch
+    } = this.dependencies;
+    const dependencies = this.getListSelectDependencies();
+    const usecase = this.createUseCase(dependencies, ListSelectSelectUsecase);
+    usecase.execute({
+      dispatch
+    });
+  }
+
+  deselectAllRecords() {
+    const {
+      dispatch
+    } = this.dependencies;
+    const dependencies = this.getListSelectDependencies();
+    const usecase = this.createUseCase(dependencies, ListSelectDeselectUsecase);
+    usecase.execute({
+      dispatch
+    });
+  }
+
+  reOrderRecord(fromIndex, toIndex) {
+    this.validateInput('reOrderRecord', {
+      fromIndex,
+      toIndex
+    }, SdkContracts.reOrderRecordInputMeta);
+    const {
+      dispatch
+    } = this.dependencies;
+    const dependencies = this.getListDependencies();
+    const usecase = this.createUseCase(dependencies, ReOrderUseCase);
+    usecase.execute({
+      newIndex: toIndex,
+      oldIndex: fromIndex,
+      dispatch
+    });
+  }
+
+}

package/es/platform/components/table-connected/application/interfaces/ISmartTableResource.js

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

package/es/platform/components/table-connected/frameworks/ErrorEventHandlersFactory.js

@@ -0,0 +1,126 @@
+import { ZLIST_FETCH_MORE_RECORDS_FAILED, ZLIST_INITIAL_AVAILABLE_FIELDS_FETCH_FAILED, ZLIST_INITIAL_CLIENT_ACTIONS_FETCH_FAILED, ZLIST_INITIAL_RECORDS_FETCH_FAILED, ZLIST_INITIAL_SELECTED_FIELDS_FETCH_FAILED, ZLIST_RECORD_DELETE_FAILED, ZLIST_RECORD_UPDATE_FAILED } from "../../../../bc/zlist/Constants";
+import { ERROR_OCCURRED } from "../../../../cc/table-connected/constants/Events";
+import { ErrorCode } from "../../../../cc/table-connected/ErrorEventType";
+export default class ErrorEventHandlersFactory {
+  static create() {
+    return {
+      [ZLIST_FETCH_MORE_RECORDS_FAILED]: _ref => {
+        let {
+          action,
+          dispatch
+        } = _ref;
+        return dispatch({
+          type: ERROR_OCCURRED,
+          payload: {
+            code: ErrorCode.FETCH_MORE_RECORDS_FAILED,
+            message: action.payload.error.message,
+            errorDetails: {
+              from: action.payload.from,
+              limit: action.payload.limit,
+              error: action.payload.error
+            }
+          }
+        });
+      },
+      [ZLIST_INITIAL_AVAILABLE_FIELDS_FETCH_FAILED]: _ref2 => {
+        let {
+          action,
+          dispatch
+        } = _ref2;
+        return dispatch({
+          type: ERROR_OCCURRED,
+          payload: {
+            code: ErrorCode.INITIAL_AVAILABLE_FIELDS_FETCH_FAILED,
+            message: action.payload.error.message,
+            errorDetails: {
+              error: action.payload.error
+            }
+          }
+        });
+      },
+      [ZLIST_INITIAL_CLIENT_ACTIONS_FETCH_FAILED]: _ref3 => {
+        let {
+          action,
+          dispatch
+        } = _ref3;
+        return dispatch({
+          type: ERROR_OCCURRED,
+          payload: {
+            code: ErrorCode.INITIAL_CLIENT_ACTIONS_FETCH_FAILED,
+            message: action.payload.error.message,
+            errorDetails: {
+              error: action.payload.error
+            }
+          }
+        });
+      },
+      [ZLIST_INITIAL_RECORDS_FETCH_FAILED]: _ref4 => {
+        let {
+          action,
+          dispatch
+        } = _ref4;
+        return dispatch({
+          type: ERROR_OCCURRED,
+          payload: {
+            code: ErrorCode.INITIAL_RECORDS_FETCH_FAILED,
+            message: action.payload.error.message,
+            errorDetails: {
+              error: action.payload.error
+            }
+          }
+        });
+      },
+      [ZLIST_INITIAL_SELECTED_FIELDS_FETCH_FAILED]: _ref5 => {
+        let {
+          action,
+          dispatch
+        } = _ref5;
+        return dispatch({
+          type: ERROR_OCCURRED,
+          payload: {
+            code: ErrorCode.INITIAL_SELECTED_FIELDS_FETCH_FAILED,
+            message: action.payload.error.message,
+            errorDetails: {
+              error: action.payload.error
+            }
+          }
+        });
+      },
+      [ZLIST_RECORD_DELETE_FAILED]: _ref6 => {
+        let {
+          action,
+          dispatch
+        } = _ref6;
+        return dispatch({
+          type: ERROR_OCCURRED,
+          payload: {
+            code: ErrorCode.RECORD_DELETE_FAILED,
+            message: action.payload.error.message,
+            errorDetails: {
+              recordId: action.payload.recordId,
+              error: action.payload.error
+            }
+          }
+        });
+      },
+      [ZLIST_RECORD_UPDATE_FAILED]: _ref7 => {
+        let {
+          action,
+          dispatch
+        } = _ref7;
+        return dispatch({
+          type: ERROR_OCCURRED,
+          payload: {
+            code: ErrorCode.RECORD_UPDATE_FAILED,
+            message: action.payload.error.message,
+            errorDetails: {
+              recordId: action.payload.recordId,
+              error: action.payload.error
+            }
+          }
+        });
+      }
+    };
+  }
+
+}

package/es/{desk-frameworks → platform/components}/table-connected/frameworks/EventHandlersFactory.js

@@ -1,45 +1,54 @@
-import { LIST_SELECTION_RECORDS_DESELECTED, LIST_SELECTION_RECORDS_SELECTED, LIST_SELECTION_SELECTION_LIMIT_EXCEEDED } from "../../../bc/list-selection/Constants";
-import { RESIZE_FINISHED } from "../../../bc/table-column-resizer/Constants";
-import { ZLIST_SORT } from "../../../bc/zlist/Constants";
-import { COLUMN_CHOOSER_BEHAVIOUR_UPDATED } from "../../../bc/column-chooser/Constants";
-import { COLUMN_CHOOSER_OPEN_REQUESTED } from "../../../cc/table-column-chooser/Constants";
+import { LIST_SELECTION_RECORDS_DESELECTED, LIST_SELECTION_RECORDS_SELECTED, LIST_SELECTION_SELECTION_LIMIT_EXCEEDED } from "../../../../bc/list-selection/Constants";
+import { RESIZE_FINISHED } from "../../../../bc/table-column-resizer/Constants";
+import { ZLIST_SORT } from "../../../../bc/zlist/Constants";
+import { COLUMN_CHOOSER_BEHAVIOUR_UPDATED } from "../../../../bc/column-chooser/Constants";
+import { COLUMN_CHOOSER_OPEN_REQUESTED } from "../../../../cc/table-column-chooser/Constants";
 import ListSdkFactory from "./ListSdkFactory";
-import { SmartTableConstants } from "../../../cc/table-connected";
-import TableListEventConstants from "../../../cc/table-list/Constants";
+import { SmartTableConstants } from "../../../../cc/table-connected";
+import TableListEventConstants from "../../../../cc/table-list/Constants";
 import ResizeStartController from "../adapters/controllers/ResizeStartController";
 import ResizeByMouseController from "../adapters/controllers/ResizeByMouseController";
 import ResizeEndController from "../adapters/controllers/ResizeEndController";
 import { ResizeFinishController } from "../adapters/controllers/ResizeFinishController";
+import { ReOrderFinishController } from "../adapters/controllers/ReOrderFinishController";
 import ScrollController from "../adapters/controllers/ScrollController";
 import ColumnChooserUpdateController from "../adapters/controllers/ColumnChooserUpdateController";
 import ColumnChooserOpenedController from "../adapters/controllers/ColumnChooserOpenedController";
+import { platformSDK } from "../../../sdk/frameworks/Sdk";
+import ErrorEventHandlersFactory from "./ErrorEventHandlersFactory";
 const {
   TABLE_LIST_RESIZE_START_REQUESTED,
   TABLE_LIST_RESIZE_MOVE_REQUESTED,
   TABLE_LIST_RESIZE_END_REQUESTED,
-  TABLE_LIST_SCROLLED
+  TABLE_LIST_SCROLLED,
+  TABLE_LIST_ROW_DRAG_END
 } = TableListEventConstants;
 
 function createHandlerWithSdk(handler) {
   return input => {
     const {
-      state,
-      dispatch
+      state
     } = input;
-    handler(input, ListSdkFactory.create({
-      state,
-      dispatch
+    const instanceName = state.properties.instanceName;
+    handler({ ...input,
+      platformSDK
+    }, ListSdkFactory.create({
+      instanceName
     }));
   };
 }
 
 export default class EventHandlersFactory {
-  static create(eventHandlers) {
-    const wrapped = Object.fromEntries(Object.keys(eventHandlers).map(eventName => {
+  static getSdkWrappedEventHandler(eventHandlers) {
+    return Object.fromEntries(Object.keys(eventHandlers).map(eventName => {
       const handler = createHandlerWithSdk(eventHandlers[eventName]);
       return [eventName, handler];
     }));
-    return { ...wrapped,
+  }
+
+  static create(eventHandlers) {
+    const wrapped = EventHandlersFactory.getSdkWrappedEventHandler(eventHandlers);
+    const defaultEventHandlers = {
       NAVIGATION: NavigationHandler,
       [RESIZE_FINISHED]: new ResizeFinishController().handle,
       [TABLE_LIST_RESIZE_START_REQUESTED]: new ResizeStartController().handle,
@@ -87,10 +96,42 @@ export default class EventHandlersFactory {
           type: SmartTableConstants.Events.SELECTION_LIMIT_EXCEEDED,
           payload: action.payload
         });
-      }
+      },
+      [TABLE_LIST_ROW_DRAG_END]: new ReOrderFinishController().handle
     };
+    return mergeEventHandlers([defaultEventHandlers, ErrorEventHandlersFactory.create(), wrapped]);
+  }
+
+}
+
+function mergeEventHandlers(eventHandlersList) {
+  const mergedEventHandlers = {};
+  const allEventNames = new Set();
+
+  for (const handlers of eventHandlersList) {
+    Object.keys(handlers).forEach(eventName => allEventNames.add(eventName));
   }
 
+  for (const eventName of allEventNames) {
+    mergedEventHandlers[eventName] = createMergedHandler(eventHandlersList, eventName);
+  }
+
+  return mergedEventHandlers;
+}
+
+function createMergedHandler(eventHandlersList, eventName) {
+  return function () {
+    for (const handlers of eventHandlersList) {
+      const handler = handlers[eventName];
+
+      if (typeof handler === 'function') {
+        try {
+          handler(...arguments);
+        } catch {// Silently ignore errors
+        }
+      }
+    }
+  };
 }
 
 function NavigationHandler(event) {

package/es/platform/components/table-connected/frameworks/ListSdkFactory.js

@@ -0,0 +1,57 @@
+import ResourceNamesEnum from "../../../../bc/sdk/ResourceNamesEnum";
+import { platformSDK } from "../../../sdk/frameworks/Sdk";
+export default class ListSdkFactory {
+  static getRecordSdks(smartTable) {
+    return {
+      getRecords: () => smartTable.getRecords(),
+      getRecord: recordId => smartTable.getRecord(recordId),
+      getContext: variableName => smartTable.getContext(variableName),
+      deleteRecord: recordId => smartTable.deleteRecord(recordId),
+      deleteRecords: function (recordIds) {
+        let shouldFetch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+        return smartTable.deleteRecords(recordIds, shouldFetch);
+      },
+      updateRecord: (recordId, record) => smartTable.updateRecord(recordId, record),
+      updateRecords: function (recordsMap) {
+        let shouldFetch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+        return smartTable.updateRecords(recordsMap, shouldFetch);
+      },
+      reOrderRecord: (fromIndex, toIndex) => smartTable.reOrderRecord(fromIndex, toIndex)
+    };
+  }
+
+  static getSelectionSdks(smartTable) {
+    return {
+      selectRecords: ids => smartTable.selectRecords(ids),
+      deselectRecords: ids => smartTable.deselectRecords(ids),
+      selectAllRecords: () => smartTable.selectAllRecords(),
+      deselectAllRecords: () => smartTable.deselectAllRecords()
+    };
+  }
+
+  static create(_ref) {
+    let {
+      instanceName
+    } = _ref;
+    const smartTable = platformSDK[ResourceNamesEnum.SMART_TABLE](instanceName);
+    const recordSdks = ListSdkFactory.getRecordSdks(smartTable);
+    const selectionSdks = ListSdkFactory.getSelectionSdks(smartTable);
+    return {
+      zlist: {
+        getRecords: recordSdks.getRecords,
+        getRecord: recordSdks.getRecord,
+        getContext: recordSdks.getContext,
+        deleteRecord: recordSdks.deleteRecord,
+        deleteRecords: recordSdks.deleteRecords,
+        updateRecord: recordSdks.updateRecord,
+        updateRecords: recordSdks.updateRecords,
+        selectRecords: selectionSdks.selectRecords,
+        deselectRecords: selectionSdks.deselectRecords,
+        selectAllRecords: selectionSdks.selectAllRecords,
+        deselectAllRecords: selectionSdks.deselectAllRecords,
+        reOrderRecord: recordSdks.reOrderRecord
+      }
+    };
+  }
+
+}