szwlServer/src/main/java/com/szwl/controller/IndexController.java

package com.szwl.controller;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.google.gson.Gson;
import com.qiniu.http.Response;
import com.qiniu.storage.BucketManager;
import com.qiniu.storage.Configuration;
import com.qiniu.storage.Region;
import com.qiniu.storage.UploadManager;
import com.qiniu.storage.model.DefaultPutRet;
import com.qiniu.util.Auth;
import com.szwl.constant.ConfigConsts;
import com.szwl.constant.ResponseCodesEnum;
import com.szwl.model.bean.*;
import com.szwl.model.bo.JsonUtils;
import com.szwl.model.bo.R;
import com.szwl.model.bo.ResponseModel;
import com.szwl.model.dto.MachineDTO;
import com.szwl.model.dto.ReturnCoinVo;
import com.szwl.model.entity.*;
import com.szwl.model.utils.AdminUtils;
import com.szwl.model.utils.HttpClientSslUtils;
import com.szwl.model.utils.PushUtils;
import com.szwl.service.*;
import com.szwl.service.es.EsTEquipmentService;
import com.szwl.util.IDGenerator;
import com.szwl.util.WechatSendUtil;
import com.szwl.util.WhoIsUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.ibatis.annotations.Case;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

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

import static com.szwl.util.geoCoderUtil.getLocByLonLatVer;


@Api(value = "/indexController", tags = {"设备信息上传接口"})
@RestController
@RequestMapping("/api/app_equipment/index")
public class IndexController {

    @Autowired
    TAdminService adminService;

    @Autowired
    TEquipmentService equipmentService;

    @Autowired
    TEquipmentApplyService equipmentApplyService;

    @Autowired
    TProductService productService;

    @Autowired
    TProportionService proportionService;

    @Autowired
    TEquipmentDescService equipmentDescService;

    @Autowired
    EsTEquipmentService esTEquipmentService;

    @Autowired
    TParametersService parametersService;

    @Autowired
    TPriceService priceService;

    @Autowired
    TPromoCodeService promoCodeService;

    @Autowired
    TDiyFlowerService diyFlowerService;

    @Autowired
    TNameDictionaryService nameDictionaryService;

    @Autowired
    TWechatService wechatService;

    @Resource
    TLocationCheckService locationCheckService;

    @Autowired
    TGoodsDataService goodsDataService;

    @Autowired
    TAlarmRecordService alarmRecordService;

    @Autowired
    ReturnCoinRecordService returnCoinRecordService;

    private static final String appid = "07784f5fedb508046c841b391005b7de";

    @ApiOperation(value = "心跳")
    @RequestMapping(value = "/heart.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String heart(@RequestBody EquipmentVo equipmentVo) {

        String clientId = equipmentVo.getClientId();
        Date lastUpdateTime = equipmentVo.getLastUpdateTime();
        String cabinetHd = equipmentVo.getCabinetHd();
        String cabinetTm = equipmentVo.getCabinetTm();
        String furnaceSp = equipmentVo.getFurnaceSp();
        String furnaceTm = equipmentVo.getFurnaceTm();
        String gtClientId = equipmentVo.getGtClientId();
        String volume = equipmentVo.getVolume();
        Integer eqeStatus = equipmentVo.getEqeStatus();
        Boolean isSleep = equipmentVo.getIs_sleep();
        String netWorkingMode = equipmentVo.getNetWorkingMode();
        String numberOne = equipmentVo.getNumberOne();
        String candyGeneratorTm = equipmentVo.getCandyGeneratorTm();
        String outsideTm = equipmentVo.getOutsideTm();
        String outsideHd = equipmentVo.getOutsideHd();
        Integer workingMode = equipmentVo.getWorkingMode();
        Integer isAlarm = equipmentVo.getIsAlarm();

        //有记录，则进行修改
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment newEquipment = equipmentService.getOne(query);
        if (newEquipment != null) {
            newEquipment.setNetWorkingMode(netWorkingMode);
            if (StringUtils.isNotEmpty(cabinetTm)) {
                newEquipment.setCabinetTm(cabinetTm);
            }
            if (StringUtils.isNotEmpty(cabinetHd)) {
                newEquipment.setCabinetHd(cabinetHd);
            }
            if (StringUtils.isNotEmpty(furnaceSp)) {
                newEquipment.setFurnaceSp(furnaceSp);
            }
            if (StringUtils.isNotEmpty(furnaceTm)) {
                newEquipment.setFurnaceTm(furnaceTm);
            }
            newEquipment.setLastUpdateTime(lastUpdateTime);
            if (eqeStatus != null) {
                newEquipment.setEqeStatus(eqeStatus);
            }
            if (isSleep != null) {
                newEquipment.setIsSleep(isSleep);
            }
            if (!StringUtils.isEmpty(furnaceTm)) {
                int fur = Integer.parseInt(furnaceTm);
                if (newEquipment.getEqeStatus() == 0 && fur > 150) {
                    newEquipment.setEqeStatus(1);
                }
                if (newEquipment.getEqeStatus() == null) {
                    newEquipment.setEqeStatus(1);
                }
            }
            if (!StringUtils.isEmpty(volume)) {
                newEquipment.setVolume(volume);
            }
            // 是否报警
            if (isAlarm != null) {
                if (isAlarm == 1) {
                    newEquipment.setIsAlarm(true);
                } else if (isAlarm == 0) {
                    // 更改报警状态，并消除以往的报警记录
                    LambdaUpdateWrapper<TAlarmRecord> wrapper = Wrappers.lambdaUpdate();
                    wrapper.eq(TAlarmRecord::getClientId, clientId);
                    wrapper.eq(TAlarmRecord::getIsEliminate, 0);
                    wrapper.le(TAlarmRecord::getCreateDate, new Date());
                    wrapper.set(TAlarmRecord::getIsEliminate, 1);
                    alarmRecordService.update(wrapper);
                    newEquipment.setIsAlarm(false);

                }
            }
            newEquipment.setGtClientId(gtClientId);
            newEquipment.setModifyDate(new Date());
            equipmentService.updateById(newEquipment);
            TEquipmentDesc equipmentDesc = equipmentDescService.getById(newEquipment.getId());
            if (StringUtils.isNotEmpty(equipmentVo.getBlueSugar())) {
                equipmentDesc.setBlueSugar(equipmentVo.getBlueSugar());
            }
            if (StringUtils.isNotEmpty(equipmentVo.getRedSugar())) {
                equipmentDesc.setRedSugar(equipmentVo.getRedSugar());
            }
            if (StringUtils.isNotEmpty(equipmentVo.getYellowSugar())) {
                equipmentDesc.setYellowSugar(equipmentVo.getYellowSugar());
            }
            if (StringUtils.isNotEmpty(equipmentVo.getWhiteSugar())) {
                equipmentDesc.setWhiteSugar(equipmentVo.getWhiteSugar());
            }
            if (StringUtils.isNotEmpty(equipmentVo.getWater())) {
                equipmentDesc.setWater(equipmentVo.getWater());
            }
            if (StringUtils.isNotEmpty(equipmentVo.getWasteWater())) {
                equipmentDesc.setWasteWater(equipmentVo.getWasteWater());
            }
            if (StringUtils.isNotEmpty(equipmentVo.getStick())) {
                equipmentDesc.setStick(equipmentVo.getStick());
            }
            // 如果是爆米花机
            String machineType = newEquipment.getMachineType();
            if (StringUtils.isNotEmpty(machineType) && "1".equals(newEquipment.getMachineType())) {
                // 爆米花机搅拌温度
                if (StringUtils.isNotEmpty(cabinetTm)) {
                    equipmentDesc.setStirTm(cabinetTm);
                }
                // 爆米花机玉米发生器温度
                if (StringUtils.isNotEmpty(cabinetHd)) {
                    equipmentDesc.setCornGeneratorTm(cabinetHd);
                }
                // 爆米花机杯子剩余量
                if (StringUtils.isNotEmpty(furnaceTm)) {
                    equipmentDesc.setCupQuantity(Long.parseLong(furnaceTm));
                }
            }
            // 如果是雪糕机
            if (StringUtils.isNotEmpty(machineType) && "2".equals(newEquipment.getMachineType())) {
                if (workingMode != null) {
                    equipmentDesc.setWorkingMode(workingMode);
                }
            }
            if (StringUtils.isNotEmpty(numberOne)) {
                equipmentDesc.setNumberOne(numberOne);
            }
            if (StringUtils.isNotEmpty(candyGeneratorTm)) {
                equipmentDesc.setCandyGeneratorTm(candyGeneratorTm);
            }
            if (StringUtils.isNotEmpty(outsideHd)) {
                equipmentDesc.setOutsideHd(outsideHd);
            }
            if (StringUtils.isNotEmpty(outsideTm)) {
                equipmentDesc.setOutsideTm(outsideTm);
            }
            equipmentDescService.updateById(equipmentDesc);
            return "心跳成功";
        }
        return "心跳失败";
    }

    /**
     * 设备初始化申请2
     */
    @ApiOperation(value = "设备初始化申请2")
    @RequestMapping(value = "/initNew2.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String initNew2(String clientId, String managerId, String gtClientId, String equipmentType, String ip, String longitude, String latitude) throws IOException {
        if (StringUtils.isEmpty(clientId) || StringUtils.isEmpty(longitude) || StringUtils.isEmpty(latitude)) {
            return "设备编号、经纬度不能为空";
        }

        // 根据 clientId 查设备的 location，country
        LambdaQueryWrapper<TLocationCheck> lqw = Wrappers.lambdaQuery();
        lqw.eq(TLocationCheck::getClientId, clientId);
        TLocationCheck locationCheck = locationCheckService.getOne(lqw);
        if (Objects.isNull(locationCheck)) {
            return "生产部未录入改设备的位置信息";
        }

        // 判断ip是否属于国内，if 国内，放行
        double lon = Double.parseDouble(longitude);
        double lat = Double.parseDouble(latitude);

        // 经度范围在73至135之间，纬度范围在3至53之间，即国内区域
        // 经度：73~124，纬度17~47，经度排除韩国，纬度排除俄罗斯，海南以南
        if (!(lon >= 73) || !(lon <= 124) || !(lat >= 17) || !(lat <= 47)) {
            // 根据 ip 校验位置信息
//            String addr = WhoIsUtil.getLocByIp(ip);
            // 根据 longitude, latitude 校验位置信息
            String addr;
            String ipApiAddr = WhoIsUtil.getLocByIp2(ip);
            try {
                String lonLatAddr = getLocByLonLatVer(longitude, latitude);
                if (lonLatAddr != null && !lonLatAddr.isEmpty()) {
                    addr = lonLatAddr + ipApiAddr;
                } else {
                    addr = ipApiAddr;
                }
            } catch (Exception e) {
                e.printStackTrace();
                addr = "Failed to get geolocation";
            }
            locationCheck.setIp(ip);
            locationCheck.setLongitude(longitude);
            locationCheck.setLatitude(latitude);
            locationCheck.setAddr(addr);
            locationCheckService.saveOrUpdate(locationCheck);

            String checkResult = locationCheckService.locCheckMsg(locationCheck, clientId, addr);
            if (checkResult.equals("fail")) {
                return "位置不匹配，请联系营销经理/售后处理";
            }
        }
        return this.initNew(clientId, managerId, gtClientId, equipmentType);
    }


