package com.izouma.awesomeadmin.service.impl;

import com.izouma.awesomeadmin.constant.AppConstant;
import com.izouma.awesomeadmin.dao.*;
import com.izouma.awesomeadmin.dto.Page;
import com.izouma.awesomeadmin.dto.Result;
import com.izouma.awesomeadmin.dto.WxPayRefundData;
import com.izouma.awesomeadmin.model.*;
import com.izouma.awesomeadmin.service.*;
import com.izouma.awesomeadmin.util.*;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.xml.sax.InputSource;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.StringReader;
import java.math.BigDecimal;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * service接口实现类
 */
@Service
public class UserOrderServiceImpl implements UserOrderService {

    private static Logger logger = Logger.getLogger(UserOrderServiceImpl.class);

    @Autowired
    private UserOrderMapper userOrderMapper;

    @Autowired
    private UserInfoService userInfoService;

    @Autowired
    private WxpayTempMapper wxpayTempMapper;

    @Autowired
    private MemberPointService memberPointService;

    @Autowired
    private MemberCoinService memberCoinService;

    @Autowired
    private AlipayTempMapper alipayTempMapper;

    @Autowired
    private UserAddressMapper userAddressMapper;

    @Autowired
    private OrderAddressMapper orderAddressMapper;

    @Autowired
    private SystemConfigMapper systemConfigMapper;

    @Autowired
    private OrderRepairMapper orderRepairMapper;

    @Autowired
    private ProductInfoMapper productInfoMapper;

    @Autowired
    private StoreInfoService storeInfoService;

    @Autowired
    private RechargeRecordMapper rechargeRecordMapper;

    @Autowired
    private UserCouponMapper userCouponMapper;

    @Autowired
    private CouponDetailMapper couponDetailMapper;

    @Autowired
    private OrderImageService orderImageService;

    @Autowired
    private OrderAlbumMapper orderAlbumMapper;

    @Autowired
    private OSSFileService OSSFileService;

    @Autowired
    private ActivityInfoService activityInfoService;

    @Autowired
    private OrderAcceptLogMapper orderAcceptLogMapper;

    @Autowired
    private OrderAlbumRepairMapper orderAlbumRepairMapper;

    @Autowired
    private ClientNoticeService clientNoticeService;

    @Autowired
    private ClientOrderService clientOrderService;


    @Override
    public List<UserOrder> getUserOrderList(UserOrder record) {

        logger.info("getUserOrderList");
        try {

            return userOrderMapper.queryAllUserOrder(record);
        } catch (Exception e) {
            logger.error("getUserOrderList", e);
        }

        return null;
    }

    @Override
    public List<UserOrder> getTop10UserOrderList(UserOrder record) {

        logger.info("getTop10UserOrderList");
        try {

            return userOrderMapper.queryTop10UserOrder(record);
        } catch (Exception e) {
            logger.error("getTop10UserOrderList", e);
        }

        return null;
    }

    @Override
    public List<UserOrder> getUserOrderByPage(Page page, UserOrder record) {

        logger.info("getUserOrderByPage");
        try {

            Map<String, Object> parameter = new HashMap<String, Object>();
            parameter.put("record", record);
            parameter.put(AppConstant.PAGE, page);

            return userOrderMapper.queryUserOrderByPage(parameter);
        } catch (Exception e) {
            logger.error("getUserOrderByPage", e);
        }

        return null;
    }

    @Override
    public UserOrder getUserOrderById(String id) {

        logger.info("getUserOrderyId");
        try {

            return userOrderMapper.selectByPrimaryKey(Integer.valueOf(id));
        } catch (Exception e) {
            logger.error("getUserOrderById", e);
        }

        return null;
    }

    @Override
    public UserOrder getUserOrder(UserOrder record) {

        logger.info("getUserOrder");
        try {

            return userOrderMapper.queryUserOrder(record);
        } catch (Exception e) {
            logger.error("getUserOrder", e);
        }

        return null;
    }

    @Override
    public boolean createUserOrder(UserOrder record) {

        logger.info("createUserOrder");
        try {
            record.setOrderCode(MbappUtil.getOrderIdByUUId());
            if (record.getQuantity() != null && record.getUnitPrice() != null) {
                BigDecimal unitPrice = record.getUnitPrice();

                /**
                 * 计算价格开始
                 */
                ProductInfo productInfo = new ProductInfo();
                productInfo.setId(record.getProductId());

                productInfo = productInfoMapper.queryProductInfo(productInfo);

                if (productInfo != null) {
                    unitPrice = productInfo.getPrice();

                    if (productInfo.getProductPriceList() != null && productInfo.getProductPriceList().size() > 0) {
                        for (ProductPrice productPrice : productInfo.getProductPriceList()) {
                            if (productPrice.getMaxCounts() != null
                                    && productPrice.getMinCounts() != null
                                    && record.getQuantity() <= productPrice.getMaxCounts()
                                    && record.getQuantity() >= productPrice.getMinCounts()) {
                                unitPrice = productPrice.getPrice();
                            } else if (productPrice.getMaxCounts() == null
                                    && productPrice.getMinCounts() != null
                                    && record.getQuantity() >= productPrice.getMinCounts()) {
                                unitPrice = productPrice.getPrice();
                            } else if (productPrice.getMinCounts() == null
                                    && productPrice.getMaxCounts() != null
                                    && record.getQuantity() <= productPrice.getMaxCounts()) {
                                unitPrice = productPrice.getPrice();
                            }
                        }
                    }

                }
                /**
                 * 计算价格结束
                 */

                BigDecimal totlePrice = unitPrice.multiply(BigDecimal.valueOf(record.getQuantity()));
                record.setTotlePrice(totlePrice);
                BigDecimal dealPrice = totlePrice;


                /**
                 * 优惠券
                 */
                if (record.getUserCouponId() != null) {
                    UserCoupon userCoupon = userCouponMapper.selectByPrimaryKey(record.getUserCouponId());
                    if (userCoupon != null) {
                        if (record.getStoreId().equals(userCoupon.getStoreId())) {//订单ID和优惠券ID相等
                            CouponInfo couponInfo = userCoupon.getCouponInfo();
                            if (couponInfo != null) {
                                if (new Date().after(couponInfo.getBeginTime()) && new Date().before(couponInfo.getEndTime())) {//在可用时间内
                                    BigDecimal discountMoney = couponInfo.getDiscountMoney();
                                    BigDecimal limitMoney = couponInfo.getLimitMoney();
                                    if (totlePrice.compareTo(limitMoney) > 0) {
                                        dealPrice = totlePrice.subtract(discountMoney);

                                        userCoupon.setIsUsed("Y");
                                        userCouponMapper.updateByPrimaryKeySelective(userCoupon);

                                        CouponDetail couponDetail = new CouponDetail();
                                        couponDetail.setId(userCoupon.getCouponDetailId());
                                        couponDetail.setUseTime(new Date());
                                        couponDetail.setUseFlag("Y");
                                        couponDetailMapper.updateByPrimaryKeySelective(couponDetail);

                                    }

                                }
                            }

                        }
                    }


                }

                record.setDealPrice(dealPrice);
                record.setOffPrice(totlePrice.subtract(dealPrice));

                double point = 0;
                UserInfo userInfo = new UserInfo();
                userInfo.setId(record.getUserId());
                userInfo = userInfoService.getSingleUserInfo(userInfo);
                if (userInfo == null) {
                    return false;
                }
                double moneyPoint = userInfo.getMoneyPoint();

                if (record.getPoint() != null && record.getPoint().compareTo(BigDecimal.ZERO) > 0) {
                    point = record.getPoint().doubleValue();
                    if (record.getPoint().doubleValue() > moneyPoint) {
                        point = moneyPoint;
                    }

                }

                record.setPoint(BigDecimal.valueOf(point));
                record.setDealPrice(dealPrice.subtract(BigDecimal.valueOf(point)));//成交价减去积分


                int updates = userOrderMapper.insertSelective(record);


                if (StringUtils.isNotEmpty(record.getUserAddressId())) {
                    UserAddress userAddress = userAddressMapper.selectByPrimaryKey(Integer.valueOf(record.getUserAddressId()));

                    if (userAddress != null) {
                        OrderAddress orderAddress = new OrderAddress();

                        orderAddress.setOrderId(record.getId());
                        orderAddress.setUserId(record.getUserId());
                        orderAddress.setRealName(userAddress.getRealName());
                        orderAddress.setTelephone(userAddress.getTelephone());
                        orderAddress.setPostcode(userAddress.getPostcode());
                        orderAddress.setAddress(userAddress.getAddress());
                        orderAddress.setAddressDetail(userAddress.getAddressDetail());
                        orderAddress.setUserAddressId(record.getUserAddressId());

                        orderAddressMapper.insertSelective(orderAddress);


                    }

                }

                //购买减库存。
                if (productInfo != null) {
                    ProductInfo updateProduct = new ProductInfo();

                    updateProduct.setId(productInfo.getId());
                    updateProduct.setInventory(productInfo.getInventory() - record.getQuantity());
                    updateProduct.setSalesVolume(productInfo.getSalesVolume() + record.getQuantity());
                    productInfoMapper.updateByPrimaryKeySelective(updateProduct);
                }


                if (updates > 0) {

                    if (point > 0) {
                        //积分兑换区 只能用商城积分
                        MemberPoint memberPoint = new MemberPoint();
                        memberPoint.setCreateUser("web消费");
                        memberPoint.setOrderId(record.getId() + "");
                        memberPoint.setUserId(record.getUserId() + "");
                        memberPoint.setMoney(String.valueOf(-point + 0.0));
                        memberPoint.setBalance(String.valueOf(moneyPoint - point));
                        memberPoint.setTypeFlag(AppConstant.CoinType.CONSUMPTION);
                        memberPoint.setRemark("消费，订单号：" + record.getOrderCode());
                        memberPointService.createMemberPoint(memberPoint);


                        UserInfo updateUser = new UserInfo();
                        updateUser.setId(record.getUserId());
                        updateUser.setMoneyPoint(moneyPoint - point);
                        userInfoService.updateUserInfo(updateUser);
                    }

                    return true;
                }
            }
        } catch (Exception e) {
            logger.error("createUserOrder", e);
        }

        return false;
    }

