整理

nidapeng

2024-03-21 5e22559b6dff23ff58cabe635481956fcc8b80c0

 server/dmvisit_service/src/main/java/com/doumee/service/business/impl/hksync/HkSyncEmpowerServiceImpl.java

@@ -1,23 +1,32 @@
package com.doumee.service.business.impl.hksync;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.doumee.biz.system.SystemDictDataBiz;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.core.haikang.model.HKConstants;
import com.doumee.core.haikang.model.param.BaseResponse;
import com.doumee.core.haikang.model.param.request.VisitAppointmentRequest;
import com.doumee.core.haikang.model.param.respose.VisitAppointmentResponse;
import com.doumee.core.haikang.model.param.request.*;
import com.doumee.core.haikang.model.param.respose.*;
import com.doumee.core.haikang.service.HKService;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.DateUtil;
import com.doumee.dao.business.DeviceMapper;
import com.doumee.dao.business.MemberCardMapper;
import com.doumee.dao.business.MemberMapper;
import com.doumee.dao.business.join.EmpowerJoinMapper;
import com.doumee.dao.business.join.VisitsJoinMapper;
import com.doumee.dao.business.model.Empower;
import com.doumee.dao.business.model.Member;
import com.doumee.dao.business.model.Visits;
import com.doumee.dao.business.model.*;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@@ -30,53 +39,663 @@
@Slf4j
public class HkSyncEmpowerServiceImpl extends HkSyncBaseServiceImpl {
    @Autowired
    private EmpowerJoinMapper empowerJoinMapper;
    private EmpowerJoinMapper empowerMapper;
    @Autowired
    private SystemDictDataBiz systemDictDataBiz;
    @Autowired
    private MemberMapper memberMapper;
    @Autowired
    private DeviceMapper deviceMapper;
    @Autowired
    private MemberCardMapper memberCardMapper;