    /**
     * 设备申请
     *
     * @param clientId  个推
     * @param managerId 管理系统id
     * @return
     */
    @ApiOperation(value = "设备申请")
    @RequestMapping(value = "/initNew.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String initNew(String clientId, String managerId, String gtClientId, String equimentType) {
        String machineType = "0";
        String status = "0";
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.like(TEquipment::getClientId, clientId);
        List<TEquipment> list = equipmentService.list(query);
        if (!list.isEmpty()) {
            TEquipment equipment = list.get(0);
            if (equipment.getAdminId() != 31) {
                if (!equipment.getClientId().substring(equipment.getClientId().length() - 3, equipment.getClientId().length()).equals("xxx")) {
                    String managerId1 = equipment.getManagerId();
                    if (!managerId.equals(managerId1)) {
                        return "该设备未脱离";
                    } else {
                        return "该设备已经初始化";
                    }
                }
            } else {
                status = "1";
            }
        }

        if (StringUtils.isEmpty(gtClientId)) {
            return "设备不能为空";
        }
        LambdaQueryWrapper<TEquipmentApply> query1 = Wrappers.lambdaQuery();
        query1.eq(TEquipmentApply::getClientId, clientId);
        query1.eq(TEquipmentApply::getStatusType, "1");
        query1.eq(TEquipmentApply::getManagerId, managerId);
        String dateStr = "2022-12-28 00:00:00";
        //获得SimpleDateFormat类，我们转换为yyyy-MM-dd的时间格式
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            //使用SimpleDateFormat的parse()方法生成Date
            Date date = sf.parse(dateStr);
            query1.gt(TEquipmentApply::getCreateDate, date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        List<TEquipmentApply> list1 = equipmentApplyService.list(query1);
        if (list1.size() > 0) {
            return "重复申请";
        }
        TEquipmentApply equipmentApply = new TEquipmentApply();
        equipmentApply.setStatusType(1);
        equipmentApply.setClientId(clientId);
        equipmentApply.setManagerId(managerId);
        equipmentApply.setGtClientId(gtClientId);
        Long adminId = AdminUtils.decrypt(false, managerId);
        if (adminId == null) {
            return "找不到商家";
        }

        TAdmin admin = adminService.getById(adminId);
        if (admin == null) {
            return "找不到商家";
        }
        Integer type = admin.getType();
        if (type != null && type == 3) {
            return "账号类型错误，请使用商家账号绑定";
        }
        //所属商家
        String username = admin.getUsername();
        equipmentApply.setAdminId(adminId);
        equipmentApply.setAdminUserName(username);
        equipmentApply.setEquimentType(equimentType);
        // 如果是爆米花
        if (equimentType.equals("P10") || equimentType.equals("P20") || equimentType.equals("P30") || equimentType.equals("SBM10")) {
            machineType = "1";
        }
        // 如果是冰淇淋
        if (equimentType.equals("SI320")) {
            machineType = "2";
        }
        // 如果是冰沙机
        if (equimentType.equals("EF210")) {
            machineType = "3";
        }
        equipmentApply.setMachineType(machineType);
        equipmentApply.setCreateDate(new Date());
        equipmentApply.setModifyDate(new Date());
        equipmentApplyService.save(equipmentApply);
        if (status.equals("1") || String.valueOf(adminId).equals("3") || String.valueOf(adminId).equals("31") || String.valueOf(adminId).equals("506") || String.valueOf(adminId).equals("1090")) {
            Long id = equipmentApply.getId();
            agree(id);
            return "设备申请成功";
        }
        if (admin.getApplyStartTime() != null && admin.getApplyEndTime() != null) {
            Date applyStartTime = admin.getApplyStartTime();
            Date applyEndTime = admin.getApplyEndTime();
            Date now = new Date();
            if (now.getTime() > applyStartTime.getTime() && now.getTime() < applyEndTime.getTime()) {
                Long id = equipmentApply.getId();
                agree(id);
                return "设备申请成功";
            }
        }

        return "设备申请中，请耐心等待";

    }

    private void agree(Long id) {
        String status = "agreed";
        if (null != id) {
            TEquipmentApply equipmentApply = equipmentApplyService.getById(id);
            Integer statusType = equipmentApply.getStatusType();
            if (statusType > 1) {
                equipmentApply = null;
            }
            if (equipmentApply != null) {
                if (!StringUtils.isEmpty(status)) {
                    if (status.equals("agreed")) {
                        String clientId = equipmentApply.getClientId();
                        //判断是否设备初始化
                        Long adminId = equipmentApply.getAdminId();
                        String adminLevel = equipmentApply.getAdminLevel();
                        String adminUserName = equipmentApply.getAdminUserName();
                        String gtClientId = equipmentApply.getGtClientId();
                        String equimentType = equipmentApply.getEquimentType();
                        String machineType = equipmentApply.getMachineType();
                        TAdmin admin = adminService.getById(adminId);
                        String companyType = admin.getCompanyType(); // 公司平台

                        String old = "";
                        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
                        query.like(TEquipment::getClientId, clientId + "xxx");
                        List<TEquipment> list = equipmentService.list(query);
                        LambdaQueryWrapper<TEquipment> query0 = Wrappers.lambdaQuery();
                        query0.eq(TEquipment::getClientId, clientId);
                        List<TEquipment> list2 = equipmentService.list(query0);
                        equipmentApply.setStatusType(3);
                        if (list.size() > 0 || list2.size() > 0) {
                            //表示设备第二次申请了:主要为了区分脱离以及初始化
                            old = "1";
                            //重新修改设备名称
                            TEquipment equipment = new TEquipment();
                            if (list2.size() > 0) {
                                equipment = list2.get(0);
                            } else {
                                equipment = list.get(0);
                            }
                            equipment.setClientId(clientId);
                            equipment.setGtClientId(gtClientId);
                            equipment.setAdminId(adminId);
                            equipment.setAdminLevel(adminLevel);
                            equipment.setAdminUserName(adminUserName);
                            equipment.setMachineType(machineType);
                            equipment.setCompanyType(companyType);
                            if (equipmentApply.getEquimentType().equals("MG320-1")) {
                                if (!equipmentApply.getEquimentType().equals(equipment.getEquimentType()) && equipment.getEquimentType().equals("MG320")) {
                                    LambdaQueryWrapper<TProduct> queryProduct = Wrappers.lambdaQuery();
                                    queryProduct.eq(TProduct::getEquipmentId, equipment.getId());
                                    List<TProduct> productList = productService.list(queryProduct);
                                    if (productList.size() == 18) {
                                        //从18种变成30种花型
                                        saveProductMG12(equipment.getId());
                                    }
                                }
                                equipment.setEquimentType("MG320");
                            } else {
                                equipment.setEquimentType(equipmentApply.getEquimentType());
                            }
//                            if (equipmentApply.getEquimentType().equals("MG330")) {
//                                equipment.setEquimentType("MG330");
//                            }
//                            if (equipmentApply.getEquimentType().equals("P30")) {
//                                equipment.setEquimentType(equipmentApply.getEquimentType());
//                            }
//                            if (equipmentApply.getEquimentType().equals("SI320")) {
//                                equipment.setEquimentType(equipmentApply.getEquimentType());
//                            }
                            equipmentService.updateById(equipment);
                            LambdaQueryWrapper<TProportion> queryProportion = Wrappers.lambdaQuery();
                            queryProportion.eq(TProportion::getEquipmentId, equipment.getId());
                            List<TProportion> list1 = proportionService.list(queryProportion);
                            if (list1.size() > 0) {
                                for (TProportion proportion : list1) {
                                    proportionService.removeById(proportion.getId());
                                }
                            }
                            try {
                                esTEquipmentService.updateDataById(equipment);
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                            if (StringUtils.isEmpty(machineType) || machineType.equals("0")) {
                                equipmentService.sentMessage(clientId, PushUtils.buildJson("statusType", "agreed" + old).toString());
                                PushUtils.push(equipmentApply.getGtClientId(), "【棉花糖】设备初始化申请", "同意", PushUtils.buildJson("statusType", "agreed" + old).toString());
                            } else if (StringUtils.isNotEmpty(machineType) && machineType.equals("1")) {
                                equipmentService.sentMessage(clientId, PushUtils.buildJson("statusType", "agreed" + old).toString());
                                PushUtils.push(equipmentApply.getGtClientId(), "【爆米花】设备初始化申请", "同意", PushUtils.buildJson("statusType", "agreed" + old).toString());
                            } else if (StringUtils.isNotEmpty(machineType) && machineType.equals("2")) {
                                equipmentService.sentMessage(clientId, PushUtils.buildJson("statusType", "agreed" + old).toString());
                                PushUtils.push(equipmentApply.getGtClientId(), "【冰淇淋】设备初始化申请", "同意", PushUtils.buildJson("statusType", "agreed" + old).toString());
                            }
                            if (equipment.getEquimentType().equals("280")) {
                                equipmentService.sentMessage(clientId, PushUtils.buildJson("endDate", String.valueOf(equipment.getEndDate().getTime())).toString());
                                PushUtils.push(equipmentApply.getGtClientId(), "", "", PushUtils.buildJson("endDate", String.valueOf(equipment.getEndDate().getTime())).toString());
                            }
                            LambdaQueryWrapper<TEquipmentDesc> lqw = Wrappers.lambdaQuery();
                            lqw.eq(TEquipmentDesc::getEquipmentId, equipment.getId());
                            List<TEquipmentDesc> equipmentDescs = equipmentDescService.list(lqw);
                            if (equipmentDescs.size() == 0) {
                                TEquipmentDesc equipmentDesc = new TEquipmentDesc();
                                equipmentDesc.setEquipmentId(equipment.getId());
                                equipmentDescService.save(equipmentDesc);
                            }
                        } else {

                            TEquipment equipment = new TEquipment();
                            equipment.setId(IDGenerator.commonID());
                            equipment.setCreateDate(new Date());
                            equipment.setModifyDate(new Date());
                            equipment.setClientId(clientId);
                            equipment.setManagerId(equipmentApply.getManagerId());
                            equipment.setAdminId(adminId);
                            equipment.setAdminLevel(adminLevel);
                            equipment.setGtClientId(gtClientId);
                            equipment.setAdminUserName(adminUserName);
                            equipment.setIsUsing(true);
                            equipment.setIsNetWork(true);
                            equipment.setGuestPwd("123456");
                            equipment.setAdminPwd("123456");
                            equipment.setChannel("1");
                            equipment.setProductTotal(0);
                            equipment.setCompanyType(companyType);
                            equipment.setMachineType(machineType);
                            //设置默认规则
                            equipment.setTimeRuleId(Long.valueOf(1));
                            if (equimentType.equals("MG320-1")) {
                                equipment.setEquimentType("MG320");
                            } else {
                                equipment.setEquimentType(equimentType);
                            }
                            if (!StringUtils.isEmpty(equimentType) && equimentType.equals("MG280")) {
                                Long monthBegin = getMonthBegin(new Date());
                                long time = System.currentTimeMillis();
                                if (time < monthBegin) {
                                    equipment.setEndDate(new Date(monthBegin));
                                } else {
                                    Date date = nextMonthDate();
                                    equipment.setEndDate(date);
                                }
                                equipmentService.sentMessage(clientId, PushUtils.buildJson("endDate", String.valueOf(equipment.getEndDate().getTime())).toString());
                                PushUtils.push(equipmentApply.getGtClientId(), "", "", PushUtils.buildJson("endDate", String.valueOf(equipment.getEndDate().getTime())).toString());
                            }

                            equipmentService.save(equipment);
                            if (StringUtils.isEmpty(machineType) || machineType.equals("0")) {
                                equipmentService.sentMessage(clientId, PushUtils.buildJson("statusType", "agreed" + old).toString());
                                PushUtils.push(equipmentApply.getGtClientId(), "【棉花糖】设备初始化申请", "同意", PushUtils.buildJson("statusType", "agreed" + old).toString());
                            } else if (StringUtils.isNotEmpty(machineType) && machineType.equals("1")) {
                                equipmentService.sentMessage(clientId, PushUtils.buildJson("statusType", "agreed" + old).toString());
                                PushUtils.push(equipmentApply.getGtClientId(), "【爆米花】设备初始化申请", "同意", PushUtils.buildJson("statusType", "agreed" + old).toString());
                            } else if (StringUtils.isNotEmpty(machineType) && machineType.equals("2")) {
                                equipmentService.sentMessage(clientId, PushUtils.buildJson("statusType", "agreed" + old).toString());
                                PushUtils.push(equipmentApply.getGtClientId(), "【冰淇淋】设备初始化申请", "同意", PushUtils.buildJson("statusType", "agreed" + old).toString());
                            }
                            LambdaQueryWrapper<TEquipment> query3 = Wrappers.lambdaQuery();
                            query3.eq(TEquipment::getClientId, clientId);
                            TEquipment tEquipment = equipmentService.getOne(query3);
                            try {
                                if (tEquipment != null) {
                                    esTEquipmentService.insertData(tEquipment);
                                }
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                            TEquipmentDesc equipmentDesc = new TEquipmentDesc();
                            equipmentDesc.setEquipmentId(tEquipment.getId());
                            equipmentDescService.save(equipmentDesc);
                        }
                        //获取设备的id
                        LambdaQueryWrapper<TEquipment> query1 = Wrappers.lambdaQuery();
                        query1.eq(TEquipment::getClientId, clientId);
                        TEquipment equipment = equipmentService.getOne(query1);
                        Long equipmentId = equipment.getId();
                        // 如果存在旧花型，就删除重新创建
                        LambdaQueryWrapper<TProduct> queryProduct = Wrappers.lambdaQuery();
                        queryProduct.eq(TProduct::getEquipmentId, equipment.getId());
                        List<TProduct> productList = productService.list(queryProduct);
                        if (productList.isEmpty()) {
                            if (StringUtils.isEmpty(machineType) || machineType.equals("0")) {
                                if (equipmentApply.getEquimentType() != null && equipmentApply.getEquimentType().equals("MG280")) {
                                    saveProductMG280(equipmentId);
                                } else if (equipmentApply.getEquimentType() != null && equipmentApply.getEquimentType().equals("MG320-1")) {
                                    saveProductMG1(equipmentId);
                                } else {
                                    saveProduct(equipmentId);
                                }
                            } else if (StringUtils.isNotEmpty(machineType) && machineType.equals("1")) {
                                switch (equimentType) {
                                    case "P30":
                                        saveGoodsData(equipmentId, machineType, 6, equimentType);
                                        break;
                                    case "P20":
                                        saveGoodsData(equipmentId, machineType, 12, equimentType);
                                        break;
                                    case "P10":
                                        saveGoodsData(equipmentId, machineType, 2, equimentType);
                                        break;
                                    case "SBM10":
                                        saveGoodsData(equipmentId, machineType, 2, equimentType);
                                        break;
                                    default:
                                        break;
                                }
                            } else if (StringUtils.isNotEmpty(machineType) && machineType.equals("2")) {
                                if (equimentType.equals("SI320")) {
                                    saveGoodsData(equipmentId, machineType, 6, equimentType);
                                }
                            } else if (StringUtils.isNotEmpty(machineType) && machineType.equals("3")) {
                                if (equimentType.equals("EF210")) {
                                    saveGoodsData(equipmentId, machineType, 5, equimentType);
                                }
                            }
                        }

                        if (String.valueOf(adminId).equals("3") || String.valueOf(adminId).equals("31") || String.valueOf(adminId).equals("506") || String.valueOf(adminId).equals("1090")) {
                            //自动设置分销
                            setProportion(adminId, equipmentId, clientId);
                        }
                    } else if (status.equals("rejected")) {
                        equipmentApply.setStatusType(2);
                        equipmentService.sentMessage(equipmentApply.getClientId(), PushUtils.buildJson("statusType", "rejected").toString());
                    }
                    equipmentApplyService.updateById(equipmentApply);
                }
            }
        }
    }

    private void setProportion(Long adminId, Long equipmentId, String clientId) {
        //先找到原账户的分销
        LambdaQueryWrapper<TProportion> query3 = Wrappers.lambdaQuery();
        query3.eq(TProportion::getAdminId, adminId);
        List<TProportion> list3 = proportionService.list(query3);
        if (list3.size() > 0) {
            TProportion adminProportion = list3.get(0);
            if (StringUtils.isEmpty(adminProportion.getClientId())) {
                TProportion equipmentProportion = new TProportion();
                equipmentProportion.setCreateDate(new Date());
                equipmentProportion.setModifyDate(new Date());
                equipmentProportion.setAdminId(adminId);
                equipmentProportion.setClientId(clientId);
                equipmentProportion.setEquipmentId(equipmentId);
                equipmentProportion.setAdminProportion(adminProportion.getAdminProportion());
                Integer type = adminProportion.getType();
                if (type != null) {
                    switch (type) {
                        case 1:
                            equipmentProportion.setProportion(adminProportion.getAgencyProportion());
                            equipmentProportion.setAgencyProportion(new BigDecimal("0.00"));
                            equipmentProportion.setMerchantProportion(new BigDecimal("0.00"));
                            equipmentProportion.setPersonageProportion(new BigDecimal("0.00"));
                            equipmentProportion.setType(0);
                            break;
                        case 2:
                            equipmentProportion.setProportion(adminProportion.getMerchantProportion());
                            equipmentProportion.setAgencyProportion(adminProportion.getAgencyProportion());
                            equipmentProportion.setAgencyId(adminProportion.getAgencyId());
                            TAdmin byId = adminService.getById(adminProportion.getAgencyId());
                            equipmentProportion.setAgencyName(byId.getUsername());
                            equipmentProportion.setMerchantProportion(new BigDecimal("0.00"));
                            equipmentProportion.setPersonageProportion(new BigDecimal("0.00"));
                            equipmentProportion.setType(1);
                            break;
                        case 3:
                            equipmentProportion.setProportion(adminProportion.getPersonageProportion());
                            equipmentProportion.setAgencyProportion(adminProportion.getAgencyProportion());
                            equipmentProportion.setAgencyId(adminProportion.getAgencyId());
                            TAdmin byId1 = adminService.getById(adminProportion.getAgencyId());
                            equipmentProportion.setAgencyName(byId1.getUsername());
                            equipmentProportion.setMerchantProportion(adminProportion.getMerchantProportion());
                            equipmentProportion.setMerchantId(adminProportion.getMerchantId());
                            TAdmin byId2 = adminService.getById(adminProportion.getMerchantId());
                            equipmentProportion.setMerchantName(byId2.getUsername());
                            equipmentProportion.setPersonageProportion(new BigDecimal("0.00"));
                            equipmentProportion.setType(2);
                            break;
                    }
                    boolean save = proportionService.save(equipmentProportion);
                }

            }

        }
    }

    /**
     * 添加商品
     *
     * @param id
     * @param machineType
     * @param number
     */
    private void saveGoodsData(Long id, String machineType, Integer number, String equipmentType) {
        LambdaQueryWrapper<TGoodsData> wrapper = Wrappers.lambdaQuery();
        wrapper.eq(TGoodsData::getNumber, number);
        wrapper.eq(TGoodsData::getMachineType, machineType);
        if (!machineType.equals("0")) {
            wrapper.eq(TGoodsData::getEquipmentType, equipmentType);
        }
        TGoodsData goodsData = goodsDataService.getOne(wrapper);
        String goods = goodsData.getGoods();
        String[] str = goods.split(",");

        for (int i = 0; i < str.length; i++) {
            TProduct product = new TProduct();
            product.setCreateDate(new Date());
            product.setModifyDate(new Date());
            product.setEquipmentId(id);
            String[] split = str[i].split("-");
            product.setProductName(split[0]);
            product.setNo(split[1]);
            product.setRmbPrice(new BigDecimal(0.01));
            product.setCodePrice(new BigDecimal(0.01));
            productService.save(product);
        }
    }

    /**
     * 添加棉花糖产品
     *
     * @param id
     */
    private void saveProduct(Long id) {
        String[] str = {"玫瑰精灵-A01", "童心未泯-A02", "五彩缤纷-A03", "天雪恋舞-A04", "水中芙蓉-A05", "烈焰红唇-A06", "美梦成真-A07", "一见钟情-A08", "幽兰爱恋-A09", "心之守护-A10",
                "夏日爱恋-A11", "冰美人-A12", "国色天香-A13", "赤子之心-A14", "海洋之心-A15", "水晶之恋-A16", "彩色精灵-A17", "小棉袄-A18"};

        for (int i = 0; i < str.length; i++) {
            TProduct product = new TProduct();
            product.setCreateDate(new Date());
            product.setModifyDate(new Date());
            product.setEquipmentId(id);
            String[] split = str[i].split("-");
            product.setProductName(split[0]);
            product.setNo(split[1]);
            product.setRmbPrice(new BigDecimal(0.01));
            product.setCodePrice(new BigDecimal(0.01));
            productService.save(product);
        }

    }

    private void saveProductMG280(Long id) {
        String[] str = {"水中芙蓉-A05", "水中芙蓉mini-A31", "烈焰红唇-A06", "烈焰红唇mini-A32", "夏日爱恋-A11", "夏日爱恋mini-A33", "冰美人-A12", "冰美人mini-A34", "彩色精灵-A17", "彩色精灵mini-A35"};

        for (int i = 0; i < str.length; i++) {
            TProduct product = new TProduct();
            product.setCreateDate(new Date());
            product.setModifyDate(new Date());
            product.setEquipmentId(id);
            String[] split = str[i].split("-");
            product.setProductName(split[0]);
            product.setNo(split[1]);
            product.setRmbPrice(new BigDecimal(0.01));
            product.setCodePrice(new BigDecimal(0.01));
            productService.save(product);
        }

    }

    private void saveProductMG1(Long id) {
        String[] str = {"玫瑰精灵-A01", "童心未泯-A02", "五彩缤纷-A03", "天雪恋舞-A04", "水中芙蓉-A05", "烈焰红唇-A06", "美梦成真-A07", "一见钟情-A08", "幽兰爱恋-A09",
                "心之守护-A10", "夏日爱恋-A11", "冰美人-A12", "国色天香-A13", "赤子之心-A14", "海洋之心-A15", "水晶之恋-A16", "彩色精灵-A17", "小棉袄-A18",
                "精灵蝶梦-A19", "夏日倾城-A20", "百花齐放-A21", "蜂缠蝶恋-A22", "豆蔻年华-A23", "星空幻想-A24", "坠入星空-A25", "雪花飞舞-A26", "春暖花开-A27", "花飞蝶舞-A28",
                "花样年华-A29", "心花怒放-A30"};

        for (int i = 0; i < str.length; i++) {
            TProduct product = new TProduct();
            product.setCreateDate(new Date());
            product.setModifyDate(new Date());
            product.setEquipmentId(id);
            String[] split = str[i].split("-");
            product.setProductName(split[0]);
            product.setNo(split[1]);
            product.setRmbPrice(new BigDecimal(0.01));
            product.setCodePrice(new BigDecimal(0.01));
            productService.save(product);
        }

    }

    private void saveProductMG12(Long id) {
        String[] str = {"精灵蝶梦-A19", "夏日倾城-A20", "百花齐放-A21", "蜂缠蝶恋-A22", "豆蔻年华-A23", "星空幻想-A24"
                , "坠入星空-A25", "雪花飞舞-A26", "春暖花开-A27", "花飞蝶舞-A28", "花样年华-A29", "心花怒放-A30"};
        for (int i = 0; i < str.length; i++) {
            TProduct product = new TProduct();
            product.setEquipmentId(id);
            product.setCreateDate(new Date());
            product.setModifyDate(new Date());
            String[] split = str[i].split("-");
            product.setProductName(split[0]);
            product.setNo(split[1]);
            product.setRmbPrice(new BigDecimal(0.01));
            product.setCodePrice(new BigDecimal(0.01));
            productService.save(product);
        }
    }

    private void saveProductMG22(Long id) {
        String[] str = {"玫瑰精灵-A01", "童心未泯-A02", "五彩缤纷-A03", "天雪恋舞-A04", "水中芙蓉-A05", "烈焰红唇-A06", "美梦成真-A07", "一见钟情-A08", "幽兰爱恋-A09", "心之守护-A10",
                "夏日爱恋-A11", "冰美人-A12", "国色天香-A13", "赤子之心-A14", "海洋之心-A15", "水晶之恋-A16", "彩色精灵-A17", "小棉袄-A18", "精灵蝶梦-A19", "蜂缠蝶恋-A22", "坠入星空-A25", "花飞蝶舞-A28"};

        for (int i = 0; i < str.length; i++) {
            TProduct product = new TProduct();
            product.setCreateDate(new Date());
            product.setModifyDate(new Date());
            product.setEquipmentId(id);
            String[] split = str[i].split("-");
            product.setProductName(split[0]);
            product.setNo(split[1]);
            product.setRmbPrice(new BigDecimal(0.01));
            product.setCodePrice(new BigDecimal(0.01));
            productService.save(product);
        }

    }

    private void saveProductMG26(Long id) {
        String[] str = {"玫瑰精灵-A01", "童心未泯-A02", "五彩缤纷-A03", "天雪恋舞-A04", "水中芙蓉-A05", "烈焰红唇-A06", "美梦成真-A07", "一见钟情-A08", "幽兰爱恋-A09", "心之守护-A10",
                "夏日爱恋-A11", "冰美人-A12", "国色天香-A13", "赤子之心-A14", "海洋之心-A15", "水晶之恋-A16", "彩色精灵-A17", "小棉袄-A18", "精灵蝶梦-A19", "蜂缠蝶恋-A22", "坠入星空-A25", "花飞蝶舞-A28",
                "夏日倾城-A20", "雪花飞舞-A26", "豆蔻年华-A23", "花样年华-A29"};
        for (int i = 0; i < str.length; i++) {
            TProduct product = new TProduct();
            product.setCreateDate(new Date());
            product.setModifyDate(new Date());
            product.setEquipmentId(id);
            String[] split = str[i].split("-");
            product.setProductName(split[0]);
            product.setNo(split[1]);
            product.setRmbPrice(new BigDecimal(0.01));
            product.setCodePrice(new BigDecimal(0.01));
            productService.save(product);
        }

    }

    private void saveProductMG42(Long id) {
        String[] str = {"玫瑰精灵-A01", "童心未泯-A02", "五彩缤纷-A03", "天雪恋舞-A04", "水中芙蓉-A05", "烈焰红唇-A06", "美梦成真-A07", "一见钟情-A08", "幽兰爱恋-A09",
                "心之守护-A10", "夏日爱恋-A11", "冰美人-A12", "国色天香-A13", "赤子之心-A14", "海洋之心-A15", "水晶之恋-A16", "彩色精灵-A17", "小棉袄-A18",
                "精灵蝶梦-A19", "夏日倾城-A20", "百花齐放-A21", "蜂缠蝶恋-A22", "豆蔻年华-A23", "星空幻想-A24", "坠入星空-A25", "雪花飞舞-A26", "春暖花开-A27", "花飞蝶舞-A28",
                "花样年华-A29", "心花怒放-A30", "花好月圆-A37", "出水芙蓉-A38", "微光染晕-A39", "夏日莓莓-A40", "芳楚纷飞-A41", "晨夕光晕-A42", "坠入爱河-A43", "天马行空-A44",
                "灼灼其华-A45", "一帘幽梦-A46", "七月初夏-A47", "四月微风-A48"};
        for (int i = 0; i < str.length; i++) {
            TProduct product = new TProduct();
            product.setCreateDate(new Date());
            product.setModifyDate(new Date());
            product.setEquipmentId(id);
            String[] split = str[i].split("-");
            product.setProductName(split[0]);
            product.setNo(split[1]);
            product.setRmbPrice(new BigDecimal(0.01));
            product.setCodePrice(new BigDecimal(0.01));
            productService.save(product);
        }

    }

    /**
     * 添加爆米花产品
     *
     * @param id
     */
    private void saveProductP30(Long id) {
        String[] str = {"活力爆米花(正常糖)-B01", "活力爆米花(无糖)-B02", "活力爆米花(巧克力)-B03", "活力爆米花(焦糖)-B04", "活力爆米花(水蜜桃)-B05", "活力爆米花(蓝莓)-B06"};

        for (int i = 0; i < str.length; i++) {
            TProduct product = new TProduct();
            product.setCreateDate(new Date());
            product.setModifyDate(new Date());
            product.setEquipmentId(id);
            String[] split = str[i].split("-");
            product.setProductName(split[0]);
            product.setNo(split[1]);
            product.setRmbPrice(new BigDecimal(0.01));
            product.setCodePrice(new BigDecimal(0.01));
            productService.save(product);
        }
    }

    /**
     * 添加冰淇淋产品
     *
     * @param id
     */
    private void saveProductSI320(Long id) {
        LambdaQueryWrapper<TGoodsData> wrapper = Wrappers.lambdaQuery();
        wrapper.eq(TGoodsData::getNumber, 6);
        wrapper.eq(TGoodsData::getMachineType, "2");
        TGoodsData goodsData = goodsDataService.getOne(wrapper);
        String goods = goodsData.getGoods();
        String[] str = goods.split(",");

        for (int i = 0; i < str.length; i++) {
            TProduct product = new TProduct();
            product.setCreateDate(new Date());
            product.setModifyDate(new Date());
            product.setEquipmentId(id);
            String[] split = str[i].split("-");
            product.setProductName(split[0]);
            product.setNo(split[1]);
            product.setRmbPrice(new BigDecimal(0.01));
            product.setCodePrice(new BigDecimal(0.01));
            productService.save(product);
        }
    }

    /**
     * 获取指定日期所在月份开始的时间戳
     *
     * @param date 指定日期
     * @return
     */
    public static Long getMonthBegin(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);

        //设置为10号,当前日期既为本月10号
        c.set(Calendar.DAY_OF_MONTH, 10);
        //将小时至0
        c.set(Calendar.HOUR_OF_DAY, 0);
        //将分钟至0
        c.set(Calendar.MINUTE, 0);
        //将秒至0
        c.set(Calendar.SECOND, 0);
        //将毫秒至0
        c.set(Calendar.MILLISECOND, 0);
        // 获取本月第一天的时间戳
        return c.getTimeInMillis();
    }

    public static Date nextMonthDate() {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_MONTH, 10);
        //将小时至0
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        //将分钟至0
        calendar.set(Calendar.MINUTE, 0);
        //将秒至0
        calendar.set(Calendar.SECOND, 0);
        //将毫秒至0
        calendar.set(Calendar.MILLISECOND, 0);
        calendar.add(Calendar.MONTH, 1);
        return calendar.getTime();
    }

    /**
     * 改花型
     *
     * @param
     * @return
     */
    @RequestMapping(value = "/updateFlowers.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String updateFlowers(String clientId, String number) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment != null) {
            Long id = equipment.getId();
            //修改花型记录数目
            equipment.setFlowers(number);
            equipmentService.updateById(equipment);
            //修改设备描述表中的花型记录数目
            TEquipmentDesc equipmentDesc = equipmentDescService.getById(id);
            if (equipmentDesc != null) {
                equipmentDesc.setFlowers(number);
                equipmentDescService.updateById(equipmentDesc);
            } else {
                TEquipmentDesc equipmentDesc1 = new TEquipmentDesc();
                equipmentDesc1.setEquipmentId(id);
                equipmentDesc1.setFlowers(number);
                equipmentDescService.save(equipmentDesc1);
            }
            //删除旧花型
            LambdaQueryWrapper<TProduct> queryProduct = Wrappers.lambdaQuery();
            queryProduct.eq(TProduct::getEquipmentId, equipment.getId());
            List<TProduct> productList = productService.list(queryProduct);
            for (TProduct product : productList) {
                productService.removeById(product.getId());
            }
            // 机器类型
            String machineType = equipment.getMachineType();
            if (StringUtils.isEmpty(equipment.getMachineType())) {
                machineType = "0";
            }
            String equipmentType = equipment.getEquimentType();
            //创建花型
            saveGoodsData(id, machineType, Integer.parseInt(number), equipmentType);
            return "success";
        } else {
            return "error";
        }
    }

