caimei365-manager/src/main/java/com/caimei/modules/order/web/NewOrderController.java

package com.caimei.modules.order.web;

import com.alibaba.fastjson.JSONObject;
import com.caimei.constants.NewPayWay;
import com.caimei.dfs.image.beens.ImageUploadInfo;
import com.caimei.modules.bulkpurchase.entity.BpClause;
import com.caimei.modules.bulkpurchase.entity.CmFinanceCharge;
import com.caimei.modules.bulkpurchase.service.BpClauseService;
import com.caimei.modules.bulkpurchase.service.CmFinanceChargeService;
import com.caimei.modules.bulkpurchase.service.PurchaseProductService;
import com.caimei.modules.common.utils.ExcelUtil;
import com.caimei.modules.common.utils.UploadUtils;
import com.caimei.modules.order.dao.*;
import com.caimei.modules.order.entity.*;
import com.caimei.modules.order.service.*;
import com.caimei.modules.order.utils.OrderUtil;
import com.caimei.modules.product.dao.CmPromotionDao;
import com.caimei.modules.product.dao.ProductDao;
import com.caimei.modules.product.entity.CmPromotion;
import com.caimei.modules.product.entity.Product;
import com.caimei.modules.product.entity.RepeatPurchasePrice;
import com.caimei.modules.product.entity.RepeatPurchasePriceHistory;
import com.caimei.modules.product.service.CmSecondHandDetailService;
import com.caimei.modules.product.service.RepeatPurchasePriceHistoryService;
import com.caimei.modules.product.service.RepeatPurchasePriceService;
import com.caimei.modules.project.dao.ClubDao;
import com.caimei.modules.project.model.ClubModel;
import com.caimei.modules.sys.utils.UploadImageUtils;
import com.caimei.modules.user.dao.CmUserDao;
import com.caimei.modules.user.entity.*;
import com.caimei.modules.user.service.CmMessageService;
import com.caimei.modules.user.service.CmUserOrganizeService;
import com.caimei.modules.user.service.CmUserService;
import com.caimei.modules.user.service.NewCmShopService;
import com.caimei.modules.user.utils.UserType;
import com.caimei.po.ProductLadderPrice;
import com.caimei.utils.AppKeys;
import com.caimei.utils.AppUtils;
import com.caimei.utils.MathUtil;
import com.caimei.utils.StringUtil;
import com.google.common.collect.Lists;
import com.thinkgem.jeesite.common.config.Global;
import com.thinkgem.jeesite.common.mapper.JsonMapper;
import com.thinkgem.jeesite.common.persistence.Page;
import com.thinkgem.jeesite.common.utils.Encodes;
import com.thinkgem.jeesite.common.utils.StringUtils;
import com.thinkgem.jeesite.common.web.BaseController;
import org.apache.commons.collections.CollectionUtils;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayOutputStream;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.IntStream;

/**
 * 订单模块重构-订单Controller
 *
 * @author lwt
 * @version 2018-07-23
 */
@Controller
@RequestMapping(value = "${adminPath}/order")
public class NewOrderController extends BaseController {

    @Resource
    private NewOrderService newOrderService;
    @Resource
    private BpClauseService bpClauseService;
    @Resource
    private NewOrderProductService newOrderProductService;
    @Autowired
    private NewReceiptListService newReceiptListService;
    @Resource
    private NewShopOrderService newShopOrderService;
    @Resource
    private CmFinanceChargeService cmFinanceChargeService;
    @Resource
    private OrderUserInfoService orderUserInfoService;
    @Resource
    private CmMessageService cmMessageService;
    @Resource
    private ClubDao clubDao;
    @Autowired
    private ProductDao productDao;
    @Resource
    private CmProductSnService cmProductSnService;
    @Autowired
    private NewOrderProductDao newOrderProductDao;
    @Resource
    private CmReturnedPurchaseDao cmReturnedPurchaseDao;
    @Resource
    private CmUserService cmUserService;
    @Resource
    private RepeatPurchasePriceService repeatPurchasePriceService;
    @Resource
    private NewCmShopService newCmShopService;
    @Resource
    private RepeatPurchasePriceHistoryService repeatPurchasePriceHistoryService;
    @Resource
    private NewOrderConfigService newOrderConfigService;
    @Resource
    private CmDiscernReceiptService cmDiscernReceiptService;
    @Resource
    private CmUserDao cmUserDao;
    @Resource
    private CmReturnedPurchaseService cmReturnedPurchaseService;
    @Resource
    private CmReceiptOrderRelationDao cmReceiptOrderRelationDao;
    @Autowired
    private CmUserOrganizeService cmUserOrganizeService;
    @Autowired
    private CmSecondHandDetailService cmSecondHandDetailService;
    @Autowired
    private CmDiscernReceiptDao cmDiscernReceiptDao;
    @Autowired
    private CmReceiptOrderRelationService cmReceiptOrderRelationService;
    @Resource
    private CmPromotionDao cmPromotionDao;
    @Autowired
    private PurchaseProductService purchaseProductService;
    @Autowired
    private LogisticsRecordDao logisticsRecordDao;

    @ModelAttribute
    public NewOrder get(@RequestParam(required = false) String id) {
        NewOrder entity = null;
        if (StringUtils.isNotBlank(id)) {
            entity = newOrderService.get(id);
        }
        if (entity == null) {
            entity = new NewOrder();
        }
        return entity;
    }

    @RequiresPermissions("order:order:view")
    @RequestMapping("orderList")
    public String orderList(NewOrder order, HttpServletRequest request, HttpServletResponse response, Model model) {
        if (null != order.getStartTime() && !"".equals(order.getStartTime()) && !order.getStartTime().endsWith("00:00:00")) {
            model.addAttribute("startTime", order.getStartTime());
            order.setStartTime(order.getStartTime() + " 00:00:00");
        }
        if (null != order.getEndTime() && !"".equals(order.getEndTime()) && !order.getEndTime().endsWith("23:59:59")) {
            model.addAttribute("endTime", order.getEndTime());
            order.setEndTime(order.getEndTime() + " 23:59:59");
        }
        if (null != order.getStartConfirmTime() && !"".equals(order.getStartConfirmTime()) && !order.getStartConfirmTime().endsWith("00:00:00")) {
            model.addAttribute("startConfirmTime", order.getStartConfirmTime());
            order.setStartConfirmTime(order.getStartConfirmTime() + " 00:00:00");
        }
        if (null != order.getEndConfirmTime() && !"".equals(order.getEndConfirmTime()) && !order.getEndConfirmTime().endsWith("23:59:59")) {
            model.addAttribute("endConfirmTime", order.getEndConfirmTime());
            order.setEndConfirmTime(order.getEndConfirmTime() + " 23:59:59");
        }
        if (null != order.getStartRefundTime() && !"".equals(order.getStartRefundTime()) && !order.getStartRefundTime().endsWith("00:00:00")) {
            model.addAttribute("startRefundTime", order.getStartRefundTime());
            order.setStartRefundTime(order.getStartRefundTime() + " 00:00:00");
        }
        if (null != order.getEndRefundTime() && !"".equals(order.getEndRefundTime()) && !order.getEndRefundTime().endsWith("23:59:59")) {
            model.addAttribute("endRefundTime", order.getEndRefundTime());
            order.setEndRefundTime(order.getEndRefundTime() + " 23:59:59");
        }
        model.addAttribute("orderRefundType", order.getOrderRefundType());
        if (null != order.getBuyer()) {
            order.setBuyer(order.getBuyer().trim());
        }
        if (null != order.getReceiver()) {
            order.setReceiver(order.getReceiver().trim());
        }
        //查询内部处理了已收,未付统计（包含运费）
        Page<NewOrder> page = newOrderService.findPage(new Page<>(request, response, 20), order);
        //获取组织列表
        List<CmUserOrganize> cmUserOrganizeList = cmUserOrganizeService.findOrganize();
        model.addAttribute("cmUserOrganizeList", cmUserOrganizeList);
        //获取上线协销人员，排除采美默认协销经理
        List<NewCmSp> serviceProviderList = newOrderService.findServiceProviderList();
        model.addAttribute("serviceProviderList", serviceProviderList);
        model.addAttribute("page", page);
        return "modules/order/newOrderList";
    }

    @RequiresPermissions("order:order:edit")
    @RequestMapping(value = "form")
    public String form(NewOrder newOrder, Model model, HttpServletRequest request) {
        BpClause bpClause = new BpClause();
        bpClause.setEnabledStatus("1");
        List<BpClause> bpClauses = bpClauseService.findList(bpClause);
        model.addAttribute("bpClauses", bpClauses);
        if (null != newOrder.getClauseID() && StringUtils.equals("1", newOrder.getConfirmFlag())) {//订单，且确认
            BpClause bpClause1 = bpClauseService.get(newOrder.getClauseID().toString());
            model.addAttribute("bpClause", bpClause1);
        }
        if (null != newOrder) {
            //根据订单产品
            List<NewOrderProduct> orderProducts = newOrder.getOrderProduct();
            if (null != orderProducts && orderProducts.size() > 0) {
                BigDecimal alreadyShopOtherPay = new BigDecimal(0);
                for (NewOrderProduct orderProduct : orderProducts) {
                    //重新赋值
                    alreadyShopOtherPay = BigDecimal.ZERO;
                    orderProduct.setShopFeeFlag("0");
                    //获取订单商品的应付信息
                    List<CmFinanceCharge> cmFinanceCharges = cmFinanceChargeService.findListByProductId(orderProduct.getId());
                    if (null != cmFinanceCharges && cmFinanceCharges.size() > 0) {
                        for (int i = 0; i < cmFinanceCharges.size(); i++) {  //一个产品多个出账记录
                            if ("3".equals(cmFinanceCharges.get(i).getStatus())) {
                                alreadyShopOtherPay = MathUtil.add(alreadyShopOtherPay, cmFinanceCharges.get(i).getShopFee());//已审核通过付给供应商金额
                            }
                        }
                    } else {
                        orderProduct.setShopFeeFlag("0");//没有  则可以修改应付供应商
                    }
                    //金额不为空  且  金额相等
                    if (BigDecimal.valueOf(orderProduct.getShopFee()).compareTo(alreadyShopOtherPay) == 0 && alreadyShopOtherPay.compareTo(BigDecimal.ZERO) != 0) {
                        orderProduct.setShopFeeFlag("1");//审核通过 不可修改
                    }
                    // 促销
                    CmPromotion orderPromotions = null;
                    if (null != orderProduct.getOrderPromotionsId()) {
                        orderPromotions = cmPromotionDao.findOrderPromotions(orderProduct.getOrderPromotionsId());
                        if (null != orderPromotions) {
                            orderProduct.setPromotionsId(orderPromotions.getPromotionsId());
                            orderProduct.setLadderPriceFlag(0);
                        }
                    }
                    if (null == orderPromotions) {
                        Product product = productDao.get(orderProduct.getProductID().toString());
                        if (1 == orderProduct.getLadderPriceFlag() && "1".equals(product.getLadderPriceFlag())) {
                            // 查询商品当前阶梯价格
                            List<ProductLadderPrice> ladderPriceList = purchaseProductService.findLadderPriceList(orderProduct.getProductID().longValue());
                            if (null != ladderPriceList && ladderPriceList.size() > 0) {
                                IntStream.range(0, ladderPriceList.size()).forEach(i -> {
                                    if (i == ladderPriceList.size() - 1) {
                                        ladderPriceList.get(i).setBuyNumRangeShow("≥" + ladderPriceList.get(i).getBuyNum());
                                    } else {
                                        String buyNumRangeShow = ladderPriceList.get(i).getBuyNum() + "~" + (ladderPriceList.get(i + 1).getBuyNum() - 1);
                                        ladderPriceList.get(i).setBuyNumRangeShow(buyNumRangeShow);
                                    }
                                });
                                orderProduct.setLadderPriceList(ladderPriceList);
                            }
                        } else {
                            orderProduct.setLadderPriceFlag(0);
                            orderProduct.setIsActProduct("0");
                        }
                    }
                }
            }
            if (null != newOrder.getOrderID() && null != newOrder.getClauseName()) {
                newOrderService.updateClauseContent(newOrder);
            }
            if (StringUtil.isEmpty(newOrder.getOrderTime())) {
                newOrder.setOrderTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            }
            if (null == newOrder.getOrderID()) {
                newOrder.setOrderSource("4");
            }
        }
        model.addAttribute("order", newOrder);
        return "modules/order/orderForm";
    }

