zhuoka/src/main/java/com/izouma/tcg/service/card/CardCaseService.java

package com.izouma.tcg.service.card;

import com.izouma.tcg.domain.BaseEntity;
import com.izouma.tcg.domain.User;
import com.izouma.tcg.domain.card.*;
import com.izouma.tcg.domain.card.Collection;
import com.izouma.tcg.domain.customizeStore.Store;
import com.izouma.tcg.domain.orderInfo.OrderInfo;
import com.izouma.tcg.domain.orderInfo.OrderRefundApply;
import com.izouma.tcg.dto.CardBoxDTO;
import com.izouma.tcg.dto.CaseJackpotDTO;
import com.izouma.tcg.dto.GroupDTO;
import com.izouma.tcg.dto.PageQuery;
import com.izouma.tcg.dto.cardCase.CardCaseDTO;
import com.izouma.tcg.dto.cardCase.CardCaseInputDTO;
import com.izouma.tcg.dto.cardCase.CardDTO;
import com.izouma.tcg.dto.cardCase.CaseDTO;
import com.izouma.tcg.enums.AuthorityName;
import com.izouma.tcg.enums.CaseStatus;
import com.izouma.tcg.enums.OrderStatus;
import com.izouma.tcg.exception.BusinessException;
import com.izouma.tcg.repo.card.*;
import com.izouma.tcg.repo.customizeStore.StoreRepo;
import com.izouma.tcg.repo.orderInfo.OrderInfoRepo;
import com.izouma.tcg.repo.orderInfo.OrderRefundApplyRepo;
import com.izouma.tcg.security.Authority;
import com.izouma.tcg.service.orderInfo.OrderRefundApplyService;
import com.izouma.tcg.utils.JpaUtils;
import com.izouma.tcg.utils.SecurityUtils;
import lombok.AllArgsConstructor;
import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;

import javax.naming.Name;
import javax.persistence.criteria.Predicate;
import javax.transaction.Transactional;
import java.util.*;
import java.util.stream.Collectors;

import static com.izouma.tcg.utils.JpaUtils.*;

@Service
@AllArgsConstructor
public class CardCaseService {

    private final CardCaseRepo            cardCaseRepo;
    private final CollectionRepo          collectionRepo;
    private final CardBoxRepo             cardBoxRepo;
    private final StoreRepo               storeRepo;
    private final OrderRefundApplyService orderRefundApplyService;
    private final OrderInfoRepo           orderInfoRepo;
    private final OrderRefundApplyRepo    orderRefundApplyRepo;
    private final JackpotRepo             jackpotRepo;
    private final LevelRepo               levelRepo;
    private final CaseJackpotsRepo        caseJackpotsRepo;

    public Page<CardCase> all(PageQuery pageQuery) {
        return cardCaseRepo
                .findAll(JpaUtils.toSpecification(pageQuery, CardCase.class), JpaUtils.toPageRequest(pageQuery));
    }

    public List<GroupDTO> genNewCardCase(Integer group, Integer groupCount, boolean special) {
        List<GroupDTO> GroupDTOs = new ArrayList<>();
        for (int i = 0; i < group; i++) {
            int groupNo = i + 1;
            GroupDTO groupDTO = new GroupDTO();
            groupDTO.setTagTitle(String.valueOf(groupNo));
            if (special) {
                if (i == 0) {
                    groupDTO.setTagTitle("A");
                } else {
                    groupDTO.setTagTitle("B");
                }
            }
            List<CardBoxDTO> cardBoxDTOs = new ArrayList<>();
            for (int j = 0; j < groupCount; j++) {
                int boxNo = j + 1;

                CardBoxDTO cardBoxDTO = new CardBoxDTO();
                cardBoxDTO.setName(boxNo + "号");
                cardBoxDTO.setIdx(boxNo);
                cardBoxDTO.setSold(false);
                cardBoxDTOs.add(cardBoxDTO);
                groupDTO.setDynamicTags(cardBoxDTOs);
            }
            GroupDTOs.add(groupDTO);
        }
        return GroupDTOs;
    }

