sourcecode/server/gateway-api/src/main/java/com/qxgmat/service/extend/OrderFlowService.java

package com.qxgmat.service.extend;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.nuliji.tools.Tools;
import com.nuliji.tools.Transform;
import com.nuliji.tools.exception.ParameterException;
import com.qxgmat.data.constants.enums.ServiceKey;
import com.qxgmat.data.constants.enums.ServiceVipKey;
import com.qxgmat.data.constants.enums.module.CourseModule;
import com.qxgmat.data.constants.enums.module.ProductType;
import com.qxgmat.data.constants.enums.trade.PayChannel;
import com.qxgmat.data.constants.enums.trade.PayMethod;
import com.qxgmat.data.constants.enums.trade.PayModule;
import com.qxgmat.data.constants.enums.trade.RecordSource;
import com.qxgmat.data.dao.entity.*;
import com.qxgmat.service.UserServiceService;
import com.qxgmat.service.UsersService;
import com.qxgmat.service.annotation.*;
import com.qxgmat.service.inline.*;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

@Service
public class OrderFlowService {
    @Resource
    private ToolsService toolsService;

    @Resource
    private CourseService courseService;

    @Resource
    private CourseExtendService courseExtendService;

    @Resource
    private CoursePackageService coursePackageService;

    @Resource
    private CourseDataService courseDataService;

    @Resource
    private UserCourseService userCourseService;

    @Resource
    private UserServiceService userServiceService;

    @Resource
    private UserOrderService userOrderService;

    @Resource
    private UserOrderCheckoutService userOrderCheckoutService;

    @Resource
    private UserOrderRecordService userOrderRecordService;

    @Resource
    private UsersService usersService;

    @Resource
    private ExaminationService examinationService;

    @Resource
    private MessageExtendService messageExtendService;

    @Resource
    private TextbookService textbookService;

    private TradeService tradeService;

    @Resource
    private void registerTrade(TradeService tradeService) {
        this.tradeService = tradeService;
        this.tradeService.register(PayModule.ORDER, (obj)->{
            Pay pay = (Pay)obj;
            Integer userId = pay.getUserId();
            Integer orderId = pay.getModuleExtend();
            return this.payed(orderId, userId, pay.getId(), pay.getPayTime(), PayMethod.FromChannel(PayChannel.ValueOf(pay.getChannel())), pay.getTransactionNo());
        });
    }

    private Map<ProductType, InitCheckout> initCheckoutCallback = new HashMap<>();

    private Map<ProductType, ChangeCheckout> changeCheckoutCallback = new HashMap<>();

    private Map<ProductType, RemoveCheckout> removeCheckoutCallback = new HashMap<>();

    private Map<ProductType, InitOrder> initOrderCallback = new HashMap<>();

    private Map<ProductType, InitRecord> initRecordCallback = new HashMap<>();

    private Map<ProductType, UseRecord> useRecordCallback = new HashMap<>();

    private Map<ProductType, StopRecord> stopRecordCallback = new HashMap<>();

