@zohodesk/library-platform 1.0.0-exp.5 → 1.0.0-exp.6

package/es/platform/zlist/entities/interfaces/RecordExecuteAfterMetaData.js

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

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_RECORDS, ZLIST_FETCH_MORE, ZLIST_FETCH_SORTED, ZLIST_RECORD_UPDATE } from "../../../bc/zlist/Constants";
+import { ZLIST_DELETE_RECORD, ZLIST_DELETE_RECORDS, ZLIST_FETCH_MORE, ZLIST_FETCH_SORTED, ZLIST_RECORD_UPDATE } from "../../../bc/zlist/Constants";
 import FetchMoreController from "../adapters/controllers/FetchMoreController";
 import SortController from "../adapters/controllers/SortController";
 import FieldChangeController from "../adapters/controllers/FieldChangeController";
@@ -12,6 +12,10 @@ import LifeCycleAction from "../../../cc/architecture/LifeCycleActionEnum";
 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 } from "../../../bc/zrecord/Constants";
 export default class ActionHandlersFactory {
   static create() {
     const repository = new Repository();
@@ -27,6 +31,9 @@ export default class ActionHandlersFactory {
       fieldChange: new FieldChangeController(service).handle,
       recordUpdate: new RecordUpdateController(service).handle,
       deleteMultipleRecord: new DeleteMultipleRecordController(service).handle,
+      deleteRecord: new DeleteSingleRecordController(service).handle,
+      recordExecuteSucceeded: new RecordExecuteSucceededController(service).handle,
+      recordExecuteFailed: new RecordExecuteFailedController(service).handle,
       sort: new SortController(service).handle
     };
     return {
@@ -36,6 +43,9 @@ export default class ActionHandlersFactory {
       [ZLIST_FETCH_MORE]: controller.fetchMore,
       [ZLIST_RECORD_UPDATE]: controller.recordUpdate,
       [TableListConstants.TABLE_LIST_FIELD_CHANGED]: controller.fieldChange,
+      [ZLIST_DELETE_RECORD]: controller.deleteRecord,
+      [RECORD_EXECUTE_SUCCEEDED]: controller.recordExecuteSucceeded,
+      [RECORD_EXECUTE_FAILED]: controller.recordExecuteFailed,
       [ZLIST_FETCH_SORTED]: controller.sort
     };
   }

package/es/platform/zlist/usecases/interactors/DeleteSingleRecordUseCase.js

@@ -0,0 +1,19 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class DeleteSingleRecordUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      dispatch,
+      recordId
+    } = input;
+    const {
+      repository
+    } = this.dependencies;
+    const list = repository.getList();
+    const action = list.getDeleteSingleRecordAction(recordId);
+    dispatch(action);
+  }
+
+}
+
+export default DeleteSingleRecordUseCase;

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

@@ -0,0 +1,22 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class RecordExecuteFailedUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      dispatch,
+      metaData,
+      payload
+    } = input;
+    const {
+      repository
+    } = this.dependencies;
+    const list = repository.getList();
+    const actions = list.getRecordExecuteFailedActions(payload, metaData);
+    actions.forEach(action => {
+      dispatch(action);
+    });
+  }
+
+}
+
+export default RecordExecuteFailedUseCase;

package/es/platform/zlist/usecases/interactors/RecordExecuteSucceededUseCase.js

@@ -0,0 +1,22 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class RecordExecuteSucceededUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      dispatch,
+      payload,
+      metaData
+    } = input;
+    const {
+      repository
+    } = this.dependencies;
+    const list = repository.getList();
+    const actions = list.getRecordExecuteSucceededActions(payload, metaData);
+    actions.forEach(action => {
+      dispatch(action);
+    });
+  }
+
+}
+
+export default RecordExecuteSucceededUseCase;

package/es/platform/zlist/usecases/interfaces/input/DeleteSingleRecordUseCaseInput.js

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

package/es/platform/zlist/usecases/interfaces/input/RecordExecuteFailedUseCaseInput.js

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

package/es/platform/zlist/usecases/interfaces/input/RecordExecuteSucceededUseCaseInput.js

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

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

