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

package com.szwl.controller;


import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.szwl.model.bean.CommonParamVo;
import com.szwl.model.bean.EquipmentDTO;
import com.szwl.model.bean.EquipmentVo;
import com.szwl.model.bean.ProductVo;
import com.szwl.model.bo.JsonMessage;
import com.szwl.model.bo.JsonUtils;
import com.szwl.model.entity.*;
import com.szwl.model.utils.AdminUtils;
import com.szwl.model.utils.PushUtils;
import com.szwl.service.*;
import com.szwl.service.es.EsTEquipmentService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.kafka.KafkaProperties;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.math.BigDecimal;
import java.util.*;


@Api(value = "/api/app_equipment/index", tags = {"设备信息上传接口"})
@RestController
@RequestMapping("/api/app_equipment/index")
public class IndexController { ;
    @Autowired
    TAdminService adminService;
    @Autowired
    TEquipmentService equipmentService;
    @Autowired
    TEquipmentApplyService equipmentApplyService;
    @Autowired
    TProductService productService;
    @Autowired
    TEquipmentDescService equipmentDescService;
    @Autowired
    EsTEquipmentService esTEquipmentService;
    @Autowired
    TParametersService parametersService;
    @ApiOperation(value = "心跳")
    @PostMapping("/heart.htm")
    public JsonMessage heart(@RequestBody EquipmentVo equipmentVo) {

        String clientId = equipmentVo.getClientId();
        Date lastUpdateTime = equipmentVo.getLastUpdateTime();
        Double longitude = equipmentVo.getLongitude();
        Double latitude = equipmentVo.getLatitude();
        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 is_sleep = equipmentVo.getIs_sleep();
        String netWorkingMode = equipmentVo.getNetWorkingMode();
        //有记录，则进行修改
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId,clientId);
        List<TEquipment> list = equipmentService.list(query);
        TEquipment _new = list.get(0);
//        Equipment _new = equipmentService.findByClientId(clientId);
        if (_new != null) {
            _new.setNetWorkingMode(netWorkingMode);
            if(StringUtils.isNotEmpty(cabinetTm)){
                _new.setCabinetTm(cabinetTm);
            }
            if(StringUtils.isNotEmpty(cabinetHd)){
                _new.setCabinetHd(cabinetHd);
            }
            if(StringUtils.isNotEmpty(furnaceSp)){
                _new.setFurnaceSp(furnaceSp);
            }
            if(StringUtils.isNotEmpty(furnaceTm)){
                _new.setFurnaceTm(furnaceTm);
            }
            _new.setLastUpdateTime(lastUpdateTime);
//            _new.setLongitude(longitude);
            if(eqeStatus!=null){
                _new.setEqeStatus(eqeStatus);
            }
            if(is_sleep!=null){
                _new.setIsSleep(is_sleep);
            }
            if(!StringUtils.isEmpty(furnaceTm)){
                int fur = Integer.parseInt(furnaceTm);
                if(_new.getEqeStatus()==0&&fur>150){
                    _new.setEqeStatus(1);
                }
                if(_new.getEqeStatus()==null&&fur>150){
                    _new.setEqeStatus(1);
                }
            }
            if(!StringUtils.isEmpty(volume)){
                _new.setVolume(volume);
            }
//            _new.setLatitude(latitude);
            _new.setGtClientId(gtClientId);
            _new.setModifyDate(new Date());
            equipmentService.updateById(_new);
            return JsonMessage.success("心跳成功");
        }
        return JsonMessage.error("心跳失败");
    }
    /**
     * 设备申请
     *
     * @param clientId  个推
     * @param managerId 管理系统id
     * @return
     */
    @ApiOperation(value = "设备申请")
//    @PostMapping("/init3")
    @PostMapping("/initNew.htm")
