zhuoka/src/main/java/com/izouma/tcg/service/orderInfo/OrderInfoService.java

package com.izouma.tcg.service.orderInfo;

import com.github.benmanes.caffeine.cache.Cache;
import com.izouma.tcg.domain.MemberInfo;
import com.izouma.tcg.domain.User;
import com.izouma.tcg.domain.card.CardBox;
import com.izouma.tcg.domain.card.CardCase;
import com.izouma.tcg.domain.customizeStore.Store;
import com.izouma.tcg.domain.orderInfo.CaseResult;
import com.izouma.tcg.domain.orderInfo.OrderInfo;
import com.izouma.tcg.domain.orderInfo.TransactionRecord;
import com.izouma.tcg.dto.OrderInfoDTO;
import com.izouma.tcg.dto.PageQuery;
import com.izouma.tcg.dto.cardCase.OrderBoxDTO;
import com.izouma.tcg.enums.CaseStatus;
import com.izouma.tcg.enums.OrderStatus;
import com.izouma.tcg.enums.PayMethod;
import com.izouma.tcg.enums.TransactionRecordType;
import com.izouma.tcg.exception.BusinessException;
import com.izouma.tcg.repo.MemberInfoRepo;
import com.izouma.tcg.repo.card.CardBoxRepo;
import com.izouma.tcg.repo.card.CardCaseRepo;
import com.izouma.tcg.repo.card.JackpotRepo;
import com.izouma.tcg.repo.customizeStore.StoreRepo;
import com.izouma.tcg.repo.orderInfo.CaseResultRepo;
import com.izouma.tcg.repo.orderInfo.OrderInfoRepo;
import com.izouma.tcg.repo.orderInfo.TransactionRecordRepo;
import com.izouma.tcg.service.card.CardCaseService;
import com.izouma.tcg.service.delay.OrderDelayService;
import com.izouma.tcg.utils.*;
import lombok.AllArgsConstructor;
import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.lang.RandomStringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.springframework.web.server.session.InMemoryWebSessionStore;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

@Service
@AllArgsConstructor
public class OrderInfoService {
    @Autowired
    private OrderInfoRepo         orderInfoRepo;
    @Autowired
    private CardBoxRepo           cardBoxRepo;
    @Autowired
    private CardCaseRepo          cardCaseRepo;
    @Autowired
    private Cache<String, Object> caffeineCache;
    @Autowired
    private TransactionRecordRepo transactionRecordRepo;
    @Autowired
    private OrderDelayService     orderDelayService;
    @Autowired
    private StoreRepo             storeRepo;
    @Autowired
    private MemberInfoRepo        memberInfoRepo;
    @Autowired
    private CaseResultService     caseResultService;
    @Autowired
    private CaseResultRepo        caseResultRepo;
    @Autowired
    private JackpotRepo           jackpotRepo;

    public OrderInfoService() {
    }

    public Page<OrderInfo> all(PageQuery pageQuery) {
        return orderInfoRepo
                .findAll(JpaUtils.toSpecification(pageQuery, OrderInfo.class), JpaUtils.toPageRequest(pageQuery));

    }