    public OrderFlowService(){
        initCheckoutCallback.put(ProductType.COURSE, ((checkout, userOrderCheckoutList) -> {
            // 判断课程是否已经存在
            UserOrderCheckout tmp=null;
            for(UserOrderCheckout in: userOrderCheckoutList){
                if (!in.getProductType().equals(ProductType.COURSE.key)) continue;
                if (in.getProductId().equals(checkout.getProductId())){
                    tmp = in;
                    break;
                }
            }
            Course mainCourse = courseService.get(checkout.getProductId());

            // 判断是否是1v1课程
            if (mainCourse.getCourseModule().equals(CourseModule.VS.key)){
                if (tmp != null){
                    // 累加课时
                    checkout.setId(tmp.getId());
                    checkout.setNumber(tmp.getNumber() + checkout.getNumber());
                }
                checkout.setOriginMoney(mainCourse.getPrice().multiply(BigDecimal.valueOf(checkout.getNumber())));
                int percent = toolsService.computeVsMoney(checkout);
                checkout.setMoney(checkout.getOriginMoney().multiply(BigDecimal.valueOf(percent)).divide(BigDecimal.valueOf(100), BigDecimal.ROUND_HALF_UP));

                // 设定有效期
                checkout.setExpireDays(mainCourse.getExpireDays());
                checkout.setUseExpireDays(courseExtendService.computeExpire(checkout.getNumber(), mainCourse));
                return checkout;
            }else{
                // 课程已添加，无需添加
                if(tmp != null){
                    return null;
                }
                // 设定有效期信息
                checkout.setExpireDays(mainCourse.getExpireDays());
                checkout.setUseExpireDays(courseExtendService.computeExpire(mainCourse));
            }

            // 填充金额
            checkout.setMoney(mainCourse.getPrice());
            checkout.setOriginMoney(mainCourse.getPrice());

            // 先加入列表，统一处理
            userOrderCheckoutList.add(checkout);
            // 判断是否符合套餐情况: 剩余的独立课程
            List<UserOrderCheckout> courseCheckout = userOrderCheckoutList.stream().filter((in)-> in.getProductType().equals(ProductType.COURSE.key) && in.getParentId() == 0).collect(Collectors.toList());
            Collection courseIds = Transform.getIds(courseCheckout, UserOrderCheckout.class, "productId");
            CoursePackage coursePackage = coursePackageService.combineCourse(courseIds);
            if(coursePackage != null){
                List<Course> courseList = courseService.select(coursePackage.getCourseIds());
                BigDecimal originMoney = BigDecimal.valueOf(0);
                for(Course course : courseList){
                    originMoney = originMoney.add(course.getPrice());
                }
                // 加入套餐： 无需进入course_package的初始化流程
                UserOrderCheckout packageCheckout = UserOrderCheckout.builder()
                        .productType(ProductType.COURSE_PACKAGE.key)
                        .productId(coursePackage.getId())
                        .money(coursePackage.getPrice())
                        .originMoney(originMoney)
                        .build();
                packageCheckout = userOrderCheckoutService.add(packageCheckout);
                // 绑定所属
                List<Integer> ids = Arrays.stream(coursePackage.getCourseIds()).collect(Collectors.toList());
                for(UserOrderCheckout c:courseCheckout){
                    if (ids.contains(c.getProductId())){
                        if (c.getId() !=null && c.getId() > 0){
                            userOrderCheckoutService.edit(UserOrderCheckout.builder()
                                    .id(c.getId())
                                    .parentId(packageCheckout.getId())
                                    .build());
                        }else{
                            c.setParentId(packageCheckout.getId());
                            userOrderCheckoutService.add(c);
                        }
                    }
                }

                return null;
            }
            // 正常添加
            return checkout;
        }));
        initCheckoutCallback.put(ProductType.COURSE_PACKAGE, ((checkout, userOrderCheckoutList)->{
            for(UserOrderCheckout in: userOrderCheckoutList){
                if (!in.getProductType().equals(ProductType.COURSE_PACKAGE.key)) continue;
                if (in.getProductId().equals(checkout.getProductId())) return null;
            }
            CoursePackage coursePackage = coursePackageService.get(checkout.getProductId());
            List<Course> courseList = courseService.select(coursePackage.getCourseIds());
            Map<Integer, Course> courseMap = new HashMap<>();
            for(Course course : courseList){
                courseMap.put(course.getId(), course);
            }
            BigDecimal originMoney = BigDecimal.valueOf(0);
            for(Course course : courseList){
                originMoney = originMoney.add(course.getPrice());
            }
            checkout.setMoney(coursePackage.getPrice());
            checkout.setOriginMoney(originMoney);
            checkout = userOrderCheckoutService.add(checkout);

            // 转移课程包含的独立课程
            List<Integer> ids = Arrays.stream(coursePackage.getCourseIds()).collect(Collectors.toList());
            List<UserOrderCheckout> courseCheckout = userOrderCheckoutList.stream().filter((in)-> in.getProductType().equals(ProductType.COURSE.key) && in.getParentId() == 0).collect(Collectors.toList());
            for(UserOrderCheckout in : courseCheckout){
                if (ids.contains(in.getProductId())){
                    in.setParentId(checkout.getId());
                    // 转移该购物车记录
                    userOrderCheckoutService.edit(UserOrderCheckout.builder()
                            .id(in.getId())
                            .parentId(checkout.getId())
                            .build());
                    ids.remove(in.getProductId());
                }
            }
            // 添加还未添加的课程记录
            for(Integer id : ids){
                UserOrderCheckout tmp = UserOrderCheckout.builder()
                        .parentId(checkout.getId())
                        .productType(ProductType.COURSE.key)
                        .productId(id)
                        .build();
                // 获取有效期和金额
                initCheckoutCallback.get(ProductType.COURSE).callback(tmp, userOrderCheckoutList);
                userOrderCheckoutService.add(tmp);
            }
            return null;
        }));
        initCheckoutCallback.put(ProductType.DATA, ((checkout, userOrderCheckoutList)->{
            for(UserOrderCheckout in: userOrderCheckoutList){
                if (!in.getProductType().equals(ProductType.DATA.key)) continue;
                if (in.getProductId().equals(checkout.getProductId())) return null;
            }
            CourseData courseData = courseDataService.get(checkout.getProductId());
            checkout.setMoney(courseData.getPrice());
            checkout.setOriginMoney(courseData.getPrice());
            return checkout;
        }));
        initCheckoutCallback.put(ProductType.SERVICE, ((checkout, userOrderCheckoutList)->{
            for(UserOrderCheckout in: userOrderCheckoutList){
                if (!in.getProductType().equals(ProductType.SERVICE.key)) continue;
                if (in.getService().equals(checkout.getService())){
                    checkout.setId(in.getId());
                    break;
                }
            }
            BigDecimal money = BigDecimal.valueOf(toolsService.getServicePrice(checkout.getService(), checkout.getParam()));
            checkout.setOriginMoney(money);
            ServiceKey serviceKey = ServiceKey.ValueOf(checkout.getService());

            Integer useExpireDay = serviceKey.useExpireDay;
            Integer expireDay = serviceKey.expireDay;
            if(serviceKey == ServiceKey.VIP){
                ServiceVipKey vipKey = ServiceVipKey.ValueOf(checkout.getParam());
                useExpireDay = vipKey.useExpireDay;
            }
            checkout.setExpireDays(expireDay);
            checkout.setUseExpireDays(useExpireDay);

            if (serviceKey == ServiceKey.TEXTBOOK){
                // 是否存在半价机经券
                User user = usersService.get(checkout.getUserId());
                checkout.setMoney(user.getTextbookHalf() > 0 ? money.divide(BigDecimal.valueOf(2), BigDecimal.ROUND_HALF_UP):money);
            }else{
                checkout.setMoney(money);
            }
            return checkout;
        }));

        changeCheckoutCallback.put(ProductType.COURSE, ((originCheckout, checkout)->{
            Course mainCourse = courseService.get(originCheckout.getProductId());

            // 判断是否是1v1课程
            if (mainCourse.getCourseModule().equals(CourseModule.VS.key)){
                checkout.setOriginMoney(mainCourse.getPrice().multiply(BigDecimal.valueOf(checkout.getNumber())));
                int percent = toolsService.computeVsMoney(checkout);
                checkout.setMoney(checkout.getOriginMoney().multiply(BigDecimal.valueOf(percent)).divide(BigDecimal.valueOf(100), BigDecimal.ROUND_HALF_UP));

                // 设定有效期
                checkout.setExpireDays(mainCourse.getExpireDays());
                checkout.setUseExpireDays(courseExtendService.computeExpire(checkout.getNumber(), mainCourse));
                return checkout;
            }else{
                // 无法修改
                throw new ParameterException("记录无法修改");
            }
        }));

        removeCheckoutCallback.put(ProductType.COURSE, ((checkout, userOrderCheckoutList)->{
            // 子项目不允许参数，则无需处理
        }));
        removeCheckoutCallback.put(ProductType.COURSE_PACKAGE, ((checkout, userOrderCheckoutList)->{
            // 删除对应子项目
        }));
        removeCheckoutCallback.put(ProductType.DATA, ((checkout, userOrderCheckoutList)->{
            // miss
        }));
        removeCheckoutCallback.put(ProductType.SERVICE, ((checkout, userOrderCheckoutList)->{
            // miss
        }));

        initOrderCallback.put(ProductType.SERVICE, ((order, userOrderCheckoutList) -> {
            // 累计金额
            BigDecimal money = order.getMoney();
            BigDecimal originMoney = order.getOriginMoney();
            for(UserOrderCheckout checkout:userOrderCheckoutList){
                ServiceKey serviceKey = ServiceKey.ValueOf(checkout.getService());

                if (serviceKey == ServiceKey.TEXTBOOK){
                    // 是否存在半价机经券
                    if (!checkout.getMoney().equals(checkout.getOriginMoney())){
                        JSONObject info = new JSONObject();
                        info.put("originMoney", originMoney);
                        info.put("money", money);
                        info.put("key", "textbook-half");
                        info.put("message", "半价机经券");
                        JSONArray promote = order.getPromote();
                        promote.add(info);
                    }
                }
                money = money.add(checkout.getMoney());
                originMoney = originMoney.add(checkout.getMoney());
            }
            order.setMoney(money);
            order.setOriginMoney(originMoney);
        }));
        initOrderCallback.put(ProductType.DATA, ((order, userOrderCheckoutList) -> {
            // 累计金额
            BigDecimal money = order.getMoney();
            BigDecimal originMoney = order.getOriginMoney();
            for(UserOrderCheckout checkout:userOrderCheckoutList){
                money = money.add(checkout.getMoney());
                originMoney = originMoney.add(checkout.getMoney());
            }
            order.setMoney(money);
            order.setOriginMoney(originMoney);
        }));
        initOrderCallback.put(ProductType.COURSE, ((order, userOrderCheckoutList) -> {
            BigDecimal money = order.getMoney();
            BigDecimal originMoney = order.getOriginMoney();
            Integer vsNumber = 0;

            // 独立课程信息: 排除套餐内的
            List<UserOrderCheckout> courseCheckout = userOrderCheckoutList.stream().filter((checkout)-> checkout.getProductType().equals(ProductType.COURSE.key) && checkout.getParentId() == 0).collect(Collectors.toList());
            Collection courseIds = Transform.getIds(courseCheckout, UserOrderCheckout.class, "productId");
            List<Course> courseList = courseService.select(courseIds);
            Map<Integer, Course> courseMap = new HashMap<>();
            for(Course course : courseList){
                courseMap.put(course.getId(), course);
            }
            BigDecimal courseMoney = BigDecimal.valueOf(0);

            // 视频课程优惠
            List<UserOrderCheckout> videoCheckout = courseCheckout.stream().filter((checkout)-> courseMap.get(checkout.getProductId()).getCourseModule().equals(CourseModule.VIDEO.key)).collect(Collectors.toList());
            BigDecimal videoMoney = BigDecimal.valueOf(0);
            BigDecimal videoOriginMoney = BigDecimal.valueOf(0);
            for(UserOrderCheckout checkout : videoCheckout){
                videoMoney = videoMoney.add(checkout.getMoney());
                videoOriginMoney = videoOriginMoney.add(checkout.getOriginMoney());
            }
            int percent = toolsService.computeVideoMoney(courseCheckout);
            if (percent < 100){
                BigDecimal promoteVideoMoney = videoMoney.multiply(BigDecimal.valueOf(percent)).divide(BigDecimal.valueOf(100), BigDecimal.ROUND_HALF_UP);
                courseMoney = courseMoney.add(promoteVideoMoney);
                money = money.add(promoteVideoMoney);

                // 添加视频优惠记录
                JSONObject info = new JSONObject();
                info.put("originMoney", videoMoney);
                info.put("money", promoteVideoMoney);
                info.put("message", toolsService.videoMoneyMessage());
                info.put("key", "video");
                JSONArray promote = order.getPromote();
                promote.add(info);
            }else{
                courseMoney = courseMoney.add(videoMoney);
                money = money.add(videoMoney);
            }
            originMoney = originMoney.add(videoOriginMoney);

            BigDecimal vsMoney = BigDecimal.valueOf(0);
            // 1v1课程优惠: 添加时计算
            List<UserOrderCheckout> vsCheckout = courseCheckout.stream().filter((checkout)-> courseMap.get(checkout.getProductId()).getCourseModule().equals(CourseModule.VS.key)).collect(Collectors.toList());
            for(UserOrderCheckout checkout: vsCheckout){
                vsMoney  = vsMoney.add(checkout.getMoney());
                money = money.add(checkout.getMoney());
                originMoney = originMoney.add(checkout.getOriginMoney());
                vsNumber += checkout.getNumber();

                if(!money.equals(originMoney)){
                    // 添加1v1优惠记录
                    JSONObject info = new JSONObject();
                    info.put("originMoney", originMoney);
                    info.put("money", money);
                    info.put("message", toolsService.vsMoneyMessage());
                    info.put("key", "vs");
                    JSONArray promote = order.getPromote();
                    promote.add(info);
                }
            }

            // 套餐费用: 添加时计算
            List<UserOrderCheckout> packageCheckout = userOrderCheckoutList.stream().filter((checkout)-> checkout.getProductType().equals(ProductType.COURSE_PACKAGE.key)).collect(Collectors.toList());
            for(UserOrderCheckout checkout : packageCheckout){
                courseMoney = courseMoney.add(checkout.getMoney());
                money = money.add(checkout.getMoney());
                originMoney = originMoney.add(checkout.getOriginMoney());
                // 套餐优惠记录 - 不参与总价，单独展示逻辑
            }

            // 满金额处理
            // 回复时长: 总金额
            JSONObject askInfo = toolsService.getAskTime(courseMoney.add(vsMoney));
            if(askInfo != null) order.setAskTime(askInfo.getIntValue("hour") * 3600);

            // 1v1辅导：视频课程金额
            JSONObject vsVideoMoney = toolsService.getVsVideoMoney(courseMoney);

            // 满课时处理：vs课时
            JSONObject vsVsNumber = toolsService.getVsVsNumber(vsNumber);

            JSONArray gift = order.getGift();
            if (askInfo!=null && askInfo.getIntValue("money") > 0){
                // 因为存在默认最低值，金额超过限额，才写入赠送
                JSONObject info = new JSONObject();
                info.put("key", "ask");
                info.put("money", askInfo.getIntValue("money"));
                info.put("hour", askInfo.getIntValue("hour"));
                info.put("message", toolsService.askTimeMessage().replace("{}", askInfo.getInteger("hour").toString()));
                gift.add(info);
            }
            // vsVsNumber与vsVideoMoney
            if(vsVsNumber != null){
                JSONObject info = new JSONObject();
                info.put("key", "vs");
                info.put("from", "vsNumber");
                info.put("number", vsVsNumber.getIntValue("number"));
                info.put("value", vsVsNumber.getIntValue("value"));
                info.put("message", toolsService.vsVsNumberMessage().replace("{}", vsVsNumber.getInteger("value").toString()));
                gift.add(info);
            }else if (vsVideoMoney != null){
                JSONObject info = new JSONObject();
                info.put("key", "vs");
                info.put("from", "videoMoney");
                info.put("money", vsVideoMoney.getIntValue("money"));
                info.put("value", vsVideoMoney.getIntValue("value"));
                info.put("message", toolsService.vsVideoMoneyMessage().replace("{}", vsVideoMoney.getInteger("value").toString()));
                gift.add(info);
            }

            order.setMoney(money);
            order.setOriginMoney(originMoney);
            // 课程金额进行开票处理
            order.setInvoiceMoney(courseMoney.add(vsMoney));
        }));

        initRecordCallback.put(ProductType.COURSE, ((order, record) -> {
            Course course = courseService.get(record.getProductId());

            // 记录销售数量
            courseService.accumulation(course.getId(), 0, record.getParentId() == null || record.getProductId() ==0 ? 1:0, record.getParentId() != null && record.getProductId() != 0 ? 1:0);

            CourseModule courseModule = CourseModule.ValueOf(course.getCourseModule());
            // 小班课程不会存在记录，在线视频和1v1授课都有有效期
            Date startTime = new Date();
            Date endTime = Tools.addDate(startTime, record.getExpireDays());
            record.setStartTime(startTime);
            record.setEndTime(endTime);
            // 绑定订单的回复时长
            record.setAskTime(order.getAskTime());
            // 计算vs课程编号
            if (courseModule == CourseModule.VS){
                Integer no = userOrderRecordService.maxVsNo(order.getUserId());
                record.setVsNo(no+1);
            }
            return record;
        }));
        initRecordCallback.put(ProductType.COURSE_PACKAGE, ((order, record)->{
            // 资料无需开启，也没有有效期
            record.setIsUsed(1);
            Date time = new Date();
            record.setUseTime(time);
            // 处理套餐赠送
            CoursePackage coursePackage = coursePackageService.get(record.getProductId());

            // 记录销售数量
            coursePackageService.accumulation(coursePackage.getId(), 1);

            InitRecord callback = initRecordCallback.get(ProductType.SERVICE);
            JSONObject gift = coursePackage.getGift();
            Integer qxCat = gift.getInteger(ServiceKey.QX_CAT.key);
            if (qxCat != null && qxCat > 0){
                // 添加cat
                UserOrderRecord giftRecord = UserOrderRecord.builder()
                        .orderId(order.getId())
                        .userId(order.getUserId())
                        .productType(ProductType.SERVICE.key)
                        .service(ServiceKey.QX_CAT.key)
                        .source(RecordSource.GIFT_COURSE.key)
                        .build();
                callback.callback(order, giftRecord);
                userOrderRecordService.add(giftRecord);
            }
            Integer textbook = gift.getInteger(ServiceKey.TEXTBOOK.key);
            if (textbook != null && textbook > 0){
                // 添加text
                UserOrderRecord giftRecord = UserOrderRecord.builder()
                        .orderId(order.getId())
                        .userId(order.getUserId())
                        .productType(ProductType.SERVICE.key)
                        .service(ServiceKey.TEXTBOOK.key)
                        .source(RecordSource.GIFT_COURSE.key)
                        .build();
                callback.callback(order, giftRecord);
                userOrderRecordService.add(giftRecord);
            }
            String vip = gift.getString(ServiceKey.VIP.key);
            ServiceVipKey vipKey = ServiceVipKey.ValueOf(vip);
            if (vipKey != null){
                // 添加vip，并开通
                UserOrderRecord giftRecord = UserOrderRecord.builder()
                        .orderId(order.getId())
                        .userId(order.getUserId())
                        .productType(ProductType.SERVICE.key)
                        .service(ServiceKey.VIP.key)
                        .param(vipKey.key)
                        .source(RecordSource.GIFT_COURSE.key)
                        .build();
                callback.callback(order, giftRecord);
                userOrderRecordService.add(giftRecord);
            }
            return record;
        }));
        initRecordCallback.put(ProductType.DATA, ((order, record)->{
            // 资料无需开启，也没有有效期
            record.setIsUsed(1);
            record.setIsSubscribe(1);
            Date time = new Date();
            record.setUseTime(time);

            // 记录销售数量
            courseDataService.accumulation(record.getProductId(), 1, 0);
            return record;
        }));
        initRecordCallback.put(ProductType.SERVICE, ((order, record)->{
            if(record.getService().equals(ServiceKey.VIP.key)){
                // VIP直接开通
                record = useRecordCallback.get(ProductType.SERVICE).callback(record);
                record.setProductType(ProductType.SERVICE.key);
            }else{
                ServiceKey serviceKey = ServiceKey.ValueOf(record.getService());
                Date startTime = new Date();
                Date endTime = Tools.addMonth(startTime, record.getExpireDays());
                record.setStartTime(startTime);
                record.setEndTime(endTime);
                // 如果使用半价优惠券，则扣除
                if (serviceKey == ServiceKey.TEXTBOOK){
                    User user = usersService.get(record.getUserId());
                    if (user.getTextbookHalf() == 0) {
                        // todo 支付存在问题
                    }
                    usersService.edit(User.builder().id(user.getId()).textbookHalf(user.getTextbookHalf() - 1).build());
                }
            }
            return record;
        }));

        useRecordCallback.put(ProductType.COURSE, (record->{
            record.setIsUsed(1);
            Date time = new Date();
            record.setUseTime(time);

            Course course = courseService.get(record.getProductId());
            Integer expireDay = record.getUseExpireDays();
            if (course.getCourseModule().equals(CourseModule.ONLINE.key)){
                // 小班课程，无需更新有效时间
                return record;
            }
            Date startTime = time;
            Date endTime = null;
            if(expireDay > 0){
                // 设置结束有效期
                endTime = Tools.addDate(startTime, expireDay);
            }
            if (course.getCourseModule().equals(CourseModule.VIDEO.key)){
                UserCourse userCourse = userCourseService.getCourseBase(record.getUserId(), record.getProductId());
                if(userCourse == null){
                    userCourse = UserCourse.builder()
                            .userId(record.getUserId())
                            .courseId(course.getId())
                            .recordId(record.getId())
                            .startTime(startTime)
                            .expireTime(endTime)
                            .build();
                    userCourse = userCourseService.add(userCourse);
                }else{
                    if (userCourse.getExpireTime().before(time)){
                        // 已到期 - 续期
                        userCourse.setStartTime(startTime);
                        userCourse.setExpireTime(endTime);
                        userCourse.setRecordId(record.getId());
                    }else{
                        // 未到期 - 报错
                        throw new ParameterException("已开通当前课程");
                    }
                    userCourse = userCourseService.edit(userCourse);
                }
            }

            record.setUseStartTime(startTime);
            if (endTime!=null )record.setUseEndTime(endTime);
            return record;
        }));
        useRecordCallback.put(ProductType.COURSE_PACKAGE, (record->{
            // miss
            throw new ParameterException("套餐无需开通");
        }));
        useRecordCallback.put(ProductType.DATA, (record->{
            // miss
            throw new ParameterException("资料无需开通");
        }));
        useRecordCallback.put(ProductType.SERVICE, (record->{
            record.setIsUsed(1);
            Date time = new Date();
            record.setUseTime(time);

            ServiceKey serviceKey = ServiceKey.ValueOf(record.getService());
            Integer expireDay = record.getUseExpireDays();

            Date startTime = time;
            Date endTime = null;
            if(expireDay > 0){
                // 设置结束有效期
                endTime = Tools.addDate(startTime, expireDay);
            }
            UserService userService = userServiceService.getServiceBase(record.getUserId(), serviceKey);
            if (userService == null){
                userService = UserService.builder()
                        .userId(record.getUserId())
                        .service(serviceKey.key)
                        .isSubscribe(record.getIsSubscribe())
                        .isReset(0)
                        .startTime(startTime)
                        .expireTime(endTime)
                        .build();
                userService = userServiceService.add(userService);
            }else{
                if (serviceKey == ServiceKey.QX_CAT){
                    // cat逻辑独立
                    if (userService.getExpireTime().after(time)){
                        // 有效期内
                        if (userService.getIsReset() == 0) throw new ParameterException("已开通当前服务");
                        // 第二次还未做完
                        if (userService.getIsReset() == 1 && examinationService.isFinishCat(record.getUserId()))  throw new ParameterException("已开通当前服务");
                    }
                    // 重置
                    examinationService.resetCat(record.getUserId(), true);
                    userService.setIsReset(0);
                }else if (userService.getExpireTime() != null && userService.getExpireTime().before(time)){
                    // 已到期 - 续期
                    userService.setStartTime(startTime);
                    userService.setExpireTime(endTime);
                }else{
                    // 未到期 - 延长有效期
                    startTime = userService.getExpireTime();
                    if (expireDay > 0){
                        endTime = Tools.addDate(userService.getExpireTime(), expireDay);
                        userService.setExpireTime(endTime);
                    }
                }
                userService.setIsSubscribe(record.getIsSubscribe());
                userService = userServiceService.edit(userService);
            }
            if (serviceKey == ServiceKey.TEXTBOOK){
                // 自动报名: 使用机经的后10天所在月份
                textbookService.enroll(record.getUserId(), Tools.addDate(new Date(), 10));
            }

            record.setUseStartTime(startTime);
            if (endTime!=null )record.setUseEndTime(endTime);
            return record;
        }));

        stopRecordCallback.put(ProductType.COURSE, (record->{
            record.setIsStop(1);
            if (record.getIsUsed() == 0) return record;
            if (record.getUseEndTime().before(new Date())) return record;

            UserCourse userCourse = userCourseService.getCourseBase(record.getUserId(), record.getProductId());
            if(userCourse != null){
                userCourse.setExpireTime(new Date());
                userCourse = userCourseService.edit(userCourse);
            }
            return record;
        }));
        stopRecordCallback.put(ProductType.COURSE_PACKAGE, (record->{
            // miss
            throw new ParameterException("套餐无需停用");
        }));
        stopRecordCallback.put(ProductType.DATA, (record->{
            // 停用后无法查看
            record.setIsStop(1);
            return record;
        }));
        stopRecordCallback.put(ProductType.SERVICE, (record->{
            record.setIsStop(1);
            if (record.getIsUsed() == 0) return record;
            if (record.getUseEndTime().before(new Date())) return record;

            ServiceKey serviceKey = ServiceKey.ValueOf(record.getService());

            UserService userService = userServiceService.getServiceBase(record.getUserId(), serviceKey);
            if (userService != null){
                userService.setExpireTime(new Date());
                userService = userServiceService.edit(userService);
            }
            return record;
        }));
    }