//    public JsonMessage initNew(String clientId, String managerId, String gtClientId,String equimentType,String machineType) {
    public JsonMessage initNew(String clientId, String managerId, String gtClientId,String equimentType) {
        String machineType = "0";
        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);
            String managerId1 = equipment.getManagerId();
            if(!managerId.equals(managerId1)){
                return JsonMessage.error("该设备未脱离");
            }else {
                return JsonMessage.error("该设备已经初始化");
            }
        }

        if (StringUtils.isEmpty(gtClientId)) {
            return JsonMessage.error("设备不能为空");
        }

        TEquipmentApply equipmentApply = new TEquipmentApply();
        equipmentApply.setStatusType(1);
        equipmentApply.setClientId(clientId);
        equipmentApply.setManagerId(managerId);
        equipmentApply.setGtClientId(gtClientId);
        Long adminId = AdminUtils.decrypt(false, managerId);

        TAdmin admin = adminService.getById(adminId);
        if (admin == null) {
            return JsonMessage.error("找不到商家");
        }
        //所属商家
        String username = admin.getUsername();
        equipmentApply.setAdminId(adminId);
        equipmentApply.setAdminUserName(username);
        equipmentApply.setEquimentType(equimentType);
        equipmentApply.setMachineType(machineType);
        equipmentApply.setCreateDate(new Date());
        equipmentApply.setModifyDate(new Date());
        equipmentApplyService.save(equipmentApply);
        if(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 JsonMessage.success("设备申请成功");
        }
        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 JsonMessage.success("设备申请成功");
        }
        return JsonMessage.success("设备申请中，请耐心等待");

    }

    private void agree(Long id) {
        String status = "agreed";
        if (null != id) {
            TEquipmentApply equipmentApply = equipmentApplyService.getById(id);
            if (equipmentApply != null) {
                if (!StringUtils.isEmpty(status)) {
                    if (status.equals("agreed")) {
                        String clientId = equipmentApply.getClientId();
                        //判断是否设备初始化
//                        if (equipmentService.findByClientId(clientId) != null) {
//                            addFlashMessage(redirectAttributes, Message.error("该设备已经初始化"));
//                            return "redirect:listInit.htm";
//                        }
                        Long adminId = equipmentApply.getAdminId();
                        String adminLevel = equipmentApply.getAdminLevel();
                        String adminUserName = equipmentApply.getAdminUserName();
                        String gtClientId = equipmentApply.getGtClientId();
                        String equimentType = equipmentApply.getEquimentType();
                        String machineType = equipmentApply.getMachineType();

                        String old = "";
//                        ArrayList<Filter> filters = new ArrayList<>();
//                        filters.add(Filter.eq("clientId", clientId + "xxx"));
//                        List<TEquipment> list = equipmentService.findList(null, filters, null);
                        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
                        query.like(TEquipment::getClientId,clientId+"xxx");
                        List<TEquipment> list = equipmentService.list(query);
                        equipmentApply.setStatusType(3);
                        if (list.size() > 0) {
                            //表示设备第二次申请了:主要为了区分脱离以及初始化
                            old = "1";
                            //重新修改设备名称
                            TEquipment equipment = list.get(0);
                            equipment.setClientId(clientId);
                            equipment.setGtClientId(gtClientId);
                            equipment.setAdminId(adminId);
                            equipment.setAdminLevel(adminLevel);
                            equipment.setAdminUserName(adminUserName);
                            equipment.setMachineType(machineType);
                            if(equipmentApply.getEquimentType().equals("MG320-1")){
                                if(!equipmentApply.getEquimentType().equals(equipment.getEquimentType())&&equipment.getEquimentType().equals("MG320")){
//                                    List<Filter> filter = new ArrayList<>();
//                                    filter.add(Filter.eq("equipmentId",  equipment.getId()));
//                                    List<Product> productList = productService.findList(null, filter, null);
                                    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());
                                    }
                                    //从18种变成30种花型
//                                    saveProductMG12(equipment.getId());
                                }
                                equipment.setEquimentType("MG320");
                            }
                            equipmentService.updateById(equipment);
//                            String data = com.alibaba.fastjson.JSON.toJSONString(equipment);
                            try {
//                                String result = HttpClientUtils.sentData(HttpClientUtils.Update_Equipment_Url, data);
//                                if(!result.equals("200")){
//                                    result = HttpClientUtils.sentData(HttpClientUtils.Update_Equipment_Url, data);
//                                    if(!result.equals("200")){
//                                        result = HttpClientUtils.sentData(HttpClientUtils.Update_Equipment_Url, data);
//                                        if(!result.equals("200")){
//                                        }
//                                    }
//                                }
                                esTEquipmentService.updateDataById(equipment);
                            }catch (Exception e) {
                                e.printStackTrace();
                            }
//                            addFlashMessage(redirectAttributes, SUCCESS_MESSAGE);
                            equipmentService.sentMessage(clientId,PushUtils.buildJson("statusType", "agreed" + old).toString());
                            PushUtils.push(equipmentApply.getGtClientId(), "【棉花糖】设备初始化申请", "同意", PushUtils.buildJson("statusType", "agreed" + old).toString());
//                            equipmentApplyService.update(equipmentApply);
                            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());
                            }
//                            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());
//                            return "redirect:listInit.htm";
                            return;
                        }else{

                            TEquipment equipment = new TEquipment();
                            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.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 = new Date().getTime();
                                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);
                            equipmentService.sentMessage(clientId,PushUtils.buildJson("statusType", "agreed" + old).toString());
                            PushUtils.push(equipmentApply.getGtClientId(), "【棉花糖】设备初始化申请", "同意", PushUtils.buildJson("statusType", "agreed" + old).toString());
//                            Equipment byClientId = equipmentService.findByClientId(equipment.getClientId());
//                            String data = com.alibaba.fastjson.JSON.toJSONString(byClientId);
                            LambdaQueryWrapper<TEquipment> query1 = Wrappers.lambdaQuery();
                            query1.eq(TEquipment::getClientId,clientId);
                            List<TEquipment> list1 = equipmentService.list(query1);
                            try {
                                if(list1.size()>0){
                                    TEquipment tEquipment = list1.get(0);
                                    esTEquipmentService.insertData(tEquipment);
                                }
//                                String result = HttpClientUtils.sentData(HttpClientUtils.Equipment_Url, data);
//                                if(!result.equals("200")){
//                                    byClientId = equipmentService.findByClientId(equipment.getClientId());
//                                    result = HttpClientUtils.sentData(HttpClientUtils.Equipment_Url, data);
//                                    if(!result.equals("200")){
//                                        byClientId = equipmentService.findByClientId(equipment.getClientId());
//                                        result = HttpClientUtils.sentData(HttpClientUtils.Equipment_Url, data);
//                                        if(!result.equals("200")){
//                                        }
//                                    }
//                                }
                            }catch (Exception e) {
                                e.printStackTrace();
                            }
                            TEquipmentDesc equipmentDesc = new TEquipmentDesc();
                            equipmentDesc.setEquipmentId(list1.get(0).getId());
                            equipmentDescService.save(equipmentDesc);
                        }
                        //获取设备的id
