vd/frontend/src/store/module/order.js

import * as API from 'api/real/orders';

let remove_selected = (selected, array) => {
  return selected.filter(el => {
    return array.findIndex(e => {
      return e._rowIndex === el._rowIndex;
    }) === -1;
  });
};

const state = {
  order_group: {}, // 订单组
  real_orders: [], // RD订单
  cards: [], // RD订单卡列表
  relations: [],
  selected: [],
  counts: 0, // 选择的卡数量
  selectedMapped: [], // 选择的卡索引
  orderParams: {},
  cardParams: {},
  real_companies: [],
  real_packages: [],
  relationParams: {},
  relationObj: {
    real_company_id: '',
    real_package_id: '',
    virtual_company_id: '',
    virtual_package_id: ''
  }
};

const getters = {
  relations: state => state.relations,
  relationObj: state => state.relationObj,
  orders: state => state.real_orders,
  cards: state => state.cards,
  selected: state => state.selected,
  selectedMapped: state => state.selectedMapped,
  counts: state => state.counts,
  order_group: state => state.order_group,
  total: (state) => {
    if (!state.cards.length) {
      return 0;
    }

    return state.cards.reduce((acc, cur) => {
      return acc + cur.counts;
    }, 0);
  },
  getFilterUsedCards: () => (cards) => {
    return cards.filter(item => item.virtual_order_id === 0 && !item.refunded_at);
  },
  getSelectedByOrderId: (state) => (order_id) => {
    if (typeof order_id !== 'object') {
      order_id = [order_id];
    }

    return state.selected.filter(item => {
      return order_id.includes(item.order_id);
    });
  },
  real_companies: (state) => {
    return state.real_orders.map(el => { return el.company_name; }).filter((v, i, s) => { return s.indexOf(v) === i; });
  },
  real_packages: (state) => {
    return state.real_orders.map(el => { return el.package_name; }).filter((v, i, s) => { return s.indexOf(v) === i; });
  }
};

const mutations = {
  SET_ORDER_GROUP(state, data) {
    state.order_group = data;
  },
  SET_REAL_ORDERS(state, data) {
    state.real_orders = data;
  },
  SET_CARDS(state, data) {
    state.cards = data;
  },
  SET_RELATIONS(state, data) {
    state.relations = data;
  },
  SET_RELATION_OBJ(state, obj) {
    state.relationObj = obj;
  },
  SET_RELATION_PARAMS(state, data) {
    state.relationParams = data;
  },
  SET_CARD_PARAMS(state, obj) {
    state.cardParams = obj;
  },
  SET_ORDER_PARAMS(state, obj) {
    state.orderParams = obj;
  },
  PUSH_CARDS(state, cards) {
    let data = cards.filter(el => {
      return state.cards.findIndex(v => {
        return v.sim === el.sim && v.order_id === el.order_id;
      }) === -1;
    });
    let concatCards = state.cards.concat(data);
    state.cards = concatCards;
  },
  SET_SELECTED(state, data) {
    state.selected = data;
  },
  SET_SELECTED_COUNTS(state, value) {
    state.counts = value;
  },
  SET_SELECTED_MAPPED(state, data) {
    state.selectedMapped = data;
  }
};

const actions = {
  initOrder(context) {
    context.commit('SET_RELATION_PARAMS', {});
    context.commit('SET_ORDER_PARAMS', {});
    context.commit('SET_CARD_PARAMS', {});
    context.commit('SET_ORDER_GROUP', {});
    context.commit('SET_REAL_ORDERS', []);
    context.commit('SET_CARDS', []);
    context.dispatch('setSelected', []);
  },
  getRelations(context, params) {
    return new Promise((resolve, reject) => {
      if (JSON.stringify(context.state.relationParams) == JSON.stringify(params)) {
        return resolve(context.state.relations);
      }

      context.commit('SET_RELATION_PARAMS', params);

      API.relations(params).then(res => {
        if (res.code === 0) {
          context.commit('SET_RELATIONS', res.data);
          resolve(res.data);
        } else {
          reject(res);
        }
      }).catch(err => {
        reject(err);
      });
    });
  },
  getOrders(context, params) {
    params.limit = 0;
    return new Promise((resolve, reject) => {
      if (JSON.stringify(context.state.orderParams) == JSON.stringify(params)) {
        return resolve(context.state.real_orders);
      }

      context.commit('SET_ORDER_PARAMS', params);

      API.index(params).then(res => {
        if (res.code === 0) {
          context.commit('SET_REAL_ORDERS', res.data);
          resolve(res.data);
        } else {
          reject(res);
        }
      }).catch(err => {
        reject(err);
      });
    });
  },
  getCards(context, { order_id, type }) {
    return new Promise((resolve, reject) => {
      if (typeof order_id !== 'object') {
        order_id = [order_id];
      }

      let array = [];

      for (let index = 0; index < order_id.length; index++) {
        const id = order_id[index];

        let i = context.state.cards.findIndex(item => {
          return item.order_id === id;
        });

        if (i === -1 && array.indexOf(id) === -1) {
          array.push(id);
        }
      }

      let cards = [];

      if (!array.length) {
        cards = context.state.cards.filter(v => {
          return order_id.indexOf(v.order_id) !== -1;
        });

        return resolve(cards);
      }

      let params = { order_id: array, type };
      API.cards(params).then(res => {
        if (res.code === 0) {
          let data = res.data;
          data.map(row => {
            row._rowIndex = row.sim + row.order_id;
          });
          context.commit('PUSH_CARDS', data);
          resolve(data);
        } else {
          reject(res);
        }
      }).catch(err => {
        reject(err);
      });
    });
  },
  getCardsByParams(context, params) {
    return new Promise((resolve, reject) => {
      API.cards(params).then(res => {
        if (res.code === 0) {
          let data = res.data;

          data.map(row => {
            row._rowIndex = row.sim + row.order_id;
          });

          context.commit('PUSH_CARDS', data);
          resolve(data);
        } else {
          reject(res);
        }
      }).catch(err => {
        reject(err);
      });
    });
  },
  setSelected(context, selected) {
    let mapped = selected.map(el => { return el._rowIndex; });
    context.commit('SET_SELECTED', selected);
    context.commit('SET_SELECTED_MAPPED', mapped);
    context.commit('SET_SELECTED_COUNTS', selected.reduce((acc, cur) => {
      return acc + cur.counts;
    }, 0));
  },
  pushSelected(context, array) {
    let selected = JSON.parse(JSON.stringify(context.getters.selected));
    selected = remove_selected(selected, array);
    array.map(el => { selected.push(el); });
    context.dispatch('setSelected', selected);
  },
  removeSelected(context, array) {
    let selected = JSON.parse(JSON.stringify(context.getters.selected));
    selected = remove_selected(selected, array);
    context.dispatch('setSelected', selected);
  },
  removeSelectedByOrderId(context, order_id) {
    if (typeof order_id !== 'object') {
      order_id = [order_id];
    }

    let array = context.state.cards.filter(el => {
      return order_id.indexOf(el.order_id) !== -1;
    });

    context.dispatch('removeSelected', array);
  }
};

export default {
  state,
  getters,
  mutations,
  actions
};