by2025/SmartParks
9
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master'
Some checks are pending
Gitea Actions Demo / Explore-Gitea-Actions (push) Waiting to run
Details

Browse Source
This commit is contained in:
yuyongle 2025-07-18 09:22:10 +08:00
commit 9c0591dfaa
15 changed files with 936 additions and 1101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
ruoyi-modules/Sis/src/main/java/org/dromara/sis/sdk/e8/AccessControlService.java
View File

@ -1,51 +0,0 @@
package org.dromara.sis.sdk.e8;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.sis.sdk.e8.domain.QueryDto;
import org.dromara.sis.sdk.e8.domain.accessControl.req.CustomerAuthAddReq;
import org.dromara.sis.sdk.e8.domain.accessControl.req.RemoteOpenDoorReq;
import org.dromara.sis.sdk.e8.domain.accessControl.res.AccessRecordFindRes;
import org.dromara.sis.sdk.e8.domain.accessControl.res.CustomerAuthFindRes;
/**
* @author lsm
* @apiNote AccessControlService
* @since 2025/6/24
*/
public interface AccessControlService {
/**
* 远程开门
*
* @param req 传参
* @return Boolean
*/
Boolean remoteOpenDoor(RemoteOpenDoorReq req);
/**
* 获取通行记录分页列表
*
* @param dto 传参
* @return IPage<AccessRecordFindRes>
*/
TableDataInfo<AccessRecordFindRes> getPageAccessRecordList(QueryDto dto);
/**
* 人员授权
*
* @param req 传参
* @return Boolean
*/
Boolean addCustomerAuth(CustomerAuthAddReq req);
/**
* 获取人员权限分页列表
*
* @param dto 传参
* @return TableDataInfo<CustomerAuthFindRes>
*/
TableDataInfo<CustomerAuthFindRes> getPageCustomerAuth(QueryDto dto);
}

57
ruoyi-modules/Sis/src/main/java/org/dromara/sis/sdk/e8/CustomerService.java
View File

@ -1,57 +0,0 @@
package org.dromara.sis.sdk.e8;
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.dromara.sis.sdk.e8.domain.QueryDto;
import org.dromara.sis.sdk.e8.domain.custom.req.CustomAddReq;
import org.dromara.sis.sdk.e8.domain.custom.req.CustomFindReq;
import org.dromara.sis.sdk.e8.domain.custom.req.CustomUpdateReq;
import org.dromara.sis.sdk.e8.domain.custom.res.CustomAddRes;
import org.dromara.sis.sdk.e8.domain.custom.res.CustomFindRes;
/**
* @author lsm
* @apiNote CustomerService
* @since 2025/6/23
*/
public interface CustomerService {
/**
* 查询单个人员信息
*
* @param findReq 传参
* @return CustomFindRes
*/
CustomFindRes findCustomer(CustomFindReq findReq);
/**
* 人员信息分页查询
*
* @param dto 传参
* @return IPage<CustomFindRes>
*/
IPage<CustomFindRes> findCustomerList(QueryDto dto);
/**
* 新增人员信息
*
* @param addReq 传参
* @return CustomAddRes
*/
CustomAddRes addCustomer(CustomAddReq addReq);
/**
* 人员信息修改
*
* @param updateReq 传参
* @return Boolean
*/
Boolean updateCustomer(CustomUpdateReq updateReq);
/**
* 删除人员信息
*
* @param id 传参
* @return Boolean
*/
Boolean deleteCustomer(Long id);
}

66
ruoyi-modules/Sis/src/main/java/org/dromara/sis/sdk/e8/DoorDeviceService.java
View File

@ -1,66 +0,0 @@
package org.dromara.sis.sdk.e8;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.sis.sdk.e8.domain.door.req.DoorDeviceAddReq;
import org.dromara.sis.sdk.e8.domain.door.req.DoorDeviceUpdateReq;
import org.dromara.sis.sdk.e8.domain.door.res.AuthDoorDeviceFindRes;
import org.dromara.sis.sdk.e8.domain.door.res.DoorDeviceAddRes;
import org.dromara.sis.sdk.e8.domain.door.res.DoorDeviceFindRes;
import org.dromara.sis.sdk.e8.domain.QueryDto;
import java.util.List;
/**
* @author lsm
* @apiNote DoorDeviceService
* @since 2025/6/20
*/
public interface DoorDeviceService {
/**
* 查询门禁信息
*
* @param id 入参
* @return DoorDeviceFindRes
*/
DoorDeviceFindRes findDoorDevice(Long id);
/**
* 门禁信息分页查询
*
* @param dto 入参
* @return IPage<DoorDeviceFindRes>
*/
TableDataInfo<DoorDeviceFindRes> findDoorDeviceList(QueryDto dto);
/**
* 新增门禁信息
*
* @param addReq 入参
* @return DoorDeviceAddRes
*/
DoorDeviceAddRes addDoorDevice(DoorDeviceAddReq addReq);
/**
* 门禁信息修改
*
* @param updateReq 入参
* @return DoorDeviceUpdateRes
*/
Boolean updateDoorDevice(DoorDeviceUpdateReq updateReq);
/**
* 删除门禁信息
*
* @param id 入参
* @return Boolean
*/
Boolean deleteDoorDevice(Long id);
/**
* 分页获取授权门信息
*
* @return TableDataInfo<AuthDoorDeviceFindRes>
*/
List<AuthDoorDeviceFindRes> getPageAuthDoorDeviceList();
}

231
ruoyi-modules/Sis/src/main/java/org/dromara/sis/sdk/e8/E8PlatformApi.java Normal file
View File

@ -0,0 +1,231 @@
package org.dromara.sis.sdk.e8;
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.sis.sdk.e8.domain.QueryDto;
import org.dromara.sis.sdk.e8.domain.accessControl.req.CustomerAuthAddReq;
import org.dromara.sis.sdk.e8.domain.accessControl.req.RemoteOpenDoorReq;
import org.dromara.sis.sdk.e8.domain.accessControl.res.AccessRecordFindRes;
import org.dromara.sis.sdk.e8.domain.accessControl.res.CustomerAuthFindRes;
import org.dromara.sis.sdk.e8.domain.custom.req.CustomAddReq;
import org.dromara.sis.sdk.e8.domain.custom.req.CustomFindReq;
import org.dromara.sis.sdk.e8.domain.custom.req.CustomUpdateReq;
import org.dromara.sis.sdk.e8.domain.custom.res.CustomAddRes;
import org.dromara.sis.sdk.e8.domain.custom.res.CustomFindRes;
import org.dromara.sis.sdk.e8.domain.door.req.DoorDeviceAddReq;
import org.dromara.sis.sdk.e8.domain.door.req.DoorDeviceUpdateReq;
import org.dromara.sis.sdk.e8.domain.door.res.AuthDoorDeviceFindRes;
import org.dromara.sis.sdk.e8.domain.door.res.DoorDeviceAddRes;
import org.dromara.sis.sdk.e8.domain.door.res.DoorDeviceFindRes;
import org.dromara.sis.sdk.e8.domain.lift.req.LiftAddReq;
import org.dromara.sis.sdk.e8.domain.lift.req.LiftUpdateReq;
import org.dromara.sis.sdk.e8.domain.lift.res.LiftFindRes;
import org.dromara.sis.sdk.e8.domain.voucher.req.ChangeCardReq;
import org.dromara.sis.sdk.e8.domain.voucher.req.IssueVoucherReq;
import org.dromara.sis.sdk.e8.domain.voucher.req.OperateVoucherReq;
import java.util.List;
/**
* @author lsm
* @apiNote E8PlatformApi
* @since 2025/7/17
*/
public interface E8PlatformApi {
//***************************************客户信息接口*******************************************/
/**
* 查询单个人员信息
*
* @param findReq 传参
* @return CustomFindRes
*/
CustomFindRes findCustomer(CustomFindReq findReq);
/**
* 人员信息分页查询
*
* @param dto 传参
* @return IPage<CustomFindRes>
*/
IPage<CustomFindRes> findCustomerList(QueryDto dto);
/**
* 新增人员信息
*
* @param addReq 传参
* @return CustomAddRes
*/
CustomAddRes addCustomer(CustomAddReq addReq);
/**
* 人员信息修改
*
* @param updateReq 传参
* @return Boolean
*/
Boolean updateCustomer(CustomUpdateReq updateReq);
/**
* 删除人员信息
*
* @param id 传参
* @return Boolean
*/
Boolean deleteCustomer(Long id);
//***************************************门禁信息接口*******************************************
/**
* 查询门禁信息
*
* @param id 入参
* @return DoorDeviceFindRes
*/
DoorDeviceFindRes findDoorDevice(Long id);
/**
* 门禁信息分页查询
*
* @param dto 入参
* @return IPage<DoorDeviceFindRes>
*/
TableDataInfo<DoorDeviceFindRes> findDoorDeviceList(QueryDto dto);
/**
* 新增门禁信息
*
* @param addReq 入参
* @return DoorDeviceAddRes
*/
DoorDeviceAddRes addDoorDevice(DoorDeviceAddReq addReq);
/**
* 门禁信息修改
*
* @param updateReq 入参
* @return DoorDeviceUpdateRes
*/
Boolean updateDoorDevice(DoorDeviceUpdateReq updateReq);
/**
* 删除门禁信息
*
* @param id 入参
* @return Boolean
*/
Boolean deleteDoorDevice(Long id);
/**
* 分页获取授权门信息
*
* @return TableDataInfo<AuthDoorDeviceFindRes>
*/
List<AuthDoorDeviceFindRes> getPageAuthDoorDeviceList();
/**
* 远程开门
*
* @param req 传参
* @return Boolean
*/
Boolean remoteOpenDoor(RemoteOpenDoorReq req);
/**
* 获取通行记录分页列表
*
* @param dto 传参
* @return IPage<AccessRecordFindRes>
*/
TableDataInfo<AccessRecordFindRes> getPageAccessRecordList(QueryDto dto);
/**
* 人员授权
*
* @param req 传参
* @return Boolean
*/
Boolean addCustomerAuth(CustomerAuthAddReq req);
/**
* 获取人员权限分页列表
*
* @param dto 传参
* @return TableDataInfo<CustomerAuthFindRes>
*/
TableDataInfo<CustomerAuthFindRes> getPageCustomerAuth(QueryDto dto);
//***************************************电梯信息接口*******************************************
/**
* 电梯信息分页查询
*
* @param dto 传参
* @return IPage<LiftFindRes>
*/
IPage<LiftFindRes> getPageList(QueryDto dto);
/**
* 查询电梯楼层
*
* @param id 传参
* @return LiftFindRes
*/
LiftFindRes getLiftFloor(Long id);
/**
* 添加电梯
*
* @param addReq 传参
* @return Boolean
*/
Boolean addLift(LiftAddReq addReq);
/**
* 修改电梯信息
*
* @param updateReq 传参
* @return Boolean
*/
Boolean updateLift(LiftUpdateReq updateReq);
/**
* 删除电梯信息
*
* @param id 传参
* @return Boolean
*/
Boolean deleteLift(Integer id);
//***************************************凭证信息接口*******************************************
/**
* 发行凭证
*
* @param req 凭证数据
* @return Boolean
*/
Long issueVoucher(IssueVoucherReq req);
/**
* 操作凭证
*
* @param req 入参
* @return Boolean
*/
Boolean operateVoucher(OperateVoucherReq req);
/**
* 换卡补卡
*
* @param req 入参
* @return Boolean
*/
Boolean changeCard(ChangeCardReq req);
/**
* 上传人脸
*
* @param imageByte 入参
* @return imageUrl 人脸图片地址
*/
String uploadFace(byte[] imageByte);
}

