hbyt/cloud-battery-manage
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

集成mongodb, 记录电池信息

Browse Source
This commit is contained in:
andy 2025-04-30 09:48:01 +08:00
parent 9800c2695f
commit 42323ded0d
28 changed files with 967 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
base-commons/common-core/src/main/java/com/evotech/hd/common/core/dao/resource/auth/AuthUserStationDao.java
View File

@ -1,7 +1,9 @@
package com.evotech.hd.common.core.dao.resource.auth;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.evotech.hd.common.core.constant.HDConstant;
import com.evotech.hd.common.core.entity.resource.auth.AuthUserStation;
import com.evotech.hd.common.core.permission.DataScope;
/**
* @desc: 用户和充电站的关联
@ -11,5 +13,7 @@ import com.evotech.hd.common.core.entity.resource.auth.AuthUserStation;
* @contact: 17330188597
* @remark: 开发人员联系方式 1042025947@qq.com/微信同步
*/
@DataScope(permissionObject = HDConstant.OPERATOR_ROLE_CODE, permissionScopeName = "station_code", permissionScopeRedisKey = HDConstant.PermissionConstant.PERMISSION_STATION_CODE)
public interface AuthUserStationDao extends BaseMapper<AuthUserStation> {
}

24
base-commons/common-core/src/main/java/com/evotech/hd/common/core/entity/resource/auth/AuthUser.java
View File

@ -93,28 +93,12 @@ public class AuthUser extends BaseEntity implements Serializable {
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
private Date lastLoginTime;
/*@Schema(description = "创建人", hidden = true)
@TableField(fill = FieldFill.INSERT)
private String creater;
@Schema(description = "创建时间", hidden = true)
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
@TableField(fill = FieldFill.INSERT)
private Date ctime;
@Schema(description = "更新人", hidden = true)
@TableField(fill = FieldFill.UPDATE)
private String updater;
@Schema(description = "更新时间", hidden = true)
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
@TableField(fill = FieldFill.UPDATE)
private Date uptime;*/
@Schema(description = "角色编码", hidden = true)
@TableField(exist = false)
private String rcodes;
@Schema(description = "站编码", hidden = true)
@TableField(exist = false)
private String stationCodes;
}

8
base-commons/common-core/src/main/java/com/evotech/hd/common/core/entity/resource/auth/AuthUserStation.java
View File

@ -1,17 +1,13 @@
package com.evotech.hd.common.core.entity.resource.auth;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.evotech.hd.common.core.entity.BaseEntity;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotBlank;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
import java.util.Date;
/**
* 账户和站的关系, 一般是运营端使用
@ -25,7 +21,7 @@ import java.util.Date;
@Setter
@TableName("yt_auth_user_station")
@Schema(name = "账号角色关系")
public class AuthUserStation implements Serializable {
public class AuthUserStation extends BaseEntity implements Serializable {
private static final long serialVersionUID = 1L;

25
base-commons/common-mongodb/pom.xml Normal file
View File

@ -0,0 +1,25 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.evotech.hd</groupId>
<artifactId>base-commons</artifactId>
<version>1.0.0-SNAPSHOT</version>
</parent>
<artifactId>common-mongodb</artifactId>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<scope>provided</scope>
</dependency>
</dependencies>
</project>

90
base-commons/common-mongodb/src/main/java/com/evotech/hd/common/config/AbstractMongoDbConfig.java Normal file
View File

@ -0,0 +1,90 @@
package com.evotech.hd.common.config;
import com.mongodb.ConnectionString;
import lombok.Data;
import org.springframework.data.mongodb.MongoDatabaseFactory;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.SimpleMongoClientDatabaseFactory;
import org.springframework.util.StringUtils;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
/**
* mongoDB类
*
* @ClassName:AbstractMongoDbConfig
* @date: 2025年04月29日 14:41
* @author: andy.shi
* @contact: 17330188597
* @remark: 开发人员联系方式 1042025947@qq.com/微信同步
*/
@Data
public abstract class AbstractMongoDbConfig{
// MongoDB Properties
private String uri, userName, password, host, dataBase, authenticationDataBase;
private Integer port;
public MongoDatabaseFactory mongoDbFactory(){
//String connectionString = "mongodb://" + userName + ":" + password+ "@"+ host+":"+port+"/" + dataBase+"?authSource="+authenticationDataBase;
return new SimpleMongoClientDatabaseFactory(getConnectionString());
}
private ConnectionString getConnectionString(){
if (StringUtils.hasText(uri)) {
return new ConnectionString(uri);
}
StringBuilder builder = new StringBuilder("mongodb://");
if (StringUtils.hasText(userName)) {
builder.append(encode(userName));
builder.append(":");
if (StringUtils.hasText(password)) {
builder.append(encode(password));
}
builder.append("@");
}
builder.append((StringUtils.hasText(host)) ? host : "localhost");
if (port != null) {
builder.append(":");
builder.append(port);
}
//集群多地址配置, 具体参考 propertiesMongoConnectionDetails
// if (this.properties.getAdditionalHosts() != null) {
// builder.append(",");
// builder.append(String.join(",", this.properties.getAdditionalHosts()));
// }
builder.append("/");
builder.append(dataBase);
List<String> options = getOptions();
if (!options.isEmpty()) {
builder.append("?");
builder.append(String.join("&", options));
}
return new ConnectionString(builder.toString());
}
private String encode(String input) {
return URLEncoder.encode(input, StandardCharsets.UTF_8);
}
private List<String> getOptions() {
List<String> options = new ArrayList<>();
//集群,名称. 具体参考 propertiesMongoConnectionDetails
// if (this.properties.getReplicaSetName() != null) {
// options.add("replicaSet=" + this.properties.getReplicaSetName());
// }
if (StringUtils.hasText(userName) && StringUtils.hasText(authenticationDataBase)) {
options.add("authSource=" + authenticationDataBase);
}
return options;
}
abstract public MongoTemplate getMongoTemplate() throws Exception;
}

30
base-commons/common-mongodb/src/main/java/com/evotech/hd/common/config/BatteryBoxProperties.java Normal file
View File

