package com.zhgd.xmgl.call;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import cn.xuyanwu.spring.file.storage.FileStorageService;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.zhgd.jeecg.common.api.vo.Result;
import com.zhgd.jeecg.common.execption.OpenAlertException;
import com.zhgd.jeecg.common.execption.OpenPromptException;
import com.zhgd.redis.lock.RedisRepository;
import com.zhgd.xmgl.async.AsyncAiAnalyse;
import com.zhgd.xmgl.async.AsyncHikvision;
import com.zhgd.xmgl.base.*;
import com.zhgd.xmgl.call.entity.ChargeDeletionParam;
import com.zhgd.xmgl.constant.Cts;
import com.zhgd.xmgl.modules.basicdata.entity.SystemUser;
import com.zhgd.xmgl.modules.basicdata.service.ISystemUserService;
import com.zhgd.xmgl.modules.basicdata.service.UploadFileService;
import com.zhgd.xmgl.modules.basicdata.service.impl.NoticeServiceImpl;
import com.zhgd.xmgl.modules.car.entity.CarCamera;
import com.zhgd.xmgl.modules.car.entity.CarInfo;
import com.zhgd.xmgl.modules.car.entity.CarPassRecord;
import com.zhgd.xmgl.modules.car.enums.CarInfoCarModuleTypeEnum;
import com.zhgd.xmgl.modules.car.mapper.CarCameraMapper;
import com.zhgd.xmgl.modules.car.mapper.CarInfoMapper;
import com.zhgd.xmgl.modules.car.mapper.CarPassRecordMapper;
import com.zhgd.xmgl.modules.car.mapper.CarTypeMapper;
import com.zhgd.xmgl.modules.car.service.impl.CarInfoServiceImpl;
import com.zhgd.xmgl.modules.car.service.impl.CarPassRecordServiceImpl;
import com.zhgd.xmgl.modules.frontierprotectionnonet.entity.FrontierProtectionNoNetData;
import com.zhgd.xmgl.modules.frontierprotectionnonet.mapper.FrontierProtectionNoNetDevMapper;
import com.zhgd.xmgl.modules.frontierprotectionnonet.service.IFrontierProtectionNoNetDevService;
import com.zhgd.xmgl.modules.frontierprotectionnonet.service.impl.FrontierProtectionNoNetDataServiceImpl;
import com.zhgd.xmgl.modules.project.entity.Project;
import com.zhgd.xmgl.modules.project.entity.vo.ProjectInfoExtVo;
import com.zhgd.xmgl.modules.project.mapper.ProjectMapper;
import com.zhgd.xmgl.modules.project.service.IProjectUfaceConfigService;
import com.zhgd.xmgl.modules.project.service.impl.ProjectServiceImpl;
import com.zhgd.xmgl.modules.video.entity.AiAnalyseHardWareAlarmRecord;
import com.zhgd.xmgl.modules.video.entity.AiAnalyseHardWareRecord;
import com.zhgd.xmgl.modules.video.mapper.AiAnalyseHardWareAlarmRecordMapper;
import com.zhgd.xmgl.modules.video.mapper.AiAnalyseHardWareRecordMapper;
import com.zhgd.xmgl.modules.video.service.IAiAnalyseHardWareAlarmRecordService;
import com.zhgd.xmgl.modules.video.service.IAiAnalyseHardWareRecordService;
import com.zhgd.xmgl.modules.worker.entity.*;
import com.zhgd.xmgl.modules.worker.enums.WorkerInfoPersonTypeEnum;
import com.zhgd.xmgl.modules.worker.mapper.EnterpriseInfoMapper;
import com.zhgd.xmgl.modules.worker.mapper.UfaceDevMapper;
import com.zhgd.xmgl.modules.worker.mapper.WorkerAttendanceMapper;
import com.zhgd.xmgl.modules.worker.mapper.WorkerInfoMapper;
import com.zhgd.xmgl.modules.worker.service.IUfaceDevService;
import com.zhgd.xmgl.modules.worker.service.IWorkerAttendancePresenceService;
import com.zhgd.xmgl.modules.worker.service.IWorkerAttendanceService;
import com.zhgd.xmgl.modules.worker.service.impl.EnterpriseInfoServiceImpl;
import com.zhgd.xmgl.modules.worker.service.impl.WorkerAttendanceServiceImpl;
import com.zhgd.xmgl.modules.xz.entity.XzHikvisionSync;
import com.zhgd.xmgl.modules.xz.enums.XzHikvisionSyncBigTypeEnum;
import com.zhgd.xmgl.modules.xz.enums.XzHikvisionSyncOperateEnum;
import com.zhgd.xmgl.modules.xz.mapper.XzHikvisionCompareDataMapper;
import com.zhgd.xmgl.modules.xz.mapper.XzHikvisionSyncMapper;
import com.zhgd.xmgl.modules.xz.service.IXzHikvisionCompareDataService;
import com.zhgd.xmgl.modules.xz.service.impl.XzHikvisionSyncServiceImpl;
import com.zhgd.xmgl.security.entity.UserInfo;
import com.zhgd.xmgl.util.*;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
import org.jetbrains.annotations.NotNull;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Lazy;
import org.springframework.scheduling.annotation.Async;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import springfox.documentation.annotations.ApiIgnore;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

@Slf4j
@RestController
@RequestMapping("/xmgl/hikvision")
public class HikvisionCall {
    public static final String SUC_CODE = "0";
    public static final String EVENT_IAS = "event_ias";
    public static final String X_00052102 = "0x00052102";
    public static final String CODE = "code";
    public static final String X_00072202 = "0x00072202";
    public static final String X_02_E_33900 = "0x02e33900";
    public static final String X_02_E_33400 = "0x02e33400";
    public static final String X_00072003 = "0x00072003";
    public static final String X_00052301 = "0x00052301";
    public static final String MSG = "msg";
    public static final String DATA = "data";
    public static final String X_00072002 = "0x00072002";
    public static final String FAIL = "失败";
    public static final String SUC = "成功";
    public static final String X_15403007 = "0x15403007";
    public static final String X_02401033 = "0x02401033";
    public static final String LIST = "list";
    public static final String EVENT_PMS = "event_pms";
    public static final String EVENT_VSS = "event_vss";
    private static final String FIXED_CAR_GROUP_NAME = "业主车辆";
    public AsyncHikvision asyncHikvision;
    @Autowired
    XzHikvisionSyncServiceImpl xzHikvisionSyncService;
    @Lazy
    @Autowired
    UploadFileService uploadFileService;
    @Lazy
    @Autowired
    ProjectServiceImpl projectService;
    @Lazy
    @Autowired
    FileStorageService fileStorageService;
    @Lazy
    @Autowired
    CarPassRecordServiceImpl carPassRecordService;
    @Lazy
    @Autowired
    HikvisionCall hikvisionCall;
    @Lazy
    @Autowired
    CarInfoServiceImpl carInfoService;
    @Autowired
    @Lazy
    EnterpriseInfoServiceImpl enterpriseInfoService;
    @Lazy
    @Autowired
    private XzHikvisionCompareDataMapper xzHikvisionCompareDataMapper;
    @Lazy
    @Autowired
    private AiAnalyseHardWareAlarmRecordMapper aiAnalyseHardWareAlarmRecordMapper;
    @Lazy
    @Autowired
    private AsyncAiAnalyse asyncAiAnalyse;
    @Value("${upload.image.url.prefix:}")
    private String imageUrlPrefix;
    @Value("${basePath:}")
    private String basePath;
    @Autowired
    @Lazy
    private ProjectMapper projectMapper;
    @Autowired
    @Lazy
    private RedisRepository redisRepository;
    @Autowired
    @Lazy
    private EnterpriseInfoMapper enterpriseInfoMapper;
    @Autowired
    @Lazy
    private NoticeServiceImpl noticeService;
    @Autowired
    @Lazy
    private IWorkerAttendanceService workerAttendanceService;
    @Autowired
    @Lazy
    private WorkerAttendanceMapper workerAttendanceMapper;
    @Autowired
    @Lazy
    private IWorkerAttendancePresenceService workerAttendancePresenceService;
    @Autowired
    @Lazy
    private WorkerInfoMapper workerInfoMapper;
    @Autowired
    @Lazy
    private CarCameraMapper carCameraMapper;
    @Autowired
    @Lazy
    private CarPassRecordMapper carPassRecordMapper;
    @Autowired
    @Lazy
    private CarTypeMapper carTypeMapper;
    @Autowired
    @Lazy
    private CarInfoMapper carInfoMapper;
    @Autowired
    @Lazy
    private WorkerAttendanceServiceImpl workerAttendanceServiceImpl;
    @Autowired
    private UfaceDevMapper ufaceDevMapper;
    @Autowired
    private XzHikvisionSyncMapper xzHikvisionSyncMapper;
    @Autowired
    private IAiAnalyseHardWareRecordService aiAnalyseHardWareRecordService;
    @Autowired
    private IFrontierProtectionNoNetDevService frontierProtectionNoNetDevService;
    @Lazy
    @Autowired
    private IAiAnalyseHardWareAlarmRecordService aiAnalyseHardWareAlarmRecordService;
    @Lazy
    @Autowired
    private AiAnalyseHardWareRecordMapper aiAnalyseHardWareRecordMapper;
    @Lazy
    @Autowired
    private FrontierProtectionNoNetDevMapper frontierProtectionNoNetDevMapper;
    @Lazy
    @Autowired
    private FrontierProtectionNoNetDataServiceImpl frontierProtectionNoNetDataService;
    @Lazy
    @Autowired
    private IXzHikvisionCompareDataService xzHikvisionCompareDataService;
    @Lazy
    @Resource
    private IUfaceDevService ufaceDevService;
    @Lazy
    @Resource
    private IProjectUfaceConfigService projectUfaceConfigService;
    @Lazy
    @Autowired
    private ISystemUserService systemUserService;

    /**
     * 获取图片
     *
     * @param rq
     * @param artemisConfigHost
     * @param artemisConfigAppKey
     * @param artemisConfigAppSecret
     * @return
     */
    public static String getHikvisionEventsPicture(HikvisionEventsPictureRq rq, String artemisConfigHost, String
            artemisConfigAppKey, String artemisConfigAppSecret) throws Exception {
        if (StrUtil.isBlank(rq.getPicUri()) || StrUtil.isBlank(rq.getSvrIndexCode())) {
            return null;
        }
        final String artemisPath = "/artemis";
        final String path = artemisPath + "/api/video/v1/events/picture";
        String host = "https://" + artemisConfigHost;
        String body = JSONObject.toJSONString(rq);
        String rs = HikvisionUtil.doPost(host, path, body, null, artemisConfigAppKey, artemisConfigAppSecret);
        JSONObject rsJo = JSONObject.parseObject(rs);
        String code = rsJo.getString(CODE);
        if (Objects.equals(code, SUC_CODE)) {
            return rsJo.getJSONObject(DATA).getString("picUrl");
        }
        return null;
    }

    public static String getWorkerJson(WorkerInfo workerInfo) {
        JSONObject jsonBody = new JSONObject();
        jsonBody.put("personId", workerInfo.getId());
        jsonBody.put("personName", workerInfo.getWorkerName());
        jsonBody.put("gender", workerInfo.getSex());
        jsonBody.put("orgIndexCode", getOrgIndexCode(workerInfo));
        jsonBody.put("birthday", workerInfo.getBirthday());
        jsonBody.put("phoneNo", workerInfo.getPhoneNumber());
        jsonBody.put("email", workerInfo.getPersonMail());
        jsonBody.put("certificateType", "111");
        jsonBody.put("certificateNo", workerInfo.getIdCard());
        jsonBody.put("jobNo", workerInfo.getPersonSn());
        return jsonBody.toJSONString();
    }

    private static String getOrgIndexCode(WorkerInfo workerInfo) {
        if (workerInfo == null) {
            return null;
        }
        if (Objects.equals(workerInfo.getPersonType(), WorkerInfoPersonTypeEnum.LW.getValue())) {
            return String.valueOf(workerInfo.getTeamId());
        } else if (Objects.equals(workerInfo.getPersonType(), WorkerInfoPersonTypeEnum.GL.getValue())) {
            return String.valueOf(workerInfo.getDepartmentId());
        } else if (Objects.equals(workerInfo.getPersonType(), WorkerInfoPersonTypeEnum.LS.getValue())) {
            return String.valueOf(workerInfo.getProjectSn());
        }
        return null;
    }

