tour-server/tour-module/src/main/java/com/tour/module/service/impl/OrderServiceImpl.java

package com.tour.module.service.impl;

import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.google.common.collect.Lists;
import com.tour.common.core.domain.entity.SysUser;
import com.tour.common.enums.UserTypeEnums;
import com.tour.common.exception.CustomException;
import com.tour.common.utils.SnCodeUtils;
import com.tour.module.domain.Agent;
import com.tour.module.domain.Card;
import com.tour.module.domain.Contacts;
import com.tour.module.domain.dto.OmsOrderDto;
import com.tour.module.domain.dto.SystemOrderDto;
import com.tour.module.enums.StatusEnum;
import com.tour.module.service.IAgentService;
import com.tour.module.service.ICardService;
import com.tour.module.service.IContactsService;
import com.tour.module.vo.*;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import org.apache.commons.lang3.StringUtils;
import com.tour.module.mapper.OrderMapper;
import com.tour.module.domain.Order;
import com.tour.module.service.IOrderService;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 订单Service业务层处理
 *
 * @author zoe
 * @date 2023-05-23
 */
@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements IOrderService {

    @Resource
    ICardService cardService;

    @Resource
    IContactsService contactsService;
    @Resource
    IAgentService agentService;
    @Resource
    IContactsService iContactsService;

    @Override
    public List<Order> queryList(Order order) {
        LambdaQueryWrapper<Order> lqw = Wrappers.lambdaQuery();
        if (order.getMemberId() != null) {
            lqw.eq(Order::getMemberId, order.getMemberId());
        }

        if (order.getAgentId() != null) {
            lqw.eq(Order::getAgentId, order.getAgentId());
        }
        if (StringUtils.isNotBlank(order.getCardKey())) {
            lqw.eq(Order::getCardKey, order.getCardKey());
        }
        if (order.getStatus() != null && order.getStatus() != 10) {
            lqw.eq(Order::getStatus, order.getStatus());
        }
        if (order.getAgentIds() != null) {
            lqw.in(Order::getAgentId, order.getAgentIds());
        }
        if (order.getStatus() != null && order.getStatus() == 10) {//完成和取消
            List<Integer> list = new ArrayList<>();
            list.add(3);
            list.add(-1);
            lqw.in(Order::getStatus, list);
        }
        List<Order> orders = this.list(lqw);
        return orders;
    }

    @Override
    public List<OmsOrderDto> queryPageList(SystemOrderDto order, SysUser user) {
        boolean result = this.handleListSearchCondition(order, user);
        if (!result) {
            return Lists.newArrayList();
        }
        List<OmsOrderDto> orderList = baseMapper.queryPageList(order);
        if (CollectionUtils.isEmpty(orderList)) {
            return Lists.newArrayList();
        }

        // 代理商名称
        List<Long> agentIds = orderList.stream().map(OmsOrderDto::getAgentId).collect(Collectors.toList());
        List<Agent> agentList = agentService.list(new QueryWrapper<Agent>().in("id", agentIds));
        Map<Long, Agent> agentMap = Optional.of(agentList).map(list -> list.stream().collect(Collectors.toMap(Agent::getId, v -> v, (v1, v2) -> v1))).orElse(new HashMap<>());
        for (OmsOrderDto o : orderList) {
            // 增加代理商名称
            Agent agent = agentMap.get(o.getAgentId());
            o.setAgentName(agent == null ? null : agent.getAgentName());
        }
        return orderList;
    }

    private boolean handleListSearchCondition(SystemOrderDto order, SysUser user) {
        boolean result = true;
        if (UserTypeEnums.AGENT.getCode().equals(user.getType()) && user.getAgentId() != null) {
            List<Long> agentIds = agentService.listAgent(user.getAgentId());
            if (com.baomidou.mybatisplus.core.toolkit.CollectionUtils.isEmpty(agentIds)) {
                result = false;
            }
            order.setAgentIds(agentIds);
        }
        if (order.getAId() != null) {
            List<Long> aIds = agentService.listAgent(order.getAId());
            if (com.baomidou.mybatisplus.core.toolkit.CollectionUtils.isEmpty(order.getAgentIds())) {
                order.setAgentIds(aIds);
            } else {
                order.getAgentIds().retainAll(aIds);
            }
            if (com.baomidou.mybatisplus.core.toolkit.CollectionUtils.isEmpty(order.getAgentIds())) {
                result = false;
            }
        }
        return result;
    }

    @Override
    public Long addOrder(OrderCreateVo orderVo) {
        Card card = cardService.getOne(new QueryWrapper<Card>().eq("card_key", orderVo.getCardKey()).eq("status", 0));
        if (card == null) {
            throw new CustomException("卡密无效");
        }
        //会员卡和旅游卡的区别 会员卡要判断是否在有效期内
        if ("1".equals(card.getType()) && card.getValidEndTime().getTime() < System.currentTimeMillis()) {//会员卡
            throw new CustomException("会员卡已失效");
        }
        Order order = new Order();
        BeanUtils.copyProperties(orderVo, order);
        order.setAgentId(card.getAgentId());
        String orderSn = SnCodeUtils.createSn();
        order.setOrderNo(orderSn);
        order.setCardType(card.getType());
        boolean result = true;
        if (card.getType() == 2) {//旅游卡
            card.setStatus(StatusEnum.SHOW.getStatus().toString());//激活
            result = cardService.updateById(card);
        }
        if (result) {
            this.save(order);
        }

        return order.getOrderId();
    }

    @Override
    public Boolean addOrderContact(OrderMemberVo orderVo) {
        String travelers = orderVo.getTravelerList();
        List<Contacts> array = JSONArray.parseArray(travelers, Contacts.class);
        String travelName = "";
        String travelIds = "";
        for (Contacts item : array) {
            Contacts contacts = new Contacts();
            contacts.setContactName(item.getContactName());
            contacts.setMemberId(orderVo.getMemberId());
            List<Contacts> list = contactsService.queryList(contacts);
            if (CollectionUtils.isEmpty(list)) {
                contactsService.save(item);
            } else {
                item.setId(list.get(0).getId());
                contactsService.updateById(item);
            }
            travelName += item.getContactName() + ",";
            travelIds += item.getId() + ",";
        }
        Order order = this.getById(orderVo.getOrderId());
        order.setTravelers(travelName.substring(0, travelName.length() - 1));
        order.setTravelerIds(travelIds.substring(0, travelIds.length() - 1));
        boolean result = this.updateById(order);
        return result;
    }

    @Override
    public String getQrCode(Long orderId) {
        Order order = this.getById(orderId);
        Agent agent = agentService.getById(order.getAgentId());
        return agent.getQrCode();
    }

    @Override
    public Boolean subTrip(OrderTravelVo orderVo) {
        Order order = new Order();
        order.setOrderId(orderVo.getOrderId());
        order.setTravelDetail(orderVo.getTravelDetail());
        return this.updateById(order);
    }

    @Override
    public OrderDetailVo getOrderDetail(Long orderId) {
        OrderDetailVo vo = baseMapper.getOrderDetail(orderId);
        String travelerIds = vo.getTravelerIds();
        if (StringUtils.isNotBlank(travelerIds)) {
            List<String> ids = Arrays.asList(travelerIds.split(","));
            List<Contacts> contactsList = iContactsService.list(new QueryWrapper<Contacts>().in("id", ids));
            vo.setContactsList(contactsList);
        }
        return vo;
    }

    @Override
    public Map getOrderStatusNum(Long memberId) {
        Order order = new Order();
        order.setMemberId(memberId);
        List<Order> list = queryList(order);
        int waitNum=0;
        int hasTravel=0;
        int finishOrCancelNum=0;
        Map map = new HashMap();
        if (!CollectionUtils.isEmpty(list)) {
            List<Order> wait = list.stream().filter(item -> item.getStatus() == 0).collect(Collectors.toList());
            List<Order> has = list.stream().filter(item -> item.getStatus() == 1).collect(Collectors.toList());

            //待出行数量
            waitNum = wait.size();
            //出行中数量
            hasTravel = has.size();
            //完成和取消数量
            finishOrCancelNum = list.size() - waitNum - hasTravel;
        }
        map.put("waitNum",waitNum);
        map.put("hasTravel",hasTravel);
        map.put("finishOrCancelNum",finishOrCancelNum);
        return map;
    }

    public List<OmsOrderDto> queryOrderList(SystemOrderDto order) {
        List<OmsOrderDto> orderList = baseMapper.queryPageList(order);
        return orderList;
    }

    @Override
    public Map getAgentOrderStatusNum(Long agentId) {
        List<Long> agentIds = agentService.getIds(agentId);
        Order order = new Order();
        order.setAgentIds(agentIds);
        List<Order> list = queryList(order);
        int waitNum=0;
        int hasTravel=0;
        int finishNum=0;
        int cancelNum=0;
        Map map = new HashMap();
        if (!CollectionUtils.isEmpty(list)) {
            List<Order> wait = list.stream().filter(item -> item.getStatus() == 0).collect(Collectors.toList());
            List<Order> has = list.stream().filter(item -> item.getStatus() == 1).collect(Collectors.toList());
            List<Order> finish = list.stream().filter(item -> item.getStatus() == 3).collect(Collectors.toList());
            List<Order> cancel = list.stream().filter(item -> item.getStatus() == -1).collect(Collectors.toList());
            //待出行数量
            waitNum = wait.size();
            //出行中数量
            hasTravel = has.size();
            //完成和取消数量
            finishNum = finish.size();
            cancelNum = cancel.size();
        }
        map.put("waitNum",waitNum);
        map.put("hasTravel",hasTravel);
        map.put("finishNum",finishNum);
        map.put("cancelNum",cancelNum);

        return map;
    }
}