@zohodesk/library-platform 1.0.0 → 1.0.2-exp.1.0

package/es/platform/zhttp/applications/usecases/FetchUseCase.ts

@@ -0,0 +1,63 @@
+/* eslint-disable @zohodesk/architecturerules/no-returnStatement-rule */
+/* eslint-disable max-lines-per-function */
+import { FETCH_FAILED, FETCH_SUCCESS_NO_CONTENT, FETCH_REQUESTED, FETCH_SUCCESS } from '@bc/zhttp/Constants';
+import FetchInputModel from '../interfaces/input/FetchInputModel';
+import AbstractUseCase from './AbstractUseCase';
+
+class FetchUseCase extends AbstractUseCase<FetchInputModel> {
+  async execute(inputModel: FetchInputModel): Promise<void> {
+    const { fetchGateWay } = this.dependencies;
+    const { url, method = 'GET', getResponse } = inputModel;
+    const { metaData, dispatch, payload, headers } = inputModel;
+
+    dispatch({
+      type: FETCH_REQUESTED,
+      payload: {
+        url,
+        method,
+        headers,
+        metaData
+      }
+    });
+
+    try {
+      // NOTE: getResponse is hacky solution to get the data using function call instead of fetch, So any handling added to here needs to be added to fetch and vise versa
+      if (typeof getResponse === 'function') {
+        const data = await getResponse();
+        if (data === undefined) {
+          dispatch({ type: FETCH_SUCCESS_NO_CONTENT, payload: {}, metaData });
+        } else {
+          dispatch({
+            type: FETCH_SUCCESS,
+            payload: { response: data },
+            metaData
+          });
+        }
+      } else {
+        const response = await fetchGateWay.fetch(url, { headers, method, body: method === 'GET' ? null : payload });
+        if (response.ok) {
+          if (response.status === 204) {
+            dispatch({ type: FETCH_SUCCESS_NO_CONTENT, payload: {}, metaData });
+          } else if (response.status === 200 && method === 'DELETE') {
+            dispatch({ type: FETCH_SUCCESS, payload: {}, metaData });
+          } else {
+            const data = await response.json();
+
+            dispatch({
+              type: FETCH_SUCCESS,
+              payload: { response: data },
+              metaData
+            });
+          }
+        } else {
+          const data = await response.json();
+          dispatch({ type: FETCH_FAILED, payload: { error: data }, metaData });
+        }
+      }
+    } catch (e) {
+      dispatch({ type: FETCH_FAILED, payload: { error: e }, metaData });
+    }
+  }
+}
+
+export default FetchUseCase;

package/es/platform/zhttp/frameworks/ActionsHandlerFactory.ts

@@ -0,0 +1,19 @@
+import { FETCH } from '@bc/zhttp/Constants';
+import ZHttpActionHandlers from '@bc/zhttp/ActionHandlers';
+import FetchController from '../adapters/controllers/FetchController';
+import FetchUseCase from '../applications/usecases/FetchUseCase';
+import FetchGateWay from '../adapters/gateway/FetchGateWay';
+
+class ActionsHandlersFactory {
+  static create(windowFetch): ZHttpActionHandlers {
+    const fetchGateWay = new FetchGateWay(windowFetch);
+    const fetchUseCase = new FetchUseCase({ fetchGateWay: fetchGateWay });
+
+    const fetchController = new FetchController(fetchUseCase);
+
+    return {
+      [FETCH]: fetchController.handle
+    };
+  }
+}
+export default ActionsHandlersFactory;

package/es/platform/zhttp/frameworks/ZHttpBehaviourFactory.ts

@@ -0,0 +1,16 @@
+import Behaviour from '@cc/component/Behaviour';
+import Properties from '@bc/zhttp/Properties';
+import ActionsHandlersFactory from './ActionsHandlerFactory';
+
+export default class ZHttpBehaviourFactory {
+  static create(): Behaviour {
+    const behaviour: Behaviour = {
+      name: 'zhttp',
+      properties: Properties,
+      setInitialState: () => ({}),
+      eventHandlers: ActionsHandlersFactory.create(window.fetch.bind(window)),
+    };
+
+    return behaviour;
+  }
+}