//                        Long equipmentId = equipmentService.findByClientId(clientId).getId();
                        LambdaQueryWrapper<TEquipment> query1 = Wrappers.lambdaQuery();
                        query1.eq(TEquipment::getClientId,clientId);
                        List<TEquipment> list1 = equipmentService.list(query1);
                        Long equipmentId = list1.get(0).getId();
//                        if (!productService.exists(Filter.eq("equipmentId", equipmentId))) {
                        if (true) {
                            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 (status.equals("rejected")) {
                        equipmentApply.setStatusType(3);
                        equipmentService.sentMessage(equipmentApply.getClientId(),PushUtils.buildJson("statusType", "rejected").toString());
//                        PushUtils.push(equipmentApply.getGtClientId(), "【棉花糖】设备初始化申请", "拒绝", PushUtils.buildJson("statusType", "rejected").toString());
                    }
                    equipmentApplyService.updateById(equipmentApply);

//                    addFlashMessage(redirectAttributes, SUCCESS_MESSAGE);

                }
            }
        }
    }
    /**
     * 添加产品
     *
     * @param id
     */
    private void saveProduct(Long id) {
        String[] str = {"玫瑰精灵", "童心未泯", "五彩缤纷", "天雪恋舞", "水中芙蓉", "烈焰红唇", "美梦成真", "一见钟情", "幽兰爱恋", "心之守护",
                "夏日爱恋", "冰美人", "国色天香", "赤子之心", "海洋之心", "水晶之恋", "彩色精灵", "小棉袄"};

        for (int i = 0; i < str.length; i++) {
            TProduct product = new TProduct();
            product.setCreateDate(new Date());
            product.setModifyDate(new Date());
            product.setEquipmentId(id);
            product.setProductName(str[i]);
            product.setRmbPrice(BigDecimal.ZERO);
            product.setCodePrice(BigDecimal.ZERO);
            productService.save(product);
        }

    }
    private void saveProductMG280(Long id) {
        String[] str = { "水中芙蓉", "水中芙蓉mini", "烈焰红唇", "烈焰红唇mini", "夏日爱恋", "夏日爱恋mini", "冰美人", "冰美人mini", "彩色精灵", "彩色精灵mini"};

        for (int i = 0; i < str.length; i++) {
            TProduct product = new TProduct();
            product.setCreateDate(new Date());
            product.setModifyDate(new Date());
            product.setEquipmentId(id);
            product.setProductName(str[i]);
            product.setRmbPrice(BigDecimal.ZERO);
            product.setCodePrice(BigDecimal.ZERO);
            productService.save(product);
        }

    }
    private void saveProductMG1(Long id) {
        String[] str = {"玫瑰精灵", "童心未泯", "五彩缤纷", "天雪恋舞", "水中芙蓉", "烈焰红唇", "美梦成真", "一见钟情", "幽兰爱恋", "心之守护",
                "夏日爱恋", "冰美人", "国色天香", "赤子之心", "海洋之心", "水晶之恋", "彩色精灵", "小棉袄", "精灵蝶梦","夏日倾城","百花齐放","蜂缠蝶恋","豆蔻年华","星空幻想"
                ,"坠入星空","雪花飞舞","春暖花开","花飞蝶舞","花样年华","心花怒放"};

        for (int i = 0; i < str.length; i++) {
            TProduct product = new TProduct();
            product.setCreateDate(new Date());
            product.setModifyDate(new Date());
            product.setEquipmentId(id);
            product.setProductName(str[i]);
            product.setRmbPrice(BigDecimal.ZERO);
            product.setCodePrice(BigDecimal.ZERO);
            productService.save(product);
        }

    }
    private void saveProductMG12(Long id) {
        String[] str = { "精灵蝶梦","夏日倾城","百花齐放","蜂缠蝶恋","豆蔻年华","星空幻想"
                ,"坠入星空","雪花飞舞","春暖花开","花飞蝶舞","花样年华","心花怒放"};
        for (int i = 0; i < str.length; i++) {
            TProduct product = new TProduct();
            product.setCreateDate(new Date());
            product.setModifyDate(new Date());
            product.setEquipmentId(id);
            product.setProductName(str[i]);
            product.setRmbPrice(BigDecimal.ZERO);
            product.setCodePrice(BigDecimal.ZERO);
            productService.save(product);
        }
    }
    private void saveProductMG22(Long id) {
        String[] str = {"玫瑰精灵", "童心未泯", "五彩缤纷", "天雪恋舞", "水中芙蓉", "烈焰红唇", "美梦成真", "一见钟情", "幽兰爱恋", "心之守护",
                "夏日爱恋", "冰美人", "国色天香", "赤子之心", "海洋之心", "水晶之恋", "彩色精灵", "小棉袄", "精灵蝶梦","蜂缠蝶恋","坠入星空","花飞蝶舞"};

        for (int i = 0; i < str.length; i++) {
            TProduct product = new TProduct();
            product.setCreateDate(new Date());
            product.setModifyDate(new Date());
            product.setEquipmentId(id);
            product.setProductName(str[i]);
            product.setRmbPrice(BigDecimal.ZERO);
            product.setCodePrice(BigDecimal.ZERO);
            productService.save(product);
        }

    }
    private void saveProductMG26(Long id) {
        String[] str = {"玫瑰精灵", "童心未泯", "五彩缤纷", "天雪恋舞", "水中芙蓉", "烈焰红唇", "美梦成真", "一见钟情", "幽兰爱恋", "心之守护",
                "夏日爱恋", "冰美人", "国色天香", "赤子之心", "海洋之心", "水晶之恋", "彩色精灵", "小棉袄", "精灵蝶梦","蜂缠蝶恋","坠入星空","花飞蝶舞",
                "夏日倾城", "雪花飞舞", "豆蔻年华", "花样年华"};
        for (int i = 0; i < str.length; i++) {
            TProduct product = new TProduct();
            product.setCreateDate(new Date());
            product.setModifyDate(new Date());
            product.setEquipmentId(id);
            product.setProductName(str[i]);
            product.setRmbPrice(BigDecimal.ZERO);
            product.setCodePrice(BigDecimal.ZERO);
            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)
    @ResponseBody
    public JsonMessage updateFlowers(String clientId,String number){
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId,clientId);
        List<TEquipment> list = equipmentService.list(query);
        TEquipment equipment = list.get(0);
        if(equipment!=null){
            Long id = equipment.getId();
            //修改花型记录数目
            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);
            }
            //删除旧花型
