huimv.farm.huatong/huimv-receive/src/main/java/com/huimv/receive/service/impl/BillPersonnelAdmissionServiceImpl.java

package com.huimv.receive.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.http.Header;
import cn.hutool.http.HttpRequest;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.huimv.receive.common.token.TokenSign;
import com.huimv.receive.common.utils.*;
import com.huimv.receive.entity.*;
import com.huimv.receive.entity.vo.*;
import com.huimv.receive.mapper.*;
import com.huimv.receive.service.IBillPersonnelAdmissionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.URL;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;

/**
 * <p>
 * 入场申请 服务实现类
 * </p>
 *
 * @author author
 * @since 2023-07-21
 */
@Service
public class BillPersonnelAdmissionServiceImpl extends ServiceImpl<BillPersonnelAdmissionMapper, BillPersonnelAdmission> implements IBillPersonnelAdmissionService {
    @Resource
    private BillPersonnelAdmissionMapper billPersonnelAdmissionMapper;
    @Resource
    private BaseProcessMapper baseProcessMapper;
    @Resource
    private BillPcrMapper billPcrMapper;
    @Resource
    private BaseLocationMapper baseLocationMapper;
    @Resource
    private BillIsolateMapper billIsolateMapper;
    @Resource
    private BillCleanMapper billCleanMapper;
    @Resource
    private SysAccountMultilevelMapper sysAccountMultilevelMapper;
    @Autowired
    private UploadImage uploadImage;
    @Autowired
    private BillDryMapper dryMapper;
    @Resource
    private BillGoodsInventoryMapper billGoodsInventoryMapper;
    @Resource
    private ExistMapper existMapper;
    @Autowired
    private BillGateMapper gateMapper;
    @Autowired
    private BillAccessDoorMapper doorMapper;
    @Autowired
    private DeviceListMapper deviceListMapper;
    @Autowired
    private PeopleListMapper peopleListMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result addAdmission(HttpServletRequest httpServletRequest, String admissionType, String vistitType, String userName, String phone, String workName, String papersType, String papersCode, MultipartFile imgUrl, String img, String vistitDate, String vistitReson, String destId, String destName, String farmId, String carNum, String source, String goods) throws IOException {
        Integer userId = TokenSign.getMemberIdByJwtToken(httpServletRequest);
        if (!PhoneNumberValidator.isValidPhoneNumber(phone)) {
            return new Result(10001, "手机号格式错误！", false);
        }
        if (papersType.equals("0")) {
            if (!IDCardValidator.isValidIDCard(papersCode)) {
                return new Result(10001, "身份证号格式错误!", false);
            }
        }
        SysAccountMultilevel sysAccountMultilevel1 = sysAccountMultilevelMapper.selectById(userId);

        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
        BillPersonnelAdmission billPersonnelAdmission = new BillPersonnelAdmission();
        billPersonnelAdmission.setAdmissionType(Integer.parseInt(admissionType));
        billPersonnelAdmission.setVistitType(Integer.parseInt(vistitType));
        billPersonnelAdmission.setDestId(Integer.parseInt(destId));
        billPersonnelAdmission.setDestName(destName);
        billPersonnelAdmission.setAdmissionUserId(userId);
        billPersonnelAdmission.setAdmissionUserName(userName);
        billPersonnelAdmission.setVistitDate(LocalDateTime.parse(vistitDate, dateTimeFormatter));
        billPersonnelAdmission.setSubDate(LocalDateTime.now());
        billPersonnelAdmission.setPhone(phone);
        billPersonnelAdmission.setWorkName(workName);
        billPersonnelAdmission.setPapersType(Integer.parseInt(papersType));
        billPersonnelAdmission.setPapersCode(papersCode);
        billPersonnelAdmission.setUserImgUrl(sysAccountMultilevel1.getImgUrl());
        if (ObjectUtil.isNotEmpty(carNum)) {
            billPersonnelAdmission.setCarNum(carNum);
        }
        if (ObjectUtil.isNotEmpty(imgUrl)) {
            if (uploadImage.getImageCom(imgUrl).equals("上传失败")) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return new Result(10001, "图片上传失败", false);
            }
            billPersonnelAdmission.setImgUrl(uploadImage.getImageCom(imgUrl));
        }
        if (ObjectUtil.isNotEmpty(img)) {
            billPersonnelAdmission.setImgUrl(img);
        }
        if (ObjectUtil.isNotEmpty(source)) {
            billPersonnelAdmission.setSource(source);
        }
        billPersonnelAdmission.setVistitReson(vistitReson);
        billPersonnelAdmission.setFarmId(Integer.parseInt(farmId));
        BaseProcess baseProcess = new BaseProcess();
        baseProcess.setDestName(destName);
        baseProcess.setDestId(Integer.parseInt(destId));
        baseProcess.setAdmissionUserId(userId);
        baseProcess.setAdmissionUserName(userName);
        baseProcess.setSubDate(DateTime.now());
        baseProcess.setUpdateDate(LocalDateTime.now().format(dateTimeFormatter));
        baseProcess.setCurrentStatus("0");

        QueryWrapper<BaseLocation> queryWrapper = new QueryWrapper<>();
        QueryWrapper<Exist> existQueryWrapper = new QueryWrapper<>();
        existQueryWrapper.eq("farm_id", farmId);
        Exist exist = existMapper.selectOne(existQueryWrapper);
        if (vistitType.equals("5") && exist.getExist() == 0) {
            if (destId.equals("9")) {
                baseProcess.setAllLocationStatus("1,0");
                baseProcess.setAllLocation("场外,初级洗消站");
                baseProcess.setAllLocationId("26,9");
            } else if (destId.equals("10")) {
                baseProcess.setAllLocationId("9,10");
                baseProcess.setAllLocation("初级洗消站,二级洗消站");
                baseProcess.setAllLocationStatus("1,0");
            } else if (destId.equals("11")) {
                baseProcess.setAllLocationId("10,11");
                baseProcess.setAllLocation("二级洗消站,三级洗消站");
                baseProcess.setAllLocationStatus("1,0");
            }
        } else if (vistitType.equals("5") && exist.getExist() == 1) {
            if (destId.equals("9")) {
                baseProcess.setAllLocationStatus("1,0");
                baseProcess.setAllLocation("场外,初级洗消站");
                baseProcess.setAllLocationId("26,9");
            }
        } else {
            queryWrapper.eq("vistit_type", vistitType).orderByAsc("location_type");
            List<BaseLocation> baseLocations = baseLocationMapper.selectList(queryWrapper);
            if (admissionType.equals("1")) {
                baseProcess.setAllLocation("场外," + destName);
                QueryWrapper<BaseLocation> queryWrapper1 = new QueryWrapper<>();
                queryWrapper1.eq("vistit_type", vistitType).eq("location_type", 0);
                baseProcess.setAllLocationId(baseLocationMapper.selectOne(queryWrapper1).getId() + "," + destId);
                baseProcess.setAllLocationStatus("1,0");
            } else {

                if (vistitType.equals("0") && exist.getExist() == 1 && Integer.parseInt(destId) > 3) {
                    if (Integer.parseInt(destId) == 4) {
                        baseProcess.setAllLocation("场外,人员初级洗消站,净区,场内");
                        baseProcess.setAllLocationId("20,1,2,4");
                        baseProcess.setAllLocationStatus("1,0,0,0");
                    } else {
                        baseProcess.setAllLocation("场外,人员初级洗消站,净区,场内,生产区");
                        baseProcess.setAllLocationId("20,1,2,4,5");
                        baseProcess.setAllLocationStatus("1,0,0,0,0");
                    }
                } else if (vistitType.equals("3") && exist.getExist() == 1 && Integer.parseInt(destId) > 7) {
                    baseProcess.setAllLocation("场外,车辆初级洗消站,中转料塔外围");
                    baseProcess.setAllLocationId("20,6,8");
                    baseProcess.setAllLocationStatus("1,0,0");

                } else {
                    String allLocation = "";
                    String allLocationId = "";
                    String allLocationStatus = "";
                    for (BaseLocation baseLocation : baseLocations) {
                        if (baseLocation.getId() < Integer.parseInt(destId) || baseLocation.getId() >= 20) {
                            allLocation = allLocation + baseLocation.getLocationName() + ",";
                            allLocationId = allLocationId + baseLocation.getId() + ",";
                            allLocationStatus = allLocationStatus + "0" + ",";
                        }
                        if (baseLocation.getId() == Integer.parseInt(destId)) {
                            allLocation = allLocation + baseLocation.getLocationName();
                            allLocationId = allLocationId + baseLocation.getId();
                            allLocationStatus = allLocationStatus + "0";
                        }
                    }
                    baseProcess.setAllLocation(allLocation);
                    baseProcess.setAllLocationId(allLocationId);
                    String[] split = allLocationStatus.split(",");
                    split[0] = "1";
                    baseProcess.setAllLocationStatus(split[0] + allLocationStatus.substring(1));
                }

            }
        }


        //获取位置
        BaseLocation baseLocation;
        if (vistitType.equals("5")) {
            baseLocation = baseLocationMapper.selectById(destId);
        } else {
            baseLocation = baseLocationMapper.selectOne(new QueryWrapper<BaseLocation>().eq("vistit_type", vistitType).eq("parent_id", 0));
        }
        if (ObjectUtil.isEmpty(baseLocation)) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return new Result(10001, "该来访类型位置不存在", false);
        }
        baseProcess.setCurrentLocation(baseLocation.getLocationName());
        baseProcess.setCurrentLocationId(baseLocation.getId().toString());
        baseProcess.setFarmId(Integer.parseInt(farmId));
        baseProcessMapper.insert(baseProcess);
        billPersonnelAdmission.setProcessId(baseProcess.getId());
        billPersonnelAdmissionMapper.insert(billPersonnelAdmission);
        ArrayList<String> phoneList = new ArrayList<>();
        List<SysAccountMultilevel> safe = sysAccountMultilevelMapper.selectList(new QueryWrapper<SysAccountMultilevel>().eq("farm_ids", farmId).eq("type", 3));
        for (SysAccountMultilevel sysAccountMultilevel : safe) {
            phoneList.add(sysAccountMultilevel.getPhone());
        }
