@zohodesk/library-platform 1.1.3-exp.3 → 1.1.3-exp.4

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

@@ -1,7 +1,8 @@
 import FieldTypes from "../../../../../cc/fields/field/Types";
 
-function EmptyViewModel() {
+function EmptyViewModel(fieldName) {
   return {
+    name: fieldName,
     type: FieldTypes.SingleLineField,
     value: '-'
   };

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

@@ -3,7 +3,7 @@ import ClientActionsTranslator from "../../../../client-actions/translators/clie
 import { SortOrder } from "../../../../zlist/domain/entities/interfaces/Properties";
 import { i18NProviderUtils } from '@zohodesk/i18n';
 
-function HeaderTranslator(field, actions, context, modifiedWidths, sortBy) {
+function HeaderTranslator(field, actions, context, modifiedWidths, sortBy, records) {
   const {
     id,
     name,
@@ -15,7 +15,8 @@ function HeaderTranslator(field, actions, context, modifiedWidths, sortBy) {
     sort: translateSortBy(field.id, sortBy)
   };
   const transformedActions = ClientActionsTranslator.transform(actions, { ...context,
-    field: newField
+    field: newField,
+    recordsLength: records.length.toString()
   });
   const width = modifiedWidths[name];
   return {

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

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

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

@@ -10,6 +10,7 @@ const CurrencyFieldTranslator = (field, value, appendToActionPayload) => {
     uiType: uiType || FieldTypes.CurrencyField,
     appendToActionPayload,
     name,
+    currencyLocale: "INR",
     value
   });
 };

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

@@ -19,6 +19,9 @@ const FormulaFieldTranslator = (field, value, appendToActionPayload) => {
     uiType: uiType || setFieldType,
     appendToActionPayload,
     name,
+    ...(setFieldType === FieldTypes.CurrencyField && {
+      currencyLocale: "INR"
+    }),
     value
   });
 };

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

@@ -39,7 +39,7 @@ class DefaultClientActions {
       },
       conditions: {
         fields: [{
-          fieldName: 'field.isSortable',
+          fieldName: '{{@context.field.isSortable}}',
           condition: '=',
           value: ['true']
         }],

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

@@ -7,9 +7,10 @@ class ListFactory {
       sortBy,
       query,
       context,
-      errorRecordFailed
+      errorState,
+      isReOrderLoading
     } = input;
-    return new List(limit, sortBy, query, context, errorRecordFailed);
+    return new List(limit, sortBy, query, context, isReOrderLoading, errorState);
   }
 
 }

package/es/platform/zlist/applications/interfaces/input/ReOrderRecordUseCaseInput.js

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

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

@@ -10,7 +10,7 @@ class FetchMoreUseCase extends AbstractUseCase {
     } = this.dependencies;
     const list = repository.getList();
 
-    if (!list.getErrorRecordFailed()) {
+    if (!list.hasFetchingFailedInMoreRecords()) {
       dispatch(list.createMoreRecordFetchAction());
     }
   }

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

@@ -0,0 +1,22 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class ReOrderFailedUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      metaData
+    } = input;
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    const list = repository.getList();
+
+    if (metaData.isReOrder) {
+      list.reOrderEnded();
+      presenter.updateView(list.toObject());
+    }
+  }
+
+}
+
+export default ReOrderFailedUseCase;

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

@@ -0,0 +1,25 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class ReOrderUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      dispatch,
+      newIndex,
+      oldIndex
+    } = input;
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    const list = repository.getList();
+    list.reOrderStarted();
+    presenter.updateView(list.toObject());
+    dispatch(list.getReOrderRecordAction({
+      newIndex,
+      oldIndex
+    }));
+  }
+
+}
+
+export default ReOrderUseCase;

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