    /**
     * 完成订单支付
     * @param orderId
     * @param userId
     * @param payTime
     * @param payMethod
     * @return
     */
    @Transactional
    public boolean payed(Integer orderId, Integer userId, Long payId, Date payTime, PayMethod payMethod, String transactionNo){
        UserOrder userOrder = userOrderService.get(orderId);
        if (userOrder == null) return false;
        if (userOrder.getPayStatus() > 0) return false;
        userOrderService.edit(UserOrder.builder()
                .id(userOrder.getId())
                .payId(payId)
                .payMethod(payMethod.key)
                .payTime(payTime)
                .transactionNo(transactionNo)
                .payStatus(1)
                .build());
        userOrder.setPayId(payId);
        userOrder.setPayMethod(payMethod.key);
        userOrder.setPayTime(payTime);
        userOrder.setTransactionNo(transactionNo);
        userOrder.setPayStatus(1);
        // 转换购物车记录为购买记录
        List<UserOrderCheckout> checkoutList = userOrderCheckoutService.allByUser(userId, orderId);
        List<UserOrderCheckout> pList = checkoutList.stream().filter((checkout)-> checkout.getParentId() == 0).collect(Collectors.toList());
        List<UserOrderCheckout> cList = checkoutList.stream().filter((checkout)-> checkout.getParentId() > 0).collect(Collectors.toList());
        Map<Integer, Integer> pMap = new HashMap<>();
        for(UserOrderCheckout checkout : pList){
            UserOrderRecord record = Transform.convert(checkout, UserOrderRecord.class);
            record.setSource(RecordSource.FromPayModule(payMethod).key);
            InitRecord callback = initRecordCallback.get(ProductType.ValueOf(record.getProductType()));
            callback.callback(userOrder, record);
            record = userOrderRecordService.add(record);
            // 建立新旧id关系
            pMap.put(checkout.getId(), record.getId());
        }

        for(UserOrderCheckout checkout : cList){
            UserOrderRecord record = Transform.convert(checkout, UserOrderRecord.class);
            // 记录parentid
            record.setParentId(pMap.get(checkout.getParentId()));
            record.setSource(RecordSource.FromPayModule(payMethod).key);
            InitRecord callback = initRecordCallback.get(ProductType.ValueOf(record.getProductType()));
            callback.callback(userOrder, record);
            userOrderRecordService.add(record);
        }

        JSONArray gift = userOrder.getGift();
        if (gift != null){
            for(Object infoO : gift){
                JSONObject info = (JSONObject)infoO;
                if(info.get("key").equals("vs")){
                    // 添加赠送课时
                    Integer courseId = info.getInteger("courseId");
                    if(courseId != null){
                        UserOrderRecord record = UserOrderRecord.builder()
                                .orderId(userOrder.getId())
                                .userId(userOrder.getUserId())
                                // 赠品不出现在订单详细列表中
                                .parentId(Integer.MAX_VALUE)
                                .productType(ProductType.COURSE.key)
                                .productId(courseId)
                                .number(info.getIntValue("number"))
                                .source(RecordSource.GIFT_COURSE.key)
                                .build();

                        InitRecord callback = initRecordCallback.get(ProductType.ValueOf(record.getProductType()));
                        callback.callback(userOrder, record);
                        userOrderRecordService.add(record);
                    }
                }
            }
        }

        userOrderCheckoutService.deleteByUser(userId, orderId);

        // 累加用户支付信息
        usersService.accumulation(userOrder.getUserId(), userOrder.getMoney());

        // 发送通知
        User user = usersService.get(userId);
        if (user.getIsCourse() == 0 && userOrder.getProductTypes().contains(ProductType.COURSE.key)){
            // 设定标志
            usersService.edit(User.builder().id(userOrder.getUserId()).isCourse(1).build());
        }
        messageExtendService.sendPayed(user, userOrder);
        return true;
    }