    //    public List<CardCaseDTO> showStoreViewCases(CaseStatus caseStatus, List<String> sortStrings) {
//        List<CardCase> cardCases = new ArrayList<>();
//        Set<Long> collectionIds = new HashSet<>();
//        if (StringUtils.isNotBlank(search)) {
//            collectionIds = collectionRepo.findAllByNameLike("%" + search + "%").stream().map(Collection::getId)
//                    .collect(Collectors.toSet());
//            cardCases = cardCaseRepo
//                    .findAllByCaseStatusAndCollectionIdInAndSeriesId(caseStatus, collectionIds, seriesId);
//        }
//        if (collectionId != null) {
//            collectionIds.add(collectionId);
//            cardCases = cardCaseRepo
//                    .findAllByCaseStatusAndCollectionIdInAndSeriesId(caseStatus, collectionIds, seriesId);
//        }
//        if (collectionId == null & StringUtils.isBlank(search)) {
//            cardCases = cardCaseRepo.findAllByCaseStatusAndSeriesId(caseStatus, seriesId);
//        }
//        List<CardCaseDTO> result = new ArrayList<>();
//        cardCases.removeIf(CardCase::isDel);
//        cardCases.forEach(cardCase -> {
//            CardCaseDTO cardCaseDTO = new CardCaseDTO();
//            cardCaseDTO.setCardCaseId(cardCase.getId());
//            cardCaseDTO
//                    .setCaseName(Optional.ofNullable(cardCase.getCollection()).orElseThrow(new BusinessException("暂无"))
//                            .getName() + cardCase.getCode());
//            cardCaseDTO.setImage(cardCase.getCollection().getImages().get(0));
//            cardCaseDTO.setEndTime(cardCase.getStartTime());
//            cardCaseDTO.setPrice(cardCase.getBoxPrice());
//            cardCaseDTO.setTotal(cardCase.getCardBoxList().size());
//            cardCaseDTO.setCaseStatus(cardCase.getCaseStatus().toString());
//            Integer preorderCount = cardBoxRepo.countAllByCardCaseIdAndUserIdNotNull(cardCase.getId());
//            cardCaseDTO.setPreorder(preorderCount);
//            result.add(cardCaseDTO);
//        });
//        return result;
//    }

    public List<CardCaseDTO> showStoreCasesMA(PageQuery pageQuery) {
        List<CardCase> cardCases = cardCaseRepo
                .findAll((Specification<CardCase>) (root, criteriaQuery, criteriaBuilder) ->
                        criteriaBuilder.and(criteriaBuilder.and(
                                criteriaBuilder.equal(root.get("storeId"), pageQuery.getQuery().get("storeId")),
                                root.get("caseStatus").in(pageQuery.getQuery().get("caseStatus")),
                                criteriaBuilder.equal(root.get("del"), false))), toPageRequest(pageQuery)).getContent();
        return getCardCaseDTOS(cardCases);
    }

    public List<CardCaseDTO> showRoomCasesMA(Long roomId, Long storeId) {
        List<CardCase> cardCases = cardCaseRepo.findAllByRoomIdAndStoreId(roomId, storeId);
        return getCardCaseDTOS(cardCases);
    }

    private List<CardCaseDTO> getCustomSearchResult(List<CaseDTO> caseDTOS) {
        List<CardCaseDTO> result = new ArrayList<>();
        caseDTOS.forEach(caseDTO -> {
            CardCaseDTO cardCaseDTO = new CardCaseDTO();
            cardCaseDTO.setCardCaseId(caseDTO.getCardCaseId());
            Collection collection = collectionRepo.findById(caseDTO.getCollectionId()).orElse(null);
            if (caseDTO.getCaseName() != null) {
                cardCaseDTO.setCaseName(caseDTO.getCaseName());
            } else {
                cardCaseDTO
                        .setCaseName(collection
                                .getName());
            }
            if (caseDTO.getImages().size() == 0) {
                cardCaseDTO.setImage(collection.getImages().get(0));
            } else {
                cardCaseDTO.setImage(caseDTO.getImages().get(0));
            }
            cardCaseDTO.setEndTime(caseDTO.getEndTime());
            cardCaseDTO.setCaseStatus(caseDTO.getCaseStatus().toString());
            Integer totalCount = cardBoxRepo.countAllByCardCaseId(caseDTO.getCardCaseId());
            Integer preorderCount = cardBoxRepo.countAllByCardCaseIdAndUserIdNotNull(caseDTO.getCardCaseId());
            Integer otherPreorderCount = cardBoxRepo.countAllByCardCaseIdAndBindNameNotNull(caseDTO.getCardCaseId());
            preorderCount = preorderCount + otherPreorderCount;
            cardCaseDTO.setPrice(caseDTO.getPrice());
            if (caseDTO.isSpecial()) {
                cardCaseDTO.setTotal(totalCount / 2);
                cardCaseDTO.setPreorder(preorderCount / 2);
            } else {
                cardCaseDTO.setPreorder(preorderCount);
                cardCaseDTO.setTotal(totalCount);
            }
            cardCaseDTO.setLiveNow(caseDTO.isLiveNow());
            cardCaseDTO.setInstant(caseDTO.isInstant());
            cardCaseDTO.setRoomId(caseDTO.getRoomId());
            cardCaseDTO.setStoreName(storeRepo.findById(caseDTO.getStoreId()).orElse(null).getStoreName());
            result.add(cardCaseDTO);
        });
        return result;
    }

