stitch-ui/src/services/actions.js

import { createAction } from "redux-act";
import { makeAsyncActions, asyncActionExecutor } from "../util";
import { addAlert } from "../alert";

const NAME = "services/";
export const loadSvcActions = makeAsyncActions(`${NAME}load service`);
export const saveSvcConfigActions = makeAsyncActions(`${NAME}save svc config`);
export const addSvcRuleActions = makeAsyncActions(`${NAME}add svc rule`);
export const updateSvcRuleActions = makeAsyncActions(`${NAME}update svc rule`);
export const deleteSvcRuleActions = makeAsyncActions(`${NAME}delete svc rule`);
export const deleteSvcActions = makeAsyncActions(`${NAME}delete svc`);
export const setRuleErrorAction = createAction(`${NAME}set rule error`);
export const setConfigInput = createAction(`${NAME}set config input`);

export const updateRule = asyncActionExecutor(
  updateSvcRuleActions,
  (client, groupId, appId, svcName, ruleId, rule) => () =>
    client
      .apps(groupId)
      .app(appId)
      .services()
      .service(svcName)
      .rules()
      .rule(ruleId)
      .update(rule),
  true
);

export const deleteRule = asyncActionExecutor(
  deleteSvcRuleActions,
  (client, groupId, appId, svcName, ruleId) => () =>
    client
      .apps(groupId)
      .app(appId)
      .services()
      .service(svcName)
      .rules()
      .rule(ruleId)
      .remove()
);

export const deleteSvc = asyncActionExecutor(
  deleteSvcRuleActions,
  (client, groupId, appId, svcName) =>
    client.apps(groupId).app(appId).services().service(svcName).remove
);

export const loadSvc = asyncActionExecutor(
  loadSvcActions,
  (client, groupId, appId, svcName) =>
    client.apps(groupId).app(appId).services().service(svcName).get,
  true
);

export const saveConfig = asyncActionExecutor(
  saveSvcConfigActions,
  (client, groupId, appId, svcName, config) => () =>
    client
      .apps(groupId)
      .app(appId)
      .services()
      .service(svcName)
      .setConfig(config),
  true
);

export const addRule = asyncActionExecutor(
  addSvcRuleActions,
  (client, groupId, appId, svcName, rule) => () =>
    client
      .apps(groupId)
      .app(appId)
      .services()
      .service(svcName)
      .rules()
      .create(rule)
);

export const configEditMapper = {
  mapStateToProps: (state, ownProps) => ({
    loadedSvcName: state.service.base.serviceName
      ? state.service.base.serviceName
      : ownProps.service.name,
    serviceConfig: state.service.base.service
      ? state.service.base.service.config
      : ownProps.service.config,
    serviceConfigInputs: state.service.base.configInput,
    savingConfig: state.service.base.savingConfig,
    configSaveError: state.service.base.configSaveError,
    alertKey: `${ownProps.svcname}edit_config`
  }),
  mapDispatchToProps: (dispatch, ownProps) => ({
    setConfigInput: (key, value) => dispatch(setConfigInput({ key, value })),
    onSubmit: config =>
      dispatch(
        saveConfig(
          ownProps.app.groupId,
          ownProps.app._id,
          ownProps.svcname,
          config
        )
      )
        .then(() =>
          dispatch(addAlert(`${ownProps.svcname}edit_config`, "Saved"))
        )
        .catch(() => {})
  })
};

export const rulesEditMapper = {
  mapStateToProps: (state, ownProps) => ({
    addRuleAlertKey: `${ownProps.svcname}/addrule`,
    ruleSaveState: state.service.base.ruleSaveState.toJS()
  }),
  mapDispatchToProps: (dispatch, ownProps) => {
    const reloadService = () =>
      dispatch(
        loadSvc(ownProps.app.groupId, ownProps.app._id, ownProps.svcname)
      );
    return {
      addAlert: (key, message) => dispatch(addAlert(key, message)),
      reloadService: () =>
        dispatch(
          loadSvc(ownProps.app.groupId, ownProps.app._id, ownProps.svcname)
        ),
      setRuleError: (ruleId, error) =>
        dispatch(setRuleErrorAction({ ruleId, error })),
      addRule: rule =>
        dispatch(
          addRule(
            ownProps.app.groupId,
            ownProps.app._id,
            ownProps.svcname,
            rule
          )
        ),
      deleteRule: ruleId =>
        dispatch(
          deleteRule(
            ownProps.app.groupId,
            ownProps.app._id,
            ownProps.svcname,
            ruleId
          )
        ).then(reloadService),
      updateRule: (ruleId, rule) =>
        dispatch(
          updateRule(
            ownProps.app.groupId,
            ownProps.app._id,
            ownProps.svcname,
            ruleId,
            rule
          )
        )
    };
  }
};