orderServer/src/main/java/com/szwl/service/impl/TOrderServiceImpl.java

package com.szwl.service.impl;

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.alibaba.excel.write.style.column.LongestMatchColumnWidthStyleStrategy;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.szwl.constant.ConfigConsts;
import com.szwl.exception.MyException;
import com.szwl.feign.SzwlFeign;
import com.szwl.model.bean.ChartBean;
import com.szwl.model.bean.ChartColumn;
import com.szwl.model.bean.OrderDaoChuDTO;
import com.szwl.model.bo.ChartType;
import com.szwl.model.bo.R;
import com.szwl.model.dto.OrderDto;
import com.szwl.model.entity.TAdmin;
import com.szwl.model.entity.TAdminEquipment;
import com.szwl.model.entity.TEquipment;
import com.szwl.model.entity.TOrder;
import com.szwl.mapper.TOrderMapper;
import com.szwl.model.excel.NewOrderTarget;
import com.szwl.model.excel.OrderTarget;
import com.szwl.model.query.OrderDaoChuParam;
import com.szwl.model.query.OrderStatisticsDTO;
import com.szwl.model.query.StatisticsParam;
import com.szwl.model.utils.DateUtils;
import com.szwl.service.TOrderService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.szwl.util.YunPianSms;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URLEncoder;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author wuhs
 * @since 2022-06-14
 */
@Service
public class TOrderServiceImpl extends ServiceImpl<TOrderMapper, TOrder> implements TOrderService {
    @Resource
    TOrderMapper tOrderMapper;
    @Autowired
    SzwlFeign szwlFeign;

    private static final String appid = "07784f5fedb508046c841b391005b7de";
    //首页统计
    @Override
    public ChartColumn getStatistics(StatisticsParam param) {
        List<ChartBean> list = new ArrayList<>();
        String msg = "";
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            //使用SimpleDateFormat的parse()方法生成Date
            Date start = sf.parse(param.getStartDate());
            Date end = sf.parse(param.getEndDate());
            SimpleDateFormat endsf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
            param.setStartDate(endsf.format(start));
            param.setEndDate(endsf.format(end));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        if (ChartType.day.toString().equals(param.getChartType())) {
            list = tOrderMapper.getDayStatistics(param);
            msg = "日统计";
        }
        if (ChartType.week.toString().equals(param.getChartType())) {
            list = tOrderMapper.getWeekStatistics(param);
            msg = "周统计";
        }
        if (ChartType.month.toString().equals(param.getChartType())) {
            list = tOrderMapper.getMonthStatistics(param);
            msg = "月统计";
        }
        if (ChartType.year.toString().equals(param.getChartType())) {
            list = tOrderMapper.getYearStatistics(param);
            msg = "年统计";
        }

//        if (CollectionUtils.isEmpty(list)) {
//            throw new MyException("获取" + msg + "数据为空");
//        }
        ChartColumn chartColumn = new ChartColumn(list);
        return chartColumn;
    }

    //机器排行统计
    @Override
    public ChartColumn getEquipmentStatistics(StatisticsParam param) {
        List<ChartBean> list = new ArrayList<>();
        String msg = "";
        if (ChartType.day.toString().equals(param.getChartType())) {
            msg = "日统计";
        }
        if (ChartType.week.toString().equals(param.getChartType())) {
            msg = "周统计";
        }
        if (ChartType.month.toString().equals(param.getChartType())) {
            msg = "月统计";
        }
        if (ChartType.year.toString().equals(param.getChartType())) {
            msg = "年统计";
        }
        if("1".equals(param.getChangeType())){
            // 花型统计
            list = tOrderMapper.getProductNameStatistics(param);
        }else{
            list = tOrderMapper.getEquipmentStatistics(param);
            if(list.size()>0){
                for(ChartBean chartBean:list){
                    String categorie = chartBean.getCategorie();
                    TEquipment tEquipment = R.getDataIfSuccess(szwlFeign.findEquipmentByClientId(param.getClientId()));
                    if(StringUtils.isNotEmpty(tEquipment.getName())){
                        chartBean.setCategorie(tEquipment.getName());
                    }else {
                        chartBean.setCategorie(categorie.substring(categorie.length()-6,categorie.length()));
                    }
                }
            }
        }
        if (CollectionUtils.isEmpty(list)) {
            throw new MyException("获取" + msg + "数据为空");
        }
        ChartColumn chartColumn = new ChartColumn(list);
        return chartColumn;
    }