//            List<Filter> filters = new ArrayList<>();
//            filters.add(Filter.eq("equipmentId", id));
//            List<Product> list = productService.findList(null, filters, null);
            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());
            }
            //创建花型
            if(number.equals("18")){
                saveProduct(id);
            }
            if(number.equals("22")){
                saveProductMG22(id);
            }
            if(number.equals("26")){
                saveProductMG26(id);
            }
            if(number.equals("30")){
                saveProductMG1(id);
            }
            return JsonMessage.success("success");
        }else {
            return JsonMessage.success("error");
        }
    }
    /**
     * 设备类型  开机时上传
     *
     * @param clientId  个推

     * @return
     */
    @RequestMapping(value = "/equimentType.htm", method = RequestMethod.POST)
    @ResponseBody
    public JsonMessage equimentType(String clientId, String equimentType){
        if(!StringUtils.isEmpty(equimentType)){
            LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
            query.eq(TEquipment::getClientId,clientId);
            List<TEquipment> list = equipmentService.list(query);
            TEquipment equipment = list.get(0);
            equipment.setEquimentType(equimentType);
            equipmentService.updateById(equipment);
        }

        return JsonMessage.success("success");
    }
    /**
     * 设备地址  开机时上传
     * @param clientId  个推
     * @return
     */
    @RequestMapping(value = "/equimentArea", method = RequestMethod.GET)
    @ResponseBody
    public JsonMessage 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);
            List<TEquipment> list = equipmentService.list(query);
            TEquipment equipment = list.get(0);
            equipment.setLatitude(Double.valueOf(latitude));
            equipment.setLongitude(Double.valueOf(longitude));
            equipment.setFullName(fullName+"-");
            equipmentService.updateById(equipment);
            return JsonMessage.success("success");
        }
        return JsonMessage.success("error");
    }
    /**
     * 商品调价
     */
    @RequestMapping(value = "/updateProduct", method = RequestMethod.POST)
    @ResponseBody
    public JsonMessage updateProduct(@RequestBody List<ProductVo> productVos) {
        Double f=0.00;
        int num=0;
        int n=0;
        HashSet<Double> price = new HashSet<Double>();
        HashSet<Double> minprice = new HashSet<Double>();
        for (ProductVo product : productVos) {
            String clientId = product.getClientId();
            LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
            query.eq(TEquipment::getClientId,clientId);
            List<TEquipment> list = equipmentService.list(query);
            TEquipment equipment = list.get(0);
            Long id = equipment.getId();
            if(StringUtils.isNotEmpty(product.getShowType())){
//                productService.updateByClientID2(id, product.getRmbPrice(), product.getCodePrice(), product.getProductName(), product.getSellStatus(),product.getShowType());
                LambdaQueryWrapper<TProduct> queryProduct = Wrappers.lambdaQuery();
                queryProduct.eq(TProduct::getEquipmentId,equipment.getId());
                queryProduct.eq(TProduct::getProductName,product.getProductName());
                List<TProduct> productList = productService.list(queryProduct);
                TProduct tProduct = productList.get(0);
                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,equipment.getId());
                queryProduct.eq(TProduct::getProductName,product.getProductName());
                List<TProduct> productList = productService.list(queryProduct);
                TProduct tProduct = productList.get(0);
                tProduct.setRmbPrice(BigDecimal.valueOf(product.getRmbPrice()));
                tProduct.setCodePrice(BigDecimal.valueOf(product.getCodePrice()));
                tProduct.setSellStatus(product.getSellStatus());
                productService.updateById(tProduct);
//                productService.updateByClientID(id, product.getRmbPrice(), product.getCodePrice(), product.getProductName(), product.getSellStatus());
            }
        }

        return JsonMessage.success("调价成功");
    }
    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", method = RequestMethod.POST)
    @ResponseBody
    public JsonMessage updatePwd(String clientId, String pwdType, String pwd) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId,clientId);
        List<TEquipment> list = equipmentService.list(query);
        TEquipment equipment = list.get(0);
        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 JsonMessage.success("更新密码成功");
            }

        }
        return JsonMessage.error("更新密码失败");
    }

    /**
     * 修改支付方式
     *
     * @param clientId
     * @param payType: 无需支付
     *                 线上支付
     *                 线下支付
     *                 线上/线下
     * @return
     */
    @RequestMapping(value = "/updatePayType", method = RequestMethod.POST)
    @ResponseBody
    public JsonMessage updatePayType(String clientId, String payType) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId,clientId);
        List<TEquipment> list = equipmentService.list(query);
        TEquipment equipment = list.get(0);
        if (equipment == null) {
            return JsonMessage.error("修改支付方式失败");
        }
        equipment.setPayType(0);
        equipmentService.updateById(equipment);
        return JsonMessage.success("修改成功");
    }

    /**
     * 日志上传
     */
    @RequestMapping(value = "/sendLog", method = RequestMethod.POST)
    @ResponseBody
    public String uploadFile(HttpServletRequest request, HttpServletResponse response, String fileName) throws Exception{
//        String fileName = request.getParameter("fileName");
//        log.info("filename:"+fileName);
//        String fileName ="shafei.xls";
//        file1.length();
//        String name = request.getParameter("inputName");
        String fileFullPath = "/home/hboxs/log/" + fileName+".txt";
//        String fileFullPath = "/root/uploadfile/apache-tomcat-8.5.42/" + fileName;

        InputStream input = null;
        FileOutputStream fos = null;
        try {
            input = request.getInputStream();
            File file = new File("/home/hboxs/log/");
            if(!file.exists()){
                file.mkdirs();
            }
            fos = new FileOutputStream(fileFullPath);
            int size = 0;
            byte[] buffer = new byte[1024];
            while ((size = input.read(buffer,0,1024)) != -1) {
                fos.write(buffer, 0, size);
            }

            //响应信息 json字符串格式
            Map<String,Object> responseMap = new HashMap<String,Object>();
            responseMap.put("flag", true);

            //生成响应的json字符串
            String jsonResponse = JSONObject.toJSONString(responseMap);
            sendResponse(jsonResponse,response);
        } catch (IOException e) {
            //响应信息 json字符串格式
            Map<String,Object> responseMap = new HashMap<String,Object>();
            responseMap.put("flag", false);
            responseMap.put("errorMsg", e.getMessage());
            String jsonResponse = JSONObject.toJSONString(responseMap);
            sendResponse(jsonResponse,response);
        } finally{
            if(input != null){
                input.close();
            }
            if(fos != null){
                fos.close();
            }
        }

        return null;
    }

    /**
     * 返回响应
     *
     * @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)
    @ResponseBody
    public JsonMessage separate(String clientId) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId,clientId);
        List<TEquipment> list = equipmentService.list(query);
        TEquipment equipment = list.get(0);
        if (equipment == null) {
            return JsonMessage.error("该设备不存在");
        }
        equipmentService.sentMessage(clientId,PushUtils.buildJson("tuoji", "0").toString());
//        PushUtils.push(equipment.getGtClientId(), "", "", PushUtils.buildJson("tuoji", "0").toString());
        if("xxx".equals(equipment.getClientId().substring(equipment.getClientId().length()-3,equipment.getClientId().length()))){
            return JsonMessage.success("脱离成功");
        }
        equipment.setClientId(equipment.getClientId() + "xxx");
        equipmentService.updateById(equipment);
        return JsonMessage.success("脱离成功");
    }



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

    /**
     * 设备上传公司电话
     */
    @RequestMapping(value = "/sentCompanyPhone.htm", method = RequestMethod.POST)
    @ResponseBody
    public JsonMessage sentCompanyPhone(String clientId, String companyPhone) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId,clientId);
        List<TEquipment> list = equipmentService.list(query);
        TEquipment equipment = list.get(0);
        if (equipment == null) {
            return JsonMessage.error("该设备不存在");
        }
        equipment.setCompanyPhone(companyPhone);
        equipmentService.updateById(equipment);
        return JsonMessage.success("修改成功");
    }
    /**
     * 获取二维码图片
     */
    @RequestMapping(value = "/getQrCodeImgUrl.htm", method = RequestMethod.GET)
    @ResponseBody
    public String getQrCodeImgUrl(String clientId) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId,clientId);
        List<TEquipment> list = equipmentService.list(query);
        TEquipment equipment = list.get(0);
        if (equipment == null) {
            return "404";
        }
        //TODO