    /**
     * 同步海康组织信息,根据erp同步组织结果，定时检查需要下发到海康的组织信息
     * 定时查询权限下发任务进度执行结果
     */
    @Override
    public  void syncEmpowerData(){
        if(Constants.DEALING_HK_EMPOWER){
    public  Integer   syncEmpowerDetailData(Integer endId){
//        if(Constants.DEALING_HK_EMPOWER_DETAIL){
//            return   ;
//        }
//        Constants.DEALING_HK_EMPOWER_DETAIL = true;
            //查询所有完成下载，待查询结果的数据记录
            List<Empower>  list = getDealListDetail(endId);
           if(list == null || list.size() ==0){
               return null;
           }
        Thread t1=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    for(Empower c : list){
                        TaskPersonDetailRequest param = new TaskPersonDetailRequest();
                        param.setPageNo(1);
                        param.setPageSize(10);
                        param.setPersonIds(new String[]{c.getMemberHkId()});
                        param.setTaskId(c.getHkId());
                        TaskDataAdditionResourceRequest rec = new TaskDataAdditionResourceRequest();
                        rec.setResourceIndexCode(c.getDeviceIndexCode());
                        rec.setResourceType(c.getDeviceType());
                        param.setResourceInfo(rec);
                        //查询下发状态
                        BaseResponse<TaskPersonDetailListResponse> response = HKService.taskPersoDetail(param);
                        if(response!=null
                                && StringUtils.equals(response.getCode(),HKConstants.RESPONSE_SUCCEE) && response.getData()!=null
                        ) {
                            if (response.getData().getList() != null
                                    && response.getData().getList().size() > 0) {
                                TaskPersonDetailResponse model = response.getData().getList().get(0);
                                if (model != null && StringUtils.equals(model.getPersondownloadResult(), "0")) {
                                    //更新已完成下载任务
                                    String remark = "";
                                    String cardInfo = "卡片下发失败";
                                    TaskPersonDetailCardFaceResponse d = model.getPersonDownloadDetail();
                                    if (d.getCards() != null && d.getCards().size() > 0) {
                                        cardInfo = "卡片：【";
                                        for (TaskPersonDetailCardInfoResponse card : d.getCards()) {
                                            cardInfo += card.getId() + " ";
                                        }
                                        cardInfo += "】下发成功";
                                    }
                                    if (d.getFaces() == null || d.getFaces().size() == 0) {
                                        remark = cardInfo + "， 不支持人脸设备！";
                                    } else {
                                        remark = "" + cardInfo + "，人脸下发成功！";
                                    }
                                    empowerMapper.update(null, new UpdateWrapper<Empower>()
                                            .lambda()
                                            .eq(Empower::getId, c.getId())
                                            .set(Empower::getRemark, remark)
                                            .set(Empower::getSendInfo, remark)
                                            .set(Empower::getSendStatus, Constants.EmpowerStatus.pass));
                                } else {
                                    empowerMapper.update(null, new UpdateWrapper<Empower>()
                                            .lambda()
                                            .eq(Empower::getId, c.getId())
                                            .set(Empower::getRemark, "下发失败")
                                            .set(Empower::getSendInfo, "下发失败")
                                            .set(Empower::getSendStatus, Constants.EmpowerStatus.fail));
                                }
                            } else {
                                //如果是已删除的数据，下发失败（防止设备离线），则尝试重新下发任务
                                if(Constants.equalsInteger(c.getIsdeleted(), Constants.ONE) ){
//                               && Constants.formatIntegerNum(c.getTryNum())+1 < tryNum ){
                              /*      empowerMapper.update(null, new UpdateWrapper<Empower>()
                                            .lambda()
                                            .eq(Empower::getId, c.getId())
                                            .set(Empower::getRemark,  "下发失败，等待重新删除权限")
                                            .set(Empower::getTryNum,Constants.formatIntegerNum(c.getTryNum())+1)
                                            .set(Empower::getSendInfo, "下发失败，等待重新删除权限")
                                            .set(Empower::getSendStatus, Constants.EmpowerStatus.wait));*/
                                    empowerMapper.update(null, new UpdateWrapper<Empower>()
                                            .lambda()
                                            .eq(Empower::getId, c.getId())
                                            .set(Empower::getRemark, "删除权限下发失败")
                                            .set(Empower::getSendInfo, "删除权限下发失败")
                                            .set(Empower::getSendStatus, Constants.EmpowerStatus.fail));
                                }else{
                                    empowerMapper.update(null, new UpdateWrapper<Empower>()
                                            .lambda()
                                            .eq(Empower::getId, c.getId())
                                            .set(Empower::getRemark, "下发失败")
                                            .set(Empower::getSendInfo, "下发失败")
                                            .set(Empower::getSendStatus, Constants.EmpowerStatus.fail));
                                }
                            }
                            checkDelMemberTask(c.getMemberId());
                        }
                    }
                }catch (Exception e){

                }finally {
//                    Constants.DEALING_HK_EMPOWER_DETAIL=false;
                }
            }
        });
        t1.start();
         return list.get(list.size()-1).getId();

    }


    /**
     * 对海康删除组织信息
     * @param id
     * @param date
     */
    private boolean doHkDeleteUser(Integer  id,String delHkIds,  Date date ) {
        if(StringUtils.isBlank(delHkIds)){
            return true;
        }
        UserDelRequest request = new UserDelRequest();
        request.setPersonIds(new String[]{delHkIds});
        BaseResponse<List<UserDelResponse>> result =  HKService.delBatchUser(request);
        if(result !=null && StringUtils.equals(result.getCode(),HKConstants.RESPONSE_SUCCEE)){
            List<String> fIds = new ArrayList<>();
            //标记删除成功的数据（海康对接状态为已同步，，同步失败的仍为待同步，等下一次继续处理，知道全部删除完毕）
            if(result.getData()!=null && result.getData().size()>0){
                log.info("海康删除用户失败：==============="+result.getData().get(0).getPersonId());
                memberMapper.update(null,new UpdateWrapper<Member>().lambda()
                        .set(Member::getHkStatus,Constants.TWO)//同步失败
                        .set(Member::getRemark,"同步海康删除失败")//同步失败
                        .set(Member::getHkDate,date)
                        .in(Member::getId, id));
            }else{
                //标记删除成功的数据（海康对接状态为已同步，，同步失败的仍为待同步，等下一次继续处理，知道全部删除完毕）
                memberMapper.update(null,new UpdateWrapper<Member>().lambda()
                        .set(Member::getHkStatus,Constants.ONE)//同步成功
                        .set(Member::getRemark,"同步海康删除失败")//同步失败
                        .set(Member::getHkDate,date)
                        .in(Member::getId, id));
                //删除所有绑定的卡片信息
                memberCardMapper.delete(new QueryWrapper<MemberCard>().lambda().eq(MemberCard::getMemberId,id));
            }
            return true;
        }
        return false;
    }

    /**
     * 检查删除人员的权限是否都删除完成，如果权限删除完成， 进行海康人员的删除操作
     */
    private void checkDelMemberTask(Integer memberId) {
            Date date = new Date();
            Member member = memberMapper.selectById(memberId);
            if(member!=null && Constants.equalsInteger(member.getIsdeleted(),Constants.ONE) ){
                if(empowerMapper.selectCount(new QueryWrapper<Empower>().lambda()
                        .eq(Empower::getMemberId,member.getId())
                        .eq(Empower::getIsdeleted,Constants.ONE)
                        .ne(Empower::getSendStatus,Constants.EmpowerStatus.pass)) ==0){
                    //如果权限都已经删除成功，则删除海康人员和卡片数据
                     doHkDeleteUser(member.getId(),member.getHkId(),date);
            }
        }
    }

    public  void syncEmpowerDetailDataOld(){
        if(Constants.DEALING_HK_EMPOWER_DETAIL){
            return   ;
        }
        Constants.DEALING_HK_EMPOWER =true;
        Constants.DEALING_HK_EMPOWER_DETAIL = true;
        try {
            //查询所有需要同步的企业数据
            //查询所有完成下载，待查询结果的数据记录
            List<Empower>  list = getDealListDetail(0);
           if(list == null || list.size() ==0){
               return;
           }
           for(Empower c : list){
               AuthItemListRequest param = new AuthItemListRequest();
               param.setPageNo(1);
               param.setPageSize(100);
//               param.setPersonIds(new ArrayList<>());

            MPJLambdaWrapper<Empower> queryWrapper = new MPJLambdaWrapper<>();
            queryWrapper.selectAll(Empower.class);
            queryWrapper.selectAs(Member::getName,Visits::getReceptMemberName)
                        .select("t1.hk_id as receptMemberHkId")
                        .leftJoin(Member.class,Member::getId,Visits::getReceptMemberId);
            queryWrapper.eq(Visits::getStatus,Constants.VisitStatus.pass)//审批通过
                    .eq(Visits::getHkStatus,Constants.ZERO)//未同步到海康
                    .orderByAsc(Visits::getCreateDate);
            List<Empower> list = empowerJoinMapper.selectJoinList(Empower.class,queryWrapper);
            if(list ==null || list.size()==0){
                return;
            }
            Date date = new Date();
            for(Empower c : list) {
                //删除的数据，进行删除
                VisitAppointmentRequest request = new VisitAppointmentRequest();
                BaseResponse<VisitAppointmentResponse> response = HKService.visitAppiontment(request);
                if (response != null
                        && StringUtils.equals(response.getCode(), HKConstants.RESPONSE_SUCCEE)
                        &&response.getData()!=null
                        &&StringUtils.isNotBlank(response.getData().getAppointRecordId())) {
                    //海康下发成功
                    c.setHkId( response.getData().getAppointRecordId());//预约标识
                } else {
                    //海康下发成功
                }
                empowerJoinMapper.updateById(c);
            }
               param.setPersonIds(new String[]{c.getMemberHkId()});
               param.setQueryType(c.getDeviceType());
               TaskDataAdditionResourceRequest rec = new TaskDataAdditionResourceRequest();
               rec.setResourceIndexCode(c.getDeviceIndexCode());
               rec.setResourceType(c.getDeviceType());
//               rec.setChannelNos(c.getDeviceChannelNo().split(","));
               List<TaskDataAdditionResourceRequest> resourceRequests = new ArrayList<>();
               resourceRequests.add(rec);
//               param.setResourceInfos(resourceRequests);
               //查询已下载
//               param.setPersonStatus(new Integer[]{3});
               //查询下发状态
               BaseResponse<AuthItemListResponse> response = HKService.authItemList(param);
               if(response!=null
                       && StringUtils.equals(response.getCode(),HKConstants.RESPONSE_SUCCEE)
                       && response.getData()!=null
                       && response.getData().getList() != null
                       && response.getData().getList().size()>0 ){
                   //更新已完成下载任务
                   empowerMapper.update(null,new UpdateWrapper<Empower>()
                           .lambda()
                           .eq(Empower::getId,c.getId() )
                           .set(Empower::getSendStatus,Constants.EmpowerStatus.pass) );
               }
           }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            Constants.DEALING_HK_EMPOWER =false;
            Constants.DEALING_HK_EMPOWER_DETAIL=false;
        }

    }
    /**
     * 定时查询权限下发任务进度执行结果
     */
    @Override
    public  Integer syncEmpowerResultData(Integer endId){
//        if(Constants.DEALING_HK_EMPOWER_RESULT){
//            return  null ;
//        }
//        Constants.DEALING_HK_EMPOWER_RESULT=true;
            //查询所有执行中得数据
         List<Empower>  list = getIngTaskListResult(Constants.formatIntegerNum(endId));
           if(list == null || list.size() ==0){
               return null;
           }
            Thread t1=new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        for(Empower c : list){
                            TaskProgressRequest param = new TaskProgressRequest();
                            param.setTaskId(c.getHkId());
                            //查询下发状态
                            BaseResponse<TaskProgressNumResponse> response = HKService.taskProgressNum(param);
                            if(response!=null
                                    && StringUtils.equals(response.getCode(),HKConstants.RESPONSE_SUCCEE)
                                    && response.getData()!=null){
                                //更新已完成下载任务
                                if(  response.getData().getIsDownloadFinished() != null
                                        && response.getData().getIsDownloadFinished() ){
                                    empowerMapper.update(null,new UpdateWrapper<Empower>()
                                            .lambda()
                                            .eq(Empower::getHkId,c.getHkId() )
                                            .set(Empower::getSendInfo,"任务已下载完成" )
                                            .set(Empower::getSendStatus,Constants.EmpowerStatus.downloaded) );

                                }
                            }
                        }
                    }catch (Exception e1){
                        e1.printStackTrace();
                    }finally {
                        Constants.DEALING_HK_EMPOWER_RESULT =false;
                    }
                }
            });
            t1.start();
            return list.get(list.size()-1).getId();

    }



    /**
     * 处理人员授权数据，定时下发
     */
    @Override
    public  Integer syncEmpowerFailData(Integer endId) {
        List<Empower> allList =getAllFailDealList( endId);
        if(allList!=null && allList.size()>0){
            Date date = new Date();
            for(Empower empower:allList){
                if(Constants.equalsObject(empower.getIsdeleted(),Constants.ONE)){
                    //如果是删除的权限下发，查询是否伺候有下发成功的数据，如果有，则不处理
                    Empower param = empowerMapper.selectOne(new QueryWrapper<Empower>().lambda()
                            .eq(Empower::getMemberId,empower.getMemberId())
                            .eq(Empower::getDeviceId,empower.getDeviceId() )
                            .gt(Empower::getId,empower.getId())
                            .last("limit 1"));
                    if(empower ==null || Constants.equalsInteger(empower.getIsdeleted(),Constants.ONE)){
//                        addIds.add(did);
                    }
                }
                //更新重新下发次数
                empowerMapper.update(null,new UpdateWrapper<Empower>().lambda()
                        .eq(Empower::getEditDate,date)
                        .setSql("try_num = ifnull(tyr_num,0) +1" )
                        .set(Empower::getSendStatus,Constants.EmpowerStatus.wait)
                        .set(Empower::getSendDate,null)
                        .set(Empower::getEditDate,date)
                        .set(Empower::getRemark,"下发失败，待重新下发~")
                        .set(Empower::getRemark,"下发失败，待重新下发~")
                        .eq(Empower::getId,empower.getId()));
            }
            return allList.get(allList.size()-1).getId();
        }
        return null;
    }
    /**
     * 处理人员授权数据，定时下发
     */
    @Override
    public  Integer syncEmpowerData(Integer endId) {
//        if(Constants.DEALING_HK_EMPOWER){
//            return  null ;
//        }
//        Constants.DEALING_HK_EMPOWER =true;
            //先删除所有需要取消授权的数据
            List<Empower> allList =getAllWaitDealList( endId);
            if(allList !=null && allList.size()>0){
                //查询所有需要同步的数据,重新下发最新人员权限即可
//            dealNewListTask(getDealList(Constants.ZERO,endId));
                List<Empower> dellist = new ArrayList<>();
                List<Empower> addlist = new ArrayList<>();
                for(Empower e : allList){
                    if(Constants.equalsInteger(e.getIsdeleted(),Constants.ONE)){
                        dellist.add(e);
                    }else {
                        addlist.add(e);
                    }
                }
                Thread t1=new Thread(new Runnable() {
                    @Override
                    public void run() {
                        if(dellist!=null &&dellist.size()>0) {
                            dealDelListTask(dellist);
                        }
                        if(addlist!=null &&addlist.size()>0) {
                            dealNewListTask(addlist);
                        }
                    }
                });
                t1.start();
                return allList.get(allList.size()-1).getId();
            }
        return null;
    }
    @Override
    public  void syncEmpowerDataNew(int start,int end) {
        try {
            //先删除所有需要取消授权的数据
            dealDelListTask(getDealList(Constants.ONE,start,end));
            //查询所有需要同步的数据,重新下发最新人员权限即可
            dealNewListTask(getDealList(Constants.ZERO,start,end));
        }catch (Exception e){
            e.printStackTrace();
        }finally {

        }
    }

    /**
     * 分段请求下发权限
     * @param list
     */
    private void dealDelListTask(List<Empower> list) {
        int sublistSize = 100;
        int startIndex = 0;
        int endIndex = sublistSize;

        while (startIndex < list.size()) {
            if (endIndex > list.size()) {
                endIndex = list.size();
            }
            List<Empower> sublist = list.subList(startIndex, endIndex);
            if(sublist.size()>0){
                dealDelListTaskDo(sublist);
            }
            startIndex = endIndex;
            endIndex += sublistSize;
        }
    }
    private void dealDelListTaskDo(List<Empower> list) {
        //按照父级申请分批处理每次申请数据
        if(list ==null || list.size()==0){
            return;
        }
        Date date = new Date();
        //创建任务
        String taskId = hkTaskAddtion();
        List<Integer> successList = new ArrayList<>();
        List<Integer> errorList = new ArrayList<>();
        for(Empower c : list) {
            //向任务添加人员、设备信息数据
            if(addTaskData(c,taskId,HKConstants.OPERA_TYPE.DEL.getKey())){
                successList.add(c.getId());
            }else{
                errorList.add(c.getId());
            }
        }
        if(successList.size()>0){
            //开始执行下发
            boolean status = startTask(taskId);
            empowerMapper.update(null,new UpdateWrapper<Empower>()
                    .lambda()
                    .set(Empower::getSendDate,date)
                    .set(Empower::getEditDate,date)
                    .set(Empower::getSendStatus,status?Constants.EmpowerStatus.ing:Constants.EmpowerStatus.fail)
                    .set(Empower::getHkId,taskId)
                    .set(Empower::getSendInfo,status?"下发任务执行成功":"下发任务执行失败")
                    .set(Empower::getRemark,status?"下发任务执行成功":"下发任务执行失败")
                    .set(Empower::getEditDate,date)
                    .in(Empower::getId,successList));
        }

        empowerMapper.update(null,new UpdateWrapper<Empower>()
                .lambda()
                .set(Empower::getSendStatus,Constants.EmpowerStatus.fail)
                .set(Empower::getSendDate,date)
                .set(Empower::getEditDate,date)
                .set(Empower::getHkId,taskId)
                .set(Empower::getSendInfo, "添加下发任务数据刪除授权失败")
                .set(Empower::getRemark, "添加下发任务数据刪除授权失败")
                .set(Empower::getEditDate,date)
                .in(Empower::getId,errorList));
    }
    public class TaskRuner implements Runnable{
        private    List<Empower> list ;
        @Override
        public void run() {
            dealNewListTask(list);
        }

        public List<Empower> getList() {
            return list;
        }

        public void setList(List<Empower> list) {
            this.list = list;
        }
    }
    private void dealNewListTask(List<Empower> list) {
        //按照父级申请分批处理每次申请数据
        if(list ==null || list.size()==0){
            return;
        }
//        clearAllEmpowerFirst(list);
        Date date = new Date();
        //创建任务
        String taskId = hkTaskAddtion();
        List<Empower> successList = new ArrayList<>();
        List<Empower> errorList = new ArrayList<>();
        for(Empower c : list) {
            //向任务添加人员、设备信息数据
            if(addTaskData(c,taskId,HKConstants.OPERA_TYPE.ADD.getKey())){
                successList.add(c);
            }else{
                errorList.add(c);
            }
        }
        if(successList.size()>0){
            //开始执行下发
            boolean status = startTask(taskId);
            for(Empower model : successList){
                Empower update = new Empower();
                update.setId(model.getId());
                update.setSendDate(date);
                update.setEditDate(date);
                update.setHkId(taskId);
                update.setRemark(status?"下发任务成功":"下发任务失败");
                update.setSendInfo(status?"下发任务成功":"下发任务失败");
                //下发中
                update.setSendStatus(status?Constants.EmpowerStatus.ing:Constants.EmpowerStatus.fail);
                empowerMapper.updateById(update);
            }
        }

        for(Empower model : errorList){
            Empower update = new Empower();
            update.setId(model.getId());
            update.setSendDate(date);
            update.setEditDate(date);
            update.setHkId(taskId);
            update.setSendStatus(Constants.EmpowerStatus.fail);
            update.setRemark( "添加下发任务数据失败");
            update.setSendInfo( "添加下发任务数据失败");
            empowerMapper.updateById(update);
        }


    }

    private void clearAllEmpowerFirst(List<Empower> list) {
        //查询全部数据
        List<Device> allDevice = deviceMapper.selectList(new QueryWrapper<Device>().lambda().isNotNull(Device::getHkId));
        //创建任务
        String taskId = hkTaskAddtion();
        for(Empower c : list) {
            //向任务刪除人员的所有设备信息数据
            addTaskDataAllDel(c.getHkId(),taskId,allDevice);
        }
        startTask(taskId);
    }

    private boolean addTaskData(Empower c,String taskId,int type) {
        if(StringUtils.isBlank(c.getMemberHkId() )
                ||StringUtils.isBlank(c.getDeviceChannelNo())
                ||StringUtils.isBlank(c.getDeviceType())
                ||StringUtils.isBlank(c.getDeviceIndexCode())){
            //必填参数校验
            c.setSendInfo("设备信息不支持授权下发，检查人员是否已下发海康或者设备是否【设备类型、通道号】是否完善");
            c.setRemark("设备信息不支持授权下发，检查人员是否已下发海康或者设备是否【设备类型、通道号】是否完善");
            return  false;
        }
        TaskDataAdditionRequest param = new TaskDataAdditionRequest();
        param.setTaskId(taskId);
        List<TaskDataAdditionResourceRequest> resourceInfos = new ArrayList<>();//   object[]   True   资源对象
        TaskDataAdditionResourceRequest res = new TaskDataAdditionResourceRequest();
        res.setChannelNos(c.getDeviceChannelNo().split(","));
        res.setResourceType(c.getDeviceType());
        res.setResourceIndexCode(c.getDeviceIndexCode());
        resourceInfos.add(res);
        List<TaskDataAdditionPersonRequest> personInfos = new ArrayList<>();
        TaskDataAdditionPersonRequest pinfo = new TaskDataAdditionPersonRequest();
        pinfo.setName(c.getMemberName());
        pinfo.setEndTime(DateUtil.getISO8601Timestamp(c.getEndTime()));
        pinfo.setStartTime(DateUtil.getISO8601Timestamp(c.getStartTime()));
        pinfo.setOperatorType(type);
        pinfo.setPersonId(c.getMemberHkId());
        personInfos.add(pinfo);//
        param.setResourceInfos(resourceInfos);
        param.setPersonInfos(personInfos);

        //--------------卡片添加----------
      /*  if(StringUtils.isNotBlank(c.getCardNos())){
            List<TaskDataAdditionCardRequest> cards = new ArrayList<>();
            for(String s : c.getCardNos().split(",")){
                TaskDataAdditionCardRequest tc = new TaskDataAdditionCardRequest();
                tc.setCard(s);
                tc.setStatus(HKConstants.OPERA_TYPE.ADD.getKey());
                tc.setCardType(HKConstants.CARD_TYPE.NORMAL.getKey());
                cards.add(tc);
            }
            param.setCards(cards);
        }*/
        BaseResponse response =  HKService.taskDataAddition(param);
        if(response!=null
                && StringUtils.equals(response.getCode(),HKConstants.RESPONSE_SUCCEE)){
            return true;
        }else{
            c.setRemark("添加人员、设备通道权限下发数据失败"+(response!=null?response.getMsg():""));
            c.setSendInfo("添加人员、设备通道权限下发数据失败"+(response!=null?response.getMsg():""));
            return  false;
        }
    }
    private List<Empower> getDealList(int del ,Integer endId ) {
        MPJLambdaWrapper<Empower> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper.selectAll(Empower.class);
        queryWrapper.selectAs(Device::getChannelNo,Empower::getDeviceChannelNo);
        queryWrapper.selectAs(Member::getHkId,Empower::getMemberHkId);
        queryWrapper.selectAs(Device::getHkId,Empower::getDeviceIndexCode);
        queryWrapper.selectAs(Device::getResourceType,Empower::getDeviceType);
        queryWrapper.leftJoin(Device.class,Device::getId,Empower::getDeviceId);
        queryWrapper.leftJoin(Member.class,Member::getId,Empower::getMemberId);
        queryWrapper.eq(Empower::getSendStatus,Constants.EmpowerStatus.wait);
//        queryWrapper.eq( Empower::getIsdeleted,del);
        queryWrapper.gt(Empower::getId,endId);
        queryWrapper.orderByAsc(Empower::getId );
//        queryWrapper.orderByAsc(Empower::getCreateDate );
        queryWrapper.last("limit 100");//每次限制下发100个
        List<Empower> list = empowerMapper.selectJoinList(Empower.class,queryWrapper);
        return list;
    }
    private List<Empower> getAllWaitDealList(int endId   ) {
        MPJLambdaWrapper<Empower> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper.selectAll(Empower.class);
        queryWrapper.selectAs(Device::getChannelNo,Empower::getDeviceChannelNo);
        queryWrapper.selectAs(Member::getHkId,Empower::getMemberHkId);
        queryWrapper.selectAs(Device::getHkId,Empower::getDeviceIndexCode);
        queryWrapper.selectAs(Device::getResourceType,Empower::getDeviceType);
        queryWrapper.leftJoin(Device.class,Device::getId,Empower::getDeviceId);
        queryWrapper.leftJoin(Member.class,Member::getId,Empower::getMemberId);
        queryWrapper.eq(Empower::getSendStatus,Constants.EmpowerStatus.wait);
//        queryWrapper.eq( Empower::getIsdeleted,del);
        queryWrapper.gt(Empower::getId,endId);
        queryWrapper.orderByAsc(Empower::getId );
//        queryWrapper.orderByAsc(Empower::getCreateDate );
        queryWrapper.last("limit 100");//每次限制下发100个
        List<Empower> list = empowerMapper.selectJoinList(Empower.class,queryWrapper);
        return list;
    }
    private List<Empower> getAllFailDealList(int endId   ) {
        MPJLambdaWrapper<Empower> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper.selectAll(Empower.class);
        queryWrapper.selectAs(Device::getChannelNo,Empower::getDeviceChannelNo);
        queryWrapper.selectAs(Member::getHkId,Empower::getMemberHkId);
        queryWrapper.selectAs(Device::getHkId,Empower::getDeviceIndexCode);
        queryWrapper.selectAs(Device::getResourceType,Empower::getDeviceType);
        queryWrapper.leftJoin(Device.class,Device::getId,Empower::getDeviceId);
        queryWrapper.leftJoin(Member.class,Member::getId,Empower::getMemberId);
        queryWrapper.eq(Empower::getSendStatus,Constants.EmpowerStatus.fail);
        queryWrapper.gt(Empower::getId,endId);
        queryWrapper.orderByAsc(Empower::getId );
//      queryWrapper.orderByAsc(Empower::getCreateDate );
        queryWrapper.last("limit 100");//每次限制下发100个
        List<Empower> list = empowerMapper.selectJoinList(Empower.class,queryWrapper);
        return list;
    }

    private List<Empower> getDealList(int del ,int start,int end) {
        MPJLambdaWrapper<Empower> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper.selectAll(Empower.class);
        queryWrapper.selectAs(Device::getChannelNo,Empower::getDeviceChannelNo);
        queryWrapper.selectAs(Member::getHkId,Empower::getMemberHkId);
        queryWrapper.selectAs(Device::getHkId,Empower::getDeviceIndexCode);
        queryWrapper.selectAs(Device::getResourceType,Empower::getDeviceType);
        queryWrapper.leftJoin(Device.class,Device::getId,Empower::getDeviceId);
        queryWrapper.leftJoin(Member.class,Member::getId,Empower::getMemberId);
        queryWrapper.eq(Empower::getSendStatus,Constants.EmpowerStatus.wait);
        queryWrapper.eq( Empower::getIsdeleted,del);
        queryWrapper.gt( Empower::getId,start);
        queryWrapper.le( Empower::getId,end);
        queryWrapper.orderByDesc(Empower::getId );
//        queryWrapper.orderByAsc(Empower::getCreateDate );
        queryWrapper.last("limit 100");//每次限制下发100个
        List<Empower> list = empowerMapper.selectJoinList(Empower.class,queryWrapper);
        return list;
    }
    private List<Empower> getDealListDetail(int endId ) {
        MPJLambdaWrapper<Empower> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper.selectAll(Empower.class);
        queryWrapper.selectAs(Device::getChannelNo,Empower::getDeviceChannelNo);
        queryWrapper.selectAs(Member::getHkId,Empower::getMemberHkId);
        queryWrapper.selectAs(Device::getHkId,Empower::getDeviceIndexCode);
        queryWrapper.selectAs(Device::getResourceType,Empower::getDeviceType);
        queryWrapper.leftJoin(Member.class,Member::getId,Empower::getMemberId);
        queryWrapper.leftJoin(Device.class,Device::getId,Empower::getDeviceId);
        queryWrapper.eq(Empower::getSendStatus,Constants.EmpowerStatus.downloaded);
        queryWrapper.isNotNull(Member::getHkId) ;
        queryWrapper.gt(Empower::getId,endId);
        queryWrapper.orderByAsc(Empower::getSendDate);
        queryWrapper.last("limit 100");//每次限制下发100个
        List<Empower> list = empowerMapper.selectJoinList(Empower.class,queryWrapper);
        return list;
    }
    private List<Empower> getIngTaskListResult(int endId) {
        MPJLambdaWrapper<Empower> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper.selectAll(Empower.class);
        queryWrapper.eq(Empower::getSendStatus,Constants.EmpowerStatus.ing);
        queryWrapper.gt(Empower::getId,endId);
        queryWrapper.groupBy(Empower::getHkId);
        queryWrapper.orderByAsc(Empower::getSendDate);
        queryWrapper.last("limit 100");//每次限制下发100个
        List<Empower> list = empowerMapper.selectList(queryWrapper);
        return list;
    }


}