@ -0,0 +1,30 @@
package com.evotech.hd.common.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.core.MongoTemplate;
/**
* 类
*
* @ClassName:BatteryInfoProperties
* @date: 2025年04月29日 16:32
* @author: andy.shi
* @contact: 17330188597
* @remark: 开发人员联系方式 1042025947@qq.com/微信同步
*/
@Configuration
@ConfigurationProperties(prefix = "yt.battery-box", ignoreUnknownFields = true)
public class BatteryBoxProperties extends AbstractMongoDbConfig {
@Bean("mongoTemplateBatteryBox")
@Override
public MongoTemplate getMongoTemplate() throws Exception {
return new MongoTemplate(mongoDbFactory());
}
}

29
base-commons/common-mongodb/src/main/java/com/evotech/hd/common/config/BatteryInfoProperties.java Normal file
View File

@ -0,0 +1,29 @@
package com.evotech.hd.common.config;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.mongodb.core.MongoTemplate;
/**
* 类
*
* @ClassName:BatteryInfoProperties
* @date: 2025年04月29日 16:32
* @author: andy.shi
* @contact: 17330188597
* @remark: 开发人员联系方式 1042025947@qq.com/微信同步
*/
@Configuration
@ConfigurationProperties(prefix = "yt.battery-info", ignoreUnknownFields = true)
public class BatteryInfoProperties extends AbstractMongoDbConfig {
@Primary
@Bean("mongoTemplateBatteryInfo")
@Override
public MongoTemplate getMongoTemplate() throws Exception {
return new MongoTemplate(mongoDbFactory());
}
}

49
base-commons/common-mongodb/src/main/java/com/evotech/hd/common/constant/MongoConstant.java Normal file
View File

@ -0,0 +1,49 @@
package com.evotech.hd.common.constant;
/**
* MongoDB的静态类
* @ClassName:MongoConstant
* @date: 2025年04月29日 9:21
* @author: andy.shi
* @contact: 17330188597
* @remark: 开发人员联系方式 1042025947@qq.com/微信同步
*/
public class MongoConstant {
//电池实时信息数据库
public static final String BATTERY_DATA_BASE="battery_info";
//电池箱实时信息数据库
public static final String BATTERY_BOX_DATA_BASE="battery_box";
public static final String SEPARATION = "_";
/***
* 或者查询, 示例
* put(OR+"条件名称"+SEPARATION+"条件名称"...,"条件值"+SEPARATION+"条件值"....)
*/
public static final String OR = "or"+SEPARATION;
/***
* 条件查询, 示例
* put(查询类型+"条件名称","条件值")
*/
public static final String AND = "and";
public static final String IN = "in";
public static final String NOT_IN = "not_in";
public static final String GT = "gt";
public static final String GE = "ge";
public static final String LT = "lt";
public static final String LE = "le";
public static final String REGEX = "regex";
/***
* 排序, 示例
* put(SORT+SORT_ASC,"条件名称")
*/
public static final String SORT = "Sort";
public static final String SORT_ASC ="asc";
public static final String SORT_DESC = "desc";
/***
* 排序, 示例
* put(PAGE,"当前页"+SEPARATION+"每页显示的条数")
*/
public static final String PAGE = "page";
}

74
base-commons/common-mongodb/src/main/java/com/evotech/hd/common/documnet/BatData.java Normal file
View File

@ -0,0 +1,74 @@
package com.evotech.hd.common.documnet;
import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
/**
* 电池实时信息
* @ClassName:BatData
* @date: 2025年04月30日 9:13
* @author: andy.shi
* @contact: 17330188597
* @remark: 开发人员联系方式 1042025947@qq.com/微信同步
*/
@Data
@Document
public class BatData {
/***
* 时间戳做id
*/
@Id
String id;
String stationCode;
String batCode;
String cabinetNo;
String value;
/***
* value 内容参考
* 仓位序号 cabinetNo int 仓位序号
* 单体电压总个数 batCellVoltCnt int32
* 单体电压 batCellVoltList list<float> 单位-V (每个型号的电池单体单体个数不定)
* 单体电压采样时间 voltSampleTime string 格式:yyyy-MM-dd HH:mm:ss (需要架载机支持)
* 探针温度总个数 probeTempCnt int32
* 探针温度 probeTempList list<int32> 单位-°C (个数不定)
* 探针温度采样时 间 tempSampleTime string 格式:yyyy-MM-dd HH:mm:ss (需要架载机支持)
* 电池包 SOH soh float %
* 电池包总电流，充电为负值，放电为正值 batTotalCurr float 单位-A
* 电池包允许最大 回充电电流值 (脉冲) batAvailMaxChgCu rr float 单位-A
* 电池包允许最大 放电电流值(脉 冲) batAvailMaxDisch gCurr float 单位-A
* 电池包正极绝缘 值 batPosiInsu float 单位-kohm
* 电池包负极绝缘 值 batNegaInsu float 单位-kohm
* 电池端高压(主 继电器内侧) batHighVoltInner float 单位-V
* 母线端高压(主 继电器外侧) batHighVoltOuter float 单位-V
* TMS 工作状态 tmsState int 0 关机;
* 1 制冷;
* 2 制热;
* 3 自循环;
* TMS 高压继电器 状态 tmsRelayState int 0 断开;1 闭合;2~3 无效;
* 出水温度(机组 到电池) outletWaterTemp int 单位-°C
* 回水温度(电池 到机组) inletWaterTemp int 单位-°C
* TMS 需求功率 tmsDemandPower float 单位-kW
* TMS 故障码 tmsFaultCode int 0 无故障;
* 出现 1 种以上循环发送
* TMS 故障码等级 tmsFaultLevel int 1 1 级故障; 2 2 级故障; 3 3 级故障; 0 无效;
* 电池ID batCode string 唯一识别码
*/
public BatData() {
}
public BatData(String id, String stationCode, String batCode, String cabinetNo, String value) {
this.id = id;
this.stationCode = stationCode;
this.batCode = batCode;
this.cabinetNo = cabinetNo;
this.value = value;
}
}

178
base-commons/common-mongodb/src/main/java/com/evotech/hd/common/documnet/ChargingData.java Normal file
View File