    @Override
    public boolean deleteUserOrder(String id) {

        logger.info("deleteUserOrder");
        try {

            int updates = userOrderMapper.delete(id);

            if (updates > 0) {
                return true;
            }
        } catch (Exception e) {
            logger.error("deleteUserOrder", e);
        }

        return false;
    }

    @Override
    public boolean updateUserOrder(UserOrder record) {

        logger.info("updateUserOrder");
        try {

            int updates = userOrderMapper.updateByPrimaryKeySelective(record);

            if (updates > 0) {
                return true;
            }
        } catch (Exception e) {
            logger.error("updateUserOrder", e);
        }

        return false;
    }


    @Override
    public Result payOrder(String orderId, double coin, double point, double cash, int payMode) {

        logger.info("payOrder：支付订单");
        try {

            UserOrder userOrder = new UserOrder();

            userOrder.setId(Integer.valueOf(orderId));

            userOrder = userOrderMapper.queryUserOrder(userOrder);

            if (userOrder == null) {
                return new Result(false, "支付失败，订单不存在");
            }


            double money = userOrder.getDealPrice().doubleValue();

            point = 0;//目前不需要支付时扣积分。

            if (AppConstant.PayMode.COIN == payMode) {
                //如果支付总额不足则用余额补足；
                if (money > (coin + point + cash)) {
                    coin = money - point - cash;
                }
            }


            UserInfo userInfo = userInfoService.getUserInfoById(userOrder.getUserId() + "");

            if (userInfo == null) {
                return new Result(false, "支付失败，用户不存在！");
            }

            /**
             * 余额
             */
            double moneyCoin = userInfo.getMoneyCoin();
            if (coin > moneyCoin) {
                return new Result(false, "支付失败，余额不足");
            }

            /**
             * 商城积分
             */
            double moneyPoint = userInfo.getMoneyPoint();
            if (point > moneyPoint) {
                return new Result(false, "支付失败，商城积分不足");
            }


            if (money > (coin + point + cash)) {
                return new Result(false, "支付失败，金额不足");
            }

            if (point > 0) {
                //积分兑换区 只能用商城积分
                MemberPoint memberPoint = new MemberPoint();
                memberPoint.setCreateUser("系统");
                memberPoint.setOrderId(orderId);
                memberPoint.setUserId(userOrder.getUserId() + "");
                memberPoint.setMoney(String.valueOf(-point + 0.0));
                memberPoint.setBalance(String.valueOf(moneyPoint - point));
                memberPoint.setTypeFlag(AppConstant.CoinType.CONSUMPTION);
                memberPoint.setRemark("购买商品消费，订单号：" + userOrder.getOrderCode());
                memberPointService.createMemberPoint(memberPoint);


            }


            // 个人店铺，只能用余额支付
            if (coin > 0) {

                MemberCoin memberCoin = new MemberCoin();
                memberCoin.setCreateUser("系统");
                memberCoin.setOrderId(orderId);
                memberCoin.setUserId(userOrder.getUserId() + "");
                memberCoin.setMoney(String.valueOf(-coin + 0.0));
                memberCoin.setBalance(String.valueOf(moneyCoin - coin));
                memberCoin.setTypeFlag(AppConstant.CoinType.CONSUMPTION);
                memberCoin.setRemark("购买积分商品消费，订单号：" + userOrder.getOrderCode());
                memberCoinService.createMemberCoin(memberCoin);

            }


            UserInfo updateUser = new UserInfo();
            updateUser.setId(userOrder.getUserId());
            updateUser.setMoneyCoin(moneyCoin - coin);
            updateUser.setMoneyPoint(moneyPoint - point);
            userInfoService.updateUserInfo(updateUser);

            //更新为已经支付
            UserOrder userOrderPay = new UserOrder();

            userOrderPay.setId(Integer.valueOf(orderId));
            userOrderPay.setCoin(BigDecimal.valueOf(coin));
            //userOrderPay.setPoint(BigDecimal.valueOf(point));
            userOrderPay.setCash(BigDecimal.valueOf(cash));
            userOrderPay.setPayMode(payMode);
            userOrderPay.setPayTime(new Date());
            userOrderPay.setStatusFlag(AppConstant.OrderStatus.PAY_OVER);

            userOrderMapper.updateByPrimaryKeySelective(userOrderPay);


            /**
             * 发送短信通知商家 begin
             */
            ProductInfo productInfo = userOrder.getProductInfo();
            if (productInfo != null) {
                UserInfo shangJiaUser = userInfoService.getUserInfoById(productInfo.getStoreInfo().getUserId() + "");

                if (shangJiaUser != null) {
                    MsgUtil.sendOrderSms(shangJiaUser.getPhone(), userOrder.getOrderCode(), "完成付款");
                }
            }
            /**
             * 发送短信通知商家 end
             */

            return new Result(true, "支付成功");
        } catch (Exception e) {
            logger.error("payOrder：支付订单异常", e);
        }
        return new Result(false, "支付失败");
    }

