tanlifan/ski-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update:功能

Browse Source
This commit is contained in:
tanlifan
2025-12-01 08:12:11 +08:00
parent d20f559563
commit a9399f5497
51 changed files with 2319 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
ski-dashboard-service/pom.xml
View File

@@ -9,7 +9,6 @@
<version>0.0.1-SNAPSHOT</version>
</parent>
<groupId>com.ski.lichuan</groupId>
<artifactId>ski-dashboard-service</artifactId>
<properties>
@@ -17,6 +16,35 @@
<maven.compiler.target>21</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<repositories>
<!-- ThingsBoard 官方仓库 -->
<repository>
<id>thingsboard</id>
<name>ThingsBoard Repository</name>
<url>https://repo.thingsboard.io/artifactory/libs-release-public</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
<!-- 阿里云镜像配置 -->
<repository>
<id>aliyunmaven</id>
<name>aliyunmaven</name>
<url>https://maven.aliyun.com/repository/public</url>
<layout>default</layout>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>com.ski</groupId>
@@ -25,11 +53,55 @@
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.ski.lichuan</groupId>
<groupId>com.ski</groupId>
<artifactId>ski-dashboard-common</artifactId>
<version>0.0.1-SNAPSHOT</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.thingsboard</groupId>
<artifactId>rest-client</artifactId>
<version>4.2.1</version>
</dependency>
</dependencies>
<pluginRepositories>
<pluginRepository>
<id>aliyunmaven</id>
<name>aliyunmaven</name>
<url>https://maven.aliyun.com/repository/public</url>
<layout>default</layout>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</pluginRepository>
<pluginRepository>
<id>thingsboard</id>
<name>ThingsBoard Repository</name>
<url>https://repo.thingsboard.io/artifactory/libs-release-public</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</pluginRepository>
</pluginRepositories>
<build>
<plugins>
<!-- 排除Spring Boot Maven插件，因为这是一个数据模型模块，不是可执行应用程序 -->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<skip>true</skip>
</configuration>
</plugin>
</plugins>
</build>
</project>

119
ski-dashboard-service/src/main/java/com/ski/lichuan/Demo.java Normal file
View File

@@ -0,0 +1,119 @@
package com.ski.lichuan;
import org.thingsboard.rest.client.RestClient;
import org.thingsboard.server.common.data.Dashboard;
import org.thingsboard.server.common.data.DashboardInfo;
import org.thingsboard.server.common.data.Device;
import org.thingsboard.server.common.data.EntityType;
import org.thingsboard.server.common.data.page.PageData;
import org.thingsboard.server.common.data.page.PageLink;
import org.thingsboard.server.common.data.query.*;
import java.util.ArrayList;
import java.util.List;
public class Demo {
public static void main(String[] args) {
List<Device> devicesList = getDevices();
// List<DashboardInfo> dashboardsList = getDashboards();
for (Device device : devicesList) {
if (!device.getName().equals("iot_snowmaker_m005")) {
continue;
}
System.out.println("找到指定设备");
getDataByDevice(device);
}
}
/**
* 获取ThingsBoard客户端
* @return
*/
public static List<Device> getDevices() {
String url = "https://tb.ski.bkiiot.com";
String username = "tenant@thingsboard.org";
String password = "tenant";
List<Device> devicesList = new ArrayList<>();
RestClient client = new RestClient(url);
client.login(username, password);
PageData<Device> devices;
PageLink pageLink = new PageLink(10);
do {
devices = client.getTenantDevices("", pageLink);
devices.getData().forEach(System.out::println);
devicesList.addAll(devices.getData());
pageLink = pageLink.nextPageLink();
} while (devices.hasNext());
client.logout();
client.close();
return devicesList;
}
/**
* 获取仪表盘
*/
public static List<DashboardInfo> getDashboards() {
String url = "https://tb.ski.bkiiot.com";
String username = "tenant@thingsboard.org";
String password = "tenant";
List<DashboardInfo> dashboardsList = new ArrayList<>();
RestClient client = new RestClient(url);
client.login(username, password);
PageData<DashboardInfo> dashboards;
PageLink pageLink = new PageLink(10);
do {
dashboards = client.getTenantDashboards(pageLink);
dashboards.getData().forEach(System.out::println);
dashboardsList.addAll(dashboards.getData());
pageLink = pageLink.nextPageLink();
} while (dashboards.hasNext());
client.logout();
client.close();
return dashboardsList;
}
/**
* 获取设备属性
*/
public static void getDeviceAttributes(Device device) {
String url = "https://tb.ski.bkiiot.com";
String username = "tenant@thingsboard.org";
String password = "tenant";
RestClient client = new RestClient(url);
client.login(username, password);
// 获取属性
List<String> keys = client.getAttributeKeys(device.getId());
client.getAttributeKvEntries(device.getId(), keys).forEach(System.out::println);
}
/**
* 获取设备数据
*/
public static void getDataByDevice(Device device) {
String url = "https://tb.ski.bkiiot.com";
String username = "tenant@thingsboard.org";
String password = "tenant";
RestClient client = new RestClient(url);
client.login(username, password);
client.getLatestTimeseries(device.getId(), List.of()).forEach(System.out::println);
client.logout();
client.close();
}
}