56
ruoyi-modules/Sis/src/main/java/org/dromara/sis/sdk/e8/LiftService.java
View File

@ -1,56 +0,0 @@
package org.dromara.sis.sdk.e8;
import com.baomidou.mybatisplus.core.metadata.IPage;
import org.dromara.sis.sdk.e8.domain.QueryDto;
import org.dromara.sis.sdk.e8.domain.lift.req.LiftAddReq;
import org.dromara.sis.sdk.e8.domain.lift.req.LiftUpdateReq;
import org.dromara.sis.sdk.e8.domain.lift.res.LiftFindRes;
/**
* @author zcxlsm
* @apiNote LiftService
* @since 2025/5/9 18:04
*/
public interface LiftService {
/**
* 电梯信息分页查询
*
* @param dto 传参
* @return IPage<LiftFindRes>
*/
IPage<LiftFindRes> getPageList(QueryDto dto);
/**
* 查询电梯楼层
*
* @param id 传参
* @return LiftFindRes
*/
LiftFindRes getLiftFloor(Long id);
/**
* 添加电梯
*
* @param addReq 传参
* @return Boolean
*/
Boolean addLift(LiftAddReq addReq);
/**
* 修改电梯信息
*
* @param updateReq 传参
* @return Boolean
*/
Boolean updateLift(LiftUpdateReq updateReq);
/**
* 删除电梯信息
*
* @param id 传参
* @return Boolean
*/
Boolean deleteLift(Integer id);
}

45
ruoyi-modules/Sis/src/main/java/org/dromara/sis/sdk/e8/VoucherControlService.java
View File

@ -1,45 +0,0 @@
package org.dromara.sis.sdk.e8;
import org.dromara.sis.sdk.e8.domain.voucher.req.ChangeCardReq;
import org.dromara.sis.sdk.e8.domain.voucher.req.IssueVoucherReq;
import org.dromara.sis.sdk.e8.domain.voucher.req.OperateVoucherReq;
/**
* @author lsm
* @apiNote VoucherControlService
* @since 2025/6/24
*/
public interface VoucherControlService {
/**
* 发行凭证
*
* @param req 凭证数据
* @return Boolean
*/
Long issueVoucher(IssueVoucherReq req);
/**
* 操作凭证
*
* @param req 入参
* @return Boolean
*/
Boolean operateVoucher(OperateVoucherReq req);
/**
* 换卡补卡
*
* @param req 入参
* @return Boolean
*/
Boolean changeCard(ChangeCardReq req);
/**
* 上传人脸
*
* @param imageByte 入参
* @return imageUrl 人脸图片地址
*/
String uploadFace(byte[] imageByte);
}

162
ruoyi-modules/Sis/src/main/java/org/dromara/sis/sdk/e8/impl/AccessControlServiceImpl.java
View File

@ -1,162 +0,0 @@
package org.dromara.sis.sdk.e8.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.lang.TypeReference;
import cn.hutool.json.JSONUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.sis.sdk.e8.AccessControlService;
import org.dromara.sis.sdk.e8.domain.ApiResp;
import org.dromara.sis.sdk.e8.domain.QueryDto;
import org.dromara.sis.sdk.e8.domain.accessControl.req.AccessRecordFindReq;
import org.dromara.sis.sdk.e8.domain.accessControl.req.CustomerAuthAddReq;
import org.dromara.sis.sdk.e8.domain.accessControl.req.CustomerAuthFindReq;
import org.dromara.sis.sdk.e8.domain.accessControl.req.RemoteOpenDoorReq;
import org.dromara.sis.sdk.e8.domain.accessControl.res.AccessRecordFindRes;
import org.dromara.sis.sdk.e8.domain.accessControl.res.CustomerAuthFindRes;
import org.dromara.sis.sdk.e8.utils.E8ApiUtil;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.Map;
/**
* @author lsm
* @apiNote AccessControlServiceImpl
* @since 2025/6/24
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class AccessControlServiceImpl implements AccessControlService {
// 远程开门
private static final String REMOTE_OPEN_DOOR = "/api/E8Door/man-device-info/device-control";
// 获取通行记录分页列表
private static final String GET_PAGE_ACCESS_RECORD_PAGE_LIST = "/api/E8Door/man-pass-record/get-page-list";
// 人员授权
private static final String PERSON_AUTHORIZATION = "/api/E8Door/man-auth-info/auth-info-by-type";
// 获取人员权限分页列表
private static final String GET_PAGE_PERSON_AUTHORIZATION_PAGE_LIST = "/api/E8Door/man-person-device-finally/get-page-list";
private final E8ApiUtil e8ApiUtil;
/**
* 远程开门
*
* @param req 入参
* @return Boolean
*/
@Override
public Boolean remoteOpenDoor(RemoteOpenDoorReq req) {
// 将RemoteOpenDoorReq转为Map对象，以便作为API请求的参数
Map<String, Object> params = BeanUtil.beanToMap(req);
// 调用第三方API进行开门操作，传入处理后的参数和指定的API端点
ApiResp apiResp = e8ApiUtil.doPost(params, REMOTE_OPEN_DOOR);
if (!apiResp.getSuccess()) log.error("调用E8远程开门失败，errorMsg:{}", apiResp);
// 返回API调用是否成功的结果
return apiResp.getSuccess();
}
/**
* 获取通行记录分页列表
*
* @param dto 传参
* @return IPage<AccessRecordFindRes>
*/
@Override
public TableDataInfo<AccessRecordFindRes> getPageAccessRecordList(QueryDto dto) {
// 创建一个参数映射，用于存储API请求的参数
Map<String, Object> params = new HashMap<>();
// 将分页索引和最大结果数放入参数映射中
params.put("pageIndex", dto.getPageIndex());
params.put("maxResultCount", dto.getMaxResultCount());
// 将查询DTO转换为JSON字符串，再转换为Map对象，然后放入参数映射中
params.put("queryDto", JSONUtil.toBean(JSONUtil.toJsonStr(dto.getQueryDto()), AccessRecordFindReq.class));
// 调用API工具类的POST方法，传入参数和API路径，获取API响应对象
ApiResp apiResp = e8ApiUtil.doPost(params, GET_PAGE_ACCESS_RECORD_PAGE_LIST);
// 如果API响应不成功，则返回null
if (!apiResp.getSuccess()) {
log.error("调用E8获取通行记录分页列表失败，errorMsg:{}", apiResp);
return null;
}
// 将API响应的结果转换为JSON字符串，再转换为Map对象
Map<String, Object> result = JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), new TypeReference<>() {
}, false);
// 创建一个分页对象，传入分页索引和最大结果数
TableDataInfo<AccessRecordFindRes> tableData = new TableDataInfo<>();
// 从结果映射中获取总记录数，转换为长整型后设置到分页对象中
tableData.setTotal(Long.parseLong(result.get("total").toString()));
// 从结果映射中获取项目列表，转换为访问记录信息列表后设置到分页对象中
tableData.setRows(JSONUtil.toList(JSONUtil.toJsonStr(result.get("item")), AccessRecordFindRes.class));
// 返回填充了数据的分页对象
return tableData;
}
/**
* 人员授权
*
* @param req 传参
* @return Boolean
*/
@Override
public Boolean addCustomerAuth(CustomerAuthAddReq req) {
// 创建一个参数映射，用于存储API请求的参数
Map<String, Object> params = BeanUtil.beanToMap(req);
// 调用API工具类的POST方法，传入参数和API路径，获取API响应对象
ApiResp apiResp = e8ApiUtil.doPost(params, PERSON_AUTHORIZATION);
if (!apiResp.getSuccess()) log.error("调用E8人员授权失败，errorMsg:{}", apiResp);
// 返回API调用是否成功
return apiResp.getSuccess();
}
/**
* 获取人员权限分页列表
*
* @param dto 传参
* @return TableDataInfo<CustomerAuthFindRes>
*/
@Override
public TableDataInfo<CustomerAuthFindRes> getPageCustomerAuth(QueryDto dto) {
// 创建一个参数映射，用于存储API请求的参数
Map<String, Object> params = new HashMap<>();
// 将分页索引和最大结果数放入参数映射中
params.put("pageIndex", dto.getPageIndex());
params.put("maxResultCount", dto.getMaxResultCount());
// 将查询DTO转换为JSON字符串，再转换为Map对象，然后放入参数映射中
params.put("queryDto", JSONUtil.toBean(JSONUtil.toJsonStr(dto.getQueryDto()), CustomerAuthFindReq.class));
// 调用API工具类的POST方法，传入参数和API路径，获取API响应对象
ApiResp apiResp = e8ApiUtil.doPost(params, GET_PAGE_PERSON_AUTHORIZATION_PAGE_LIST);
// 如果API响应不成功，则返回null
if (!apiResp.getSuccess()) {
log.error("调用E8获取人员权限分页列表失败，errorMsg:{}", apiResp);
return null;
}
// 将API响应的结果转换为JSON字符串，再转换为Map对象
Map<String, Object> result = JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), new TypeReference<>() {
}, false);
// 创建一个分页对象，传入分页索引和最大结果数
TableDataInfo<CustomerAuthFindRes> tableData = new TableDataInfo<>();
// 从结果映射中获取总记录数，转换为长整型后设置到分页对象中
tableData.setTotal(Long.parseLong(result.get("total").toString()));
// 从结果映射中获取项目列表，转换为访问记录信息列表后设置到分页对象中
tableData.setRows(JSONUtil.toList(JSONUtil.toJsonStr(result.get("item")), CustomerAuthFindRes.class));
// 返回填充了数据的分页对象
return tableData;
}
}