    @Override
    public double calculatedPrice(String orderId, double coin, double point) {

        logger.info("calculatedPrice：计算价格");
        try {

            UserOrder userOrder = new UserOrder();

            userOrder.setId(Integer.valueOf(orderId));

            userOrder = userOrderMapper.queryUserOrder(userOrder);

            double money = userOrder.getDealPrice().doubleValue();

            point = 0;//目前不需要支付时扣积分。

            double cash = money - coin - point;

            return cash;

        } catch (Exception e) {
            logger.error("calculatedPrice：计算价格异常", e);
        }
        return 0;
    }


    @Override
    public Result payOrder(HttpServletRequest request, HttpServletResponse response) {

        logger.info("payOrder：支付订单");
        try {

            System.out.print("微信支付回调数据开始");
            String inputLine;
            String notityXml = "";
            String resXml = "";

            try {
                while ((inputLine = request.getReader().readLine()) != null) {
                    notityXml += inputLine;
                }
                request.getReader().close();
            } catch (Exception e) {
                e.printStackTrace();
            }

            System.out.println("接收到的报文：" + notityXml);

            Map m = WeixinUtil.xmlToMap(notityXml);

            if ("SUCCESS".equals(m.get("result_code").toString())) {
                //支付成功
                resXml = "<xml>" + "<return_code><![CDATA[SUCCESS]]></return_code>" + "<return_msg><![CDATA[OK]]></return_msg>" + "</xml> ";
                String attach = m.get("attach").toString();
                JSONObject attachJson = new JSONObject(attach);

                payOrder(attachJson.getString("orderId"), attachJson.getDouble("coin"),
                        attachJson.getDouble("point"), attachJson.getDouble("cash"), AppConstant.PayMode.WEI_XIN);

                WxpayTemp wxpayTemp = new WxpayTemp();

                wxpayTemp.setOrderId(attachJson.getString("orderId"));
                wxpayTemp.setCoin(BigDecimal.valueOf(attachJson.getDouble("coin")));
                wxpayTemp.setPoint(BigDecimal.valueOf(attachJson.getDouble("point")));
                wxpayTemp.setCash(BigDecimal.valueOf(attachJson.getDouble("cash")));
                wxpayTemp.setTotalAmount(BigDecimal.valueOf(attachJson.getInt("total") / 100.0));
                wxpayTemp.setOutTradeNo(m.get("out_trade_no").toString());
                wxpayTemp.setTransactionId(m.get("transaction_id").toString());
                wxpayTemp.setTypeFlag(AppConstant.Aliapi.BUY);

                wxpayTempMapper.insertSelective(wxpayTemp);

            } else {
                resXml = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>" + "<return_msg><![CDATA[报文为空]]></return_msg>" + "</xml> ";
            }
            System.out.println("微信支付回调数据结束");

            HttpSession seesion = request.getSession();
            seesion.setAttribute("notify", "微信支付回调");
            try {
                BufferedOutputStream out = new BufferedOutputStream(response.getOutputStream());
                out.write(resXml.getBytes());
                out.flush();
                out.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        } catch (Exception e) {
            logger.error("payOrder：支付订单异常", e);
        }
        return new Result(false, "支付失败");
    }

    @Override
    public Result recharge(HttpServletRequest request, HttpServletResponse response) {

        logger.info("recharge：支付充值");
        try {

            System.out.print("微信支付回调数据开始 支付充值");
            String inputLine;
            String notityXml = "";
            String resXml = "";

            try {
                while ((inputLine = request.getReader().readLine()) != null) {
                    notityXml += inputLine;
                }
                request.getReader().close();
            } catch (Exception e) {
                e.printStackTrace();
            }

            System.out.println("接收到的报文：" + notityXml);

            Map m = WeixinUtil.xmlToMap(notityXml);

            if ("SUCCESS".equals(m.get("result_code").toString())) {
                //支付成功
                resXml = "<xml>" + "<return_code><![CDATA[SUCCESS]]></return_code>" + "<return_msg><![CDATA[OK]]></return_msg>" + "</xml> ";
                String attach = m.get("attach").toString();
                JSONObject attachJson = new JSONObject(attach);

                Integer userId = attachJson.getInt("userId");
                Integer money = attachJson.getInt("money") / 100;

                UserInfo userInfo = userInfoService.getUserInfoById(userId + "");


                /**
                 * 余额
                 */
                double moneyCoin = userInfo.getMoneyCoin();
                UserInfo updateUser = new UserInfo();
                updateUser.setId(userId);
                updateUser.setMoneyCoin(moneyCoin + money);
                userInfoService.updateUserInfo(updateUser);


                MemberCoin memberCoin = new MemberCoin();
                memberCoin.setCreateUser("微信充值");
                memberCoin.setUserId(userId + "");
                memberCoin.setMoney(String.valueOf(money));
                memberCoin.setBalance(String.valueOf(moneyCoin + money));
                memberCoin.setTypeFlag(AppConstant.CoinType.RECHARGE);
                memberCoin.setRemark("微信充值，" + money);
                memberCoinService.createMemberCoin(memberCoin);


                WxpayTemp wxpayTemp = new WxpayTemp();

                wxpayTemp.setUserId(String.valueOf(userId));
                wxpayTemp.setOutTradeNo(m.get("out_trade_no").toString());
                wxpayTemp.setTransactionId(m.get("transaction_id").toString());
                wxpayTemp.setTotalAmount(BigDecimal.valueOf(money));
                wxpayTemp.setTypeFlag(AppConstant.Aliapi.RECHARGE);

                wxpayTempMapper.insertSelective(wxpayTemp);


                //充值记录
                RechargeRecord rechargeRecord = new RechargeRecord();
                rechargeRecord.setCreateUser("系统");
                rechargeRecord.setUserId(userInfo.getId());
                rechargeRecord.setTypeFlag(1);
                rechargeRecord.setMoney(BigDecimal.valueOf(money));
                rechargeRecord.setCash(BigDecimal.valueOf(money));
                rechargeRecord.setBalance(BigDecimal.valueOf(moneyCoin + money));
                rechargeRecord.setOutTradeNo(wxpayTemp.getOutTradeNo());
                rechargeRecord.setRemark("微信充值，" + money);

                rechargeRecordMapper.insertSelective(rechargeRecord);


                //充值送积分
                activityInfoService.rechargeSongMoney(rechargeRecord);


            } else {
                resXml = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>" + "<return_msg><![CDATA[报文为空]]></return_msg>" + "</xml> ";
            }
            System.out.println("微信支付回调数据结束");

            HttpSession seesion = request.getSession();
            seesion.setAttribute("notify", "微信支付回调");
            try {
                BufferedOutputStream out = new BufferedOutputStream(response.getOutputStream());
                out.write(resXml.getBytes());
                out.flush();
                out.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        } catch (Exception e) {
            logger.error("payOrder：支付订单异常", e);
        }
        return new Result(false, "支付失败");
    }


    @SuppressWarnings({"rawtypes", "unchecked"})
    private Map parseXmlToList2(String xml) {

        Map retMap = new HashMap();
        try {
            StringReader read = new StringReader(xml);
            // 创建新的输入源SAX 解析器将使用 InputSource 对象来确定如何读取 XML 输入
            InputSource source = new InputSource(read);
            // 创建一个新的SAXBuilder
            SAXBuilder sb = new SAXBuilder();
            // 通过输入源构造一个Document
            org.jdom.Document doc = sb.build(source);
            Element root = (Element) doc.getRootElement();// 指向根节点
            List<Element> es = root.getChildren();
            if (es != null && es.size() != 0) {
                for (Element element : es) {
                    retMap.put(element.getName(), element.getValue());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return retMap;
    }


    /**
     * <p>支付宝支付成功回调接口。</p>
     *
     * @param tradeNo
     * @param tradeStatus
     */
    @Override
    public void alipaySuccess(String tradeNo, String tradeStatus) {

        logger.info("alipaySuccess：支付宝支付成功回调接口 tradeNo：" + tradeNo + ", tradeStatus:" + tradeStatus);
        try {
            AlipayTemp alipayTemp = new AlipayTemp();
            alipayTemp.setOutTradeNo(tradeNo);
            alipayTemp = alipayTempMapper.queryAlipayTemp(alipayTemp);

            if (alipayTemp != null) {

                if (!AppConstant.Aliapi.TRADE_SUCCESS.equals(alipayTemp.getTradeStatus())) {

                    payOrder(alipayTemp.getOrderId() + "", alipayTemp.getCoin().doubleValue(),
                            alipayTemp.getPoint().doubleValue(), alipayTemp.getCash().doubleValue(), AppConstant.PayMode.ALIPAY);

                    alipayTemp.setTradeStatus(tradeStatus);

                    alipayTempMapper.updateByPrimaryKeySelective(alipayTemp);
                }

            }

        } catch (Exception e) {
            logger.error("alipaySuccess：支付宝支付成功回调接口异常 tradeNo：" + tradeNo + ", tradeStatus:" + tradeStatus, e);
        }

    }

    @Override
    public Result cancel(UserOrder record) {

        logger.info("cancel：取消订单");
        try {
            UserOrder userOrder = userOrderMapper.selectByPrimaryKey(record.getId());
            if (userOrder != null) {
                if (AppConstant.OrderStatus.NO_PAY == userOrder.getStatusFlag()) {

                    record.setStatusFlag(AppConstant.OrderStatus.CANCEL);
                    userOrderMapper.updateByPrimaryKeySelective(record);

                    /**
                     * 获取产品信息
                     */
                    ProductInfo productInfo = new ProductInfo();
                    productInfo.setId(userOrder.getProductId());

                    productInfo = productInfoMapper.queryProductInfo(productInfo);

                    //取消加库存库存。
                    if (productInfo != null) {
                        ProductInfo updateProduct = new ProductInfo();

                        updateProduct.setId(productInfo.getId());
                        updateProduct.setInventory(productInfo.getInventory() + userOrder.getQuantity());
                        updateProduct.setSalesVolume(productInfo.getSalesVolume() - userOrder.getQuantity());
                        productInfoMapper.updateByPrimaryKeySelective(updateProduct);
                    }


                    /**
                     * 如果有优惠券，则还原
                     */
                    if (userOrder.getUserCouponId() != null) {
                        UserCoupon userCoupon = userCouponMapper.selectByPrimaryKey(userOrder.getUserCouponId());
                        if (userCoupon != null) {
                            CouponInfo couponInfo = userCoupon.getCouponInfo();
                            if (couponInfo != null) {

                                userCoupon.setIsUsed("N");
                                userCouponMapper.updateByPrimaryKeySelective(userCoupon);

                                CouponDetail couponDetail = new CouponDetail();
                                couponDetail.setId(userCoupon.getCouponDetailId());
                                couponDetail.setUseTime(new Date());
                                couponDetail.setUseFlag("N");
                                couponDetailMapper.updateByPrimaryKeySelective(couponDetail);


                            }
                        }


                    }


                    if (userOrder.getPoint() != null && userOrder.getPoint().compareTo(BigDecimal.ZERO) > 0) {


                        double point = userOrder.getPoint().doubleValue();
                        UserInfo userInfo = new UserInfo();
                        userInfo.setId(record.getUserId());
                        userInfo = userInfoService.getSingleUserInfo(userInfo);
                        if (userInfo == null) {
                            return new Result(false, "用户不存在");
                        }

                        double moneyPoint = userInfo.getMoneyPoint();

                        //积分兑换区 只能用商城积分
                        MemberPoint memberPoint = new MemberPoint();
                        memberPoint.setCreateUser("取消订单退还");
                        memberPoint.setOrderId(userOrder.getId() + "");
                        memberPoint.setUserId(userOrder.getUserId() + "");
                        memberPoint.setMoney(String.valueOf(point));
                        memberPoint.setBalance(String.valueOf(moneyPoint + point));
                        memberPoint.setTypeFlag(AppConstant.CoinType.FAN_HUAN);
                        memberPoint.setRemark("取消订单，订单号：" + userOrder.getOrderCode());
                        memberPointService.createMemberPoint(memberPoint);


                        UserInfo updateUser = new UserInfo();
                        updateUser.setId(record.getUserId());
                        updateUser.setMoneyPoint(moneyPoint + point);
                        userInfoService.updateUserInfo(updateUser);

                    }

                }


            }

            return new Result(true, "cancel：取消订单成功");

        } catch (Exception e) {
            logger.error("cancel：取消订单异常", e);
        }
        return new Result(false, "cancel：取消订单失败");
    }

    @Override
    public Result confirm(UserOrder record) {

        logger.info("confirm：确认完成订单");
        try {
            UserOrder userOrder = userOrderMapper.selectByPrimaryKey(record.getId());
            if (userOrder != null) {

                boolean confirmFlag = false;


                if (AppConstant.ProductType.IMAGE.equals(userOrder.getProductType())) {
                    if (AppConstant.OrderStatus.ACCEPT == userOrder.getStatusFlag() ||
                            AppConstant.OrderStatus.REWORK == userOrder.getStatusFlag()) {//修图完成


                        if ("order_image".equals(record.getAcceptType()) || "image_album".equals(record.getAcceptType())) {
                            confirmFlag = true;

                            record.setStatusFlag(AppConstant.OrderStatus.FINISH);
                            record.setConfirmTime(new Date());
                        }

                    }

                    if (AppConstant.OrderAlbumStatus.WAIT_ACCEPT == userOrder.getAlbumStatus() ||
                            AppConstant.OrderAlbumStatus.REWORK == userOrder.getAlbumStatus()) {//修图完成

                        if ("order_album".equals(record.getAcceptType()) || "image_album".equals(record.getAcceptType())) {
                            confirmFlag = true;
                            record.setAlbumStatus(AppConstant.OrderAlbumStatus.FINISH);
                            record.setAlbumConfirmTime(new Date());
                        }


                    }


                } else if (AppConstant.ProductType.PHYSICAL.equals(userOrder.getProductType())) {
                    if (AppConstant.OrderStatus.PAY_OVER == userOrder.getStatusFlag()) {//已发货
                        confirmFlag = true;
                        record.setStatusFlag(AppConstant.OrderStatus.FINISH);
                        record.setConfirmTime(new Date());

                    }
                }


                if (confirmFlag) {

                    userOrderMapper.updateByPrimaryKeySelective(record);

                    //结算商家
                    //jieSuan(userOrder.getId() + "");
//
//                    try {
//
//                        ClientNotice clientNotice = new ClientNotice();
//                        clientNotice.setClientOrderId(userOrder.getClientOrderId());
//                        clientNotice.setOrderId(userOrder.getId());
//                        clientNotice.setUserId(userOrder.getUserId());
//                        clientNotice.setProductId(userOrder.getProductId());
//                        clientNotice.setStoreId(userOrder.getStoreId());
//                        clientNotice.setTypeFlag(AppConstant.ClientNoticeType.CONFIRM);
//
//                        clientNoticeService.createClientNotice(clientNotice);
//                    } catch (Exception e) {
//                        logger.error("确认完成通知异常", e);
//                    }


                    if ("order_image".equals(record.getAcceptType()) || "image_album".equals(record.getAcceptType())) {
                        /**
                         * 获取产品信息
                         */
                        ProductInfo productInfo = new ProductInfo();
                        productInfo.setId(userOrder.getProductId());

                        productInfo = productInfoMapper.queryProductInfo(productInfo);

                        //取消加库存库存。
                        if (productInfo != null) {
                            ProductInfo updateProduct = new ProductInfo();

                            updateProduct.setId(productInfo.getId());
                            updateProduct.setInventory(productInfo.getInventory() + userOrder.getQuantity());
                            productInfoMapper.updateByPrimaryKeySelective(updateProduct);
                        }


                        //计算返片率
                        storeInfoService.calculateRate(userOrder.getStoreId() + "");
                    }

                    if ("Y".equals(userOrder.getClientFlag())) {
                        //clientOrderService.confirm(userOrder.getClientOrderId());
                        clientOrderService.confirm(null);
                    }
                }


            }

            return new Result(true, "confirm：确认完成成功");

        } catch (Exception e) {
            logger.error("confirm：确认完成异常", e);
        }
        return new Result(false, "confirm：确认完成失败");
    }

    @Override
    public Result jieSuan(String orderId) {

        logger.info("jieSuan：结算订单");
        try {


            UserOrder userOrder = new UserOrder();

            userOrder.setId(Integer.valueOf(orderId));

            userOrder = userOrderMapper.queryUserOrder(userOrder);
            if (userOrder != null) {

                if ((AppConstant.OrderStatus.FINISH == userOrder.getStatusFlag() || AppConstant.OrderStatus.END == userOrder.getStatusFlag())
                        && !"Y".equals(userOrder.getJieSuan())) {

                    if ((userOrder.getAlbumQuantity() > 0 && AppConstant.OrderAlbumStatus.FINISH == userOrder.getAlbumStatus()) || userOrder.getAlbumQuantity() <= 0) {


                        MemberCoin checkMemberCoin = new MemberCoin();
                        checkMemberCoin.setUserId(userOrder.getProductInfo().getStoreInfo().getUserId() + "");
                        checkMemberCoin.setOrderId(orderId);
                        checkMemberCoin.setTypeFlag(AppConstant.CoinType.SALE);

                        checkMemberCoin = memberCoinService.getMemberCoin(checkMemberCoin);

                        if (checkMemberCoin == null) {

                            StoreInfo storeInfo = userOrder.getProductInfo().getStoreInfo();

                            UserInfo shangJiaUser = userInfoService.getUserInfoById(storeInfo.getUserId() + "");

                            SystemConfig systemConfig = systemConfigMapper.selectByPrimaryKey(1);

                            //double money = userOrder.getDealPrice().doubleValue();
                            //double money = userOrder.getTotlePrice().doubleValue();
                            double money = userOrder.getDealPrice().doubleValue();
                            //如果使用积分支付，结算时需要加上积分的值。
                            if (userOrder.getPoint() != null && userOrder.getPoint().compareTo(BigDecimal.ZERO) > 0) {
                                money = money + userOrder.getPoint().doubleValue();
                            }


                            double shangJiaCoin = shangJiaUser.getMoneyCoin();
                            double fee = 0;


                            if ("Y".equals(systemConfig.getUseFlag())) {//使用默认抽成比率
                                fee = money * Double.valueOf(systemConfig.getOrderRate()) / 100.0;
                            }

                            if ("Y".equals(storeInfo.getRateFlag())) {//如果使用店铺自己的抽成比率
                                fee = money * Double.valueOf(storeInfo.getOrderRate()) / 100.0;
                            }

                            BigDecimal bd = new BigDecimal(fee);
                            BigDecimal bd2 = bd.setScale(2, BigDecimal.ROUND_HALF_UP);

                            fee = bd2.doubleValue();

                            if (money < fee) {
                                fee = money;
                            }
                            //更新商家余额
                            MemberCoin memberCoin = new MemberCoin();
                            memberCoin.setCreateUser("系统");
                            memberCoin.setUserId(shangJiaUser.getId() + "");
                            memberCoin.setOrderId(orderId);
                            memberCoin.setMoney(String.valueOf(money - fee));
                            memberCoin.setBalance(String.valueOf(shangJiaCoin + money - fee));
                            memberCoin.setTypeFlag(AppConstant.CoinType.SALE);
                            memberCoin.setRemark("售卖商品获得" + money + "订单号：" + userOrder.getOrderCode() + ";服务费：" + fee);
                            memberCoinService.createMemberCoin(memberCoin);


                            UserInfo updateShangJia = new UserInfo();
                            updateShangJia.setId(shangJiaUser.getId());
                            updateShangJia.setMoneyCoin(shangJiaCoin + money - fee);
                            userInfoService.updateUserInfo(updateShangJia);


                            //消费返积分
                            activityInfoService.consumptionSongMoney(userOrder);

                            UserOrder updateUserOrder = new UserOrder();
                            updateUserOrder.setId(userOrder.getId());
                            updateUserOrder.setJieSuan("Y");
                            userOrderMapper.updateByPrimaryKeySelective(updateUserOrder);

                        }
                    }

                }


            }

            return new Result(true, "jieSuan：结算订单成功");

        } catch (Exception e) {
            logger.error("jieSuan：结算订单异常", e);
        }
        return new Result(false, "jieSuan：结算订单失败");
    }


    @Override
    public Result refundFail(String orderId) {

        logger.info("refundFail：拒绝退款");
        try {

            UserOrder userOrder = userOrderMapper.selectByPrimaryKey(Integer.valueOf(orderId));
            if (userOrder != null) {

                if (AppConstant.OrderStatus.REFUNDING == userOrder.getStatusFlag()) {

                    UserOrder updateOrder = new UserOrder();
                    updateOrder.setId(userOrder.getId());
                    updateOrder.setStatusFlag(AppConstant.OrderStatus.REFUND_FAIL);
                    userOrderMapper.updateByPrimaryKeySelective(updateOrder);

                }
            }

            return new Result(true, "拒绝退款成功");

        } catch (Exception e) {
            logger.error("refundFail：拒绝退款异常", e);
        }
        return new Result(false, "拒绝退款失败");
    }


    @Override
    public Result refundOrder(String orderId) {

        logger.info("refundOrder：退款");
        try {

            UserOrder userOrder = userOrderMapper.selectByPrimaryKey(Integer.valueOf(orderId));
            if (userOrder != null) {

                if (AppConstant.OrderStatus.REFUNDING == userOrder.getStatusFlag()) {


                    double coin = userOrder.getCoin().doubleValue();

//                    double point = userOrder.getPoint().doubleValue();

                    double cash = userOrder.getCash().doubleValue();

                    int payMode = userOrder.getPayMode();
                    UserInfo userInfo = userInfoService.getUserInfoById(userOrder.getUserId() + "");


                    /**
                     * 余额
                     */
                    double moneyCoin = userInfo.getMoneyCoin();

                    /**
                     * 商城积分
                     */
//                    double moneyPoint = userInfo.getMoneyPoint();


                    if (coin > 0) {

                        MemberCoin memberCoin = new MemberCoin();
                        memberCoin.setCreateUser("系统");
                        memberCoin.setUserId(userInfo.getId() + "");
                        memberCoin.setOrderId(orderId);
                        memberCoin.setMoney(String.valueOf(coin + 0.0));
                        memberCoin.setBalance(String.valueOf(moneyCoin + coin));
                        memberCoin.setTypeFlag(AppConstant.CoinType.REFUND);
                        memberCoin.setRemark("退款，订单号：" + userOrder.getOrderCode());
                        memberCoinService.createMemberCoin(memberCoin);

                    }

//                    if (point > 0) {
//                        MemberPoint memberPoint = new MemberPoint();
//                        memberPoint.setCreateUser("系统");
//                        memberPoint.setOrderId(orderId);
//                        memberPoint.setUserId(userInfo.getId() + "");
//                        memberPoint.setMoney(String.valueOf(point + 0.0));
//                        memberPoint.setBalance(String.valueOf(moneyPoint + point));
//                        memberPoint.setTypeFlag(AppConstant.CoinType.REFUND);
//                        memberPoint.setRemark("退款，订单号：" + userOrder.getOrderCode());
//                        memberPointService.createMemberPoint(memberPoint);
//                    }


                    if (cash > 0) {
                        if (AppConstant.PayMode.ALIPAY == payMode) {
                            AlipayTemp alipayTemp = new AlipayTemp();
                            alipayTemp.setTradeStatus(AppConstant.Aliapi.TRADE_SUCCESS);
                            alipayTemp.setOrderId(orderId);
                            alipayTemp.setTypeFlag(AppConstant.Aliapi.BUY);
                            alipayTemp = alipayTempMapper.queryAlipayTemp(alipayTemp);
                            if (alipayTemp != null) {

                                AlipayClientFactory.refund(alipayTemp.getOutTradeNo(), cash);
                            }
                        }

                        if (AppConstant.PayMode.WEI_XIN == payMode) {

                            WxpayTemp wxpayTemp = new WxpayTemp();
                            wxpayTemp.setOrderId(orderId);
                            wxpayTemp.setTypeFlag(AppConstant.Aliapi.BUY);
                            wxpayTemp = wxpayTempMapper.queryWxpayTemp(wxpayTemp);

                            if (wxpayTemp != null) {

                                String out_refund_no = MbappUtil.create_out_trade_no();
                                WxPayRefundData data = new WxPayRefundData();
                                data.setAppid(PropertiesFileLoader.getProperties("weixinappid"));
                                data.setMch_id(PropertiesFileLoader.getProperties("weixin_mch_id"));
                                data.setDevice_info(AppConstant.DEVICE_INFO);
                                data.setNonce_str(MbappUtil.create_nonce_str());
                                data.setOut_trade_no(wxpayTemp.getOutTradeNo());
                                data.setTransaction_id(wxpayTemp.getTransactionId());
                                data.setOut_refund_no(out_refund_no);
                                data.setTotal_fee((int) (cash * 100));
                                data.setRefund_fee((int) (cash * 100));
                                data.setOp_user_id(PropertiesFileLoader.getProperties("weixin_mch_id"));

                                WXRefundService.refund(data, "UTF-8", PropertiesFileLoader.getProperties("weixin_cert_path"), PropertiesFileLoader.getProperties("weixin_mch_id"));

                                wxpayTemp.setOutRefundNo(out_refund_no);

                                wxpayTempMapper.updateByPrimaryKeySelective(wxpayTemp);

                            }
                        }
                    }

                    UserInfo updateUser = new UserInfo();
                    updateUser.setId(userInfo.getId());
                    updateUser.setMoneyCoin(moneyCoin + coin);
//                    updateUser.setMoneyPoint(moneyPoint + point);
                    userInfoService.updateUserInfo(updateUser);

                    UserOrder updateOrder = new UserOrder();
                    updateOrder.setId(userOrder.getId());
                    updateOrder.setStatusFlag(AppConstant.OrderStatus.REFUND_SUCCESS);


                    userOrderMapper.updateByPrimaryKeySelective(updateOrder);

                }
            }

            return new Result(true, "退款成功");

        } catch (Exception e) {
            logger.error("refundOrder：退款异常", e);
        }
        return new Result(false, "退款失败");
    }

    @Override
    public Result ziDong() {

        logger.info("ziDong：定时任务");
        try {

            //取消无效订单
            autoCancel();
            clientOrderService.autoCancel();


            return new Result(true, "定时任务成功");

        } catch (Exception e) {
            logger.error("ziDong：定时任务异常", e);
        }
        return new Result(false, "定时任务失败");
    }

    @Override
    public Result autoCancel() {

        logger.info("autoCancel：取消无用订单");
        try {
            //获取待取消订单
            List<UserOrder> userOrders = userOrderMapper.getAutoCancel();

            for (UserOrder userOrder : userOrders) {

                UserOrder record = new UserOrder();
                record.setId(userOrder.getId());
                record.setCancelReason("30分钟未支付，系统自动取消！");
                cancel(record);
            }

            return new Result(true, "取消无用订单成功");

        } catch (Exception e) {
            logger.error("autoCancel：取消无用订单异常", e);
        }
        return new Result(false, "取消无用订单失败");
    }

    @Override
    public Result autoJieSuan() {

        logger.info("autoJieSuan：自动结算订单");
        try {
            //获取待取消订单
            List<UserOrder> userOrders = userOrderMapper.getAutoJieSuan();

            for (UserOrder userOrder : userOrders) {

                jieSuan(userOrder.getId() + "");

            }

            return new Result(true, "自动结算订单成功");

        } catch (Exception e) {
            logger.error("autoJieSuan：自动结算订单异常", e);
        }
        return new Result(false, "自动结算订单失败");
    }


    /**
     * 返修
     *
     * @param record
     * @return
     */
    @Override
    public boolean repair(UserOrder record) {

        logger.info("repair");
        try {

            if (record.getId() != null && record.getId() > 0) {
                if ("order_image".equals(record.getAcceptType()) || "image_album".equals(record.getAcceptType())) {

                    record.setStatusFlag(AppConstant.OrderStatus.REWORK);
                    OrderRepair orderRepair = new OrderRepair();
                    orderRepair.setOrderId(record.getId() + "");
                    orderRepairMapper.repairByOrderId(orderRepair);

                }

                if ("order_album".equals(record.getAcceptType()) || "image_album".equals(record.getAcceptType())) {

                    record.setAlbumStatus(AppConstant.OrderAlbumStatus.REWORK);
                    OrderAlbumRepair orderAlbumRepair = new OrderAlbumRepair();
                    orderAlbumRepair.setOrderId(record.getId() + "");
                    orderAlbumRepairMapper.repairByOrderId(orderAlbumRepair);
                }

                int updates = userOrderMapper.updateByPrimaryKeySelective(record);


                if (updates > 0) {


//                    try {
//                        UserOrder userOrder = new UserOrder();
//                        userOrder.setId(record.getId());
//                        userOrder = userOrderMapper.querySingleUserOrder(userOrder);
//
//                        ClientNotice clientNotice = new ClientNotice();
//                        clientNotice.setClientOrderId(userOrder.getClientOrderId());
//                        clientNotice.setOrderId(userOrder.getId());
//                        clientNotice.setUserId(userOrder.getUserId());
//                        clientNotice.setProductId(userOrder.getProductId());
//                        clientNotice.setStoreId(userOrder.getStoreId());
//                        clientNotice.setTypeFlag(AppConstant.ClientNoticeType.ACCEPT_OVER);
//
//                        clientNoticeService.createClientNotice(clientNotice);
//                    } catch (Exception e) {
//                        logger.error("审核完成通知异常", e);
//                    }


                    return true;
                }
            }


        } catch (Exception e) {
            logger.error("repair", e);
        }

        return false;
    }

    @Override
    public boolean sendMsg(String orderId, String typeFlag, String message) {

        logger.info("sendMsg");
        try {

            UserOrder userOrder = new UserOrder();

            userOrder.setId(Integer.valueOf(orderId));

            userOrder = userOrderMapper.queryUserOrder(userOrder);
            if (userOrder != null) {

                if ("1".equals(typeFlag)) {

                    UserInfo shangJiaUser = userInfoService.getUserInfoById(userOrder.getProductInfo().getStoreInfo().getUserId() + "");

                    MsgUtil.sendOrderSms(shangJiaUser.getPhone(), userOrder.getOrderCode(), message);
                } else {
                    UserInfo userInfo = userOrder.getUserInfo();
                    MsgUtil.sendOrderSms(userInfo.getPhone(), userOrder.getOrderCode(), message);

                }

            }


            return true;

        } catch (Exception e) {
            logger.error("sendMsg", e);
        }

        return false;
    }


    @Override
    public Result autoCleanOss(UserOrder record) {

        logger.info("autoCleanOss：清理订单OSS资源");
        try {
            //获取待取消订单
            List<UserOrder> userOrders = userOrderMapper.getqueryAutoCleanOrder(record);

            for (UserOrder userOrder : userOrders) {

                // 清理orderImage
                OrderImage orderImage = new OrderImage();
                orderImage.setOrderId(String.valueOf(userOrder.getId()));
                orderImageService.autoCleanOrderImage(orderImage);


                // 清理orderAlbum
                OrderAlbum orderAlbum = new OrderAlbum();
                orderAlbum.setOrderId(String.valueOf(userOrder.getId()));
                orderAlbum.setCleanFlag("N");
                List<OrderAlbum> orderAlbumList = orderAlbumMapper.queryAllOrderAlbum(orderAlbum);

                for (OrderAlbum album : orderAlbumList) {

                    album.setCleanFlag("Y");

                    if (StringUtils.isNotEmpty(album.getFinishedImage())) {
                        String artwork = album.getFinishedImage().replace(PropertiesFileLoader.getProperties("aliImageSever") + "/", "");
                        OSSFileService.deleteObject(artwork);
                    }
                    if (StringUtils.isNotEmpty(album.getFinishedArtwork())) {
                        String artwork = album.getFinishedArtwork().replace(PropertiesFileLoader.getProperties("aliImageSever") + "/", "");
                        OSSFileService.deleteObject(artwork);
                    }

                    orderAlbumMapper.updateByPrimaryKeySelective(album);
                }


                // 清理 订单 zip

                String zipName = userOrder.getOrderCode() + "_";

                if (StringUtils.isNotEmpty(userOrder.getZipName())) {
                    zipName = userOrder.getZipName() + "_";
                }

                String originalZip = PropertiesFileLoader.getProperties("projectname") + "/" + userOrder.getStoreId() + "/" + userOrder.getId() + "/" + zipName + "original.zip";
                String finishedZip = PropertiesFileLoader.getProperties("projectname") + "/" + userOrder.getStoreId() + "/" + userOrder.getId() + "/" + zipName + "finished.zip";
                OSSFileService.deleteObject(originalZip);
                OSSFileService.deleteObject(finishedZip);


            }

            return new Result(true, "自动清理订单OSS资源成功");

        } catch (Exception e) {
            logger.error("autoCleanOss：自动清理订单OSS资源异常", e);
        }
        return new Result(false, "自动清理订单OSS资源失败");
    }


    @Override
    public Result waitAccept(UserOrder record) {

        logger.info("waitAccept：更新回片状态");
        try {

            UserOrder userOrder = userOrderMapper.querySingleUserOrder(record);

            if (userOrder == null) {
                return new Result(false, "订单不存在");
            }

            OrderAcceptLog orderAcceptLog = new OrderAcceptLog();
            orderAcceptLog.setClientOrderId(userOrder.getClientOrderId());
            orderAcceptLog.setOrderId(userOrder.getId());
            orderAcceptLog.setUserId(userOrder.getUserId());
            orderAcceptLog.setProductId(userOrder.getProductId());
            orderAcceptLog.setStoreId(userOrder.getStoreId());
            orderAcceptLog.setTypeFlag(record.getAcceptType());

            if (AppConstant.OrderStatus.FINISH > userOrder.getStatusFlag()) {//如果订单尚未完成

                record.setStatusFlag(AppConstant.OrderStatus.ACCEPT);
            }

            if (AppConstant.OrderAlbumStatus.FINISH != userOrder.getAlbumStatus()) {//相册状态不等于完成状态

                record.setAlbumStatus(AppConstant.OrderAlbumStatus.WAIT_ACCEPT);
            }

            record.setOrderPassword(MbappUtil.getRandomNum(6));

            userOrderMapper.updateByPrimaryKeySelective(record);

            orderAcceptLogMapper.insertSelective(orderAcceptLog);

            sendMsg(String.valueOf(userOrder.getId()), "2", "上传回片");

            if ("Y".equals(userOrder.getClientFlag())) {//如果是客户端订单，通知

                UserOrder checkUserOrder = new UserOrder();
                checkUserOrder.setId(userOrder.getId());
                checkUserOrder = userOrderMapper.querySingleUserOrder(record);

                if (checkUserOrder != null && (AppConstant.OrderStatus.ACCEPT == checkUserOrder.getStatusFlag()
                        || (checkUserOrder.getAlbumQuantity() > 0 ? AppConstant.OrderAlbumStatus.WAIT_ACCEPT == checkUserOrder.getAlbumStatus() : true))) {
                    try {
                        ClientNotice clientNotice = new ClientNotice();
                        clientNotice.setClientOrderId(checkUserOrder.getClientOrderId());
                        clientNotice.setOrderId(checkUserOrder.getId());
                        clientNotice.setUserId(checkUserOrder.getUserId());
                        clientNotice.setProductId(checkUserOrder.getProductId());
                        clientNotice.setStoreId(checkUserOrder.getStoreId());
                        clientNotice.setTypeFlag(AppConstant.ClientNoticeType.WAIT_ACCEPT);

                        clientNoticeService.createClientNotice(clientNotice);
                    } catch (Exception e) {
                        logger.error("回片完成通知异常", e);
                    }
                }

            }


            return new Result(true, "更新回片状态成功");


        } catch (Exception e) {
            logger.error("waitAccept：更新回片状态异常", e);
        }
        return new Result(false, "更新回片状态失败");
    }


    @Override
    public Result extendAccept(UserOrder record) {

        logger.info("extendAccept：延期订单审片时间");
        try {


            OrderAcceptLog orderAcceptLog = new OrderAcceptLog();
            orderAcceptLog.setOrderId(record.getId());
            //orderAcceptLog.setTypeFlag(record.getAcceptType());
            orderAcceptLog.setStatusFlag(0);

            orderAcceptLog = orderAcceptLogMapper.queryOrderAcceptLog(orderAcceptLog);

            if (orderAcceptLog != null) {
                orderAcceptLog.setLimitDay(15);
                orderAcceptLog.setRemark(DateTimeTool.dateTimeToTimeYYYYHHmmStr(new Date()) + "审核延期");

                orderAcceptLogMapper.updateByPrimaryKeySelective(orderAcceptLog);

                return new Result(true, "延期订单审片时间成功");
            }


        } catch (Exception e) {
            logger.error("extendAccept：延期订单审片时间异常", e);
        }
        return new Result(false, "延期订单审片时间失败");
    }


    @Override
    public Result autoAccept() {

        logger.info("autoAccept：超时自动通过");
        try {

            List<OrderAcceptLog> orderAcceptLogList = orderAcceptLogMapper.autoAccept(null);

            for (OrderAcceptLog orderAcceptLog : orderAcceptLogList) {

                if (orderAcceptLog.getStatusFlag() == 0) {

                    UserOrder userOrder = orderAcceptLog.getUserOrder();

                    if (userOrder.getStatusFlag() == AppConstant.OrderStatus.ACCEPT ||
                            userOrder.getAlbumStatus() == AppConstant.OrderAlbumStatus.WAIT_ACCEPT) {


                        sendMsg(String.valueOf(userOrder.getId()), "1", "审片超时，系统自动通过");
                        sendMsg(String.valueOf(userOrder.getId()), "2", "审片超时，系统自动通过");


                        //userOrder.setAcceptType(orderAcceptLog.getTypeFlag());

                        confirm(userOrder);//确认订单


                        orderAcceptLog.setUpdateUser(DateTimeTool.dateTimeToTimeYYYYHHmmStr(new Date()) + "系统自动审核通过");
                        orderAcceptLog.setStatusFlag(1);
                        orderAcceptLogMapper.updateByPrimaryKeySelective(orderAcceptLog);

                        //打压缩包
                        orderImageService.createZip(String.valueOf(userOrder.getId()), "finished");
                    }

                }

            }


            return new Result(true, "超时自动通过成功");


        } catch (Exception e) {
            logger.error("autoAccept：超时自动通过异常", e);
        }
        return new Result(false, "超时自动通过失败");
    }


    @Override
    public Result checkImageAndAlbum(String orderId, String repairId, String albumRepairId) {

        logger.info("checkImageAndAlbum：检测数量");
        try {
            UserOrder resultOrder = new UserOrder();

            UserOrder userOrder = new UserOrder();
            userOrder.setId(Integer.valueOf(orderId));
            userOrder = userOrderMapper.queryUserOrder(userOrder);
            if (userOrder != null) {


                resultOrder.setQuantity(userOrder.getQuantity());
                resultOrder.setAlbumQuantity(userOrder.getAlbumQuantity());

                OrderImage orderImage = orderImageService.checkImageNum(orderId, repairId);

                if (orderImage != null) {
                    resultOrder.setTotalImage(orderImage.getTotalNum());
                    resultOrder.setNeedImage(orderImage.getNeedNum());
                }

                OrderAlbum orderAlbum = new OrderAlbum();
                orderAlbum.setOrderId(orderId);
                orderAlbum.setBaseRepairId(albumRepairId);

                orderAlbum = orderAlbumMapper.checkAlbumNum(orderAlbum);

                if (orderAlbum != null) {
                    if (StringUtils.isNotBlank(albumRepairId)) {

                        resultOrder.setTotalAlbum(orderAlbum.getTotalNum());
                        resultOrder.setNeedAlbum(orderAlbum.getNeedNum());
                    } else {
                        resultOrder.setTotalAlbum(userOrder.getAlbumQuantity());
                        resultOrder.setNeedAlbum(orderAlbum.getNeedNum());
                    }

                    resultOrder.setFailAlbum(orderAlbum.getFailNum());
                }


            }

            return new Result(true, resultOrder);

        } catch (Exception e) {
            logger.error("refundFail：checkImageAndAlbum异常", e);
        }
        return new Result(false, "checkImageAndAlbum失败");
    }

    @Override
    public Result checkRepairImageAndAlbum(String orderId, String repairId, String albumRepairId) {

        logger.info("checkRepairImageAndAlbum：检测数量");
        try {
            UserOrder resultOrder = new UserOrder();

            UserOrder userOrder = new UserOrder();
            userOrder.setId(Integer.valueOf(orderId));
            userOrder = userOrderMapper.querySingleUserOrder(userOrder);
            if (userOrder != null) {


                OrderImage orderImage = orderImageService.checkRepairImageNum(orderId, repairId);

                if (orderImage != null) {
                    resultOrder.setTotalImage(orderImage.getTotalNum());
                    resultOrder.setNeedImage(orderImage.getNeedNum());
                    resultOrder.setFailImage(orderImage.getFailNum());
                }

                OrderAlbum orderAlbum = new OrderAlbum();
                orderAlbum.setOrderId(orderId);
                orderAlbum.setBaseRepairId(albumRepairId);

                orderAlbum = orderAlbumMapper.checkRepairAlbumNum(orderAlbum);

                if (orderAlbum != null) {
                    resultOrder.setTotalAlbum(orderAlbum.getTotalNum());
                    resultOrder.setNeedAlbum(orderAlbum.getNeedNum());
                    resultOrder.setFailAlbum(orderAlbum.getFailNum());
                }


            }

            return new Result(true, resultOrder);

        } catch (Exception e) {
            logger.error("checkRepairImageAndAlbum异常", e);
        }
        return new Result(false, "checkRepairImageAndAlbum失败");
    }

    @Override
    public Result updateImageAndAlbumRepair(UserOrder record) {

        logger.info("updateImageAndAlbumRepair：检测数量");
        try {

            if (record.getImageRepairId() != null && record.getImageRepairStatus() != null) {

                OrderRepair orderRepair = new OrderRepair();
                orderRepair.setId(record.getImageRepairId());
                orderRepair.setStatusFlag(record.getImageRepairStatus());
                orderRepairMapper.updateByPrimaryKeySelective(orderRepair);
            }
            if (record.getAlbumRepairId() != null && record.getAlbumRepairStatus() != null) {

                OrderAlbumRepair orderAlbumRepair = new OrderAlbumRepair();
                orderAlbumRepair.setId(record.getAlbumRepairId());
                orderAlbumRepair.setStatusFlag(record.getAlbumRepairStatus());
                orderAlbumRepairMapper.updateByPrimaryKeySelective(orderAlbumRepair);
            }


            return new Result(true, "更新成功");

        } catch (Exception e) {
            logger.error("updateImageAndAlbumRepair异常", e);
        }
        return new Result(false, "updateImageAndAlbumRepair失败");
    }


}