    /**
     * 设备类型  开机时上传
     *
     * @param clientId 个推
     * @return
     */
    @RequestMapping(value = "/equimentType.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String equimentType(String clientId, String equimentType) {
        if (!StringUtils.isEmpty(equimentType)) {
            LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
            query.eq(TEquipment::getClientId, clientId);
            TEquipment equipment = equipmentService.getOne(query);
            equipment.setEquimentType(equimentType);
            equipmentService.updateById(equipment);
        }
        return "success";
    }

    /**
     * 设备地址  开机时上传
     *
     * @param clientId 个推
     * @return
     */
    @RequestMapping(value = "/equimentArea.htm", method = RequestMethod.GET, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String equimentArea(String clientId, String longitude, String latitude, String fullName) {
        if (!StringUtils.isEmpty(longitude) && !StringUtils.isEmpty(latitude) && !StringUtils.isEmpty(fullName)) {
            LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
            query.eq(TEquipment::getClientId, clientId);
            TEquipment equipment = equipmentService.getOne(query);
            equipment.setLatitude(Double.valueOf(latitude));
            equipment.setLongitude(Double.valueOf(longitude));
            equipment.setFullName(fullName + "-");
            equipmentService.updateById(equipment);
            return "success";
        }
        return "error";
    }

    /**
     * 商品调价
     */
    @RequestMapping(value = "/updateProduct.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String updateProduct(@RequestBody List<ProductVo> productVos) {
        for (ProductVo product : productVos) {
            String clientId = product.getClientId();
            LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
            query.eq(TEquipment::getClientId, clientId);
            TEquipment equipment = equipmentService.getOne(query);
            Long id = equipment.getId();
            if (StringUtils.isNotEmpty(product.getShowType())) {
                LambdaQueryWrapper<TProduct> queryProduct = Wrappers.lambdaQuery();
                queryProduct.eq(TProduct::getEquipmentId, id);
                queryProduct.eq(TProduct::getProductName, product.getProductName());
                TProduct tProduct = productService.getOnly(queryProduct);
                if (tProduct == null) {
                    LambdaQueryWrapper<TNameDictionary> wrapper = Wrappers.lambdaQuery();
                    wrapper.eq(TNameDictionary::getLanguage, "zh");
                    wrapper.eq(TNameDictionary::getName, product.getProductName());
                    TNameDictionary nameDictionary = nameDictionaryService.getOne(wrapper);
                    LambdaQueryWrapper<TProduct> queryWrapper = Wrappers.lambdaQuery();
                    queryWrapper.eq(TProduct::getEquipmentId, id);
                    queryWrapper.eq(TProduct::getNo, nameDictionary.getNo());
                    tProduct = productService.getOnly(queryWrapper);
                }
                tProduct.setRmbPrice(BigDecimal.valueOf(product.getRmbPrice()));
                tProduct.setCodePrice(BigDecimal.valueOf(product.getCodePrice()));
                tProduct.setShowType(product.getShowType());
                tProduct.setSellStatus(product.getSellStatus());
                productService.updateById(tProduct);
            } else {
                LambdaQueryWrapper<TProduct> queryProduct = Wrappers.lambdaQuery();
                queryProduct.eq(TProduct::getEquipmentId, id);
                queryProduct.eq(TProduct::getProductName, product.getProductName());
                TProduct tProduct = productService.getOnly(queryProduct);
                if (tProduct == null) {
                    LambdaQueryWrapper<TNameDictionary> wrapper = Wrappers.lambdaQuery();
                    wrapper.eq(TNameDictionary::getLanguage, "zh");
                    wrapper.eq(TNameDictionary::getName, product.getProductName());
                    TNameDictionary nameDictionary = nameDictionaryService.getOne(wrapper);
                    LambdaQueryWrapper<TProduct> queryWrapper = Wrappers.lambdaQuery();
                    queryWrapper.eq(TProduct::getEquipmentId, id);
                    queryWrapper.eq(TProduct::getNo, nameDictionary.getNo());
                    tProduct = productService.getOnly(queryWrapper);
                }
                tProduct.setRmbPrice(BigDecimal.valueOf(product.getRmbPrice()));
                tProduct.setCodePrice(BigDecimal.valueOf(product.getCodePrice()));
                tProduct.setSellStatus(product.getSellStatus());
                productService.updateById(tProduct);
            }
        }
        return "调价成功";
    }

    public Double tran(Double d) {
        return new BigDecimal(d).setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    public Double tran2(Double d) {
        return new BigDecimal(d).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 密码修改
     *
     * @param clientId 设备个推Id
     * @param pwdType  密码类型 1d代表修adminPwd,0代表guestPwd
     * @return
     * @Param pwd 密码内容
     */
    @RequestMapping(value = "/updatePwd.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String updatePwd(String clientId, String pwdType, String pwd) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment != null) {
            if (!StringUtils.isEmpty(pwdType)) {
                switch (pwdType) {
                    case "1":
                        equipment.setAdminPwd(pwd);
                        break;
                    case "0":
                        equipment.setGuestPwd(pwd);
                        break;
                }
                equipmentService.updateById(equipment);
                return "更新密码成功";
            }

        }
        return "更新密码失败";
    }

    /**
     * 设备获取密码
     */
    @GetMapping(value = "/getPwd", produces = "text/html;charset=utf-8")
    @ResponseBody
    public String getPwd(String clientId) {
        if (StringUtils.isEmpty(clientId)) {
            return null;
        }
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        Map<String, String> map = new HashMap<>();
        map.put("adminPwd", equipment.getAdminPwd());
        map.put("guestPwd", equipment.getGuestPwd());
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("code", 0);
        jsonObject.put("data", JSONObject.toJSON(map).toString());
        jsonObject.put("errmsg", "");
        return jsonObject.toJSONString();
    }

    /**
     * 修改支付方式
     *
     * @param clientId
     * @param payType: 无需支付
     *                 线上支付
     *                 线下支付
     *                 线上/线下
     * @return
     */
    @RequestMapping(value = "/updatePayType.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String updatePayType(String clientId, String payType) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment == null) {
            return "修改支付方式失败";
        }
        equipment.setPayType(0);
        equipmentService.updateById(equipment);
        return "修改成功";
    }

    /**
     * 日志上传
     */
    @RequestMapping(value = "/sendLog.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String uploadFile(HttpServletRequest request, HttpServletResponse response, String fileName) throws Exception {
        //构造一个带指定 Region 对象的配置类
        Configuration cfg = new Configuration(Region.region2());
        cfg.resumableUploadAPIVersion = Configuration.ResumableUploadAPIVersion.V2;// 指定分片上传版本
        UploadManager uploadManager = new UploadManager(cfg);
        //默认不指定key的情况下，以文件内容的hash值作为文件名
        String key = "log/" + fileName + ".txt";
        try {
            ServletInputStream input = request.getInputStream();
            Auth auth = Auth.create(ConfigConsts.QINIU_CLOUD_ACCESS_KEY, ConfigConsts.QINIU_CLOUD_SECRET_KEY);
            String upToken = auth.uploadToken(ConfigConsts.QINIU_CLOUD_BUCKET, key);
            Response responseMap = uploadManager.put(input, key, upToken, null, null);
            //解析上传成功的结果
            DefaultPutRet putRet = new Gson().fromJson(responseMap.bodyString(), DefaultPutRet.class);
            String result = "https://qiniuyun.sunzee.com.cn/" + key;
            Configuration cfg0 = new Configuration(Region.region0());
            int days = 7;
            BucketManager bucketManager = new BucketManager(auth, cfg0);
            bucketManager.deleteAfterDays(ConfigConsts.QINIU_CLOUD_BUCKET, key, days);
        } catch (Exception ex) {
            //响应信息 json字符串格式
            Map<String, Object> responseMap = new HashMap<String, Object>();
            responseMap.put("flag", false);
            responseMap.put("errorMsg", ex.getMessage());
            String jsonResponse = JSONObject.toJSONString(responseMap);
            sendResponse(jsonResponse, response);
        }
        return "success";
    }

    /**
     * 返回响应
     *
     * @throws Exception
     */
    private void sendResponse(String responseString, HttpServletResponse response) throws Exception {
        response.setContentType("application/json;charset=UTF-8");
        PrintWriter pw = null;
        try {
            pw = response.getWriter();
            pw.write(responseString);
            pw.flush();
        } finally {
            IOUtils.closeQuietly(pw);
        }
    }

    /**
     * 脱离系统
     *
     * @param clientId
     * @return
     */
    @RequestMapping(value = "/separate.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String separate(String clientId) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment == null) {
            return "该设备不存在";
        }
        equipmentService.sentMessage(clientId, PushUtils.buildJson("tuoji", "0").toString());
        if ("xxx".equals(equipment.getClientId().substring(equipment.getClientId().length() - 3, equipment.getClientId().length()))) {
            return "脱离成功";
        }
        equipment.setClientId(equipment.getClientId() + "xxx");
        equipmentService.updateById(equipment);
        return "脱离成功";
    }

