@zohodesk/library-platform 1.1.0-exp.2 → 1.1.1-exp.6

package/es/platform/zlist/adapters/presenters/translators/actions/ActionsTranslator.js

@@ -0,0 +1,89 @@
+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 ClientActionsTranslator from "../../../../../client-actions/translators/client-actions-translator";
+
+class ActionsTranslator {
+  constructor() {
+    let actions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    let records = arguments.length > 1 ? arguments[1] : undefined;
+    let fields = arguments.length > 2 ? arguments[2] : undefined;
+    let context = arguments.length > 3 ? arguments[3] : undefined;
+    this.records = records;
+    this.fields = fields;
+    this.context = context;
+
+    _defineProperty(this, "headerActions", void 0);
+
+    _defineProperty(this, "fieldActions", void 0);
+
+    _defineProperty(this, "rowActions", void 0);
+
+    _defineProperty(this, "noLocation", void 0);
+
+    this.pipe = this.pipe.bind(this);
+    this.headerActions = actions.filter(action => (action === null || action === void 0 ? void 0 : action.location) === 'header_actions');
+    this.fieldActions = actions.filter(action => (action === null || action === void 0 ? void 0 : action.location) === 'field_actions');
+    this.rowActions = actions.filter(action => (action === null || action === void 0 ? void 0 : action.location) === 'row_actions');
+    this.noLocation = actions.filter(action => !(action !== null && action !== void 0 && action.location));
+  }
+
+  getTranslator() {
+    return {
+      name: 'actionsTranslator',
+      mapping: this.pipe
+    };
+  }
+
+  getField(field_name) {
+    return this.fields.find(field => field.name === field_name);
+  }
+
+  getRecord(record_id) {
+    return this.records.find(record => record.id === record_id);
+  }
+
+  translateHeadersActions(headers) {
+    return headers.map(header => {
+      return { ...header,
+        actions: ClientActionsTranslator.transform(this.headerActions, { ...this.context,
+          field: this.getField(header.name)
+        })
+      };
+    });
+  }
+
+  translateFieldActions(row) {
+    return row.columns.map(column => {
+      return { ...column,
+        actions: ClientActionsTranslator.transform(this.fieldActions, { ...this.context,
+          record: this.getRecord(row.id),
+          field: this.getField(column.name)
+        })
+      };
+    });
+  }
+
+  translateRowsActions(data) {
+    return data.rows.map(row => {
+      return { ...row,
+        columns: this.translateFieldActions(row),
+        rowActionLocation: {
+          actions: ClientActionsTranslator.transform(this.rowActions, { ...this.context,
+            record: this.getRecord(row.id)
+          })
+        }
+      };
+    });
+  }
+
+  pipe(data) {
+    const newModel = { ...data,
+      headers: this.translateHeadersActions(data.headers),
+      rows: this.translateRowsActions(data)
+    };
+    return newModel;
+  }
+
+}
+
+export default ActionsTranslator;

package/es/platform/zlist/adapters/presenters/translators/fields/MultiSelectFieldTranslator.js

@@ -1,24 +1,44 @@
 import FieldTypes from "../../../../../../cc/fields/field/Types";
 import MultiListFieldModel from "../../../../../../cc/fields/multi-select/Model";
+import ColouredMultiListFieldModel from "../../../../../../cc/fields/coloured-multi-select/Model";
 
 const MultiSelectFieldTranslator = (field, value, appendToActionPayload) => {
   const {
     uiType,
-    name
+    name,
+    subType,
+    pickListValues
   } = field;
-  const updatedValue = value.split(';').map(item => {
-    if (item === '') {
-      return '-None-';
-    }
+  const updatedValue = value.split(';').map(item => item === '' ? '-None-' : item);
+
+  if (['colored', 'ColorCoded'].includes(subType)) {
+    return ColouredMultiSelectFieldTranslator(field, updatedValue, appendToActionPayload);
+  }
 
-    return item;
-  });
   return MultiListFieldModel({
     uiType: uiType || FieldTypes.MultiSelectField,
     appendToActionPayload,
     name,
+    options: pickListValues,
     value: updatedValue
   });
 };
 