174
ruoyi-modules/Sis/src/main/java/org/dromara/sis/sdk/e8/impl/CustomerServiceImpl.java
View File

@ -1,174 +0,0 @@
package org.dromara.sis.sdk.e8.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.lang.TypeReference;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.dromara.sis.sdk.e8.CustomerService;
import org.dromara.sis.sdk.e8.domain.ApiResp;
import org.dromara.sis.sdk.e8.domain.QueryDto;
import org.dromara.sis.sdk.e8.domain.custom.req.CustomAddReq;
import org.dromara.sis.sdk.e8.domain.custom.req.CustomFindReq;
import org.dromara.sis.sdk.e8.domain.custom.req.CustomUpdateReq;
import org.dromara.sis.sdk.e8.domain.custom.res.CustomAddRes;
import org.dromara.sis.sdk.e8.domain.custom.res.CustomFindRes;
import org.dromara.sis.sdk.e8.utils.E8ApiUtil;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.Map;
/**
* @author lsm
* @apiNote CustomerServiceImpl
* @since 2025/6/23
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class CustomerServiceImpl implements CustomerService {
private final static String CUSTOMER_GET_PAGE_LIST = "/api/E8/customer/get-page-list";
private final static String CUSTOMER_GET_FIRST_OR_DEFAULT = "/api/E8/customer/get-first-or-default";
private final static String CUSTOMER_CREATE = "/api/E8/customer";
private final static String CUSTOMER_UPDATE = "/api/E8/customer/{id}/update";
private final static String CUSTOMER_DELETE = "/api/E8/customer/{id}";
private final E8ApiUtil e8ApiUtil;
/**
* 查询单个人员信息
*
* @param findReq 传参
* @return CustomerInfo
*/
@Override
public CustomFindRes findCustomer(CustomFindReq findReq) {
// 将查询请求对象转换为参数映射
Map<String, Object> params = BeanUtil.beanToMap(findReq);
// 调用API接口获取客户信息
ApiResp apiResp = e8ApiUtil.doPost(params, CUSTOMER_GET_FIRST_OR_DEFAULT);
// 检查API调用是否成功
if (!apiResp.getSuccess()) {
log.error("E8查询人员信息失败 errorMsg:{}", apiResp);
// 如果API调用失败，返回null
return null;
}
// 将API响应结果转换为CustomFindRes对象并返回
return JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), CustomFindRes.class);
}
/**
* 人员信息分页查询
*
* @param dto 传参
* @return IPage<CustomerInfo>
*/
@Override
public IPage<CustomFindRes> findCustomerList(QueryDto dto) {
// 创建参数映射，用于存储HTTP请求的参数
Map<String, Object> params = new HashMap<>();
// 添加分页参数：当前页码和最大结果数量
params.put("pageIndex", dto.getPageIndex());
params.put("maxResultCount", dto.getMaxResultCount());
// 将查询条件对象转换为JSON字符串，并再次转换为Map对象，然后添加到参数映射中
params.put("queryDto", JSONUtil.toBean(JSONUtil.toJsonStr(dto.getQueryDto()), CustomFindReq.class));
// 调用API工具类的POST方法，发送请求到第三方API，并获取响应结果
ApiResp apiResp = e8ApiUtil.doPost(params, CUSTOMER_GET_PAGE_LIST);
if (!apiResp.getSuccess()) {
log.error("E8人员信息分页查询 errorMsg:{}", apiResp);
// 如果API响应不成功，返回null
return null;
}
// 将API响应结果转换为Map对象，以便于后续处理
Map<String, Object> result = JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), new TypeReference<>() {
}, false);
// 创建一个分页对象，用于存储客户信息列表和分页数据
IPage<CustomFindRes> pageInfo = new Page<>(dto.getPageIndex(), dto.getMaxResultCount());
// 设置总记录数
pageInfo.setTotal(Long.parseLong(result.get("total").toString()));
// 将API响应结果中的客户信息列表转换为CustomFindRes对象列表，并设置到分页对象中
pageInfo.setRecords(JSONUtil.toList(JSONUtil.toJsonStr(result.get("item")), CustomFindRes.class));
// 返回分页对象
return pageInfo;
}
/**
* 新增人员信息
*
* @param addReq 传参
* @return Boolean
*/
@Override
public CustomAddRes addCustomer(CustomAddReq addReq) {
// 将添加请求对象转换为Map对象，以便后续API调用
Map<String, Object> params = BeanUtil.beanToMap(addReq);
// 执行客户创建API调用，并获取API响应对象
ApiResp apiResp = e8ApiUtil.doPost(params, CUSTOMER_CREATE);
// 检查API调用是否成功
if (!apiResp.getSuccess()) {
log.error("E8新增人员信息失败 errorMsg:{}", apiResp);
// 如果API调用失败，返回null
return null;
}
// 返回API调用是否成功的标志
return JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), CustomAddRes.class);
}
/**
* 人员信息修改
*
* @param updateReq 传参
* @return Boolean
*/
@Override
public Boolean updateCustomer(CustomUpdateReq updateReq) {
// 根据更新请求构建API URL
String api = CUSTOMER_UPDATE.replace("{id}", updateReq.getId().toString());
// 将更新请求对象转换为Map，以便后续API调用
Map<String, Object> params = BeanUtil.beanToMap(updateReq);
// 调用API工具类发送POST请求，并获取API响应对象
ApiResp apiResp = e8ApiUtil.doPost(params, api);
if (!apiResp.getSuccess()) log.error("E8人员信息修改失败 errorMsg:{}", apiResp);
// 返回API调用是否成功的标志
return apiResp.getSuccess();
}
/**
* 删除人员信息
*
* @param id 传参
* @return Boolean
*/
@Override
public Boolean deleteCustomer(Long id) {
// 构造删除客户的API请求URL
String api = CUSTOMER_DELETE.replace("{id}", id.toString());
// 调用API工具类的 doGetOrDel 方法发送GET或DELETE请求，并获取响应结果
ApiResp apiResp = e8ApiUtil.doGetOrDel(api, null, true);
if (!apiResp.getSuccess()) log.error("E8删除人员信息失败 errorMsg:{}", apiResp);
// 返回API请求是否成功的标志
return apiResp.getSuccess();
}
}

206
ruoyi-modules/Sis/src/main/java/org/dromara/sis/sdk/e8/impl/DoorDeviceServiceImpl.java
View File

