@zohodesk/library-platform 1.1.12-exp.1 → 1.1.12-exp.3

package/es/platform/components/table-connected/adapters/controllers/ScrollController.js

@@ -1,15 +1,36 @@
 import { RESIZE_SCROLL } from "../../../../../bc/table-column-resizer/Constants";
 import AbstractController from "./AbstractController";
+import { FLOAT_PAGINATION_BEHAVIOUR_UPDATE_REQUESTED } from "../../../../../bc/float-pagination/Constants";
 export default class ScrollController extends AbstractController {
-  handle(event) {
-    // const tableElement = event.host;
-    const tableElement = event.host.getElementsByTagName('table')[0];
-    event.dispatch({
-      type: RESIZE_SCROLL,
-      payload: {
-        tableElement
+  handle(_ref) {
+    let {
+      host,
+      dispatch,
+      state
+    } = _ref;
+    const {
+      properties: {
+        resizeConfig,
+        floatPaginationConfig
       }
-    });
+    } = state;
+
+    if (floatPaginationConfig?.isEnabled) {
+      dispatch({
+        type: FLOAT_PAGINATION_BEHAVIOUR_UPDATE_REQUESTED
+      });
+    }
+
+    if (resizeConfig?.isEnabled) {
+      // const tableElement = event.host;
+      const tableElement = host.getElementsByTagName('table')[0];
+      dispatch({
+        type: RESIZE_SCROLL,
+        payload: {
+          tableElement
+        }
+      });
+    }
   }
 
 }

package/es/platform/components/table-connected/adapters/controllers/ScrollEndReachedController.js

@@ -0,0 +1,23 @@
+import { ZLIST_FETCH_MORE } from "../../../../../bc/zlist/Constants";
+import AbstractController from "./AbstractController";
+export default class ScrollEndReachedController extends AbstractController {
+  handle(_ref) {
+    let {
+      dispatch,
+      state
+    } = _ref;
+    const {
+      behaviours: {
+        zrecord
+      }
+    } = state;
+
+    if (zrecord?.records?.length) {
+      dispatch({
+        type: ZLIST_FETCH_MORE,
+        payload: {}
+      });
+    }
+  }
+
+}

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

@@ -1,6 +1,5 @@
 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";
@@ -17,10 +16,17 @@ import UpdateMultipleRecordUseCase from "../../../../zlist/applications/usecases
 import GetContextUseCase from "../../../../zlist/applications/usecases/GetContextUseCase";
 import ReOrderUseCase from "../../../../zlist/applications/usecases/ReOrderUseCase";
 import { SdkContracts } from "../../../../../cc/table-connected/SdkContract";
-import SortUseCase from "../../../../zlist/applications/usecases/SortUseCase";
 import { Analytics } from "../../../../../library/analytics";
 import MarkAsReadUseCase from "../../../../zrecord/applications/usecases/MarkAsReadUseCase";
 import MarkAsUnReadUseCase from "../../../../zrecord/applications/usecases/MarkAsUnReadUseCase";
+import GetFilterConditionUseCase from "../../../../zrecord/applications/usecases/GetFilterConditionUseCase";
+import SetFilterUseCase from "../../../../zrecord/applications/usecases/SetFilterUseCase";
+import ClearAllFiltersUseCase from "../../../../zrecord/applications/usecases/ClearAllFiltersUseCase";
+import RefreshRecordsUseCase from "../../../../zrecord/applications/usecases/RefreshRecordsUseCase";
+import GetFilterConfigUseCase from "../../../../zrecord/applications/usecases/GetFilterConfigUseCase";
+import { initialSortConfig } from "../../../../../bc/zlist/Types";
+import GetSortConfigUseCase from "../../../../zlist/applications/usecases/GetSortConfigUseCase";
+import SetSortConfigUseCase from "../../../../zlist/applications/usecases/SetSortConfigUseCase";
 export class SmartTableResource extends AbstractResource {
   initialize() {}
 
@@ -37,8 +43,7 @@ export class SmartTableResource extends AbstractResource {
   getListDependencies() {
     const dependencies = {
       repository: new ZListRepository(),
-      presenter: new ZListPresenters(),
-      sortBy: new ZListSortBy()
+      presenter: new ZListPresenters()
     };
     return dependencies;
   }
@@ -68,7 +73,7 @@ export class SmartTableResource extends AbstractResource {
     } = this.dependencies;
     const now = new Date().toISOString();
     const smartTableSdkMethodUsed = {
-      event: "smart_table_sdk_method_used",
+      event: 'smart_table_sdk_method_used',
       timestamp: now,
       contextDetails: {
         moduleName: state.moduleName,
@@ -237,6 +242,95 @@ export class SmartTableResource extends AbstractResource {
     return getData();
   }
 
+  getFilterCondition() {
+    const {
+      dispatch
+    } = this.dependencies;
+    const {
+      getData,
+      setData
+    } = this.createCallback();
+    const dependencies = this.getRecordDependencies();
+    const usecase = this.createUseCase(dependencies, GetFilterConditionUseCase);
+    usecase.execute({
+      dispatch,
+      callback: setData
+    });
+    return getData();
+  }
+
+  getFilterConfig() {
+    const {
+      dispatch
+    } = this.dependencies;
+    const {
+      getData,
+      setData
+    } = this.createCallback();
+    const dependencies = this.getRecordDependencies();
+    const usecase = this.createUseCase(dependencies, GetFilterConfigUseCase);
+    usecase.execute({
+      dispatch,
+      callback: setData
+    });
+    return getData();
+  }
+
+  setFilter(filterConfig) {
+    this.validateInput('setFilter', {
+      filterConfig
+    }, SdkContracts.setFilterInputMeta);
+    const {
+      dispatch
+    } = this.dependencies;
+    const {
+      getData,
+      setData
+    } = this.createCallback();
+    const dependencies = this.getRecordDependencies();
+    const usecase = this.createUseCase(dependencies, SetFilterUseCase);
+    usecase.execute({
+      filterConfig,
+      dispatch,
+      callback: setData
+    });
+    return getData();
+  }
+
+  clearAllFilters() {
+    const {
+      dispatch
+    } = this.dependencies;
+    const {
+      getData,
+      setData
+    } = this.createCallback();
+    const dependencies = this.getRecordDependencies();
+    const usecase = this.createUseCase(dependencies, ClearAllFiltersUseCase);
+    usecase.execute({
+      dispatch,
+      callback: setData
+    });
+    return getData();
+  }
+
+  refreshRecords() {
+    const {
+      dispatch
+    } = this.dependencies;
+    const {
+      getData,
+      setData
+    } = this.createCallback();
+    const dependencies = this.getRecordDependencies();
+    const usecase = this.createUseCase(dependencies, RefreshRecordsUseCase);
+    usecase.execute({
+      dispatch,
+      callback: setData
+    });
+    return getData();
+  }
+
   selectRecords(ids) {
     this.validateInput('selectRecords', {
       ids
@@ -304,7 +398,8 @@ export class SmartTableResource extends AbstractResource {
       oldIndex: fromIndex,
       dispatch
     });
-  }
+  } // @deprecated use sortRecords
+
 
   sortRecords(sortBy) {
     this.validateInput('sortRecords', {
@@ -313,12 +408,78 @@ export class SmartTableResource extends AbstractResource {
     const {
       dispatch
     } = this.dependencies;
+    const {
+      getData,
+      setData
+    } = this.createCallback();
+    const dependencies = this.getListDependencies();
+    const usecase = this.createUseCase(dependencies, SetSortConfigUseCase);
+    const sortConfig = {
+      fieldName: sortBy.name,
+      order: sortBy.order
+    };
+    usecase.execute({
+      sortConfig,
+      dispatch,
+      callback: setData
+    });
+    return getData();
+  }
+
+  getSortConfig() {
+    const {
+      dispatch
+    } = this.dependencies;
+    const {
+      getData,
+      setData
+    } = this.createCallback();
+    const dependencies = this.getListDependencies();
+    const usecase = this.createUseCase(dependencies, GetSortConfigUseCase);
+    usecase.execute({
+      dispatch,
+      callback: setData
+    });
+    return getData();
+  }
+
+  setSortConfig(sortConfig) {
+    this.validateInput('setSortConfig', {
+      sortConfig
+    }, SdkContracts.setSortConfigInputMeta);
+    const {
+      dispatch
+    } = this.dependencies;
+    const {
+      getData,
+      setData
+    } = this.createCallback();
     const dependencies = this.getListDependencies();
-    const usecase = this.createUseCase(dependencies, SortUseCase);
+    const usecase = this.createUseCase(dependencies, SetSortConfigUseCase);
     usecase.execute({
-      sortBy,
+      sortConfig,
+      dispatch,
+      callback: setData
+    });
+    return getData();
+  }
+
+  clearSorting() {
+    const {
       dispatch
+    } = this.dependencies;
+    const {
+      getData,
+      setData
+    } = this.createCallback();
+    const dependencies = this.getListDependencies();
+    const usecase = this.createUseCase(dependencies, SetSortConfigUseCase);
+    usecase.execute({
+      sortConfig: initialSortConfig,
+      dispatch,
+      callback: setData
     });
+    return getData();
   }
 
   markAsRead(recordId) {

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

@@ -23,13 +23,20 @@ import { TableListConstants } from "../../../../cc/table-list";
 import ResolutionBasedLimitController from "../adapters/controllers/ResolutionBasedLimitController";
 import { TableTextOverflowConstants } from "../../../../cc/table-text-overflow";
 import { TEXT_OVERFLOW_BEHAVIOUR_UPDATE_REQUESTED } from "../../../../bc/clip-wrap/Constants";
+import { SMART_TABLE_SORT_BY_REQUESTED } from "../../../../cc/table-connected/constants/Events";
+import { SortedBy } from "../../../../cc/table-list/data-types/Header";
+import { SortOrder } from "../../../../bc/zlist/Types";
+import { FloatingPaginationConstants } from "../../../../cc/floating-pagination";
+import { FLOAT_PAGINATION_BEHAVIOUR_BOTTOM_UPDATED, FLOAT_PAGINATION_BEHAVIOUR_TOP_UPDATED } from "../../../../bc/float-pagination/Constants";
+import ScrollEndReachedController from "../adapters/controllers/ScrollEndReachedController";
 const {
   TABLE_LIST_RESIZE_START_REQUESTED,
   TABLE_LIST_RESIZE_MOVE_REQUESTED,
   TABLE_LIST_RESIZE_END_REQUESTED,
   TABLE_LIST_SCROLLED,
   TABLE_LIST_ROW_DRAG_END,
-  TABLE_LIST_NAME_FIELD_CLICKED
+  TABLE_LIST_NAME_FIELD_CLICKED,
+  TABLE_LIST_SCROLL_END_REACHED
 } = TableListEventConstants;
 
 function createHandlerWithSdk(handler) {
@@ -154,8 +161,8 @@ export default class EventHandlersFactory {
         contextDetails: {
           moduleName,
           instanceName,
-          sortBy: zlist.sortBy.name,
-          direction: zlist.sortBy.order
+          sortBy: zlist.sortConfig.fieldName,
+          direction: zlist.sortConfig.order
         }
       }; // -------------------------
       // 5. Column Resized
@@ -326,18 +333,41 @@ export default class EventHandlersFactory {
       [SmartTableConstants.ExternalConstants.SMART_TABLE_MARK_AS_READ_REQUESTED]: markAsReadHandler,
       [SmartTableConstants.ExternalConstants.SMART_TABLE_MARK_AS_UNREAD_REQUESTED]: markAsUnReadHandler,
       [TABLE_LIST_NAME_FIELD_CLICKED]: navigationHandler,
+      [TABLE_LIST_SCROLL_END_REACHED]: new ScrollEndReachedController().handle,
+      [FloatingPaginationConstants.SCROLL_UP_CLICKED]: args => {
+        const {
+          dispatch
+        } = args;
+        dispatch({
+          type: FLOAT_PAGINATION_BEHAVIOUR_TOP_UPDATED
+        });
+      },
+      [FloatingPaginationConstants.SCROLL_DOWN_CLICKED]: args => {
+        const {
+          dispatch
+        } = args;
+        dispatch({
+          type: FLOAT_PAGINATION_BEHAVIOUR_BOTTOM_UPDATED
+        });
+      },
       [`${name}#${LifeCycleEvents.STATE_UPDATED}`]: addMetrics,
       [RESIZE_FINISHED]: new ResizeFinishController().handle,
       [TABLE_LIST_RESIZE_START_REQUESTED]: new ResizeStartController().handle,
       [TABLE_LIST_RESIZE_MOVE_REQUESTED]: new ResizeByMouseController().handle,
-      [SmartTableConstants.Events.SORT]: _ref => {
+      [SMART_TABLE_SORT_BY_REQUESTED]: _ref => {
         let {
           action,
           dispatch
         } = _ref;
         return dispatch({
           type: ZLIST_SORT,
-          payload: action.payload
+          payload: {
+            fieldName: action.payload.name,
+            order: {
+              [SortedBy.Ascending]: SortOrder.ASC,
+              [SortedBy.Descending]: SortOrder.DES
+            }[action.payload.order] || SortOrder.NONE
+          }
         });
       },
       [TABLE_LIST_RESIZE_END_REQUESTED]: new ResizeEndController().handle,
@@ -417,7 +447,8 @@ function createMergedHandler(eventHandlersList, eventName) {
       if (typeof handler === 'function') {
         try {
           handler(...arguments);
-        } catch {// Silently ignore errors
+        } catch (error) {
+          __DEVELOPMENT__ && console.error(error);
         }
       }
     }

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

@@ -42,6 +42,7 @@ import { SmartTableEventsContracts } from "../../../../cc/table-connected";
 import ClientScriptsBehaviourFactory from "../../../client-scripts/behaviour/zclient-scripts-fetch/frameworks/ClientScriptsBehaviourFactory";
 import AppContextBehaviourFactory from "../../../app-context-behaviour/frameworks/AppContextBehaviourFactory";
 import ClipWrapBehaviourFactory from "../../../../library/behaviours/clip-wrap/frameworks/ui/ClipWrapBehaviourFactory";
+import FloatPaginationBehaviourFactory from "../../../../library/behaviours/float-pagination/frameworks/ui/FloatPaginationBehaviourFactory";
 export default class TableConnectedFactory {
   static create(_ref) {
     let {
@@ -70,7 +71,7 @@ export default class TableConnectedFactory {
   }
 
   static getBehaviours(_dataSource) {
-    return [SdkBehaviourFactory.create([ResourceNamesEnum.SMART_TABLE, ResourceNamesEnum.CLIENT_ACTION]), TableColumnResizerBehaviorFactory.create(), KeyboardControlBehaviourFactory.create(), ClipWrapBehaviourFactory.create(), LocalStorageBehaviourFactory.create(), ZHttpBehaviourFactory.create(), DataSourceBehaviourFactory.create(), ...TableConnectedFactory.getPlatformBehaviours(_dataSource), ColumnChooserBehaviourFactory.create(), ListItemSelectionBehaviourFactory.create()];
+    return [SdkBehaviourFactory.create([ResourceNamesEnum.SMART_TABLE, ResourceNamesEnum.CLIENT_ACTION]), TableColumnResizerBehaviorFactory.create(), KeyboardControlBehaviourFactory.create(), ClipWrapBehaviourFactory.create(), FloatPaginationBehaviourFactory.create(), LocalStorageBehaviourFactory.create(), ZHttpBehaviourFactory.create(), DataSourceBehaviourFactory.create(), ...TableConnectedFactory.getPlatformBehaviours(_dataSource), ColumnChooserBehaviourFactory.create(), ListItemSelectionBehaviourFactory.create()];
   }
 
   static getPlatformBehaviours(_dataSource) {

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

@@ -18,6 +18,7 @@ function View(_ref, ref) {
     focussedRow,
     keyboardControlsConfig,
     textOverflowConfig,
+    floatPaginationConfig,
     reOrderConfig
   } = state.viewModel;
   const {
@@ -48,6 +49,7 @@ function View(_ref, ref) {
     selectionConfig: selectionConfig,
     keyboardControlsConfig: keyboardControlsConfig,
     textOverflowConfig: textOverflowConfig,
+    floatPaginationConfig: floatPaginationConfig,
     focussedRow: focussedRow
   });
 }

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

@@ -9,7 +9,7 @@ let getComponentMapping = {
       payload,
       headers
     } = _ref;
-    return {};
+    return [];
   },
   transformer: res => res,
   properties: {}

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

@@ -3,6 +3,7 @@ let getRecords = {
   api: '/{{servicePrefix}}/{{orgName}}/api/v1/{{moduleName}}',
   parameters: `{
         "viewId":"{{viewId}}",
+        "filter":"{{filter}}",
         "from":{{from}},
         "limit":{{limit}},
         "sortBy":"{{sortBy}}"

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

@@ -0,0 +1,51 @@
+const getSingleRecord = {
+  name: 'records',
+  api: '/{{servicePrefix}}/{{orgName}}/api/v1/{{moduleName}}/{{recordId}}',
+  parameters: `{}`,
+  // parameters: `{ "include": "{{include}}" }`,
+  type: 'GET',
+  transformer: data => data,
+  properties: {
+    servicePrefix: {
+      required: true,
+      typeMetadata: {
+        schema: {
+          type: 'string'
+        }
+      }
+    },
+    orgName: {
+      required: true,
+      typeMetadata: {
+        schema: {
+          type: 'string'
+        }
+      }
+    },
+    // include: {
+    //   required: false,
+    //   typeMetadata: {
+    //     schema: {
+    //       type: 'string'
+    //     }
+    //   }
+    // },
+    moduleName: {
+      required: true,
+      typeMetadata: {
+        schema: {
+          type: 'string'
+        }
+      }
+    },
+    recordId: {
+      required: true,
+      typeMetadata: {
+        schema: {
+          type: 'string'
+        }
+      }
+    }
+  }
+};
+export default getSingleRecord;

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

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

package/es/platform/zform/applications/interfaces/input/GetInitialRecordSuccessUseCaseInputModel.js

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

package/es/platform/zform/applications/usecases/GetInitialRecordSuccessUseCase.js

@@ -0,0 +1,132 @@
+import AbstractUseCase from "./AbstractUseCase";
+import { ZFORM_API_FAILURE, ZFORM_DEPENDENCY_MAPPINGS_SUCCESS, ZFORM_LAYOUT_RULES_SUCCESS, ZFORM_MY_FORM_SUCCESS } from "../../../../bc/zform/Symbol";
+import { DATA_SOURCE_EXECUTE as DATA_BROKER_EXECUTE } from "../../../../bc/zdata-source/Constants";
+import { DATA_SOURCE_SUCCESS, DATA_SOURCE_NO_CONTENT, DATA_SOURCE_FAILURE } from "../../../../bc/zdata-source/Symbols";
+
+class GetInitialRecordSuccessUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      disableValidationRule,
+      disableLayoutRule,
+      disableDependencyMapping
+    } = input;
+    const {
+      dispatch,
+      record
+    } = input;
+    const zformEntity = this.dependencies.repository.getFormEntity();
+    zformEntity.setInitialRecord(record);
+    const context = { ...zformEntity.getContext(),
+      layoutId: zformEntity.getLayoutId()
+    };
+    dispatch({
+      type: DATA_BROKER_EXECUTE,
+      payload: {
+        actionName: "getMyForm",
+        props: context
+      },
+      metaData: {
+        actionName: "getMyForm",
+        //hack
+        initialRecordData: record,
+        // Store record data here for later use
+        [DATA_SOURCE_NO_CONTENT]: {
+          type: ZFORM_MY_FORM_SUCCESS,
+          metaData: {
+            actionName: "getMyForm",
+            initialRecordData: record
+          }
+        },
+        //hack
+        [DATA_SOURCE_FAILURE]: {
+          type: ZFORM_API_FAILURE,
+          metaData: {
+            actionName: 'getMyForm'
+          }
+        },
+        [DATA_SOURCE_SUCCESS]: {
+          type: ZFORM_MY_FORM_SUCCESS,
+          metaData: {
+            actionName: "getMyForm",
+            initialRecordData: record
+          }
+        }
+      }
+    });
+
+    if (!disableDependencyMapping) {
+      dispatch({
+        type: DATA_BROKER_EXECUTE,
+        payload: {
+          actionName: "getDependencyMappings",
+          props: context
+        },
+        metaData: {
+          actionName: "getDependencyMappings",
+          //hack
+          [DATA_SOURCE_SUCCESS]: {
+            type: ZFORM_DEPENDENCY_MAPPINGS_SUCCESS,
+            metaData: {
+              actionName: "getDependencyMappings"
+            }
+          },
+          [DATA_SOURCE_FAILURE]: {
+            type: ZFORM_API_FAILURE,
+            metaData: {
+              actionName: 'getDependencyMappings'
+            }
+          },
+          [DATA_SOURCE_NO_CONTENT]: {
+            type: ZFORM_DEPENDENCY_MAPPINGS_SUCCESS,
+            metaData: {
+              actionName: "getDependencyMappings"
+            }
+          }
+        }
+      });
+    } else {
+      zformEntity.setDependencyFetching(false);
+    }
+
+    if (!disableLayoutRule) {
+      dispatch({
+        type: DATA_BROKER_EXECUTE,
+        payload: {
+          actionName: "getLayoutRules",
+          props: { ...context,
+            activeRulesOnly: true
+          }
+        },
+        metaData: {
+          actionName: "getLayoutRules",
+          //hack
+          [DATA_SOURCE_NO_CONTENT]: {
+            type: ZFORM_LAYOUT_RULES_SUCCESS,
+            metaData: {
+              actionName: "getLayoutRules"
+            }
+          },
+          [DATA_SOURCE_FAILURE]: {
+            type: ZFORM_API_FAILURE,
+            metaData: {
+              actionName: 'getLayoutRules'
+            }
+          },
+          [DATA_SOURCE_SUCCESS]: {
+            type: ZFORM_LAYOUT_RULES_SUCCESS,
+            metaData: {
+              actionName: "getLayoutRules"
+            }
+          }
+        }
+      });
+    } else {
+      zformEntity.setLayoutRulesFetching(false);
+    }
+
+    this.dependencies.presenter.updateFormResponse(zformEntity.toObject());
+  }
+
+}
+
+export default GetInitialRecordSuccessUseCase;

package/es/platform/zlist/adapters/controllers/RefreshRecordsRequestedController.js

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