-export default MultiSelectFieldTranslator;
+export default MultiSelectFieldTranslator;
+
+const ColouredMultiSelectFieldTranslator = (field, value, appendToActionPayload) => {
+  const {
+    uiType,
+    name,
+    pickListValues
+  } = field;
+  return ColouredMultiListFieldModel({
+    uiType: uiType || FieldTypes.ColouredMultiSelectField,
+    appendToActionPayload,
+    name,
+    options: pickListValues.map(option => ({ ...option,
+      colorCode: option.colorCode || ''
+    })),
+    value
+  });
+};

package/es/platform/zlist/adapters/presenters/translators/fields/PickListFieldTranslator.js

@@ -1,17 +1,43 @@
 import FieldTypes from "../../../../../../cc/fields/field/Types";
 import PickListFieldModel from "../../../../../../cc/fields/pick-list/Model";
+import ColouredPickListFieldModel from "../../../../../../cc/fields/coloured-pick-list/Model";
 
 const PickListFieldTranslator = (field, value, appendToActionPayload) => {
   const {
     uiType,
-    name
+    name,
+    pickListValues,
+    subType
   } = field;
+
+  if (['colored', 'ColorCoded'].includes(subType)) {
+    return ColouredPickListFieldTranslator(field, value, appendToActionPayload);
+  }
+
   return PickListFieldModel({
     uiType: uiType || FieldTypes.PickListField,
     appendToActionPayload,
+    options: pickListValues,
     name,
     value
   });
 };
 
-export default PickListFieldTranslator;
+export default PickListFieldTranslator;
+
+const ColouredPickListFieldTranslator = (field, value, appendToActionPayload) => {
+  const {
+    uiType,
+    name,
+    pickListValues
+  } = field;
+  return ColouredPickListFieldModel({
+    uiType: uiType || FieldTypes.ColouredPickListField,
+    appendToActionPayload,
+    options: pickListValues.map(option => ({ ...option,
+      colorCode: option.colorCode || ''
+    })),
+    name,
+    value
+  });
+};

package/es/platform/zlist/adapters/presenters/translators/interfaces/Context.js

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

package/es/platform/zlist/adapters/presenters/translators/interfaces/FieldComponentMapping.js

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

package/es/platform/zlist/adapters/presenters/translators/interfaces/ModifiedFieldWidths.js

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

package/es/platform/zlist/adapters/presenters/translators/interfaces/PreferencesProperties.js

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

package/es/platform/zlist/adapters/presenters/utils/DefaultClientActions.js

@@ -0,0 +1,54 @@
+import ClientAction from "../../../../client-actions/behaviour/zclient-actions/domain/entities/ClientAction";
+
+class DefaultClientActions {
+  static constructAction(clientAction) {
+    return new ClientAction(clientAction).toObject();
+  }
+
+  static constructSortAction() {
+    return this.constructAction({
+      uiComponentMapping: {
+        component: 'TableColumnSort',
+        name: 'SortBy',
+        propertiesValueMapping: {
+          value: '{{@context.field.sort.order}}',
+          ascendingLabel: 'Ascending',
+          descendingLabel: 'Descending'
+        },
+        eventMappings: [{
+          payloadValueMapping: {
+            id: '{{@context.field.id}}',
+            name: '{{@context.field.name}}',
+            order: `{{@payload.value}}`
+          },
+          sourceEvent: 'SORT#CLICKED',
+          targetEvent: 'SMART_TABLE#SORT',
+          id: '4000000080005'
+        }],
+        id: '4000000080003'
+      },
+      conditions: {
+        fields: [{
+          fieldName: 'field.isSortable',
+          condition: '=',
+          value: ['true']
+        }],
+        pattern: '1'
+      },
+      location: 'header_actions',
+      id: '4000000080009',
+      modules: ['MODULE'],
+      name: 'SortBy Action',
+      component: 'SmartTable',
+      modifiedTime: '2024-11-21T06:11:59.000Z',
+      createdTime: '2024-11-21T06:11:59.000Z'
+    });
+  }
+
+  static createSortActions(fields, clientActions) {
+    return [...clientActions, this.constructSortAction()];
+  }
+
+}
+
+export default DefaultClientActions;