    private List<CardCaseDTO> getCardCaseDTOS(List<CardCase> cardCases) {
        List<CardCaseDTO> result = new ArrayList<>();
        cardCases.forEach(cardCase -> {
            CardCaseDTO cardCaseDTO = new CardCaseDTO();
            cardCaseDTO.setCardCaseId(cardCase.getId());
            if (cardCase.getCustomName() != null) {
                cardCaseDTO.setCaseName(cardCase.getCustomName());
            } else {
                cardCaseDTO
                        .setCaseName(Optional.ofNullable(cardCase.getCollection())
                                .orElseThrow(new BusinessException("暂无"))
                                .getName() + cardCase.getCode());
            }
            if (cardCase.getImages().size() == 0) {
                cardCaseDTO.setImage(cardCase.getCollection().getImages().get(0));
            } else {
                cardCaseDTO.setImage(cardCase.getImages().get(0));
            }
            cardCaseDTO.setEndTime(cardCase.getStartTime());
            cardCaseDTO.setCaseStatus(cardCase.getCaseStatus().toString());
            cardCaseDTO.setDescription(cardCase.getDescription());
            cardCaseDTO.setPostage(cardCase.getPostage());
            Integer preorderCount = cardBoxRepo.countAllByCardCaseIdAndUserIdNotNull(cardCase.getId());
            Integer otherPreorderCount = cardBoxRepo.countAllByCardCaseIdAndBindNameNotNull(cardCase.getId());
            preorderCount = preorderCount + otherPreorderCount;
            Store store = storeRepo.findById(cardCase.getStoreId()).orElse(null);
            if (store != null) {
                cardCaseDTO.setStoreId(store.getId());
                cardCaseDTO.setStoreName(store.getStoreName());
                cardCaseDTO.setStoreLogo(store.getLogo());
            }
            cardCaseDTO.setPrice(cardCase.getBoxPrice());
            if (cardCase.isSpecial()) {
                cardCaseDTO.setTotal(cardCase.getCardBoxList().size() / 2);
                cardCaseDTO.setPreorder(preorderCount / 2);
            } else {
                cardCaseDTO.setPreorder(preorderCount);
                cardCaseDTO.setTotal(cardCase.getCardBoxList().size());
            }
            cardCaseDTO.setLiveNow(cardCase.isLiveNow());
            cardCaseDTO.setInstant(cardCase.isInstant());
            cardCaseDTO.setRoomId(cardCase.getRoomId());
            result.add(cardCaseDTO);
        });
        return result;
    }


    public Page<CardCaseDTO> showCardCasesMA(CaseStatus caseStatus, Long collectionId, String search, Long seriesId, Pageable pageable) {
        Page<CaseDTO> cardCases;
        Set<Long> collectionIds = new HashSet<>();
        if (StringUtils.isNotBlank(search)) {
            collectionIds = collectionRepo.findAllByNameLike("%" + search + "%").stream().map(Collection::getId)
                    .collect(Collectors.toSet());
        }
        if (collectionId != null) {
            collectionIds.add(collectionId);
        }
        if (collectionId == null & StringUtils.isBlank(search)) {
            cardCases = cardCaseRepo.customFindList1(caseStatus, seriesId, pageable);
        } else {
            cardCases = cardCaseRepo
                    .customFindList2(caseStatus, collectionIds, seriesId, pageable);
        }
        return new PageImpl<>(getCustomSearchResult(cardCases.getContent()), cardCases.getPageable(), cardCases
                .getTotalElements());
    }