12
ski-dashboard-service/src/main/java/com/ski/lichuan/initializer/AdminUserInitializer.java
View File

@@ -1,13 +1,16 @@
package com.ski.lichuan.initializer;
import com.ski.lichuan.common.utils.MD5Util;
import com.ski.lichuan.mapper.UserMapper;
import com.ski.lichuan.model.auth.SysUser;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Component;
@Component
@Slf4j
public class AdminUserInitializer implements CommandLineRunner {
@Autowired
@@ -24,15 +27,16 @@ public class AdminUserInitializer implements CommandLineRunner {
// 创建默认管理员用户
SysUser adminUser = new SysUser();
adminUser.setUsername("admin");
// 默认密码为 admin123，实际使用时应修改为更安全的密码
adminUser.setPassword(passwordEncoder.encode("admin123"));
// 默认密码为 123456，实际使用时应修改为更安全的密码 使用MD5加密
String text = MD5Util.encrypt("123456");
adminUser.setPassword(passwordEncoder.encode(text));
adminUser.setNickname("系统管理员");
adminUser.setStatus(1); // 启用状态
// 插入用户到数据库
userMapper.insertUser(adminUser);
System.out.println("默认管理员用户已创建，用户名: admin, 密码: admin123 (请登录后及时修改密码)");
log.info("默认管理员用户已创建，用户名: admin, 密码: 123456 (请登录后及时修改密码)");
} else {
System.out.println("管理员用户已存在");
log.info("管理员用户已存在");
}
}
}

53
ski-dashboard-service/src/main/java/com/ski/lichuan/initializer/TrailInitializer.java Normal file
View File

@@ -0,0 +1,53 @@
package com.ski.lichuan.initializer;
import com.ski.lichuan.mapper.TrailPositionMapper;
import com.ski.lichuan.model.dashboard.TrailPosition;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import java.util.List;
@Slf4j
public class TrailInitializer implements CommandLineRunner {
@Autowired
private TrailPositionMapper trailPositionMapper;
@Override
public void run(String... args) throws Exception {
List<TrailPosition> trailPositions = trailPositionMapper.selectAll();
if (trailPositions.isEmpty()) {
log.info("数据库中不存在坑位数据，开始初始化...");
Integer[][] positions = {
{1, 1},
{1, 2},
{1, 3},
{1, 4},
{2, 1},
{2, 2},
{2, 3},
{2, 4},
{2, 5},
{2, 6},
{3, 1},
{3, 2},
{3, 3},
{3, 4},
{3, 5},
{3, 6},
{4, 1},
{4, 2},
{4, 3}
};
for (Integer[] position : positions) {
TrailPosition trailPosition = new TrailPosition();
trailPosition.setTrailId(position[0]);
trailPosition.setPosition(position[1]);
trailPosition.setName(position[0] + "-" + position[1]);
trailPositionMapper.insert(trailPosition);
}
}
}
}

177
ski-dashboard-service/src/main/java/com/ski/lichuan/services/DeviceDataPollingService.java Normal file
View File