@ -0,0 +1,178 @@
package com.evotech.hd.common.documnet;
import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
/**
* 充电过程实时信息
* @ClassName:ChargingData
* @date: 2025年04月29日 15:13
* @author: andy.shi
* @contact: 17330188597
* @remark: 开发人员联系方式 1042025947@qq.com/微信同步
*/
@Data
@Document
public class ChargingData {
/***
* 时间戳做id
*/
@Id
String id;
String stationCode;
String batCode;
String chgSn;
String value;
/***
* value 内容参考
* 充电机编号 chgID string 充电机编号，采用 16 位数字编码
* 枪编号 gunNo int 从 1 开始，比如:1-A 枪，2-B 枪 ... (充电切换旋钮为“连接器”状 态时，只发 A 枪)
* 充电开始时间 startTime string 格式-yyyy-MM-dd hh:mm:ss
* 充电机输出电压 chgOutputVolt float 单位-V，小数点后一位
* 充电机输出电流 chgOutputCurr float 单位-A，小数点后一位
* 充电电量 chgQty float 单位-kWh，小数点后一位
* 电池ID batCode string 电池唯一识别码
* SOC soc float 当前电池电量0-100%
* 电池箱所在仓位 cabinetNo int 仓位序号
* 最高单体电压 batMaxVolt float 单位-V
* 最高单体电压组 号 batMaxVoltNo int
* 最低单体电压 batMinVolt float 单位-V
* 最低单体电压组 号 batMinVoltNo int
* 最高单体温度 batMaxTemp int 单位-°C
* 最高单体温度组 号 batMaxTempNo int
* 最低单体温度 batMinTemp int 单位-°C
* 最低单体温度组 号 batMinTempNo int
* 电池电压需求 voltDemand float 单位-V，小数点后一位
* 电池电流需求 currDemand float 单位-A，小数点后一位
* 充电模式 chgMode int 1、恒压充电 2、恒流充电 3、恒功率充电
* 剩余充电时长 remainderChgTi me int 单位-min 从 BMS 获取
* 直流电表电量 dcMeterElect float 单位-kWh，小数点后一位
* 充电流水号 chgSn string
*/
// //充电机编号
// String chgID;
// /***
// * 枪编号
// */
// Integer gunNo;
// /***
// * 充电开始时间
// * 格式-yyyy-MM-dd hh:mm:ss
// */
// String startTime;
// /***
// * 充电机输出电压
// * 单位-V，小数点后一位
// */
// Float chgOutputVolt;
// /***
// * 充电机输出电流
// * 单位-A，小数点后一位
// */
// Float chgOutputCurr;
// /***
// * 充电电量
// * 单位-kWh，小数点后一位
// */
// String chgQty;
// /***
// * 电池ID
// * 电池唯一识别码
// */
// String batCode;
// /***
// * SOC
// * 当前电池电量0-100%
// */
// Float soc;
//
// /***
// * 电池箱所在仓位
// * 仓位序号
// */
// Integer cabinetNo;
// /***
// * 最高单体电压
// * 单位-V
// */
// Float batMaxVolt;
// /***
// * 最高单体电压组 号
// * 单位-V
// */
// Integer batMaxVoltNo;
// /***
// * 最低单体电压
// * 单位-V
// */
// Float batMinVolt;
// /***
// * 最低单体电压组
// */
// Integer batMinVoltNo;
// /***
// * 最高单体温度
// * 单位-°C
// */
// Integer batMaxTemp;
// /***
// * 最低单体温度
// * 单位-°C
// */
// Integer batMinTemp;
// /***
// * 最低单体温度组
// * 单位-°C
// */
// Integer batMinTempNo;
// /***
// * 电池电压需求
// * 单位-V，小数点后一位
// */
// Float voltDemand;
// /***
// * 电池电流需求
// * 单位-V，小数点后一位
// */
// Float currDemand;
//
// /***
// * 充电模式
// * 1、恒压充电 2、恒流充电 3、恒功率充电
// */
// Integer chgMode;
// /***
// * 剩余充电时长
// * 单位-min
// */
// Integer remainderChgTime;
// /***
// * 直流电表电量
// * 单位-kWh，小数点后一位
// */
// Float dcMeterElect;
// /***
// * 充电流水号
// * 电池唯一识别码
// */
// String chgSn;
public ChargingData() {
}
public ChargingData(String id,String stationCode, String batCode, String chgSn, String value) {
this.id = id;
this.stationCode = stationCode;
this.batCode = batCode;
this.chgSn = chgSn;
this.value = value;
}
}

25
base-commons/common-mongodb/src/main/java/com/evotech/hd/common/exception/MongoDBException.java Normal file
View File

@ -0,0 +1,25 @@
package com.evotech.hd.common.exception;
import lombok.extern.slf4j.Slf4j;
/**
* 类
*
* @ClassName:MongoDBException
* @date: 2025年04月30日 8:56
* @author: andy.shi
* @contact: 17330188597
* @remark: 开发人员联系方式 1042025947@qq.com/微信同步
*/
@Slf4j
public class MongoDBException extends Exception{
public MongoDBException() {
super();
}
public MongoDBException(String message) {
super(message);
log.error("mongodb 数据库存储异常============{}", message);
}
}

218
base-commons/common-mongodb/src/main/java/com/evotech/hd/common/service/MongoDBService.java Normal file
View File

