lanju-app/src/pages/raw/handover/aggregating/model.ts

import {
  getModule,
  Module,
  Mutation,
  Action,
  MutationAction,
  VuexModule,
} from 'vuex-module-decorators';
import store from '@/store';
import http from '@/utils/request';
import { url } from '@/utils/url';
import { cloneDeep } from 'lodash/fp';

@Module({
  namespaced: true,
  dynamic: true,
  store,
  name: 'raw.handover.aggregating',
})
export class AggregatingModule extends VuexModule {
  /**
   * 查询列表
   */
  proOrderList = [];

  /**
   * 查询结果列表
   */
  proOrderResultList = [];

  /**
   * 查询结果汇总列表
   */
  aggregateList: any[] = [];

  /**
   * 查询结果按单列表
   */
  orderList: any[] = [];

  /**
   * 查询结果辅料列表
   */
  accessoryList: any[] = [];

  /**
   * 库存地点列表
   */
  locationList = [];

  /**
   * 是否全选
   */
  get isCheckedAll() {
    return !this.proOrderList.filter((_: any) => !_.checked).length;
  }

  /**
   * 是否有选择项
   */
  get hasChecked() {
    return this.checkedProOrderList.length > 0;
  }

  /**
   * 获取选中的查询列表
   */
  get checkedProOrderList() {
    return this.proOrderList.filter((_: any) => _.checked);
  }

  /**
   * 清空查询结果列表
   */
  @Mutation
  clearProOrderResultList() {
    this.proOrderResultList = [];
  }
  /**
   * 查询列表
   */
  @Mutation
  clearProOrderList() {
    this.proOrderList = [];
  }
  /**
   * 汇总列表是否全选
   */
  get isAggregateCheckedAll() {
    return !this.aggregateList.filter((_: any) => !_.checked).length;
  }

  /**
   * 全选/取消全选汇总列表
   * @param checked
   */
  @Mutation
  checkAllAggregateList(checked: boolean) {
    this.aggregateList = this.aggregateList.map((item: any) => {
      item.checked = checked;
      return item;
    });
  }

  /**
   * 列表提交-汇总交接
   * @param params
   */
  @Action
  async uploadAggregateList(params: any) {
    return http.post(url.sumscan.u.hzlist, params);
  }

  /**
   * 设置汇总列表项本次交接数量
   * @param params
   */
  @Mutation
  setAggregateListItemHvAmount({ index, hvAmount }: { index: number; hvAmount: number }) {
    const original = this.aggregateList[index];
    const newItem = { ...original, hvAmount };
    this.aggregateList.splice(index, 1, newItem);
  }

  /**
   * 设置按单列表项本次交接数量
   * @param params
   */
  @Mutation
  setOrderListItemHvAmount({ index, hvAmount }: { index: number; hvAmount: number }) {
    const original = this.orderList[index];
    const newItem = { ...original, hvAmount };
    this.orderList.splice(index, 1, newItem);
  }
  // setOrderListItemHvAmount(params: { hvAmount: number }) {
  //   this.orderList
  //     .filter((_: any) => _.checked)
  //     .forEach((item: any) => {
  //       if (params.hvAmount) {
  //         item.currentAmount = params.hvAmount;
  //       }
  //     });
  // }

  /**
   * 设置辅料列表项本次交接数量
   * @param params
   */
  @Mutation
  setAccessoryListItemHvAmount({ index, hvAmount }: { index: number; hvAmount: number }) {
    const original = this.accessoryList[index];
    const newItem = { ...original, hvAmount };
    this.accessoryList.splice(index, 1, newItem);
  }

  /**
   * 按单列表是否全选
   */
  get isOrderCheckedAll() {
    return !this.orderList.filter((_: any) => !_.checked).length;
  }

  /**
   * 全选/取消按单列表
   * @param checked
   */
  @Mutation
  checkAllOrderList(checked: boolean) {
    this.orderList = this.orderList.map((item: any) => {
      item.checked = checked;
      return item;
    });
  }

  /**
   * 查询看单号
   * @param params
   */
  @MutationAction
  async queryProOrder(params: any) {
    const { values }: any = await http.post(url.sumscan.query.orderno, params);
    const proOrderList = values.map((v: string) => ({ prdOrder: v }));
    proOrderList.forEach((_: any) => (_.checked = true));
    if (!proOrderList.length) {
      uni.showToast({
        icon: 'none',
        title: 'No Data Found！',
      });
    }
    return { proOrderList };
  }

  /**
   * 查询结果列表
   * @param params
   */
  @MutationAction
  async queryProOrderResult(params: any) {
    const { list: proOrderResultList }: any = await http.post(url.sumscan.query.ordoutlist, params);
    return { proOrderResultList };
  }

  /**
   * 查询结果-汇总列表
   * @param params
   */
  @MutationAction
  async queryAggregateList(params: any) {
    const { list: aggregateList }: any = await http.post(url.sumscan.query.hzlist, params);
    if (!aggregateList.length) {
      uni.showToast({
        icon: 'none',
        title: 'No Data Found！',
      });
    }
    return { aggregateList };
  }

  /**
   * 查询结果-按单列表
   * @param params
   */
  @MutationAction
  async queryOrderList(params: any) {
    const { queryParams, proOrderResultList } = params;
    await http.post(url.sumscan.lock.list, queryParams);
    const orderList = cloneDeep<any>(proOrderResultList);
    return { orderList };
  }

  /**
   * 查询结果-辅料列表
   * @param params
   */
  @MutationAction
  async queryAccessoryList(params: any) {
    const { list: accessoryList }: any = await http.post(url.sumscan.query.fllist, params);
    if (!accessoryList.length) {
      uni.showToast({
        icon: 'none',
        title: 'No Data Found！',
      });
    }
    return { accessoryList };
  }

  /**
   * 列表提交-按单交接
   * @param params
   */
  @Action
  async uploadOrderList(params: any) {
    await http.post(url.sumscan.u.order, params);
    uni.showToast({
      icon: 'success',
      title: 'success',
    });
  }

  /**
   * 列表提交-辅料交接
   * @param params
   */
  @Action
  async uploadAccessoryList(params: any) {
    return http.post(url.sumscan.u.fllist, params);
  }
}

export default getModule(AggregatingModule);