    public Map<String, Object> showCaseInfoMA(Long caseId) {
        CardCase cardCase = cardCaseRepo.findById(caseId).orElseThrow(new BusinessException("无信息"));
        if (cardCase.isDel()) {
            throw new BusinessException("已删除");
        }
        List<CardBox> caseBoxList = cardCase.getCardBoxList();
        Map<String, List<CardBox>> groupBoxMap = caseBoxList.stream()
                .collect(Collectors.groupingBy(CardBox::getGroupCode));
        groupBoxMap.forEach((k, v) -> {
            if (v.get(0).getBoxIdx() != null) {
                List<CardBox> sortedList = v.stream().sorted(Comparator.comparing(CardBox::getBoxIdx))
                        .collect(Collectors.toList());
                groupBoxMap.put(k, sortedList);
            }
        });
        List<CardDTO> jackpots = new ArrayList<>();
        cardCase.getCaseJackpots().forEach(jackpot -> {
            CardDTO cardDTO = new CardDTO();
            cardDTO.setCardName(jackpot.getJackpot().getName());
            cardDTO.setId(jackpot.getJackpotId());
            cardDTO.setImage(jackpot.getJackpot().getImage());
            cardDTO.setMoney(jackpot.getJackpot().getValue());
            cardDTO.setCount(jackpot.getCount());
            if (!jackpot.getCount().equals(jackpot.getRest()) & jackpot.getRest() != null) {
                cardDTO.setCount(jackpot.getRest());
            }
            jackpots.add(cardDTO);
        });
        Collections.sort(jackpots);

        Map<String, List<CardBox>> listResult = new TreeMap<>();
        groupBoxMap.entrySet().stream()
                .sorted(Map.Entry.comparingByKey())
                .forEachOrdered(x -> listResult.put(x.getKey(), x.getValue()));
        Map<String, Object> result = new HashMap<>();
        CardCaseDTO cardCaseDTO = new CardCaseDTO();
        cardCaseDTO.setCardCaseId(cardCase.getId());
        if (cardCase.getCustomName() != null) {
            cardCaseDTO.setCaseName(cardCase.getCustomName());
        } else {
            cardCaseDTO
                    .setCaseName(Optional.ofNullable(cardCase.getCollection())
                            .orElseThrow(new BusinessException("暂无"))
                            .getName() + cardCase.getCode());
        }
        cardCaseDTO.setDescription(cardCase.getDescription());
        if (cardCase.getCustomName() != null) {
            cardCaseDTO.setImage(cardCase.getImages().get(0));
        } else {
            cardCaseDTO.setImage(cardCase.getCollection().getImages().get(0));
        }
        cardCaseDTO.setImages(cardCase.getImages());
        cardCaseDTO.setCardDTOs(jackpots);
        if (cardCaseDTO.getImages().size() == 0) {
            cardCaseDTO.setImages(cardCase.getCollection().getImages());
        }
        cardCaseDTO.setEndTime(cardCase.getStartTime());
        cardCaseDTO.setPrice(cardCase.getBoxPrice());
        cardCaseDTO.setCaseStatus(cardCase.getCaseStatus().toString());
        cardCaseDTO.setSpecial(cardCase.isSpecial());
        cardCaseDTO.setLiveNow(cardCase.isLiveNow());
        cardCaseDTO.setInstant(cardCase.isInstant());
        cardCaseDTO.setRoomId(cardCase.getRoomId());
        cardCaseDTO.setDescription(cardCase.getDescription());
        cardCaseDTO.setPostage(cardCase.getPostage());
        Integer preorderCount = cardBoxRepo.countAllByCardCaseIdAndUserIdNotNull(cardCase.getId());
        Integer otherPreorderCount = cardBoxRepo.countAllByCardCaseIdAndBindNameNotNull(cardCase.getId());
        preorderCount = preorderCount + otherPreorderCount;
        Store store = storeRepo.findById(cardCase.getStoreId()).orElse(null);
        if (store != null) {
            cardCaseDTO.setStoreId(store.getId());
            cardCaseDTO.setStoreName(store.getStoreName());
            cardCaseDTO.setStoreLogo(store.getStoreName());
        }
        if (cardCase.isSpecial()) {
            cardCaseDTO.setTotal(cardCase.getCardBoxList().size() / 2);
            cardCaseDTO.setPreorder(preorderCount / 2);
        } else {
            cardCaseDTO.setTotal(cardCase.getCardBoxList().size());
            cardCaseDTO.setPreorder(preorderCount);
        }
        result.put("cardCaseInfo", cardCaseDTO);
        result.put("groupBoxMap", listResult);
        return result;
    }