    @Override
    public List<OrderDaoChuDTO> orderDaoChu(String begin, String end, Long adminId, String clientId, String type, String companyType, long current, long size) {
        OrderDaoChuParam daoChuParam = new OrderDaoChuParam();
        daoChuParam.setAdminId(adminId);
        daoChuParam.setBegin(begin);
        daoChuParam.setEnd(end);
        daoChuParam.setClientId(clientId);
        daoChuParam.setType(type);
        daoChuParam.setCurrent(current-1);
        daoChuParam.setSize(size);
        daoChuParam.setCompanyType(companyType);
        return tOrderMapper.getOrderDaoCu(daoChuParam);
    }

    @Override
    public List<OrderTarget> findById(TAdmin admin, List<TOrder> list) throws ParseException {


        List<OrderTarget> list1 = new ArrayList<>();
        for (TOrder order : list) {
            if(!order.getProductName().equals("优惠码")){
                OrderTarget orderTarget = new OrderTarget();
                orderTarget.setSn(order.getSn());
                orderTarget.setProductName(order.getProductName());
                if(order.getRefundAmount() != null) {
                    orderTarget.setPrice(order.getPrice().subtract(order.getRefundAmount()).setScale(2));
                } else {
                    orderTarget.setPrice(order.getPrice());
                }
                orderTarget.setClientId(order.getClientId());
                orderTarget.setName(admin.getUsername());
                // 格式化时间
                if(order.getPayDate()!=null) {
                    String formatPayDate = DateUtils.formatDate(order.getPayDate(), DateUtils.PATTERN_yyyy_MM_dd_HH_mm_ss);
                    orderTarget.setPayDate(formatPayDate);
                }
                if(order.getRefundDate()!=null) {
                    String formatRefundDate = DateUtils.formatDate(order.getRefundDate(), DateUtils.PATTERN_yyyy_MM_dd_HH_mm_ss);
                    orderTarget.setRefundDate(formatRefundDate);
                }
                Integer status = order.getStatus();
                if (status == 0) {
                    orderTarget.setStatus("未支付");
                } else if (status == 1) {
                    orderTarget.setStatus("已支付");
                } else if (status == 3) {
                    orderTarget.setStatus("已退款");
                } else {
                    orderTarget.setStatus(String.valueOf(status));
                }

                if (order.getAgencyProportion()!=null) {
                    orderTarget.setAgencyProportion(String.valueOf(order.getAgencyProportion()));
                }
                if (order.getMerchantProportion()!=null) {
                    orderTarget.setMerchantProportion(String.valueOf(order.getMerchantProportion()));
                }
                if (order.getPersonageProportion()!=null) {
                    orderTarget.setPersonageProportion(String.valueOf(order.getPersonageProportion()));
                }

                if ("WEIXIN_NATIVE".equals(order.getFrpCode())) {
                    orderTarget.setFrp_code("微信主扫支付");
                } else if("ALIPAY_NATIVE".equals(order.getFrpCode())){
                    orderTarget.setFrp_code("支付宝主扫支付");
                }else if("WEIXIN_CARD".equals(order.getFrpCode())){
                    orderTarget.setFrp_code("微信被扫支付");
                }else if("ALIPAY_CARD".equals(order.getFrpCode())){
                    orderTarget.setFrp_code("支付宝被扫支付");
                }else {
                    orderTarget.setFrp_code(order.getFrpCode());
                }


                if(StringUtils.isEmpty(orderTarget.getFrp_code())){
                    orderTarget.setFrp_code(order.getFrpCode());
                }
                list1.add(orderTarget);
            }
        }
        return list1;
    }

    @Override
    public List<OrderStatisticsDTO> findByTime(String clientId, Date startTime, Date endTime, Integer unit) {
        return tOrderMapper.findByTime(clientId,startTime,endTime,unit);
    }