@ -1,206 +0,0 @@
package org.dromara.sis.sdk.e8.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.lang.TypeReference;
import cn.hutool.json.JSONUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.sis.sdk.e8.DoorDeviceService;
import org.dromara.sis.sdk.e8.domain.ApiResp;
import org.dromara.sis.sdk.e8.domain.door.req.DoorDeviceAddReq;
import org.dromara.sis.sdk.e8.domain.door.req.DoorDeviceFindReq;
import org.dromara.sis.sdk.e8.domain.door.req.DoorDeviceUpdateReq;
import org.dromara.sis.sdk.e8.domain.door.res.AuthDoorDeviceFindRes;
import org.dromara.sis.sdk.e8.domain.door.res.DoorDeviceAddRes;
import org.dromara.sis.sdk.e8.domain.door.res.DoorDeviceFindRes;
import org.dromara.sis.sdk.e8.domain.QueryDto;
import org.dromara.sis.sdk.e8.utils.E8ApiUtil;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author lsm
* @apiNote DoorDeviceServiceImpl
* @since 2025/6/20
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class DoorDeviceServiceImpl implements DoorDeviceService {
private final static String DOOR_DEVICE_GET_PAGE_LIST = "/api/e8door/man-device-info/get-page-list";
private final static String DOOR_DEVICE_GET_FIRST_OR_DEFAULT = "/api/E8Door/man-device-info/{id}";
private final static String DOOR_DEVICE_CREATE = "/api/E8Door/man-device-info";
private final static String DOOR_DEVICE_UPDATE = "/api/E8Door/man-device-info/{id}/update";
private final static String DOOR_DEVICE_DELETE = "/api/E8Door/man-device-info/{id}";
private final static String AUTH_DOOR_DEVICE_GET_LIST = "/api/E8Door/man-auth-info/get-page-list-auth-data";
private final E8ApiUtil e8ApiUtil;
/**
* 查询门禁信息
*
* @param id 传参
* @return DoorDeviceFindRes
*/
@Override
public DoorDeviceFindRes findDoorDevice(Long id) {
// 使用给定的ID替换API模板中的{id}占位符
String api = DOOR_DEVICE_GET_FIRST_OR_DEFAULT.replace("{id}", id.toString());
// 调用E8 API工具类的doGetOrDel方法发送GET请求，并获取响应结果
ApiResp apiResp = e8ApiUtil.doGetOrDel(api, null, false);
// 检查API响应是否成功
if (!apiResp.getSuccess()) {
log.error("查询E8门禁信息失败 errorMsg:{}", apiResp);
// 如果响应不成功，则返回null
return null;
}
// 将API响应结果转换为指定的Java对象，并返回该对象
return JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), DoorDeviceFindRes.class);
}
/**
* 门禁信息分页查询
*
* @param dto 传参
* @return IPage<DoorDeviceFindRes>
*/
@Override
public TableDataInfo<DoorDeviceFindRes> findDoorDeviceList(QueryDto dto) {
// 创建一个参数映射，用于存储API请求所需的参数
Map<String, Object> params = new HashMap<>();
// 将分页索引和最大结果数放入参数映射中
params.put("PageIndex", dto.getPageIndex());
params.put("MaxResultCount", dto.getMaxResultCount());
// 将查询DTO转换为JSON字符串，再转换为Map对象，然后放入参数映射中
params.put("QueryDto", JSONUtil.toBean(JSONUtil.toJsonStr(dto.getQueryDto()), DoorDeviceFindReq.class));
// 调用第三方API，获取门禁设备分页列表
ApiResp apiResp = e8ApiUtil.doPost(params, DOOR_DEVICE_GET_PAGE_LIST);
// 如果API调用不成功，则返回null
if (!apiResp.getSuccess()) {
log.error("分页查询E8门禁信息失败 errorMsg:{}", apiResp);
// 如果响应不成功，则返回null
return null;
}
// 将API响应结果转换为Map对象，以便后续处理
Map<String, Object> result = JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), new TypeReference<>() {
}, false);
// 创建一个分页对象，用于存储处理后的门禁设备信息
TableDataInfo<DoorDeviceFindRes> tableDataInfo = new TableDataInfo<>();
// 设置分页对象的总记录数
tableDataInfo.setTotal(Long.parseLong(result.get("total").toString()));
// 将API响应结果中的门禁设备信息列表转换为DoorDeviceFindRes对象列表，并设置到分页对象中
tableDataInfo.setRows(JSONUtil.toList(JSONUtil.toJsonStr(result.get("item")), DoorDeviceFindRes.class));
// 返回处理后的分页对象
return tableDataInfo;
}
/**
* 新增门禁信息
*
* @param addReq 传参
* @return Boolean
*/
@Override
public DoorDeviceAddRes addDoorDevice(DoorDeviceAddReq addReq) {
// 将DoorDeviceAddReq转为Map对象，以便作为API请求的参数
Map<String, Object> params = BeanUtil.beanToMap(addReq);
// 调用第三方API进行门禁设备创建，并传入转换后的参数
ApiResp apiResp = e8ApiUtil.doPost(params, DOOR_DEVICE_CREATE);
if (!apiResp.getSuccess()) {
log.error("新增E8门禁信息，errorMsg:{}", apiResp);
// 如果响应不成功，则返回null
return null;
}
return JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), DoorDeviceAddRes.class);
}
/**
* 门禁信息修改
*
* @param updateReq 传参
* @return DoorDeviceUpdateRes
*/
@Override
public Boolean updateDoorDevice(DoorDeviceUpdateReq updateReq) {
// 构造门设备更新API的URL
String api = DOOR_DEVICE_UPDATE.replace("{id}", updateReq.getId().toString());
// 将门设备信息对象转换为键值对形式的参数
Map<String, Object> params = BeanUtil.beanToMap(updateReq);
// 调用API进行门设备信息更新
ApiResp apiResp = e8ApiUtil.doPost(params, api);
if (!apiResp.getSuccess()) log.error("修改E8门禁信息，errorMsg:{}", apiResp);
return apiResp.getSuccess();
}
/**
* 删除门禁信息
*
* @param id 传参
* @return Boolean
*/
@Override
public Boolean deleteDoorDevice(Long id) {
// 构造删除门设备的API路径，使用设备ID替换占位符
String api = DOOR_DEVICE_DELETE.replace("{id}", id.toString());
// 调用E8 API工具类进行HTTP DELETE请求，参数为构造的API路径和null（因为DELETE请求通常不需要请求体）
ApiResp apiResp = e8ApiUtil.doGetOrDel(api, null, true);
if (!apiResp.getSuccess()) log.error("删除E8门禁信息，errorMsg:{}", apiResp);
// 返回API响应的成功标志
return apiResp.getSuccess();
}
/**
* 分页获取授权门信息
*
* @return List<AuthDoorDeviceFindRes>
*/
public List<AuthDoorDeviceFindRes> getPageAuthDoorDeviceList() {
Map<String, Object> queryDto = new HashMap<>();
queryDto.put("type", -1);
queryDto.put("matchString", "");
// 创建一个参数映射，用于存储API请求所需的参数
Map<String, Object> params = new HashMap<>();
params.put("PageIndex", 1);
params.put("MaxResultCount", 100000);
params.put("QueryDto", queryDto);
ApiResp apiResp = e8ApiUtil.doPost(params, AUTH_DOOR_DEVICE_GET_LIST);
// 如果API调用不成功，则返回null
if (!apiResp.getSuccess()) {
log.error("分页获取授权门信息失败 errorMsg:{}", apiResp);
// 如果响应不成功，则返回null
return null;
}
// 将API响应结果转换为Map对象，以便后续处理
Map<String, Object> result = JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), new TypeReference<>() {
}, false);
// 返回list
return JSONUtil.toList(JSONUtil.toJsonStr(result.get("item")), AuthDoorDeviceFindRes.class);
}
}

161
ruoyi-modules/Sis/src/main/java/org/dromara/sis/sdk/e8/impl/LiftServiceImpl.java
View File

