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

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/controllers/UpdateSuccessController.js

@@ -0,0 +1,25 @@
+import AbstractController from "./AbstractController";
+
+class UpdateSuccessController extends AbstractController {
+  handle(event) {
+    const {
+      state,
+      dispatch,
+      action
+    } = event;
+    const {
+      recordId
+    } = action.payload;
+    const {
+      updateSuccessUseCase
+    } = this.service;
+    updateSuccessUseCase.updateDependency(state);
+    updateSuccessUseCase.execute({
+      dispatch,
+      recordId
+    });
+  }
+
+}
+
+export default UpdateSuccessController;

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,26 +14,36 @@ class Repository {
 
   getList() {
     const {
-      limit,
-      sortBy,
-      filter,
+      departmentId,
+      viewId,
       moduleName,
-      pageContext
+      query,
+      context
     } = this.state.properties;
+    const {
+      sortBy
+    } = this.getZListState();
     const list = ListFactory.createList({
-      pageContext,
-      filter: { ...filter,
-        departmentId: filter.departmentId,
-        viewId: filter.viewId,
-        orgId: filter.orgId,
-        moduleName
+      context,
+      query: {
+        departmentId,
+        viewId,
+        moduleName,
+        ...query
       },
-      sortBy,
-      limit
+      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

@@ -10,6 +10,9 @@ import RecordUpdateUseCase from "../../applications/usecases/RecordUpdateUseCase
 import DeleteSingleRecordUseCase from "../../applications/usecases/DeleteSingleRecordUseCase";
 import RecordExecuteSucceededUseCase from "../../applications/usecases/RecordExecuteSucceededUseCase";
 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) {
@@ -29,12 +32,18 @@ class Service {
 
     _defineProperty(this, "recordExecuteSucceededUseCase", void 0);
 
+    _defineProperty(this, "recordSuccessCallbackUseCase", void 0);
+
     _defineProperty(this, "recordExecuteFailedUseCase", void 0);
 
     _defineProperty(this, "sortUseCase", void 0);
 
     _defineProperty(this, "recordUpdateUseCase", void 0);
 
+    _defineProperty(this, "updateSuccessUseCase", void 0);
+
+    _defineProperty(this, "deleteSuccessUseCase", void 0);
+
     this.initializeUseCase = new InitializeUseCase(this.dependencies);
     this.propertiesChangeUseCase = new PropertiesChangeUseCase(this.dependencies);
     this.fetchMoreUseCase = new FetchMoreUseCase(this.dependencies);
@@ -43,8 +52,11 @@ 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);
+    this.deleteSuccessUseCase = new DeleteSuccessUseCase(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,54 +5,59 @@ 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;
 
-const splitActions = rowActions => {
-  const noUiActions = [];
-  const newRowActions = [];
-  rowActions.forEach(action => {
-    if (!action.uiType || action.uiType === 'no-ui') {
-      noUiActions.push(action);
-    } else {
-      newRowActions.push(action);
-    }
-  });
-  return {
-    noUiActions,
-    newRowActions
-  };
-};
-
 export default class TableTranslator {
   static transformState(state) {
+    var _localStorageBehaviou, _localStorageBehaviou2;
+
     const {
       behaviours,
       properties
     } = state;
     const {
-      uiMapping,
-      rowActions,
-      pageContext
+      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
+      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
-    } = fallbackToDefault(zrecord, {}); // FIX: zrecord should be available by default
+    } = fallbackToDefault(zrecord, {}); // FIX: zrecord should be available by defau
 
-    const fieldUiMapping = uiMapping.fields;
-    const rowActionsUiType = uiMapping.rowActionsComponentName;
     const {
-      noUiActions,
-      newRowActions
-    } = splitActions(rowActions);
-    const isRowClickable = noUiActions.some(action => action.eventMapping.some(mapping => mapping.action.dispatchType === TableListConstants.TABLE_LIST_ROW_CLICKED));
-    const rowCursor = isRowClickable ? RowCursor.Pointer : RowCursor.Default;
+      clientActions,
+      isFetching: isClientActionsFetching
+    } = fallbackToDefault(zclientAction, {}); // FIX: zclientAction should be available by defaultlt
+
+    const fieldComponentMapping = fallbackToDefault(componentMapping.fields, {});
+    const rowActionsUiType = componentMapping.rowActionsComponentName;
     const {
       fields: availableFields,
       selectedFields,
@@ -62,22 +67,65 @@ 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 headersTranslator = new HeadersTranslator(fields);
-    const rowsTranslator = new RowsTranslator(records, fields, newRowActions, pageContext, fieldUiMapping, rowActionsUiType);
-    const translators = [headersTranslator.getTranslator(), rowsTranslator.getTranslator()]; // TODO: Implement ModuleTableModel, and move data and isLoading to tableViewModel Object
+    const newClientActions = DefaultClientActions.createSortActions(fields, clientActions || EMPTY_ARRAY);
+    const {
+      headerActions,
+      fieldActions,
+      rowActions,
+      noLocation
+    } = 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 {
+      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()];
+
+    const translators = [headersTranslator.getTranslator(), rowsTranslator.getTranslator()];
+    const data = Pipeline.run(translators, {}); // TODO: Implement ModuleTableModel, and move data and isLoading to tableViewModel Object
 
     return {
       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(newRowActions === null || newRowActions === void 0 ? void 0 : newRowActions.length),
+        hasActions: Boolean(rowActions === null || rowActions === void 0 ? void 0 : rowActions.length),
+        // Boolean(newRowActions?.length),
         columnWidth: ColumnWidth.XSmall
       },
       isLoading,
-      emptyStateUiType: uiMapping.emptyState || '',
-      data: Pipeline.run(translators, {})
+      emptyStateUiType: componentMapping.emptyState || '',
+      data
     };
   }
 
+}
+
+function mapClientActions(clientActions) {
+  const allowedActingLocations = ['header_actions', 'field_actions', 'row_actions', null];
+  clientActions.forEach(action => {
+    if (!allowedActingLocations.includes(action.location)) {
+      console.warn('Client action without location:', action.location);
+    }
+  });
+  return {
+    headerActions: clientActions.filter(action => action.location && action.location === 'header_actions'),
+    fieldActions: clientActions.filter(action => action.location && action.location === 'field_actions'),
+    rowActions: clientActions.filter(action => action.location && action.location === 'row_actions'),
+    noLocation: clientActions.filter(action => !action.location)
+  };
 }

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

@@ -1,7 +1,7 @@
-import { Width } from "../../../../../cc/table-list/data-types/Header"; // TODO: Need to get the final column width from the visual team
-
+import { Width } from "../../../../../cc/table-list/data-types/Header";
 const columnSizeMapping = {
   Multiselect: Width.XXLarge,
+  Email: Width.XLarge,
   Boolean: Width.Medium,
   Number: Width.Medium,
   Decimal: Width.Medium,

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

@@ -1,34 +1,44 @@
 import EmptyViewModel from "./EmptyViewModel";
 import * as FieldTranslators from "./fields";
+import ClientActionsTranslator from "../../../../client-actions/translators/client-actions-translator";
 
-function ColumnTranslator(field, record, fieldUiMapping) {
+function ColumnTranslator(fieldModel, record, fieldComponentMapping, fieldActions) {
   var _record$cf;
 
+  const field = { ...fieldModel
+  };
   const {
     isCustomField,
     name,
     type
   } = field;
   const value = isCustomField ? (_record$cf = record.cf) === null || _record$cf === void 0 ? void 0 : _record$cf[name] : record[name];
+  const actions = ClientActionsTranslator.transform(fieldActions, {
+    field,
+    record
+  });
 
   if (!value && value !== false) {
-    return EmptyViewModel(type);
+    return EmptyViewModel();
   }
 
-  if (fieldUiMapping[name]) {
-    field.uiType = fieldUiMapping[name];
+  if (fieldComponentMapping[name]) {
+    field.uiType = fieldComponentMapping[name];
   }
 
   const fieldTranslator = FieldTranslators[type];
 
   if (!fieldTranslator) {
     console.error(`Field type ${type} not supported`);
-    return EmptyViewModel(type);
+    return EmptyViewModel();
   }
 
-  return fieldTranslator(field, value, {
-    recordId: record.id
-  });
+  return {
+    actions,
+    ...fieldTranslator(field, value, {
+      recordId: record.id
+    })
+  };
 }
 
 export default ColumnTranslator;

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

@@ -1,7 +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) {
+function HeaderTranslator(field, actions, context, modifiedWidths, sortBy) {
   const {
     id,
     name,
@@ -9,14 +10,43 @@ function HeaderTranslator(field) {
     isSortable,
     type
   } = field;
+  const newField = { ...field,
+    sort: translateSortBy(field.id, sortBy)
+  };
+  const transformedActions = ClientActionsTranslator.transform(actions, { ...context,
+    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,7 +1,11 @@
 import HeaderTranslator from "./Header";
 export default class HeadersTranslator {
-  constructor(fields) {
+  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);
   }
 
@@ -10,7 +14,7 @@ export default class HeadersTranslator {
       return [];
     }
 
-    return this.fields.map(field => HeaderTranslator(field));
+    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/Row.js

@@ -1,20 +1,24 @@
 import ColumnTranslator from "./ColumnTranslator";
-import RowActionTranslator from "./RowActionTranslator";
+import ClientActionsTranslator from "../../../../client-actions/translators/client-actions-translator";
 export default function RowTranslator(_ref) {
   let {
     record,
     fields,
-    fieldUiMapping,
+    fieldComponentMapping,
     rowActionsUiType,
     rowActions,
-    pageContext
+    fieldActions,
+    context
   } = _ref;
+  const actions = ClientActionsTranslator.transform(rowActions, { ...context,
+    record
+  });
   return {
     id: record.id,
-    columns: fields.map(field => ColumnTranslator(field, record, fieldUiMapping)),
+    columns: fields.map(field => ColumnTranslator(field, record, fieldComponentMapping, fieldActions)),
     rowActionLocation: {
-      type: rowActionsUiType || '',
-      actions: rowActions.map(rowAction => RowActionTranslator(rowAction, record, pageContext))
+      type: rowActionsUiType,
+      actions
     }
   };
 }

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

@@ -1,12 +1,12 @@
-import TemplateHelpers from "../../../../zdata-broker/adapters/gateways/TemplateHelpers";
+import TemplateHelpers from "../../../../zdata-source/adapters/gateways/TemplateHelpers";
 const templateHelpers = new TemplateHelpers();
-export default function RowActionTranslator(rowAction, record, pageContext) {
+export default function RowActionTranslator(rowAction, record, context) {
   const templateContext = {
-    orgName: pageContext.orgName,
-    departmentName: pageContext.departmentName,
-    moduleSanitatedName: pageContext.moduleSanitatedName,
+    orgName: context.orgName,
+    departmentName: context.departmentName,
+    moduleSanitatedName: context.moduleSanitatedName,
     record,
-    moduleName: pageContext.moduleName,
+    moduleName: context.moduleName,
     recordId: record.id
   };
   const properties = PropertiesTranslator(rowAction.properties, templateContext);

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

@@ -1,12 +1,13 @@
 import RowTranslator from "./Row";
 export default class RowsTranslator {
-  constructor(records, fields, rowActions, pageContext, fieldUiMapping, rowActionsUiType) {
+  constructor(records, fields, rowActions, context, fieldComponentMapping, rowActionsUiType, fieldActions) {
     this.records = records;
     this.fields = fields;
     this.rowActions = rowActions;
-    this.pageContext = pageContext;
-    this.fieldUiMapping = fieldUiMapping;
+    this.context = context;
+    this.fieldComponentMapping = fieldComponentMapping;
     this.rowActionsUiType = rowActionsUiType;
+    this.fieldActions = fieldActions;
     this.pipe = this.pipe.bind(this);
   }
 
@@ -18,10 +19,11 @@ export default class RowsTranslator {
     return this.records.map(record => RowTranslator({
       record,
       fields: this.fields,
-      fieldUiMapping: this.fieldUiMapping,
+      fieldComponentMapping: this.fieldComponentMapping,
       rowActionsUiType: this.rowActionsUiType,
       rowActions: this.rowActions,
-      pageContext: this.pageContext
+      fieldActions: this.fieldActions,
+      context: this.context
     }));
   }