//        TAdmin admin = adminService.find(equipment.getAdminId());
//        String qrCodeImgUrl = admin.getQrCodeImgUrl();
//        if(!StringUtils.isEmpty(qrCodeImgUrl)){
//            return qrCodeImgUrl;
//        }else {
//            return "400";
//        }
        return "400";
    }
    /**
     * 上传4G卡号
     */
    @RequestMapping(value = "/sentSimNo.htm", method = RequestMethod.POST)
    @ResponseBody
    public JsonMessage sentSimNo(String clientId, String simNo) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId,clientId);
        List<TEquipment> list = equipmentService.list(query);
        TEquipment equipment = list.get(0);
        if (equipment == null) {
            return JsonMessage.error("该设备不存在");
        }
        equipment.setSimNo(simNo);
        equipmentService.updateById(equipment);
        return JsonMessage.success("修改成功");
    }

    /**
     * 修改设备状态
     *
     * @param clientId
     * @param eqeStatus 设备状态1开 0关
     * @return
     */
    @RequestMapping(value = "/updateEqeStatus.htm", method = RequestMethod.POST)
    @ResponseBody
    public JsonMessage updateEqeStatus(String clientId, Integer eqeStatus) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId,clientId);
        List<TEquipment> list = equipmentService.list(query);
        TEquipment equipment = list.get(0);
        if (equipment == null) {
            return JsonMessage.error("该设备不存在");
        }
        if(eqeStatus!=null){
            equipment.setEqeStatus(eqeStatus);
            equipment.setModifyDate(new Date());
            equipmentService.updateById(equipment);
        }
        return JsonMessage.success("修改成功");
    }
    /**
     * 新修改设备状态
     *
     * @param clientId
     * @param eqeStatus 设备状态1开 0关
     * @return
     */
    @RequestMapping(value = "/updateEqeStatusNew.htm", method = RequestMethod.POST)
    @ResponseBody
    public JsonMessage updateEqeStatusNew(String clientId, Integer eqeStatus,String netTime) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId,clientId);
        List<TEquipment> list = equipmentService.list(query);
        TEquipment equipment = list.get(0);
        if (equipment == null) {
            return JsonMessage.error("该设备不存在");
        }
        if(eqeStatus!=null){
            equipment.setNetwork(netTime);
            equipment.setEqeStatus(eqeStatus);
            equipmentService.updateById(equipment);
        }
        return JsonMessage.success("修改成功");
    }
    /**
     * 修改设备锁定状态
     *
     * @param clientId
     * @param block
     * @return
     */
    @RequestMapping(value = "/updateBlock.htm", method = RequestMethod.POST)
    @ResponseBody
    public JsonMessage updateBlock(String clientId, Boolean block) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId,clientId);
        List<TEquipment> list = equipmentService.list(query);
        TEquipment equipment = list.get(0);
        if (equipment == null) {
            return JsonMessage.error("该设备不存在");
        }
        equipment.setIsBlocked(block);
        equipmentService.updateById(equipment);
        return JsonMessage.success("修改成功");
    }

    /**
     * 修改设备睡眠状态
     *
     * @param clientId
     * @param is_sleep
     * @return
     */
    @RequestMapping(value = "/updateSleep.htm", method = RequestMethod.POST)
    @ResponseBody
    public JsonMessage updateSleep(String clientId, Boolean is_sleep) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId,clientId);
        List<TEquipment> list = equipmentService.list(query);
        TEquipment equipment = list.get(0);
        if (equipment == null) {
            return JsonMessage.error("该设备不存在");
        }
        if(is_sleep!=null){
            equipment.setIsSleep(is_sleep);
            equipmentService.updateById(equipment);
        }
        return JsonMessage.success("修改成功");
    }

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

    /**
     * 修改设备共同参数/进阶参数
     *
     * @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：调试页参数
     * @param
     * @return
     */
    @PostMapping(value = "/updateParamNew.htm/{code}/{clientId}", produces = "application/json;charset=UTF-8")
    @ResponseBody
    public JsonMessage updateParamNew(@PathVariable Integer code, @PathVariable String clientId, @RequestBody List<CommonParamVo> commonParamVos) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId,clientId);
        List<TEquipment> list = equipmentService.list(query);
        TEquipment equipment = list.get(0);
        if (equipment == null) {
            return JsonMessage.error("设备不存在");
        }
        if(commonParamVos.size()<=0){
            return JsonMessage.error("参数为空");
        }