    @RequiresPermissions("order:order:edit")
    @RequestMapping(value = "secondeProductOrderForm")
    public String secondeProductOrderForm(NewOrder newOrder, Model model, HttpServletRequest request) {
        BpClause bpClause = new BpClause();
        bpClause.setEnabledStatus("1");
        List<BpClause> bpClauses = bpClauseService.findList(bpClause);
        model.addAttribute("bpClauses", bpClauses);
        if (null != newOrder.getClauseID() && StringUtils.equals("1", newOrder.getConfirmFlag())) {//订单，且确认
            BpClause bpClause1 = bpClauseService.get(newOrder.getClauseID().toString());
            model.addAttribute("bpClause", bpClause1);
        }
        if (null != newOrder) {
            //根据订单产品
            List<NewOrderProduct> orderProducts = newOrder.getOrderProduct();
            if (null != orderProducts && orderProducts.size() > 0) {
                BigDecimal alreadyShopOtherPay = new BigDecimal(0);
                for (NewOrderProduct orderProduct : orderProducts) {
                    //重新赋值
                    alreadyShopOtherPay = BigDecimal.ZERO;
                    orderProduct.setShopFeeFlag("0");
                    //获取订单商品的应付信息
                    List<CmFinanceCharge> cmFinanceCharges = cmFinanceChargeService.findListByProductId(orderProduct.getId());
                    if (null != cmFinanceCharges && cmFinanceCharges.size() > 0) {
                        for (int i = 0; i < cmFinanceCharges.size(); i++) {  //一个产品多个出账记录
                            if ("3".equals(cmFinanceCharges.get(i).getStatus())) {
                                alreadyShopOtherPay = MathUtil.add(alreadyShopOtherPay, cmFinanceCharges.get(i).getShopFee());//已审核通过付给供应商金额
                            }
                        }
                    } else {
                        orderProduct.setShopFeeFlag("0");//没有  则可以修改应付供应商
                    }
                    //金额不为空  且  金额相等
                    if (new BigDecimal(orderProduct.getShopFee()).compareTo(alreadyShopOtherPay) == 0 && alreadyShopOtherPay.compareTo(BigDecimal.ZERO) != 0) {
                        orderProduct.setShopFeeFlag("1");//审核通过 不可修改
                    }
                }
            }
            if (null != newOrder.getOrderID() && null != newOrder.getClauseName()) {
                newOrderService.updateClauseContent(newOrder);
            }
            if (StringUtil.isEmpty(newOrder.getOrderTime())) {
                newOrder.setOrderTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            }
        }
        model.addAttribute("order", newOrder);
        return "modules/order/secondProductOrderForm";
    }


    @RequiresPermissions("order:order:edit")
    @RequestMapping(value = "save")
    public String save(NewOrder newOrder, Model model, RedirectAttributes redirectAttributes, HttpServletRequest request) {
        // 是否为二手订单(二手订单只存在一个商品)
        boolean isSecondHandOrder = false;
        if (!beanValidator(model, newOrder)) {
            return form(newOrder, model, request);
        }
        if (CollectionUtils.isEmpty(newOrder.getOrderProduct())) {
            model.addAttribute("message", "保存失败商品不能为空");
            return form(newOrder, model, request);
        } else {
            List<NewOrderProduct> orderProductList = Lists.newArrayList();
            for (NewOrderProduct newOrderProduct : newOrder.getOrderProduct()) {
                if (StringUtils.isNotEmpty(newOrderProduct.getEnabledStatus())) {
                    NewOrderProduct o = (NewOrderProduct) JsonMapper.fromJsonString(newOrderProduct.getEnabledStatus(), NewOrderProduct.class);
                    JSONObject jsonObject = JSONObject.parseObject(newOrderProduct.getEnabledStatus());
                    String productId = jsonObject.getString("productId");
                    if (productId != null && !"".equals(productId)) {
                        o.setProductID(Integer.valueOf(productId));
                    }
                    String shopId = jsonObject.getString("shopId");
                    if (shopId != null && !"".equals(shopId)) {
                        o.setShopID(Integer.valueOf(shopId));
                    }
                    String singleShopFee = jsonObject.getString("shopFee1");
                    if (singleShopFee != null && !"".equals(singleShopFee)) {
                        o.setSingleShopFee(Double.valueOf(singleShopFee));
                    }
                    String singleOtherFee = jsonObject.getString("otherFee1");
                    if (singleOtherFee != null && !"".equals(singleOtherFee)) {
                        o.setSingleOtherFee(Double.valueOf(singleOtherFee));
                    }
                    String singleCmFee = jsonObject.getString("cmFee1");
                    if (singleCmFee != null && !"".equals(singleCmFee)) {
                        o.setSingleCmFee(Double.valueOf(singleCmFee));
                    }
                    String productType = jsonObject.getString("productType");
                    if (productType != null && !"".equals(productType)) {
                        o.setProductType(Integer.valueOf(productType));
                    }
                    String ladderPriceFlag = jsonObject.getString("ladderPriceFlag");
                    if (ladderPriceFlag != null && !"".equals(ladderPriceFlag)) {
                        o.setLadderPriceFlag(Integer.valueOf(ladderPriceFlag));
                    }
                    if ("0".equals(productType)) {
                        o.setPreferential((o.getPrice() - o.getDiscountPrice()) * o.getNum());//折扣
                        o.setDiscountFee(BigDecimal.valueOf(o.getTotalFee()).subtract(BigDecimal.valueOf(o.getShouldPayFee())).doubleValue());//经理折扣
                        o.setTotalAmount(o.getPrice() * o.getNum());//商品总金额
                        //设置订单商品的默认应付税费（只有默认的时候应付税费才等于应收税费）
                        if (o.getShouldPayTotalTax() == null) {
                            o.setSingleShouldPayTotalTax(o.getAddedValueTax());
                            o.setShouldPayTotalTax(o.getTotalAddedValueTax());
                        }
                    } else {
                        o.setPreferential(0d);
                        o.setDiscount(100d);
                        o.setDiscountFee(0d);
                        o.setTotalAmount(0d);
                        o.setShouldPayFee(0d);
                        o.setSingleShouldPayTotalTax(0d);
                        o.setShouldPayTotalTax(0d);
                        o.setCmFee(0d);
                        o.setTotalFee(0d);
                        o.setTotalAddedValueTax(0d);
                        o.setAddedValueTax(0d);
                        o.setTaxRate(0d);
                    }
                    o.setPresentNum(0);
                    o.setNotOutStore(o.getNum());
                    o.setStatus(0);//订单商品待付款
                    if (o.getPayStatus() == null) {
                        o.setPayStatus("0"); //默认值为未付款(0 未进账 1 待财务审核 2 已进账)
                    }
                    Integer promotionsId = o.getPromotionsId() != null ? o.getPromotionsId() : 0;
                    o.setPromotionsId(promotionsId);
                    orderProductList.add(o);
                    String productCategory = o.getProductCategory();
                    if (StringUtils.equals(productCategory, "2")) {
                        isSecondHandOrder = true;
                        newOrder.setRebateFlag("0");
                    }
                }
            }
            if (CollectionUtils.isNotEmpty(orderProductList)) {
                newOrder.setOrderProduct(orderProductList);
            }
        }
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time = sdf.format(date);
        if (isSecondHandOrder) {
            newOrder.setSecondHandOrderFlag("1");
        } else {
            newOrder.setSecondHandOrderFlag("0");
        }
        //后台添加订单状态为0；待确认
        if (StringUtils.isEmpty(newOrder.getStatus())) {
            newOrder.setStatus("0");
        }
        if (newOrder.getPayableAmount() == 0 && newOrder.getPayTotalFee() == 0) {
            // 订单状态
            newOrder.setStatus("31");
            newOrder.setReceiptStatus("3");
            newOrder.setPayFlag("1");

            newOrder.setConfirmFlag("1");//标记为确认订单
            newOrder.setConfirmTime(time);
        }

        //后台添加订单订单提交类型；后台提交4
        if (StringUtils.isEmpty(newOrder.getOrderSubmitType())) {
            newOrder.setOrderSubmitType("4");
        }

        //如果是[5:外单]类型则订单状态直接为交易完成
        if (StringUtils.equals("5", newOrder.getOrderSource())) {
            newOrder.setConfirmFlag("1");//标记为确认订单
            newOrder.setConfirmTime(time);
        }
        if (StringUtils.equals("1", newOrder.getCooFreeFlag())) {
            //如果是分期订单
            newOrder.setCooFreeFlag("0");
            newOrder.setCooFreeRate(0);
            newOrder.setCooFreeAmount(0.00d);
        }
        if (newOrder.getOrderID() == null) {
            //  lwt  订单的下单时间和单号 都再订单保存后再展示
            newOrder.setOrderNo(OrderUtil.geneAdminOrderNo());
            newOrder.setOrderType("0"); // 订单类型 协销订单 0 普通订单 1
            newOrder.setOrderSubmitType("4");
            newOrder.setSplitFlag("1"); //订单可拆分
        }
        if (newOrder.getClauseID() == null) {
            newOrder.setClauseID(1);  //没有选择条款的话  默认就是无条款
        }
        BpClause clause = bpClauseService.get(newOrder.getClauseID().toString());
        newOrder.setClauseContent(clause.getContent());
        newOrder.setClauseName(clause.getName());
        //保存订单
        newOrderService.save(newOrder);
        if (newOrder.getOrderID() != null) {
            //订单重新保存后则修改订单商品需供应商确认
            newOrderProductService.updateShopConfigFlag(newOrder.getOrderID());
        }
        addMessage(redirectAttributes, "保存订单成功");
        return "redirect:" + Global.getAdminPath() + "/order/orderList";
    }

    @RequiresPermissions("order:order:edit")
    @RequestMapping("printOrder")
    public String printOrder(Integer orderID, Integer shopOrderID, Model model) {
        if (shopOrderID != null) {
            NewShopOrder shopOrder = newShopOrderService.findByShopOrderID(shopOrderID);
            NewOrder order = newOrderService.findByOrderID(shopOrder.getOrderID());
            String payWay = order.getPayWay();
            if (payWay != null) {
                for (NewPayWay type : NewPayWay.values()) {
                    if (payWay.contains(type.getCode() + ""))
                        payWay = payWay.replaceAll(type.getCode() + "", type.getDesc());
                }
                order.setPayWay(payWay);
            } else {
                order.setPayWay("-");
            }
            OrderUserInfo orderUserInfo = orderUserInfoService.findByOrderID(order.getOrderID());
            model.addAttribute("shopOrder", shopOrder);
            model.addAttribute("order", order);
            model.addAttribute("orderUserInfo", orderUserInfo);
            return "modules/order/printSubOrder";
        }
        if (orderID != null) {
            NewOrder order = newOrderService.get(orderID + "");
            order.getOrderProduct().forEach(o -> {
                if (o.getOrderPromotionsId() != null) {
                    CmPromotion promotions = cmPromotionDao.findOrderPromotions(o.getOrderPromotionsId());
                    if (promotions != null && "1".equals(promotions.getMode())) {
                        o.setDiscountPrice(promotions.getTouchPrice());
                    }
                }
            });
            order.getNewShopOrders().removeIf(so -> so.getPostFeeCos().equals("1"));
            model.addAttribute("order", order);
            return "modules/order/printOrder";
        }
        return "modules/order/printOrder";
    }

    /**
     * 普通订单商品修改
     *
     * @param model
     * @return
     */
    @RequiresPermissions("order:order:edit")
    @RequestMapping("modifyProduct")
    public String modifyProduct(Model model, Integer orderID) {
        NewOrder order = newOrderService.get(orderID.toString());
        model.addAttribute("order", order);
        return "modules/order/modifyProduct";
    }