    /**
     * 添加购物车
     * @param userId
     * @param checkout
     * @return
     */
    @Transactional
    public int addCheckout(Integer userId, UserOrderCheckout checkout){
        List<UserOrderCheckout> list = userOrderCheckoutService.allByUser(userId, 0);
        InitCheckout callback = initCheckoutCallback.get(ProductType.ValueOf(checkout.getProductType()));
        checkout = callback.callback(checkout, list);
        if (checkout == null) {
            // 无需操作
        }else if(checkout.getId() != null && checkout.getId() > 0){
            userOrderCheckoutService.edit(checkout);
        }else{
            userOrderCheckoutService.add(checkout);
        }

        // 计算购物车数量
        return userOrderCheckoutService.allByUser(userId, 0).size();
    }

    /**
     * 修改购物车
     * @param userId
     * @param checkout
     * @return
     */
    @Transactional
    public int changeCheckout(Integer userId, UserOrderCheckout checkout){
        UserOrderCheckout in = userOrderCheckoutService.get(checkout.getId());
        ChangeCheckout callback = changeCheckoutCallback.get(ProductType.ValueOf(in.getProductType()));
        if (callback == null){
            throw new ParameterException("无法修改记录");
        }
        checkout = callback.callback(in, checkout);
        if (checkout == null){
            // 无需操作
        }else{
            userOrderCheckoutService.edit(checkout);
        }

        // 计算购物车数量
        return userOrderCheckoutService.allByUser(userId, 0).size();
    }