@@ -0,0 +1,29 @@
+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; }
+
+export default class SetRecordsController {
+  constructor(service) {
+    this.service = service;
+
+    _defineProperty(this, "handle", event => {
+      const {
+        state,
+        updateState,
+        action
+      } = event;
+      const {
+        payload
+      } = action;
+      const {
+        records
+      } = payload;
+      const {
+        setRecordsUseCase
+      } = this.service;
+      setRecordsUseCase.updateDependency(state, updateState);
+      setRecordsUseCase.execute({
+        records
+      });
+    });
+  }
+
+}

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

@@ -11,6 +11,7 @@ import RecordUpdateLocalUseCase from "../../usecases/interactors/RecordUpdateLoc
 import DeleteMultipleRecordUseCase from "../../usecases/interactors/DeleteMultipleRecordUseCase";
 import AppendRecordsUseCase from "../../usecases/interactors/AppendRecordsUseCase";
 import FieldChangeUseCase from "../../usecases/interactors/FieldChangeUseCase";
+import SetRecordsUseCase from "../../usecases/interactors/SetRecordsUseCase";
 export default class Service {
   constructor(dependencies) {
     _defineProperty(this, "initializeUseCase", void 0);
@@ -27,6 +28,8 @@ export default class Service {
 
     _defineProperty(this, "appendRecordsUseCase", void 0);
 
+    _defineProperty(this, "setRecordsUseCase", void 0);
+
     _defineProperty(this, "fieldChangeUseCase", void 0);
 
     _defineProperty(this, "fetchMoreUseCase", void 0);
@@ -42,6 +45,7 @@ export default class Service {
     this.refetchUseCase = new RefetchUseCase(dependencies);
     this.noContentUseCase = new NoContentUseCase(dependencies);
     this.appendRecordsUseCase = new AppendRecordsUseCase(dependencies);
+    this.setRecordsUseCase = new SetRecordsUseCase(dependencies);
     this.fieldChangeUseCase = new FieldChangeUseCase(dependencies);
     this.fetchMoreUseCase = new FetchMoreUseCase(dependencies);
     this.recordUpdateLocalUseCase = new RecordUpdateLocalUseCase(dependencies);

package/es/platform/zrecord/entities/APITemplate.js

@@ -1,5 +1,10 @@
 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 API_METHODS from "./interfaces/ApiEnum";
+
+// import IAPITemplate from '../interfaces/api-template/IAPITemplate';
+// import { API_METHODS, APITemplateModel, APIDetailsModel } from '../interfaces/api-template/APIModels';
+// import { ITemplateHelpers } from '../interfaces/api-template/ITemplateHelpers';
 class APITemplate {
   constructor(input, templateHelpers) {
     _defineProperty(this, "input", void 0);
@@ -14,11 +19,14 @@ class APITemplate {
 
     _defineProperty(this, "helper", void 0);
 
+    _defineProperty(this, "getResponseInTemplate", void 0);
+
     this.input = input;
     this.api = input.api;
+    this.getResponseInTemplate = input.getResponse;
     this.payload = input.requestBody;
     this.parameters = input.parameters;
-    this.type = input.type;
+    this.type = API_METHODS[input.type];
     this.helper = templateHelpers;
   }
 
@@ -51,15 +59,29 @@ class APITemplate {
     }
 
     return `${this.getApi(obj)}?${query}`;
-  }
+  } // eslint-disable-next-line max-lines-per-function
+
 
   getApiDetails(obj) {
-    return {
+    const apiDetails = {
       url: this.constructURL(obj),
       type: this.type,
       method: this.type,
       payload: this.getPayload(obj)
     };
+
+    if (this.getResponseInTemplate) {
+      apiDetails.getResponse = () => {
+        const payload = JSON.parse(this.getPayload(obj));
+        const params = JSON.parse(this.getParameter(obj));
+        return this.getResponseInTemplate({
+          payload,
+          params
+        });
+      };
+    }
+
+    return apiDetails;
   }
 
   getTransformer() {

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

@@ -1,7 +1,7 @@
 /* eslint-disable max-lines-per-function */
 import { RECORD_FAILURE, RECORD_NO_CONTENT, RECORD_SUCCESS } from "../../../bc/zrecord/Symbols";
 import { FETCH } from "../../../bc/zhttp/Constants";
-import { APPEND_RECORDS, RECORD_LOCAL_MULTIPLE_DELETE, RECORD_LOCAL_UPDATE, RecordApiActionName } from "../../../bc/zrecord/Constants";
+import { APPEND_RECORDS, SET_RECORDS, RECORD_EXECUTE_FAILED, RECORD_EXECUTE_SUCCEEDED, RECORD_LOCAL_MULTIPLE_DELETE, RECORD_LOCAL_UPDATE, RecordApiActionName } from "../../../bc/zrecord/Constants";
 export default class RecordsManager {
   constructor(apiTemplates, records) {
     this.apiTemplates = apiTemplates;
@@ -16,20 +16,46 @@ export default class RecordsManager {
     };
   }
 
+  isGetRecordsApi(metaData) {
+    const {
+      actionName
+    } = metaData;
+    return RecordApiActionName.GET_RECORDS === actionName;
+  }
+
   createFetchRecordMeta(actionName, apiName, headers, props) {
     let successMeta = {
-      type: APPEND_RECORDS,
-      metaData: {}
+      type: '',
+      metaData: {
+        props
+      }
     };
     let successNoContentMeta = {
       type: '',
-      metaData: {}
+      metaData: {
+        props
+      }
+    };
+    let failureMeta = {
+      type: '',
+      metaData: {
+        props
+      }
     };
 
     if (RecordApiActionName.UPDATE_RECORD === actionName) {
       successMeta = {
         type: RECORD_LOCAL_UPDATE,
-        metaData: {}
+        metaData: {
+          props
+        }
+      };
+    } else if (RecordApiActionName.GET_RECORDS === actionName) {
+      successMeta = {
+        type: SET_RECORDS,
+        metaData: {
+          props
+        }
       };
     } else if (RecordApiActionName.DELETE_RECORDS === actionName) {
       successMeta = {
@@ -44,6 +70,19 @@ export default class RecordsManager {
           props
         }
       };
+    } else if (RecordApiActionName.DELETE_RECORD === actionName) {
+      successMeta = {
+        type: RECORD_LOCAL_MULTIPLE_DELETE,
+        metaData: {
+          props
+        }
+      };
+      successNoContentMeta = {
+        type: RECORD_LOCAL_MULTIPLE_DELETE,
+        metaData: {
+          props
+        }
+      };
     }
 
     return {
@@ -51,22 +90,41 @@ export default class RecordsManager {
       apiName,
       actionName,
       [RECORD_NO_CONTENT]: successNoContentMeta,
+      [RECORD_FAILURE]: failureMeta,
       [RECORD_SUCCESS]: successMeta
     };
   }
 
-  createFetchMoreRecordMeta(actionName, apiName, headers) {
+  createFetchMoreRecordMeta(actionName, apiName, headers, props) {
+    const successMeta = {
+      type: APPEND_RECORDS,
+      metaData: {
+        props
+      }
+    };
+    const successNoContentMeta = {
+      type: '',
+      metaData: {
+        props
+      }
+    };
+    const failureMeta = {
+      type: '',
+      metaData: {
+        props
+      }
+    };
     return {
       headers,
       apiName,
       actionName,
-      [RECORD_SUCCESS]: {
-        type: APPEND_RECORDS
-      }
+      [RECORD_NO_CONTENT]: successNoContentMeta,
+      [RECORD_FAILURE]: failureMeta,
+      [RECORD_SUCCESS]: successMeta
     };
   }
 
-  createSuccessAction(transformedRes, metaData) {
+  createSuccessActions(transformedResponse, metaData) {
     const {
       actionName
     } = metaData;
@@ -74,32 +132,83 @@ export default class RecordsManager {
       type,
       metaData: successMeta
     } = metaData[RECORD_SUCCESS];
+    const actions = [];
 
     if (RecordApiActionName.UPDATE_RECORD === actionName) {
-      return {
+      const record = transformedResponse;
+      const recordId = transformedResponse.id;
+      type && actions.push({
         type,
+        metaData,
         payload: {
-          record: transformedRes,
-          recordId: transformedRes.id
+          record,
+          recordId
         }
-      };
-    }
-
-    if (RecordApiActionName.DELETE_RECORDS === actionName) {
-      return {
+      });
+      actions.push({
+        type: RECORD_EXECUTE_SUCCEEDED,
+        metaData,
+        payload: {
+          actionName,
+          record,
+          recordId
+        }
+      });
+    } else if (RecordApiActionName.DELETE_RECORDS === actionName) {
+      const recordIds = successMeta.props.recordIds;
+      actions.push({
         type,
+        metaData,
         payload: {
-          recordIds: successMeta.props.recordIds
+          recordIds
         }
-      };
+      });
+      actions.push({
+        type: RECORD_EXECUTE_SUCCEEDED,
+        metaData,
+        payload: {
+          actionName,
+          recordIds
+        }
+      });
+    } else if (RecordApiActionName.DELETE_RECORD === actionName) {
+      const recordId = successMeta.props.recordId;
+      const recordIds = [recordId];
+      actions.push({
+        type,
+        metaData,
+        payload: {
+          recordIds
+        }
+      });
+      actions.push({
+        type: RECORD_EXECUTE_SUCCEEDED,
+        metaData,
+        payload: {
+          actionName,
+          recordId
+        }
+      });
+    } else if (RecordApiActionName.GET_RECORDS === actionName) {
+      const records = transformedResponse;
+      actions.push({
+        type,
+        metaData,
+        payload: {
+          records
+        }
+      });
+      actions.push({
+        type: RECORD_EXECUTE_SUCCEEDED,
+        metaData,
+        payload: {
+          actionName,
+          records
+        }
+      });
     }
 
-    return {
-      type,
-      payload: {
-        records: transformedRes
-      }
-    };
+    return actions;
   }
 
   createNoContentAction(metaData) {
@@ -108,40 +217,132 @@ export default class RecordsManager {
     } = metaData;
     const {
       type,
-      payload,
       metaData: noContentMeta
     } = metaData[RECORD_NO_CONTENT];
 
     if (RecordApiActionName.DELETE_RECORDS === actionName) {
       return {
         type,
+        metaData,
         payload: {
           recordIds: noContentMeta.props.recordIds
         }
       };
     }
 
+    if (RecordApiActionName.DELETE_RECORD === actionName) {
+      return {
+        type,
+        metaData,
+        payload: {
+          recordId: noContentMeta.props.recordId
+        }
+      };
+    }
+
     return {
       type,
-      payload
+      metaData,
+      payload: {}
     };
   }
 
-  createFailureAction(error, metaData) {
+  createFailureActions(error, metaData) {
+    const {
+      actionName
+    } = metaData;
     const {
-      type
-    } = metaData[RECORD_FAILURE];
-    return {
       type,
-      payload: {
-        error
-      }
-    };
+      metaData: failureMeta
+    } = metaData[RECORD_FAILURE];
+    const actions = [];
+
+    if (RecordApiActionName.UPDATE_RECORD === actionName) {
+      const {
+        recordId
+      } = failureMeta.props;
+      type && actions.push({
+        type,
+        metaData,
+        payload: {
+          error,
+          recordId
+        }
+      });
+      actions.push({
+        type: RECORD_EXECUTE_FAILED,
+        metaData,
+        payload: {
+          actionName,
+          error,
+          recordId
+        }
+      });
+    } else if (RecordApiActionName.DELETE_RECORD === actionName) {
+      const {
+        recordId
+      } = failureMeta.props;
+      type && actions.push({
+        type,
+        metaData,
+        payload: {
+          error,
+          recordId
+        }
+      });
+      actions.push({
+        type: RECORD_EXECUTE_FAILED,
+        metaData,
+        payload: {
+          actionName,
+          error,
+          recordId
+        }
+      });
+    } else if (RecordApiActionName.DELETE_RECORDS === actionName) {
+      const {
+        recordIds
+      } = failureMeta.props;
+      type && actions.push({
+        type,
+        metaData,
+        payload: {
+          error,
+          recordIds
+        }
+      });
+      actions.push({
+        type: RECORD_EXECUTE_FAILED,
+        metaData,
+        payload: {
+          actionName,
+          error,
+          recordIds
+        }
+      });
+    } else {
+      type && actions.push({
+        type,
+        metaData,
+        payload: {
+          error
+        }
+      });
+      actions.push({
+        type: RECORD_EXECUTE_FAILED,
+        metaData,
+        payload: {
+          error
+        }
+      });
+    }
+
+    return actions;
   }
 
   getApiDetails(actionName, props) {
     return this.apiTemplates.getApiDetails(actionName, { ...props,
-      from: this.records.getRecordsLength()
+      from: this.records.getRecordsLength() + 1
     });
   }
 
@@ -158,6 +359,10 @@ export default class RecordsManager {
     this.records.setHasMore(true);
   }
 
+  setNoMoreDataInRecords() {
+    this.records.setHasMore(false);
+  }
+
   hasMoreRecords() {
     return this.records.hasMoreRecords();
   }
@@ -166,6 +371,11 @@ export default class RecordsManager {
     return this.records.isRecordsFetching();
   }
 
+  setRecords(records) {
+    this.records.setRecords(records);
+    this.records.updateHasMore(records.length);
+  }
+
   appendRecords(records) {
     this.records.appendRecords(records);
     this.records.updateHasMore(records.length);

package/es/platform/zrecord/entities/interfaces/MetaData.js

@@ -1 +1 @@
-import { RECORD_FAILURE, RECORD_SUCCESS } from "../../../../bc/zrecord/Symbols";
+import { RECORD_FAILURE, RECORD_NO_CONTENT, RECORD_SUCCESS } from "../../../../bc/zrecord/Symbols";

package/es/platform/zrecord/frameworks/ActionsHandlersFactory.js

@@ -1,5 +1,5 @@
 /* eslint-disable max-lines-per-function */
-import { APPEND_RECORDS, RECORD_EXECUTE, RECORD_FETCH_MORE, RECORD_FIELD_CHANGE, RECORD_LOCAL_MULTIPLE_DELETE, RECORD_LOCAL_UPDATE, RECORD_REFETCH } from "../../../bc/zrecord/Constants";
+import { APPEND_RECORDS, RECORD_EXECUTE, RECORD_FETCH_MORE, RECORD_FIELD_CHANGE, RECORD_LOCAL_MULTIPLE_DELETE, RECORD_LOCAL_UPDATE, SET_RECORDS, RECORD_REFETCH } from "../../../bc/zrecord/Constants";
 import { FETCH_FAILED, FETCH_SUCCESS, FETCH_SUCCESS_NO_CONTENT } from "../../../bc/zhttp/Constants";
 import MountController from "../adapters/controllers/MountController";
 import Presenter from "../adapters/presenters/Presenter";
@@ -16,6 +16,7 @@ import FetchMoreController from "../adapters/controllers/FetchMoreController";
 import FieldChangeController from "../adapters/controllers/FieldChangeController";
 import RecordUpdateLocalController from "../adapters/controllers/RecordUpdateLocalController";
 import DeleteMultipleRecordLocalController from "../adapters/controllers/DeleteMultipleRecordLocalController";
+import SetRecordsController from "../adapters/controllers/SetRecordsController";
 export default class ActionsHandlersFactory {
   static create(apiDetails) {
     const presenter = new Presenter();
@@ -35,6 +36,7 @@ export default class ActionsHandlersFactory {
     const refetchController = new RefetchController(service);
     const noContentController = new NoContentController(service);
     const appendRecordsController = new AppendRecordsController(service);
+    const setRecordsController = new SetRecordsController(service);
     const fieldChangeController = new FieldChangeController(service);
     const recordUpdateLocalController = new RecordUpdateLocalController(service);
     const deleteMultipleRecordLocalController = new DeleteMultipleRecordLocalController(service);
@@ -47,6 +49,7 @@ export default class ActionsHandlersFactory {
       [FETCH_SUCCESS]: successController.handle,
       [RECORD_LOCAL_MULTIPLE_DELETE]: deleteMultipleRecordLocalController.handle,
       [APPEND_RECORDS]: appendRecordsController.handle,
+      [SET_RECORDS]: setRecordsController.handle,
       [RECORD_FIELD_CHANGE]: fieldChangeController.handle,
       [RECORD_LOCAL_UPDATE]: recordUpdateLocalController.handle,
       [FETCH_SUCCESS_NO_CONTENT]: noContentController.handle

package/es/platform/zrecord/usecases/interactors/ExecuteActionUseCase.js

@@ -22,8 +22,12 @@ class ExecuteActionUseCase extends AbstractUseCase {
 
     const apiDetails = recordManager.getApiDetails(actionName, props);
     const metaData = recordManager.createFetchRecordMeta(actionName, apiName, inputMeta.headers, props);
-    recordManager.fetchingStarted();
-    presenter.updateRecord(recordManager.toObject());
+
+    if (recordManager.isGetRecordsApi(metaData)) {
+      recordManager.fetchingStarted();
+      presenter.updateRecord(recordManager.toObject());
+    }
+
     dispatch(recordManager.createFetchAction(apiDetails, metaData));
   }