    public OrderInfo create(String boxIdStr, Long caseId, String remark, Long userAddressId) {
        List<Long> boxIds = Arrays.asList((Long[]) ConvertUtils.convert(boxIdStr.split(","), Long.class));
        List<CardBox> cardBoxList = cardBoxRepo.findAllByIdIn(boxIds);
        cardBoxList.forEach(cardbox -> {
            if (cardbox.isSold()) {
                throw new BusinessException("卖完啦，本次选位已被其他用户抢先购买！");
            }
        });
        User user = SecurityUtils.getAuthenticatedUser();
        CardCase cardCase = cardCaseRepo.findById(caseId).orElseThrow(new BusinessException("无信息"));
        if (cardCase.isDel()) {
            throw new BusinessException("该卡箱已经删除，不可以购买");
        }
        if (!cardCase.getCaseStatus().equals(CaseStatus.WAIT) & !cardCase.getCaseStatus().equals(CaseStatus.PROGRESS)) {
            throw new BusinessException("该拼箱活动未在开箱状态中");
        }
        if (cardCase.getStartTime().compareTo(LocalDateTime.now()) < 0) {
            throw new BusinessException("拼箱时间已过，无法购买");
        }
        if (!checkBox(boxIdStr, caseId)) {
            throw new BusinessException("卡箱已被人预定，请重新购买");
        }
        OrderInfo record = new OrderInfo();
        record.setOrderStatus(OrderStatus.CREATED);
        record.setBoxesCount(cardBoxList.size());
        BigDecimal postage = cardCase.getPostage();
        if (postage == null) {
            postage = BigDecimal.ZERO;
        }
        record.setTotal(cardBoxList.stream().map(CardBox::getBoxPrice).reduce(BigDecimal::add).orElse(BigDecimal.ZERO)
                .add(postage));
        record.setStoreId(cardCase.getStoreId());
        record.setUserId(user.getId());
        record.setUserAddressId(userAddressId);
        record.setRemark(remark);
        record.setCaseId(caseId);
        record.setCardBoxStr(boxIdStr);
        OrderInfo saved = orderInfoRepo.save(record);
        cardBoxList.forEach(cardBox -> {
            if (cardBox.getUserId() != null & cardBox.getOrderInfoId() != null) {
                throw new BusinessException("该卡包已被预定，请重新选择。");
            }
            cardBox.setUserId(user.getId());
            cardBox.setOrderInfoId(saved.getId());
            cardBox.setSold(true);
            cardBoxRepo.save(cardBox);
        });
        OrderInfo result = orderInfoRepo.findById(saved.getId()).orElseThrow(new BusinessException("未找到"));
        orderDelayService.orderDelay(result.getId(), result.getCreatedAt());
        return result;
    }

    public boolean checkBox(String boxIdStr, Long caseId) {
        Long userId = SecurityUtils.getAuthenticatedUser().getId();
        List<Long> boxIds = Arrays.asList((Long[]) ConvertUtils.convert(boxIdStr.split(","), Long.class));
        List<CardBox> cardBoxList = cardBoxRepo.findAllByIdIn(boxIds);
        CardCase cardCase = cardCaseRepo.findById(caseId).orElseThrow(new BusinessException("无信息"));
        if (cardCase.isLimitOne()) {
            if (boxIds.size() > 1) {
                throw new BusinessException("本次拼箱每人限购一份");
            }
            List<OrderStatus> orderStatuses = new ArrayList<>();
            orderStatuses.add(OrderStatus.CANCELED);
            orderStatuses.add(OrderStatus.REFUNDED);
            Long count = orderInfoRepo.countAllByOrderStatusNotInAndUserIdAndCaseId(orderStatuses, userId, caseId);
            if (count > 0) {
                throw new BusinessException("本次拼箱每人限购一份");
            }
        }
        if (cardCase.isSpecial()) {
            Map<String, List<CardBox>> stringListMap = cardBoxList.stream()
                    .collect(Collectors.groupingBy(CardBox::getGroupCode));
            List<CardBox> AList = stringListMap.get("A");
            List<CardBox> BList = stringListMap.get("B");
            if (AList != null & BList != null) {
                return AList.size() == BList.size();
            }
            return false;
        }
        return true;
    }

    public Map<String, Object> showPreview(String boxIdStr, Long caseId) {
        Long userId = SecurityUtils.getAuthenticatedUser().getId();
        List<Long> boxIds = Arrays.asList((Long[]) ConvertUtils.convert(boxIdStr.split(","), Long.class));
        List<CardBox> cardBoxList = cardBoxRepo.findAllByIdIn(boxIds);
        CardCase cardCase = cardCaseRepo.findById(caseId).orElseThrow(new BusinessException("无信息"));
        if (cardCase.isDel()) {
            throw new BusinessException("该卡箱已经删除，不可以购买");
        }
        if (cardCase.isLimitOne()) {
            if (boxIds.size() > 1) {
                throw new BusinessException("本次拼箱每人限购一份");
            }
            List<OrderStatus> orderStatuses = new ArrayList<>();
            orderStatuses.add(OrderStatus.CANCELED);
            orderStatuses.add(OrderStatus.REFUNDED);
            Long count = orderInfoRepo.countAllByOrderStatusNotInAndUserIdAndCaseId(orderStatuses, userId, caseId);
            if (count > 0) {
                throw new BusinessException("本次拼箱每人限购一份");
            }
        }
        Map<String, Object> resultMap = new HashMap<>();
        storeRepo.findById(cardCase.getStoreId()).ifPresent(store -> resultMap.put("store", store));
        if (cardCase.isSpecial()) {
            Map<String, List<CardBox>> stringListMap = cardBoxList.stream()
                    .collect(Collectors.groupingBy(CardBox::getGroupCode));
            List<CardBox> AList = stringListMap.get("A");
            List<CardBox> BList = stringListMap.get("B");
            if (AList.size() != BList.size()) {
                resultMap.put("error", "卡箱类型需要A,B两组选择卡包数量相等。");
                return resultMap;
            }
        }
        BigDecimal postage = cardCase.getPostage();
        if (postage == null) {
            postage = BigDecimal.ZERO;
        }
        resultMap.put("selectedBoxes", cardBoxList);
        resultMap.put("selectedCase", cardCase);
        resultMap.put("total", cardBoxList.stream().map(CardBox::getBoxPrice).reduce(BigDecimal::add)
                .orElse(BigDecimal.ZERO)
                .add(postage));
        return resultMap;
    }