    @Override
    public String setMessage(Long id, String customerPhone) {
        TOrder order = tOrderMapper.selectById(id);
        if(order != null) {
            String companyType = order.getCompanyType();
            String clientId = order.getClientId();
            String sn = order.getSn();
            TEquipment equipment = R.getDataIfSuccess(szwlFeign.findEquipmentByClientId(order.getClientId()));
            if (equipment == null) {
                return  "设备不存在";
            }
            String operationalPhone = equipment.getOperationalPhone();
            String phone = null;
            //判断是否有机器运营者，作为短信接收通知人
            if(!StringUtils.isEmpty(operationalPhone)){
                //直接发送到机器运营者
                phone = operationalPhone;
            }else{
                //直接发送到账户拥有者手机
                TAdmin admin = R.getDataIfSuccess(szwlFeign.getAdmin(String.valueOf(equipment.getAdminId())));
                if(admin != null){
                    if(!StringUtils.isEmpty(admin.getPhone())){
                        phone = admin.getPhone();
                    }
                } else {
                    return "账户不存在";
                }
            }
            if(!StringUtils.isEmpty(phone)){
                //发短信
                try {
                    String price = String.valueOf(order.getPrice());
                    Date payDate = order.getPayDate();
                    String pattern = "yyyy-MM-dd HH:mm:ss";
                    SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
                    String paytime = simpleDateFormat.format(payDate);
                    String clientId6 = clientId.substring(clientId.length() - 6);
                    if (StringUtils.isNotEmpty(companyType) && companyType.equals("1")) {
                        // 如果是七云科技的用户
                        YunPianSms.sendSms(appid, getScMessage(sn, price, paytime,
                                equipment.getName(), clientId6, customerPhone), phone);
                    } else {
                        // 如果是申泽智能的用户
                        YunPianSms.sendSms(appid, getSzMessage(sn, price, paytime,
                                equipment.getName(), clientId6, customerPhone), phone);
                    }
                } catch (Exception e) {
                }
            } else {
                return "设备运营者手机号为空";
            }
        }
        return ConfigConsts.SUCCESS;
    }

    @Override
    public List<NewOrderTarget> exportOrderData(TAdmin admin, List<TOrder> list) {
        List<NewOrderTarget> orderTargets = new ArrayList<>();
        for (TOrder order : list) {
            if(!order.getProductName().equals("优惠码")){
                NewOrderTarget orderTarget = new NewOrderTarget();
                orderTarget.setSn(order.getSn());
                orderTarget.setProductName(order.getProductName());
                if(order.getRefundAmount() != null) {
                    orderTarget.setPrice(order.getPrice().subtract(order.getRefundAmount()).setScale(2));
                } else {
                    orderTarget.setPrice(order.getPrice());
                }
                orderTarget.setClientId(order.getClientId());
                orderTarget.setName(admin.getUsername());
                // 格式化时间
                if(order.getPayDate()!=null) {
                    String formatPayDate = DateUtils.formatDate(order.getPayDate(), DateUtils.PATTERN_yyyy_MM_dd_HH_mm_ss);
                    orderTarget.setPayDate(formatPayDate);
                }
                if(order.getRefundDate()!=null) {
                    String formatRefundDate = DateUtils.formatDate(order.getRefundDate(), DateUtils.PATTERN_yyyy_MM_dd_HH_mm_ss);
                    orderTarget.setRefundDate(formatRefundDate);
                }
                Integer status = order.getStatus();
                if (status == 0) {
                    orderTarget.setStatus("未支付");
                } else if (status == 1) {
                    orderTarget.setStatus("已支付");
                } else if (status == 3) {
                    orderTarget.setStatus("已退款");
                } else {
                    orderTarget.setStatus(String.valueOf(status));
                }

                if (order.getAgencyProportion()!=null) {
                    orderTarget.setAgencyProportion(String.valueOf(order.getAgencyProportion()));
                }
                if (order.getMerchantProportion()!=null) {
                    orderTarget.setMerchantProportion(String.valueOf(order.getMerchantProportion()));
                }
                if (order.getPersonageProportion()!=null) {
                    orderTarget.setPersonageProportion(String.valueOf(order.getPersonageProportion()));
                }

                if ("WEIXIN_NATIVE".equals(order.getFrpCode())) {
                    orderTarget.setFrp_code("微信主扫支付");
                } else if("ALIPAY_NATIVE".equals(order.getFrpCode())){
                    orderTarget.setFrp_code("支付宝主扫支付");
                }else if("WEIXIN_CARD".equals(order.getFrpCode())){
                    orderTarget.setFrp_code("微信被扫支付");
                }else if("ALIPAY_CARD".equals(order.getFrpCode())){
                    orderTarget.setFrp_code("支付宝被扫支付");
                }else {
                    orderTarget.setFrp_code(order.getFrpCode());
                }


                if(StringUtils.isEmpty(orderTarget.getFrp_code())){
                    orderTarget.setFrp_code(order.getFrpCode());
                }
                orderTargets.add(orderTarget);
            }
        }
        return orderTargets;
    }

