sd_project/sd-wln/src/main/java/com/sd/wln/context/OrderContext.java

package com.sd.wln.context;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.extra.spring.SpringUtil;
import com.alibaba.fastjson2.JSONObject;
import com.ruoyi.common.core.domain.BaseIdPo;
import com.ruoyi.framework.mybatis.holder.LogicHolder;
import com.sd.business.entity.bom.bo.BomSpecBo;
import com.sd.business.entity.department.po.Department;
import com.sd.business.entity.order.po.OrderInfo;
import com.sd.business.entity.order.po.OrderPackageBom;
import com.sd.business.entity.order.po.OrderSku;
import com.sd.business.entity.order.po.OrderSkuBom;
import com.sd.business.entity.price.po.PriceBillingStandardDetail;
import com.sd.business.entity.sku.po.SkuSpec;
import com.sd.business.entity.sku.po.SkuSpecLink;
import com.sd.business.service.department.DepartmentService;
import com.sd.business.service.order.OrderService;
import com.sd.business.service.order.OrderSkuService;
import com.sd.business.service.price.PriceBillingStandardDetailService;
import com.sd.business.service.sku.SkuSpecLinkService;
import com.sd.business.service.sku.SkuSpecService;
import com.sd.wln.util.WlnUtil;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@Slf4j
public class OrderContext {

    private static final OrderService orderService = SpringUtil.getBean(OrderService.class);
    private static final OrderSkuService orderSkuService = SpringUtil.getBean(OrderSkuService.class);
    private static final DepartmentService departmentService = SpringUtil.getBean(DepartmentService.class);
    private static final SkuSpecService skuSpecService = SpringUtil.getBean(SkuSpecService.class);
    private static final SkuSpecLinkService skuSpecLinkService = SpringUtil.getBean(SkuSpecLinkService.class);
    private static final PriceBillingStandardDetailService priceBillingStandardDetailService = SpringUtil.getBean(PriceBillingStandardDetailService.class);

    /**
     * 保存订单列表
     */
    @Getter
    private final List<OrderInfo> saveOrderList = new ArrayList<>();

    /**
     * 更新订单列表
     */
    @Getter
    private final List<OrderInfo> updateOrderList = new ArrayList<>();

    /**
     * 保存订单明细列表
     */
    @Getter
    private final List<OrderSku> saveOrderSkuList = new ArrayList<>();

    /**
     * 保存订单包材
     */
    @Getter
    private final List<OrderSkuBom> saveOrderSkuBomList = new ArrayList<>();

    /**
     * 保存订单包装
     */
    @Getter
    private final List<OrderPackageBom> orderPackageBomList = new ArrayList<>();

    /**
     * 当前时间
     */
    @Getter
    private final Date endDate;

    /**
     * 万里牛订单列表
     */
    @Getter
    private final List<JSONObject> wlnOrderList;

    /**
     * 事业部
     */
    @Getter
    private final Department department;

    /**
     * 已存在数据库中的订单map
     * key：万里牛订单uid
     * value：订单实体
     */
    private Map<String, OrderInfo> existOrderMap;

    /**
     * 已存在数据库中的订单sku map
     * key：订单id
     * value：订单sku实体列表
     */
    private Map<Long, List<OrderSku>> existOrderSkuMap;

    /**
     * sku规格map
     * key：万里牛sku规格uid
     * value：sku规格实体
     */
    private Map<String, SkuSpec> skuSpecMap;

    /**
     * sku规格关联bom
     * key：sku规格id
     * value： key：类型 1包材 2快递包装 value：sku规格实体
     */
    private Map<Long, Map<Integer, List<SkuSpecLink>>> skuSpecLinkBomSpecMap;

    /**
     * bom规格明细
     * key：bom规格id
     * value：bom规格明细
     */
    private Map<Long, BomSpecBo> bomSpecBoMap;

    /**
     * 加工计费标准明细列表
     */
    private List<PriceBillingStandardDetail> priceBillingStandardList;

    /**
     * 实例化
     */
    public OrderContext(String warehouseCode) {
        this.endDate = new Date();
        this.wlnOrderList = selectWlnOrderList(warehouseCode);
        this.department = departmentService.getDepartmentByWarehouseCode(warehouseCode);
    }

    /**
     * 查询万里牛订单列表
     */
    private List<JSONObject> selectWlnOrderList(String warehouseCode) {

        long endTime = endDate.getTime();
        long startTime;

        OrderInfo orderInfo = orderService.getOne(q -> q
                .eq(OrderInfo::getWlnStorageCode, warehouseCode)
                .orderByDesc(OrderInfo::getWlnModifyTimestamp));

        if (orderInfo == null) {
            startTime = endTime - 1000 * 60 * 60 * 24;
        } else {
            startTime = orderInfo.getWlnModifyTimestamp();
            if (endTime - startTime > 1000 * 60 * 60 * 24 * 7) {
                startTime = endTime - 1000 * 60 * 60 * 24 * 7;
            }
        }

        List<JSONObject> list = new ArrayList<>();

        int page = 1;
        int size;
        do {
            try {
                List<JSONObject> itemList = WlnUtil.getOrderList(page, 200, startTime, endTime, warehouseCode);
                page++;
                size = itemList.size();
                list.addAll(itemList);
            } catch (Exception e) {
                log.error("订单同步失败", e);
                return Collections.emptyList();
            }
        } while (size >= 200);

        return list;
    }