@ -1,161 +0,0 @@
package org.dromara.sis.sdk.e8.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.lang.TypeReference;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.dubbo.config.annotation.DubboService;
import org.dromara.sis.sdk.e8.LiftService;
import org.dromara.sis.sdk.e8.domain.ApiResp;
import org.dromara.sis.sdk.e8.domain.QueryDto;
import org.dromara.sis.sdk.e8.domain.lift.req.LiftAddReq;
import org.dromara.sis.sdk.e8.domain.lift.req.LiftFindReq;
import org.dromara.sis.sdk.e8.domain.lift.req.LiftUpdateReq;
import org.dromara.sis.sdk.e8.domain.lift.res.LiftFindRes;
import org.dromara.sis.sdk.e8.utils.E8ApiUtil;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;
/**
* @author lsm
* @apiNote LiftServiceImpl
* @since 2025/5/9 11:52
*/
@Service
@DubboService
public class LiftServiceImpl implements LiftService {
private static final String GET_PAGE_LIST = "/api/E8Door/man-elevator-management/get-page-list";
private static final String GET_LIFT_FLOOR = "/api/E8Door/man-elevator-management/{id}/get-man-elevator-floors";
private static final String LIFT_ADD = "/api/E8Door/man-elevator-management";
private static final String LIFT_UPDATE = "/api/E8Door/man-elevator-management/{id}/update";
private static final String LIFT_DELETE = "/api/E8Door/man-elevator-management/{id}";
@Resource
private E8ApiUtil e8ApiUtil;
/**
* 电梯信息分页查询
*
* @param dto 传参
* @return IPage<LiftFindRes>
*/
@Override
public IPage<LiftFindRes> getPageList(QueryDto dto) {
// 创建一个参数映射，用于存储API请求所需的参数
Map<String, Object> params = new HashMap<>();
// 将分页索引和最大结果数放入参数映射中
params.put("pageIndex", dto.getPageIndex());
params.put("maxResultCount", dto.getMaxResultCount());
// 将查询DTO转换为LiftInfo对象，并将其添加到参数映射中
params.put("queryDto", JSONUtil.toBean(JSONUtil.toJsonStr(dto.getQueryDto()), LiftFindReq.class));
// 调用E8 API工具类的POST方法，传入参数和API路径，获取API响应
ApiResp apiResp = e8ApiUtil.doPost(params, GET_PAGE_LIST);
// 如果API响应不成功，则返回null
if (!apiResp.getSuccess()) {
return null;
}
// 将API响应的结果转换为一个Map对象
Map<String, Object> result = JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), new TypeReference<>() {
}, false);
// 创建一个分页对象，传入分页索引和最大结果数
IPage<LiftFindRes> page = new Page<>(dto.getPageIndex(), dto.getMaxResultCount());
// 设置分页对象的总记录数
page.setTotal(Long.parseLong(result.get("total").toString()));
// 将结果中的项转换为LiftFindRes列表，并设置为分页对象的记录
page.setRecords(JSONUtil.toList(JSONUtil.toJsonStr(result.get("item")), LiftFindRes.class));
// 返回填充了数据的分页对象
return page;
}
/**
* 查询电梯楼层
*
* @param id 传参
* @return LiftFindRes
*/
@Override
public LiftFindRes getLiftFloor(Long id) {
// 构造请求URL，其中{id}将被liftInfo的ID替换
String url = GET_LIFT_FLOOR.replace("{id}", id.toString());
// 调用API接口，获取电梯信息
ApiResp apiResp = e8ApiUtil.doPost(null, url);
// 如果API调用不成功，则返回null
if (!apiResp.getSuccess()) {
return null;
}
// 将API响应结果转换为LiftFindRes对象，并返回
return JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), LiftFindRes.class);
}
/**
* 添加电梯
*
* @param addReq 传参
* @return Boolean
*/
@Override
public Boolean addLift(LiftAddReq addReq) {
// 将添加请求对象转换为Map对象，便于后续操作
Map<String, Object> params = BeanUtil.beanToMap(addReq);
// 调用第三方API进行电梯添加操作，并获取API响应结果
ApiResp apiResp = e8ApiUtil.doPost(params, LIFT_ADD);
// 返回API操作是否成功的标志
return apiResp.getSuccess();
}
/**
* 修改电梯信息
*
* @param updateReq 传参
* @return Boolean
*/
@Override
public Boolean updateLift(LiftUpdateReq updateReq) {
// 根据LiftUpdateReq对象中的ID生成请求URL
String url = LIFT_UPDATE.replace("{id}", updateReq.getId().toString());
// 将LiftUpdateReq对象转换为Map类型，以便于API请求参数的处理
Map<String, Object> params = BeanUtil.beanToMap(updateReq);
// 调用E8 API进行POST请求，并返回API响应对象
ApiResp apiResp = e8ApiUtil.doPost(params, url);
// 返回API调用是否成功的标志
return apiResp.getSuccess();
}
/**
* 删除电梯信息
*
* @param id 传参
* @return Boolean
*/
@Override
public Boolean deleteLift(Integer id) {
// 构造删除电梯的API请求URL，使用id替换模板中的{id}占位符
String url = LIFT_DELETE.replace("{id}", id.toString());
// 调用e8ApiUtils工具类执行DELETE请求，并获取API响应结果
ApiResp apiResp = e8ApiUtil.doGetOrDel(url, null, true);
// 返回API响应中的成功标志，表示删除操作是否成功
return apiResp.getSuccess();
}
}

115
ruoyi-modules/Sis/src/main/java/org/dromara/sis/sdk/e8/impl/VoucherControlServiceImpl.java
View File

@ -1,115 +0,0 @@
package org.dromara.sis.sdk.e8.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.json.JSONUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.dromara.sis.sdk.e8.VoucherControlService;
import org.dromara.sis.sdk.e8.domain.ApiResp;
import org.dromara.sis.sdk.e8.domain.voucher.req.ChangeCardReq;
import org.dromara.sis.sdk.e8.domain.voucher.req.IssueVoucherReq;
import org.dromara.sis.sdk.e8.domain.voucher.req.OperateVoucherReq;
import org.dromara.sis.sdk.e8.domain.voucher.res.IssueVoucherRes;
import org.dromara.sis.sdk.e8.utils.E8ApiUtil;
import org.springframework.stereotype.Service;
import java.util.Map;
/**
* @author lsm
* @apiNote VoucherControlServiceImpl
* @since 2025/6/25
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class VoucherControlServiceImpl implements VoucherControlService {
private static final String ISSUANCE_VOUCHER = "/api/E8/voucher/issue-voucher";
private static final String OPERATE_VOUCHER = "/api/E8/voucher/operate-many";
private static final String CHANGE_CARD = "/api/E8/voucher/change-card";
private final E8ApiUtil e8ApiUtil;
/**
* 发行凭证
*
* @param req 入参
* @return 是否成功
*/
@Override
public Long issueVoucher(IssueVoucherReq req) {
// 封装入参
Map<String, Object> params = BeanUtil.beanToMap(req);
// 调用API
ApiResp apiResp = e8ApiUtil.doPost(params, ISSUANCE_VOUCHER);
if (!apiResp.getSuccess()) {
log.error("E8发行凭证失败，errorMsg：{}", apiResp);
return null;
}
IssueVoucherRes res = JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), IssueVoucherRes.class);
return res.getId();
}
/**
* 操作凭证
*
* @param req 入参
* @return Boolean
*/
@Override
public Boolean operateVoucher(OperateVoucherReq req) {
// 封装入参
Map<String, Object> params = BeanUtil.beanToMap(req);
// 调用API
ApiResp apiResp = e8ApiUtil.doPost(params, OPERATE_VOUCHER);
if (!apiResp.getSuccess()) log.error("E8操作凭证失败，errorMsg：{}", apiResp);
return apiResp.getSuccess();
}
/**
* 换卡补卡
*
* @param req 入参
* @return Boolean
*/
@Override
public Boolean changeCard(ChangeCardReq req) {
// 封装入参
Map<String, Object> params = BeanUtil.beanToMap(req);
// 调用API
ApiResp apiResp = e8ApiUtil.doPost(params, CHANGE_CARD);
if (!apiResp.getSuccess()) log.error("E8换卡补卡失败，errorMsg：{}", apiResp);
return apiResp.getSuccess();
}
/**
* 上传人脸
*
* @param imageByte 入参
* @return imageUrl 人脸图片地址
*/
@Override
public String uploadFace(byte[] imageByte) {
ApiResp apiResp = e8ApiUtil.doFaceImgUpload(imageByte);
if (!apiResp.getSuccess()) {
log.error("上传人脸图片失败，errorMsg：{}", apiResp);
return null;
}
return apiResp.getMessage();
}
}

697
ruoyi-modules/Sis/src/main/java/org/dromara/sis/sdk/e8/service/E8PlatformApiService.java Normal file
View File