    @Override
    public void dataExport(OrderDto orderDto, Date begin, Date end, HttpServletResponse response) throws IOException {
        //判断当前账号状态
        TAdmin admin = R.getDataIfSuccess(szwlFeign.getAdmin(orderDto.getAdminId()));
        LambdaQueryWrapper<TOrder> query = Wrappers.lambdaQuery();
        if (!orderDto.getUserName().equals("admin")) {
            if (StringUtils.isNotEmpty(orderDto.getUserName())) {
                TAdmin data = R.getDataIfSuccess(szwlFeign.getAdminByUsername(orderDto.getUserName()));
                if (data == null || data.getId() == null) {
                    return;
                }
                if (data.getIsAdmined()) {
                    query.eq(TOrder::getAdminId, data.getId());
                } else {
                    if (data.getParentId() != 1) {
                        query.eq(TOrder::getAdminId, data.getParentId());
                        //查找子账户所管理的机器
                        TAdminEquipment adminEquipment = R.getDataIfSuccess(szwlFeign.getClientIdList(orderDto.getAdminId()));
                        if (!adminEquipment.getType().equals("0")) {
                            List<String> list = R.getDataIfSuccess(szwlFeign.getClientIds(orderDto.getAdminId()));
                            if (list == null || list.size() == 0) {
                                return;
                            }
                            query.in(TOrder::getClientId, list);
                        }
                    }
                }
            } else {
                //adminType="all"时，代表查全部下级  子账户没有这个权限  公司人员默认查所有人
                if (StringUtils.isNotEmpty(orderDto.getAdminType())) {
                    if (admin.getIsAdmined() && admin.getType() > 1) {
                        if (admin.getType() > 1) {
                            if (orderDto.getAdminType().equals("all")) {
                                //查找所有下级
                                List<Long> admidIdList = R.getDataIfSuccess(szwlFeign.getAdminIdList(orderDto.getAdminId()));
                                query.in(TOrder::getAdminId, admidIdList);
                            }
                        }
                    } else {
                        if (admin.getType() > 1) {
                            //登录账户为子账户 不查下级 只查对应机器的订单
                            TAdminEquipment adminEquipment = R.getDataIfSuccess(szwlFeign.getClientIdList(String.valueOf(admin.getParentId())));
                            if (adminEquipment.getType().equals("0")) {
                                //全部机器
                                TAdmin upAdmin = R.getDataIfSuccess(szwlFeign.getAdmin(String.valueOf(admin.getParentId())));
                                query.eq(TOrder::getAdminId, upAdmin.getId());
                            } else {
                                String equipmentIds = adminEquipment.getEquipmentIds();
                                List<String> equipmentIdList = JSON.parseArray(equipmentIds, String.class);
                                query.in(TOrder::getClientId, equipmentIdList);
                            }
                        }
                    }
                } else {
                    //判断当前账号状态 公司还是商家
                    if (admin.getType() > 1) {
                        //商家 判断是否子账户
                        if (admin.getIsAdmined()) {
                            //商家自己
                            query.eq(TOrder::getAdminId, orderDto.getAdminId());
                        } else {
                            //商家 子账户
                            //登录账户为子账户 不查下级 只查对应机器的订单
                            TAdminEquipment adminEquipment = R.getDataIfSuccess(szwlFeign.getClientIdList(String.valueOf(admin.getParentId())));
                            if (adminEquipment.getType().equals("0")) {
                                //全部机器
                                TAdmin upAdmin = R.getDataIfSuccess(szwlFeign.getAdmin(String.valueOf(admin.getParentId())));
                                query.eq(TOrder::getAdminId, upAdmin.getId());
                            } else {
                                String equipmentIds = adminEquipment.getEquipmentIds();
                                List<String> equipmentIdList = JSON.parseArray(equipmentIds, String.class);
                                query.in(TOrder::getClientId, equipmentIdList);
                            }
                        }
                    }
                }
            }
        }
        if (StringUtils.isNotEmpty(orderDto.getPayType())) {
            query.eq(TOrder::getFrpCode, orderDto.getPayType());
        }
        if (StringUtils.isNotEmpty(orderDto.getClientId())) {
            TEquipment equipment = R.getDataIfSuccess(szwlFeign.findEquipmentByClientId(orderDto.getClientId()));
            //判断机器是否属于这个登陆账号
            if (admin.getType() > 1) {
                //商家
                if (equipment.getAdminId().toString().equals(admin.getId().toString())) {
                    query.eq(TOrder::getEquipmentId, equipment.getId());
                }
            } else {
                query.eq(TOrder::getEquipmentId, equipment.getId());
            }
        }
        if (StringUtils.isNotEmpty(orderDto.getEquipmentId())) {
            query.eq(TOrder::getEquipmentId, orderDto.getEquipmentId());
        }
        if (StringUtils.isNotEmpty(orderDto.getStatus())) {
            query.eq(TOrder::getStatus, orderDto.getStatus());
        }
        if (StringUtils.isNotEmpty(orderDto.getDateType())) {
            if (orderDto.getDateType().equals("0")) {
                //创建时间
                if (begin != null && end != null) {
                    query.gt(TOrder::getCreateDate, begin);
                    query.lt(TOrder::getCreateDate, end);
                }
            }
            if (orderDto.getDateType().equals("1")) {
                //退款时间
                if (begin != null && end != null) {
                    query.gt(TOrder::getRefundDate, begin);
                    query.lt(TOrder::getRefundDate, end);
                }
            }
        }
        // 公司平台
        // 申泽平台管理员
        String companyType = orderDto.getCompanyType();
        if (admin.getId() == 2738) {
            companyType = "0";
        }
        // 七云平台管理员
        if (admin.getId() == 2739) {
            companyType = "1";
        }
        if (StringUtils.isNotEmpty(companyType)) {
            if (companyType.equals("0")) {
                String finalCompanyType = companyType;
                query.nested(q -> q.isNull(TOrder::getCompanyType).or()
                        .eq(TOrder::getCompanyType, finalCompanyType));
            } else {
                query.eq(TOrder::getCompanyType, companyType);
            }
        }
        String machineType = orderDto.getMachineType();
        if (StringUtils.isNotEmpty(machineType)) {
            if (machineType.equals("0")) {
                query.nested(q -> q.isNull(TOrder::getMachineType).or()
                        .eq(TOrder::getMachineType, machineType));
            } else {
                query.eq(TOrder::getMachineType, machineType);
            }
        }
        // 查询总数
        int pageSize = 1000;
        int total = count(query);
        // 总页数
        int totalPages = (total + pageSize - 1) / pageSize;
        // 这里注意 有同学反应使用swagger 会导致各种问题，请直接用浏览器或者用postman
        response.setContentType("application/octet-stream; charset=UTF-8");
        response.setCharacterEncoding("utf-8");
        // 这里URLEncoder.encode可以防止中文乱码
        String fileName = URLEncoder.encode("订单记录-" + System.currentTimeMillis(), "UTF-8").replaceAll("\\+", "%20");
        response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xlsx");
        // 创建ExcelWriter对象
        ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream(), NewOrderTarget.class).registerWriteHandler(new LongestMatchColumnWidthStyleStrategy()).build();
        // 创建 Sheet 对象
        WriteSheet writeSheet = EasyExcel.writerSheet(0, "订单").build();
        // 创建 CountDownLatch 对象
        CountDownLatch countDownLatch = new CountDownLatch(totalPages);
        // 创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        // 循环写入数据
        for (int i = 1; i <= totalPages; i++) {
            int page = i;
            executorService.submit(() -> {
                try {
                    Page<TOrder> orderPage = new Page<>(page, pageSize);
                    Page<TOrder> pageList = page(orderPage, query);
                    List<TOrder> list = pageList.getRecords();
                    // 写入数据
                    List<NewOrderTarget> orderTargetList = exportOrderData(admin, list);
                    synchronized (excelWriter) {
                        excelWriter.write(orderTargetList, writeSheet);
                    }
                } catch (Exception e) {
                    // 异常处理
                    e.printStackTrace();
                } finally {
                    // 计数器减一
                    countDownLatch.countDown();
                }
            });
        }
        // 等待所有线程执行完毕
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 关闭 ExcelWriter 对象
        excelWriter.finish();

