Commit 8394fc19 authored by 颜佳斌's avatar 颜佳斌

项目初始化

parent 18e6a3d0
Pipeline #6943 failed with stages
target/
!.mvn/wrapper/maven-wrapper.jar
!**/src/main/**/target/
!**/src/test/**/target/
### IntelliJ IDEA ###
.idea/modules.xml
.idea/jarRepositories.xml
.idea/compiler.xml
.idea/libraries/
*.iws
*.iml
*.ipr
### Eclipse ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
.sts4-cache
### NetBeans ###
/nbproject/private/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/
build/
!**/src/main/**/build/
!**/src/test/**/build/
### VS Code ###
.vscode/
### Mac OS ###
.DS_Store
\ No newline at end of file
<?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>
<groupId>com.zkhj.project</groupId>
<artifactId>zkhj-roadside-platform</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.5.8</version> <!-- 或最新版本 -->
</parent>
<modules>
<module>zkhj-roadside-service</module>
<module>zkhj-roadside-service/zkhj-roadside-user-service</module>
<module>zkhj-roadside-dto</module>
<module>zkhj-roadside-dto/zkhj-roadside-user-dto</module>
<module>zkhj-roadside-feign-api</module>
<module>zkhj-roadside-feign-api/zkhj-roadside-user-feign-api</module>
</modules>
<properties>
<!-- Java 版本 -->
<java.version>21</java.version>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<!-- base -->
<slf4j-api.version>2.0.17</slf4j-api.version>
<junit-jupiter.version>6.0.1</junit-jupiter.version>
<!-- mybatis & db -->
<mybatis-spring-boot-starter.version>3.0.5</mybatis-spring-boot-starter.version>
<mysql-connector-j.version>9.5.0</mysql-connector-j.version>
<!-- Spring 版本 -->
<spring-boot.version>3.5.8</spring-boot.version>
<spring-cloud.version>2025.0.0</spring-cloud.version>
<spring-cloud-alibaba.version>2025.0.0.0</spring-cloud-alibaba.version>
<spring.version>6.2.14</spring.version>
<mapstruct.version>1.5.5.Final</mapstruct.version>
<lombok.version>1.18.34</lombok.version>
<mybatis-plus.version>3.5.9</mybatis-plus.version>
<mysql.version>8.3.0</mysql.version>
<hutool.version>5.8.44</hutool.version>
<postgresql.version>42.6.2</postgresql.version>
<hbase.version>2.4.18</hbase.version>
<phoenix.version>5.1.3</phoenix.version>
<phoenix-queryserver.version>6.0.0</phoenix-queryserver.version>
</properties>
<!-- 依赖管理 -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>${spring-boot.version}</version> <!-- 使用你需要的版本号 -->
<type>pom</type>
<scope>import</scope>
</dependency>
<!-- Spring Boot -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>${spring-boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!-- Spring Cloud -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-alibaba-sentinel-gateway</artifactId>
<version>${spring-cloud-alibaba.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!-- Spring Cloud Alibaba -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-alibaba-dependencies</artifactId>
<version>${spring-cloud-alibaba.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>${hutool.version}</version>
</dependency>
<!-- mybatis plus-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-spring-boot3-starter</artifactId>
<version>${mybatis-plus.version}</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-extension</artifactId>
<version>${mybatis-plus.version}</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>${mybatis-plus.version}</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-jsqlparser</artifactId>
<version>${mybatis-plus.version}</version>
</dependency>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>${postgresql.version}</version>
</dependency>
<!--hbase-->
<dependency>
<groupId>org.apache.hbase</groupId>
<artifactId>hbase-client</artifactId>
<version>${hbase.version}</version>
</dependency>
<dependency>
<groupId>org.apache.hbase</groupId>
<artifactId>hbase-common</artifactId>
<version>${hbase.version}</version>
</dependency>
<!--hbase sql层-->
<dependency>
<groupId>org.apache.phoenix</groupId>
<artifactId>phoenix-client-hbase-2.4</artifactId>
<version>${phoenix.version}</version>
</dependency>
<dependency>
<groupId>org.apache.phoenix</groupId>
<artifactId>phoenix-queryserver-client</artifactId>
<version>${phoenix-queryserver.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<!-- 测试依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- Spring Cloud LoadBalancer -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>
<!-- Lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
<repositories>
<repository>
<id>justh5-releases</id>
<url>http://maven.justh5.com/repository/maven-releases/</url>
<releases><enabled>true</enabled></releases>
<snapshots><enabled>false</enabled></snapshots>
</repository>
<repository>
<id>justh5-snapshots</id>
<url>http://maven.justh5.com/repository/maven-snapshots/</url>
<releases><enabled>false</enabled></releases>
<snapshots><enabled>true</enabled></snapshots>
</repository>
</repositories>
<distributionManagement>
<repository>
<id>justh5-releases</id>
<url>http://maven.justh5.com/repository/maven-releases/</url>
</repository>
<snapshotRepository>
<id>justh5-snapshots</id>
<url>http://maven.justh5.com/repository/maven-snapshots/</url>
</snapshotRepository>
</distributionManagement>
<build>
<plugins>
<!-- Maven 编译插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.13.0</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
<encoding>${project.build.sourceEncoding}</encoding>
<annotationProcessorPaths>
<path>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>${lombok.version}</version>
</path>
<path>
<groupId>org.mapstruct</groupId>
<artifactId>mapstruct-processor</artifactId>
<version>${mapstruct.version}</version>
</path>
</annotationProcessorPaths>
</configuration>
</plugin>
<!-- Spring Boot Maven 插件 -->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>${spring-boot.version}</version>
<configuration>
<excludes>
<exclude>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</exclude>
</excludes>
</configuration>
</plugin>
</plugins>
</build>
</project>
<?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.zkhj.project</groupId>
<artifactId>zkhj-roadside-platform</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<artifactId>zkhj-roadside-dto</artifactId>
<packaging>pom</packaging>
<modules>
<module>zkhj-roadside-user-dto</module>
</modules>
<properties>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<skip>true</skip>
</configuration>
</plugin>
</plugins>
</build>
</project>
<?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.zkhj.project</groupId>
<artifactId>zkhj-roadside-platform</artifactId>
<version>1.0-SNAPSHOT</version>
<relativePath>../../pom.xml</relativePath>
</parent>
<artifactId>zkhj-roadside-user-dto</artifactId>
<properties>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>com.zkhj.project</groupId>
<artifactId>zkhj-dto-core</artifactId>
<version>1.0-SNAPSHOT</version>
<scope>compile</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<skip>true</skip>
</configuration>
</plugin>
</plugins>
</build>
</project>
package com.zkhj.dto.roadside.berth.req;
import lombok.Data;
@Data
public class AddUpdateRoadBerth {
/**
* 主键
*/
private Long id;
/**
* 泊位编码
*/
private String berthCode;
/**
* 泊位名称对外
*/
private String berthName;
/**
* 路段id
*/
private Integer roadId;
/**
* 泊位类型
*/
private Integer berthType;
/**
* 收费规则
*/
private Integer ruleId;
/**
* 状态
*/
private Integer status;
}
package com.zkhj.dto.roadside.berth.req;
import lombok.Builder;
import lombok.Data;
@Data
@Builder
public class CommonQueryBerth {
/**
* 路段id
*/
private Integer roadId;
}
package com.zkhj.dto.roadside.berth.req;
import com.zkhj.dto.core.http.PageBase;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.List;
@EqualsAndHashCode(callSuper = true)
@Data
public class QueryRoadBerth extends PageBase {
/**
* 状态 (字典值: 1正常, 0禁用)
*/
private Integer status;
/**
* 路段ID
*/
private Integer roadId;
/**
* 收费规则
*/
private Integer ruleId;
/**
* 泊位编码
*/
private String berthCode;
/**
* 泊位类型 (字典值: 1固定泊位, 2临时泊位)
*/
private Integer berthType;
/**
* 创建时间
*/
private List<String> createTime;
}
package com.zkhj.dto.roadside.berth.resp;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.time.LocalDateTime;
@Data
public class PageRoadBerthDTO {
/**
* 主键
*/
private Long id;
/**
* 泊位编码
*/
private String berthCode;
/**
* 泊位名称对外
*/
private String berthName;
/**
* 路段id
*/
private Integer roadId;
/**
* 路段名称
*/
private String roadName;
/**
* 泊位类型
*/
private Integer berthType;
/**
* 收费规则
*/
private Integer ruleId;
/**
* 收费规则名称
*/
private String ruleName;
/**
* 状态
*/
private Integer status;
/**
* 创建时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private LocalDateTime createTime;
}
package com.zkhj.dto.roadside.berth.resp;
import lombok.Data;
@Data
public class RoadBerthStaticDTO {
private Long totalNum;
private Long enableNum;
private Long disableNum;
}
package com.zkhj.dto.roadside.berth.resp;
import lombok.Data;
/**
* 泊位总数DTO
*/
@Data
public class RoadBerthSumDTO {
/**
* 路段id
*/
private Integer roadId;
/**
* 泊位数量
*/
private Long berthNum;
}
package com.zkhj.dto.roadside.road.req;
import lombok.Data;
@Data
public class AddUpdateRoadInfo {
/**
* 主键ID,自增
*/
private Integer id;
/**
* 路段名称
*/
private String roadName;
/**
* 路段编码,唯一标识
*/
private String roadCode;
/**
* 所属区域
*/
private Integer regionId;
/**
* 路段类型 (字典值: 1主干道, 2次干道, 3支路)
*/
private Integer roadType;
/**
* 路段长度,单位:米
*/
private Integer roadLength;
/**
* 状态 (字典值: 1正常, 0禁用)
*/
private Integer status;
}
package com.zkhj.dto.roadside.road.req;
import com.zkhj.dto.core.http.PageBase;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.List;
@EqualsAndHashCode(callSuper = true)
@Data
public class QueryRoadInfo extends PageBase {
/**
* 道路编码
*/
private String roadCode;
/**
* 区域id
*/
private Integer regionId;
/**
* 状态
*/
private Integer status;
/**
* 路段类型
*/
private Integer roadType;
/**
* 创建时间
*/
private List<String> createTime;
/**
* 泊位数范围
*/
private List<Integer> berthNum;
}
package com.zkhj.dto.roadside.road.resp;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.time.LocalDateTime;
@Data
public class PageRoadInfoDTO {
/**
* 主键ID,自增
*/
private Integer id;
/**
* 路段名称
*/
private String roadName;
/**
* 路段编码,唯一标识
*/
private String roadCode;
/**
* 所属区域
*/
private Integer regionId;
/**
* 区域名称
*/
private String regionName;
/**
* 泊位数量
*/
private Long berthNum;
/**
* 路段类型 (字典值: 1主干道, 2次干道, 3支路)
*/
private Integer roadType;
/**
* 路段长度,单位:米
*/
private Integer roadLength;
/**
* 状态 (字典值: 1正常, 0禁用)
*/
private Integer status;
/**
* 创建时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private LocalDateTime createTime;
}
package com.zkhj.dto.roadside.road.resp;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.time.LocalDateTime;
@Data
public class RoadInfoDTO {
/**
* 主键ID,自增
*/
private Integer id;
/**
* 路段名称
*/
private String roadName;
/**
* 路段编码,唯一标识
*/
private String roadCode;
/**
* 所属区域
*/
private Integer regionId;
/**
* 路段类型 (字典值: 1主干道, 2次干道, 3支路)
*/
private Integer roadType;
/**
* 路段长度,单位:米
*/
private Integer roadLength;
/**
* 状态 (字典值: 1正常, 0禁用)
*/
private Integer status;
/**
* 创建时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private LocalDateTime createTime;
}
package com.zkhj.dto.roadside.road.resp;
import lombok.Data;
@Data
public class RoadInfoStaticDTO {
/**
* 总数
*/
private Integer totalNum;
/**
* 启用数量
*/
private Integer enableNum;
/**
* 总泊位数
*/
private Integer totalBerthNum;
}
package com.zkhj.dto.roadside.sys.org.req;
import com.zkhj.dto.core.assembler.Copier;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
@EqualsAndHashCode(callSuper = true)
@Data
public class AddSysOrganization extends BaseSysOrganization implements Serializable, Copier {
/*
* 账号名称
*/
private String profile;
}
package com.zkhj.dto.roadside.sys.org.req;
import com.zkhj.dto.core.assembler.Copier;
import lombok.Data;
import java.io.Serializable;
@Data
public class BaseSysOrganization implements Serializable, Copier {
/**
* 机构名称
*/
private String orgName;
/**
* 机构编码
*/
private String orgCode;
/**
* 上级机构ID,0表示顶级机构
*/
private Long parentId;
/**
* 机构类型(字典值,如:1-企业,2-部门)
*/
private Integer orgType;
/**
* 状态(字典值,如:1-启用,0-禁用)
*/
private Integer status;
/**
* 备注
*/
private String remark;
}
package com.zkhj.dto.roadside.sys.org.req;
import lombok.Data;
@Data
public class QuerySysOrganization{
/**
* 机构编码
*/
private String orgCode; // 搜索:名称或编码
/**
* 机构类型
*/
private Integer orgType; // 搜索:机构类型
/**
* 状态
*/
private Integer status;
}
package com.zkhj.dto.roadside.sys.org.req;
import com.zkhj.dto.core.assembler.Copier;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
@EqualsAndHashCode(callSuper = true)
@Data
public class UpdateSysOrganization extends BaseSysOrganization implements Serializable, Copier {
/**
* 主键
*/
private Long id;
}
package com.zkhj.dto.roadside.sys.org.resp;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.time.LocalDateTime;
import java.util.List;
@Data
public class ListSysOrganizationDTO {
/**
* 主键ID
*/
private Long id;
/**
* 机构名称
*/
private String orgName;
/**
* 机构编码
*/
private String orgCode;
/**
* 上级机构ID,0表示顶级机构
*/
private Long parentId;
/**
* 机构类型(字典值,如:1-企业,2-部门)
*/
private Integer orgType;
/**
* 机构类型名称
*/
private String orgTypeName;
/**
* 状态(字典值,如:1-启用,0-禁用)
*/
private Integer status;
/**
* 备注
*/
private String remark;
/**
* 创建时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private LocalDateTime createTime;
/**
* 等级
*/
private Integer level;
/**
* 总车场数
*/
private Integer totalParkNum;
/**
* 子机构
*/
private List<ListSysOrganizationDTO> childList;
}
package com.zkhj.dto.roadside.sys.org.resp;
import lombok.Data;
@Data
public class SysOrganizationStaticDTO {
/**
* 总机构数
*/
private Integer orgNum;
/**
* 启用机构数
*/
private Integer enableOrgNum;
/**
* 禁用机构数
*/
private Integer disableOrgNum;
/**
* 总车场数
*/
private Integer totalParkNum;
}
package com.zkhj.dto.roadside.sys.region.req;
import lombok.Data;
import lombok.EqualsAndHashCode;
@EqualsAndHashCode(callSuper = true)
@Data
public class AddSysRegion extends BaseSysRegion{
}
package com.zkhj.dto.roadside.sys.region.req;
import lombok.Data;
import java.util.Set;
@Data
public class BaseSysRegion {
/**
* 所属机构ID
*/
private Long orgId;
/**
* 父id
*/
private Integer parentId;
/**
* 区域名称
*/
private String regionName;
/**
* 区域类型
*/
private Integer regionType;
/**
* 排序
*/
private Integer sort;
/**
* 备注
*/
private String remark;
/**
* 状态 (1-启用, 0-禁用)
*/
private Integer status;
/**
* 子区域
*/
private Set<String> childRegionList;
}
package com.zkhj.dto.roadside.sys.region.req;
import lombok.Data;
@Data
public class QuerySysRegion {
/**
* 机构id
*/
private Long orgId; // 搜索:机构id
/**
* 区域类型
*/
private Integer regionType; // 搜索:区域类型
/**
* 状态
*/
private Integer status;
/**
* 区域名称
*/
private String regionName;
}
package com.zkhj.dto.roadside.sys.region.req;
import lombok.Data;
import lombok.EqualsAndHashCode;
@EqualsAndHashCode(callSuper = true)
@Data
public class UpdateSysRegion extends BaseSysRegion{
private Integer id;
}
package com.zkhj.dto.roadside.sys.region.resp;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
@Data
public class ListSysRegionDTO implements Serializable {
/**
* 主键ID
*/
private Integer id;
/**
* 所属机构ID
*/
private Long orgId;
/**
* 机构名称
*/
private String orgName;
/**
* 父id
*/
private Integer parentId;
/**
* 父名称
*/
private String parentName;
/**
* 区域名称
*/
private String regionName;
/**
* 区域类型
*/
private Integer regionType;
/**
* 排序
*/
private Integer sort;
/**
* 备注
*/
private String remark;
/**
* 状态 (1-启用, 0-禁用)
*/
private Integer status;
/**
* 创建时间
*/
private Date createTime;
/**
* 子机构
*/
private List<ListSysRegionDTO> childList;
}
package com.zkhj.dto.roadside.sys.region.resp;
import lombok.Data;
@Data
public class SysRegionStaticDTO {
/**
* 总机构数
*/
private Integer regionNum;
/**
* 启用机构数
*/
private Integer enableRegionNum;
/**
* 禁用机构数
*/
private Integer disableRegionNum;
}
package com.zkhj.dto.roadside.user;
import com.zkhj.dto.core.assembler.Copier;
import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* 系统菜单实体类
*/
@Data
public class SysMenuDto implements Serializable, Copier {
/**
* 菜单ID,主键,自增
*/
private Long menuId;
/**
* 父菜单ID,0=顶级,树的根节点
*/
private Long parentId;
/**
* 菜单类型:1=菜单,2=按钮,3=接口
*/
private Integer menuType;
/**
* 菜单名称,路由名称(name)
*/
private String name;
/**
* 菜单标题,显示名称,支持i18n
*/
private String title;
/**
* 路由地址,URL路径,唯一键
*/
private String path;
/**
* 组件路径,前端组件路径
*/
private String component;
/**
* 菜单图标,Icon图标名
*/
private String icon;
/**
* 显示排序,数值越小越靠前
*/
private Integer sort;
/**
* 是否外链:0=否,1=是(外链跳转)
*/
private Integer isFrame;
/**
* 是否缓存:0=否,1=是(keep-alive)
*/
private Integer isCache;
/**
* 是否显示:0=隐藏,1=显示(左侧菜单)
*/
private Integer isVisible;
/**
* 是否固定:0=否,1=是(固定在Tab栏)
*/
private Integer isAffix;
/**
* 状态:1=启用,0=停用
*/
private Integer status;
/**
* 外链地址,is_frame=1时填写完整URL
*/
private String link;
/**
* 权限标识,按钮权限编码,如"user:add"
*/
private String permission;
/**
* 高亮菜单,激活时高亮的父菜单path
*/
private String activeMenu;
/**
* 描述
*/
private String description;
/**
* 创建人ID
*/
private Long createUser;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新人ID
*/
private Long updateUser;
/**
* 更新时间
*/
private LocalDateTime updateTime;
/**
* 软删除标记:0=正常,1=删除
*/
private Integer deleted;
}
package com.zkhj.dto.roadside.user;
import com.zkhj.dto.core.assembler.Copier;
import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* 系统角色实体类
*/
@Data
public class SysRoleDto implements Serializable, Copier {
/**
* 角色ID,主键,自增
*/
private Long roleId;
/**
* 角色名称,如"超级管理员"
*/
private String roleName;
/**
* 角色编码,唯一键,如"R_SUPER"
*/
private String roleCode;
/**
* 角色描述,说明文字
*/
private String description;
/**
* 排序号,数值越小越靠前
*/
private Integer roleSort;
/**
* 是否启用,1=启用,0=停用
*/
private Integer enabled;
/**
* 创建人ID
*/
private Long createUser;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新人ID
*/
private Long updateUser;
/**
* 更新时间
*/
private LocalDateTime updateTime;
/**
* 软删除标记,0=正常,1=删除
*/
private Integer deleted;
}
package com.zkhj.dto.roadside.user;
import com.zkhj.dto.core.assembler.Copier;
import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;
@Data
public class SysRoleMenuDto implements Serializable, Copier {
/**
* 主键ID,自增
*/
private Long id;
/**
* 角色ID,关联 sys_role
*/
private Long roleId;
/**
* 菜单ID,关联 sys_menu
*/
private Long menuId;
/**
* 创建时间
*/
private LocalDateTime createTime;
}
package com.zkhj.dto.roadside.user;
import com.zkhj.dto.core.assembler.Copier;
import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* 系统用户实体类
*/
@Data
public class SysUserDto implements Serializable, Copier {
/**
* 用户ID,主键,自增
*/
private Long userId;
/**
* 用户名,唯一键,登录账号
*/
private String username;
/**
* 密码,加密存储(BCrypt)
*/
private String password;
/**
* 姓名,真实姓名
*/
private String name;
/**
* 头像URL,头像OSS地址
*/
private String avatar;
/**
* 性别,0=女,1=男
*/
private Integer gender;
/**
* 手机号,唯一键
*/
private String phone;
/**
* 邮箱,唯一键
*/
private String email;
/**
* 状态,1=启用,2=停用,3=离职,4=删除
*/
private Integer status;
/**
* 所属机构ID
*/
private Long orgId;
/**
* 创建人ID
*/
private Long createUser;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新人ID
*/
private Long updateUser;
/**
* 更新时间
*/
private LocalDateTime updateTime;
/**
* 软删除标记,0=正常,1=删除
*/
private Integer deleted;
}
package com.zkhj.dto.roadside.user;
import com.zkhj.dto.core.assembler.Copier;
import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;
@Data
public class SysUserRoleDto implements Serializable, Copier {
/**
* 主键ID,自增
*/
private Long id;
/**
* 用户ID,关联 sys_user
*/
private Long userId;
/**
* 角色ID,关联 sys_role
*/
private Long roleId;
/**
* 创建时间
*/
private LocalDateTime createTime;
}
package com.zkhj.dto.roadside.user.req;
import com.zkhj.dto.core.http.PageBase;
import lombok.Data;
import lombok.EqualsAndHashCode;
@EqualsAndHashCode(callSuper = true)
@Data
public class SearchUserReq extends PageBase {
private String name;
}
package com.zkhj.dto.roadside.util;
import lombok.AllArgsConstructor;
import lombok.Getter;
@AllArgsConstructor
@Getter
public enum Status {
ENABLED(1),
DISABLED(0);
private final int code;
}
<?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.zkhj.project</groupId>
<artifactId>zkhj-roadside-platform</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<artifactId>zkhj-roadside-feign-api</artifactId>
<packaging>pom</packaging>
<modules>
<module>zkhj-roadside-user-feign-api</module>
</modules>
<properties>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<skip>true</skip>
</configuration>
</plugin>
</plugins>
</build>
</project>
<?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.zkhj.project</groupId>
<artifactId>zkhj-roadside-platform</artifactId>
<version>1.0-SNAPSHOT</version>
<relativePath>../../pom.xml</relativePath>
</parent>
<artifactId>zkhj-roadside-user-feign-api</artifactId>
<properties>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>com.zkhj.project</groupId>
<artifactId>zkhj-feign-api-core</artifactId>
<version>${project.version}</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<skip>true</skip>
</configuration>
</plugin>
</plugins>
</build>
</project>
package java.com.zkhj.feign.api.roadside.user.fallback;
import com.zkhj.config.exception.BusinessException;
import com.zkhj.dto.core.http.ResultHttp;
import com.zkhj.dto.core.http.ResultHttpStatus;
import com.zkhj.feign.api.roadside.user.service.SysUserFeignService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.openfeign.FallbackFactory;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* @author fanjie
* @date 2026-03-19
* @desc 回退
*/
@Slf4j
@Component
public class SysUserFeignServiceFb implements FallbackFactory<SysUserFeignService> {
@Override
public SysUserFeignService create(Throwable throwable) {
return new SysUserFeignService() {
@Override
public ResultHttp<String> doLogin(String userName, String password) {
log.info("doLogin 熔断");
throw new BusinessException(ResultHttpStatus.SERVICE_UNAVAILABLE_ZNMG_USER);
}
@Override
public ResultHttp<List<String>> getPermission(String userName) {
log.info("getPermission 熔断");
throw new BusinessException(ResultHttpStatus.SERVICE_UNAVAILABLE_ZNMG_USER);
}
};
}
}
package java.com.zkhj.feign.api.roadside.user.service;
import com.zkhj.dto.core.http.ResultHttp;
import com.zkhj.feign.api.core.retryer.CustomRetryer;
import com.zkhj.feign.api.roadside.user.fallback.SysUserFeignServiceFb;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 用户服务
*
* @author fanjie
* @since 2026-03-18 14:00:53
* @description
*/
@FeignClient(contextId = "f-zkhj-roadside-user-service-SysUserFeignService",
name = "zkhj-roadside-user-service",
path = "/roadside/user/user-feign",
//url = "http://localhost:8081",
fallbackFactory = SysUserFeignServiceFb.class,
configuration = {CustomRetryer.class})
public interface SysUserFeignService {
@RequestMapping(value="/doLogin", method= RequestMethod.GET)
ResultHttp<String> doLogin(@RequestParam String userName, @RequestParam String password);
@RequestMapping(value="/getPermission", method= RequestMethod.GET)
ResultHttp<List<String>> getPermission(@RequestParam String userName);
}
<?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>
<packaging>pom</packaging>
<modules>
<module>zkhj-roadside-user-service</module>
</modules>
<parent>
<groupId>com.zkhj.project</groupId>
<artifactId>zkhj-middle-platform</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<artifactId>zkhj-service</artifactId>
<properties>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
</project>
# 忽略 target 目录(构建产物)
../../zkhj-roadside-user-service/target/
# 忽略 IDE 配置
.idea/
*.iml
.vscode/
# 忽略日志文件
*.log
logs/
# 忽略临时文件
*.tmp
*.bak
# 多阶段构建 - 构建阶段
FROM maven:3.9-eclipse-temurin-21 AS builder
WORKDIR /build
# 复制父 pom 和依赖模块
COPY pom.xml .
COPY zkhj-core ./zkhj-core
COPY zkhj-config ./zkhj-config
COPY zkhj-common ./zkhj-common
COPY zkhj-dto ./zkhj-dto
COPY zkhj-feign-api ./zkhj-feign-api
COPY zkhj-middleware ./zkhj-middleware
# 复制用户服务
COPY zkhj-roadside-user-service ./zkhj-roadside-user-service
# 构建项目
RUN mvn clean package -pl zkhj-roadside--service -am -DskipTests -B
# 运行阶段
FROM amazoncorretto:21-al2023-jdk
LABEL maintainer="zkhj"
LABEL service="zkhj-roadside-user-service"
LABEL version="1.0"
# 创建应用目录和日志目录
RUN mkdir -p /app /data/applogs
WORKDIR /app
# 环境变量
ENV LOG_HOME=/data/applogs \
JAVA_OPTS="-Xms512m -Xmx512m -XX:+UseG1GC -XX:MaxGCPauseMillis=200" \
PARAMS="" \
TZ=Asia/Shanghai
# 设置时区
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
# 从构建阶段复制 jar 包
COPY --from=builder /build/zkhj-roadside-user-service/target/zkhj-roadside-user-service-*.jar /app/app.jar
# 暴露端口
EXPOSE 7101
# 健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=40s --retries=3 \
CMD curl -f http://localhost:7101/roadside/user/actuator/health || exit 1
# 启动命令
ENTRYPOINT ["sh","-c","java $JAVA_OPTS -DLOG_HOME=$LOG_HOME -jar /app/app.jar $PARAMS"]
version: '3'
services:
user:
build:
context: ../../zkhj-roadside-user-service
dockerfile: ../../zkhj-roadside-user-service/Dockerfile
image: zkhj-roadside-user-service:1.0
container_name: zkhj-roadside-user-service
restart: unless-stopped
ports:
- '7101:7101'
<?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.zkhj.project</groupId>
<artifactId>zkhj-middle-platform</artifactId>
<version>1.0-SNAPSHOT</version>
<relativePath>../../pom.xml</relativePath>
</parent>
<artifactId>zkhj-roadside-user-service</artifactId>
<properties>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>com.zkhj.project</groupId>
<artifactId>zkhj-core</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.zkhj.project</groupId>
<artifactId>zkhj-middleware-redis</artifactId>
<version>1.0-SNAPSHOT</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
</dependency>
<dependency>
<groupId>com.zkhj.project</groupId>
<artifactId>zkhj-middleware-shardingjdbc</artifactId>
<version>1.0-SNAPSHOT</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.zkhj.project</groupId>
<artifactId>zkhj-roadside-user-dto</artifactId>
<version>1.0-SNAPSHOT</version>
<scope>compile</scope>
</dependency>
</dependencies>
</project>
package com.zkhj.roadside.user;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.context.annotation.Import;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@SpringBootApplication
@EnableTransactionManagement
@EnableDiscoveryClient
//@Import(FeignScanEnable.class)
@MapperScan("com.zkhj.roadside.user.mapper")
@EnableAspectJAutoProxy(proxyTargetClass = false) // 如果你的目标对象是接口,则需要设置为true来使用JDK动态代理,否则默认为CGLIB代理
public class RoadsideUser {
public static void main(String[] args) {
SpringApplication.run(RoadsideUser.class, args);
}
}
package com.zkhj.roadside.user.controller;
import com.zkhj.common.annotation.DesensitizeResponse;
import com.zkhj.dto.core.http.ResultHttp;
import com.zkhj.dto.roadside.berth.req.AddUpdateRoadBerth;
import com.zkhj.dto.roadside.berth.req.QueryRoadBerth;
import com.zkhj.dto.roadside.berth.resp.PageRoadBerthDTO;
import com.zkhj.dto.roadside.berth.resp.RoadBerthStaticDTO;
import com.zkhj.roadside.user.service.RoadBerthService;
import jakarta.annotation.Resource;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RefreshScope // 添加此注解以支持配置的自动刷新
@RestController
@RequestMapping("/index/berth")
@DesensitizeResponse
public class RoadBerthController {
@Resource
private RoadBerthService roadBerthService;
public
@PostMapping ResultHttp<?> create(@RequestBody AddUpdateRoadBerth addBerthInfo) {
return roadBerthService.createBerth(addBerthInfo);
}
@PutMapping
public ResultHttp<?> update(@RequestBody AddUpdateRoadBerth updateBerthInfo) {
return roadBerthService.updateBerth(updateBerthInfo);
}
@PostMapping("/page")
public ResultHttp<List<PageRoadBerthDTO>> list(@RequestBody(required = false) QueryRoadBerth queryRoadBerth) {
return roadBerthService.queryPage(queryRoadBerth);
}
@DeleteMapping("/{id}")
public ResultHttp<?> delete(@PathVariable Integer id) {
return roadBerthService.delete(id);
}
@PostMapping("/statistics")
public ResultHttp<RoadBerthStaticDTO> getStatistics(@RequestBody(required = false) QueryRoadBerth queryRoadBerth) {
return roadBerthService.staticData(queryRoadBerth);
}
}
package com.zkhj.roadside.user.controller;
import cn.hutool.core.bean.BeanUtil;
import com.zkhj.common.annotation.DesensitizeResponse;
import com.zkhj.dto.core.http.ResultHttp;
import com.zkhj.dto.roadside.road.req.AddUpdateRoadInfo;
import com.zkhj.dto.roadside.road.req.QueryRoadInfo;
import com.zkhj.dto.roadside.road.resp.PageRoadInfoDTO;
import com.zkhj.dto.roadside.road.resp.RoadInfoDTO;
import com.zkhj.dto.roadside.road.resp.RoadInfoStaticDTO;
import com.zkhj.roadside.user.service.RoadInfoService;
import jakarta.annotation.Resource;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RefreshScope // 添加此注解以支持配置的自动刷新
@RestController
@RequestMapping("/index/road")
@DesensitizeResponse
public class RoadInfoController {
@Resource
private RoadInfoService roadInfoService;
public
@PostMapping ResultHttp<?> create(@RequestBody AddUpdateRoadInfo addUpdateRoadInfo) {
return roadInfoService.createRoad(addUpdateRoadInfo);
}
@PutMapping
public ResultHttp<?> update(@RequestBody AddUpdateRoadInfo updateRoadInfo) {
return roadInfoService.updateRoad(updateRoadInfo);
}
@PostMapping("/page")
public ResultHttp<List<PageRoadInfoDTO>> list(@RequestBody(required = false) QueryRoadInfo queryRoadInfo) {
return roadInfoService.queryPage(queryRoadInfo);
}
@DeleteMapping("/{id}")
public ResultHttp<?> delete(@PathVariable Integer id) {
return roadInfoService.delete(id);
}
@PostMapping("/statistics")
public ResultHttp<RoadInfoStaticDTO> getStatistics(@RequestBody QueryRoadInfo queryRoadInfo) {
return roadInfoService.staticData(queryRoadInfo);
}
@PostMapping("/list")
public ResultHttp<List<RoadInfoDTO>> list() {
return ResultHttp.success(BeanUtil.copyToList(roadInfoService.list(), RoadInfoDTO.class));
}
}
package com.zkhj.roadside.user.controller;
import com.zkhj.core.common.BaseCrudUtil;
import com.zkhj.common.annotation.DesensitizeResponse;
import com.zkhj.dto.core.http.ResultHttp;
import com.zkhj.roadside.user.entity.SysOrgType;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RefreshScope // 添加此注解以支持配置的自动刷新
@RestController
@RequestMapping("/index/org/type")
@DesensitizeResponse
public class SysOrgTypeController {
@GetMapping
public ResultHttp<?> list() {
return ResultHttp.success(BaseCrudUtil.list(null, SysOrgType.class));
}
}
package com.zkhj.roadside.user.controller;
import com.zkhj.common.annotation.DesensitizeResponse;
import com.zkhj.core.common.BaseCrudUtil;
import com.zkhj.dto.core.http.ResultHttp;
import com.zkhj.dto.core.http.ResultHttpStatus;
import com.zkhj.dto.roadside.sys.org.req.AddSysOrganization;
import com.zkhj.dto.roadside.sys.org.req.QuerySysOrganization;
import com.zkhj.dto.roadside.sys.org.req.UpdateSysOrganization;
import com.zkhj.dto.roadside.sys.org.resp.SysOrganizationStaticDTO;
import com.zkhj.roadside.user.entity.SysOrganization;
import com.zkhj.roadside.user.service.SysOrganizationService;
import jakarta.annotation.Resource;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.*;
@RefreshScope // 添加此注解以支持配置的自动刷新
@RestController
@RequestMapping("/index/org")
@DesensitizeResponse
public class SysOrganizationController {
@Resource private SysOrganizationService sysOrganizationService;
@PostMapping
public ResultHttp<?> create(@RequestBody AddSysOrganization addSysOrganization) {
return sysOrganizationService.createOrg(addSysOrganization);
}
@PutMapping
public ResultHttp<?> update(@RequestBody UpdateSysOrganization updateSysOrganization) {
return sysOrganizationService.updateOrg(updateSysOrganization);
}
@DeleteMapping("/{id}")
public ResultHttp<?> delete(@PathVariable Long id) {
return sysOrganizationService.deleteOrg(id);
}
@PatchMapping("/{id}/status")
public ResultHttp<?> updateStatus(@PathVariable Long id, @RequestParam Integer status) {
SysOrganization sysOrganization = BaseCrudUtil.getById(id, SysOrganization.class);
if (sysOrganization == null) return ResultHttp.error(ResultHttpStatus.NOT_FOUND);
sysOrganization.setStatus(status);
BaseCrudUtil.update(sysOrganization, SysOrganization.class);
return ResultHttp.success();
}
@PostMapping("/list")
public ResultHttp<?> list(@RequestBody(required = false) QuerySysOrganization organization) {
return sysOrganizationService.queryList(organization);
}
@GetMapping("/statistics")
public ResultHttp<SysOrganizationStaticDTO> getStatistics() {
return sysOrganizationService.staticData();
}
}
package com.zkhj.roadside.user.controller;
import com.zkhj.common.annotation.DesensitizeResponse;
import com.zkhj.dto.core.http.ResultHttp;
import com.zkhj.dto.roadside.sys.region.req.AddSysRegion;
import com.zkhj.dto.roadside.sys.region.req.QuerySysRegion;
import com.zkhj.dto.roadside.sys.region.req.UpdateSysRegion;
import com.zkhj.dto.roadside.sys.region.resp.ListSysRegionDTO;
import com.zkhj.dto.roadside.sys.region.resp.SysRegionStaticDTO;
import com.zkhj.roadside.user.service.SysRegionService;
import jakarta.annotation.Resource;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RefreshScope // 添加此注解以支持配置的自动刷新
@RestController
@RequestMapping("/index/region")
@DesensitizeResponse
public class SysRegionController {
@Resource
private SysRegionService sysRegionService;
@PostMapping
public ResultHttp<?> create(@RequestBody AddSysRegion addSysOrganization) {
return sysRegionService.createRegion(addSysOrganization);
}
@PutMapping
public ResultHttp<?> update(@RequestBody UpdateSysRegion updateSysOrganization) {
return sysRegionService.updateRegion(updateSysOrganization);
}
@PostMapping("/list")
public ResultHttp<List<ListSysRegionDTO>> list(@RequestBody(required = false) QuerySysRegion querySysRegion) {
return sysRegionService.queryList(querySysRegion);
}
@DeleteMapping("/{id}")
public ResultHttp<?> delete(@PathVariable Integer id) {
return sysRegionService.delete(id);
}
@GetMapping("/statistics")
public ResultHttp<SysRegionStaticDTO> getStatistics() {
return sysRegionService.staticData();
}
@PatchMapping("/{id}/status")
public ResultHttp<?> updateStatus(@PathVariable Integer id, @RequestParam Integer status) {
return sysRegionService.updateStatus(id,status);
}
}
package com.zkhj.roadside.user.controller;
import com.zkhj.common.annotation.DesensitizeResponse;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.*;
@RefreshScope // 添加此注解以支持配置的自动刷新
@RestController
@RequestMapping("/index")
@DesensitizeResponse
public class SysUserController {
}
package com.zkhj.roadside.user.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDateTime;
/**
*
* @TableName t_road_berth
*/
@TableName(value ="t_road_berth")
@Data
public class RoadBerth {
/**
* 主键
*/
@TableId(type = IdType.AUTO)
private Long id;
/**
* 泊位编码
*/
private String berthCode;
/**
* 泊位名称对外
*/
private String berthName;
/**
* 路段id
*/
private Integer roadId;
/**
* 泊位类型
*/
private Integer berthType;
/**
* 收费规则
*/
private Integer ruleId;
/**
* 状态
*/
private Integer status;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 修改时间
*/
private LocalDateTime updateTime;
}
\ No newline at end of file
package com.zkhj.roadside.user.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDateTime;
import java.util.Date;
/**
* 路段信息表
* @TableName t_road_info
*/
@TableName(value ="t_road_info")
@Data
public class RoadInfo {
/**
* 主键ID,自增
*/
@TableId(type = IdType.AUTO)
private Integer id;
/**
* 路段名称
*/
private String roadName;
/**
* 路段编码,唯一标识
*/
private String roadCode;
/**
* 所属区域
*/
private Integer regionId;
/**
* 路段类型 (字典值: 1主干道, 2次干道, 3支路)
*/
private Integer roadType;
/**
* 路段长度,单位:米
*/
private Integer roadLength;
/**
* 状态 (字典值: 1正常, 0禁用)
*/
private Integer status;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 最后修改时间
*/
private LocalDateTime updateTime;
}
\ No newline at end of file
package com.zkhj.roadside.user.entity;
import com.baomidou.mybatisplus.annotation.*;
import com.zkhj.dto.core.assembler.Copier;
import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* 系统菜单实体类
*/
@Data
@TableName(value = "sys_menu")
public class SysMenu implements Serializable, Copier {
private static final long serialVersionUID = 1L;
/**
* 菜单ID,主键,自增
*/
@TableId(type = IdType.AUTO)
private Long menuId;
/**
* 父菜单ID,0=顶级,树的根节点
*/
private Long parentId;
/**
* 菜单类型:1=菜单,2=按钮,3=接口
*/
private Integer menuType;
/**
* 菜单名称,路由名称(name)
*/
private String name;
/**
* 菜单标题,显示名称,支持i18n
*/
private String title;
/**
* 路由地址,URL路径,唯一键
*/
private String path;
/**
* 组件路径,前端组件路径
*/
private String component;
/**
* 菜单图标,Icon图标名
*/
private String icon;
/**
* 显示排序,数值越小越靠前
*/
private Integer sort;
/**
* 是否外链:0=否,1=是(外链跳转)
*/
private Integer isFrame;
/**
* 是否缓存:0=否,1=是(keep-alive)
*/
private Integer isCache;
/**
* 是否显示:0=隐藏,1=显示(左侧菜单)
*/
private Integer isVisible;
/**
* 是否固定:0=否,1=是(固定在Tab栏)
*/
private Integer isAffix;
/**
* 状态:1=启用,0=停用
*/
private Integer status;
/**
* 外链地址,is_frame=1时填写完整URL
*/
private String link;
/**
* 权限标识,按钮权限编码,如"user:add"
*/
private String permission;
/**
* 高亮菜单,激活时高亮的父菜单path
*/
private String activeMenu;
/**
* 描述
*/
private String description;
/**
* 创建人ID
*/
private Long createUser;
/**
* 创建时间
*/
@TableField(fill = FieldFill.INSERT)
private LocalDateTime createTime;
/**
* 更新人ID
*/
private Long updateUser;
/**
* 更新时间
*/
@TableField(fill = FieldFill.INSERT_UPDATE)
private LocalDateTime updateTime;
/**
* 软删除标记:0=正常,1=删除
*/
@TableLogic
private Integer deleted;
}
package com.zkhj.roadside.user.entity;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
/**
* 机构信息表
* @TableName sys_org_type
*/
@TableName(value ="sys_org_type")
@Data
public class SysOrgType {
/**
*
*/
@TableId
private Integer id;
/**
* 机构名称
*/
private String orgName;
}
\ No newline at end of file
package com.zkhj.roadside.user.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.time.LocalDateTime;
import java.util.Date;
/**
* 机构表
* @TableName sys_organization
*/
@TableName(value ="sys_organization")
@Data
public class SysOrganization {
/**
* 主键ID
*/
@TableId(type=IdType.AUTO)
private Long id;
/**
* 机构名称
*/
private String orgName;
/**
* 机构编码
*/
private String orgCode;
/**
* 上级机构ID,0表示顶级机构
*/
private Long parentId;
/**
* 机构类型(字典值,如:1-企业,2-部门)
*/
private Integer orgType;
/**
* 状态(字典值,如:1-启用,0-禁用)
*/
private Integer status;
/**
* 备注
*/
private String remark;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 修改时间
*/
private LocalDateTime updateTime;
}
\ No newline at end of file
package com.zkhj.roadside.user.entity;
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 lombok.Data;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.TimeZone;
/**
* 区域表
* @TableName sys_region
*/
@TableName(value ="sys_region")
@Data
public class SysRegion {
/**
* 主键ID
*/
@TableId(type = IdType.AUTO)
private Integer id;
/**
* 所属机构ID
*/
private Long orgId;
/**
* 父id
*/
private Integer parentId;
/**
* 区域名称
*/
private String regionName;
/**
* 区域类型
*/
private Integer regionType;
/**
* 排序
*/
private Integer sort;
/**
* 备注
*/
private String remark;
/**
* 状态 (1-启用, 0-禁用)
*/
private Integer status;
/**
* 创建时间
*/
private LocalDateTime createTime;
/**
* 更新时间
*/
private LocalDateTime updateTime;
}
\ No newline at end of file
package com.zkhj.roadside.user.entity;
import com.baomidou.mybatisplus.annotation.*;
import com.zkhj.dto.core.assembler.Copier;
import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* 系统角色实体类
*/
@Data
@TableName(value = "sys_role")
public class SysRole implements Serializable, Copier {
private static final long serialVersionUID = 1L;
/**
* 角色ID,主键,自增
*/
@TableId(type = IdType.AUTO)
private Long roleId;
/**
* 角色名称,如"超级管理员"
*/
private String roleName;
/**
* 角色编码,唯一键,如"R_SUPER"
*/
private String roleCode;
/**
* 角色描述,说明文字
*/
private String description;
/**
* 排序号,数值越小越靠前
*/
private Integer roleSort;
/**
* 是否启用,1=启用,0=停用
*/
private Integer enabled;
/**
* 创建人ID
*/
private Long createUser;
/**
* 创建时间
*/
@TableField(fill = FieldFill.INSERT)
private LocalDateTime createTime;
/**
* 更新人ID
*/
private Long updateUser;
/**
* 更新时间
*/
@TableField(fill = FieldFill.INSERT_UPDATE)
private LocalDateTime updateTime;
/**
* 软删除标记,0=正常,1=删除
*/
@TableLogic
private Integer deleted;
}
package com.zkhj.roadside.user.entity;
import com.baomidou.mybatisplus.annotation.*;
import com.zkhj.dto.core.assembler.Copier;
import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;
@Data
@TableName(value = "sys_role_menu")
public class SysRoleMenu implements Serializable, Copier {
private static final long serialVersionUID = 1L;
/**
* 主键ID,自增
*/
@TableId(type = IdType.AUTO)
private Long id;
/**
* 角色ID,关联 sys_role
*/
private Long roleId;
/**
* 菜单ID,关联 sys_menu
*/
private Long menuId;
/**
* 创建时间
*/
@TableField(fill = FieldFill.INSERT)
private LocalDateTime createTime;
}
package com.zkhj.roadside.user.entity;
import com.baomidou.mybatisplus.annotation.*;
import com.zkhj.dto.core.assembler.Copier;
import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* 系统用户实体类
*/
@Data
@TableName(value = "sys_user")
public class SysUser implements Serializable, Copier {
private static final long serialVersionUID = 1L;
/**
* 用户ID,主键,自增
*/
@TableId(type = IdType.AUTO)
private Long userId;
/**
* 用户名,唯一键,登录账号
*/
private String username;
/**
* 密码,加密存储(BCrypt)
*/
private String password;
/**
* 姓名,真实姓名
*/
private String name;
/**
* 头像URL,头像OSS地址
*/
private String avatar;
/**
* 性别,0=女,1=男
*/
private Integer gender;
/**
* 手机号,唯一键
*/
private String phone;
/**
* 邮箱,唯一键
*/
private String email;
/**
* 状态,1=启用,2=停用,3=离职,4=删除
*/
private Integer status;
/**
* 所属机构ID
*/
private Long orgId;
/**
* 创建人ID
*/
private Long createUser;
/**
* 创建时间
*/
@TableField(fill = FieldFill.INSERT)
private LocalDateTime createTime;
/**
* 更新人ID
*/
private Long updateUser;
/**
* 更新时间
*/
@TableField(fill = FieldFill.INSERT_UPDATE)
private LocalDateTime updateTime;
/**
* 软删除标记,0=正常,1=删除
*/
@TableLogic
private Integer deleted;
}
package com.zkhj.roadside.user.entity;
import com.baomidou.mybatisplus.annotation.*;
import com.zkhj.dto.core.assembler.Copier;
import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;
@Data
@TableName(value = "sys_user_role")
public class SysUserRole implements Serializable, Copier {
private static final long serialVersionUID = 1L;
/**
* 主键ID,自增
*/
@TableId(type = IdType.AUTO)
private Long id;
/**
* 用户ID,关联 sys_user
*/
private Long userId;
/**
* 角色ID,关联 sys_role
*/
private Long roleId;
/**
* 创建时间
*/
@TableField(fill = FieldFill.INSERT)
private LocalDateTime createTime;
}
package com.zkhj.roadside.user.feign;
import com.zkhj.dto.core.http.ResultHttp;
import com.zkhj.roadside.user.service.SysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RefreshScope // 添加此注解以支持配置的自动刷新
@RestController
@RequestMapping("/user-feign")
public class SysUserFeignController {
@Autowired
private SysUserService sysUserService;
@RequestMapping(value="/doLogin", method= RequestMethod.GET)
public ResultHttp<String> doLogin( @RequestParam String userName, @RequestParam String password){
String ret = sysUserService.doLogin(userName,password);
return ResultHttp.success(ret);
}
@RequestMapping(value="/getPermission", method= RequestMethod.GET)
public ResultHttp<List<String>> getPermission(@RequestParam String userName){
return ResultHttp.success(sysUserService.getPermissionList(userName));
}
}
package com.zkhj.roadside.user.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.zkhj.roadside.user.entity.RoadBerth;
/**
* @author 罗俊
* @description 针对表【t_road_berth】的数据库操作Mapper
* @createDate 2026-04-23 11:19:08
* @Entity .com.zkhj.roadside.user.TRoadBerth
*/
public interface RoadBerthMapper extends BaseMapper<RoadBerth> {
}
package com.zkhj.roadside.user.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zkhj.dto.roadside.road.req.QueryRoadInfo;
import com.zkhj.roadside.user.entity.RoadInfo;
import org.apache.ibatis.annotations.Param;
/**
* @author 罗俊
* @description 针对表【t_road_info(路段信息表)】的数据库操作Mapper
* @createDate 2026-04-23 09:11:45
* @Entity .com.zkhj.roadside.user.TRoadInfo
*/
public interface RoadInfoMapper extends BaseMapper<RoadInfo> {
/**
* 分页查询路段信息(支持模糊搜索路段编码或名称)
*
* @param page 分页对象
* @param query 查询条件
* @return 分页结果
*/
IPage<RoadInfo> selectRoadInfoPage(Page<RoadInfo> page, @Param("query") QueryRoadInfo query);
/**
* 统计路段数量(用于统计数据)
*
* @param query 查询条件
* @return 数量
*/
Long countRoadInfo(@Param("query") QueryRoadInfo query);
}
package com.zkhj.roadside.user.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.zkhj.roadside.user.entity.SysMenu;
import org.apache.ibatis.annotations.Param;
import java.util.List;
public interface SysMenuMapper extends BaseMapper<SysMenu> {
List<String> selectPermissionsByUsername(@Param("username") String username);
}
package com.zkhj.roadside.user.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.zkhj.roadside.user.entity.SysOrgType;
/**
* @author 罗俊
* @description 针对表【sys_org_type(机构信息表)】的数据库操作Mapper
* @createDate 2026-04-22 09:19:29
* @Entity .com.zkhj.roadside.user.SysOrgType
*/
public interface SysOrgTypeMapper extends BaseMapper<SysOrgType> {
}
package com.zkhj.roadside.user.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.zkhj.roadside.user.entity.SysOrganization;
/**
* @author 罗俊
* @description 针对表【sys_organization(机构表)】的数据库操作Mapper
* @createDate 2026-04-21 10:46:02
* @Entity generator.enity.SysOrganization
*/
public interface SysOrganizationMapper extends BaseMapper<SysOrganization> {
}
package com.zkhj.roadside.user.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.zkhj.roadside.user.entity.SysRegion;
/**
* @author 罗俊
* @description 针对表【sys_region(区域表)】的数据库操作Mapper
* @createDate 2026-04-22 13:36:01
* @Entity .com.zkhj.roadside.user.SysRegion
*/
public interface SysRegionMapper extends BaseMapper<SysRegion> {
}
package com.zkhj.roadside.user.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.zkhj.roadside.user.entity.SysRole;
public interface SysRoleMapper extends BaseMapper<SysRole> {
}
package com.zkhj.roadside.user.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.zkhj.roadside.user.entity.SysRoleMenu;
public interface SysRoleMenuMapper extends BaseMapper<SysRoleMenu> {
}
package com.zkhj.roadside.user.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.zkhj.roadside.user.entity.SysUser;
public interface SysUserMapper extends BaseMapper<SysUser> {
}
package com.zkhj.roadside.user.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.zkhj.roadside.user.entity.SysUserRole;
public interface SysUserRoleMapper extends BaseMapper<SysUserRole> {
}
package com.zkhj.roadside.user.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.zkhj.dto.core.http.ResultHttp;
import com.zkhj.dto.roadside.berth.req.AddUpdateRoadBerth;
import com.zkhj.dto.roadside.berth.req.QueryRoadBerth;
import com.zkhj.dto.roadside.berth.resp.PageRoadBerthDTO;
import com.zkhj.dto.roadside.berth.resp.RoadBerthStaticDTO;
import com.zkhj.roadside.user.entity.RoadBerth;
import java.util.List;
/**
* @author 罗俊
* @description 针对表【t_road_berth】的数据库操作Service
* @createDate 2026-04-23 11:19:08
*/
public interface RoadBerthService extends IService<RoadBerth> {
ResultHttp<?> createBerth(AddUpdateRoadBerth addBerthInfo);
ResultHttp<?> updateBerth(AddUpdateRoadBerth updateBerthInfo);
ResultHttp<List<PageRoadBerthDTO>> queryPage(QueryRoadBerth queryRoadBerth);
ResultHttp<?> delete(Integer id);
ResultHttp<RoadBerthStaticDTO> staticData(QueryRoadBerth queryRoadBerth);
}
package com.zkhj.roadside.user.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.zkhj.dto.core.http.ResultHttp;
import com.zkhj.dto.roadside.road.req.AddUpdateRoadInfo;
import com.zkhj.dto.roadside.road.req.QueryRoadInfo;
import com.zkhj.dto.roadside.road.resp.PageRoadInfoDTO;
import com.zkhj.dto.roadside.road.resp.RoadInfoStaticDTO;
import com.zkhj.roadside.user.entity.RoadInfo;
import java.util.List;
/**
* @author 罗俊
* @description 针对表【t_road_info(路段信息表)】的数据库操作Service
* @createDate 2026-04-23 09:11:45
*/
public interface RoadInfoService extends IService<RoadInfo> {
ResultHttp<?> createRoad(AddUpdateRoadInfo addUpdateRoadInfo);
ResultHttp<?> updateRoad(AddUpdateRoadInfo updateRoadInfo);
ResultHttp<List<PageRoadInfoDTO>> queryPage(QueryRoadInfo queryRoadInfo);
ResultHttp<?> delete(Integer id);
ResultHttp<RoadInfoStaticDTO> staticData(QueryRoadInfo queryRoadInfo);
}
package com.zkhj.roadside.user.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.zkhj.roadside.user.entity.SysMenu;
public interface SysMenuService extends IService<SysMenu> {
}
package com.zkhj.roadside.user.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.zkhj.roadside.user.entity.SysOrgType;
/**
* @author 罗俊
* @description 针对表【sys_org_type(机构信息表)】的数据库操作Service
* @createDate 2026-04-22 09:19:29
*/
public interface SysOrgTypeService extends IService<SysOrgType> {
}
package com.zkhj.roadside.user.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.zkhj.dto.core.http.ResultHttp;
import com.zkhj.dto.roadside.sys.org.req.AddSysOrganization;
import com.zkhj.dto.roadside.sys.org.req.QuerySysOrganization;
import com.zkhj.dto.roadside.sys.org.req.UpdateSysOrganization;
import com.zkhj.dto.roadside.sys.org.resp.SysOrganizationStaticDTO;
import com.zkhj.roadside.user.entity.SysOrganization;
import java.util.Collection;
/**
* @author 罗俊
* @description 针对表【sys_organization(机构表)】的数据库操作Service
* @createDate 2026-04-21 10:46:02
*/
public interface SysOrganizationService extends IService<SysOrganization> {
/**
* 新增
* @param addSysOrganization 新增所用的参数
* @return true 成功 false 失败
*/
ResultHttp<?> createOrg(AddSysOrganization addSysOrganization);
/**
* 修改
* @param updateSysOrganization 修改所用参数
* @return true 成功 false 失败
*/
ResultHttp<?> updateOrg(UpdateSysOrganization updateSysOrganization);
/**
* 机构页面静态数据
* @return 返回静态数据
*/
ResultHttp<SysOrganizationStaticDTO> staticData();
/**
* 分页查询
* @param organization 查询条件
* @return 分页条件
*/
ResultHttp<?> queryList(QuerySysOrganization organization);
/**
* 删除
* @param id 主键
* @return 返回值
*/
ResultHttp<?> deleteOrg(Long id);
}
package com.zkhj.roadside.user.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.zkhj.dto.core.http.ResultHttp;
import com.zkhj.dto.roadside.sys.region.req.AddSysRegion;
import com.zkhj.dto.roadside.sys.region.req.QuerySysRegion;
import com.zkhj.dto.roadside.sys.region.req.UpdateSysRegion;
import com.zkhj.dto.roadside.sys.region.resp.ListSysRegionDTO;
import com.zkhj.dto.roadside.sys.region.resp.SysRegionStaticDTO;
import com.zkhj.roadside.user.entity.SysRegion;
import java.util.List;
/**
* @author 罗俊
* @description 针对表【sys_region(区域表)】的数据库操作Service
* @createDate 2026-04-22 13:36:01
*/
public interface SysRegionService extends IService<SysRegion> {
/**
* 新增
* @param addSysRegion 新增区域
* @return 返回
*/
ResultHttp<?> createRegion(AddSysRegion addSysRegion);
/**
* 修改
* @param updateSysRegion 修改区域数据
* @return 返回结果
*/
ResultHttp<?> updateRegion(UpdateSysRegion updateSysRegion);
/**
* 删除区域
* @param id 区域id
* @return 结果
*/
ResultHttp<?> delete(Integer id);
/**
* 统计数据
* @return 返回值
*/
ResultHttp<SysRegionStaticDTO> staticData();
/**
* 修改区域状态
* @param id 主键
* @param status 状态
* @return
*/
ResultHttp<Void> updateStatus(Integer id, Integer status);
/**
* 查询列表
* @param querySysRegion 查询参数
* @return 返回值
*/
ResultHttp<List<ListSysRegionDTO>> queryList(QuerySysRegion querySysRegion);
}
package com.zkhj.roadside.user.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.zkhj.roadside.user.entity.SysRoleMenu;
public interface SysRoleMenuService extends IService<SysRoleMenu> {
}
package com.zkhj.roadside.user.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.zkhj.roadside.user.entity.SysRole;
public interface SysRoleService extends IService<SysRole> {
}
package com.zkhj.roadside.user.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.zkhj.roadside.user.entity.SysUserRole;
public interface SysUserRoleService extends IService<SysUserRole> {
}
package com.zkhj.roadside.user.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.zkhj.roadside.user.entity.SysUser;
import java.util.List;
public interface SysUserService extends IService<SysUser> {
String doLogin(String userName, String password);
List<String> getPermissionList(String username);
}
package com.zkhj.roadside.user.service.business;
import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.zkhj.core.common.BaseCrudUtil;
import com.zkhj.dto.roadside.berth.req.CommonQueryBerth;
import com.zkhj.roadside.user.entity.RoadBerth;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@Component
public class RoadBerthToolService {
public LambdaQueryWrapper<RoadBerth> queryWrapper(CommonQueryBerth query) {
LambdaQueryWrapper<RoadBerth> queryChainWrapper = new LambdaQueryWrapper<>(RoadBerth.class);
queryChainWrapper.eq(query.getRoadId()!=null,RoadBerth::getRoadId, query.getRoadId());
return queryChainWrapper;
}
/**
* 获取每个路段的泊位总数(按路段ID分组统计)
* @return Map<路段ID, 泊位数量>
*/
public Map<Integer, Long> getRoadTotalCount() {
// 使用原生SQL进行分组统计,返回路段ID和对应的泊位数量
QueryWrapper<RoadBerth> roadBerthQueryWrapper = new QueryWrapper<>(RoadBerth.class)
.select("road_id", "COUNT(*) as count")
.groupBy("road_id");
List<Map<String, Object>> maps = BaseCrudUtil.listMap(roadBerthQueryWrapper, RoadBerth.class);
// 转换为 Map<Integer, Long> 格式
if (CollUtil.isEmpty(maps)) {
return Map.of();
}
return maps.stream()
.collect(Collectors.toMap(
map -> ((Number) map.get("road_id")).intValue(),
map -> ((Number) map.get("count")).longValue()
));
}
}
package com.zkhj.roadside.user.service.business;
import com.zkhj.core.common.BaseCrudUtil;
import com.zkhj.roadside.user.entity.RoadInfo;
import org.springframework.stereotype.Component;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@Component
public class RoadInfoToolService {
public Map<Integer, RoadInfo> getRoadInfoMap(){
List<RoadInfo> list = BaseCrudUtil.list(null, RoadInfo.class);
return list == null || list.isEmpty() ?
Collections.emptyMap() :
list.stream().collect(Collectors.toMap(RoadInfo::getId, roadInfo -> roadInfo));
}
}
package com.zkhj.roadside.user.service.business;
import cn.hutool.core.bean.BeanUtil;
import com.zkhj.dto.roadside.sys.org.req.QuerySysOrganization;
import com.zkhj.dto.roadside.sys.org.resp.ListSysOrganizationDTO;
import com.zkhj.roadside.user.entity.SysOrganization;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
@Component
public class SysOrganizationToolService {
/**
* 递归获取子机构
* @param parentId 父机构ID
* @param currentLevel 当前层级
* @param sysOrganizationList 所有机构列表
* @param orgTypeMap 机构类型Map(id -> name)
* @return 子机构列表
*/
public List<ListSysOrganizationDTO> getChildrenOrganizations(Long parentId, Integer currentLevel,
List<SysOrganization> sysOrganizationList,
Map<Integer, String> orgTypeMap) {
List<SysOrganization> children = sysOrganizationList.stream()
.filter(item -> item.getParentId().equals(parentId))
.toList();
if (children.isEmpty()) {
return Collections.emptyList();
}
int nextLevel = currentLevel + 1;
List<ListSysOrganizationDTO> childList = BeanUtil.copyToList(children, ListSysOrganizationDTO.class);
childList.forEach(child -> {
child.setLevel(nextLevel);
child.setTotalParkNum(0);
String orgTypeName = orgTypeMap != null && orgTypeMap.containsKey(child.getOrgType())
? orgTypeMap.get(child.getOrgType())
: "未知";
child.setOrgTypeName(orgTypeName);
List<ListSysOrganizationDTO> grandChildren = getChildrenOrganizations(
child.getId(),
nextLevel,
sysOrganizationList,
orgTypeMap
);
if (!grandChildren.isEmpty()) {
child.setChildList(grandChildren);
}
});
return childList;
}
/**
* 从叶子节点向上过滤,移除不满足条件的节点及其子节点
* @param nodeList 节点列表
* @param queryCondition 查询条件
* @return 过滤后的节点列表
*/
public List<ListSysOrganizationDTO> filterInvalidNodes(List<ListSysOrganizationDTO> nodeList, QuerySysOrganization queryCondition) {
if (nodeList == null || nodeList.isEmpty()) return nodeList;
List<ListSysOrganizationDTO> result = new ArrayList<>();
for (ListSysOrganizationDTO node : nodeList) {
ListSysOrganizationDTO filteredNode = filterNode(node, queryCondition);
if (filteredNode != null) {
result.add(filteredNode);
}
}
return result;
}
/**
* 递归过滤树节点
* 逻辑:先递归子节点,只要子节点有保留的,当前节点就保留(作为路径);
* 如果子节点都没了,再看自己是否符合条件。
*/
private ListSysOrganizationDTO filterNode(ListSysOrganizationDTO node, QuerySysOrganization queryCondition) {
if (node == null) return null;
// 1. 【先递归处理子节点】
if (node.getChildList() != null && !node.getChildList().isEmpty()) {
List<ListSysOrganizationDTO> filteredChildren = new ArrayList<>();
for (ListSysOrganizationDTO child : node.getChildList()) {
// 递归调用,获取过滤后的子节点
ListSysOrganizationDTO filteredChild = filterNode(child, queryCondition);
if (filteredChild != null) {
filteredChildren.add(filteredChild);
}
}
// 将过滤后的子节点列表重新设置回去
node.setChildList(filteredChildren);
}
// 2. 【关键判断】:检查过滤后是否还有有效子节点
boolean hasValidChildren = node.getChildList() != null && !node.getChildList().isEmpty();
// 3. 【保留策略】
// 情况A:如果有有效子节点 -> 说明子孙里有匹配的,当前节点必须保留(作为路径),直接返回!
// 注意:这里不需要管当前节点自己是否匹配,因为它承载了路径功能
if (hasValidChildren) return node;
// 情况B:如果没有子节点(变成了叶子节点) -> 只有当自身满足条件时才保留
// 如果自身也不满足,返回 null(被父节点过滤掉)
boolean selfMatch = checkNodeValid(node, queryCondition);
return selfMatch ? node : null;
}
private boolean checkNodeValid(ListSysOrganizationDTO node, QuerySysOrganization queryCondition) {
if (queryCondition == null) return true;
// AND 逻辑:所有不为空的条件都必须满足
if (StringUtils.isNotBlank(queryCondition.getOrgCode())) {
if (!node.getOrgName().contains(queryCondition.getOrgCode()) && queryCondition.getOrgType() != 0) {
return false;
}
}
if (queryCondition.getOrgType() != null) {
if (!queryCondition.getOrgType().equals(node.getOrgType()) && queryCondition.getOrgType() != 0) {
return false;
}
}
if (queryCondition.getStatus() != null) {
if (!queryCondition.getStatus().equals(node.getStatus()) && queryCondition.getStatus() != -1) {
return false;
}
}
return true;
}
}
package com.zkhj.roadside.user.service.business;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zkhj.core.common.BaseCrudUtil;
import com.zkhj.dto.roadside.sys.region.req.QuerySysRegion;
import com.zkhj.dto.roadside.sys.region.req.UpdateSysRegion;
import com.zkhj.dto.roadside.sys.region.resp.ListSysRegionDTO;
import com.zkhj.roadside.user.entity.SysOrganization;
import com.zkhj.roadside.user.entity.SysRegion;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
@Component
public class SysRegionToolService {
/**
* 批量保存子区域
* @param parent 父区域
* @param childRegionNames 子区域名称列表
*/
public Set<SysRegion> buildChildRegions(SysRegion parent, Set<String> childRegionNames) {
if (childRegionNames == null || childRegionNames.isEmpty()) {
return Collections.emptySet();
}
AtomicInteger sortCounter = new AtomicInteger(0);
return childRegionNames.stream()
.map(regionName -> {
SysRegion child = BeanUtil.copyProperties(parent, SysRegion.class);
child.setId(null);
child.setParentId(parent.getId());
child.setRegionType(2);
child.setRegionName(regionName);
child.setSort(sortCounter.getAndIncrement());
return child;
})
.collect(Collectors.toSet());
}
/**
* 获取区域Map
* @return 区域map
*/
public Map<Integer, SysRegion> getRegionMap(){
List<SysRegion> list = BaseCrudUtil.list(null, SysRegion.class);
return list == null || list.isEmpty() ?
Collections.emptyMap() :
list.stream().collect(Collectors.toMap(SysRegion::getId, region -> region));
}
/**
* 构建区域树形结构
* @param allRegions 所有区域DTO列表
* @param sysOrgList 机构列表
* @return 树形结构(只包含根节点)
*/
public List<ListSysRegionDTO> buildRegionTree(List<ListSysRegionDTO> allRegions, List<SysOrganization> sysOrgList) {
// 构建机构ID到机构名称的映射
Map<Long, String> orgNameMap = sysOrgList.stream()
.collect(Collectors.toMap(SysOrganization::getId, SysOrganization::getOrgName, (k1, k2) -> k1));
// 构建区域ID到区域的映射(用于查找父区域名称)
Map<Integer, ListSysRegionDTO> regionMap = allRegions.stream()
.collect(Collectors.toMap(ListSysRegionDTO::getId, r -> r, (k1, k2) -> k1));
// 填充机构名称和父区域名称
for (ListSysRegionDTO region : allRegions) {
// 填充机构名称
if (region.getOrgId() != null) {
region.setOrgName(orgNameMap.getOrDefault(region.getOrgId(), "未知机构"));
}
// parentId 已经有值,不需要额外填充
// 填充父区域名称
if (region.getParentId() != null && region.getParentId() != 0) {
ListSysRegionDTO parentRegion = regionMap.get(region.getParentId());
if (parentRegion != null) {
region.setParentName(parentRegion.getRegionName());
}
}
}
Map<Integer, List<ListSysRegionDTO>> parentMap = allRegions.stream()
.filter(r -> r.getParentId() != null)
.collect(Collectors.groupingBy(ListSysRegionDTO::getParentId));
List<ListSysRegionDTO> rootNodes = new ArrayList<>();
for (ListSysRegionDTO region : allRegions) {
Integer parentId = region.getParentId();
// 根节点:parentId 为 null 或 0
if (parentId == null || parentId == 0) {
List<ListSysRegionDTO> children = parentMap.getOrDefault(region.getId(), Collections.emptyList());
if (!children.isEmpty()) {
region.setChildList(children);
}
rootNodes.add(region);
}
}
return rootNodes;
}
/**
* 过滤区域树(自底向上,保留满足条件的节点及其父路径)
* @param tree 区域树
* @param queryCondition 查询条件
* @return 过滤后的树
*/
public List<ListSysRegionDTO> filterRegionTree(List<ListSysRegionDTO> tree, QuerySysRegion queryCondition) {
if (tree == null || tree.isEmpty()) {
return tree;
}
List<ListSysRegionDTO> result = new ArrayList<>();
for (ListSysRegionDTO node : tree) {
ListSysRegionDTO filteredNode = filterRegionNode(node, queryCondition);
if (filteredNode != null) {
result.add(filteredNode);
}
}
return result;
}
/**
* 递归过滤单个区域节点
* @param node 当前节点
* @param queryCondition 查询条件
* @return 如果节点有效返回节点,否则返回null
*/
private ListSysRegionDTO filterRegionNode(ListSysRegionDTO node, QuerySysRegion queryCondition) {
if (node == null) {
return null;
}
boolean originallyHasChildren = node.getChildList() != null && !node.getChildList().isEmpty();
// 先递归处理子节点
if (originallyHasChildren) {
List<ListSysRegionDTO> filteredChildren = new ArrayList<>();
for (ListSysRegionDTO child : node.getChildList()) {
ListSysRegionDTO filteredChild = filterRegionNode(child, queryCondition);
if (filteredChild != null) {
filteredChildren.add(filteredChild);
}
}
node.setChildList(filteredChildren);
}
// 重新判断是否有有效子节点
boolean hasValidChildren = node.getChildList() != null && !node.getChildList().isEmpty();
// 判断当前节点本身是否满足查询条件
boolean currentNodeMatch = checkRegionValid(node, queryCondition);
// 保留条件:
// 1. 如果有有效子节点 → 说明子孙中有匹配的,保留作为路径
// 2. 如果原本就没有子节点(真正的叶子节点)→ 必须自身匹配才保留
if (hasValidChildren) {
return node;
}
if (currentNodeMatch) {
return node;
}
return null;
}
/**
* 检查区域节点是否满足查询条件(AND 逻辑:所有条件都要满足)
* @param node 节点
* @param queryCondition 查询条件
* @return 是否有效
*/
private boolean checkRegionValid(ListSysRegionDTO node, QuerySysRegion queryCondition) {
if (queryCondition == null) {
return true;
}
// 校验机构ID
if (queryCondition.getOrgId() != null) {
if (!queryCondition.getOrgId().equals(node.getOrgId()) && queryCondition.getOrgId() != 0) {
return false;
}
}
// 校验区域类型
if (queryCondition.getRegionType() != null) {
if (!queryCondition.getRegionType().equals(node.getRegionType()) && queryCondition.getRegionType() != 0) {
return false;
}
}
// 校验状态
if (queryCondition.getStatus() != null) {
if (!queryCondition.getStatus().equals(node.getStatus()) && queryCondition.getStatus() != -1) {
return false;
}
}
// 区域名称状态
if (StringUtils.isNotBlank(queryCondition.getRegionName())) {
if (!queryCondition.getRegionName().contains(node.getRegionName())) {
return false;
}
}
// 所有条件都满足
return true;
}
/**
* 同步子区域(根据传入的最终状态自动计算增删)
* @param parent 父区域
* @param expectedChildNames 期望的子区域名称列表(最终状态)
*/
public void syncChildRegions(UpdateSysRegion parent, Set<String> expectedChildNames) {
if (expectedChildNames == null) {
return;
}
LambdaQueryWrapper<SysRegion> wrapper = new LambdaQueryWrapper<SysRegion>().eq(SysRegion::getParentId, parent.getId());
List<SysRegion> existingChildren =BaseCrudUtil.list(wrapper, SysRegion.class);
if (existingChildren == null || existingChildren.isEmpty()) return;
Set<String> existingNames = existingChildren.stream()
.map(SysRegion::getRegionName)
.collect(Collectors.toSet());
Set<String> toAdd = expectedChildNames.stream()
.filter(name -> !existingNames.contains(name))
.collect(Collectors.toSet());
Set<String> toDelete = existingNames.stream()
.filter(name -> !expectedChildNames.contains(name))
.collect(Collectors.toSet());
if (!toDelete.isEmpty()) {
List<Integer> idsToDelete = existingChildren.stream()
.filter(r -> toDelete.contains(r.getRegionName()))
.map(SysRegion::getId)
.collect(Collectors.toList());
if (!idsToDelete.isEmpty()) {
BaseCrudUtil.delete(idsToDelete, SysRegion.class);
}
}
if (!toAdd.isEmpty()) {
int maxSort = existingChildren.stream()
.mapToInt(SysRegion::getSort)
.max()
.orElse(0);
AtomicInteger sortCounter = new AtomicInteger(maxSort + 1);
List<SysRegion> toAddList = toAdd.stream()
.map(regionName -> {
SysRegion child = BeanUtil.copyProperties(parent, SysRegion.class);
child.setId(null);
child.setParentId(parent.getId());
child.setRegionType(2);
child.setRegionName(regionName);
child.setSort(sortCounter.getAndIncrement());
return child;
})
.collect(Collectors.toList());
if (!toAddList.isEmpty())
BaseCrudUtil.saveBatch(toAddList,SysRegion.class);
}
}
}
package com.zkhj.roadside.user.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.lang.Assert;
import com.alibaba.excel.util.StringUtils;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zkhj.dto.core.http.ResultHttp;
import com.zkhj.dto.roadside.berth.req.AddUpdateRoadBerth;
import com.zkhj.dto.roadside.berth.req.QueryRoadBerth;
import com.zkhj.dto.roadside.berth.resp.PageRoadBerthDTO;
import com.zkhj.dto.roadside.berth.resp.RoadBerthStaticDTO;
import com.zkhj.dto.roadside.util.Status;
import com.zkhj.roadside.user.entity.RoadBerth;
import com.zkhj.roadside.user.entity.RoadInfo;
import com.zkhj.roadside.user.mapper.RoadBerthMapper;
import com.zkhj.roadside.user.service.RoadBerthService;
import com.zkhj.roadside.user.service.business.RoadInfoToolService;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @author 罗俊
* @description 针对表【t_road_berth】的数据库操作Service实现
* @createDate 2026-04-23 11:19:08
*/
@Service
public class RoadBerthServiceImpl extends ServiceImpl<RoadBerthMapper, RoadBerth>
implements RoadBerthService {
@Resource private RoadInfoToolService roadInfoToolService;
@Override
public ResultHttp<?> createBerth(AddUpdateRoadBerth addBerthInfo) {
validate(addBerthInfo);
save( BeanUtil.copyProperties(addBerthInfo, RoadBerth.class));
return ResultHttp.success();
}
@Override
public ResultHttp<?> updateBerth(AddUpdateRoadBerth updateBerthInfo) {
RoadBerth roadBerth = getById(updateBerthInfo.getId());
Assert.notNull(roadBerth, "泊位不存在");
validate(updateBerthInfo);
updateById( BeanUtil.copyProperties(updateBerthInfo, RoadBerth.class));
return ResultHttp.success();
}
@Override
public ResultHttp<List<PageRoadBerthDTO>> queryPage(QueryRoadBerth queryRoadBerth) {
IPage<RoadBerth> roadBerthPage = new Page<>(queryRoadBerth.getPageNum(), queryRoadBerth.getPageSize());
List<String> createTimeList = queryRoadBerth.getCreateTime();
boolean hasCreateTime = createTimeList != null && createTimeList.size() == 2
&& createTimeList.getFirst() != null && createTimeList.getLast() != null;
LocalDateTime startTime = hasCreateTime ? LocalDateTime.parse(createTimeList.getFirst().replaceFirst(" ","T")): LocalDateTime.of(2026,4,24,0,0,0);
LocalDateTime endTime = hasCreateTime ? LocalDateTime.parse(createTimeList.getLast().replaceFirst(" ","T")) : LocalDateTime.now();
IPage<RoadBerth> page = lambdaQuery().eq(queryRoadBerth.getRoadId() != null, RoadBerth::getRoadId, queryRoadBerth.getRoadId())
.eq(queryRoadBerth.getBerthType() != null, RoadBerth::getBerthType, queryRoadBerth.getBerthType())
.eq(queryRoadBerth.getStatus() != null, RoadBerth::getStatus, queryRoadBerth.getStatus())
.eq(queryRoadBerth.getRuleId() != null, RoadBerth::getRuleId, queryRoadBerth.getRuleId())
.between(RoadBerth::getCreateTime,startTime,endTime)
.like(StringUtils.isNotBlank(queryRoadBerth.getBerthCode()),RoadBerth::getBerthCode, queryRoadBerth.getBerthCode())
.or(StringUtils.isNotBlank(queryRoadBerth.getBerthCode()) &&( queryRoadBerth.getStatus() != null || queryRoadBerth.getRoadId() != null || queryRoadBerth.getBerthType() !=null || (queryRoadBerth.getCreateTime() !=null && !queryRoadBerth.getCreateTime().isEmpty())),
i->i
.eq(queryRoadBerth.getRoadId() != null, RoadBerth::getRoadId, queryRoadBerth.getRoadId())
.eq(queryRoadBerth.getBerthType() != null, RoadBerth::getBerthType, queryRoadBerth.getBerthType())
.eq(queryRoadBerth.getStatus() != null, RoadBerth::getStatus, queryRoadBerth.getStatus())
.eq(queryRoadBerth.getRuleId() != null, RoadBerth::getRuleId, queryRoadBerth.getRuleId())
.between(RoadBerth::getCreateTime,startTime,endTime)
.like(StringUtils.isNotBlank(queryRoadBerth.getBerthCode()), RoadBerth::getBerthName, queryRoadBerth.getBerthCode())
)
.page(roadBerthPage);
Map<Integer, RoadInfo> roadInfoMap = roadInfoToolService.getRoadInfoMap();
List<PageRoadBerthDTO> pageRoadBerthDTOList = page.getRecords().stream().map(i -> {
PageRoadBerthDTO pageRoadBerthDTO = BeanUtil.copyProperties(i, PageRoadBerthDTO.class);
pageRoadBerthDTO.setRoadName(roadInfoMap.getOrDefault(i.getRoadId(),new RoadInfo()).getRoadName());
pageRoadBerthDTO.setRuleName("标准收费");
return pageRoadBerthDTO;
}).collect(Collectors.toList());
return ResultHttp.successPage((int) page.getCurrent(), (int) page.getSize(), page.getTotal(), page.getPages(), pageRoadBerthDTOList);
}
@Override
public ResultHttp<?> delete(Integer id) {
removeById(id);
return ResultHttp.success();
}
@Override
public ResultHttp<RoadBerthStaticDTO> staticData(QueryRoadBerth queryRoadBerth) {
List<String> createTimeList = queryRoadBerth.getCreateTime();
boolean hasCreateTime = createTimeList != null && createTimeList.size() == 2
&& createTimeList.getFirst() != null && createTimeList.getLast() != null;
LocalDateTime startTime = hasCreateTime ? LocalDateTime.parse(createTimeList.getFirst().replaceFirst(" ","T")): LocalDateTime.of(2026,4,24,0,0,0);
LocalDateTime endTime = hasCreateTime ? LocalDateTime.parse(createTimeList.getLast().replaceFirst(" ","T")) : LocalDateTime.now();
RoadBerthStaticDTO roadBerthStaticDTO = new RoadBerthStaticDTO();
roadBerthStaticDTO.setTotalNum(lambdaQuery().eq(queryRoadBerth.getRoadId() != null, RoadBerth::getRoadId, queryRoadBerth.getRoadId())
.eq(queryRoadBerth.getBerthType() != null, RoadBerth::getBerthType, queryRoadBerth.getBerthType())
.eq(queryRoadBerth.getRuleId() != null, RoadBerth::getRuleId, queryRoadBerth.getRuleId())
.between(RoadBerth::getCreateTime,startTime,endTime)
.like(StringUtils.isNotBlank(queryRoadBerth.getBerthCode()), RoadBerth::getBerthCode, queryRoadBerth.getBerthCode())
.or(StringUtils.isNotBlank(queryRoadBerth.getBerthCode()) &&( queryRoadBerth.getStatus() != null || queryRoadBerth.getRoadId() != null || queryRoadBerth.getBerthType() !=null || (queryRoadBerth.getCreateTime() !=null && !queryRoadBerth.getCreateTime().isEmpty())),
i->i
.eq(queryRoadBerth.getRoadId() != null, RoadBerth::getRoadId, queryRoadBerth.getRoadId())
.eq(queryRoadBerth.getBerthType() != null, RoadBerth::getBerthType, queryRoadBerth.getBerthType())
.eq(queryRoadBerth.getRuleId() != null, RoadBerth::getRuleId, queryRoadBerth.getRuleId())
.between(RoadBerth::getCreateTime,startTime,endTime)
.like(StringUtils.isNotBlank(queryRoadBerth.getBerthCode()), RoadBerth::getBerthName, queryRoadBerth.getBerthCode())
).count());
roadBerthStaticDTO.setEnableNum(lambdaQuery().eq(queryRoadBerth.getRoadId() != null, RoadBerth::getRoadId, queryRoadBerth.getRoadId())
.eq(queryRoadBerth.getBerthType() != null, RoadBerth::getBerthType, queryRoadBerth.getBerthType())
.eq( RoadBerth::getStatus, Status.ENABLED.getCode())
.eq(queryRoadBerth.getRuleId() != null, RoadBerth::getRuleId, queryRoadBerth.getRuleId())
.between(RoadBerth::getCreateTime,startTime,endTime)
.like(StringUtils.isNotBlank(queryRoadBerth.getBerthCode()), RoadBerth::getBerthCode, queryRoadBerth.getBerthCode())
.or(StringUtils.isNotBlank(queryRoadBerth.getBerthCode()) &&( queryRoadBerth.getStatus() != null || queryRoadBerth.getRoadId() != null || queryRoadBerth.getBerthType() !=null || (queryRoadBerth.getCreateTime() !=null && !queryRoadBerth.getCreateTime().isEmpty())),
i->i
.eq(queryRoadBerth.getRoadId() != null, RoadBerth::getRoadId, queryRoadBerth.getRoadId())
.eq(queryRoadBerth.getBerthType() != null, RoadBerth::getBerthType, queryRoadBerth.getBerthType())
.eq( RoadBerth::getStatus, Status.ENABLED.getCode())
.eq(queryRoadBerth.getRuleId() != null, RoadBerth::getRuleId, queryRoadBerth.getRuleId())
.between(RoadBerth::getCreateTime,startTime,endTime)
.like(StringUtils.isNotBlank(queryRoadBerth.getBerthCode()), RoadBerth::getBerthName, queryRoadBerth.getBerthCode())
).count());
roadBerthStaticDTO.setDisableNum(lambdaQuery().eq(queryRoadBerth.getRoadId() != null, RoadBerth::getRoadId, queryRoadBerth.getRoadId())
.eq(queryRoadBerth.getBerthType() != null, RoadBerth::getBerthType, queryRoadBerth.getBerthType())
.eq( RoadBerth::getStatus, Status.DISABLED.getCode())
.eq(queryRoadBerth.getRuleId() != null, RoadBerth::getRuleId, queryRoadBerth.getRuleId())
.between(RoadBerth::getCreateTime,startTime,endTime)
.like(StringUtils.isNotBlank(queryRoadBerth.getBerthCode()), RoadBerth::getBerthCode, queryRoadBerth.getBerthCode())
.or(StringUtils.isNotBlank(queryRoadBerth.getBerthCode()) &&( queryRoadBerth.getStatus() != null || queryRoadBerth.getRoadId() != null || queryRoadBerth.getBerthType() !=null || (queryRoadBerth.getCreateTime() !=null && !queryRoadBerth.getCreateTime().isEmpty())),
i->i
.eq(queryRoadBerth.getRoadId() != null, RoadBerth::getRoadId, queryRoadBerth.getRoadId())
.eq(queryRoadBerth.getBerthType() != null, RoadBerth::getBerthType, queryRoadBerth.getBerthType())
.eq( RoadBerth::getStatus, Status.DISABLED.getCode())
.eq(queryRoadBerth.getRuleId() != null, RoadBerth::getRuleId, queryRoadBerth.getRuleId())
.between(RoadBerth::getCreateTime,startTime,endTime)
.like(StringUtils.isNotBlank(queryRoadBerth.getBerthCode()), RoadBerth::getBerthName, queryRoadBerth.getBerthCode())
).count());
return ResultHttp.success(roadBerthStaticDTO);
}
public void validate(AddUpdateRoadBerth addUpdateRoadBerth){
Long count = lambdaQuery().eq(RoadBerth::getBerthCode, addUpdateRoadBerth.getBerthCode())
.ne(addUpdateRoadBerth.getId()!=null,RoadBerth::getId, addUpdateRoadBerth.getId()).count();
Assert.isTrue(count<=0, "泊位编码已存在");
Long berthNameCount = lambdaQuery().eq(RoadBerth::getBerthName, addUpdateRoadBerth.getBerthName())
.ne(addUpdateRoadBerth.getId()!=null,RoadBerth::getId, addUpdateRoadBerth.getId())
.eq(RoadBerth::getRoadId, addUpdateRoadBerth.getRoadId()).count();
Assert.isTrue(berthNameCount<=0, "泊位号牌已存在");
}
}
package com.zkhj.roadside.user.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.lang.Assert;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zkhj.core.common.BaseCrudUtil;
import com.zkhj.dto.core.http.ResultHttp;
import com.zkhj.dto.roadside.berth.req.CommonQueryBerth;
import com.zkhj.dto.roadside.road.req.AddUpdateRoadInfo;
import com.zkhj.dto.roadside.road.req.QueryRoadInfo;
import com.zkhj.dto.roadside.road.resp.PageRoadInfoDTO;
import com.zkhj.dto.roadside.road.resp.RoadInfoStaticDTO;
import com.zkhj.dto.roadside.util.Status;
import com.zkhj.roadside.user.entity.RoadBerth;
import com.zkhj.roadside.user.entity.RoadInfo;
import com.zkhj.roadside.user.entity.SysRegion;
import com.zkhj.roadside.user.mapper.RoadInfoMapper;
import com.zkhj.roadside.user.service.RoadInfoService;
import com.zkhj.roadside.user.service.business.RoadBerthToolService;
import com.zkhj.roadside.user.service.business.SysRegionToolService;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @author 罗俊
* @description 针对表【t_road_info(路段信息表)】的数据库操作Service实现
* @createDate 2026-04-23 09:11:45
*/
@Service
public class RoadInfoServiceImpl extends ServiceImpl<RoadInfoMapper, RoadInfo>
implements RoadInfoService {
@Resource private RoadBerthToolService roadBerthToolService;
@Resource private SysRegionToolService sysRegionToolService;
@Override
public ResultHttp<?> createRoad(AddUpdateRoadInfo addRoadInfo) {
Long count = lambdaQuery().eq(RoadInfo::getRoadCode, addRoadInfo.getRoadCode()).count();
Assert.isTrue(count<=0, "路段编码已存在");
save( BeanUtil.copyProperties(addRoadInfo, RoadInfo.class));
return ResultHttp.success();
}
@Override
public ResultHttp<?> updateRoad(AddUpdateRoadInfo updateRoadInfo) {
RoadInfo roadInfo = getById(updateRoadInfo.getId());
Assert.notNull(roadInfo, "路段数据不存在");
Long count = lambdaQuery().eq(RoadInfo::getRoadCode, updateRoadInfo.getRoadCode())
.ne(RoadInfo::getId,updateRoadInfo.getId()).count();
Assert.isTrue(count<=0,"路段编码已存在");
updateById(BeanUtil.copyProperties(updateRoadInfo, RoadInfo.class));
return ResultHttp.success();
}
@Override
public ResultHttp<List<PageRoadInfoDTO>> queryPage(QueryRoadInfo queryRoadInfo) {
Page<RoadInfo> page = new Page<>(queryRoadInfo.getPageNum(), queryRoadInfo.getPageSize());
// 使用 XML 方式查询
IPage<RoadInfo> resultPage = getBaseMapper().selectRoadInfoPage(page, queryRoadInfo);
//区域map
Map<Integer, SysRegion> regionMap = sysRegionToolService.getRegionMap();
//路段总泊位数map
Map<Integer, Long> roadTotalCountMap = roadBerthToolService.getRoadTotalCount();
List<PageRoadInfoDTO> result = resultPage.getRecords().stream().map(i -> {
PageRoadInfoDTO roadInfoDTO = BeanUtil.copyProperties(i, PageRoadInfoDTO.class);
roadInfoDTO.setBerthNum(roadTotalCountMap.getOrDefault(i.getId(), 0L));
roadInfoDTO.setRegionName(regionMap.getOrDefault(i.getRegionId(), new SysRegion()).getRegionName());
return roadInfoDTO;
}).collect(Collectors.toList());
return ResultHttp.successPage((int) resultPage.getCurrent(), (int) resultPage.getSize(), resultPage.getTotal(), resultPage.getPages(), result);
}
@Override
public ResultHttp<?> delete(Integer id) {
CommonQueryBerth queryBerth = CommonQueryBerth.builder().roadId(id).build();
Long count = BaseCrudUtil.count(roadBerthToolService.queryWrapper(queryBerth), RoadBerth.class);
Assert.isTrue(count<=0, "路段下有泊位数据,请先删除泊位数据");
removeById(id);
return ResultHttp.success();
}
@Override
public ResultHttp<RoadInfoStaticDTO> staticData(QueryRoadInfo queryRoadInfo) {
// 使用 XML 方式统计
Long totalNum = getBaseMapper().countRoadInfo(queryRoadInfo);
// 统计启用数量:需要单独构建查询条件
QueryRoadInfo enabledQuery = new QueryRoadInfo();
enabledQuery.setRoadCode(queryRoadInfo.getRoadCode());
enabledQuery.setRegionId(queryRoadInfo.getRegionId());
enabledQuery.setStatus(Status.ENABLED.getCode());
Long enableNum = getBaseMapper().countRoadInfo(enabledQuery);
RoadInfoStaticDTO staticDTO = new RoadInfoStaticDTO();
staticDTO.setTotalNum(totalNum.intValue());
staticDTO.setEnableNum(enableNum.intValue());
staticDTO.setTotalBerthNum(0);
return ResultHttp.success(staticDTO);
}
}
package com.zkhj.roadside.user.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zkhj.roadside.user.entity.SysMenu;
import com.zkhj.roadside.user.mapper.SysMenuMapper;
import com.zkhj.roadside.user.service.SysMenuService;
import org.springframework.stereotype.Service;
@Service
public class SysMenuServiceImpl extends ServiceImpl<SysMenuMapper, SysMenu> implements SysMenuService {
}
package com.zkhj.roadside.user.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zkhj.roadside.user.entity.SysOrgType;
import com.zkhj.roadside.user.mapper.SysOrgTypeMapper;
import com.zkhj.roadside.user.service.SysOrgTypeService;
import org.springframework.stereotype.Service;
/**
* @author 罗俊
* @description 针对表【sys_org_type(机构信息表)】的数据库操作Service实现
* @createDate 2026-04-22 09:19:29
*/
@Service
public class SysOrgTypeServiceImpl extends ServiceImpl<SysOrgTypeMapper, SysOrgType>
implements SysOrgTypeService {
}
package com.zkhj.roadside.user.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.lang.Assert;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zkhj.core.common.BaseCrudUtil;
import com.zkhj.dto.core.http.ResultHttp;
import com.zkhj.dto.roadside.sys.org.req.AddSysOrganization;
import com.zkhj.dto.roadside.sys.org.req.BaseSysOrganization;
import com.zkhj.dto.roadside.sys.org.req.QuerySysOrganization;
import com.zkhj.dto.roadside.sys.org.req.UpdateSysOrganization;
import com.zkhj.dto.roadside.sys.org.resp.ListSysOrganizationDTO;
import com.zkhj.dto.roadside.sys.org.resp.SysOrganizationStaticDTO;
import com.zkhj.roadside.user.entity.SysOrgType;
import com.zkhj.roadside.user.entity.SysOrganization;
import com.zkhj.roadside.user.mapper.SysOrganizationMapper;
import com.zkhj.roadside.user.service.SysOrganizationService;
import com.zkhj.roadside.user.service.business.SysOrganizationToolService;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import java.util.stream.Collectors;
import static java.util.stream.Collectors.toMap;
/**
* @author 罗俊
*/
@Service
public class SysOrganizationServiceImpl extends ServiceImpl<SysOrganizationMapper, SysOrganization>
implements SysOrganizationService {
@Resource private SysOrganizationToolService sysOrganizationToolService;
@Transactional
@Override
public ResultHttp<?> createOrg(AddSysOrganization addSysOrganization) {
//1.基础校验
validateOrg(addSysOrganization);
//2.转换
SysOrganization sysOrganization = BeanUtil.copyProperties(addSysOrganization, SysOrganization.class);
//3.创建组织
save(sysOrganization);
//todo:账号同步(等多数据源完成)
return ResultHttp.success();
}
@Override
public ResultHttp<?> updateOrg(UpdateSysOrganization updateSysOrganization) {
//1.基础校验
SysOrganization rawData = getById(updateSysOrganization.getId());
Assert.notNull(rawData, "组织数据不存在");
validateOrg(updateSysOrganization);
//2.转换
SysOrganization sysOrganization = BeanUtil.copyProperties(updateSysOrganization, SysOrganization.class);
//3.创建组织
updateById(sysOrganization);
return ResultHttp.success();
}
@Override
public ResultHttp<SysOrganizationStaticDTO> staticData() {
List<SysOrganization> list = lambdaQuery().list();
SysOrganizationStaticDTO staticDTO = new SysOrganizationStaticDTO();
staticDTO.setOrgNum(list.size());
staticDTO.setEnableOrgNum((int) list.stream().filter(item -> item.getStatus() == 1).count());
staticDTO.setDisableOrgNum((int) list.stream().filter(item -> item.getStatus() == 0).count());
//todo:待补充总车场数
staticDTO.setTotalParkNum(0);
return ResultHttp.success(staticDTO);
}
@Override
public ResultHttp<?> queryList(QuerySysOrganization organization) {
//父级机构
List<SysOrganization> allSysOrg = lambdaQuery().list();
//组织机构
List<SysOrgType> sysOrgTypeList = BaseCrudUtil.list(null, SysOrgType.class);
Map<Integer, String> orgTypeMap = Optional.ofNullable(sysOrgTypeList)
.filter(list -> !list.isEmpty())
.map(list -> list.stream()
.collect(toMap(SysOrgType::getId, SysOrgType::getOrgName, (k1, k2) -> k1)))
.orElse(Collections.emptyMap());
List<ListSysOrganizationDTO> result = new ArrayList<>();
//递归获取子机构
allSysOrg.forEach(parent -> {
if (parent.getParentId() == 0) {
ListSysOrganizationDTO pageSysOrganizationDTO = BeanUtil.copyProperties(parent, ListSysOrganizationDTO.class);
pageSysOrganizationDTO.setLevel(1);
pageSysOrganizationDTO.setTotalParkNum(0);
pageSysOrganizationDTO.setOrgTypeName(orgTypeMap.getOrDefault(parent.getOrgType(), "未知"));
List<ListSysOrganizationDTO> children = sysOrganizationToolService.getChildrenOrganizations(
parent.getId(),
pageSysOrganizationDTO.getLevel(),
allSysOrg,
orgTypeMap
);
if (!children.isEmpty()) {
pageSysOrganizationDTO.setChildList(children);
}
result.add(pageSysOrganizationDTO);
}
});
return ResultHttp.success(sysOrganizationToolService.filterInvalidNodes(result,organization));
}
@Override
public ResultHttp<?> deleteOrg(Long id) {
List<SysOrganization> list = lambdaQuery().eq(SysOrganization::getParentId, id).list();
long count = list.stream().filter(i -> i.getParentId() != 0).count();
Assert.isTrue(count <= 0 ,"该机构存在下级机构,请先删除下级机构");
Set<Long> parent = list.stream().map(SysOrganization::getId).collect(Collectors.toSet());
if (!parent.isEmpty()) {
Long parentCount = lambdaQuery().in(SysOrganization::getParentId, parent).count();
Assert.isTrue(parentCount <= 0, "该机构下存在用户,无法删除");
}
BaseCrudUtil.delete(Collections.singleton(id),SysOrganization.class);
return ResultHttp.success();
}
/**
* 新增修改校验
* @param organization 组织数据
* @param <T> 子类数据
*/
public <T extends BaseSysOrganization> void validateOrg(T organization){
Long count = 0L;
if (organization instanceof AddSysOrganization){
count = lambdaQuery().eq(SysOrganization::getOrgCode, organization.getOrgCode()).count();
}else if (organization instanceof UpdateSysOrganization){
count = lambdaQuery().eq(SysOrganization::getOrgCode, organization.getOrgCode())
.ne( ((UpdateSysOrganization)organization).getId() != null,SysOrganization::getId, ((UpdateSysOrganization)organization).getId()).count();
}
Assert.isTrue(count <= 0, "机构所对应的机构码已存在");
if (organization.getParentId() != null && organization.getParentId() != 0) {
SysOrganization parentOrg = getById(organization.getParentId());
Assert.notNull(parentOrg, "上级机构不存在");
if (parentOrg.getParentId() != null && parentOrg.getParentId() != 0) {
SysOrganization grandParentOrg = getById(parentOrg.getParentId());
Assert.notNull(grandParentOrg, "上级机构的上级机构不存在");
Assert.isTrue(grandParentOrg.getParentId() == null || grandParentOrg.getParentId() == 0, "最多只支持三级机构");
}
}
}
}
package com.zkhj.roadside.user.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.lang.Assert;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zkhj.core.common.BaseCrudUtil;
import com.zkhj.dto.core.http.ResultHttp;
import com.zkhj.dto.roadside.sys.region.req.AddSysRegion;
import com.zkhj.dto.roadside.sys.region.req.QuerySysRegion;
import com.zkhj.dto.roadside.sys.region.req.UpdateSysRegion;
import com.zkhj.dto.roadside.sys.region.resp.ListSysRegionDTO;
import com.zkhj.dto.roadside.sys.region.resp.SysRegionStaticDTO;
import com.zkhj.dto.roadside.util.Status;
import com.zkhj.roadside.user.entity.SysOrganization;
import com.zkhj.roadside.user.entity.SysRegion;
import com.zkhj.roadside.user.mapper.SysRegionMapper;
import com.zkhj.roadside.user.service.SysRegionService;
import com.zkhj.roadside.user.service.business.SysRegionToolService;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
/**
* @author 罗俊
*/
@Service
public class SysRegionServiceImpl extends ServiceImpl<SysRegionMapper, SysRegion>
implements SysRegionService {
@Resource SysRegionToolService sysRegionToolService;
@Override
@Transactional
public ResultHttp<?> createRegion(AddSysRegion addSysRegion) {
//1.基础校验
Long count = lambdaQuery().eq(SysRegion::getRegionName, addSysRegion.getRegionName()).eq(SysRegion::getParentId, addSysRegion.getParentId()).count();
Assert.isTrue(count<=0 , "区域已存在" );
//2.转换,创建组织 默认开启
SysRegion sysRegion = BeanUtil.copyProperties(addSysRegion, SysRegion.class);
sysRegion.setStatus(Status.ENABLED.getCode());
save(sysRegion);
//3.子区域新增 父区域id赋值进去就行
Set<SysRegion> childRegions = sysRegionToolService.buildChildRegions(sysRegion, addSysRegion.getChildRegionList());
if (!childRegions.isEmpty())
saveBatch(childRegions);
return ResultHttp.success();
}
@Override
public ResultHttp<?> updateRegion(UpdateSysRegion updateSysRegion) {
SysRegion rawData = getById(updateSysRegion.getId());
Assert.notNull(rawData, "区域数据不存在");
Long count = lambdaQuery().eq(SysRegion::getRegionName, updateSysRegion.getRegionName())
.eq(updateSysRegion.getParentId()!=null,SysRegion::getParentId, updateSysRegion.getParentId())
.ne(SysRegion::getId,updateSysRegion.getId()).count();
Assert.isTrue(count<=0 , "区域已存在" );
boolean isParentRegion = rawData.getParentId() == null || rawData.getParentId() == 0;
SysRegion sysRegion = BeanUtil.copyProperties(updateSysRegion, SysRegion.class);
updateById(sysRegion);
if (isParentRegion && updateSysRegion.getChildRegionList() != null) {
sysRegionToolService.syncChildRegions(updateSysRegion, updateSysRegion.getChildRegionList());
}
return ResultHttp.success();
}
@Override
public ResultHttp<?> delete(Integer id) {
List<SysRegion> childList = lambdaQuery().in(SysRegion::getParentId, id).list();
SysRegion sysRegion = getById(id);
childList.add(sysRegion);
BaseCrudUtil.delete(childList.stream().map(SysRegion::getId).collect(Collectors.toSet()), SysRegion.class);
return ResultHttp.success();
}
@Override
public ResultHttp<SysRegionStaticDTO> staticData() {
List<SysRegion> list = lambdaQuery().list();
SysRegionStaticDTO staticDTO = new SysRegionStaticDTO();
staticDTO.setRegionNum(list.size());
staticDTO.setEnableRegionNum((int) list.stream().filter(item -> item.getStatus() == 1).count());
staticDTO.setDisableRegionNum((int) list.stream().filter(item -> item.getStatus() == 0).count());
return ResultHttp.success(staticDTO);
}
@Override
@Transactional
public ResultHttp<Void> updateStatus(Integer id, Integer status) {
SysRegion sysRegion = getById(id);
if (sysRegion.getParentId() == 0){
if (status == Status.ENABLED.getCode()){
sysRegion.setStatus(status);
updateById(sysRegion);
}else if (status == Status.DISABLED.getCode()){
List<SysRegion> list = this.lambdaQuery().eq(SysRegion::getParentId, sysRegion.getId()).list();
list.add(sysRegion);
list.forEach(item -> {
item.setStatus(status);
});
updateBatchById( list);
}
}else {
//父类不是顶级父类
sysRegion.setStatus(status);
updateById(sysRegion);
}
return ResultHttp.success();
}
@Override
public ResultHttp<List<ListSysRegionDTO>> queryList(QuerySysRegion querySysRegion) {
// 1. 查出所有区域数据
List<SysRegion> allRegions = lambdaQuery().orderByAsc(SysRegion::getSort).list();
if (allRegions.isEmpty()) {
return ResultHttp.success(Collections.emptyList());
}
// 2. 转换为 DTO
List<ListSysRegionDTO> allDTOs = allRegions.stream()
.map(region -> BeanUtil.copyProperties(region, ListSysRegionDTO.class))
.collect(Collectors.toList());
// 3. 组装树形结构
List<SysOrganization> sysOrgList = BaseCrudUtil.list(null, SysOrganization.class);
if (sysOrgList == null || sysOrgList.isEmpty()) return ResultHttp.success(Collections.emptyList());
List<ListSysRegionDTO> tree = sysRegionToolService.buildRegionTree(allDTOs,sysOrgList);
// 4. 应用查询条件过滤
List<ListSysRegionDTO> filteredTree = sysRegionToolService.filterRegionTree(tree, querySysRegion);
return ResultHttp.success(filteredTree);
}
}
package com.zkhj.roadside.user.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zkhj.roadside.user.entity.SysRoleMenu;
import com.zkhj.roadside.user.mapper.SysRoleMenuMapper;
import com.zkhj.roadside.user.service.SysRoleMenuService;
import org.springframework.stereotype.Service;
@Service
public class SysRoleMenuServiceImpl extends ServiceImpl<SysRoleMenuMapper, SysRoleMenu> implements SysRoleMenuService {
}
package com.zkhj.roadside.user.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zkhj.roadside.user.entity.SysRole;
import com.zkhj.roadside.user.mapper.SysRoleMapper;
import com.zkhj.roadside.user.service.SysRoleService;
import org.springframework.stereotype.Service;
@Service
public class SysRoleServiceImpl extends ServiceImpl<SysRoleMapper, SysRole> implements SysRoleService {
}
package com.zkhj.roadside.user.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zkhj.roadside.user.entity.SysUserRole;
import com.zkhj.roadside.user.mapper.SysUserRoleMapper;
import com.zkhj.roadside.user.service.SysUserRoleService;
import org.springframework.stereotype.Service;
@Service
public class SysUserRoleServiceImpl extends ServiceImpl<SysUserRoleMapper, SysUserRole> implements SysUserRoleService {
}
package com.zkhj.roadside.user.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zkhj.roadside.user.entity.SysUser;
import com.zkhj.roadside.user.mapper.SysMenuMapper;
import com.zkhj.roadside.user.mapper.SysUserMapper;
import com.zkhj.roadside.user.service.SysUserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Slf4j
@Service
public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> implements SysUserService {
@Autowired
private SysMenuMapper menuMapper;
@Override
public String doLogin(String username, String password) {
//1、查询用户信息
SysUser sysUser = this.getOne(
new LambdaQueryWrapper<SysUser>()
.eq(SysUser::getUsername, username)
.eq(SysUser::getDeleted, 0)
);
if(sysUser==null){
return null;
}
//2、校验密码
if(sysUser.getPassword().equals(password)){
return sysUser.getUsername();
}
return null;
}
@Override
public List<String> getPermissionList(String username) {
return menuMapper.selectPermissionsByUsername(username);
}
}
#nacos-ip: 127.0.0.1
#nacos-port: 8848
#nacos-namespace: public
#nacos-group: DEFAULT_GROUP
nacos-ip: 120.24.176.53
nacos-port: 48848
nacos-namespace: public
nacos-group: DEFAULT_GROUP
server:
port: 7101
servlet:
context-path: /roadside/user
spring:
application:
name: zkhj-roadside-user-service
config:
import:
# 1. 导入服务专属配置
- optional:nacos:${spring.application.name}.yaml?refreshEnabled=true&group=${nacos-group}
# 2. 导入feign配置
- optional:nacos:feign-config.yaml?refreshEnabled=true&group=${nacos-group}
# 3. 导入redis配置
- optional:nacos:redis.yaml?refreshEnabled=true&group=${nacos-group}
# 4. 导入mybatis-plus配置
- optional:nacos:mybatis-plus.yaml?refreshEnabled=true&group=${nacos-group}
# 5. 导入mysql配置
#- optional:nacos:mysql.yaml?refreshEnabled=true&group=${nacos-group}
# 6. 导入postgresql配置
- optional:nacos:road-postgresql.yaml?refreshEnabled=true&group=${nacos-group}
# - optional:nacos:roadside-sharding.yaml?refreshEnabled=true&group=${nacos-group}
# 7. 导入脱敏配置
- optional:nacos:desensitize.yaml?refreshEnabled=true&group=${nacos-group}
cloud:
nacos:
discovery:
server-addr: ${nacos-ip}:${nacos-port}
namespace: ${nacos-namespace}
heart-beat-interval: 5000
heart-beat-timeout: 15000
ip: 127.0.0.1
port: ${server.port}
register-enabled: true
metadata:
context-path: ${server.servlet.context-path}
config:
server-addr: ${nacos-ip}:${nacos-port}
namespace: ${nacos-namespace}
file-extension: yaml
refresh-enabled: true
group: ${nacos-group}
prefix: ${spring.application.name}
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zkhj.roadside.user.mapper.RoadBerthMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zkhj.roadside.user.mapper.RoadInfoMapper">
<!-- 通用查询条件片段 -->
<sql id="whereCondition">
<where>
<!-- 路段编码或名称模糊搜索 -->
<if test="query.roadCode != null and query.roadCode != ''">
AND (
road_code LIKE CONCAT('%', #{query.roadCode}, '%')
OR road_name LIKE CONCAT('%', #{query.roadCode}, '%')
)
</if>
<!-- 状态精确匹配 -->
<if test="query.status != null">
AND status = #{query.status}
</if>
<!-- 区域ID精确匹配 -->
<if test="query.regionId != null">
AND region_id = #{query.regionId}
</if>
<!-- 路段类型精确匹配 -->
<if test="query.roadType != null">
AND road_type = #{query.roadType}
</if>
<!-- 创建时间范围查询 -->
<if test="query.createTime != null and query.createTime.size() == 2">
AND create_time BETWEEN #{query.createTime[0]}::timestamp AND #{query.createTime[1]}::timestamp
</if>
<!-- 泊位数范围查询(需要关联查询或子查询) -->
<if test="query.berthNum != null and query.berthNum.size() == 2">
AND id IN (
SELECT road_id FROM t_road_berth
GROUP BY road_id
HAVING COUNT(*) BETWEEN #{query.berthNum[0]} AND #{query.berthNum[1]}
)
</if>
</where>
</sql>
<!-- 分页查询路段信息 -->
<select id="selectRoadInfoPage" resultType="com.zkhj.roadside.user.entity.RoadInfo">
SELECT
id,
road_code,
road_name,
region_id,
road_type,
road_length,
status,
create_time
FROM t_road_info
<include refid="whereCondition"/>
ORDER BY create_time DESC
</select>
<!-- 统计路段数量 -->
<select id="countRoadInfo" resultType="java.lang.Long">
SELECT COUNT(*)
FROM t_road_info
<include refid="whereCondition"/>
</select>
</mapper>
\ No newline at end of file
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zkhj.roadside.user.mapper.SysMenuMapper">
<resultMap id="BaseResultMap" type="com.zkhj.roadside.user.entity.SysMenu">
</resultMap>
<select id="selectPermissionsByUsername" resultType="java.lang.String">
SELECT DISTINCT m.permission
FROM sys_user u
INNER JOIN sys_user_role ur ON u.user_id = ur.user_id
INNER JOIN sys_role_menu rm ON ur.role_id = rm.role_id
INNER JOIN sys_menu m ON rm.menu_id = m.menu_id
WHERE u.username = #{username}
AND u.deleted = 0
AND u.status = 1
AND m.status = 1
AND m.deleted = 0
AND m.permission IS NOT NULL
AND m.permission != ''
ORDER BY m.sort ASC
</select>
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zkhj.roadside.user.mapper.SysOrgTypeMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zkhj.roadside.user.mapper.SysOrganizationMapper">
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zkhj.roadside.user.mapper.SysRegionMapper">
</mapper>
\ No newline at end of file
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zkhj.roadside.user.mapper.SysRoleMapper">
<resultMap id="BaseResultMap" type="com.zkhj.roadside.user.entity.SysRole">
</resultMap>
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zkhj.roadside.user.mapper.SysRoleMenuMapper">
<resultMap id="BaseResultMap" type="com.zkhj.roadside.user.entity.SysRoleMenu">
</resultMap>
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zkhj.roadside.user.mapper.SysUserMapper">
<resultMap id="BaseResultMap" type="com.zkhj.roadside.user.entity.SysUser">
</resultMap>
</mapper>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zkhj.roadside.user.mapper.SysUserRoleMapper">
<resultMap id="BaseResultMap" type="com.zkhj.roadside.user.entity.SysUserRole">
</resultMap>
</mapper>
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment