@zohodesk/library-platform 1.0.1 → 1.0.2-exp.1.1

package/es/platform/client-actions/behaviour/zclient-actions/adapters/controllers/FetchStateStopController.js

@@ -0,0 +1,21 @@
+import AbstractController from "./AbstractController";
+export default class FetchStateStopController extends AbstractController {
+  handle(event) {
+    const {
+      state,
+      updateState,
+      action
+    } = event;
+    const {
+      metaData
+    } = action;
+    const {
+      fetchStateStopUseCase
+    } = this.service;
+    fetchStateStopUseCase.updateDependency(state, updateState);
+    fetchStateStopUseCase.execute({
+      metaData
+    });
+  }
+
+}

package/es/platform/client-actions/behaviour/zclient-actions/adapters/controllers/MountController.js

@@ -0,0 +1,25 @@
+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 MountController {
+  constructor(recordApis, service) {
+    this.recordApis = recordApis;
+    this.service = service;
+
+    _defineProperty(this, "handle", event => {
+      const {
+        state,
+        updateState,
+        dispatch
+      } = event;
+      const {
+        initializeUseCase
+      } = this.service;
+      initializeUseCase.updateDependency(state, updateState);
+      initializeUseCase.execute({
+        dispatch,
+        apiTemplates: this.recordApis
+      });
+    });
+  }
+
+}

package/es/platform/client-actions/behaviour/zclient-actions/adapters/controllers/NoContentController.js