package/es/platform/zlist/adapters/controllers/AbstractController.ts

@@ -0,0 +1,12 @@
+import IService from '../../applications/interfaces/gateways/IService';
+
+abstract class AbstractController {
+  constructor(protected service: IService) {
+    this.service = service;
+    this.handle = this.handle.bind(this);
+  }
+
+  abstract handle(event): void;
+}
+
+export default AbstractController;

package/es/platform/zlist/adapters/controllers/DeleteMultipleRecordController.ts

@@ -0,0 +1,12 @@
+import AbstractController from './AbstractController';
+
+export default class DeleteMultipleRecordController extends AbstractController {
+  handle(event: any) {
+    const { state, updateState, dispatch, action } = event;
+    const { recordIds } = action.payload;
+    const { deleteMultipleRecordUseCase } = this.service;
+
+    deleteMultipleRecordUseCase.updateDependency(state, updateState);
+    deleteMultipleRecordUseCase.execute({ dispatch, recordIds });
+  }
+}

package/es/platform/zlist/adapters/controllers/DeleteSingleRecordController.ts

@@ -0,0 +1,12 @@
+import AbstractController from './AbstractController';
+
+export default class DeleteSingleRecordController extends AbstractController {
+  handle(event: any) {
+    const { state, updateState, dispatch, action } = event;
+    const { recordId } = action.payload;
+    const { deleteSingleRecordUseCase } = this.service;
+
+    deleteSingleRecordUseCase.updateDependency(state, updateState);
+    deleteSingleRecordUseCase.execute({ dispatch, recordId });
+  }
+}

package/es/platform/zlist/adapters/controllers/DeleteSuccessController.ts

@@ -0,0 +1,14 @@
+import AbstractController from './AbstractController';
+
+class DeleteSuccessController extends AbstractController {
+  handle(event: any) {
+    const { state, dispatch, action } = event;
+    const { recordId } = action.payload;
+    const { deleteSuccessUseCase } = this.service;
+
+    deleteSuccessUseCase.updateDependency(state);
+    deleteSuccessUseCase.execute({ dispatch, recordId });
+  }
+}
+
+export default DeleteSuccessController;

package/es/platform/zlist/adapters/controllers/FetchMoreController.ts

@@ -0,0 +1,11 @@
+import AbstractController from './AbstractController';
+
+export default class FetchMoreController extends AbstractController {
+  handle(event) {
+    const { state, updateState, dispatch } = event;
+    const { fetchMoreUseCase } = this.service;
+
+    fetchMoreUseCase.updateDependency(state, updateState);
+    fetchMoreUseCase.execute({ dispatch });
+  }
+}

package/es/platform/zlist/adapters/controllers/FieldChangeController.ts

@@ -0,0 +1,12 @@
+import AbstractController from './AbstractController';
+
+export default class FieldChangeController extends AbstractController {
+  handle(event: any) {
+    const { state, updateState, dispatch, action } = event;
+    const { fieldName, rowId, value } = action.payload;
+    const { fieldChangeUseCase } = this.service;
+
+    fieldChangeUseCase.updateDependency(state, updateState);
+    fieldChangeUseCase.execute({ dispatch, fieldName, rowId, value });
+  }
+}

package/es/platform/zlist/adapters/controllers/MountController.ts

@@ -0,0 +1,12 @@
+import AbstractController from './AbstractController';
+
+class MountController extends AbstractController {
+  handle(event) {
+    const { state, updateState, dispatch } = event;
+    const { initializeUseCase } = this.service;
+    initializeUseCase.updateDependency(state, updateState);
+    initializeUseCase.execute({ dispatch });
+  }
+}
+
+export default MountController;

package/es/platform/zlist/adapters/controllers/PropertiesChangeController.ts