//        ArrayList<Filter> filters = new ArrayList<>();
//        filters.add(Filter.eq("status", code));
//        filters.add(Filter.eq("clientId", clientId));
//        filters.add(Filter.eq("equipmentId", equipment.getId()));
//        List<Parameters> list = parametersService.findList(null, filters, null);
        LambdaQueryWrapper<TParameters> queryParameters = Wrappers.lambdaQuery();
        queryParameters.eq(TParameters::getClientId,clientId);
        queryParameters.eq(TParameters::getStatus,code);
        queryParameters.eq(TParameters::getEquipmentId,equipment.getId());
        List<TParameters> list1 = parametersService.list(queryParameters);
        if(list1.size()>0){
            for(TParameters parameters:list1){
                //删除旧的参数
                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 JsonMessage.success("修改成功");
    }

    /**
     * 修改单个设备共同参数/进阶参数
     *  code 0：通用参数；1：进阶参数；2：调试页参数
     * @param
     * @return
     */
    @PostMapping(value = "/updateAloneParam.htm", produces = "application/json;charset=UTF-8")
    @ResponseBody
    public JsonMessage updateAloneParam(String code, String clientId,String name,String val) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId,clientId);
        List<TEquipment> list = equipmentService.list(query);
        TEquipment equipment = list.get(0);
        if (equipment == null) {
            return JsonMessage.error("设备不存在");
        }
