package com.zhgd.xmgl.call;

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 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.zhgd.jeecg.common.api.vo.Result;
import com.zhgd.redis.lock.RedisRepository;
import com.zhgd.xmgl.base.*;
import com.zhgd.xmgl.modules.basicdata.entity.HikvisionRequestRetry;
import com.zhgd.xmgl.modules.basicdata.mapper.HikvisionRequestRetryMapper;
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.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.project.entity.Project;
import com.zhgd.xmgl.modules.project.entity.ProjectVideoConfig;
import com.zhgd.xmgl.modules.project.mapper.ProjectMapper;
import com.zhgd.xmgl.modules.worker.entity.*;
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.IWorkerAttendancePresenceService;
import com.zhgd.xmgl.modules.worker.service.IWorkerAttendanceService;
import com.zhgd.xmgl.modules.worker.service.impl.WorkerAttendanceServiceImpl;
import com.zhgd.xmgl.security.util.SecurityUtils;
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.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Lazy;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.web.bind.annotation.*;
import springfox.documentation.annotations.ApiIgnore;

import java.util.*;
import java.util.concurrent.CompletableFuture;

@Slf4j
@RestController
@RequestMapping("/xmgl/hikvision")
public class HikvisionCall {
    private static String FIXED_CAR_GROUP_NAME = "固定车永久通行";

    @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 HikvisionRequestRetryMapper hikvisionRequestRetryMapper;
    @Autowired
    @Lazy
    private CarTypeMapper carTypeMapper;
    @Autowired
    @Lazy
    private CarInfoMapper carInfoMapper;
    @Autowired
    @Lazy
    private WorkerAttendanceServiceImpl workerAttendanceServiceImpl;
    @Autowired
    private UfaceDevMapper ufaceDevMapper;