    /**
     * 删除购物车
     * @param checkoutId
     * @param userId
     * @return
     */
    @Transactional
    public int removeCheckout(Integer checkoutId, Integer userId){
        UserOrderCheckout in = userOrderCheckoutService.get(checkoutId);
        if (in == null){
            throw new ParameterException("记录不存在");
        }
        if (!in.getUserId().equals(userId)){
            throw new ParameterException("记录不存在");
        }
        if (in.getParentId() != null && in.getParentId() > 0){
            // 如果能删除子项目，要处理删除父项目，转移其他子项目
            throw new ParameterException("套餐内，不允许单独删除");
        }
        userOrderCheckoutService.delete(checkoutId);

        List<UserOrderCheckout> list = userOrderCheckoutService.allByUser(userId, 0);
        // 删除子项目
        for(UserOrderCheckout checkout: list){
            if (checkout.getParentId()==null || checkout.getParentId() == 0) continue;
            if (checkout.getParentId().equals(in.getId())){
                userOrderCheckoutService.delete(checkout.getId());
            }
        }
        RemoveCheckout callback = removeCheckoutCallback.get(ProductType.ValueOf(in.getProductType()));
        callback.callback(in, list);

        // 计算购物车数量
        return userOrderCheckoutService.allByUser(userId, 0).size();
    }