    public void pay(Long orderInfoId, String transactionId) {
        OrderInfo orig = orderInfoRepo.findById(orderInfoId).orElseThrow(new BusinessException("无信息"));
        if (!orig.getOrderStatus().equals(OrderStatus.CREATED)) {
            throw new BusinessException("订单未在待支付状态，无法支付");
        }
        if (org.apache.commons.lang3.StringUtils.isNotBlank(transactionId)) {
            orig.setTransactionId(transactionId);
            orig.setPayMethod(PayMethod.WECHAT);
        } else {
            orig.setTransactionId(RandomStringUtils.randomNumeric(12));
            orig.setPayMethod(PayMethod.BALANCE);
            MemberInfo memberInfo = memberInfoRepo.findAllByUserId(orig.getUserId());
            if (memberInfo.getMoney().compareTo(orig.getTotal()) < 0) {
                throw new BusinessException("余额不足");
            }
            memberInfo.setMoney(memberInfo.getMoney().subtract(orig.getTotal()));
            memberInfoRepo.save(memberInfo);
        }

        orig.setOrderStatus(OrderStatus.PAYED);
        orig.setPaidTime(LocalDateTime.now());
        orig.setTotal(orig.getTotal());
        orderInfoRepo.save(orig);
        Store store = storeRepo.findById(orig.getStoreId()).orElse(null);
        if (store != null) {
            MemberInfo memberInfo = memberInfoRepo.findAllByUserId(store.getUserId());
            memberInfo.setMoney(memberInfo.getMoney().add(orig.getTotal()));
            memberInfoRepo.save(memberInfo);

            TransactionRecord transactionRecord = new TransactionRecord();
            transactionRecord.setRemark(orig.getRemark());
            transactionRecord.setUserId(store.getUserId());
            transactionRecord.setStoreId(orig.getStoreId());
            transactionRecord.setSettleTime(LocalDateTime.now());
            transactionRecord.setAttach("orderInfoId" + ":" + orderInfoId);
            transactionRecord
                    .setTitle(orig.getCardCase().getCollection().getName() + orig.getCardCase().getCode() + "出售");
            transactionRecord.setAmount(orig.getTotal());
            transactionRecord.setType(TransactionRecordType.SOLD);
            transactionRecordRepo.save(transactionRecord);
        }

        TransactionRecord transactionRecord = new TransactionRecord();
        transactionRecord.setRemark(orig.getRemark());
        transactionRecord.setUserId(orig.getUserId());
        transactionRecord.setStoreId(orig.getStoreId());
        transactionRecord.setSettleTime(LocalDateTime.now());
        transactionRecord.setAttach("orderInfoId" + ":" + orderInfoId);
        transactionRecord.setTitle(orig.getCardCase().getCollection().getName() + orig.getCardCase().getCode() + "拼箱");
        transactionRecord.setAmount(orig.getTotal());
        transactionRecord.setType(TransactionRecordType.PAY);
        transactionRecordRepo.save(transactionRecord);
        CardCase cardCase = cardCaseRepo.findById(orig.getCaseId()).orElseThrow(new BusinessException("暂无信息"));
        if (!cardCase.isHasLive()) {
            if (cardCase.isInstant()) {
                orig.getCardBoxList().forEach(box -> {
                    caseResultService.genInstant(box.getId());
                });
            } else {
                caseResultService.genRandomResult(orig.getCaseId());
            }
        }
    }