//        SendSMS.sendSMS(phoneList,TokenSign.getUserNameByJwtToken(httpServletRequest)+"入场申请测试");
        if (ObjectUtil.isNotEmpty(goods)) {
            ObjectMapper objectMapper = new ObjectMapper();
            List<BillGoodsInventory> admissionAndGoods = objectMapper.readValue(goods, new TypeReference<List<BillGoodsInventory>>() {
            });
            for (BillGoodsInventory good : admissionAndGoods) {
                good.setBillAdmission(billPersonnelAdmission.getId());
                BaseLocation baseLocation1 = baseLocationMapper.selectById(destId);
                good.setCurrentLocation(baseLocation1.getLocationName());
                good.setCurrentLocationId(baseLocation1.getId());
                good.setCreateDate(new Date());
                good.setFarmId(farmId);
                billGoodsInventoryMapper.insert(good);
            }
        }
        return Result.SUCCESS();
    }

    @Override
    public Result listPersonalAdmission(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String farmId = paramsMap.get("farmId");
        String pageNo = paramsMap.get("pageNum");
        String pageSize = paramsMap.get("pageSize");
        String vistitType = paramsMap.get("vistitType");
        Page<BillPersonnelAdmission> page = new Page<>(Integer.parseInt(pageNo), Integer.parseInt(pageSize));
        QueryWrapper<BillPersonnelAdmission> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq(StringUtils.isNotBlank(vistitType), "vistit_type", vistitType).eq("farm_id", farmId)
                .eq("admission_user_id", TokenSign.getMemberIdByJwtToken(httpServletRequest))
                .orderByDesc("sub_date");
        Page<BillPersonnelAdmission> billPersonnelAdmissionPage = billPersonnelAdmissionMapper.selectPage(page, new QueryWrapper<BillPersonnelAdmission>()
                .eq(StringUtils.isNotBlank(vistitType), "vistit_type", vistitType)
                .eq("admission_user_id", TokenSign.getMemberIdByJwtToken(httpServletRequest))
                .eq("farm_id", farmId)
                .orderByDesc("sub_date"));
        return new Result(ResultCode.SUCCESS, billPersonnelAdmissionPage, billPersonnelAdmissionMapper.selectCount(queryWrapper));
    }

    @Override
    public Result listAdmission(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String pageNo = paramsMap.get("pageNum");
        String pageSize = paramsMap.get("pageSize");
        String type = paramsMap.get("type");
        String farmId = paramsMap.get("farmId");
        QueryWrapper<BillPersonnelAdmission> queryWrapper = new QueryWrapper<>();
        Integer userType = TokenSign.getUserTypeByJwtToken(httpServletRequest);
        if (userType == 3) {
            //生物安全负责人
            queryWrapper.eq("admission_type", 0);
        } else if (userType == 2) {
            //紧急入场
            queryWrapper.ne("admission_type", 0);
        }
        switch (type) {
            case "1":
                queryWrapper.eq("bill_status", 0);
                break;
            case "2":
                queryWrapper.eq("bill_status", 1);
                break;
            case "3":
                queryWrapper.eq("bill_status", 2);
                break;
            default:
                break;
        }
        queryWrapper.orderByDesc("sub_date").eq("farm_id", farmId);
//        List<BaseLocation> baseLocations = baseLocationMapper.selectList(new QueryWrapper<BaseLocation>().eq("serial_number", 0));
//        List<Integer> locationIds = new ArrayList<>();
//        for (BaseLocation baseLocation : baseLocations) {
//            locationIds.add(baseLocation.getId());
//        }
//        if (!locationIds.contains(Integer.parseInt(TokenSign.getWorkIdByJwtToken(httpServletRequest)))){
//            queryWrapper.eq("id",0);
//        }
        Page<BillPersonnelAdmission> page = new Page<>(Integer.parseInt(pageNo), Integer.parseInt(pageSize));
        Page<BillPersonnelAdmission> billPersonnelAdmissionPage = billPersonnelAdmissionMapper.selectPage(page, queryWrapper);
        QueryWrapper<BillPersonnelAdmission> queryWrapper1 = new QueryWrapper<>();
        queryWrapper1.eq("farm_id", farmId);
        if (userType == 3) {
            //生物安全负责人
            queryWrapper1.eq("admission_type", 0);
        } else if (userType == 2) {
            //紧急入场
            queryWrapper1.ne("admission_type", 0);
        }
        queryWrapper1.eq("bill_status", 0);
        return new Result(ResultCode.SUCCESS, billPersonnelAdmissionPage, billPersonnelAdmissionMapper.selectList(queryWrapper1).size());
    }

    @Override
    @Transactional
    public Result handleAdmission(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) throws IOException {
        String type = paramsMap.get("type");
        String id = paramsMap.get("id");
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
        BillPersonnelAdmission billPersonnelAdmission = billPersonnelAdmissionMapper.selectById(id);
        Integer userType = TokenSign.getUserTypeByJwtToken(httpServletRequest);
        billPersonnelAdmission.setPassDate(LocalDateTime.now());
        billPersonnelAdmission.setPassUserId(TokenSign.getMemberIdByJwtToken(httpServletRequest));
        billPersonnelAdmission.setPassUserName(TokenSign.getUserNameByJwtToken(httpServletRequest));
        BaseProcess baseProcess = baseProcessMapper.selectById(billPersonnelAdmission.getProcessId());

        ArrayList<String> phoneList = new ArrayList<>();
        phoneList.add(billPersonnelAdmission.getPhone());
        if (StringUtils.isBlank(baseProcess.getUpdateDate())) {
            baseProcess.setUpdateDate(LocalDateTime.now().format(dateTimeFormatter));
        } else {
            baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + LocalDateTime.now().format(dateTimeFormatter));
        }
        if (type.equals("0")) {
            String[] split = baseProcess.getCurrentStatus().split(",");
            split[split.length - 1] = "2";
            //拒绝
            billPersonnelAdmission.setBillStatus(2);
            baseProcess.setProcessType(2);
            baseProcess.setCurrentStatus(String.join(",", split));
            String status = baseProcess.getAllLocationStatus();
            String[] split1 = status.split(",");
            split1[0] = "3";
            baseProcess.setAllLocationStatus(split1[0] + status.substring(1));
//            SendSMS.sendSMS(phoneList,"拒绝入场申请测试");
        } else {

            if (billPersonnelAdmission.getBillStatus() != 0) {
                return new Result(10001, "该订单已通过，无需再次点击！", false);
            }
            //通过
            billPersonnelAdmission.setBillStatus(1);
            //获取pcr位置
            String locationId = baseProcess.getCurrentLocationId();
            String[] strings = locationId.split(",");
            String laseLocationId = strings[strings.length - 1];
            BaseLocation baseLocation = baseLocationMapper.selectById(laseLocationId);
            if (userType == 3) {
                String[] split = baseProcess.getCurrentStatus().split(",");
                split[split.length - 1] = "1";
                StringBuilder result = new StringBuilder();
                for (String element : split) {
                    result.append(element).append(",");
                }
                result.append("0");
                baseProcess.setCurrentStatus(result.toString());
                baseProcess.setCurrentLocation(baseProcess.getCurrentLocation() + "," + baseLocation.getLocationName());
                baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId() + "," + baseLocation.getId());

                String status = baseProcess.getAllLocationStatus();
                String[] split1 = status.split(",");
                split1[0] = "2";
                split1[1] = "1";
                baseProcess.setAllLocationStatus(split1[0] + "," + split1[1] + status.substring(3));

                BillPcr billPcr = new BillPcr();
                billPcr.setVistitType(billPersonnelAdmission.getVistitType());
                billPcr.setDestName(billPersonnelAdmission.getDestName());
                billPcr.setDestId(billPersonnelAdmission.getDestId());
                billPcr.setPhone(billPersonnelAdmission.getPhone());
                billPcr.setAdmissionUserId(billPersonnelAdmission.getAdmissionUserId());
                billPcr.setAdmissionUserName(billPersonnelAdmission.getAdmissionUserName());
                billPcr.setSubDate(LocalDateTime.now());
                billPcr.setVistitDate(billPersonnelAdmission.getVistitDate());
                billPcr.setFarmId(billPersonnelAdmission.getFarmId());
                billPcr.setProcessId(billPersonnelAdmission.getProcessId());
                billPcr.setAdmissionId(Integer.parseInt(id));
                if (ObjectUtil.isNotEmpty(billPersonnelAdmission.getCarNum())) {
                    billPcr.setCarNum(billPersonnelAdmission.getCarNum());
                }
                billPcr.setTestLocation(baseLocation.getLocationName());
                billPcr.setTestLocationId(baseLocation.getId());
                billPcrMapper.insert(billPcr);
//                SendSMS.sendSMS(phoneList,"通过入场申请测试");
            } else {
                baseProcess.setCurrentStatus("1");
                baseProcess.setProcessType(1);
                baseProcess.setAllLocationStatus("2,2");
//                baseProcess.setCurrentLocation(baseProcess.getCurrentLocation()+","+baseLocation.getLocationName());
//                baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId() +","+baseLocation.getId());
                //TODO 紧急入场通过先不处理
            }

            //通过生成门禁白名单
            QueryWrapper<DeviceList> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("farm_id", billPersonnelAdmission.getFarmId()).eq("location_id", locationId);
            DeviceList deviceList = deviceListMapper.selectOne(queryWrapper);
            if (ObjectUtil.isNotEmpty(deviceList)) {
                if (deviceList.getDeviceType() == 0) {
                    //通过生成门禁白名单
                    PeopleList peopleList = new PeopleList();
                    peopleList.setFarmId(billPersonnelAdmission.getFarmId().toString());
                    peopleList.setDeviceCode(deviceList.getDeviceCode());
                    peopleList.setUserId(billPersonnelAdmission.getAdmissionUserId());
                    peopleList.setUserName(billPersonnelAdmission.getAdmissionUserName());
                    peopleList.setPassword("123456");
                    peopleList.setType(0);
                    peopleList.setCreateTime(new Date());
                    Date date = new Date();
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTime(date);
                    calendar.add(Calendar.HOUR_OF_DAY, 2);
                    Date date1 = calendar.getTime();
                    peopleList.setOutTime(date1);
                    peopleListMapper.insert(peopleList);

                    HashMap<String, Object> jsonObject = new HashMap<>();
                    jsonObject.put("seq", deviceList.getDeviceCode());
                    String savePath = "D:\\works\\pig_projects\\甜妹.jpg";
                    URL url = new URL(billPersonnelAdmission.getUserImgUrl());
                    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
                    connection.setRequestMethod("GET");
                    int resCode = connection.getResponseCode();
                    if (resCode == HttpURLConnection.HTTP_OK) {
                        InputStream inputStream = connection.getInputStream();
                        byte[] buffer = new byte[4096];
                        int length;
                        //读取数据并写入到文件中
                        try (FileOutputStream outStream = new FileOutputStream(savePath)) {
                            while ((length = inputStream.read(buffer)) != -1) {
                                outStream.write(buffer, 0, length);
                            }
                            outStream.flush();
                        } finally {
                            inputStream.close();
                        }
                    } else {
                        System.out.println("文件下载错误码为" + resCode);
                    }

                    jsonObject.put("face", FileUtil.file("D:\\works\\pig_projects\\甜妹.jpg"));
                    jsonObject.put("name", billPersonnelAdmission.getAdmissionUserName());
                    jsonObject.put("password", "123456");
                    jsonObject.put("timestamp", date1.getTime());
                    jsonObject.put("uid", billPersonnelAdmission.getAdmissionUserId());
                    String post = HttpRequest.post("http://192.168.1.42:8040/addDeviceUser")
                            .header(Header.CONTENT_TYPE, "multipart/form-data")
                            .form(jsonObject)
                            .timeout(30 * 1000).execute().body();
                    System.out.println(post);
                } else {
                    //车辆闸机
                    PeopleList peopleList = new PeopleList();
                    peopleList.setFarmId(billPersonnelAdmission.getFarmId().toString());
                    peopleList.setDeviceCode(deviceList.getDeviceCode());
                    peopleList.setUserId(billPersonnelAdmission.getAdmissionUserId());
                    peopleList.setUserName(billPersonnelAdmission.getAdmissionUserName());
                    peopleList.setPassword("123456");
                    peopleList.setType(1);
                    peopleList.setCreateTime(new Date());
                    Date date = new Date();
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTime(date);
                    calendar.add(Calendar.HOUR_OF_DAY, 2);
                    Date date1 = calendar.getTime();
                    peopleList.setOutTime(date1);
                    peopleListMapper.insert(peopleList);

                    //需要先验证车辆是否存在白名单内，如果车辆已存在于白名单当中，则需要更新白名单，将车牌从白名单中删除后
                    //重新进行添加，如果车辆不存在于白名单当中则直接添加入白名单
                    JSONObject jsonObject = new JSONObject();
                    jsonObject.put("seq", deviceList.getDeviceCode());
                    jsonObject.put("isBlack", false);
                    String request = HttpRequest.get("http://192.168.1.42:8040/getCarDeviceWoBList")
                            .body(jsonObject.toJSONString())
                            .header(Header.CONTENT_TYPE, "application/json")
                            .timeout(30 * 1000).execute().body();
                    JSONObject object = JSON.parseObject(request);
                    System.out.println(object);
                    JSONArray data = (JSONArray) object.get("data");
                    System.out.println(data);
                    for (int i = 0; i < data.size(); i++) {
                        JSONObject jsonObject1 = (JSONObject) data.get(i);
                        if (jsonObject1.get("plate").equals(billPersonnelAdmission.getCarNum())) {
                            JSONObject jsonObject2 = new JSONObject();
                            jsonObject2.put("isBlack", false);
                            jsonObject2.put("seq", deviceList.getDeviceCode());
                            List<Integer> list = new ArrayList<>();
                            list.add((Integer) jsonObject1.get("cid"));
                            jsonObject2.put("cids", list);

                            String body = HttpRequest.post(" http://192.168.1.42:8040/delCarDeviceWoBList").header(Header.CONTENT_TYPE, "application/json")
                                    .body(jsonObject2.toJSONString())
                                    .timeout(30 * 1000).execute().body();
                            System.out.println(body);
                        }
                    }


                    JSONObject jsonObject1 = new JSONObject();
                    JSONArray jsonArray = new JSONArray();
                    JSONObject object1 = new JSONObject();
                    jsonObject1.put("seq", deviceList.getDeviceCode());
                    jsonObject1.put("isBlack", false);

                    object1.put("timestamp", date1.getTime());
                    object1.put("name", billPersonnelAdmission.getAdmissionUserName());
                    object1.put("plate", billPersonnelAdmission.getCarNum());

                    jsonArray.add(object1);
                    jsonObject1.put("plates", jsonArray);

                    String post = HttpRequest.post(" http://192.168.1.42:8040/addCarDeviceWoBList")
                            .header(Header.CONTENT_TYPE, "application/json")
                            .body(jsonObject1.toJSONString())
                            .timeout(30 * 1000).execute().body();
                    System.out.println(post);
                }

            }
        }
        baseProcessMapper.updateById(baseProcess);
        billPersonnelAdmissionMapper.updateById(billPersonnelAdmission);
        return Result.SUCCESS();
    }


    @Override
    public Result listAll(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String type = paramsMap.get("type");
        String farmId = paramsMap.get("farmId");
        String pageNo = paramsMap.get("pageNum");
        String pageSize = paramsMap.get("pageSize");
//        QueryWrapper<BillPersonnelAdmission> queryWrapper = new QueryWrapper<>();
//        queryWrapper.eq("farm_id", farmId);
        Page<FactoryDirectorVo> page = new Page<>(Integer.parseInt(pageNo), Integer.parseInt(pageSize));
        IPage<FactoryDirectorVo> factoryDirectorList;
//        factoryDirectorList = billPersonnelAdmissionMapper.listAll(queryWrapper,page);
        if (type.equals("0")) {
            factoryDirectorList = billPersonnelAdmissionMapper.listAll(type, farmId, page);
        } else {
            factoryDirectorList = billPersonnelAdmissionMapper.listCarAll(type, farmId, page);
        }

        return new Result(ResultCode.SUCCESS, factoryDirectorList/*, factoryDirectorList.getSize()*/);
    }

    @Override
    public Result getDetail(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String type = paramsMap.get("type");
        String id = paramsMap.get("id");
        if (type.equals("0")) {
            BillPersonnelAdmission billPersonnelAdmission = billPersonnelAdmissionMapper.selectById(id);
            BillAdmissionAndGoods billAdmissionAndGoods = new BillAdmissionAndGoods();
            BeanUtil.copyProperties(billPersonnelAdmission, billAdmissionAndGoods);
            List<BillGoodsInventory> billGoodsInventories = billGoodsInventoryMapper.selectList(new QueryWrapper<BillGoodsInventory>().eq("bill_admission", id));
            billAdmissionAndGoods.setGoods(billGoodsInventories);
            return new Result(ResultCode.SUCCESS, billAdmissionAndGoods);
        } else if (type.equals("1")) {
            return new Result(ResultCode.SUCCESS, billPcrMapper.selectById(id));
        } else if (type.equals("2")) {
            return new Result(ResultCode.SUCCESS, billCleanMapper.selectById(id));
        } else if (type.equals("4")) {
            return new Result(ResultCode.SUCCESS, dryMapper.selectById(id));
        } else {
            return new Result(ResultCode.SUCCESS, billIsolateMapper.selectById(id));
        }
    }

    @Override
    public Result listDoor(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String farmId = paramsMap.get("farmId");
        String type = paramsMap.get("type");//1为车辆 2为闸机
        String status = paramsMap.get("status");//0为全部 1为通过 2为不通过
        String pageNum = paramsMap.get("pageNum");
        String pageSize = paramsMap.get("pageSize");
        if ("".equals(pageNum) || null == pageNum) {
            pageNum = "1";
        }
        if ("".equals(pageSize) || null == pageSize) {
            pageSize = "10";
        }
        if ("".equals(status) || null == status) {
            status = "0";
        }
        if ("1".equals(type)) {
            QueryWrapper<BillAccessDoor> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("farm_id", farmId).orderByDesc("check_date");
            if ("1".equals(status)) {
                queryWrapper.eq("bill_status", 1);
            } else if ("2".equals(status)) {
                queryWrapper.eq("bill_status", 0);
            }
            Page<BillAccessDoor> page = new Page<>(Integer.parseInt(pageNum), Integer.parseInt(pageSize));
            return new Result(ResultCode.SUCCESS, doorMapper.selectPage(page, queryWrapper));
        } else {
            QueryWrapper<BillGate> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("farm_id", farmId).orderByDesc("check_date");
            if ("1".equals(status)) {
                queryWrapper.eq("bill_status", 1);
            } else if ("2".equals(status)) {
                queryWrapper.eq("bill_status", 0);
            }
            Page<BillGate> page = new Page<>(Integer.parseInt(pageNum), Integer.parseInt(pageSize));
            return new Result(ResultCode.SUCCESS, gateMapper.selectPage(page, queryWrapper));
        }
    }

    @Override
    public Result countAdmission(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String farmId = paramsMap.get("farmId");
        String type = paramsMap.get("type");
        if ("".equals(type) || type == null) {
            type = "1";
        }
        List<ListAdmissionVo> admissionVo = null;
        QueryWrapper<BillPersonnelAdmission> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("farm_id", farmId);
        //默认今日
        if ("1".equals(type)) {
            Date timesmorning = DataUill.getTimesmorning();
            queryWrapper.ge("sub_date", timesmorning);
            admissionVo = billPersonnelAdmissionMapper.countAdmission(queryWrapper);
            for (ListAdmissionVo listAdmissionVo : admissionVo) {
                QueryWrapper<BillPersonnelAdmission> queryWrapper1 = new QueryWrapper<>();
                queryWrapper1.eq("farm_id", farmId).ge("sub_date", timesmorning)
                        .eq("vistit_type", listAdmissionVo.getType()).eq("bill_status", 1);
                QueryWrapper<BillPersonnelAdmission> queryWrapper2 = new QueryWrapper<>();
                queryWrapper2.eq("farm_id", farmId).ge("sub_date", timesmorning)
                        .eq("vistit_type", listAdmissionVo.getType()).eq("bill_status", 2);
                listAdmissionVo.setPassCount(billPersonnelAdmissionMapper.selectCount(queryWrapper1));
                listAdmissionVo.setRefuseCount(billPersonnelAdmissionMapper.selectCount(queryWrapper2));
            }
        } else if ("2".equals(type)) {
            // 本周
            Calendar calendar = Calendar.getInstance();
            calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) - 7);
            queryWrapper.ge("sub_date", calendar.getTime());
            admissionVo = billPersonnelAdmissionMapper.countAdmission(queryWrapper);
            for (ListAdmissionVo listAdmissionVo : admissionVo) {
                QueryWrapper<BillPersonnelAdmission> queryWrapper1 = new QueryWrapper<>();
                queryWrapper1.eq("farm_id", farmId).ge("sub_date", calendar.getTime())
                        .eq("vistit_type", listAdmissionVo.getType()).eq("bill_status", 1);
                QueryWrapper<BillPersonnelAdmission> queryWrapper2 = new QueryWrapper<>();
                queryWrapper2.eq("farm_id", farmId).ge("sub_date", calendar.getTime())
                        .eq("vistit_type", listAdmissionVo.getType()).eq("bill_status", 2);
                listAdmissionVo.setPassCount(billPersonnelAdmissionMapper.selectCount(queryWrapper1));
                listAdmissionVo.setRefuseCount(billPersonnelAdmissionMapper.selectCount(queryWrapper2));
            }
        } else if ("3".equals(type)) {
            //本月
            Date timesMonthmorning = DataUill.getTimesMonthmorning();
            queryWrapper.ge("sub_date", timesMonthmorning);
            admissionVo = billPersonnelAdmissionMapper.countAdmission(queryWrapper);
            for (ListAdmissionVo listAdmissionVo : admissionVo) {
                QueryWrapper<BillPersonnelAdmission> queryWrapper1 = new QueryWrapper<>();
                queryWrapper1.eq("farm_id", farmId).ge("sub_date", timesMonthmorning)
                        .eq("vistit_type", listAdmissionVo.getType()).eq("bill_status", 1);
                QueryWrapper<BillPersonnelAdmission> queryWrapper2 = new QueryWrapper<>();
                queryWrapper2.eq("farm_id", farmId).ge("sub_date", timesMonthmorning)
                        .eq("vistit_type", listAdmissionVo.getType()).eq("bill_status", 2);
                listAdmissionVo.setPassCount(billPersonnelAdmissionMapper.selectCount(queryWrapper1));
                listAdmissionVo.setRefuseCount(billPersonnelAdmissionMapper.selectCount(queryWrapper2));
            }
        }
        return new Result(ResultCode.SUCCESS, admissionVo);
    }

    @Override
    public Result listTop(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String farmId = paramsMap.get("farmId");
        String type = paramsMap.get("type");
        if ("".equals(type) || type == null) {
            type = "1";
        }
        List<ListAdmissionVo> admissionVo = null;
        QueryWrapper<BillPersonnelAdmission> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("farm_id", farmId);
        //今日
        if ("1".equals(type)) {
            Date timesmorning = DataUill.getTimesmorning();
            queryWrapper.ge("sub_date", timesmorning);
            admissionVo = billPersonnelAdmissionMapper.countAdmission(queryWrapper);
        } else if ("2".equals(type)) {
            // 本周
            Calendar calendar = Calendar.getInstance();
            calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) - 7);
            queryWrapper.ge("sub_date", calendar.getTime());
            admissionVo = billPersonnelAdmissionMapper.countAdmission(queryWrapper);
        } else if ("3".equals(type)) {
            //本月
            Date timesMonthmorning = DataUill.getTimesMonthmorning();
            queryWrapper.ge("sub_date", timesMonthmorning);
            admissionVo = billPersonnelAdmissionMapper.countAdmission(queryWrapper);
        }
        JSONArray jsonArray = new JSONArray();
        for (ListAdmissionVo listAdmissionVo : admissionVo) {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("type", listAdmissionVo.getType());
            if (listAdmissionVo.getType() == 0) {
                jsonObject.put("name", "人员");
            } else if (listAdmissionVo.getType() == 1) {
                jsonObject.put("name", "环保车");
            } else if (listAdmissionVo.getType() == 2) {
                jsonObject.put("name", "拉猪车");
            } else if (listAdmissionVo.getType() == 3) {
                jsonObject.put("name", "饲料车");
            } else if (listAdmissionVo.getType() == 4) {
                jsonObject.put("name", "送猪车");
            } else if (listAdmissionVo.getType() == 5) {
                jsonObject.put("name", "物资车");
            }
            jsonObject.put("value", listAdmissionVo.getCount());
            jsonArray.add(jsonObject);
        }
        JSONArray array = jsonArraySort(jsonArray, "value", true);
        for (int i = 0; i < array.size(); i++) {
            JSONObject jsonObject = array.getJSONObject(i);
            jsonObject.put("rank", i + 1);
        }

        return new Result(ResultCode.SUCCESS, array);
    }

    @Override
    public Result admissionTail(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String farmId = paramsMap.get("farmId");
        String type = paramsMap.get("type");
        if ("".equals(type) || type == null) {
            type = "3";
        }
        //今日
        List<BillAdmissionVo> admissionVos = null;
        QueryWrapper<BillPersonnelAdmission> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("farm_id", farmId);
        if ("1".equals(type)) {
            Date timesmorning = DataUill.getTimesmorning();
            queryWrapper.ge("sub_date", timesmorning);
            admissionVos = billPersonnelAdmissionMapper.admissionTail(queryWrapper);
        } else if ("2".equals(type)) {
            // 本周
            Calendar calendar = Calendar.getInstance();
            calendar.set(Calendar.DATE, calendar.get(Calendar.DATE) - 7);
            queryWrapper.ge("sub_date", calendar.getTime());
            admissionVos = billPersonnelAdmissionMapper.admissionTail(queryWrapper);
        } else if ("3".equals(type)) {
            //本月
            Date timesMonthmorning = DataUill.getTimesMonthmorning();
            queryWrapper.ge("sub_date", timesMonthmorning);
            admissionVos = billPersonnelAdmissionMapper.admissionTail(queryWrapper);
        }
        for (BillAdmissionVo admissionVo : admissionVos) {
            admissionVo.setCommitCount(admissionVo.getPassCount() + admissionVo.getRefuseCount());
        }
        return new Result(ResultCode.SUCCESS, admissionVos);
    }

    @Override
    public Result selectList(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String farmId = paramsMap.get("farmId");
        String type = paramsMap.get("type");//来访类型
        String destId = paramsMap.get("destId");//目的地
        String startTime = paramsMap.get("startTime");
        String endTime = paramsMap.get("endTime");
        String pageNum = paramsMap.get("pageNum");
        String pageSize = paramsMap.get("pageSize");
        if ("".equals(pageNum) || null == pageNum) {
            pageNum = "1";
        }
        if ("".equals(pageSize) || null == pageSize) {
            pageSize = "10";
        }
        QueryWrapper<BillPersonnelAdmission> queryWrapper = new QueryWrapper<>();
        if (ObjectUtil.isNotEmpty(startTime)) {
            startTime = startTime + " 00:00:00";
            endTime = endTime + " 23:59:59";
            queryWrapper.between("sub_date", startTime, endTime);
        }
        queryWrapper.lambda().orderByDesc(BillPersonnelAdmission::getId);
        queryWrapper.eq("farm_id", farmId).eq(StringUtils.isNotBlank(destId), "dest_id", destId).eq(StringUtils.isNotBlank(type), "vistit_type", type);
        Page<BillPersonnelAdmission> page = new Page<>(Integer.parseInt(pageNum), Integer.parseInt(pageSize));
        return new Result(ResultCode.SUCCESS, billPersonnelAdmissionMapper.selectPage(page, queryWrapper));
    }

    @Override
    public void printAdmission(HttpServletResponse httpServletRequest, Map<String, String> paramsMap) throws Exception {
        String ids = paramsMap.get("ids");
        String[] split = ids.split(",");
        List<BillPersonnelAdmission> list = new ArrayList<>();
        for (String s : split) {
            BillPersonnelAdmission admission = billPersonnelAdmissionMapper.selectById(s);
            list.add(admission);
        }
        Print.printAdmission(list);
    }

    @Override
    public Result jingJiAdmission(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String farmId = paramsMap.get("farmId");
        QueryWrapper<BillPersonnelAdmission> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("farm_id", farmId).eq("admission_type", 1).orderByDesc("sub_date")
                .last(" limit 10");
        return new Result(ResultCode.SUCCESS, billPersonnelAdmissionMapper.selectList(queryWrapper));
    }

    @Override
    public Result allCount(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String farmId = paramsMap.get("farmId");
        Calendar currCal = Calendar.getInstance();
        Calendar calendar = Calendar.getInstance();
        calendar.clear();
        calendar.set(Calendar.YEAR, currCal.get(Calendar.YEAR));
        Date time = calendar.getTime();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String firstday = format.format(time);
        QueryWrapper<BillClean> cleanQueryWrapper = new QueryWrapper<>();
        cleanQueryWrapper.eq("farm_id", farmId).ge("sub_date", firstday);
        QueryWrapper<BillPcr> pcrQueryWrapper = new QueryWrapper<>();
        pcrQueryWrapper.eq("farm_id", farmId).ge("sub_date", firstday);
        QueryWrapper<BillGoodsInventory> goodsInventoryQueryWrapper = new QueryWrapper<>();
        goodsInventoryQueryWrapper.ge("create_date", firstday).eq("farm_id", farmId);
        JSONObject jsonObject = new JSONObject();
        Integer integer = pcrMapper.selectCount(pcrQueryWrapper);
        Integer integer1 = cleanMapper.selectCount(cleanQueryWrapper);
        Integer integer2 = billGoodsInventoryMapper.selectCount(goodsInventoryQueryWrapper);
        jsonObject.put("pcr", integer);
        jsonObject.put("clean", integer1);
        jsonObject.put("goods", integer2);
        jsonObject.put("allCount", integer + integer1 + integer2);
        jsonObject.put("look", "22");
        return new Result(ResultCode.SUCCESS, jsonObject);
    }

    @Override
    public Result uploadImgAndAdmissin(MultipartFile imgUrl, Integer id) throws IOException {
        BillPersonnelAdmission billPersonnelAdmission = billPersonnelAdmissionMapper.selectById(id);
        String imageCom = "";
        if (ObjectUtil.isNotEmpty(imgUrl)) {
            if (uploadImage.getImageCom(imgUrl).equals("上传失败")) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return new Result(10001, "图片上传失败", false);
            }
            imageCom = uploadImage.getImageCom(imgUrl);
        }

        billPersonnelAdmission.setUserImgUrl(imageCom);
        billPersonnelAdmissionMapper.updateById(billPersonnelAdmission);
        SysAccountMultilevel sysAccountMultilevel = new SysAccountMultilevel();

        sysAccountMultilevel.setId(billPersonnelAdmission.getAdmissionUserId());
        sysAccountMultilevel.setImgUrl(imageCom);
        sysAccountMultilevelMapper.updateById(sysAccountMultilevel);
        return new Result(10000, "修改成功", true);
    }

    /*数组排序*/
    public static JSONArray jsonArraySort(JSONArray jsonArr, String sortKey, boolean is_desc) {
        //存放排序结果json数组
        JSONArray sortedJsonArray = new JSONArray();
        //用于排序的list
        List<JSONObject> jsonValues = new ArrayList<JSONObject>();
        //将参数json数组每一项取出，放入list

        for (int i = 0; i < jsonArr.size(); i++) {
            jsonValues.add(jsonArr.getJSONObject(i));
        }
        //快速排序，重写compare方法，完成按指定字段比较，完成排序
        Collections.sort(jsonValues, new Comparator<JSONObject>() {
            //排序字段
            private final String KEY_NAME = sortKey;

            //重写compare方法
            @Override
            public int compare(JSONObject a, JSONObject b) {
                //如果用String接会导致一位数和两位数混合比对的时候不能准确比出来，要用int类型接
                //String valA = new String();
                //String valB = new String();
                Float valA = 0.00f;
                Float valB = 0.00f;
                try {
                    valA = Float.parseFloat(a.getString(KEY_NAME));
                    valB = Float.parseFloat(b.getString(KEY_NAME));
                } catch (JSONException e) {
                    e.printStackTrace();
                }
                //是升序还是降序
                if (is_desc) {
                    return -valA.compareTo(valB);
                } else {
                    return -valB.compareTo(valA);
                }

            }
        });
        //将排序后结果放入结果jsonArray
        for (int i = 0; i < jsonArr.size(); i++) {
            sortedJsonArray.add(jsonValues.get(i));
        }

        return sortedJsonArray;
    }

    @Autowired
    private BillPcrMapper pcrMapper;
    @Autowired
    private BaseProcessMapper processMapper;
    @Autowired
    private BaseLocationMapper locationMapper;
    @Autowired
    private BillCleanMapper cleanMapper;
    @Autowired
    private BillIsolateMapper isolateMapper;

    @Override
    public Result listPrc(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String type = paramsMap.get("type");//类型
        String pageNum = paramsMap.get("pageNum");
        String pageSize = paramsMap.get("pageSize");
        if ("".equals(pageNum) || null == pageNum) {
            pageNum = "1";
        }
        if ("".equals(pageSize) || null == pageSize) {
            pageSize = "20";
        }
        Page<BillPcr> page = new Page<>(Integer.parseInt(pageNum), Integer.parseInt(pageSize));
        if ("".equals(type) || null == type) {
            type = "0";
        }
        String farmId = paramsMap.get("farmId");
        QueryWrapper<BillPcr> queryWrapper = new QueryWrapper<>();

        queryWrapper.eq("farm_id", farmId).orderByDesc("sub_date");
        if ("0".equals(type)) {
            queryWrapper.in("pcr_type", 1, 2, 3);
        }
        if ("1".equals(type)) {
            queryWrapper.eq("pcr_type", 1);
        }
        if ("2".equals(type)) {
            queryWrapper.eq("pcr_type", 2);
        }
        if ("3".equals(type)) {
            queryWrapper.eq("pcr_type", 3);
        }
        QueryWrapper<BillPcr> queryWrapper1 = new QueryWrapper<>();

        queryWrapper1.eq("farm_id", farmId).orderByDesc("sub_date").eq("pcr_type", 1);
        return new Result(ResultCode.SUCCESS, pcrMapper.selectPage(page, queryWrapper), pcrMapper.selectCount(queryWrapper1));
    }

    @Override
    public Result listById(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String id = paramsMap.get("id");
        return new Result(ResultCode.SUCCESS, pcrMapper.selectById(id));
    }

    @Override
    public Result editStatus(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) throws ParseException {
        String farmId = paramsMap.get("farmId");
        String type = paramsMap.get("type");
        String id = paramsMap.get("id");
        String data = paramsMap.get("data");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        if (StringUtils.isBlank(data)) {
            data = sdf.format(new Date());
        }
        BillPcr billPcr = pcrMapper.selectById(id);

        if (billPcr.getPcrType() != 1) {
            return new Result(10001, "pcr已通过或拒绝，无需再次复审", false);
        }

        QueryWrapper<BaseProcess> processQueryWrapper = new QueryWrapper<>();
        processQueryWrapper.eq("farm_id", farmId).eq("id", billPcr.getProcessId());
        BaseProcess baseProcess = processMapper.selectOne(processQueryWrapper);//进程

        QueryWrapper<BaseLocation> locationQueryWrapper = new QueryWrapper<>();
        locationQueryWrapper.eq("id", billPcr.getTestLocationId());
        BaseLocation baseLocation = locationMapper.selectOne(locationQueryWrapper);//当前pcr检测所在的位置


        if (baseProcess.getProcessType() == 2 || baseProcess.getProcessType() == 1) {
            return new Result(10001, "修改失败！该申请已提前结束或者被拒绝", false);
        } else {
            if (billPcr.getDestId() >= billPcr.getTestLocationId()) {
                //说明当前不是目的地
                if ("1".equals(type)) {

                    billPcr.setBillStatus(1);
                    billPcr.setPcrType(2);
                    billPcr.setPassUserName(TokenSign.getUserNameByJwtToken(httpServletRequest));
                    billPcr.setPassUserId(TokenSign.getMemberIdByJwtToken(httpServletRequest));
                    billPcr.setTestLocation(baseLocation.getLocationName());
                    billPcr.setTestLocationId(baseLocation.getId());
                    billPcr.setPassDate(sdf.parse(sdf.format(new Date())));
                    billPcr.setCheckDate(sdf.parse(data));

                    //通过生成洗消记录
                    BillClean billClean = new BillClean();
                    billClean.setPhone(billPcr.getPhone());
                    billClean.setVistitType(billPcr.getVistitType());
                    billClean.setDestName(billPcr.getDestName());
                    billClean.setDestId(billPcr.getDestId());
                    billClean.setAdmissionUserName(billPcr.getAdmissionUserName());
                    billClean.setAdmissionUserId(billPcr.getAdmissionUserId());
                    billClean.setVistitDate(billPcr.getVistitDate());
                    billClean.setSubDate(LocalDateTime.now());
                    billClean.setFarmId(billPcr.getFarmId());
                    billClean.setPassUserName(billPcr.getPassUserName());
                    billClean.setPassDate(billPcr.getPassDate());
                    billClean.setPassUserId(billPcr.getPassUserId());
                    billClean.setProcessId(billPcr.getProcessId());
                    billClean.setTestLocation(baseLocation.getLocationName());
                    billClean.setTestLocationId(baseLocation.getId());
                    billClean.setImgStatus(0);
                    billClean.setCarNum(billPcr.getCarNum());
                    cleanMapper.insert(billClean);

                    baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + sdf.format(new Date()));
                    baseProcess.setCurrentLocation(baseProcess.getCurrentLocation() + "," + baseLocation.getNextLocation());
                    baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId() + "," + baseLocation.getNextId());
                    String status = baseProcess.getCurrentStatus();
                    String substring = status.substring(0, status.length() - 1);

                    baseProcess.setCurrentStatus(substring + "1," + 0);

                    processMapper.updateById(baseProcess);
                    pcrMapper.updateById(billPcr);
                    return new Result(10000, "修改成功！", true);
                } else {
                    billPcr.setBillStatus(2);
                    billPcr.setPcrType(3);
                    billPcr.setPassUserName(TokenSign.getUserNameByJwtToken(httpServletRequest));
                    billPcr.setPassUserId(TokenSign.getMemberIdByJwtToken(httpServletRequest));
                    billPcr.setTestLocation(baseLocation.getLocationName());
                    billPcr.setTestLocationId(baseLocation.getId());
                    billPcr.setPassDate(sdf.parse(sdf.format(new Date())));
                    billPcr.setCheckDate(sdf.parse(data));

                    baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + sdf.format(new Date()));
                    baseProcess.setCurrentLocation(baseProcess.getCurrentLocation());
                    baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId());
                    String status = baseProcess.getCurrentStatus();
                    String substring = status.substring(0, status.length() - 1);

                    baseProcess.setCurrentStatus(substring + "2");
                    baseProcess.setProcessType(2);

                    String status1 = baseProcess.getAllLocationStatus();
                    String[] split1 = status1.split(",");
                    split1[0] = "2";
                    split1[1] = "3";
                    baseProcess.setAllLocationStatus(split1[0] + "," + split1[1] + status1.substring(3));

                    processMapper.updateById(baseProcess);
                    pcrMapper.updateById(billPcr);
                    return new Result(10000, "修改成功！", true);
                }
            } else {

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

                    billPcr.setBillStatus(1);
                    billPcr.setPcrType(2);
                    billPcr.setPassUserName(TokenSign.getUserNameByJwtToken(httpServletRequest));
                    billPcr.setPassUserId(TokenSign.getMemberIdByJwtToken(httpServletRequest));
                    billPcr.setTestLocation(baseLocation.getLocationName());
                    billPcr.setTestLocationId(baseLocation.getId());
                    billPcr.setPassDate(sdf.parse(sdf.format(new Date())));
                    billPcr.setCheckDate(sdf.parse(data));

                    baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + sdf.format(new Date()));
                    baseProcess.setCurrentLocation(baseProcess.getCurrentLocation());
                    baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId());
                    String status = baseProcess.getCurrentStatus();
                    String substring = status.substring(0, status.length() - 1);
                    baseProcess.setCurrentStatus(substring + "1");
                    baseProcess.setProcessType(1);

                    String status1 = baseProcess.getAllLocationStatus();
                    String[] split1 = status1.split(",");
                    split1[0] = "2";
                    split1[1] = "1";
                    baseProcess.setAllLocationStatus(split1[0] + "," + split1[1] + status1.substring(3));

                    processMapper.updateById(baseProcess);
                    pcrMapper.updateById(billPcr);
                    return new Result(10000, "修改成功！", true);
                } else {
                    baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + sdf.format(new Date()));
                    baseProcess.setCurrentLocation(baseProcess.getCurrentLocation());
                    baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId());
                    String status = baseProcess.getCurrentStatus();
                    String substring = status.substring(0, status.length() - 1);
                    baseProcess.setCurrentStatus(substring + "2");
                    baseProcess.setProcessType(2);
                    billPcr.setBillStatus(2);
                    billPcr.setPcrType(3);
                    billPcr.setPassUserName(TokenSign.getUserNameByJwtToken(httpServletRequest));
                    billPcr.setPassUserId(TokenSign.getMemberIdByJwtToken(httpServletRequest));
                    billPcr.setTestLocation(baseLocation.getLocationName());
                    billPcr.setTestLocationId(baseLocation.getId());
                    billPcr.setPassDate(sdf.parse(sdf.format(new Date())));
                    billPcr.setCheckDate(sdf.parse(data));

                    String status1 = baseProcess.getAllLocationStatus();
                    String[] split1 = status.split(",");
                    split1[0] = "2";
                    split1[1] = "3";
                    baseProcess.setAllLocationStatus(split1[0] + "," + split1[1] + status1.substring(3));

                    processMapper.updateById(baseProcess);
                    pcrMapper.updateById(billPcr);
                    return new Result(10000, "修改成功！", true);
                }

            }
        }
    }

    @Override
    public Result listIsolate(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String type = paramsMap.get("type");//类型
        String pageNum = paramsMap.get("pageNum");
        String pageSize = paramsMap.get("pageSize");
        if ("".equals(pageNum) || null == pageNum) {
            pageNum = "1";
        }
        if ("".equals(pageSize) || null == pageSize) {
            pageSize = "20";
        }
        Page<BillIsolate> page = new Page<>(Integer.parseInt(pageNum), Integer.parseInt(pageSize));
        if ("".equals(type) || null == type) {
            type = "0";
        }
        String farmId = paramsMap.get("farmId");
        QueryWrapper<BillIsolate> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("farm_id", farmId).orderByDesc("sub_date");
        if ("0".equals(type)) {
            queryWrapper.in("bill_status", 0, 1, 2, 3);
        }
        if ("1".equals(type)) {
            queryWrapper.eq("bill_status", 0);
        }
        if ("2".equals(type)) {
            queryWrapper.in("bill_status", 1, 2);
        }
        if ("3".equals(type)) {
            queryWrapper.eq("bill_status", 3);
        }
        QueryWrapper<BillIsolate> queryWrapper1 = new QueryWrapper<>();
        queryWrapper1.eq("farm_id", farmId).eq("bill_status", 0);
        return new Result(ResultCode.SUCCESS, isolateMapper.selectPage(page, queryWrapper), isolateMapper.selectCount(queryWrapper1));
    }

    @Override
    public Result isolateById(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String id = paramsMap.get("id");
        return new Result(ResultCode.SUCCESS, isolateMapper.selectById(id));
    }

    @Override
    public Result commitIsolate(HttpServletRequest httpServletRequest, BillIsolate billIsolate) {
        BillIsolate isolate = isolateMapper.selectById(billIsolate.getId());
        Date startDate = billIsolate.getIsolateStartDate();
        String dayNum = billIsolate.getIsolateDayNum();//隔离天数
        Date endDate = billIsolate.getIsolateEndDate();
        isolate.setIsolateStartDate(startDate);
        isolate.setIsolateEndDate(endDate);
        isolate.setIsolateDayNum(dayNum);
        isolate.setBillStatus(1);
        isolateMapper.updateById(isolate);
 /*       ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(10);
        Runnable task = new Runnable() {
            @Override
            public void run() {
                //这里写业务
                BillIsolate isolate = isolateMapper.selectById(billIsolate.getId());
                QueryWrapper<BaseLocation> locationQueryWrapper = new QueryWrapper<>();
                locationQueryWrapper.eq("farm_id", isolate.getFarmId()).eq("id", isolate.getIsolateLocationId());
                BaseLocation baseLocation = locationMapper.selectOne(locationQueryWrapper);//当前所在的位置
                QueryWrapper<BaseProcess> processQueryWrapper = new QueryWrapper<>();
                processQueryWrapper.eq("farm_id", isolate.getFarmId()).eq("id", isolate.getProcessId());
                BaseProcess baseProcess = processMapper.selectOne(processQueryWrapper);//进程
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
                if (isolate.getBillStatus() == 1) {
                    isolate.setBillStatus(2);
                    if (isolate.getDestId() >= isolate.getIsolateLocationId()) { //当前不是目的地
                        if (isolate.getIsolateLocationId() == 3 && baseProcess.getDestId() > 3) {

                            //通过生成洗消记录
                            BillClean billClean = new BillClean();
                            billClean.setPhone(isolate.getPhone());
                            billClean.setVistitType(isolate.getVistitType());
                            billClean.setDestName(isolate.getDestName());
                            billClean.setDestId(isolate.getDestId());
                            billClean.setAdmissionUserName(isolate.getAdmissionUserName());
                            billClean.setAdmissionUserId(isolate.getAdmissionUserId());
                            billClean.setVistitDate(isolate.getVistitDate());
                            billClean.setSubDate(isolate.getSubDate());
                            billClean.setFarmId(isolate.getFarmId());
                            billClean.setPassUserName(isolate.getPassUserName());
                            billClean.setPassDate(isolate.getPassDate());
                            billClean.setPassUserId(isolate.getPassUserId());
                            billClean.setProcessId(isolate.getProcessId());
                            billClean.setTestLocation(baseLocation.getNextLocation());
                            billClean.setTestLocationId(baseLocation.getNextId());
                            cleanMapper.insert(billClean);
                            baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + sdf.format(new Date()));
                            baseProcess.setCurrentLocation(baseProcess.getCurrentLocation() + "," + baseLocation.getNextLocation());
                            baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId() + "," + baseLocation.getNextId());
                            String status = baseProcess.getCurrentStatus();
                            String substring = status.substring(0, status.length() - 1);
                            baseProcess.setCurrentStatus(substring + "1," + 0);
                            processMapper.updateById(baseProcess);
                        } else {
                            baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + sdf.format(new Date()));
                            baseProcess.setCurrentLocation(baseProcess.getCurrentLocation());
                            baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId());
                            String status = baseProcess.getCurrentStatus();
                            String substring = status.substring(0, status.length() - 1);
                            baseProcess.setCurrentStatus(substring + "2");
                            baseProcess.setProcessType(1);
                            processMapper.updateById(baseProcess);
                        }
                    } else {
                        baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + sdf.format(new Date()));
                        baseProcess.setCurrentLocation(baseProcess.getCurrentLocation());
                        baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId());
                        String status = baseProcess.getCurrentStatus();
                        String substring = status.substring(0, status.length() - 1);
                        baseProcess.setCurrentStatus(substring + "2");
                        baseProcess.setProcessType(1);
                        processMapper.updateById(baseProcess);
                    }
                    isolateMapper.updateById(isolate);
                }
            }
        };
        // 设定延迟时间（两小时后执行，单位为秒）
        long delay = (endDate.getTime() - startDate.getTime()) / 1000;
        // 执行定时任务
        scheduler.schedule(task, delay, TimeUnit.SECONDS);*/
        return new Result(10000, "提交成功！", true);
    }

    @Override
    public Result editIsolate(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) throws ParseException {
        String id = paramsMap.get("id");
        String farmId = paramsMap.get("farmId");
        String remark = paramsMap.get("remark");//是否提前结束隔离的标识
        BillIsolate billIsolate = isolateMapper.selectById(id);
        BaseProcess baseProcess = processMapper.selectById(billIsolate.getProcessId());
        QueryWrapper<BaseLocation> locationQueryWrapper = new QueryWrapper<>();
        locationQueryWrapper.eq("id", billIsolate.getIsolateLocationId());
        BaseLocation baseLocation = locationMapper.selectOne(locationQueryWrapper);//当前隔离所在的位置

        QueryWrapper<Exist> existQueryWrapper = new QueryWrapper<>();
        existQueryWrapper.eq("farm_id", farmId);
        Exist exist = existMapper.selectOne(existQueryWrapper);//判断是否有二级洗消站

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String end = sdf.format(billIsolate.getIsolateEndDate());
        String start = sdf.format(billIsolate.getIsolateStartDate());
        String now = sdf.format(new Date());
        int res = now.compareTo(end);


        //提前结束隔离
        if (baseProcess.getDestId().equals(billIsolate.getIsolateLocationId())) {
            //目的地就是当前隔离地点
            baseProcess.setProcessType(1);
            baseProcess.setCurrentLocation(baseProcess.getCurrentLocation());
            baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId());
        } else {
            baseProcess.setProcessType(0);
            baseProcess.setCurrentLocation(baseProcess.getCurrentLocation() + "," + baseLocation.getNextLocation());
            baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId() + "," + baseLocation.getNextId());
        }

        if (billIsolate.getIsolateLocationId() == 3 && baseProcess.getDestId() >= 4) {
            //通过生成洗消记录
            BillClean billClean = new BillClean();
            billClean.setVistitType(billIsolate.getVistitType());
            billClean.setDestName(billIsolate.getDestName());
            billClean.setDestId(billIsolate.getDestId());
            billClean.setAdmissionUserName(billIsolate.getAdmissionUserName());
            billClean.setAdmissionUserId(billIsolate.getAdmissionUserId());
            billClean.setVistitDate(billIsolate.getVistitDate());
            billClean.setSubDate(LocalDateTime.now());
            billClean.setFarmId(billIsolate.getFarmId());
            billClean.setPassUserName(billIsolate.getPassUserName());
            billClean.setPassDate(billIsolate.getPassDate());
            billClean.setPassUserId(billIsolate.getPassUserId());
            billClean.setProcessId(billIsolate.getProcessId());
            billClean.setTestLocation("场内");
            billClean.setTestLocationId(4);
            billClean.setPhone(billIsolate.getPhone());
            cleanMapper.insert(billClean);

            String status = baseProcess.getAllLocationStatus();
            String[] split = status.split(",");
            split[0] = "2";
            split[1] = "2";
            split[2] = "2";
            split[3] = "2";
            split[4] = "1";
            baseProcess.setAllLocationStatus(split[0] + "," + split[1] + "," + split[2] + "," + split[3] + "," + split[4] + status.substring(9));
        }
        billIsolate.setIsolateRealEndDate(new Date());
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
        Calendar cal1 = Calendar.getInstance();
        Calendar cal2 = Calendar.getInstance();
        Date startDate = sdf1.parse(start);
        Date endDate = sdf1.parse(now);
        cal1.setTime(startDate);
        cal2.setTime(endDate);
        long days = (startDate.getTime() - endDate.getTime()) / (1000 * 3600);
        Integer l1 = (Integer.parseInt(String.valueOf(days / 24)));
        long l = l1 % 24;
        String num = l1.toString() + "天" + l + "小时";