    /**
     * 获取已存在数据库中的订单map
     */
    public Map<String, OrderInfo> getExistOrderMap() {
        if (existOrderMap == null) {
            LogicHolder.setLogicHolder(true);
            List<String> uidList = wlnOrderList.stream().map(item -> item.getString("uid")).collect(Collectors.toList());
            existOrderMap = orderService.mapKEntity(OrderInfo::getWlnUid, q -> q.in(OrderInfo::getWlnUid, uidList));
            LogicHolder.clear();
        }
        return existOrderMap;
    }

    /**
     * 已存在数据库中的订单sku map
     */
    public Map<Long, List<OrderSku>> getExistOrderSkuMap() {
        if (existOrderSkuMap == null) {
            List<Long> orderIdList = getExistOrderMap().values().stream().map(BaseIdPo::getId).collect(Collectors.toList());
            if (orderIdList.size() == 0) {
                existOrderSkuMap = Collections.emptyMap();
            } else {
                existOrderSkuMap = orderSkuService.mapKGroup(OrderSku::getOrderId, q -> q.in(OrderSku::getOrderId, orderIdList));
            }
        }
        return existOrderSkuMap;
    }

    /**
     * 获取sku规格map
     */
    public Map<String, SkuSpec> getSkuSpecMap() {
        if (skuSpecMap == null) {
            List<String> wlnSkuSpecUidList = wlnOrderList.stream()
                    .flatMap(item -> item.getJSONArray("orders").toJavaList(JSONObject.class).stream())
                    .map(item -> item.getString("sys_spec_uid"))
                    .filter(ObjectUtil::isNotNull)
                    .distinct()
                    .collect(Collectors.toList());

            if (wlnSkuSpecUidList.size() == 0) {
                skuSpecMap = Collections.emptyMap();
            } else {
                skuSpecMap = skuSpecService.mapKEntity(SkuSpec::getWlnUid, q -> q.in(SkuSpec::getWlnUid, wlnSkuSpecUidList));
            }
        }
        return skuSpecMap;
    }

    /**
     * 获取sku规格关联bom
     */
    public Map<Long, Map<Integer, List<SkuSpecLink>>> getSkuSpecLinkBomSpecMap() {

        if (skuSpecLinkBomSpecMap == null) {
            if (department == null) {
                skuSpecLinkBomSpecMap = Collections.emptyMap();
                return skuSpecLinkBomSpecMap;
            }

            List<Long> skuSpecId = getSkuSpecMap().values().stream().map(SkuSpec::getId).collect(Collectors.toList());

            if (skuSpecId.size() == 0) {
                skuSpecLinkBomSpecMap = Collections.emptyMap();
                return skuSpecLinkBomSpecMap;
            }

            List<SkuSpecLink> list = skuSpecLinkService.list(q -> q
                    .in(SkuSpecLink::getSkuSpecId, skuSpecId)
                    .eq(SkuSpecLink::getDepartmentId, department.getId()));

            skuSpecLinkBomSpecMap = list.stream().collect(
                    Collectors.groupingBy(SkuSpecLink::getSkuSpecId, Collectors.groupingBy(SkuSpecLink::getType)));
        }

        return skuSpecLinkBomSpecMap;
    }

    /**
     * 获取bom规格明细
     */
    public Map<Long, BomSpecBo> getBomSpecBoMap() {
        if (bomSpecBoMap == null) {
            List<Long> bomSpecIdList = Stream.concat(
                            getSkuSpecMap().values().stream().map(SkuSpec::getBomSpecId),
                            getSkuSpecLinkBomSpecMap().values().stream().flatMap(item -> Stream.concat(
                                    item.getOrDefault(1, Collections.emptyList()).stream(),
                                    item.getOrDefault(2, Collections.emptyList()).stream()
                            )).map(SkuSpecLink::getBomSpecId))
                    .distinct().collect(Collectors.toList());
            bomSpecBoMap = skuSpecService.getBomSpecBoByIdList(bomSpecIdList);
        }
        return bomSpecBoMap;
    }

    /**
     * 获取加工计费标准明细列表
     */
    public List<PriceBillingStandardDetail> getPriceBillingStandardList() {
        if (priceBillingStandardList == null) {
            if (department == null || department.getPriceBillingStandardId() == null) {
                priceBillingStandardList = Collections.emptyList();
            } else {
                priceBillingStandardList = priceBillingStandardDetailService.list(q -> q
                        .eq(PriceBillingStandardDetail::getPriceBillingStandardId, department.getPriceBillingStandardId()));
            }
        }
        return priceBillingStandardList;
    }

}