    /**
     * 脱离系统
     *
     * @param clientId
     * @return
     */
    @RequestMapping(value = "/updateClientId", method = RequestMethod.POST)
    @ResponseBody
    public String updateClientId(String clientId) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment == null) {
            return "该设备不存在";
        }
        if ("xxx".equals(equipment.getClientId().substring(equipment.getClientId().length() - 3, equipment.getClientId().length()))) {
            return "脱离成功";
        }
        equipment.setClientId(equipment.getClientId() + "xxx");
        equipment.setManagerId(null);
        equipmentService.updateById(equipment);
        return "脱离成功";
    }

    /**
     * 修改设备联系人名称以及电话
     */
    @RequestMapping(value = "/updateContractPN.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String updateContractPN(String clientId, String contactName, String contactPhone) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment == null) {
            return "该设备不存在";
        }
        equipment.setContactName(contactName);
        equipment.setContactPhone(contactPhone);
        equipmentService.updateById(equipment);
        return "修改成功";
    }

    /**
     * 设备上传公司电话
     */
    @RequestMapping(value = "/sentCompanyPhone.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String sentCompanyPhone(String clientId, String companyPhone) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment == null) {
            return "该设备不存在";
        }
        equipment.setCompanyPhone(companyPhone);
        equipmentService.updateById(equipment);
        return "修改成功";
    }

    /**
     * 获取二维码图片
     */
    @RequestMapping(value = "/getQrCodeImgUrl.htm", method = RequestMethod.GET, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String getQrCodeImgUrl(String clientId) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment == null) {
            return "404";
        }
        return "400";
    }

    /**
     * 上传4G卡号
     */
    @RequestMapping(value = "/sentSimNo.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String sentSimNo(String clientId, String simNo) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment == null) {
            return "该设备不存在";
        }
        equipment.setSimNo(simNo);
        equipmentService.updateById(equipment);
        return "修改成功";
    }

    /**
     * 上传机器的apk版本
     */
    @RequestMapping(value = "/sendApkVersion.htm", method = RequestMethod.GET, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String sendApkVersion(String clientId, String apkVersion) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment == null) {
            return "该设备不存在";
        }
        equipment.setApkVersion(apkVersion);
        equipmentService.updateById(equipment);
        return "success";
    }

    /**
     * 上传机器的做糖状态
     */
    @RequestMapping(value = "/equipmentStatus.htm", method = RequestMethod.GET, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String equipmentStatus(String clientId, String status) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment == null) {
            return "该设备不存在";
        }
        TEquipmentDesc equipmentDesc = equipmentDescService.getById(equipment.getId());
        //机器状态；0：空闲，1：在做糖;
        equipmentDesc.setStatus(status);
        equipmentDescService.updateById(equipmentDesc);
        return "success";
    }

    /**
     * 修改设备状态
     *
     * @param clientId
     * @param eqeStatus 设备状态1开 0关
     * @return
     */
    @RequestMapping(value = "/updateEqeStatus.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String updateEqeStatus(String clientId, Integer eqeStatus) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment == null) {
            return "该设备不存在";
        }
        if (eqeStatus != null) {
            equipment.setEqeStatus(eqeStatus);
            equipment.setModifyDate(new Date());
//            if (eqeStatus == 0) {
//                equipment.setCabinetTm("0");
//                equipment.setCabinetHd("0");
//                equipment.setFurnaceTm("0");
//                equipment.setFurnaceSp("0");
//            }
            equipmentService.updateById(equipment);
        }
        return "修改成功";
    }

    /**
     * 新修改设备状态
     *
     * @param clientId
     * @param eqeStatus 设备状态1开 0关
     * @return
     */
    @RequestMapping(value = "/updateEqeStatusNew.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String updateEqeStatusNew(String clientId, Integer eqeStatus, String netTime) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment == null) {
            return "该设备不存在";
        }
        // 设备名称
        String name = equipment.getName();
        // 如果为空就拿设备编号后六位
        if (StringUtils.isEmpty(name)) {
            name = equipment.getClientId().substring(equipment.getClientId().length() - 6);
        }
        if (eqeStatus != null) {
            equipment.setNetwork(netTime);
            equipment.setEqeStatus(eqeStatus);
            equipment.setModifyDate(new Date());
            // 查询是否有绑定微信
            LambdaQueryWrapper<TWechat> wechatQuery = Wrappers.lambdaQuery();
            wechatQuery.eq(TWechat::getAdminId, equipment.getAdminId());
            TWechat wechat = wechatService.getOne(wechatQuery);
            // 查询用户
            TAdmin admin = adminService.getById(equipment.getAdminId());
            // 如果有绑定微信
            if (admin != null) {
                // 查询是申泽还是七云的
                String companyType = admin.getCompanyType();
                // 查询用户是否开启设备上线提醒功能
                String onOffNotice = admin.getOnOffNotice();
                if (wechat != null && StringUtils.isNotEmpty(wechat.getOpenId()) && StringUtils.isNotEmpty(onOffNotice) && onOffNotice.equals("1")) {
                    // 微信发送设备上下线提醒消息
                    wechatService.sendOnOffMessage(wechat.getOpenId(), equipment.getClientId(), netTime, companyType, name, eqeStatus);
                }
                // 查询是否国外账号，国外就发送邮件
                String ifForeign = admin.getIfForeign();
                if (StringUtils.isNotEmpty(ifForeign) && ifForeign.equals("1") && onOffNotice.equals("1")) {
                    // 发送邮件提醒
                    String machineType = equipment.getMachineType();
                    if (StringUtils.isNotEmpty(machineType)) {
                        machineType = "0";
                    }
                    String messageReceiver = equipment.getMessageReceiver();
                    String timeZone = admin.getTimeZone();
                    // 发送设备设置的报警邮箱，没有设置就发送到账户邮箱
                    if (StringUtils.isNotEmpty(messageReceiver)) {
                        String[] split = messageReceiver.split(",");
                        for (String s : split) {
                            WechatSendUtil.sentEmail(s, name, timeZone, machineType, eqeStatus);
                        }
                    } else {
                        String email = admin.getEmail();
                        if (email != null) {
                            WechatSendUtil.sentEmail(admin.getEmail(), name, timeZone, machineType, eqeStatus);
                        }
                    }
                }
            }
            equipmentService.updateById(equipment);
        }
        return "修改成功";
    }

    /**
     * 修改设备锁定状态
     *
     * @param clientId
     * @param block
     * @return
     */
    @RequestMapping(value = "/updateBlock.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String updateBlock(String clientId, Boolean block) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment == null) {
            return "该设备不存在";
        }
        equipment.setIsBlocked(block);
        equipmentService.updateById(equipment);
        return "修改成功";
    }

    /**
     * 修改设备睡眠状态
     *
     * @param clientId
     * @param is_sleep
     * @return
     */
    @RequestMapping(value = "/updateSleep.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String updateSleep(String clientId, Boolean is_sleep) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment == null) {
            return "该设备不存在";
        }
        if (is_sleep != null) {
            equipment.setIsSleep(is_sleep);
            equipmentService.updateById(equipment);
        }
        return "修改成功";
    }

    /**
     * 修改设备生产棉花糖个数
     *
     * @param clientId
     * @param productTotal
     * @return
     */
    @RequestMapping(value = "/updateProductTotal.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String updateProductTotal(String clientId, Integer productTotal) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment == null) {
            return "该设备不存在";
        }
        Integer total = equipment.getProductTotal();
        if (total == null) {
            total = 0;
        }
        equipment.setProductTotal(total + productTotal);
        equipmentService.updateById(equipment);
        return "修改成功";
    }

    /**
     * 修改设备共同参数/进阶参数
     *
     * @param
     * @return
     */