    @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");
        if (Objects.equals(method, "OnEventNotify")) {
            JSONObject paramsJo = jsonObject.getJSONObject("params");
            String ability = paramsJo.getString("ability");
            if (Objects.equals(ability, "event_acs")) {
                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 happenTime = jo1.getString("happenTime");
                        String srcIndex = jo1.getString("srcIndex");
                        String extEventPersonNo = dataJo.getString("ExtEventPersonNo");
                        String extEventCardNo = dataJo.getString("ExtEventCardNo");
                        WorkerInfo workerInfo = workerInfoMapper.selectById(extEventPersonNo);
                        if (workerInfo == null) {
                            log.info("未找到该人员信息,extEventPersonNo:{}", extEventPersonNo);
                            return Result.error("未找到该人员信息,extEventPersonNo:" + extEventPersonNo);
                        }
                        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);
                        }
                        HashMap<String, Object> map = new HashMap<>();
                        String time = DateUtil.formatDateTime(DateUtil.parse(happenTime));
                        map.put("passTime", time);
                        map.put("idCard", idCard);
                        Integer count = workerAttendanceMapper.selectCount(new LambdaQueryWrapper<WorkerAttendance>()
                                .eq(WorkerAttendance::getPersonSn, workerInfo.getPersonSn())
                                .eq(WorkerAttendance::getCreateTime, time)
                        );
                        if (count != 0) {
                            continue;
                        }
                        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", srcIndex);
                        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) {
                            e.printStackTrace();
                        }
                        workerAttendanceService.saveExternalPassRecord(map);
                    }
                }
            } 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) {
                            //压线事件
                            CarPassRecord entity = new CarPassRecord();
                            entity.setCarNumber(plateNo);
                            entity.setType(getPassType(carCamera.getPassType()));
                            entity.setPassTime(time);
                            Integer count = carPassRecordMapper.selectCount(new LambdaQueryWrapper<CarPassRecord>()
                                    .eq(CarPassRecord::getCarNumber, plateNo)
                                    .eq(CarPassRecord::getPassTime, time)
                            );
                            if (count != 0) {
                                continue;
                            }

                            try {
                                //车牌
                                JSONObject picUrlJo = dataJo.getJSONObject("picUrl");
                                String svrIndex = dataJo.getString("svrIndex");
                                String vehiclePicUrl = picUrlJo.getString("vehiclePicUrl");
                                String platePicUrl = picUrlJo.getString("platePicUrl");
                                entity.setImageUrl(saveToLocal(getHikvisionEventsPicture(new HikvisionEventsPictureRq(svrIndex, platePicUrl), project.getArtemisConfigHost(), project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret())));
                                entity.setPanoramaUrl(saveToLocal(getHikvisionEventsPicture(new HikvisionEventsPictureRq(svrIndex, vehiclePicUrl), project.getArtemisConfigHost(), project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret())));
                            } catch (Exception e) {
                                e.printStackTrace();
                            }

                            entity.setCarColor(getCarColor(dataJo.getInteger("plateColor")));
                            entity.setLocation(carCamera.getCameraName());
                            entity.setProjectSn(carCamera.getProjectSn());
                            entity.setColor(getColor(dataJo.getInteger("vehicleColor")));
                            entity.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)) {
                                entity.setIsOpen(1);
                            } else {
                                entity.setIsOpen(0);
                            }
                            carPassRecordMapper.insert(entity);
                        }
                    }
                }
            }
        }
        return Result.ok();
    }

    /**
     * 海康请求失败重试定时
     */
    @Scheduled(cron = "4 0 0 * * ?")
    @PostMapping(value = "/failRetry")
    public void failRetry() {
        List<HikvisionRequestRetry> hikvisionRequestRetries = hikvisionRequestRetryMapper.selectList(new LambdaQueryWrapper<HikvisionRequestRetry>()
                .lt(HikvisionRequestRetry::getRequestNum, 4));
        for (HikvisionRequestRetry retry : hikvisionRequestRetries) {
            HikvisionUtil.doPost(retry.getHost(), retry.getPath(), retry.getBody(), null, retry.getAppKey(), retry.getAppSecret(), retry.getId());
        }
    }

    @ApiOperation(value = "按事件类型订阅事件", notes = "按事件类型订阅事件", httpMethod = "POST")
    @PostMapping(value = "/subscribeEvent")
    public Result subscribeEvent(@ApiIgnore @RequestBody SubscribeEventQo qo) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/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);
            if (!redisRepository.setNx("getDoorEvents:projectSn" + projectSn, 1000 * 30L)) {
                return Result.ok("正在同步中请耐心等待通知！");
            }
        }
        List<Project> projects = projectMapper.selectList(queryWrapper);
        if (CollUtil.isEmpty(projects)) {
            return Result.error("项目未配置海康同步功能");
        }
        CompletableFuture.runAsync(() -> {
            for (Project project : projects) {
                List<UfaceDev> ufaceDevs = ufaceDevMapper.selectList(new LambdaQueryWrapper<UfaceDev>()
                        .eq(UfaceDev::getProjectSn, project.getProjectSn()));
                for (UfaceDev ufaceDev : ufaceDevs) {
                    param.put("doorIndexCode", ufaceDev.getDevSn());
                    param.put("pageNo", 1);
                    Integer total = 0;
                    do {
                        String rs = getDoorEventsForHttp(project, param);
                        JSONObject joData = HikvisionUtil.getJSONObjectData(rs);
                        if (joData != null) {
                            total = joData.getInteger("total");
                            if (!Objects.equals(total, 0)) {
                                JSONArray 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<>();
                                    String time = DateUtil.formatDateTime(DateUtil.parse(eventTime));
                                    map.put("passTime", time);
                                    Integer count = workerAttendanceMapper.selectCount(new LambdaQueryWrapper<WorkerAttendance>()
                                            .eq(WorkerAttendance::getPersonSn, workerInfo.getPersonSn())
                                            .eq(WorkerAttendance::getCreateTime, time)
                                    );
                                    if (count != 0) {
                                        continue;
                                    }
                                    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);

                                    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) {
                                        e.printStackTrace();
                                    }
                                    workerAttendanceService.saveExternalPassRecord(map);
                                }
                                param.put("pageNo", param.getIntValue("pageNo") + 1);
                            }
                        }
                    } while (total > 0);
                }
                workerAttendancePresenceService.addNowAllWorkerAttendancePresence(projectSn);
            }
            log.info("服务挂了主动获取门禁点事件的人员通行记录执行完成，startTime：{}，endTime：{}", startTime, endTime);
            if (SecurityUtils.getUser().getUserId() != null) {
                String title = "同步人员通行数据成功";
                String msg = title + ",同步时间段：startTime：" + startTime + "，endTime：" + endTime;
                noticeService.addUserNotice(SecurityUtils.getUser().getUserId(), msg, title, "2");
            }
        });
        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 = "/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);
            if (!redisRepository.setNx("getCrossRecords:projectSn" + projectSn, 1000 * 30L)) {
                return Result.ok("正在同步中请耐心等待通知！");
            }
        }
        List<Project> projects = projectMapper.selectList(queryWrapper);
        if (CollUtil.isEmpty(projects)) {
            return Result.error("项目未配置海康同步功能");
        }
        CompletableFuture.runAsync(() -> {
            for (Project project : projects) {
                param.put("pageNo", 1);
                String projectParkCode = getProjectParkCode(project);
                if (StringUtils.isBlank(projectParkCode)) {
                    continue;
                }
                param.put("parkSyscode", projectParkCode);
                Integer total = 0;
                do {
                    String rs = getCrossRecordsForHttp(project, param);
                    JSONObject joData = HikvisionUtil.getJSONObjectData(rs);
                    if (joData != null) {
                        total = joData.getInteger("total");
                        if (!Objects.equals(total, 0)) {
                            JSONArray 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;
                                }
                                Integer count = carPassRecordMapper.selectCount(new LambdaQueryWrapper<CarPassRecord>()
                                        .eq(CarPassRecord::getCarNumber, plateNo)
                                        .eq(CarPassRecord::getPassTime, time)
                                );
                                if (count != 0) {
                                    continue;
                                }
                                CarPassRecord entity = new CarPassRecord();
                                entity.setCarNumber(plateNo);
                                entity.setType(getPassType(carCamera.getPassType()));
                                entity.setPassTime(time);

                                try {
                                    //车牌
                                    entity.setImageUrl(saveToLocal(getHikvisionEventsPicture(new HikvisionEventsPictureRq(aswSyscode, plateNoPicUri), project.getArtemisConfigHost(), project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret())));
                                    entity.setPanoramaUrl(saveToLocal(getHikvisionEventsPicture(new HikvisionEventsPictureRq(aswSyscode, vehiclePicUri), project.getArtemisConfigHost(), project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret())));
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }

                                entity.setCarColor(getCarColor(listJo.getInteger("plateColor")));
                                entity.setLocation(carCamera.getCameraName());
                                entity.setProjectSn(carCamera.getProjectSn());
                                entity.setColor(getColor(listJo.getInteger("vehicleColor")));
                                entity.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)) {
                                    entity.setIsOpen(1);
                                } else {
                                    entity.setIsOpen(0);
                                }
                                carPassRecordMapper.insert(entity);
                            }
                            param.put("pageNo", param.getIntValue("pageNo") + 1);
                        }
                    }
                } while (total > 0);
            }
            log.info("服务挂了主动获取车辆事件的车辆通行记录执行完成，startTime：{}，endTime：{}", startTime, endTime);
            if (SecurityUtils.getUser().getUserId() != null) {
                String title = "同步车辆通行数据成功";
                String msg = title + ",同步时间段：startTime：" + startTime + "，endTime：" + endTime;
                noticeService.addUserNotice(SecurityUtils.getUser().getUserId(), msg, title, "2");
            }
        });
        return Result.ok("已在后台同步车辆通行数据，请耐心等待！");
    }

    /**
     * 测试查询组织
     *
     * @return
     */
    @GetMapping("/getOrg")
    public Result getOrg() {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, "B717CB992D054A878FDAFB4A5C169947"));
        getOrg(project);
        return null;
    }

    /**
     * 测试查询停车场
     *
     * @return
     */
    @GetMapping("/getPark")
    public Result getParkList() {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, "B717CB992D054A878FDAFB4A5C169947"));
        JSONArray parkList = getParkList(project);
        return null;
    }

    /**
     * 查询车辆列表v2
     *
     * @return
     */
    @GetMapping("/getCarList")
    public Result getCarList() {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, "B717CB992D054A878FDAFB4A5C169947"));
        getCarList(project);
        return null;
    }

    /**
     * 测试获取图片
     *
     * @return
     */
    @GetMapping("/getPic")
    public Result getPic() {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, "B717CB992D054A878FDAFB4A5C169947"));
        String svrIndex = null;
        String platePicUrl = null;
        getHikvisionEventsPicture(new HikvisionEventsPictureRq(svrIndex, platePicUrl), project.getArtemisConfigHost(), project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        return null;
    }

    /**
     * 测试获取人员详情
     *
     * @return
     */
    @GetMapping("/getWorkInfo")
    public Result getWorkInfo() {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, "B717CB992D054A878FDAFB4A5C169947"));
        String svrIndex = null;
        String platePicUrl = null;
        WorkerInfo workerInfo = workerInfoMapper.selectById(1765673550491725825L);
        getWorkerInfo(workerInfo, project);
        return null;
    }

    /**
     * 查询车辆分类
     *
     * @return
     */
    @GetMapping("/categorySearch")
    public Result categorySearch() {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, "B717CB992D054A878FDAFB4A5C169947"));
        String svrIndex = null;
        String platePicUrl = null;
        categorySearch(project);
        return null;
    }

    /**
     * 获取车辆颜色
     *
     * @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 "未识别的车辆颜色";
        }
        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 "其他颜色";
        }
        return null;
    }

    private Integer getPassType(Integer passType) {
        if (passType == null) {
            return null;
        }
        //1进，2出
        switch (passType) {
            case 1:
                return 0;
            case 2:
                return 1;
        }
        return null;
    }


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

    private void addWorkerFromHttp(WorkerInfo workerInfo, Project project) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v2/person/single/add";
        String host = "https://" + project.getArtemisConfigHost();
        String body = getWorkerJson(workerInfo);
        String rs = HikvisionUtil.doPost(host, path, body, null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        sendNoticeForWorker("添加人员到海康isc", rs, workerInfo);
    }


    private 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());
        String fieldAcquisitionUrl = workerInfo.getFieldAcquisitionUrl();
        if (StringUtils.isNotBlank(fieldAcquisitionUrl)) {
            ArrayList<HashMap<String, String>> faceList = new ArrayList<>();
            HashMap<String, String> faceMap = new HashMap<>();
            faceMap.put("faceData", Base64Util.convertFileToBase64(PathUtil.reviseSlash(basePath + "/" + fieldAcquisitionUrl)));
            faceList.add(faceMap);
            jsonBody.put("faces", faceList);
        }
        return jsonBody.toJSONString();
    }

    private String getOrgIndexCode(WorkerInfo workerInfo) {
        if (workerInfo == null) {
            return null;
        }
        if (Objects.equals(workerInfo.getPersonType(), 1)) {
            return String.valueOf(workerInfo.getTeamId());
        } else if (Objects.equals(workerInfo.getPersonType(), 2)) {
            return String.valueOf(workerInfo.getDepartmentId());
        } else if (Objects.equals(workerInfo.getPersonType(), 3)) {
            return String.valueOf(workerInfo.getProjectSn());
        }
        return null;
    }

    /**
     * 编辑人员
     *
     * @param workerInfo
     */
    public void editWorkerForHikvision(WorkerInfo workerInfo) {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, workerInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        JSONObject wiJo = getWorkerInfo(workerInfo, project);
        if (wiJo != null) {
            editWorkerFromHttp(workerInfo, project);

            editWorkerFace(workerInfo, project);
        } else {
            addWorkerForHikvision(workerInfo);
        }
    }

    private void editWorkerFromHttp(WorkerInfo workerInfo, Project project) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/person/single/update";
        String host = "https://" + project.getArtemisConfigHost();
        String body = getWorkerJson(workerInfo);
        String rs = HikvisionUtil.doPost(host, path, body, null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        sendNoticeForWorker("更新人员到海康isc", rs, workerInfo);
    }

    /**
     * 添加人脸
     *
     * @param workerInfo
     * @param project
     */
    private void addWorkerFace(WorkerInfo workerInfo, Project project) {
        String fieldAcquisitionUrl = workerInfo.getFieldAcquisitionUrl();
        if (StringUtils.isNotBlank(fieldAcquisitionUrl)) {
            final String ARTEMIS_PATH = "/artemis";
            final String path = ARTEMIS_PATH + "/api/resource/v1/face/single/add";
            String host = "https://" + project.getArtemisConfigHost();
            JSONObject jo = new JSONObject();
            jo.put("personId", String.valueOf(workerInfo.getId()));
            jo.put("faceData", Base64Util.convertFileToBase64(PathUtil.reviseSlash(basePath + "/" + fieldAcquisitionUrl)));
            String rs = HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
            sendNoticeForWorker("添加人员照片到海康isc", rs, workerInfo);
        }
    }

    private void sendNoticeForCarInfo(String title, String rs, CarInfo carInfo) {
        if (StringUtils.isBlank(rs)) {
            return;
        }
        if (SecurityUtils.getUser().getUserId() != null) {
            boolean success = HikvisionUtil.isSuccess(rs);
            String msg = "";
            String type = "24";
            if (success) {
                msg = "同步成功，车牌号码：" + carInfo.getCarNumber();
                title += "成功";
            } else {
                msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：" + rs;
                title += "失败";
            }
            noticeService.addUserNotice(SecurityUtils.getUser().getUserId(), msg, title, type);
        }
    }

    private void sendNoticeForOrg(String title, String rs, String orgName) {
        if (StringUtils.isBlank(rs)) {
            return;
        }
        if (SecurityUtils.getUser().getUserId() != null) {
            boolean success = HikvisionUtil.isSuccess(rs);
            String msg = "";
            String type = "25";
            if (success) {
                msg = "同步成功，组织名称：" + orgName;
                title += "成功";
            } else {
                msg = "同步失败，组织名称：" + orgName + "。失败原因：" + rs;
                title += "失败";
            }
            noticeService.addUserNotice(SecurityUtils.getUser().getUserId(), msg, title, type);
        }
    }

    private void sendNoticeForWorker(String title, String rs, WorkerInfo workerInfo) {
        if (StringUtils.isBlank(rs)) {
            return;
        }
        if (SecurityUtils.getUser().getUserId() != null) {
            boolean success = HikvisionUtil.isSuccess(rs);
            String msg = "";
            String type = "23";
            if (success) {
                msg = "同步成功，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard();
                title += "成功";
            } else {
                msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：" + rs;
                title += "失败";
            }
            noticeService.addUserNotice(SecurityUtils.getUser().getUserId(), msg, title, type);
        }
    }

    /**
     * 编辑人脸
     *
     * @param workerInfo
     * @param project
     */
    private void editWorkerFace(WorkerInfo workerInfo, Project project) {
        ArrayList<String> workerFaceIds = getWorkerFaceIds(workerInfo, project);
        if (CollUtil.isNotEmpty(workerFaceIds)) {
            String workerFaceId = workerFaceIds.get(0);
            final String ARTEMIS_PATH = "/artemis";
            final String path = ARTEMIS_PATH + "/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());
            sendNoticeForWorker("更新人员照片到海康isc", rs, workerInfo);
        } else {
            addWorkerFace(workerInfo, project);
        }
    }

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

        deleteWorkerFromHttp(workerInfo, project);
    }

    private void deleteWorkerFromHttp(WorkerInfo workerInfo, Project project) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/person/batch/delete";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jsonBody = new JSONObject();
        jsonBody.put("personIds", Arrays.asList(workerInfo.getId()));
        String body = jsonBody.toJSONString();
        String rs = HikvisionUtil.doPost(host, path, body, null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        sendNoticeForWorker("删除人员到海康isc", rs, workerInfo);
    }

    private void deleteWorkerFace(WorkerInfo workerInfo, Project project) {
        ArrayList<String> workerFaceIds = getWorkerFaceIds(workerInfo, project);
        if (CollUtil.isNotEmpty(workerFaceIds)) {
            for (String workerFaceId : workerFaceIds) {
                sendDeleteWorkerFace(project, workerFaceId);
            }
        }
    }

    /**
     * 删除人脸
     *
     * @param project
     * @param workerFaceId
     */
    private void sendDeleteWorkerFace(Project project, String workerFaceId) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/face/single/delete";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        jo.put("faceId", workerFaceId);
        HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
    }

    /**
     * 获取人员人脸id列表
     *
     * @param workerInfo
     * @param project
     * @return
     */
    private ArrayList<String> getWorkerFaceIds(WorkerInfo workerInfo, Project project) {
        JSONObject joData = getWorkerInfo(workerInfo, 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;
    }

    /**
     * 获取单个劳务人员信息，根据人员id
     *
     * @param workerInfo
     * @param project
     * @return
     */
    private JSONObject getWorkerInfo(WorkerInfo workerInfo, Project project) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/person/condition/personInfo";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        jo.put("paramName", "personId");
        jo.put("paramValue", Arrays.asList(String.valueOf(workerInfo.getId())));
        String rs = HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        JSONObject joData = HikvisionUtil.getJSONObjectData(rs);
        if (joData != null) {
            Integer total = joData.getInteger("total");
            if (Objects.equals(total, 1)) {
                JSONArray jsonArray = joData.getJSONArray("list");
                for (int i = 0; i < jsonArray.size(); i++) {
                    JSONObject jsonObject = jsonArray.getJSONObject(i);
                    return jsonObject;
                }
            }
        }
        return null;
    }


    /**
     * 添加车辆
     *
     * @param carInfo
     */
    public void addCarInfoFromHttp(CarInfo carInfo) {
        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.getCarModuleType(), 1)) {
            //固定车
            addCarInfoFromHttp(carInfo, project);

            //绑定固定的群组
            JSONArray ja = categorySearch(project);
            String categoryCode = getFixedCarGroupName(ja);
            if (StringUtils.isNotBlank(categoryCode)) {
                carCategoryBind(project, 1, categoryCode, String.valueOf(carInfo.getId()), carInfo);
            }
        }

        ifReservationCar(project, carInfo);
    }

    private void addCarInfoFromHttp(CarInfo carInfo, Project project) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/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());
        sendNoticeForCarInfo("添加车辆白名单到海康isc", rs, carInfo);
    }

    private String getCarInfoListFromHttp(String carNumber, Project project) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v2/vehicle/advance/vehicleList";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        jo.put("plateNo", carNumber);
        jo.put("pageNo", 1);
        jo.put("pageSize", 1000);
        String rs = HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        return rs;
    }

    private HikvisionCarInfo getHikvisionCarInfo(CarInfo carInfo) {
        HikvisionCarInfo hikvisionCarInfo = new HikvisionCarInfo();
        hikvisionCarInfo.setVehicleId(String.valueOf(carInfo.getId()));
        hikvisionCarInfo.setPlateNo(carInfo.getCarNumber());
        String[] driverList = StringUtils.split(carInfo.getDriverWorkerId(), ",");
        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;
    }

    private String getPlateColor(CarInfo carInfo) {
        String carColor = carInfo.getCarColor();
        if (StringUtils.isBlank(carColor)) {
            return null;
        }
        switch (carColor) {
            case "蓝色":
                return "0";
            case "黄色":
                return "1";
            case "白色":
                return "2";
            case "黑色":
                return "3";
            case "绿色":
                return "4";
            case "民航黑色":
                return "5";
            case "其他颜色":
                return "255";
        }
        return null;
    }

    private String getVehicleType(CarInfo carInfo) {
        String carTypeName = carInfoMapper.getCarTypeName(carInfo);
        switch (carTypeName) {
            case "其他车":
                return "0";
            case "小型车":
                return "1";
            case "大型车":
                return "2";
            case "摩托车":
                return "3";
        }
        return null;
    }

    private String getVehicleColor(String carColor) {
        if (StringUtils.isBlank(carColor)) {
            return null;
        }
        switch (carColor) {
            case "其他颜色":
                return "0";
            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
     */
    public void editCarInfoForHikvision(CarInfo carInfo) {
        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.getCarModuleType(), 1)) {
            //固定车，需要添加群组
            String rs = getCarInfoListFromHttp(carInfo.getCarNumber(), project);
            JSONObject dJo = HikvisionUtil.getJSONObjectData(rs);
            if (dJo != null) {
                Integer total = dJo.getInteger("total");
                if (total > 0) {
                    editCarInfoFromHttp(carInfo, project);
                } else {
                    addCarInfoFromHttp(carInfo, project);
                }
            }

            //绑定车辆群组
            ifBindGroup(project, 1, carInfo);
        } else if (Objects.equals(carInfo.getCarModuleType(), 2)) {
            //解绑车辆群组
            ifBindGroup(project, 2, carInfo);

            deleteCarInfoForHikvision(carInfo, project);
        }
        //预约车辆
        ifReservationCar(project, carInfo);
    }

    private void editCarInfoFromHttp(CarInfo carInfo, Project project) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/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());
        sendNoticeForCarInfo("更新车辆白名单到海康isc", rs, carInfo);
    }

    private void ifBindGroup(Project project, int operation, CarInfo carInfo) {
        JSONArray ja = categorySearch(project);
        String categoryCode = getFixedCarGroupName(ja);
        if (StringUtils.isBlank(categoryCode)) {
            carCategoryBind(project, operation, categoryCode, String.valueOf(carInfo.getId()), 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");
                }
            }
        }
        return null;
    }

    /**
     * 删除车辆
     *
     * @param carInfo
     */
    public void deleteCarInfoForHikvision(CarInfo carInfo) {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, carInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        deleteCarInfoForHikvision(carInfo, project);

        deleteReservationCarInfo(carInfo, project);
    }

    private void deleteCarInfoForHikvision(CarInfo carInfo, Project project) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/vehicle/batch/delete";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        ArrayList<String> list = new ArrayList<>();
        list.add(String.valueOf(carInfo.getId()));
        jo.put("vehicleIds", list);
        String rs = HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        sendNoticeForCarInfo("删除车辆白名单到海康isc", rs, carInfo);
    }

    /**
     * 取消车位预约
     *
     * @param carInfo
     * @param project
     */
    private void deleteReservationCarInfo(CarInfo carInfo, Project project) {
        try {
            final String ARTEMIS_PATH = "/artemis";
            final String path = ARTEMIS_PATH + "/api/pms/v1/parkingSpace/reservations/deletion";
            String host = "https://" + project.getArtemisConfigHost();
            JSONArray reservationCarInfoList = getReservationCarInfoList(carInfo, project);
            if (reservationCarInfoList != null) {
                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());
                    sendNoticeForCarInfo("取消车位预约到海康isc", rs, carInfo);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 查询预约记录v2
     *
     * @param carInfo
     * @param project
     */
    private JSONArray getReservationCarInfoList(CarInfo carInfo, Project project) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/pms/v2/reserveRecord/page";
        String host = "https://" + project.getArtemisConfigHost();
        HikvisionReservationCarInfo info = getHikvisionReservationCarInfoObj(carInfo, project);
        String rs = HikvisionUtil.doPost(host, path, JSON.toJSONString(info), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        try {
            JSONObject jsonObjectData = HikvisionUtil.getJSONObjectData(rs);
            return jsonObjectData.getJSONArray("list");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    private HikvisionReservationCarInfo getHikvisionReservationCarInfoObj(CarInfo carInfo, Project project) {
        JSONArray parkList = getParkList(project);
        HikvisionReservationCarInfo hikvisionReservationCarInfo = new HikvisionReservationCarInfo();
        if (parkList != null && parkList.size() > 0) {
            JSONObject jo = parkList.getJSONObject(0);
            String parkIndexCode = jo.getString("parkIndexCode");
            hikvisionReservationCarInfo.setParkSyscode(parkIndexCode);
            hikvisionReservationCarInfo.setPlateNo(carInfo.getCarNumber());
        }
        //hikvisionReservationCarInfo.setResvState();
        //hikvisionReservationCarInfo.setResvWay();
        //hikvisionReservationCarInfo.setAllowTimes();
        //hikvisionReservationCarInfo.setIsCharge();
        //hikvisionReservationCarInfo.setStartTime();
        //hikvisionReservationCarInfo.setEndTime();
        hikvisionReservationCarInfo.setPageNo(1L);
        hikvisionReservationCarInfo.setPageSize(999L);
        return hikvisionReservationCarInfo;
    }


    /**
     * 获取图片
     *
     * @param rq
     * @param artemisConfigHost
     * @param artemisConfigAppKey
     * @param artemisConfigAppSecret
     * @return
     */
    public static String getHikvisionEventsPicture(HikvisionEventsPictureRq rq, String artemisConfigHost, String
            artemisConfigAppKey, String artemisConfigAppSecret) {//获取视频事件的图片
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/video/v1/events/picture";
        String host = "https://" + artemisConfigHost;
        String body = JSONObject.toJSONString(rq);
        String rs = HikvisionUtil.doPost(host, path, body, null, artemisConfigAppKey, artemisConfigAppSecret);
        if (rs == null) {
            return null;
        }
        JSONObject rsJo = JSONObject.parseObject(rs);
        String code = rsJo.getString("code");
        if (Objects.equals(code, "0")) {
            return rsJo.getJSONObject("data").getString("picUrl");
        }
        return null;
    }

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

    private HikvisionOrganization getHikvisionOrganization(EnterpriseInfo enterpriseInfo) {
        HikvisionOrganization hikvisionOrganization = new HikvisionOrganization();
        hikvisionOrganization.setClientId(null);
        hikvisionOrganization.setOrgIndexCode(String.valueOf(enterpriseInfo.getId()));
        hikvisionOrganization.setOrgName(enterpriseInfo.getEnterpriseName());
        hikvisionOrganization.setParentIndexCode(enterpriseInfo.getProjectSn());
        return hikvisionOrganization;
    }

    /**
     * 更新组织
     *
     * @param enterpriseInfo
     */
    public void editEnterpriseInfoForHikvision(EnterpriseInfo enterpriseInfo) {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, enterpriseInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        HikvisionOrganization hikvisionOrganization = getHikvisionOrganization(enterpriseInfo);
        editOrgFromHttp(project, hikvisionOrganization);
    }

    /**
     * 删除组织
     *
     * @param enterpriseId
     * @param projectSn
     */
    public void deleteEnterpriseInfoForHikvision(String enterpriseId, String projectSn) {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, projectSn));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/org/batch/delete";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        jo.put("indexCodes", Arrays.asList(enterpriseId));
        String rs = HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        EnterpriseInfo enterpriseInfo = enterpriseInfoMapper.selectById(enterpriseId);
        if (enterpriseInfo != null) {
            sendNoticeForOrg("删除组织到海康isc", rs, enterpriseInfo.getEnterpriseName());
        }
    }

    /**
     * 添加组织
     *
     * @param teamInfo
     */
    public void addTeamInfoForHikvision(TeamInfo teamInfo) {
        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);
        addOrgFromHttp(project, hikvisionOrganization);
    }

    private HikvisionOrganization getHikvisionOrganization(TeamInfo teamInfo) {
        HikvisionOrganization hikvisionOrganization = new HikvisionOrganization();
        hikvisionOrganization.setClientId(null);
        hikvisionOrganization.setOrgIndexCode(String.valueOf(teamInfo.getId()));
        hikvisionOrganization.setOrgName(teamInfo.getTeamName());
        hikvisionOrganization.setParentIndexCode(String.valueOf(teamInfo.getEnterpriseId()));
        return hikvisionOrganization;
    }

    /**
     * 编辑组织
     *
     * @param teamInfo
     */
    public void editTeamInfoForHikvision(TeamInfo teamInfo) {
        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);
        editOrgFromHttp(project, hikvisionOrganization);
    }

    private void editOrgFromHttp(Project project, HikvisionOrganization hikvisionOrganization) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/org/single/update";
        String host = "https://" + project.getArtemisConfigHost();
        String rs = HikvisionUtil.doPost(host, path, JSONArray.toJSONString(hikvisionOrganization), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        sendNoticeForOrg("更新组织到海康isc", rs, hikvisionOrganization.getOrgName());
    }

    private void deleteOrgFromHttp(Project project, List<Long> idList, String orgName) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/org/batch/delete";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        jo.put("indexCodes", idList);
        String rs = HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        sendNoticeForOrg("删除组织到海康isc", rs, orgName);
    }

    private void addOrgFromHttp(Project project, HikvisionOrganization hikvisionOrganization) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/org/batch/add";
        String host = "https://" + project.getArtemisConfigHost();
        ArrayList<HikvisionOrganization> list = new ArrayList<>();
        list.add(hikvisionOrganization);
        String rs = HikvisionUtil.doPost(host, path, JSON.toJSONString(list), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        sendNoticeForOrg("添加组织到海康isc", rs, hikvisionOrganization.getOrgName());
    }

    /**
     * 删除组织
     *
     * @param teamInfo
     */
    public void deleteTeamInfoForHikvision(TeamInfo teamInfo) {
        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(teamInfo.getId()), teamInfo.getTeamName());
    }

    /**
     * 添加组织
     *
     * @param departmentInfo
     */
    public void addDepartmentInfoForHikvision(DepartmentInfo departmentInfo) {
        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);
        addOrgFromHttp(project, hikvisionOrganization);
    }

    private HikvisionOrganization getHikvisionOrganization(DepartmentInfo departmentInfo) {
        HikvisionOrganization hikvisionOrganization = new HikvisionOrganization();
        hikvisionOrganization.setClientId(null);
        hikvisionOrganization.setOrgIndexCode(String.valueOf(departmentInfo.getId()));
        hikvisionOrganization.setOrgName(departmentInfo.getDepartmentName());
        hikvisionOrganization.setParentIndexCode(String.valueOf(departmentInfo.getEnterpriseId()));
        return hikvisionOrganization;
    }

    /**
     * 编辑组织
     *
     * @param departmentInfo
     */
    public void editDepartmentInfoForHikvision(DepartmentInfo departmentInfo) {
        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);
        editOrgFromHttp(project, hikvisionOrganization);
    }

    /**
     * 删除组织
     *
     * @param departmentInfo
     */
    public void deleteDepartmentInfoForHikvision(DepartmentInfo departmentInfo) {
        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(departmentInfo.getId()), departmentInfo.getDepartmentName());
    }

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

    /**
     * 获取组织列表
     *
     * @param project
     */
    public void getOrg(Project project) {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/org/orgList";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        jo.put("pageNo", 1);
        jo.put("pageSize", 100);
        String body = jo.toJSONString();
        HikvisionUtil.doPost(host, path, body, null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
    }

    /**
     * 获取停车库列表
     *
     * @param project
     */
    public JSONArray getParkList(Project project) {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return null;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/park/parkList";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        String rs = HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        JSONArray jod = HikvisionUtil.getJSONArrayData(rs);
        if (jod != null) {
            return jod;
        }
        return null;
    }

    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 ifReservationCar(Project project, CarInfo carInfo) {
        try {
            //删除预约车辆
            deleteReservationCarInfo(carInfo, project);

            //临时车辆预约
            if (Objects.equals(carInfo.getCarModuleType(), 2)) {
                reservationCarFromHttp(project, carInfo);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void reservationCarFromHttp(Project project, CarInfo carInfo) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/pms/v2/parkingSpace/reservations/addition";
        String host = "https://" + project.getArtemisConfigHost();
        ParkReservation parkReservation = getParkReservation(project, carInfo);
        if (parkReservation != null) {
            String rs = HikvisionUtil.doPost(host, path, JSON.toJSONString(parkReservation), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
            sendNoticeForCarInfo("添加预约车辆到海康isc", rs, carInfo);
        }
    }

    private ParkReservation getParkReservation(Project project, CarInfo carInfo) {
        String parkIndexCode = getProjectParkCode(project);
        if (StringUtils.isNotBlank(parkIndexCode)) {
            WorkerInfo workerInfo = workerInfoMapper.selectById(carInfo.getDriverWorkerId());
            ParkReservation parkReservation = new ParkReservation();
            parkReservation.setParkSyscode(parkIndexCode);
            parkReservation.setPlateNo(carInfo.getCarNumber());
            if (workerInfo != null) {
                parkReservation.setPhoneNo(workerInfo.getPhoneNumber());
                parkReservation.setOwner(workerInfo.getWorkerName());
            }
            parkReservation.setAllowTimes(Convert.toLong(carInfo.getEntryAndExitPermit()));
            parkReservation.setIsCharge("0");
            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;
        }
        return null;
    }

    /**
     * 获取项目名称的停车场的parkIndexCode，没有一样名字的就取第一个停车场
     *
     * @param project
     * @return
     */
    public String getProjectParkCode(Project project) {
        JSONArray parkList = getParkList(project);
        if (parkList != null && parkList.size() > 0) {
            for (int i = 0; i < parkList.size(); i++) {
                JSONObject jo = parkList.getJSONObject(i);
                if (Objects.equals(jo.getString("parkName"), project.getProjectName())) {
                    return jo.getString("parkIndexCode");
                }
            }
            //没有一样名字的就取第一个停车场
            return parkList.getJSONObject(0).getString("parkIndexCode");
        }
        return null;
    }

    public static void main(String[] args) {
        System.out.println(DateUtil.format(new Date(), "yyyy-MM-dd'T'HH:mm:ss+'Z'"));
    }

    /**
     * 查询车辆列表v2
     *
     * @param project
     */
    public void getCarList(Project project) {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v2/vehicle/advance/vehicleList";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        jo.put("pageNo", 1);
        jo.put("pageSize", 1000);
        HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
    }


    public String saveToLocal(String url) {
        if (StringUtils.isBlank(url)) {
            return null;
        }
        String fileName = IdUtil.simpleUUID() + ".png";
        CompletableFuture.runAsync(() -> {
            try {
                X509TrustManagerUtil.downLoadFromUrlHttps(url, fileName, basePath);
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        return fileName;
    }

    /**
     * 车辆群组管理
     *
     * @param project
     * @param operation    绑定操作类型，1绑定、2解绑
     * @param categoryCode 车辆分类标识
     * @param vehicleIds
     * @param carInfo
     */
    public void carCategoryBind(Project project, Integer operation, String categoryCode, String vehicleIds, CarInfo carInfo) {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/pms/v1/car/categoryBind";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        jo.put("vehicleIds", vehicleIds);
        jo.put("operation", operation);
        jo.put("categoryCode", categoryCode);
        String rs = HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        if (Objects.equals(operation, 1)) {
            sendNoticeForCarInfo("绑定固定车辆群组到海康isc", rs, carInfo);
        } else if (Objects.equals(operation, 2)) {
            sendNoticeForCarInfo("解绑固定车辆群组到海康isc", rs, carInfo);
        }
    }

    /**
     * 查询车辆分类
     */
    public JSONArray categorySearch(Project project) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/pms/v1/car/category/search";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        String rs = HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        return HikvisionUtil.getJSONArrayData(rs);
    }


    /**
     * 获取监控点在线状态
     *
     * @param project
     */
    public JSONObject getCameraOnline(Project project) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/nms/v1/online/camera/get";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject requestParam = new JSONObject();
        String rs = HikvisionUtil.doPost(host, path, JSONArray.toJSONString(requestParam), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        if (rs == null) {
            return null;
        }
        JSONObject jod = HikvisionUtil.getJSONObjectData(rs);
        if (jod != null) {
            return jod;
        }
        return null;
    }

    /**
     * 获取编码设备在线状态
     *
     * @param project
     */
    public JSONObject getEncodeDeviceOnline(Project project) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/nms/v1/online/encode_device/get";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject requestParam = new JSONObject();
        String rs = HikvisionUtil.doPost(host, path, JSONArray.toJSONString(requestParam), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        JSONObject jod = HikvisionUtil.getJSONObjectData(rs);
        if (rs == null) {
            return null;
        }
        if (jod != null) {
            return jod;
        }
        return null;
    }

    /**
     * 获取视频质量诊断结果
     *
     * @param config
     */
    public JSONObject getVqdForHikvision(ProjectVideoConfig config, JSONObject requestParam) {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/nms/v1/vqd/list";
        String host = "https://" + config.getAccount() + ":" + config.getPassword();
        String rs = HikvisionUtil.doPost(host, path, JSONArray.toJSONString(requestParam), null, config.getAppId(), config.getAppSecret());
        JSONObject jod = HikvisionUtil.getJSONObjectData(rs);
        if (rs == null) {
            return null;
        }
        if (jod != null) {
            return jod;
        }
        return null;
    }

    /**
     * 查询门禁点事件v2
     *
     * @param project
     * @param param
     */
    public String getDoorEventsForHttp(Project project, JSONObject param) {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return null;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/acs/v2/door/events";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        jo.put("pageNo", param.getIntValue("pageNo"));
        jo.put("pageSize", 1000);
        //ISO8601时间格式
        jo.put("startTime", param.getString("startTime"));
        jo.put("endTime", param.getString("endTime"));
        jo.put("doorIndexCode", param.getString("doorIndexCode"));
        return HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
    }

    /**
     * 查询过车记录
     *
     * @param project
     * @param param
     */
    public String getCrossRecordsForHttp(Project project, JSONObject param) {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return null;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/pms/v1/crossRecords/page";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        jo.put("pageNo", param.getIntValue("pageNo"));
        jo.put("pageSize", 1000);
        //ISO8601时间格式
        jo.put("startTime", param.getString("startTime"));
        jo.put("endTime", param.getString("endTime"));
        jo.put("parkSyscode", param.getString("parkSyscode"));
        return HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
    }
}