@ -0,0 +1,697 @@
package org.dromara.sis.sdk.e8.service;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.lang.TypeReference;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.sis.sdk.e8.E8PlatformApi;
import org.dromara.sis.sdk.e8.domain.ApiResp;
import org.dromara.sis.sdk.e8.domain.QueryDto;
import org.dromara.sis.sdk.e8.domain.accessControl.req.AccessRecordFindReq;
import org.dromara.sis.sdk.e8.domain.accessControl.req.CustomerAuthAddReq;
import org.dromara.sis.sdk.e8.domain.accessControl.req.CustomerAuthFindReq;
import org.dromara.sis.sdk.e8.domain.accessControl.req.RemoteOpenDoorReq;
import org.dromara.sis.sdk.e8.domain.accessControl.res.AccessRecordFindRes;
import org.dromara.sis.sdk.e8.domain.accessControl.res.CustomerAuthFindRes;
import org.dromara.sis.sdk.e8.domain.custom.req.CustomAddReq;
import org.dromara.sis.sdk.e8.domain.custom.req.CustomFindReq;
import org.dromara.sis.sdk.e8.domain.custom.req.CustomUpdateReq;
import org.dromara.sis.sdk.e8.domain.custom.res.CustomAddRes;
import org.dromara.sis.sdk.e8.domain.custom.res.CustomFindRes;
import org.dromara.sis.sdk.e8.domain.door.req.DoorDeviceAddReq;
import org.dromara.sis.sdk.e8.domain.door.req.DoorDeviceFindReq;
import org.dromara.sis.sdk.e8.domain.door.req.DoorDeviceUpdateReq;
import org.dromara.sis.sdk.e8.domain.door.res.AuthDoorDeviceFindRes;
import org.dromara.sis.sdk.e8.domain.door.res.DoorDeviceAddRes;
import org.dromara.sis.sdk.e8.domain.door.res.DoorDeviceFindRes;
import org.dromara.sis.sdk.e8.domain.lift.req.LiftAddReq;
import org.dromara.sis.sdk.e8.domain.lift.req.LiftFindReq;
import org.dromara.sis.sdk.e8.domain.lift.req.LiftUpdateReq;
import org.dromara.sis.sdk.e8.domain.lift.res.LiftFindRes;
import org.dromara.sis.sdk.e8.domain.voucher.req.ChangeCardReq;
import org.dromara.sis.sdk.e8.domain.voucher.req.IssueVoucherReq;
import org.dromara.sis.sdk.e8.domain.voucher.req.OperateVoucherReq;
import org.dromara.sis.sdk.e8.domain.voucher.res.IssueVoucherRes;
import org.dromara.sis.sdk.e8.utils.E8ApiUtil;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author lsm
* @apiNote E8PlatformApiService
* @since 2025/7/17
*/
@Slf4j
@Service
@RequiredArgsConstructor
public class E8PlatformApiService implements E8PlatformApi {
private final E8ApiUtil e8ApiUtil;
//***************************************客户信息接口*******************************************
private final static String CUSTOMER_GET_PAGE_LIST = "/api/E8/customer/get-page-list";
private final static String CUSTOMER_GET_FIRST_OR_DEFAULT = "/api/E8/customer/get-first-or-default";
private final static String CUSTOMER_CREATE = "/api/E8/customer";
private final static String CUSTOMER_UPDATE = "/api/E8/customer/{id}/update";
private final static String CUSTOMER_DELETE = "/api/E8/customer/{id}";
/**
* 查询单个人员信息
*
* @param findReq 传参
* @return CustomerInfo
*/
@Override
public CustomFindRes findCustomer(CustomFindReq findReq) {
// 将查询请求对象转换为参数映射
Map<String, Object> params = BeanUtil.beanToMap(findReq);
// 调用API接口获取客户信息
ApiResp apiResp = e8ApiUtil.doPost(params, CUSTOMER_GET_FIRST_OR_DEFAULT);
// 检查API调用是否成功
if (!apiResp.getSuccess()) {
log.error("E8查询人员信息失败 errorMsg:{}", apiResp);
// 如果API调用失败，返回null
return null;
}
// 将API响应结果转换为CustomFindRes对象并返回
return JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), CustomFindRes.class);
}
/**
* 人员信息分页查询
*
* @param dto 传参
* @return IPage<CustomerInfo>
*/
@Override
public IPage<CustomFindRes> findCustomerList(QueryDto dto) {
// 创建参数映射，用于存储HTTP请求的参数
Map<String, Object> params = new HashMap<>();
// 添加分页参数：当前页码和最大结果数量
params.put("pageIndex", dto.getPageIndex());
params.put("maxResultCount", dto.getMaxResultCount());
// 将查询条件对象转换为JSON字符串，并再次转换为Map对象，然后添加到参数映射中
params.put("queryDto", JSONUtil.toBean(JSONUtil.toJsonStr(dto.getQueryDto()), CustomFindReq.class));
// 调用API工具类的POST方法，发送请求到第三方API，并获取响应结果
ApiResp apiResp = e8ApiUtil.doPost(params, CUSTOMER_GET_PAGE_LIST);
if (!apiResp.getSuccess()) {
log.error("E8人员信息分页查询 errorMsg:{}", apiResp);
// 如果API响应不成功，返回null
return null;
}
// 将API响应结果转换为Map对象，以便于后续处理
Map<String, Object> result = JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), new TypeReference<>() {
}, false);
// 创建一个分页对象，用于存储客户信息列表和分页数据
IPage<CustomFindRes> pageInfo = new Page<>(dto.getPageIndex(), dto.getMaxResultCount());
// 设置总记录数
pageInfo.setTotal(Long.parseLong(result.get("total").toString()));
// 将API响应结果中的客户信息列表转换为CustomFindRes对象列表，并设置到分页对象中
pageInfo.setRecords(JSONUtil.toList(JSONUtil.toJsonStr(result.get("item")), CustomFindRes.class));
// 返回分页对象
return pageInfo;
}
/**
* 新增人员信息
*
* @param addReq 传参
* @return Boolean
*/
@Override
public CustomAddRes addCustomer(CustomAddReq addReq) {
// 将添加请求对象转换为Map对象，以便后续API调用
Map<String, Object> params = BeanUtil.beanToMap(addReq);
// 执行客户创建API调用，并获取API响应对象
ApiResp apiResp = e8ApiUtil.doPost(params, CUSTOMER_CREATE);
// 检查API调用是否成功
if (!apiResp.getSuccess()) {
log.error("E8新增人员信息失败 errorMsg:{}", apiResp);
// 如果API调用失败，返回null
return null;
}
// 返回API调用是否成功的标志
return JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), CustomAddRes.class);
}
/**
* 人员信息修改
*
* @param updateReq 传参
* @return Boolean
*/
@Override
public Boolean updateCustomer(CustomUpdateReq updateReq) {
// 根据更新请求构建API URL
String api = CUSTOMER_UPDATE.replace("{id}", updateReq.getId().toString());
// 将更新请求对象转换为Map，以便后续API调用
Map<String, Object> params = BeanUtil.beanToMap(updateReq);
// 调用API工具类发送POST请求，并获取API响应对象
ApiResp apiResp = e8ApiUtil.doPost(params, api);
if (!apiResp.getSuccess()) log.error("E8人员信息修改失败 errorMsg:{}", apiResp);
// 返回API调用是否成功的标志
return apiResp.getSuccess();
}
/**
* 删除人员信息
*
* @param id 传参
* @return Boolean
*/
@Override
public Boolean deleteCustomer(Long id) {
// 构造删除客户的API请求URL
String api = CUSTOMER_DELETE.replace("{id}", id.toString());
// 调用API工具类的 doGetOrDel 方法发送GET或DELETE请求，并获取响应结果
ApiResp apiResp = e8ApiUtil.doGetOrDel(api, null, true);
if (!apiResp.getSuccess()) log.error("E8删除人员信息失败 errorMsg:{}", apiResp);
// 返回API请求是否成功的标志
return apiResp.getSuccess();
}
//***************************************门禁信息接口*******************************************
private final static String DOOR_DEVICE_GET_PAGE_LIST = "/api/e8door/man-device-info/get-page-list";
private final static String DOOR_DEVICE_GET_FIRST_OR_DEFAULT = "/api/E8Door/man-device-info/{id}";
private final static String DOOR_DEVICE_CREATE = "/api/E8Door/man-device-info";
private final static String DOOR_DEVICE_UPDATE = "/api/E8Door/man-device-info/{id}/update";
private final static String DOOR_DEVICE_DELETE = "/api/E8Door/man-device-info/{id}";
private final static String AUTH_DOOR_DEVICE_GET_LIST = "/api/E8Door/man-auth-info/get-page-list-auth-data";
private static final String REMOTE_OPEN_DOOR = "/api/E8Door/man-device-info/device-control";
private static final String GET_PAGE_ACCESS_RECORD_PAGE_LIST = "/api/E8Door/man-pass-record/get-page-list";
private static final String PERSON_AUTHORIZATION = "/api/E8Door/man-auth-info/auth-info-by-type";
private static final String GET_PAGE_PERSON_AUTHORIZATION_PAGE_LIST = "/api/E8Door/man-person-device-finally/get-page-list";
/**
* 查询门禁信息
*
* @param id 传参
* @return DoorDeviceFindRes
*/
@Override
public DoorDeviceFindRes findDoorDevice(Long id) {
// 使用给定的ID替换API模板中的{id}占位符
String api = DOOR_DEVICE_GET_FIRST_OR_DEFAULT.replace("{id}", id.toString());
// 调用E8 API工具类的doGetOrDel方法发送GET请求，并获取响应结果
ApiResp apiResp = e8ApiUtil.doGetOrDel(api, null, false);
// 检查API响应是否成功
if (!apiResp.getSuccess()) {
log.error("查询E8门禁信息失败 errorMsg:{}", apiResp);
// 如果响应不成功，则返回null
return null;
}
// 将API响应结果转换为指定的Java对象，并返回该对象
return JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), DoorDeviceFindRes.class);
}
/**
* 门禁信息分页查询
*
* @param dto 传参
* @return IPage<DoorDeviceFindRes>
*/
@Override
public TableDataInfo<DoorDeviceFindRes> findDoorDeviceList(QueryDto dto) {
// 创建一个参数映射，用于存储API请求所需的参数
Map<String, Object> params = new HashMap<>();
// 将分页索引和最大结果数放入参数映射中
params.put("PageIndex", dto.getPageIndex());
params.put("MaxResultCount", dto.getMaxResultCount());
// 将查询DTO转换为JSON字符串，再转换为Map对象，然后放入参数映射中
params.put("QueryDto", JSONUtil.toBean(JSONUtil.toJsonStr(dto.getQueryDto()), DoorDeviceFindReq.class));
// 调用第三方API，获取门禁设备分页列表
ApiResp apiResp = e8ApiUtil.doPost(params, DOOR_DEVICE_GET_PAGE_LIST);
// 如果API调用不成功，则返回null
if (!apiResp.getSuccess()) {
log.error("分页查询E8门禁信息失败 errorMsg:{}", apiResp);
// 如果响应不成功，则返回null
return null;
}
// 将API响应结果转换为Map对象，以便后续处理
Map<String, Object> result = JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), new TypeReference<>() {
}, false);
// 创建一个分页对象，用于存储处理后的门禁设备信息
TableDataInfo<DoorDeviceFindRes> tableDataInfo = new TableDataInfo<>();
// 设置分页对象的总记录数
tableDataInfo.setTotal(Long.parseLong(result.get("total").toString()));
// 将API响应结果中的门禁设备信息列表转换为DoorDeviceFindRes对象列表，并设置到分页对象中
tableDataInfo.setRows(JSONUtil.toList(JSONUtil.toJsonStr(result.get("item")), DoorDeviceFindRes.class));
// 返回处理后的分页对象
return tableDataInfo;
}
/**
* 新增门禁信息
*
* @param addReq 传参
* @return Boolean
*/
@Override
public DoorDeviceAddRes addDoorDevice(DoorDeviceAddReq addReq) {
// 将DoorDeviceAddReq转为Map对象，以便作为API请求的参数
Map<String, Object> params = BeanUtil.beanToMap(addReq);
// 调用第三方API进行门禁设备创建，并传入转换后的参数
ApiResp apiResp = e8ApiUtil.doPost(params, DOOR_DEVICE_CREATE);
if (!apiResp.getSuccess()) {
log.error("新增E8门禁信息，errorMsg:{}", apiResp);
// 如果响应不成功，则返回null
return null;
}
return JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), DoorDeviceAddRes.class);
}
/**
* 门禁信息修改
*
* @param updateReq 传参
* @return DoorDeviceUpdateRes
*/
@Override
public Boolean updateDoorDevice(DoorDeviceUpdateReq updateReq) {
// 构造门设备更新API的URL
String api = DOOR_DEVICE_UPDATE.replace("{id}", updateReq.getId().toString());
// 将门设备信息对象转换为键值对形式的参数
Map<String, Object> params = BeanUtil.beanToMap(updateReq);
// 调用API进行门设备信息更新
ApiResp apiResp = e8ApiUtil.doPost(params, api);
if (!apiResp.getSuccess()) log.error("修改E8门禁信息，errorMsg:{}", apiResp);
return apiResp.getSuccess();
}
/**
* 删除门禁信息
*
* @param id 传参
* @return Boolean
*/
@Override
public Boolean deleteDoorDevice(Long id) {
// 构造删除门设备的API路径，使用设备ID替换占位符
String api = DOOR_DEVICE_DELETE.replace("{id}", id.toString());
// 调用E8 API工具类进行HTTP DELETE请求，参数为构造的API路径和null（因为DELETE请求通常不需要请求体）
ApiResp apiResp = e8ApiUtil.doGetOrDel(api, null, true);
if (!apiResp.getSuccess()) log.error("删除E8门禁信息，errorMsg:{}", apiResp);
// 返回API响应的成功标志
return apiResp.getSuccess();
}
/**
* 分页获取授权门信息
*
* @return List<AuthDoorDeviceFindRes>
*/
public List<AuthDoorDeviceFindRes> getPageAuthDoorDeviceList() {
Map<String, Object> queryDto = new HashMap<>();
queryDto.put("type", -1);
queryDto.put("matchString", "");
// 创建一个参数映射，用于存储API请求所需的参数
Map<String, Object> params = new HashMap<>();
params.put("PageIndex", 1);
params.put("MaxResultCount", 100000);
params.put("QueryDto", queryDto);
ApiResp apiResp = e8ApiUtil.doPost(params, AUTH_DOOR_DEVICE_GET_LIST);
// 如果API调用不成功，则返回null
if (!apiResp.getSuccess()) {
log.error("分页获取授权门信息失败 errorMsg:{}", apiResp);
// 如果响应不成功，则返回null
return null;
}
// 将API响应结果转换为Map对象，以便后续处理
Map<String, Object> result = JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), new TypeReference<>() {
}, false);
// 返回list
return JSONUtil.toList(JSONUtil.toJsonStr(result.get("item")), AuthDoorDeviceFindRes.class);
}
/**
* 远程开门
*
* @param req 入参
* @return Boolean
*/
@Override
public Boolean remoteOpenDoor(RemoteOpenDoorReq req) {
// 将RemoteOpenDoorReq转为Map对象，以便作为API请求的参数
Map<String, Object> params = BeanUtil.beanToMap(req);
// 调用第三方API进行开门操作，传入处理后的参数和指定的API端点
ApiResp apiResp = e8ApiUtil.doPost(params, REMOTE_OPEN_DOOR);
if (!apiResp.getSuccess()) log.error("调用E8远程开门失败，errorMsg:{}", apiResp);
// 返回API调用是否成功的结果
return apiResp.getSuccess();
}
/**
* 获取通行记录分页列表
*
* @param dto 传参
* @return IPage<AccessRecordFindRes>
*/
@Override
public TableDataInfo<AccessRecordFindRes> getPageAccessRecordList(QueryDto dto) {
// 创建一个参数映射，用于存储API请求的参数
Map<String, Object> params = new HashMap<>();
// 将分页索引和最大结果数放入参数映射中
params.put("pageIndex", dto.getPageIndex());
params.put("maxResultCount", dto.getMaxResultCount());
// 将查询DTO转换为JSON字符串，再转换为Map对象，然后放入参数映射中
params.put("queryDto", JSONUtil.toBean(JSONUtil.toJsonStr(dto.getQueryDto()), AccessRecordFindReq.class));
// 调用API工具类的POST方法，传入参数和API路径，获取API响应对象
ApiResp apiResp = e8ApiUtil.doPost(params, GET_PAGE_ACCESS_RECORD_PAGE_LIST);
// 如果API响应不成功，则返回null
if (!apiResp.getSuccess()) {
log.error("调用E8获取通行记录分页列表失败，errorMsg:{}", apiResp);
return null;
}
// 将API响应的结果转换为JSON字符串，再转换为Map对象
Map<String, Object> result = JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), new TypeReference<>() {
}, false);
// 创建一个分页对象，传入分页索引和最大结果数
TableDataInfo<AccessRecordFindRes> tableData = new TableDataInfo<>();
// 从结果映射中获取总记录数，转换为长整型后设置到分页对象中
tableData.setTotal(Long.parseLong(result.get("total").toString()));
// 从结果映射中获取项目列表，转换为访问记录信息列表后设置到分页对象中
tableData.setRows(JSONUtil.toList(JSONUtil.toJsonStr(result.get("item")), AccessRecordFindRes.class));
// 返回填充了数据的分页对象
return tableData;
}
/**
* 人员授权
*
* @param req 传参
* @return Boolean
*/
@Override
public Boolean addCustomerAuth(CustomerAuthAddReq req) {
// 创建一个参数映射，用于存储API请求的参数
Map<String, Object> params = BeanUtil.beanToMap(req);
// 调用API工具类的POST方法，传入参数和API路径，获取API响应对象
ApiResp apiResp = e8ApiUtil.doPost(params, PERSON_AUTHORIZATION);
if (!apiResp.getSuccess()) log.error("调用E8人员授权失败，errorMsg:{}", apiResp);
// 返回API调用是否成功
return apiResp.getSuccess();
}
/**
* 获取人员权限分页列表
*
* @param dto 传参
* @return TableDataInfo<CustomerAuthFindRes>
*/
@Override
public TableDataInfo<CustomerAuthFindRes> getPageCustomerAuth(QueryDto dto) {
// 创建一个参数映射，用于存储API请求的参数
Map<String, Object> params = new HashMap<>();
// 将分页索引和最大结果数放入参数映射中
params.put("pageIndex", dto.getPageIndex());
params.put("maxResultCount", dto.getMaxResultCount());
// 将查询DTO转换为JSON字符串，再转换为Map对象，然后放入参数映射中
params.put("queryDto", JSONUtil.toBean(JSONUtil.toJsonStr(dto.getQueryDto()), CustomerAuthFindReq.class));
// 调用API工具类的POST方法，传入参数和API路径，获取API响应对象
ApiResp apiResp = e8ApiUtil.doPost(params, GET_PAGE_PERSON_AUTHORIZATION_PAGE_LIST);
// 如果API响应不成功，则返回null
if (!apiResp.getSuccess()) {
log.error("调用E8获取人员权限分页列表失败，errorMsg:{}", apiResp);
return null;
}
// 将API响应的结果转换为JSON字符串，再转换为Map对象
Map<String, Object> result = JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), new TypeReference<>() {
}, false);
// 创建一个分页对象，传入分页索引和最大结果数
TableDataInfo<CustomerAuthFindRes> tableData = new TableDataInfo<>();
// 从结果映射中获取总记录数，转换为长整型后设置到分页对象中
tableData.setTotal(Long.parseLong(result.get("total").toString()));
// 从结果映射中获取项目列表，转换为访问记录信息列表后设置到分页对象中
tableData.setRows(JSONUtil.toList(JSONUtil.toJsonStr(result.get("item")), CustomerAuthFindRes.class));
// 返回填充了数据的分页对象
return tableData;
}
//***************************************电梯信息接口*******************************************
private static final String GET_PAGE_LIST = "/api/E8Door/man-elevator-management/get-page-list";
private static final String GET_LIFT_FLOOR = "/api/E8Door/man-elevator-management/{id}/get-man-elevator-floors";
private static final String LIFT_ADD = "/api/E8Door/man-elevator-management";
private static final String LIFT_UPDATE = "/api/E8Door/man-elevator-management/{id}/update";
private static final String LIFT_DELETE = "/api/E8Door/man-elevator-management/{id}";
/**
* 电梯信息分页查询
*
* @param dto 传参
* @return IPage<LiftFindRes>
*/
@Override
public IPage<LiftFindRes> getPageList(QueryDto dto) {
// 创建一个参数映射，用于存储API请求所需的参数
Map<String, Object> params = new HashMap<>();
// 将分页索引和最大结果数放入参数映射中
params.put("pageIndex", dto.getPageIndex());
params.put("maxResultCount", dto.getMaxResultCount());
// 将查询DTO转换为LiftInfo对象，并将其添加到参数映射中
params.put("queryDto", JSONUtil.toBean(JSONUtil.toJsonStr(dto.getQueryDto()), LiftFindReq.class));
// 调用E8 API工具类的POST方法，传入参数和API路径，获取API响应
ApiResp apiResp = e8ApiUtil.doPost(params, GET_PAGE_LIST);
// 如果API响应不成功，则返回null
if (!apiResp.getSuccess()) {
return null;
}
// 将API响应的结果转换为一个Map对象
Map<String, Object> result = JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), new TypeReference<>() {
}, false);
// 创建一个分页对象，传入分页索引和最大结果数
IPage<LiftFindRes> page = new Page<>(dto.getPageIndex(), dto.getMaxResultCount());
// 设置分页对象的总记录数
page.setTotal(Long.parseLong(result.get("total").toString()));
// 将结果中的项转换为LiftFindRes列表，并设置为分页对象的记录
page.setRecords(JSONUtil.toList(JSONUtil.toJsonStr(result.get("item")), LiftFindRes.class));
// 返回填充了数据的分页对象
return page;
}
/**
* 查询电梯楼层
*
* @param id 传参
* @return LiftFindRes
*/
@Override
public LiftFindRes getLiftFloor(Long id) {
// 构造请求URL，其中{id}将被liftInfo的ID替换
String url = GET_LIFT_FLOOR.replace("{id}", id.toString());
// 调用API接口，获取电梯信息
ApiResp apiResp = e8ApiUtil.doPost(new HashMap<>(), url);
// 如果API调用不成功，则返回null
if (!apiResp.getSuccess()) {
return null;
}
// 将API响应结果转换为LiftFindRes对象，并返回
return JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), LiftFindRes.class);
}
/**
* 添加电梯
*
* @param addReq 传参
* @return Boolean
*/
@Override
public Boolean addLift(LiftAddReq addReq) {
// 将添加请求对象转换为Map对象，便于后续操作
Map<String, Object> params = BeanUtil.beanToMap(addReq);
// 调用第三方API进行电梯添加操作，并获取API响应结果
ApiResp apiResp = e8ApiUtil.doPost(params, LIFT_ADD);
// 返回API操作是否成功的标志
return apiResp.getSuccess();
}
/**
* 修改电梯信息
*
* @param updateReq 传参
* @return Boolean
*/
@Override
public Boolean updateLift(LiftUpdateReq updateReq) {
// 根据LiftUpdateReq对象中的ID生成请求URL
String url = LIFT_UPDATE.replace("{id}", updateReq.getId().toString());
// 将LiftUpdateReq对象转换为Map类型，以便于API请求参数的处理
Map<String, Object> params = BeanUtil.beanToMap(updateReq);
// 调用E8 API进行POST请求，并返回API响应对象
ApiResp apiResp = e8ApiUtil.doPost(params, url);
// 返回API调用是否成功的标志
return apiResp.getSuccess();
}
/**
* 删除电梯信息
*
* @param id 传参
* @return Boolean
*/
@Override
public Boolean deleteLift(Integer id) {
// 构造删除电梯的API请求URL，使用id替换模板中的{id}占位符
String url = LIFT_DELETE.replace("{id}", id.toString());
// 调用e8ApiUtils工具类执行DELETE请求，并获取API响应结果
ApiResp apiResp = e8ApiUtil.doGetOrDel(url, null, true);
// 返回API响应中的成功标志，表示删除操作是否成功
return apiResp.getSuccess();
}
//***************************************凭证信息接口*******************************************
private static final String ISSUANCE_VOUCHER = "/api/E8/voucher/issue-voucher";
private static final String OPERATE_VOUCHER = "/api/E8/voucher/operate-many";
private static final String CHANGE_CARD = "/api/E8/voucher/change-card";
/**
* 发行凭证
*
* @param req 入参
* @return 是否成功
*/
@Override
public Long issueVoucher(IssueVoucherReq req) {
// 封装入参
Map<String, Object> params = BeanUtil.beanToMap(req);
// 调用API
ApiResp apiResp = e8ApiUtil.doPost(params, ISSUANCE_VOUCHER);
if (!apiResp.getSuccess()) {
log.error("E8发行凭证失败，errorMsg：{}", apiResp);
return null;
}
IssueVoucherRes res = JSONUtil.toBean(JSONUtil.toJsonStr(apiResp.getResult()), IssueVoucherRes.class);
return res.getId();
}
/**
* 操作凭证
*
* @param req 入参
* @return Boolean
*/
@Override
public Boolean operateVoucher(OperateVoucherReq req) {
// 封装入参
Map<String, Object> params = BeanUtil.beanToMap(req);
// 调用API
ApiResp apiResp = e8ApiUtil.doPost(params, OPERATE_VOUCHER);
if (!apiResp.getSuccess()) log.error("E8操作凭证失败，errorMsg：{}", apiResp);
return apiResp.getSuccess();
}
/**
* 换卡补卡
*
* @param req 入参
* @return Boolean
*/
@Override
public Boolean changeCard(ChangeCardReq req) {
// 封装入参
Map<String, Object> params = BeanUtil.beanToMap(req);
// 调用API
ApiResp apiResp = e8ApiUtil.doPost(params, CHANGE_CARD);
if (!apiResp.getSuccess()) log.error("E8换卡补卡失败，errorMsg：{}", apiResp);
return apiResp.getSuccess();
}
/**
* 上传人脸
*
* @param imageByte 入参
* @return imageUrl 人脸图片地址
*/
@Override
public String uploadFace(byte[] imageByte) {
ApiResp apiResp = e8ApiUtil.doFaceImgUpload(imageByte);
if (!apiResp.getSuccess()) {
log.error("上传人脸图片失败，errorMsg：{}", apiResp);
return null;
}
return apiResp.getMessage();
}
}