    /**
     * 根据购物车生成对应订单信息
     * @param list
     * @return
     */
    public UserOrder preOrderWithCheckout(Integer userId, List<UserOrderCheckout> list){
        UserOrder order = UserOrder.builder()
                .userId(userId)
                .originMoney(BigDecimal.valueOf(0))
                .money(BigDecimal.valueOf(0))
                .build();
        // 记录订单优惠
        JSONArray promote = new JSONArray();
        order.setPromote(promote);
        // 记录订单类型
        JSONArray productTypes = new JSONArray();
        order.setProductTypes(productTypes);
        // 记录赠品信息
        JSONArray gift = new JSONArray();
        order.setGift(gift);

        InitOrder callback;

        // 课程: 并包含套餐
        List<UserOrderCheckout> courseCheckout = list.stream().filter((checkout)-> checkout.getProductType().equals(ProductType.COURSE.key) || checkout.getProductType().equals(ProductType.COURSE_PACKAGE.key)).collect(Collectors.toList());

        if(courseCheckout.size() > 0){
            callback = initOrderCallback.get(ProductType.COURSE);
            callback.callback(order, courseCheckout);
            productTypes.add(ProductType.COURSE.key);
        }
        // 资料
        List<UserOrderCheckout> dataCheckout = list.stream().filter((checkout)-> checkout.getProductType().equals(ProductType.DATA.key)).collect(Collectors.toList());

        if (dataCheckout.size() > 0){
            callback = initOrderCallback.get(ProductType.DATA);
            callback.callback(order, dataCheckout);
            productTypes.add(ProductType.DATA.key);
        }
        // 服务
        List<UserOrderCheckout> serviceCheckout = list.stream().filter((checkout)-> checkout.getProductType().equals(ProductType.SERVICE.key)).collect(Collectors.toList());

        if(serviceCheckout.size() > 0){
            callback = initOrderCallback.get(ProductType.SERVICE);
            callback.callback(order, serviceCheckout);
            productTypes.add(ProductType.SERVICE.key);
        }

        return order;
    }