@@ -0,0 +1,23 @@
+import AbstractController from "./AbstractController";
+export default class NoContentController extends AbstractController {
+  handle(event) {
+    const {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    const {
+      metaData
+    } = action;
+    const {
+      noContentUseCase
+    } = this.service;
+    noContentUseCase.updateDependency(state, updateState);
+    noContentUseCase.execute({
+      dispatch,
+      metaData
+    });
+  }
+
+}

package/es/platform/client-actions/behaviour/zclient-actions/adapters/controllers/SetClientActionsController.js

@@ -0,0 +1,24 @@
+import AbstractController from "./AbstractController";
+export default class SetClientActionsController extends AbstractController {
+  handle(event) {
+    const {
+      state,
+      updateState,
+      action
+    } = event;
+    const {
+      payload
+    } = action;
+    const {
+      clientActions
+    } = payload;
+    const {
+      setClientActionsUseCase
+    } = this.service;
+    setClientActionsUseCase.updateDependency(state, updateState);
+    setClientActionsUseCase.execute({
+      clientActions
+    });
+  }
+
+}

package/es/platform/client-actions/behaviour/zclient-actions/adapters/controllers/SuccessController.js

@@ -0,0 +1,28 @@
+import AbstractController from "./AbstractController";
+export default class SuccessController extends AbstractController {
+  handle(event) {
+    const {
+      state,
+      updateState,
+      action,
+      dispatch
+    } = event;
+    const {
+      metaData,
+      payload
+    } = action;
+    const {
+      response
+    } = payload;
+    const {
+      successUseCase
+    } = this.service;
+    successUseCase.updateDependency(state, updateState);
+    successUseCase.execute({
+      dispatch,
+      response,
+      metaData
+    });
+  }
+
+}

package/es/platform/client-actions/behaviour/zclient-actions/adapters/gateways/Repository.js

@@ -0,0 +1,28 @@
+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 ClientActionManagerFactory from "../../applications/entities-factory/ClientActionManagerFactory";
+export default class Repository {
+  constructor() {
+    _defineProperty(this, "state", void 0);
+  }
+
+  init(state) {
+    this.state = state;
+  }
+
+  getClientActionsManagerEntity() {
+    const {
+      zclientAction
+    } = this.state.behaviours;
+    const {
+      clientActions = [],
+      isFetching
+    } = zclientAction;
+    const clientActionManager = ClientActionManagerFactory.create({
+      data: clientActions,
+      isFetching
+    });
+    return clientActionManager;
+  }
+
+}

package/es/platform/client-actions/behaviour/zclient-actions/adapters/gateways/Service.js

@@ -0,0 +1,35 @@
+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 InitializeUseCase from "../../applications/usecases/InitializeUseCase";
+import ExecuteActionBehaviourUseCase from "../../applications/usecases/ExecuteActionBehaviourUseCase";
+import FailureUseCase from "../../applications/usecases/FailureUseCase";
+import SuccessUseCase from "../../applications/usecases/SuccessUseCase";
+import NoContentUseCase from "../../applications/usecases/NoContentUseCase";
+import SetClientActionsUseCase from "../../applications/usecases/SetClientActionsUseCase";
+import FetchStateStopUseCase from "../../applications/usecases/FetchStateStopUseCase";
+export default class Service {
+  constructor(dependencies) {
+    _defineProperty(this, "initializeUseCase", void 0);
+
+    _defineProperty(this, "executeActionBehaviourUseCase", void 0);
+
+    _defineProperty(this, "failureUseCase", void 0);
+
+    _defineProperty(this, "successUseCase", void 0);
+
+    _defineProperty(this, "fetchStateStopUseCase", void 0);
+
+    _defineProperty(this, "noContentUseCase", void 0);
+
+    _defineProperty(this, "setClientActionsUseCase", void 0);
+
+    this.initializeUseCase = new InitializeUseCase(dependencies);
+    this.executeActionBehaviourUseCase = new ExecuteActionBehaviourUseCase(dependencies);
+    this.failureUseCase = new FailureUseCase(dependencies);
+    this.successUseCase = new SuccessUseCase(dependencies);
+    this.fetchStateStopUseCase = new FetchStateStopUseCase(dependencies);
+    this.noContentUseCase = new NoContentUseCase(dependencies);
+    this.setClientActionsUseCase = new SetClientActionsUseCase(dependencies);
+  }
+
+}

package/es/platform/client-actions/behaviour/zclient-actions/adapters/presenters/Presenter.js

@@ -0,0 +1,24 @@
+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 Presenter {
+  constructor() {
+    _defineProperty(this, "updateState", void 0);
+
+    _defineProperty(this, "state", void 0);
+  }
+
+  updateDependencies(state, updateState) {
+    this.updateState = updateState;
+    this.state = state;
+  }
+
+  updateClientAction(zclientAction) {
+    this.state = { ...this.state,
+      behaviours: { ...this.state.behaviours,
+        zclientAction
+      }
+    };
+    this.updateState(this.state);
+  }
+
+}

package/es/platform/client-actions/behaviour/zclient-actions/applications/entities-factory/ClientActionFactory.js

@@ -0,0 +1,12 @@
+import ClientAction from "../../domain/entities/ClientAction";
+export default class ClientActionFactory {
+  static createSingleClientAction(clientActionModel) {
+    const clientAction = new ClientAction(clientActionModel);
+    return clientAction;
+  }
+
+  static createMultipleClientActions(data) {
+    return data.map(clientActionModel => new ClientAction(clientActionModel));
+  }
+
+}

package/es/platform/client-actions/behaviour/zclient-actions/applications/entities-factory/ClientActionManagerFactory.js

@@ -0,0 +1,10 @@
+import ClientActionManager from "../../domain/entities/ClientActionManager";
+import ClientActions from "../../domain/entities/ClientActions";
+export default class ClientActionManagerFactory {
+  static create(clientActionsModel) {
+    const clientActions = new ClientActions(clientActionsModel);
+    const clientActionManager = new ClientActionManager(clientActions);
+    return clientActionManager;
+  }
+
+}

package/es/platform/client-actions/behaviour/zclient-actions/applications/usecases/ExecuteActionBehaviourUseCase.js

@@ -0,0 +1,33 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class ExecuteActionBehaviourUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    const {
+      props,
+      dispatch,
+      apiName,
+      actionName
+    } = input;
+    const recordManager = repository.getClientActionsManagerEntity();
+
+    if (!recordManager.isClientActionApiName(apiName)) {
+      return;
+    }
+
+    const metaData = recordManager.createFetchClientActionMeta(actionName, apiName, props);
+
+    if (recordManager.isGetClientActionsApi(actionName)) {
+      recordManager.fetchingStarted();
+      presenter.updateClientAction(recordManager.toObject());
+    }
+
+    dispatch(recordManager.createDataSourceExecuteEvent(props, actionName, metaData));
+  }
+
+}
+
+export default ExecuteActionBehaviourUseCase;