//    @PostMapping(value = "/updateParam/{code}/{clientId}", produces = "application/json;charset=UTF-8")
//    @ResponseBody
//    public JsonMessage updateParam(@PathVariable Integer code, @PathVariable String clientId, @RequestBody List<CommonParamVo> commonParamVos) {
//        Equipment equipment = equipmentService.findByClientId(clientId);
//        if (equipment == null) {
//            return JsonMessage.error("设备不存在");
//        }
//        String param = JSONArray.toJSONString(commonParamVos);
//        if (code == 0) {
//            equipment.setCommonParameters(param);
//        } else {
//            equipment.setAdvancedParameters(param);
//        }
//        equipmentService.update(equipment);
//        return JsonMessage.success("修改成功");
//    }

    /**
     * 修改设备共同参数/进阶参数
     * code 0：通用参数；1：进阶参数；2：调试页参数；3：湿度参数
     *
     * @param
     * @return
     */
    @RequestMapping(value = "/updateParamNew", method = RequestMethod.POST)
    @ResponseBody
    public String updateParamNew(Integer code, String clientId, @RequestBody List<CommonParamVo> commonParamVos) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment == null) {
            return "设备不存在";
        }
        if (commonParamVos.size() <= 0) {
            return "参数为空";
        }
        LambdaQueryWrapper<TParameters> queryParameters = Wrappers.lambdaQuery();
        queryParameters.eq(TParameters::getClientId, clientId);
        queryParameters.eq(TParameters::getStatus, code);
        queryParameters.eq(TParameters::getEquipmentId, equipment.getId());
        List<TParameters> list = parametersService.list(queryParameters);
        if (list.size() > 0) {
            for (TParameters parameters : list) {
                //删除旧的参数
                parametersService.removeById(parameters.getId());
            }
        }
        Date date = new Date();
        for (CommonParamVo commonParamVo : commonParamVos) {
            TParameters parameters = new TParameters();
            parameters.setVal(commonParamVo.getVal());
            parameters.setName(commonParamVo.getName());
            parameters.setStatus(String.valueOf(code));
            parameters.setClientId(clientId);
            parameters.setEquipmentId(equipment.getId());
            parameters.setCreateDate(date);
            parameters.setModifyDate(date);
            parametersService.save(parameters);
        }
        return "修改成功";
    }

    /**
     * 修改单个设备共同参数/进阶参数
     * code 0：通用参数；1：进阶参数；2：调试页参数；3：湿度参数
     *
     * @param
     * @return
     */
    @PostMapping(value = "/updateAloneParam.htm", produces = "text/html;charset=utf-8")
    @ResponseBody
    public String updateAloneParam(String code, String clientId, String name, String val) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment == null) {
            return "设备不存在";
        }
        LambdaQueryWrapper<TParameters> queryParameters = Wrappers.lambdaQuery();
        queryParameters.eq(TParameters::getClientId, clientId);
        queryParameters.eq(TParameters::getStatus, code);
        queryParameters.eq(TParameters::getName, name);
        queryParameters.eq(TParameters::getEquipmentId, equipment.getId());
        List<TParameters> list1 = parametersService.list(queryParameters);
        if (list1.size() > 0) {
            TParameters parameters = list1.get(0);
            parameters.setVal(val);
            parameters.setModifyDate(new Date());
            parametersService.updateById(parameters);
        }

        return "修改成功";
    }

    /**
     * 获取机器列表
     */
    @RequestMapping(value = "/getEquipmentList.htm", method = RequestMethod.GET, produces = "application/json;charset=UTF-8")
    @ResponseBody
    public String getByAdminAndProduct(String adminId, String name) {
        JSONObject jsonObject = new JSONObject();
        if (StringUtils.isEmpty(adminId)) {
            jsonObject.put("code", 1);
            jsonObject.put("errmsg", "adminId为空");
            return jsonObject.toJSONString();
        }
        if (StringUtils.isEmpty(name)) {
            jsonObject.put("code", 1);
            jsonObject.put("errmsg", "name为空");
            return jsonObject.toJSONString();
        }
        TAdmin admin = adminService.getById(adminId);
        if (!admin.getUsername().equals(name)) {
            jsonObject.put("code", 1);
            jsonObject.put("errmsg", "name与adminId不匹配");
            return jsonObject.toJSONString();
        }
        List<EquipmentDTO> list = new ArrayList<>();
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getAdminId, Long.valueOf(adminId));
        List<TEquipment> equipmentList = equipmentService.list(query);
        for (TEquipment equipment : equipmentList) {
            EquipmentDTO equipmentDTO = new EquipmentDTO();
            equipmentDTO.setClientId(equipment.getClientId());
            equipmentDTO.setSn(equipment.getSn());
            equipmentDTO.setName(equipment.getName());
            equipmentDTO.setLatitude(equipment.getLatitude());
            equipmentDTO.setLongitude(equipment.getLongitude());
            equipmentDTO.setFullName(equipment.getFullName());
            equipmentDTO.setEqeStatus(equipment.getEqeStatus());
            list.add(equipmentDTO);
        }
        jsonObject.put("code", 0);
        jsonObject.put("rows", JsonUtils.toJson(list));
        jsonObject.put("errmsg", "");
        jsonObject.put("total", list.size());

        return jsonObject.toJSONString();
    }

    /**
     * 获取商品信息
     */
    @RequestMapping(value = "/getProductions.htm", method = RequestMethod.GET, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String getProductions(String adminId, String clientId) {
        JSONObject jsonObject = new JSONObject();
        if (StringUtils.isEmpty(adminId)) {
            jsonObject.put("code", 1);
            jsonObject.put("errmsg", "adminId为空");
            return jsonObject.toJSONString();
        }
        if (StringUtils.isEmpty(clientId)) {
            jsonObject.put("code", 1);
            jsonObject.put("errmsg", "clientId为空");
            return jsonObject.toJSONString();
        }
        TAdmin admin = adminService.getById(Long.valueOf(adminId));

        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);

        if (!equipment.getAdminId().toString().equals(admin.getId().toString())) {
            jsonObject.put("code", 1);
            jsonObject.put("errmsg", "clientId与adminId不匹配");
            return jsonObject.toJSONString();
        }
        List<String> list = new ArrayList<>();
        LambdaQueryWrapper<TProduct> queryProduct = Wrappers.lambdaQuery();
        queryProduct.eq(TProduct::getEquipmentId, equipment.getId());
        List<TProduct> products = productService.list(queryProduct);
        for (TProduct product : products) {
            list.add(product.getProductName());
        }
        jsonObject.put("code", 0);
        jsonObject.put("productions", JsonUtils.toJson(list));
        jsonObject.put("errmsg", "");
        jsonObject.put("total", list.size());

        return jsonObject.toJSONString();
    }

    /**
     * 根据设备编号获取商品信息
     */
    @RequestMapping(value = "/getproducts", method = RequestMethod.GET, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String getproducts(String clientId) {
        JSONObject jsonObject = new JSONObject();

        if (StringUtils.isEmpty(clientId)) {
            jsonObject.put("code", 1);
            jsonObject.put("errmsg", "clientId为空");
            return jsonObject.toJSONString();
        }
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        LambdaQueryWrapper<TProduct> queryProduct = Wrappers.lambdaQuery();
        if (equipment == null) {
            jsonObject.put("code", 1);
            jsonObject.put("errmsg", "找不到设备");
            return jsonObject.toJSONString();
        }
        queryProduct.eq(TProduct::getEquipmentId, equipment.getId());
        List<TProduct> products = productService.list(queryProduct);
        TEquipmentDesc equipmentDesc = equipmentDescService.getById(equipment.getId());
        for (TProduct product : products) {
            product.setCreateDate(null);
            product.setModifyDate(null);
            if (StringUtils.isNotEmpty(equipmentDesc.getLanguage()) && !equipmentDesc.getLanguage().equals("zh") && StringUtils.isEmpty(product.getName())) {
                LambdaQueryWrapper<TNameDictionary> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(TNameDictionary::getLanguage, "zh");
                queryWrapper.eq(TNameDictionary::getNo, product.getNo());
                TNameDictionary nameDictionary = nameDictionaryService.getOne(queryWrapper);
                if (nameDictionary != null) {
                    product.setProductName(nameDictionary.getName());
                }
            }
        }
        JSONObject jsonObject1 = new JSONObject();
        jsonObject1.put("code", 0);
        jsonObject1.put("data", JSONObject.toJSON(products).toString());
        jsonObject1.put("errmsg", "");
        return JSONObject.toJSON(products).toString();
    }

    /**
     * 是否启用物料监控功能
     * 0：不启用，1：启用
     *
     * @param clientId 个推
     * @return
     */
    @RequestMapping(value = "/updateMaterialStatus.htm", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String updateMaterialUse(String clientId, String isMaterialUse) {
        if (!StringUtils.isEmpty(clientId) && !StringUtils.isEmpty(isMaterialUse)) {
            LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
            query.eq(TEquipment::getClientId, clientId);
            TEquipment equipment = equipmentService.getOne(query);
            TEquipmentDesc equipmentDesc = equipmentDescService.getById(equipment.getId());
            equipmentDesc.setIsMaterialUse(isMaterialUse);
            equipmentDescService.updateById(equipmentDesc);
            // 改变参数表里的状态
            LambdaQueryWrapper<TParameters> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.eq(TParameters::getClientId, clientId);
            queryWrapper.eq(TParameters::getName, "M502");
            TParameters parameters = parametersService.getOne(queryWrapper);
            if (Objects.nonNull(parameters)) {
                parameters.setVal(isMaterialUse);
                parametersService.updateById(parameters);
            }
            return "success";
        }
        return "error";
    }

    //修改优惠码状态
    @RequestMapping(value = "/updateCode.htm", method = RequestMethod.GET, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String CardPay(String code, String clientId) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        LambdaQueryWrapper<TPromoCode> query1 = Wrappers.lambdaQuery();
        query1.eq(TPromoCode::getAdminId, equipment.getAdminId());
        query1.eq(TPromoCode::getCode, code);
        List<TPromoCode> list1 = promoCodeService.list(query1);
        TPromoCode promoCode = list1.get(0);
        promoCode.setIsUse("1");
        promoCode.setUseBy(equipment.getName());
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time = sdf.format(new Date());
        promoCode.setUseDate(time);
        promoCodeService.updateById(promoCode);
        return "success";
    }

    //验证优惠码
    @RequestMapping(value = "/selectCode.htm", method = RequestMethod.GET, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String selectCode(String code, String clientId) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);

        //验证优惠码
        LambdaQueryWrapper<TPromoCode> query1 = Wrappers.lambdaQuery();
        query1.eq(TPromoCode::getCode, code);
        List<TPromoCode> codeList = promoCodeService.list(query1);
        TPromoCode promoCode = new TPromoCode();
        if (codeList.size() == 0) {
            //不存在
            return "1";
        }
        for (TPromoCode cod : codeList) {
            if (!cod.getAdminId().equals("1")) {
                String adminId = cod.getAdminId();
                String adminId1 = String.valueOf(equipment.getAdminId());
                if (adminId.equals(adminId1)) {
                    promoCode = cod;
                }
            } else {
                promoCode = cod;
            }
        }
        if (promoCode.getAdminId() == null) {
            //不是本机
            return "3";
        }
        Date lastUseDate = null;
        if (promoCode != null) {
            lastUseDate = promoCode.getLastUseDate();
        }

        if (lastUseDate != null && lastUseDate.getTime() < ((new Date()).getTime())) {
            promoCode.setIsUse("2");
            promoCodeService.updateById(promoCode);
            //过期
            return "4";
        }
        if (promoCode.getId() == null) {
            //不存在
            return "1";
        }
        if (promoCode.getIsUse().equals("1")) {
            //被使用
            return "2";
        }
        if (!promoCode.getAdminId().equals("1")) {
            if (String.valueOf(equipment.getAdminId()).equals(promoCode.getAdminId())) {

            } else {
                //不是本机
                return "3";
            }
        }
        if (promoCode.getDiscount() == null) {
            //旧优惠码
            return "0";
        }
        if (promoCode.getDiscount() == 0) {
            //0折
            return "0";
        }
        return "success";
    }

    //修改机器的分销
    @RequestMapping(value = "/updateProportion.htm", method = RequestMethod.GET, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String updateProportion(String clientId) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment != null && equipment.getId() != null) {
            TAdmin admin = adminService.getById(equipment.getAdminId());
            String name = admin.getName();
            //查询机器是否已经有设置分销
            LambdaQueryWrapper<TProportion> query1 = Wrappers.lambdaQuery();
            query1.eq(TProportion::getClientId, equipment.getClientId());
            query1.eq(TProportion::getEquipmentId, equipment.getId());
            List<TProportion> list1 = proportionService.list(query1);
            if (list1.size() > 0) {
                //已有
            } else {
                //没有，需要创建
                //1，判断是否新机器
//                    Date createDate = equipment.getCreateDate();
//                    long time = createDate.getTime();
//                    DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//                    String  day= "2022-09-21 23:59:59";
//                    try {
//                        Date parse = simpleDateFormat.parse(day);
//                        if(time>parse.getTime()){
//                            return "新机器，不能已此方式生成分销！";
//                        }
//                    } catch (ParseException e) {
//                        e.printStackTrace();
//                    }
                //先找到原账户的分销
                LambdaQueryWrapper<TProportion> query2 = Wrappers.lambdaQuery();
                query2.eq(TProportion::getAdminId, admin.getId());
                List<TProportion> list2 = proportionService.list(query2);
                if (list2.size() > 0) {
                    TProportion adminProportion = list2.get(0);
                    if (StringUtils.isEmpty(adminProportion.getClientId())) {
                        TProportion equipmentProportion = new TProportion();
                        equipmentProportion.setCreateDate(new Date());
                        equipmentProportion.setModifyDate(new Date());
                        equipmentProportion.setAdminId(admin.getId());
                        equipmentProportion.setClientId(equipment.getClientId());
                        equipmentProportion.setEquipmentId(equipment.getId());
                        equipmentProportion.setAdminProportion(adminProportion.getAdminProportion());
                        Integer type = adminProportion.getType();
                        switch (type) {
                            case 1:
                                equipmentProportion.setProportion(adminProportion.getAgencyProportion());
                                equipmentProportion.setAgencyProportion(new BigDecimal("0.00"));
                                equipmentProportion.setMerchantProportion(new BigDecimal("0.00"));
                                equipmentProportion.setPersonageProportion(new BigDecimal("0.00"));
                                equipmentProportion.setType(0);
                                break;
                            case 2:
                                equipmentProportion.setProportion(adminProportion.getMerchantProportion());
                                equipmentProportion.setAgencyProportion(adminProportion.getAgencyProportion());
                                equipmentProportion.setAgencyId(admin.getAgencyId());
                                TAdmin byId = adminService.getById(admin.getAgencyId());
                                equipmentProportion.setAgencyName(byId.getUsername());
                                equipmentProportion.setMerchantProportion(new BigDecimal("0.00"));
                                equipmentProportion.setPersonageProportion(new BigDecimal("0.00"));
                                equipmentProportion.setType(1);
                                break;
                            case 3:
                                equipmentProportion.setProportion(adminProportion.getPersonageProportion());
                                equipmentProportion.setAgencyProportion(adminProportion.getAgencyProportion());
                                equipmentProportion.setAgencyId(admin.getAgencyId());
                                TAdmin byId1 = adminService.getById(admin.getAgencyId());
                                equipmentProportion.setAgencyName(byId1.getUsername());
                                equipmentProportion.setMerchantProportion(adminProportion.getMerchantProportion());
                                equipmentProportion.setMerchantId(admin.getMerchantId());
                                TAdmin byId2 = adminService.getById(admin.getMerchantId());
                                equipmentProportion.setMerchantName(byId2.getUsername());
                                equipmentProportion.setPersonageProportion(new BigDecimal("0.00"));
                                equipmentProportion.setType(2);
                                break;
                        }
                        boolean save = proportionService.save(equipmentProportion);
                    }

                } else {
                    return "原账户没有设置分销！";
                }
            }

        }
        return "success";
    }

    /**
     * @param clientId
     * @return
     */
    @GetMapping(value = "/getManagerId.htm")
    @ResponseBody
    public String getManagerId(String clientId) {
        if (!StringUtils.isEmpty(clientId)) {
            LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
            query.eq(TEquipment::getClientId, clientId);
            List<TEquipment> list = equipmentService.list(query);
            if (list.size() > 0) {
                TEquipment equipment = list.get(0);
                Long adminId = equipment.getAdminId();
                if (adminId != null) {
                    String managerId = AdminUtils.encrypt(false, adminId);
                    if (StringUtils.isEmpty(equipment.getManagerId()) || !equipment.getManagerId().equals(managerId)) {
                        equipment.setManagerId(managerId);
                        equipmentService.updateById(equipment);
                    }
                    return managerId;
                }
            }
            return "error";
        }
        return "error";
    }

    /**
     * 修改优惠券开关状态
     *
     * @param clientId
     * @return
     */
    @GetMapping(value = "/updateCouponStatus.htm")
    @ResponseBody
    public String updateCouponStatus(String clientId, String couponStatus) {
        if (!StringUtils.isEmpty(clientId) && StringUtils.isNotEmpty(couponStatus)) {
            LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
            query.eq(TEquipment::getClientId, clientId);
            TEquipment equipment = equipmentService.getOne(query);
            TEquipmentDesc equipmentDesc = equipmentDescService.getById(equipment.getId());
            equipmentDesc.setCouponStatus(couponStatus);
            equipmentDescService.updateById(equipmentDesc);
            TAdmin admin = adminService.getById(equipment.getAdminId());
            //同步数据到鲸准
            if (admin.getId().toString().equals("372") || admin.getRelationAdminId().equals("372") || admin.getId().toString().equals("639") || admin.getId().toString().equals("238")) {
                sendCouponStatus(clientId, equipment.getFullName(), equipment.getEqeStatus(), couponStatus);
            }
            return "success";
        }
        return "error";
    }

    private void sendCouponStatus(String clientId, String fullName, Integer eqeStatus, String couponStatus) {
        String url = "http://47.106.13.109:3000/api/listenDeviceStatusChange";
        Map<String, String> map = new HashMap<>();
        map.put("clientId", clientId);
        map.put("address", fullName);
        map.put("status", String.valueOf(eqeStatus));
        if (StringUtils.isEmpty(couponStatus)) {
            map.put("wxStatus", "1");
        } else {
            map.put("wxStatus", couponStatus);
        }
        String data = JSON.toJSONString(map);
        try {
            String s = HttpClientSslUtils.doPost(url, data);
            System.out.println("发送鲸准：" + s);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * @param clientId
     * @return
     */
    @GetMapping(value = "/getYouHuiPrice.htm")
    @ResponseBody
    public String getYouHuiPrice(String clientId) {
        LambdaQueryWrapper<TPrice> query = Wrappers.lambdaQuery();
        query.eq(TPrice::getName, "优惠券");
        List<TPrice> list = priceService.list(query);
        if (list.size() > 0) {
            TPrice tPrice = list.get(0);
            Double price = tPrice.getPrice();
            return new BigDecimal(price).setScale(0, RoundingMode.HALF_DOWN).toString();
        } else {
            return "5";
        }
    }

    /**
     * 修改商品名称
     *
     * @param clientId 设备个推Id
     * @param
     * @return
     * @Param
     */
    @RequestMapping(value = "/updateProductName.htm", method = RequestMethod.POST)
    @ResponseBody
    public String updateProductName(String clientId, Long productId, String oldProductName, String newProductName) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        List<TEquipment> list = equipmentService.list(query);
        if (list.size() > 0) {
            TEquipment equipment = list.get(0);
            if (equipment != null && equipment.getId() != null) {
                TProduct product = productService.getById(productId);
                product.setModifyDate(new Date());
                product.setName(oldProductName);
                product.setProductName(newProductName);
                productService.updateById(product);
                return "修改成功success！";
            }
        }

        return "更新失败error";
    }

    /**
     * 上传机器状态之门的状态：
     * type（类型，0：外门，1：内门）,
     * status（状态：0：关闭，1：开启）
     *
     * @param clientId
     * @return status（状态：0：关闭，1：开启）
     */
    @GetMapping("/updateEquipmentStatus")
    public ResponseModel<?> updateEquipmentStatus(String clientId, String type, String status) {
        if (StringUtils.isEmpty(clientId) || StringUtils.isEmpty(type) || StringUtils.isEmpty(status)) {
            return R.fail(ResponseCodesEnum.A0001, "adminId为空");
        }
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOnly(query);
        if (equipment != null && equipment.getId() != null) {
            if (type.equals("0")) {
                TEquipmentDesc equipmentDesc = equipmentDescService.getById(equipment.getId());
                equipmentDesc.setOutDoor(status);
                equipmentDescService.updateById(equipmentDesc);
                return R.ok();
            } else if (type.equals("1")) {
                TEquipmentDesc equipmentDesc = equipmentDescService.getById(equipment.getId());
                equipmentDesc.setInDoor(status);
                equipmentDescService.updateById(equipmentDesc);
                return R.ok();
            }
        }

        return R.fail(ResponseCodesEnum.A0002);
    }

    /**
     * 上传花型显示状态
     *
     * @param clientId     设备编号
     * @param tProductBean 包含花型编号和状态
     * @return
     */
    @RequestMapping(value = "/updateShowGoods", method = RequestMethod.POST)
    @ResponseBody
    public String updateShowGoods(String clientId, @RequestBody List<TProductBean> tProductBean) {
        if (StringUtils.isEmpty(clientId) || tProductBean == null) {
            return "参数为空";
        }
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOnly(query);
        if (equipment == null) {
            return "找不到设备信息";
        }
        Long equipmentId = equipment.getId();
        ArrayList<TProduct> tProducts = new ArrayList<>();
        for (TProductBean productBean : tProductBean) {
            String no = productBean.getNo();
            String showType = productBean.getShowType();
            LambdaQueryWrapper<TProduct> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(TProduct::getEquipmentId, equipmentId);
            wrapper.eq(TProduct::getNo, no);
            TProduct product = productService.getOnly(wrapper);
            product.setShowType(showType);
            tProducts.add(product);
        }
        boolean res = productService.updateBatchById(tProducts);
        if (!res) {
            return "error";
        }
        return "success";
    }

    /**
     * 上传DIY花型功能开关状态
     *
     * @param clientId：设备编号
     * @param DIYFlowerStatus:开关状态, 0: 关闭, 1: 开启
     * @return
     */
    @GetMapping(value = "/updateDIYFlowerStatus")
    @ResponseBody
    public String updateDIYFlowerStatus(String clientId, String DIYFlowerStatus) {
        if (StringUtils.isNotEmpty(clientId) && StringUtils.isNotEmpty(DIYFlowerStatus)) {
            LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
            query.eq(TEquipment::getClientId, clientId);
            TEquipment equipment = equipmentService.getOne(query);
            TEquipmentDesc equipmentDesc = equipmentDescService.getById(equipment.getId());
            equipmentDesc.setDiyFlowerStatus(DIYFlowerStatus);
            equipmentDescService.updateById(equipmentDesc);
            // 如果为开启状态
            if (DIYFlowerStatus.equals("1")) {
                LambdaQueryWrapper<TDiyFlower> queryWrapper = Wrappers.lambdaQuery();
                queryWrapper.eq(TDiyFlower::getEquipmentId, equipment.getId());
                List<TDiyFlower> list = diyFlowerService.list(queryWrapper);
                // 如何为空就添加新的花型形状和颜色
                if (list.size() == 0) {
                    saveDIYProduct(equipment.getId());
                }
            }
            return "success";
        }
        return "error";
    }

    /**
     * 添加DIY花型产品
     *
     * @param id
     */
    private void saveDIYProduct(Long id) {
        String[] str = {"圆五花-S01", "圆心-S02", "心-S03", "圆蝴蝶-S04", "圆四叶草-S05", "圆六花瓣-S06", "圆三叶草-A07", "圆三花瓣-S08", "蘑菇-S09",
                "白糖-T01", "红糖-T02", "黄糖-T03", "蓝糖-T04"};

        for (int i = 0; i < str.length; i++) {
            TDiyFlower diyFlower = new TDiyFlower();
            diyFlower.setCreateDate(new Date());
            diyFlower.setModifyDate(new Date());
            diyFlower.setEquipmentId(id);
            String[] split = str[i].split("-");
            diyFlower.setName(split[0]);
            diyFlower.setNo(split[1]);
            diyFlower.setShowType("1");
            diyFlowerService.save(diyFlower);
        }

    }

    /**
     * 上传DIY花型形状/糖显示状态
     *
     * @param clientId     设备编号
     * @param tProductBean 包含形状/糖的编号和状态
     * @return
     */
    @RequestMapping(value = "/updateDIYFlowerShow", method = RequestMethod.POST)
    @ResponseBody
    public String updateDIYFlowerShow(String clientId, @RequestBody List<TProductBean> tProductBean) {
        if (StringUtils.isEmpty(clientId) || tProductBean == null) {
            return "参数为空";
        }
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOnly(query);
        if (equipment == null) {
            return "找不到设备信息";
        }
        Long equipmentId = equipment.getId();
        ArrayList<TDiyFlower> diyFlowers = new ArrayList<>();
        for (TProductBean productBean : tProductBean) {
            String no = productBean.getNo();
            String showType = productBean.getShowType();
            LambdaQueryWrapper<TDiyFlower> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(TDiyFlower::getEquipmentId, equipmentId);
            wrapper.eq(TDiyFlower::getNo, no);
            TDiyFlower diyFlower = diyFlowerService.getOne(wrapper);
            diyFlower.setShowType(showType);
            diyFlowers.add(diyFlower);
        }
        boolean res = diyFlowerService.updateBatchById(diyFlowers);
        if (!res) {
            return "error";
        }
        return "success";
    }

    /**
     * 花型数目 开机时上传
     *
     * @param clientId 个推
     * @return
     */
    @RequestMapping(value = "/flowerNumber", method = RequestMethod.GET, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String flowerNumber(String clientId, String flowerNumber) {
        if (!StringUtils.isEmpty(flowerNumber)) {
            LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
            query.eq(TEquipment::getClientId, clientId);
            TEquipment equipment = equipmentService.getOne(query);
            equipment.setFlowers(flowerNumber);
            equipmentService.updateById(equipment);
            return "success";
        }
        return "fail";
    }


    /**
     * 设备语言 开机时上传
     *
     * @param clientId 个推
     * @return
     */
    @RequestMapping(value = "/upLoadLanguage", method = RequestMethod.GET, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String upLoadLanguage(String clientId, String language) {
        if (!StringUtils.isEmpty(language)) {
            LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
            query.eq(TEquipment::getClientId, clientId);
            TEquipment equipment = equipmentService.getOne(query);
            if (equipment == null) {
                return "fail";
            }
            TEquipmentDesc equipmentDesc = equipmentDescService.getById(equipment.getId());
            equipmentDesc.setLanguage(language);
            equipmentDescService.updateById(equipmentDesc);
            LambdaQueryWrapper<TProduct> wrapper = Wrappers.lambdaQuery();
            wrapper.eq(TProduct::getEquipmentId, equipment.getId());
            List<TProduct> products = productService.list(wrapper);
            for (TProduct product : products) {
                String no = product.getNo();
                // 如果没改过名才更改
                if (StringUtils.isEmpty(product.getName())) {
                    LambdaQueryWrapper<TNameDictionary> lambdaQueryWrapper = Wrappers.lambdaQuery();
                    lambdaQueryWrapper.eq(TNameDictionary::getLanguage, language);
                    lambdaQueryWrapper.eq(TNameDictionary::getNo, no);
                    TNameDictionary nameDictionary = nameDictionaryService.getOne(lambdaQueryWrapper);
                    if (nameDictionary != null) {
                        product.setModifyDate(new Date());
                        product.setProductName(nameDictionary.getName());
                        productService.updateById(product);
                    }
                }
            }
//            if (equipmentDesc.getLanguage() == null || !(equipmentDesc.getLanguage().equals(language))) {
//            }
            return "success";
        }
        return "fail";
    }

    /**
     * 获取DIY使用密码
     *
     * @return
     */
    @RequestMapping(value = "/getDIYPassword", method = RequestMethod.GET, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String getDIYPassword() {
        TAdmin admin = adminService.getById(1L);
        String diyPassword = admin.getDiyPassword();
        return diyPassword;
    }

    @ApiOperation(value = "更新雪糕机工作模式")
    @RequestMapping(value = "/upWorkingMode", method = RequestMethod.GET, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String upWorkingMode(String clientId, Integer workingMode) {
        if (workingMode != null) {
            LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
            query.eq(TEquipment::getClientId, clientId);
            TEquipment equipment = equipmentService.getOne(query);
            TEquipmentDesc equipmentDesc = equipmentDescService.getById(equipment.getId());
            equipmentDesc.setWorkingMode(workingMode);
            equipmentDescService.updateById(equipmentDesc);
            return "success";
        }
        return "fail";
    }

    @ApiOperation(value = "修改清洗功能状态")
    @GetMapping(value = "/updateCleanFunction", produces = "text/html;charset=utf-8")
    public String updateCleanFunction(String clientId, Boolean cleanFunction) {
        if (cleanFunction != null) {
            LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
            query.eq(TEquipment::getClientId, clientId);
            TEquipment equipment = equipmentService.getOne(query);
            TEquipmentDesc equipmentDesc = equipmentDescService.getById(equipment.getId());
            equipmentDesc.setCleanFunction(false);
            equipmentDescService.updateById(equipmentDesc);
            return "success";
        }
        return "fail";
    }

    /**
     * 商品调价
     */
    @RequestMapping(value = "/newUpdateProduct", method = RequestMethod.POST, produces = "text/html;charset=utf-8")
    @ResponseBody
    public String newUpdateProduct(@RequestBody List<ProductVo> productVos) {
        for (ProductVo product : productVos) {
            String clientId = product.getClientId();
            LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
            query.eq(TEquipment::getClientId, clientId);
            TEquipment equipment = equipmentService.getOne(query);
            Long id = equipment.getId();
            LambdaQueryWrapper<TProduct> queryProduct = Wrappers.lambdaQuery();
            queryProduct.eq(TProduct::getEquipmentId, id);
            queryProduct.eq(TProduct::getNo, product.getProductNo());
            TProduct tProduct = productService.getOnly(queryProduct);
            if (tProduct == null) {
                return "找不到商品";
            }
            tProduct.setRmbPrice(BigDecimal.valueOf(product.getRmbPrice()));
            tProduct.setCodePrice(BigDecimal.valueOf(product.getCodePrice()));
            tProduct.setShowType(product.getShowType());
            tProduct.setSellStatus(product.getSellStatus());
            productService.updateById(tProduct);
        }
        return "调价成功";
    }

    /**
     * 新修改商品名称
     *
     */
    @RequestMapping(value = "/changeProductName", method = RequestMethod.POST)
    @ResponseBody
    public String changeProductName(@RequestBody MachineDTO machineDTO) {
        String clientId = machineDTO.getClientId();
        String no = machineDTO.getProductNo();
        String name = machineDTO.getProductName();
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, machineDTO.getClientId());
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment != null && equipment.getId() != null) {
            LambdaQueryWrapper<TProduct> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.eq(TProduct::getEquipmentId, equipment.getId());
            queryWrapper.eq(TProduct::getNo, no);
            TProduct product = productService.getOne(queryWrapper);
            product.setModifyDate(new Date());
            product.setName(product.getProductName());
            product.setProductName(name);
            productService.updateById(product);
            return "success";
        }
        return "error";
    }

    @ApiOperation("上传远程退币状态")
    @PostMapping("/uploadReturnCoinStatus")
    public String uploadReturnCoinStatus(@RequestBody ReturnCoinVo returnCoinVo) {
        Long id = returnCoinVo.getId();
        ReturnCoinRecord returnCoinRecord = returnCoinRecordService.getById(id);
        returnCoinRecord.setStatus(returnCoinVo.getStatus());
        returnCoinRecord.setReason(returnCoinVo.getReason());
        returnCoinRecordService.updateById(returnCoinRecord);
        return "success";
    }

    @ApiOperation("上传支付方式状态")
    @GetMapping(value = "/updatePaymentTypeStatus")
    public String updatePaymentTypeStatus(String clientId, String paymentType) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId, clientId);
        TEquipment equipment = equipmentService.getOne(query);
        if (equipment != null && equipment.getId() != null) {
            equipment.setPaymentType(paymentType);
            equipmentService.updateById(equipment);
            return "success";
        }
        return "error";
    }
}