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;
    @Autowired
    private BaseWashoutPointMapper baseWashoutPointMapper;
    @Autowired
    private BillSamplingMapper billSamplingMapper;
    @Autowired
    private BillCleanBeforeMapper billCleanBeforeMapper;
    @Autowired
    private FlowUtil flowUtil;

    @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, String departureId, String departureName) 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);
            }
        }
        BaseWashoutPoint baseWashoutPoint1 = baseWashoutPointMapper.selectOne(new QueryWrapper<BaseWashoutPoint>().lambda().eq(BaseWashoutPoint::getLocationId, departureId).like(BaseWashoutPoint::getFarmIds, farmId).eq(BaseWashoutPoint::getVisitingType, vistitType));
        BaseWashoutPoint baseWashoutPoint2 = baseWashoutPointMapper.selectOne(new QueryWrapper<BaseWashoutPoint>().lambda().eq(BaseWashoutPoint::getLocationId, destId).like(BaseWashoutPoint::getFarmIds, farmId).eq(BaseWashoutPoint::getVisitingType, vistitType));
        if (!departureId.equals("0")){
            if (baseWashoutPoint1.getPointLevel()>baseWashoutPoint2.getPointLevel()){
                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.setDepartureName(departureName);
        billPersonnelAdmission.setDepartureId(Integer.valueOf(departureId));
        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");

        String allLocation = departureName;
        String allLocationId = departureId;
        String allLocationStatus = "0";
        String allFlowId = "";

        List<BaseWashoutPoint> baseWashoutPoints = new ArrayList<>();
        if (ObjectUtil.isEmpty(baseWashoutPoint1)){
            baseWashoutPoints = baseWashoutPointMapper.selectList(new QueryWrapper<BaseWashoutPoint>().lambda().le(BaseWashoutPoint::getPointLevel,baseWashoutPoint2.getPointLevel()).eq(BaseWashoutPoint::getVisitingType, vistitType).like(BaseWashoutPoint::getFarmIds, farmId).orderByAsc(BaseWashoutPoint::getPointLevel));
        }else {
            baseWashoutPoints = baseWashoutPointMapper.selectList(new QueryWrapper<BaseWashoutPoint>().lambda().le(BaseWashoutPoint::getPointLevel,baseWashoutPoint2.getPointLevel()).eq(BaseWashoutPoint::getVisitingType, vistitType).like(BaseWashoutPoint::getFarmIds, farmId).ge(BaseWashoutPoint::getPointLevel,baseWashoutPoint1.getPointLevel()).orderByAsc(BaseWashoutPoint::getPointLevel));
        }
        for (BaseWashoutPoint baseWashoutPoint : baseWashoutPoints) {
            allLocation = allLocation + "," + baseLocationMapper.selectById(baseWashoutPoint.getLocationId()).getLocationName();
            allLocationId = allLocationId + "," + baseWashoutPoint.getLocationId();
            allLocationStatus = allLocationStatus + "," + "0";
            allFlowId = allFlowId + "0," + baseWashoutPoint.getFlowList();

            allLocation = allLocation + "," + baseWashoutPoint.getTailLocationName();
            allLocationId = allLocationId + "," + "0";
            allLocationStatus = allLocationStatus + "," + "0";
            if (!baseWashoutPoint.equals(baseWashoutPoints.get(baseWashoutPoints.size() - 1))) {
                allFlowId = allFlowId + ",";
            }
        }
        baseProcess.setAllLocation(allLocation);
        baseProcess.setAllLocationId(allLocationId);
        baseProcess.setAllLocationStatus(allLocationStatus);
        baseProcess.setAllFlowId(allFlowId+",0");
        baseProcess.setCurrentFlowId("0");
        baseProcess.setCurrentLocation("场外");
        baseProcess.setCurrentLocationId("0");
        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")) {
            //拒绝
            billPersonnelAdmission.setBillStatus(2);
            baseProcess.setProcessType(2);
            baseProcess.setCurrentStatus("2");
            String status = baseProcess.getAllLocationStatus();
            String[] split1 = status.split(",");
            split1[0] = "3";
            baseProcess.setAllLocationStatus(split1[0] + status.substring(1));
        } else {
            if (billPersonnelAdmission.getBillStatus() != 0) {
                return new Result(10001, "该订单已通过，无需再次点击！", false);
            }
            //通过
            billPersonnelAdmission.setBillStatus(1);

            //获取下一步位置
            String allLocationId = baseProcess.getAllLocationId();
            String[] strings = allLocationId.split(",");
            String nextLocationId = strings[1];
            BaseLocation baseLocation = baseLocationMapper.selectById(nextLocationId);

            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));
                String[] split2 = baseProcess.getAllFlowId().split(",");
                String nextFlowId = split2[baseProcess.getCurrentFlowId().split(",").length];
                baseProcess.setCurrentFlowId(baseProcess.getCurrentFlowId() + "," + nextFlowId);

                if (Integer.valueOf(nextFlowId) == 1){
                    BillSampling billSampling = (BillSampling) flowUtil.getEntity(Integer.valueOf(nextFlowId),
                            billPersonnelAdmission.getVistitType(),
                            billPersonnelAdmission.getDestName(),
                            billPersonnelAdmission.getDestId(),
                            billPersonnelAdmission.getAdmissionUserId(),
                            billPersonnelAdmission.getAdmissionUserName(),
                            billPersonnelAdmission.getPhone(),
                            billPersonnelAdmission.getVistitDate(),
                            baseLocation.getId(),
                            baseLocation.getLocationName(),
                            billPersonnelAdmission.getFarmId(),
                            baseProcess.getId(),
                            billPersonnelAdmission.getDepartureName(),
                            billPersonnelAdmission.getDepartureId());
                    if (ObjectUtil.isNotEmpty(billPersonnelAdmission.getCarNum())){
                        billSampling.setCarNum(billPersonnelAdmission.getCarNum());
                    }
                    billSamplingMapper.insert(billSampling);
                }else if (Integer.valueOf(nextFlowId) == 2){
                    BillPcr billPcr = (BillPcr) flowUtil.getEntity(Integer.valueOf(nextFlowId),
                            billPersonnelAdmission.getVistitType(),
                            billPersonnelAdmission.getDestName(),
                            billPersonnelAdmission.getDestId(),
                            billPersonnelAdmission.getAdmissionUserId(),
                            billPersonnelAdmission.getAdmissionUserName(),
                            billPersonnelAdmission.getPhone(),
                            billPersonnelAdmission.getVistitDate(),
                            baseLocation.getId(),
                            baseLocation.getLocationName(),
                            billPersonnelAdmission.getFarmId(),
                            baseProcess.getId(),
                            billPersonnelAdmission.getDepartureName(),
                            billPersonnelAdmission.getDepartureId());
                    if (ObjectUtil.isNotEmpty(billPersonnelAdmission.getCarNum())){
                        billPcr.setCarNum(billPersonnelAdmission.getCarNum());
                    }
                    pcrMapper.insert(billPcr);
                }else if (Integer.valueOf(nextFlowId) == 3){
                    BillClean billClean = (BillClean) flowUtil.getEntity(Integer.valueOf(nextFlowId),
                            billPersonnelAdmission.getVistitType(),
                            billPersonnelAdmission.getDestName(),
                            billPersonnelAdmission.getDestId(),
                            billPersonnelAdmission.getAdmissionUserId(),
                            billPersonnelAdmission.getAdmissionUserName(),
                            billPersonnelAdmission.getPhone(),
                            billPersonnelAdmission.getVistitDate(),
                            baseLocation.getId(),
                            baseLocation.getLocationName(),
                            billPersonnelAdmission.getFarmId(),
                            baseProcess.getId(),
                            billPersonnelAdmission.getDepartureName(),
                            billPersonnelAdmission.getDepartureId());
                    if (ObjectUtil.isNotEmpty(billPersonnelAdmission.getCarNum())){
                        billClean.setCarNum(billPersonnelAdmission.getCarNum());
                    }
                    cleanMapper.insert(billClean);
                }else if (Integer.valueOf(nextFlowId) == 4){
                    BillIsolate billIsolate = (BillIsolate) flowUtil.getEntity(Integer.valueOf(nextFlowId),
                            billPersonnelAdmission.getVistitType(),
                            billPersonnelAdmission.getDestName(),
                            billPersonnelAdmission.getDestId(),
                            billPersonnelAdmission.getAdmissionUserId(),
                            billPersonnelAdmission.getAdmissionUserName(),
                            billPersonnelAdmission.getPhone(),
                            billPersonnelAdmission.getVistitDate(),
                            baseLocation.getId(),
                            baseLocation.getLocationName(),
                            billPersonnelAdmission.getFarmId(),
                            baseProcess.getId(),
                            billPersonnelAdmission.getDepartureName(),
                            billPersonnelAdmission.getDepartureId());
                    billIsolateMapper.insert(billIsolate);
                }else if (Integer.valueOf(nextFlowId) == 5){
                    BillDry billDry = (BillDry) flowUtil.getEntity(Integer.valueOf(nextFlowId),
                            billPersonnelAdmission.getVistitType(),
                            billPersonnelAdmission.getDestName(),
                            billPersonnelAdmission.getDestId(),
                            billPersonnelAdmission.getAdmissionUserId(),
                            billPersonnelAdmission.getAdmissionUserName(),
                            billPersonnelAdmission.getPhone(),
                            billPersonnelAdmission.getVistitDate(),
                            baseLocation.getId(),
                            baseLocation.getLocationName(),
                            billPersonnelAdmission.getFarmId(),
                            baseProcess.getId(),
                            billPersonnelAdmission.getDepartureName(),
                            billPersonnelAdmission.getDepartureId());
                    dryMapper.insert(billDry);
                }else {
                    BillCleanBefore billCleanBefore = (BillCleanBefore) flowUtil.getEntity(Integer.valueOf(nextFlowId),
                            billPersonnelAdmission.getVistitType(),
                            billPersonnelAdmission.getDestName(),
                            billPersonnelAdmission.getDestId(),
                            billPersonnelAdmission.getAdmissionUserId(),
                            billPersonnelAdmission.getAdmissionUserName(),
                            billPersonnelAdmission.getPhone(),
                            billPersonnelAdmission.getVistitDate(),
                            baseLocation.getId(),
                            baseLocation.getLocationName(),
                            billPersonnelAdmission.getFarmId(),
                            baseProcess.getId(),
                            billPersonnelAdmission.getDepartureName(),
                            billPersonnelAdmission.getDepartureId());
                    if (ObjectUtil.isNotEmpty(billPersonnelAdmission.getCarNum())){
                        billCleanBefore.setCarNum(billPersonnelAdmission.getCarNum());
                    }
                    billCleanBeforeMapper.insert(billCleanBefore);
                }
            } else {
                baseProcess.setCurrentStatus("1");
                baseProcess.setProcessType(1);
                baseProcess.setAllLocationStatus("2");
                //TODO 紧急入场通过先不处理
            }

            //通过生成门禁白名单
            QueryWrapper<DeviceList> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("farm_id", billPersonnelAdmission.getFarmId()).eq("location_id", strings[strings.length - 1]);
            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";
                    String savePath = "/opt/huatong/test.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("face", FileUtil.file(savePath));
                    jsonObject.put("name", billPersonnelAdmission.getAdmissionUserName());
                    jsonObject.put("password", "123456");
                    jsonObject.put("timestamp", date1.getTime());
                    jsonObject.put("uid", billPersonnelAdmission.getAdmissionUserId());
                    String post = HttpRequest.post("http://39.173.90.137: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://39.173.90.137: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);
                    if (data.size() > 0) {
                        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://39.173.90.137: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://39.173.90.137: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;
    @Autowired
    private BillSamplingMapper samplingMapper;
    @Autowired
    private BillCleanBeforeMapper beforeMapper;

    @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检测所在的位置

        String allLocationId = baseProcess.getAllLocationId();//所有的位置id
        String allFlowId = baseProcess.getAllFlowId();//所有的流程id
        String currentFlowId = baseProcess.getCurrentFlowId();//当前已经完成的流程id
        String substring1 = allFlowId.substring(currentFlowId.length() + 1, allFlowId.length());
        String[] split = substring1.split(",");
        Integer nextId = Integer.parseInt(split[0]);
        if (baseProcess.getProcessType() == 2 || baseProcess.getProcessType() == 1) {
            return new Result(10001, "修改失败！该申请已提前结束或者被拒绝", false);
        } 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));

                Object newObject = BillPcrServiceImpl.getNewObject(nextId, billPcr.getDestName(), billPcr.getDestId(), billPcr.getAdmissionUserName(),
                        billPcr.getAdmissionUserId(), billPcr.getVistitDate(), billPcr.getSubDate(),
                        billPcr.getProcessId(), billPcr.getFarmId(), billPcr.getTestLocation(), billPcr.getTestLocationId(),billPcr.getVistitType(),
                        billPcr.getPhone(),billPcr.getDepartureName(),billPcr.getDepartureId());
                if (nextId == 0) {
                    int index = allLocationId.indexOf(baseLocation.getId());
                    StringBuilder status = new StringBuilder(baseProcess.getAllLocationId());
                    status.setCharAt(index, '1');
                    status.setCharAt(index + 2, '1');
                    baseProcess.setAllLocationStatus(status.toString());
                } else if (nextId == 1) {
                    //新增采样
                    BillSampling sampling = (BillSampling) newObject;
                    samplingMapper.insert(sampling);
                } else if (nextId == 2) {
                    //新增pcr
                    BillPcr billClean = (BillPcr) newObject;
                    pcrMapper.insert(billClean);
                } else if (nextId == 3) {
                    //新增洗澡
                    BillClean billClean = (BillClean) newObject;
                    cleanMapper.insert(billClean);
                } else if (nextId == 4) {
                    //新增隔离
                } else if (nextId == 5) {
                    BillDry billClean = (BillDry) newObject;
                    dryMapper.insert(billClean);
                    //新增烘干
                } else if (nextId == 6) {
                    //新增洗澡前拍照
                    BillCleanBefore before = (BillCleanBefore) newObject;
                    beforeMapper.insert(before);
                }

                baseProcess.setUpdateDate(baseProcess.getUpdateDate() + "," + sdf.format(new Date()));
                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();
                StringBuilder sb = new StringBuilder(status1);
                Integer a = status1.length() - 3;
                sb.setCharAt(a, '3');
                baseProcess.setAllLocationStatus(sb.toString());

                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) throws IOException {
        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);

        /*这个地方是人员下发进入生产区洗澡前的一个人脸门禁，可以直接写死 等后期生产区划分后再修改*/
