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

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

@@ -1,10 +1,10 @@
-import { SmartTableConstants } from "../../../../cc/table-connected";
 import AbstractUseCase from "./AbstractUseCase";
+import { SMART_TABLE_SORTED } from "../../../../cc/table-connected/constants/Events";
 
 class SortUseCase extends AbstractUseCase {
   execute(input) {
     const {
-      sortBy,
+      sortConfig,
       dispatch
     } = input;
     const {
@@ -12,13 +12,13 @@ class SortUseCase extends AbstractUseCase {
       presenter
     } = this.dependencies;
     const list = repository.getList();
-    list.setSortBy(sortBy);
+    list.setSortConfig(sortConfig);
+    presenter.updateView(list.toObject());
     dispatch(list.createRecordsRefetchAction());
     dispatch({
-      type: SmartTableConstants.Events.SORTED,
-      payload: sortBy
+      type: SMART_TABLE_SORTED,
+      payload: sortConfig
     });
-    presenter.updateView(list.toObject());
   }
 
 }

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

@@ -3,13 +3,13 @@ import { FIELD_EXECUTE, FIELD_REFETCH } from "../../../../bc/zfield/Constants";
 import { CLIENTACTION_BEHAVIOUR_EXECUTE } from "../../../client-actions/bc/zclient-actions/Constants";
 import { CLIENT_ACTION_TABLE_LIST_COMPONENT_NAME, ZLIST_RECORD_DELETE_SUCCEEDED, ZLIST_RECORD_UPDATE_SUCCEEDED } from "../../../../bc/zlist/Constants";
 import { SmartTableConstants } from "../../../../cc/table-connected";
-import SortBy from "./SortBy";
 import { CLIENTSCRIPT_FETCH } from "../../../client-scripts/bc/zclient-scripts-fetch/Constants";
+import { SortOrder } from "../../../../bc/zlist/Types";
 
 class List {
-  constructor(limit, sortBy, query, context, isReOrderLoading, errorState) {
+  constructor(limit, sortConfig, query, context, isReOrderLoading, errorState) {
     this.limit = limit;
-    this.sortBy = sortBy;
+    this.sortConfig = sortConfig;
     this.query = query;
     this.context = context;
     this.isReOrderLoading = isReOrderLoading;
@@ -19,7 +19,7 @@ class List {
   toObject() {
     return {
       limit: this.limit,
-      sortBy: this.sortBy.toObject(),
+      sortConfig: this.sortConfig,
       isReOrderLoading: this.isReOrderLoading,
       errorState: this.errorState.toObject()
     };
@@ -37,16 +37,12 @@ class List {
     this.isReOrderLoading = false;
   }
 
-  setSortBy(sortBy) {
-    this.sortBy = new SortBy(sortBy.id, sortBy.name, sortBy.order);
+  getSortConfig() {
+    return this.sortConfig;
   }
 
-  toggleSortBy() {
-    const {
-      id,
-      name
-    } = this.sortBy;
-    this.sortBy.doSorting(id, name);
+  setSortConfig(sortConfig) {
+    this.sortConfig = sortConfig;
   }
 
   isAcknowledgeBySortBy(metaData) {
@@ -65,16 +61,32 @@ class List {
     return variableName ? computedContext?.[variableName] : computedContext;
   }
 
+  getSortByQueryString() {
+    const {
+      fieldName,
+      order
+    } = this.sortConfig;
+
+    if (order === SortOrder.DES) {
+      return `-${fieldName}`;
+    }
+
+    if (order === SortOrder.ASC) {
+      return fieldName;
+    }
+
+    return '';
+  }
+
   createApiProps() {
     const {
       query,
       limit,
-      sortBy,
       context
     } = this;
     return {
       limit,
-      sortBy: sortBy.toQueryString(),
+      sortBy: this.getSortByQueryString(),
       ...query,
       ...context
     };
@@ -357,7 +369,7 @@ class List {
     const props = this.createApiProps();
     const metaData = triggerer === 'sortBy' && {
       ['SMART_TABLE#SORTED']: {
-        sortBy: this.sortBy.toObject()
+        sortBy: this.sortConfig
       }
     };
     return {

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

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

package/es/platform/zlist/frameworks/EventHandlersFactory.js

@@ -9,13 +9,12 @@ import FetchMoreController from "../adapters/controllers/FetchMoreController";
 import SortController from "../adapters/controllers/SortController";
 import FieldChangeController from "../adapters/controllers/FieldChangeController";
 import LifeCycleEvents from "../../../cc/component/LifeCycleEventsEnum";
-import SortBy from "../adapters/gateways/SortBy";
 import DeleteMultipleRecordController from "../adapters/controllers/DeleteMultipleRecordController";
 import RecordUpdateController from "../adapters/controllers/RecordUpdateController";
 import DeleteSingleRecordController from "../adapters/controllers/DeleteSingleRecordController";
 import RecordExecuteFailedController from "../adapters/controllers/RecordExecuteFailedController";
 import RecordExecuteSucceededController from "../adapters/controllers/RecordExecuteSucceededController";
-import { RECORD_EXECUTE_FAILED, RECORD_EXECUTE_SUCCEEDED, RECORD_EXECUTE_SUCCESS_CALLBACK } from "../../../bc/zrecord/Constants";
+import { RECORD_EXECUTE_FAILED, RECORD_EXECUTE_SUCCEEDED, RECORD_EXECUTE_SUCCESS_CALLBACK, REFRESH_RECORDS_REQUESTED } from "../../../bc/zrecord/Constants";
 import UpdateSuccessController from "../adapters/controllers/UpdateSuccessController";
 import DeleteSuccessController from "../adapters/controllers/DeleteSuccessController";
 import Presenter from "../adapters/presenters/Presenters";
@@ -26,14 +25,13 @@ import { FIELD_FETCH_FAILURE } from "../../../bc/zfield/Constants";
 import FieldExecuteFailedController from "../adapters/controllers/FieldExecuteFailedController";
 import { CLIENTACTION_EXECUTE_FAILED } from "../../client-actions/bc/zclient-actions/Constants";
 import ResolutionBasedLimitController from "../adapters/controllers/ResolutionBasedLimitController";
+import RefreshRecordsRequestedController from "../adapters/controllers/RefreshRecordsRequestedController";
 export default class ActionHandlersFactory {
   static create() {
     const repository = new Repository();
     const presenter = new Presenter();
-    const sortByGateway = new SortBy();
     const service = new Service({
       repository,
-      sortBy: sortByGateway,
       presenter
     });
     return {
@@ -57,6 +55,7 @@ export default class ActionHandlersFactory {
       [ZLIST_RECORD_DELETE_SUCCEEDED]: new DeleteSuccessController(service).handle,
       // ({ dispatch, action }) => dispatch({ type: 'SMART_TABLE#RECORD_DELETED', payload: { id: action.payload.id } })
       [ZLIST_RECORD_REORDER]: new ReOrderController(service).handle,
+      [REFRESH_RECORDS_REQUESTED]: new RefreshRecordsRequestedController(service).handle,
       [ZLIST_RECORD_REORDER_FAILED]: new ReOrderFailedController(service).handle
     };
   }

package/es/platform/zlist/frameworks/ZListBehaviourFactory.js

@@ -1,15 +1,12 @@
 import Properties from "../../../bc/zlist/Properties";
 import EventHandlersFactory from "./EventHandlersFactory";
+import { initialSortConfig } from "../../../bc/zlist/Types";
 export default class ZListBehaviourFactory {
   static create() {
     return {
       name: 'zlist',
       setInitialState: () => ({
-        sortBy: {
-          id: '',
-          name: '',
-          order: 'none'
-        },
+        sortConfig: initialSortConfig,
         isReOrderLoading: false,
         errorState: {
           canErrorPage: false,

package/es/platform/zrecord/adapters/controllers/UpdateRecordController.js

@@ -0,0 +1,30 @@
+import AbstractController from "./AbstractController";
+export default class UpdateRecordController extends AbstractController {
+  handle(event) {
+    const {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    const {
+      payload
+    } = action;
+    const {
+      record,
+      moduleName,
+      recordId
+    } = payload;
+    const {
+      updateRecordUseCase
+    } = this.service;
+    updateRecordUseCase.updateDependency(state, updateState);
+    updateRecordUseCase.execute({
+      record,
+      moduleName,
+      recordId,
+      dispatch
+    });
+  }
+
+}

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

@@ -1,4 +1,5 @@
 import RecordsManagerFactory from "../../applications/entities-factory/RecordsManagerFactory";
+import { Filter } from "../../domain/entities/Filter";
 export default class Repository {
   init(state) {
     this.state = state;
@@ -11,13 +12,15 @@ export default class Repository {
     const {
       records = [],
       hasMore,
-      isFetching
+      isFetching,
+      filter
     } = zrecord;
+    const filterEntity = new Filter(filter.config, filter.condition, filter.queryString);
     const recordManager = RecordsManagerFactory.create({
       data: records,
       hasMore,
       isFetching
-    });
+    }, filterEntity);
     return recordManager;
   }
 

package/es/platform/zrecord/applications/entities-factory/RecordsManagerFactory.js

@@ -1,9 +1,9 @@
 import RecordsManager from "../../domain/entities/RecordsManager";
 import Records from "../../domain/entities/Records";
 export default class RecordsManagerFactory {
-  static create(recordsModel) {
+  static create(recordsModel, filter) {
     const records = new Records(recordsModel);
-    const recordManager = new RecordsManager(records);
+    const recordManager = new RecordsManager(records, filter);
     return recordManager;
   }
 

package/es/platform/zrecord/applications/interfaces/input/ClearAllFiltersUseCaseInputModel.js

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

package/es/platform/zrecord/applications/interfaces/input/GetFilterConditionUseCaseInputModel.js

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

package/es/platform/zrecord/applications/interfaces/input/GetFilterConfigUseCaseInputModel.js

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

package/es/platform/zrecord/applications/interfaces/input/RefreshRecordsUseCaseInputModel.js

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

package/es/platform/zrecord/applications/interfaces/input/SetFilterUseCaseInputModel.js

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

package/es/platform/zrecord/applications/usecases/ClearAllFiltersUseCase.js

@@ -0,0 +1,24 @@
+import AbstractUseCase from "./AbstractUseCase";
+import { REFRESH_RECORDS_REQUESTED } from "../../../../bc/zrecord/Constants";
+import { initialFilterConfig } from "../../../../bc/zrecord/Types";
+export default class ClearAllFiltersUseCase extends AbstractUseCase {
+  execute(_ref) {
+    let {
+      dispatch
+    } = _ref;
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    const recordManager = repository.getRecordsManagerEntity();
+    recordManager.setFilterConfig(initialFilterConfig);
+    presenter.updateRecord(recordManager.toObject());
+    dispatch({
+      type: REFRESH_RECORDS_REQUESTED,
+      metaData: {
+        filterConfig: initialFilterConfig
+      }
+    });
+  }
+
+}

package/es/platform/zrecord/applications/usecases/GetFilterConditionUseCase.js

@@ -0,0 +1,15 @@
+import AbstractUseCase from "./AbstractUseCase";
+export default class GetFilterConditionUseCase extends AbstractUseCase {
+  execute(_ref) {
+    let {
+      callback
+    } = _ref;
+    const {
+      repository
+    } = this.dependencies;
+    const recordManager = repository.getRecordsManagerEntity();
+    const filterCondition = recordManager.getFilterCondition();
+    callback?.(filterCondition);
+  }
+
+}

package/es/platform/zrecord/applications/usecases/GetFilterConfigUseCase.js

@@ -0,0 +1,15 @@
+import AbstractUseCase from "./AbstractUseCase";
+export default class GetFilterConfigUseCase extends AbstractUseCase {
+  execute(_ref) {
+    let {
+      callback
+    } = _ref;
+    const {
+      repository
+    } = this.dependencies;
+    const recordManager = repository.getRecordsManagerEntity();
+    const filterConfig = recordManager.getFilterConfig();
+    callback?.(filterConfig);
+  }
+
+}

package/es/platform/zrecord/applications/usecases/RefreshRecordsUseCase.js

@@ -0,0 +1,14 @@
+import AbstractUseCase from "./AbstractUseCase";
+import { REFRESH_RECORDS_REQUESTED } from "../../../../bc/zrecord/Constants";
+export default class RefreshRecordsUseCase extends AbstractUseCase {
+  execute(_ref) {
+    let {
+      dispatch
+    } = _ref;
+    dispatch({
+      type: REFRESH_RECORDS_REQUESTED,
+      metaData: {}
+    });
+  }
+
+}

package/es/platform/zrecord/applications/usecases/SetFilterUseCase.js

@@ -0,0 +1,24 @@
+import AbstractUseCase from "./AbstractUseCase";
+import { REFRESH_RECORDS_REQUESTED } from "../../../../bc/zrecord/Constants";
+export default class SetFilterUseCase extends AbstractUseCase {
+  execute(_ref) {
+    let {
+      filterConfig,
+      dispatch
+    } = _ref;
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    const recordManager = repository.getRecordsManagerEntity();
+    recordManager.setFilterConfig(filterConfig);
+    presenter.updateRecord(recordManager.toObject());
+    dispatch({
+      type: REFRESH_RECORDS_REQUESTED,
+      metaData: {
+        filterConfig
+      }
+    });
+  }
+
+}

package/es/platform/zrecord/applications/usecases/UpdateRecordUseCase.js

@@ -0,0 +1,30 @@
+import AbstractUseCase from "./AbstractUseCase";
+import RecordFactory from "../entities-factory/RecordFactory";
+import { RecordApiActionName } from "../../../../bc/zrecord/Constants";
+
+class UpdateRecordUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      presenter,
+      repository
+    } = this.dependencies;
+    const {
+      record,
+      dispatch,
+      moduleName,
+      recordId
+    } = input;
+    const recordManager = repository.getRecordsManagerEntity();
+    const recordEntity = RecordFactory.createSingleRecord(record);
+    const meta = recordManager.createRecordMeta(recordEntity);
+    dispatch(recordManager.createDataSourceExecuteEvent({
+      record: recordEntity.toObject(),
+      moduleName,
+      recordId
+    }, RecordApiActionName.UPDATE_RECORD, meta));
+    presenter.updateRecord(recordManager.toObject());
+  }
+
+}
+
+export default UpdateRecordUseCase;

package/es/platform/zrecord/domain/entities/Filter.js

@@ -0,0 +1,247 @@
+import { CommonComparators, TextComparators, NumberComparators, DateComparators, ConditionTokens } from "../../../../bc/zrecord/Types";
+export class Filter {
+  constructor(config, condition, queryString) {
+    this.config = config;
+    this.condition = condition;
+    this.queryString = queryString;
+  }
+
+  getFilterQuery() {
+    return this.queryString;
+  }
+
+  getConfig() {
+    return this.config;
+  }
+
+  getCondition() {
+    return this.condition;
+  }
+
+  toObject() {
+    return {
+      config: this.config,
+      condition: this.condition,
+      queryString: this.queryString
+    };
+  }
+
+  setConfig(config) {
+    const condition = this.convertConfigToCondition(config);
+    const queryString = this.convertConditionToQueryStringRecursive(condition);
+    this.config = config;
+    this.condition = condition;
+    this.queryString = queryString;
+  }
+  /**
+   * input:
+   *  {
+   *    conditions: [
+   *      { fieldName: 'productCode', condition: "isn't", value: '12345' },
+   *      { fieldName: 'quantity', condition: 'is', value: 100 },
+   *      { fieldName: 'category', condition: 'contains', value: 'electronics' },
+   *      { fieldName: 'discount', condition: 'is not empty', value: null }
+   *    ],
+   *    pattern: "((1and2)or(3and4))"
+   *  }
+   *
+   * output:
+   *  {
+   *    type: 'OR',
+   *    conditions: [
+   *      {
+   *        type: 'AND',
+   *        conditions: [
+   *          { type: 'CONDITION', fieldName: 'productCode', condition: "isn't", value: '12345' },
+   *          { type: 'CONDITION', fieldName: 'quantity', condition: 'is', value: 100 }
+   *        ]
+   *      },
+   *      {
+   *        type: 'AND',
+   *        conditions: [
+   *          { type: 'CONDITION', fieldName: 'category', condition: 'contains', value: 'electronics' },
+   *          { type: 'CONDITION', fieldName: 'discount', condition: 'is not empty', value: null }
+   *        ]
+   *      }
+   *    ]
+   *  }
+   */
+
+
+  convertConfigToCondition(config) {
+    const {
+      conditions,
+      pattern
+    } = config;
+
+    if (conditions.length === 0 || pattern.trim() === '') {
+      return null;
+    } // Tokenize the pattern
+
+
+    const tokens = this.tokenizePattern(pattern);
+    const aliases = this.generateAliases(conditions);
+    let pos = 0;
+
+    const parseExpression = () => {
+      if (tokens[pos] === '(') {
+        pos++; // skip '('
+
+        const left = parseExpression();
+
+        if (pos < tokens.length && tokens[pos] === ')') {
+          pos++; // skip ')'
+
+          return left;
+        }
+
+        const operator = tokens[pos];
+        pos++; // skip operator
+
+        const right = parseExpression();
+
+        if (tokens[pos] === ')') {
+          pos++; // skip ')'
+        }
+
+        return {
+          type: operator === 'AND' ? ConditionTokens.AND : ConditionTokens.OR,
+          conditions: [left, right]
+        };
+      } else if (/^\d+$/.test(tokens[pos])) {
+        const alias = tokens[pos];
+        pos++;
+        return aliases[alias];
+      }
+
+      throw new Error('Invalid pattern');
+    };
+
+    return parseExpression();
+  } // Helper method to tokenize the pattern string (e.g. "(1and2)")
+
+
+  tokenizePattern(pattern) {
+    return pattern.replace(/\(/g, ' ( ').replace(/\)/g, ' ) ').replace(/and/g, ' AND ').replace(/or/g, ' OR ').replace(/not/g, ' NOT ').split(/\s+/).filter(token => token.length > 0);
+  } // Helper method to create aliases for the conditions (e.g. "1", "2")
+
+
+  generateAliases(conditions) {
+    const aliases = {};
+    conditions.forEach((condition, index) => {
+      const alias = String(index + 1); // Starting with "1"
+
+      aliases[alias] = {
+        type: ConditionTokens.CONDITION,
+        fieldName: condition.fieldName,
+        condition: condition.condition,
+        value: condition.value
+      };
+    });
+    return aliases;
+  }
+  /**
+   * input:
+   *  {
+   *    type: 'OR',
+   *    conditions: [
+   *      {
+   *        type: 'AND',
+   *        conditions: [
+   *          { type: 'CONDITION', fieldName: 'productCode', condition: "isn't", value: '12345' },
+   *          { type: 'CONDITION', fieldName: 'quantity', condition: 'is', value: 100 }
+   *        ]
+   *      },
+   *      {
+   *        type: 'AND',
+   *        conditions: [
+   *          { type: 'CONDITION', fieldName: 'category', condition: 'contains', value: 'electronics' },
+   *          { type: 'CONDITION', fieldName: 'discount', condition: 'is not empty', value: null }
+   *        ]
+   *      }
+   *    ]
+   *  }
+   *
+   * output:
+   *  "((productCode != 12345 AND quantity = 100) OR (category.contains('electronics') AND discount.isNotEmpty()))"
+   */
+
+
+  convertConditionToQueryStringRecursive(condition) {
+    if (!condition) {
+      return '';
+    }
+
+    if (condition.type === ConditionTokens.CONDITION) {
+      const {
+        fieldName,
+        condition: comp,
+        value
+      } = condition;
+
+      switch (comp) {
+        case CommonComparators.ISEMPTY:
+          return `${fieldName}.isEmpty()`;
+
+        case CommonComparators.ISNOTEMPTY:
+          return `${fieldName}.isNotEmpty()`;
+
+        case TextComparators.IS:
+          return `${fieldName} = '${value}'`;
+
+        case TextComparators.ISNT:
+          return `${fieldName} != '${value}'`;
+
+        case TextComparators.STARTSWITH:
+          return `${fieldName}.startsWith('${value}')`;
+
+        case TextComparators.ENDSWITH:
+          return `${fieldName}.endsWith('${value}')`;
+
+        case TextComparators.CONTAINS:
+          return `${fieldName}.contains('${value}')`;
+
+        case TextComparators.DOESNTCONTAIN:
+          return `!${fieldName}.contains('${value}')`;
+
+        case NumberComparators.EQUAL:
+          return `${fieldName} = ${value}`;
+
+        case NumberComparators.NOTEQUAL:
+          return `${fieldName} != ${value}`;
+
+        case NumberComparators.LESSTHAN:
+          return `${fieldName} < ${value}`;
+
+        case NumberComparators.LESSTHANEQUAL:
+          return `${fieldName} <= ${value}`;
+
+        case NumberComparators.GREATERTHAN:
+          return `${fieldName} > ${value}`;
+
+        case NumberComparators.GREATERTHANEQUAL:
+          return `${fieldName} >= ${value}`;
+
+        case DateComparators.ISAFTER:
+          return `${fieldName} > '${value}'`;
+
+        case DateComparators.ISBEFORE:
+          return `${fieldName} < '${value}'`;
+
+        case DateComparators.BETWEEN:
+          return `${fieldName}.between('${value.start}', '${value.end}')`;
+
+        case DateComparators.NOTBETWEEN:
+          return `!${fieldName}.between('${value.start}', '${value.end}')`;
+
+        default:
+          return '';
+      }
+    } else {
+      const operator = condition.type === ConditionTokens.AND ? ' AND ' : ' OR ';
+      const parts = condition.conditions.map(c => this.convertConditionToQueryStringRecursive(c));
+      return `(${parts.join(operator)})`;
+    }
+  }
+
+}