package/es/platform/zlist/adapters/presenters/utils/calculateFieldWidths.js

@@ -0,0 +1,34 @@
+import ColumnSizeTranslator from "../translators/ColumnSizeTranslator";
+export function calculateFieldWidths(fields, modifiedFieldWidths, preferences) {
+  const modifiedWidths = {};
+
+  if (!fields) {
+    return modifiedWidths;
+  }
+
+  function decideWidth(width, fieldName, type) {
+    var _preferences$fields, _preferences$fields$f;
+
+    if (width !== undefined && width !== null) {
+      return width;
+    }
+
+    const initialWidth = (_preferences$fields = preferences.fields) === null || _preferences$fields === void 0 ? void 0 : (_preferences$fields$f = _preferences$fields[fieldName]) === null || _preferences$fields$f === void 0 ? void 0 : _preferences$fields$f.initialWidth;
+
+    if (initialWidth !== undefined && initialWidth !== null) {
+      return initialWidth;
+    }
+
+    return ColumnSizeTranslator(type);
+  }
+
+  fields.forEach(field => {
+    const {
+      name,
+      type
+    } = field;
+    const width = modifiedFieldWidths[name];
+    modifiedWidths[name] = decideWidth(width, name, type);
+  });
+  return modifiedWidths;
+}

package/es/platform/zlist/applications/entities-factory/ListFactory.js

@@ -5,10 +5,10 @@ class ListFactory {
     const {
       limit,
       sortBy,
-      filter,
-      pageContext
+      query,
+      context
     } = input;
-    return new List(limit, sortBy, filter, pageContext);
+    return new List(limit, sortBy, query, context);
   }
 
 }

package/es/platform/zlist/applications/interfaces/output/IPresenter.js

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

package/es/platform/zlist/applications/usecases/AbstractUseCase.js

@@ -4,11 +4,13 @@ class AbstractUseCase {
     this.execute = this.execute.bind(this);
   }
 
-  updateDependency(state) {
+  updateDependency(state, updateState) {
     const {
-      repository
+      repository,
+      presenter
     } = this.dependencies;
     repository.init(state);
+    presenter.updateDependencies(state, updateState);
   }
 
 }

package/es/platform/zlist/applications/usecases/DeleteSuccessUseCase.js

@@ -0,0 +1,19 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class DeleteSuccessUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      dispatch,
+      recordId
+    } = input;
+    const {
+      repository
+    } = this.dependencies;
+    const list = repository.getList();
+    const action = list.getDeleteSuccessAction(recordId);
+    dispatch(action);
+  }
+
+}
+
+export default DeleteSuccessUseCase;

package/es/platform/zlist/applications/usecases/RecordSuccessCallbackUsecase.js

@@ -0,0 +1,24 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class RecordSuccessCallbackUsecase extends AbstractUseCase {
+  execute(input) {
+    const {
+      dispatch,
+      payload,
+      metaData
+    } = input;
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    const list = repository.getList();
+
+    if (list.isAcknowledgeBySortBy(metaData)) {
+      list.setSortBy(metaData);
+      presenter.updateView(list.toObject());
+    }
+  }
+
+}
+
+export default RecordSuccessCallbackUsecase;

package/es/platform/zlist/applications/usecases/SortUseCase.js

@@ -1,3 +1,4 @@
+import { SmartTableConstants } from "../../../../cc/table-connected";
 import AbstractUseCase from "./AbstractUseCase";
 
 class SortUseCase extends AbstractUseCase {
@@ -8,11 +9,16 @@ class SortUseCase extends AbstractUseCase {
     } = input;
     const {
       repository,
-      sortBy: sortByGateway
+      presenter
     } = this.dependencies;
     const list = repository.getList();
-    const sortByQueryString = sortByGateway.toQueryString(sortBy);
-    dispatch(list.createSortByRefetchAction(sortByQueryString));
+    list.setSortBy(sortBy);
+    dispatch(list.createRecordsRefetchAction());
+    dispatch({
+      type: SmartTableConstants.Events.SORTED,
+      payload: sortBy
+    });
+    presenter.updateView(list.toObject());
   }
 
 }