package/es/platform/client-actions/behaviour/zclient-actions/applications/usecases/FailureUseCase.js

@@ -0,0 +1,22 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class FailureUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      repository
+    } = this.dependencies;
+    const {
+      dispatch,
+      metaData,
+      error
+    } = input;
+    const recordManager = repository.getClientActionsManagerEntity();
+    const events = recordManager.createFailureEvents(error, metaData);
+    events.forEach(event => {
+      dispatch(event);
+    });
+  }
+
+}
+
+export default FailureUseCase;

package/es/platform/client-actions/behaviour/zclient-actions/applications/usecases/FetchStateStopUseCase.js

@@ -0,0 +1,25 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class FetchStateStopUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      repository,
+      presenter
+    } = this.dependencies;
+    const {
+      metaData
+    } = input;
+    const {
+      actionName
+    } = metaData;
+    const recordManager = repository.getClientActionsManagerEntity();
+
+    if (recordManager.isGetClientActionsApi(actionName)) {
+      recordManager.fetchingFinished();
+      presenter.updateClientAction(recordManager.toObject());
+    }
+  }
+
+}
+
+export default FetchStateStopUseCase;

package/es/platform/client-actions/behaviour/zclient-actions/applications/usecases/InitializeUseCase.js

@@ -0,0 +1,17 @@
+import AbstractUseCase from "./AbstractUseCase";
+import { DATA_SOURCE_REGISTER } from "../../../../../../bc/zdata-source/Constants";
+export default class InitializeUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      apiTemplates,
+      dispatch
+    } = input;
+    dispatch({
+      type: DATA_SOURCE_REGISTER,
+      payload: {
+        apiTemplates
+      }
+    });
+  }
+
+}

package/es/platform/client-actions/behaviour/zclient-actions/applications/usecases/NoContentUseCase.js

@@ -0,0 +1,27 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class NoContentUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      presenter,
+      repository
+    } = this.dependencies;
+    const {
+      dispatch,
+      metaData
+    } = input;
+    const recordManager = repository.getClientActionsManagerEntity();
+
+    if (recordManager.isGetClientActionsApi(metaData.actionName)) {
+      presenter.updateClientAction(recordManager.toObject());
+    }
+
+    const events = recordManager.createNoContentEvents(metaData);
+    events.forEach(event => {
+      dispatch(event);
+    });
+  }
+
+}
+
+export default NoContentUseCase;

package/es/platform/client-actions/behaviour/zclient-actions/applications/usecases/SetClientActionsUseCase.js

@@ -0,0 +1,21 @@
+import AbstractUseCase from "./AbstractUseCase";
+import ClientActionFactory from "../entities-factory/ClientActionFactory";
+
+class SetClientActionsUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      presenter,
+      repository
+    } = this.dependencies;
+    const {
+      clientActions
+    } = input;
+    const recordManager = repository.getClientActionsManagerEntity();
+    const recordsEntity = ClientActionFactory.createMultipleClientActions(clientActions);
+    recordManager.setClientActions(recordsEntity);
+    presenter.updateClientAction(recordManager.toObject());
+  }
+
+}
+
+export default SetClientActionsUseCase;

package/es/platform/client-actions/behaviour/zclient-actions/applications/usecases/SuccessUseCase.js

@@ -0,0 +1,22 @@
+import AbstractUseCase from "./AbstractUseCase";
+
+class SuccessUseCase extends AbstractUseCase {
+  execute(input) {
+    const {
+      repository
+    } = this.dependencies;
+    const {
+      response,
+      metaData,
+      dispatch
+    } = input;
+    const recordManager = repository.getClientActionsManagerEntity();
+    const events = recordManager.createSuccessEvents(response, metaData);
+    events.forEach(event => {
+      dispatch(event);
+    });
+  }
+
+}
+
+export default SuccessUseCase;

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/ClientAction.js