    public void cancel(Long orderInfoId) {
        OrderInfo orig = orderInfoRepo.findById(orderInfoId).orElseThrow(new BusinessException("无信息"));
        orig.setOrderStatus(OrderStatus.CANCELED);
        orderInfoRepo.save(orig);
        List<CardBox> orderBoxes = orig.getCardBoxList();
        orderBoxes.forEach(cardBox -> {
            cardBox.setOrderInfoId(null);
            cardBox.setUserId(null);
            cardBox.setSold(false);
            cardBoxRepo.save(cardBox);
        });
    }

    public void confirm(Long orderInfoId, String remark) {
        OrderInfo orig = orderInfoRepo.findById(orderInfoId).orElseThrow(new BusinessException("无信息"));
        orig.setOrderStatus(OrderStatus.COMPETED);
        orig.setFinishTime(LocalDateTime.now());
        orig.setEvaluate(remark);
        orderInfoRepo.save(orig);
    }

    public void send(Long orderInfoId, String logisticNo, String type, String remark) {
        OrderInfo orderInfo = orderInfoRepo.findById(orderInfoId).orElseThrow(new BusinessException("暂无订单信息"));
        orderInfo.setOrderStatus(OrderStatus.SEND);
        orderInfo.setLogisticsNo(logisticNo);
        orderInfo.setLogisticsType(type);
        orderInfo.setRemark(remark);
        LogisticsQueryResponse result = LogisticsUtils.query(logisticNo, type);
        orderInfoRepo.save(orderInfo);
    }

