Hotax/src/models/terminal.js

import { message } from 'antd';
import { routerRedux } from 'dva/router';
import {
  deviceUnbound,
  queryTerminalList,
  createTerminalItem,
  updateTerminalItem,
  deleteTerminalItem,
  querySpecialTerminalList,
  querySpecialTerminalItem,
  createSpecialTerminalItem,
  updateSpecialTerminalItem,
  deleteSpecialTerminalItem,
  queryTerminalAuthList,
  updateTerminalAuth,
  queryTerminalTagList,
  queryTerminalTagItem,
  createTerminalTagItem,
  updateTerminalTagItem,
  deleteTerminalTagItem,
  queryTerminalRecommendCourse,
  updateTerminalRecommendCourse,
  copyMerchantTag,
  queryTerminalLoggedDevice,
} from '../services/terminal';

export default {
  namespace: 'terminal',

  state: {
    list: [],
    pageNo: 1,
    pageSize: 15,
    totalSize: 0,
    currentItem: {},
    userTagList: [],
    userRecCourse: [],
    currentUserTagItem: {},
    currentUserLoggedRecs: [],
  },

  effects: {
    *fetchTerminalList({ payload }, { call, put }) {
      const response = yield call(queryTerminalList, payload);
      if (response.success) {
        yield put({
          type: 'querySuccess',
          payload: {
            list: response.data.list || [],
            pageSize: response.data.pageSize,
            totalSize: response.data.totalSize,
            pageNo: response.data.pageNo,
          },
        });
      }
    },
    *createTerminalItem({ payload, state }, { call, put }) {
      const response = yield call(createTerminalItem, payload);
      if (response.success) {
        message.success('创建终端成功');
        yield put(routerRedux.push({
          state,
          pathname: '/terminal/user/list',
        }));
      }
    },
    *deleteTerminalItem({ payload, states }, { call, put }) {
      const response = yield call(deleteTerminalItem, payload);
      if (response.success) {
        message.success('禁用终端成功');
        yield put({
          type: 'fetchTerminalList',
          payload: states.Queryers,
        });
      }
    },
    *recoverTerminalItem({ payload, states }, { call, put }) {
      const response = yield call(updateTerminalItem, payload);
      if (response.success) {
        message.success('解禁终端成功');
        yield put({
          type: 'fetchTerminalList',
          payload: states.Queryers,
        });
      }
    },
    *updateTerminalItem({ payload, states }, { call, put }) {
      const response = yield call(updateTerminalItem, payload);
      if (response.success) {
        message.success('修改终端成功');
        yield put(routerRedux.push({
          pathname: '/terminal/user/list',
          state: states,
        }));
      }
    },
    *fetchSpecialTerminalList({ payload }, { call, put }) {
      const response = yield call(querySpecialTerminalList, payload);
      if (response.success) {
        yield put({
          type: 'querySuccess',
          payload: {
            list: response.data.list || [],
            pageSize: response.data.pageSize,
            totalSize: response.data.totalSize,
            pageNo: response.data.pageNo,
          },
        });
      }
    },
    *fetchSpecialTerminalItem({ payload }, { call, put }) {
      const response = yield call(querySpecialTerminalItem, payload);
      if (response.success) {
        yield put({
          type: 'querySuccess',
          payload: {
            currentItem: response.data,
          },
        });
      }
    },
    *createSpecialTerminalItem({ payload, states }, { call, put }) {
      const response = yield call(createSpecialTerminalItem, payload);
      if (response.success) {
        message.success('创建白名单用户成功');
        yield put(routerRedux.push({
          state: states,
          pathname: '/terminal/whitelist/list',
        }));
      }
    },
    *deleteSpecialTerminalItem({ payload, states }, { call, put }) {
      const response = yield call(deleteSpecialTerminalItem, payload);
      if (response.success) {
        message.success('删除白名单用户成功');
        yield put({
          type: 'fetchSpecialTerminalList',
          payload: states.Queryers,
        });
      }
    },
    *updateSpecialTerminalItem({ payload, states }, { call, put }) {
      const response = yield call(updateSpecialTerminalItem, payload);
      if (response.success) {
        message.success('修改白名单用户成功');
        yield put(routerRedux.push({
          pathname: '/terminal/whitelist/list',
          state: states,
        }));
      }
    },
    *deviceUnbound({ payload, states }, { call, put }) {
      const response = yield call(deviceUnbound, payload);
      if (response.success) {
        message.success('账号已成功解绑');
        yield put({
          type: 'fetchTerminalList',
          payload: states.Queryers,
        });
      }
    },
    *fetchTerminalAuthList({ payload }, { call, put }) {
      const response = yield call(queryTerminalAuthList, payload);
      if (response.success) {
        yield put({
          type: 'querySuccess',
          payload: {
            list: response.data.list || [],
            pageSize: response.data.pageSize,
            totalSize: response.data.totalSize,
            pageNo: response.data.pageNo,
          },
        });
      }
    },
    *updateTerminalAuth({ payload, states }, { call, put }) {
      const response = yield call(updateTerminalAuth, payload);
      if (response.success) {
        message.success('修改权限时长成功');
        yield put({
          type: 'fetchTerminalAuthList',
          payload: states,
        });
      }
    },
    *fetchTerminalTagList({ payload }, { call, put }) {
      const response = yield call(queryTerminalTagList, payload);
      if (response.success) {
        yield put({
          type: 'querySuccess',
          payload: {
            userTagList: response.data || [],
          },
        });
      }
    },
    *fetchTerminalTagItem({ payload }, { call, put }) {
      const response = yield call(queryTerminalTagItem, payload);
      if (response.success) {
        yield put({
          type: 'querySuccess',
          payload: {
            currentUserTagItem: response.data || {},
          },
        });
      }
    },
    *createTerminalTagItem({ payload }, { call, put }) {
      const response = yield call(createTerminalTagItem, payload);
      if (response.success) {
        message.success('终端用户标签创建成功');
        const { uid } = payload;
        yield put({
          type: 'fetchTerminalTagList',
          payload: { uid },
        });
      }
    },
    *updateTerminalTagItem({ payload }, { call, put }) {
      const response = yield call(updateTerminalTagItem, payload);
      if (response.success) {
        message.success('终端用户标签修改成功');
        const { uid } = payload;
        yield put({
          type: 'fetchTerminalTagList',
          payload: { uid },
        });
      }
    },
    *deleteTerminalTagItem({ payload }, { call, put }) {
      const response = yield call(deleteTerminalTagItem, payload);
      if (response.success) {
        message.success('终端用户标签删除成功');
        const { uid } = payload;
        yield put({
          type: 'fetchTerminalTagList',
          payload: { uid },
        });
      }
    },
    *copyMerchantTagToUser({ payload }, { call, put }) {
      const { uid, ...rest } = payload;
      const response = yield call(copyMerchantTag, rest);
      if (response.success) {
        message.success('复制渠道标签成功');
        yield put({
          type: 'fetchTerminalTagList',
          payload: { uid },
        });
      }
    },
    *fetchTerminalRecommendCourse({ payload }, { call, put }) {
      const response = yield call(queryTerminalRecommendCourse, payload);
      if (response.success) {
        yield put({
          type: 'querySuccess',
          payload: {
            userRecCourse: response.data || [],
          },
        });
      }
    },
    *updateTerminalRecommendCourse({ payload }, { call, put }) {
      const response = yield call(updateTerminalRecommendCourse, payload);
      if (response.success) {
        message.success('修改用户推荐课程成功');
        const { uid } = payload;
        yield put({
          type: 'fetchTerminalRecommendCourse',
          payload: { uid },
        });
      }
    },
    *fetchTerminalLoggedDevice({ payload }, { call, put }) {
      const response = yield call(queryTerminalLoggedDevice, payload);
      if (response.success) {
        yield put({
          type: 'querySuccess',
          payload: {
            currentUserLoggedRecs: response.data || [],
          },
        });
      }
    },
  },

  reducers: {
    querySuccess(state, action) {
      return {
        ...state,
        ...action.payload,
      };
    },
    fixCurrentItem(state, action) {
      const { currentItem } = state;
      return {
        ...state,
        currentItem: {
          ...currentItem,
          ...action.payload,
        },
      };
    },
    fixCurrentUserTagItem(state, action) {
      const { currentUserTagItem } = state;
      return {
        ...state,
        currentUserTagItem: {
          ...currentUserTagItem,
          ...action.payload,
        },
      };
    },
    fixUserRecCourse(state, action) {
      return {
        ...state,
        userRecCourse: action.payload,
      };
    },
    cleanState(state) {
      return {
        ...state,
        list: [],
        pageNo: 1,
        pageSize: 15,
        totalSize: 0,
        userTagList: [],
        userRecCourse: [],
        currentItem: {},
        currentUserTagItem: {},
      };
    },
    resetUserTagItem(state) {
      return {
        ...state,
        currentUserTagItem: {},
      };
    },
  },
};