@ -0,0 +1,218 @@
package com.evotech.hd.common.service;
import com.evotech.hd.common.constant.MongoConstant;
import com.evotech.hd.common.exception.MongoDBException;
import jakarta.annotation.PostConstruct;
import jakarta.annotation.Resource;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.util.*;
import java.util.regex.Pattern;
/**
* 类
*
* @ClassName:MongoDBService
* @date: 2025年04月29日 8:45
* @author: andy.shi
* @contact: 17330188597
* @remark: 开发人员联系方式 1042025947@qq.com/微信同步
*/
@Service
public class MongoDBService {
@Resource
private List<MongoTemplate> mongoTemplates;
private Map<String, MongoTemplate> mongoTemplateMap = new LinkedHashMap<>();
@PostConstruct
private void init(){
if(!CollectionUtils.isEmpty(mongoTemplates)){
for (MongoTemplate mongoTemplate: mongoTemplates){
System.out.println(mongoTemplate.getDb().getName());
mongoTemplateMap.put(mongoTemplate.getDb().getName(),mongoTemplate);
}
}
}
/***
* 单个对象保存
* @param collectionName 保存的集合名称
* @param document 保存的文档数据
* @return
* @param <T>
*/
public <T> T save(String database, String collectionName, T document) {
MongoTemplate mongoTemplate = null;
try {
mongoTemplate = getMongoTemplate(database, collectionName);
} catch (MongoDBException e) {
throw new RuntimeException(e);
}
if(!mongoTemplate.collectionExists(collectionName)){
mongoTemplate.createCollection(collectionName);
}
return mongoTemplate.save(document, collectionName);
}
private MongoTemplate getMongoTemplate(String database, String collectionName) throws MongoDBException {
Assert.hasText(database, "database name must not be null or empty");
Assert.hasText(collectionName, "Collection name must not be null or empty");
if(!StringUtils.hasText(database) || !StringUtils.hasText(database)){
throw new MongoDBException("请求参数为空");
}
return mongoTemplateMap.get(database);
}
/***
* 批量保存
* @param collectionName 保存的集合名称
* @param batchToSave 保存的文档数据集合
* @return
* @param <T>
*/
public <T> Collection<T> saveBatch(String database, String collectionName, Collection<? extends T> batchToSave){
MongoTemplate mongoTemplate = null;
try {
mongoTemplate = getMongoTemplate(database, collectionName);
} catch (MongoDBException e) {
throw new RuntimeException(e);
}
if(!mongoTemplate.collectionExists(collectionName)){
mongoTemplate.createCollection(collectionName);
}
return mongoTemplate.insert(batchToSave, collectionName);
}
public <T> List<T> find(String database, String collectionName, Class<T> entityClass, Map<String,Object> params) {
MongoTemplate mongoTemplate = null;
try {
mongoTemplate = getMongoTemplate(database, collectionName);
} catch (MongoDBException e) {
throw new RuntimeException(e);
}
return mongoTemplate.find(buildQuery(params), entityClass, collectionName);
}
public <T> Page<T> findPage(String database, String collectionName, Class<T> entityClass, Map<String,Object> params) {
MongoTemplate mongoTemplate = null;
try {
mongoTemplate = getMongoTemplate(database, collectionName);
} catch (MongoDBException e) {
throw new RuntimeException(e);
}
Query query = buildQuery(params);
//计算总数
long total = mongoTemplate.count(query, entityClass, collectionName);
List<T> list = mongoTemplate.find(query, entityClass, collectionName);
String pageInfo = String.valueOf(params.get(MongoConstant.PAGE));
String[] pages = pageInfo.split(MongoConstant.SEPARATION);
return new PageImpl(list, PageRequest.of(Integer.valueOf(pages[0]), Integer.valueOf(pages[1])), total);
}
// /***
// * 单个对象保存
// * @param collectionName 保存的集合名称
// * @param document 保存的文档数据
// * @return
// * @param <T>
// */
// public <T> T save(String collectionName, T document){
// Assert.hasText(collectionName, "Collection name must not be null or empty");
// if(!mongoTemplate.collectionExists(collectionName)){
// mongoTemplate.createCollection(collectionName);
// }
// return mongoTemplate.save(document, collectionName);
// }
//
// /***
// * 批量保存
// * @param collectionName 保存的集合名称
// * @param batchToSave 保存的文档数据集合
// * @return
// * @param <T>
// */
// public <T> Collection<T> saveBatch(String collectionName, Collection<? extends T> batchToSave){
// Assert.hasText(collectionName, "Collection name must not be null or empty");
// if(!mongoTemplate.collectionExists(collectionName)){
// mongoTemplate.createCollection(collectionName);
// }
// return mongoTemplate.insert(batchToSave, collectionName);
// }
//
// public <T> List<T> find(String collectionName, Class<T> entityClass, Map<String,Object> params) {
// return mongoTemplate.find(buildQuery(params), entityClass, collectionName);
// }
//
// public <T> Page<T> findPage(String collectionName, Class<T> entityClass, Map<String,Object> params) {
// Query query = buildQuery(params);
// //计算总数
// long total = mongoTemplate.count(query, entityClass, collectionName);
// List<T> list = mongoTemplate.find(query, entityClass, collectionName);
// String pageInfo = String.valueOf(params.get(MongoConstant.PAGE));
// String[] pages = pageInfo.split(MongoConstant.SEPARATION);
// return new PageImpl(list, PageRequest.of(Integer.valueOf(pages[0]), Integer.valueOf(pages[1])), total);
// }
private static Query buildQuery(Map<String, Object> params){
Query query = new Query();
if(!CollectionUtils.isEmpty(params)){
//解析参数中的key
Iterator<String> itKey = params.keySet().iterator();
while (itKey.hasNext()){
String key = itKey.next();
//解析查询类型
String[] keyAndQueryType = key.split(MongoConstant.SEPARATION);
//根据类型做查询
switch (keyAndQueryType[0]){
case MongoConstant.AND:
query.addCriteria(Criteria.where(keyAndQueryType[1]).is(params.get(key)));
break;
case MongoConstant.IN:
query.addCriteria(Criteria.where(keyAndQueryType[1]).in(params.get(key)));
break;
case MongoConstant.NOT_IN:
query.addCriteria(Criteria.where(keyAndQueryType[1]).nin(params.get(key)));
break;
case MongoConstant.GT:
query.addCriteria(Criteria.where(keyAndQueryType[1]).gt(params.get(key)));
break;
case MongoConstant.GE:
query.addCriteria(Criteria.where(keyAndQueryType[1]).gte(params.get(key)));
break;
case MongoConstant.LT:
query.addCriteria(Criteria.where(keyAndQueryType[1]).lt(params.get(key)));
break;
case MongoConstant.LE:
query.addCriteria(Criteria.where(keyAndQueryType[1]).lte(params.get(key)));
break;
case MongoConstant.REGEX:
Pattern pattern = Pattern.compile(String.valueOf(params.get(key)));
query.addCriteria(Criteria.where(keyAndQueryType[1]).regex(pattern));
break;
case MongoConstant.SORT:
query = query.with(Sort.by((MongoConstant.SORT_ASC.equals(keyAndQueryType[1]) ? Sort.Direction.ASC : Sort.Direction.DESC), (String) params.get(key)));
break;
default:
break;
}
}
}
return query;
}
}