@@ -1,4 +1,4 @@
-import AbstractUseCase from "./AbstractUseCase";
+import AbstractUseCase from "./AbstractUseCase"; // TODO Rename this file to ApiFailedHandleUseCase.ts
 
 class RecordExecuteFailedUseCase extends AbstractUseCase {
   execute(input) {
@@ -12,8 +12,9 @@ class RecordExecuteFailedUseCase extends AbstractUseCase {
       presenter
     } = this.dependencies;
     const list = repository.getList();
-    const actions = list.getRecordExecuteFailedActions(payload, metaData);
+    list.processApiError(payload, metaData);
     presenter.updateView(list.toObject());
+    const actions = list.generateApiErrorEvent(payload, metaData);
     actions.forEach(action => {
       dispatch(action);
     });

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

@@ -1,18 +1,39 @@
+import { SET_RECORDS } from "../../../../bc/zrecord/Constants";
 import AbstractUseCase from "./AbstractUseCase";
 
 class RecordSuccessCallbackUsecase extends AbstractUseCase {
-  execute(input) {
-    const {
+  execute(_ref) {
+    var _metaData$sourceMetaD;
+
+    let {
       dispatch,
       payload,
       metaData
-    } = input;
+    } = _ref;
     const {
       repository,
       presenter
     } = this.dependencies;
     const list = repository.getList();
 
+    if ((_metaData$sourceMetaD = metaData.sourceMetaData) !== null && _metaData$sourceMetaD !== void 0 && _metaData$sourceMetaD.isReOrder) {
+      list.reOrderEnded();
+      presenter.updateView(list.toObject()); // convert to separate use-case
+
+      const {
+        oldIndex,
+        newIndex
+      } = payload.response;
+      const records = repository.getRecords();
+      const reordered = oldIndex === newIndex ? records : list.arrayMoveImmutable(records, oldIndex, newIndex);
+      dispatch({
+        type: SET_RECORDS,
+        payload: {
+          records: reordered
+        }
+      });
+    }
+
     if (list.isAcknowledgeBySortBy(metaData)) {
       list.setSortBy(metaData);
       presenter.updateView(list.toObject());

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

@@ -1,26 +1,36 @@
 import { RECORD_EXECUTE, RECORD_FETCH_MORE, RECORD_REFETCH, RecordApiActionName } from "../../../../bc/zrecord/Constants";
 import { FIELD_EXECUTE, FIELD_REFETCH } from "../../../../bc/zfield/Constants";
-import { ZLIST_RECORD_DELETE_FAILED, ZLIST_RECORD_DELETE_SUCCEEDED, ZLIST_RECORD_UPDATE_FAILED, ZLIST_RECORD_UPDATE_SUCCEEDED } from "../../../../bc/zlist/Constants";
+import { ZLIST_RECORD_DELETE_SUCCEEDED, ZLIST_RECORD_UPDATE_SUCCEEDED } from "../../../../bc/zlist/Constants";
 import { CLIENTACTION_BEHAVIOUR_EXECUTE } from "../../../client-actions/bc/zclient-actions/Constants";
 import { SmartTableConstants } from "../../../../cc/table-connected";
 import SortBy from "./SortBy";
 
 class List {
-  constructor(limit, sortBy, query, context, errorRecordFailed) {
+  constructor(limit, sortBy, query, context, isReOrderLoading, errorState) {
     this.limit = limit;
     this.sortBy = sortBy;
     this.query = query;
     this.context = context;
-    this.errorRecordFailed = errorRecordFailed;
+    this.isReOrderLoading = isReOrderLoading;
+    this.errorState = errorState;
   }
 
   toObject() {
     return {
       sortBy: this.sortBy.toObject(),
-      errorRecordFailed: this.errorRecordFailed
+      isReOrderLoading: this.isReOrderLoading,
+      errorState: this.errorState.toObject()
     };
   }
 
+  reOrderStarted() {
+    this.isReOrderLoading = true;
+  }
+
+  reOrderEnded() {
+    this.isReOrderLoading = false;
+  }
+
   setSortBy(sortBy) {
     this.sortBy = new SortBy(sortBy.id, sortBy.name, sortBy.order);
   }
@@ -107,9 +117,8 @@ class List {
     }
 
     if (this.shallowDiff(preQuery, curQuery)) {
-      return [this.createRecordsRefetchAction(), this.createAvailableFieldsFetchAction(), this.createSelectedFieldsFetchAction() // TODO: this.createAvailableFieldsRefetchAction(),
+      return [this.createRecordsRefetchAction(), this.createAvailableFieldsFetchAction(), this.createSelectedFieldsFetchAction()]; // TODO: this.createAvailableFieldsRefetchAction(),
       // TODO: this.createSelectedFieldsRefetchAction()
-      ];
     }
 
     return [];
@@ -221,51 +230,16 @@ class List {
     return actions;
   }
 
-  getErrorRecordFailed() {
-    return this.errorRecordFailed;
+  hasFetchingFailedInMoreRecords() {
+    return this.errorState.hasFetchingFailedInMoreRecords();
   }
 
-  getRecordExecuteFailedActions(payload, metaData) {
-    const {
-      actionName
-    } = metaData;
-    const actions = [];
-
-    if (actionName === RecordApiActionName.GET_RECORDS) {
-      if (metaData.isAppend) {
-        this.errorRecordFailed = true;
-      }
-    }
-
-    if (actionName === RecordApiActionName.DELETE_RECORD) {
-      const {
-        recordId,
-        error
-      } = payload;
-      actions.push({
-        type: ZLIST_RECORD_DELETE_FAILED,
-        payload: {
-          recordId,
-          error
-        }
-      });
-    }
-
-    if (actionName === RecordApiActionName.UPDATE_RECORD) {
-      const {
-        recordId,
-        error
-      } = payload;
-      actions.push({
-        type: ZLIST_RECORD_UPDATE_FAILED,
-        payload: {
-          recordId,
-          error
-        }
-      });
-    }
+  processApiError(payload, metaData) {
+    return this.errorState.processApiError(payload, metaData);
+  }
 
-    return actions;
+  generateApiErrorEvent(payload, metaData) {
+    return this.errorState.generateApiErrorEvent(payload, metaData);
   }
 
   getDeleteMultipleRecordAction(recordIds) {
@@ -282,6 +256,28 @@ class List {
     };
   }
 
+  getReOrderRecordAction(_ref2) {
+    let {
+      newIndex,
+      oldIndex
+    } = _ref2;
+    const props = this.createApiProps();
+    return {
+      type: RECORD_EXECUTE,
+      metaData: {
+        isReOrder: true
+      },
+      payload: {
+        actionName: RecordApiActionName.GET_REORDERRECORD,
+        props: { ...props,
+          newIndex,
+          oldIndex
+        },
+        apiName: 'records'
+      }
+    };
+  }
+
   createMoreRecordFetchAction() {
     const props = this.createApiProps();
     return {
@@ -348,6 +344,23 @@ class List {
     };
   }
 
+  arrayMoveImmutable(data, fromIndex, toIndex) {
+    if (fromIndex === toIndex) {
+      return [...data];
+    }
+
+    const newOrder = [...data];
+    const startIndex = fromIndex < 0 ? newOrder.length + fromIndex : fromIndex;
+    const endIndex = toIndex < 0 ? newOrder.length + toIndex : toIndex;
+
+    if (startIndex >= 0 && startIndex < newOrder.length) {
+      const [item] = newOrder.splice(startIndex, 1);
+      newOrder.splice(endIndex, 0, item);
+    }
+
+    return newOrder;
+  }
+
   createAvailableFieldsRefetchAction() {
     const props = this.createApiProps();
     return {

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

@@ -0,0 +1,167 @@
+import { RecordApiActionName } from "../../../../bc/zrecord/Constants";
+import { ZLIST_FETCH_MORE_RECORDS_FAILED, ZLIST_INITIAL_AVAILABLE_FIELDS_FETCH_FAILED, ZLIST_INITIAL_CLIENT_ACTIONS_FETCH_FAILED, ZLIST_INITIAL_RECORDS_FETCH_FAILED, ZLIST_INITIAL_SELECTED_FIELDS_FETCH_FAILED, ZLIST_RECORD_DELETE_FAILED, ZLIST_RECORD_UPDATE_FAILED } from "../../../../bc/zlist/Constants";
+import { ClientActionApiActionName } from "../../../client-actions/bc/zclient-actions/Constants";
+import FieldApiName from "../../../zfield/domain/entities/interfaces/FieldApiName";
+
+class ListErrorState {
+  constructor(errorState) {
+    this.errorState = errorState;
+  }
+
+  toObject() {
+    return this.errorState;
+  }
+
+  hasFetchingFailedInMoreRecords() {
+    return this.errorState.hasFetchingFailedInMoreRecords;
+  }
+
+  processApiError(payload, metaData) {
+    const {
+      actionName
+    } = metaData;
+
+    if (FieldApiName.AVAILABLE_FIELDS === actionName || FieldApiName.SELECTED_FIELDS === actionName) {
+      this.errorState = { ...this.errorState,
+        canErrorPage: true,
+        shouldClearRecords: true
+      };
+    } else if (RecordApiActionName.GET_RECORDS === actionName) {
+      if (metaData.isAppend !== true) {
+        this.errorState = { ...this.errorState,
+          canErrorPage: true,
+          shouldClearRecords: true
+        };
+      } else {
+        this.errorState = { ...this.errorState,
+          hasFetchingFailedInMoreRecords: true
+        };
+      }
+    }
+  }
+
+  generateApiErrorEvent(payload, metaData) {
+    const {
+      actionName
+    } = metaData;
+    const actions = [];
+
+    function push(action) {
+      if (action) {
+        actions.push(action);
+      }
+    }
+
+    push(this.getAvailableFieldsFailedAction(payload, actionName));
+    push(this.getSelectedFieldsFailedAction(payload, actionName));
+    push(this.getClientActionsFailedAction(payload, actionName));
+    push(this.getGetRecordsFailedAction(payload, metaData, actionName));
+    push(this.getDeleteRecordFailedAction(payload, actionName));
+    push(this.getUpdateRecordFailedAction(payload, actionName));
+    return actions;
+  }
+
+  getAvailableFieldsFailedAction(payload, actionName) {
+    if (FieldApiName.AVAILABLE_FIELDS === actionName) {
+      //TOTO return { type: ZLIST_INITIAL_AVAILABLE_FIELDS_FETCH_FAILED, payload, metaData };
+      return {
+        type: ZLIST_INITIAL_AVAILABLE_FIELDS_FETCH_FAILED,
+        payload
+      };
+    }
+
+    return null;
+  }
+
+  getSelectedFieldsFailedAction(payload, actionName) {
+    if (FieldApiName.SELECTED_FIELDS === actionName) {
+      //TOTO return { type: ZLIST_INITIAL_SELECTED_FIELDS_FETCH_FAILED, payload, metaData };
+      return {
+        type: ZLIST_INITIAL_SELECTED_FIELDS_FETCH_FAILED,
+        payload
+      };
+    }
+
+    return null;
+  }
+
+  getClientActionsFailedAction(payload, actionName) {
+    if (ClientActionApiActionName.GET_CLIENTACTIONS === actionName) {
+      //TOTO return { type: ZLIST_INITIAL_CLIENT_ACTIONS_FETCH_FAILED, payload, metaData };
+      return {
+        type: ZLIST_INITIAL_CLIENT_ACTIONS_FETCH_FAILED,
+        payload
+      };
+    }
+
+    return null;
+  }
+
+  getGetRecordsFailedAction(payload, metaData, actionName) {
+    if (RecordApiActionName.GET_RECORDS === actionName) {
+      if (metaData.isAppend !== true) {
+        return {
+          type: ZLIST_INITIAL_RECORDS_FETCH_FAILED,
+          payload,
+          metaData
+        };
+      } else {
+        const {
+          from,
+          limit
+        } = metaData.props;
+        return {
+          type: ZLIST_FETCH_MORE_RECORDS_FAILED,
+          payload: { ...payload,
+            from,
+            limit
+          },
+          metaData
+        };
+      }
+    }
+
+    return null;
+  }
+
+  getDeleteRecordFailedAction(payload, actionName) {
+    if (actionName === RecordApiActionName.DELETE_RECORD) {
+      const {
+        recordId,
+        error
+      } = payload;
+      return {
+        type: ZLIST_RECORD_DELETE_FAILED,
+        payload: {
+          recordId,
+          error
+        }
+      };
+    }
+
+    return null;
+  }
+
+  getUpdateRecordFailedAction(payload, actionName) {
+    if (actionName === RecordApiActionName.UPDATE_RECORD) {
+      const {
+        recordId,
+        error,
+        record
+      } = payload;
+      return {
+        type: ZLIST_RECORD_UPDATE_FAILED,
+        payload: {
+          recordId,
+          error,
+          record
+        }
+      };
+    }
+
+    return null;
+  }
+
+}
+
+export default ListErrorState;

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

@@ -4,7 +4,7 @@ import Service from "../adapters/gateways/Service";
 import Repository from "../adapters/gateways/Repository";
 import MountController from "../adapters/controllers/MountController";
 import PropertiesChangeController from "../adapters/controllers/PropertiesChangeController";
-import { ZLIST_DELETE_RECORD, ZLIST_DELETE_RECORDS, ZLIST_FETCH_MORE, ZLIST_RECORD_DELETE_SUCCEEDED, ZLIST_RECORD_UPDATE, ZLIST_RECORD_UPDATE_SUCCEEDED, ZLIST_SORT } from "../../../bc/zlist/Constants";
+import { ZLIST_DELETE_RECORD, ZLIST_DELETE_RECORDS, ZLIST_FETCH_MORE, ZLIST_RECORD_DELETE_SUCCEEDED, ZLIST_RECORD_UPDATE, ZLIST_RECORD_UPDATE_SUCCEEDED, ZLIST_SORT, ZLIST_RECORD_REORDER, ZLIST_RECORD_REORDER_FAILED } from "../../../bc/zlist/Constants";
 import FetchMoreController from "../adapters/controllers/FetchMoreController";
 import SortController from "../adapters/controllers/SortController";
 import FieldChangeController from "../adapters/controllers/FieldChangeController";
@@ -20,6 +20,11 @@ import UpdateSuccessController from "../adapters/controllers/UpdateSuccessContro
 import DeleteSuccessController from "../adapters/controllers/DeleteSuccessController";
 import Presenter from "../adapters/presenters/Presenters";
 import RecordSuccessCallbackController from "../adapters/controllers/RecordSuccessCallbackController";
+import ReOrderController from "../adapters/controllers/ReOrderController";
+import ReOrderFailedController from "../adapters/controllers/ReOrderFailedController";
+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";
 export default class ActionHandlersFactory {
   static create() {
     const repository = new Repository();
@@ -37,15 +42,20 @@ export default class ActionHandlersFactory {
       [ZLIST_RECORD_UPDATE]: new RecordUpdateController(service).handle,
       [ZLIST_DELETE_RECORD]: new DeleteSingleRecordController(service).handle,
       [ZLIST_DELETE_RECORDS]: new DeleteMultipleRecordController(service).handle,
+      [FIELD_FETCH_FAILURE]: new FieldExecuteFailedController(service).handle,
+      // ({ dispatch, action }) => dispatch({ type: 'SMART_TABLE#RECORD_EXECUTE_FAILED', payload: action.payload }),
       [TableListConstants.TABLE_LIST_FIELD_CHANGED]: new FieldChangeController(service).handle,
       [RECORD_EXECUTE_SUCCEEDED]: new RecordExecuteSucceededController(service).handle,
       [RECORD_EXECUTE_FAILED]: new RecordExecuteFailedController(service).handle,
+      [CLIENTACTION_EXECUTE_FAILED]: new RecordExecuteFailedController(service).handle,
       [ZLIST_SORT]: new SortController(service).handle,
       [RECORD_EXECUTE_SUCCESS_CALLBACK]: new RecordSuccessCallbackController(service).handle,
       [ZLIST_RECORD_UPDATE_SUCCEEDED]: new UpdateSuccessController(service).handle,
       // ({ dispatch, action }) => dispatch({ type: 'SMART_TABLE#RECORD_UPDATED', payload: action.payload }),
-      [ZLIST_RECORD_DELETE_SUCCEEDED]: new DeleteSuccessController(service).handle // ({ dispatch, action }) => dispatch({ type: 'SMART_TABLE#RECORD_DELETED', payload: { id: action.payload.id } })
-
+      [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,
+      [ZLIST_RECORD_REORDER_FAILED]: new ReOrderFailedController(service).handle
     };
   }
 

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

@@ -9,6 +9,12 @@ export default class ZListBehaviourFactory {
           id: '',
           name: '',
           order: 'none'
+        },
+        isReOrderLoading: false,
+        errorState: {
+          canErrorPage: false,
+          shouldClearRecords: false,
+          hasFetchingFailedInMoreRecords: false
         }
       }),
       eventHandlers: EventHandlersFactory.create(),

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

@@ -0,0 +1,40 @@
+import { RECORD_EXECUTE_FAILED, RECORD_EXECUTE_SUCCEEDED, RECORD_EXECUTE_SUCCEEDED_NO_CONTENT } from "../../../../bc/zrecord/Constants";
+export default class ReOrderRecordStrategy {
+  createSuccessEvents(response, metaData) {
+    const events = [];
+    let {
+      oldIndex,
+      newIndex
+    } = metaData.props;
+    events.push({
+      type: RECORD_EXECUTE_SUCCEEDED,
+      payload: {
+        oldIndex,
+        newIndex
+      },
+      metaData
+    });
+    return events;
+  }
+
+  createNoContentEvents(metaData) {
+    const events = [];
+    events.push({
+      type: RECORD_EXECUTE_SUCCEEDED_NO_CONTENT,
+      payload: {},
+      metaData
+    });
+    return events;
+  }
+
+  createFailureEvents(error, metaData) {
+    const events = [];
+    events.push({
+      type: RECORD_EXECUTE_FAILED,
+      payload: {},
+      metaData
+    });
+    return events;
+  }
+
+}

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

@@ -5,11 +5,13 @@ import UpdateRecordStrategy from "./UpdateRecordStrategy";
 import DeleteRecordStrategy from "./DeleteRecordStrategy";
 import DeleteMultipleRecordStrategy from "./DeleteMultipleRecordStrategy";
 import GetRecordsStrategy from "./GetRecordsStrategy";
+import GetReOrderRecordsStrategy from "./GetReOrderRecordsStrategy";
 const recordExecuteStrategiesMap = {
   [RecordApiActionName.UPDATE_RECORD]: new UpdateRecordStrategy(),
   [RecordApiActionName.DELETE_RECORD]: new DeleteRecordStrategy(),
   [RecordApiActionName.DELETE_RECORDS]: new DeleteMultipleRecordStrategy(),
-  [RecordApiActionName.GET_RECORDS]: new GetRecordsStrategy()
+  [RecordApiActionName.GET_RECORDS]: new GetRecordsStrategy(),
+  [RecordApiActionName.GET_REORDERRECORD]: new GetReOrderRecordsStrategy()
 };
 export default class RecordsManager {
   constructor(records) {