//        ArrayList<Filter> filters = new ArrayList<>();
//        filters.add(Filter.eq("status", code));
//        filters.add(Filter.eq("clientId", clientId));
//        filters.add(Filter.eq("equipmentId", equipment.getId()));
//        filters.add(Filter.eq("name", name));
//        List<Parameters> list = parametersService.findList(null, filters, null);
        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 JsonMessage.success("修改成功");
    }
    /**
     * 获取机器列表
     */
    @RequestMapping(value = "/getEquipmentList.htm", method = RequestMethod.GET, produces = "application/json;charset=UTF-8")
    @ResponseBody
    public Object getByAdminAndProduct(String adminId,String name) {
        JSONObject jsonObject = new JSONObject();
        if(StringUtils.isEmpty(adminId)){
            jsonObject.put("code", 1);
            jsonObject.put("errmsg", "adminId为空");
            return jsonObject;
        }
        if(StringUtils.isEmpty(name)){
            jsonObject.put("code", 1);
            jsonObject.put("errmsg", "name为空");
            return jsonObject;
        }
//        Admin admin = adminService.find(Long.valueOf(adminId));
        TAdmin admin = adminService.getById(adminId);
        if(!admin.getUsername().equals(name)){
            jsonObject.put("code", 1);
            jsonObject.put("errmsg", "name与adminId不匹配");
            return jsonObject;
        }
        List<EquipmentDTO> list = new ArrayList<>();
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getAdminId,Long.valueOf(adminId));
        List<TEquipment> equipmentList = equipmentService.list(query);