    @ApiOperation(value = "海康事件回调", notes = "海康事件回调", httpMethod = "POST")
    @PostMapping(value = "/eventCallback")
    public Result eventCallback(@ApiIgnore @RequestBody JSONObject jsonObject) {
        log.info("海康事件回调:{}", JSON.toJSONString(jsonObject));
        String method = jsonObject.getString("method");
        String ability1 = jsonObject.getString("ability");
        String onEventNotify = "OnEventNotify";
        if (Objects.equals(method, onEventNotify)) {
            JSONObject paramsJo = jsonObject.getJSONObject("params");
            String ability = paramsJo.getString("ability");
            String eventAcs = "event_acs";
            if (Objects.equals(ability, eventAcs)) {
                log.info("人员通行记录事件");
                //人员通行记录
                JSONArray eventsJa = paramsJo.getJSONArray("events");
                if (eventsJa != null) {
                    for (int i = 0; i < eventsJa.size(); i++) {
                        JSONObject jo1 = eventsJa.getJSONObject(i);
                        JSONObject dataJo = jo1.getJSONObject(DATA);
                        String extEventPersonNo = dataJo.getString("ExtEventPersonNo");
                        WorkerInfo workerInfo = workerInfoMapper.selectById(extEventPersonNo);
                        if (workerInfo == null) {
                            log.info("未找到该人员信息,extEventPersonNo:{}", extEventPersonNo);
                            return Result.error("未找到该人员信息,extEventPersonNo:" + extEventPersonNo);
                        }
                        String happenTime = jo1.getString("happenTime");
                        String extEventCardNo = dataJo.getString("ExtEventCardNo");
                        String srcIndex = jo1.getString("srcIndex");
                        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, workerInfo.getProjectSn()));
                        String idCard = workerInfo.getIdCard();
                        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
                            log.info("未配置，idCard:{},extEventCardNo:{}", idCard, extEventCardNo);
                            return Result.error("未配置，idCard:" + idCard + ",extEventCardNo:" + extEventCardNo);
                        }
                        QueryWrapper<UfaceDev> devQueryWrapper = new QueryWrapper<>();
                        devQueryWrapper.lambda().eq(UfaceDev::getDevSn, srcIndex).eq(UfaceDev::getProjectSn, workerInfo.getProjectSn());
                        UfaceDev ufaceDev = ufaceDevMapper.selectOne(devQueryWrapper);
                        if (ufaceDev == null) {
                            log.error("请先上传对应设备信息，idCard:{},devSN:{}", idCard, srcIndex);
                            return Result.error("请先上传对应设备信息，idCard:" + idCard + ",extEventCardNo:" + extEventCardNo);
                        }
                        String time = DateUtil.formatDateTime(DateUtil.parse(happenTime));
                        Integer count = workerAttendanceMapper.selectCount(new LambdaQueryWrapper<WorkerAttendance>()
                                .eq(WorkerAttendance::getPersonSn, workerInfo.getPersonSn())
                                .eq(WorkerAttendance::getCreateTime, time)
                        );
                        if (count != 0) {
                            continue;
                        }
                        int passType = workerAttendanceServiceImpl.getPassType(ufaceDev, time);
                        hikvisionCall.saveEventCallbackAttendanceAsync(dataJo, workerInfo, srcIndex, project, idCard, time, passType);
                    }
                }
            } else if (Objects.equals(ability, EVENT_PMS)) {
                log.info("车辆出入场事件");
                //车辆入场压线（放行）、出场压线（放行）
                JSONArray eventsJa = paramsJo.getJSONArray("events");
                if (eventsJa != null) {
                    for (int i = 0; i < eventsJa.size(); i++) {
                        JSONObject jo1 = eventsJa.getJSONObject(i);
                        JSONObject dataJo = jo1.getJSONObject(DATA);
                        Integer status = jo1.getInteger("status");
                        String srcIndex = jo1.getString("srcIndex");
                        Long eventType = jo1.getLong("eventType");
                        String plateNo = dataJo.getString("plateNo");
                        if (!Objects.equals(status, 5)) {
                            log.info("status!=5没有图片的不记录,cameraId:{}，plateNo：{}", srcIndex, plateNo);
                            continue;
                        }
                        CarCamera carCamera = carCameraMapper.selectOne(new LambdaQueryWrapper<CarCamera>()
                                .eq(CarCamera::getCameraId, srcIndex));
                        if (carCamera == null) {
                            log.info("海康回调车辆相机设备不存在：CameraId:{}", srcIndex);
                            return Result.error("海康回调车辆相机设备不存在：CameraId:" + srcIndex);
                        }
                        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, carCamera.getProjectSn()));
                        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
                            String cameraId = carCamera.getCameraId();
                            log.info("海康事件车辆入场压线的project不存在,cameraId:{}", cameraId);
                            return Result.error("海康事件车辆入场压线的project不存在,cameraId:" + cameraId);
                        }

                        String time = DateUtil.formatDateTime(DateUtil.parse(dataJo.getString("time")));
                        if (eventType == 771760134 || eventType == 771760131) {
                            //出入场放行，不通过这个判断车辆是否通行
                            //CarPassRecord carPassRecord = carPassRecordMapper.getNewestlineBreakingEvent(plateNo, time);
                            //if (carPassRecord == null) {
                            //    log.info("海康回调出入场放行的压线不存在：plateNo:{}", plateNo);
                            //    return Result.error("");
                            //}
                            //carPassRecord.setIsOpen(1);
                            //carPassRecordMapper.updateById(carPassRecord);
                        } else if (eventType == 771760130 || eventType == 771760133) {
                            //压线事件
                            hikvisionCall.saveEventCallbackCarPassRecordAsync(dataJo, srcIndex, plateNo, carCamera, project, time);
                        }
                    }
                }
            } else if (Objects.equals(ability, EVENT_IAS)) {
                addFrontierProtectionNoNetData(paramsJo);

            } else if (Objects.equals(ability, "")) {
                log.info("告警=======" + paramsJo);
                JSONArray eventsArray = paramsJo.getJSONArray("events");
                if (eventsArray.size() > 0) {
                    JSONObject dataEvent = eventsArray.getJSONObject(0);
                    JSONArray eventDetails = dataEvent.getJSONArray("eventDetails");
                    JSONObject eventDetail = eventDetails.getJSONObject(0);
                    ability = eventDetail.getString("ability");
                    if (Objects.equals(ability, EVENT_VSS)) {
                        log.info("AI识别告警=======" + paramsJo);
                        //摄像机名称
                        String srcName = eventDetail.getString("srcName");
                        //422000003
                        String eventType = eventDetail.getString("eventType");
                        JSONObject data = eventDetail.getJSONObject(DATA);
                        //海康AI图片地址
                        String imageUrl = data.getString("url");
                        //海康AI图片地址
                        String srcIndex = eventDetail.getString("srcIndex");
                        AiAnalyseHardWareRecord dev = aiAnalyseHardWareRecordMapper.selectOne(new LambdaQueryWrapper<AiAnalyseHardWareRecord>()
                                .eq(AiAnalyseHardWareRecord::getHardwareId, srcIndex));
                        if (dev == null) {
                            log.error("未查到AI识别告警设备，设备id：{}", srcIndex);
                            return null;
                        }
                        hikvisionCall.saveEventCallbackAiAsync(dataEvent, srcName, eventType, imageUrl, srcIndex, dev);
                    } else if (Objects.equals(ability, EVENT_IAS)) {
                        log.info("临边防护告警=======" + paramsJo);
                        String srcName = eventDetail.getString("srcName");
                        String srcParentIndex = dataEvent.getString("srcParentIndex");
                        String happenTime = dataEvent.getString("happenTime");
                        String ds = srcName + "报警";
                        FrontierProtectionNoNetData data1 = new FrontierProtectionNoNetData();
                        data1.setDevSn(srcParentIndex);
                        data1.setAlarmTime(DateUtil.parse(happenTime));
                        data1.setDeviceStatus(1);
                        data1.setDetailStatus(ds);
                        data1.setDescription(ds);
                        frontierProtectionNoNetDataService.add(data1);
                    }
                }
            }
        } else if (Objects.equals(ability1, EVENT_IAS)) {
            addFrontierProtectionNoNetData(jsonObject);
        }
        return Result.ok();
    }

    /**
     * 添加红外对射预警数据
     *
     * @param paramsJo
     */
    private void addFrontierProtectionNoNetData(JSONObject paramsJo) {
        log.info("临边防护告警事件========" + paramsJo);
        JSONArray eventsJa = paramsJo.getJSONArray("events");
        JSONObject dataEvent = eventsJa.getJSONObject(0);
        hikvisionCall.saveEventCallbackIasAsync(dataEvent);
    }

    /**
     * 异步添加红外对射预警数据
     *
     * @param dataEvent
     */
    @Async("saveEventCallbackAiAsync")
    public void saveEventCallbackIasAsync(JSONObject dataEvent) {
        String devCode = dataEvent.getString("srcIndex");
        String happenTime = dataEvent.getString("happenTime");
        Date createTime = DateUtil.parse(happenTime);
        Integer count = frontierProtectionNoNetDataService.count(new LambdaQueryWrapper<FrontierProtectionNoNetData>()
                .eq(FrontierProtectionNoNetData::getCreateTime, createTime)
                .eq(FrontierProtectionNoNetData::getDevSn, devCode));
        if (count > 0) {
            log.info("重复的红外对射预警数据不保存，deviceID：{},createTime:{}", devCode, createTime);
            return;
        }
        FrontierProtectionNoNetData data1 = new FrontierProtectionNoNetData();
        data1.setDevSn(devCode);
        data1.setAlarmTime(DateUtil.parse(happenTime));
        data1.setDeviceStatus(1);
        data1.setDetailStatus(dataEvent.getString("srcName") + "-" + dataEvent.getString(DATA));
        data1.setDescription(data1.getDescription());
        frontierProtectionNoNetDataService.add(data1);
    }

    /**
     * 异步添加ai数据
     *
     * @param dataEvent
     * @param srcName
     * @param eventType
     * @param imageUrl
     * @param deviceId
     * @param dev
     */
    @Async("saveEventCallbackAiAsync")
    public void saveEventCallbackAiAsync(JSONObject dataEvent, String srcName, String eventType, String imageUrl, String deviceId, AiAnalyseHardWareRecord dev) {
        String happenTime = dataEvent.getString("happenTime");
        String createTime = DateUtil.formatDateTime(DateUtil.parse(happenTime));
        Integer count = aiAnalyseHardWareAlarmRecordMapper.selectCount(new LambdaQueryWrapper<AiAnalyseHardWareAlarmRecord>()
                .eq(AiAnalyseHardWareAlarmRecord::getCreateTime, createTime)
                .eq(AiAnalyseHardWareAlarmRecord::getHardwareId, deviceId)
        );
        if (count > 0) {
            log.info("重复的ai预警数据不保存，deviceID：{},createTime:{}", deviceId, createTime);
            return;
        }
        ProjectInfoExtVo projectInfoBySn = projectService.getProjectInfoBySn(dev.getProjectSn());
        AiAnalyseHardWareAlarmRecord record = new AiAnalyseHardWareAlarmRecord();
        record.setCreateTime(createTime);
        record.setAlarmType(Integer.valueOf(eventType));
        record.setHardwareId(deviceId);
        record.setHardwareName(dev.getHardwareName());
        record.setLocation(srcName);
        record.setAlarmDesc(record.getLocation());
        record.setProjectSn(dev.getProjectSn());
        record.setStatus(1);
        String relativePath = projectInfoBySn.getProjectName() + "/" + DateUtil.today();
        try {
            record.setImageUrl(uploadFileService.uploadUrlReturnFileName(imageUrl, relativePath));
        } catch (Exception e) {
            log.error("ai预警图片保存失败：", e);
        }
        aiAnalyseHardWareAlarmRecordMapper.insert(record);
        //将数据通过MQTT转发到前台
        asyncAiAnalyse.sendAiAnalyse(record, Cts.PROJECT_LEVEL_AND_CHILDREN);
    }

    /***
     * 异步添加车辆通行数据
     * @param dataJo
     * @param srcIndex
     * @param plateNo
     * @param carCamera
     * @param project
     * @param time
     */
    @Async("saveEventCallbackCarPassRecord")
    public void saveEventCallbackCarPassRecordAsync(JSONObject dataJo, String srcIndex, String plateNo, CarCamera carCamera, Project project, String time) {
        CarPassRecord carPassRecord = new CarPassRecord();
        carPassRecord.setCarNumber(plateNo);
        carPassRecord.setType(getPassType(carCamera.getPassType()));
        carPassRecord.setPassTime(time);
        LambdaQueryWrapper<CarPassRecord> queryWrapper = new LambdaQueryWrapper<CarPassRecord>()
                .eq(CarPassRecord::getCarNumber, plateNo)
                .eq(CarPassRecord::getPassTime, time);
        Integer count = carPassRecordMapper.selectCount(queryWrapper);
        if (count != 0) {
            log.info("重复的车辆通行的数据不保存，plateNo：{},time:{}", plateNo, time);
            return;
        }
        try {
            //车牌
            JSONObject picUrlJo = dataJo.getJSONObject("picUrl");
            String svrIndex = dataJo.getString("svrIndex");
            String vehiclePicUrl = picUrlJo.getString("vehiclePicUrl");
            String platePicUrl = picUrlJo.getString("platePicUrl");
            if (StringUtils.isNotBlank(platePicUrl)) {
                carPassRecord.setImageUrl(saveToLocal(getHikvisionEventsPicture(new HikvisionEventsPictureRq(svrIndex, platePicUrl), project.getArtemisConfigHost(), project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret())));
            }
            if (StringUtils.isNotBlank(vehiclePicUrl)) {
                carPassRecord.setPanoramaUrl(saveToLocal(getHikvisionEventsPicture(new HikvisionEventsPictureRq(svrIndex, vehiclePicUrl), project.getArtemisConfigHost(), project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret())));
            }
        } catch (Exception e) {
            log.error("error：", e);
        }

        carPassRecord.setCarColor(getCarColor(dataJo.getInteger("plateColor")));
        carPassRecord.setLocation(carCamera.getCameraName());
        carPassRecord.setProjectSn(carCamera.getProjectSn());
        carPassRecord.setColor(getColor(dataJo.getInteger("vehicleColor")));
        carPassRecord.setCameraId(srcIndex);
        List<CarInfo> carInfos = carInfoMapper.selectList(new LambdaQueryWrapper<CarInfo>()
                .eq(CarInfo::getProjectSn, carCamera.getProjectSn())
                .eq(CarInfo::getCarNumber, plateNo)
                .eq(CarInfo::getIsBlack, 0)
        );
        if (CollUtil.isNotEmpty(carInfos)) {
            carPassRecord.setIsOpen(1);
        } else {
            carPassRecord.setIsOpen(0);
        }
        carPassRecordMapper.insert(carPassRecord);
        //车进场后，意味着绑定的司机走过了人脸机，统计为在场人员。车辆出场后，在场人员随之减少
        if (carInfos.size() != 0 && carInfos.get(0) != null
                && (StringUtils.isNotEmpty(carInfos.get(0).getDriverWorkerId()) || StringUtils.isNotEmpty(carInfos.get(0).getOutsideDriverIdCard()))) {
            log.info("保存车辆绑定的司机的通行数据，车牌号：{}", carInfos.get(0).getCarNumber());
            carPassRecordService.saveDriverPassData(carPassRecord, carInfos.get(0));
        }
    }

    /**
     * 异步保存人员通行数据
     *
     * @param dataJo
     * @param workerInfo
     * @param srcIndex
     * @param project
     * @param idCard
     * @param time
     * @param passType
     */
    @Async("saveEventCallbackAttendance")
    public void saveEventCallbackAttendanceAsync(JSONObject dataJo, WorkerInfo workerInfo, String srcIndex, Project project, String idCard, String time, int passType) {
        HashMap<String, Object> map = new HashMap<>(16);
        map.put("passTime", time);
        map.put("idCard", idCard);
        map.put("attendanceNumber", workerInfo.getAttendanceNumber());
        map.put("direction", passType);
        map.put("passType", 2);
        map.put("projectCode", workerInfo.getProjectSn());
        map.put("devCode", srcIndex);
        Integer count = workerAttendanceMapper.selectCount(new LambdaQueryWrapper<WorkerAttendance>()
                .eq(WorkerAttendance::getCreateTime, time)
                .eq(WorkerAttendance::getPersonSn, workerInfo.getPersonSn())
        );
        if (count != 0) {
            log.info("重复的人员通行的数据不保存，idCard：{},time:{}", idCard, time);
            return;
        }
        try {
            String extEventPictureUrl = dataJo.getString("ExtEventPictureURL");
            String svrIndexCode = dataJo.getString("svrIndexCode");
            HikvisionEventsPictureRq rq = new HikvisionEventsPictureRq();
            rq.setPicUri(extEventPictureUrl);
            rq.setSvrIndexCode(svrIndexCode);
            map.put("faceUrl", saveToLocal(getHikvisionEventsPicture(rq, project.getArtemisConfigHost(), project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret())));
        } catch (Exception e) {
            log.error("error：", e);
        }
        workerAttendanceService.saveExternalPassRecord(map);
    }

    @ApiOperation(value = "按事件类型订阅事件", notes = "按事件类型订阅事件", httpMethod = "POST")
    @PostMapping(value = "/subscribeEvent")
    public Result subscribeEvent(@ApiIgnore @RequestBody SubscribeEventQo qo) throws Exception {
        final String artemisPath = "/artemis";
        final String path = artemisPath + "/api/eventService/v1/eventSubscriptionByEventTypes";
        String host = "https://" + qo.getArtemisConfigHost();
        String rs = HikvisionUtil.doPost(host, path, JSON.toJSONString(qo), null, qo.getArtemisConfigAppKey(), qo.getArtemisConfigAppSecret());
        return Result.ok();
    }

    @ApiOperation(value = "服务挂了主动获取门禁点事件的人员通行记录", notes = "服务挂了主动获取门禁点事件的人员通行记录", httpMethod = "POST")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "projectSn", value = "项目sn", paramType = "body", required = false, dataType = "String"),
            @ApiImplicitParam(name = "startTime", value = "开始时间", paramType = "body", required = true, dataType = "String"),
            @ApiImplicitParam(name = "endTime", value = "结束时间", paramType = "body", required = true, dataType = "String"),
    })
    @PostMapping(value = "/getDoorEvents")
    public Result getDoorEvents(@ApiIgnore @RequestBody HashMap<String, Object> paramMap) {
        String startTime = MapUtils.getString(paramMap, "startTime");
        String endTime = MapUtils.getString(paramMap, "endTime");
        DateUtils.checkLegalDate19(startTime);
        DateUtils.checkLegalDate19(endTime);
        JSONObject param = new JSONObject();
        param.put("startTime", DateUtils.getISO8601Str(DateUtil.parse(startTime)));
        param.put("endTime", DateUtils.getISO8601Str(DateUtil.parse(endTime)));
        String projectSn = MapUtils.getString(paramMap, "projectSn");
        LambdaQueryWrapper<Project> queryWrapper = new LambdaQueryWrapper<Project>()
                .eq(Project::getSyncHikvision, 1);
        if (StringUtils.isNotBlank(projectSn)) {
            queryWrapper.eq(Project::getProjectSn, projectSn);
        }
        List<Project> projects = projectMapper.selectList(queryWrapper);
        if (CollUtil.isEmpty(projects)) {
            return Result.error("项目未配置海康同步功能");
        }
        getDoorEventsAsync(startTime, endTime, param, projectSn, projects);
        return Result.ok("已在后台同步人员数据，请耐心等待！");
    }

    /**
     * 获取门禁事件的数据
     *
     * @param startTime
     * @param endTime
     * @param param
     * @param projectSn
     * @param projects
     */
    @Async("getDoorEvents")
    public void getDoorEventsAsync(String startTime, String endTime, JSONObject param, String projectSn, List<Project> projects) {
        for (Project project : projects) {
            List<UfaceDev> ufaceDevs = ufaceDevMapper.selectList(new LambdaQueryWrapper<UfaceDev>()
                    .eq(UfaceDev::getProjectSn, project.getProjectSn()));
            for (UfaceDev ufaceDev : ufaceDevs) {
                param.put("doorIndexCodes", Collections.singletonList(ufaceDev.getDevSn()));
                param.put(Cts.PAGE_NO, 0);
                param.put("pageSize", 1000);
                Integer total = 0;
                JSONArray listJa = new JSONArray();
                do {
                    String rs = null;
                    param.put("pageNo", param.getIntValue("pageNo") + 1);
                    try {
                        rs = HikvisionUtil.getDoorEvents(project, param);
                    } catch (Exception e) {
                        log.error("err:", e);
                        return;
                    }
                    JSONObject joData = HikvisionUtil.getJsonObjectData(rs);
                    if (joData != null) {
                        total = joData.getInteger("total");
                        if (!Objects.equals(total, 0)) {
                            listJa = joData.getJSONArray(LIST);
                            for (int i = 0; i < listJa.size(); i++) {
                                JSONObject listJo = listJa.getJSONObject(i);
                                String eventTime = listJo.getString("eventTime");
                                String personId = listJo.getString("personId");
                                String personName = listJo.getString("personName");
                                String doorIndexCode = listJo.getString("doorIndexCode");
                                String picUri = listJo.getString("picUri");
                                String svrIndexCode = listJo.getString("svrIndexCode");
                                WorkerInfo workerInfo = workerInfoMapper.selectById(personId);
                                if (workerInfo == null) {
                                    log.error("未找到该人员信息,personName:{}", personName);
                                    continue;
                                }
                                HashMap<String, Object> map = new HashMap<>(16);
                                String time = DateUtil.formatDateTime(DateUtil.parse(eventTime));
                                map.put("passTime", time);
                                map.put("idCard", workerInfo.getIdCard());
                                map.put("attendanceNumber", workerInfo.getAttendanceNumber());
                                int passType = workerAttendanceServiceImpl.getPassType(ufaceDev, time);
                                map.put("direction", passType);
                                map.put("passType", 2);
                                map.put("projectCode", workerInfo.getProjectSn());
                                map.put("devCode", doorIndexCode);
                                Integer count = workerAttendanceMapper.selectCount(new LambdaQueryWrapper<WorkerAttendance>()
                                        .eq(WorkerAttendance::getCreateTime, time)
                                        .eq(WorkerAttendance::getPersonSn, workerInfo.getPersonSn())
                                );
                                if (count != 0) {
                                    log.info("重复的人员通行的数据不保存，idCard：{},time:{}", workerInfo.getIdCard(), time);
                                    continue;
                                }
                                try {
                                    HikvisionEventsPictureRq rq = new HikvisionEventsPictureRq();
                                    rq.setPicUri(picUri);
                                    rq.setSvrIndexCode(svrIndexCode);
                                    map.put("faceUrl", saveToLocal(getHikvisionEventsPicture(rq, project.getArtemisConfigHost(), project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret())));
                                } catch (Exception e) {
                                    log.error("主动获取人脸图片失败>", e);
                                }
                                workerAttendanceService.saveExternalPassRecord(map);
                            }
                        }
                    }
                } while (total > param.getInteger(Cts.PAGE_NO) * 1000);
            }
        }
        log.info("服务挂了主动获取门禁点事件的人员通行记录执行完成，startTime：{}，endTime：{}", startTime, endTime);
    }

    @ApiOperation(value = "服务挂了主动获取查询过车记录", notes = "服务挂了主动获取查询过车记录", httpMethod = "POST")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "projectSn", value = "项目sn", paramType = "body", required = false, dataType = "String"),
            @ApiImplicitParam(name = "startTime", value = "开始时间", paramType = "body", required = true, dataType = "String"),
            @ApiImplicitParam(name = "endTime", value = "结束时间", paramType = "body", required = true, dataType = "String"),
    })
    @PostMapping(value = "/getCrossRecords")
    public Result getCrossRecords(@ApiIgnore @RequestBody HashMap<String, Object> paramMap) {
        String startTime = MapUtils.getString(paramMap, "startTime");
        String endTime = MapUtils.getString(paramMap, "endTime");
        DateUtils.checkLegalDate19(startTime);
        DateUtils.checkLegalDate19(endTime);
        JSONObject param = new JSONObject();
        param.put("startTime", DateUtils.getISO8601Str(DateUtil.parse(startTime)));
        param.put("endTime", DateUtils.getISO8601Str(DateUtil.parse(endTime)));
        String projectSn = MapUtils.getString(paramMap, "projectSn");
        LambdaQueryWrapper<Project> queryWrapper = new LambdaQueryWrapper<Project>()
                .eq(Project::getSyncHikvision, 1);
        if (StringUtils.isNotBlank(projectSn)) {
            queryWrapper.eq(Project::getProjectSn, projectSn);
        }
        List<Project> projects = projectMapper.selectList(queryWrapper);
        if (CollUtil.isEmpty(projects)) {
            return Result.error("项目未配置海康同步功能");
        }
        hikvisionCall.getCrossRecordsAsync(startTime, endTime, param, projects);
        return Result.ok("已在后台同步车辆通行数据，请耐心等待！");
    }

    /**
     * 异步同步车辆通行数据
     *
     * @param startTime
     * @param endTime
     * @param param
     * @param projects
     */
    @Async("getCrossRecords")
    public void getCrossRecordsAsync(String startTime, String endTime, JSONObject param, List<Project> projects) {
        for (Project project : projects) {
            String projectParkCode = null;
            try {
                projectParkCode = HikvisionUtil.getProjectParkCode(project);
            } catch (Exception e) {
                log.error("err:", e);
                return;
            }
            param.put("parkSyscode", projectParkCode);
            Integer total = 0;
            JSONArray listJa = new JSONArray();
            param.put(Cts.PAGE_NO, 0);
            do {
                String rs = null;
                param.put(Cts.PAGE_NO, param.getIntValue(Cts.PAGE_NO) + 1);
                try {
                    rs = HikvisionUtil.getCrossRecords(project, param);
                } catch (Exception e) {
                    log.error("err:", e);
                    return;
                }
                JSONObject joData = HikvisionUtil.getJsonObjectData(rs);
                if (joData != null) {
                    total = joData.getInteger("total");
                    if (!Objects.equals(total, 0)) {
                        listJa = joData.getJSONArray(LIST);
                        for (int i = 0; i < listJa.size(); i++) {
                            JSONObject listJo = listJa.getJSONObject(i);
                            String plateNo = listJo.getString("plateNo");
                            String roadwaySyscode = listJo.getString("roadwaySyscode");
                            String aswSyscode = listJo.getString("aswSyscode");
                            String crossTime = listJo.getString("crossTime");
                            String time = DateUtil.formatDateTime(DateUtil.parse(crossTime));
                            String plateNoPicUri = listJo.getString("plateNoPicUri");
                            String vehiclePicUri = listJo.getString("vehiclePicUri");
                            CarCamera carCamera = carCameraMapper.selectOne(new LambdaQueryWrapper<CarCamera>()
                                    .eq(CarCamera::getCameraId, roadwaySyscode));
                            if (carCamera == null) {
                                log.info("海康车辆相机设备不存在：CameraId:{}", roadwaySyscode);
                                continue;
                            }
                            CarPassRecord carPassRecord = new CarPassRecord();
                            carPassRecord.setCarNumber(plateNo);
                            carPassRecord.setType(getPassType(carCamera.getPassType()));
                            carPassRecord.setPassTime(time);
                            LambdaQueryWrapper<CarPassRecord> queryWrapper = new LambdaQueryWrapper<CarPassRecord>()
                                    .eq(CarPassRecord::getCarNumber, plateNo)
                                    .eq(CarPassRecord::getPassTime, time);
                            Integer count = carPassRecordMapper.selectCount(queryWrapper);
                            if (count != 0) {
                                log.info("重复的车辆通行的数据不保存，plateNo：{},time:{}", plateNo, time);
                                continue;
                            }
                            try {
                                //车牌
                                carPassRecord.setImageUrl(saveToLocal(getHikvisionEventsPicture(new HikvisionEventsPictureRq(aswSyscode, plateNoPicUri), project.getArtemisConfigHost(), project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret())));
                                carPassRecord.setPanoramaUrl(saveToLocal(getHikvisionEventsPicture(new HikvisionEventsPictureRq(aswSyscode, vehiclePicUri), project.getArtemisConfigHost(), project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret())));
                            } catch (Exception e) {
                                log.error("error：", e);
                            }

                            carPassRecord.setCarColor(getCarColor(listJo.getInteger("plateColor")));
                            carPassRecord.setLocation(carCamera.getCameraName());
                            carPassRecord.setProjectSn(carCamera.getProjectSn());
                            carPassRecord.setColor(getColor(listJo.getInteger("vehicleColor")));
                            carPassRecord.setCameraId(roadwaySyscode);
                            List<CarInfo> carInfos = carInfoMapper.selectList(new LambdaQueryWrapper<CarInfo>()
                                    .eq(CarInfo::getProjectSn, carCamera.getProjectSn())
                                    .eq(CarInfo::getCarNumber, plateNo)
                                    .eq(CarInfo::getIsBlack, 0)
                            );
                            if (CollUtil.isNotEmpty(carInfos)) {
                                carPassRecord.setIsOpen(1);
                            } else {
                                carPassRecord.setIsOpen(0);
                            }
                            carPassRecordMapper.insert(carPassRecord);
                            //车进场后，意味着绑定的司机走过了人脸机，统计为在场人员。车辆出场后，在场人员随之减少
                            if (carInfos.size() != 0 && carInfos.get(0) != null
                                    && (StringUtils.isNotEmpty(carInfos.get(0).getDriverWorkerId()) || StringUtils.isNotEmpty(carInfos.get(0).getOutsideDriverIdCard()))) {
                                log.info("保存车辆绑定的司机的通行数据，车牌号：{}", carInfos.get(0).getCarNumber());
                                carPassRecordService.saveDriverPassData(carPassRecord, carInfos.get(0));
                            }
                        }
                    }
                }
            } while (total > param.getInteger(Cts.PAGE_NO) * 1000);
        }
        log.info("服务挂了主动获取车辆事件的车辆通行记录执行完成，startTime：{}，endTime：{}", startTime, endTime);
    }

    /**
     * 获取车辆颜色
     *
     * @param plateColor
     * @return
     */
    private String getColor(Integer plateColor) {
        if (plateColor == null) {
            return null;
        }
        switch (plateColor) {
            case 0:
                return "其他颜色";
            case 1:
                return "白色";
            case 2:
                return "银色";
            case 3:
                return "灰色";
            case 4:
                return "黑色";
            case 5:
                return "红色";
            case 6:
                return "深蓝色";
            case 7:
                return "蓝色";
            case 8:
                return "黄色";
            case 9:
                return "绿色";
            case 10:
                return "棕色";
            case 11:
                return "粉色";
            case 12:
                return "紫色";
            case 13:
                return "深灰";
            case 14:
                return "杏色";
            case 255:
                return "未识别的车辆颜色";
            default:
        }
        return null;
    }

    /**
     * 车牌颜色
     *
     * @param plateColor
     * @return
     */
    private String getCarColor(Integer plateColor) {
        if (plateColor == null) {
            return null;
        }
        switch (plateColor) {
            case 0:
                return "蓝色";
            case 1:
                return "黄色";
            case 2:
                return "白色";
            case 3:
                return "黑色";
            case 4:
                return "绿色";
            case 5:
                return "民航黑色";
            case 255:
                return "其他颜色";
            default:
        }
        return null;
    }

    /**
     * 获取进出类型
     *
     * @param passType
     * @return
     */
    private Integer getPassType(Integer passType) {
        if (passType == null) {
            return null;
        }
        //1进，2出
        switch (passType) {
            case 1:
                return 0;
            case 2:
                return 1;
            default:
        }
        return null;
    }

    /**
     * 添加人员
     *
     * @param workerInfo
     * @param isSaveWorker
     * @param isSaveWorkerFace
     */
    public void addWorkerForHikvision(WorkerInfo workerInfo, boolean isSaveWorker, boolean isSaveWorkerFace) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, workerInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        if (isSaveWorker) {
            addWorkerFromHttp(workerInfo, project);
        }
        if (isSaveWorkerFace) {
            saveWorkerFace(workerInfo, project);
        }
    }

    /**
     * 添加人员
     *
     * @param workerInfo
     * @param project
     * @throws Exception
     */
    public void addWorkerFromHttp(WorkerInfo workerInfo, Project project) throws Exception {
        String rs = HikvisionUtil.addWorker(workerInfo, project);
        sendNoticeAndSetStatusForWorker("添加人员到海康isc", rs, workerInfo, 1, 1, true);
    }

    /**
     * 保存人员
     *
     * @param workerInfo
     * @param isSaveWorker
     * @param isSaveWorkerFace
     */
    public void saveWorker(WorkerInfo workerInfo, boolean isSaveWorker, boolean isSaveWorkerFace) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, workerInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        //idcard，
        //	存在：
        //		person一样，更新
        //		person不一样，删除，再新增
        //	不存在：
        //		新增
        JSONObject wiJo = HikvisionUtil.getWorkerInfoByCertificateNo(workerInfo, project);
        if (wiJo != null) {
            String iscPersonId = wiJo.getString("personId");
            if (Objects.equals(iscPersonId, workerInfo.getId() + "")) {
                if (isSaveWorker) {
                    editWorkerFromHttp(workerInfo, project);
                }
                if (isSaveWorkerFace) {
                    saveWorkerFace(workerInfo, project);
                }
            } else {
                //海康门禁isc
                List<UfaceDev> ufaceDevs = ufaceDevService.getAllDevsByProjectSn(workerInfo.getProjectSn());
                projectUfaceConfigService.buildAndSendOneWorkerForHk(ufaceDevs, workerInfo, 3, workerInfo.getProjectSn(), false);
                deleteWorkerForHikvision(iscPersonId + "", workerInfo, false);
                addWorkerForHikvision(workerInfo, isSaveWorker, isSaveWorkerFace);
            }
        } else {
            addWorkerForHikvision(workerInfo, isSaveWorker, isSaveWorkerFace);
        }
    }

    /**
     * 更新人员
     *
     * @param workerInfo
     * @param project
     * @throws Exception
     */
    public void editWorkerFromHttp(WorkerInfo workerInfo, Project project) throws Exception {
        String rs = HikvisionUtil.editWorker(workerInfo, project);
        sendNoticeAndSetStatusForWorker("更新人员到海康isc", rs, workerInfo, 1, 2, true);
    }

    /**
     * 添加人脸
     *
     * @param workerInfo
     * @param project
     */
    public void addWorkerFace(WorkerInfo workerInfo, Project project) throws Exception {
        String fieldAcquisitionUrl = workerInfo.getFieldAcquisitionUrl();
        if (StringUtils.isNotBlank(fieldAcquisitionUrl)) {
            String rs = HikvisionUtil.addWorkerFace(workerInfo, project);
            sendNoticeAndSetStatusForWorker("添加人员照片到海康isc", rs, workerInfo, 2, 1, true);
        }
    }

    /**
     * 为车辆发送通知和设置下发状态
     *
     * @param title
     * @param rs
     * @param carInfo
     * @param type
     * @param operate
     * @param setSuc
     * @param isNotice
     */
    public void sendNoticeAndSetStatusForCarInfo(String title, String rs, CarInfo carInfo, Integer type, Integer operate, Boolean setSuc, boolean isNotice) {
        String msg;
        if (setSuc == null) {
            setSuc = false;
            boolean callSuc = HikvisionUtil.isSuccess(rs);
            JSONObject jo = JSONObject.parseObject(rs);
            String code = jo.getString(CODE);
            if (callSuc) {
                Object data = jo.get(DATA);
                if (data instanceof JSONObject) {
                    JSONObject dataJo = jo.getJSONObject(DATA);
                    Optional<JSONArray> fOp = Optional.ofNullable(dataJo).map(o -> o.getJSONArray("failures"));
                    if (fOp.isPresent() && fOp.get().size() != 0) {
                        if (X_00052102.equals(fOp.get().getJSONObject(0).getString(CODE))) {
                            msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：车辆绑定的人员在isc不存在";
                            title += FAIL;
                        } else {
                            msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：下发异常";
                            title += FAIL;
                        }
                    } else {
                        msg = "同步成功，车牌号码：" + carInfo.getCarNumber();
                        title += SUC;
                        setSuc = true;
                    }
                } else {
                    msg = "同步成功，车牌号码：" + carInfo.getCarNumber();
                    title += SUC;
                    setSuc = true;
                }
            } else {
                if (Objects.equals(code, X_00072202)) {
                    msg = "同步成功，车牌号码：" + carInfo.getCarNumber();
                    title += SUC;
                    setSuc = true;
                    isNotice = false;
                } else if (Objects.equals(code, X_02_E_33900)) {
                    String msg1 = jo.getString(MSG);
                    String errMsg1 = "reservation record not existed or overdued!";
                    if (Objects.equals(msg1, errMsg1)) {
                        msg = "同步成功，车牌号码：" + carInfo.getCarNumber();
                        title += SUC;
                        setSuc = true;
                        isNotice = false;
                    } else {
                        String errMsg = "Car reservation failed! The plateNo has reserved in the parking!";
                        if (Objects.equals(msg1, errMsg)) {
                            msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：车辆预约记录已存在";
                            title += FAIL;
                        } else {
                            msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：下发异常";
                            title += FAIL;
                        }
                    }
                } else if (Objects.equals(code, X_02_E_33400)) {
                    msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：车辆属于黑名单内不能下发预约车";
                    title += FAIL;
                } else if (Objects.equals(code, X_00072003)) {
                    msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：车牌格式不正确！";
                    title += FAIL;
                } else if (Objects.equals(code, X_00052301)) {
                    String msg1 = jo.getString(MSG);
                    String errMsg = "PersonId Not Exists";
                    if (Objects.equals(msg1, errMsg)) {
                        msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：车辆绑定的人员ID不存在";
                        title += FAIL;
                    } else {
                        msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：下发异常";
                        title += FAIL;
                    }
                } else {
                    msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：下发异常";
                    title += FAIL;
                }
            }
        } else {
            if (setSuc) {
                msg = "同步成功，车牌号码：" + carInfo.getCarNumber();
                title += SUC;
            } else {
                msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：下发异常";
                title += FAIL;
            }
        }

        if (setSuc) {
            updateSuccessStatus(carInfo.getProjectSn(), carInfo.getId(), type, operate, null);
        } else {
            updateFailStatus(carInfo.getProjectSn(), carInfo.getId(), type, operate, null);
        }

        xzHikvisionCompareDataService.compareRetryForCar(carInfo, type, operate, setSuc);

        if (isNotice) {
            if (ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class) != null) {
                noticeService.addUserNotice(ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class).getUserId(), title, msg, "24");
            } else if (carInfo.getUserIds() != null && carInfo.getUserIds().size() > 0) {
                for (String userId : carInfo.getUserIds()) {
                    noticeService.addUserNotice(Long.valueOf(userId), title, msg, "24");
                }
            } else if (carInfo.getCreateBy() != null) {
                noticeService.addUserNotice(carInfo.getCreateBy(), title, msg, "24");
            }
        }
    }

    /**
     * 为组织发送通知和设置下发状态
     *
     * @param title
     * @param rs
     * @param orgName
     */
    private void sendNoticeForOrg(String title, String rs, String orgName) {
        if (StringUtils.isBlank(rs)) {
            return;
        }
        boolean success = HikvisionUtil.isSuccess(rs);
        String msg = "";
        String type = "25";
        if (success) {
            JSONObject jo = JSONObject.parseObject(rs);
            if (jo.get(DATA) instanceof JSONObject) {
                JSONObject dataJo = jo.getJSONObject(DATA);
                Optional<JSONArray> fOp = Optional.ofNullable(dataJo).map(o -> o.getJSONArray("failures"));
                if (fOp.isPresent() && fOp.get().size() != 0) {
                    if (X_00052102.equals(fOp.get().getJSONObject(0).getString(CODE))) {
                        msg = "同步失败，组织名称：" + orgName + "。失败原因：上级组织不存在";
                        title += FAIL;
                        success = false;
                    } else {
                        msg = "同步失败，组织名称：" + orgName + "。失败原因：下发异常";
                        title += FAIL;
                        success = false;
                    }
                } else {
                    msg = "同步成功，组织名称：" + orgName;
                    title += SUC;
                }
            } else if (jo.get(DATA) instanceof JSONArray) {
                JSONArray dataJa = jo.getJSONArray(DATA);
                if (CollUtil.isNotEmpty(dataJa)) {
                    String errMsg = "Exists Child Org";
                    if (X_00052102.equals(dataJa.getJSONObject(0).getString(CODE)) && errMsg.equals(dataJa.getJSONObject(0).getString(MSG))) {
                        msg = "同步失败，组织名称：" + orgName + "。失败原因：ISC存在下级组织";
                        title += FAIL;
                        success = false;
                    } else {
                        msg = "同步失败，组织名称：" + orgName + "。失败原因：下发异常";
                        title += FAIL;
                        success = false;
                    }
                } else {
                    msg = "同步成功，组织名称：" + orgName;
                    title += SUC;
                }
            } else {
                msg = "同步成功，组织名称：" + orgName;
                title += SUC;
            }
        } else {
            msg = "同步失败，组织名称：" + orgName + "。失败原因：" + rs;
            title += FAIL;
            success = false;
        }
        if (success) {
            xzHikvisionCompareDataService.compareRetrySuc();
        } else {
            xzHikvisionCompareDataService.compareRetryFail();
        }
        if (ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class) != null) {
            noticeService.addUserNotice(ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class).getUserId(), title, msg, type);
        }
    }

    /**
     * 为人员发送通知和设置下发状态
     *
     * @param title
     * @param rs
     * @param workerInfo
     * @param type
     * @param operate
     * @param sendNotice
     */
    private void sendNoticeAndSetStatusForWorker(String title, String rs, WorkerInfo workerInfo, int type, int operate, boolean sendNotice) {
        boolean callSuc = HikvisionUtil.isSuccess(rs);
        String msg = "";
        String noticeType = "23";
        boolean success = false;
        if (callSuc) {
            success = true;
            msg = "同步成功，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard();
            title += SUC;
        } else {
            JSONObject jo = JSONObject.parseObject(rs);
            String code = jo.getString(CODE);
            if (Objects.equals(code, X_00072002)) {
                String msg1 = jo.getString(MSG);
                String errMsg = "Please Change Picture,Picture Max Size Is Limit 200KB";
                if (Objects.equals(msg1, errMsg)) {
                    msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：人脸图片不能大于200KB";
                    title += FAIL;
                } else {
                    msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：下发异常";
                    title += FAIL;
                }
            } else if (Objects.equals(code, X_00052301)) {
                String msg1 = jo.getString(MSG);
                String orgIndexCodeNotExists = "OrgIndexCode Not Exists";
                String personIdAlreadyInDb = "PersonId Already In Db";
                String personNotExists = "Person Not Exists";
                if (Objects.equals(msg1, orgIndexCodeNotExists)) {
                    String pN = "";
                    if (Objects.equals(workerInfo.getPersonType(), WorkerInfoPersonTypeEnum.LW.getValue())) {
                        pN = "班组";
                    } else if (Objects.equals(workerInfo.getPersonType(), WorkerInfoPersonTypeEnum.GL.getValue())) {
                        pN = "部门";
                    }
                    msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：" + pN + "未同步成功";
                    title += FAIL;
                } else if (Objects.equals(msg1, personIdAlreadyInDb)) {
                    //成功
                    success = true;
                    msg = "同步成功，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard();
                    title += SUC;
                } else if (Objects.equals(msg1, personNotExists)) {
                    msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：人员不存在";
                    title += FAIL;
                } else {
                    msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：下发异常";
                    title += FAIL;
                }
            } else if (Objects.equals(code, X_00072003)) {
                String msg1 = jo.getString(MSG);
                String errMsg = "The format of parameter phoneNo is not correct.";
                if (Objects.equals(msg1, errMsg)) {
                    msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：手机号码格式不正确";
                    title += FAIL;
                } else {
                    msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：下发异常";
                    title += FAIL;
                }
            } else {
                msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：下发异常";
                title += FAIL;
            }
        }
        if (success) {
            updateSuccessStatus(workerInfo.getProjectSn(), workerInfo.getId(), type, operate, null);
            xzHikvisionCompareDataService.compareRetrySuc();
        } else {
            updateFailStatus(workerInfo.getProjectSn(), workerInfo.getId(), type, operate, null);
            xzHikvisionCompareDataService.compareRetryFail();
        }
        Set<Long> userIdSet = getNoticeUserIds(workerInfo.getNoticeUserId(), workerInfo.getProjectSn());
        if (sendNotice) {
            for (Long userId : userIdSet) {
                noticeService.addUserNotice(userId, title, msg, noticeType);
            }
        }
    }

    /**
     * 通知发起人，项目账号，操作的人
     *
     * @param flowStartUser
     * @param projectSn
     * @return
     */
    public Set<Long> getNoticeUserIds(Long flowStartUser, String projectSn) {
        //项目级别账号
        List<SystemUser> systemUsers = systemUserService.getSystemUsersBySn(new MapBuilder<String, Object>().put(Cts.SN, projectSn).put(Cts.QUERY_TYPE, Cts.PROJECT_LEVEL).build());
        Set<Long> userIdSet = systemUsers.stream().map(SystemUser::getUserId).collect(Collectors.toSet());
        //审批的发起人
        if (flowStartUser != null) {
            userIdSet.add(flowStartUser);
        }
        if (ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class) != null) {
            userIdSet.add(ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class).getUserId());
        }
        return userIdSet;
    }

    /**
     * 更新所有未同步失败状态
     *
     * @param projectSn
     * @param workerList
     * @param bigType
     * @param operate
     */
    public void updateAllFailStatusIfNullForAuth(String projectSn, List<WorkerInfo> workerList, Integer bigType, Integer operate) {
        for (WorkerInfo workerInfo : workerList) {
            hikvisionCall.updateAllFailStatusIfNullForAuth(projectSn, workerInfo.getId(), bigType, operate);
        }
    }

    /**
     * 更新某个为失败状态
     *
     * @param projectSn
     * @param whoId
     * @param bigType
     * @param operate
     */
    @Transactional(rollbackFor = Exception.class)
    public void updateAllFailStatusIfNullForAuth(String projectSn, Long whoId, Integer bigType, Integer operate) {
        xzHikvisionSyncMapper.update(null, new LambdaUpdateWrapper<XzHikvisionSync>()
                .set(XzHikvisionSync::getIsSuccess, 0)
                .isNull(XzHikvisionSync::getIsSuccess)
                .eq(XzHikvisionSync::getType, 3)
                .eq(XzHikvisionSync::getOperate, operate)
                .eq(XzHikvisionSync::getWhoId, whoId)
                .eq(XzHikvisionSync::getBigType, bigType)
        );
        this.updateTotalStatus(projectSn, whoId, bigType);
    }

    /**
     * 更新某个为失败状态
     *
     * @param projectSn
     * @param whoId
     * @param bigType
     */
    @Transactional(rollbackFor = Exception.class)
    public void updateAllFailStatusIfNull(String projectSn, Long whoId, Integer bigType) {
        xzHikvisionSyncMapper.update(null, new LambdaUpdateWrapper<XzHikvisionSync>()
                .set(XzHikvisionSync::getIsSuccess, 0)
                .isNull(XzHikvisionSync::getIsSuccess)
                .eq(XzHikvisionSync::getWhoId, whoId)
                .eq(XzHikvisionSync::getBigType, bigType)
        );
        updateTotalStatus(projectSn, whoId, bigType);
    }

    /**
     * 更新某个为失败状态
     *
     * @param projectSn
     * @param whoId
     * @param type
     * @param operate
     * @param deviceSn
     */
    public void updateFailStatus(String projectSn, Long whoId, Integer type, Integer operate, String deviceSn) {
        updateStatus(projectSn, whoId, type, operate, deviceSn, false);
    }

    /**
     * 更新成功状态
     *
     * @param projectSn
     * @param whoId
     * @param type
     * @param operate
     * @param deviceSn
     */
    public void updateSuccessStatus(String projectSn, Long whoId, Integer type, Integer operate, String deviceSn) {
        updateStatus(projectSn, whoId, type, operate, deviceSn, true);
    }

    /**
     * 更新某个状态
     *
     * @param projectSn
     * @param whoId
     * @param type
     * @param operate
     * @param deviceSn
     * @param isSuccess
     */
    @Transactional(rollbackFor = Exception.class)
    public void updateStatus(String projectSn, Long whoId, Integer type, Integer operate, String deviceSn, Boolean isSuccess) {
        LambdaQueryWrapper<XzHikvisionSync> queryWrapper = new LambdaQueryWrapper<XzHikvisionSync>()
                .eq(XzHikvisionSync::getProjectSn, projectSn)
                .eq(XzHikvisionSync::getWhoId, whoId)
                .eq(XzHikvisionSync::getType, type)
                .eq(StringUtils.isNotBlank(deviceSn), XzHikvisionSync::getDeviceSn, deviceSn);
        if (operate != null) {
            if (operate.equals(XzHikvisionSyncOperateEnum.DELETE.getValue())) {
                queryWrapper.eq(XzHikvisionSync::getOperate, operate);
            } else {
                queryWrapper.ne(XzHikvisionSync::getOperate, XzHikvisionSyncOperateEnum.DELETE.getValue());
            }
        }
        List<XzHikvisionSync> xzHikvisionSyncs = xzHikvisionSyncMapper.selectList(queryWrapper);
        if (CollUtil.isNotEmpty(xzHikvisionSyncs)) {
            for (XzHikvisionSync xzHikvisionSync : xzHikvisionSyncs) {
                xzHikvisionSync.setIsSuccess(isSuccess ? 1 : 0);
                xzHikvisionSyncMapper.updateById(xzHikvisionSync);
            }
            updateTotalStatus(projectSn, whoId, xzHikvisionSyncs.get(0).getBigType());
        }
    }

    /**
     * 更下总状态
     *
     * @param projectSn
     * @param whoId
     * @param bigType
     */
    public void updateTotalStatus(String projectSn, Long whoId, Integer bigType) {
        List<XzHikvisionSync> xzHikvisionSyncs = xzHikvisionSyncMapper.selectList(new LambdaQueryWrapper<XzHikvisionSync>()
                .eq(XzHikvisionSync::getProjectSn, projectSn)
                .eq(XzHikvisionSync::getWhoId, whoId)
                .eq(XzHikvisionSync::getBigType, bigType)
        );
        Integer sendSuccessStatus = 4;
        if (CollUtil.isEmpty(xzHikvisionSyncs) || xzHikvisionSyncs.stream().allMatch(xzHikvisionSync1 -> xzHikvisionSync1.getIsSuccess() == null)) {
            sendSuccessStatus = 4;
        } else if (xzHikvisionSyncs.stream().allMatch(xzHikvisionSync1 -> Objects.equals(xzHikvisionSync1.getIsSuccess(), 1))) {
            sendSuccessStatus = 1;
        } else if (xzHikvisionSyncs.stream().allMatch(xzHikvisionSync1 -> xzHikvisionSync1.getIsSuccess() == null || Objects.equals(xzHikvisionSync1.getIsSuccess(), 0))) {
            sendSuccessStatus = 2;
        } else {
            sendSuccessStatus = 3;
        }
        if (Objects.equals(bigType, XzHikvisionSyncBigTypeEnum.CAR.getValue())) {
            carInfoMapper.update(null, new LambdaUpdateWrapper<CarInfo>()
                    .eq(CarInfo::getId, whoId)
                    .set(CarInfo::getSendSuccessStatus, sendSuccessStatus)
            );
        } else {
            workerInfoMapper.update(null, new LambdaUpdateWrapper<WorkerInfo>()
                    .eq(WorkerInfo::getId, whoId)
                    .set(WorkerInfo::getSendSuccessStatus, sendSuccessStatus)
            );
        }
    }

    /**
     * 保存人脸
     *
     * @param workerInfo
     * @param project
     */
    public void saveWorkerFace(WorkerInfo workerInfo, Project project) throws Exception {
        if (StrUtil.isNotBlank(workerInfo.getFieldAcquisitionUrl())) {
            ArrayList<String> workerFaceIds = getWorkerFaceIds(String.valueOf(workerInfo.getId()), project);
            if (CollUtil.isNotEmpty(workerFaceIds)) {
                String workerFaceId = workerFaceIds.get(0);
                final String artemisPath = "/artemis";
                final String path = artemisPath + "/api/resource/v1/face/single/update";
                String host = "https://" + project.getArtemisConfigHost();
                JSONObject jo = new JSONObject();
                jo.put("faceId", workerFaceId);
                jo.put("faceData", Base64Util.convertFileToBase64(PathUtil.reviseSlash(basePath + "/" + workerInfo.getFieldAcquisitionUrl())));
                String rs = HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
                sendNoticeAndSetStatusForWorker("更新人员照片到海康isc", rs, workerInfo, 2, 2, true);
            } else {
                addWorkerFace(workerInfo, project);
            }
        }
    }

    /**
     * 删除人员
     *
     * @param uniqueId
     * @param workerInfo
     * @param sendNotice
     */
    public void deleteWorkerForHikvision(String uniqueId, WorkerInfo workerInfo, boolean sendNotice) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, workerInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        deleteWorkerFace(uniqueId, workerInfo, project, sendNotice);

        deleteWorkerFromHttp(uniqueId, workerInfo, project, sendNotice);
    }

    /**
     * 删除人员到海康isc
     *
     * @param uniqueId
     * @param workerInfo
     * @param project
     * @param sendNotice
     * @throws Exception
     */
    public void deleteWorkerFromHttp(String uniqueId, WorkerInfo workerInfo, Project project, boolean sendNotice) throws Exception {
        String rs = HikvisionUtil.deleteWorkerById(uniqueId, project).toJSONString();
        sendNoticeAndSetStatusForWorker("删除人员到海康isc", rs, workerInfo, 1, 3, sendNotice);
    }

    /**
     * 删除人员图片到海康isc
     *
     * @param uniqueId
     * @param workerInfo
     * @param project
     * @param sendNotice
     * @throws Exception
     */
    public void deleteWorkerFace(String uniqueId, WorkerInfo workerInfo, Project project, boolean sendNotice) throws Exception {
        List<String> workerFaceIds = getWorkerFaceIds(uniqueId, project);
        if (CollUtil.isNotEmpty(workerFaceIds)) {
            for (String workerFaceId : workerFaceIds) {
                JSONObject rsJo = HikvisionUtil.deleteWorkerFace(project, workerFaceId);
                sendNoticeAndSetStatusForWorker("删除人员图片到海康isc", rsJo.toJSONString(), workerInfo, 2, 3, sendNotice);
            }
        }
    }

    /**
     * 获取人员人脸id列表
     *
     * @param uniqueId
     * @param project
     * @return
     */
    private ArrayList<String> getWorkerFaceIds(String uniqueId, Project project) throws Exception {
        JSONObject joData = HikvisionUtil.getWorkerInfoByPersonId(uniqueId, project);
        ArrayList<String> ids = new ArrayList<>();
        if (joData != null) {
            JSONArray ppJa = joData.getJSONArray("personPhoto");
            if (ppJa != null) {
                for (int j = 0; j < ppJa.size(); j++) {
                    JSONObject jo1 = ppJa.getJSONObject(j);
                    ids.add(jo1.getString("personPhotoIndexCode"));
                }
            }
        }
        return ids;
    }

    /**
     * 保存车辆
     *
     * @param carInfo
     */
    public void saveCarInfoFromHikvision(CarInfo carInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, carInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        if (carInfo.getIsBlack() == 0) {
            handleAlarmCar(project, carInfo);
        }
        cancelCharge(project, carInfo);
        if (Objects.equals(carInfo.getCarModuleType(), CarInfoCarModuleTypeEnum.GD.getValue())) {
            //删除预约车辆
            deleteReservationCarFromHttp(carInfo, project, true);
            saveFixedCar(carInfo, project);
            saveBindCategory(carInfo, project);
        } else if (Objects.equals(carInfo.getCarModuleType(), CarInfoCarModuleTypeEnum.CQ.getValue()) || Objects.equals(carInfo.getCarModuleType(), CarInfoCarModuleTypeEnum.LS.getValue())) {
            unbindCar(project, carInfo);
            deleteFixedCarForHikvision(carInfo, project);
            saveReservationCar(project, carInfo);
        }
    }

    /**
     * 车辆取消布防/布防
     *
     * @param project
     * @param carInfo
     * @throws Exception
     */
    public void handleAlarmCar(Project project, CarInfo carInfo) {
        try {
            JSONObject jo = new JSONObject();
            jo.put("searchKey", carInfo.getCarNumber());
            jo.put("pageNo", 1);
            jo.put("pageSize", 1);
            JSONObject joRs = HikvisionUtil.getBlackCarList(project, jo);
            if (HikvisionUtil.isSuccess(joRs)) {
                JSONObject dataJo = HikvisionUtil.getJsonObjectData(joRs);
                JSONArray listJa = dataJo.getJSONArray(LIST);
                if (CollUtil.isEmpty(listJa)) {
                    if (carInfo.getIsBlack() == 1) {
                        JSONObject addJo = new JSONObject();
                        CarInfo c = carInfoService.queryById(String.valueOf(carInfo.getId()));
                        addJo.put("driver", c.getDriverWorkerName());
                        addJo.put("driverPhone", c.getDriverTelephone());
                        addJo.put("plateNo", carInfo.getCarNumber());
                        JSONObject rs = HikvisionUtil.addAlarmCar(project, addJo);
                        sendNoticeAndSetStatusForCarInfo("车辆添加黑名单到海康isc", rs.toJSONString(), carInfo, 7, null, null, true);
                    } else {
                        sendNoticeAndSetStatusForCarInfo("车辆取消黑名单到海康isc", null, carInfo, 7, null, true, false);
                    }
                } else {
                    if (carInfo.getIsBlack() == 1) {
                        sendNoticeAndSetStatusForCarInfo("车辆添加黑名单到海康isc", null, carInfo, 7, null, true, true);
                    } else {
                        JSONObject joOne = listJa.getJSONObject(0);
                        String alarmSyscode = joOne.getString("alarmSyscode");
                        JSONObject deleteJo = new JSONObject();
                        deleteJo.put("alarmSyscodes", alarmSyscode);
                        JSONObject rs = HikvisionUtil.deletionAlarmCar(project, deleteJo);
                        sendNoticeAndSetStatusForCarInfo("车辆取消黑名单到海康isc", rs.toJSONString(), carInfo, 7, null, null, true);
                    }
                }
            } else {
                failAlarmNotice(carInfo);
            }
        } catch (Exception e) {
            failAlarmNotice(carInfo);
        }
    }

    /**
     * 添加车辆黑名单失败报警通知
     *
     * @param carInfo
     */
    private void failAlarmNotice(CarInfo carInfo) {
        if (carInfo.getIsBlack() == 1) {
            sendNoticeAndSetStatusForCarInfo("车辆添加黑名单到海康isc", new JSONObject().toJSONString(), carInfo, 7, null, false, true);
        } else {
            sendNoticeAndSetStatusForCarInfo("车辆取消黑名单到海康isc", new JSONObject().toJSONString(), carInfo, 7, null, false, true);
        }
    }

    /**
     * 保存固定车
     *
     * @param carInfo
     * @param project
     * @throws Exception
     */
    private void saveFixedCar(CarInfo carInfo, Project project) throws Exception {
        //根据车牌号删除车辆
        JSONObject oldCarInfo = searchCarInfoByCarNumberFromHttp(carInfo.getCarNumber(), project);
        if (oldCarInfo != null) {
            log.info("查询到海康车辆，车牌号：{}", carInfo.getCarNumber());
            carInfo.setHikvisionVehicleId(oldCarInfo.getString("vehicleId"));
            editCarInfoFromHttp(carInfo, project);
        } else {
            log.info("未查询到海康车辆，车牌号：{}", carInfo.getCarNumber());
            //固定车
            addCarInfoFromHttp(carInfo, project);
        }
    }

    /**
     * 通过车牌号获取isc的车辆id
     *
     * @param carNumber
     * @param project
     * @return
     * @throws Exception
     */
    private String getRemoteCarIdByCarNumber(String carNumber, Project project) throws Exception {
        JSONObject oldCarInfo = searchCarInfoByCarNumberFromHttp(carNumber, project);
        return oldCarInfo == null ? null : oldCarInfo.getString("vehicleId");
    }

    /**
     * 保存绑定群组关系
     *
     * @param carInfo
     * @param project
     * @throws Exception
     */
    private void saveBindCategory(CarInfo carInfo, Project project) throws Exception {
        bindCar(project, carInfo);
    }

    /**
     * 获取绑定的固定车辆群组
     *
     * @param project
     * @return
     * @throws Exception
     */
    @NotNull
    private String getCategoryCode(Project project) throws Exception {
        //绑定固定的群组
        JSONArray ja = HikvisionUtil.getCategoryList(project);
        return getFixedCarGroupName(ja);
    }

    /**
     * 添加车辆
     *
     * @param carInfo
     * @param project
     * @throws Exception
     */
    public void addCarInfoFromHttp(CarInfo carInfo, Project project) throws Exception {
        final String artemisPath = "/artemis";
        final String path = artemisPath + "/api/resource/v1/vehicle/batch/add";
        String host = "https://" + project.getArtemisConfigHost();
        HikvisionCarInfo hikvisionCarInfo = getHikvisionCarInfo(carInfo);
        ArrayList<HikvisionCarInfo> list = new ArrayList<>();
        list.add(hikvisionCarInfo);
        String rs = HikvisionUtil.doPost(host, path, JSON.toJSONString(list), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        sendNoticeAndSetStatusForCarInfo("添加车辆白名单到海康isc", rs, carInfo, 4, 1, null, true);
    }

    /**
     * 获取车辆
     *
     * @param carInfo
     * @return
     */
    private HikvisionCarInfo getHikvisionCarInfo(CarInfo carInfo) {
        HikvisionCarInfo hikvisionCarInfo = new HikvisionCarInfo();
        hikvisionCarInfo.setVehicleId(carInfo.getHikvisionVehicleId());
        hikvisionCarInfo.setPlateNo(carInfo.getCarNumber());
        String[] driverList = StringUtils.split(carInfo.getDriverWorkerId(), Cts.COMMA);
        if (driverList != null && driverList.length > 0) {
            hikvisionCarInfo.setPersonId(driverList[0]);
        }
        hikvisionCarInfo.setPlateType(null);
        hikvisionCarInfo.setPlateColor(getPlateColor(carInfo));
        hikvisionCarInfo.setVehicleType(getVehicleType(carInfo));
        hikvisionCarInfo.setVehicleColor(getVehicleColor(carInfo.getCarColor()));
        hikvisionCarInfo.setDescription(null);
        return hikvisionCarInfo;
    }

    /**
     * 获取isc的车牌颜色
     *
     * @param carInfo
     * @return
     */
    private String getPlateColor(CarInfo carInfo) {
        String carColor = carInfo.getCarColor();
        if (StringUtils.isBlank(carColor)) {
            return null;
        }
        switch (carColor) {
            case "蓝色":
                return SUC_CODE;
            case "黄色":
                return "1";
            case "白色":
                return "2";
            case "黑色":
                return "3";
            case "绿色":
                return "4";
            case "民航黑色":
                return "5";
            case "其他颜色":
                return "255";
            default:
        }
        return null;
    }

    /**
     * 获取isc的车辆类型
     *
     * @param carInfo
     * @return
     */
    private String getVehicleType(CarInfo carInfo) {
        String carTypeName = carInfoMapper.getCarTypeName(carInfo);
        switch (carTypeName) {
            case "其他车":
                return SUC_CODE;
            case "小型车":
                return "1";
            case "大型车":
                return "2";
            case "摩托车":
                return "3";
            default:
        }
        return null;
    }

    /**
     * 获取isc的车辆颜色
     *
     * @param carColor
     * @return
     */
    private String getVehicleColor(String carColor) {
        if (StringUtils.isBlank(carColor)) {
            return null;
        }
        switch (carColor) {
            case "其他颜色":
                return SUC_CODE;
            case "白色":
                return "1";
            case "银色":
                return "2";
            case "灰色":
                return "3";
            case "黑色":
                return "4";
            case "红色":
                return "5";
            case "深蓝色":
                return "6";
            case "蓝色":
                return "7";
            case "黄色":
                return "8";
            case "绿色":
                return "9";
            case "棕色":
                return "10";
            case "粉色":
                return "11";
            case "紫色":
                return "12";
            case "深灰":
                return "13";
            case "杏色":
                return "14";
            case "未识别的车辆颜色":
                return "255";
            default:
                return null;
        }
    }

    /**
     * 编辑车辆
     *
     * @param carInfo
     * @param old
     */
    public void editCarInfoForHikvision(CarInfo carInfo, CarInfo old) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, carInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        if (!Objects.equals(carInfo.getCarNumber(), old.getCarNumber())) {
            //删除旧的车辆数据
            deleteCarInfoForHikvision(old, false);
        }
        saveCarInfoFromHikvision(carInfo);
    }

    /**
     * 修改车辆
     *
     * @param carInfo
     * @param project
     * @throws Exception
     */
    private void editCarInfoFromHttp(CarInfo carInfo, Project project) throws Exception {
        final String artemisPath = "/artemis";
        final String path = artemisPath + "/api/resource/v1/vehicle/single/update";
        String host = "https://" + project.getArtemisConfigHost();
        HikvisionCarInfo hikvisionCarInfo = getHikvisionCarInfo(carInfo);
        String rs = HikvisionUtil.doPost(host, path, JSON.toJSONString(hikvisionCarInfo), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        sendNoticeAndSetStatusForCarInfo("更新车辆白名单到海康isc", rs, carInfo, 4, 2, null, true);
    }

    /**
     * 解绑车辆群组
     *
     * @param project
     * @param carInfo
     * @throws Exception
     */
    private void unbindCar(Project project, CarInfo carInfo) throws Exception {
        String categoryCode = getCategoryCode(project);
        bindOrNotCarCategory(project, 2, categoryCode, carInfo);
    }

    /**
     * 解绑车辆群组
     *
     * @param project
     * @param carInfo
     * @throws Exception
     */
    private void bindCar(Project project, CarInfo carInfo) throws Exception {
        String categoryCode = getCategoryCode(project);
        bindOrNotCarCategory(project, 1, categoryCode, carInfo);
    }

    /**
     * 获取固定车的categoryCode
     *
     * @param ja
     */
    private String getFixedCarGroupName(JSONArray ja) {
        if (ja != null) {
            for (int i = 0; i < ja.size(); i++) {
                JSONObject jo = ja.getJSONObject(i);
                String categoryName = jo.getString("categoryName");
                if (Objects.equals(categoryName, FIXED_CAR_GROUP_NAME)) {
                    return jo.getString("categoryCode");
                }
            }
        }
        log.error("获取固定车的群组失败");
        throw new OpenPromptException("获取固定车的群组失败");
    }

    /**
     * 删除车辆
     *
     * @param carInfo
     * @param isSetBlack
     */
    public void deleteCarInfoForHikvision(CarInfo carInfo, boolean isSetBlack) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, carInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        cancelCharge(project, carInfo);
        unbindCar(project, carInfo);
        deleteFixedCarForHikvision(carInfo, project);
        deleteReservationCarFromHttp(carInfo, project, true);
        CarInfo c = new CarInfo();
        BeanUtil.copyProperties(carInfo, c);
        c.setIsBlack(isSetBlack ? 1 : 0);
        handleAlarmCar(project, c);
    }

    /**
     * 删除固定车
     *
     * @param carInfo
     * @param project
     * @throws Exception
     */
    private void deleteFixedCarForHikvision(CarInfo carInfo, Project project) throws Exception {
        //根据车牌号删除车辆
        JSONObject oldCarInfo = searchCarInfoByCarNumberFromHttp(carInfo.getCarNumber(), project);
        if (oldCarInfo != null) {
            log.info("海康存在车辆，车牌号：{}", oldCarInfo.getString("plateNo"));
            String rs = HikvisionUtil.deleteCarInfoById(oldCarInfo.getString("vehicleId"), project);
            sendNoticeAndSetStatusForCarInfo("删除车辆白名单到海康isc", rs, carInfo, 4, 3, null, true);
        } else {
            sendNoticeAndSetStatusForCarInfo("删除车辆白名单到海康isc", null, carInfo, 4, 3, true, false);
        }
    }

    /**
     * 根据车牌号查询车辆
     *
     * @param carNumber
     * @param project
     * @return
     * @throws Exception
     */
    private JSONObject searchCarInfoByCarNumberFromHttp(String carNumber, Project project) throws Exception {
        long total = 0;
        JSONObject o1 = null;
        int pageNo = 0;
        do {
            JSONObject jo = HikvisionUtil.getFixCarListByCarNumber(carNumber, project, ++pageNo);
            if (HikvisionUtil.isSuccess(jo)) {
                JSONObject dataJo = HikvisionUtil.getJsonObjectData(jo);
                total = dataJo.getInteger("total");
                JSONArray listJa = dataJo.getJSONArray(LIST);
                Optional<Object> plateNoOpt = listJa.stream().filter(o -> {
                    JSONObject j = (JSONObject) o;
                    return carNumber.equals(j.getString("plateNo"));
                }).findFirst();
                if (plateNoOpt.isPresent()) {
                    o1 = (JSONObject) plateNoOpt.get();
                }
            } else {
                return null;
            }
        } while (o1 == null && total > pageNo * 1000L);
        return o1;
    }

    /**
     * 取消车位预约
     *
     * @param carInfo
     * @param project
     * @param isNotice
     */
    private void deleteReservationCarFromHttp(CarInfo carInfo, Project project, boolean isNotice) throws Exception {
        final String artemisPath = "/artemis";
        final String path = artemisPath + "/api/pms/v1/parkingSpace/reservations/deletion";
        String host = "https://" + project.getArtemisConfigHost();
        JSONArray reservationCarInfoList = HikvisionUtil.getIscActiveReservationCarList(carInfo.getCarNumber(), project);
        if (CollUtil.isNotEmpty(reservationCarInfoList)) {
            for (int i = 0; i < reservationCarInfoList.size(); i++) {
                JSONObject jsonObject = reservationCarInfoList.getJSONObject(i);
                String reserveOrderNo = jsonObject.getString("reserveOrderNo");
                JSONObject jsonObject1 = new JSONObject();
                jsonObject1.put("reserveOrderNo", reserveOrderNo);
                String rs = HikvisionUtil.doPost(host, path, jsonObject1.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
                sendNoticeAndSetStatusForCarInfo("取消车位预约到海康isc", rs, carInfo, 6, 3, null, isNotice);
            }
        } else {
            sendNoticeAndSetStatusForCarInfo("取消车位预约到海康isc", null, carInfo, 6, 3, true, false);
        }
    }

    /**
     * 添加组织
     *
     * @param enterpriseInfo
     */
    public void addEnterpriseInfoForHikvision(EnterpriseInfo enterpriseInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, enterpriseInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        enterpriseInfo = BeanUtil.toBean(enterpriseInfoService.getEnterpriseInfoById(new MapBuilder<String, Object>()
                .put(Cts.PROJECT_SN, enterpriseInfo.getProjectSn()).put(Cts.ENTERPRISE_ID, enterpriseInfo.getId()).build()), EnterpriseInfo.class);
        HikvisionOrganization hikvisionOrganization = getHikvisionOrganization(enterpriseInfo, String.valueOf(enterpriseInfo.getProjectEnterprise().getId()));
        addOrgNoticeFromHttp(project, hikvisionOrganization);
    }

    /**
     * 映射isc的组织
     *
     * @param enterpriseInfo
     * @param orgIndexCode
     * @return
     */
    private HikvisionOrganization getHikvisionOrganization(EnterpriseInfo enterpriseInfo, String orgIndexCode) {
        HikvisionOrganization hikvisionOrganization = new HikvisionOrganization();
        hikvisionOrganization.setClientId(null);
        hikvisionOrganization.setOrgIndexCode(orgIndexCode);
        hikvisionOrganization.setOrgName(enterpriseInfo.getEnterpriseName());
        hikvisionOrganization.setParentIndexCode(enterpriseInfo.getProjectSn());
        return hikvisionOrganization;
    }

    /**
     * 更新组织
     *
     * @param enterpriseInfo
     */
    public void editEnterpriseInfoForHikvision(EnterpriseInfo enterpriseInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, enterpriseInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        Pair<Boolean, String> existAndIndexCode = existAndGetEnterpriseOrgIndexCodeByEnterpriseId(project, String.valueOf(enterpriseInfo.getId()), null);
        HikvisionOrganization hikvisionOrganization = getHikvisionOrganization(enterpriseInfo, existAndIndexCode.getRight());
        if (existAndIndexCode.getLeft()) {
            editOrgFromHttp(project, hikvisionOrganization);
        } else {
            addOrgNoticeFromHttp(project, hikvisionOrganization);
        }
    }

    /**
     * @param project
     * @param enterpriseId
     * @param projectEnterpriseId
     * @return
     * @throws Exception
     */
    private Pair<Boolean, String> existAndGetEnterpriseOrgIndexCodeByEnterpriseId(Project project, String enterpriseId, Long projectEnterpriseId) throws Exception {
        if (projectEnterpriseId == null) {
            EnterpriseInfo enterpriseInfo = BeanUtil.toBean(enterpriseInfoService.getEnterpriseInfoById(new MapBuilder<String, Object>()
                    .put(Cts.PROJECT_SN, project.getProjectSn()).put(Cts.ENTERPRISE_ID, enterpriseId).build()), EnterpriseInfo.class);
            if (enterpriseInfo.getProjectEnterprise() != null) {
                projectEnterpriseId = enterpriseInfo.getProjectEnterprise().getId();
            }
        }
        JSONArray orgList = getOrgList(project, StrUtil.join(Cts.COMMA, enterpriseId, projectEnterpriseId != null ? projectEnterpriseId : ""), project.getProjectSn());
        String index = null;
        if (CollUtil.isEmpty(orgList)) {
            index = projectEnterpriseId != null ? String.valueOf(projectEnterpriseId) : enterpriseId;
        } else {
            index = orgList.getJSONObject(0).getString("orgIndexCode");
        }
        return new ImmutablePair<>(CollUtil.isNotEmpty(orgList), index);
    }

    /**
     * 删除组织
     *
     * @param projectSn
     * @param enterpriseName
     */
    public void deleteEnterpriseInfoForHikvision(String projectSn, String enterpriseName) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, projectSn));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        String orgIndex = getOrgIndexByParentIndexAndName(project, enterpriseName);
        String rs = HikvisionUtil.deleteOrgByIndexCodes(project, Collections.singletonList(orgIndex));
        sendNoticeForOrg("删除组织到海康isc", rs, enterpriseName);
    }

    /**
     * 根据父级索引和名称获取组织索引
     *
     * @param project
     * @param orgName
     * @return
     * @throws Exception
     */
    private String getOrgIndexByParentIndexAndName(Project project, String orgName) throws Exception {
        JSONObject param = new JSONObject();
        param.put("pageNo", 1);
        param.put("pageSize", 1000);
        param.put("orgName", orgName);
        param.put("parentOrgIndexCodes", project.getProjectSn());
        String rs = HikvisionUtil.getOrgV2(project, param);
        JSONObject dataJo = HikvisionUtil.getJsonObjectData(rs);
        JSONArray listJa = dataJo.getJSONArray(LIST);
        for (int i = 0; i < listJa.size(); i++) {
            JSONObject jo = listJa.getJSONObject(i);
            if (jo.getString("orgName").equals(orgName)) {
                return jo.getString("orgIndexCode");
            }
        }
        return null;
    }

    /**
     * 添加组织
     *
     * @param teamInfo
     */
    public void addTeamInfoForHikvision(TeamInfo teamInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, teamInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        HikvisionOrganization hikvisionOrganization = getHikvisionOrganization(teamInfo, project);
        addOrgNoticeFromHttp(project, hikvisionOrganization);
    }

    /**
     * 映射isc的组织
     *
     * @param teamInfo
     * @param project
     * @return
     * @throws Exception
     */
    private HikvisionOrganization getHikvisionOrganization(TeamInfo teamInfo, Project project) throws Exception {
        HikvisionOrganization hikvisionOrganization = new HikvisionOrganization();
        hikvisionOrganization.setClientId(null);
        hikvisionOrganization.setOrgIndexCode(String.valueOf(teamInfo.getId()));
        hikvisionOrganization.setOrgName(teamInfo.getTeamName());
        hikvisionOrganization.setParentIndexCode(existAndGetEnterpriseOrgIndexCodeByEnterpriseId(project, String.valueOf(teamInfo.getEnterpriseId()), null).getRight());
        return hikvisionOrganization;
    }

    /**
     * 编辑组织
     *
     * @param teamInfo
     */
    public void editTeamInfoForHikvision(TeamInfo teamInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, teamInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        HikvisionOrganization hikvisionOrganization = getHikvisionOrganization(teamInfo, project);
        if (existOrg(project, String.valueOf(teamInfo.getId()), hikvisionOrganization.getParentIndexCode())) {
            editOrgFromHttp(project, hikvisionOrganization);
        } else {
            addOrgNoticeFromHttp(project, hikvisionOrganization);
        }
    }

    /**
     * 更新组织到海康isc
     *
     * @param project
     * @param hikvisionOrganization
     * @throws Exception
     */
    private void editOrgFromHttp(Project project, HikvisionOrganization hikvisionOrganization) throws Exception {
        String rs = HikvisionUtil.editOrg(project, hikvisionOrganization);
        sendNoticeForOrg("更新组织到海康isc", rs, hikvisionOrganization.getOrgName());
    }

    /**
     * 删除组织到海康isc
     *
     * @param project
     * @param idList
     * @param orgName
     * @throws Exception
     */
    private void deleteOrgFromHttp(Project project, List<String> idList, String orgName) throws Exception {
        String rs = HikvisionUtil.deleteOrgByIndexCodes(project, idList);
        sendNoticeForOrg("删除组织到海康isc", rs, orgName);
    }

    /**
     * 添加组织到海康isc
     *
     * @param project
     * @param hikvisionOrganization
     * @throws Exception
     */
    private void addOrgNoticeFromHttp(Project project, HikvisionOrganization hikvisionOrganization) throws Exception {
        String rs = HikvisionUtil.addOrg(project, hikvisionOrganization);
        sendNoticeForOrg("添加组织到海康isc", rs, hikvisionOrganization.getOrgName());
    }

    /**
     * 删除组织
     *
     * @param id
     * @param teamInfo
     */
    public void deleteTeamInfoForHikvision(String id, TeamInfo teamInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, teamInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        deleteOrgFromHttp(project, Arrays.asList(id), teamInfo.getTeamName());
    }

    /**
     * 添加组织
     *
     * @param departmentInfo
     */
    public void addDepartmentInfoForHikvision(DepartmentInfo departmentInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, departmentInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        HikvisionOrganization hikvisionOrganization = getHikvisionOrganization(departmentInfo, project);
        addOrgNoticeFromHttp(project, hikvisionOrganization);
    }

    /**
     * 映射isc的组织
     *
     * @param departmentInfo
     * @param project
     * @return
     * @throws Exception
     */
    private HikvisionOrganization getHikvisionOrganization(DepartmentInfo departmentInfo, Project project) throws Exception {
        HikvisionOrganization hikvisionOrganization = new HikvisionOrganization();
        hikvisionOrganization.setClientId(null);
        hikvisionOrganization.setOrgIndexCode(String.valueOf(departmentInfo.getId()));
        hikvisionOrganization.setOrgName(departmentInfo.getDepartmentName());
        hikvisionOrganization.setParentIndexCode(existAndGetEnterpriseOrgIndexCodeByEnterpriseId(project, String.valueOf(departmentInfo.getEnterpriseId()), null).getRight());
        return hikvisionOrganization;
    }

    /**
     * 编辑组织
     *
     * @param departmentInfo
     */
    public void editDepartmentInfoForHikvision(DepartmentInfo departmentInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, departmentInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        HikvisionOrganization hikvisionOrganization = getHikvisionOrganization(departmentInfo, project);
        if (existOrg(project, String.valueOf(departmentInfo.getId()), hikvisionOrganization.getParentIndexCode())) {
            editOrgFromHttp(project, hikvisionOrganization);
        } else {
            addOrgNoticeFromHttp(project, hikvisionOrganization);
        }

    }

    /**
     * 删除组织
     *
     * @param uniqueId
     * @param departmentInfo
     */
    public void deleteDepartmentInfoForHikvision(String uniqueId, DepartmentInfo departmentInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, departmentInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        deleteOrgFromHttp(project, Arrays.asList(uniqueId), departmentInfo.getDepartmentName());
    }

    /**
     * 添加组织
     *
     * @param project
     */
    public void editProjectForHikvision(Project project) throws Exception {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        HikvisionOrganization hikvisionOrganization = getHikvisionOrganization(project);
        HikvisionUtil.addOrg(project, hikvisionOrganization);
    }

    /**
     * 组织是否存在
     *
     * @param project
     * @param orgIndexs          逗号分割
     * @param parentOrgIndexCode
     * @return
     */
    public boolean existOrg(Project project, String orgIndexs, String parentOrgIndexCode) throws Exception {
        JSONArray list = getOrgList(project, orgIndexs, parentOrgIndexCode);
        return list.size() > 0;
    }

    /**
     * 查询组织
     *
     * @param project
     * @param orgIndexs          逗号分割
     * @param parentOrgIndexCode
     * @return
     */
    private JSONArray getOrgList(Project project, String orgIndexs, String parentOrgIndexCode) throws Exception {
        JSONObject param = new JSONObject();
        param.put("pageNo", 1);
        param.put("pageSize", 1000);
        param.put("orgIndexCodes", orgIndexs);
        param.put("parentOrgIndexCodes", parentOrgIndexCode);
        String rs = HikvisionUtil.getOrgV2(project, param);
        JSONObject jo = HikvisionUtil.getJsonObjectData(rs);
        return jo.getJSONArray(LIST);
    }

    /**
     * 映射isc的组织
     *
     * @param project
     * @return
     */
    private HikvisionOrganization getHikvisionOrganization(Project project) {
        HikvisionOrganization hikvisionOrganization = new HikvisionOrganization();
        hikvisionOrganization.setClientId(null);
        hikvisionOrganization.setOrgIndexCode(project.getProjectSn());
        hikvisionOrganization.setOrgName(project.getProjectName());
        hikvisionOrganization.setParentIndexCode("root000000");
        return hikvisionOrganization;
    }


    /**
     * 保存预约车辆
     *
     * @param project
     * @param carInfo
     */
    public void saveReservationCar(Project project, CarInfo carInfo) throws Exception {
        //删除预约车辆
        deleteReservationCarFromHttp(carInfo, project, false);
        //临时车辆预约
        reservationCarFromHttp(project, carInfo);
    }

    /**
     * 取消车辆包期
     *
     * @param project
     * @param carInfo
     * @throws Exception
     */
    private void cancelCharge(Project project, CarInfo carInfo) throws Exception {
        //取消车辆包期
        String parkIndexCode = HikvisionUtil.getProjectParkCode(project);
        HikvisionUtil.chargeDeletion(project, new ChargeDeletionParam(parkIndexCode, carInfo.getCarNumber()));
    }

    /**
     * 添加预约车辆到海康isc
     *
     * @param project
     * @param carInfo
     * @throws Exception
     */
    private void reservationCarFromHttp(Project project, CarInfo carInfo) throws Exception {
        final String artemisPath = "/artemis";
        final String path = artemisPath + "/api/pms/v2/parkingSpace/reservations/addition";
        String host = "https://" + project.getArtemisConfigHost();
        ParkReservation parkReservation = getParkReservation(project, carInfo);
        String rs = HikvisionUtil.doPost(host, path, JSON.toJSONString(parkReservation), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        sendNoticeAndSetStatusForCarInfo("添加预约车辆到海康isc", rs, carInfo, 6, 1, null, true);
    }

    /**
     * 映射车辆预约信息
     *
     * @param project
     * @param carInfo
     * @return
     * @throws Exception
     */
    private ParkReservation getParkReservation(Project project, CarInfo carInfo) throws Exception {
        String parkIndexCode = HikvisionUtil.getProjectParkCode(project);
        WorkerInfo workerInfo = workerInfoMapper.selectById(carInfo.getDriverWorkerId());
        ParkReservation parkReservation = new ParkReservation();
        parkReservation.setParkSyscode(parkIndexCode);
        parkReservation.setPlateNo(carInfo.getCarNumber());
        if (Objects.equals(carInfo.getCarModuleType(), CarInfoCarModuleTypeEnum.LS.getValue())) {
            parkReservation.setOwner(carInfo.getDriverWorkerName());
        } else if (workerInfo != null) {
            parkReservation.setOwner(workerInfo.getWorkerName());
        }
        parkReservation.setPhoneNo(carInfo.getDriverTelephone());
        parkReservation.setAllowTimes(Convert.toLong(carInfo.getEntryAndExitPermit()));
        parkReservation.setIsCharge(SUC_CODE);
        parkReservation.setStartTime(DateUtil.format(carInfo.getReserveStartTime(), "yyyy-MM-dd'T'HH:mm:ss") + "+08:00");
        parkReservation.setEndTime(DateUtil.format(carInfo.getReserveEndTime(), "yyyy-MM-dd'T'HH:mm:ss") + "+08:00");
        return parkReservation;
    }

    /**
     * 保存图片本体
     *
     * @param url
     * @return
     */
    public String saveToLocal(String url) {
        return UrlUtil.saveToLocal(url, basePath, IdUtil.simpleUUID() + ".png");
    }

    /**
     * 保存车辆群组绑定关系
     *
     * @param project
     * @param categoryCode
     * @param carInfo
     * @throws Exception
     */
    public void saveCarCategoryBind(Project project, String categoryCode, CarInfo carInfo) throws Exception {
        bindOrNotCarCategory(project, 2, categoryCode, carInfo);
        bindOrNotCarCategory(project, 1, categoryCode, carInfo);
    }

    /**
     * 车辆群组管理，解绑使用
     *
     * @param project
     * @param operation    绑定操作类型，1绑定、2解绑
     * @param categoryCode 车辆分类标识
     * @param carInfo
     */
    public void bindOrNotCarCategory(Project project, Integer operation, String categoryCode, CarInfo carInfo) throws Exception {
        int bind = 1;
        int unbind = 2;
        if (Objects.equals(operation, bind)) {
            //绑定
            Set<String> ids = getHkCarIds(project, carInfo);
            JSONObject bindParam = new JSONObject();
            bindParam.put("vehicleIds", StrUtil.join(Cts.COMMA, ids));
            bindParam.put("operation", bind);
            bindParam.put("categoryCode", categoryCode);
            JSONObject jo = HikvisionUtil.bindCarCategory(project, bindParam);
            String rs = jo.toJSONString();
            sendNoticeAndSetStatusForCarInfo("绑定" + FIXED_CAR_GROUP_NAME + "到海康isc", rs, carInfo, 5, bind, null, true);
        } else if (Objects.equals(operation, unbind)) {
            //解绑
            String carId = this.getRemoteCarIdByCarNumber(carInfo.getCarNumber(), project);
            JSONObject param = new JSONObject();
            Object vehicleIds = carId == null ? carInfo.getId() : carId;
            if (vehicleIds == null) {
                return;
            }
            param.put("vehicleIds", vehicleIds);
            param.put("operation", unbind);
            param.put("categoryCode", categoryCode);
            JSONObject jo = HikvisionUtil.bindCarCategory(project, param);
            String rs = jo.toJSONString();
            sendNoticeAndSetStatusForCarInfo("解绑" + FIXED_CAR_GROUP_NAME + "到海康isc", rs, carInfo, 5, 3, null, true);
        }
    }

    /**
     * 获取isc的海康的车辆ids
     *
     * @param project
     * @param carInfo
     * @return
     * @throws Exception
     */
    @NotNull
    private Set<String> getHkCarIds(Project project, CarInfo carInfo) throws Exception {
        JSONObject param = new JSONObject();
        param.putIfAbsent("pageNo", 0);
        param.putIfAbsent("pageSize", 1000);
        JSONArray listJa = new JSONArray();
        int total = 0;
        do {
            param.put("pageNo", param.getInteger("pageNo") + 1);
            JSONObject hkFixCars = HikvisionUtil.getFixCarList(project, param);
            JSONObject jo = HikvisionUtil.getJsonObjectData(hkFixCars);
            total = jo.getInteger("total");
            JSONArray oneList = jo.getJSONArray(LIST);
            listJa.addAll(oneList);
        } while (total > param.getInteger(Cts.PAGE_NO) * 1000);
        List<CarInfo> myFixCars = carInfoMapper.selectList(new LambdaQueryWrapper<CarInfo>()
                .eq(CarInfo::getProjectSn, project.getProjectSn())
                .eq(CarInfo::getCarModuleType, CarInfoCarModuleTypeEnum.GD.getValue())
        );
        Set<String> ids = new HashSet<>();
        Set<String> carNumSet = myFixCars.stream().map(CarInfo::getCarNumber).collect(Collectors.toSet());
        for (int i = 0; i < listJa.size(); i++) {
            JSONObject jo = listJa.getJSONObject(i);
            if (carNumSet.contains(jo.getString("plateNo"))) {
                ids.add(jo.getString("vehicleId"));
            }
        }
        ids.add(carInfo.getId() + "");
        return ids;
    }

    /**
     * 人脸评分
     */
    public boolean faceScore(Project project, JSONObject param) throws Exception {
        final String artemisPath = "/artemis";
        final String path = artemisPath + "/api/frs/v1/face/picture/check";
        String host = "https://" + project.getArtemisConfigHost();
        String rs = HikvisionUtil.doPost(host, path, param.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        if (HikvisionUtil.isSuccess(rs)) {
            JSONObject rsJo = HikvisionUtil.getJsonObjectData(rs);
            return rsJo.getBoolean("checkResult");
        } else {
            return false;
        }
    }

    /**
     * 更新人员权限
     *
     * @param i 0新增，2删除
     */
    public void updatePersonAuth(WorkerInfo workerInfo, String devSn, StringBuilder sucSb, StringBuilder failSb, int i) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, workerInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        UfaceDev dev = ufaceDevMapper.selectOne(new LambdaQueryWrapper<UfaceDev>()
                .eq(UfaceDev::getDevSn, devSn));
        String json = "{\n" +
                "    \"pageNo\": 1,\n" +
                "    \"pageSize\": 1,\n" +
                "\t \"expressions\": [\n" +
                "        {\n" +
                "            \"key\": \"resourceIndexCode\",\n" +
                "            \"operator\": 0,\n" +
                "            \"values\": [\n" +
                "                \"" + devSn + "\"\n" +
                "            ]\n" +
                "        }\n" +
                "    ],\n" +
                "}";
        JSONObject rs = HikvisionUtil.getDoorsV2(project, JSONObject.parseObject(json));
        JSONObject jo = HikvisionUtil.getJsonObjectData(rs);
        JSONArray listJa = jo.getJSONArray(LIST);
        if (CollUtil.isEmpty(listJa)) {
            throw new OpenAlertException("失败信息：isc不存在该设备");
        }
        String channelNo = listJa.getJSONObject(0).getString("channelNo");
        String sdStr = "{\n" +
                "\t\"taskType\": 5,\n" +
                "\t\"resourceInfo\": {\n" +
                "\t\t\"channelNos\": [" + channelNo + "],\n" +
                "\t\t\"resourceIndexCode\": \"" + devSn + "\",\n" +
                "\t\t\"resourceType\": \"door\"\n" +
                "\t},\n" +
                "\t\"personInfo\": {\n" +
                "\t\t\"personId\": \"" + workerInfo.getId() + "\",\n" +
                "\t\t\"operatorType\": " + i + "\n" +
                "\t}\n" +
                "}";
        JSONObject sdRs = HikvisionUtil.downloadSimple(project, sdStr);
        if (HikvisionUtil.isFail(sdRs)) {
            log.error("下发人员权限失败：" + workerInfo.getWorkerName() + "，" + dev.getDevName() + " fail：" + sdRs.toJSONString() + ",");
            String code = sdRs.getString(CODE);
            if (Objects.equals(code, X_15403007)) {
                //已存在权限，下发成功
                updateSucForUpdatePersonAuth(workerInfo, devSn, i);
                sucSb.append(workerInfo.getWorkerName() + "，" + dev.getDevName() + "；");
                return;
            }
            if (Objects.equals(code, X_02401033)) {
                failSb.append(workerInfo.getWorkerName() + "，" + dev.getDevName() + "，失败原因：网络异常；");
            } else {
                failSb.append(workerInfo.getWorkerName() + "，" + dev.getDevName() + "，失败原因：下发异常；");
            }
            return;
        }
        JSONObject sdRsJo = HikvisionUtil.getJsonObjectData(sdRs);
        Integer downloadResult = sdRsJo.getJSONObject("resourceDownloadResult").getInteger("downloadResult");
        if (downloadResult == 0) {
            updateSucForUpdatePersonAuth(workerInfo, devSn, i);
            sucSb.append(workerInfo.getWorkerName() + "，" + dev.getDevName() + "；");
        } else {
            log.error(workerInfo.getWorkerName() + "，" + dev.getDevName() + ",fail：" + sdRsJo.toJSONString());
            failSb.append(workerInfo.getWorkerName() + "，" + dev.getDevName() + "，失败原因：下发异常；");
        }
    }

    /**
     * 为人员权限设置成功下发状态
     *
     * @param workerInfo
     * @param devSn
     * @param i
     */
    private void updateSucForUpdatePersonAuth(WorkerInfo workerInfo, String devSn, int i) {
        updateSuccessStatus(workerInfo.getProjectSn(), workerInfo.getId(), 3, i == 0 ? 1 : 3, devSn);
    }

    /**
     * 需要简单删除权限方法
     *
     * @param workerId
     * @param dev
     * @param project
     * @param flowStartUser
     * @param workerIdMap
     * @param jsonObject
     * @throws Exception
     */
    public void simpleDeletePersonAuth(String workerId, UfaceDev dev, ProjectInfoExtVo project, Long flowStartUser, Map<String, WorkerInfo> workerIdMap, JSONObject jsonObject) throws Exception {
        WorkerInfo workerInfo = workerIdMap.get(workerId);
        String sdStr = "{\n" +
                "\t\"taskType\": 5,\n" +
                "\t\"resourceInfo\": {\n" +
                "\t\t\"channelNos\": [" + jsonObject.getString("channelNo") + "],\n" +
                "\t\t\"resourceIndexCode\": \"" + jsonObject.getString("parentIndexCode") + "\",\n" +
                "\t\t\"resourceType\": \"acsDevice\"\n" +
                "\t},\n" +
                "\t\"personInfo\": {\n" +
                "\t\t\"personId\": \"" + workerId + "\",\n" +
                "\t\t\"operatorType\": 2\n" +
                "\t}\n" +
                "}";
        JSONObject sdRs = HikvisionUtil.downloadSimple(project, sdStr);
        boolean isSuc;
        String exceptionReason = "";
        if (HikvisionUtil.isFail(sdRs)) {
            log.error("下发人员权限失败：" + workerInfo.getWorkerName() + "，" + dev.getDevName() + " fail：" + sdRs.toJSONString() + ",");
            String code = sdRs.getString(CODE);
            if (Objects.equals(code, X_15403007)) {
                //已存在权限，下发成功
                isSuc = true;
            } else if (Objects.equals(code, X_02401033)) {
                isSuc = false;
                exceptionReason = "网络异常";
            } else {
                isSuc = false;
                exceptionReason = "下发异常";
            }
        } else {
            JSONObject sdRsJo = HikvisionUtil.getJsonObjectData(sdRs);
            Integer downloadResult = sdRsJo.getJSONObject("resourceDownloadResult").getInteger("downloadResult");
            isSuc = downloadResult == 0;
            exceptionReason = "下发异常";
        }
        String projectSn = project.getProjectSn();
        if (isSuc) {
            hikvisionCall.updateSuccessStatus(projectSn, Long.valueOf(workerId), 3, 3, dev.getDevSn());
        } else {
            hikvisionCall.updateFailStatus(projectSn, Long.valueOf(workerId), 3, 3, dev.getDevSn());
        }
        Set<Long> noticeUserIds = this.getNoticeUserIds(flowStartUser, projectSn);
        for (Long noticeUserId : noticeUserIds) {
            noticeService.addUserNotice(noticeUserId,
                    "人员下发设备提醒", StrUtil.format("[{}]取消下发到[{}]{}",
                            workerInfo.getWorkerName(),
                            dev.getDevName(),
                            isSuc ? "成功" : "失败，" + exceptionReason),
                    "1");
        }
    }
}