xiaodaozi
/
yinyitong-zhongyuyuan-dll-stand
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

添加操作状态码，日志记录格式调整

This commit is contained in:
王志成 2025-02-26 18:19:44 +08:00
parent 7c55b7d2d2
commit f088a42aff
2 changed files with 117 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
src/main/java/com/dpkj/common/vo/Result.java
View File

@ -28,6 +28,11 @@ public class Result<T> implements Serializable {
*/
private Integer code = 0;
/**
* 状态
*/
private int state;
/**
* 返回数据对象 data
*/
@ -42,49 +47,61 @@ public class Result<T> implements Serializable {
}
public static <T> Result<T> ok() {
return ok("", null);
return ok("", null, 0);
}
public static <T> Result<T> ok(String msg) {
return ok(msg, null);
return ok(msg, null, 0);
}
public static <T> Result<T> ok(T data) {
return ok("", data);
return ok("", data, 0);
}
public static <T> Result<T> ok(String msg, T data) {
return ok(msg, data, 0);
}
public static <T> Result<T> ok(String msg, T data, int state) {
Result<T> r = new Result<T>();
r.setSuccess(true);
r.setCode(CommonConst.SC_200);
r.setMessage(msg);
r.setResult(data);
r.setState(state);
return r;
}
public static <T> Result<T> error(String msg, T data) {
return error(CommonConst.SC_500, msg, data);
return error(CommonConst.SC_500, msg, data, 0);
}
public static <T> Result<T> error(String msg, int state) {
return error(CommonConst.SC_500, msg, null, state);
}
public static <T> Result<T> error(String msg) {
return error(CommonConst.SC_500, msg, null);
return error(CommonConst.SC_500, msg, null, 0);
}
public static <T> Result<T> error(ErrorEnum errorEnum) {
return error(errorEnum.getCode(), errorEnum.getMessage(), null);
return error(errorEnum.getCode(), errorEnum.getMessage(), null, 0);
}
public static <T> Result<T> error(int code, String message) {
return error(code, message, null);
return error(code, message, null, 0);
}
public static <T> Result<T> error(int code, String msg, T data) {
return error(code, msg, data, 0);
}
public static <T> Result<T> error(int code, String msg, T data, int state) {
Result<T> r = new Result<T>();
r.setCode(code);
r.setMessage(msg);
r.setSuccess(false);
r.setResult(data);
r.setState(state);
return r;
}
}

163
src/main/java/com/dpkj/modules/readcard/service/impl/ReadCardServiceImpl.java
View File