/*        //通过生成门禁白名单
        QueryWrapper<DeviceList> deviceListQueryWrapper = new QueryWrapper<>();
        deviceListQueryWrapper.eq("farm_id", isolate.getFarmId()).eq("location_id", 5);
        List<DeviceList> deviceLists = deviceListMapper.selectList(deviceListQueryWrapper);
        //找到对应的入场申请表
        QueryWrapper<BillPersonnelAdmission> queryWrapper1 = new QueryWrapper<>();
        queryWrapper1.eq("farm_id", isolate.getFarmId()).eq("process_id", isolate.getProcessId());
        BillPersonnelAdmission billPersonnelAdmission = billPersonnelAdmissionMapper.selectOne(queryWrapper1);
        if (deviceLists.size() > 0) {
            for (DeviceList deviceList : deviceLists) {
                //通过生成门禁白名单
                PeopleList peopleList = new PeopleList();
                peopleList.setFarmId(isolate.getFarmId().toString());
                peopleList.setDeviceCode(deviceList.getDeviceCode());
                peopleList.setUserId(isolate.getAdmissionUserId());
                peopleList.setUserName(isolate.getAdmissionUserName());
                peopleList.setPassword("123456");
                peopleList.setType(0);
                peopleList.setCreateTime(new Date());
                Date date2 = new Date();
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(date2);
                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";
                String savePath = "/opt/huatong/test.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("face", FileUtil.file(savePath));
                jsonObject.put("name", billPersonnelAdmission.getAdmissionUserName());
                jsonObject.put("password", "123456");
                jsonObject.put("timestamp", date1.getTime());
                jsonObject.put("uid", billPersonnelAdmission.getAdmissionUserId());
                String post = HttpRequest.post("http://39.173.90.137:8040/addDeviceUser")
                        .header(Header.CONTENT_TYPE, "multipart/form-data")
                        .form(jsonObject)
                        .timeout(30 * 1000).execute().body();
                System.out.println(post);
            }
        }*/
        return new Result(10000, "提交成功！", true);
    }

    @Override
    @Transactional
    public Result editIsolate(HttpServletRequest httpServletRequest, Map<String, String> paramsMap) throws ParseException {
        String id = paramsMap.get("id");
        String farmId = paramsMap.get("farmId");
        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);//当前隔离所在的位置

        String allLocationId = baseProcess.getAllLocationId();//所有的位置id
        String allFlowId = baseProcess.getAllFlowId();//所有的流程id
        String currentFlowId = baseProcess.getCurrentFlowId();//当前已经完成的流程id
        String substring1 = allFlowId.substring(currentFlowId.length() + 1, allFlowId.length());
        String[] splits = substring1.split(",");
        Integer nextId = Integer.parseInt(splits[0]);
        Object newObject = BillPcrServiceImpl.getNewObject(nextId, billIsolate.getDestName(), billIsolate.getDestId(), billIsolate.getAdmissionUserName(),
                billIsolate.getAdmissionUserId(), billIsolate.getVistitDate(), billIsolate.getSubDate(),
                billIsolate.getProcessId(), billIsolate.getFarmId(), billIsolate.getIsolateLocation(), billIsolate.getIsolateLocationId(),
                billIsolate.getVistitType(),billIsolate.getPhone(),billIsolate.getDepartureName(),billIsolate.getDepartureId());
        if (nextId == 0) {
            if (StringUtils.isBlank(splits[1])) {
                baseProcess.setProcessType(1);
                if (allLocationId.length() > 5) {
                    baseProcess.setAllLocationStatus("2,2,2,2,2");
                } else {
                    baseProcess.setAllLocationStatus("2,2,2");
                }
            } else {
                String[] strings = allLocationId.split(",");
                Integer index = 0;
                for (int i = 0; i < strings.length; i++) {
                    if ((baseLocation.getId().toString()).equals(strings[i])) {
                        index = i;
                    }
                }
                QueryWrapper<BaseLocation> queryWrapper1 = new QueryWrapper();
                queryWrapper1.eq("id", strings[index + 2]);
                BaseLocation location = locationMapper.selectOne(queryWrapper1);
                FlowUtil flowUtil = new FlowUtil();
                Object entity = flowUtil.getEntity(Integer.parseInt(splits[1]), billIsolate.getVistitType(), billIsolate.getDestName()
                        , billIsolate.getDestId(), billIsolate.getAdmissionUserId(), billIsolate.getAdmissionUserName(), billIsolate.getPhone(),
                        billIsolate.getVistitDate(), location.getId(), location.getLocationName(), Integer.parseInt(farmId)
                        , baseProcess.getId(), billIsolate.getDepartureName(), billIsolate.getDepartureId());
                if (Integer.parseInt(splits[1]) == 1) {
                    //新增采样
                    BillSampling billSampling = (BillSampling) entity;
                    samplingMapper.insert(billSampling);
                } else if (Integer.parseInt(splits[1]) == 2) {
                    //新增pcr
                    BillPcr billClean = (BillPcr) entity;
                    pcrMapper.insert(billClean);
                } else if (Integer.parseInt(splits[1]) == 3) {
                    //新增洗澡
                    BillClean billClean = (BillClean) entity;
                    cleanMapper.insert(billClean);
                } else if (Integer.parseInt(splits[1]) == 4) {
                    //新增隔离
                    BillIsolate pcr = (BillIsolate) entity;
                    isolateMapper.insert(pcr);
                } else if (Integer.parseInt(splits[1]) == 5) {
                    BillDry billClean = (BillDry) entity;
                    dryMapper.insert(billClean);
                    //新增烘干
                } else if (Integer.parseInt(splits[1]) == 6) {
                    //新增洗澡前拍照
                    BillCleanBefore before = (BillCleanBefore) entity;
                    beforeMapper.insert(before);
                }
                baseProcess.setCurrentFlowId(baseProcess.getCurrentFlowId() + "," + nextId + "," + splits[1]);
            }
        } else if (nextId == 1) {
            //新增采样
            BillSampling billSampling = (BillSampling) newObject;
            samplingMapper.insert(billSampling);
            baseProcess.setCurrentFlowId(baseProcess.getCurrentFlowId() + "," + nextId);
        }else if (nextId == 2) {
            //新增pcr
            BillPcr pcr = (BillPcr) newObject;
            pcrMapper.insert(pcr);
            baseProcess.setCurrentFlowId(baseProcess.getCurrentFlowId() + "," + nextId);
        }else if (nextId == 3) {
            //新增洗澡
            BillClean pcr = (BillClean) newObject;
            cleanMapper.insert(pcr);
            baseProcess.setCurrentFlowId(baseProcess.getCurrentFlowId() + "," + nextId);
        }else if (nextId == 4) {
            //新增隔离
            BillIsolate pcr = (BillIsolate) newObject;
            isolateMapper.insert(pcr);
            baseProcess.setCurrentFlowId(baseProcess.getCurrentFlowId() + "," + nextId);
        }else if (nextId == 5) {
            BillDry pcr = (BillDry) newObject;
            dryMapper.insert(pcr);
            baseProcess.setCurrentFlowId(baseProcess.getCurrentFlowId() + "," + nextId);
            //新增烘干
        }else if (nextId == 6) {
            //新增洗澡前拍照
            BillCleanBefore before = (BillCleanBefore) newObject;
            beforeMapper.insert(before);
            baseProcess.setCurrentFlowId(baseProcess.getCurrentFlowId() + "," + nextId);
        }

        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());


        //提前结束隔离
        baseProcess.setProcessType(1);
        baseProcess.setCurrentLocation(baseProcess.getCurrentLocation());
        baseProcess.setCurrentLocationId(baseProcess.getCurrentLocationId());
        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 + "小时";
        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);



        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);
            }


        }
    }

}