@@ -0,0 +1,65 @@
+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 UIComponentMapping from "./UIComponentMapping";
+export default class ClientAction {
+  constructor(clientActionObj) {
+    _defineProperty(this, "id", void 0);
+
+    _defineProperty(this, "name", void 0);
+
+    _defineProperty(this, "component", void 0);
+
+    _defineProperty(this, "location", void 0);
+
+    _defineProperty(this, "uiComponentMapping", void 0);
+
+    _defineProperty(this, "modules", void 0);
+
+    _defineProperty(this, "modifiedTime", void 0);
+
+    _defineProperty(this, "createdTime", void 0);
+
+    _defineProperty(this, "modifiedBy", void 0);
+
+    _defineProperty(this, "createdBy", void 0);
+
+    _defineProperty(this, "conditions", void 0);
+
+    _defineProperty(this, "conditionMeta", void 0);
+
+    this.id = clientActionObj.id;
+    this.name = clientActionObj.name;
+    this.component = clientActionObj.component;
+    this.location = clientActionObj.location;
+    this.uiComponentMapping = new UIComponentMapping(clientActionObj.uiComponentMapping);
+    this.modules = clientActionObj.modules;
+    this.modifiedTime = clientActionObj.modifiedTime;
+    this.createdTime = clientActionObj.createdTime;
+    this.modifiedBy = clientActionObj.modifiedBy;
+    this.createdBy = clientActionObj.createdBy;
+    this.conditions = clientActionObj.conditions;
+    this.conditionMeta = clientActionObj.conditions;
+  }
+
+  toObject() {
+    return {
+      id: this.id,
+      name: this.name,
+      component: this.component,
+      location: this.location,
+      uiComponentMapping: this.uiComponentMapping.toObject(),
+      modules: this.modules,
+      modifiedTime: this.modifiedTime,
+      createdTime: this.createdTime,
+      modifiedBy: this.modifiedBy,
+      createdBy: this.createdBy,
+      conditions: this.conditions,
+      conditionsMeta: this.conditionMeta
+    };
+  }
+
+  getId() {
+    return this.id;
+  }
+
+}

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/ClientActionManager.js