package/es/platform/zlist/applications/usecases/UpdateSuccessUseCase.js

@@ -0,0 +1,19 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class UpdateSuccessUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      dispatch,
+      recordId
+    } = input;
+    const {
+      repository
+    } = this.dependencies;
+    const list = repository.getList();
+    const action = list.getUpdateSuccessAction(recordId);
+    dispatch(action);
+  }
+
+}
+
+export default UpdateSuccessUseCase;

package/es/platform/zlist/domain/entities/List.js

@@ -1,55 +1,98 @@
 import { RECORD_EXECUTE, RECORD_FETCH_MORE, RECORD_REFETCH, RecordApiActionName } from "../../../../bc/zrecord/Constants";
 import { FIELD_EXECUTE, FIELD_REFETCH } from "../../../../bc/zfield/Constants";
 import { ZLIST_RECORD_DELETE_FAILED, ZLIST_RECORD_DELETE_SUCCEEDED, ZLIST_RECORD_UPDATE_FAILED, ZLIST_RECORD_UPDATE_SUCCEEDED } from "../../../../bc/zlist/Constants";
-import { CLIENTACTION_BEHAVIOUR_EXECUTE } from "../../../../bc/zclient-actions/Constants";
+import { CLIENTACTION_BEHAVIOUR_EXECUTE } from "../../../client-actions/bc/zclient-actions/Constants";
+import { SmartTableConstants } from "../../../../cc/table-connected";
+import SortBy from "./SortBy";
 
 class List {
-  constructor(limit, sortBy, filter, pageContext) {
+  constructor(limit, sortBy, query, context) {
     this.limit = limit;
     this.sortBy = sortBy;
-    this.filter = filter;
-    this.pageContext = pageContext;
+    this.query = query;
+    this.context = context;
+  }
+
+  toObject() {
+    return {
+      sortBy: this.sortBy.toObject()
+    };
+  }
+
+  setSortBy(sortBy) {
+    this.sortBy = new SortBy(sortBy.id, sortBy.name, sortBy.order);
+  }
+
+  toggleSortBy() {
+    const {
+      id,
+      name
+    } = this.sortBy;
+    this.sortBy.doSorting(id, name);
+  }
+
+  isAcknowledgeBySortBy(metaData) {
+    return metaData && metaData['SMART_TABLE#SORTED'];
   }
 
   createApiProps() {
     const {
-      filter,
+      query,
       limit,
       sortBy,
-      pageContext
+      context
     } = this;
     return {
       limit,
-      sortBy,
-      ...filter,
-      ...pageContext
+      sortBy: sortBy.toQueryString(),
+      ...query,
+      ...context
     };
   }
 
-  createSortByRefetchAction(sortBy) {
-    this.sortBy = sortBy;
-    return this.createRecordsRefetchAction();
-  }
-
   getInitialMountFetchActions() {
     return [this.createRecordsFetchAction(), this.createAvailableFieldsFetchAction(), this.createSelectedFieldsFetchAction(), this.createClientActionsFetchAction()];
   }
 
+  shallowDiff(obj1, obj2) {
+    const allKeys = new Set([...Object.keys(obj1), ...Object.keys(obj2)]);
+
+    for (const key of allKeys) {
+      if (obj1[key] !== obj2[key]) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
   getPropertiesChangeRefetchActions(previousProperties, currentProperties) {
     const {
       sortBy: prevSortBy,
-      filter: prevFilter
+      departmentId: preDepartmentId,
+      viewId: preViewId,
+      query: preQuery
     } = previousProperties;
     const {
       sortBy: sortBy,
-      filter: currentFilter
+      departmentId: currentDepartmentId,
+      viewId: currentViewId,
+      query: curQuery
     } = currentProperties;
 
     if (prevSortBy !== sortBy) {
       return [this.createRecordsRefetchAction()];
     }
 
-    if (prevFilter.departmentId !== currentFilter.departmentId || prevFilter.viewId !== currentFilter.viewId) {
+    if (preDepartmentId !== currentDepartmentId) {
+      return [this.createRecordsRefetchAction(), this.createAvailableFieldsFetchAction(), this.createSelectedFieldsFetchAction()];
+    }
+
+    if (preViewId !== currentViewId) {
+      return [this.createRecordsRefetchAction(), this.createSelectedFieldsFetchAction()];
+    }
+
+    if (this.shallowDiff(preQuery, curQuery)) {
       return [this.createRecordsRefetchAction(), this.createAvailableFieldsFetchAction(), this.createSelectedFieldsFetchAction() // TODO: this.createAvailableFieldsRefetchAction(),
       // TODO: this.createSelectedFieldsRefetchAction()
       ];
@@ -115,6 +158,20 @@ class List {
     };
   }
 
+  getDeleteSuccessAction(recordIds) {
+    return {
+      type: SmartTableConstants.Events.DELETE_RECORDS_SUCCESS,
+      payload: recordIds
+    };
+  }
+
+  getUpdateSuccessAction(recordId) {
+    return {
+      type: SmartTableConstants.Events.UPDATE_RECORDS_SUCCESS,
+      payload: recordId
+    };
+  }
+
   getRecordExecuteSucceededActions(payload, metaData) {
     const {
       actionName
@@ -249,15 +306,21 @@ class List {
     };
   }
 
-  createRecordsRefetchAction() {
+  createRecordsRefetchAction(triggerer) {
     const props = this.createApiProps();
+    const metaData = triggerer === 'sortBy' && {
+      ['SMART_TABLE#SORTED']: {
+        sortBy: this.sortBy.toObject()
+      }
+    };
     return {
       type: RECORD_REFETCH,
       payload: {
         actionName: RecordApiActionName.GET_RECORDS,
         props,
         apiName: 'records'
-      }
+      },
+      metaData
     };
   }
 

package/es/platform/zlist/domain/entities/SortBy.js

@@ -0,0 +1,58 @@
+import { SortOrder } from "./interfaces/Properties";
+
+class SortBy {
+  constructor(id, name, order) {
+    this.id = id;
+    this.name = name;
+    this.order = order;
+  }
+
+  toObject() {
+    return {
+      id: this.id,
+      name: this.name,
+      order: this.order
+    };
+  }
+
+  toQueryString() {
+    const {
+      name,
+      order
+    } = this;
+    let sortQueryString = '';
+
+    if (order === SortOrder.DES) {
+      sortQueryString = `-${name}`;
+    } else if (order === SortOrder.ASC) {
+      sortQueryString = name;
+    }
+
+    return sortQueryString;
+  }
+
+  doSorting(id, name) {
+    if (this.id === id) {
+      this.toggleSort();
+    } else {
+      this.resetSortBy(id, name);
+    }
+  }
+
+  toggleSort() {
+    if (this.order === SortOrder.ASC) {
+      this.order = SortOrder.DES;
+    } else {
+      this.order = SortOrder.ASC;
+    }
+  }
+
+  resetSortBy(id, name) {
+    this.id = id;
+    this.name = name;
+    this.order = SortOrder.ASC;
+  }
+
+}
+
+export default SortBy;

package/es/platform/zlist/domain/entities/interfaces/ISortBy.js

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

package/es/platform/zlist/domain/entities/interfaces/ListModel.js

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

package/es/platform/zlist/domain/entities/interfaces/Properties.js

@@ -1 +1,6 @@
-export {};
+export let SortOrder = /*#__PURE__*/function (SortOrder) {
+  SortOrder["NONE"] = "none";
+  SortOrder["ASC"] = "ascending";
+  SortOrder["DES"] = "descending";
+  return SortOrder;
+}({});