//            long days = (cal2.getTimeInMillis() - cal1.getTimeInMillis()) / (1000 * 3600 * 24);
        billIsolate.setIsolateRealDayNum(num);
        billIsolate.setBillStatus(3);
        billIsolate.setPassUserName(TokenSign.getUserNameByJwtToken(httpServletRequest));
        billIsolate.setPassUserId(TokenSign.getMemberIdByJwtToken(httpServletRequest));

        baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + now);

        String status = baseProcess.getCurrentStatus();
        String substring = status.substring(0, status.length() - 1);
        baseProcess.setCurrentStatus(substring + "1," + 0);

        if (billIsolate.getIsolateLocationId() == 5 && exist.getExist() == 0) {

            baseProcess.setAllLocationStatus("2,2,2,2,2,2");
        }
        if (billIsolate.getIsolateLocationId() == 5 && exist.getExist() == 1) {

            baseProcess.setAllLocationStatus("2,2,2,2,2");
        }

        if (billIsolate.getIsolateLocationId() == 3) {
            String status1 = baseProcess.getAllLocationStatus();
            String[] split = status1.split(",");
            split[0] = "2";
            split[1] = "2";
            split[2] = "2";
            split[3] = "2";
            baseProcess.setAllLocationStatus(split[0] + "," + split[1] + "," + split[2] + "," + split[3] + status1.substring(7));
        }


        isolateMapper.updateById(billIsolate);
        processMapper.updateById(baseProcess);
        return new Result(10000, "提前解除隔离成功！", true);

    }

    @Override
    public Result listClean(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String type = paramsMap.get("type");//类型
        String pageNum = paramsMap.get("pageNum");
        String pageSize = paramsMap.get("pageSize");
        if ("".equals(pageNum) || null == pageNum) {
            pageNum = "1";
        }
        if ("".equals(pageSize) || null == pageSize) {
            pageSize = "20";
        }
        Page<CleanAndDryVo2> cleanAndDryVo2Page = null;
        Page<CleanAndDryVo2> page = new Page<>(Integer.parseInt(pageNum), Integer.parseInt(pageSize));
        if ("".equals(type) || null == type) {
            type = "0";
        }
        String farmId = paramsMap.get("farmId");
        QueryWrapper<BillClean> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("farm_id", farmId).ne("vistit_type", 0).orderByDesc("sub_date").eq("img_status", 1);
        QueryWrapper<BillDry> queryWrapper1 = new QueryWrapper<>();
        queryWrapper1.eq("farm_id", farmId).ne("vistit_type", 0).orderByDesc("sub_date").eq("img_status", 1);
        if ("0".equals(type)) {
            cleanAndDryVo2Page = cleanMapper.CleanAndDry2(page, farmId, "0,1,2".split(","));
        }
        ArrayList<String> arrayList = new ArrayList<>();
        if ("1".equals(type)) {
            arrayList.add("0");
            String[] s = arrayList.toArray(new String[arrayList.size()]);
            cleanAndDryVo2Page = cleanMapper.CleanAndDry2(page, farmId, s);
        }
        if ("2".equals(type)) {
            arrayList.add("1");
            String[] s = arrayList.toArray(new String[arrayList.size()]);
            cleanAndDryVo2Page = cleanMapper.CleanAndDry2(page, farmId, s);
        }
        if ("3".equals(type)) {
            arrayList.add("2");
            String[] s = arrayList.toArray(new String[arrayList.size()]);
            cleanAndDryVo2Page = cleanMapper.CleanAndDry2(page, farmId, s);
        }
        queryWrapper.eq("bill_status", 0);
        queryWrapper1.eq("bill_status", 0);
        Integer integer = cleanMapper.selectCount(queryWrapper);
        Integer integer1 = dryMapper.selectCount(queryWrapper1);
        return new Result(ResultCode.SUCCESS, cleanAndDryVo2Page, integer + integer1);

    }

    @Override
    public Result listByIdClean(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) {
        String id = paramsMap.get("id");
        return new Result(ResultCode.SUCCESS, cleanMapper.selectById(id));
    }

    //清洗和洗消的检测
    @Override
    public Result editClean(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) throws ParseException {
        String result = paramsMap.get("result");
        String id = paramsMap.get("id");
        String farmId = paramsMap.get("farmId");
        BillClean billClean = cleanMapper.selectById(id);
        QueryWrapper<BaseProcess> processQueryWrapper = new QueryWrapper<>();
        processQueryWrapper.eq("farm_id", farmId).eq("id", billClean.getProcessId());
        BaseProcess baseProcess = processMapper.selectOne(processQueryWrapper);//进程

        QueryWrapper<BaseLocation> locationQueryWrapper = new QueryWrapper<>();
        locationQueryWrapper.eq("id", billClean.getTestLocationId());
        BaseLocation baseLocation = locationMapper.selectOne(locationQueryWrapper);//当前洗消检测所在的位置
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");

        if (billClean.getBillStatus() != 0) {
            return new Result(10001, "该订单已通过，无需再次提交！", false);
        }
        if (billClean.getDestId() >= billClean.getTestLocationId()) { //说明当前不是目的地
            if ("1".equals(result)) {
                billClean.setBillStatus(1);
                billClean.setPassUserName(TokenSign.getUserNameByJwtToken(httpServletRequest));
                billClean.setPassUserId(TokenSign.getMemberIdByJwtToken(httpServletRequest));
                billClean.setTestLocation(baseLocation.getLocationName());
                billClean.setTestLocationId(baseLocation.getId());
                billClean.setPassDate(sdf.parse(sdf.format(new Date())));
                billClean.setCheckDate(sdf.parse(sdf.format(new Date())));

                //拉猪车结束
                if (billClean.getTestLocationId() == 15) {
                    baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + sdf.format(new Date()));
                    baseProcess.setCurrentLocation(baseProcess.getCurrentLocation());
                    baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId());
                    String status = baseProcess.getCurrentStatus();
                    String substring = status.substring(0, status.length() - 1);
                    baseProcess.setCurrentStatus(substring + "1");
                    baseProcess.setProcessType(1);
                    baseProcess.setAllLocationStatus("2,2,2");

                } else {
                    baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + sdf.format(new Date()));
                    baseProcess.setCurrentLocation(baseProcess.getCurrentLocation() + "," + baseLocation.getNextLocation());
                    baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId() + "," + baseLocation.getNextId());
                    String status = baseProcess.getCurrentStatus();
                    String substring = status.substring(0, status.length() - 1);
                    baseProcess.setCurrentStatus(substring + "1," + 0);
                }


                //环保车洗消合格生成烘干申请
                if (billClean.getTestLocationId() == 12 || billClean.getTestLocationId() == 13) {
                    BillDry billDry = new BillDry();
                    billDry.setVistitType(billClean.getVistitType());
                    billDry.setDestName(billClean.getDestName());
                    billDry.setDestId(billClean.getDestId());
                    billDry.setAdmissionUserName(billClean.getAdmissionUserName());
                    billDry.setAdmissionUserId(billClean.getAdmissionUserId());
                    billDry.setVistitDate(billClean.getVistitDate());
                    billDry.setSubDate(LocalDateTime.now());
                    billDry.setFarmId(billClean.getFarmId());
                    billDry.setBillStatus(0);
                    billDry.setProcessId(billClean.getProcessId());
                    billDry.setTestLocation(baseLocation.getLocationName());
                    billDry.setTestLocationId(baseLocation.getId());
                    billDry.setPhone(billClean.getPhone());
                    billDry.setCarNum(billClean.getCarNum());
                    billDry.setImgStatus(0);
                    dryMapper.insert(billDry);
                }
                //拉猪车洗消合格生成烘干申请

                if (billClean.getTestLocationId() == 15) {
                    QueryWrapper<BillClean> queryWrapper = new QueryWrapper<>();
                    queryWrapper.eq("farm_id", farmId).eq("process_id", baseProcess.getId());
                    List<BillClean> billCleans = cleanMapper.selectList(queryWrapper);
                    if (billCleans.size() == 1) {
                        BillDry billDry = new BillDry();
                        billDry.setVistitType(billClean.getVistitType());
                        billDry.setDestName(billClean.getDestName());
                        billDry.setDestId(billClean.getDestId());
                        billDry.setAdmissionUserName(billClean.getAdmissionUserName());
                        billDry.setAdmissionUserId(billClean.getAdmissionUserId());
                        billDry.setVistitDate(billClean.getVistitDate());
                        billDry.setSubDate(LocalDateTime.now());
                        billDry.setFarmId(billClean.getFarmId());
                        billDry.setBillStatus(0);
                        billDry.setProcessId(billClean.getProcessId());
                        billDry.setTestLocation(baseLocation.getLocationName());
                        billDry.setTestLocationId(baseLocation.getId());
                        billDry.setPhone(billClean.getPhone());
                        billDry.setCarNum(billClean.getCarNum());
                        billDry.setImgStatus(0);
                        baseProcess.setAllLocationStatus("2,1,0");
                        dryMapper.insert(billDry);
                    }
                }

                //送猪车洗消合格生成烘干申请
                if (billClean.getTestLocationId() == 17) {
                    BillDry billDry = new BillDry();
                    billDry.setVistitType(billClean.getVistitType());
                    billDry.setDestName(billClean.getDestName());
                    billDry.setDestId(billClean.getDestId());
                    billDry.setAdmissionUserName(billClean.getAdmissionUserName());
                    billDry.setAdmissionUserId(billClean.getAdmissionUserId());
                    billDry.setVistitDate(billClean.getVistitDate());
                    billDry.setSubDate(LocalDateTime.now());
                    billDry.setFarmId(billClean.getFarmId());
                    billDry.setBillStatus(0);
                    billDry.setProcessId(billClean.getProcessId());
                    billDry.setTestLocation(baseLocation.getLocationName());
                    billDry.setTestLocationId(baseLocation.getId());
                    billDry.setPhone(billClean.getPhone());
                    billDry.setCarNum(billClean.getCarNum());
                    billDry.setImgStatus(0);
                    String status1 = baseProcess.getAllLocationStatus();
                    String[] split = status1.split(",");
                    if (billClean.getTestLocationId() == 17) {
                        split[0] = "2";
                        split[1] = "1";
                        baseProcess.setAllLocationStatus(split[0] + "," + split[1] + status1.substring(3));
                    }
                    dryMapper.insert(billDry);
                }
                processMapper.updateById(baseProcess);
                cleanMapper.updateById(billClean);
                return new Result(10000, "修改成功！", true);
            } else {
                billClean.setBillStatus(2);
                billClean.setPassUserName(TokenSign.getUserNameByJwtToken(httpServletRequest));
                billClean.setPassUserId(TokenSign.getMemberIdByJwtToken(httpServletRequest));
                billClean.setTestLocation(baseLocation.getLocationName());
                billClean.setTestLocationId(baseLocation.getId());
                billClean.setPassDate(sdf.parse(sdf.format(new Date())));
                billClean.setCheckDate(sdf.parse(sdf.format(new Date())));
                billClean.setImgStatus(1);

                baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + sdf.format(new Date()));
                baseProcess.setCurrentLocation(baseProcess.getCurrentLocation());
                baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId());
                String status = baseProcess.getCurrentStatus();
                String substring = status.substring(0, status.length() - 1);

                String status1 = baseProcess.getAllLocationStatus();
                String[] split = status1.split(",");
                if (billClean.getTestLocationId() == 12) {
                    split[0] = "2";
                    split[1] = "3";
                    baseProcess.setAllLocationStatus(split[0] + "," + split[1] + status1.substring(3));
                }
                if (billClean.getTestLocationId() == 13) {
                    split[0] = "2";
                    split[1] = "2";
                    split[2] = "3";
                    baseProcess.setAllLocationStatus(split[0] + "," + split[1] + "," + split[2] + status1.substring(5));
                }

                if (billClean.getTestLocationId() == 15 || billClean.getTestLocationId() == 16) {
                    split[0] = "2";
                    split[1] = "3";
                    baseProcess.setAllLocationStatus(split[0] + "," + split[1] + status1.substring(3));
                }

                if (billClean.getTestLocationId() == 17) {
                    split[0] = "2";
                    split[1] = "3";
                    baseProcess.setAllLocationStatus(split[0] + "," + split[1] + status1.substring(3));
                }

                baseProcess.setCurrentStatus(substring + "2");
                baseProcess.setProcessType(2);

                processMapper.updateById(baseProcess);
                cleanMapper.updateById(billClean);
                return new Result(10000, "修改成功！", true);
            }
        } else {
            if ("1".equals(result)) {
                billClean.setBillStatus(1);
                billClean.setPassUserName(TokenSign.getUserNameByJwtToken(httpServletRequest));
                billClean.setPassUserId(TokenSign.getMemberIdByJwtToken(httpServletRequest));
                billClean.setTestLocation(baseLocation.getLocationName());
                billClean.setTestLocationId(baseLocation.getId());
                billClean.setPassDate(sdf.parse(sdf.format(new Date())));
                billClean.setCheckDate(sdf.parse(sdf.format(new Date())));

                baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + sdf.format(new Date()));
                baseProcess.setCurrentLocation(baseProcess.getCurrentLocation());
                baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId());
                String status = baseProcess.getCurrentStatus();
                String substring = status.substring(0, status.length() - 1);
                baseProcess.setCurrentStatus(substring + "1");
                baseProcess.setProcessType(1);
                if (billClean.getTestLocationId() == 15 || billClean.getDestId() == 16) {
                    baseProcess.setAllLocationStatus("2,2,0");
                }
                if (billClean.getTestLocationId() == 17) {
                    baseProcess.setAllLocationStatus("2,1");
                }
                processMapper.updateById(baseProcess);
                cleanMapper.updateById(billClean);
                return new Result(10000, "修改成功！", true);
            } else {
                baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + sdf.format(new Date()));
                baseProcess.setCurrentLocation(baseProcess.getCurrentLocation());
                baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId());
                String status = baseProcess.getCurrentStatus();
                String substring = status.substring(0, status.length() - 1);
                baseProcess.setCurrentStatus(substring + "2");
                baseProcess.setProcessType(2);
                billClean.setBillStatus(2);
                billClean.setPassUserName(TokenSign.getUserNameByJwtToken(httpServletRequest));
                billClean.setPassUserId(TokenSign.getMemberIdByJwtToken(httpServletRequest));
                billClean.setTestLocation(baseLocation.getLocationName());
                billClean.setTestLocationId(baseLocation.getId());
                billClean.setPassDate(sdf.parse(sdf.format(new Date())));
                billClean.setCheckDate(sdf.parse(sdf.format(new Date())));
                billClean.setImgStatus(1);

                String status1 = baseProcess.getAllLocationStatus();
                String[] split = status1.split(",");
                if (billClean.getTestLocationId() == 12) {
                    split[0] = "2";
                    split[1] = "3";
                    baseProcess.setAllLocationStatus(split[0] + "," + split[1] + status1.substring(3));
                }
                if (billClean.getTestLocationId() == 13) {
                    split[0] = "2";
                    split[1] = "2";
                    split[2] = "3";
                    baseProcess.setAllLocationStatus(split[0] + "," + split[1] + "," + split[2] + status1.substring(5));
                }
                if (billClean.getTestLocationId() == 17) {
                    split[0] = "2";
                    split[1] = "3";
                    baseProcess.setAllLocationStatus(split[0] + "," + split[1] + status1.substring(3));
                }
                if (billClean.getTestLocationId() == 15) {
                    split[0] = "2";
                    split[1] = "3";
                    baseProcess.setAllLocationStatus(split[0] + "," + split[1] + status1.substring(3));
                }

                processMapper.updateById(baseProcess);
                cleanMapper.updateById(billClean);
                return new Result(10000, "修改成功！", true);
            }

        }

    }

    //烘干检测
    @Override
    public Result editDry(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) throws ParseException {
        String result = paramsMap.get("result");
        String id = paramsMap.get("id");
        String farmId = paramsMap.get("farmId");
        BillDry billClean = dryMapper.selectById(id);
        QueryWrapper<BaseProcess> processQueryWrapper = new QueryWrapper<>();
        processQueryWrapper.eq("farm_id", farmId).eq("id", billClean.getProcessId());
        BaseProcess baseProcess = processMapper.selectOne(processQueryWrapper);//进程

        QueryWrapper<BaseLocation> locationQueryWrapper = new QueryWrapper<>();
        locationQueryWrapper.eq("id", billClean.getTestLocationId());
        BaseLocation baseLocation = locationMapper.selectOne(locationQueryWrapper);//当前洗消检测所在的位置
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
        if (billClean.getBillStatus() != 0) {
            return new Result(10001, "该订单已通过，无需再次提交！", false);
        }
        if (billClean.getDestId() >= billClean.getTestLocationId()) { //说明当前不是目的地
            if ("1".equals(result)) {
                billClean.setBillStatus(1);
                billClean.setPassUserName(TokenSign.getUserNameByJwtToken(httpServletRequest));
                billClean.setPassUserId(TokenSign.getMemberIdByJwtToken(httpServletRequest));
                billClean.setTestLocation(baseLocation.getLocationName());
                billClean.setTestLocationId(baseLocation.getId());
                billClean.setPassDate(sdf.parse(sdf.format(new Date())));
                billClean.setCheckDate(sdf.parse(sdf.format(new Date())));

                //最终结束
                if (billClean.getTestLocationId() == 13 || billClean.getTestLocationId() == 17 || billClean.getTestLocationId() == 43) {
                    baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + sdf.format(new Date()));
                    baseProcess.setCurrentLocation(baseProcess.getCurrentLocation());
                    baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId());
                    String status = baseProcess.getCurrentStatus();
                    String substring = status.substring(0, status.length() - 1);
                    baseProcess.setCurrentStatus(substring + "1");
                    baseProcess.setProcessType(1);
                    if (billClean.getTestLocationId() == 17) {
                        baseProcess.setAllLocationStatus("2,2,2");
                    }
                    if (billClean.getTestLocationId() == 13) {
                        baseProcess.setAllLocationStatus("2,2,2,2");
                    }
                } else {
                    baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + sdf.format(new Date()));
                    baseProcess.setCurrentLocation(baseProcess.getCurrentLocation() + "," + baseLocation.getNextLocation());
                    baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId() + "," + baseLocation.getNextId());
                    String status = baseProcess.getCurrentStatus();
                    String substring = status.substring(0, status.length() - 1);
                    baseProcess.setCurrentStatus(substring + "1," + 0);
                }

                //环保车烘干合格生成洗消申请
                if (billClean.getTestLocationId() == 12 && baseProcess.getDestId() > 12) {

                    BillClean clean = new BillClean();
                    clean.setVistitType(billClean.getVistitType());
                    clean.setDestName(billClean.getDestName());
                    clean.setDestId(billClean.getDestId());
                    clean.setAdmissionUserName(billClean.getAdmissionUserName());
                    clean.setAdmissionUserId(billClean.getAdmissionUserId());
                    clean.setVistitDate(billClean.getVistitDate());
                    clean.setSubDate(LocalDateTime.now());
                    clean.setFarmId(billClean.getFarmId());
                    clean.setBillStatus(0);
                    clean.setProcessId(billClean.getProcessId());
                    clean.setTestLocationId(baseLocation.getNextId());
                    clean.setTestLocation(baseLocation.getNextLocation());
                    clean.setPhone(billClean.getPhone());
                    clean.setCarNum(billClean.getCarNum());
                    clean.setImgStatus(0);
                    cleanMapper.insert(clean);
                    if (billClean.getDestId() == 13) {
                        baseProcess.setAllLocationStatus("2,2,1");
                    } else {
                        baseProcess.setAllLocationStatus("2,2,1,0");
                    }

                }

                if (billClean.getTestLocationId() == 12 && baseProcess.getDestId() == 12) {
                    baseProcess.setAllLocationStatus("2,2");
                }

                //拉猪车烘干合格生成洗消申请
                if (billClean.getTestLocationId() == 15) {
                    BillClean clean = new BillClean();
                    clean.setVistitType(billClean.getVistitType());
                    clean.setDestName(billClean.getDestName());
                    clean.setDestId(billClean.getDestId());
                    clean.setAdmissionUserName(billClean.getAdmissionUserName());
                    clean.setAdmissionUserId(billClean.getAdmissionUserId());
                    clean.setVistitDate(billClean.getVistitDate());
                    clean.setSubDate(LocalDateTime.now());
                    clean.setFarmId(billClean.getFarmId());
                    clean.setBillStatus(0);
                    clean.setProcessId(billClean.getProcessId());
                    clean.setTestLocationId(baseLocation.getId());
                    clean.setTestLocation(baseLocation.getLocationName());
                    clean.setPhone(billClean.getPhone());
                    clean.setCarNum(billClean.getCarNum());
                    clean.setImgStatus(0);
                    baseProcess.setAllLocationStatus("2,1,0");
                    cleanMapper.insert(clean);
                }

                processMapper.updateById(baseProcess);
                dryMapper.updateById(billClean);
                return new Result(10000, "修改成功！", true);
            } else {
                billClean.setBillStatus(2);
                billClean.setPassUserName(TokenSign.getUserNameByJwtToken(httpServletRequest));
                billClean.setPassUserId(TokenSign.getMemberIdByJwtToken(httpServletRequest));
                billClean.setTestLocation(baseLocation.getLocationName());
                billClean.setTestLocationId(baseLocation.getId());
                billClean.setPassDate(sdf.parse(sdf.format(new Date())));
                billClean.setCheckDate(sdf.parse(sdf.format(new Date())));
                billClean.setImgStatus(1);

                baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + sdf.format(new Date()));
                baseProcess.setCurrentLocation(baseProcess.getCurrentLocation());
                baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId());
                String status = baseProcess.getCurrentStatus();
                String substring = status.substring(0, status.length() - 1);

                String status1 = baseProcess.getAllLocationStatus();
                String[] split = status1.split(",");
                if (billClean.getTestLocationId() == 12) {
                    split[0] = "2";
                    split[1] = "3";
                    baseProcess.setAllLocationStatus(split[0] + "," + split[1] + status1.substring(3));
                }
                if (billClean.getTestLocationId() == 13) {
                    split[0] = "2";
                    split[1] = "2";
                    split[2] = "3";
                    baseProcess.setAllLocationStatus(split[0] + "," + split[1] + "," + split[2] + status1.substring(5));
                }

                if (billClean.getTestLocationId() == 15) {
                    split[0] = "2";
                    split[1] = "3";
                    baseProcess.setAllLocationStatus(split[0] + "," + split[1] + status1.substring(3));
                }
                if (billClean.getTestLocationId() == 17) {
                    split[0] = "2";
                    split[1] = "3";
                    baseProcess.setAllLocationStatus(split[0] + "," + split[1] + status1.substring(3));
                }

                baseProcess.setCurrentStatus(substring + "2");
                baseProcess.setProcessType(2);
                processMapper.updateById(baseProcess);
                dryMapper.updateById(billClean);
                return new Result(10000, "修改成功！", true);
            }
        } else {
            if ("1".equals(result)) {
                billClean.setBillStatus(1);
                billClean.setPassUserName(TokenSign.getUserNameByJwtToken(httpServletRequest));
                billClean.setPassUserId(TokenSign.getMemberIdByJwtToken(httpServletRequest));
                billClean.setTestLocation(baseLocation.getLocationName());
                billClean.setTestLocationId(baseLocation.getId());
                billClean.setPassDate(sdf.parse(sdf.format(new Date())));
                billClean.setCheckDate(sdf.parse(sdf.format(new Date())));

                baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + sdf.format(new Date()));
                baseProcess.setCurrentLocation(baseProcess.getCurrentLocation());
                baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId());
                String status = baseProcess.getCurrentStatus();
                String substring = status.substring(0, status.length() - 1);
                baseProcess.setCurrentStatus(substring + "1");
                baseProcess.setProcessType(1);

                if (billClean.getTestLocationId() == 15) {
                    baseProcess.setAllLocationStatus("2,1,0");
                }

                if (billClean.getTestLocationId() == 12) {
                    baseProcess.setAllLocationStatus("2,2");
                }
                if (billClean.getTestLocationId() == 13) {
                    baseProcess.setAllLocationStatus("2,2,2");
                }
                if (billClean.getTestLocationId() == 17) {
                    baseProcess.setAllLocationStatus("2,1,0");
                }
                processMapper.updateById(baseProcess);
                dryMapper.updateById(billClean);
                return new Result(10000, "修改成功！", true);
            } else {
                baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + sdf.format(new Date()));
                baseProcess.setCurrentLocation(baseProcess.getCurrentLocation());
                baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId());
                String status = baseProcess.getCurrentStatus();
                String substring = status.substring(0, status.length() - 1);
                baseProcess.setCurrentStatus(substring + "2");
                baseProcess.setProcessType(2);
                billClean.setBillStatus(2);
                billClean.setPassUserName(TokenSign.getUserNameByJwtToken(httpServletRequest));
                billClean.setPassUserId(TokenSign.getMemberIdByJwtToken(httpServletRequest));
                billClean.setTestLocation(baseLocation.getLocationName());
                billClean.setTestLocationId(baseLocation.getId());
                billClean.setPassDate(sdf.parse(sdf.format(new Date())));
                billClean.setCheckDate(sdf.parse(sdf.format(new Date())));
                billClean.setImgStatus(1);

                String status1 = baseProcess.getAllLocationStatus();
                String[] split = status1.split(",");
                if (billClean.getTestLocationId() == 12) {
                    split[0] = "2";

                    split[1] = "3";
                    baseProcess.setAllLocationStatus(split[0] + "," + split[1] + status1.substring(3));
                }
                if (billClean.getTestLocationId() == 13) {
                    split[0] = "2";
                    split[1] = "2";
                    split[2] = "3";
                    baseProcess.setAllLocationStatus(split[0] + "," + split[1] + "," + split[2] + status1.substring(5));
                }
                if (billClean.getTestLocationId() == 15) {
                    split[0] = "2";
                    split[1] = "3";
                    baseProcess.setAllLocationStatus(split[0] + "," + split[1] + status1.substring(3));
                }

                if (billClean.getTestLocationId() == 17) {
                    split[0] = "2";
                    split[1] = "3";
                    baseProcess.setAllLocationStatus(split[0] + "," + split[1] + status1.substring(3));
                }

                processMapper.updateById(baseProcess);
                dryMapper.updateById(billClean);
                return new Result(10000, "修改成功！", true);
            }


        }
    }

}