@@ -0,0 +1,177 @@
package com.ski.lichuan.services;
import com.ski.lichuan.model.dashboard.TrailPosition;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.thingsboard.rest.client.RestClient;
import org.thingsboard.server.common.data.Device;
import org.thingsboard.server.common.data.page.PageData;
import org.thingsboard.server.common.data.page.PageLink;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@Slf4j
@Service
public class DeviceDataPollingService {
// 高优先级查询列表（造雪机）
public static final List<String> HIGH_PRIORITY_SNOWMACHINE_IDS = Arrays.asList();
// 高优先级查询列表（水泵）
public static final List<String> HIGH_PRIORITY_PUMP_IDS = Arrays.asList();
@Value("${thingsboard.client.url:https://tb.ski.bkiiot.com}")
private String clientUrl;
@Value("${thingsboard.client.username:tenant@thingsboard.org}")
private String clientUsername;
@Value("${thingsboard.client.password:tenant}")
private String clientPassword;
// 客户端
private RestClient client;
@Autowired
private TrailPositionService trailPositionService;
@Autowired
private SnowMachineDeviceService snowMachineDeviceService;
/**
* 定时轮询设备状态
*/
@Scheduled(fixedRate = 60000)
public void pollDeviceStatus() {
/**
* 核心逻辑：每60秒轮询一次所有设备状态，查询所有坑位上的雪机和水泵的状态
*/
}
/**
* 定时轮询设备数据
* 每15秒执行一次
*/
@Scheduled(fixedRate = 15000)
public void pollDeviceData() {
/**
* 核心逻辑：每15秒轮询一次所有设备数据，查询所有坑位上的雪机和水泵的状态
*/
}
/**
* 定时轮询设备列表（造雪机、水泵）
* 每120秒执行一次
*/
@Scheduled(fixedRate = 120000)
public void pollDevices() {
/**
* 核心逻辑：每120秒轮询一次所有设备列表，更新造雪机设备和水泵
*/
log.info("开始查询设备列表");
List<Device> devices = getDevices();
List<TrailPosition> trailPositions = trailPositionService.getAllTrailPositionList();
// 转为Map，方便查询 (TrailId,Position) -> TrailPosition
Map<Integer, TrailPosition> trailPositionMap = trailPositions.stream()
.collect(Collectors.toMap(trailPosition -> trailPosition.getTrailId() * 10000 + trailPosition.getPosition(), trailPosition -> trailPosition));
for (Device device : devices) {
//s-{id}-{trailId}-{position}-{disable}
if (device.getLabel() != null && device.getLabel().startsWith("s-")) {
String[] parts = device.getLabel().split("-");
if (parts.length < 3) {
// 异常的设备
log.warn("异常的造雪机设备标签格式：{}", device.getLabel());
continue;
}
if (parts.length >= 4 && "disable".equals(parts[3])) {
// 禁用状态，跳过
log.info("造雪机设备 {} 已禁用，跳过", device.getLabel());
continue;
}
// 说明是造雪机设备
String id = parts[1];
String trailId = parts[2];
String position = parts[3];
// 判断是数字
if (!trailId.matches("\\d+") || !position.matches("\\d+")) {
// 不是数字，跳过
log.warn("造雪机设备 {} 标签格式错误，跳过", device.getLabel());
continue;
}
// id 不为空
if (id.isEmpty()) {
// 空id，跳过
log.warn("造雪机设备 {} 标签格式错误，跳过", device.getLabel());
continue;
}
Integer idValue = Integer.parseInt(id);
Integer trailIdValue = Integer.parseInt(trailId);
Integer positionValue = Integer.parseInt(position);
// 更新雪机信息
String name = device.getName() != null ? device.getName() : "雪机" + trailId + position;
try {
snowMachineDeviceService.updateSnowMachineDeviceNameAndLora(idValue, name, device.getId().toString());
log.info("更新造雪机设备信息 {} 成功", device.getLabel());
} catch (Exception e) {
log.error("更新造雪机设备信息 {} 失败：{}", device.getLabel(), e.getMessage());
}
// 检查是否存在对应的雪道位置
TrailPosition trailPosition = trailPositionMap.get(trailIdValue * 10000 + positionValue);
if (trailPosition == null) {
// 雪道位置不存在，跳过
log.warn("造雪机设备 {} 对应的雪道位置不存在，跳过", device.getLabel());
continue;
}
// 更新雪道位置的造雪机ID
trailPosition.setSnowMachineId(idValue);
trailPositionService.updateTrailPositionSnowMachineId(trailPosition.getId(), idValue);
// 从Map中删除该雪道位置，防止重复处理
trailPositionMap.remove(trailIdValue * 10000 + positionValue);
}
}
// 清楚Map中剩余的雪道位置
List<Integer> mapIdList = trailPositionMap.values().stream().map(TrailPosition::getId).collect(Collectors.toList());
try {
trailPositionService.clearTrailPositionSnowMachineIdBatch(mapIdList);
} catch (Exception e) {
log.error("清除雪道位置 {} 造雪机ID失败：{}", mapIdList, e.getMessage());
}
}
private RestClient getClient() {
if (client == null) {
client = new RestClient(clientUrl);
client.login(clientUsername, clientPassword);
}
return client;
}
public List<Device> getDevices() {
RestClient client = getClient();
List<Device> devicesList = new ArrayList<>();
PageData<Device> devices;
PageLink pageLink = new PageLink(10);
do {
devices = client.getTenantDevices("", pageLink);
devices.getData().forEach(device -> log.info("获取到的造雪机设备：{}", device));
devicesList.addAll(devices.getData());
pageLink = pageLink.nextPageLink();
} while (devices.hasNext());
return devicesList;
}
}

