package com.doumee.service.business.impl.hksync.ferp;
|
|
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.config.DataSyncConfig;
|
import com.doumee.core.erp.model.openapi.request.erp.UserFailRequest;
|
import com.doumee.core.haikang.model.HKConstants;
|
import com.doumee.core.haikang.model.param.BaseResponse;
|
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.model.LoginUserInfo;
|
import com.doumee.core.utils.Constants;
|
import com.doumee.core.utils.DESUtil;
|
import com.doumee.core.utils.DateUtil;
|
import com.doumee.core.utils.ImageBase64Util;
|
import com.doumee.dao.business.*;
|
import com.doumee.dao.business.dao.CompanyMapper;
|
import com.doumee.dao.business.join.MemberJoinMapper;
|
import com.doumee.dao.business.model.*;
|
import com.doumee.service.business.ext.ERPSyncService;
|
import com.doumee.service.business.impl.hksync.HkSyncBaseServiceImpl;
|
import com.doumee.service.business.impl.hksync.HkSyncEmpowerServiceImpl;
|
import com.github.yulichang.wrapper.MPJLambdaWrapper;
|
import io.swagger.models.auth.In;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.collections.CollectionUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.*;
|
|
/**
|
* 海康组织人员通过步Service实现
|
* @author 江蹄蹄
|
* @date 2023/11/30 15:33
|
*/
|
@Service
|
@Slf4j
|
public class HkSyncOrgUserToHKServiceImpl extends HkSyncBaseServiceImpl {
|
@Autowired
|
private CompanyMapper companyMapper;
|
|
@Autowired
|
private MemberRoleMapper memberRoleMapper;
|
@Autowired
|
private DeviceRoleMapper deviceRoleMapper;
|
@Autowired
|
private DeviceMapper deviceMapper;
|
@Autowired
|
private EmpowerMapper empowerMapper;
|
@Autowired
|
private ParkBookMapper bookMapper;
|
@Autowired
|
private MemberCardMapper memberCardMapper;
|
@Autowired
|
private MemberJoinMapper memberMapper;
|
@Autowired
|
private MemberMapper memberMapper1;
|
@Autowired
|
private ERPSyncService erpSyncService;
|
@Autowired
|
private SystemDictDataBiz systemDictDataBiz;
|
@Autowired
|
private DataSyncConfig dataSyncConfig;
|
|
/**
|
* 同步海康组织信息,根据erp同步组织结果，定时检查需要下发到海康的组织信息
|
*/
|
@Override
|
public void syncOrgData(LoginUserInfo user){
|
if(Constants.DEALING_HK_ORG ||
|
!(Constants.formatIntegerNum(dataSyncConfig.getOrgUserDataOrigin()) == DataSyncConfig.origin.erp
|
|| Constants.formatIntegerNum(dataSyncConfig.getOrgUserDataOrigin()) == DataSyncConfig.origin.self)){
|
return ;
|
}
|
Constants.DEALING_HK_ORG =true;
|
try {
|
//查询所有需要同步的企业数据
|
String rootOrgId = systemDictDataBiz.queryByCode(Constants.HK_PARAM,Constants.HK_ROOTORG_CODE).getCode();
|
List<Company> list = companyMapper.selectList(new QueryWrapper<Company>()
|
.select("*,(select b.hk_id from company b where company.erp_parent_id = b.erp_id limit 1) as hkParentId")
|
.lambda()
|
.eq(Company::getHkStatus,Constants.ZERO)
|
.orderByAsc(Company::getErpDate));
|
if(list ==null || list.size()==0){
|
return;
|
}
|
Date date = new Date();
|
List<OrgEditRequest> editHkList = new ArrayList<>();
|
List<OrgAddRequest> addList = new ArrayList<>();
|
List<Company> updateList = new ArrayList<>();
|
List<Integer> delIds = new ArrayList<>();
|
List<String> delHKIds = new ArrayList<>();
|
for(Company c : list){
|
if(StringUtils.isBlank(c.getErpParentId())){
|
//如果是erp顶层组织，默认再海康根组织下创建组织
|
c.setHkParentId(rootOrgId);
|
}
|
if(StringUtils.isBlank(c.getHkParentId())){
|
//如果上级海康部门还没同步，则此次不处理
|
continue;
|
}
|
if(StringUtils.isBlank(c.getHkId())){
|
//如果新增同步數據
|
if(Constants.equalsInteger(Constants.ONE,c.getIsdeleted())){
|
//删除的组织，不做处理,海康状态更新为不处理，下次不再处理这个记录
|
c.setHkStatus(Constants.TWO);
|
companyMapper.updateById(c);
|
continue ;
|
}
|
OrgAddRequest m = getOrgAddModel(c,rootOrgId);
|
addList.add(m);
|
c.setHkId(m.getOrgIndexCode());
|
updateList.add(c);
|
}else{
|
if(Constants.equalsInteger(c.getIsdeleted(),Constants.ONE)){
|
//删除的数据，进行删除
|
delIds.add(c.getId());
|
delHKIds.add(c.getHkId());
|
}else{
|
//如果更新
|
editHkList.add(getOrgHkEditModel(c,rootOrgId));
|
}
|
updateList.add(c);
|
}
|
}
|
//处理删除数据
|
doHkDeleteOrg(delIds,delHKIds,date);
|
//处理新增数据
|
doHkAddOrg(updateList,addList,editHkList);
|
}catch (Exception e){
|
e.printStackTrace();
|
}finally {
|
Constants.DEALING_HK_ORG =false;
|
}
|
|
}
|
|
/**
|
* 处理批量新增的海康数据，更新同步数据状态
|
* @param updateList
|
* @param addList
|
*/
|
private void doHkAddOrg(List<Company> updateList, List<OrgAddRequest> addList, List<OrgEditRequest> editHkList) {
|
Date date = new Date();
|
if(addList!=null &&addList.size()>0){
|
//处理新增
|
BaseResponse<OrgOrUserAddResponse> result = HKService.addBatchOrg(addList);
|
if(result !=null && StringUtils.equals(result.getCode(),HKConstants.RESPONSE_SUCCEE)){
|
OrgOrUserAddResponse data = result.getData();
|
if(data.getSuccesses()!=null && data.getSuccesses().size()>0){
|
//处理新增成功的数据，修改海康同步状态
|
for(OrgOrUserAddSuccessResponse r :data.getSuccesses()){
|
Integer index = getCompanyId(updateList,r.getOrgIndexCode());
|
if(index!=null){
|
companyMapper.update(null,new UpdateWrapper<Company>().lambda()
|
.set(Company::getHkStatus,Constants.ONE)
|
.set(Company::getHkDate,date)
|
.set(Company::getHkId,r.getOrgIndexCode())
|
.eq(Company::getId, index) );
|
}
|
}
|
}
|
}
|
}
|
if(editHkList!=null){
|
//执行更新操作
|
List<String> success = new ArrayList<>();
|
List<String> error = new ArrayList<>();
|
for(OrgEditRequest param : editHkList){
|
BaseResponse result = HKService.editOrg(param);
|
if(result !=null && StringUtils.equals(result.getCode(),HKConstants.RESPONSE_SUCCEE)){
|
success.add(param.getOrgIndexCode());
|
}else{
|
error.add(param.getOrgIndexCode());
|
}
|
}
|
if(success.size()>0){
|
companyMapper.update(null,new UpdateWrapper<Company>().lambda()
|
.set(Company::getHkStatus,Constants.ONE)
|
.set(Company::getHkDate,date)
|
.in(Company::getHkId, success) );
|
}
|
if(error.size()>0){
|
companyMapper.update(null,new UpdateWrapper<Company>().lambda()
|
.set(Company::getHkStatus,Constants.TWO)
|
.set(Company::getHkDate,date)
|
.in(Company::getHkId, error) );
|
}
|
}
|
}
|
|
private Integer getCompanyId(List<Company> updateList, String orgIndexCode) {
|
if(updateList!=null && StringUtils.isNotBlank(orgIndexCode)){
|
for(Company c : updateList){
|
if(StringUtils.equals(c.getHkId(),orgIndexCode)){
|
return c.getId();
|
}
|
}
|
}
|
return null;
|
}
|
|
private OrgAddRequest getOrgAddModel(Company c,String rootOrgId) {
|
OrgAddRequest model = new OrgAddRequest();
|
model.setOrgIndexCode(HKConstants.RES_ORG_INDEX+UUID.randomUUID().toString().replace("-",""));
|
model.setOrgName(c.getName()+HKConstants.RES_ORG_NAME_INDEX);
|
// model.setOrgCode(c.getCode());
|
model.setParentIndexCode(c.getHkParentId());
|
return model;
|
|
}
|
private OrgEditRequest getOrgHkEditModel(Company c,String rootOrgId) {
|
OrgEditRequest model = new OrgEditRequest();
|
model.setOrgIndexCode(c.getHkId());
|
model.setOrgName(c.getName());
|
return model;
|
}
|
|
/**
|
* 对海康删除组织信息
|
* @param delIds
|
* @param date
|
*/
|
private void doHkDeleteOrg(List<Integer> delIds,List<String> delHkIds, Date date) {
|
if(delHkIds.size() == 0){
|
return;
|
}
|
OrgDelRequest request = new OrgDelRequest();
|
request.setIndexCodes( delHkIds.toArray(new String[]{}));
|
BaseResponse<List<OrgUpdateFailureResponse>> result = HKService.delBatchOrg(request);
|
if(result !=null && StringUtils.equals(result.getCode(),HKConstants.RESPONSE_SUCCEE)){
|
List<String> fIds = new ArrayList<>();
|
if(result.getData()!=null){
|
for(OrgUpdateFailureResponse r : result.getData()){
|
if(r.getCode().equals("0x00052102")){
|
//不存在的也算删除成功
|
fIds.add(r.getOrgIndexCode());//删除失败的数据集合
|
}
|
}
|
}
|
//标记删除成功的数据（海康对接状态为已同步，，同步失败的仍为待同步，等下一次继续处理，知道全部删除完毕）
|
companyMapper.update(null,new UpdateWrapper<Company>().lambda()
|
.set(Company::getHkStatus,Constants.ONE)
|
.set(Company::getHkDate,date)
|
.set(Company::getHkId,null )
|
.in(Company::getId, delIds)
|
.notIn(fIds.size()>0,Company::getHkId, fIds));
|
companyMapper.update(null,new UpdateWrapper<Company>().lambda()
|
.set(Company::getHkStatus,Constants.TWO)
|
.set(Company::getHkDate,date)
|
.in(Company::getId, delIds)
|
.in(fIds.size()>0,Company::getHkId, fIds));
|
}
|
}
|
|
/**
|
* 同步海康人员信息
|
* @return
|
*/
|
@Override
|
public void syncUserData(LoginUserInfo user){
|
if(Constants.DEALING_HK_USER ||
|
!(Constants.formatIntegerNum(dataSyncConfig.getOrgUserDataOrigin()) == DataSyncConfig.origin.erp
|
|| Constants.formatIntegerNum(dataSyncConfig.getOrgUserDataOrigin()) == DataSyncConfig.origin.self)){
|
return ;
|
}
|
Constants.DEALING_HK_USER =true;
|
try {
|
//查询所有需要同步的企业数据
|
List<Member> list = memberMapper.selectJoinList(Member.class,new MPJLambdaWrapper<Member>()
|
.selectAll(Member.class )
|
.selectAs(Company::getHkId,Member::getHkOrgId)
|
// .isNotNull(Member::getFaceId
|
.leftJoin(Company.class,Company::getId,Member::getCompanyId)
|
.eq(Member::getHkStatus,Constants.ZERO)
|
.eq(Member::getStatus,Constants.ZERO)
|
.eq(Member::getType,Constants.memberType.internal)
|
.notExists("select d.id from empower d where d.member_id=t.id and d.send_status in (1,5)")//排除有正在同步下发任务的数据
|
.orderByAsc(Member::getErpDate));
|
if(list ==null || list.size()==0){
|
return;
|
}
|
Date date = new Date();
|
String path = systemDictDataBiz.queryByCode(Constants.FTP,Constants.FTP_RESOURCE_PATH).getCode()
|
+systemDictDataBiz.queryByCode(Constants.FTP,Constants.MEMBER_IMG).getCode();
|
for(Member c : list){
|
dealMemberInfoBiz(c,date,path) ;
|
}
|
}catch (Exception e){
|
e.printStackTrace();
|
}finally {
|
Constants.DEALING_HK_USER =false;
|
}
|
}
|
/**
|
* 同步海康人员信息
|
* @return
|
*/
|
@Override
|
public void syncMemberDelData(){
|
if(Constants.DEALING_HK_DEL_USER || Constants.formatIntegerNum(dataSyncConfig.getOrgUserDataOrigin()) != DataSyncConfig.origin.erp){
|
return ;
|
}
|
Constants.DEALING_HK_DEL_USER =true;
|
try {
|
dealWaitDelMemberData();//等待删除权限数据的删除下发
|
// dealFailDelMemberData();//处理删除失败数据重新下发
|
}catch (Exception e){
|
e.printStackTrace();
|
}finally {
|
Constants.DEALING_HK_DEL_USER =false;
|
}
|
}
|
|
/**
|
* 处理删除失败数据重新下发
|
*/
|
private void dealFailDelMemberData() {
|
//查询所有需要同步的企业数据
|
List<Member> list = memberMapper.selectJoinList(Member.class,new MPJLambdaWrapper<Member>()
|
.selectAll(Member.class )
|
.eq(Member::getHkStatus,Constants.TWO)//等待下发完成的
|
.eq(Member::getIsdeleted,Constants.ONE)//已删除的
|
.eq(Member::getType,Constants.memberType.internal)
|
.orderByAsc(Member::getEditDate));
|
if(list ==null || list.size()==0){
|
return;
|
}
|
Date date = new Date();
|
for(Member member : list){
|
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::getFailFlag,Constants.ONE)
|
.ne(Empower::getSendStatus,Constants.EmpowerStatus.pass)) ==0) {
|
//如果权限都已经删除成功，则删除海康人员和卡片数据
|
HkSyncEmpowerServiceImpl.doHkDeleteUser(member.getId(),member.getHkId(),new Date(),memberMapper1,memberCardMapper);
|
}
|
}
|
}
|
}
|
|
/**
|
* 等待删除权限数据的删除下发
|
*/
|
private void dealWaitDelMemberData() {
|
//查询所有需要同步的企业数据
|
List<Member> list = memberMapper.selectJoinList(Member.class,new MPJLambdaWrapper<Member>()
|
.selectAll(Member.class )
|
.eq(Member::getHkStatus,Constants.FOUR)//等待下发完成的
|
.eq(Member::getIsdeleted,Constants.ONE)//已删除的
|
.eq(Member::getType,Constants.memberType.internal)
|
.orderByAsc(Member::getEditDate));
|
if(list ==null || list.size()==0){
|
return;
|
}
|
Date date = new Date();
|
for(Member member : list){
|
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::getFailFlag,Constants.ONE)
|
.ne(Empower::getSendStatus,Constants.EmpowerStatus.pass)) ==0) {
|
//如果权限都已经删除成功，则删除海康人员和卡片数据
|
|
HkSyncEmpowerServiceImpl.doHkDeleteUser(member.getId(),member.getHkId(),date,memberMapper1,memberCardMapper);
|
}
|
}
|
}
|
}
|
|
public static List<Integer> getRoleIdByParam( Member member,DeviceRoleMapper deviceRoleMapper) {
|
//查询数据库存在的权限
|
List<DeviceRole> deviceRoleList= deviceRoleMapper.selectList(new QueryWrapper<DeviceRole>().lambda()
|
.eq(DeviceRole::getType,Constants.TWO)
|
.exists("(select b.id from member_role b where b.ROLE_ID = device_role.ID and b.MEMBER_ID="+member.getId()+")"));
|
if(CollectionUtils.isNotEmpty(deviceRoleList)){
|
List<MemberRole> memberRoleList = new ArrayList<>();
|
String ids = "";
|
List<Integer> r = new ArrayList<>();
|
for (int i = 0; i < deviceRoleList.size(); i++) {
|
DeviceRole deviceRole =deviceRoleList.get(i);
|
if(i>0){
|
ids += ",";
|
}
|
String doorids =deviceRole.getDoorIds();
|
if(StringUtils.isNotBlank(doorids)){
|
String[] ss = doorids.split(",");
|
for(String s :ss){
|
try {
|
Integer ts =Integer.parseInt(s);
|
r.add(ts);
|
}catch (Exception e){
|
//脏数据不处理
|
}
|
}
|
|
}
|
}
|
return r;
|
}
|
return null;
|
}
|
|
private static boolean isNorExistInList(Integer ts, List<Integer> list) {
|
for(Integer r :list){
|
if(Constants.equalsInteger(ts,r)){
|
return true;
|
}
|
}
|
return false;
|
}
|
|
@Transactional
|
public boolean dealMemberInfoBiz(Member c, Date date, String path) {
|
if( c.getCompanyId() == null){
|
//如果没有组织不做处理
|
return false;
|
}
|
if(!Constants.equalsInteger(Constants.ONE,c.getIsdeleted()) && StringUtils.isBlank(c.getHkId())){
|
//如果新增同步數據
|
dealUserHkAddBiz(c,date,path);
|
}else{
|
//如果之前已经和海康同步，则更新用户数据以及人脸数据（可能新增人脸 也可能更新人脸）
|
dealUserHkEditBiz(c,date,path);
|
}
|
return false;
|
}
|
private int dealDelMemberRoleEmpower(Member member ) {
|
//待移除权限的设备数据授权记录（针对删除和更新丢失的权限，需要同步下发删除权限）
|
bookMapper.update(null,new UpdateWrapper<ParkBook>().lambda()
|
.eq(ParkBook::getMemberId,member.getId())
|
.set(ParkBook::getRemark,"等待同步删除安防平台")
|
.set(ParkBook::getIsdeleted,Constants.ONE)
|
.eq(ParkBook::getIsdeleted,Constants.ZERO)
|
.set(ParkBook::getHkStatus,Constants.ZERO));
|
//把所有待下发的任务改成 已取消
|
empowerMapper.update(null,new UpdateWrapper<Empower>().lambda()
|
.eq(Empower::getMemberId,member.getId())
|
.eq(Empower::getIsdeleted,Constants.ZERO)
|
.eq(Empower::getSendStatus,Constants.EmpowerStatus.wait)
|
.set(Empower::getIsdeleted,Constants.ONE)
|
.set(Empower::getSendStatus,Constants.EmpowerStatus.cancel));
|
return empowerMapper.update(null,new UpdateWrapper<Empower>().lambda()
|
.eq(Empower::getMemberId,member.getId())
|
.set(Empower::getIsdeleted,Constants.ONE)
|
.notIn(Empower::getSendStatus,Constants.EmpowerStatus.fail)
|
.set(Empower::getRemark,"等待同步删除安防平台")
|
.eq(Empower::getIsdeleted,Constants.ZERO)
|
.eq(Empower::getIsdeleted,Constants.ZERO)
|
.set(Empower::getSendStatus,Constants.ZERO));
|
}
|
private void dealMemberRoleEmpower(Member member ) {
|
//处理新增的人员卡片数据（与海康同步）
|
List<MemberCard> cards = dealMemberHkCard(member);
|
dealMemberRoleEmpowerDo(cards,member,deviceRoleMapper,empowerMapper,deviceMapper);
|
}
|
|
public static void dealMemberRoleEmpowerDo(List<MemberCard> cards1,Member member , DeviceRoleMapper deviceRoleMapper, EmpowerMapper empowerMapper, DeviceMapper deviceMapper) {
|
List<Integer> doorIds = getRoleIdByParam(member,deviceRoleMapper);
|
if(doorIds==null || doorIds.size() == 0){
|
//如果权限清空，则清空人员授权的权限数据
|
empowerMapper.update(null,new UpdateWrapper<Empower>().lambda()
|
.eq(Empower::getMemberId,member.getId())
|
.set(Empower::getIsdeleted,Constants.ONE)
|
.eq(Empower::getIsdeleted,Constants.ZERO)
|
.set(Empower::getSendStatus,Constants.ZERO));
|
return;
|
}
|
// if((cards == null || cards.size() == 0) && StringUtils.isBlank(member.getFaceId())){
|
if( StringUtils.isBlank(member.getFaceId())){
|
//如果没有卡 也没有人脸
|
return;
|
}
|
|
if(Constants.equalsInteger(member.getIsdeleted(),Constants.ZERO)){
|
// && Constants.equalsInteger(member.getHkStatus(),Constants.ONE)){
|
List<Integer> deviceIds =new ArrayList<>();//新设备编码集合
|
List<Empower> list = new ArrayList<>();//新授权记录集合
|
//如果用户是同步海康成功，添加带下发权限（只管理新增或者编辑的）
|
List<Device> deviceList = deviceMapper.selectList(new QueryWrapper<Device>().lambda().in(Device::getId,doorIds));
|
if(deviceList == null || deviceList.size() == 0){
|
return;
|
}
|
for (Device deviceRole:deviceList) {
|
Empower model = new Empower();
|
model.setCreateDate(new Date());
|
model.setMemberId(member.getId());
|
model.setIsdeleted(Constants.ZERO);
|
model.setDeviceId(deviceRole.getId());
|
model.setSendStatus(Constants.ZERO);
|
model.setSendInfo("待同步安防平台");
|
model.setRemark("待同步安防平台");
|
model.setStartTime(member.getStartTime());
|
model.setFailFlag(Constants.ZERO);
|
model.setEndTime(member.getEndTime());
|
//默认给于虚拟卡
|
model.setCardNos(Constants.VIRTUAL_CARD_INDEX+member.getId());
|
model.setSendType(Constants.ZERO);
|
//标记最新的授权设备编码集合
|
deviceIds.add(deviceRole.getId());
|
list.add(model);
|
}
|
//待移除权限的设备数据授权记录（针对删除和更新丢失的权限，需要同步下发删除权限）
|
empowerMapper.update(null,new UpdateWrapper<Empower>().lambda()
|
.eq(Empower::getMemberId,member.getId())
|
.set(Empower::getIsdeleted,Constants.ONE)
|
.eq(Empower::getIsdeleted,Constants.ZERO)
|
.notIn(deviceIds.size()>0,Empower::getDeviceId,deviceIds)
|
.set(Empower::getSendStatus,Constants.ZERO));
|
//导入新增的授权信息
|
if(list.size()>0){
|
//直接覆盖重复的设备权限，直接删除即可
|
empowerMapper.delete(new UpdateWrapper<Empower>().lambda()
|
.eq(Empower::getMemberId,member.getId())
|
.eq(Empower::getIsdeleted,Constants.ZERO)
|
.in(Empower::getDeviceId,deviceIds) );
|
empowerMapper.insert(list);
|
}
|
}
|
}
|
public static void dealChangeDeviceRoleEmpower( Member member ,List<Integer> addDoorIds,List<Integer> delDoorIds, DeviceRoleMapper deviceRoleMapper, EmpowerMapper empowerMapper, DeviceMapper deviceMapper) {
|
if(delDoorIds!=null && delDoorIds.size()>0){
|
//待移除权限的设备数据授权记录（针对删除和更新丢失的权限，需要同步下发删除权限）
|
empowerMapper.update(null,new UpdateWrapper<Empower>().lambda()
|
.eq(Empower::getMemberId,member.getId())
|
.set(Empower::getIsdeleted,Constants.ONE)
|
.eq(Empower::getIsdeleted,Constants.ZERO)
|
.in(Empower::getDeviceId,delDoorIds)
|
.set(Empower::getSendStatus,Constants.ZERO));
|
}
|
if(addDoorIds==null || addDoorIds.size()==0){
|
//待移除权限的设备数据授权记录（针对删除和更新丢失的权限，需要同步下发删除权限）
|
return;
|
}
|
if(StringUtils.isBlank(member.getFaceId())){
|
//如果没有卡 也没有人脸
|
return;
|
}
|
|
List<Integer> deviceIds =new ArrayList<>();//新设备编码集合
|
List<Empower> list = new ArrayList<>();//新授权记录集合
|
if(Constants.equalsInteger(member.getIsdeleted(),Constants.ZERO)
|
&& Constants.equalsInteger(member.getHkStatus(),Constants.ONE)){
|
//如果用户是同步海康成功，添加带下发权限（只管理新增或者编辑的）
|
List<Device> deviceList = deviceMapper.selectList(new QueryWrapper<Device>().lambda().in(Device::getId,addDoorIds));
|
if(deviceList == null || deviceList.size() == 0){
|
return;
|
}
|
for (Device deviceRole:deviceList) {
|
Empower model = new Empower();
|
model.setCreateDate(new Date());
|
model.setMemberId(member.getId());
|
model.setIsdeleted(Constants.ZERO);
|
model.setFailFlag(Constants.ZERO);
|
model.setDeviceId(deviceRole.getId());
|
model.setSendStatus(Constants.ZERO);
|
model.setSendInfo("待同步安防平台");
|
model.setRemark("待同步安防平台");
|
model.setStartTime(member.getStartTime());
|
model.setEndTime(member.getEndTime());
|
//默认给于虚拟卡
|
model.setCardNos(Constants.VIRTUAL_CARD_INDEX+member.getId());
|
model.setSendType(Constants.ZERO);
|
//标记最新的授权设备编码集合
|
deviceIds.add(deviceRole.getId());
|
list.add(model);
|
}
|
}
|
//导入新增的授权信息
|
if(list.size()>0){
|
//直接覆盖重复的设备权限，直接删除即可
|
empowerMapper.delete(new UpdateWrapper<Empower>().lambda()
|
.eq(Empower::getMemberId,member.getId())
|
.eq(Empower::getIsdeleted,Constants.ZERO)
|
.in(Empower::getDeviceId,deviceIds) );
|
empowerMapper.insert(list);
|
}
|
}
|
|
/**
|
* 对人员带开卡数据进行自动开卡操作
|
* @param member
|
* @return
|
*/
|
private List<MemberCard> dealMemberHkCard(Member member) {
|
List<MemberCard> memberCards = memberCardMapper.selectList(new QueryWrapper<MemberCard>().lambda()
|
.eq(MemberCard::getMemberId,member.getId())
|
// .eq(MemberCard::getType,Constants.TWO)
|
.eq(MemberCard::getHkStatus,Constants.ZERO) );
|
if(memberCards==null || memberCards.size()==0){
|
//没有带处理的数据，直接跳过
|
return getNormalCardList(member,memberCardMapper);
|
}
|
|
List<Integer> allCodes = new ArrayList<>();
|
List<String> doneCodes = new ArrayList<>();
|
CardBingdingRequest param = new CardBingdingRequest();
|
if(member.getStartTime() !=null && member.getEndTime()!=null){
|
param.setStartDate(DateUtil.getISO8601Timestamp(member.getStartTime()));
|
param.setEndDate(DateUtil.getISO8601Timestamp(member.getEndTime()));
|
}
|
param.setCardList(new ArrayList<>());
|
for(MemberCard m : memberCards){
|
allCodes.add(m.getId());
|
if(StringUtils.isBlank(m.getCode())){
|
continue;
|
}
|
CardInfoRequest cr = new CardInfoRequest();
|
cr.setCardNo(m.getCode());
|
cr.setOrgIndexCode(member.getHkOrgId());
|
cr.setPersonId(member.getHkId());
|
cr.setCardType(m.getType());
|
param.getCardList().add(cr);
|
}
|
|
//处理新增数据
|
BaseResponse<List<CardInfoResponse>> result = HKService.cardBingding(param);
|
if(result !=null && StringUtils.equals(result.getCode(),HKConstants.RESPONSE_SUCCEE) ){
|
|
// 0x04a12022","msg":"cardNo [1223382985] is exists
|
if(result.getData()!=null ){
|
for(CardInfoResponse r : result.getData()){
|
doneCodes.add(r.getCardNo());
|
}
|
}
|
}
|
if(doneCodes.size()>0){
|
memberCardMapper.update(null,new UpdateWrapper<MemberCard>().lambda()
|
.eq(MemberCard::getMemberId,member.getId())
|
.eq(MemberCard::getHkStatus,Constants.ZERO)
|
.set(MemberCard::getHkStatus,Constants.ONE)
|
.set(MemberCard::getHkDate,new Date())
|
.set(MemberCard::getRemark,"开卡成功")
|
.in(MemberCard::getCode,doneCodes));
|
}
|
memberCardMapper.update(null,new UpdateWrapper<MemberCard>().lambda()
|
.eq(MemberCard::getMemberId,member.getId())
|
.eq(MemberCard::getHkStatus,Constants.ZERO)
|
.set(MemberCard::getHkStatus,Constants.TWO)
|
.set(MemberCard::getRemark,"开卡失败")
|
.set(MemberCard::getHkDate,new Date())
|
.notIn(doneCodes.size()>0,MemberCard::getCode,doneCodes)
|
.in(MemberCard::getId,allCodes));
|
|
return getNormalCardList(member,memberCardMapper);
|
}
|
|
public static List<MemberCard> getNormalCardList(Member member,MemberCardMapper memberCardMapper) {
|
return memberCardMapper.selectList(new QueryWrapper<MemberCard>().lambda()
|
.eq(MemberCard::getMemberId,member.getId())
|
// .eq(MemberCard::getType,Constants.TWO)
|
.eq(MemberCard::getStatus,Constants.MemberCard.normal)
|
.eq(MemberCard::getHkStatus,Constants.ONE) );
|
|
}
|
|
|
/**
|
* 如果之前已经和海康同步，则更新用户数据以及人脸数据（可能新增人脸 也可能更新人脸）
|
* @param c
|
* @param date
|
* @param path
|
*/
|
private void dealUserHkEditBiz(Member c, Date date, String path) {
|
c.setHkStatus(Constants.ONE);
|
if(Constants.equalsInteger(Constants.ONE,c.getIsdeleted())){
|
//处理删除数据（删除之前下发的海康人员权限信息）
|
int rr = dealDelMemberRoleEmpower(c);
|
if(rr >0){
|
//如果有權限待刪除，等待删除完成再删除人员
|
c.setHkStatus(Constants.FOUR );
|
c.setFaceStatus(Constants.ONE);//把异常人脸状态改为正常，用于删除权限数据
|
c.setRemark( "等待删除授权！");
|
c.setEditDate(date);
|
memberMapper.updateById(c);
|
}else{
|
//没有权限直接删除人员
|
HkSyncEmpowerServiceImpl.doHkDeleteUser(c.getId(),c.getHkId(),new Date(),memberMapper1,memberCardMapper);;
|
}
|
}else{
|
//处理修改数据，并且更新人脸
|
UserAddRequest addHkModel = getUserAddModel(c,path,1);//修改
|
//处理新增数据
|
BaseResponse result = HKService.editUser(addHkModel);
|
if(result !=null && StringUtils.equals(result.getCode(),HKConstants.RESPONSE_SUCCEE) ){
|
if(StringUtils.isNotBlank(c.getFaceImg()) && Constants.equalsInteger(c.getFaceStatus(),Constants.ZERO)){
|
//如果有人脸照片，处理人脸照片同步
|
String faceid = dealMemberFace(c,path);
|
if(StringUtils.isBlank(faceid)){
|
noticeErpFail(c,Constants.ZERO,"人脸信息更新失败，请检查人脸照片是否合法！");
|
c.setHkStatus(Constants.TWO);
|
c.setFaceStatus(Constants.TWO);
|
c.setRemark("人脸信息更新失败，请检查人脸照片是否合法！！"+result.getMsg());
|
}else{
|
c.setFaceId(faceid);
|
c.setFaceStatus(Constants.ONE);
|
//如果人脸跟你，重新下发权限数据
|
c.setRemark("人员和人脸信息同步成功"+result.getMsg());
|
dealMemberRoleEmpower(c);
|
}
|
}
|
}else{
|
noticeErpFail(c,Constants.ZERO,"人员信息同步安防平台失败，请修正后重试！");
|
c.setHkStatus(Constants.TWO);
|
c.setRemark("人员信息同步安防平台更新失败，请修正后重试！！"+(result!=null?result.getCode()+result.getMsg():""));
|
}
|
c.setHkDate(date);
|
c.setEditDate(date);
|
memberMapper.updateById(c);
|
}
|
}
|
|
/**
|
* 新用户同步到海康平台
|
* @param c
|
* @param date
|
* @param path
|
* @return
|
*/
|
private boolean dealUserHkAddBiz(Member c, Date date, String path) {
|
if(Constants.equalsInteger(Constants.ONE,c.getIsdeleted())){
|
//删除的组织，不做处理,海康状态更新为不处理，下次不再处理这个记录
|
c.setHkStatus(Constants.TWO);
|
c.setRemark("未同步数据，直接删除");
|
c.setEditDate(date);
|
c.setErpId(c.getErpOrgId()+"_"+UUID.randomUUID().toString());
|
memberMapper.updateById(c);
|
return false;
|
}
|
UserAddRequest addHkModel = getUserAddModel(c,path,0);//新增
|
if(addHkModel == null){
|
//如果人脸数据不正确，下载失败等原因
|
noticeErpFail(c,Constants.ZERO,"人脸照片不存在，获取失败！");
|
c.setHkStatus(Constants.TWO);
|
c.setFaceStatus(Constants.TWO);
|
c.setRemark("人脸照片不存在，获取失败！");
|
c.setHkDate(new Date());
|
memberMapper.updateById(c);
|
return false;
|
}
|
//处理新增数据
|
BaseResponse<UserAddResponse> result = HKService.addUser(addHkModel);
|
if(result!=null && StringUtils.equals(result.getCode(),HKConstants.RESPONSE_SUCCEE) && result.getData()!=null){
|
c.setFaceId(result.getData().getFaceId());
|
if(StringUtils.isNotBlank(c.getFaceId())){
|
c.setFaceStatus(Constants.ONE);
|
}else{
|
c.setFaceStatus(Constants.ZERO);
|
}
|
c.setHkStatus(Constants.ONE);
|
c.setHkId(addHkModel.getPersonId());
|
c.setHkDate(new Date());
|
memberMapper.updateById(c);
|
// dealMemberRoleEmpower(c);
|
return true;
|
}else{
|
noticeErpFail(c,Constants.ZERO,"人员信息同步安防平台失败，请修正后重试！"+result.getCode()+result.getMsg());
|
c.setHkStatus(Constants.TWO);
|
c.setRemark("人员信息同步安防平台失败，请修正后重试！"+(result!=null?result.getMsg():""));
|
c.setHkDate(new Date());
|
memberMapper.updateById(c);
|
return false;
|
}
|
}
|
|
/**
|
* 处理新增或者修改人脸信息
|
* @param c
|
* @param path
|
* @return
|
*/
|
public static String dealMemberFace(Member c,String path) {
|
if(StringUtils.isBlank(c.getFaceId())){
|
BaseResponse<FaceAddOrEditesponse> response = HKService.addFace(getFaceAddModel(c,path));
|
if(response !=null && StringUtils.equals(response.getCode(),HKConstants.RESPONSE_SUCCEE)&& response.getData()!=null ){
|
return response.getData().getFaceId();
|
}
|
}else{
|
FaceEditRequest param =getFaceUpdateModel(c,path);
|
if(param !=null){
|
BaseResponse response = HKService.editFace(param);
|
if(StringUtils.equals(response.getCode(),HKConstants.RESPONSE_SUCCEE) ){
|
return c.getFaceId();
|
}
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 通知erp系统，人员下发同步信息状态失败
|
* @param c
|
* @param type
|
* @param s
|
*/
|
private void noticeErpFail(Member c, int type, String s) {
|
UserFailRequest r = new UserFailRequest();
|
r.setUserId(c.getErpId());
|
r.setInfo(s);
|
r.setType(type);
|
//通知ERP人脸数据不正确
|
erpSyncService.noticeUserFail(r);
|
}
|
/*
|
*//**
|
* 对海康删除组织信息
|
* @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)){
|
//标记删除成功的数据（海康对接状态为已同步，，同步失败的仍为待同步，等下一次继续处理，知道全部删除完毕）
|
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::getHkDate,date)
|
.set(Member::getRemark,"同步海康删除失败:"+ JSONObject.toJSONString(result.getData().get(0) ))
|
.in(Member::getId, id));
|
}else{
|
//标记删除成功的数据（海康对接状态为已同步，，同步失败的仍为待同步，等下一次继续处理，知道全部删除完毕）
|
memberMapper.update(null,new UpdateWrapper<Member>().lambda()
|
.set(Member::getHkStatus,Constants.ONE)//同步成功
|
.set(Member::getHkDate,date)
|
.set(Member::getRemark,"已同步")
|
.in(Member::getId, id));
|
}
|
return true;
|
}
|
return false;
|
}*/
|
|
/**
|
* 删除人员所有设备上的权限信息
|
* @param userId
|
* @param allDevice
|
*/
|
private void delUserHkRolle(String userId,List<Device> allDevice) {
|
//创建任务
|
String taskId = hkTaskAddtion();
|
//
|
if(taskId!=null){
|
//删除所有设备上的权限
|
addTaskDataAllDel(userId,taskId,allDevice);
|
startTask(taskId);
|
}
|
}
|
|
public static UserAddRequest getUserAddModel(Member c,String path,int type) {
|
UserAddRequest model = new UserAddRequest();
|
model.setOrgIndexCode(c.getHkOrgId());
|
model.setJobNo(c.getCode());
|
model.setPhoneNo(c.getPhone());
|
if(StringUtils.isNotBlank(c.getIdcardNo())){
|
model.setCertificateNo(DESUtil.decrypt(Constants.EDS_PWD, c.getIdcardNo()));
|
}
|
model.setCertificateType(HKConstants.CertificateType.SHENFENZHENG.getKey()+"");
|
model.setPersonId(type == 0 ?UUID.randomUUID().toString().replace("-", ""):c.getHkId());
|
model.setGender(Constants.formatIntegerNum(c.getSex())+"");
|
model.setPersonName(c.getName());
|
if(StringUtils.isNotBlank(c.getFaceImg())){
|
model.setFaces(new ArrayList<>());
|
UserAddFaceRequest face = new UserAddFaceRequest();
|
String imageBase = ImageBase64Util.Image2Base64(path+c.getFaceImg());
|
if(imageBase== null){
|
//人脸数据不正确，
|
return null;
|
}
|
face.setFaceData(imageBase);
|
model.getFaces().add(face);
|
}
|
return model;
|
}
|
public static FaceAddRequest getFaceAddModel(Member c,String path) {
|
FaceAddRequest model = new FaceAddRequest();
|
model.setPersonId(c.getHkId());
|
if(StringUtils.isNotBlank(c.getFaceImg())){
|
String imageBase = ImageBase64Util.Image2Base64(path+c.getFaceImg());
|
if(imageBase == null){
|
//人脸数据不正确，
|
return null;
|
}
|
model.setFaceData(imageBase);
|
}
|
return model;
|
}
|
public static FaceEditRequest getFaceUpdateModel(Member c,String path) {
|
FaceEditRequest model = new FaceEditRequest();
|
model.setFaceId(c.getFaceId());
|
if(StringUtils.isNotBlank(c.getFaceImg())){
|
String imageBase = ImageBase64Util.Image2Base64(path+c.getFaceImg());
|
if(imageBase == null){
|
//人脸数据不正确，
|
return null;
|
}
|
model.setFaceData(imageBase);
|
}
|
return model;
|
}
|
|
|
}
|