@@ -0,0 +1,14 @@
+import AbstractController from './AbstractController';
+
+class PropertiesChangeController extends AbstractController {
+  handle(event) {
+    const { state, updateState, dispatch, action } = event;
+    const { currentProperties, previousProperties } = action.payload;
+    const { propertiesChangeUseCase } = this.service;
+
+    propertiesChangeUseCase.updateDependency(state, updateState);
+    propertiesChangeUseCase.execute({ dispatch, currentProperties, previousProperties });
+  }
+}
+
+export default PropertiesChangeController;

package/es/platform/zlist/adapters/controllers/RecordExecuteFailedController.ts

@@ -0,0 +1,12 @@
+import AbstractController from './AbstractController';
+
+export default class RecordExecuteFailedController extends AbstractController {
+  handle(event: any) {
+    const { state, updateState, dispatch, action } = event;
+    const { payload, metaData } = action;
+    const { recordExecuteFailedUseCase } = this.service;
+
+    recordExecuteFailedUseCase.updateDependency(state, updateState);
+    recordExecuteFailedUseCase.execute({ dispatch, payload, metaData });
+  }
+}

package/es/platform/zlist/adapters/controllers/RecordExecuteSucceededController.ts

@@ -0,0 +1,12 @@
+import AbstractController from './AbstractController';
+
+export default class RecordExecuteSucceededController extends AbstractController {
+  handle(event: any) {
+    const { state, updateState, dispatch, action } = event;
+    const { payload, metaData } = action;
+    const { recordExecuteSucceededUseCase } = this.service;
+
+    recordExecuteSucceededUseCase.updateDependency(state, updateState);
+    recordExecuteSucceededUseCase.execute({ dispatch, payload, metaData });
+  }
+}

package/es/platform/zlist/adapters/controllers/RecordUpdateController.ts

@@ -0,0 +1,12 @@
+import AbstractController from './AbstractController';
+
+export default class RecordUpdateController extends AbstractController {
+  handle(event: any) {
+    const { state, updateState, dispatch, action } = event;
+    const { recordId, record } = action.payload;
+    const { recordUpdateUseCase } = this.service;
+
+    recordUpdateUseCase.updateDependency(state, updateState);
+    recordUpdateUseCase.execute({ dispatch, recordId, record });
+  }
+}

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

@@ -0,0 +1,14 @@
+import AbstractController from './AbstractController';
+
+class SortController extends AbstractController {
+  handle(event) {
+    const { sortUseCase } = this.service;
+    const { state, updateState, action, dispatch } = event;
+    const { sortBy } = action.payload;
+
+    sortUseCase.updateDependency(state, updateState);
+    sortUseCase.execute({ sortBy, dispatch });
+  }
+}
+
+export default SortController;

package/es/platform/zlist/adapters/controllers/UpdateSuccessController.ts