    /**
     * 支付购物车
     * @param userId
     * @return
     */
    @Transactional
    public UserOrder makeOrder(Integer userId, Integer courseId){
        List<UserOrderCheckout> list = userOrderCheckoutService.allByUser(userId, 0);
        UserOrder order = preOrderWithCheckout(userId, list);
        // 保存课程赠送选择: 付款后添加
        JSONArray gift = order.getGift();
        for(Object infoO:gift){
            JSONObject info = (JSONObject)infoO;
            if(info.getString("key").equals("vs")){
                info.put("courseId", courseId);
            }
        }
        order = userOrderService.add(order);

        // 转移购物车信息
        userOrderCheckoutService.changeByUser(userId, 0, UserOrderCheckout.builder().orderId(order.getId()).build());
        return order;
    }

    /**
     * 立即购买
     * @param userId
     * @param checkout
     * @return
     */
    @Transactional
    public UserOrder makeOrderWithSpeed(Integer userId, UserOrderCheckout checkout){
        List<UserOrderCheckout> list = new ArrayList<>();
        checkout.setUserId(userId);
        InitCheckout callback = initCheckoutCallback.get(ProductType.ValueOf(checkout.getProductType()));
        checkout = callback.callback(checkout, list);
        if (checkout == null){
            throw new ParameterException("创建失败");
        }
        list.add(checkout);

        UserOrder order = preOrderWithCheckout(userId, list);
        order.setIsSpeed(1);
        order = userOrderService.add(order);
        checkout.setOrderId(order.getId());
        if(checkout.getId() != null && checkout.getId() > 0){
            userOrderCheckoutService.edit(checkout);
        }else{
            userOrderCheckoutService.add(checkout);
        }
        return order;
    }