    @Transactional
    public CardCase save(CardCaseInputDTO cardCaseInputDTO) {
        CardCase cardCase = new CardCase();
        if (cardCaseInputDTO.getId() != null) {
            CardCase orig = cardCaseRepo.findById(cardCaseInputDTO.getId()).orElse(null);
            if (orig != null) {
                cardCase = orig;
            }
        }
        User user = SecurityUtils.getAuthenticatedUser();
        Store store = storeRepo.findFirstByUserId(user.getId());
        if (store != null) {
            cardCase.setStoreId(store.getId());
        }
        if (StringUtils.isNotBlank(cardCaseInputDTO.getName())) {
            cardCase.setSeriesId(103L);
            cardCase.setCollectionId(16507L);
            cardCase.setCustomName(cardCaseInputDTO.getName());
        } else {
            Collection collection = collectionRepo.findById(cardCaseInputDTO.getCollectionId())
                    .orElseThrow(new BusinessException("无系列信息"));
            cardCase.setSeriesId(collection.getSeriesId());
            cardCase.setCollectionId(collection.getId());
        }
        cardCase.setCode(cardCaseInputDTO.getCode());
        cardCase.setDescription(cardCaseInputDTO.getDescription());
        if (cardCase.getCode() == null) {
            cardCase.setCode("");
        }

        cardCase.setCaseStatus(cardCaseInputDTO.getCaseStatus());
        cardCase.setStartTime(cardCaseInputDTO.getStartTime());
        cardCase.setBoxPrice(cardCaseInputDTO.getBoxPrice());
        if (cardCaseInputDTO.getImages() != null) {
            String imageString = cardCaseInputDTO.getImages();
            String rep = imageString.replaceAll("[\\[\\]]", "");
            if (cardCaseInputDTO.getImages().length() > 0) {
                List<String> images = Arrays
                        .asList((String[]) ConvertUtils.convert(rep.split(","), String.class));
                cardCase.setImages(images);
            } else {
                cardCase.setImages(null);
            }
        } else {
            cardCase.setImages(null);
        }
        cardCase.setPostage(cardCaseInputDTO.getPostage());
        cardCase.setBoxesCount(cardCaseInputDTO.getBoxesCount());
        cardCase.setSpecial(cardCaseInputDTO.isSpecial());
        cardCase.setLimitOne(cardCaseInputDTO.isLimitOne());
        cardCase.setHasLive(cardCaseInputDTO.isHasLive());
        cardCase.setInstant(cardCaseInputDTO.isInstant());
        //绑定卡池信息
        if (cardCaseInputDTO.getCards() != null & cardCaseInputDTO.getGroupDTOS() != null) {
            if (cardCaseInputDTO.getCaseJackpots().stream().map(CaseJackpotDTO::getAmount).reduce(Long::sum).orElse(0L)
                    .intValue() != cardCaseInputDTO.getGroupDTOS().stream()
                    .map(groupDTO -> groupDTO.getDynamicTags().size()).reduce(Integer::sum).orElse(0)) {
                throw new BusinessException("奖池与坑位数量不一致，请重新编辑!");
            }
        }

        CardCase result = cardCaseRepo.save(cardCase);
        //解析卡盒与组
        if (cardCaseInputDTO.getCaseJackpots().size() > 0) {
            List<Long> cardIds = cardCaseInputDTO.getCaseJackpots().stream().map(CaseJackpotDTO::getJackpotId)
                    .collect(Collectors.toList());
            Set<Jackpot> cards = jackpotRepo.findAllByIdIn(cardIds);
            List<CaseJackpotDTO> caseJackpotDTOS = cardCaseInputDTO.getCaseJackpots();
            caseJackpotDTOS.forEach(caseJackpotDTO -> {
                if (caseJackpotDTO.getId() == null) {
                    CaseJackpots caseJackpots = new CaseJackpots();
                    caseJackpots.setCaseId(result.getId());
                    caseJackpots.setCount(caseJackpotDTO.getAmount());
                    caseJackpots.setJackpotId(caseJackpotDTO.getJackpotId());
                    caseJackpotsRepo.save(caseJackpots);
                }
            });
            cardCase.setJackpots(cards);
        }
        List<Long> newIds = new ArrayList<>();
        List<GroupDTO> groupDTOS = cardCaseInputDTO.getGroupDTOS();
        groupDTOS.forEach(groupDTO -> {
            String groupName = groupDTO.getTagTitle();
            List<CardBoxDTO> boxDTOs = groupDTO.getDynamicTags();
            boxDTOs.forEach(box -> {
                CardBox cardBox;
                if (box.getCardBoxId() != null) {
                    cardBox = cardBoxRepo.findById(box.getCardBoxId()).orElse(null);
                    if (cardBox != null) {
                        cardBox.setCardCaseId(result.getId());
                        cardBox.setBoxCode(box.getName());
                        cardBox.setGroupCode(groupName);
                        cardBox.setMoney(result.getBoxPrice());
                        cardBox.setCaseStatus(result.getCaseStatus());
                        cardBox.setBoxPrice(result.getBoxPrice());
                        cardBoxRepo.save(cardBox);
                        newIds.add(cardBox.getId());
                    }
                } else {
                    cardBox = new CardBox();
                    cardBox.setCardCaseId(result.getId());
                    cardBox.setBoxCode(box.getName());
                    cardBox.setBoxIdx(box.getIdx());
                    cardBox.setGroupCode(groupName);
                    cardBox.setMoney(result.getBoxPrice());
                    cardBox.setCaseStatus(result.getCaseStatus());
                    cardBox.setBoxPrice(result.getBoxPrice());
                    cardBoxRepo.save(cardBox);
                }
            });
        });
        if (cardCase.getCardBoxList() != null) {
            List<Long> cardBoxIds = cardCase.getCardBoxList().stream().map(CardBox::getId).collect(Collectors.toList());
            if (cardBoxIds.size() > 0) {
                cardBoxIds.removeIf(newIds::contains);
                cardBoxRepo.deleteAllByIdIn(cardBoxIds);
            }
        }
        return result;
    }