        // 关闭线程池
        executorService.shutdown();
    }

    private String getSzMessage(String sn, String price, String payTime,String equipmentName,String clientId,String customerPhone) {
        String message = "";
        if(StringUtils.isNotEmpty(customerPhone)&&customerPhone.length()>3){
            message = "【申泽智能】您好，接到消费者投诉：机器做糖出现问题，需要您退款。订单号："
                    +sn+"，机器名称："+equipmentName+"，设备编号："+clientId+
                    "，价格："+price+"元，订单支付时间："+payTime+"，消费者联系方式："+customerPhone+
                    "。如果已通过私下退款的方式，麻烦提供一下退款截屏到群里。请于24小时内将此订单进行退款处理，过后我司将自行帮您进行退款处理，若超过5次超时处理，可能会有冻结银行卡的风险，谢谢配合。";
        }else {
            message = "【申泽智能】您好，接到消费者投诉：机器做糖出现问题，需要您退款。订单号："
                    +sn+"，机器名称："+equipmentName+"，设备编号："+clientId+
                    "，价格："+price+"元，订单支付时间："+payTime+"，该投诉消费者没有留联系方式，如需核实，请把你的联系方式反馈给我们，我们会把你的联系方式通知到消费者手上，让消费者联系您。" +
                    "如果已通过私下退款的方式，麻烦提供一下退款截屏到群里。请于24小时内将此订单进行退款处理，过后我司将自行帮您进行退款处理，若超过5次超时处理，可能会有冻结银行卡的风险，谢谢配合。";
        }
        return message;
    }

    private String getScMessage(String sn, String price, String payTime,String equipmentName,String clientId,String customerPhone) {
        String message = "";
        if(StringUtils.isNotEmpty(customerPhone)&&customerPhone.length()>3){
            message = "【七云科技】您好，接到消费者投诉：机器做糖出现问题，需要您退款。订单号："
                    +sn+"，机器名称："+equipmentName+"，设备编号："+clientId+
                    "，价格："+price+"元，订单支付时间："+payTime+"，消费者联系方式："+customerPhone+
                    "。如果已通过私下退款的方式，麻烦提供一下退款截屏到群里。请于24小时内将此订单进行退款处理，过后我司将自行帮您进行退款处理，若超过5次超时处理，可能会有冻结银行卡的风险，谢谢配合。";
        }else {
            message = "【七云科技】您好，接到消费者投诉：机器做糖出现问题，需要您退款。订单号："
                    +sn+"，机器名称："+equipmentName+"，设备编号："+clientId+
                    "，价格："+price+"元，订单支付时间："+payTime+"，该投诉消费者没有留联系方式，如需核实，请把你的联系方式反馈给我们，我们会把你的联系方式通知到消费者手上，让消费者联系您。" +
                    "如果已通过私下退款的方式，麻烦提供一下退款截屏到群里。请于24小时内将此订单进行退款处理，过后我司将自行帮您进行退款处理，若超过5次超时处理，可能会有冻结银行卡的风险，谢谢配合。";
        }
        return message;
    }

}