productDev/dmvisit.git

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

			import com.alibaba.fastjson.JSONObject;
			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.haikang.model.HKConstants;
			import com.doumee.core.haikang.model.HKResponseCode;
			import com.doumee.core.haikang.model.param.BaseListPageResponse;
			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.Device;
			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.MemberCard;
			import com.github.yulichang.wrapper.MPJLambdaWrapper;
			import lombok.extern.slf4j.Slf4j;
			import org.apache.commons.lang3.StringUtils;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.stereotype.Service;

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

			@@ -30,53 +40,839 @@
			@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
			&& response.getData().getList() != null
			&& response.getData().getList().size() > 0
			&&response.getData().getList().get(0) !=null){
			TaskPersonDetailResponse model = response.getData().getList().get(0);
			if (model.getPersonDownloadDetail()!=null ) {
			boolean isface = false;//是否人脸下发成功
			boolean iscard = false;//是否有卡片下发成功
			//更新已完成下载任务
			String remark = "";
			String cardInfo ="";
			TaskPersonDetailCardFaceResponse d = model.getPersonDownloadDetail();
			if (d.getCards() != null && d.getCards().size() > 0) {
			for (TaskPersonDetailCardInfoResponse card : d.getCards()) {
			if(StringUtils.equals(card.getErrorCode(),HKResponseCode.ReturnCode.RESPONSE_SUCCEE.getKey())){
			cardInfo += card.getId() + " ";
			iscard=true;
			}
			}
			if(iscard){
			cardInfo = "卡片【"+cardInfo+"】下发成功";
			}else{
			cardInfo = "卡片下发失败";
			}
			}else {
			cardInfo = "卡片下发失败";
			}
			if (d.getFaces() == null \|\| d.getFaces().size() == 0) {
			remark = cardInfo + "，无人脸下发！";
			} else {
			if(d.getFaces().get(0).getErrorCode() !=null && d.getFaces().get(0).getErrorCode().equals(HKConstants.RESPONSE_SUCCEE)){
			isface=true;
			remark = "" + cardInfo + "，人脸下发成功！";
			}else{
			isface=false;
			if(d.getFaces().get(0).getErrorCode()!=null &&
			(d.getFaces().get(0).getErrorCode().equals(HKResponseCode.ReturnCode.RESPONSE_FACE_ERROR.getKey()) \|\|
			d.getFaces().get(0).getErrorCode().equals(HKResponseCode.ReturnCode.RESPONSE_FACE_ERROR2.getKey()))){
			//如果人脸不合格
			memberMapper.update(null,new UpdateWrapper<Member>().lambda()
			.eq(Member::getId,c.getMemberId())
			.set(Member::getFaceStatus,Constants.THREE)
			.set(Member::getEditDate,new Date())
			);
			remark = "" + cardInfo + "，人脸建模失败！";
			}else if(d.getFaces().get(0).getErrorCode()!=null && d.getFaces().get(0).getErrorCode().equals(HKResponseCode.ReturnCode.RESPONSE_DEVICE_NOFAVOR.getKey())){
			//如果设备不支持人脸下发
			isface=true;//此情况不要考虑人脸下发结果
			remark = "" + cardInfo + "，设备不支持人脸下发！";
			}else{
			remark = "" + cardInfo + "，人脸下发失败！";
			}
			}
			}
			//如果返回下发成功或者人脸下发成功并且卡片下发成功
			boolean isSuccess =StringUtils.equals(model.getPersondownloadResult(), "0") \|\| (iscard&&isface);
			empowerMapper.update(null, new UpdateWrapper<Empower>()
			.lambda()
			.eq(Empower::getId, c.getId())
			.set(Empower::getRemark, remark)
			.set(Empower::getEditDate,new Date())
			.set(Empower::getSendInfo, remark)
			.set(Empower::getSendStatus, isSuccess?Constants.EmpowerStatus.pass:Constants.EmpowerStatus.fail));
			if(isSuccess && Constants.equalsInteger(c.getMemberDeleted(), Constants.ONE)&& Constants.equalsInteger(c.getIsdeleted(), Constants.ONE) ){
			//如果是删除权限成功，检查是否删除人员
			checkDelMemberTask(c.getMemberId(),c.getMemberHkId());
			}
			continue;
			}
			}
			//所有异常情况都标记为下发失败
			//如果是已删除的数据，下发失败（防止设备离线），则尝试重新下发任务
			if(Constants.equalsInteger(c.getIsdeleted(), Constants.ONE) ){
			empowerMapper.update(null, new UpdateWrapper<Empower>()
			.lambda()
			.eq(Empower::getId, c.getId())
			.set(Empower::getRemark, "删除权限下发失败")
			.set(Empower::getSendInfo, "删除权限下发失败")
			.set(Empower::getTryNum,Constants.formatIntegerNum(c.getTryNum())+1)
			.set(Empower::getSendStatus, Constants.EmpowerStatus.fail));
			}else{
			empowerMapper.update(null, new UpdateWrapper<Empower>()
			.lambda()
			.eq(Empower::getId, c.getId())
			.set(Empower::getEditDate,new Date())
			.set(Empower::getRemark, "下发失败")
			.set(Empower::getTryNum,Constants.formatIntegerNum(c.getTryNum())+1)
			.set(Empower::getSendInfo, "下发失败")
			.set(Empower::getSendStatus, Constants.EmpowerStatus.fail));
			}
			}
			}catch (Exception e){
			e.printStackTrace();
			}
			}
			});
			t1.start();
			return list.get(list.size()-1).getId();

			}


			/**
			* 对海康删除组织信息
			* @param id
			* @param date
			*/
			public static boolean doHkDeleteUser(Integer id,String delHkIds, Date date ,MemberMapper memberMapper,MemberCardMapper memberCardMapper) {
			if(StringUtils.isBlank(delHkIds)){

			return true;
			}
			UserDelRequest request = new UserDelRequest();
			request.setPersonIds(new String[]{delHkIds});
			BaseResponse<List<UserDelResponse>> result = HKService.delBatchUser(request);
			boolean succes = false;
			if(result !=null && StringUtils.equals(result.getCode(),HKConstants.RESPONSE_SUCCEE)){
			//标记删除成功的数据（海康对接状态为已同步，，同步失败的仍为待同步，等下一次继续处理，知道全部删除完毕）
			if(result.getData()!=null && result.getData().size()>0){
			UserDelResponse tem = result.getData().get(0);
			if(tem!=null && StringUtils.equals(tem.getPersonId(),delHkIds)){
			UserByParamListRequest param = new UserByParamListRequest();
			param.setPersonIds(delHkIds);
			param.setPageNo(1);
			param.setPageSize(2);
			BaseResponse<BaseListPageResponse<UserInfoResponse>> t = HKService.personList(param);
			if(t!=null && t.getData()!=null && t.getData().getTotal() ==0){
			//人员信息已被删除的异常作为已删除成功处理
			succes =true;
			}else{
			//排除人员信息已被删除的异常
			memberMapper.update(null,new UpdateWrapper<Member>().lambda()
			.set(Member::getHkStatus,Constants.TWO)//同步失败
			.set(Member::getRemark,"同步海康删除失败" + JSONObject.toJSONString(result.getData().get(0)))//同步失败
			.set(Member::getHkDate,date)
			.in(Member::getId, id));
			}
			}
			}else{
			//标记删除成功的数据（海康对接状态为已同步，，同步失败的仍为待同步，等下一次继续处理，知道全部删除完毕）
			succes =true;
			}
			if(succes){
			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 succes;
			}

			/**
			* 检查删除人员的权限是否都删除完成，如果权限删除完成，进行海康人员的删除操作
			*/
			private void checkDelMemberTask(Integer memberId,String memberHkid) {
			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,memberId)
			.eq(Empower::getIsdeleted,Constants.ONE)
			.ne(Empower::getFailFlag,Constants.ONE)
			.ne(Empower::getSendStatus,Constants.EmpowerStatus.pass)) ==0){
			//如果权限都已经删除成功，则删除海康人员和卡片数据
			doHkDeleteUser(memberId,memberHkid,date,memberMapper,memberCardMapper);
			// }
			}
			}

			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::getRemark,"任务已下载完成" )
			.set(Empower::getSendStatus,Constants.EmpowerStatus.downloaded) );

			}
			}else if(response!=null
			&& StringUtils.equals(response.getCode(),HKConstants.RESPONSE_SUCCEE)
			&& response.getData()==null){
			empowerMapper.update(null,new UpdateWrapper<Empower>()
			.lambda()
			.eq(Empower::getHkId,c.getHkId() )
			.set(Empower::getSendInfo,"任务已被删除，下发失败" )
			.set(Empower::getRemark,"任务已被删除，下发失败" )
			.set(Empower::getSendStatus,Constants.EmpowerStatus.fail) );
			}
			}
			}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();
			List<Integer> retryIds = new ArrayList<>();
			List<Integer> noIds = new ArrayList<>();
			for(Empower empower:allList){
			//如果是删除的权限下发，查询是否伺候有下发成功的数据，如果有，则不处理
			// int flag= empowerMapper.selectCount(new QueryWrapper<Empower>().lambda()
			// .eq(Empower::getMemberId,empower.getMemberId())
			// .eq(Empower::getDeviceId,empower.getDeviceId() )
			// .gt(Empower::getId,empower.getId())
			// .last("limit 1"));
			if(empower.getTempCouunt() ==0){
			retryIds.add(empower.getId());
			}else{
			//如果之后时间内又重新下发记录，则跳过不做处理
			noIds.add(empower.getId());
			}
			}

			if(retryIds.size()>0){
			empowerMapper.update(null,new UpdateWrapper<Empower>().lambda()
			.set(Empower::getCreateDate,date)
			.set(Empower::getSendStatus,Constants.EmpowerStatus.wait)
			.set(Empower::getEditDate,date)
			.set(Empower::getRemark,"下发失败，待重新下发~")
			.set(Empower::getSendInfo,"下发失败，待重新下发~")
			.in(Empower::getId,retryIds));
			}
			if(noIds.size()>0){
			empowerMapper.update(null,new UpdateWrapper<Empower>().lambda()
			.set(Empower::getEditDate,date)
			.set(Empower::getRemark,"下发失败，已失效~")
			.set(Empower::getSendInfo,"下发失败，已失效~")
			.set(Empower::getFailFlag,Constants.ONE)
			.in(Empower::getId,noIds));
			}
			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;
			//先删除所有需要取消授权的数据
			if(empowerMapper.selectCount(new QueryWrapper<Empower>().lambda()
			.eq(Empower::getSendStatus,Constants.EmpowerStatus.ing)) > 1000){
			//如果当前任务大于1000个（大概10个任务）
			return endId;
			}
			List<Empower> allList =getAllWaitDealList( endId);
			if(allList !=null && allList.size()>0){
			//查询所有需要同步的数据,重新下发最新人员权限即可
			Thread t1=new Thread(new Runnable() {
			@Override
			public void run() {
			dealAllListTask(allList);
			}
			});
			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));
			}
			if(errorList.size()>0){
			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 dealAllListTask(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<>();
			List<Empower> waitList = new ArrayList<>();
			List<Empower> cancelList = new ArrayList<>();
			List<Empower> faceErrorList = new ArrayList<>();
			for(Empower c : list) {
			//向任务添加人员、设备信息数据
			if (Constants.equalsInteger(c.getDeviceDeleted(),Constants.ONE) \|\|
			(Constants.equalsInteger(c.getMemberDeleted(), Constants.ONE) &&
			Constants.equalsInteger(c.getMemberHkStatus(), Constants.ONE))){
			cancelList.add(c);
			continue;
			}
			if(c.getDeviceOnline() !=null && Constants.equalsInteger(c.getDeviceOnline(),0)){
			waitList.add(c);
			continue;
			}
			if( Constants.equalsInteger(c.getMemberFaceStatus(),Constants.THREE)){
			faceErrorList.add(c);
			continue;
			}
			HKConstants.OPERA_TYPE flag = HKConstants.OPERA_TYPE.ADD;
			if(Constants.equalsObject(c.getIsdeleted(),Constants.ONE)){
			flag = HKConstants.OPERA_TYPE.DEL;
			}
			if(addTaskData(c,taskId,flag.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);
			}
			}

			if(errorList.size()>0){
			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);
			}
			}
			if(waitList.size()>0){
			for(Empower model : waitList){
			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);
			}
			}
			if(cancelList.size()>0){
			for(Empower model : cancelList){
			Empower update = new Empower();
			update.setId(model.getId());
			update.setSendDate(date);
			update.setEditDate(date);
			update.setHkId(taskId);
			update.setFailFlag(Constants.ONE);
			update.setSendStatus(Constants.EmpowerStatus.cancel);
			update.setRemark( "设备或人员已删除，取消下发");
			update.setSendInfo( "设备或人员已删除，取消下发");
			empowerMapper.updateById(update);
			}
			}
			if(faceErrorList.size()>0){
			for(Empower model : faceErrorList){
			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 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);
			}
			}

			if(errorList.size()>0){
			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(Member::getFaceStatus,Empower::getMemberFaceStatus);
			queryWrapper.selectAs(Member::getMemberHkStatus,Empower::getMemberHkStatus);
			queryWrapper.selectAs(Device::getOnline,Empower::getDeviceOnline);
			queryWrapper.selectAs(Device::getIsdeleted,Empower::getDeviceDeleted);
			queryWrapper.selectAs(Member::getIsdeleted,Empower::getMemberDeleted);
			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.select(Empower::getId,Empower::getMemberId,Empower::getDeviceId,Empower::getIsdeleted);
			queryWrapper.select(" (select count(1) from empower ee where ee.member_id=t.MEMBER_ID and ee.device_id =t.DEVICE_ID and ee.id>t.id) as tempCouunt");
			queryWrapper.leftJoin(Member.class,Member::getId,Empower::getMemberId);
			queryWrapper.leftJoin(Device.class,Device::getId,Empower::getDeviceId);
			queryWrapper.ne(Member::getFaceStatus,Constants.THREE);//人脸建模没有失败过的
			queryWrapper.ne(Device::getOnline,Constants.ZERO+"");//非离线
			queryWrapper.eq(Empower::getSendStatus,Constants.EmpowerStatus.fail);
			queryWrapper.gt(Empower::getId,endId);
			queryWrapper.and(w-> w.eq( Empower::getFailFlag,Constants.ZERO).or().isNull(Empower::getFailFlag));
			queryWrapper.orderByAsc(Empower::getId );
			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::getIsdeleted,Empower::getMemberDeleted);
			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;
			}


			}