    public CardCaseInputDTO getCardCaseInputDTO(Long id) {
        CardCase cardCase = cardCaseRepo.findById(id).orElseThrow(new BusinessException("无信息"));
        CardCaseInputDTO cardCaseInputDTO = new CardCaseInputDTO();
        cardCaseInputDTO.setCaseStatus(cardCase.getCaseStatus());
        cardCaseInputDTO.setBoxPrice(cardCase.getBoxPrice());
        cardCaseInputDTO.setCode(cardCase.getCode());
        cardCaseInputDTO.setId(cardCase.getId());
        cardCaseInputDTO.setBoxesCount(cardCase.getBoxesCount());
        cardCaseInputDTO.setCollectionId(cardCase.getCollectionId());
        cardCaseInputDTO.setSeriesId(cardCase.getSeriesId());
        cardCaseInputDTO.setStartTime(cardCase.getStartTime());
        cardCaseInputDTO.setDescription(cardCase.getDescription());
        cardCaseInputDTO.setSpecial(cardCase.isSpecial());
        if (cardCase.getCustomName() != null) {
            cardCaseInputDTO.setName(cardCase.getCustomName());
        }
        cardCaseInputDTO.setLimitOne(cardCase.isLimitOne());
        cardCaseInputDTO.setHasLive(cardCase.isHasLive());
        cardCaseInputDTO.setInstant(cardCase.isInstant());
        cardCaseInputDTO.setCards(cardCase.getJackpots().stream().map(Jackpot::getId).collect(Collectors.toList()));
        String imagesList = String.join(",", cardCase.getImages());
        long total = cardCase.getCardBoxList().size();
        long beenBuy = cardCase.getCardBoxList().stream().filter(CardBox::isSold).count();
        cardCaseInputDTO.setSoldStatus(beenBuy + "/" + total);
        if (cardCase.isSpecial()) {
            cardCaseInputDTO.setSoldStatus(beenBuy / 2 + "/" + total / 2);
        }
        cardCaseInputDTO.setImages(imagesList);
//
//        cardCaseInputDTO.setImages(images);
        cardCaseInputDTO.setPostage(cardCase.getPostage());
        Map<String, List<CardBox>> groupMap = cardCase.getCardBoxList().stream()
                .collect(Collectors.groupingBy(CardBox::getGroupCode));
        List<GroupDTO> groupDTOS = new ArrayList<>();
        groupMap.forEach((groupCode, cardBoxList) -> {
            GroupDTO groupDTO = new GroupDTO();
            groupDTO.setTagTitle(groupCode);
            List<CardBoxDTO> dtos = new ArrayList<>();
            cardBoxList.forEach(cardBox -> {
                CardBoxDTO cardBoxDTO = new CardBoxDTO();
                cardBoxDTO.setCardBoxId(cardBox.getId());
                cardBoxDTO.setName(cardBox.getBoxCode());
                cardBoxDTO.setIdx(cardBox.getBoxIdx());
                cardBoxDTO.setSold(cardBox.isSold());
                dtos.add(cardBoxDTO);
            });
            groupDTO.setDynamicTags(dtos);
            groupDTOS.add(groupDTO);
        });
        cardCaseInputDTO.setGroupDTOS(groupDTOS);
        List<CaseJackpots> caseJackpots = cardCase.getCaseJackpots();
        List<CaseJackpotDTO> dtos = new ArrayList<>();
        caseJackpots.forEach(caseJackpot -> {
            CaseJackpotDTO caseJackpotDTO = new CaseJackpotDTO();
            caseJackpotDTO.setId(caseJackpot.getId());
            caseJackpotDTO.setJackpotId(caseJackpot.getJackpotId());
            caseJackpotDTO.setName(caseJackpot.getJackpot().getName());
            caseJackpotDTO.setAmount(caseJackpot.getCount());
            caseJackpotDTO.setImage(caseJackpot.getJackpot().getImage());
            dtos.add(caseJackpotDTO);
        });
        cardCaseInputDTO.setCaseJackpots(dtos);
        return cardCaseInputDTO;
    }