4
ski-dashboard-service/src/main/java/com/ski/lichuan/services/IoTService.java Normal file
View File

@@ -0,0 +1,4 @@
package com.ski.lichuan.services;
public class IoTService {
}

158
ski-dashboard-service/src/main/java/com/ski/lichuan/services/SnowMachineDeviceService.java Normal file
View File

@@ -0,0 +1,158 @@
package com.ski.lichuan.services;
import com.ski.lichuan.mapper.SnowMachineMapper;
import com.ski.lichuan.model.device.Impl.SnowMachineDevice;
import com.ski.lichuan.model.device.config.SnowMachineDeviceParams;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class SnowMachineDeviceService {
@Autowired
private SnowMachineMapper snowMachineMapper;
/**
* 新增造雪机设备
*
* @param snowMachineDevice 造雪机设备
* @return 新增结果
*/
public int addSnowMachineDevice(SnowMachineDevice snowMachineDevice) {
// 检查是否已存在相同LORA地址的造雪机设备
if (snowMachineMapper.selectByLora(snowMachineDevice.getLora()) != null) {
throw new IllegalArgumentException("造雪机设备已存在相同LORA地址");
}
return snowMachineMapper.insert(snowMachineDevice);
}
/**
* 查询所有未绑定位置的造雪机设备
*
* @return 未绑定位置的造雪机设备列表
*/
public List<SnowMachineDevice> selectUnboundMachines() {
return snowMachineMapper.selectUnboundMachines();
}
/**
* 查询所有造雪机设备
*
* @return 所有造雪机设备列表
*/
public List<SnowMachineDevice> getAllSnowMachineDevices() {
return snowMachineMapper.selectAll();
}
/**
* 根据ID查询造雪机设备
*
* @param id 造雪机设备ID
* @return 造雪机设备
*/
public SnowMachineDevice getSnowMachineDeviceById(Integer id) {
// 检查是否存在该ID的造雪机设备
if (snowMachineMapper.selectById(id) == null) {
throw new IllegalArgumentException("造雪机设备不存在");
}
return snowMachineMapper.selectById(id);
}
/**
* 根据LORA地址查询造雪机设备
*
* @param lora 造雪机设备LORA地址
* @return 造雪机设备
*/
public SnowMachineDevice selectByLora(String lora) {
return snowMachineMapper.selectByLora(lora);
}
/**
* 统计造雪机设备数量
*
* @return 造雪机设备数量
*/
public int count() {
return snowMachineMapper.count();
}
/**
* 更新造雪机设备名称
*
* @param snowMachineDevice 造雪机设备
* @return 更新结果
*/
public int updateSnowMachineDevice(SnowMachineDevice snowMachineDevice) {
if (snowMachineMapper.selectById(snowMachineDevice.getId()) == null) {
throw new IllegalArgumentException("造雪机设备不存在");
}
return snowMachineMapper.updateName(snowMachineDevice);
}
/**
* 更新造雪机信息
*
* @param id 造雪机设备ID
* @param name 造雪机设备名称
* @param lora 造雪机设备LORA地址
* @return 更新结果
*/
public int updateSnowMachineDeviceNameAndLora(Integer id, String name, String lora) {
// 检查是否存在该ID的造雪机设备
if (snowMachineMapper.selectById(id) == null) {
// 则新增
SnowMachineDevice newSnowMachineDevice = new SnowMachineDevice();
newSnowMachineDevice.setId(id);
newSnowMachineDevice.setName(name);
newSnowMachineDevice.setLora(lora);
return snowMachineMapper.insertById(newSnowMachineDevice);
} else {
// 更新造雪机设备信息
SnowMachineDevice snowMachineDevice = snowMachineMapper.selectById(id);
snowMachineDevice.setName(name);
snowMachineDevice.setLora(lora);
return snowMachineMapper.updateName(snowMachineDevice);
}
}
/**
* 删除造雪机设备
*
* @param id 造雪机设备ID
* @return 删除结果
*/
public int deleteSnowMachineDevice(Integer id) {
return snowMachineMapper.deleteById(id);
}
/**
* 获取所有雪机设备信息
*
* @return 所有雪机设备列表
*/
public List<SnowMachineDevice> selectAllDevices() {
return snowMachineMapper.selectAll();
}
/**
* 群控雪机设备
* @param deviceList 雪机设备列表
* @param params 造雪机设备参数
* @return 群控结果
*/
public boolean groupControl(List<SnowMachineDevice> deviceList, SnowMachineDeviceParams params) {
// 检查是否存在该ID的造雪机设备
if (deviceList.isEmpty()) {
throw new IllegalArgumentException("造雪机设备不存在");
}
// 群控雪机设备
for (SnowMachineDevice device : deviceList) {
// 发送群控指令
// ...
}
return true;
}
}