6
ruoyi-modules/Sis/src/main/java/org/dromara/sis/sdk/hik/calback/HikAlarmCallBack.java
View File

@ -9,7 +9,7 @@ import org.apache.dubbo.config.annotation.DubboReference;
import org.dromara.property.api.RemoteFloorService;
import org.dromara.property.api.domain.vo.RemoteFloorVo;
import org.dromara.sis.domain.vo.*;
import org.dromara.sis.sdk.e8.AccessControlService;
import org.dromara.sis.sdk.e8.E8PlatformApi;
import org.dromara.sis.sdk.e8.domain.accessControl.req.RemoteOpenDoorReq;
import org.dromara.sis.sdk.hik.HCNetSDK;
import org.dromara.sis.sdk.hik.HikApiService;
@ -33,7 +33,7 @@ public class HikAlarmCallBack implements HCNetSDK.FMSGCallBack_V31 {
private final ISisAccessControlService accessControlService;
private final ISisElevatorFloorRefService elevatorFloorRefService;
private final AccessControlService e8AccessControlService;
private final E8PlatformApi e8PlatformApi;
@DubboReference
private RemoteFloorService remoteFloorService;
@ -99,7 +99,7 @@ public class HikAlarmCallBack implements HCNetSDK.FMSGCallBack_V31 {
data.setDeviceId(Long.parseLong(ac.getOutCode()));
data.setDoorId(Long.parseLong(ac.getOutCode()));
req.setControlList(List.of(data));
Boolean flag = e8AccessControlService.remoteOpenDoor(req);
Boolean flag = e8PlatformApi.remoteOpenDoor(req);
log.info("远程开门结果,result={}", flag);
}
});