    public void softDelete(Long caseId) {
        CardCase cardCase = cardCaseRepo.findById(caseId).orElseThrow(new BusinessException("无信息"));
        cardCase.setCaseStatus(CaseStatus.UNDO);
        cardCaseRepo.save(cardCase);
    }

    public void revive(Long caseId) {
        CardCase cardCase = cardCaseRepo.findById(caseId).orElseThrow(new BusinessException("无信息"));
        cardCase.setCaseStatus(CaseStatus.PROGRESS);
        cardCase.getCardBoxList().forEach(cardBox -> {
            cardBox.setCaseStatus(CaseStatus.PROGRESS);
            cardBoxRepo.save(cardBox);
        });
        cardCaseRepo.save(cardCase);
    }

    public void multipleDelete(String caseList) {
        List<Long> boxIds = Arrays.asList((Long[]) ConvertUtils.convert(caseList.split(","), Long.class));
        boxIds.forEach(this::softDelete);
    }

    public void cancel(Long caseId) {
        CardCase cardCase = cardCaseRepo.findById(caseId).orElseThrow(new BusinessException("报错咯，无卡箱信息"));
        cardCase.getCardBoxList().forEach(cardBox -> {
            cardBox.setCaseStatus(CaseStatus.FINISH);
            cardBoxRepo.save(cardBox);
        });
        cardCase.setCaseStatus(CaseStatus.FINISH);
        cardCaseRepo.save(cardCase);
        List<OrderStatus> orderStatuses = new ArrayList<>();
        orderStatuses.add(OrderStatus.REFUND);
        orderStatuses.add(OrderStatus.PAYED);
        List<OrderInfo> orderInfos = orderInfoRepo.findAllByCaseIdAndOrderStatusIn(caseId, orderStatuses);
        List<OrderRefundApply> orderRefundApplies = new ArrayList<>();
        orderInfos.forEach(orderInfo -> {
            if (orderInfo.getOrderStatus().equals(OrderStatus.REFUND)) {
                orderRefundApplies.add(orderRefundApplyRepo.findById(orderInfo.getRefundId()).orElse(null));
            } else {
                orderRefundApplies.add(orderRefundApplyService.apply(orderInfo.getId(), "拼箱失败，自动发起退款"));
            }
        });
        orderRefundApplies.forEach(orderRefundApply -> {
            orderRefundApplyService.audit(orderRefundApply.getId());
        });
    }
}