    /**
     * 后台直接添加记录
     * @param record
     * @return
     */
    @Transactional
    public UserOrderRecord addRecord(UserOrderRecord record){
        if (record.getExpireDays() == null) record.setExpireDays(0);
        if (record.getUseExpireDays() == null) record.setUseExpireDays(0);
        InitRecord callback = initRecordCallback.get(ProductType.ValueOf(record.getProductType()));
        // 虚拟order
        callback.callback(UserOrder.builder().build(), record);
        return userOrderRecordService.add(record);
    }

    /**
     * 开通记录
     * @param userId
     * @param recordId
     * @return
     */
    @Transactional
    public UserOrderRecord useRecord(Integer userId, Integer recordId){
        UserOrderRecord in = userOrderRecordService.get(recordId);
        if (in == null){
            throw new ParameterException("记录不存在");
        }
        if (!in.getUserId().equals(userId)){
            throw new ParameterException("记录不存在");
        }

        UseRecord callback = useRecordCallback.get(ProductType.ValueOf(in.getProductType()));
        callback.callback(in);
        return in;
    }

    public void stopRecord(Integer recordId){
        UserOrderRecord in = userOrderRecordService.get(recordId);
        if (in == null){
            throw new ParameterException("记录不存在");
        }
        if (in.getIsStop()> 0){
            throw new ParameterException("已停用");
        }

        UseRecord callback = useRecordCallback.get(ProductType.ValueOf(in.getProductType()));
        callback.callback(in);
    }

    /**
     * 给用户邀请奖励： 7天vip
     * @param userId
     */
    public void giveInvite(Integer userId){
        UserOrderRecord record = UserOrderRecord.builder()
                .userId(userId)
                .productType(ProductType.SERVICE.key)
                .service(ServiceKey.VIP.key)
                .param(ServiceVipKey.DAY7.key)
                .source(RecordSource.INVITE.key)
                .expireDays(0)
                .useExpireDays(ServiceVipKey.DAY7.useExpireDay)
                .build();
        // 虚拟order
        record = initRecordCallback.get(ProductType.SERVICE).callback(UserOrder.builder().build(), record);
        userOrderRecordService.add(record);
    }

    /**
     * 给用户备考奖励： 7天vip
     * @param userId
     */
    public void givePrepare(Integer userId){
        UserOrderRecord record = UserOrderRecord.builder()
                .userId(userId)
                .productType(ProductType.SERVICE.key)
                .service(ServiceKey.VIP.key)
                .param(ServiceVipKey.DAY7.key)
                .source(RecordSource.PREPARE.key)
                .expireDays(0)
                .useExpireDays(ServiceVipKey.DAY7.useExpireDay)
                .build();
        // 虚拟order
        record = initRecordCallback.get(ProductType.SERVICE).callback(UserOrder.builder().build(), record);
        userOrderRecordService.add(record);
    }

    /**
     * 给用户实名认证奖励: 180天vip
     * @param userId
     */
    public void giveReal(Integer userId){
        UserOrderRecord record = UserOrderRecord.builder()
                .userId(userId)
                .productType(ProductType.SERVICE.key)
                .service(ServiceKey.VIP.key)
                .param(ServiceVipKey.MONTH3.key)
                .source(RecordSource.REAL.key)
                .expireDays(0)
                .useExpireDays(ServiceVipKey.MONTH3.useExpireDay)
                .build();
        // 虚拟order
        record = initRecordCallback.get(ProductType.SERVICE).callback(UserOrder.builder().build(), record);
        userOrderRecordService.add(record);
    }

}