@@ -0,0 +1,141 @@
+import { DATA_SOURCE_FAILURE, DATA_SOURCE_NO_CONTENT, DATA_SOURCE_SUCCESS } from "../../../../../../bc/zdata-source/Symbols";
+import { DATA_SOURCE_EXECUTE } from "../../../../../../bc/zdata-source/Constants";
+import { CLIENTACTION_EXECUTE_FAIL_CALLBACK, CLIENTACTION_EXECUTE_SUCCESS_CALLBACK, CLIENTACTION_EXECUTE_SUCCESS_NO_CONTENT_CALLBACK, ClientActionApiActionName } from "../../../../bc/zclient-actions/Constants";
+import GetClientActionsStrategy from "./GetClientActionsStrategy";
+const clientActionExecuteStrategiesMap = {
+  [ClientActionApiActionName.GET_CLIENTACTIONS]: new GetClientActionsStrategy()
+};
+export default class ClientActionManager {
+  constructor(clientActions) {
+    this.clientActions = clientActions;
+  }
+
+  createDataSourceMeta(_ref) {
+    let {
+      actionName,
+      successMeta,
+      successNoContentMeta,
+      failureMeta
+    } = _ref;
+    return {
+      actionName,
+      [DATA_SOURCE_NO_CONTENT]: successNoContentMeta,
+      [DATA_SOURCE_FAILURE]: failureMeta,
+      [DATA_SOURCE_SUCCESS]: successMeta
+    };
+  }
+
+  createDataSourceExecuteEvent(props, actionName, metaData) {
+    return {
+      type: DATA_SOURCE_EXECUTE,
+      payload: {
+        props,
+        actionName
+      },
+      metaData
+    };
+  }
+
+  createFetchClientActionMeta(actionName, apiName, props) {
+    const clientActionExecuteStrategyMeta = {
+      actionName,
+      apiName,
+      props
+    };
+
+    if (this.isGetClientActionsApi(actionName)) {
+      clientActionExecuteStrategyMeta.props.from = 1;
+    }
+
+    const successMeta = {
+      type: CLIENTACTION_EXECUTE_SUCCESS_CALLBACK,
+      metaData: clientActionExecuteStrategyMeta
+    };
+    const successNoContentMeta = {
+      type: CLIENTACTION_EXECUTE_SUCCESS_NO_CONTENT_CALLBACK,
+      metaData: clientActionExecuteStrategyMeta
+    };
+    const failureMeta = {
+      type: CLIENTACTION_EXECUTE_FAIL_CALLBACK,
+      metaData: clientActionExecuteStrategyMeta
+    };
+    return this.createDataSourceMeta({
+      actionName,
+      successNoContentMeta,
+      failureMeta,
+      successMeta
+    });
+  }
+
+  createSuccessEvents(response, metaData) {
+    const {
+      actionName
+    } = metaData;
+    const strategy = clientActionExecuteStrategiesMap[actionName];
+
+    if (strategy) {
+      return strategy.createSuccessEvents(response, metaData);
+    } else {
+      return [];
+    }
+  }
+
+  createNoContentEvents(metaData) {
+    const {
+      actionName
+    } = metaData;
+    const strategy = clientActionExecuteStrategiesMap[actionName];
+
+    if (strategy) {
+      return strategy.createNoContentEvents(metaData);
+    } else {
+      return [];
+    }
+  }
+
+  createFailureEvents(error, metaData) {
+    const {
+      actionName
+    } = metaData;
+    const strategy = clientActionExecuteStrategiesMap[actionName];
+
+    if (strategy) {
+      return strategy.createFailureEvents(error, metaData);
+    } else {
+      return [];
+    }
+  }
+
+  fetchingStarted() {
+    this.clientActions.setIsFetching(true);
+  }
+
+  fetchingFinished() {
+    this.clientActions.setIsFetching(false);
+  }
+
+  setClientActions(clientActions) {
+    this.clientActions.setClientActions(clientActions);
+  }
+
+  isGetClientActionsApi(actionName) {
+    return ClientActionApiActionName.GET_CLIENTACTIONS === actionName;
+  }
+
+  isClientActionsFetching() {
+    return this.clientActions.isClientActionsFetching();
+  }
+
+  isClientActionApiName(apiName) {
+    return apiName === 'clientActions';
+  }
+
+  toObject() {
+    const clientActionsObj = this.clientActions.toObject();
+    return {
+      clientActions: clientActionsObj.data,
+      isFetching: clientActionsObj.isFetching
+    };
+  }
+
+}

package/es/platform/client-actions/behaviour/zclient-actions/domain/entities/ClientActions.js

@@ -0,0 +1,50 @@
+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 ClientAction from "./ClientAction";
+export default class ClientActions {
+  constructor(_ref) {
+    let {
+      data,
+      isFetching
+    } = _ref;
+    let fetchLimit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;
+
+    _defineProperty(this, "clientActions", void 0);
+
+    _defineProperty(this, "isFetching", void 0);
+
+    _defineProperty(this, "fetchLimit", void 0);
+
+    this.clientActions = data.map(obj => new ClientAction(obj));
+    this.fetchLimit = fetchLimit;
+    this.isFetching = isFetching;
+  }
+
+  setIsFetching(isFetching) {
+    this.isFetching = isFetching;
+  }
+
+  setClientActions(clientActions) {
+    this.clientActions = clientActions;
+  }
+
+  isClientActionsFetching() {
+    return this.isFetching;
+  }
+
+  getClientActionsLength() {
+    return this.clientActions.length;
+  }
+
+  getClientAction(id) {
+    return this.clientActions.find(clientAction => clientAction.getId() === id) || null;
+  }
+
+  toObject() {
+    return {
+      data: this.clientActions.map(action => action.toObject()),
+      isFetching: this.isFetching
+    };
+  }
+
+}