kmall-haikong/kmall-admin/src/main/java/com/kmall/admin/controller/OrderController.java

package com.kmall.admin.controller;

import com.kmall.admin.dto.OrderExpressDto;
import com.kmall.admin.dto.SystemFormatDto;
import com.kmall.admin.entity.*;
import com.kmall.admin.fromcomm.entity.SysUserEntity;
import com.kmall.admin.service.*;
import com.kmall.admin.utils.CalculateTax;
import com.kmall.admin.utils.ParamUtils;
import com.kmall.admin.utils.ShiroUtils;
import com.kmall.common.constant.Dict;
import com.kmall.common.constant.JxlsXmlTemplateName;
import com.kmall.common.utils.*;
import com.kmall.common.utils.excel.Entry;
import com.kmall.common.utils.excel.ExcelExport;
import com.kmall.common.utils.excel.ExcelUtil;
import com.kmall.common.utils.print.ticket.item.Ticket;
import com.kmall.common.utils.wechat.WechatMicropayApiResult;
import com.kmall.common.utils.wechat.WechatRefundApiResult;
import com.kmall.common.utils.wechat.WechatReverseApiResult;
import com.kmall.manager.manager.alipay.AliPayMicropayApiResult;
import com.kmall.manager.manager.alipay.AliPayUtil;
import com.kmall.manager.manager.merch.OmsMerchPropertiesBuilder;
import com.kmall.manager.manager.pingan.PinganUtil;
import com.kmall.manager.manager.pingan.dto.PinganResponseDto;
import com.kmall.manager.manager.wechat.WechatGlobalUtil;
import com.kmall.manager.manager.wechat.WechatUtil;
import com.kmall.manager.manager.wechat.wxglobal.dto.WechatGlobalRefundApiResult;
import net.sf.json.JSONObject;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;


/**
 * @author Scott
 * @email
 * @date 2017-08-13 10:41:09
 */
@RestController
@RequestMapping("order")
public class OrderController {
    private Log logger = LogFactory.getLog(OrderController.class);
    @Autowired
    private OrderService orderService;
    @Autowired
    private OrderGoodsService orderGoodsService;
    @Autowired
    private OrderProcessRecordService orderProcessRecordService;
    @Autowired
    private OrderRefundService orderRefundService;
    @Autowired
    private OrderExceptionRecordService orderExceptionRecordService;
    @Autowired
    private StoreService storeService;
    @Autowired
    private OrderWXPayRecordService orderWXPayRecordService;
    @Autowired
    private PinganResponseService pinganResponseService;
    @Autowired
    private ExcelUtil excelUtil;
    @Autowired
    private ShippingService shippingService;

    private volatile Integer code = 1;
    @Autowired
    private UserService userService;
    @Autowired
    private GoodsService goodsService;

    /**
     * 列表
     */
    @RequestMapping("/list")
    @RequiresPermissions("order:list")
    public R list(@RequestParam Map<String, Object> params) {
        ParamUtils.setQueryPowerByRoleType(params, "storeId", "merchSn", "thirdPartyMerchCode");
        params = ParamUtils.setTimeMap(params);
        //查询列表数据
        Query query = new Query(params);
        query.put("isOnfiilineOrder", Dict.isOnfflineOrder.item_0.getItem());
        List<OrderEntity> orderList = orderService.queryList(query);
        int total = orderService.queryTotal(query);

        PageUtils pageUtil = new PageUtils(orderList, total, query.getLimit(), query.getPage());

        return R.ok().put("page", pageUtil);
    }
    /**
     * 信息
     */
    @RequestMapping("/info/{id}")
    @RequiresPermissions("order:info")
    public R info(@PathVariable("id") Long id) {
        OrderEntity order = orderService.queryObject(id);
        return R.ok().put("order", order);
    }

    /**
     * 信息
     */
    @RequestMapping("/infos/{id}")
    @RequiresPermissions("order:infos")
    public R infos(@PathVariable("id") Long id) {
        OrderEntity order = orderService.queryInfos(id);
        return R.ok().put("order", order);
    }

    /**
     * 保存
     */
    @RequestMapping("/save")
    @RequiresPermissions("order:save")
    public R save(@RequestBody OrderEntity order) {
        orderService.save(order);

        return R.ok();
    }

    /**
     * 修改
     */
    @RequestMapping("/update")
    @RequiresPermissions("order:update")
    public R update(@RequestBody OrderEntity order) {
        orderService.update(order);

        return R.ok();
    }

    /**
     * 删除
     */
    @RequestMapping("/delete")
    @RequiresPermissions("order:delete")
    public R delete(@RequestBody Long[] ids) {
        orderService.deleteBatch(ids);

        return R.ok();
    }

    /**
     * 查看所有列表
     */
    @RequestMapping("/queryAll")
    public R queryAll(@RequestParam Map<String, Object> params) {
        ParamUtils.setQueryPowerByRoleType(params, "storeId", "merchSn", "thirdPartyMerchCode");
        List<OrderEntity> list = orderService.queryList(params);

        return R.ok().put("list", list);
    }

    /**
     * 总计
     */
    @RequestMapping("/queryTotal")
    public R queryTotal(@RequestParam Map<String, Object> params) {
        ParamUtils.setQueryPowerByRoleType(params, "storeId", "merchSn", "thirdPartyMerchCode");
        int sum = orderService.queryTotal(params);

        return R.ok().put("sum", sum);
    }

    /**
     * 确定收货
     *
     * @param id
     * @return
     */
    @RequestMapping("/confirm")
    @RequiresPermissions("order:confirm")
    public R confirm(@RequestBody Long id) {
        orderService.confirm(id);

        return R.ok();
    }

    /**
     * 发货
     *
     * @param order
     * @return
     */
    @RequestMapping("/sendGoods")
    @RequiresPermissions("order:sendGoods")
    public R sendGoods(@RequestBody OrderEntity order) {
        orderService.sendGoods(order);

        return R.ok();
    }

    /**
     * 跟踪快递轨迹
     *
     * @param id
     * @return
     */
    @RequestMapping("/getLogistics/{id}")
    @RequiresPermissions("order:getLogistics")
    public R getLogistics(@PathVariable("id") Long id) {
        Map result = orderService.getLogistics(id);
        return R.ok().put("result", result);
    }

    /**
     * 获取订单清关信息
     *
     * @param orderSn
     * @return
     */
    @RequestMapping("/getProcess/{orderSn}")
    @RequiresPermissions("order:getProcess")
    public R getProcess(@PathVariable("orderSn") String orderSn) {
        OrderProcessRecordEntity orderProcessRecordEntity = orderProcessRecordService.queryObjectByOrderSn(orderSn);
        if (orderProcessRecordEntity != null) {
            if (orderProcessRecordEntity.getShipmentStartTime() != null) {
                orderProcessRecordEntity.setShipmentStartTimeStr(
                        DateUtils.format(orderProcessRecordEntity.getShipmentStartTime(), DateUtils.DATE_TIME_PATTERN));
            }
            if (orderProcessRecordEntity.getShipmentSuccTime() != null) {
                orderProcessRecordEntity.setShipmentSuccTimeStr(
                        DateUtils.format(orderProcessRecordEntity.getShipmentSuccTime(), DateUtils.DATE_TIME_PATTERN));
            }
            if (orderProcessRecordEntity.getCustomsStartTime() != null) {
                orderProcessRecordEntity.setCustomsStartTimeStr(
                        DateUtils.format(orderProcessRecordEntity.getCustomsStartTime(), DateUtils.DATE_TIME_PATTERN));
            }
            if (orderProcessRecordEntity.getCustomsSuccTime() != null) {
                orderProcessRecordEntity.setCustomsSuccTimeStr(
                        DateUtils.format(orderProcessRecordEntity.getCustomsSuccTime(), DateUtils.DATE_TIME_PATTERN));
            }
            if (orderProcessRecordEntity.getWaybillStartTime() != null) {
                orderProcessRecordEntity.setWaybillStartTimeStr(
                        DateUtils.format(orderProcessRecordEntity.getWaybillStartTime(), DateUtils.DATE_TIME_PATTERN));
            }
            if (orderProcessRecordEntity.getWaybillSuccTime() != null) {
                orderProcessRecordEntity.setWaybillSuccTimeStr(
                        DateUtils.format(orderProcessRecordEntity.getWaybillSuccTime(), DateUtils.DATE_TIME_PATTERN));
            }
            if (orderProcessRecordEntity.getEleOrderStartTime() != null) {
                orderProcessRecordEntity.setEleOrderStartTimeStr(
                        DateUtils.format(orderProcessRecordEntity.getEleOrderStartTime(), DateUtils.DATE_TIME_PATTERN));
            }
            if (orderProcessRecordEntity.getEleOrderSuccTime() != null) {
                orderProcessRecordEntity.setEleOrderSuccTimeStr(
                        DateUtils.format(orderProcessRecordEntity.getEleOrderSuccTime(), DateUtils.DATE_TIME_PATTERN));
            }
            if (orderProcessRecordEntity.getAddOrderStartTime() != null) {
                orderProcessRecordEntity.setAddOrderStartTimeStr(
                        DateUtils.format(orderProcessRecordEntity.getAddOrderStartTime(), DateUtils.DATE_TIME_PATTERN));
            }
            if (orderProcessRecordEntity.getAddOrderSuccTime() != null) {
                orderProcessRecordEntity.setAddOrderSuccTimeStr(
                        DateUtils.format(orderProcessRecordEntity.getAddOrderSuccTime(), DateUtils.DATE_TIME_PATTERN));
            }
            if (orderProcessRecordEntity.getPaySuccTime() != null) {
                orderProcessRecordEntity.setPaySuccTimeStr(
                        DateUtils.format(orderProcessRecordEntity.getPaySuccTime(), DateUtils.DATE_TIME_PATTERN));
            }
            if (orderProcessRecordEntity.getPayStartTime() != null) {
                orderProcessRecordEntity.setPayStartTimeStr(
                        DateUtils.format(orderProcessRecordEntity.getPayStartTime(), DateUtils.DATE_TIME_PATTERN));
            }
            if (orderProcessRecordEntity.getPaymentStartTime() != null) {
                orderProcessRecordEntity.setPaymentStartTimeStr(
                        DateUtils.format(orderProcessRecordEntity.getPaymentStartTime(), DateUtils.DATE_TIME_PATTERN));
            }
            if (orderProcessRecordEntity.getPaymentSuccTime() != null) {
                orderProcessRecordEntity.setPaymentSuccTimeStr(
                        DateUtils.format(orderProcessRecordEntity.getPaymentSuccTime(), DateUtils.DATE_TIME_PATTERN));
            }
        }
        return R.ok().put("orderProcessRecordEntity", orderProcessRecordEntity);
    }