    public Map<String, Object> checkLogistics(Long orderId) {
        //先从缓存取，判断是否取出
        caffeineCache.getIfPresent(orderId);
        Map<String, Object> resultMap = new HashMap<>();
        OrderInfo orderInfo = orderInfoRepo.findById(orderId).orElseThrow(new BusinessException("订单不存在"));
        LogisticsQueryResponse cacheResult = (LogisticsQueryResponse) caffeineCache.asMap().get(orderId.toString());
        if (!StringUtils.isEmpty(cacheResult)) {
            resultMap.put("logistic", cacheResult);
            resultMap.put("address", orderInfo.getAddress());
            return resultMap;
        }
        if (orderInfo.getLogisticsNo().isEmpty() || orderInfo.getLogisticsType().isEmpty()) {
            throw new BusinessException("未发货或发货信息错误，请联系客服");
        }
        LogisticsQueryResponse result = LogisticsUtils.query(orderInfo.getLogisticsNo(), orderInfo.getLogisticsType());
        List<ResultData> resultData = result.getResult().getList();
        List<ResultData> newList = new ArrayList<>();
        resultData.forEach(resultData1 -> {
            ResultData newOne = new ResultData();
            LocalDateTime localDateTime = LocalDateTime
                    .parse(resultData1.getTime(), DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("MM-dd HH:mm:ss");
            String newTimeStr = localDateTime.format(dateTimeFormatter);
            newOne.setTime(newTimeStr);
            newOne.setStatus(resultData1.getStatus());
            newList.add(newOne);
        });
        Result newResult = result.getResult();
        newResult.setList(newList);
        result.setResult(newResult);
        caffeineCache.put(orderId.toString(), result);

        resultMap.put("logistic", result);
        resultMap.put("address", orderInfo.getAddress());
        return resultMap;
    }

    public List<OrderInfoDTO> showMyStoreOrders(Long userId, OrderStatus orderStatus, Long orderInfoId) {
        List<OrderInfo> orderInfos = new ArrayList<>();
        Store store = storeRepo.findFirstByUserId(userId);
        if (orderInfoId != null) {
            orderInfos = orderInfoRepo.findAllById(orderInfoId);
        } else {
            if (orderStatus.equals(OrderStatus.ALL)) {
                orderInfos = orderInfoRepo
                        .findAllByStoreIdAndOrderStatusNotOrderByCreatedAtDesc(store.getId(), OrderStatus.DELETED);
            } else {
                orderInfos = orderInfoRepo
                        .findAllByOrderStatusAndStoreIdOrderByCreatedAtDesc(orderStatus, store.getId());
            }
        }
        List<OrderInfoDTO> result = new ArrayList<>();
        orderInfos.forEach(orderInfo -> {
            OrderInfoDTO orderInfoDTO = new OrderInfoDTO();
            orderInfoDTO.setOrderInfoId(orderInfo.getId());
            orderInfoDTO.setCaseId(orderInfo.getCaseId());
            if (orderInfo.getCardCase().getCustomName() != null) {
                orderInfoDTO.setImage(orderInfo.getCardCase().getImages().get(0));
            } else {
                orderInfoDTO.setImage(orderInfo.getCardCase().getCollection().getImages().get(0));
            }
            orderInfoDTO.setCreateTime(orderInfo.getCreatedAt());
            orderInfoDTO.setRemark(orderInfo.getRemark());
            orderInfoDTO.setStatus(orderInfo.getOrderStatus());
            orderInfoDTO.setTotal(orderInfo.getTotal());
            orderInfoDTO.setStoreName("卓卡官方");
            orderInfoDTO.setUserNickName(orderInfo.getUser().getNickname());
            orderInfoDTO.setUserId(orderInfo.getUserId());
            orderInfoDTO.setAvatar(orderInfo.getUser().getAvatar());
            if (store != null) {
                orderInfoDTO.setStoreName(store.getStoreName());
                orderInfoDTO.setStoreId(store.getId());
                orderInfoDTO.setLogo(store.getLogo());
                orderInfoDTO.setStoreUserId(store.getUserId());
            }
            List<OrderBoxDTO> orderBoxDTOS = new ArrayList<>();
            if (orderInfo.getCardBoxList().size() < 1 & orderInfo.getCardBoxStr() != null) {
                List<Long> boxIds = Arrays
                        .asList((Long[]) ConvertUtils.convert(orderInfo.getCardBoxStr().split(","), Long.class));
                List<CardBox> cardBoxList = cardBoxRepo.findAllByIdIn(boxIds);
                orderInfo.setCardBoxList(cardBoxList);
            }
            orderInfo.getCardBoxList().forEach(cardBox -> {
                OrderBoxDTO orderBoxDTO = new OrderBoxDTO();
                if (cardBox.getCardCase().getCustomName() != null) {
                    orderBoxDTO.setCaseName(cardBox.getCardCase().getCustomName());
                } else {
                    orderBoxDTO.setCaseName(cardBox.getCardCase().getCollection().getName());
                }
                orderBoxDTO.setBoxName(cardBox.getGroupCode() + "-" + cardBox.getBoxCode());
                orderBoxDTO.setMoney(cardBox.getMoney());
                if (orderInfo.getCardCase().getCustomName() != null) {
                    orderBoxDTO.setImages(orderInfo.getCardCase().getImages().get(0));
                } else {
                    orderBoxDTO.setImages(orderInfo.getCardCase().getCollection().getImages().get(0));
                }
                CaseResult caseResult = caseResultRepo.findFirstByBoxId(cardBox.getId());
                if (caseResult != null) {
                    orderBoxDTO.setImage(Objects
                            .requireNonNull(jackpotRepo.findById(caseResult.getJackpotId()).orElse(null)).getImage());
                    orderBoxDTO.setHasResult(true);
                    orderBoxDTO.setCardName(Objects
                            .requireNonNull(jackpotRepo.findById(caseResult.getJackpotId()).orElse(null)).getName());
                } else {
                    orderBoxDTO.setHasResult(false);
                }
                orderBoxDTOS.add(orderBoxDTO);
            });
            orderInfoDTO.setOrderBoxDTOS(orderBoxDTOS);
            result.add(orderInfoDTO);
        });
        return result;
    }

    public List<OrderInfoDTO> showMyOrderInfos(Long userId, OrderStatus orderStatus, Long orderInfoId) {
        List<OrderInfo> orderInfos = new ArrayList<>();
        if (orderInfoId != null) {
            orderInfos = orderInfoRepo.findAllById(orderInfoId);
        } else {
            if (orderStatus.equals(OrderStatus.ALL)) {
                orderInfos = orderInfoRepo
                        .findAllByUserIdAndOrderStatusNotOrderByCreatedAtDesc(userId, OrderStatus.DELETED);
            } else {
                orderInfos = orderInfoRepo.findAllByOrderStatusAndUserIdOrderByCreatedAtDesc(orderStatus, userId);
            }
        }
        List<OrderInfoDTO> result = new ArrayList<>();
        orderInfos.forEach(orderInfo -> {
            OrderInfoDTO orderInfoDTO = new OrderInfoDTO();
            orderInfoDTO.setOrderInfoId(orderInfo.getId());
            orderInfoDTO.setCaseId(orderInfo.getCaseId());
            if (orderInfo.getCardCase().getCustomName() != null) {
                orderInfoDTO.setImage(orderInfo.getCardCase().getImages().get(0));
            } else {
                orderInfoDTO.setImage(orderInfo.getCardCase().getCollection().getImages().get(0));
            }
            orderInfoDTO.setCreateTime(orderInfo.getCreatedAt());
            orderInfoDTO.setRemark(orderInfo.getRemark());
            orderInfoDTO.setStatus(orderInfo.getOrderStatus());
            orderInfoDTO.setTotal(orderInfo.getTotal());
            orderInfoDTO.setStoreName("卓卡官方");
            orderInfoDTO.setUserNickName(orderInfo.getUser().getNickname());
            orderInfoDTO.setUserId(orderInfo.getUserId());
            orderInfoDTO.setAvatar(orderInfo.getUser().getAvatar());
            Store store = storeRepo.findById(orderInfo.getStoreId()).orElse(null);
            if (store != null) {
                orderInfoDTO.setStoreName(store.getStoreName());
                orderInfoDTO.setStoreId(store.getId());
                orderInfoDTO.setLogo(store.getLogo());
                orderInfoDTO.setStoreUserId(store.getUserId());
            }
            List<OrderBoxDTO> orderBoxDTOS = new ArrayList<>();
            if (orderInfo.getCardBoxList().size() < 1 & orderInfo.getCardBoxStr() != null) {
                List<Long> boxIds = Arrays
                        .asList((Long[]) ConvertUtils.convert(orderInfo.getCardBoxStr().split(","), Long.class));
                List<CardBox> cardBoxList = cardBoxRepo.findAllByIdIn(boxIds);
                orderInfo.setCardBoxList(cardBoxList);
            }
            orderInfo.getCardBoxList().forEach(cardBox -> {
                OrderBoxDTO orderBoxDTO = new OrderBoxDTO();
                if (orderInfo.getCardCase().getCustomName() != null) {
                    orderBoxDTO.setCaseName(orderInfo.getCardCase().getCustomName());
                } else {
                    orderBoxDTO.setCaseName(orderInfo.getCardCase().getCollection().getName());
                }
                orderBoxDTO.setBoxName(cardBox.getGroupCode() + "-" + cardBox.getBoxCode());
                orderBoxDTO.setMoney(cardBox.getMoney());
                if (orderInfo.getCardCase().getCustomName() != null) {
                    orderBoxDTO.setImages(orderInfo.getCardCase().getImages().get(0));
                } else {
                    orderBoxDTO.setImages(orderInfo.getCardCase().getCollection().getImages().get(0));
                }
                CaseResult caseResult = caseResultRepo.findFirstByBoxId(cardBox.getId());
                if (caseResult != null) {
                    orderBoxDTO.setImage(Objects
                            .requireNonNull(jackpotRepo.findById(caseResult.getJackpotId()).orElse(null)).getImage());
                    orderBoxDTO.setHasResult(true);
                    orderBoxDTO.setCardName(Objects
                            .requireNonNull(jackpotRepo.findById(caseResult.getJackpotId()).orElse(null)).getName());
                } else {
                    orderBoxDTO.setHasResult(false);
                }
                orderBoxDTOS.add(orderBoxDTO);
            });
            orderInfoDTO.setOrderBoxDTOS(orderBoxDTOS);
            result.add(orderInfoDTO);
        });
        return result;
    }

    public void refund(Long orderInfoId, String remark) {
        OrderInfo orderInfo = orderInfoRepo.findById(orderInfoId).orElseThrow(new BusinessException("没有信息"));
        orderInfo.setOrderStatus(OrderStatus.REFUND);
        orderInfoRepo.save(orderInfo);
    }

    public void newAfterSale(Long orderInfoId, String remark, List<String> images) {

    }

    public void delete(Long orderInfoId) {
        OrderInfo orderInfo = orderInfoRepo.findById(orderInfoId).orElseThrow(new BusinessException("无信息"));
        orderInfo.setOrderStatus(OrderStatus.DELETED);
        orderInfoRepo.save(orderInfo);
    }

    public void saveLogistic(Long id, String logisticNo, String type) {
        OrderInfo orderInfo = orderInfoRepo.findById(id).orElseThrow(new BusinessException("无信息"));
        if (type.equals("SFEXPRESS")) {
            String phoneNumber = orderInfo.getAddress().getPhone();

            StringBuilder tailNum = new StringBuilder();
            if (phoneNumber != null) {
                int len = phoneNumber.length();
                for (int i = len - 1; i >= len - 4; i--) {
                    tailNum.append(phoneNumber.charAt(i));
                }
                tailNum.reverse();
            }
            logisticNo = logisticNo + tailNum.toString();
        }
        orderInfo.setLogisticsType(type);
        orderInfo.setLogisticsNo(logisticNo);
        orderInfo.setOrderStatus(OrderStatus.SEND);
        LogisticsQueryResponse result = LogisticsUtils.query(logisticNo, type);
        orderInfoRepo.save(orderInfo);
    }

    public List<OrderInfoDTO> toOrderInfoDTOs(List<OrderInfo> orderInfos) {
        List<OrderInfoDTO> result = new ArrayList<>();
        orderInfos.forEach(orderInfo -> {
            if (!orderInfo.getCardCase().isDel()) {
                Store store = orderInfo.getStore();
                OrderInfoDTO orderInfoDTO = new OrderInfoDTO();
                orderInfoDTO.setOrderInfoId(orderInfo.getId());
                orderInfoDTO.setCaseId(orderInfo.getCaseId());
                if (orderInfo.getCardCase().getCustomName() != null) {
                    orderInfoDTO.setImage(orderInfo.getCardCase().getImages().get(0));
                } else {
                    orderInfoDTO.setImage(orderInfo.getCardCase().getCollection().getImages().get(0));
                }
                orderInfoDTO.setCreateTime(orderInfo.getCreatedAt());
                orderInfoDTO.setRemark(orderInfo.getRemark());
                orderInfoDTO.setStatus(orderInfo.getOrderStatus());
                orderInfoDTO.setTotal(orderInfo.getTotal());
                orderInfoDTO.setStoreName("卓卡官方");
                orderInfoDTO.setUserNickName(orderInfo.getUser().getNickname());
                orderInfoDTO.setUserId(orderInfo.getUserId());
                orderInfoDTO.setAvatar(orderInfo.getUser().getAvatar());
                orderInfoDTO.setSelectedBoxes(orderInfo.getCardBoxList().stream()
                        .map(cardBox -> cardBox.getGroupCode() + "-" + cardBox.getBoxCode())
                        .collect(Collectors.joining(",")));
                if (orderInfo.getCardCase().getCustomName() != null) {
                    orderInfoDTO
                            .setCaseStr(orderInfo.getCardCase().getCustomName() + orderInfo.getCardCase().getCode());
                } else {
                    orderInfoDTO
                            .setCaseStr(orderInfo.getCardCase().getCollection().getName() + "-" + orderInfo
                                    .getCardCase()
                                    .getCode());
                }
                orderInfoDTO.setStatusStr(orderInfo.getOrderStatus().getDescription());
                orderInfoDTO.setPaidTime(orderInfo.getPaidTime());
                orderInfoDTO.setTransactionId(orderInfo.getTransactionId());
                if (store != null) {
                    orderInfoDTO.setStoreName(store.getStoreName());
                    orderInfoDTO.setStoreId(store.getId());
                    orderInfoDTO.setLogo(store.getLogo());
                    orderInfoDTO.setStoreUserId(store.getUserId());
                }
//            List<OrderBoxDTO> orderBoxDTOS = new ArrayList<>();
//            if (orderInfo.getCardBoxList().size() < 1 & orderInfo.getCardBoxStr() != null) {
//                List<Long> boxIds = Arrays
//                        .asList((Long[]) ConvertUtils.convert(orderInfo.getCardBoxStr().split(","), Long.class));
//                List<CardBox> cardBoxList = cardBoxRepo.findAllByIdIn(boxIds);
//                orderInfo.setCardBoxList(cardBoxList);
//            }
//            orderInfo.getCardBoxList().forEach(cardBox -> {
//                OrderBoxDTO orderBoxDTO = new OrderBoxDTO();
//                orderBoxDTO.setCaseName(cardBox.getCardCase().getCollection().getName());
//                orderBoxDTO.setBoxName(cardBox.getGroupCode() + "-" + cardBox.getBoxCode());
//                orderBoxDTO.setMoney(cardBox.getMoney());
//                orderBoxDTO.setImages(cardBox.getCardCase().getCollection().getImages().get(0));
//                orderBoxDTOS.add(orderBoxDTO);
//            });
//            orderInfoDTO.setOrderBoxDTOS(orderBoxDTOS);
                result.add(orderInfoDTO);
            }
        });
        return result;
    }
}