    /**
     * 协销订单确认
     *
     * @param model
     * @return
     */
    @RequiresPermissions("order:order:confirmOrder")
    @RequestMapping("confirmOrder")
    public String confirmOrder(Integer orderID, Model model, RedirectAttributes redirectAttributes) {
        NewOrder order = newOrderService.get(orderID + "");
        //————————————————————————————-----
        //确认订单时处理买家商品价格库信息
        final Integer userID;
        if ("6".equals(order.getOrderSubmitType())) {
            userID = order.getUserID();
        } else {
            Integer clubId = order.getClubID();
            ClubModel clubByUserId = clubDao.getClubByUserId(Integer.parseInt(clubId.toString()));
            userID = clubByUserId.getUserID();
        }
        List<NewOrderProduct> orderProduct = order.getOrderProduct();
        if (CollectionUtils.isNotEmpty(orderProduct) && orderProduct.size() > 0) {
            for (NewOrderProduct op : orderProduct) {
                String isActProduct = op.getIsActProduct();
                //活动商品和阶梯商品不写入价格库
                if (StringUtil.equals("0", isActProduct)) {
                    String buyAgainFlag = op.getBuyAgainFlag();
                    //对于可以复购的商品添加买家商品价格，提供再次购买商品使用（如果不存在没有改买家商品价格则不能购买该商品）
                    if (StringUtils.isNotEmpty(buyAgainFlag) && StringUtils.equals("1", buyAgainFlag)) {
                        Product product = productDao.get(op.getProductID().toString());
                        if (null != product) {
                            String costPrice = product.getCostPrice();//成本价
                            //version 4.6.0 写入复购价格库
                            Double buyPrice = op.getDiscountPrice(); //该商品的购买价
                            Date now = new Date();
                            Date begin = product.getBeginTime();
                            Date end = product.getEndTime();
                            CmUser u = cmUserService.get(userID + "");
                            if ("1".equals(product.getLadderPriceFlag()) ||
                                    ("1".equals(product.getActFlag()) &&
                                            "1001".equals(product.getActType()) &&
                                            new Date().after(begin) && now.before(end))) {
                                //如果商品启用了阶梯价格或者团购活动,那么不使用购买价格而是用用户对应身份的非活动价格参与复购价格库计算
                                //确认用户类型
                                Integer userType = 1;//查看价格用户类型（1：游客，2：普通用户，3：会员）
                                if ("10".equals(u.getRegisterUserTypeID())) {//普通用户或者游客
                                    boolean isVisitor = newOrderService.isVisitor(userID.toString());//是否是游客
                                    if (isVisitor) {
                                        userType = 1;
                                        buyPrice = product.getPrice8().doubleValue();
                                    } else {
                                        userType = 2;
                                        buyPrice = product.getPrice0().doubleValue();
                                    }
                                } else {
                                    //未冻结 上线会所 上线创客查看会员价
                                    if (AppKeys.FLAG_YES.equals(u.getValidFlag()) &&
                                            (UserType.isClub(u.getRegisterUserTypeID())
                                                    && (StringUtils.isNotEmpty(u.getClubStatus()) &&
                                                    ("40".equals(u.getClubStatus()) || "90".equals(u.getClubStatus())))
                                            )) {
                                        userType = 3;
                                        buyPrice = product.getPrice1().doubleValue();
                                    }
                                    //普通用户 非上线创客会所 供应商 已冻结用户 展示普通价
                                    else {
                                        userType = 2;
                                        buyPrice = product.getPrice0().doubleValue();
                                    }
                                }
                            }
                            Integer clubID = null;
                            Integer uID = null;
                            if (UserType.isClub(u.getRegisterUserTypeID())) {
                                clubID = StringUtils.isEmpty(u.getClubID()) ? null : Integer.valueOf(u.getClubID());
                            } else {
                                uID = u.getUserID();
                            }
                            // 当前购买价格与成本价比较
                            String costCheckFlag = product.getCostCheckFlag();//成本价选中标志：1固定成本 2比例成本
                            if ("2".equals(costCheckFlag)) {
                                costPrice = MathUtil.div(MathUtil.mul(product.getPrice1().doubleValue(), product.getCostProportional()), 100).toString();
                                if ("0".equals(costPrice)) costPrice = op.getCostPrice().toString();
                            }
                            //购买价大于成本价,采美赚钱 就写入复购价格库
                            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                            String strDate = formatter.format(new Date());
                            String flag = "0";
                            if (StringUtils.isNotBlank(costPrice) && buyPrice > Double.valueOf(costPrice)) {
                                // 查询复购价格库 比较复购价格库中的购买价格与这一次的购买价格
                                RepeatPurchasePrice p = repeatPurchasePriceService.getLastBuyPrice(clubID, uID, product.getProductID());
                                if (p == null) {
                                    NewCmShop shop = newCmShopService.get(product.getShopID().toString());
                                    p = new RepeatPurchasePrice();
                                    p.setClubId(clubID);
                                    p.setUserId(u.getUserID());
                                    p.setCurrentPrice(buyPrice.toString());
                                    p.setCreateTime(strDate);
                                    p.setProductId(product.getProductID());
                                    p.setOrderId(orderID.toString());
                                    p.setShopId(shop == null ? null : shop.getShopID());
                                    p.setShopName(shop == null ? "" : shop.getName());
                                    p.setTaxRate(String.valueOf(op.getTaxRate()));
                                    repeatPurchasePriceService.insert(p);
                                } else if (StringUtils.isNotBlank(p.getCurrentPrice()) && buyPrice < Double.valueOf(p.getCurrentPrice())) { // 这一次的购买价格小于复购价格库中的价格
                                    p.setCurrentPrice(buyPrice.toString());
                                    p.setOrderId(orderID.toString());
                                    p.setTaxRate(String.valueOf(op.getTaxRate()));
                                    repeatPurchasePriceService.update(p);
                                }
                                flag = "1";
                            }
                            RepeatPurchasePriceHistory r = new RepeatPurchasePriceHistory();
                            r.setClubId(clubID);
                            r.setUserId(u.getUserID());
                            r.setPrice(buyPrice.toString());
                            r.setOrderId(orderID);
                            r.setCurrentCostPrice(costPrice);
                            r.setCreateTime(strDate);
                            r.setProductId(product.getProductID());
                            r.setValid(flag);
                            repeatPurchasePriceHistoryService.insert(r);
                        }
                    }
                }
                // 二手商品确认商品如果是二手仪器则需要把该二手商品置为已售
                if (StringUtils.equals(op.getSecondHandType(), "1") && StringUtils.equals("2", op.getProductCategory())) {
                    cmSecondHandDetailService.updatSecondHnadproductSold(op.getProductID());
                }
            }
        }
        //————————————————————————————-----
        CmMessage msg = new CmMessage();
        msg.setAddTime(com.caimei.utils.DateUtils.getDateTime());
        msg.setContent("您有一笔订单等待支付，快去订单列表进行支付。");
        msg.setTitle("订单确认结果");
        msg.setToUserID(order.getUserID());
        msg.setMessageTypeID("1");
        msg.setReadFlag("0");
        cmMessageService.save(msg);
        newOrderService.confirmOrder(orderID);

        //确认订单的时候将用户余额修改为抵扣之后金额（协销下单，后台下单--待确认订单）注意用户自己下单的时候直接则两个金额同时减少，取消同时回滚
        Double balancePayFee = order.getBalancePayFee();
        CmUser u = cmUserService.get(userID + "");
        if (null != u && null != balancePayFee) {
            Double userMoney = u.getUserMoney();
            if (null != userMoney) {
                u.setUserMoney(userMoney - balancePayFee);
                cmUserDao.updateMoney(u);
            }
        }//
        addMessage(redirectAttributes, "确认订单成功");
        return "redirect:" + Global.getAdminPath() + "/order/detail/?id=" + orderID;
    }


    /**
     * 取消订单
     *
     * @return
     */
    @RequiresPermissions("order:order:edit")
    @RequestMapping("cancelOrder")
    public String cancelOrder(Integer orderID, RedirectAttributes redirectAttributes) {
        newOrderService.cancelOrder(orderID);
        addMessage(redirectAttributes, "取消订单成功");
        return "redirect:" + Global.getAdminPath() + "/order/detail/?id=" + orderID;
    }

    /**
     * 确认收货
     *
     * @param shopOrderID
     * @param redirectAttributes
     * @return
     */
    @RequiresPermissions("order:order:edit")
    @RequestMapping("confirmReceipt")
    public String confirmReceipt(Integer shopOrderID, RedirectAttributes redirectAttributes) {
        newShopOrderService.confirmReceipt(shopOrderID);
        addMessage(redirectAttributes, "确认收货成功");
        return "redirect:" + Global.getAdminPath() + "/order/detailPage/?shopOrderID=" + shopOrderID;
    }


    /**
     * 去子订单orderProduct页面
     *
     * @return
     */
    @RequiresPermissions("order:order:edit")
    @RequestMapping("toDeliveryPage")
    public String toDeliveryPage(NewOrder order, Model model) {
        List<NewOrderProduct> orderProduct = order.getOrderProduct();
        if (CollectionUtils.isNotEmpty(orderProduct))
            orderProduct.removeIf(p -> p.getProductID().intValue() == 999);
        for (NewOrderProduct newOrderProduct : orderProduct) {
            Integer cancelNum = newOrderProductDao.getActualCancelNum(newOrderProduct.getOrderProductID());
            cancelNum = cancelNum == null ? 0 : cancelNum;
            //统计未发货数量
            newOrderProduct.setNotOutStore(newOrderProduct.getNotOutStore() - cancelNum);
        }
        model.addAttribute("order", order);
        return "modules/order/ship";
    }

    /**
     * 填写物流信息页面
     *
     * @param params key = orderProdductID value = 发货数量
     * @return
     */
    @RequiresPermissions("order:order:edit")
    @RequestMapping("addLogisticsInfo")
    @ResponseBody
    public Map<String, Object> addLogisticsInfo(Model model, @RequestBody Map<String, String> params) {
        Map<String, Object> r = new HashMap<>();
        // 参数转换
        List<NewOrderProduct> orderProductList = new ArrayList<>();
        for (Map.Entry<String, String> entry : params.entrySet()) {
            NewOrderProduct orderProduct = newOrderProductService.get(entry.getKey());
            orderProduct.setDeliveryNum(Integer.valueOf(entry.getValue()));
            orderProductList.add(orderProduct);
        }
        model.addAttribute("orderProductList", orderProductList);
        r.put("data", orderProductList);
        return r;
    }

    @RequestMapping("toShipLogistic")
    public String toShipLogistic(Integer orderID, Model model) {
        model.addAttribute("orderID", orderID);
        return "modules/order/shipLogistic";
    }


    private String setImagePath(String path) {
        //获取文件服务器地址
        String photoServer = Global.getConfig("photoServer");
        ImageUploadInfo saveImageSerivce = new ImageUploadInfo();
        if (StringUtils.isNotBlank(path) && !path.startsWith("http:") && !path.startsWith("https:")) {
            path = Encodes.urlDecode(path);
            String realPath = UploadImageUtils.getAbsolutePath(path);
            int pointerIndex = realPath.lastIndexOf(".");
            try {
                saveImageSerivce = UploadUtils.saveImageSerivce(realPath, pointerIndex, realPath);
                return photoServer + saveImageSerivce.getSource();
            } catch (Exception e) {
                return path;
            }
        }
        return path;
    }