4
ruoyi-modules/Sis/src/main/java/org/dromara/sis/sdk/unview/service/VideoAlarmService.java
View File

@ -3,7 +3,7 @@ package org.dromara.sis.sdk.unview.service;
import com.alibaba.fastjson.JSONObject;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.dromara.sis.sdk.e8.AccessControlService;
import org.dromara.sis.sdk.e8.E8PlatformApi;
import org.dromara.sis.sdk.hik.HikApiService;
import org.dromara.sis.sdk.unview.model.UvModel;
import org.dromara.sis.sdk.unview.model.enums.AlarmTypeEnum;
@ -28,7 +28,7 @@ public class VideoAlarmService {
private final ISisDeviceManageService deviceManageService;
private final ISisAuthRecordService authRecordService;
private final AccessControlService accessControlService;
private final E8PlatformApi e8PlatformApi;
private final ISisAccessControlService sisAccessControlService;
private final ISisDeviceBindRefService deviceBindRefService;

6
ruoyi-modules/Sis/src/main/java/org/dromara/sis/service/impl/SisAccessControlServiceImpl.java
View File

@ -22,7 +22,7 @@ import org.dromara.sis.domain.enums.ControlTypeEnum;
import org.dromara.sis.domain.vo.SisAccessControlVo;
import org.dromara.sis.domain.vo.SisDeviceManageVo;
import org.dromara.sis.mapper.SisAccessControlMapper;
import org.dromara.sis.sdk.e8.DoorDeviceService;
import org.dromara.sis.sdk.e8.E8PlatformApi;
import org.dromara.sis.sdk.e8.domain.door.res.AuthDoorDeviceFindRes;
import org.dromara.sis.service.ISisAccessControlService;
import org.dromara.sis.service.ISisDeviceBindRefService;
@ -47,7 +47,7 @@ import java.util.Map;
public class SisAccessControlServiceImpl implements ISisAccessControlService {
private final SisAccessControlMapper baseMapper;
private final DoorDeviceService doorDeviceService;
private final E8PlatformApi e8PlatformApi;
private final ISisDeviceManageService sisDeviceManageService;
private final ISisDeviceBindRefService sisDeviceBindRefService;
@DubboReference
@ -207,7 +207,7 @@ public class SisAccessControlServiceImpl implements ISisAccessControlService {
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean syncE8() {
List<AuthDoorDeviceFindRes> authDoorDeviceFindRes = doorDeviceService.getPageAuthDoorDeviceList();
List<AuthDoorDeviceFindRes> authDoorDeviceFindRes = e8PlatformApi.getPageAuthDoorDeviceList();
LambdaQueryWrapper<SisAccessControl> lqw = Wrappers.lambdaQuery();
lqw.eq(true, SisAccessControl::getControlType, 2);