310
ski-dashboard-service/src/main/java/com/ski/lichuan/services/TrailPositionService.java Normal file
View File

@@ -0,0 +1,310 @@
package com.ski.lichuan.services;
import com.ski.lichuan.mapper.SnowMachineMapper;
import com.ski.lichuan.mapper.TrailPositionMapper;
import com.ski.lichuan.model.common.DeviceEnum;
import com.ski.lichuan.model.dashboard.*;
import com.ski.lichuan.model.device.Impl.SnowMachineDevice;
import com.ski.lichuan.model.device.config.SnowMachineDeviceParams;
import com.ski.lichuan.model.device.config.SnowMachineDevicePitchHorizontalParams;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
@Service
public class TrailPositionService {
@Autowired
private TrailPositionMapper trailPositionMapper;
@Autowired
private SnowMachineMapper snowMachineDeviceMapper;
/**
* 获取所有已绑定雪机的雪道位置信息
*/
public List<TrailPosition> getBoundTrailPositions() {
return trailPositionMapper.selectBoundPositions();
}
/**
* 获取所有未绑定雪机的雪道位置信息
*/
public List<TrailPosition> getUnboundTrailPositions() {
return trailPositionMapper.selectUnboundPositions();
}
/**
* 获取所有雪道及位置信息
*/
public List<List<TrailPosition>> getAllTrailPositions() {
List<TrailPosition> allTrailPositions = trailPositionMapper.selectAll();
List<List<TrailPosition>> result = new ArrayList<>();
for (int i = 1; i <= 4; i++) {
int finalI = i;
List<TrailPosition> trailPositions = allTrailPositions.stream()
.filter(trailPosition -> trailPosition.getTrailId().equals(finalI))
.collect(Collectors.toList());
result.add(trailPositions);
}
// 遍历result，将每个雪道的位置信息按position排序
for (List<TrailPosition> trailPositions : result) {
// 更新trailPosition状态
for (TrailPosition trailPosition : trailPositions) {
if (trailPosition.getSnowMachineStatus() == 0) {
// 暂时随机
trailPosition.setSnowMachineStatus((int) (Math.random() * 3));
}
}
trailPositions.sort((p1, p2) -> p1.getPosition().compareTo(p2.getPosition()));
}
return result;
}
/**
* 获取雪道位置的详细信息（造雪机）
*/
public TrailPositionInfo getTrailPositionInfo(Integer id) {
TrailPosition trailPosition = trailPositionMapper.selectById(id);
if (trailPosition == null) {
return null;
} else {
TrailPositionInfo result = new TrailPositionInfo();
Integer trailId = id / 10;
Integer position = id % 10;
// 雪机设备
SnowMachineDevice snowMachineDevice = new SnowMachineDevice();
snowMachineDevice.setLora("1234567890123456");
snowMachineDevice.setId(1000000000 + id);
snowMachineDevice.setName("造雪机-" + id);
snowMachineDevice.setType(DeviceEnum.SNOW_MAKER.getValue());
// 雪道位置信息
trailPosition.setSnowMachineStatus(1);
// 雪道位置状态信息
TrailPositionMonitorInfo trailPositionMonitorInfo = new TrailPositionMonitorInfo();
trailPositionMonitorInfo.setTrailPosition(trailPosition);
trailPositionMonitorInfo.setSnowMakerName(snowMachineDevice.getName());
trailPositionMonitorInfo.setPriority(1);
trailPositionMonitorInfo.setEnvironmentTemperature(-3.5);
trailPositionMonitorInfo.setEnvironmentHumidity(50.0);
trailPositionMonitorInfo.setWetBulbTemperature(0.5);
trailPositionMonitorInfo.setCommunicationStatus(true);
trailPositionMonitorInfo.setIsNormal(true);
trailPositionMonitorInfo.setIsRunning(true);
trailPositionMonitorInfo.setTemperatureConditionSatisfied(true);
trailPositionMonitorInfo.setWindSpeed(5.0);
trailPositionMonitorInfo.setWindDirection(180.0);
// 造雪机设备状态
SnowMachineDeviceInfo snowMachineDeviceInfo = new SnowMachineDeviceInfo();
snowMachineDeviceInfo.setSnowMachineDevice(snowMachineDevice);
snowMachineDeviceInfo.setFrontWaterPressure(0.5 + Math.random() * 0.3); // 前端水压 0.5-0.8 MPa
snowMachineDeviceInfo.setBackWaterPressure(0.4 + Math.random() * 0.2); // 后端水压 0.4-0.6 MPa
snowMachineDeviceInfo.setPressure(0.8 + Math.random() * 0.2); // 气压 0.8-1.0 MPa
snowMachineDeviceInfo.setTemperature(2.5 + Math.random() * 2.0); // 水温 2.5-4.5 ℃
snowMachineDeviceInfo.setGivenAngle(45.0 + Math.random() * 10.0); // 给定开度 45-55°
snowMachineDeviceInfo.setActualAngle(44.0 + Math.random() * 12.0); // 实际开度 44-56°
snowMachineDeviceInfo.setIsNormal(Math.random() > 0.1); // 是否正常 90%概率正常
snowMachineDeviceInfo.setMode((int) (Math.random() * 3) + 1); // 模式 1-3随机
snowMachineDeviceInfo.setCompressorStatus((int) (Math.random() * 2) + 1); // 空压机状态 1-2随机
snowMachineDeviceInfo.setFanStatus((int) (Math.random() * 2) + 1); // 风机状态 1-2随机
snowMachineDeviceInfo.setHeatingRingStatus((int) (Math.random() * 2) + 1); // 加热环状态 1-2随机
snowMachineDeviceInfo.setValveStatus((int) (Math.random() * 2) + 1); // 电磁阀状态1 1-2随机
snowMachineDeviceInfo.setValveStatus2((int) (Math.random() * 2) + 1); // 电磁阀状态2 1-2随机
snowMachineDeviceInfo.setValveStatus3((int) (Math.random() * 2) + 1); // 电磁阀状态3 1-2随机
snowMachineDeviceInfo.setPitchMode((int) (Math.random() * 3) + 1); // 俯仰模式 1-3随机
snowMachineDeviceInfo.setPitchAngle(15.0 + Math.random() * 20.0); // 俯仰角度 15-35°
snowMachineDeviceInfo.setPitchStatus((int) (Math.random() * 2) + 1); // 俯仰状态 1-2随机
snowMachineDeviceInfo.setYawMode((int) (Math.random() * 3) + 1); // 摆头模式 1-3随机
snowMachineDeviceInfo.setYawAngle(30.0 + Math.random() * 40.0); // 摆头角度 30-70°
snowMachineDeviceInfo.setYawStatus((int) (Math.random() * 2) + 1); // 摆头状态 1-2随机
// 造雪机配置
SnowMachineDeviceParams snowMakerDeviceParams = new SnowMachineDeviceParams();
snowMakerDeviceParams.setWorkMode((int) (Math.random() * 3) + 1); // 工作模式 1-3随机
snowMakerDeviceParams.setPriority((int) (Math.random() * 5) + 1); // 优先级 1-5随机
snowMakerDeviceParams.setSnowQuality((int) (Math.random() * 5) + 1); // 雪质 1-5随机
snowMakerDeviceParams.setStartTemperature(-5.0 + Math.random() * 10.0); // 启动温度 -5.0 ~ 5.0
snowMakerDeviceParams.setStopTemperature(-5.0 + Math.random() * 10.0); // 停止温度 -5.0 ~ 5.0
snowMakerDeviceParams.setFlowAdjustment((int) (Math.random() * 50)); // 流量调节 0 ~ 50
// 数据统计
TrailPositionStatisticsInfo trailPositionStatisticsInfo = new TrailPositionStatisticsInfo();
trailPositionStatisticsInfo.setRunningDuration(120.5 + Math.random() * 100.0); // 运行时长 120.5-220.5分钟
trailPositionStatisticsInfo.setFlowStatistics(1000.0 + Math.random() * 500.0); // 流量统计 1000-1500 L/H
trailPositionStatisticsInfo.setSnowArea(500.0 + Math.random() * 300.0); // 造雪面积 500-800 平方米
result.setTrailPositionMonitorInfo(trailPositionMonitorInfo);
result.setSnowMakerInfo(snowMachineDeviceInfo);
result.setSnowMakerDeviceParams(snowMakerDeviceParams);
result.setTrailPositionStatisticsInfo(trailPositionStatisticsInfo);
return result;
}
}
/**
* 关联造雪机设备
*/
public boolean connectDevice(Integer trailPositionId, Integer deviceId) {
TrailPosition trailPosition = trailPositionMapper.selectById(trailPositionId);
if (trailPosition == null) {
return false;
}
SnowMachineDevice snowMachineDevice = snowMachineDeviceMapper.selectById(deviceId);
if (snowMachineDevice == null) {
return false;
}
trailPosition.setSnowMachineId(deviceId);
trailPosition.setSnowMachineStatus(1);
trailPositionMapper.updateSnowMachine(trailPositionId, trailPosition.getSnowMachineId());
return true;
}
/**
* 取消关联造雪机设备
*/
public boolean disconnectDevice(Integer trailPositionId) {
TrailPosition trailPosition = trailPositionMapper.selectById(trailPositionId);
if (trailPosition == null) {
return false;
}
trailPosition.setSnowMachineId(null);
trailPosition.setSnowMachineStatus(0);
trailPositionMapper.clearSnowMachine(trailPositionId);
return true;
}
/**
* 群控造雪机设备
*
* @param trailPositionIds 雪道位置ID列表
* @param params 造雪机设备参数
* @return 群控结果
*/
public boolean groupControl(List<Integer> trailPositionIds, SnowMachineDeviceParams params) {
// 检查是否存在该ID的造雪机设备
if (trailPositionIds.isEmpty()) {
throw new IllegalArgumentException("雪道位置不存在");
}
// 反查造雪机设备ID
List<Integer> deviceIds = trailPositionMapper.selectDeviceIdsByTrailPositionIds(trailPositionIds);
if (deviceIds.isEmpty()) {
throw new IllegalArgumentException("造雪机设备不存在");
}
// 群控雪机设备
for (Integer deviceId : deviceIds) {
// 发送群控指令
// ...
}
return true;
}
/**
* 俯仰水平控制
*
* @param trailPositionId 雪道位置ID
* @param params 俯仰水平参数
* @return 控制结果
*/
public Boolean pitchHorizontalControl(Integer trailPositionId, SnowMachineDevicePitchHorizontalParams params) {
// 检查是否存在该ID的造雪机设备
TrailPosition trailPosition = trailPositionMapper.selectById(trailPositionId);
if (trailPosition == null) {
throw new IllegalArgumentException("雪道位置不存在");
}
// 反查造雪机设备ID
SnowMachineDevice snowMachineDevice = snowMachineDeviceMapper.selectById(trailPosition.getSnowMachineId());
if (snowMachineDevice == null) {
throw new IllegalArgumentException("造雪机设备不存在");
}
// 发送俯仰水平控制指令
// ...
return true;
}
/**
* 保存造雪机参数
*
* @param trailPosition 雪道位置ID
* @param params 造雪机设备参数
* @return 保存结果
*/
public Boolean saveSnowMakerDeviceParams(Integer trailPosition, SnowMachineDeviceParams params) {
// 检查是否存在该ID的造雪机设备
TrailPosition trailPositionEntity = trailPositionMapper.selectById(trailPosition);
if (trailPositionEntity == null) {
throw new IllegalArgumentException("雪道位置不存在");
}
// 反查造雪机设备ID
SnowMachineDevice snowMachineDevice = snowMachineDeviceMapper.selectById(trailPositionEntity.getSnowMachineId());
if (snowMachineDevice == null) {
throw new IllegalArgumentException("造雪机设备不存在");
}
// 保存造雪机参数
// ...
return true;
}
/**
* 更新雪道坑位雪机信息
*
* @param trailPositionId 雪道位置ID
* @param snowMachineId 造雪机设备ID
* @return 更新结果
*/
public Boolean updateTrailPositionSnowMachineId(Integer trailPositionId, Integer snowMachineId) {
// 检查是否存在该ID的雪道位置
TrailPosition trailPosition = trailPositionMapper.selectById(trailPositionId);
if (trailPosition == null) {
throw new IllegalArgumentException("雪道位置不存在");
}
// 更新雪道位置雪机信息
trailPosition.setSnowMachineId(snowMachineId);
trailPositionMapper.updateSnowMachine(trailPositionId, snowMachineId);
return true;
}
/**
* 清空雪道位置雪机信息
*
* @param trailPositionIds 雪道位置ID列表
* @return 更新结果
*/
public Boolean clearTrailPositionSnowMachineIdBatch(List<Integer> trailPositionIds) {
// 检查是否存在该ID的雪道位置
if (trailPositionIds.isEmpty()) {
throw new IllegalArgumentException("雪道位置不存在");
}
// 清空雪道位置雪机信息
for (Integer trailPositionId : trailPositionIds) {
TrailPosition trailPosition = trailPositionMapper.selectById(trailPositionId);
if (trailPosition == null) {
throw new IllegalArgumentException("雪道位置不存在");
}
trailPosition.setSnowMachineId(null);
trailPosition.setSnowMachineStatus(0);
trailPositionMapper.clearSnowMachine(trailPositionId);
}
return true;
}
/**
* 平铺返回所有雪道位置信息
*
* @return 所有雪道位置信息列表
*/
public List<TrailPosition> getAllTrailPositionList() {
return trailPositionMapper.selectAll();
}
}

