zhangFan / analysis_imf · 提交

转到一个项目

作者 朱兆平
提交 2b59a1686c0ce6dd8702f1876c94dcfd7095b2f3 1 个父辈 df7f5eba

抬杆判定优化

内嵌 并排对比
正在显示 25 个修改的文件 包含 1498 行增加 和 285 行删除
... ... @@ -6,6 +6,10 @@ eureka.client.service-url.defaultZone=http://192.168.1.53:12345/eureka/
spring.application.name=kako_analysisforstation
spring.cloud.service-registry.auto-registration.enabled=false
spring.cloud.discovery.client.health-indicator.enabled=false
spring.cloud.service-registry.auto-registration.register-management=false
spring.cloud.features.enabled=false
spring.cloud.discovery.enabled=false
spring.devtools.restart.enabled=true
... ... @@ -15,15 +19,18 @@ spring.mvc.view.suffix=/WEB-INF/jsp/
spring.mvc.view.prefix=.jsp
spring.redis.host=192.168.1.53
spring.redis.port=6379
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# 测试环境
spring.datasource.username=110
spring.datasource.password=QAHqCJf2kFYCLirM
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://118.31.66.166:3306/station?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false&allowMultiQueries=true&useSSL=true&serverTimezone=Asia/Shanghai
#spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#spring.datasource.url=jdbc:mysql://localhost:3306/station?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false&allowMultiQueries=true&useSSL=true&serverTimezone=Asia/Shanghai
#spring.datasource.username=station
#spring.datasource.password=station@10.50.7.70
# 生产环境
#spring.datasource.url=jdbc:mysql://10.50.7.60:3306/station?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false&allowMultiQueries=true&useSSL=true&serverTimezone=Asia/Shanghai
#spring.datasource.username=110
#spring.datasource.password=vmvnv1v2VV.
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
... ... @@ -54,9 +61,9 @@ pagehelper.reasonable=true
pagehelper.support-methods-arguments=true
pagehelper.params=count=countSql
# 是否启用httpclient
feign.httpclient.enabled=false
feign.httpclient.enabled=true
# 是否启用httpok（性能比httpclient高）
feign.okhttp.enabled=true
#feign.okhttp.enabled=true
# 是否启用hystrix
feign.hystrix.enabled=true
# 请求连接超时时间（毫秒）
... ... @@ -66,5 +73,5 @@ wharf.interface.host=http://10.50.3.66:1983/
#新舱单运单查询数据接口,注意尾部带/符号
nmms.interface.host=http://10.50.3.82:8081/
#新舱单网站内网接口,注意尾部带/符号
nmms.site.host=http://nmms1.15miaoo.com:17999
nmms.site.host=http://10.50.3.61:90
custom.receptDirectory= bw/read/
... ...
... ... @@ -5,7 +5,7 @@
<groupId>com.sy</groupId>
<artifactId>analysis_imf</artifactId>
<version>2.1-BH-SNAPSHOT</version>
<version>2.12-BH-SNAPSHOT</version>
<packaging>jar</packaging>
<name>analysis_imf</name>
... ... @@ -33,6 +33,10 @@
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
... ...
... ... @@ -5,6 +5,7 @@ import com.sy.logic.LiftBar;
import com.sy.logic.LogicOperation;
import com.sy.model.*;
import com.sy.service.*;
import com.sy.service.impl.GatherInfoServiceImpl;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
... ... @@ -31,7 +32,7 @@ public class AnalysisRoute implements Runnable{
private CLRService clrService;
@Autowired
private GatherInfoService infoService;
private GatherInfoServiceImpl infoService;
@Autowired
private CommandInfoService commandService;
... ... @@ -89,7 +90,7 @@ public class AnalysisRoute implements Runnable{
PropertyConfigurator.configure("config/log4j.properties");
string = string.replace("Msg","MSG");
Message message = analysis.readTicketsXml(string);;
Message message = analysis.readTicketsXml(string);
String stype = message.getMeta().getSmType();
if (stype.equals("CARM")) {
if(message.getComInfo() !=null){
... ...
package com.sy.bwAnalysis;
import com.sy.bwAssist.Message;
import com.sy.model.GatherInfo;
import com.sy.model.commandInfo;
import org.apache.commons.lang.NullArgumentException;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Component;
/**
* 车辆过卡报文处理器
* @author mrz
*/
@Component
public class GatherInfoHandle implements Runnable{
private String message;
public String getMessage() {
return message;
}
public void setMessage(String message) {
/**
* 1). 非空验证
*/
if (StringUtils.isNotEmpty(message)){
this.message = message;
}else {
throw new NullArgumentException("报文内容为空");
}
}
@Override
public void run() {
/**
* 一. 报文处理
*/
stypConfirmAndRoute();
}
/**
* 1). 通过将xml转实体类进行验证,
* 同时验证报文的合法性,
* 转换失败会throw 异常出来
*/
private Message xmlTransToBean(){
message = message.replace("Msg","MSG");
MessageAnalysis analysis = new MessageAnalysis();
return analysis.readTicketsXml(message);
}
/**
* XML报文类型判断
* 通过META节点的STYP节点判定
*/
private void stypConfirmAndRoute(){
Message messageBean = xmlTransToBean();
String stype = messageBean.getMeta().getSmType();
if ("CARM".equals(stype)) {
if(messageBean.getComInfo() !=null){
CommandInfoAnalysis commandInfoAnalysis = new CommandInfoAnalysis();
commandInfo info = commandInfoAnalysis.toJavaBean(messageBean);
/**
* x22 commandInfo抬杆指令报文的处理
*/
}else{
/**
* x21 gatherInfo通道采集报文的处理
*/
GatherInfoAnalysis gatherInfoAnalysis = new GatherInfoAnalysis();
GatherInfo info = gatherInfoAnalysis.toJavaBean(messageBean);
}
}
}
}
... ...
... ... @@ -12,7 +12,7 @@ public class MessageAnalysis {
return getMessage(str);
}
static Message getMessage(String str) {
private Message getMessage(String str) {
XStream xstream = new XStream(new DomDriver("UTF-8", new XmlFriendlyNameCoder("_-", "_")));
xstream.processAnnotations(Message.class);
//对xstream对象设置默认的安全防护
... ...
... ... @@ -30,6 +30,8 @@ public interface LandBusinessTypeListMapper {
List<LandBusinessTypeList> selectByBarcode(@Param("barcode")String barcode);
List<LandBusinessTypeList> selectByBarcodeWithE(@Param("barcode")String barcode);
int updateByBarCode(@Param("barcode")String barcode);
... ...
package com.sy.model;
public enum BusinessTypeEnum {
/**
* 业务类型枚举
* todo: 代码暂时不正确
*/
IMPORT_LOCAL_DELIVER("进口提货","100001"),
EXPORT_LOCAL("出口送货","100002");
/**
* 业务类型
*/
private String name;
/**
* 对应金二业务代码
*/
private String code;
BusinessTypeEnum(String name, String code) {
this.name = name;
this.code = code;
}
public String getName() {
return name;
}
public String getCode() {
return code;
}
}
package com.sy.service;
/**
* @author mrz
* 描述:抬杆放行判定接口
*/
public interface BayonetReleaseCheck {
/**
* 车辆过卡信息抬杆指令判定_适配器
* @param businesstype 申请业务类型
* @param ieType 进出卡口类型 I 进 E 出
*/
public void bayonetCrossCheck(String businesstype,String ieType);
/**
* 车辆信息及车辆备案及黑名单判定
* @param veName 车牌号
*/
public void veInfoCHeck(String veName);
}
package com.sy.service;
/**
* @author mrz
* 描述:抬杆放行判定适配器
*/
public interface BayonetReleaseCheckAdvanced {
/**
* 进口清关提货
* 车辆过卡信息抬杆指令判定_适配器
* @param ieType 进出卡口类型 I 进 E 出
*/
public void importLocalDelivery(String ieType);
/**
* 出口清关送货
*/
public void exportLocalCustoms(String ieType);
}
... ... @@ -5,4 +5,9 @@ import com.sy.model.GatherInfo;
public interface GatherInfoService {
int save(GatherInfo info);
/**
* 根据过卡进行抬杆指令处理
*/
void handel(GatherInfo info);
}
... ...
... ... @@ -26,6 +26,8 @@ public interface LandBusListService {
List<LandBusinessTypeList> selectByBarcode(String barcode);
List<LandBusinessTypeList> selectByBarcodeWithE(String barcode);
int updateByBarcode(String barcode);
List<LandBusinessTypeList> selectMessageId(String messageId);
... ...
package com.sy.service;
import java.util.Set;
/**
* @author mrz
*/
public interface RedisService {
boolean expire(String key,long time);
boolean hasKey(String key);
void del(String ... key);
Set<String> deleteBatchByKeys(String key);
String get(String key);
boolean set(String key,String value);
boolean set(String key,String value,long time);
}
... ...
package com.sy.service.adapter;
import com.sy.service.BayonetReleaseCheck;
import com.sy.service.BayonetReleaseCheckAdvanced;
/**
* 车辆过卡路由适配器
* @author mrz
* @date 2022-08-07
*/
public class BayonetReleaseCheckAdapter implements BayonetReleaseCheck {
private static final String IMPORT_LOCAL_DELIVER = "进口提货";
private static final String EXPORT_LOCAL = "出口送货";
private BayonetReleaseCheckAdvanced bayonetReleaseCheckAdvanced;
public BayonetReleaseCheckAdapter(String businesstype) {
switch (businesstype){
case "进口提货":
bayonetReleaseCheckAdvanced = new BayonetReleaseCheckImportCustomsClearance();
break;
case "出口送货":
bayonetReleaseCheckAdvanced = new BayonetReleaseCheckExportCustomsClearance();
break;
default:
System.out.println("无法处理的业务类型");
break;
}
}
@Override
public void bayonetCrossCheck(String businesstype, String ieType) {
switch (businesstype){
case "进口提货":
bayonetReleaseCheckAdvanced.importLocalDelivery(ieType);
break;
case "出口送货":
bayonetReleaseCheckAdvanced.exportLocalCustoms(ieType);
default:
break;
}
}
@Override
public void veInfoCHeck(String veName) {
}
}
package com.sy.service.adapter;
import com.sy.service.BayonetReleaseCheckAdvanced;
/**
* 本地出口清关适配器处理器
*/
public class BayonetReleaseCheckExportCustomsClearance implements BayonetReleaseCheckAdvanced {
private static final org.slf4j.Logger log4 = org.slf4j.LoggerFactory.getLogger(BayonetReleaseCheckExportCustomsClearance.class);
@Override
public void importLocalDelivery( String ieType) {
log4.info("[Adapter]-进口-{}-本地-清关适配器处理,什么也不做",ieType);
}
@Override
public void exportLocalCustoms(String ieType) {
log4.info("[Adapter]-出口-{}-本地-清关适配器处理,处理出口送货清关业务",ieType);
}
}
package com.sy.service.adapter;
import com.sy.service.BayonetReleaseCheck;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 业务类型抬杆指令处理入口
* @author mrz
*/
public class BayonetReleaseCheckHandle implements BayonetReleaseCheck {
private static final Logger log4 = LoggerFactory.getLogger(BayonetReleaseCheckHandle.class);
private BayonetReleaseCheckAdapter bayonetReleaseCheckAdapter;
@Override
public void bayonetCrossCheck(String businesstype, String ieType) {
bayonetReleaseCheckAdapter = new BayonetReleaseCheckAdapter(businesstype);
bayonetReleaseCheckAdapter.bayonetCrossCheck(businesstype,ieType);
}
@Override
public void veInfoCHeck(String veName) {
}
}
package com.sy.service.adapter;
import com.sy.service.BayonetReleaseCheckAdvanced;
/**
* 进口清关适配器处理器
*/
public class BayonetReleaseCheckImportCustomsClearance implements BayonetReleaseCheckAdvanced {
private static final org.slf4j.Logger log4 = org.slf4j.LoggerFactory.getLogger(BayonetReleaseCheckImportCustomsClearance.class);
@Override
public void importLocalDelivery( String ieType) {
log4.info("[Adapter]-进口-{}-本地-清关适配器处理,处理本地清关业务",ieType);
}
@Override
public void exportLocalCustoms(String ieType) {
log4.info("[Adapter]-出口-{}-本地清关适配器处理,什么也不做",ieType);
}
}
package com.sy.service.impl;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.sy.crossDomain.buildBarCode;
import com.sy.logic.LiftBar;
import com.sy.model.*;
import com.sy.service.*;
import com.sy.socket.CommandClient;
import com.sy.utils.FileTool;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.validation.constraints.NotNull;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;
import static com.sy.service.impl.ResMessageServiceImpl.toStrArry;
@Service("GatherInfoHandle")
public class GatherInfoHandleImpl implements GatherInfoService {
private static final Logger logger = LoggerFactory.getLogger(LiftBar.class);
//逻辑判断后的返回信息定义
private static String PERMITTHOUGH = "直接放行";
private static String GROWSSEXCETION = "禁止通行，重量不在可控范围";
private static String NORECORD = "车辆未备案或者识别错误，车牌号：";
private static String NO_CHEPAI = "未识别到车牌号：";
private static String INPUTSTATION = "此车辆未做进站申请";
private static String ENTERSTATION = "此车辆未做出站申请";
private static String ISVALID = "二维码数据异常，请使用正确的二维码数据";
private static String ERRORWT = "出起始场站的重量和进目的场站的重量不一致";
private static String IEPORSE = "无相对应进出场申请";
private static String FANGXING= "有运单未放行";
private static String FENBO = "装载运单的分拨申请舱单未通过校验";
private static String NOGrossWt = "过磅重量异常";
private static String BLACKLIST= "此车辆已被拉进黑名单，不允许出区";
@Autowired
FeignService feignService;
@Autowired
NmmsService nmmsService;
/**
* 车辆信息备案表
*/
@Autowired
LandRoadVeService veService;
@Autowired
RedisService redisService;
@Autowired
BusnesslistinfoService busnesslistinfoService;
/**
* 进出场申请表
*/
@Autowired
LandBusListService listService;
/**
* 重量校验算法
*/
@Autowired
WeightCheckHandleService weightCheckHandleService;
/**
* 查询运单放行表
*/
@Autowired
ResMessageService resMessageService;
@Autowired
CommandLogService commandLogService;
/**
* 车辆过卡信息
*/
private GatherInfo info;
/**
* 车辆流转申请表头信息
*/
private LandBusinessTypeList landBusinessTypeList;
private List<LandBusinessTypeList> landBusinessTypeListList;
/**
* 车辆申请表体信息
*/
private List<LAND_BUSINEESTYPE_LIST_INFO> listinfos;
/**
* 过磅重量
*/
private double growssWt=0.0;
/**
* 车牌号
*/
private String vaName;
/**
* 车辆备案重量
*/
private double selfWt=0.0;
/**
* 初始化装载货物重量
*/
private double goodsWt=0.0;
/**
* 车辆入场时的重量
*/
private double inWt=0.0;
/**
* 计算后的车辆进出场差值
*/
private double diffVal=0.0;
@Override
public int save(GatherInfo info) {
return 0;
}
@Override
public void handel(GatherInfo gatherInfo) {
this.info = gatherInfo;
//获取过磅重量
growssWt = info.getGrosswt().doubleValue();
//取车牌号，判定卡口是否取到车牌号
vaName = info.getVename();
}
/**
* 一.
* 场站白名单
* @return 白名单 true. 其他走校验
*/
private boolean areaWhiteListCheck(){
if(FileTool.readProperties("stationsf").equals(info.getAreaid())) {
return true;
}
return false;
}
/**
* 1. 车牌信息校验
*/
private boolean veNameCheck(String veName){
//1. 若无车牌号，返回未识别错误
if (StringUtils.isEmpty(vaName)) {
logger.error(NO_CHEPAI+vaName);
sendBw(info,false,NO_CHEPAI + vaName,new LandBusinessTypeList(),listinfos);
//CommandClient.Client(info, NO_CHEPAI + vaName);
return false;
}
return true;
}
/**
* 2. 车辆备案信息校验
*/
private boolean veRecordCheck(){
//2. 校验车辆是否备案
LandRoadVe ve = veService.selectByFrameNo(vaName);
//若无备案信息或者黑名单，返回车辆未备案或者识别错误,
if (ve == null && !veBlackListCheck(ve)) {
logger.error(NORECORD+vaName);
sendBw(info,false,NORECORD + vaName,new LandBusinessTypeList(),listinfos);
//CommandClient.Client(info, NORECORD + vaName);
return false;
}
//车辆备案重量
selfWt=Double.parseDouble(ve.getSelfWt());
return true;
}
/**
* 3. 车辆黑名单校验
*/
private boolean veBlackListCheck(LandRoadVe ve){
if("Y".equals(ve.getVeState())){
sendBw(info,false,BLACKLIST + vaName,new LandBusinessTypeList(),listinfos);
return false;
}
return true;
}
/**
* 4. 车辆进出场流转申请单信息校验
* 二维码不用校验了,二维码失效会删除redis缓存
* @return
*/
private boolean LandBusinessFormCheck(){
try {
//通过车牌号，二维码，场站，通道号，进出类型查询进出场站申请列表
String landBusinessJson = redisService.get(info.getVename());
List<LandBusinessTypeList> list = new ArrayList<>();
if (StringUtils.isNotEmpty(landBusinessJson)){
list = (List<LandBusinessTypeList>) JSON.parseObject(landBusinessJson,List.class);
landBusinessTypeListList = list;
//4. 若查询结果为null，返回无相对应进出场申请
if (list == null || list.isEmpty()) {
logger.error(vaName+IEPORSE);
sendBw(info,false,vaName+IEPORSE,null,listinfos);
return false;
}
list.stream()
.filter( item->{
if (item.getAisle().equals(info.getChnlno()) && item.getBarcode().equals(info.getBarcode())){
landBusinessTypeList = item;
//离场装载货物重量
goodsWt = Double.parseDouble(landBusinessTypeList.getRemark());
return true;
}else {
return false;
}
});
}else {
logger.error("未找到车辆-{}的申请缓存信息",info.getVename());
logger.info("未找到车辆-{}的申请缓存信息,或者流转已超期失效",info.getVename());
}
}catch (Exception e){
return false;
}
return true;
}
/**
* 流转申请-货物类型白名单,白名单的货物类型目前直接放行
* @return
*/
private boolean goodsWhiteListCheck(){
if(!"普通货物".equals(landBusinessTypeList.getCocode())
&& !"转关货物".equals(landBusinessTypeList.getCocode())
&& !"退库货物".equals(landBusinessTypeList.getCocode()) ) {
//todo:比如货物类型为快件货物,只走重量校验,不走放行信息等校验.
//todo:退库货物可以关联货运系统,得到退库信息进行比对
//todo:查验货物走查验信息比对
//todo:快件暂不校验直接放行,不过得录单
//todo:换单货物校验逻辑待定
//todo:未来取消货物类型判定.
logger.info("车辆装载货物为:" + landBusinessTypeList.getCocode());
return true;
}
return false;
}
/**
* 5. 车辆过磅重量校验
* @return true 通过 false 不通过
*/
private boolean weightCheck(GatherInfo info){
if(info.getGrosswt().compareTo(BigDecimal.ZERO) > 0){
logger.info("过磅重量校验通过，过磅重量大于0");
}else{
sendBw(info,false,NOGrossWt + growssWt,new LandBusinessTypeList(),listinfos);
return false;
}
return true;
}
/**
* 离场时需要获取的车辆进场信息,入场重量,进出场差值
*/
private void inStationInfo(){
List<LandBusinessTypeList> stationInChanleInfo= listService.selectwt(info.getVename(),info.getBarcode(),info.getAreaid(),"I");
if (stationInChanleInfo.isEmpty()){
logger.info("未查询到车辆:{}的入场信息",info.getVename());
}else {
for(LandBusinessTypeList typeList:stationInChanleInfo){
if(typeList.getAislewt()!=null){
//对应场站进场过磅重量
inWt=typeList.getAislewt();
}
diffVal = inWt- growssWt;
}
//TODO:进场校验 增加 车辆备案重量要 <= 进场过磅重量 ,要有误差判定
}
}
/**
* 此通道对应的流转申请货物重量.
*/
private void setGoodsWt(LandBusinessTypeList list){
}
/**
* todo:通道及金二路由判定,是金二通道的话,等金二X22
* 目前宽进严出策略,本地判定
*
*/
private boolean chanelInCheck(){
if ("I".equals(info.getIetype())){
return true;
}else {
return false;
}
}
/**
* 设置表体全局变量
*/
private void setListinfos(){
//查询运单列表
listinfos=busnesslistinfoService.selectmanilist(info.getBarcode());
}
/**
* 出区抬杆放行判定
* @return
*/
private boolean checkRelease(){
logger.info("[进出场申请]-业务类型为:"+landBusinessTypeList.getCocode()+landBusinessTypeList.getBusinesstype());
switch (landBusinessTypeList.getBusinesstype()){
case "空车业务":
if(weightCheckHandleService.checkEmpty(growssWt,selfWt)){
return true;
}else{
logger.error("[空车业务]-出场重量未通过校验:"+GROWSSEXCETION);
sendBw(info,false,GROWSSEXCETION,landBusinessTypeList,listinfos);
return false;
}
case "出口转关":
case "出口送货":
if (weightCheckHandleService.checkExportDownLoading(growssWt, selfWt, goodsWt,inWt)){
return true;
}else{
logger.error("[出口送货]-出场重量未通过校验:"+GROWSSEXCETION);
sendBw(info,false,GROWSSEXCETION,landBusinessTypeList,listinfos);
return false;
}
case "进口转关":
case "进口提货":
if (weightCheckHandleService.checkImportDlv(growssWt, selfWt, goodsWt,inWt)){
if ("退库货物".equals(landBusinessTypeList.getCocode())){
/**
* 退库货物不校验运单放行.
*/
logger.info("[退库业务]-重量核验通过.");
}else{
//检查运单放行
if (resMessageService.checkManifestRelease(info,listinfos)){
return true;
}else {
//有运单未放行
logger.error("[进口提货]-出场未通过校验:"+FANGXING+landBusinessTypeList.getMasterList());
sendBw(info,false,FANGXING+landBusinessTypeList.getMasterList(),landBusinessTypeList,listinfos);
return false;
}
}
//todo:装载运单历史数据累加超重判定
}else{
logger.error("[进口提货]-出场重量未通过校验:"+GROWSSEXCETION);
sendBw(info,false,GROWSSEXCETION,landBusinessTypeList,listinfos);
return false;
}
break;
case "分拨业务":
if (weightCheckHandleService.checkAllocateOrDispatch(growssWt, selfWt, goodsWt,inWt)){
//todo:检查分拨申请
boolean allocatCheck = checkNmmsAllocate(landBusinessTypeList.getMasterList());
if(!allocatCheck){
logger.error("[分拨业务]-分拨申请舱单未通过校验:"+FENBO);
sendBw(info,false,FENBO,landBusinessTypeList,listinfos);
return false;
}
return true;
//todo:分拨运抵通知,重车入场视为运抵
}else{
logger.error("[分拨业务]-出场重量未通过校验:"+GROWSSEXCETION);
sendBw(info,false,GROWSSEXCETION,landBusinessTypeList,listinfos);
return false;
}
case "调拨业务":
if (weightCheckHandleService.checkAllocateOrDispatch(growssWt, selfWt, goodsWt,inWt)){
//检查运单放行
if (resMessageService.checkManifestRelease(info,listinfos)){
return true;
}else {
//有运单未放行
logger.error("[调拨业务]-出场未通过校验:"+FANGXING+landBusinessTypeList.getMasterList());
sendBw(info,false,FANGXING,landBusinessTypeList,listinfos);
return false;
}
//todo:检查ULD放行.
}else{
logger.error("[调拨业务]-出场未通过校验:"+GROWSSEXCETION);
sendBw(info,false,GROWSSEXCETION,landBusinessTypeList,listinfos);
return false;
}
default:
logger.error("[未知业务类型]-出场未通过校验");
break;
}
return false;
}
/**
* 记录进出区信息
*/
private void record(){
if ("I".equals(info.getIetype())){
landBusinessTypeList.setAislewt(info.getGrosswt().doubleValue());
landBusinessTypeList.setUpdateDate(new Date());
landBusinessTypeList.setRemark(String.format("%.1f", goodsWt));
//车辆备案重量
landBusinessTypeList.setRemark2(String.valueOf(selfWt));
landBusinessTypeList.setContrastflag("已进站");
}else {
landBusinessTypeList.setAislewt(info.getGrosswt().doubleValue());
landBusinessTypeList.setUpdateDate(new Date());
//装载货物总重量
landBusinessTypeList.setRemark(String.format("%.1f", goodsWt));
//进出差值
landBusinessTypeList.setRemark1(String.format("%.1f", diffVal));
landBusinessTypeList.setRemark2(String.valueOf(selfWt));
landBusinessTypeList.setContrastflag("已出站");
}
//todo:判定放行后,插入数据库,出入区记录
landBusinessTypeList.setId(UUID.randomUUID().toString());
landBusinessTypeList.setIsvalid("1");
//todo:这里SEQN也要入库
listService.saveList(landBusinessTypeList);
}
/**
* 流转申请是否核销判定
*/
private void releaseFormCheck(){
//二维码已出区的记录
List<LandBusinessTypeList> havenCrossList = listService.selectByBarcodeWithE(info.getBarcode());
//申请核销判定
for (LandBusinessTypeList businessTypeList : havenCrossList) {
List<LandBusinessTypeList> r = landBusinessTypeListList.stream().filter(item ->{
if(item.getEndstation().equals(businessTypeList.getEndstation())) {
landBusinessTypeListList.remove(item);
return true;
}else {
return false;
}
})
.collect(Collectors.toList());
}
if (landBusinessTypeListList.isEmpty()){
//todo:流转申请状态核销
//二维码核销
releaseBarCode();
}
}
/**
* 二维码失效核销->判定及失效通知.
*/
private void releaseBarCode(){
//二维码判定
int count=listService.selectlaststation(info.getVename(),info.getBarcode());
//二维码失效通知,已进入场站的与缓存比较.
if(count==0){
//todo:测试注释掉,二维码释放
logger.info("[进出场申请]-二维码释放:"+vaName);
buildBarCode.cancleBarCode(vaName);
}
}
/**
* todo:车单关系绑定报文
*/
/**
* 发送X22指令
* @param info
* @param check
* @param reason
* @param land
* @param list_infos
* @return
*/
public boolean sendBw(GatherInfo info, boolean check, String reason, LandBusinessTypeList land, List<LAND_BUSINEESTYPE_LIST_INFO> list_infos) {
logger.info(String.format("开始发送指令：车牌%s，场站%s，通道%s，重量%s",info.getVename(),info.getAreaid(),info.getChnlno(),info.getGrosswt()));
boolean flag = false;
if (check) {
CommandClient.Client(info, PERMITTHOUGH);
logger.info("=============>>>>>>>>放行报文发送成功<<<<<<<<<==============");
flag = true;
} else {
CommandClient.Client(info, reason);
logger.info("=============>>>>>>>>重量异常报文发送成功<<<<<<<<<==============");
}
commandlog(info,check,reason,land,list_infos);
return flag;
}
/**
* 放行日志记录
* @param info
* @param check
* @param reason
* @param land
* @param list_infos
*/
public void commandlog(GatherInfo info,boolean check,String reason,LandBusinessTypeList land,List<LAND_BUSINEESTYPE_LIST_INFO> list_infos){
String flag="",type="";
commandLog command=new commandLog();
command.setId(UUID.randomUUID().toString());
command.setBarcode(info.getBarcode());
if(land!=null){
command.setBarcode(land.getBarcode());
command.setBusnessType(land.getBusinesstype());
}
command.setAreaId(info.getAreaid());
command.setChnlNo(info.getChnlno());
if (check){
flag = "00";
} else{
flag = "11";
}
if("I".equals(info.getIetype())){
type="000000200000000000";
}else{
type="000000100000000000";
}
command.setReasonCode(flag+type);
command.setReasonText(reason);
command.setVeName(info.getVename());
command.setVeWeight(selfWt);
command.setIeType(info.getIetype());
command.setExitGrossWeight(info.getGrosswt().doubleValue());
command.setInGrossWeight(inWt);
command.setGoodsWeight(goodsWt);
command.setActualGoodsWeight(diffVal);
if(list_infos.size()>0){
command.setMasterList(Arrays.toString(toStrArry(list_infos)));
}
commandLogService.insert(command);
}
/**
* 新舱单分拨申请数据查询
* @param waybill 查询的运单号
* @return
*/
private Map nmmsAllocate(@NotNull String waybill){
logger.info("新舱单查询分拨申请数据开始");
Feign_Allocate_Search feignAllocateSearch = new Feign_Allocate_Search(waybill,0,10);
Map map = nmmsService.getAllocate(feignAllocateSearch);
logger.info(""+map);
return map;
}
/**
* 分拨申请查询
* @param waybill
* @return
*/
private boolean checkNmmsAllocate(String waybill){
if (waybill.length() < 1) {
return false;
}
waybill = waybill.replace("-", "");
//中文逗号替换
waybill = waybill.replace("，", ",");
String[] maifest = waybill.split(",");
logger.info("运单列表:" + waybill);
boolean flag = false;
for (String awb : maifest) {
Map map= nmmsAllocate(awb);
if (map.containsKey("reslut")){
String result = map.get("reslut").toString();
JSONObject jsonObject = JSON.parseObject(result);
if (jsonObject.containsKey("ds")) {
JSONArray ds = jsonObject.getJSONArray("ds");
JSONObject awbinfo = ds.getJSONObject(0);
if (awbinfo.containsKey("RECEIPTINFORMATION")){
if (awbinfo.getString("RECEIPTINFORMATION").contains("39301") || awbinfo.getString("RECEIPTINFORMATION").contains("39103")){
logger.info("运单:{},分拨回执查询结果:{}",awb,awbinfo.getString("RECEIPTINFORMATION"));
}else {
logger.info("运单{}分拨申请回执不正常:{}",awb,awbinfo.getString("RECEIPTINFORMATION"));
return false;
}
}
}else {
logger.info("运单:{}分拨申请回执未查询到,或未进行分拨申请",awb);
return false;
}
}else{
logger.info("运单:{}分拨申请回执未查询到,或未进行分拨申请",awb);
return false;
}
}
return true;
}
}
... ...
... ... @@ -22,4 +22,10 @@ public class GatherInfoServiceImpl implements GatherInfoService {
}
return row;
}
@Override
public void handel(GatherInfo info){
}
}
... ...
... ... @@ -66,6 +66,17 @@ public class LandBusListServiceImpl implements LandBusListService {
}
@Override
public List<LandBusinessTypeList> selectByBarcodeWithE(String barcode){
List<LandBusinessTypeList> list= null;
try{
list = listMapper.selectByBarcodeWithE(barcode);
}catch (Exception e){
System.out.println(e.getMessage());
}
return list;
}
@Override
public int updateByBarcode(String barcode) {
return listMapper.updateByBarCode(barcode);
}
... ...
package com.sy.service.impl;
import com.sy.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.TimeUnit;
@Service
public class RedisServiceImpl implements RedisService {
@Autowired
private StringRedisTemplate redisTemplate;
/**
* 指定缓存失效时间
* @param key 键
* @param time 时间(秒)
* @return
*/
@Override
public boolean expire(String key, long time){
try {
if(time>0){
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据key 获取过期时间
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效
*/
public long getExpire(String key){
return redisTemplate.getExpire(key,TimeUnit.SECONDS);
}
/**
* 判断key是否存在
* @param key 键
* @return true 存在 false不存在
*/
@Override
public boolean hasKey(String key){
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除缓存
* @param key 可以传一个值 或多个
*/
@Override
@SuppressWarnings("unchecked")
public void del(String ... key){
if(key!=null&&key.length>0){
if(key.length==1){
redisTemplate.delete(key[0]);
}else{
redisTemplate.delete(CollectionUtils.arrayToList(key));
}
}
}
/**
* 【 递归删除redis key-value 】
* 效率会低点 但是删除方法安全
* @author yangjunxiong
* @date 2021/6/21 10:05
**/
@Override
public Set<String> deleteBatchByKeys(String key) {
Set<String> keys = new HashSet<>();
redisTemplate.execute((RedisCallback<Set<String>>) connection -> {
try (Cursor<byte[]> cursor = connection.scan(new ScanOptions.ScanOptionsBuilder()
.match(key + "*")
.count(5000).build())) {
while (cursor.hasNext()) {
keys.add(new String(cursor.next(), StandardCharsets.UTF_8));
}
} catch (Exception e) {
throw new RuntimeException(e);
}
return keys;
});
if (CollectionUtils.isEmpty(keys)) {
return Collections.emptySet();
}
for (String key1 : keys) {
redisTemplate.delete(key1);
}
if (!CollectionUtils.isEmpty(keys)) {
return deleteBatchByKeys(key);
}
return keys;
}
//============================String=============================
/**
* 普通缓存获取
* @param key 键
* @return 值
*/
@Override
public String get(String key){
return key==null?null:redisTemplate.opsForValue().get(key);
}
/**
* 普通缓存放入
* @param key 键
* @param value 值
* @return true成功 false失败
*/
@Override
public boolean set(String key, String value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 普通缓存放入并设置时间
* @param key 键
* @param value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
* @return true成功 false 失败
*/
@Override
public boolean set(String key, String value, long time){
try {
if(time>0){
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
}else{
set(key, value);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 递增
* @param key 键
* @param delta 要增加几(大于0)
* @return
*/
public long incr(String key, long delta){
if(delta<0){
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
* @param key 键
* @param delta 要减少几(小于0)
* @return
*/
public long decr(String key, long delta){
if(delta<0){
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, -delta);
}
//================================Map=================================
/**
* HashGet
* @param key 键 不能为null
* @param item 项 不能为null
* @return 值
*/
public Object hget(String key,String item){
return redisTemplate.opsForHash().get(key, item);
}
/**
* 获取hashKey对应的所有键值
* @param key 键
* @return 对应的多个键值
*/
public Map<Object,Object> hmget(String key){
return redisTemplate.opsForHash().entries(key);
}
/**
* HashSet
* @param key 键
* @param map 对应多个键值
* @return true 成功 false 失败
*/
public boolean hmset(String key, Map<String,String> map){
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* HashSet 并设置时间
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
public boolean hmset(String key, Map<String,String> map, long time){
try {
redisTemplate.opsForHash().putAll(key, map);
if(time>0){
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
* @param key 键
* @param item 项
* @param value 值
* @return true 成功 false失败
*/
public boolean hset(String key,String item,String value) {
try {
redisTemplate.opsForHash().put(key, item, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
* @param key 键
* @param item 项
* @param value 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
public boolean hset(String key,String item,String value,long time) {
try {
redisTemplate.opsForHash().put(key, item, value);
if(time>0){
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除hash表中的值
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hdel(String key, String... item){
redisTemplate.opsForHash().delete(key,item);
}
/**
* 判断hash表中是否有该项的值
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String item){
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
* @return
*/
public double hincr(String key, String item,double by){
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
* @return
*/
public double hdecr(String key, String item,double by){
return redisTemplate.opsForHash().increment(key, item,-by);
}
//============================set=============================
/**
* 根据key获取Set中的所有值
* @param key 键
* @return
*/
public Set<String> sGet(String key){
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 根据value从一个set中查询,是否存在
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public boolean sHasKey(String key,String value){
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将数据放入set缓存
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSet(String key, String...values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 将set数据放入缓存
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSetAndTime(String key,long time,String...values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if(time>0) {
expire(key, time);
}
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 获取set缓存的长度
* @param key 键
* @return
*/
public long sGetSetSize(String key){
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 移除值为value的
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long setRemove(String key, String ...values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
//===============================list=================================
/**
* 获取list缓存的内容
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
* @return
*/
public List<String> lGet(String key, long start, long end){
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 获取list缓存的长度
* @param key 键
* @return
*/
public long lGetListSize(String key){
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 通过索引 获取list中的值
* @param key 键
* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
* @return
*/
public String lGetIndex(String key,long index){
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, String value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, String value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, List<String> value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, List<String> value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据索引修改list中的某条数据
* @param key 键
* @param index 索引
* @param value 值
* @return
*/
public boolean lUpdateIndex(String key, long index,String value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 移除N个值为value
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public long lRemove(String key,long count,String value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 模糊查询获取key值
* @param pattern
* @return
*/
public Set keys(String pattern){
return redisTemplate.keys(pattern);
}
/**
* 使用Redis的消息队列
* @param channel
* @param message 消息内容
*/
public void convertAndSend(String channel, String message){
redisTemplate.convertAndSend(channel,message);
}
//=========BoundListOperations 用法 start============
/**
*将数据添加到Redis的list中（从右边添加）
* @param listKey
* @param expireEnum 有效期的枚举类
* @param values 待添加的数据
*/
// public void addToListRight(String listKey, Status.ExpireEnum expireEnum, String... values) {
// //绑定操作
// BoundListOperations<String, String> boundValueOperations = redisTemplate.boundListOps(listKey);
// //插入数据
// boundValueOperations.rightPushAll(values);
// //设置过期时间
// boundValueOperations.expire(expireEnum.getTime(),expireEnum.getTimeUnit());
// }
/**
* 根据起始结束序号遍历Redis中的list
* @param listKey
* @param start 起始序号
* @param end 结束序号
* @return
*/
public List<String> rangeList(String listKey, long start, long end) {
//绑定操作
BoundListOperations<String, String> boundValueOperations = redisTemplate.boundListOps(listKey);
//查询数据
return boundValueOperations.range(start, end);
}
/**
* 弹出右边的值 --- 并且移除这个值
* @param listKey
*/
public String rifhtPop(String listKey){
//绑定操作
BoundListOperations<String, String> boundValueOperations = redisTemplate.boundListOps(listKey);
return boundValueOperations.rightPop();
}
}
... ...
... ... @@ -103,6 +103,13 @@
where BARCODE = #{barcode,jdbcType=VARCHAR} AND ISVALID = "0"
</select>
<select id="selectByBarcodeWithE" parameterType="java.lang.String" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from land_businesstype_list
where BARCODE = #{barcode,jdbcType=VARCHAR} AND ISVALID = "1" and and TURNOVERFLAG = "E"
</select>
<select id="selectMessageId" parameterType="java.lang.String" resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
... ...
... ... @@ -91,52 +91,7 @@ public class BeihuoTests {
"\t</GATHER_INFO>\n" +
"</MSG>";
public static String XML = "<MSG>\n" +
"\t<META>\n" +
"\t\t<SNDR>KAO</SNDR>\n" +
"\t\t<RCVR/>\n" +
"\t\t<SEQN>20220624063157</SEQN>\n" +
"\t\t<DDTM>20220624063157</DDTM>\n" +
"\t\t<TYPE>KAKO</TYPE>\n" +
"\t\t<STYP>CARM</STYP>\n" +
"\t</META>\n" +
"\t<GATHER_INFO AREA_ID=\"0000000000\" CHNL_NO=\"0000000000\" I_E_TYPE=\"I\" SEQ_NO=\"123\">\n" +
"\t\t<IC>\n" +
"\t\t\t<DR_IC_NO/>\n" +
"\t\t\t<IC_DR_CUSTOMS_NO/>\n" +
"\t\t\t<IC_CO_CUSTOMS_NO/>\n" +
"\t\t\t<IC_BILL_NO/>\n" +
"\t\t\t<IC_GROSS_WT/>\n" +
"\t\t\t<IC_VE_CUSTOMS_NO/>\n" +
"\t\t\t<IC_VE_NAME/>\n" +
"\t\t\t<IC_CONTA_ID/>\n" +
"\t\t\t<IC_ESEAL_ID/>\n" +
"\t\t\t<IC_EX_DATA/>\n" +
"\t\t</IC>\n" +
"\t\t<WEIGHT>\n" +
"\t\t\t<GROSS_WT>22000</GROSS_WT>\n" +
"\t\t</WEIGHT>\n" +
"\t\t<CAR>\n" +
"\t\t\t<VE_NAME/>\n" +
"\t\t\t<CAR_EC_NO/>\n" +
"\t\t\t<CAR_EC_NO2/>\n" +
"\t\t\t<VE_CUSTOMS_NO/>\n" +
"\t\t\t<VE_WT/>\n" +
"\t\t</CAR>\n" +
"\t\t<CONTA>\n" +
"\t\t\t<CONTA_NUM/>\n" +
"\t\t\t<CONTA_RECO/>\n" +
"\t\t\t<CONTA_MODEL_F/>\n" +
"\t\t\t<CONTA_MODEL_B/>\n" +
"\t\t\t<CONTA_ID_F/>\n" +
"\t\t\t<CONTA_ID_B/>\n" +
"\t\t</CONTA>\n" +
"\t\t<SEAL>\n" +
"\t\t\t<ESEAL_ID/>\n" +
"\t\t</SEAL>\n" +
"\t\t<BAR_CODE>1111</BAR_CODE>\n" +
"\t</GATHER_INFO>\n" +
"</MSG>";
/**
* 进场测试
*/
... ... @@ -145,18 +100,18 @@ public class BeihuoTests {
//车牌号
String voNo = "豫A61CR7";
//过卡重量
String cross_weight= "2000";
String cross_weight= "4800";
//场站编号
String areaID = "4604600000";
String areaID = "4604000000";
//通道编号
String chnlNo = "4604601011";
String chnlNo = "4604333311";
//进出场类型I/E
String ie = "I";
//二维码
String barcode = "5198ad";
String barcode = "fb2-4fdb-aa62-b6ee0d33c915";
logger.error("开始进场测试");
IMPORT_XML= XML.replace("${car}",voNo)
IMPORT_XML= IMPORT_XML.replace("${car}",voNo)
.replace("${cross_weight}",cross_weight)
.replace("${areaID}",areaID)
.replace("${chnlNo}",chnlNo)
... ... @@ -175,17 +130,17 @@ public class BeihuoTests {
public void exportDownload_E(){
//车牌号
String voNo = "豫A61CR7";
String voNo = "豫A61CR8";
//过卡重量
String cross_weight= String.valueOf(2000);
String cross_weight= String.valueOf(4200);
//场站编号
String areaID = "4604600000";
String areaID = "4600329012";
//通道编号
String chnlNo = "4604600011";
String chnlNo = "4600010006";
//进出场类型I/E
String ie = "E";
//二维码
String barcode = "5198ad";
String barcode = "f7f-461a-bb39-b61c0a4d5677";
logger.error("开始出口送货离场测试");
IMPORT_XML= IMPORT_XML.replace("${car}",voNo)
.replace("${cross_weight}",cross_weight)
... ...
package com.sy.service;
import com.alibaba.fastjson.JSON;
import com.sy.model.LandBusinessTypeList;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import static org.junit.jupiter.api.Assertions.*;
@RunWith(SpringRunner.class)
@SpringBootTest
class RedisServiceTest {
@Autowired
RedisService redisService;
@Test
void expire() {
}
@Test
void hasKey() {
}
@Test
void del() {
}
@Test
void deleteBatchByKeys() {
}
@Test
void get() {
}
@Test
void set() {
LandBusinessTypeList list = new LandBusinessTypeList();
list.setTrailerFrameNo("豫A61CR7");
list.setBarcode("123-3132");
list.setAislewt(2022.22);
list.setId("020201");
list.setStartsatation("西货站");
list.setEndstation("北货站");
redisService.set(list.getTrailerFrameNo(), JSON.toJSONString(list),60*30);
String userJson = redisService.get(list.getTrailerFrameNo());
System.out.println("userJson = " + userJson);
LandBusinessTypeList u = JSON.parseObject(userJson,LandBusinessTypeList.class);
}
@Test
void testSet() {
}
}
... ...
package com.sy.service.impl;
import com.sy.service.adapter.BayonetReleaseCheckHandle;
import org.junit.jupiter.api.Test;
class BayonetReleaseCheckTest {
@Test
void bayonetCrossCheck() {
BayonetReleaseCheckHandle bayonetReleaseCheck = new BayonetReleaseCheckHandle();
bayonetReleaseCheck.bayonetCrossCheck("进口提货","I");
bayonetReleaseCheck.bayonetCrossCheck("出口送货","I");
}
}
... ... @@ -17,7 +17,7 @@ class WeightCheckHandleServiceImplTest {
@Test
void checkExportDownLoading() {
weightCheckHandleService.checkExportDownLoading(21540,20200,19213.0,39360);
weightCheckHandleService.checkExportDownLoading(21540,10500,2200,14960);
}
@Test
... ... @@ -25,7 +25,9 @@ class WeightCheckHandleServiceImplTest {
weightCheckHandleService.checkImportDlv(33180,20300,12653.00,20280);
}
@Test
void checkAllocateOrDispatch() {
void checkAllocateOrDispatch(){
weightCheckHandleService.checkAllocateOrDispatch(12740,10500,2200+4630,14960);
}
}
... ...