1
base-commons/pom.xml
View File

@ -15,5 +15,6 @@
<module>common-mybatis</module>
<module>common-redis</module>
<module>common-permission</module>
<module>common-mongodb</module>
</modules>
</project>

5
cloud-manage-server/pom.xml
View File

@ -31,6 +31,11 @@
<artifactId>common-permission</artifactId>
<version>1.0.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>com.evotech.hd</groupId>
<artifactId>common-mongodb</artifactId>
<version>1.0.0-SNAPSHOT</version>
</dependency>
<!-- openfein -->
<dependency>
<groupId>org.springframework.cloud</groupId>

2
cloud-manage-server/src/main/java/com/evotech/hd/cloud/controller/BatteryStationController.java
View File

@ -104,7 +104,7 @@ public class BatteryStationController {
}
@Operation(summary = "查询")
@GetMapping("/resource/list")
@PostMapping("/resource/list")
public Result<List<BatteryStation>> resourceList(@RequestParam String pkIds) {
return batteryStationService.resourceList(pkIds);
}

19
cloud-manage-server/src/main/java/com/evotech/hd/cloud/controller/test/TestController.java
View File

@ -10,6 +10,7 @@ import com.evotech.hd.cloud.dao.BatteryStationDao;
import com.evotech.hd.cloud.dao.OrderSwapBatteryPreDao;
import com.evotech.hd.cloud.dao.VehicleWechatUserRelationDao;
import com.evotech.hd.cloud.device.dh.DHRequestUtil;
import com.evotech.hd.cloud.mqtt.message.processor.impl.MqttStateChargingDataRequestExchangeProcessor;
import com.evotech.hd.cloud.utils.components.SwapOrderBasicFeeComponent;
import com.evotech.hd.common.core.entity.Result;
import com.evotech.hd.common.core.entity.cloud.BatteryStation;
@ -41,6 +42,24 @@ public class TestController {
private OrderSwapBatteryPreDao orderSwapBatteryPreDao;
@Resource
private SwapOrderBasicFeeComponent orderBasicFeeComponent;
@Resource
MqttStateChargingDataRequestExchangeProcessor mqttStateChargingDataRequestExchangeProcessor;
// @Resource
// MongoDBService mongoDBService;
@PostMapping("/mongodb/save")
public Result mongodbSave() {
mqttStateChargingDataRequestExchangeProcessor.exchange(null,null,JSONUtil.parseObj("{batCode:123,orderNo:123321}"));
return new Result().success("搞定");
}
@PostMapping("/mongodb/list")
public Result mongoList() {
// mongoDBService.find("123", ChargingData.class, Collections.asMap(MongoConstant.REGEX+MongoConstant.SEPARATION+"value","\"batCode\":124"))
return new Result().success("");
}
@GetMapping("/station")
public Result list() {

3
cloud-manage-server/src/main/java/com/evotech/hd/cloud/mqtt/config/MqttConnectInit.java
View File

@ -12,14 +12,13 @@ import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Date;
import java.util.concurrent.ConcurrentHashMap;
@Component
//@Component
@Order(value = 20)
@Slf4j
public class MqttConnectInit implements ApplicationRunner {

6
cloud-manage-server/src/main/java/com/evotech/hd/cloud/mqtt/enums/StateFunctionTypesEnum.java
View File

@ -11,7 +11,11 @@ public enum StateFunctionTypesEnum {
FUN_ORDERSTATUS("orderStatus", "", "站端反馈订单状态"),
FUN_SWAPSTEP("swapStep", "", "站端反馈换电步骤"),
FUN_BATTERYSTATUS("batteryStatus", "", "站端反馈电池状态"),
FUN_TEST("test", "", "没用的占位");
FUN_TEST("test", "", "没用的占位"),
FUN_CHARGING_DATA("chargingData", "", "充电过程实时信息"),
FUN_BAT_DATA("batData", "", "电池实时信息"),
;
String function;
String reFunction;

55
cloud-manage-server/src/main/java/com/evotech/hd/cloud/mqtt/message/handle/RequestMessageService.java
View File

@ -1,26 +1,11 @@
package com.evotech.hd.cloud.mqtt.message.handle;
import java.util.*;
import java.util.stream.Stream;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.StrUtil;
import com.evotech.hd.cloud.mqtt.message.processor.MqttMessageRequestExchangeProcessor;
import com.evotech.hd.common.core.entity.cloud.request.BatterySwapResponse;
import com.evotech.hd.cloud.mqtt.message.dto.newer.req.battery.*;
import com.evotech.hd.cloud.mqtt.message.dto.newer.req.order.*;
import com.evotech.hd.cloud.service.WechatUserService;
import com.evotech.hd.common.core.entity.Result;
import com.evotech.hd.common.core.entity.wechat.WechatUser;
import com.evotech.hd.common.redis.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import cn.hutool.json.JSONConfig;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.evotech.hd.cloud.dao.BatteryStationDcDao;
@ -30,22 +15,38 @@ import com.evotech.hd.cloud.mqtt.enums.MqttMessageTypeEnum;
import com.evotech.hd.cloud.mqtt.enums.RequestFunctionTypesEnum;
import com.evotech.hd.cloud.mqtt.message.MessageTopic;
import com.evotech.hd.cloud.mqtt.message.MqttMessageHeader;
import com.evotech.hd.cloud.mqtt.message.dto.newer.req.battery.BatteryData;
import com.evotech.hd.cloud.mqtt.message.dto.newer.req.battery.BatteryInfoReq;
import com.evotech.hd.cloud.mqtt.message.dto.newer.req.battery.BatteryInfoResponse;
import com.evotech.hd.cloud.mqtt.message.dto.newer.req.carinfo.CarInfoReq;
import com.evotech.hd.cloud.mqtt.message.dto.newer.req.carinfo.CarInfoResponse;
import com.evotech.hd.cloud.mqtt.message.dto.newer.req.carinfo.VehicleData;
import com.evotech.hd.cloud.mqtt.message.dto.newer.req.order.*;
import com.evotech.hd.cloud.mqtt.message.processor.MqttRequestExchangeProcessor;
import com.evotech.hd.cloud.service.OrderSwapBatteryService;
import com.evotech.hd.cloud.service.WechatUserService;
import com.evotech.hd.cloud.utils.CommonUtil;
import com.evotech.hd.common.core.dao.cloud.OrderSwapBatteryDao;
import com.evotech.hd.common.core.entity.Result;
import com.evotech.hd.common.core.entity.cloud.BatteryStationDc;
import com.evotech.hd.common.core.entity.cloud.OrderSwapBattery;
import com.evotech.hd.common.core.entity.cloud.OrderSwapBatteryPre;
import com.evotech.hd.common.core.entity.cloud.VehicleWechatUserRelation;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import cn.hutool.json.JSONConfig;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.evotech.hd.common.core.entity.cloud.request.BatterySwapResponse;
import com.evotech.hd.common.core.entity.wechat.WechatUser;
import com.evotech.hd.common.redis.utils.RedisUtil;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.util.*;
import java.util.stream.Stream;
/**
* request消息 处理
@ -101,11 +102,11 @@ public class RequestMessageService {
handlStartSwap(topic,header,battery);
break;
default:
Map<String, MqttMessageRequestExchangeProcessor> mqttMessageRequestExchangeProcessorMap = applicationContext.getBeansOfType(MqttMessageRequestExchangeProcessor.class);
Map<String, MqttRequestExchangeProcessor> mqttMessageRequestExchangeProcessorMap = applicationContext.getBeansOfType(MqttRequestExchangeProcessor.class);
if(CollectionUtils.isEmpty(mqttMessageRequestExchangeProcessorMap)){
log.error("mqttRequestExchangeProcessorMap is empty, 没有找到当前的请求信息， 请求接口{}, 请求参数{}", JSONUtil.toJsonStr(header), JSONUtil.toJsonStr(dataBody));
}
for (MqttMessageRequestExchangeProcessor processor : mqttMessageRequestExchangeProcessorMap.values()) {
for (MqttRequestExchangeProcessor processor : mqttMessageRequestExchangeProcessorMap.values()) {
if(processor.accept(header.getFunction())){
processor.exchange(topic, header, dataBody);
}

43
cloud-manage-server/src/main/java/com/evotech/hd/cloud/mqtt/message/handle/StateMessageService.java
View File

@ -1,42 +1,36 @@
package com.evotech.hd.cloud.mqtt.message.handle;
import java.util.Date;
import java.util.Objects;
import cn.hutool.core.date.DatePattern;
import cn.hutool.json.JSONConfig;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.evotech.hd.cloud.service.OrderSwapBatteryService;
import com.evotech.hd.common.core.entity.Result;
import org.springframework.beans.BeanUtils;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.evotech.hd.cloud.dao.BatteryStationDcDao;
import com.evotech.hd.cloud.dao.OrderSwapBatteryPreDao;
import com.evotech.hd.cloud.dao.OrderSwapBatteryStepDao;
import com.evotech.hd.cloud.dao.VehicleInfoDao;
import com.evotech.hd.cloud.mqtt.enums.StateFunctionTypesEnum;
import com.evotech.hd.cloud.mqtt.message.MessageTopic;
import com.evotech.hd.cloud.mqtt.message.MqttMessageHeader;
import com.evotech.hd.cloud.mqtt.message.dto.newer.state.OrderStatus;
import com.evotech.hd.cloud.mqtt.message.dto.newer.state.OrderStatusData;
import com.evotech.hd.cloud.mqtt.message.dto.newer.state.SwapStep;
import com.evotech.hd.cloud.mqtt.message.processor.MqttRequestExchangeProcessor;
import com.evotech.hd.cloud.service.BatteryStationDcService;
import com.evotech.hd.cloud.utils.components.HDStepDictComponent;
import com.evotech.hd.common.core.dao.cloud.OrderSwapBatteryDao;
import com.evotech.hd.common.core.entity.cloud.BatteryStationDc;
import com.evotech.hd.common.core.entity.cloud.BatteryTrace;
import com.evotech.hd.common.core.entity.cloud.OrderSwapBattery;
import com.evotech.hd.common.core.entity.cloud.OrderSwapBatteryPre;
import com.evotech.hd.common.core.entity.cloud.OrderSwapBatteryStep;
import com.evotech.hd.common.core.entity.cloud.VehicleInfo;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.Date;
import java.util.Map;
import java.util.Objects;
/**
* state消息 处理
@ -55,6 +49,8 @@ public class StateMessageService {
private BatteryStationDcService batteryStationDcService;
@Resource
private HDStepDictComponent hdStepDictComponent;
@Autowired
private ApplicationContext applicationContext;
@Async("taskExecutor")
@ -82,6 +78,15 @@ public class StateMessageService {
case FUN_TEST:
break;
default:
Map<String, MqttRequestExchangeProcessor> mqttRequestExchangeProcessorMap = applicationContext.getBeansOfType(MqttRequestExchangeProcessor.class);
if(CollectionUtils.isEmpty(mqttRequestExchangeProcessorMap)){
log.error("mqttRequestExchangeProcessorMap is empty, 没有找到当前的请求信息， 请求接口{}, 请求参数{}", JSONUtil.toJsonStr(header), JSONUtil.toJsonStr(dataBody));
}
for (MqttRequestExchangeProcessor processor : mqttRequestExchangeProcessorMap.values()) {
if(processor.accept(header.getFunction())){
processor.exchange(topic, header, dataBody);
}
}
break;
}

4
cloud-manage-server/src/main/java/com/evotech/hd/cloud/mqtt/message/processor/MqttMessageRequestExchangeProcessor.java → cloud-manage-server/src/main/java/com/evotech/hd/cloud/mqtt/message/processor/MqttRequestExchangeProcessor.java
View File

@ -27,9 +27,9 @@ import java.util.Date;
* @remark: 开发人员联系方式 1042025947@qq.com/微信同步
*/
public interface MqttMessageRequestExchangeProcessor {
public interface MqttRequestExchangeProcessor {
Logger logger = LoggerFactory.getLogger(MqttMessageRequestExchangeProcessor.class);
Logger logger = LoggerFactory.getLogger(MqttRequestExchangeProcessor.class);
boolean accept(String functionName);

6
cloud-manage-server/src/main/java/com/evotech/hd/cloud/mqtt/message/processor/impl/StrategyMqttMessageRequestExchangeProcessorImpl.java → cloud-manage-server/src/main/java/com/evotech/hd/cloud/mqtt/message/processor/impl/MqttMessageStrategyRequestExchangeProcessorImpl.java
View File

@ -6,7 +6,7 @@ import com.evotech.hd.cloud.mqtt.enums.RequestFunctionTypesEnum;
import com.evotech.hd.cloud.mqtt.message.MessageTopic;
import com.evotech.hd.cloud.mqtt.message.MqttMessageHeader;
import com.evotech.hd.cloud.mqtt.message.dto.newer.req.MqttResponse;
import com.evotech.hd.cloud.mqtt.message.processor.MqttMessageRequestExchangeProcessor;
import com.evotech.hd.cloud.mqtt.message.processor.MqttRequestExchangeProcessor;
import com.evotech.hd.cloud.service.BatteryStationCdStrategyService;
import com.evotech.hd.common.core.entity.cloud.BatteryStationCdStrategy;
import jakarta.annotation.Resource;
@ -26,13 +26,13 @@ import java.util.List;
*/
@Slf4j
@Service
public class StrategyMqttMessageRequestExchangeProcessorImpl implements MqttMessageRequestExchangeProcessor {
public class MqttMessageStrategyRequestExchangeProcessorImpl implements MqttRequestExchangeProcessor {
@Resource
BatteryStationCdStrategyService batteryStationCdStrategyService;
@Override
public boolean accept(String functionName) {
return RequestFunctionTypesEnum.FUN_STRATEGY_INFO.getReFunction().equals(functionName);
return RequestFunctionTypesEnum.FUN_STRATEGY_INFO.getFunction().equals(functionName);
}
@Override

53
cloud-manage-server/src/main/java/com/evotech/hd/cloud/mqtt/message/processor/impl/MqttStateBatDataDataRequestExchangeProcessor.java Normal file
View File

@ -0,0 +1,53 @@
package com.evotech.hd.cloud.mqtt.message.processor.impl;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.evotech.hd.cloud.mqtt.enums.StateFunctionTypesEnum;
import com.evotech.hd.cloud.mqtt.message.MessageTopic;
import com.evotech.hd.cloud.mqtt.message.MqttMessageHeader;
import com.evotech.hd.cloud.mqtt.message.processor.MqttRequestExchangeProcessor;
import com.evotech.hd.common.constant.MongoConstant;
import com.evotech.hd.common.documnet.BatData;
import com.evotech.hd.common.service.MongoDBService;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
/**
* 充电过程实时信息类
*
* @ClassName:ChargingDataMqttStateRequestEx
* @date: 2025年04月29日 13:26
* @author: andy.shi
* @contact: 17330188597
* @remark: 开发人员联系方式 1042025947@qq.com/微信同步
*/
@Slf4j
@Service
public class MqttStateBatDataDataRequestExchangeProcessor implements MqttRequestExchangeProcessor {
@Resource
MongoDBService mongoDBService;
@Override
public boolean accept(String functionName) {
return StateFunctionTypesEnum.FUN_BAT_DATA.getFunction().equals(functionName);
}
@Override
public void exchange(MessageTopic topic, MqttMessageHeader header, JSONObject dataBody) {
//记录充电过程信息
log.info("MqttStateBatDataDataRequestExchangeProcessor-->>>>> 请求参数{}", JSONUtil.toJsonStr(dataBody));
String batCode = dataBody.getStr("batCode");
if (StringUtils.isEmpty(batCode)) {
log.error("MqttStateBatDataDataRequestExchangeProcessor-->>>>> batCode is null");
return;
}
String cabinetNo = dataBody.getStr("cabinetNo");
if (StringUtils.isEmpty(cabinetNo)) {
log.error("MqttStateChargingDataRequestExchangeProcessor-->>>>> cabinetNo is null");
return;
}
mongoDBService.save(MongoConstant.BATTERY_DATA_BASE, batCode, new BatData(String.valueOf(System.currentTimeMillis()), topic.getStationCode(), batCode,cabinetNo,dataBody.toString()));
}
}

53
cloud-manage-server/src/main/java/com/evotech/hd/cloud/mqtt/message/processor/impl/MqttStateChargingDataRequestExchangeProcessor.java Normal file
View File

@ -0,0 +1,53 @@
package com.evotech.hd.cloud.mqtt.message.processor.impl;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.evotech.hd.cloud.mqtt.enums.StateFunctionTypesEnum;
import com.evotech.hd.cloud.mqtt.message.MessageTopic;
import com.evotech.hd.cloud.mqtt.message.MqttMessageHeader;
import com.evotech.hd.cloud.mqtt.message.processor.MqttRequestExchangeProcessor;
import com.evotech.hd.common.constant.MongoConstant;
import com.evotech.hd.common.documnet.ChargingData;
import com.evotech.hd.common.service.MongoDBService;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
/**
* 充电过程实时信息类
*
* @ClassName:ChargingDataMqttStateRequestEx
* @date: 2025年04月29日 13:26
* @author: andy.shi
* @contact: 17330188597
* @remark: 开发人员联系方式 1042025947@qq.com/微信同步
*/
@Slf4j
@Service
public class MqttStateChargingDataRequestExchangeProcessor implements MqttRequestExchangeProcessor {
@Resource
MongoDBService mongoDBService;
@Override
public boolean accept(String functionName) {
return StateFunctionTypesEnum.FUN_CHARGING_DATA.getFunction().equals(functionName);
}
@Override
public void exchange(MessageTopic topic, MqttMessageHeader header, JSONObject dataBody) {
//记录充电过程信息
log.info("MqttStateChargingDataRequestExchangeProcessor-->>>>> 请求参数{}", JSONUtil.toJsonStr(dataBody));
String batCode = dataBody.getStr("batCode");
if (StringUtils.isEmpty(batCode)) {
log.error("MqttStateChargingDataRequestExchangeProcessor-->>>>> batCode is null");
return;
}
String chgSn = dataBody.getStr("chgSn");
if (StringUtils.isEmpty(chgSn)) {
log.error("MqttStateChargingDataRequestExchangeProcessor-->>>>> chgSn is null");
return;
}
mongoDBService.save(MongoConstant.BATTERY_DATA_BASE, batCode, new ChargingData(String.valueOf(System.currentTimeMillis()), topic.getStationCode(), batCode,chgSn,dataBody.toString()));
}
}

2
cloud-manage-server/src/main/java/com/evotech/hd/cloud/service/impl/BatteryStationServiceImpl.java
View File

@ -311,7 +311,7 @@ public class BatteryStationServiceImpl implements BatteryStationService {
@Override
public Result<List<BatteryStation>> resourceList(String pkIds) {
String[] pkIdArray = pkIds.split(",");
return new Result<List<BatteryStation>>().success(batteryStationDao.selectList(new LambdaQueryWrapper<BatteryStation>().eq((pkIdArray != null && pkIdArray.length > 0), BatteryStation::getPkId, Arrays.asList(pkIdArray)).eq(BatteryStation::getStatus, 1).eq(BatteryStation::getDelFlag, 0).select(BatteryStation::getPkId, BatteryStation::getCode)));
return new Result<List<BatteryStation>>().success(batteryStationDao.selectList(new LambdaQueryWrapper<BatteryStation>().in((pkIdArray != null && pkIdArray.length > 0), BatteryStation::getPkId, Arrays.asList(pkIdArray)).eq(BatteryStation::getStatus, 1).eq(BatteryStation::getDelFlag, 0).select(BatteryStation::getPkId, BatteryStation::getCode)));
}
@Override

3
cloud-manage-server/src/main/resources/application.yml
View File

@ -9,7 +9,7 @@ logging:
level:
'[com.evotech.hd.cloud.dao]': debug
# 3.spring
spring:
spring:
# 服务名称必须带上，不然nacos服务列表中没有，也不会有注册成功的信息
application:
name: ${cloud-manage-server:cloud-server}
@ -23,6 +23,7 @@ spring:
- nacos:yt-common.properties?refreshEnabled=true
- nacos:cloud-server.yaml?refreshEnabled=true
- nacos:yt-redis.yaml?refreshEnabled=true
- nacos:yt-mongodb.yaml?refreshEnabled=true
cloud:
nacos:
serverAddr: 192.168.5.213:8848

42
resource-server/src/main/java/com/evotech/hd/resource/service/impl/AuthUserServiceImpl.java
View File

@ -31,10 +31,7 @@ import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.stream.Collectors;
@Service
@ -136,7 +133,13 @@ public class AuthUserServiceImpl implements AuthUserService {
if(Collections.isNotEmpty(companyList)){
businessNames.putAll(companyList.stream().collect(Collectors.toMap(Company::getCcode, Company::getCname, (k1,k2)->k1)));
}
//查询站信息, 展示站对象
Map<String, String> stationMap = getStationCode();
//查询角色信息, 展示角色对象
Map<String, String> roleMap = getRoleCode();
page.getRecords().stream().forEach(user ->{
user.setStationCodes(stationMap.get(user.getUid()));//初始化站信息
user.setRcodes(roleMap.get(user.getUid()));//初始化角色信息
if(StringUtils.hasText(user.getBusinessCode())){
user.setBusinessName(businessNames.get(user.getBusinessCode()));
}else{
@ -148,7 +151,36 @@ public class AuthUserServiceImpl implements AuthUserService {
return new com.evotech.hd.common.core.entity.Result<List<AuthUser>>().success(page);
}
public Map<String, String> getRoleCode(){
Map<String, String> roleCodeMap = Collections.emptyMap();
Map<String, List<AuthUserRole>> roleMap = authUserRoleDao.selectList(new LambdaQueryWrapper<AuthUserRole>().select(AuthUserRole::getUid, AuthUserRole::getRcode)).stream().collect(Collectors.groupingBy(AuthUserRole::getUid));
if(Collections.isNotEmpty(roleMap)){
Iterator<String> keyIt = roleMap.keySet().iterator();
while (keyIt.hasNext()){
String key = keyIt.next();
String roleCodes = roleMap.get(key).stream().map(AuthUserRole::getRcode).collect(Collectors.joining(","));
roleCodeMap.put(key, roleCodes);
}
}
return roleCodeMap;
}
public Map<String, String> getStationCode(){
Map<String, String> stationCodeMap = Collections.emptyMap();
Map<String, List<AuthUserStation>> authUserStationMap = authUserStationDao.selectList(new LambdaQueryWrapper<AuthUserStation>().select(AuthUserStation::getUid, AuthUserStation::getStationCode)).stream().collect(Collectors.groupingBy(AuthUserStation::getUid));
if(Collections.isNotEmpty(authUserStationMap)){
Iterator<String> keyIt = authUserStationMap.keySet().iterator();
while (keyIt.hasNext()){
String key = keyIt.next();
String stationCodes = authUserStationMap.get(key).stream().map(AuthUserStation::getStationCode).collect(Collectors.joining(","));
stationCodeMap.put(key, stationCodes);
}
}
return stationCodeMap;
}
@Override
public com.evotech.hd.common.core.entity.Result<Integer> addUserRole(AuthUserRole aur) {
authUserRoleDao.delete(new QueryWrapper<AuthUserRole>()

6
resource-server/src/main/java/com/evotech/hd/resource/service/rpc/CloudService.java
View File

@ -6,6 +6,8 @@ import com.evotech.hd.common.core.entity.cloud.Company;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
@ -13,9 +15,9 @@ import java.util.List;
public interface CloudService {
@GetMapping(value = "/batterystation/resource/list",
@PostMapping(value = "/batterystation/resource/list",
consumes = {MediaType.APPLICATION_FORM_URLENCODED_VALUE})
public Result<List<BatteryStation>> resourceList(String pkIds);
public Result<List<BatteryStation>> resourceList(@RequestParam String pkIds);
@GetMapping(value = "/company/resource/list", consumes = {MediaType.APPLICATION_FORM_URLENCODED_VALUE})
public Result<List<Company>> resourceCompanyList();