31
ski-dashboard-service/src/main/resources/sql/sys_user.sql
View File

@@ -10,4 +10,33 @@ CREATE TABLE sys_user (
COMMENT ON COLUMN sys_user.username IS '用户名';
COMMENT ON COLUMN sys_user.password IS '加密后的密码（BCrypt）';
COMMENT ON COLUMN sys_user.nickname IS '昵称';
COMMENT ON COLUMN sys_user.status IS '状态（1-正常，0-禁用）';
COMMENT ON COLUMN sys_user.status IS '状态（1-正常，0-禁用）';
CREATE TABLE snow_machine (
id BIGSERIAL PRIMARY KEY,
type SMALLINT DEFAULT 1,
name VARCHAR(255),
lora VARCHAR(255),
CONSTRAINT uk_lora UNIQUE (lora)
);
COMMENT ON COLUMN snow_machine.type IS '类型1雪机2水泵';
COMMENT ON COLUMN snow_machine.name IS '名称';
COMMENT ON COLUMN snow_machine.lora IS 'Lora 地址';
CREATE TABLE trail_position (
id BIGSERIAL PRIMARY KEY,
trail_id BIGINT NOT NULL,
position SMALLINT,
trail_name VARCHAR(255),
snow_machine_id BIGINT,
snow_machine_status SMALLINT DEFAULT 0,
);
COMMENT ON COLUMN trail_position.trail_id IS '雪道ID';
COMMENT ON COLUMN trail_position.position IS '位置';
COMMENT ON COLUMN trail_position.trail_name IS '雪道名称';
COMMENT ON COLUMN trail_position.snow_machine_id IS '雪机ID';
COMMENT ON COLUMN trail_position.snow_machine_status IS '雪机状态 0无 1正常 2停止';