@zohodesk/library-platform 1.1.1 → 1.1.2

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

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

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

@@ -11,9 +11,7 @@ class SortController extends AbstractController {
       action,
       dispatch
     } = event;
-    const {
-      sortBy
-    } = action.payload;
+    const sortBy = action.payload;
     sortUseCase.updateDependency(state, updateState);
     sortUseCase.execute({
       sortBy,

package/es/platform/zlist/adapters/gateways/Repository.js

@@ -1,6 +1,7 @@
 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 ListFactory from "../../applications/entities-factory/ListFactory";
+import SortBy from "../../domain/entities/SortBy";
 
 class Repository {
   constructor() {
@@ -13,13 +14,15 @@ class Repository {
 
   getList() {
     const {
-      sortBy,
       departmentId,
       viewId,
       moduleName,
       query,
       context
     } = this.state.properties;
+    const {
+      sortBy
+    } = this.getZListState();
     const list = ListFactory.createList({
       context,
       query: {
@@ -28,12 +31,19 @@ class Repository {
         moduleName,
         ...query
       },
-      sortBy,
+      sortBy: new SortBy(sortBy.id, sortBy.name, sortBy.order),
       limit: 50
     });
     return list;
   }
 
+  getZListState() {
+    const {
+      zlist
+    } = this.state.behaviours;
+    return zlist;
+  }
+
 }
 
 export default Repository;

package/es/platform/zlist/adapters/gateways/Service.js

@@ -12,6 +12,7 @@ import RecordExecuteSucceededUseCase from "../../applications/usecases/RecordExe
 import RecordExecuteFailedUseCase from "../../applications/usecases/RecordExecuteFailedUseCase";
 import UpdateSuccessUseCase from "../../applications/usecases/UpdateSuccessUseCase";
 import DeleteSuccessUseCase from "../../applications/usecases/DeleteSuccessUseCase";
+import RecordSuccessCallbackUsecase from "../../applications/usecases/RecordSuccessCallbackUsecase";
 
 class Service {
   constructor(dependencies) {
@@ -31,6 +32,8 @@ class Service {
 
     _defineProperty(this, "recordExecuteSucceededUseCase", void 0);
 
+    _defineProperty(this, "recordSuccessCallbackUseCase", void 0);
+
     _defineProperty(this, "recordExecuteFailedUseCase", void 0);
 
     _defineProperty(this, "sortUseCase", void 0);
@@ -49,6 +52,7 @@ class Service {
     this.deleteMultipleRecordUseCase = new DeleteMultipleRecordUseCase(this.dependencies);
     this.deleteSingleRecordUseCase = new DeleteSingleRecordUseCase(this.dependencies);
     this.recordExecuteSucceededUseCase = new RecordExecuteSucceededUseCase(this.dependencies);
+    this.recordSuccessCallbackUseCase = new RecordSuccessCallbackUsecase(this.dependencies);
     this.recordExecuteFailedUseCase = new RecordExecuteFailedUseCase(this.dependencies);
     this.recordUpdateUseCase = new RecordUpdateUseCase(this.dependencies);
     this.updateSuccessUseCase = new UpdateSuccessUseCase(this.dependencies);

package/es/platform/zlist/adapters/presenters/Presenters.js

@@ -0,0 +1,26 @@
+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; }
+
+class Presenter {
+  constructor() {
+    _defineProperty(this, "updateState", void 0);
+
+    _defineProperty(this, "state", void 0);
+  }
+
+  updateDependencies(state, updateState) {
+    this.updateState = updateState;
+    this.state = state;
+  }
+
+  updateView(zlist) {
+    this.state = { ...this.state,
+      behaviours: { ...this.state.behaviours,
+        zlist
+      }
+    };
+    this.updateState(this.state);
+  }
+
+}
+
+export default Presenter;

package/es/platform/zlist/adapters/presenters/TableTranslator.js

@@ -5,11 +5,18 @@ import RowsTranslator from "./translators/RowsTranslator";
 import Pipeline from "./utils/Pipeline";
 import RowCursor from "../../../../cc/table-list/data-types/RowCursor";
 import { TableListConstants } from "../../../../cc/table-list";
+import { ResizerStateTranslator } from "./translators/ResizerStateTranslator";
+import { calculateFieldWidths } from "./utils/calculateFieldWidths";
+import DefaultClientActions from "./utils/DefaultClientActions";
+const EMPTY_OBJECT = {};
+const EMPTY_ARRAY = [];
 
 const fallbackToDefault = (value, defaultValue) => [undefined, null].includes(value) ? defaultValue : value;
 
 export default class TableTranslator {
   static transformState(state) {
+    var _localStorageBehaviou, _localStorageBehaviou2;
+
     const {
       behaviours,
       properties
@@ -18,14 +25,27 @@ export default class TableTranslator {
       componentMapping,
       context
     } = properties;
+    const {
+      localStorage: localStorageBehaviour,
+      columnResizer
+    } = behaviours;
+    const {
+      resizeConfig,
+      preferences
+    } = properties;
     context['servicePrefix'] = 'supportapi/zd'; // FIX: servicePrefix defaultValue should be available from properties
 
     const {
+      zlist,
       zrecord,
       zfield,
       zclientAction
     } = fallbackToDefault(behaviours, {}); // FIX: behaviours should be available by default
 
+    const {
+      sortBy
+    } = fallbackToDefault(zlist, {}); // FIX: zlist should be available by default
+
     const {
       records,
       isFetching: isRecordsFetching
@@ -36,7 +56,7 @@ export default class TableTranslator {
       isFetching: isClientActionsFetching
     } = fallbackToDefault(zclientAction, {}); // FIX: zclientAction should be available by defaultlt
 
-    const fieldComponentMapping = componentMapping.fields;
+    const fieldComponentMapping = fallbackToDefault(componentMapping.fields, {});
     const rowActionsUiType = componentMapping.rowActionsComponentName;
     const {
       fields: availableFields,
@@ -47,15 +67,23 @@ export default class TableTranslator {
 
     const isLoading = !!(isRecordsFetching || isAvailableFieldsFetching || isSelectedFieldsFetching);
     const fields = selectedFields === null || selectedFields === void 0 ? void 0 : selectedFields.map(selectedField => availableFields === null || availableFields === void 0 ? void 0 : availableFields.find(availableField => availableField.name === selectedField)).filter(f => f != undefined);
+    const newClientActions = DefaultClientActions.createSortActions(fields, clientActions || EMPTY_ARRAY);
     const {
       headerActions,
       fieldActions,
       rowActions,
       noLocation
-    } = mapClientActions(clientActions || []);
+    } = mapClientActions(newClientActions || EMPTY_ARRAY);
     const isRowClickable = noLocation.some(action => action.uiComponentMapping.eventMappings.some(mapping => mapping.sourceEvent === TableListConstants.TABLE_LIST_ROW_CLICKED));
     const rowCursor = isRowClickable ? RowCursor.Pointer : RowCursor.Default;
-    const headersTranslator = new HeadersTranslator(fields, headerActions, context);
+    const {
+      moduleName,
+      viewId
+    } = properties; // TODO: move this to a separate file as selector
+
+    const localStorageFieldWidths = fallbackToDefault(localStorageBehaviour === null || localStorageBehaviour === void 0 ? void 0 : (_localStorageBehaviou = localStorageBehaviour[moduleName]) === null || _localStorageBehaviou === void 0 ? void 0 : (_localStorageBehaviou2 = _localStorageBehaviou[viewId]) === null || _localStorageBehaviou2 === void 0 ? void 0 : _localStorageBehaviou2.modifiedWidths, EMPTY_OBJECT);
+    const modifiedWidths = calculateFieldWidths(fields, localStorageFieldWidths, preferences);
+    const headersTranslator = new HeadersTranslator(fields, headerActions, context, modifiedWidths, sortBy);
     const rowsTranslator = new RowsTranslator(records, fields, rowActions, context, fieldComponentMapping, rowActionsUiType, fieldActions); // const actionTranslator = new ClientActionsTranslator(clientActions, records, fields, pageContext);
     // const translators = [headersTranslator.getTranslator(), rowsTranslator.getTranslator(), actionTranslator.getTranslator()];
 
@@ -66,7 +94,14 @@ export default class TableTranslator {
       properties,
       behaviours,
       selection: behaviours === null || behaviours === void 0 ? void 0 : behaviours.selection,
+      sortBy,
       rowCursor,
+      resizerState: ResizerStateTranslator({
+        columnResizer: columnResizer,
+        resizeConfig: resizeConfig,
+        headerNames: selectedFields,
+        modifiedWidths
+      }),
       rowActionsConfig: {
         hasActions: Boolean(rowActions === null || rowActions === void 0 ? void 0 : rowActions.length),
         // Boolean(newRowActions?.length),

package/es/platform/zlist/adapters/presenters/translators/ColumnTranslator.js

@@ -2,9 +2,11 @@ import EmptyViewModel from "./EmptyViewModel";
 import * as FieldTranslators from "./fields";
 import ClientActionsTranslator from "../../../../client-actions/translators/client-actions-translator";
 
-function ColumnTranslator(field, record, fieldComponentMapping, fieldActions) {
+function ColumnTranslator(fieldModel, record, fieldComponentMapping, fieldActions) {
   var _record$cf;
 
+  const field = { ...fieldModel
+  };
   const {
     isCustomField,
     name,

package/es/platform/zlist/adapters/presenters/translators/Header.js

@@ -1,8 +1,8 @@
-import ColumnSizeTranslator from "./ColumnSizeTranslator";
 import ColumnAlignmentTranslator from "./ColumnAlignmentTranslator";
 import ClientActionsTranslator from "../../../../client-actions/translators/client-actions-translator";
+import { SortOrder } from "../../../../zlist/domain/entities/interfaces/Properties";
 
-function HeaderTranslator(field, actions, context) {
+function HeaderTranslator(field, actions, context, modifiedWidths, sortBy) {
   const {
     id,
     name,
@@ -10,18 +10,43 @@ function HeaderTranslator(field, actions, context) {
     isSortable,
     type
   } = field;
+  const newField = { ...field,
+    sort: translateSortBy(field.id, sortBy)
+  };
   const transformedActions = ClientActionsTranslator.transform(actions, { ...context,
-    field
+    field: newField
   });
+  const width = modifiedWidths[name];
   return {
     id: id,
     name: name,
     text: displayLabel,
     sortable: isSortable,
     alignment: ColumnAlignmentTranslator(type),
-    width: ColumnSizeTranslator(type),
+    width,
     actions: transformedActions
   };
 }
 
-export default HeaderTranslator;
+export default HeaderTranslator;
+
+function translateSortBy(id, sortBy) {
+  const newSortBy = { ...sortBy,
+    tooltip: ''
+  };
+
+  if (sortBy.id === id) {
+    if (sortBy.order === SortOrder.ASC) {
+      newSortBy.tooltip = 'Click to Sort Descending';
+    } else if (newSortBy.order === SortOrder.DES) {
+      newSortBy.tooltip = 'Click to Sort Ascending';
+    } else if (newSortBy.order === SortOrder.NONE) {
+      newSortBy.tooltip = 'Click to Sort';
+    }
+  } else {
+    newSortBy.order = SortOrder.NONE;
+    newSortBy.tooltip = 'Click to Sort';
+  }
+
+  return newSortBy;
+}

package/es/platform/zlist/adapters/presenters/translators/HeadersTranslator.js

@@ -1,9 +1,11 @@
 import HeaderTranslator from "./Header";
 export default class HeadersTranslator {
-  constructor(fields, actions, context) {
+  constructor(fields, actions, context, modifiedWidths, sortBy) {
     this.fields = fields;
     this.actions = actions;
     this.context = context;
+    this.modifiedWidths = modifiedWidths;
+    this.sortBy = sortBy;
     this.pipe = this.pipe.bind(this);
   }
 
@@ -12,7 +14,7 @@ export default class HeadersTranslator {
       return [];
     }
 
-    return this.fields.map(field => HeaderTranslator(field, this.actions, this.context));
+    return this.fields.map(field => HeaderTranslator(field, this.actions, this.context, this.modifiedWidths, this.sortBy));
   }
 
   pipe(viewModel) {

package/es/platform/zlist/adapters/presenters/translators/ResizerStateTranslator.js

@@ -0,0 +1,98 @@
+const defaultResizerUiState = {
+  isEnabled: false,
+  isCurrentlyResizing: false,
+  currentlyResizingColumn: '',
+  extraWidth: 0,
+  initialPosition: 0,
+  resizedPosition: 0,
+  tooltip: ''
+};
+export function ResizerStateTranslator(_ref) {
+  let {
+    columnResizer,
+    resizeConfig,
+    headerNames,
+    modifiedWidths
+  } = _ref;
+  const {
+    isEnabled: isEnabled,
+    minWidth,
+    maxWidth
+  } = resizeConfig;
+
+  if (!columnResizer || !headerNames || headerNames.length === 0) {
+    return { ...defaultResizerUiState,
+      isEnabled
+    };
+  }
+
+  const {
+    isResizing,
+    allowedWidth,
+    columnName,
+    initialPosition,
+    resizedPosition
+  } = columnResizer.resizerState; // const extraWidth = allowedWidth - (resizedPosition - initialPosition);
+  // MUST: be calculated based on the columnName and modifiedWidths
+
+  const extraWidth = calculateExtraSpaceWidth({
+    headerNames,
+    modifiedWidths,
+    columnName,
+    maxWidth
+  });
+  const tooltip = tooltipI18nHandler({
+    minWidth,
+    maxWidth,
+    width: allowedWidth
+  });
+  return {
+    isEnabled,
+    isCurrentlyResizing: isResizing,
+    currentlyResizingColumn: columnName,
+    extraWidth,
+    initialPosition,
+    resizedPosition,
+    tooltip
+  };
+}
+
+function tooltipI18nHandler(_ref2) {
+  let {
+    minWidth,
+    maxWidth,
+    width
+  } = _ref2;
+
+  if (width === maxWidth) {
+    // return `Max width (${width}px) reached`;
+    return `Max Limit Reached ${width}`;
+  }
+
+  if (width === minWidth) {
+    // return `Min width (${width}px) reached`;
+    return `Min Limit Reached ${width}`;
+  } // return `Width: ${width}px`;
+
+
+  return `Width - ${width}px`;
+}
+
+function calculateExtraSpaceWidth(_ref3) {
+  let {
+    headerNames,
+    modifiedWidths,
+    columnName,
+    maxWidth
+  } = _ref3;
+  const index = headerNames.indexOf(columnName);
+
+  if (index === -1) {
+    return 0;
+  }
+
+  const resizableSpace = headerNames.slice(index + 1).reduce((resizableSpace, columnName) => {
+    return resizableSpace + modifiedWidths[columnName];
+  }, 0);
+  return Math.max(0, maxWidth - resizableSpace);
+}

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

@@ -0,0 +1,26 @@
+import FieldTypes from "../../../../../../cc/fields/field/Types";
+import FormulaFieldModel from "../../../../../../cc/fields/formula/Model";
+
+const FormulaFieldTranslator = (field, value, appendToActionPayload) => {
+  const {
+    uiType,
+    name
+  } = field;
+  const fieldTypeFactory = {
+    STRING: FieldTypes.SingleLineField,
+    BOOLEAN: FieldTypes.CheckboxField,
+    DECIMAL: FieldTypes.DecimalField,
+    CURRENCY: FieldTypes.CurrencyField,
+    DATE: FieldTypes.DateField,
+    DATETIME: FieldTypes.DateTimeField
+  };
+  const setFieldType = fieldTypeFactory[field.returnType] || FieldTypes.SingleLineField;
+  return FormulaFieldModel({
+    uiType: uiType || setFieldType,
+    appendToActionPayload,
+    name,
+    value
+  });
+};
+
+export default FormulaFieldTranslator;

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/fields/index.js

@@ -13,7 +13,8 @@ export { default as Date } from "./DateFieldTranslator";
 export { default as DateTime } from "./DateTimeFieldTranslator";
 export { default as Picklist } from "./PickListFieldTranslator";
 export { default as Multiselect } from "./MultiSelectFieldTranslator";
-export { default as LookUp } from "./LookUpFieldTranslator"; // // Field Name is to be similar to the API response
+export { default as LookUp } from "./LookUpFieldTranslator";
+export { default as Formula } from "./FormulaFieldTranslator"; // // Field Name is to be similar to the API response
 // class FieldTranslator {
 //   static translate(field, value) {
 //     const { type } = field;

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/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);
   }
 
 }