    /**
     * 发货
     *
     * @param params 参数 包含 shopOrderID子订单ID, key = orderProductID  value = 发货数量  物流单号信息 key = 物流公司  value = 快递单号
     * @return
     */
    @RequiresPermissions("order:order:edit")
    @RequestMapping("delivery")
    @ResponseBody
    public Map<String, Object> delivery(@RequestBody Map<String, Object> params) {
        logger.info("delivery  params===== " + params);
        Map<Integer, Integer> orderProductMap = new HashMap<>();
        Map<Integer, List<NewOrderProduct>> deliveryData = new HashMap<>();  //eg: {shopOrderID : [orderProductList], }
        Map<String, List<String>> logisticsInfo = new HashMap<>();
        String remarks = null;
        String[] images = new String[0];
        // 参数转换
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            if (entry.getKey().contains("orderProductID")) {
                orderProductMap.put(Integer.valueOf(entry.getKey().split("_")[1]), Integer.valueOf(entry.getValue().toString()));
            }
            if (entry.getKey().contains("logisticsInfo")) {
                List<String> logisticsNus = Arrays.asList(entry.getValue().toString().split("_"));
                logisticsInfo.put(entry.getKey().split("_")[1], logisticsNus);
            }
            if (entry.getKey().contains("remarks")) {
                remarks = entry.getValue().toString();
            }
            if (entry.getKey().contains("remarkImages")) {
                images = entry.getValue().toString().split("##");
            }
        }
        String[] imgPath = new String[images.length];
        if (images.length > 0) {
            for (int i = 0; i < imgPath.length; i++) {
                imgPath[i] = setImagePath(images[i]);
            }
        }
        String remarkImage = StringUtils.join(imgPath, "##");
        Map<String, Object> result = new HashMap<>();
        List<NewOrderProduct> orderProducts = new ArrayList<>();
        for (Map.Entry<Integer, Integer> entry : orderProductMap.entrySet()) {
            NewOrderProduct o = newOrderProductService.get(String.valueOf(entry.getKey()));
            if (o.getNotOutStore() - entry.getValue() < 0) {
                result.put("success", false);
                result.put("msg", "发货数量异常");
                return result;
            }
            o.setNotOutStore(o.getNotOutStore() - entry.getValue());
            o.setThisTimePostNum(entry.getValue()); //这一次的发货数量
            if (o.getNotOutStore().intValue() == 0) {
                // 订单商品 已经发完
                o.setStatus(3);
            } else {
                // 订单商品 还没发完
                o.setStatus(4);
            }
            orderProducts.add(o);
            if (deliveryData.get(o.getShopOrderID()) == null) {
                List<NewOrderProduct> ops = new ArrayList<>();
                deliveryData.put(o.getShopOrderID(), ops);
                ops.add(o);
            } else {
                List<NewOrderProduct> ops = deliveryData.get(o.getShopOrderID());
                ops.add(o);
            }
        }
        //物流批次id
        String logisticsBatchId;
        try {
            logisticsBatchId = newOrderService.delivery(deliveryData, orderProducts, orderProductMap, logisticsInfo, remarks, remarkImage);
        } catch (Exception e) {
            logger.info(e.toString(), e);
            result.put("success", false);
            result.put("msg", e.getMessage());
            return result;
        }
        result.put("success", true);
        result.put("logisticsBatchId", logisticsBatchId);
        return result;
    }


    /**
     * 订单拆分
     *
     * @return
     */
    @RequiresPermissions("order:order:edit")
    @RequestMapping("splitOrder")
    @ResponseBody
    public Map<String, Object> splitOrder(@RequestBody Map<String, Map<String, String>> p) {
        Map<String, Object> map = new HashMap<>();
        try {
            for (Map.Entry<String, Map<String, String>> b : p.entrySet()) {
                Map<String, String> params = new HashMap<>();
                params.put("shopOrderID", b.getKey().split("_")[1]);
                for (Map.Entry<String, String> e : b.getValue().entrySet()) {
                    params.put(e.getKey(), e.getValue());
                }
                Integer shopOrderID = null; //子订单ID
                Map<Integer, Integer> orderProductMap = new HashMap<>();
                for (Map.Entry<String, String> entry : params.entrySet()) {
                    if ("shopOrderID".equals(entry.getKey()))
                        shopOrderID = Integer.valueOf(entry.getValue());
                    if (entry.getKey().contains("orderProductID"))
                        orderProductMap.put(Integer.valueOf(entry.getKey().split("_")[1]), Integer.valueOf(entry.getValue()));
                }
                if (shopOrderID == null) {
                    logger.info("参数错误shopOrderID == null了");
                    map.put("success", false);
                    map.put("msg", "参数错误");
                    return map;
                }
                // 无收款记录的订单可对该订单下的商品可根据数量拆成一个订单
                // 还需要加上有无收款记录的判断
                List<Integer> receiptID = cmDiscernReceiptService.getReceiptRecords(shopOrderID);
                if (CollectionUtils.isNotEmpty(receiptID)) {
                    //查到了收款记录仪   不能进行拆单操作了
                    logger.info("收款记录ID ----->" + StringUtil.join(receiptID, ","));
                    map.put("success", false);
                    map.put("msg", "订单进行过收款操作, 无法拆分");
                    return map;
                }
                List<NewOrderProduct> oldOrderProductList = new ArrayList<>();
                List<NewOrderProduct> newOrderProductList = new ArrayList<>();
                List<NewCmFinanceReceipts> cfrBakList = new ArrayList<>();
                for (Map.Entry<Integer, Integer> entry : orderProductMap.entrySet()) {
                    if (entry.getValue() == null || entry.getValue() == 0) {
                        continue;// 拆分数量为零则跳过
                    }
                    NewOrderProduct dbOrderProduct = newOrderProductService.get(entry.getKey() + "");
                    int allNum = dbOrderProduct.getNum() + dbOrderProduct.getPresentNum();// 商品订单里面的总的商品数量(含赠品)
                    double productNum = dbOrderProduct.getNum().doubleValue();// 商品订单里面的总的商品数量(不含赠品)
                    NewOrderProduct newOrderProduct = newOrderProductService.get(entry.getKey() + "");
                    newOrderProduct.setOrderProductID(null);
                    newOrderProduct.setShopOrderID(null);
                    newOrderProduct.setShopOrderNo(null);
                    if (entry.getValue() >= dbOrderProduct.getNum()) {  // 购买数量(含赠品)数量拆分
                        // 拆分数量 >= 购买数量(不含赠品)
                        newOrderProduct.setNum(dbOrderProduct.getNum());
                        newOrderProduct.setPresentNum(entry.getValue() - dbOrderProduct.getNum());
                        int dbOrderProductNum = dbOrderProduct.getNum();
                        dbOrderProduct.setNum(0);
                        dbOrderProduct.setPresentNum(dbOrderProduct.getPresentNum() - (entry.getValue() - dbOrderProductNum));
                        if (dbOrderProduct.getNum().intValue() == 0 && dbOrderProduct.getPresentNum().intValue() == 0) {
                            dbOrderProduct.setDelFlag("1");
                            List<NewOrderProduct> orderProducts = newOrderProductService.findListByShopOrderID(shopOrderID); //子订单商品
                            if (CollectionUtils.isNotEmpty(orderProducts) && orderProducts.size() == 1) { // 子订单里面只有一类订单商品
                                //  别把商品全部拆走啦
                                map.put("success", false);
                                map.put("msg", "别把商品全部拆走啦");
                                return map;
                            }
                        }
                    } else {
                        newOrderProduct.setNum(entry.getValue());
                        newOrderProduct.setPresentNum(0);
                        dbOrderProduct.setNum(dbOrderProduct.getNum() - entry.getValue());
                    }
                    dbOrderProduct.setNotOutStore(dbOrderProduct.getNotOutStore() - entry.getValue()); //未发货数量
                    newOrderProduct.setNotOutStore(entry.getValue()); //未发货数量

                    //总税费 TotalAddedValueTax
                    Double oldAddedValueTax = dbOrderProduct.getTotalAddedValueTax();
                    Double newAddedValueTax = newOrderProduct.getTotalAddedValueTax();
                    dbOrderProduct.setTotalAddedValueTax(oldAddedValueTax * (dbOrderProduct.getNum() / productNum)); //单个税费 * 购买数量(不含赠品)
                    newOrderProduct.setTotalAddedValueTax(newAddedValueTax * (newOrderProduct.getNum() / productNum)); //单个税费 * 购买数量(不含赠品)

                    //总应付税费 shouldPayTotalTax---获取老的应付税费（不能使用单个计算，因为单个税费不包含经理折扣）
                    Double oldshouldPayTotalTax = dbOrderProduct.getShouldPayTotalTax();
                    Double NewhouldPayTotalTax = newOrderProduct.getShouldPayTotalTax();
                    dbOrderProduct.setShouldPayTotalTax(oldshouldPayTotalTax * (dbOrderProduct.getNum() / productNum)); //单个税费 * 购买数量(不含赠品)
                    newOrderProduct.setShouldPayTotalTax(NewhouldPayTotalTax * (newOrderProduct.getNum() / productNum)); //单个税费 * 购买数量(不含赠品)

                    // 总价 totalFee
                    dbOrderProduct.setTotalFee(dbOrderProduct.getDiscountPrice() * dbOrderProduct.getNum() + (dbOrderProduct.getAddedValueTax() * dbOrderProduct.getNum())); //折后单价 * 购买数量(不含赠品) + 税费
                    newOrderProduct.setTotalFee(newOrderProduct.getDiscountPrice() * newOrderProduct.getNum() + (newOrderProduct.getAddedValueTax() * newOrderProduct.getNum())); //折后单价 * 购买数量(不含赠品)+ 税费
                    //todo 5.0.0 经理折扣在订单商品中移除
                    // 经理折扣 discountFee
                    dbOrderProduct.setDiscountFee(dbOrderProduct.getDiscountFee() * (MathUtil.div(dbOrderProduct.getNum(), productNum).doubleValue())); // 按拆单前后购买数量的比例来分经理折扣
//                    cfrOld.setDeductionAmount(dbOrderProduct.getDiscountFee().toString());
                    newOrderProduct.setDiscountFee(newOrderProduct.getDiscountFee() * (MathUtil.div(newOrderProduct.getNum(), productNum).doubleValue())); // 按拆单前后购买数量的比例来分经理折扣
//                    cfrNew.setDeductionAmount(newOrderProduct.getDiscountFee().toString());
                    // 优惠 preferential
                    dbOrderProduct.setPreferential((dbOrderProduct.getPrice() - dbOrderProduct.getDiscountPrice()) * dbOrderProduct.getNum()); // 优惠 (price - discountPrice) * num
                    newOrderProduct.setPreferential((newOrderProduct.getPrice() - newOrderProduct.getDiscountPrice()) * newOrderProduct.getNum()); // 优惠 (price - discountPrice) * num
                    // 应付金额
                    dbOrderProduct.setShouldPayFee(dbOrderProduct.getTotalFee() - dbOrderProduct.getDiscountFee()); //应付金额 = totalFee - discountFee'
//                    cfrOld.setShouldPayAmount(dbOrderProduct.getShouldPayFee().toString());
                    newOrderProduct.setShouldPayFee(newOrderProduct.getTotalFee() - newOrderProduct.getDiscountFee()); //应付金额 = totalFee - discountFee'
//                    cfrNew.setShouldPayAmount(newOrderProduct.getShouldPayFee().toString());
                    // 应付供应商
                    dbOrderProduct.setShopFee(dbOrderProduct.getSingleShopFee() * (dbOrderProduct.getNum() + dbOrderProduct.getPresentNum()));
                    newOrderProduct.setShopFee(newOrderProduct.getSingleShopFee() * (newOrderProduct.getNum() + newOrderProduct.getPresentNum())); // 后台拆单后订单有采美 发货 应付金额全部给采美
                    // 应付第三方（不能使用单个计算，因为单个税费不包含经理折扣）
                    Double oldOtherFee = dbOrderProduct.getOtherFee();
                    Double newOtherFee = newOrderProduct.getOtherFee();
                    dbOrderProduct.setOtherFee((oldOtherFee / productNum) * dbOrderProduct.getNum());
                    newOrderProduct.setOtherFee((newOtherFee / productNum) * newOrderProduct.getNum()); // 后台拆单后订单有采美 发货 应付金额全部给采美
                    // 应付采美
                    Double oldCmFee = dbOrderProduct.getCmFee();
                    Double newCmFee = newOrderProduct.getCmFee();
                    dbOrderProduct.setCmFee((oldCmFee / productNum) * dbOrderProduct.getNum());
                    newOrderProduct.setCmFee((newCmFee / productNum) * newOrderProduct.getNum());
                    //重新计算orderProduct总价
                    dbOrderProduct.setTotalAmount(dbOrderProduct.getNum() * dbOrderProduct.getPrice());
//                    cfrOld.setTotalAmount(dbOrderProduct.getTotalAmount().toString());
                    newOrderProduct.setTotalAmount(newOrderProduct.getNum() * newOrderProduct.getPrice());
//                    cfrNew.setTotalAmount(newOrderProduct.getTotalAmount().toString());
                    newOrderProduct.setShopID(1000); // shopID = 1000 数据库固定数据表示采美
                    oldOrderProductList.add(dbOrderProduct);
                    newOrderProductList.add(newOrderProduct);
                }
                NewShopOrder dbShopOrder = newShopOrderService.findByShopOrderID(shopOrderID);
                // 我要把没有参与拆单的订单商品 添加到oldOrderProductList 里面重新统计订单金额
                loopA:
                for (NewOrderProduct nop : dbShopOrder.getNewOrderProducts()) {
                    loopB:
                    for (NewOrderProduct old : oldOrderProductList) {
                        if (old.getOrderProductID().intValue() == nop.getOrderProductID().intValue()) {
                            continue loopA;
                        }
                    }
                    oldOrderProductList.add(nop); // looB  正常结束  说明这个nop没有参与拆单
                }
                newOrderService.splitOrder(shopOrderID, oldOrderProductList, newOrderProductList, cfrBakList);
            }
            map.put("success", true);
        } catch (Exception e) {
            logger.debug(e.toString(), e);
            map.put("success", false);
            map.put("msg", "拆分失败");
        }
        return map;
    }


    /**
     * 获取子订单所有的发货记录
     *
     * @param shopOrderID
     * @return
     */
    @RequiresPermissions("order:order:edit")
    @RequestMapping("logisticsList")
    public String logisticsList(Integer shopOrderID, Model model) {
        List<List<NewOrderProduct>> logisticsList = newOrderProductService.logisticsList(shopOrderID);
        model.addAttribute("logisticsList", logisticsList);
        return "modules/order/addLogistics";
    }

    /**
     * 发货完成以后去追加物流信息的页面,并且展示已有的物流单号
     *
     * @param logisticsBatchID 发货批次ID
     * @return
     */
    @RequiresPermissions("order:order:edit")
    @RequestMapping("toAppendLogisticsInfo")
    public String toAppendLogisticsInfo(String logisticsBatchID, Model model) {
        List<NewOrderProduct> opInfo = newShopOrderService.getBatchInfo(logisticsBatchID);
        Map<String, List<String>> loInfo = newShopOrderService.getLogisticsInfo(logisticsBatchID);
        model.addAttribute("opInfo", opInfo);
        model.addAttribute("loInfo", loInfo);
        model.addAttribute("logisticsBatchID", logisticsBatchID);
        return "modules/order/appendShipLogistic";
    }

    /**
     * 已经发货后追加物流信息
     * params = {logisticsBatchID : 发货批次, remarks: 备注, logisticsInfo_快递公司名称: 单号_单号_.... }
     *
     * @return
     */
    @RequiresPermissions("order:order:edit")
    @RequestMapping("appendLogisticsInfo")
    @ResponseBody
    public Map<String, Object> appendLogisticsInfo(@RequestBody Map<String, String> params) {
        Map<String, Object> result = new HashMap<>();
        String logisticsBatchID = null;
        String remarks = null;
        Map<String, List<String>> logisticsInfo = new HashMap<>();//物流编码
        // 参数转换
        for (Map.Entry<String, String> entry : params.entrySet()) {
            if ("logisticsBatchID".equals(entry.getKey()))
                logisticsBatchID = entry.getValue();
            if ("remarks".equals(entry.getKey()))
                remarks = entry.getValue();
            if (entry.getKey().contains("logisticsInfo")) {
                List<String> logisticsNus = Arrays.asList(entry.getValue().split("_"));
                logisticsInfo.put(entry.getKey().split("_")[1], logisticsNus);
            }
        }
        try {
            Integer shopOrderID = newShopOrderService.appendLogisticsInfo(logisticsBatchID, logisticsInfo, remarks);
            result.put("shopOrderID", shopOrderID);
            result.put("success", true);
        } catch (Exception e) {
            result.put("success", false);
            logger.debug(e.toString(), e);
            result.put("msg", "数据异常");
        }
        return result;
    }

    /**
     * 根据订单类型以及状态去不同的详情页
     * (这是5.0.0以前的订单详情页面)
     *
     * @param order
     * @return
     */
    @RequiresPermissions("order:order:edit")
    @RequestMapping("detailPage")
    public String detailPage(NewOrder order, Integer shopOrderID, Model model) {
        if (order.getOrderID() != null) {
            model.addAttribute("orderID", order.getOrderID());
            model.addAttribute("orderProducts", order.getOrderProduct());
        } else {
            model.addAttribute("shopOrderID", shopOrderID);
        }
        NewShopOrder shopOrder = null;
        if (shopOrderID != null) {
            shopOrder = newShopOrderService.findByShopOrderID(shopOrderID);
            order = newOrderService.get(shopOrder.getOrderID().toString());
            model.addAttribute("orderProducts", shopOrder.getNewOrderProducts());
            model.addAttribute("snOrderProducts", shopOrder.getSnOrderProducts());
        }

        if (shopOrderID != null && shopOrder.getSnOrderProducts() != null && shopOrder.getSnOrderProducts().size() > 0) {
            //查询是否输入过SN码
            List<CmProductSn> listSign = cmProductSnService.findSnByShopOrderID(shopOrderID);
            if (null != listSign && listSign.size() > 0) {
                model.addAttribute("listSign", listSign);
            }
        }

        String payWay = order.getPayWay();
        if (payWay != null) {
            for (NewPayWay type : NewPayWay.values()) {
                if (payWay.contains(type.getCode() + ""))
                    payWay = payWay.replaceAll(type.getCode() + "", type.getDesc());
            }
            order.setPayWay(payWay);
        } else {
            order.setPayWay("-");
        }
        model.addAttribute("orderUserInfo", order.getBpOrderUserinfo());
        model.addAttribute("shopOrder", shopOrder);
        model.addAttribute("order", order);
        if ("0".equals(order.getOrderType())) {
            // 协销订单
            return "modules/order/bpOrderDetail";
        } else {
            // 普通订单
            return "modules/order/normalOrderDetail";
        }
    }


    /**
     * 订单详情页 5.0.0版本  x
     * 这个是新改的协销订单的详情页面
     *
     * @param order
     * @return
     */
    @RequiresPermissions("order:order:view")
    @RequestMapping("detail")
    public String detail(NewOrder order, Model model) {
        BpClause bpClause = new BpClause();
        bpClause.setEnabledStatus("1");
        List<BpClause> bpClauses = bpClauseService.findList(bpClause);
        model.addAttribute("bpClauses", bpClauses);
        //获取订单是否可以申请付款
        List<Integer> oId = new ArrayList<>();
        oId.add(order.getOrderID());
        List<Integer> orderIdsInApplyReturn = cmReturnedPurchaseDao.findOrderIDsInApplyReturnFlag(oId);
        if (CollectionUtils.isNotEmpty(orderIdsInApplyReturn) && orderIdsInApplyReturn.size() > 0) {
            order.setApplyReturnedPurchaseFlag("0");
        } else {
            order.setApplyReturnedPurchaseFlag("1");
        }
        //判断是否有在收款审核的订单
        List<Integer> ids = cmReceiptOrderRelationDao.toAudit(order.getOrderID());
        if (ids != null && ids.size() > 0) {
            order.setToAudit("1");
        }
        //一个子订单只有一个商品时,不可拆分
        int count = 0;
        for (NewShopOrder newShopOrder : order.getNewShopOrders()) {
            if (newShopOrder.getShopID() != 998) {
                count++;
            }
        }
        if (order.getProductCount() == null) {
            order.setProductCount(1);
        }
        if (order.getProductCount() <= count) {
            order.setSplitFlag("0");
        }
        //是否抹平支付过（抹平最多只允许存在一次）
        CmDiscernReceipt cmDiscernReceipt = cmDiscernReceiptDao.findSmoothoutInfo(order.getOrderID().toString());
        if (null != cmDiscernReceipt) {
            order.setAssociationType(cmDiscernReceipt.getAssociationType());
            String confirmType = cmDiscernReceipt.getConfirmType();
            order.setConfirmType(confirmType);

            // 是否是一比款收了多个订单
            if (StringUtils.equals(confirmType, "1") || StringUtils.equals(confirmType, "2") || StringUtils.equals(confirmType, "3")) {
                List<CmReceiptOrderRelation> byReceiptList = cmReceiptOrderRelationService.findByReceiptID(cmDiscernReceipt.getId());
                if (CollectionUtils.isNotEmpty(byReceiptList) && byReceiptList.size() > 1) {
                    order.setReceiptOrderFlag(true);
                }
            }
        }

        // 订单已收款才会出现抹平或者多收退余额，（已收再退款或者撤销退款订单即使存在抹平也需要当未抹平重新计算付款）
        String receiptStatus = order.getReceiptStatus();
        if (StringUtils.equals("3", receiptStatus)) {
            if (null != cmDiscernReceipt) {
                String confirmType = cmDiscernReceipt.getConfirmType();
                order.setConfirmType(confirmType);
                double associateAmount = cmDiscernReceiptDao.getAssociateAmount(String.valueOf(order.getOrderID()));
                order.setOrderReceivedAmount(associateAmount);
                //大额退余额
                if (StringUtils.equals("3", confirmType)) {
                    String id = cmDiscernReceipt.getId();
                    double returnBalanceAmount = cmDiscernReceiptDao.getReturnBalanceAmount(id);
                    order.setReturnBalanceAmount(returnBalanceAmount);
                }
            }
        }

        model.addAttribute("order", order);
        if ("0".equals(order.getStatus())) {
            try {
                NewOrderConfig confirmOverTime = newOrderConfigService.getValueByKey("confirmOverTime");
                Double value = confirmOverTime.getValue(); //待确认超过 value 小时自动取消订单
                GregorianCalendar gc = new GregorianCalendar();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                Date orderTime = sdf.parse(order.getOrderTime());
                gc.setTime(orderTime);
                gc.add(Calendar.HOUR, value.intValue());
                Date time = gc.getTime();
                String ot = sdf.format(time);
                if (time.after(new Date()))
                    model.addAttribute("time", ot);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        CmReturnedPurchase cmReturnedPurchase = new CmReturnedPurchase();
        cmReturnedPurchase.setStatus("2");
        cmReturnedPurchase.setOrderID(order.getOrderID());
        List<CmReturnedPurchase> dataList = cmReturnedPurchaseService.getReturnedPurchaseList(cmReturnedPurchase);
        Double returnedPurchaseFee = 0D;    //退款(退货)总金额
        Double refundFee = 0D;  //退款总额(给买家)
        for (CmReturnedPurchase bean : dataList) {
            if (!bean.getStatus().equals("3")) {
                returnedPurchaseFee += bean.getReturnedPurchaseFee();
                refundFee += bean.getRefundFee();
            }
        }
        double returnValue = 0d;   //退货价值
        if (order.getDiscountFee() >= returnedPurchaseFee) {
            returnValue = 0d;   //如果经理折扣大于退款(退货)总金额之和  那么先抵扣经理折扣  退款价值为0
        } else {
            returnValue = returnedPurchaseFee - order.getDiscountFee(); //抵用完经理折扣后才是真实价值
        }
        //订单已收金额
        Double receiptAmount = cmDiscernReceiptService.findOrderReceipt(order.getOrderID());
        model.addAttribute("returnValue", returnValue);
        model.addAttribute("receiptAmount", receiptAmount == null ? 0 : receiptAmount);
        model.addAttribute("returnedPurchaseFee", returnedPurchaseFee);
        return "modules/order/orderDetail";
    }


    /**
     * 去拆分订单详情页 5.0.0版本
     *
     * @param order
     * @return
     */
    @RequiresPermissions("order:order:edit")
    @RequestMapping("toSplit")
    public String toSplit(NewOrder order, Model model) {
        BpClause bpClause = new BpClause();
        bpClause.setEnabledStatus("1");
        List<BpClause> bpClauses = bpClauseService.findList(bpClause);
        model.addAttribute("bpClauses", bpClauses);
        model.addAttribute("order", order);
        return "modules/order/splitPage";
    }

    /**
     * 普通订单修改
     *
     * @param order
     * @param model
     * @return
     */
    @RequiresPermissions("order:order:edit")
    @RequestMapping("normalOrderModify")
    public String normalOrderModify(NewOrder order, Model model) {
        model.addAttribute("order", order);
        return "modules/order/modifyProduct";
    }

    /**
     * 更新普通订单
     *
     * @param newOrder
     * @param model
     * @return
     */
    @RequiresPermissions("order:order:edit")
    @RequestMapping("updateNormalOrder")
    public String updateNormalOrder(NewOrder newOrder, Model model) {
        if (!beanValidator(model, newOrder)) {
            return normalOrderModify(newOrder, model);
        }
        if (CollectionUtils.isEmpty(newOrder.getOrderProduct())) {
            model.addAttribute("message", "保存失败商品不能为空");
            return normalOrderModify(newOrder, model);
        } else {
            List<NewOrderProduct> orderProductList = Lists.newArrayList();
            for (NewOrderProduct newOrderProduct : newOrder.getOrderProduct()) {
                if (StringUtils.isNotEmpty(newOrderProduct.getEnabledStatus())) {
                    NewOrderProduct o = (NewOrderProduct) JsonMapper.fromJsonString(newOrderProduct.getEnabledStatus(), NewOrderProduct.class);
                    Integer presentNum = o.getPresentNum() != null ? o.getPresentNum() : 0;
                    o.setPreferential((o.getPrice() - o.getDiscountPrice()) * o.getNum());//折扣
                    o.setDiscountFee(o.getTotalFee() - o.getShouldPayFee());//经理折扣
                    o.setTotalAmount(o.getPrice() * o.getNum());//商品总金额
                    o.setNotOutStore(o.getNum() + presentNum);
                    orderProductList.add(o);
                }
            }
            if (CollectionUtils.isNotEmpty(orderProductList)) {
                newOrder.setOrderProduct(orderProductList);
            }
        }
        //更新订单
        newOrderService.updateNormalOrder(newOrder);
        return "redirect:" + Global.getAdminPath() + "/order/detailPage/?id=" + newOrder.getOrderID();
    }

    /**
     * 物流详情展示
     * <p>
     * //     * @param shopOrderID
     *
     * @param model
     * @return
     */
    @RequiresPermissions("order:order:edit")
    @RequestMapping("logisticsDetails")
    public String logisticsDetails(Integer orderID, String logisticsBatchID, Model model) {
        List<LogisticsInfoVo> logisticsInfoVos = new ArrayList<>();
        logisticsInfoVos = newShopOrderService.logisticsDetails(orderID, logisticsBatchID);
        model.addAttribute("orderID", orderID);
        model.addAttribute("logisticsInfoVos", logisticsInfoVos);
        return "modules/order/logisticsDetails";
    }

    /**
     * 删除订单
     *
     * @return
     */
    @RequiresPermissions("order:order:delete")
    @RequestMapping("deleteOrder")
    public String deleteOrder(NewOrder order, Integer shopOrderID) {
        if (order.getOrderID() != null) {
            newOrderService.deleteOrder(order);
        } else if (shopOrderID != null) {
            newShopOrderService.deleteOrder(shopOrderID);
        }
        return "redirect:" + Global.getAdminPath() + "/order/orderList";
    }

    // 保存订单条款信息
    @RequestMapping(value = "editclausecontent")
    public String editclausecontent(NewOrder order, Model model) {
        model.addAttribute("order", order);
        return "modules/order/orderClause";
    }

    @RequestMapping(value = "saveClause")
    public String saveClause(NewOrder order, RedirectAttributes redirectAttributes, HttpServletRequest request) {
        String clauseContent = request.getParameter("clauseContent");
        String clauseName = request.getParameter("clauseName");
        order.setClauseContent(clauseContent);
        order.setClauseName(clauseName);
        newOrderService.updateClauseContent(order);
        if (order.getOrderID() == null) {
            //订单重新保存后则修改订单商品需供应商确认
            newOrderProductService.updateShopConfigFlag(order.getOrderID());
        }
        return "redirect:" + Global.getAdminPath() + "/order/orderList";

    }

    /**
     * 导出订单信息
     *
     * @param contractOrder
     * @param shopOrderID
     * @return
     */
    @RequiresPermissions("order:order:export")
    @RequestMapping(value = "exportOrderInfo")
    public void exportOrderInfo(NewOrder contractOrder, Integer shopOrderID, RedirectAttributes redirectAttributes, HttpServletResponse response) {
        //获取订单数据
        String fileName = contractOrder.getOrderID() + "-" + contractOrder.getBpOrderUserinfo().getName() + "-采美365网购订单.xls";
        String template = Global.getConfig("export.template");
        String templateFileName = template + "/new_bpstages_template.xls";
        try {
            List<NewOrderProduct> products = newOrderProductService.findWithOrderID(contractOrder.getOrderID());
            for (NewOrderProduct orderProduct2 : products) {
                //如果 =0 则设置为 0  方便页面判断
                BigDecimal totalPay = new BigDecimal(orderProduct2.getTotalFee());
                if (totalPay.compareTo(BigDecimal.ZERO) == 0) {
                    orderProduct2.setTotalFee(0D);
                }
                //设置税费
                if (null == orderProduct2.getAddedValueTax() || "".equals(orderProduct2.getAddedValueTax()) || new BigDecimal(orderProduct2.getAddedValueTax()).compareTo(BigDecimal.ZERO) == 0) {
                    orderProduct2.setAddedValueTax(0D);
                }
                String image = orderProduct2.getImage();
                //设置图片完整路径
                orderProduct2.setImage(AppUtils.getProductImageURL(image, 0, Global.getConfig("wwwServer")));
            }
            List<NewOrderProduct> products1 = newOrderProductService.findByOrderIdGroupByShopId(contractOrder.getOrderID());
            StringBuffer shopNameInfo = new StringBuffer();
            //设置供应商信息
            for (NewOrderProduct orderProduct1 : products1) {
                shopNameInfo.append(orderProduct1.getShopName() + "、");
            }
            shopNameInfo.setLength(shopNameInfo.length() - 1);
            contractOrder.setShopNameInfo(shopNameInfo.toString());
            //设置订单商品信息
            contractOrder.setOrderProduct(products);
            BigDecimal stagesTotalFee = new BigDecimal(0);
            StringBuffer buffer = new StringBuffer();
            //设置list数据
            List<NewOrder> list = Lists.newArrayList();
            contractOrder.setClauseContent(StringUtils.replaceHtml(contractOrder.getClauseContent()));
            list.add(contractOrder);
            new ExcelUtil().createExcel(templateFileName, list, fileName, response);
        } catch (Exception e) {
            addMessage(redirectAttributes, "订单信息导出失败！" + e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 对账订单
     *
     * @param endTime    收款结束
     * @param startTime  收款开始
     * @param searchflag 0搜索，1导出
     * @return
     */
    @RequiresPermissions("order:order:edit")
    @RequestMapping("checkAccount")
    public String checkAccount(String startTime, String endTime, Page page, String searchflag, Model model, RedirectAttributes redirectAttributes, HttpServletResponse response) {
        if (StringUtils.isNotEmpty(startTime)) {
            model.addAttribute("startTime", startTime);
            startTime = startTime + " 00:00:00";
        }
        if (StringUtils.isNotEmpty(endTime)) {
            model.addAttribute("endTime", endTime);
            endTime = endTime + " 23:59:59";
        }
        NewReceiptList nr = new NewReceiptList();
        nr.setStartTime(startTime);
        nr.setEndTime(endTime);
        page.setPageSize(10);
        nr.setPage(page);
        List<NewReceiptList> checkAccountList = newReceiptListService.findCheckAccountList(nr);

        if (StringUtils.isNotEmpty(searchflag) && searchflag.length() != 2) {//导出操作
            NewReceiptList nrExcel = new NewReceiptList();
            nrExcel.setStartTime(startTime);
            nrExcel.setEndTime(endTime);
            List<NewReceiptList> excelList = newReceiptListService.findCheckAccountList(nrExcel);
            setInit(excelList);
            try {
                excel(response, excelList);
            } catch (Exception e) {
                addMessage(redirectAttributes, "采美财务对账列表！" + e.getMessage());
                e.printStackTrace();
            }
        }
        setInit(checkAccountList);//初始化列表数据
        page.setList(checkAccountList);
        model.addAttribute("page", page);
        return "modules/order/checkAccountOrder";
    }


    public void setInit(List<NewReceiptList> checkAccountList) {
        if (CollectionUtils.isNotEmpty(checkAccountList)) {
            for (NewReceiptList neList : checkAccountList) {
                //统计订单已收总金额（已收商品金额+已收运费）
                String received = neList.getReceived();//已收商品金额
                neList.setReceivedTotal(received);//给定已收总金额默认值（协销订单没有运费,以及普通订单未付款或者到付情况下已收总金额=已收商品金额）
                String orderTypeSys = neList.getOrderTypeSys();//订单类型---协销订单:0 ;普通订单:1
                String status = neList.getStatus();//0, "待付款" 1,"待确认" 2, "已付款" "6, "交易关闭
                String freight = neList.getFreight();//运费
                String freePostFlag = neList.getFreePostFlag();//免邮标志  运费：-1到付，0包邮，1需要运费
                if (StringUtils.equals(orderTypeSys, "1")) {//普通订单
                    if (StringUtils.equals(status, "2")) {//已付款
                        if (StringUtils.equals(freePostFlag, "1")) {//需要运费
                            double receivedD = Double.parseDouble(received);
                            double freightD = Double.parseDouble(freight);
                            double newReceivedTotal = receivedD + freightD;
                            neList.setReceivedTotal(String.valueOf(newReceivedTotal));//如果存在已付款的订单并且存在运费则已收金额需要加上运费
                        }
                    }
                }

                //订单全年99包邮处理
                List<NewOrderProduct> orderProductList = newOrderProductDao.findListByOrderID(neList.getOrderId());
                if (CollectionUtils.isNotEmpty(orderProductList) && orderProductList.size() > 0) {
                    for (NewOrderProduct nop : orderProductList) {
                        Integer orderProductID = nop.getProductID();
                        if (4413 == orderProductID) {
                            neList.setPostageFlag("1");//该订单是否包含99元包邮劵商品：0不是，1是99包邮劵
                        }
                    }
                }
                Map<String, Integer> typeMap = new HashMap<>();//存在同一个付款方式，过滤
                //设置支付方式（客户付款）
                String payWay = neList.getPayWay();
                String payways = "";
                if (StringUtils.isNotEmpty(payWay)) {
                    String[] split = payWay.split(",");
                    if (null != split) {
                        for (int i = 0; i < split.length; i++) {
                            Integer s = Integer.parseInt(split[i]);
                            String newPayWayName = NewPayWay.getNewPayWayName(s) + ",";
                            payways += newPayWayName;
                        }
                    }
                }
                if (null != payways && payways.length() > 0)
                    neList.setPayWay(payways.substring(0, payways.length() - 1));

                //设置交易方式（付给供应商）
                String transactionType = newReceiptListService.findTransactionType(neList.getOrderNo());
                if (StringUtils.isNotEmpty(transactionType)) {
                    String[] split = transactionType.split(",");
                    if (null != split) {
                        for (int i = 0; i < split.length; i++) {
                            Integer s = Integer.parseInt(split[i]);
                            typeMap.put("" + s, s);
                        }
                    }
                }

                String transactionTypes = "";
                if (null != typeMap) {
                    for (Integer s : typeMap.values()) {
                        if (102 == s) {
                            transactionTypes += "线下-建设银行7297,";
                        } else if (103 == s) {
                            transactionTypes += "线下-中信银行0897,";
                        } else if (104 == s) {
                            transactionTypes += "线下-中信银行7172,";
                        } else if (105 == s) {
                            transactionTypes += "线上-易宝支付,";
                        } else if (106 == s) {
                            transactionTypes += "线下-广发银行0115,";
                        } else if (101 == s) {
                            transactionTypes += "____________";
                        }
                    }
                }
                if (null != transactionTypes && transactionTypes.length() > 0)
                    neList.setTransactionType(transactionTypes.substring(0, transactionTypes.length() - 1));

                //设置三个应付信息
                NewReceiptList orderFees = newReceiptListService.findOrderFees(neList.getOrderId());
                if (null != orderFees) {
                    neList.setTaxFee(orderFees.getTaxFee());
                    neList.setShopFee(orderFees.getShopFee());
                    neList.setOtherFee(orderFees.getOtherFee());
                    neList.setCmFee(orderFees.getCmFee());
                } else {
                    neList.setTaxFee("0");
                    neList.setShopFee("0");
                    neList.setOtherFee("0");
                    neList.setCmFee("0");
                }

                //设置订单对应的供应商信息
                List<NewOrderShop> newOrderShop = newReceiptListService.findNewOrderShop(neList.getOrderId());
                neList.setNewOrderShopList(newOrderShop);
            }

        }
    }

    public void excel(HttpServletResponse response, List<NewReceiptList> excelList) {
        //创建一个webbook，对应一个Excel文件
        HSSFWorkbook wb = new HSSFWorkbook();
        //在webbook中添加一个sheet,对应Excel文件中的sheet
        HSSFSheet sheet = wb.createSheet("采美财务对账订单");

        //创建单元格，并设置值表头 设置表头居中
        HSSFCellStyle style = wb.createCellStyle();
        style.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);//垂直
        style.setAlignment(HSSFCellStyle.ALIGN_CENTER);//水平
        style.setFillForegroundColor(HSSFColor.ORANGE.index);


        HSSFCellStyle textStyle = wb.createCellStyle();
//        textStyle.setf
//            textStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);// 左右居中
//            textStyle.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);// 上下居中

        //设置列宽（第几列，宽度）receivedTotal
        sheet.setColumnWidth(0, 1500);//订单ID
        sheet.setColumnWidth(1, 4800);//订单编号
        sheet.setColumnWidth(2, 4800);//订单日期
        sheet.setColumnWidth(3, 4800);//收款日期
        sheet.setColumnWidth(4, 5000);//支付方式
        sheet.setColumnWidth(5, 5000);//客户(会所)
        sheet.setColumnWidth(6, 3200);//订单实付金额
        sheet.setColumnWidth(7, 3200);//已收总金额
        sheet.setColumnWidth(8, 3200);//已收商品金额
        sheet.setColumnWidth(9, 3200);//已收运费
        sheet.setColumnWidth(10, 5000);//付款方式
        sheet.setColumnWidth(11, 3200);//应付税费
        sheet.setColumnWidth(12, 3200);//应付供应商
        sheet.setColumnWidth(13, 6000);//供应商名称
        sheet.setColumnWidth(14, 3200);//支付类型
        sheet.setColumnWidth(15, 3200);//已付金额
        sheet.setColumnWidth(16, 3200);//应付第三方
        sheet.setColumnWidth(17, 3200);//应付采美
        sheet.setDefaultRowHeight((short) 0x270);//设置行高----貌似没有效果，所以下面每行独立设置行高

        //第一行(表头)
        String[] head = new String[]{"订单ID", "订单编号", "订单日期", "收款日期", "支付方式", "客户(会所)", "订单实付金额", "已收总金额", "已收商品金额", "已收运费", "付款方式", "应付税费", "应付供应商", "供应商名称", "支付类型", "已付金额", "应付第三方", "应付采美"};//在excel中的第4行每列的参数
        HSSFCell cell;
        HSSFRow row = sheet.createRow(0);
        for (int i = 0; i < head.length; i++) {
            cell = row.createCell(i);
            row.setHeight((short) 0x270);
            cell.setCellValue(head[i]);
            cell.setCellStyle(style);
        }

        Integer currentUseRow = 1;//当前已使用行号(表头存在一行从1开始)
        Integer currentMergeStartRow = 1;//开始合并行号
        //循环遍历所有集合数据
        if (CollectionUtils.isNotEmpty(excelList)) {
            for (NewReceiptList rp : excelList) {
                List<NewOrderShop> newOrderShopList = rp.getNewOrderShopList();
                if (CollectionUtils.isNotEmpty(newOrderShopList)) {
                    int size = newOrderShopList.size() * 2;
                    for (int i = 0; i < newOrderShopList.size() * 2; i++) {
                        String shopName = "";
                        //String shopFees = newOrderShopList.get(i).getShopFees();//已付供应商金额
                        //1、首先求解本次遍历的i原始值是多少（列如：i=0[0/1],i=1[2/3],i=2[4/5]当为[]中的值时i的原始值如i）(相邻两行需相同，合并所需)
                        //1.1、求解公式集合原始i的值【为基数时：遍历i的值 减 1 除 2 、为偶数时：遍历i的值 除 2】
                        if (0 == i) {
                            shopName = newOrderShopList.get(i).getShopName();
                        } else {
                            int valuei = i;
                            boolean isEven = false;//是否是偶数，默认基数
                            isEven = i % 2 == 0 ? true : false;//是否是偶数
                            if (isEven) {//偶数
                                valuei = i / 2;
                            } else {//基数
                                valuei = (i - 1) / 2;
                            }
                            shopName = newOrderShopList.get(valuei).getShopName();
                        }

                        HSSFRow row2 = sheet.createRow(currentUseRow);
                        row2.setHeight((short) 0x270);
                        //创建订单ID列
                        cell = row2.createCell(0);
                        cell.setCellValue(rp.getOrderId());
                        cell.setCellStyle(textStyle);
                        //创建订单编号列
                        cell = row2.createCell(1);
                        cell.setCellValue(rp.getOrderNo());
                        cell.setCellStyle(textStyle);
                        //创建订单日期列
                        cell = row2.createCell(2);
                        String createTime = "———————";
                        if (null != rp.getCreateDate()) {
                            createTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(rp.getCreateDate());
                        }
                        cell.setCellValue(createTime);
                        cell.setCellStyle(textStyle);

                        //创建收款日期列
                        cell = row2.createCell(3);
                        String PayTime = "———————";
                        if (null != rp.getPayTime()) {
                            PayTime = rp.getPayTime();
                        }
                        cell.setCellValue(PayTime);
                        cell.setCellStyle(textStyle);
                        //创建支付方式列
                        cell = row2.createCell(4);
                        String payWay = "———————";
                        if (StringUtils.isNotEmpty(rp.getPayWay())) {
                            payWay = rp.getPayWay();
                        }
                        cell.setCellValue(payWay);
                        cell.setCellStyle(textStyle);
                        //创建客户(会所)列
                        cell = row2.createCell(5);
                        cell.setCellValue(rp.getName());
                        cell.setCellStyle(textStyle);
                        //创建订单实付金额列
                        cell = row2.createCell(6);
                        String payTotalFee = "0";
                        if (null != rp.getReceived()) {
                            payTotalFee = String.format("%.2f", Double.parseDouble(rp.getPayTotalFee()));
                        }
                        String postageFlag = rp.getPostageFlag();//该订单是否包含99元包邮劵商品：0不是，1是99包邮劵
                        if (StringUtils.equals("1", postageFlag)) {
                            payTotalFee = payTotalFee + "(含99元包邮劵)";
                        }
                        cell.setCellValue(payTotalFee);
                        cell.setCellStyle(textStyle);
                        //创建已收总金额列
                        cell = row2.createCell(7);
                        String receivedTotal = "0";
                        if (null != rp.getReceivedTotal()) {
                            receivedTotal = String.format("%.2f", Double.parseDouble(rp.getReceivedTotal()));
                        }
                        cell.setCellValue(receivedTotal);
                        cell.setCellStyle(textStyle);
                        //创建已收商品金额列
                        cell = row2.createCell(8);
                        String received = "0";
                        if (null != rp.getReceived()) {
                            received = String.format("%.2f", Double.parseDouble(rp.getReceived()));
                        }
                        cell.setCellValue(received);
                        cell.setCellStyle(textStyle);

                        //创建已收运费列
                        cell = row2.createCell(9);
                        String freight = "0";//默认运费
                        String status = rp.getStatus();//状态：0, "待付款" 1,"待确认" 2, "已付款" "6, "交易关闭
                        String freePostFlag = rp.getFreePostFlag();//免邮标志  运费：-1到付，0包邮，1需要运费

                        //没区分协销或者普通订单，因为协销订单运费默认为0不影响
                        if (StringUtils.equals(status, "2")) {//已付款
                            if (StringUtils.equals(freePostFlag, "-1")) {//-1到付
                                freight = "到付";
                            } else if (StringUtils.equals(freePostFlag, "0")) {//0包邮
                                freight = "包邮";
                            } else if (StringUtils.equals(freePostFlag, "1")) {//运费
                                freight = rp.getFreight();
                            }
                        } else {//未付款
                            if (StringUtils.equals(freePostFlag, "-1")) {//-1到付
                                freight = "到付";
                            } else if (StringUtils.equals(freePostFlag, "0")) {//0包邮
                                freight = "包邮";
                            } else if (StringUtils.equals(freePostFlag, "1")) {//运费
                                freight = "0";
                            }
                        }

                        cell.setCellValue(freight);
                        cell.setCellStyle(textStyle);
                        //创建付款方式列
                        cell = row2.createCell(10);
                        String transactionType = "———————";
                        if (null != rp.getTransactionType()) {
                            transactionType = rp.getTransactionType();
                        }
                        cell.setCellValue(transactionType);
                        cell.setCellStyle(textStyle);
                        //创建应付税费列
                        cell = row2.createCell(11);
                        String taxFee = "0";
                        if (null != rp.getTaxFee()) {
                            taxFee = String.format("%.2f", Double.parseDouble(rp.getTaxFee()));
                        }
                        cell.setCellValue(taxFee);
                        cell.setCellStyle(textStyle);
                        //创建应付供应商列
                        cell = row2.createCell(12);
                        String shopFee = "0";
                        if (null != rp.getShopFee()) {
                            shopFee = String.format("%.2f", Double.parseDouble(rp.getShopFee()));
                        }
                        cell.setCellValue(shopFee);
                        cell.setCellStyle(textStyle);


                        //11创建动态已收供应商列
                        cell = row2.createCell(13);//供应商名称
                        cell.setCellValue(shopName);


                        //公式解析等同上解释---（每个供应商存在两个账：公、私账）---遍历对应公私账的列数
                        if (0 == i) {//公账
                            cell = row2.createCell(14);//支付类型
                            cell.setCellValue("公账");
                            String publicAccount = newOrderShopList.get(i).getPublicAccount();
                            if (StringUtils.isEmpty(publicAccount)) {
                                publicAccount = "0";
                            }
                            cell = row2.createCell(15);//已付金额
                            cell.setCellValue(publicAccount);
                        } else {
                            int valuei = i;
                            boolean isEven = false;//是否是偶数，默认基数
                            isEven = i % 2 == 0 ? true : false;//是否是偶数
                            if (isEven) {//偶数(公账)
                                valuei = i / 2;
                                cell = row2.createCell(14);//支付类型
                                cell.setCellValue("公账");
                                String publicAccount = newOrderShopList.get(valuei).getPublicAccount();
                                if (StringUtils.isEmpty(publicAccount)) {
                                    publicAccount = "0";
                                }
                                cell = row2.createCell(15);//已付金额
                                cell.setCellValue(publicAccount);
                            } else {//基数(私账)
                                valuei = (i - 1) / 2;
                                cell = row2.createCell(14);//支付类型
                                cell.setCellValue("私账");
                                String privateAccount = newOrderShopList.get(valuei).getPrivateAccount();
                                if (StringUtils.isEmpty(privateAccount)) {
                                    privateAccount = "0";
                                }
                                cell = row2.createCell(15);//已付金额
                                cell.setCellValue(privateAccount);
                            }
                        }


                        //创建应付三方
                        cell = row2.createCell(16);//应付三方
                        String otherFee = "0";
                        if (null != rp.getOtherFee()) {
                            otherFee = String.format("%.2f", Double.parseDouble(rp.getOtherFee()));
                        }
                        cell.setCellValue(otherFee);
                        cell.setCellStyle(textStyle);
                        //创建应付采美
                        cell = row2.createCell(17);
                        String cmFee = "0";
                        if (null != rp.getCmFee()) {
                            cmFee = String.format("%.2f", Double.parseDouble(rp.getCmFee()));
                        }
                        cell.setCellValue(cmFee);
                        cell.setCellStyle(textStyle);

                        currentUseRow += 1;//供应商大小*2决定的存在的行数(累计统计)
                    }
                    //合并订单数据（除供应商名称和已付金额外都合并）
                    for (int j = currentMergeStartRow; j < currentUseRow; j++) {
                        sheet.addMergedRegion(new CellRangeAddress(j, currentUseRow - 1, 0, 0));//起始行号，终止行号， 起始列号，终止列号
                        sheet.addMergedRegion(new CellRangeAddress(j, currentUseRow - 1, 1, 1));//起始行号，终止行号， 起始列号，终止列号
                        sheet.addMergedRegion(new CellRangeAddress(j, currentUseRow - 1, 2, 2));//起始行号，终止行号， 起始列号，终止列号
                        sheet.addMergedRegion(new CellRangeAddress(j, currentUseRow - 1, 3, 3));//起始行号，终止行号， 起始列号，终止列号
                        sheet.addMergedRegion(new CellRangeAddress(j, currentUseRow - 1, 4, 4));//起始行号，终止行号， 起始列号，终止列号
                        sheet.addMergedRegion(new CellRangeAddress(j, currentUseRow - 1, 5, 5));//起始行号，终止行号， 起始列号，终止列号
                        sheet.addMergedRegion(new CellRangeAddress(j, currentUseRow - 1, 6, 6));//起始行号，终止行号， 起始列号，终止列号
                        sheet.addMergedRegion(new CellRangeAddress(j, currentUseRow - 1, 7, 7));//起始行号，终止行号， 起始列号，终止列号
                        sheet.addMergedRegion(new CellRangeAddress(j, currentUseRow - 1, 8, 8));//起始行号，终止行号， 起始列号，终止列号
                        sheet.addMergedRegion(new CellRangeAddress(j, currentUseRow - 1, 9, 9));//起始行号，终止行号， 起始列号，终止列号
                        sheet.addMergedRegion(new CellRangeAddress(j, currentUseRow - 1, 10, 10));//起始行号，终止行号， 起始列号，终止列号
                        sheet.addMergedRegion(new CellRangeAddress(j, currentUseRow - 1, 11, 11));//起始行号，终止行号， 起始列号，终止列号
                        sheet.addMergedRegion(new CellRangeAddress(j, currentUseRow - 1, 12, 12));//起始行号，终止行号， 起始列号，终止列号
                        sheet.addMergedRegion(new CellRangeAddress(j, currentUseRow - 1, 16, 16));//起始行号，终止行号， 起始列号，终止列号
                        sheet.addMergedRegion(new CellRangeAddress(j, currentUseRow - 1, 17, 17));//起始行号，终止行号， 起始列号，终止列号
                    }

                    currentMergeStartRow += size;//提供下一个订单出账合并使用
                }

            }
        }

        try {
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            wb.write(os);
            //调用浏览器自带的下载器，要先将数据转成byte流
            String fileName = "采美订单对账列表.xls";
            byte[] content = os.toByteArray();
            response.setContentType("application/x-download");
            response.setHeader("Content-disposition", "attachment; filename=" + Encodes.urlEncode(fileName));
            response.getOutputStream().write(content);
            response.getOutputStream().flush();
            response.getOutputStream().close();
            os.flush();
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * date 2019-1-28
     * 最新的导出功能  以子订单来导出
     * 导出子订单信息
     *
     * @param shopOrderID
     * @return
     */
    @RequiresPermissions("order:order:export")
    @RequestMapping(value = "exportSubOrder")
    public void exportSubOrder(Integer shopOrderID, RedirectAttributes redirectAttributes, HttpServletResponse response) {
        //获取订单数据
        if (shopOrderID != null) {
            NewShopOrder shopOrder = newShopOrderService.findByShopOrderID(shopOrderID);
            if (shopOrder == null) {
                addMessage(redirectAttributes, "参数异常, 订单信息导出失败！");
                return;
            }
            NewOrder order = newOrderService.get(shopOrder.getOrderID().toString());
            String fileName = order.getOrderID() + "-" + order.getBpOrderUserinfo().getName() + "-采美365网购订单.xls";
            String template = Global.getConfig("export.template");
            String templateFileName = template + "/shopOrder_template.xls";
            OrderUserInfo orderUserInfo = orderUserInfoService.findByOrderID(order.getOrderID());
            Map data = new HashMap<String, Object>();
            data.put("shopOrder", shopOrder);
            data.put("order", order);
            data.put("orderUserInfo", orderUserInfo);
            new ExcelUtil().createExcel(templateFileName, data, fileName, response);
        } else {
            addMessage(redirectAttributes, "参数异常, 订单信息导出失败！");
            return;
        }
    }

    /**
     * 导出订单信息
     *
     * @param order
     * @return
     */
    @RequiresPermissions("order:order:export")
    @RequestMapping(value = "exportOrder")
    public void exportOrder(NewOrder order, RedirectAttributes redirectAttributes, HttpServletResponse response) {
        //获取订单数据
        String fileName = order.getOrderID() + "-" + order.getBpOrderUserinfo().getName() + "-采美365网购订单.xls";
        String template = Global.getConfig("export.template");
        String templateFileName = template + "/order_info_template.xls";
        try {
            //freight 运费要算一下 ,totalAddedValueTax
            Map data = new HashMap<String, Object>();
            data.put("order", order);
            new ExcelUtil().createExcel(templateFileName, data, fileName, response);
        } catch (Exception e) {
            addMessage(redirectAttributes, "订单信息导出失败！" + e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * @return
     */
    @RequiresPermissions("order:order:edit")
    @RequestMapping(value = "postageOrderForm")
    public String postageOrderForm(NewOrder newOrder, Model model) {
        newOrder.setFreight(10D);
        model.addAttribute("order", newOrder);
        return "modules/order/postageOrderForm";
    }

    @RequiresPermissions("order:order:edit")
    @RequestMapping(value = "postageOrderSave")
    public String postageOrderSave(NewOrder newOrder, Model model, RedirectAttributes redirectAttributes, HttpServletRequest request) {
        if (!beanValidator(model, newOrder)) {
            return form(newOrder, model, request);
        }
        //保存订单
        newOrderService.postageOrderSave(newOrder);
        addMessage(redirectAttributes, "保存订单成功");
        return "redirect:" + Global.getAdminPath() + "/order/orderList";
    }

    /**
     * 编辑经理折扣
     */
    @RequiresPermissions("order:order:edit")
    @RequestMapping(value = "DiscountFee")
    public String editDiscountFee(NewOrder newOrder, Model model, RedirectAttributes redirectAttributes) {
        NewOrder order = newOrderService.editDiscountFee(newOrder);
        model.addAttribute("order", order);
        return "modules/order/newOrderEdit";
    }

    /**
     * 保存经理折扣
     */
    @RequiresPermissions("order:order:edit")
    @ResponseBody
    @RequestMapping(value = "saveDiscountFee")
    public Map<String, Object> saveDiscountFee(NewOrder newOrder) {
        Map<String, Object> map = new HashMap();
        try {
            newOrderService.saveDiscountFee(newOrder);
            map.put("success", true);
            map.put("msg", "修改经理折扣成功");
        } catch (Exception e) {
            map.put("success", false);
            map.put("msg", "修改经理折扣失败");
        }
        return map;
    }

    /**
     * 供应商订单二维码
     */
    @ResponseBody
    @RequestMapping("/shopOrderLink")
    public Map<String, Object> shopOrderLink(Integer shopOrderId) {
        Map<String, Object> map = new HashMap<>();
        if (null == shopOrderId) {
            map.put("success", false);
            map.put("msg", "参数异常");
            return map;
        }
        return newOrderService.shopOrderLink(shopOrderId);
    }

    /**
     * 抹平收款数据显示
     */
    @ResponseBody
    @RequestMapping("/gatheringData")
    public Map<String, Object> gatheringData(Integer orderId) {
        Map<String, Object> map = new HashMap<>();
        if (null == orderId) {
            map.put("success", false);
            map.put("msg", "参数异常");
            return map;
        }
        return newOrderService.gatheringData(orderId);
    }

    /**
     * 抹平收款
     */
    @RequestMapping("/smoothOutCollection")
    public void smoothOutCollection(CmDiscernReceipt discernReceipt) {
        newOrderService.smoothOutCollection(discernReceipt);
    }

    /**
     * 余额抵扣
     */
    @RequestMapping("balanceDeduction")
    public String balanceDeduction(Integer orderID, RedirectAttributes redirectAttributes) {
        newOrderService.balanceDeduction(orderID);
        addMessage(redirectAttributes, "余额抵扣成功");
        return "redirect:" + Global.getAdminPath() + "/order/orderList";
    }

    /**
     * 转为返佣订单
     */
    @RequestMapping("modifyRebate")
    public String modifyRebate(Integer orderId) {
        newOrderService.modifyRebate(orderId);
        return "redirect:" + Global.getAdminPath() + "/order/orderList";
    }

    /**
     * 商品资质列表
     */
    @RequestMapping("qualificationList")
    public String qualificationList(Integer logisticsBatchId, Model model) {
        List<LogisticsRecord> logisticsRecords = newOrderService.qualificationList(logisticsBatchId);
        model.addAttribute("logisticsRecords", logisticsRecords);
        Integer orderId = 0;
        if (logisticsRecords != null && logisticsRecords.size() > 0) {
            orderId = logisticsRecords.get(0).getOrderID();
        }
        model.addAttribute("orderId", orderId);
        return "modules/order/qualification";
    }

    /**
     * 商品资质编辑页面
     */
    @RequestMapping("qualificationForm")
    public String qualificationForm(Integer recordId, Model model) {
        LogisticsRecord logisticsRecord = newOrderService.qualificationForm(recordId);
        model.addAttribute("logisticsRecord", logisticsRecord);
        return "modules/order/qualificationForm";
    }

    /**
     * 商品资质保存
     */
    @RequestMapping("saveQualification")
    public String saveQualification(LogisticsRecord logisticsRecord, RedirectAttributes redirectAttributes) {
        newOrderService.saveQualification(logisticsRecord);
        addMessage(redirectAttributes, "上传商品资质成功");
        return "redirect:" + Global.getAdminPath() + "/order/qualificationList?logisticsBatchId=" + logisticsRecord.getLogisticsBatchID();
    }

    /**
     * 查看商品资质
     */
    @RequestMapping("qualificationInfo")
    public String qualificationInfo(Integer logisticsBatchId, Integer orderId, Model model) {
        List<LogisticsRecord> recordList = newOrderService.qualificationInfo(logisticsBatchId);
        model.addAttribute("recordList", recordList);
        if (recordList != null && recordList.size() > 0) {
            model.addAttribute("shopName", recordList.get(0).getShopName());
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String uploadTime = format.format(recordList.get(0).getUploadTime());
            model.addAttribute("uploadTime", uploadTime);
        }
        model.addAttribute("logisticsBatchId", logisticsBatchId);
        model.addAttribute("orderId", orderId);
        return "modules/order/qualificationInfo";
    }
}