@@ -0,0 +1,14 @@
+import AbstractController from './AbstractController';
+
+class UpdateSuccessController extends AbstractController {
+  handle(event: any) {
+    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.ts

@@ -0,0 +1,28 @@
+import ListFactory from '../../applications/entities-factory/ListFactory';
+import IRepository from '../../applications/interfaces/gateways/IRepository';
+import IList from '../../domain/entities/interfaces/IList';
+
+class Repository implements IRepository {
+  private state;
+
+  init(state) {
+    this.state = state;
+  }
+
+  getList(): IList {
+    const { sortBy, departmentId, viewId, moduleName, context } = this.state.properties;
+    const list = ListFactory.createList({
+      context,
+      filter: {
+        departmentId,
+        viewId,
+        moduleName
+      },
+      sortBy,
+      limit: 50
+    });
+    return list;
+  }
+}
+
+export default Repository;

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

@@ -0,0 +1,46 @@
+import IService from '../../applications/interfaces/gateways/IService';
+import UseCaseDependencies from '../../applications/interfaces/UseCaseDependencies';
+
+import InitializeUseCase from '../../applications/usecases/InitializeUseCase';
+import PropertiesChangeUseCase from '../../applications/usecases/PropertiesChangeUseCase';
+import FetchMoreUseCase from '../../applications/usecases/FetchMoreUseCase';
+import FieldChangeUseCase from '../../applications/usecases/FieldChangeUseCase';
+import DeleteMultipleRecordUseCase from '../../applications/usecases/DeleteMultipleRecordUseCase';
+import SortUseCase from '../../applications/usecases/SortUseCase';
+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 '@platform/zlist/applications/usecases/UpdateSuccessUseCase';
+import DeleteSuccessUseCase from '@platform/zlist/applications/usecases/DeleteSuccessUseCase';
+
+class Service implements IService {
+  initializeUseCase: InitializeUseCase;
+  propertiesChangeUseCase: PropertiesChangeUseCase;
+  fieldChangeUseCase: FieldChangeUseCase;
+  fetchMoreUseCase: FetchMoreUseCase;
+  deleteMultipleRecordUseCase: DeleteMultipleRecordUseCase;
+  deleteSingleRecordUseCase: DeleteSingleRecordUseCase;
+  recordExecuteSucceededUseCase: RecordExecuteSucceededUseCase;
+  recordExecuteFailedUseCase: RecordExecuteFailedUseCase;
+  sortUseCase: SortUseCase;
+  recordUpdateUseCase: RecordUpdateUseCase;
+  updateSuccessUseCase: UpdateSuccessUseCase;
+  deleteSuccessUseCase: DeleteSuccessUseCase;
+
+  constructor(private dependencies: UseCaseDependencies) {
+    this.initializeUseCase = new InitializeUseCase(this.dependencies);
+    this.propertiesChangeUseCase = new PropertiesChangeUseCase(this.dependencies);
+    this.fetchMoreUseCase = new FetchMoreUseCase(this.dependencies);
+    this.fieldChangeUseCase = new FieldChangeUseCase(this.dependencies);
+    this.sortUseCase = new SortUseCase(this.dependencies);
+    this.deleteMultipleRecordUseCase = new DeleteMultipleRecordUseCase(this.dependencies);
+    this.deleteSingleRecordUseCase = new DeleteSingleRecordUseCase(this.dependencies);
+    this.recordExecuteSucceededUseCase = new RecordExecuteSucceededUseCase(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);
+  }
+}
+export default Service;

package/es/platform/zlist/adapters/gateways/SortBy.ts

@@ -0,0 +1,27 @@
+import SortByOutputModel from '@library/behaviours/sort-by/usecases/interfaces/output/SortByOutputModel';
+import SortOrder from '@bc/sort-by/SortOrderEnum';
+import ISortBy from '../../applications/interfaces/gateways/ISortBy';
+
+class SortBy implements ISortBy {
+  toQueryString(sortBy: SortByOutputModel): string {
+    const { name, order } = sortBy;
+    let sortQueryString = '';
+    if (order === SortOrder.ASC) {
+      sortQueryString = name;
+    } else if (order === SortOrder.DES) {
+      sortQueryString = `-${name}`;
+    }
+    return sortQueryString;
+  }
+
+  toObject(sortBy: string): { name: string; order: SortOrder } {
+    let sortByParsed = sortBy.split('-');
+    if (sortByParsed[0] === '-') {
+      return { name: sortByParsed[1], order: SortOrder.DES };
+    } else {
+      return { name: sortByParsed[0], order: SortOrder.ASC };
+    }
+  }
+}
+
+export default SortBy;

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

@@ -0,0 +1,80 @@
+/* eslint-disable max-lines-per-function */
+import { Width as ColumnWidth } from '@cc/table-list/data-types/Header';
+import TableListDataType from '@cc/table-list/Data';
+import { State } from './translators/interfaces/State';
+import HeadersTranslator from './translators/HeadersTranslator';
+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 ActionsTranslator from './translators/actions/ActionsTranslator';
+import { ClientActionModel } from '@platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/ClientActionModel';
+
+const fallbackToDefault = (value, defaultValue) => ([undefined, null].includes(value) ? defaultValue : value);
+
+export default class TableTranslator {
+  static transformState(state: State): TableListDataType {
+    const { behaviours, properties } = state;
+    const { componentMapping, context } = properties;
+    context['servicePrefix'] = 'supportapi/zd'; // FIX: servicePrefix defaultValue should be available from properties
+    const { zrecord, zfield, zclientAction } = fallbackToDefault(behaviours, {}); // FIX: behaviours should be available by default
+    const { records, isFetching: isRecordsFetching } = fallbackToDefault(zrecord, {}); // FIX: zrecord should be available by defau
+    const { clientActions, isFetching: isClientActionsFetching } = fallbackToDefault(zclientAction, {}); // FIX: zclientAction should be available by defaultlt
+    const fieldComponentMapping = componentMapping.fields;
+    const rowActionsUiType = componentMapping.rowActionsComponentName;
+
+    const {
+      fields: availableFields,
+      selectedFields,
+      isFieldsFetching: isAvailableFieldsFetching,
+      isSelectedFieldsFetching
+    } = fallbackToDefault(zfield, {}); // FIX: zfield should be available by default
+    const isLoading = !!(isRecordsFetching || isAvailableFieldsFetching || isSelectedFieldsFetching);
+
+    const fields = selectedFields
+      ?.map(selectedField => availableFields?.find(availableField => availableField.name === selectedField))
+      .filter(f => f != undefined);
+
+    const { headerActions, fieldActions, rowActions, noLocation } = mapClientActions(clientActions || []);
+    
+    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 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,
+      rowCursor,
+      rowActionsConfig: {
+        hasActions: Boolean(rowActions?.length), // Boolean(newRowActions?.length),
+        columnWidth: ColumnWidth.XSmall
+      },
+      isLoading,
+      emptyStateUiType: componentMapping.emptyState || '',
+      data
+    };
+  }
+}
+
+function mapClientActions(clientActions): { [key: string]: ClientActionModel[] } {
+  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/ColumnAlignmentTranslator.ts

@@ -0,0 +1,11 @@
+import { Alignment } from '@cc/table-list/data-types/Header';
+
+function ColumnAlignmentTranslator(type: string): Alignment {  
+  if(type === 'Boolean') {
+    return Alignment.Center;
+  } else {
+    return Alignment.Left;
+  }
+}
+
+export default ColumnAlignmentTranslator;

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

@@ -0,0 +1,22 @@
+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,
+  Currency: Width.Medium,
+  Date: Width.Medium,
+  Percent: Width.Medium
+};
+
+function ColumnSizeTranslator(type: string): Width {
+  const columnSize: Width = columnSizeMapping[type];
+  if(columnSize) {
+    return columnSize;
+  }
+  return Width.Large;
+}
+
+export default ColumnSizeTranslator;

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

@@ -0,0 +1,32 @@
+import Column from '@cc/table-list/data-types/Column';
+import { RecordModel } from '@platform/zrecord/domain/entities/interfaces/RecordModel';
+import FieldModel from '@platform/zfield/domain/entities/interfaces/FieldModel';
+import EmptyViewModel from './EmptyViewModel';
+import * as FieldTranslators from './fields';
+import FieldComponentMapping from './interfaces/FieldComponentMapping';
+import { ClientActionModel } from '@platform/client-actions/behaviour/zclient-actions/applications/interfaces/ClientActionModel';
+import ClientActionsTranslator from '@platform/client-actions/translators/client-actions-translator';
+
+function ColumnTranslator(field: FieldModel, record: RecordModel, fieldComponentMapping: FieldComponentMapping, fieldActions: ClientActionModel[]): Column {
+  const { isCustomField, name, type } = field;
+
+  const value = isCustomField ? record.cf?.[name] : record[name];
+  const actions = ClientActionsTranslator.transform(fieldActions, { field, record });
+
+  if (!value && value !== false) {
+    return EmptyViewModel();
+  }
+
+  if (fieldComponentMapping[name]) {
+    field.uiType = fieldComponentMapping[name];
+  }
+
+  const fieldTranslator = FieldTranslators[type];
+  if (!fieldTranslator) {
+    console.error(`Field type ${type} not supported`);
+    return EmptyViewModel();
+  }
+  return { actions, ...fieldTranslator(field, value, { recordId: record.id }) };
+}
+
+export default ColumnTranslator;

package/es/platform/zlist/adapters/presenters/translators/EmptyViewModel.ts

@@ -0,0 +1,10 @@
+import FieldTypes from "@cc/fields/field/Types";
+
+function EmptyViewModel() {
+  return {
+    type: FieldTypes.SingleLineField,
+    value: '-'
+  };
+}
+
+export default EmptyViewModel;

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

@@ -0,0 +1,22 @@
+import Header from '@cc/table-list/data-types/Header';
+import FieldModel from './interfaces/FieldModel';
+import ColumnSizeTranslator from './ColumnSizeTranslator';
+import ColumnAlignmentTranslator from './ColumnAlignmentTranslator';
+import { ClientActionModel } from '@platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/ClientActionModel';
+import ClientActionsTranslator from '@platform/client-actions/translators/client-actions-translator';
+
+function HeaderTranslator(field: FieldModel, actions: ClientActionModel[], context: object): Header {
+  const { id, name, displayLabel, isSortable, type } = field;
+  const transformedActions = ClientActionsTranslator.transform(actions, { ...context, field });
+  return {
+    id: id,
+    name: name,
+    text: displayLabel,
+    sortable: isSortable,
+    alignment: ColumnAlignmentTranslator(type),
+    width: ColumnSizeTranslator(type),
+    actions: transformedActions
+  };
+}
+
+export default HeaderTranslator;

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

@@ -0,0 +1,32 @@
+import Header from '@cc/table-list/data-types/Header';
+import FieldModel from './interfaces/FieldModel';
+import HeaderTranslator from './Header';
+import { ClientActionModel } from '@platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/ClientActionModel';
+
+export default class HeadersTranslator {
+  constructor(
+    private fields: FieldModel[],
+    private actions: ClientActionModel[],
+    private context: object
+  ) {
+    this.pipe = this.pipe.bind(this);
+  }
+
+  translate(): Header[] {
+    if (!this.fields) {
+      return [];
+    }
+    return this.fields.map(field => HeaderTranslator(field, this.actions, this.context));
+  }
+
+  pipe(viewModel: any): any {
+    return {
+      ...viewModel,
+      headers: this.translate()
+    };
+  }
+
+  getTranslator() {
+    return { name: 'headerTransformer', mapping: this.pipe };
+  }
+}

package/es/platform/zlist/adapters/presenters/translators/Row.ts

@@ -0,0 +1,29 @@
+import Row from '@cc/table-list/data-types/Row';
+import { RecordModel } from '@platform/zrecord/domain/entities/interfaces/RecordModel';
+import FieldModel from './interfaces/FieldModel';
+import ColumnTranslator from './ColumnTranslator';
+import FieldComponentMapping from './interfaces/FieldComponentMapping';
+import { Context } from './interfaces/Context';
+import { ClientActionModel } from '@platform/client-actions/behaviour/zclient-actions/domain/entities/interfaces/ClientActionModel';
+import ClientActionsTranslator from '@platform/client-actions/translators/client-actions-translator';
+
+type Input = {
+  record: RecordModel;
+  fields: FieldModel[];
+  fieldComponentMapping: FieldComponentMapping;
+  rowActionsUiType: string;
+  rowActions: ClientActionModel[];
+  fieldActions: ClientActionModel[];
+  context: Context;
+};
+export default function RowTranslator({ record, fields, fieldComponentMapping, rowActionsUiType, rowActions, fieldActions, context }: Input): Row {
+  const actions = ClientActionsTranslator.transform(rowActions, { ...context, record });
+  return {
+    id: record.id,
+    columns: fields.map(field => ColumnTranslator(field, record, fieldComponentMapping, fieldActions)),
+    rowActionLocation: {
+      type: rowActionsUiType,
+      actions
+    }
+  };
+}