@ -36,6 +36,12 @@ public class ReadCardServiceImpl implements ReadCardService {
@Autowired
private ThirdServiceUtil thirdServiceUtil;
private String getLogPrefix() {
StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
String methodName = stackTrace[3].getMethodName();
return "[" + this.getClass().getSimpleName() + "#" + methodName + "] ";
}
/**
* 身份证读取
* 1. 获取设备状态
@ -48,19 +54,21 @@ public class ReadCardServiceImpl implements ReadCardService {
*/
@Override
public Result IDCardReader() {
// String logPrefix = getLogPrefix();
Result result = null;
log.info("开始执行身份证读取流程");
log.info("[ReadCardServiceImpl][IDCardReader][60]: {}", "开始执行身份证读取流程");
try {
// 获取设备状态
LexMarkDTO status = new LexMarkDTO();
status.setDevName(LexMarkConst.ID_CARD_READ);
status.setCallID(0);
status.setActionName(MiddlewareFunctionsConst.GET_STATUS_SYNC);
JSONObject statusParam = new JSONObject();
statusParam.put("timeout", 0);
log.info("获取设备状态，参数: {}", status);
log.info("[ReadCardServiceImpl][IDCardReader][69]: 获取设备状态，参数:{}", status);
IDCardReadResultVO statusResult = thirdServiceUtil.callDevice(status, IDCardReadResultVO.class);
log.info("获取设备状态结果: {}", statusResult);
log.info("[ReadCardServiceImpl][IDCardReader][71]: 获取设备状态结果{}", statusResult);
if (statusResult.getResult() == 0) {
// 连接状态，初始化
LexMarkDTO reset = new LexMarkDTO();
@ -69,40 +77,41 @@ public class ReadCardServiceImpl implements ReadCardService {
reset.setActionName(MiddlewareFunctionsConst.RESET);
JSONObject resetParam = new JSONObject();
resetParam.put("ResetAction", 1);
log.info("调用复位（初始化）方法，参数: {}", reset);
log.info("[ReadCardServiceImpl][IDCardReader][80]: 调用复位（初始化）方法，参数:{}", reset);
IDCardReadResultVO resetResult = thirdServiceUtil.callDevice(reset, IDCardReadResultVO.class);
log.info("设备复位（初始化）结果: {}", resetResult);
log.info("[ReadCardServiceImpl][IDCardReader][82]: 设备复位（初始化）结果: {}", resetResult);
if (resetResult.getResult() == 0) {
// 复位成功
result = connectAndReadIDCard(result);
} else {
result = Result.error("身份证读取设备（初始化）异常，详情：" + ErrorCodeConstants.COMMON_ERROR_CODE.get(resetResult.getResult()));
log.info("身份证读取设备（初始化）异常，详情：{}", ErrorCodeConstants.COMMON_ERROR_CODE.get(resetResult.getResult()));
result = Result.error(ErrorCodeConstants.COMMON_ERROR_CODE.get(resetResult.getResult()), resetResult.getResult());
log.info("[ReadCardServiceImpl][IDCardReader][88]: 身份证读取设备（初始化）异常，详情：{}", ErrorCodeConstants.COMMON_ERROR_CODE.get(resetResult.getResult()));
}
} else {
// 设备未连接，无需复位（初始化）
result = connectAndReadIDCard(result);
}
} finally {
log.info("准备关闭身份证读卡设备");
log.info("[ReadCardServiceImpl][IDCardReader][95]: {}", "准备关闭身份证读卡设备");
// 关闭身份证读卡设备
LexMarkDTO close = new LexMarkDTO();
close.setDevName(LexMarkConst.ID_CARD_READ);
close.setCallID(0);
close.setActionName(MiddlewareFunctionsConst.CLOSE_CONNECTION);
log.info("调用设备关闭方法，参数: {}", close);
log.info("[ReadCardServiceImpl][IDCardReader][101]: 调用设备关闭方法，参数: {}", close);
IDCardReadResultVO closeResult = thirdServiceUtil.callDevice(close, IDCardReadResultVO.class);
log.info("设备关闭结果: {}", closeResult);
log.info("[ReadCardServiceImpl][IDCardReader][103]: 设备关闭结果: {}", closeResult);
if (closeResult.getResult() != 0) {
log.error("身份证读卡设备关闭异常！");
log.info("[ReadCardServiceImpl][IDCardReader][105]: {}", "身份证读卡设备关闭异常！");
}
}
log.info("身份证读取流程结束，最终返回结果: {}", result);
log.info("[ReadCardServiceImpl][IDCardReader][108]: 身份证读取流程结束，最终返回结果: {}", result);
return result;
}
private Result connectAndReadIDCard(Result result) {
log.info("准备连接非接身份证读卡模块");
// String logPrefix = getLogPrefix();
log.info("[ReadCardServiceImpl][connectAndReadIDCard][114]: {}", "准备连接非接身份证读卡模块");
// 连接非接身份证读卡模块
LexMarkDTO connect = new LexMarkDTO();
connect.setActionName(MiddlewareFunctionsConst.OPEN_CONNECTION);
@ -112,11 +121,11 @@ public class ReadCardServiceImpl implements ReadCardService {
connectParam.put("TimeOut", 30000);
connectParam.put("ServiceName", LexMarkConst.ID_CARD_READ);
connect.setParam(connectParam.toJSONString());
log.info("调用设备连接方法，参数: {}", connect);
log.info("[ReadCardServiceImpl][connectAndReadIDCard][124]: 调用设备连接方法，参数: {}", connect);
IDCardReadResultVO connectResult = thirdServiceUtil.callDevice(connect, IDCardReadResultVO.class);
log.info("设备连接结果: {}", connectResult);
log.info("[ReadCardServiceImpl][connectAndReadIDCard][126]: 设备连接结果: {}", connectResult);
if (connectResult.getResult() == 0) {
log.info("设备连接成功，准备读取身份证");
log.info("[ReadCardServiceImpl][connectAndReadIDCard][128]: {}", "设备连接成功，准备读取身份证");
// 身份证读取
LexMarkDTO read = new LexMarkDTO();
read.setActionName(MiddlewareFunctionsConst.ACCEPT_AND_READ_TRACKS);
@ -126,14 +135,14 @@ public class ReadCardServiceImpl implements ReadCardService {
readParam.put("TimeOut", 80000);
readParam.put("TrackMap", 776);
read.setParam(readParam.toJSONString());
log.info("调用设备读取方法，参数: {}", read);
log.info("[ReadCardServiceImpl][connectAndReadIDCard][138]: 调用设备读取方法，参数: {}", read);
IDCardReadResultVO readResult = thirdServiceUtil.callDevice(read, IDCardReadResultVO.class);
log.info("设备读取结果: {}", readResult);
log.info("[ReadCardServiceImpl][connectAndReadIDCard][140]: 设备读取结果: {}", readResult);
if (readResult.getResult() == 0) {
log.info("身份证读取成功，开始解析身份证信息");
log.info("[ReadCardServiceImpl][connectAndReadIDCard][142]: {}", "身份证读取成功，开始解析身份证信息");
IDCardReadResultVO.Param resultParam = JSON.parseObject(readResult.getParam().toString(), IDCardReadResultVO.Param.class);
if (resultParam.getResult() == 0) {
log.info("身份证信息解析成功，开始封装用户信息");
log.info("[ReadCardServiceImpl][connectAndReadIDCard][145]: {}", "身份证信息解析成功，开始封装用户信息");
UserInfoVO userInfoVO = new UserInfoVO();
// 身份证基本信息 解析
String[] array = Stream.of(resultParam.getChipdata().getDatas().split("\\|"))
@ -155,18 +164,20 @@ public class ReadCardServiceImpl implements ReadCardService {
// 反面
userInfoVO.setBackimage(resultParam.getBackimage().getDatas().replace("\\\\", "/"));
result = Result.ok(userInfoVO);
log.info("用户信息封装成功，返回结果: {}", result);
log.info("[ReadCardServiceImpl][connectAndReadIDCard][167]: 用户信息封装成功，返回结果: {}", result);
} else {
result = Result.error("身份证读取失败！失败原因：" + ErrorCodeConstants.COMMON_ERROR_CODE.get(resultParam.getResult()));
log.error("身份证信息解析失败，错误信息: {}, 返回结果: {}", ErrorCodeConstants.COMMON_ERROR_CODE.get(resultParam.getResult()), result);
result = Result.error(ErrorCodeConstants.COMMON_ERROR_CODE.get(resultParam.getResult()), resultParam.getResult());
log.info("[ReadCardServiceImpl][connectAndReadIDCard][170]: 身份证信息解析失败，错误信息: {}, 返回结果: {}",
ErrorCodeConstants.COMMON_ERROR_CODE.get(resultParam.getResult()), result);
}
} else {
result = Result.error(ErrorCodeConstants.COMMON_ERROR_CODE.get(readResult.getResult()));
log.error("身份证读取失败，错误信息: {}, 返回结果: {}", ErrorCodeConstants.COMMON_ERROR_CODE.get(readResult.getResult()), result);
result = Result.error(ErrorCodeConstants.COMMON_ERROR_CODE.get(readResult.getResult()), readResult.getResult());
log.info("[ReadCardServiceImpl][connectAndReadIDCard][175]: 身份证读取失败，错误信息: {}, 返回结果: {}",
ErrorCodeConstants.COMMON_ERROR_CODE.get(readResult.getResult()), result);
}
} else {
result = Result.error(ErrorCodeConstants.COMMON_ERROR_CODE.get(connectResult.getResult()));
log.error("设备连接失败，错误信息: {}, 返回结果: {}", connectResult, result);
result = Result.error(ErrorCodeConstants.COMMON_ERROR_CODE.get(connectResult.getResult()), connectResult.getResult());
log.info("[ReadCardServiceImpl][connectAndReadIDCard][180]: 设备连接失败，错误信息: {}, 返回结果: {}", connectResult, result);
}
return result;
}
@ -185,6 +196,7 @@ public class ReadCardServiceImpl implements ReadCardService {
*/
@Override
public Result SocialSecurityCardReader() {
// String logPrefix = getLogPrefix();
Result result = null;
// 获取设备状态
LexMarkDTO status = new LexMarkDTO();
@ -193,9 +205,9 @@ public class ReadCardServiceImpl implements ReadCardService {
status.setActionName(MiddlewareFunctionsConst.GET_STATUS_SYNC);
JSONObject statusParam = new JSONObject();
statusParam.put("timeout", 0);
log.info("获取设备状态，参数: {}", status);
log.info("[ReadCardServiceImpl][SocialSecurityCardReader][208]: 获取设备状态，参数: {}", status);
IDCardReadResultVO statusResult = thirdServiceUtil.callDevice(status, IDCardReadResultVO.class);
log.info("获取设备状态结果: {}", statusResult);
log.info("[ReadCardServiceImpl][SocialSecurityCardReader][210]: 获取设备状态结果: {}", statusResult);
if (statusResult.getResult() == 0) {
// 连接状态，初始化
LexMarkDTO reset = new LexMarkDTO();
@ -204,29 +216,31 @@ public class ReadCardServiceImpl implements ReadCardService {
reset.setActionName(MiddlewareFunctionsConst.RESET);
JSONObject resetParam = new JSONObject();
resetParam.put("ResetAction", 1);
log.info("调用复位（初始化）方法，参数: {}", reset);
log.info("[ReadCardServiceImpl][SocialSecurityCardReader][219]: 调用复位（初始化）方法，参数: {}", reset);
IDCardReadResultVO resetResult = thirdServiceUtil.callDevice(reset, IDCardReadResultVO.class);
log.info("设备复位（初始化）结果: {}", resetResult);
log.info("[ReadCardServiceImpl][SocialSecurityCardReader][221]: 设备复位（初始化）结果: {}", resetResult);
if (resetResult.getResult() == 0) {
// 复位成功
result = connectAndSocialSecurityCardReader(result);
} else {
result = Result.error("社保卡读取设备（初始化）异常，详情：" + ErrorCodeConstants.COMMON_ERROR_CODE.get(resetResult.getResult()));
log.info("社保卡读取设备（初始化）异常，详情：{}", ErrorCodeConstants.COMMON_ERROR_CODE.get(resetResult.getResult()));
result = Result.error(ErrorCodeConstants.COMMON_ERROR_CODE.get(resetResult.getResult()), resetResult.getResult());
log.info("[ReadCardServiceImpl][SocialSecurityCardReader][227]: 社保卡读取设备（初始化）异常，详情：{}",
ErrorCodeConstants.COMMON_ERROR_CODE.get(resetResult.getResult()));
}
} else {
// 设备未连接，无需复位（初始化）
result = connectAndSocialSecurityCardReader(result);
}
log.info("社保卡读取流程结束，最终返回结果: {}", result);
log.info("[ReadCardServiceImpl][SocialSecurityCardReader][234]: 社保卡读取流程结束，最终返回结果: {}", result);
return result;
}
public Result connectAndSocialSecurityCardReader(Result result) {
log.info("开始执行社保卡读取流程");
// String logPrefix = getLogPrefix();
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][240]: {}", "开始执行社保卡读取流程");
// 社保卡读卡设备连接
log.info("准备连接社保卡读卡设备");
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][243]: {}", "准备连接社保卡读卡设备");
LexMarkDTO connect = new LexMarkDTO();
connect.setActionName(MiddlewareFunctionsConst.OPEN_CONNECTION);
connect.setCallID(19256);
@ -235,14 +249,14 @@ public class ReadCardServiceImpl implements ReadCardService {
connectParam.put("TimeOut", 30000);
connectParam.put("ServiceName", LexMarkConst.CARD_READER);
connect.setParam(connectParam.toJSONString());
log.info("调用设备连接方法，参数: {}", connect);
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][252]: 调用设备连接方法，参数: {}", connect);
IDCardReadResultVO connectResult = thirdServiceUtil.callDevice(connect, IDCardReadResultVO.class);
log.info("设备连接结果: {}", connectResult);
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][254]: 设备连接结果: {}", connectResult);
if (connectResult.getResult() == 0) {
log.info("社保卡读卡设备连接成功，准备进卡");
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][256]: {}", "社保卡读卡设备连接成功，准备进卡");
// 进卡
log.info("准备执行进卡操作");
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][259]: {}", "准备执行进卡操作");
LexMarkDTO enterTheCard = new LexMarkDTO();
enterTheCard.setActionName(MiddlewareFunctionsConst.ACCEPT_AND_READ_TRACKS);
enterTheCard.setCallID(19256);
@ -252,14 +266,14 @@ public class ReadCardServiceImpl implements ReadCardService {
enterTheCardParam.put("TrackMap", 11);
enterTheCardParam.put("TimeOut", 80000);
enterTheCard.setParam(enterTheCardParam.toJSONString());
log.info("调用进卡方法，参数: {}", enterTheCard);
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][269]: 调用进卡方法，参数: {}", enterTheCard);
IDCardReadResultVO enterTheCardResult = thirdServiceUtil.callDevice(enterTheCard, IDCardReadResultVO.class);
log.info("进卡操作结果: {}", enterTheCardResult);
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][271]: 进卡操作结果: {}", enterTheCardResult);
if (enterTheCardResult.getResult() == 0) {
log.info("进卡操作成功，准备上电");
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][273]: {}", "进卡操作成功，准备上电");
// 上电
log.info("准备执行上电操作");
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][276]: {}", "准备执行上电操作");
LexMarkDTO powerOn = new LexMarkDTO();
powerOn.setActionName(MiddlewareFunctionsConst.CHIPPOWER);
powerOn.setCallID(19256);
@ -268,14 +282,14 @@ public class ReadCardServiceImpl implements ReadCardService {
powerOnParam.put("PsamNo", 1);
powerOnParam.put("ChipAction", 2);
powerOn.setParam(powerOnParam.toJSONString());
log.info("调用上电方法，参数: {}", powerOn);
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][285]: 调用上电方法，参数: {}", powerOn);
IDCardReadResultVO powerOnResult = thirdServiceUtil.callDevice(powerOn, IDCardReadResultVO.class);
log.info("上电操作结果: {}", powerOnResult);
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][287]: 上电操作结果: {}", powerOnResult);
if (powerOnResult.getResult() == 0) {
log.info("上电操作成功，准备读取社保卡信息");
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][289]: {}", "上电操作成功，准备读取社保卡信息");
// 社保卡信息读取
log.info("准备读取社保卡信息");
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][292]: {}", "准备读取社保卡信息");
LexMarkDTO socialSecurityCardReader = new LexMarkDTO();
socialSecurityCardReader.setActionName(MiddlewareFunctionsConst.I_READ_CARD_BAS);
socialSecurityCardReader.setCallID(19256);
@ -283,11 +297,11 @@ public class ReadCardServiceImpl implements ReadCardService {
JSONObject socialSecurityCardReaderParam = new JSONObject();
socialSecurityCardReaderParam.put("iType", 3);
socialSecurityCardReader.setParam(socialSecurityCardReaderParam.toJSONString());
log.info("调用读取社保卡信息方法，参数: {}", socialSecurityCardReader);
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][300]: 调用读取社保卡信息方法，参数: {}", socialSecurityCardReader);
IDCardReadResultVO socialSecurityCardReaderResult = thirdServiceUtil.callDevice(socialSecurityCardReader, IDCardReadResultVO.class);
log.info("读取社保卡信息结果: {}", socialSecurityCardReaderResult);
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][302]: 读取社保卡信息结果: {}", socialSecurityCardReaderResult);
if (socialSecurityCardReaderResult.getResult() == 0) {
log.info("社保卡信息读取成功，开始解析信息");
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][304]: {}", "社保卡信息读取成功，开始解析信息");
// 社保信息
IDCardReadResultVO.SocialSecurityCard resultParam = JSON.parseObject(socialSecurityCardReaderResult.getParam().toString(), IDCardReadResultVO.SocialSecurityCard.class);
@ -305,23 +319,27 @@ public class ReadCardServiceImpl implements ReadCardService {
socialSecurityCardInfoVO.setExpireDate(split[8]);
socialSecurityCardInfoVO.setTerminalNumber(split[9]);
socialSecurityCardInfoVO.setTerminalDeviceNumber(split[10]);
log.info("社保卡信息解析完成，返回成功结果");
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][322]: {}", "社保卡信息解析完成，返回成功结果");
return Result.ok(socialSecurityCardInfoVO);
} else {
log.error("社保卡信息读取失败，详情：{}", ErrorCodeConstants.SOCIAL_SECURITYCARD_ERROR_CODE.get(socialSecurityCardReaderResult.getResult()));
return Result.error("社保卡信息读取失败，详情：{}" + ErrorCodeConstants.SOCIAL_SECURITYCARD_ERROR_CODE.get(socialSecurityCardReaderResult.getResult()));
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][325]: 社保卡信息读取失败，详情：{}",
ErrorCodeConstants.SOCIAL_SECURITYCARD_ERROR_CODE.get(socialSecurityCardReaderResult.getResult()));
return Result.error(ErrorCodeConstants.SOCIAL_SECURITYCARD_ERROR_CODE.get(socialSecurityCardReaderResult.getResult()), socialSecurityCardReaderResult.getResult());
}
} else {
log.error("社保卡读取设备上电失败，详情：{}", ErrorCodeConstants.COMMON_ERROR_CODE.get(powerOnResult.getResult()));
return Result.error("社保卡读取设备上电失败，详情：" + ErrorCodeConstants.COMMON_ERROR_CODE.get(powerOnResult.getResult()));
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][330]: 社保卡读取设备上电失败，详情：{}",
ErrorCodeConstants.COMMON_ERROR_CODE.get(powerOnResult.getResult()));
return Result.error(ErrorCodeConstants.COMMON_ERROR_CODE.get(powerOnResult.getResult()), powerOnResult.getResult());
}
} else {
log.error("社保卡读取设备进卡失败，详情：{}", ErrorCodeConstants.COMMON_ERROR_CODE.get(enterTheCardResult.getResult()));
return Result.error("社保卡读取设备进卡失败，详情：" + ErrorCodeConstants.COMMON_ERROR_CODE.get(enterTheCardResult.getResult()));
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][335]: 社保卡读取设备进卡失败，详情：{}",
ErrorCodeConstants.COMMON_ERROR_CODE.get(enterTheCardResult.getResult()));
return Result.error(ErrorCodeConstants.COMMON_ERROR_CODE.get(enterTheCardResult.getResult()), enterTheCardResult.getResult());
}
} else {
log.error("社保卡读取设备连接失败，详情：{}", ErrorCodeConstants.COMMON_ERROR_CODE.get(connectResult.getResult()));
return Result.error("社保卡读取设备连接失败，详情：" + ErrorCodeConstants.COMMON_ERROR_CODE.get(connectResult.getResult()));
log.info("[ReadCardServiceImpl][connectAndSocialSecurityCardReader][340]: 社保卡读取设备连接失败，详情：{}",
ErrorCodeConstants.COMMON_ERROR_CODE.get(connectResult.getResult()));
return Result.error(ErrorCodeConstants.COMMON_ERROR_CODE.get(connectResult.getResult()), connectResult.getResult());
}
}
@ -332,10 +350,11 @@ public class ReadCardServiceImpl implements ReadCardService {
*/
@Override
public Result cardRefund() {
log.info("开始执行社保卡退卡流程");
// String logPrefix = getLogPrefix();
log.info("[ReadCardServiceImpl][cardRefund][354]: {}", "开始执行社保卡退卡流程");
// 社保卡退卡
log.info("准备发起社保卡退卡请求");
log.info("[ReadCardServiceImpl][cardRefund][357]: {}", "准备发起社保卡退卡请求");
LexMarkDTO cardRefund = new LexMarkDTO();
cardRefund.setDevName(LexMarkConst.CARD_READER);
cardRefund.setCallID(19256);
@ -344,30 +363,32 @@ public class ReadCardServiceImpl implements ReadCardService {
cardRefundParam.put("position", 1);
cardRefundParam.put("ejectpos", 1);
cardRefund.setParam(cardRefundParam.toJSONString());
log.info("调用设备退卡方法，参数: {}", cardRefund);
log.info("[ReadCardServiceImpl][cardRefund][366]: 调用设备退卡方法，参数: {}", cardRefund);
IDCardReadResultVO cardRefundResult = thirdServiceUtil.callDevice(cardRefund, IDCardReadResultVO.class);
log.info("设备退卡操作结果: {}", cardRefundResult);
log.info("[ReadCardServiceImpl][cardRefund][368]: 设备退卡操作结果: {}", cardRefundResult);
if (cardRefundResult.getResult() == 0) {
log.info("社保卡退卡成功，准备关闭社保卡读卡设备");
log.info("[ReadCardServiceImpl][cardRefund][371]: {}", "社保卡退卡成功，准备关闭社保卡读卡设备");
// 退卡成功再关闭社保卡读卡设备
LexMarkDTO close = new LexMarkDTO();
close.setDevName(LexMarkConst.CARD_READER);
close.setCallID(0);
close.setActionName(MiddlewareFunctionsConst.CLOSE_CONNECTION);
log.info("调用设备关闭方法，参数: {}", close);
log.info("[ReadCardServiceImpl][cardRefund][378]: {}", "调用设备关闭方法，参数: {}", close);
IDCardReadResultVO closeResult = thirdServiceUtil.callDevice(close, IDCardReadResultVO.class);
log.info("设备关闭操作结果: {}", closeResult);
log.info("[ReadCardServiceImpl][cardRefund][380]: 设备关闭操作结果: {}", closeResult);
if (closeResult.getResult() != 0) {
log.error("社保卡读卡设备关闭异常！详情：{}", ErrorCodeConstants.SOCIAL_SECURITYCARD_ERROR_CODE.get(closeResult.getResult()));
log.info("[ReadCardServiceImpl][cardRefund][383]: 社保卡读卡设备关闭异常！详情：{}",
ErrorCodeConstants.SOCIAL_SECURITYCARD_ERROR_CODE.get(closeResult.getResult()), closeResult.getResult());
}
log.info("社保卡退卡流程完成，退卡成功");
log.info("[ReadCardServiceImpl][cardRefund][386]: {}", "社保卡退卡流程完成，退卡成功");
return Result.ok("退卡成功！");
} else {
log.error("退卡失败！请联系工作人员！失败原因：{}", ErrorCodeConstants.SOCIAL_SECURITYCARD_ERROR_CODE.get(cardRefundResult.getResult()));
return Result.error("退卡失败！请联系工作人员！失败原因：" + ErrorCodeConstants.SOCIAL_SECURITYCARD_ERROR_CODE.get(cardRefundResult.getResult()));
log.info("[ReadCardServiceImpl][cardRefund][389]: 退卡失败！请联系工作人员！失败原因：{}",
ErrorCodeConstants.SOCIAL_SECURITYCARD_ERROR_CODE.get(cardRefundResult.getResult()));
return Result.error(ErrorCodeConstants.SOCIAL_SECURITYCARD_ERROR_CODE.get(cardRefundResult.getResult()), cardRefundResult.getResult());
}
}
}