    /**
     * 打印小票
     *
     * @param id
     * @return
     */
    @RequestMapping("/printMsg")
    public R printMsg(@RequestBody Long id) {
        Ticket ticket = orderService.printMsg(id);
        return R.ok().put("ticket", ticket);
    }

    @RequestMapping("/printMsgAndChangeCode")
    public R printMsgAndChangeCode(@RequestBody Map param) {
        Integer id = (Integer) param.get("id");
        String sessionId = (String) param.get("sessionId");
        Ticket ticket = orderService.printMsg(id.longValue(),sessionId);
        return R.ok().put("ticket", ticket);
    }

    /**
     * 打印快递面单
     * @param param
     * @return
     */
    @RequestMapping("/printMsgChangeEwb")
    public R printMsgChangeEwb(@RequestBody Map param) {
        Integer id = (Integer) param.get("id");
        String sessionId = (String) param.get("sessionId");
        Ticket ticket = orderService.printMsgEwb(id.longValue(),sessionId);
        return R.ok().put("ticket", ticket);
    }

    @RequestMapping("/printCode")
    public R printMsg(){

        Map map = new HashMap();
        map.put("code",code++); // 系统中累加
        map.put("shopName","深圳xxxxxxCW店"); // 根据门店编号查询
        map.put("time",new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        map.put("orderNo",UUID.randomUUID().toString().replace("//-","")); //

        return R.ok().put("ticket", map);
    }






    /**
     * 订单取消请求
     */
    @RequiresPermissions(value = {"order:refund"})
    @RequestMapping(value = "cancel", method = RequestMethod.POST)
    public Object cancel(Long orderId) {
        OrderEntity orderInfo = orderService.queryObject(orderId);
        if (null == orderInfo) {
            return R.error("订单不存在");
        }

        if (orderInfo.getOrderStatus() != 0) {
            return R.error("订单状态不支持取消");
        }

        orderService.cancelOrder(orderInfo);
        return R.ok();
    }

    /**
     * 订单退款请求
     */
    @RequiresPermissions(value = {"order:refund"})
    @RequestMapping(value = "refund", method = RequestMethod.POST)
    public Object refund(Long orderId, String refundId, BigDecimal refundMoney) {
        OrderEntity orderInfo = orderService.queryObject(orderId);
        if (null == orderInfo) {
            return R.error("订单不存在");
        }
        if (orderInfo.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_401.getItem()) ||
            orderInfo.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_402.getItem())) {
            return R.error("订单已退款");
        }
        Double totalActualPrice = orderService.getTotalActualPrice(orderInfo.getMerchOrderSn());
        if (totalActualPrice == null) {
            totalActualPrice = 0d;
        }
        OrderProcessRecordEntity processRecordEntity = orderProcessRecordService.queryObjectByOrderSn(orderInfo.getOrderSn());
        if(org.apache.commons.lang.StringUtils.isNotEmpty(processRecordEntity.getIsCustomsSend())) {
            if (processRecordEntity.getIsCustomsSend().equalsIgnoreCase("2")) {
                return R.error("订单正在清关中，不能退款");
            }
            if (processRecordEntity.getIsCustomsSend().equalsIgnoreCase("1")) {
                return R.error("订单已清关完成，不能退款");
            }
        }
        String refundResult = "";
        if (orderInfo.getOrderStatus() != Integer.parseInt(Dict.orderStatus.item_0.getItem())) {
            if (orderInfo.getPayFlag().equalsIgnoreCase(Dict.payFlag.item_wxglobalpay.getItem())) {
                refundResult = wxGlobalRefund(orderInfo, totalActualPrice);
                if (StringUtils.isNotBlank(refundResult)) {
                    return R.error(refundResult);
                }
            } else if (orderInfo.getPayFlag().equalsIgnoreCase(Dict.payFlag.item_pingan.getItem())) {
                refundResult = pinganRefund(orderInfo, refundId);
                if (StringUtils.isNotBlank(refundResult)) {
                    return R.error(refundResult);
                }
            } else{
                refundResult = wxRefund(orderInfo,totalActualPrice);
                if(StringUtils.isNotBlank(refundResult)){
                    return R.error(refundResult);
                }
            }
        }
        return R.ok("退款成功");
    }

    /**
     * 平安申请退款
     * @param orderInfo
     * @return
     */
    private String pinganRefund(OrderEntity orderInfo, String refundId){
        Integer refundAmount =  orderInfo.getActualPrice().multiply(new BigDecimal(100)).intValue();
        PinganResponseDto responseDto = PinganUtil.pinganPayRefund(orderInfo.getMerchOrderSn(), refundId, refundAmount, null);

        if (!Objects.isNull(responseDto)) {
            responseDto.setOutNo(orderInfo.getMerchOrderSn());
            responseDto.setCreateTime(new Date());
            pinganResponseService.save(responseDto);

            if ("0".equals(responseDto.getErrcode())) {
                JSONObject tradeResult = JSONObject.fromObject(responseDto.getDatajson());
                if (Dict.pinganRefundStatus.item_1.getItem().equals(tradeResult.getString("status"))) {
                    orderService.pinganRefund(orderInfo, tradeResult, refundId);
                } else {
                    OrderRefundEntity mallOrderRefund = orderRefundService.queryObjectByOrderId(orderInfo.getId());
                    OrderRefundEntity orderRefund = new OrderRefundEntity();
                    orderRefund.setRefundType(Integer.parseInt(Dict.RefundType.item_1.getItem()));
                    orderRefund.setRefundMoney(BigDecimal.valueOf(orderInfo.getActualPrice().doubleValue()));
                    orderRefund.setRefundStatus(Integer.parseInt(Dict.RefundStatus.item_4.getItem()));
                    SysUserEntity user = ShiroUtils.getUserEntity();
                    orderRefund.setModerSn(user.getUsername());
                    orderRefund.setModTime(new Date());
                    orderRefund.setOutRefundNo(tradeResult.getString("ord_no"));
                    if (mallOrderRefund != null) {
                        orderRefund.setId(mallOrderRefund.getId());
                        orderRefundService.update(orderRefund);//退款记录
                    }
                    OrderExceptionRecordEntity mallOrderExceptionRecord = new OrderExceptionRecordEntity();
                    mallOrderExceptionRecord.setUserId(Integer.parseInt(orderInfo.getUserId() + ""));
                    mallOrderExceptionRecord.setOrderSn(orderInfo.getOrderSn());
                    mallOrderExceptionRecord.setExceptionStatus(Dict.exceptionStatus.item_03.getItem());
                    mallOrderExceptionRecord.setExceptionContent("退款失败");
                    mallOrderExceptionRecord.setCreateTime(new Date());
                    orderExceptionRecordService.save(mallOrderExceptionRecord);
                    return "发起平安支付退款失败！";
                }
            } else {
                return responseDto.getMsg();
            }
        }
        return "";
    }

    /**
     * 微信申请退款
     * @param orderInfo
     * @param totalActualPrice
     * @return
     */
    private String wxRefund(OrderEntity orderInfo,Double totalActualPrice){
        WechatRefundApiResult result = WechatUtil.wxRefund(orderInfo.getMerchOrderSn().toString(), totalActualPrice,
                orderInfo.getActualPrice().doubleValue());
        if (result.getResult_code().equals(WechatUtil.WXTradeState.SUCCESS.getCode())) {
            orderService.refund(orderInfo, result);
        } else {
            OrderRefundEntity mallOrderRefund = orderRefundService.queryObjectByOrderId(orderInfo.getId());
            OrderRefundEntity orderRefund = new OrderRefundEntity();
            orderRefund.setRefundType(Integer.parseInt(Dict.RefundType.item_1.getItem()));
            orderRefund.setRefundMoney(BigDecimal.valueOf(orderInfo.getActualPrice().doubleValue()));
            orderRefund.setRefundStatus(Integer.parseInt(Dict.RefundStatus.item_4.getItem()));
            SysUserEntity user = ShiroUtils.getUserEntity();
            orderRefund.setModerSn(user.getUsername());
            orderRefund.setModTime(new Date());
//            orderRefund.setOutRefundNo(result.getOut_refund_no());
            if (mallOrderRefund != null) {
                orderRefund.setId(mallOrderRefund.getId());
                orderRefundService.update(orderRefund);//退款记录
            }
            OrderExceptionRecordEntity mallOrderExceptionRecord = new OrderExceptionRecordEntity();
            mallOrderExceptionRecord.setOrderSn(orderInfo.getOrderSn());
            mallOrderExceptionRecord.setUserId(Integer.parseInt(orderInfo.getUserId() + ""));
            mallOrderExceptionRecord.setExceptionStatus(Dict.exceptionStatus.item_03.getItem());
            mallOrderExceptionRecord.setExceptionContent("退款失败" + result.getErr_code_des());
            mallOrderExceptionRecord.setCreateTime(new Date());
            orderExceptionRecordService.save(mallOrderExceptionRecord);
            return result.getErr_code_des();
        }
        return "";
    }

    /**
     * 微信国际申请退款
     * @param orderInfo
     * @param totalActualPrice
     * @return
     */
    private String wxGlobalRefund(OrderEntity orderInfo,Double totalActualPrice){
        WechatGlobalRefundApiResult result = WechatGlobalUtil.wxRefund(orderInfo.getMerchOrderSn().toString(), totalActualPrice,
                orderInfo.getActualPrice().doubleValue());
        if (result.getResult_code().equals(WechatUtil.WXTradeState.SUCCESS.getCode())) {
            orderService.globalRefund(orderInfo, result);
        } else {
            OrderRefundEntity mallOrderRefund = orderRefundService.queryObjectByOrderId(orderInfo.getId());
            OrderRefundEntity orderRefund = new OrderRefundEntity();
            orderRefund.setRefundType(Integer.parseInt(Dict.RefundType.item_1.getItem()));
            orderRefund.setRefundStatus(Integer.parseInt(Dict.RefundStatus.item_4.getItem()));
            orderRefund.setRefundMoney(BigDecimal.valueOf(orderInfo.getActualPrice().doubleValue()));
//            orderRefund.setOutRefundNo(result.getOut_refund_no());
            orderRefund.setModTime(new Date());
            if (mallOrderRefund != null) {
                orderRefund.setId(mallOrderRefund.getId());
                orderRefundService.update(orderRefund);//退款记录
            }
            OrderExceptionRecordEntity mallOrderExceptionRecord = new OrderExceptionRecordEntity();
            mallOrderExceptionRecord.setUserId(Integer.parseInt(orderInfo.getUserId() + ""));
            mallOrderExceptionRecord.setOrderSn(orderInfo.getOrderSn());
            mallOrderExceptionRecord.setExceptionStatus(Dict.exceptionStatus.item_03.getItem());
            mallOrderExceptionRecord.setExceptionContent("退款失败" + result.getErr_code_des());
            mallOrderExceptionRecord.setCreateTime(new Date());
            orderExceptionRecordService.save(mallOrderExceptionRecord);
            return result.getErr_code_des();
        }
        return "";
    }
    /**
     * 订单退款请求
     */
    @RequiresPermissions(value = {"order:offilineRefund"})
    @RequestMapping(value = "offilineRefund", method = RequestMethod.POST)
    public Object offilineRefund(Long orderId) {
        OrderEntity orderInfo = orderService.queryObject(orderId);
        if (null == orderInfo) {
            return R.error("订单不存在");
        }
        if (orderInfo.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_401.getItem()) ||
            orderInfo.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_402.getItem())) {
            return R.error("订单已退款");
        }

        if (orderInfo.getOrderStatus() != Integer.parseInt(Dict.orderStatus.item_0.getItem())) {
            if (Dict.payFlag.item_cash.getItem().equals(orderInfo.getPayFlag())) {
                //现金支付，直接修改订单状态
                orderService.refund(orderInfo);
            } else if (Dict.payFlag.item_weixin.getItem().equals(orderInfo.getPayFlag())) {
                //微信线下扫码支付
                WechatRefundApiResult result = WechatUtil
                        .wxRefund(orderInfo.getOrderSnWx(), orderInfo.getActualPrice().doubleValue(),
                                  orderInfo.getActualPrice().doubleValue());
                if (result.getResult_code().equals(WechatUtil.WXTradeState.SUCCESS.getCode())) {
                    orderService.refund(orderInfo, result);
                } else {
                    OrderRefundEntity mallOrderRefund = orderRefundService.queryObjectByOrderId(orderInfo.getId());
                    OrderRefundEntity orderRefund = new OrderRefundEntity();
                    orderRefund.setRefundType(Integer.parseInt(Dict.RefundType.item_1.getItem()));
                    orderRefund.setRefundMoney(BigDecimal.valueOf(orderInfo.getActualPrice().doubleValue()));
                    orderRefund.setRefundStatus(Integer.parseInt(Dict.RefundStatus.item_4.getItem()));
//                    orderRefund.setOutRefundNo(result.getOut_refund_no());
                    SysUserEntity user = ShiroUtils.getUserEntity();
                    orderRefund.setModerSn(user.getUsername());
                    orderRefund.setModTime(new Date());
                    if (mallOrderRefund != null) {
                        orderRefund.setId(mallOrderRefund.getId());
                        orderRefundService.update(orderRefund);//退款记录
                    }

                    OrderExceptionRecordEntity mallOrderExceptionRecord = new OrderExceptionRecordEntity();
                    mallOrderExceptionRecord.setUserId(Integer.parseInt(orderInfo.getUserId() + ""));
                    mallOrderExceptionRecord.setOrderSn(orderInfo.getOrderSn());
                    mallOrderExceptionRecord.setExceptionStatus(Dict.exceptionStatus.item_03.getItem());
                    mallOrderExceptionRecord.setExceptionContent("退款失败" + result.getErr_code_des());
                    mallOrderExceptionRecord.setCreateTime(new Date());
                    orderExceptionRecordService.save(mallOrderExceptionRecord);

                    return R.error(result.getErr_code_des());
                }
            }else if(Dict.payFlag.item_alipay.getItem().equals(orderInfo.getPayFlag())){
                // 支付宝线下扫码支付
                AliPayMicropayApiResult result = null;
                try {
                    result = AliPayUtil.aliTradeRefund(orderInfo.getOrderSn(),orderInfo.getActualPrice()+"",
                            "顾客退款",orderInfo.getStoreId().toString());
                } catch (Exception e) {
                    e.printStackTrace();
                }

                if (result.getCode().equals(AliPayUtil.AliPayTradeState.SUCC.getCode())) {
                    orderService.refund(orderInfo, result);
                } else {
                    OrderRefundEntity mallOrderRefund = orderRefundService.queryObjectByOrderId(orderInfo.getId());
                    OrderRefundEntity orderRefund = new OrderRefundEntity();
                    orderRefund.setRefundType(Integer.parseInt(Dict.RefundType.item_1.getItem()));
                    orderRefund.setRefundMoney(BigDecimal.valueOf(orderInfo.getActualPrice().doubleValue()));
                    orderRefund.setRefundStatus(Integer.parseInt(Dict.RefundStatus.item_4.getItem()));
//                    orderRefund.setOutRefundNo(result.getOut_refund_no());
                    SysUserEntity user = ShiroUtils.getUserEntity();
                    orderRefund.setModerSn(user.getUsername());
                    orderRefund.setModTime(new Date());
                    if (mallOrderRefund != null) {
                        orderRefund.setId(mallOrderRefund.getId());
                        orderRefundService.update(orderRefund);//退款记录
                    }

                    OrderExceptionRecordEntity mallOrderExceptionRecord = new OrderExceptionRecordEntity();
                    mallOrderExceptionRecord.setUserId(Integer.parseInt(orderInfo.getUserId() + ""));
                    mallOrderExceptionRecord.setOrderSn(orderInfo.getOrderSn());
                    mallOrderExceptionRecord.setExceptionStatus(Dict.exceptionStatus.item_03.getItem());
                    mallOrderExceptionRecord.setExceptionContent("退款失败" + result.getSubMsg());
                    mallOrderExceptionRecord.setCreateTime(new Date());
                    orderExceptionRecordService.save(mallOrderExceptionRecord);

                    return R.error(result.getSubMsg());
                }
            } else{
                return R.ok("退款成功");
            }

        }

        return R.ok("退款成功");
    }

    /**
     * 获取首页展示信息--会员购买率相关
     *
     * @param params
     * @return
     */
    @RequestMapping("/getUserOrderInfo")
    public R getUserOrderInfo(@RequestParam Map<String, Object> params) {
        ParamUtils.setQueryPowerByRoleType(params, "storeId", "merchSn", "thirdPartyMerchCode");
        int result = orderService.getUserOrderInfo(params);

        return R.ok().put("result", result);
    }

    @RequiresPermissions(value = {"order:orderSubmit"})
    @RequestMapping(value = "orderSubmit", method = RequestMethod.POST)
    @ResponseBody
    public R orderSubmit(@RequestBody List<OfflineCartEntity> offlineCartEntityList) {
        Map resultObj = null;
        try {
            SysUserEntity user = ShiroUtils.getUserEntity();
            resultObj = orderService.orderSubmit(offlineCartEntityList, user);
            if (((Integer) resultObj.get("errno")) != 0) {
                return R.error((String) resultObj.get("errmsg"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return R.ok("订单提交成功");
    }

    /**
     * 确认付款
     *
     * @param id
     * @return
     */
    @RequestMapping("/confirmPay")
    @RequiresPermissions("order:confirmPay")
    public R confirmPay(@RequestBody Long id) {
        orderService.confirmPay(id, Dict.payFlag.item_cash.getItem(), null);

        return R.ok();
    }

    @RequestMapping("/offilineOrderList")
    @RequiresPermissions("order:offilineOrderList")
    public R offilineOrderList(@RequestParam Map<String, Object> params) {
        ParamUtils.setQueryPowerByRoleType(params, "storeId", "merchSn", "thirdPartyMerchCode");
        params = ParamUtils.setTimeMap(params);
        //查询列表数据
        Query query = new Query(params);
        query.put("isOnfiilineOrder", Dict.isOnfflineOrder.item_1.getItem());
        List<OrderEntity> orderList = orderService.queryOffilineOrderList(query);
        int total = orderService.queryOffilineOrderTotal(query);


        for(OrderEntity orderEntity : orderList) {
            BigDecimal tax = new BigDecimal(0);
            Map map = new HashMap();
            map.put("orderId", orderEntity.getId());
            List<OrderGoodsEntity> goodsList = orderGoodsService.queryList(map);

            for (OrderGoodsEntity orderGoodsEntity : goodsList) {
                GoodsEntity goodsEntity = goodsService.queryObject(orderGoodsEntity.getGoodsId());
                BigDecimal goodsTax = CalculateTax.calculateFinalTax(goodsEntity,orderGoodsEntity.getMarketPrice(),goodsService).setScale(3,RoundingMode.HALF_UP);
                goodsTax = goodsTax.multiply(new BigDecimal(orderGoodsEntity.getNumber())).setScale(2,RoundingMode.HALF_UP);
                orderGoodsEntity.setTax(goodsTax);
                tax = tax.add(goodsTax).setScale(2,RoundingMode.HALF_UP);

//                BigDecimal goodsTax = orderGoodsEntity.getMarketPrice().divide(new BigDecimal(1).add(orderGoodsEntity.getGoodsRate()),2,RoundingMode.HALF_DOWN).multiply(orderGoodsEntity.getGoodsRate())
//                        .multiply(new BigDecimal(orderGoodsEntity.getNumber())).setScale(2,RoundingMode.HALF_DOWN);
//                tax = tax.add(goodsTax).setScale(2,RoundingMode.HALF_UP);
            }
            orderEntity.setTax(tax);
        }

        // 遍历循环订单是哪个店员销售的，根据订单号查询

        PageUtils pageUtil = new PageUtils(orderList, total, query.getLimit(), query.getPage());

        return R.ok().put("page", pageUtil);
    }

    /**
     * 当查验单从保税仓发货时, 会导致门店库存不还原
     * 还原查验单库存
     * @param orderSns  查验单单号
     * @return          请求结果
     */
    @RequestMapping(value = "/restore", method = RequestMethod.POST)
    public R restore (@RequestBody String orderSns) {

        if (StringUtils.isEmpty(orderSns)) {
            return R.error("订单编号不能为空!");
        }
        try {
            Boolean restore = orderService.restore(orderSns);
            if (restore) {
                return R.ok("恢复【" + orderSns + "】这些查验订单的库存成功");
            }
        } catch (Exception e) {
            return R.error("恢复【 " + orderSns + " 】这些查验订单的库存失败！");
        }
        return R.error("恢复【 " + orderSns + " 】这些查验订单的库存失败！");
    }

    @RequestMapping("/offlineInfos/{id}")
    @RequiresPermissions("order:offlineInfos")
    public R queryObjectBySysUser(@PathVariable("id") Long id) {
        OrderEntity order = orderService.queryObjectBySysUser(id);
        List<OrderWXPayRecordEntity> payRecords = orderWXPayRecordService.getRecordsByOutTradeNo(order.getOrderSn());
        BigDecimal tax = new BigDecimal(0);
        List<OrderGoodsEntity> goodsList = order.getOrderGoodsEntityList();

        for (OrderGoodsEntity orderGoodsEntity : goodsList) {
            GoodsEntity goodsEntity = goodsService.queryObject(orderGoodsEntity.getGoodsId());
            BigDecimal goodsTax = CalculateTax.calculateFinalTax(goodsEntity,orderGoodsEntity.getMarketPrice(),goodsService).setScale(3,RoundingMode.HALF_UP);
            goodsTax = goodsTax.multiply(new BigDecimal(orderGoodsEntity.getNumber())).setScale(2,RoundingMode.HALF_UP);
            orderGoodsEntity.setTax(goodsTax);
            tax = tax.add(goodsTax).setScale(2,RoundingMode.HALF_UP);

//            BigDecimal goodsTax = orderGoodsEntity.getMarketPrice().divide(new BigDecimal(1).add(orderGoodsEntity.getGoodsRate()),2,RoundingMode.HALF_DOWN).multiply(orderGoodsEntity.getGoodsRate())
//                    .multiply(new BigDecimal(orderGoodsEntity.getNumber())).setScale(2,RoundingMode.HALF_DOWN);
//            orderGoodsEntity.setTax(goodsTax);
//
//            tax = tax.add(goodsTax).setScale(2,RoundingMode.HALF_UP);

        }
        order.setTax(tax);
        order.setPayRecordList(payRecords);
        return R.ok().put("order", order);
    }

    @RequestMapping("/pickUpCodeList")
    public R pickUpCodeList(@RequestBody Map<String, Object> params) {
        ParamUtils.setQueryPowerByRoleType(params, "storeId", "merchSn", "thirdPartyMerchCode");
        //查询列表数据
        params.put("isOnfiilineOrder", Dict.isOnfflineOrder.item_1.getItem());
        List<OrderEntity> orderList = orderService.queryPickUpCodeList(params);

        return R.ok().put("list", orderList);
    }

    @RequestMapping("/wxMicropayPay")
    @RequiresPermissions("order:wxMicropayPay")
    public R wxMicropayPay(Long id, String auth_code) {
        R r = null;
        SysUserEntity user = ShiroUtils.getUserEntity();
        if (user == null) {
            throw new RRException("用户登录超时，请重新登录");
        }
        if (!user.getRoleType().equalsIgnoreCase("2")) {
            throw new RRException("该操作只允许店员账户操作");
        }
        OrderEntity orderEntity = orderService.queryObject(id);
        if (orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_201.getItem())) {
            throw new RRException("此订单已付款！");
        }
        if (orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_301.getItem())) {
            throw new RRException("此订单已完成！");
        }
        if (orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_101.getItem())) {
            throw new RRException("此订单已取消！");
        }
        if (orderEntity.getOrderStatus() == Integer.parseInt(Dict.orderStatus.item_102.getItem())) {
            throw new RRException("此订单已删除！");
        }

        //保存支付记录
        OrderWXPayRecordEntity orderWXPayRecordCurrent = orderWXPayRecordService.saveRecord(orderEntity);

        StoreEntity store = storeService.queryObject(orderEntity.getStoreId());
        WechatMicropayApiResult wechatMicropayApiResult = WechatUtil
                .wxMicropay(store.getMerchName() + "-" + store.getStoreName(), orderEntity.getOrderBizType(), null,
                            orderWXPayRecordCurrent.getOutTradeNoWX(), orderEntity.getActualPrice().doubleValue(),
                            "127.0.0.1", auth_code);
        orderWXPayRecordService.updateRecord(orderWXPayRecordCurrent.getId(), wechatMicropayApiResult);

        //当支付成功时,修改订单,并把其他支付记录撤销
        if (WechatUtil.WXTradeState.SUCCESS.getCode().equals(wechatMicropayApiResult.getTrade_state())) {
            //查询当前订单所有的支付记录
            List<OrderWXPayRecordEntity> orderWXPayRecordEntitys =
                    orderWXPayRecordService.getRecordsByOutTradeNo(orderEntity.getOrderSn());
            for (OrderWXPayRecordEntity orderWXPayRecordTemp : orderWXPayRecordEntitys) {
                //查询出来的记录排除当前已支付成功的记录,对其他记录交易状态为未撤销,未关闭的订单，调用撤销订单
                if (!orderWXPayRecordTemp.getId().equals(orderWXPayRecordCurrent.getId()) &&
                    (!WechatUtil.WXTradeState.REVOKED.getCode().equals(orderWXPayRecordTemp.getTradeState()) ||
                     !WechatUtil.WXTradeState.CLOSED.getCode().equals(orderWXPayRecordTemp.getTradeState()))) {
                    WechatReverseApiResult wechatReverseApiResult =
                            WechatUtil.wxReverse(orderWXPayRecordTemp.getOutTradeNoWX());
                    //撤销订单成功
                    if (WechatUtil.WXTradeState.SUCCESS.getCode().equals(wechatReverseApiResult.getReturn_code()) &&
                            WechatUtil.WXTradeState.SUCCESS.getCode().equals(wechatReverseApiResult.getResult_code())) {
                        //调用订单查询接口
                        WechatRefundApiResult wechatRefundApiResult =
                                WechatUtil.wxOrderQuery(orderWXPayRecordTemp.getOutTradeNoWX());
                        if (WechatUtil.WXTradeState.SUCCESS.getCode().equals(wechatRefundApiResult.getReturn_code()) &&
                                WechatUtil.WXTradeState.SUCCESS.getCode().equals(wechatRefundApiResult.getResult_code())) {
                            // 修改订单支付记录
                            orderWXPayRecordService
                                    .updateWXPayRecordTradeState(orderWXPayRecordTemp.getId(), wechatRefundApiResult);
                        }
                    }
                }
            }
            orderService.confirmPay(id, Dict.payFlag.item_weixin.getItem(), orderWXPayRecordCurrent.getOutTradeNoWX());
            r = R.ok();
            //用户支付中
        } else if (WechatUtil.WXTradeState.USERPAYING.getCode().equals(wechatMicropayApiResult.getTrade_state())) {
            r = R.error(WechatUtil.WXTradeState.USERPAYING.getCodeZn() + ",稍等片刻后请刷新页面重新查看订单状态");
            //用户支付失败
        } else if (WechatUtil.WXTradeState.PAYERROR.getCode().equals(wechatMicropayApiResult.getTrade_state())) {
            WechatReverseApiResult wechatReverseApiResult =
                    WechatUtil.wxReverse(orderWXPayRecordCurrent.getOutTradeNoWX());
            //撤销订单成功
            if (WechatUtil.WXTradeState.SUCCESS.getCode().equals(wechatReverseApiResult.getReturn_code()) &&
                    WechatUtil.WXTradeState.SUCCESS.getCode().equals(wechatReverseApiResult.getResult_code())) {
                //调用订单查询接口
                WechatRefundApiResult wechatRefundApiResult =
                        WechatUtil.wxOrderQuery(orderWXPayRecordCurrent.getOutTradeNoWX());
                if (WechatUtil.WXTradeState.SUCCESS.getCode().equals(wechatRefundApiResult.getReturn_code()) &&
                        WechatUtil.WXTradeState.SUCCESS.getCode().equals(wechatRefundApiResult.getResult_code())) {
                    // 修改订单支付记录
                    orderWXPayRecordService
                            .updateWXPayRecordTradeState(orderWXPayRecordCurrent.getId(), wechatRefundApiResult);
                }
                r = R.error(orderWXPayRecordCurrent.getErrCodeDes());
            } else {
                r = R.error(wechatReverseApiResult.getErr_code_des());
            }

        }
        return r;
    }
    /**
     * 线上订单导出请求
     */
    @RequiresPermissions(value = {"order:export"})
    @RequestMapping(value = "export")
    public Object export(@RequestParam Map<String, Object> params, HttpServletResponse response, HttpServletRequest request) {
        ParamUtils.setQueryPowerByRoleType(params, "storeId", "merchSn", "thirdPartyMerchCode");
        params = ParamUtils.setTimeMap(params);
        //查询列表数据
        params.put("isOnfiilineOrder", Dict.isOnfflineOrder.item_0.getItem());
        ExcelExport ee = new ExcelExport("线上订单信息");

        // =================================================线上订单明细导出开始=====================================
        List<OrderEntity> orderList = orderService.queryExportList(params);
        String[] header = new String[]{"订单编号", "商户订单编号", "所属门店", "供应商", "供应商第三方商户代码", "订单状态", "SKU", "商品名称", "数量",
                "销售价", "促销价", "实际支付金额", "保税模式", "快递公司", "配送单号", "快递费用", "发货状态", "修改人",
                "海关清单编号", "收货人姓名", "收件人手机", "收件人省份", "收件人城市", "收件人区县", "收件人地址", "下单时间", "支付流水号", "身份证号"
                , "原产国", "规格型号", "品牌", "单位", "毛重(kg)", "净重"};

        List<Map<String, Object>> list = new ArrayList<>();
        if (orderList != null && orderList.size() != 0) {
            for (OrderEntity orderEntity : orderList) {
                LinkedHashMap<String, Object> map = new LinkedHashMap<>();
                Integer orderStatus = orderEntity.getOrderStatus();
                String orderBizType = orderEntity.getOrderBizType();
                Integer shippingStatus = orderEntity.getShippingStatus();

                map.put("OrderSn", orderEntity.getOrderSn());
                map.put("MerchOrderSn", orderEntity.getMerchOrderSn());
                map.put("StoreName", orderEntity.getStoreName());
                map.put("SupplierThirdPartyMerchName", orderEntity.getSupplierThirdPartyMerchName());
                map.put("SupplierThirdPartyMerchCode", orderEntity.getSupplierThirdPartyMerchCode());
                map.put("OrderStatus", StringUtils.isEmpty(orderStatus.toString())? "":Dict.orderStatus.valueOf("item_"+ orderStatus).getItemName());
                map.put("SKU", orderEntity.getSku());
                map.put("GoodsName", orderEntity.getGoodsName());
                map.put("Number", orderEntity.getNumber());
                map.put("RetailPrice", orderEntity.getRetailPrice());
                map.put("TopicPrice", orderEntity.getTopicPrice());
                map.put("ActualPrice", orderEntity.getActualPrice());

                map.put("OrderBizType", StringUtils.isEmpty(orderBizType)? "":Dict.orderBizType.valueOf("item_"+orderBizType).getItemName());
                map.put("ShippingName", orderEntity.getShippingName());
                map.put("ShippingNo", orderEntity.getShippingNo());
                map.put("ShippingFee", orderEntity.getShippingFee());
                map.put("ShippingStatus", Dict.shippingStatus.valueOf("item_"+shippingStatus).getItemName());
                map.put("ModerSn", orderEntity.getModerSn());
                map.put("InvtNo", orderEntity.getOrderProcessRecord()==null?"":orderEntity.getOrderProcessRecord().getInvtNo());
                map.put("Consignee", orderEntity.getConsignee());
                map.put("Mobile", orderEntity.getMobile());
                map.put("Province", orderEntity.getProvince());
                map.put("City", orderEntity.getCity());
                map.put("District", orderEntity.getDistrict());
                map.put("Address", orderEntity.getAddress());

                map.put("OrderStartTime", orderEntity.getOrderProcessRecord()==null?"":DateUtils.format(orderEntity.getOrderProcessRecord().getAddOrderStartTime(),"yyyy-MM-dd HH:mm:ss"));
                map.put("PayId", orderEntity.getPayTransactionId());
                map.put("IdNo", orderEntity.getIdNo());
                map.put("OriCntCode", orderEntity.getOriCntCode());
                map.put("CiqProdModel", orderEntity.getCiqProdModel());
                map.put("Brand", orderEntity.getBrand());
                map.put("UnitCode", orderEntity.getUnitCode());
                map.put("GrossWeight", orderEntity.getGrossWeight());
                map.put("NetWeight", orderEntity.getNetWeight());

                // 零售价\促销价\成交价
//                map.put("SellPrice",orderEntity.getRetailPrice());
//
//                map.put("FinalPrice",orderEntity.getActualPrice());

                list.add(map);
            }
        }
        // =================================================线上订单明细导出开始=====================================
        // =================================================线上订单导出开始=====================================
        List<OrderEntity> masterOrderList = orderService.queryMasterExportList(params);
        String[] headerMatser = new String[]{"所属门店", "订单号", "会员", "支付类型", "商户订单号", "订单业务类型", "订单状态", "订付人核验", "付款状态",
                "实际支付", "订单总价", "下单时间", "快递公司", "配送单号", "快递费用", "发货状态", "修改人",};
        List<Map<String, Object>> listMaster = new ArrayList<>();
        if (masterOrderList != null && masterOrderList.size() > 0) {
            for (OrderEntity orderEntity : masterOrderList) {
                LinkedHashMap<String, Object> map = new LinkedHashMap<>();
                String orderBizType = orderEntity.getOrderBizType();
                Integer orderStatus = orderEntity.getOrderStatus();
                String isMergePay = orderEntity.getIsMergePay();
                String buyerPayCheck = orderEntity.getBuyerPayCheck();
                map.put("StoreName",orderEntity.getStoreName());
                map.put("OrderSn",orderEntity.getOrderSn());
                map.put("UserName",orderEntity.getUserName());
                map.put("IsMergePay",StringUtils.isEmpty(isMergePay)?"-":Dict.isMergePay.valueOf("item_"+isMergePay).getItemName());
                map.put("MerchOrderSn",orderEntity.getMerchOrderSn());
                map.put("OrderBizType",StringUtils.isEmpty(orderBizType)? "":Dict.orderBizType.valueOf("item_"+orderBizType).getItemName());
                map.put("OrderStatus",Dict.orderStatus.valueOf("item_"+ orderStatus).getItemName());
                map.put("BuyerPayCheck",StringUtils.isEmpty(buyerPayCheck)?"":Dict.merchReturnSubjectChecked.valueOf("item_"+buyerPayCheck).getItemName());
                map.put("PayStatus",Dict.payStatus.valueOf("item_"+orderEntity.getPayStatus()).getItemName());
                map.put("ActualPrice",orderEntity.getActualPrice());
                map.put("OrderPrice",orderEntity.getOrderPrice());
                map.put("AddTime",orderEntity.getAddTime());
                map.put("ShippingName",orderEntity.getShippingName());
                map.put("ShippingNo",orderEntity.getShippingNo());
                map.put("ShippingFee",orderEntity.getShippingFee());
                map.put("ShippingStatus",Dict.shippingStatus.valueOf("item_"+orderEntity.getShippingStatus()).getItemName());
                map.put("ModerSn",orderEntity.getModerSn());
                listMaster.add(map);
            }
        }
        // =================================================线上订单导出结束=====================================
        ee.addSheetByMap("线上订单信息", listMaster, headerMatser);
        ee.addSheetByMap("线上订单明细信息", list, header);
        ee.export(response);

        return R.ok();
    }

    /**
     * 订单修改已发货的快递信息
     */
    @RequestMapping("/updateExpressInfo")
    @RequiresPermissions("order:updateExpressInfo")
    public Object updateExpressInfo(@RequestBody OrderEntity orderEntity) {
        OrderEntity orderInfo = orderService.queryObject(orderEntity.getId());
        if (orderInfo != null){
            if(orderInfo.getShippingStatus() == Integer.parseInt(Dict.shippingStatus.item_1.getItem())) {
                OrderEntity order = new OrderEntity();
                order.setId(orderInfo.getId());
                order.setShippingCode(orderEntity.getShippingCode());
                Map map = new HashMap();
                map.put("code", orderEntity.getShippingCode());
                ShippingEntity shippingEntity = shippingService.queryObjectByCode(orderEntity.getShippingCode());
                if(shippingEntity != null) {
                    order.setShippingName(shippingEntity.getName());
                }else{
                    throw new RRException("此订单修改的快递公司信息不存在！不能操作");
                }
                order.setShippingNo(orderEntity.getShippingNo());
                order.setModerSn(ShiroUtils.getUserEntity().getUsername());
                order.setModTime(new Date());
                orderService.update(order);
            }else{
                throw new RRException("此订单"+Dict.shippingStatus.valueOf("item_"+orderInfo.getShippingStatus()).getItemName()+"！不能操作");
            }
        }
        return R.ok();
    }


    /**
     * 上传文件
     */
    @RequestMapping("/expressUpload")
    @ResponseBody
    public R expressUpload(@RequestParam("file") MultipartFile file) {
        List<OrderExpressDto> orderExpressList = new ArrayList<>();//快递信息
        try {
            Map<String, Object> beans = new HashMap<String, Object>();
            beans.put("OrderExpressList", orderExpressList);
            if (file.isEmpty()) {
                return R.error("文件不能为空！");
            }
            excelUtil.readExcel(JxlsXmlTemplateName.ORDER_EXPRESS_LIST, beans, file.getInputStream());
        } catch (Exception e) {
            e.printStackTrace();
            return R.error("导入失败！");
        }
        orderService.uploadExcel(orderExpressList);
        //上传文件
        return R.ok();
    }

    /**
     * 获取ccnet需要重发的订单数据
     */
    @RequestMapping("/wxOrderResendQueryAllList")
    public R wxOrderResendQueryAllList(@RequestParam Map<String, Object> params) {
        ParamUtils.setQueryPowerByRoleType(params, "storeId", "merchSn", "thirdPartyMerchCode");
        //查询列表数据
        Query query = new Query(params);

        List<WxOrderEntity> orderList = orderService.wxOrderResendQueryAllList(query);

        PageUtils pageUtil = new PageUtils(orderList, orderList.size(), query.getLimit(), query.getPage());

        return R.ok().put("page", pageUtil);
    }


    /**
     * 收银端支付
     * @param param
     * @return
     * @throws IOException
     */
    @RequestMapping("/orderConfirm")
    public R orderConfirm(@RequestBody Map param) throws IOException {

        SysUserEntity user = ShiroUtils.getUserEntity();
        Map resultObj = null;
        try {
//            throw new RuntimeException("系统异常");
            resultObj = orderService.offlineRetailSubmit(param,user);
            if(resultObj.get("errno") != null && ((Integer)resultObj.get("errno")) == 400){
                return R.error((String) resultObj.get("errmsg"));
            }
            return R.ok().put("resultObj", resultObj);
        }catch (Exception e) {
            if (e.getMessage().contains("java.lang.IllegalStateException: invalid auth_code!")){
                return R.error("付款码异常，请重新输入!");
            }
            return R.error(e.getMessage());
        }

    }

    /**
     *
     * @param param
     * @return
     * @throws IOException
     */
    @RequestMapping("/orderRefund")
    public R orderRefund( @RequestBody Map param) {

        SysUserEntity user = ShiroUtils.getUserEntity();
        Integer orderId = (Integer) param.get("orderId");
        OrderEntity orderInfo = orderService.queryObject(orderId.longValue());

        String sessionId = (String) param.get("sessionId");

        try {
            return orderService.orderRefund(orderInfo,sessionId,user);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return R.ok();

    }

    @RequestMapping("/resendOrderToCCNET/{orderSn}/{resendType}")
    public R resendWayBill(@PathVariable("orderSn") String orderSn, @PathVariable("resendType") String resendType){

        String response = null;
        Map map = new HashMap();
        map.put("orderSn",orderSn);
        try {
            String url = "";
            if("waybill".equals(resendType)){
                url = OmsMerchPropertiesBuilder.instance().getWxOrderResendUrl() + "/resendWaybill/"+orderSn;

            }else if("payment".equals(resendType)){
                url = OmsMerchPropertiesBuilder.instance().getWxOrderResendUrl() + "/resendPayment/"+orderSn;
            }else if("notice".equals(resendType)){
                url = OmsMerchPropertiesBuilder.instance().getWxOrderResendUrl() + "/notice/"+orderSn;
            }else if("clsOrder".equals(resendType)){
                url = OmsMerchPropertiesBuilder.instance().getWxOrderResendUrl() + "/clsOrder/"+orderSn;
            }else if("forceSend".equals(resendType)){
                url = OmsMerchPropertiesBuilder.instance().getWxOrderResendUrl() + "/forceSend/"+orderSn;
            }
            // 同步访问,返回结果字符串
            response = OkHttpUtils.post(map, url, "SSL");
            ResponseData responseData = JacksonUtils.fromStringJson(response, ResponseData.class);
            if(responseData.getCode().equalsIgnoreCase("0")){
                List<WxOrderEntity> list = responseData.getData().getRows();
            }
        } catch (Exception e) {
            logger.error("查询失败。"+e.getMessage());
        }


        return R.ok(response);
    }


    @RequestMapping("/orderDetail/{orderSn}")
    public R orderDetail(@PathVariable("orderSn") String orderSn) throws IOException {


        OrderProcessRecordEntity orderProcessRecordEntity = orderProcessRecordService.queryObjectByOrderSn(orderSn);
        OrderEntity orderEntity = orderService.queryObjectByOrderSn(orderSn);
        Map map = new HashMap();
        map.put("orderId",orderEntity.getId());
        List<OrderGoodsEntity> goodsList = orderGoodsService.queryList(map);

        BigDecimal tax = new BigDecimal(0);
        for(OrderGoodsEntity orderGoodsEntity : goodsList){
            BigDecimal retailPrice = orderGoodsEntity.getRetailPrice();
            BigDecimal goodsRate = orderGoodsEntity.getGoodsRate();
            Integer number = orderGoodsEntity.getNumber();

            GoodsEntity goodsEntity = goodsService.queryObject(orderGoodsEntity.getGoodsId());
            BigDecimal goodsTax = CalculateTax.calculateFinalTax(goodsEntity,retailPrice,goodsService).setScale(3,RoundingMode.HALF_UP);
            goodsTax = goodsTax.multiply(new BigDecimal(number)).setScale(2,RoundingMode.HALF_UP);
            orderGoodsEntity.setTax(goodsTax);
            tax = tax.add(goodsTax).setScale(2,RoundingMode.HALF_UP);
//            BigDecimal goodsTax = retailPrice.divide(new BigDecimal(1).add(goodsRate),2,RoundingMode.HALF_DOWN).multiply(goodsRate).multiply(new BigDecimal(number)).setScale(0,RoundingMode.HALF_DOWN);
        }
        String response = null;

        try {
            // 查询失败原因
            String url = OmsMerchPropertiesBuilder.instance().getWxOrderResendUrl() + "/"+orderSn;
            // 同步访问,返回结果字符串
            response = OkHttpUtils.post(map, url, "SSL");
        } catch (Exception e) {
            logger.error("查询失败。"+e.getMessage());
        }

        Map<String,Object> result = new HashMap<>();
        result.put("orderProcessRecordEntity",orderProcessRecordEntity);
        result.put("orderEntity",orderEntity);
        result.put("goodsList",goodsList);
        result.put("tax",tax.setScale(2, RoundingMode.HALF_DOWN).toString());
        result.put("response",response);

        return R.ok().put("resultObj", result);
    }

    @RequestMapping("/queryIDCardInfo/{mobile}")
    public R queryIDCardInfo(@PathVariable("mobile")String mobile) throws IOException {

        UserEntity userEntity = userService.queryByMobile(mobile);
        if (userEntity == null) {
            return R.error("该手机号未找到对应信息");
        }


        return R.ok().put("userEntity",userEntity);

    }


    @RequestMapping("/purchaseSalesInStockDetail")
//    @RequiresPermissions("order:offilineOrderList")
    public R purchaseSalesInStockDetail(@RequestParam Map<String, Object> params) {
        ParamUtils.setQueryPowerByRoleType(params, "storeId", "merchSn", "thirdPartyMerchCode");
        //查询列表数据
        Query query = new Query(params);

        List<PurchaseSalesInStockDetail> orderList = orderService.purchaseSalesInStockDetailList(query);
        int total = orderService.purchaseSalesInStockDetailTotal(query);

        // 遍历循环订单是哪个店员销售的，根据订单号查询

        PageUtils pageUtil = new PageUtils(orderList, total, query.getLimit(), query.getPage());

        return R.ok().put("page", pageUtil);
    }


    /**
     * 线下订单导出请求
     */
    @RequiresPermissions("order:exportOffilineOrder")
    @RequestMapping(value = "exportOffilineOrder")
    public R exportOffilineOrder(@RequestParam Map<String, Object> params, HttpServletResponse response, HttpServletRequest request) {
        ParamUtils.setQueryPowerByRoleType(params, "storeId", "merchSn", "thirdPartyMerchCode");
        params = ParamUtils.setTimeMap(params);
        params.put("isOnfiilineOrder", Dict.isOnfflineOrder.item_1.getItem());
        ExcelExport ee = new ExcelExport("线下订单信息");
        //查询列表数据
        // =================================================线下订单明细导出开始=====================================
        List<OrderEntity> orderEntityList = orderService.queryExportOffilineOrderList(params);
        String[] header = new String[]{"订单号", "操作店员", "购买类型", "订单业务类型", "订单状态",
                "付款状态", "sku", "商品名称", "数量", "实际支付", /*"订单总价",*/ "下单时间", "付款时间", "零售价", "优惠金额", "成交价"};

        List<Map<String, Object>> list = new LinkedList<>();
        if (orderEntityList != null && orderEntityList.size() > 0) {
            for (OrderEntity orderEntity : orderEntityList) {
                LinkedHashMap<String, Object> map = new LinkedHashMap<>();

                // 订单业务类型
                String orderBizType = orderEntity.getOrderBizType();
                // 订单状态
                Integer orderStatus = orderEntity.getOrderStatus();
                // 付款状态
                Integer payStatus = orderEntity.getPayStatus();
                map.put("OrderSn", orderEntity.getOrderSn());
                map.put("UserName", orderEntity.getUserName());
                map.put("IsOnfflineOrder", Dict.isOnfflineOrder.item_1.getItem().equals(orderEntity.getIsOnfflineOrder()) ? "线下购买" : "线上购买");
                map.put("OrderBizType", StringUtils.isEmpty(orderBizType)?"":Dict.orderBizType.valueOf("item_"+orderBizType).getItemName());
                map.put("OrderStatus", Dict.orderStatus.valueOf("item_"+orderStatus).getItemName());
                map.put("PayStatus", Dict.payStatus.valueOf("item_"+payStatus).getItemName());
                map.put("Sku", orderEntity.getSku());
                map.put("GoodsName", orderEntity.getGoodsName());
                map.put("Number", orderEntity.getNumber());

                map.put("ActualPrice", orderEntity.getActualPrice()); // 实际支付价
//                map.put("OrderPrice", orderEntity.getOrderPrice()); // 订单总价
                map.put("AddTime", orderEntity.getAddTime());

                map.put("PayTime", orderEntity.getPayTime());
                map.put("SellPrice", orderEntity.getRetailPrice()); // 零售价
                map.put("CouponPrice", orderEntity.getCouponPrice()); // 促销价
                map.put("FinalPrice", orderEntity.getActualPrice()); // 成交价

                list.add(map);
            }
        }

        // =================================================线下订单明细导出结束=====================================

        // =================================================线下订单导出开始=====================================
        List<OrderEntity> masterOrderEntityList = orderService.queryMasterExportOffilineOrderList(params);
        String[] headerMaster = new String[]{"订单号", "操作店员", "购买类型", "订单业务类型", "订单状态",
                "付款状态", "实际支付", "订单总价", "下单时间", "付款时间"};
        List<Map<String, Object>> listMaster = new LinkedList<>();
        if (masterOrderEntityList != null && masterOrderEntityList.size() > 0) {

            for (OrderEntity orderEntity : masterOrderEntityList) {
                LinkedHashMap<String, Object> map = new LinkedHashMap<>();
                // 订单业务类型
                String orderBizType = orderEntity.getOrderBizType();
                // 订单状态
                Integer orderStatus = orderEntity.getOrderStatus();
                // 付款状态
                Integer payStatus = orderEntity.getPayStatus();

                map.put("OrderSn", orderEntity.getOrderSn());
                map.put("UserName", orderEntity.getUserName());
                map.put("IsOnfflineOrder", Dict.isOnfflineOrder.item_1.getItem().equals(orderEntity.getIsOnfflineOrder()) ? "线下购买" : "线上购买");
                map.put("OrderBizType", StringUtils.isEmpty(orderBizType)?"":Dict.orderBizType.valueOf("item_"+orderBizType).getItemName());
                map.put("OrderStatus", Dict.orderStatus.valueOf("item_"+orderStatus).getItemName());
                map.put("PayStatus", Dict.payStatus.valueOf("item_"+payStatus).getItemName());
                map.put("ActualPrice", orderEntity.getActualPrice());
                map.put("OrderPrice", orderEntity.getOrderPrice());
                map.put("AddTime", orderEntity.getAddTime());
                map.put("PayTime", orderEntity.getPayTime());

                listMaster.add(map);
            }
        }
        // =================================================线下订单导出结束=====================================

        ee.addSheetByMap("线下订单信息", listMaster, headerMaster);
        ee.addSheetByMap("线下订单明细信息", list, header);
        ee.export(response);


        return R.ok();
    }


    @RequestMapping("/queryOrderStatus/{orderSn}")
    public R queryOrderStatus(@PathVariable("orderSn")String orderSn){
        try {

            // 根据订单查询是什么支付方式
            OrderEntity order = orderService.queryObjectByOrderSn(orderSn);
            if(order == null){
                return R.error("该订单不存在");
            }
            String payFlag = order.getPayFlag();
            if("alipay".equals(payFlag)){
                AliPayMicropayApiResult aliPayMicropayApiResult = AliPayUtil.aliTradeQuery(orderSn, "");
                String tradeStatus = aliPayMicropayApiResult.getTradeStatus();
                if(StringUtils.isBlank(tradeStatus)){
                    return R.error("交易不存在");
                }
                return R.ok("订单号：" +orderSn + "支付方式为：支付宝支付，"+
                        "订单支付状态："+tradeStatus);
            }else if("weixin".equals(payFlag)){
                WechatRefundApiResult wechatRefundApiResult = WechatUtil.wxOrderQuery(orderSn);
                String tradeState = wechatRefundApiResult.getTrade_state();
                String tradeStateDesc = wechatRefundApiResult.getTrade_state_desc();
                if(StringUtils.isBlank(tradeState)){
                    return R.error("交易不存在");
                }
                return R.ok("订单号：" +orderSn + "支付方式为：微信支付，"+
                        "订单支付状态："+tradeState+"。 交易详情："+tradeStateDesc);
            }else{
                return R.ok();
            }

        } catch (Exception e) {
            e.printStackTrace();
            return R.error();
        }

    }

    @RequestMapping("/queryInveResponse/{orderSn}")
    public R queryInveResponse(@PathVariable("orderSn")String orderSn){
        try {

            // 查询订单是否存在
//            OrderEntity order = orderService.queryObjectByOrderSn(orderSn);
//            if(order == null){
//                return R.error("该订单不存在");
//            }

            List<String> resultMessage = orderService.queryInveResponse(orderSn);
            if(resultMessage == null || resultMessage.size() == 0){
                resultMessage.add("暂无回执");
            }
            return R.ok().put("resultMessage",resultMessage);



        } catch (Exception e) {
            e.printStackTrace();
            return R.error("系统异常："+e.getMessage());
        }

    }








    /**
     * System Format 导出请求
     */
    @RequestMapping(value = "exportSystemFormat")
    public R exportSystemFormat(@RequestParam Map<String, Object> params, HttpServletResponse response, HttpServletRequest request) throws ParseException {

        ParamUtils.setQueryPowerByRoleType(params, "storeId", "merchSn", "thirdPartyMerchCode");
        params = ParamUtils.setTimeMap(params);
        params.put("isOnfiilineOrder", Dict.isOnfflineOrder.item_1.getItem());
        ExcelExport ee = new ExcelExport("Daily sales report");
        //查询列表数据
        // =================================================System Format导出开始=====================================
        List<SystemFormatDto> systemFormatList = orderService.queryExportSystemFormatList(params);
        String[] header = new String[]{"Receipt No.","Store Name", "Cash Register No.", "Time Stamp Details (Date & Time)", "Staff ID", "Staff Name","Pay Flag","Order Status","Order SnWx","Order SnAli",
                "HS Code", "HS Code Name", "E-matou Code", "PLU", "MychemID", "Product Name (EN)","Product Name (CN)", "Barcode", "Pack Size", "Product Specification",
                "Brand","EDLP","Current Price","Cost Price",/*"Prime Cost","Goods Number",*/"Deduction Rate","Unit Sold","Sales","Tax amount","Total Sales incl. Tax","Tax Rate",
                "GP ￥","GP %","Product Category","Supplier Name","Transaction Type","Sale Return Type","Remark"};

//        LinkedHashMap<String, Object> headerMap = initHeaderMap();
        List<Entry> headerMap = initHeaderMap();
//        List<Map<String, Object>> list = new LinkedList<>();
        List<List<Entry>> list = new ArrayList<>();
        list.add(headerMap);
        if (systemFormatList != null && systemFormatList.size() > 0) {
            for (SystemFormatDto systemFormat : systemFormatList) {

//                // 如果有退款，获取销售时间的年月和退款时间的年月
//                if (StringUtils.isNotEmpty(systemFormat.getOutRefundNo())){
//                    Date saleDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(systemFormat.getTimeStampDetails());
//                    Date refundDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(systemFormat.getRefundTime());
//                    Calendar saleC = Calendar.getInstance();
//                    saleC.setTime(saleDate);
//                    Calendar refundC = Calendar.getInstance();
//                    refundC.setTime(refundDate);
//                    int saleYear = saleC.get(Calendar.YEAR);// 销售的年
//                    int refundYear = refundC.get(Calendar.YEAR);// 退款的年
//                    int saleMonth = saleC.get(Calendar.MONTH);
//                    int refundMonth = refundC.get(Calendar.MONTH);
//
//                    // 如果是同一年并且销售时间是比退款时间少的话
//                    if (saleMonth<refundMonth && saleYear==refundYear){
//                        systemFormat.setOrderStatus(Dict.orderStatus.item_301.getItem());
//                    }
//                    if (saleYear!= refundYear){
//                        systemFormat.setOrderStatus(Dict.orderStatus.item_301.getItem());
//                    }
//
//
//                }


//                LinkedHashMap<String, Object> map = new LinkedHashMap<>(32);
                List<Entry> entries = new ArrayList<>();
                if (Objects.nonNull(systemFormat.getTaxRate()) && Objects.nonNull(systemFormat.getTotalSalesInclTax())){


                    BigDecimal unitSold = new BigDecimal(systemFormat.getUnitSold());

                    // 设置综合税额
                    BigDecimal totalSalesIncTax = new BigDecimal(systemFormat.getTotalSalesInclTax());
                    BigDecimal taxRate = new BigDecimal(systemFormat.getTaxRate());
//                    GoodsEntity goodsEntity = goodsService.queryObject(systemFormat.getGoodsId());
//                    BigDecimal goodsTax = CalculateTax.calculateFinalTax(goodsEntity,totalSalesIncTax.divide(unitSold,2,RoundingMode.HALF_UP),goodsService).setScale(3,RoundingMode.HALF_UP);
//                    goodsTax = goodsTax.multiply(unitSold).setScale(2,RoundingMode.HALF_UP);
                    String goodsTax = systemFormat.getTaxPrice();
                    systemFormat.setSales(totalSalesIncTax.subtract(new BigDecimal(goodsTax)).setScale(2,BigDecimal.ROUND_HALF_UP).toString());
                    systemFormat.setTaxAmount(totalSalesIncTax.subtract(new BigDecimal(systemFormat.getSales())).setScale(2,BigDecimal.ROUND_HALF_UP).toString());

                    // 设置实际销售额
                    systemFormat.setCurrentPrice(totalSalesIncTax.divide(unitSold,2,BigDecimal.ROUND_HALF_UP).setScale(2,BigDecimal.ROUND_HALF_UP).toEngineeringString());
                    if (Dict.orderStatus.item_401.getItem().equals(systemFormat.getOrderStatus())){
                        systemFormat.setUnitSold("-"+ unitSold);
                        systemFormat.setSales("-"+systemFormat.getSales());
                        systemFormat.setTaxAmount("-"+systemFormat.getTaxAmount());
                        systemFormat.setTotalSalesInclTax("-"+systemFormat.getTotalSalesInclTax());
                    }
                }

                if (Objects.nonNull(systemFormat.getCurrentPrice()) && Objects.nonNull(systemFormat.getEdlp())){
                    // 设置扣率
                    BigDecimal edlp = new BigDecimal(systemFormat.getEdlp());
                    BigDecimal currentPrice = new BigDecimal(systemFormat.getCurrentPrice());
                    if (!"0".equals(systemFormat.getEdlp())  && edlp.compareTo(BigDecimal.ZERO)!=0) {
                        systemFormat.setDeductionRate(new BigDecimal(1).subtract(currentPrice.divide(edlp, 4, BigDecimal.ROUND_HALF_UP)).multiply(new BigDecimal(100)).setScale(2, BigDecimal.ROUND_HALF_UP).toString()+"%");
                    }
                    if (Objects.nonNull(systemFormat.getCostPrice())){
                        // 设置GP ￥
                        systemFormat.setGp1(currentPrice.subtract(new BigDecimal(systemFormat.getCostPrice())).setScale(2,BigDecimal.ROUND_HALF_UP).toString());
                        // 设置GP %
                        if (!"0".equals(systemFormat.getCurrentPrice()) && StringUtils.isNotEmpty(systemFormat.getCurrentPrice())
                                && currentPrice.compareTo(BigDecimal.ZERO)!=0) {
                            BigDecimal gp1 = new BigDecimal(systemFormat.getGp1());
                            systemFormat.setGp2(gp1.divide(currentPrice, 4, BigDecimal.ROUND_HALF_UP).multiply(new BigDecimal(100)).setScale(2, BigDecimal.ROUND_HALF_UP).toString() + "%");
                        }
                        if (Dict.orderStatus.item_401.getItem().equals(systemFormat.getOrderStatus())){
                            if (!systemFormat.getGp1().contains("-")) {
                                systemFormat.setGp1("-" + systemFormat.getGp1());
                            }
                            if (StringUtils.isNotEmpty(systemFormat.getGp2()) && !systemFormat.getGp2().contains("-")) {
                                systemFormat.setGp2("-" + systemFormat.getGp2());
                            }
                        }

                    }
                }
                // 如果是退货
                String orderStatus = systemFormat.getOrderStatus();
                if (Dict.orderStatus.item_401.getItem().equals(orderStatus)){
                    systemFormat.setSaleReturnType("整单退货");
                    systemFormat.setTransactionType("退货");
                }else{
                    systemFormat.setTransactionType("销售");
                }
                orderStatus = Dict.orderStatus.valueOf("item_"+orderStatus).getItemName();
                if (Objects.nonNull(systemFormat.getPrimeCost()) && Objects.nonNull(systemFormat.getGoodsNumber())) {
                    String primeCost = systemFormat.getPrimeCost();
                    BigDecimal gp = new BigDecimal(primeCost);
                    primeCost = gp.setScale(2,BigDecimal.ROUND_HALF_UP).toString();
                    systemFormat.setPrimeCost(primeCost);
                }
                /*map.put("ReceiptNo",systemFormat.getReceiptNo());
                map.put("StoreName",systemFormat.getStoreName());
                map.put("CashRegisterNo",systemFormat.getCashRegisterNo());
                map.put("TimeStampDetails",systemFormat.getTimeStampDetails());
                map.put("StaffID",systemFormat.getStaffID());
                map.put("StaffName",systemFormat.getStaffName());
                map.put("PayFlag",systemFormat.getPayFlag());
                map.put("OrderStatus",orderStatus);
                map.put("OrderSnWx",systemFormat.getOrderSnWx());
                map.put("OrderSnAli",systemFormat.getOrderSnAli());
                map.put("HSCode",systemFormat.getHsCode());
                map.put("HSCodeName",systemFormat.getHsCodeName());
                map.put("EmatouCode",systemFormat.getEmatouCode());
                map.put("PLU",systemFormat.getPlu());
                map.put("MychemID",systemFormat.getMychemID());
                map.put("ProductNameEN",systemFormat.getProductNameEN());
                map.put("ProductNameCN",systemFormat.getProductNameCN());
                map.put("Barcode",systemFormat.getBarcode());
                map.put("PackSize",systemFormat.getPackSize());
                map.put("ProductSpecification",systemFormat.getProductSpecification());
                map.put("Brand",systemFormat.getBrand());
                map.put("EDLP",systemFormat.getEdlp());
                map.put("CurrentPrice",systemFormat.getCurrentPrice());
                map.put("CostPrice",systemFormat.getCostPrice());
//                map.put("PrimeCost",systemFormat.getPrimeCost());
//                map.put("GoodsNumber",systemFormat.getGoodsNumber());
                map.put("DeductionRate",systemFormat.getDeductionRate());
                map.put("UnitSold",systemFormat.getUnitSold());
                map.put("Sales",systemFormat.getSales());
                map.put("TaxAmount",systemFormat.getTaxAmount());
                map.put("TotalSalesInclTax",systemFormat.getTotalSalesInclTax());
                map.put("TaxRate",systemFormat.getTaxRate());
                map.put("GP1",systemFormat.getGp1());
                map.put("GP2",systemFormat.getGp2());
                map.put("ProductCategory",systemFormat.getProductCategory());
                map.put("SupplierName",systemFormat.getSupplierName());
                map.put("TransactionType",systemFormat.getTransactionType());
                map.put("SaleReturnType",systemFormat.getSaleReturnType());


                map.put("Remark",systemFormat.getRemark());

                list.add(map);*/

                entries.add(new Entry("ReceiptNo",systemFormat.getReceiptNo()));
                entries.add(new Entry("StoreName",systemFormat.getStoreName()));
                entries.add(new Entry("CashRegisterNo",systemFormat.getCashRegisterNo()));
                entries.add(new Entry("TimeStampDetails",systemFormat.getTimeStampDetails()));
                entries.add(new Entry("StaffID",systemFormat.getStaffID()));
                entries.add(new Entry("StaffName",systemFormat.getStaffName()));
                entries.add(new Entry("PayFlag",systemFormat.getPayFlag()));
                entries.add(new Entry("OrderStatus",orderStatus));
                entries.add(new Entry("OrderSnWx",systemFormat.getOrderSnWx()));
                entries.add(new Entry("OrderSnAli",systemFormat.getOrderSnAli()));
                entries.add(new Entry("HSCode",systemFormat.getHsCode()));
                entries.add(new Entry("HSCodeName",systemFormat.getHsCodeName()));
                entries.add(new Entry("EmatouCode",systemFormat.getEmatouCode()));
                entries.add(new Entry("PLU",systemFormat.getPlu()));
                entries.add(new Entry("MychemID",systemFormat.getMychemID()));
                entries.add(new Entry("ProductNameEN",systemFormat.getProductNameEN()));
                entries.add(new Entry("ProductNameCN",systemFormat.getProductNameCN()));
                entries.add(new Entry("Barcode",systemFormat.getBarcode()));
                entries.add(new Entry("PackSize",systemFormat.getPackSize()));
                entries.add(new Entry("ProductSpecification",systemFormat.getProductSpecification()));
                entries.add(new Entry("Brand",systemFormat.getBrand()));
                entries.add(new Entry("EDLP",systemFormat.getEdlp()));
                entries.add(new Entry("CurrentPrice",systemFormat.getCurrentPrice()));
                entries.add(new Entry("CostPrice",systemFormat.getCostPrice()));
//                entries.add(new Entry("PrimeCost",systemFormat.getPrimeCost()));
//                entries.add(new Entry("GoodsNumber",systemFormat.getGoodsNumber()));
                entries.add(new Entry("DeductionRate",systemFormat.getDeductionRate()));
                entries.add(new Entry("UnitSold",systemFormat.getUnitSold()));
                entries.add(new Entry("Sales",systemFormat.getSales()));
                entries.add(new Entry("TaxAmount",systemFormat.getTaxAmount()));
                entries.add(new Entry("TotalSalesInclTax",systemFormat.getTotalSalesInclTax()));
                entries.add(new Entry("TaxRate",systemFormat.getTaxRate()));
                entries.add(new Entry("GP1",systemFormat.getGp1()));
                entries.add(new Entry("GP2",systemFormat.getGp2()));
                entries.add(new Entry("ProductCategory",systemFormat.getProductCategory()));
                entries.add(new Entry("SupplierName",systemFormat.getSupplierName()));
                entries.add(new Entry("TransactionType",systemFormat.getTransactionType()));
                entries.add(new Entry("SaleReturnType",systemFormat.getSaleReturnType()));


                entries.add(new Entry("Remark",systemFormat.getRemark()));

                list.add(entries);
            }

        }

        // =================================================System Format导出结束=====================================

        ee.addSheetByList("Daily sales report", list, header);
        ee.export(response);


        return R.ok();
    }

    private ArrayList<Entry> initHeaderMap() {
//        LinkedHashMap<String, Object> headerMap = new LinkedHashMap<>();
        ArrayList<Entry> entries = new ArrayList<>();
        entries.add(new Entry("ReceiptNo","销售单号"));
        entries.add(new Entry("StoreName","门店名称"));
        entries.add(new Entry("CashRegisterNo","收银台"));
        entries.add(new Entry("TimeStampDetails","销售时间"));
        entries.add(new Entry("StaffID","收银员"));
        entries.add(new Entry("StaffName","收银员姓名"));
        entries.add(new Entry("PayFlag","支付方式"));
        entries.add(new Entry("OrderStatus","支付状态"));
        entries.add(new Entry("OrderSnWx","微信流水号"));
        entries.add(new Entry("OrderSnAli","支付宝流水号"));
        entries.add(new Entry("HSCode","海关商品编码"));
        entries.add(new Entry("HSCodeName","品类名称"));
        entries.add(new Entry("EmatouCode","料件号"));
        entries.add(new Entry("PLU","PLU"));
        entries.add(new Entry("MychemID","MychemID"));
        entries.add(new Entry("ProductNameEN","商品名称(英文)"));
        entries.add(new Entry("ProductNameCN","商品名称(中文)"));
        entries.add(new Entry("Barcode","商品主条码"));
        entries.add(new Entry("PackSize","规格"));
        entries.add(new Entry("ProductSpecification","单位"));
        entries.add(new Entry("Brand","品牌"));
        entries.add(new Entry("EDLP","日常价"));
        entries.add(new Entry("CurrentPrice","实际销售价"));
        entries.add(new Entry("CostPrice","进货价"));
//        entries.add(new Entry("PrimeCost","成本价");
//        entries.add(new Entry("GoodsNumber","可用库存数");
        entries.add(new Entry("DeductionRate","扣率 (EDLP vs 实际销售价)"));
        entries.add(new Entry("UnitSold","销售数量"));
        entries.add(new Entry("Sales","销售额"));
        entries.add(new Entry("TaxAmount","综合税额"));
        entries.add(new Entry("TotalSalesInclTax","总销售额"));
        entries.add(new Entry("TaxRate","综合税率"));
        entries.add(new Entry("GP1","预估毛利额"));
        entries.add(new Entry("GP2","预估毛利率"));
        entries.add(new Entry("ProductCategory","商品类型"));
        entries.add(new Entry("SupplierName","主供应商名称"));
        entries.add(new Entry("TransactionType","销售类型"));
        entries.add(new Entry("SaleReturnType","退货类型"));
        entries.add(new Entry("Remark","备注"));
        return entries;
    }

}