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;

    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, 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));
                return checkout;
            }else{
                // 课程已添加，无需添加
                if(tmp != null){
                    return null;
                }
            }

            // 填充金额
            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());
                }
                // 加入套餐
                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())){
                    // 转移该购物车记录
                    userOrderCheckoutService.edit(UserOrderCheckout.builder()
                            .id(in.getId())
                            .parentId(checkout.getId())
                            .build());
                    ids.remove(in.getProductId());
                }
            }
            // 添加还未添加的课程记录
            for(Integer id : ids){
                Course course = courseMap.get(id);
                userOrderCheckoutService.add(UserOrderCheckout.builder()
                        .parentId(checkout.getId())
                        .productType(ProductType.COURSE.key)
                        .productId(id)
                        .money(course.getPrice())
                        .originMoney(course.getPrice())
                        .build());
            }
            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());
            if (serviceKey == ServiceKey.TEXTBOOK){
                // 是否存在半价机经券
                User user = usersService.get(checkout.getId());
                checkout.setMoney(user.getTextbookHalf() > 0 ? money.divide(BigDecimal.valueOf(2), BigDecimal.ROUND_HALF_UP):money);
            }else{
                checkout.setMoney(money);
            }
            return checkout;
        }));

        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", "half");
                        JSONObject promote = order.getPromote();
                        promote.put("textbook", 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();

            // 独立课程信息: 排除套餐内的
            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);
            for(UserOrderCheckout checkout : videoCheckout){
                videoMoney = videoMoney.add(checkout.getMoney());
            }
            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());
                JSONObject promote = order.getPromote();
                promote.put("video", info);
            }else{
                courseMoney = courseMoney.add(videoMoney);
                money = money.add(videoMoney);
            }
            originMoney = originMoney.add(videoMoney);

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

            // 套餐费用: 添加时计算
            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.getMoney());
                // 套餐优惠记录 - 不参与总价，单独展示逻辑
            }

            // 满金额处理
            Integer ask = toolsService.getAskTime(courseMoney);
            order.setAskTime(ask * 3600);

            JSONArray gift = order.getGift();
            if (ask> 0){
                JSONObject info = new JSONObject();
                info.put("key", "ask");
                info.put("message", toolsService.askTimeMessage().replace("{}", ask.toString()));
                gift.add(info);
            }

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

        initRecordCallback.put(ProductType.COURSE, ((order, record) -> {
            Course course = courseService.get(record.getProductId());
            CourseModule courseModule = CourseModule.ValueOf(course.getCourseModule());
            // 小班课程不会存在记录，在线视频和1v1授课都有有效期
            Date startTime = new Date();
            Date endTime = Tools.addDate(startTime, courseModule.expireDay);
            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);
            return record;
        }));
        initRecordCallback.put(ProductType.DATA, ((order, record)->{
            // 资料无需开启，也没有有效期
            record.setIsUsed(1);
            Date time = new Date();
            record.setUseTime(time);
            return record;
        }));
        initRecordCallback.put(ProductType.SERVICE, ((order, record)->{
            if(record.getService().equals(ServiceKey.VIP.key)){
                // VIP直接开通
                record = useRecordCallback.get(ProductType.SERVICE).callback(record);
            }else{
                ServiceKey serviceKey = ServiceKey.ValueOf(record.getService());
                Date startTime = new Date();
                Date endTime = Tools.addMonth(startTime, serviceKey.expireDay);
                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 = 0;
            if (course.getCourseModule().equals(CourseModule.VS.key)){
                // 根据课时数进行计算
                expireDay = courseExtendService.computeExpire(record.getNumber(), course);
            }else{
                // 根据设置进行计算
                expireDay = courseExtendService.computeExpire(course);
            }
            Date startTime = time;
            Date endTime = Tools.addDate(startTime, expireDay);
            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);
            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 = serviceKey.useExpireDay;
            if(serviceKey == ServiceKey.VIP){
                ServiceVipKey vipKey = ServiceVipKey.ValueOf(record.getParam());
                expireDay = vipKey.useExpireDay;
            }

            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())
                        .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("已开通当前服务");
                    }
                    // 重置
                    userService.setIsReset(0);
                    examinationService.resetCat(record.getUserId(), true);
                }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);
            }

            record.setUseStartTime(startTime);
            record.setUseEndTime(endTime);
            return record;
        }));

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

            Course course = courseService.get(record.getProductId());
            Integer expireDay = 0;
            if (course.getCourseModule().equals(CourseModule.VS.key)){
                // 根据课时数进行计算
                expireDay = courseExtendService.computeExpire(record.getNumber(), course);
            }else{
                // 根据设置进行计算

            }
            Date startTime = time;
            Date endTime = Tools.addDate(startTime, expireDay);
            UserCourse userCourse = userCourseService.getCourseBase(record.getUserId(), record.getProductId());
            if(userCourse == null){
                userCourse = UserCourse.builder()
                        .userId(record.getUserId())
                        .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);
            record.setUseEndTime(endTime);
            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.setIsUsed(1);
            Date time = new Date();
            record.setUseTime(time);

            ServiceKey serviceKey = ServiceKey.ValueOf(record.getService());
            Integer expireDay = serviceKey.useExpireDay;
            if(serviceKey == ServiceKey.VIP){
                ServiceVipKey vipKey = ServiceVipKey.ValueOf(record.getParam());
                expireDay = vipKey.useExpireDay;
            }

            Date startTime = time;
            Date endTime = Tools.addDate(startTime, expireDay);
            UserService userService = userServiceService.getServiceBase(record.getUserId(), serviceKey);
            if (userService == null){
                userService = UserService.builder()
                        .userId(record.getUserId())
                        .isSubscribe(record.getIsSubscribe())
                        .startTime(startTime)
                        .expireTime(endTime)
                        .build();
                userService = userServiceService.add(userService);
            }else{
                if (userService.getExpireTime().before(time)){
                    // 已到期 - 续期
                    userService.setStartTime(startTime);
                    userService.setExpireTime(endTime);
                }else{
                    if (serviceKey == ServiceKey.QX_CAT){
                        // 未到期 - 报错
                        throw new ParameterException("已开通当前服务");
                    }
                    // 未到期 - 延长有效期
                    startTime = userService.getExpireTime();
                    endTime = Tools.addDate(userService.getExpireTime(), expireDay);
                    userService.setExpireTime(endTime);
                }
                userService.setIsSubscribe(record.getIsSubscribe());
                userService = userServiceService.edit(userService);
            }
            record.setUseStartTime(startTime);
            record.setUseEndTime(endTime);
            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;
        userOrder = userOrderService.edit(UserOrder.builder()
                .id(userOrder.getId())
                .payId(payId)
                .payMethod(payMethod.key)
                .payTime(payTime)
                .transactionNo(transactionNo)
                .payStatus(1)
                .build());

        // 转换购物车记录为购买记录
        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);
        }
        userOrderCheckoutService.deleteByUser(userId, orderId);

        // 累加用户支付信息
        usersService.accumulation(userOrder.getUserId(), userOrder.getMoney());
        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() > 0){
            userOrderCheckoutService.edit(checkout);
        }else{
            userOrderCheckoutService.add(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();
        // 记录订单优惠
        JSONObject promote = new JSONObject();
        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());
        callback = initOrderCallback.get(ProductType.COURSE);
        callback.callback(order, courseCheckout);
        if(courseCheckout.size() > 0){
            productTypes.add(ProductType.COURSE.key);
        }
        // 资料
        List<UserOrderCheckout> dataCheckout = list.stream().filter((checkout)-> checkout.getProductType().equals(ProductType.DATA.key)).collect(Collectors.toList());
        callback = initOrderCallback.get(ProductType.DATA);
        callback.callback(order, courseCheckout);
        if (dataCheckout.size() > 0){
            productTypes.add(ProductType.DATA.key);
        }
        // 服务
        List<UserOrderCheckout> serviceCheckout = list.stream().filter((checkout)-> checkout.getProductType().equals(ProductType.SERVICE.key)).collect(Collectors.toList());
        callback = initOrderCallback.get(ProductType.SERVICE);
        callback.callback(order, courseCheckout);
        if(serviceCheckout.size() > 0){
            productTypes.add(ProductType.SERVICE.key);
        }

        return order;
    }

    /**
     * 支付购物车
     * @param userId
     * @return
     */
    @Transactional
    public UserOrder makeOrder(Integer userId){
        List<UserOrderCheckout> list = userOrderCheckoutService.allByUser(userId, 0);
        UserOrder order = preOrderWithCheckout(userId, list);
        order = userOrderService.add(order);

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

    /**
     * 立即购买
     * @param userId
     * @param checkout
     * @return
     */
    @Transactional
    public UserOrder makeOrderWithProduct(Integer userId, UserOrderCheckout checkout){
        List<UserOrderCheckout> list = new ArrayList<UserOrderCheckout>(){{add(checkout);}};
        UserOrder order = preOrderWithCheckout(userId, list);
        order = userOrderService.add(order);
        checkout.setOrderId(order.getId());
        userOrderCheckoutService.add(checkout);
        return order;
    }

    /**
     * 后台直接添加记录
     * @param record
     * @return
     */
    @Transactional
    public UserOrderRecord addRecord(UserOrderRecord record){
        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)
                .service(ServiceKey.VIP.key)
                .param(ServiceVipKey.DAY7.key)
                .source(RecordSource.INVITE.key)
                .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)
                .service(ServiceKey.VIP.key)
                .param(ServiceVipKey.DAY7.key)
                .source(RecordSource.PREPARE.key)
                .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)
                .service(ServiceKey.VIP.key)
                .param(ServiceVipKey.MONTH3.key)
                .source(RecordSource.REAL.key)
                .build();
        // 虚拟order
        record = initRecordCallback.get(ProductType.SERVICE).callback(UserOrder.builder().build(), record);
        userOrderRecordService.add(record);
    }

}