//        List<TEquipment> equipmentList = equipmentService.findByAdminId(Long.valueOf(adminId));
        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;
    }

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

        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId,clientId);
        List<TEquipment> list1 = equipmentService.list(query);
        TEquipment equipment = list1.get(0);
//        Equipment equipment = equipmentService.findByClientId(clientId);

        if(!equipment.getAdminId().toString().equals(admin.getId().toString())){
            jsonObject.put("code", 1);
            jsonObject.put("errmsg", "clientId与adminId不匹配");
            return jsonObject;
        }
//        ArrayList<Filter> filters = new ArrayList<>();
//        filters.add(Filter.eq("equipmentId", equipment.getId()));
//        List<Product> products = productService.findList(null, filters, null);
        List<String> list = new ArrayList<>();
        LambdaQueryWrapper<TProduct> queryProduct = Wrappers.lambdaQuery();
        queryProduct.eq(TProduct::getEquipmentId,equipment.getId());
        List<TProduct> products = productService.list(queryProduct);
//        TProduct tProduct = products.get(0);
        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;
    }
//    @ApiOperation(value = "分页查询")
//    @GetMapping("/testPage")
//    public ResponseModel<IPage<?>> testPage(TAdminParam param) {
//        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
//        query.eq(TAdmin::getIsEnabled,true);
//        if(StrUtil.isNotBlank(param.getName())){
//            query.like(TAdmin::getName,param.getName());
//        }
//        query.orderByDesc(TAdmin::getApplyStartTime);
//        Page<TAdmin> page = new Page<>(param.getCurrent(), param.getSize(), true);
//        IPage<TAdmin> iPage = tAdminService.page(page, query);
//        return R.ok(iPage);
//    }
//
//    @ApiOperation(value = "列表查询")
//    @GetMapping("/testList")
//    public ResponseModel<List<?>> testList(TAdminParam param) {
//        LambdaQueryWrapper<TAdmin> query = Wrappers.lambdaQuery();
//        query.eq(TAdmin::getIsEnabled,true);
//        if(StrUtil.isNotBlank(param.getName())){
//            query.like(TAdmin::getName,param.getName());
//        }
//        query.orderByDesc(TAdmin::getApplyStartTime);
//        List<TAdmin> list = tAdminService.list(query);
//        return R.ok(list);
//    }
//    @ApiOperation(value = "返回失败")
//    @GetMapping("/testError")
//    public ResponseModel<List<?>> testError(boolean success) {
//        if(success){
//            return R.ok();
//        }else{
//            return R.fail(ResponseCodesEnum.B0001,"你的错误信息");
//        }
//    }
}