wsr/orange-admin
1
0
Fork 0
mirror of https://gitee.com/orangeform/orange-admin.git synced 2026-01-17 18:46:36 +08:00
Code Issues Packages Projects Releases Wiki Activity

commit：添加单体工程开源版本

Browse Source
This commit is contained in:
Jerry
2020-09-25 10:45:02 +08:00
parent 28ea2247f6
commit 53270e70f8
354 changed files with 40271 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
orange-demo-service/zz-orange-demo.sql
View File

@@ -266,7 +266,7 @@ CREATE TABLE `zz_student` (
`birthday` date NOT NULL COMMENT '生日',
`experience_level` tinyint(4) NOT NULL COMMENT '经验等级 (0: 初级 1: 中级 2: 高级 3: 资深)',
`total_coin` int(11) NOT NULL DEFAULT '0' COMMENT '总共充值学币数量',
`left_coin` int(11) NOT NULL COMMENT '可用学币数量',
`left_coin` int(11) NOT NULL DEFAULT '0' COMMENT '可用学币数量',
`grade_id` int(11) NOT NULL COMMENT '年级Id',
`school_id` bigint(20) NOT NULL COMMENT '校区Id',
`register_time` datetime NOT NULL COMMENT '注册时间',
@@ -648,10 +648,6 @@ INSERT INTO `zz_sys_menu` VALUES (1093809448598376533, 1093376634916704256, '新
INSERT INTO `zz_sys_menu` VALUES (1093809448598376534, 1093376634916704256, '编辑', 3, NULL, 3, NULL, CURDATE(), 1);
INSERT INTO `zz_sys_menu` VALUES (1093809448598376535, 1093376634916704256, '删除', 3, NULL, 4, NULL, CURDATE(), 1);
INSERT INTO `zz_sys_menu` VALUES (1093809448598376536, 1093376634916704256, '重置密码', 3, NULL, 5, NULL, CURDATE(), 1);
INSERT INTO `zz_sys_menu` VALUES (1093809448598376544, 1093376634916704257, '显示', 3, NULL, 1, NULL, CURDATE(), 1);
INSERT INTO `zz_sys_menu` VALUES (1093809448598376545, 1093376634916704257, '新增', 3, NULL, 2, NULL, CURDATE(), 1);
INSERT INTO `zz_sys_menu` VALUES (1093809448598376546, 1093376634916704257, '编辑', 3, NULL, 3, NULL, CURDATE(), 1);
INSERT INTO `zz_sys_menu` VALUES (1093809448598376547, 1093376634916704257, '删除', 3, NULL, 4, NULL, CURDATE(), 1);
INSERT INTO `zz_sys_menu` VALUES (1093809448598376554, 1093376634916704258, '角色管理', 2, NULL, 1, NULL, CURDATE(), 1);
INSERT INTO `zz_sys_menu` VALUES (1093809448598376555, 1093376634916704258, '用户授权', 2, NULL, 2, NULL, CURDATE(), 1);
INSERT INTO `zz_sys_menu` VALUES (1093809448598376556, 1093809448598376554, '显示', 3, NULL, 1, NULL, CURDATE(), 1);
@@ -822,10 +818,6 @@ INSERT INTO `zz_sys_menu_perm_code` VALUES (1093809448598376533, 109380944859837
INSERT INTO `zz_sys_menu_perm_code` VALUES (1093809448598376534, 1093809448598376540);
INSERT INTO `zz_sys_menu_perm_code` VALUES (1093809448598376535, 1093809448598376541);
INSERT INTO `zz_sys_menu_perm_code` VALUES (1093809448598376536, 1093809448598376542);
INSERT INTO `zz_sys_menu_perm_code` VALUES (1093809448598376544, 1093809448598376549);
INSERT INTO `zz_sys_menu_perm_code` VALUES (1093809448598376545, 1093809448598376550);
INSERT INTO `zz_sys_menu_perm_code` VALUES (1093809448598376546, 1093809448598376551);
INSERT INTO `zz_sys_menu_perm_code` VALUES (1093809448598376547, 1093809448598376552);
INSERT INTO `zz_sys_menu_perm_code` VALUES (1093809448598376556, 1093809448598376564);
INSERT INTO `zz_sys_menu_perm_code` VALUES (1093809448598376560, 1093809448598376565);
INSERT INTO `zz_sys_menu_perm_code` VALUES (1093809448598376557, 1093809448598376566);

BIN
orange-demo-single-service/.DS_Store vendored Normal file
View File

Binary file not shown.

26
orange-demo-single-service/.gitignore vendored Normal file
View File

@@ -0,0 +1,26 @@
/target/
!.mvn/wrapper/maven-wrapper.jar
/.mvn/*
### STS ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
.sts4-cache
### IntelliJ IDEA ###
.idea
*.iws
*.iml
*.ipr
### NetBeans ###
/nbproject/private/
/build/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/

3
orange-demo-single-service/README.md Normal file
View File

@@ -0,0 +1,3 @@
### 服务启动环境依赖
---

24
orange-demo-single-service/application-common/pom.xml Normal file
View File

@@ -0,0 +1,24 @@
<?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">
<parent>
<groupId>com.orange.demo</groupId>
<artifactId>OrangeSingleDemo</artifactId>
<version>1.0.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>application-common</artifactId>
<version>1.0.0</version>
<name>application-common</name>
<packaging>jar</packaging>
<dependencies>
<dependency>
<groupId>com.orange.demo</groupId>
<artifactId>common-core</artifactId>
<version>1.0.0</version>
</dependency>
</dependencies>
</project>

49
orange-demo-single-service/application-common/src/main/java/com/orange/demo/application/common/constant/DeviceType.java Normal file
View File

@@ -0,0 +1,49 @@
package com.orange.demo.application.common.constant;
import java.util.HashMap;
import java.util.Map;
/**
* 设备类型常量字典对象。
*
* @author Jerry
* @date 2020-09-25
*/
public final class DeviceType {
/**
* iOS。
*/
public static final int IOS = 0;
/**
* Android。
*/
public static final int ANDROID = 1;
/**
* PC。
*/
public static final int PC = 2;
private static final Map<Object, String> DICT_MAP = new HashMap<>(3);
static {
DICT_MAP.put(IOS, "iOS");
DICT_MAP.put(ANDROID, "Android");
DICT_MAP.put(PC, "PC");
}
/**
* 判断参数是否为当前常量字典的合法值。
*
* @param value 待验证的参数值。
* @return 合法返回true，否则false。
*/
public static boolean isValid(Integer value) {
return value != null && DICT_MAP.containsKey(value);
}
/**
* 私有构造函数，明确标识该常量类的作用。
*/
private DeviceType() {
}
}

49
orange-demo-single-service/application-common/src/main/java/com/orange/demo/application/common/constant/ExpLevel.java Normal file
View File

@@ -0,0 +1,49 @@
package com.orange.demo.application.common.constant;
import java.util.HashMap;
import java.util.Map;
/**
* 经验等级常量字典对象。
*
* @author Jerry
* @date 2020-09-25
*/
public final class ExpLevel {
/**
* 初级学员。
*/
public static final int LOWER = 0;
/**
* 中级学员。
*/
public static final int MIDDLE = 1;
/**
* 高级学员。
*/
public static final int HIGH = 2;
private static final Map<Object, String> DICT_MAP = new HashMap<>(3);
static {
DICT_MAP.put(LOWER, "初级学员");
DICT_MAP.put(MIDDLE, "中级学员");
DICT_MAP.put(HIGH, "高级学员");
}
/**
* 判断参数是否为当前常量字典的合法值。
*
* @param value 待验证的参数值。
* @return 合法返回true，否则false。
*/
public static boolean isValid(Integer value) {
return value != null && DICT_MAP.containsKey(value);
}
/**
* 私有构造函数，明确标识该常量类的作用。
*/
private ExpLevel() {
}
}

44
orange-demo-single-service/application-common/src/main/java/com/orange/demo/application/common/constant/Gender.java Normal file
View File

@@ -0,0 +1,44 @@
package com.orange.demo.application.common.constant;
import java.util.HashMap;
import java.util.Map;
/**
* 性别常量字典对象。
*
* @author Jerry
* @date 2020-09-25
*/
public final class Gender {
/**
* 男。
*/
public static final int MALE = 1;
/**
* 女。
*/
public static final int FEMALE = 0;
private static final Map<Object, String> DICT_MAP = new HashMap<>(2);
static {
DICT_MAP.put(MALE, "男");
DICT_MAP.put(FEMALE, "女");
}
/**
* 判断参数是否为当前常量字典的合法值。
*
* @param value 待验证的参数值。
* @return 合法返回true，否则false。
*/
public static boolean isValid(Integer value) {
return value != null && DICT_MAP.containsKey(value);
}
/**
* 私有构造函数，明确标识该常量类的作用。
*/
private Gender() {
}
}

89
orange-demo-single-service/application-common/src/main/java/com/orange/demo/application/common/constant/StudentActionType.java Normal file
View File

@@ -0,0 +1,89 @@
package com.orange.demo.application.common.constant;
import java.util.HashMap;
import java.util.Map;
/**
* 学生行为常量字典对象。
*
* @author Jerry
* @date 2020-09-25
*/
public final class StudentActionType {
/**
* 充值。
*/
public static final int RECHARGE = 0;
/**
* 购课。
*/
public static final int BUY_COURSE = 1;
/**
* 上课签到。
*/
public static final int SIGNIN_COURSE = 2;
/**
* 上课签退。
*/
public static final int SIGNOUT_COURSE = 3;
/**
* 看视频课。
*/
public static final int WATCH_VIDEO = 4;
/**
* 做作业。
*/
public static final int DO_PAPER = 5;
/**
* 刷题。
*/
public static final int REFRESH_EXERCISE = 6;
/**
* 献花。
*/
public static final int PRESENT_FLOWER = 7;
/**
* 购买视频。
*/
public static final int BUY_VIDEO_COURSE = 8;
/**
* 购买鲜花。
*/
public static final int BUY_FLOWER = 9;
/**
* 购买作业。
*/
public static final int BUY_PAPER = 10;
private static final Map<Object, String> DICT_MAP = new HashMap<>(11);
static {
DICT_MAP.put(RECHARGE, "充值");
DICT_MAP.put(BUY_COURSE, "购课");
DICT_MAP.put(SIGNIN_COURSE, "上课签到");
DICT_MAP.put(SIGNOUT_COURSE, "上课签退");
DICT_MAP.put(WATCH_VIDEO, "看视频课");
DICT_MAP.put(DO_PAPER, "做作业");
DICT_MAP.put(REFRESH_EXERCISE, "刷题");
DICT_MAP.put(PRESENT_FLOWER, "献花");
DICT_MAP.put(BUY_VIDEO_COURSE, "购买视频");
DICT_MAP.put(BUY_FLOWER, "购买鲜花");
DICT_MAP.put(BUY_PAPER, "购买作业");
}
/**
* 判断参数是否为当前常量字典的合法值。
*
* @param value 待验证的参数值。
* @return 合法返回true，否则false。
*/
public static boolean isValid(Integer value) {
return value != null && DICT_MAP.containsKey(value);
}
/**
* 私有构造函数，明确标识该常量类的作用。
*/
private StudentActionType() {
}
}

49
orange-demo-single-service/application-common/src/main/java/com/orange/demo/application/common/constant/StudentStatus.java Normal file
View File

@@ -0,0 +1,49 @@
package com.orange.demo.application.common.constant;
import java.util.HashMap;
import java.util.Map;
/**
* 学生状态常量字典对象。
*
* @author Jerry
* @date 2020-09-25
*/
public final class StudentStatus {
/**
* 正常。
*/
public static final int NORMAL = 0;
/**
* 锁定。
*/
public static final int LOCKED = 1;
/**
* 注销。
*/
public static final int DELETED = 2;
private static final Map<Object, String> DICT_MAP = new HashMap<>(3);
static {
DICT_MAP.put(NORMAL, "正常");
DICT_MAP.put(LOCKED, "锁定");
DICT_MAP.put(DELETED, "注销");
}
/**
* 判断参数是否为当前常量字典的合法值。
*
* @param value 待验证的参数值。
* @return 合法返回true，否则false。
*/
public static boolean isValid(Integer value) {
return value != null && DICT_MAP.containsKey(value);
}
/**
* 私有构造函数，明确标识该常量类的作用。
*/
private StudentStatus() {
}
}

49
orange-demo-single-service/application-common/src/main/java/com/orange/demo/application/common/constant/Subject.java Normal file
View File

@@ -0,0 +1,49 @@
package com.orange.demo.application.common.constant;
import java.util.HashMap;
import java.util.Map;
/**
* 学科常量字典对象。
*
* @author Jerry
* @date 2020-09-25
*/
public final class Subject {
/**
* 语文。
*/
public static final int CHINESE = 0;
/**
* 数学。
*/
public static final int MATCH = 1;
/**
* 英语。
*/
public static final int ENGLISH = 2;
private static final Map<Object, String> DICT_MAP = new HashMap<>(3);
static {
DICT_MAP.put(CHINESE, "语文");
DICT_MAP.put(MATCH, "数学");
DICT_MAP.put(ENGLISH, "英语");
}
/**
* 判断参数是否为当前常量字典的合法值。
*
* @param value 待验证的参数值。
* @return 合法返回true，否则false。
*/
public static boolean isValid(Integer value) {
return value != null && DICT_MAP.containsKey(value);
}
/**
* 私有构造函数，明确标识该常量类的作用。
*/
private Subject() {
}
}

67
orange-demo-single-service/application/pom.xml Normal file
View File

@@ -0,0 +1,67 @@
<?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">
<parent>
<groupId>com.orange.demo</groupId>
<artifactId>OrangeSingleDemo</artifactId>
<version>1.0.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>application</artifactId>
<version>1.0.0</version>
<name>application</name>
<packaging>jar</packaging>
<dependencies>
<!-- 业务组件依赖 -->
<dependency>
<groupId>com.orange.demo</groupId>
<artifactId>common-core</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>com.orange.demo</groupId>
<artifactId>application-common</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>com.orange.demo</groupId>
<artifactId>common-sequence</artifactId>
<version>1.0.0</version>
</dependency>
</dependencies>
<build>
<resources>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.*</include>
</includes>
<filtering>false</filtering>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>${spring-boot.version}</version>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

18
orange-demo-single-service/application/src/main/java/com/orange/demo/MyApplication.java Normal file
View File

@@ -0,0 +1,18 @@
package com.orange.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* 应用服务启动类。
*
* @author Jerry
* @date 2020-09-25
*/
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}

56
orange-demo-single-service/application/src/main/java/com/orange/demo/app/controller/AreaCodeController.java Normal file
View File

@@ -0,0 +1,56 @@
package com.orange.demo.app.controller;
import cn.jimmyshi.beanquery.BeanQuery;
import com.orange.demo.app.model.AreaCode;
import com.orange.demo.app.service.AreaCodeService;
import com.orange.demo.common.core.object.ResponseResult;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.*;
/**
* 行政区划数据访问接口类。
*
* @author Jerry
* @date 2020-09-25
*/
@RestController
@RequestMapping("/admin/app/areaCode")
public class AreaCodeController {
@Autowired
private AreaCodeService areaCodeService;
/**
* 按照字典的形式返回行政区划列表。
*
* @return 字典形式的行政区划列表。
*/
@GetMapping("/listDictAreaCode")
public ResponseResult<List<Map<String, Object>>> listDictAreaCode() {
List<AreaCode> resultList = areaCodeService.getAllList();
return ResponseResult.success(BeanQuery.select(
"parentId as parentId", "areaId as id", "areaName as name").executeFrom(resultList));
}
/**
* 根据上级行政区划Id获取其下级行政区划列表。
*
* @param parentId 上级行政区划Id。
* @return 按照字典的形式返回下级行政区划列表。
*/
@GetMapping("/listDictAreaCodeByParentId")
public ResponseResult<List<Map<String, Object>>> listDictAreaCodeByParentId(@RequestParam(required = false) Long parentId) {
Collection<AreaCode> resultList = areaCodeService.getListByParentId(parentId);
if (CollectionUtils.isEmpty(resultList)) {
return ResponseResult.success(new LinkedList<>());
}
return ResponseResult.success(BeanQuery.select(
"parentId as parentId", "areaId as id", "areaName as name").executeFrom(resultList));
}
}

253
orange-demo-single-service/application/src/main/java/com/orange/demo/app/controller/CourseController.java Normal file
View File

@@ -0,0 +1,253 @@
package com.orange.demo.app.controller;
import cn.hutool.core.util.ReflectUtil;
import cn.jimmyshi.beanquery.BeanQuery;
import com.github.pagehelper.page.PageMethod;
import com.orange.demo.app.model.*;
import com.orange.demo.app.service.*;
import com.orange.demo.common.core.object.*;
import com.orange.demo.common.core.util.*;
import com.orange.demo.common.core.constant.ErrorCodeEnum;
import com.orange.demo.common.core.annotation.MyRequestBody;
import com.orange.demo.common.core.validator.UpdateGroup;
import com.orange.demo.common.core.cache.SessionCacheHelper;
import com.orange.demo.config.ApplicationConfig;
import lombok.extern.slf4j.Slf4j;
import com.alibaba.fastjson.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.*;
import javax.validation.groups.Default;
/**
* 课程数据操作控制器类。
*
* @author Jerry
* @date 2020-09-25
*/
@Slf4j
@RestController
@RequestMapping("/admin/app/course")
public class CourseController {
@Autowired
private CourseService courseService;
@Autowired
private ApplicationConfig appConfig;
@Autowired
private SessionCacheHelper cacheHelper;
/**
* 新增课程数据数据。
*
* @param course 新增对象。
* @return 应答结果对象，包含新增对象主键Id。
*/
@PostMapping("/add")
public ResponseResult<JSONObject> add(@MyRequestBody Course course) {
String errorMessage = MyCommonUtil.getModelValidationError(course);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
// 验证关联Id的数据合法性
CallResult callResult = courseService.verifyRelatedData(course, null);
if (!callResult.isSuccess()) {
errorMessage = callResult.getErrorMessage();
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
course = courseService.saveNew(course);
JSONObject responseData = new JSONObject();
responseData.put("courseId", course.getCourseId());
return ResponseResult.success(responseData);
}
/**
* 更新课程数据数据。
*
* @param course 更新对象。
* @return 应答结果对象。
*/
@PostMapping("/update")
public ResponseResult<Void> update(@MyRequestBody Course course) {
String errorMessage = MyCommonUtil.getModelValidationError(course, Default.class, UpdateGroup.class);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
// 验证关联Id的数据合法性
Course originalCourse = courseService.getById(course.getCourseId());
if (originalCourse == null) {
//NOTE: 修改下面方括号中的话述
errorMessage = "数据验证失败，当前 [数据] 并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
// 验证关联Id的数据合法性
CallResult callResult = courseService.verifyRelatedData(course, originalCourse);
if (!callResult.isSuccess()) {
errorMessage = callResult.getErrorMessage();
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
if (!courseService.update(course, originalCourse)) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success();
}
/**
* 删除课程数据数据。
*
* @param courseId 删除对象主键Id。
* @return 应答结果对象。
*/
@PostMapping("/delete")
public ResponseResult<Void> delete(@MyRequestBody Long courseId) {
String errorMessage;
if (MyCommonUtil.existBlankArgument(courseId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
// 验证关联Id的数据合法性
Course originalCourse = courseService.getById(courseId);
if (originalCourse == null) {
// NOTE: 修改下面方括号中的话述
errorMessage = "数据验证失败，当前 [对象] 并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
if (!courseService.remove(courseId)) {
errorMessage = "数据操作失败，删除的对象不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
return ResponseResult.success();
}
/**
* 列出符合过滤条件的课程数据列表。
*
* @param courseFilter 过滤对象。
* @param orderParam 排序参数。
* @param pageParam 分页参数。
* @return 应答结果对象，包含查询结果集。
*/
@PostMapping("/list")
public ResponseResult<JSONObject> list(
@MyRequestBody Course courseFilter,
@MyRequestBody MyOrderParam orderParam,
@MyRequestBody MyPageParam pageParam) {
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
String orderBy = MyOrderParam.buildOrderBy(orderParam, Course.class);
List<Course> resultList = courseService.getCourseListWithRelation(courseFilter, orderBy);
return ResponseResult.success(MyPageUtil.makeResponseData(resultList));
}
/**
* 查看指定课程数据对象详情。
*
* @param courseId 指定对象主键Id。
* @return 应答结果对象，包含对象详情。
*/
@GetMapping("/view")
public ResponseResult<Course> view(@RequestParam Long courseId) {
if (MyCommonUtil.existBlankArgument(courseId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
Course course = courseService.getByIdWithRelation(courseId, MyRelationParam.full());
if (course == null) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success(course);
}
/**
* 附件文件下载。
* 这里将图片和其他类型的附件文件放到不同的父目录下，主要为了便于今后图片文件的迁移。
*
* @param courseId 附件所在记录的主键Id。
* @param fieldName 附件所属的字段名。
* @param filename 文件名。如果没有提供该参数，就从当前记录的指定字段中读取。
* @param asImage 下载文件是否为图片。
* @param response Http 应答对象。
*/
@GetMapping("/download")
public void download(
@RequestParam(required = false) Long courseId,
@RequestParam String fieldName,
@RequestParam String filename,
@RequestParam Boolean asImage,
HttpServletResponse response) {
if (MyCommonUtil.existBlankArgument(fieldName, filename, asImage)) {
response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
return;
}
// 使用try来捕获异常，是为了保证一旦出现异常可以返回500的错误状态，便于调试。
// 否则有可能给前端返回的是200的错误码。
try {
// 如果请求参数中没有包含主键Id，就判断该文件是否为当前session上传的。
if (courseId == null) {
if (!cacheHelper.existSessionUploadFile(filename)) {
response.setStatus(HttpServletResponse.SC_FORBIDDEN);
return;
}
} else {
Course course = courseService.getById(courseId);
if (course == null) {
response.setStatus(HttpServletResponse.SC_NOT_FOUND);
return;
}
String fieldJsonData = (String) ReflectUtil.getFieldValue(course, fieldName);
if (fieldJsonData == null) {
response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
return;
}
if (!UpDownloadUtil.containFile(fieldJsonData, filename)) {
response.setStatus(HttpServletResponse.SC_FORBIDDEN);
return;
}
}
UpDownloadUtil.doDownload(appConfig.getUploadFileBaseDir(),
Course.class.getSimpleName(), fieldName, filename, asImage, response);
} catch (Exception e) {
response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
log.error(e.getMessage(), e);
}
}
/**
* 文件上传操作。
*
* @param fieldName 上传文件名。
* @param asImage 是否作为图片上传。如果是图片，今后下载的时候无需权限验证。否则就是附件上传，下载时需要权限验证。
* @param uploadFile 上传文件对象。
* @param response Http 应答对象。
* @throws IOException 文件读写错误。
*/
@PostMapping("/upload")
public void upload(
@RequestParam String fieldName,
@RequestParam Boolean asImage,
@RequestParam("uploadFile") MultipartFile uploadFile,
HttpServletResponse response) throws IOException {
String filename = UpDownloadUtil.doUpload(appConfig.getUploadFileBaseDir(),
Course.class.getSimpleName(), fieldName, asImage, uploadFile, response);
if (filename != null) {
cacheHelper.putSessionUploadFile(filename);
}
}
/**
* 以字典形式返回全部课程数据数据集合。字典的键值为[courseId, courseName]。
* 白名单接口，登录用户均可访问。
*
* @param filter 过滤对象。
* @return 应答结果对象，包含的数据为 List<Map<String, String>>，map中包含两条记录，key的值分别是id和name，value对应具体数据。
*/
@GetMapping("/listDictCourse")
public ResponseResult<List<Map<String, Object>>> listDictCourse(Course filter) {
List<Course> resultList = courseService.getListByFilter(filter, null);
return ResponseResult.success(BeanQuery.select(
"courseId as id", "courseName as name").executeFrom(resultList));
}
}

99
orange-demo-single-service/application/src/main/java/com/orange/demo/app/controller/CourseTransStatsController.java Normal file
View File

@@ -0,0 +1,99 @@
package com.orange.demo.app.controller;
import com.github.pagehelper.page.PageMethod;
import com.orange.demo.app.model.*;
import com.orange.demo.app.service.*;
import com.orange.demo.common.core.object.*;
import com.orange.demo.common.core.util.*;
import com.orange.demo.common.core.constant.ErrorCodeEnum;
import com.orange.demo.common.core.annotation.MyRequestBody;
import lombok.extern.slf4j.Slf4j;
import com.alibaba.fastjson.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.*;
/**
* 课程统计操作控制器类。
*
* @author Jerry
* @date 2020-09-25
*/
@Slf4j
@RestController
@RequestMapping("/admin/app/courseTransStats")
public class CourseTransStatsController {
@Autowired
private CourseTransStatsService courseTransStatsService;
/**
* 列出符合过滤条件的课程统计列表。
*
* @param courseTransStatsFilter 过滤对象。
* @param orderParam 排序参数。
* @param pageParam 分页参数。
* @return 应答结果对象，包含查询结果集。
*/
@PostMapping("/list")
public ResponseResult<JSONObject> list(
@MyRequestBody CourseTransStats courseTransStatsFilter,
@MyRequestBody MyOrderParam orderParam,
@MyRequestBody MyPageParam pageParam) {
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
String orderBy = MyOrderParam.buildOrderBy(orderParam, CourseTransStats.class);
List<CourseTransStats> resultList = courseTransStatsService.getCourseTransStatsListWithRelation(courseTransStatsFilter, orderBy);
return ResponseResult.success(MyPageUtil.makeResponseData(resultList));
}
/**
* 分组列出符合过滤条件的课程统计列表。
*
* @param courseTransStatsFilter 过滤对象。
* @param groupParam 分组参数。
* @param orderParam 排序参数。
* @param pageParam 分页参数。
* @return 应答结果对象，包含查询结果集。
*/
@PostMapping("/listWithGroup")
public ResponseResult<JSONObject> listWithGroup(
@MyRequestBody CourseTransStats courseTransStatsFilter,
@MyRequestBody MyGroupParam groupParam,
@MyRequestBody MyOrderParam orderParam,
@MyRequestBody MyPageParam pageParam) {
String orderBy = MyOrderParam.buildOrderBy(orderParam, CourseTransStats.class);
groupParam = MyGroupParam.buildGroupBy(groupParam, CourseTransStats.class);
if (groupParam == null) {
return ResponseResult.error(
ErrorCodeEnum.INVALID_ARGUMENT_FORMAT, "数据参数错误，分组参数不能为空！");
}
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
MyGroupCriteria criteria = groupParam.getGroupCriteria();
List<CourseTransStats> resultList = courseTransStatsService.getGroupedCourseTransStatsListWithRelation(
courseTransStatsFilter, criteria.getGroupSelect(), criteria.getGroupBy(), orderBy);
return ResponseResult.success(MyPageUtil.makeResponseData(resultList));
}
/**
* 查看指定课程统计对象详情。
*
* @param statsId 指定对象主键Id。
* @return 应答结果对象，包含对象详情。
*/
@GetMapping("/view")
public ResponseResult<CourseTransStats> view(@RequestParam Long statsId) {
if (MyCommonUtil.existBlankArgument(statsId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
CourseTransStats courseTransStats = courseTransStatsService.getByIdWithRelation(statsId, MyRelationParam.full());
if (courseTransStats == null) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success(courseTransStats);
}
}

114
orange-demo-single-service/application/src/main/java/com/orange/demo/app/controller/GradeController.java Normal file
View File

@@ -0,0 +1,114 @@
package com.orange.demo.app.controller;
import com.orange.demo.app.model.*;
import com.orange.demo.app.service.*;
import com.orange.demo.common.core.constant.ErrorCodeEnum;
import com.orange.demo.common.core.util.MyCommonUtil;
import com.orange.demo.common.core.object.ResponseResult;
import com.orange.demo.common.core.annotation.MyRequestBody;
import com.orange.demo.common.core.validator.UpdateGroup;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import cn.jimmyshi.beanquery.BeanQuery;
import javax.validation.groups.Default;
import java.util.*;
/**
* 年级操作控制器类。
*
* @author Jerry
* @date 2020-09-25
*/
@Slf4j
@RestController
@RequestMapping("/admin/app/grade")
public class GradeController {
@Autowired
private GradeService gradeService;
/**
* 新增年级数据。
*
* @param grade 新增对象。
* @return 应答结果对象，包含新增对象主键Id。
*/
@PostMapping("/add")
public ResponseResult<JSONObject> add(@MyRequestBody Grade grade) {
String errorMessage = MyCommonUtil.getModelValidationError(grade);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
grade = gradeService.saveNew(grade);
JSONObject responseData = new JSONObject();
responseData.put("gradeId", grade.getGradeId());
return ResponseResult.success(responseData);
}
/**
* 更新年级数据。
*
* @param grade 更新对象。
* @return 应答结果对象。
*/
@PostMapping("/update")
public ResponseResult<Void> update(@MyRequestBody Grade grade) {
String errorMessage = MyCommonUtil.getModelValidationError(grade, Default.class, UpdateGroup.class);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
Grade originalGrade = gradeService.getById(grade.getGradeId());
if (originalGrade == null) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
if (!gradeService.update(grade, originalGrade)) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success();
}
/**
* 删除年级数据。
*
* @param gradeId 删除对象主键Id。
* @return 应答结果对象。
*/
@PostMapping("/delete")
public ResponseResult<Void> delete(@MyRequestBody Integer gradeId) {
if (MyCommonUtil.existBlankArgument(gradeId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
if (!gradeService.remove(gradeId)) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success();
}
/**
* 以字典形式返回全部年级数据集合。
* 白名单接口，登录用户均可访问。
*
* @return 应答结果对象，包含字典形式的数据集合。
*/
@GetMapping("/listDictGrade")
public ResponseResult<List<Map<String, Object>>> listDictGrade() {
List<Grade> resultList = gradeService.getAllList();
return ResponseResult.success(BeanQuery.select(
"gradeId as id", "gradeName as name").executeFrom(resultList));
}
/**
* 将当前字典表的数据重新加载到缓存中。
* 由于缓存的数据更新，在add/update/delete等接口均有同步处理。因此该接口仅当同步过程中出现问题时，
* 可手工调用，或者每天晚上定时同步一次。
*/
@GetMapping("/reloadCachedData")
public ResponseResult<Boolean> reloadCachedData() {
gradeService.reloadCachedData(true);
return ResponseResult.success(true);
}
}

167
orange-demo-single-service/application/src/main/java/com/orange/demo/app/controller/SchoolInfoController.java Normal file
View File

@@ -0,0 +1,167 @@
package com.orange.demo.app.controller;
import cn.jimmyshi.beanquery.BeanQuery;
import com.github.pagehelper.page.PageMethod;
import com.orange.demo.app.model.*;
import com.orange.demo.app.service.*;
import com.orange.demo.common.core.object.*;
import com.orange.demo.common.core.util.*;
import com.orange.demo.common.core.constant.ErrorCodeEnum;
import com.orange.demo.common.core.annotation.MyRequestBody;
import com.orange.demo.common.core.validator.UpdateGroup;
import lombok.extern.slf4j.Slf4j;
import com.alibaba.fastjson.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.*;
import javax.validation.groups.Default;
/**
* 校区数据操作控制器类。
*
* @author Jerry
* @date 2020-09-25
*/
@Slf4j
@RestController
@RequestMapping("/admin/app/schoolInfo")
public class SchoolInfoController {
@Autowired
private SchoolInfoService schoolInfoService;
/**
* 新增校区数据数据。
*
* @param schoolInfo 新增对象。
* @return 应答结果对象，包含新增对象主键Id。
*/
@PostMapping("/add")
public ResponseResult<JSONObject> add(@MyRequestBody SchoolInfo schoolInfo) {
String errorMessage = MyCommonUtil.getModelValidationError(schoolInfo);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
// 验证关联Id的数据合法性
CallResult callResult = schoolInfoService.verifyRelatedData(schoolInfo, null);
if (!callResult.isSuccess()) {
errorMessage = callResult.getErrorMessage();
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
schoolInfo = schoolInfoService.saveNew(schoolInfo);
JSONObject responseData = new JSONObject();
responseData.put("schoolId", schoolInfo.getSchoolId());
return ResponseResult.success(responseData);
}
/**
* 更新校区数据数据。
*
* @param schoolInfo 更新对象。
* @return 应答结果对象。
*/
@PostMapping("/update")
public ResponseResult<Void> update(@MyRequestBody SchoolInfo schoolInfo) {
String errorMessage = MyCommonUtil.getModelValidationError(schoolInfo, Default.class, UpdateGroup.class);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
// 验证关联Id的数据合法性
SchoolInfo originalSchoolInfo = schoolInfoService.getById(schoolInfo.getSchoolId());
if (originalSchoolInfo == null) {
//NOTE: 修改下面方括号中的话述
errorMessage = "数据验证失败，当前 [数据] 并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
// 验证关联Id的数据合法性
CallResult callResult = schoolInfoService.verifyRelatedData(schoolInfo, originalSchoolInfo);
if (!callResult.isSuccess()) {
errorMessage = callResult.getErrorMessage();
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
if (!schoolInfoService.update(schoolInfo, originalSchoolInfo)) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success();
}
/**
* 删除校区数据数据。
*
* @param schoolId 删除对象主键Id。
* @return 应答结果对象。
*/
@PostMapping("/delete")
public ResponseResult<Void> delete(@MyRequestBody Long schoolId) {
String errorMessage;
if (MyCommonUtil.existBlankArgument(schoolId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
// 验证关联Id的数据合法性
SchoolInfo originalSchoolInfo = schoolInfoService.getById(schoolId);
if (originalSchoolInfo == null) {
// NOTE: 修改下面方括号中的话述
errorMessage = "数据验证失败，当前 [对象] 并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
if (!schoolInfoService.remove(schoolId)) {
errorMessage = "数据操作失败，删除的对象不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
return ResponseResult.success();
}
/**
* 列出符合过滤条件的校区数据列表。
*
* @param schoolInfoFilter 过滤对象。
* @param orderParam 排序参数。
* @param pageParam 分页参数。
* @return 应答结果对象，包含查询结果集。
*/
@PostMapping("/list")
public ResponseResult<JSONObject> list(
@MyRequestBody SchoolInfo schoolInfoFilter,
@MyRequestBody MyOrderParam orderParam,
@MyRequestBody MyPageParam pageParam) {
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
String orderBy = MyOrderParam.buildOrderBy(orderParam, SchoolInfo.class);
List<SchoolInfo> resultList = schoolInfoService.getSchoolInfoListWithRelation(schoolInfoFilter, orderBy);
return ResponseResult.success(MyPageUtil.makeResponseData(resultList));
}
/**
* 查看指定校区数据对象详情。
*
* @param schoolId 指定对象主键Id。
* @return 应答结果对象，包含对象详情。
*/
@GetMapping("/view")
public ResponseResult<SchoolInfo> view(@RequestParam Long schoolId) {
if (MyCommonUtil.existBlankArgument(schoolId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
SchoolInfo schoolInfo = schoolInfoService.getByIdWithRelation(schoolId, MyRelationParam.full());
if (schoolInfo == null) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success(schoolInfo);
}
/**
* 以字典形式返回全部校区数据数据集合。字典的键值为[schoolId, schoolName]。
* 白名单接口，登录用户均可访问。
*
* @param filter 过滤对象。
* @return 应答结果对象，包含的数据为 List<Map<String, String>>，map中包含两条记录，key的值分别是id和name，value对应具体数据。
*/
@GetMapping("/listDictSchoolInfo")
public ResponseResult<List<Map<String, Object>>> listDictSchoolInfo(SchoolInfo filter) {
List<SchoolInfo> resultList = schoolInfoService.getListByFilter(filter, null);
return ResponseResult.success(BeanQuery.select(
"schoolId as id", "schoolName as name").executeFrom(resultList));
}
}

99
orange-demo-single-service/application/src/main/java/com/orange/demo/app/controller/StudentActionStatsController.java Normal file
View File

@@ -0,0 +1,99 @@
package com.orange.demo.app.controller;
import com.github.pagehelper.page.PageMethod;
import com.orange.demo.app.model.*;
import com.orange.demo.app.service.*;
import com.orange.demo.common.core.object.*;
import com.orange.demo.common.core.util.*;
import com.orange.demo.common.core.constant.ErrorCodeEnum;
import com.orange.demo.common.core.annotation.MyRequestBody;
import lombok.extern.slf4j.Slf4j;
import com.alibaba.fastjson.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.*;
/**
* 学生行为统计操作控制器类。
*
* @author Jerry
* @date 2020-09-25
*/
@Slf4j
@RestController
@RequestMapping("/admin/app/studentActionStats")
public class StudentActionStatsController {
@Autowired
private StudentActionStatsService studentActionStatsService;
/**
* 列出符合过滤条件的学生行为统计列表。
*
* @param studentActionStatsFilter 过滤对象。
* @param orderParam 排序参数。
* @param pageParam 分页参数。
* @return 应答结果对象，包含查询结果集。
*/
@PostMapping("/list")
public ResponseResult<JSONObject> list(
@MyRequestBody StudentActionStats studentActionStatsFilter,
@MyRequestBody MyOrderParam orderParam,
@MyRequestBody MyPageParam pageParam) {
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
String orderBy = MyOrderParam.buildOrderBy(orderParam, StudentActionStats.class);
List<StudentActionStats> resultList = studentActionStatsService.getStudentActionStatsListWithRelation(studentActionStatsFilter, orderBy);
return ResponseResult.success(MyPageUtil.makeResponseData(resultList));
}
/**
* 分组列出符合过滤条件的学生行为统计列表。
*
* @param studentActionStatsFilter 过滤对象。
* @param groupParam 分组参数。
* @param orderParam 排序参数。
* @param pageParam 分页参数。
* @return 应答结果对象，包含查询结果集。
*/
@PostMapping("/listWithGroup")
public ResponseResult<JSONObject> listWithGroup(
@MyRequestBody StudentActionStats studentActionStatsFilter,
@MyRequestBody MyGroupParam groupParam,
@MyRequestBody MyOrderParam orderParam,
@MyRequestBody MyPageParam pageParam) {
String orderBy = MyOrderParam.buildOrderBy(orderParam, StudentActionStats.class);
groupParam = MyGroupParam.buildGroupBy(groupParam, StudentActionStats.class);
if (groupParam == null) {
return ResponseResult.error(
ErrorCodeEnum.INVALID_ARGUMENT_FORMAT, "数据参数错误，分组参数不能为空！");
}
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
MyGroupCriteria criteria = groupParam.getGroupCriteria();
List<StudentActionStats> resultList = studentActionStatsService.getGroupedStudentActionStatsListWithRelation(
studentActionStatsFilter, criteria.getGroupSelect(), criteria.getGroupBy(), orderBy);
return ResponseResult.success(MyPageUtil.makeResponseData(resultList));
}
/**
* 查看指定学生行为统计对象详情。
*
* @param statsId 指定对象主键Id。
* @return 应答结果对象，包含对象详情。
*/
@GetMapping("/view")
public ResponseResult<StudentActionStats> view(@RequestParam Long statsId) {
if (MyCommonUtil.existBlankArgument(statsId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
StudentActionStats studentActionStats = studentActionStatsService.getByIdWithRelation(statsId, MyRelationParam.full());
if (studentActionStats == null) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success(studentActionStats);
}
}

152
orange-demo-single-service/application/src/main/java/com/orange/demo/app/controller/StudentActionTransController.java Normal file
View File

@@ -0,0 +1,152 @@
package com.orange.demo.app.controller;
import com.github.pagehelper.page.PageMethod;
import com.orange.demo.app.model.*;
import com.orange.demo.app.service.*;
import com.orange.demo.common.core.object.*;
import com.orange.demo.common.core.util.*;
import com.orange.demo.common.core.constant.ErrorCodeEnum;
import com.orange.demo.common.core.annotation.MyRequestBody;
import com.orange.demo.common.core.validator.UpdateGroup;
import lombok.extern.slf4j.Slf4j;
import com.alibaba.fastjson.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.*;
import javax.validation.groups.Default;
/**
* 学生行为流水操作控制器类。
*
* @author Jerry
* @date 2020-09-25
*/
@Slf4j
@RestController
@RequestMapping("/admin/app/studentActionTrans")
public class StudentActionTransController {
@Autowired
private StudentActionTransService studentActionTransService;
/**
* 新增学生行为流水数据。
*
* @param studentActionTrans 新增对象。
* @return 应答结果对象，包含新增对象主键Id。
*/
@PostMapping("/add")
public ResponseResult<JSONObject> add(@MyRequestBody StudentActionTrans studentActionTrans) {
String errorMessage = MyCommonUtil.getModelValidationError(studentActionTrans);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
// 验证关联Id的数据合法性
CallResult callResult = studentActionTransService.verifyRelatedData(studentActionTrans, null);
if (!callResult.isSuccess()) {
errorMessage = callResult.getErrorMessage();
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
studentActionTrans = studentActionTransService.saveNew(studentActionTrans);
JSONObject responseData = new JSONObject();
responseData.put("transId", studentActionTrans.getTransId());
return ResponseResult.success(responseData);
}
/**
* 更新学生行为流水数据。
*
* @param studentActionTrans 更新对象。
* @return 应答结果对象。
*/
@PostMapping("/update")
public ResponseResult<Void> update(@MyRequestBody StudentActionTrans studentActionTrans) {
String errorMessage = MyCommonUtil.getModelValidationError(studentActionTrans, Default.class, UpdateGroup.class);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
// 验证关联Id的数据合法性
StudentActionTrans originalStudentActionTrans = studentActionTransService.getById(studentActionTrans.getTransId());
if (originalStudentActionTrans == null) {
//NOTE: 修改下面方括号中的话述
errorMessage = "数据验证失败，当前 [数据] 并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
// 验证关联Id的数据合法性
CallResult callResult = studentActionTransService.verifyRelatedData(studentActionTrans, originalStudentActionTrans);
if (!callResult.isSuccess()) {
errorMessage = callResult.getErrorMessage();
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
if (!studentActionTransService.update(studentActionTrans, originalStudentActionTrans)) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success();
}
/**
* 删除学生行为流水数据。
*
* @param transId 删除对象主键Id。
* @return 应答结果对象。
*/
@PostMapping("/delete")
public ResponseResult<Void> delete(@MyRequestBody Long transId) {
String errorMessage;
if (MyCommonUtil.existBlankArgument(transId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
// 验证关联Id的数据合法性
StudentActionTrans originalStudentActionTrans = studentActionTransService.getById(transId);
if (originalStudentActionTrans == null) {
// NOTE: 修改下面方括号中的话述
errorMessage = "数据验证失败，当前 [对象] 并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
if (!studentActionTransService.remove(transId)) {
errorMessage = "数据操作失败，删除的对象不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
return ResponseResult.success();
}
/**
* 列出符合过滤条件的学生行为流水列表。
*
* @param studentActionTransFilter 过滤对象。
* @param orderParam 排序参数。
* @param pageParam 分页参数。
* @return 应答结果对象，包含查询结果集。
*/
@PostMapping("/list")
public ResponseResult<JSONObject> list(
@MyRequestBody StudentActionTrans studentActionTransFilter,
@MyRequestBody MyOrderParam orderParam,
@MyRequestBody MyPageParam pageParam) {
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
String orderBy = MyOrderParam.buildOrderBy(orderParam, StudentActionTrans.class);
List<StudentActionTrans> resultList = studentActionTransService.getStudentActionTransListWithRelation(studentActionTransFilter, orderBy);
return ResponseResult.success(MyPageUtil.makeResponseData(resultList));
}
/**
* 查看指定学生行为流水对象详情。
*
* @param transId 指定对象主键Id。
* @return 应答结果对象，包含对象详情。
*/
@GetMapping("/view")
public ResponseResult<StudentActionTrans> view(@RequestParam Long transId) {
if (MyCommonUtil.existBlankArgument(transId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
StudentActionTrans studentActionTrans = studentActionTransService.getByIdWithRelation(transId, MyRelationParam.full());
if (studentActionTrans == null) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success(studentActionTrans);
}
}

429
orange-demo-single-service/application/src/main/java/com/orange/demo/app/controller/StudentClassController.java Normal file
View File

@@ -0,0 +1,429 @@
package com.orange.demo.app.controller;
import com.github.pagehelper.page.PageMethod;
import com.orange.demo.app.model.*;
import com.orange.demo.app.service.*;
import com.orange.demo.common.core.object.*;
import com.orange.demo.common.core.util.*;
import com.orange.demo.common.core.constant.ErrorCodeEnum;
import com.orange.demo.common.core.annotation.MyRequestBody;
import com.orange.demo.common.core.validator.UpdateGroup;
import lombok.extern.slf4j.Slf4j;
import com.alibaba.fastjson.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.*;
import javax.validation.groups.Default;
import java.util.stream.Collectors;
/**
* 班级数据操作控制器类。
*
* @author Jerry
* @date 2020-09-25
*/
@Slf4j
@RestController
@RequestMapping("/admin/app/studentClass")
public class StudentClassController {
@Autowired
private StudentClassService studentClassService;
@Autowired
private CourseService courseService;
@Autowired
private StudentService studentService;
/**
* 新增班级数据数据。
*
* @param studentClass 新增对象。
* @return 应答结果对象，包含新增对象主键Id。
*/
@PostMapping("/add")
public ResponseResult<JSONObject> add(@MyRequestBody StudentClass studentClass) {
String errorMessage = MyCommonUtil.getModelValidationError(studentClass);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
// 验证关联Id的数据合法性
CallResult callResult = studentClassService.verifyRelatedData(studentClass, null);
if (!callResult.isSuccess()) {
errorMessage = callResult.getErrorMessage();
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
studentClass = studentClassService.saveNew(studentClass);
JSONObject responseData = new JSONObject();
responseData.put("classId", studentClass.getClassId());
return ResponseResult.success(responseData);
}
/**
* 更新班级数据数据。
*
* @param studentClass 更新对象。
* @return 应答结果对象。
*/
@PostMapping("/update")
public ResponseResult<Void> update(@MyRequestBody StudentClass studentClass) {
String errorMessage = MyCommonUtil.getModelValidationError(studentClass, Default.class, UpdateGroup.class);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
// 验证关联Id的数据合法性
StudentClass originalStudentClass = studentClassService.getById(studentClass.getClassId());
if (originalStudentClass == null) {
//NOTE: 修改下面方括号中的话述
errorMessage = "数据验证失败，当前 [数据] 并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
// 验证关联Id的数据合法性
CallResult callResult = studentClassService.verifyRelatedData(studentClass, originalStudentClass);
if (!callResult.isSuccess()) {
errorMessage = callResult.getErrorMessage();
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
if (!studentClassService.update(studentClass, originalStudentClass)) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success();
}
/**
* 删除班级数据数据。
*
* @param classId 删除对象主键Id。
* @return 应答结果对象。
*/
@PostMapping("/delete")
public ResponseResult<Void> delete(@MyRequestBody Long classId) {
String errorMessage;
if (MyCommonUtil.existBlankArgument(classId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
// 验证关联Id的数据合法性
StudentClass originalStudentClass = studentClassService.getById(classId);
if (originalStudentClass == null) {
// NOTE: 修改下面方括号中的话述
errorMessage = "数据验证失败，当前 [对象] 并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
if (!studentClassService.remove(classId)) {
errorMessage = "数据操作失败，删除的对象不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
return ResponseResult.success();
}
/**
* 列出符合过滤条件的班级数据列表。
*
* @param studentClassFilter 过滤对象。
* @param orderParam 排序参数。
* @param pageParam 分页参数。
* @return 应答结果对象，包含查询结果集。
*/
@PostMapping("/list")
public ResponseResult<JSONObject> list(
@MyRequestBody StudentClass studentClassFilter,
@MyRequestBody MyOrderParam orderParam,
@MyRequestBody MyPageParam pageParam) {
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
String orderBy = MyOrderParam.buildOrderBy(orderParam, StudentClass.class);
List<StudentClass> resultList = studentClassService.getStudentClassListWithRelation(studentClassFilter, orderBy);
return ResponseResult.success(MyPageUtil.makeResponseData(resultList));
}
/**
* 查看指定班级数据对象详情。
*
* @param classId 指定对象主键Id。
* @return 应答结果对象，包含对象详情。
*/
@GetMapping("/view")
public ResponseResult<StudentClass> view(@RequestParam Long classId) {
if (MyCommonUtil.existBlankArgument(classId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
StudentClass studentClass = studentClassService.getByIdWithRelation(classId, MyRelationParam.full());
if (studentClass == null) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success(studentClass);
}
/**
* 列出不与指定班级数据存在多对多关系的 [课程数据] 列表数据。通常用于查看添加新 [课程数据] 对象的候选列表。
*
* @param classId 主表关联字段。
* @param courseFilter [课程数据] 过滤对象。
* @param orderParam 排序参数。
* @param pageParam 分页参数。
* @return 应答结果对象，返回符合条件的数据列表。
*/
@PostMapping("/listNotInClassCourse")
public ResponseResult<JSONObject> listNotInClassCourse(
@MyRequestBody Long classId,
@MyRequestBody Course courseFilter,
@MyRequestBody MyOrderParam orderParam,
@MyRequestBody MyPageParam pageParam) {
ResponseResult<Void> verifyResult = this.doClassCourseVerify(classId);
if (!verifyResult.isSuccess()) {
return ResponseResult.errorFrom(verifyResult);
}
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
String orderBy = MyOrderParam.buildOrderBy(orderParam, Course.class);
List<Course> resultList =
courseService.getNotInCourseListByClassId(classId, courseFilter, orderBy);
JSONObject responseData = MyPageUtil.makeResponseData(resultList);
return ResponseResult.success(responseData);
}
/**
* 列出与指定班级数据存在多对多关系的 [课程数据] 列表数据。
*
* @param classId 主表关联字段。
* @param courseFilter [课程数据] 过滤对象。
* @param orderParam 排序参数。
* @param pageParam 分页参数。
* @return 应答结果对象，返回符合条件的数据列表。
*/
@PostMapping("/listClassCourse")
public ResponseResult<JSONObject> listClassCourse(
@MyRequestBody Long classId,
@MyRequestBody Course courseFilter,
@MyRequestBody MyOrderParam orderParam,
@MyRequestBody MyPageParam pageParam) {
ResponseResult<Void> verifyResult = this.doClassCourseVerify(classId);
if (!verifyResult.isSuccess()) {
return ResponseResult.errorFrom(verifyResult);
}
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
String orderBy = MyOrderParam.buildOrderBy(orderParam, Course.class);
List<Course> resultList =
courseService.getCourseListByClassId(classId, courseFilter, orderBy);
JSONObject responseData = MyPageUtil.makeResponseData(resultList);
return ResponseResult.success(responseData);
}
private ResponseResult<Void> doClassCourseVerify(Long classId) {
if (MyCommonUtil.existBlankArgument(classId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
if (!studentClassService.existId(classId)) {
return ResponseResult.error(ErrorCodeEnum.INVALID_RELATED_RECORD_ID);
}
return ResponseResult.success();
}
/**
* 批量添加班级数据和 [课程数据] 对象的多对多关联关系数据。
*
* @param classId 主表主键Id。
* @param classCourseList 关联对象列表。
* @return 应答结果对象。
*/
@PostMapping("/addClassCourse")
public ResponseResult<Void> addClassCourse(
@MyRequestBody Long classId,
@MyRequestBody(elementType = ClassCourse.class) List<ClassCourse> classCourseList) {
if (MyCommonUtil.existBlankArgument(classId, classCourseList)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
for (ClassCourse classCourse : classCourseList) {
String errorMessage = MyCommonUtil.getModelValidationError(classCourse);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
}
Set<Long> courseIdSet =
classCourseList.stream().map(ClassCourse::getCourseId).collect(Collectors.toSet());
if (!studentClassService.existId(classId)
|| !courseService.existUniqueKeyList("courseId", courseIdSet)) {
return ResponseResult.error(ErrorCodeEnum.INVALID_RELATED_RECORD_ID);
}
studentClassService.addClassCourseList(classCourseList, classId);
return ResponseResult.success();
}
/**
* 更新指定班级数据和指定 [课程数据] 的多对多关联数据。
*
* @param classCourse 对多对中间表对象。
* @return 应答结果对象。
*/
@PostMapping("/updateClassCourse")
public ResponseResult<Void> updateClassCourse(@MyRequestBody ClassCourse classCourse) {
String errorMessage = MyCommonUtil.getModelValidationError(classCourse);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
if (!studentClassService.updateClassCourse(classCourse)) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success();
}
/**
* 显示班级数据和指定 [课程数据] 的多对多关联详情数据。
*
* @param classId 主表主键Id。
* @param courseId 从表主键Id。
* @return 应答结果对象，包括中间表详情。
*/
@GetMapping("/viewClassCourse")
public ResponseResult<ClassCourse> viewClassCourse(
@RequestParam Long classId, @RequestParam Long courseId) {
if (MyCommonUtil.existBlankArgument(classId, courseId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
ClassCourse classCourse = studentClassService.getClassCourse(classId, courseId);
if (classCourse == null) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success(classCourse);
}
/**
* 移除指定班级数据和指定 [课程数据] 的多对多关联关系。
*
* @param classId 主表主键Id。
* @param courseId 从表主键Id。
* @return 应答结果对象。
*/
@PostMapping("/deleteClassCourse")
public ResponseResult<Void> deleteClassCourse(
@MyRequestBody Long classId, @MyRequestBody Long courseId) {
if (MyCommonUtil.existBlankArgument(classId, courseId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
if (!studentClassService.removeClassCourse(classId, courseId)) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success();
}
/**
* 列出不与指定班级数据存在多对多关系的 [学生数据] 列表数据。通常用于查看添加新 [学生数据] 对象的候选列表。
*
* @param classId 主表关联字段。
* @param studentFilter [学生数据] 过滤对象。
* @param orderParam 排序参数。
* @param pageParam 分页参数。
* @return 应答结果对象，返回符合条件的数据列表。
*/
@PostMapping("/listNotInClassStudent")
public ResponseResult<JSONObject> listNotInClassStudent(
@MyRequestBody Long classId,
@MyRequestBody Student studentFilter,
@MyRequestBody MyOrderParam orderParam,
@MyRequestBody MyPageParam pageParam) {
ResponseResult<Void> verifyResult = this.doClassStudentVerify(classId);
if (!verifyResult.isSuccess()) {
return ResponseResult.errorFrom(verifyResult);
}
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
String orderBy = MyOrderParam.buildOrderBy(orderParam, Student.class);
List<Student> resultList =
studentService.getNotInStudentListByClassId(classId, studentFilter, orderBy);
JSONObject responseData = MyPageUtil.makeResponseData(resultList);
return ResponseResult.success(responseData);
}
/**
* 列出与指定班级数据存在多对多关系的 [学生数据] 列表数据。
*
* @param classId 主表关联字段。
* @param studentFilter [学生数据] 过滤对象。
* @param orderParam 排序参数。
* @param pageParam 分页参数。
* @return 应答结果对象，返回符合条件的数据列表。
*/
@PostMapping("/listClassStudent")
public ResponseResult<JSONObject> listClassStudent(
@MyRequestBody Long classId,
@MyRequestBody Student studentFilter,
@MyRequestBody MyOrderParam orderParam,
@MyRequestBody MyPageParam pageParam) {
ResponseResult<Void> verifyResult = this.doClassStudentVerify(classId);
if (!verifyResult.isSuccess()) {
return ResponseResult.errorFrom(verifyResult);
}
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
String orderBy = MyOrderParam.buildOrderBy(orderParam, Student.class);
List<Student> resultList =
studentService.getStudentListByClassId(classId, studentFilter, orderBy);
JSONObject responseData = MyPageUtil.makeResponseData(resultList);
return ResponseResult.success(responseData);
}
private ResponseResult<Void> doClassStudentVerify(Long classId) {
if (MyCommonUtil.existBlankArgument(classId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
if (!studentClassService.existId(classId)) {
return ResponseResult.error(ErrorCodeEnum.INVALID_RELATED_RECORD_ID);
}
return ResponseResult.success();
}
/**
* 批量添加班级数据和 [学生数据] 对象的多对多关联关系数据。
*
* @param classId 主表主键Id。
* @param classStudentList 关联对象列表。
* @return 应答结果对象。
*/
@PostMapping("/addClassStudent")
public ResponseResult<Void> addClassStudent(
@MyRequestBody Long classId,
@MyRequestBody(elementType = ClassStudent.class) List<ClassStudent> classStudentList) {
if (MyCommonUtil.existBlankArgument(classId, classStudentList)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
for (ClassStudent classStudent : classStudentList) {
String errorMessage = MyCommonUtil.getModelValidationError(classStudent);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
}
Set<Long> studentIdSet =
classStudentList.stream().map(ClassStudent::getStudentId).collect(Collectors.toSet());
if (!studentClassService.existId(classId)
|| !studentService.existUniqueKeyList("studentId", studentIdSet)) {
return ResponseResult.error(ErrorCodeEnum.INVALID_RELATED_RECORD_ID);
}
studentClassService.addClassStudentList(classStudentList, classId);
return ResponseResult.success();
}
/**
* 移除指定班级数据和指定 [学生数据] 的多对多关联关系。
*
* @param classId 主表主键Id。
* @param studentId 从表主键Id。
* @return 应答结果对象。
*/
@PostMapping("/deleteClassStudent")
public ResponseResult<Void> deleteClassStudent(
@MyRequestBody Long classId, @MyRequestBody Long studentId) {
if (MyCommonUtil.existBlankArgument(classId, studentId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
if (!studentClassService.removeClassStudent(classId, studentId)) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success();
}
}

167
orange-demo-single-service/application/src/main/java/com/orange/demo/app/controller/StudentController.java Normal file
View File

@@ -0,0 +1,167 @@
package com.orange.demo.app.controller;
import cn.jimmyshi.beanquery.BeanQuery;
import com.github.pagehelper.page.PageMethod;
import com.orange.demo.app.model.*;
import com.orange.demo.app.service.*;
import com.orange.demo.common.core.object.*;
import com.orange.demo.common.core.util.*;
import com.orange.demo.common.core.constant.ErrorCodeEnum;
import com.orange.demo.common.core.annotation.MyRequestBody;
import com.orange.demo.common.core.validator.UpdateGroup;
import lombok.extern.slf4j.Slf4j;
import com.alibaba.fastjson.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.*;
import javax.validation.groups.Default;
/**
* 学生数据操作控制器类。
*
* @author Jerry
* @date 2020-09-25
*/
@Slf4j
@RestController
@RequestMapping("/admin/app/student")
public class StudentController {
@Autowired
private StudentService studentService;
/**
* 新增学生数据数据。
*
* @param student 新增对象。
* @return 应答结果对象，包含新增对象主键Id。
*/
@PostMapping("/add")
public ResponseResult<JSONObject> add(@MyRequestBody Student student) {
String errorMessage = MyCommonUtil.getModelValidationError(student);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
// 验证关联Id的数据合法性
CallResult callResult = studentService.verifyRelatedData(student, null);
if (!callResult.isSuccess()) {
errorMessage = callResult.getErrorMessage();
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
student = studentService.saveNew(student);
JSONObject responseData = new JSONObject();
responseData.put("studentId", student.getStudentId());
return ResponseResult.success(responseData);
}
/**
* 更新学生数据数据。
*
* @param student 更新对象。
* @return 应答结果对象。
*/
@PostMapping("/update")
public ResponseResult<Void> update(@MyRequestBody Student student) {
String errorMessage = MyCommonUtil.getModelValidationError(student, Default.class, UpdateGroup.class);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
// 验证关联Id的数据合法性
Student originalStudent = studentService.getById(student.getStudentId());
if (originalStudent == null) {
//NOTE: 修改下面方括号中的话述
errorMessage = "数据验证失败，当前 [数据] 并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
// 验证关联Id的数据合法性
CallResult callResult = studentService.verifyRelatedData(student, originalStudent);
if (!callResult.isSuccess()) {
errorMessage = callResult.getErrorMessage();
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
if (!studentService.update(student, originalStudent)) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success();
}
/**
* 删除学生数据数据。
*
* @param studentId 删除对象主键Id。
* @return 应答结果对象。
*/
@PostMapping("/delete")
public ResponseResult<Void> delete(@MyRequestBody Long studentId) {
String errorMessage;
if (MyCommonUtil.existBlankArgument(studentId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
// 验证关联Id的数据合法性
Student originalStudent = studentService.getById(studentId);
if (originalStudent == null) {
// NOTE: 修改下面方括号中的话述
errorMessage = "数据验证失败，当前 [对象] 并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
if (!studentService.remove(studentId)) {
errorMessage = "数据操作失败，删除的对象不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
return ResponseResult.success();
}
/**
* 列出符合过滤条件的学生数据列表。
*
* @param studentFilter 过滤对象。
* @param orderParam 排序参数。
* @param pageParam 分页参数。
* @return 应答结果对象，包含查询结果集。
*/
@PostMapping("/list")
public ResponseResult<JSONObject> list(
@MyRequestBody Student studentFilter,
@MyRequestBody MyOrderParam orderParam,
@MyRequestBody MyPageParam pageParam) {
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
String orderBy = MyOrderParam.buildOrderBy(orderParam, Student.class);
List<Student> resultList = studentService.getStudentListWithRelation(studentFilter, orderBy);
return ResponseResult.success(MyPageUtil.makeResponseData(resultList));
}
/**
* 查看指定学生数据对象详情。
*
* @param studentId 指定对象主键Id。
* @return 应答结果对象，包含对象详情。
*/
@GetMapping("/view")
public ResponseResult<Student> view(@RequestParam Long studentId) {
if (MyCommonUtil.existBlankArgument(studentId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
Student student = studentService.getByIdWithRelation(studentId, MyRelationParam.full());
if (student == null) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success(student);
}
/**
* 以字典形式返回全部学生数据数据集合。字典的键值为[studentId, studentName]。
* 白名单接口，登录用户均可访问。
*
* @param filter 过滤对象。
* @return 应答结果对象，包含的数据为 List<Map<String, String>>，map中包含两条记录，key的值分别是id和name，value对应具体数据。
*/
@GetMapping("/listDictStudent")
public ResponseResult<List<Map<String, Object>>> listDictStudent(Student filter) {
List<Student> resultList = studentService.getListByFilter(filter, null);
return ResponseResult.success(BeanQuery.select(
"studentId as id", "studentName as name").executeFrom(resultList));
}
}

13
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/AreaCodeMapper.java Normal file
View File

@@ -0,0 +1,13 @@
package com.orange.demo.app.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.app.model.AreaCode;
/**
* 行政区划数据操作访问接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface AreaCodeMapper extends BaseDaoMapper<AreaCode> {
}

13
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/ClassCourseMapper.java Normal file
View File

@@ -0,0 +1,13 @@
package com.orange.demo.app.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.app.model.ClassCourse;
/**
* 数据操作访问接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface ClassCourseMapper extends BaseDaoMapper<ClassCourse> {
}

13
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/ClassStudentMapper.java Normal file
View File

@@ -0,0 +1,13 @@
package com.orange.demo.app.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.app.model.ClassStudent;
/**
* 数据操作访问接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface ClassStudentMapper extends BaseDaoMapper<ClassStudent> {
}

52
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/CourseMapper.java Normal file
View File

@@ -0,0 +1,52 @@
package com.orange.demo.app.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.app.model.Course;
import org.apache.ibatis.annotations.Param;
import java.util.*;
/**
* 课程数据数据操作访问接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface CourseMapper extends BaseDaoMapper<Course> {
/**
* 获取过滤后的对象列表。
*
* @param courseFilter 主表过滤对象。
* @param orderBy 排序字符串，order by从句的参数。
* @return 对象列表。
*/
List<Course> getCourseList(
@Param("courseFilter") Course courseFilter, @Param("orderBy") String orderBy);
/**
* 根据关联主表Id，获取关联从表数据列表。
*
* @param classId 关联主表Id。
* @param courseFilter 从表过滤对象。
* @param orderBy 排序字符串，order by从句的参数。
* @return 从表数据列表。
*/
List<Course> getCourseListByClassId(
@Param("classId") Long classId,
@Param("courseFilter") Course courseFilter,
@Param("orderBy") String orderBy);
/**
* 根据关联主表Id，获取关联从表中没有和主表建立关联关系的数据列表。
*
* @param classId 关联主表Id。
* @param courseFilter 过滤对象。
* @param orderBy 排序字符串，order by从句的参数。
* @return 与主表没有建立关联的从表数据列表。
*/
List<Course> getNotInCourseListByClassId(
@Param("classId") Long classId,
@Param("courseFilter") Course courseFilter,
@Param("orderBy") String orderBy);
}

41
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/CourseTransStatsMapper.java Normal file
View File

@@ -0,0 +1,41 @@
package com.orange.demo.app.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.app.model.CourseTransStats;
import org.apache.ibatis.annotations.Param;
import java.util.*;
/**
* 课程统计数据操作访问接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface CourseTransStatsMapper extends BaseDaoMapper<CourseTransStats> {
/**
* 获取分组计算后的数据对象列表。
*
* @param courseTransStatsFilter 主表过滤对象。
* @param groupSelect 分组显示字段列表字符串，SELECT从句的参数。
* @param groupBy 分组字段列表字符串，GROUP BY从句的参数。
* @param orderBy 排序字符串，ORDER BY从句的参数。
* @return 对象列表。
*/
List<CourseTransStats> getGroupedCourseTransStatsList(
@Param("courseTransStatsFilter") CourseTransStats courseTransStatsFilter,
@Param("groupSelect") String groupSelect,
@Param("groupBy") String groupBy,
@Param("orderBy") String orderBy);
/**
* 获取过滤后的对象列表。
*
* @param courseTransStatsFilter 主表过滤对象。
* @param orderBy 排序字符串，order by从句的参数。
* @return 对象列表。
*/
List<CourseTransStats> getCourseTransStatsList(
@Param("courseTransStatsFilter") CourseTransStats courseTransStatsFilter, @Param("orderBy") String orderBy);
}

13
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/GradeMapper.java Normal file
View File

@@ -0,0 +1,13 @@
package com.orange.demo.app.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.app.model.Grade;
/**
* 年级数据操作访问接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface GradeMapper extends BaseDaoMapper<Grade> {
}

13
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/MaterialEditionMapper.java Normal file
View File

@@ -0,0 +1,13 @@
package com.orange.demo.app.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.app.model.MaterialEdition;
/**
* 数据操作访问接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface MaterialEditionMapper extends BaseDaoMapper<MaterialEdition> {
}

26
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/SchoolInfoMapper.java Normal file
View File

@@ -0,0 +1,26 @@
package com.orange.demo.app.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.app.model.SchoolInfo;
import org.apache.ibatis.annotations.Param;
import java.util.*;
/**
* 校区数据数据操作访问接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface SchoolInfoMapper extends BaseDaoMapper<SchoolInfo> {
/**
* 获取过滤后的对象列表。
*
* @param schoolInfoFilter 主表过滤对象。
* @param orderBy 排序字符串，order by从句的参数。
* @return 对象列表。
*/
List<SchoolInfo> getSchoolInfoList(
@Param("schoolInfoFilter") SchoolInfo schoolInfoFilter, @Param("orderBy") String orderBy);
}

41
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/StudentActionStatsMapper.java Normal file
View File

@@ -0,0 +1,41 @@
package com.orange.demo.app.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.app.model.StudentActionStats;
import org.apache.ibatis.annotations.Param;
import java.util.*;
/**
* 学生行为统计数据操作访问接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface StudentActionStatsMapper extends BaseDaoMapper<StudentActionStats> {
/**
* 获取分组计算后的数据对象列表。
*
* @param studentActionStatsFilter 主表过滤对象。
* @param groupSelect 分组显示字段列表字符串，SELECT从句的参数。
* @param groupBy 分组字段列表字符串，GROUP BY从句的参数。
* @param orderBy 排序字符串，ORDER BY从句的参数。
* @return 对象列表。
*/
List<StudentActionStats> getGroupedStudentActionStatsList(
@Param("studentActionStatsFilter") StudentActionStats studentActionStatsFilter,
@Param("groupSelect") String groupSelect,
@Param("groupBy") String groupBy,
@Param("orderBy") String orderBy);
/**
* 获取过滤后的对象列表。
*
* @param studentActionStatsFilter 主表过滤对象。
* @param orderBy 排序字符串，order by从句的参数。
* @return 对象列表。
*/
List<StudentActionStats> getStudentActionStatsList(
@Param("studentActionStatsFilter") StudentActionStats studentActionStatsFilter, @Param("orderBy") String orderBy);
}

26
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/StudentActionTransMapper.java Normal file
View File

@@ -0,0 +1,26 @@
package com.orange.demo.app.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.app.model.StudentActionTrans;
import org.apache.ibatis.annotations.Param;
import java.util.*;
/**
* 学生行为流水数据操作访问接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface StudentActionTransMapper extends BaseDaoMapper<StudentActionTrans> {
/**
* 获取过滤后的对象列表。
*
* @param studentActionTransFilter 主表过滤对象。
* @param orderBy 排序字符串，order by从句的参数。
* @return 对象列表。
*/
List<StudentActionTrans> getStudentActionTransList(
@Param("studentActionTransFilter") StudentActionTrans studentActionTransFilter, @Param("orderBy") String orderBy);
}

26
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/StudentClassMapper.java Normal file
View File

@@ -0,0 +1,26 @@
package com.orange.demo.app.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.app.model.StudentClass;
import org.apache.ibatis.annotations.Param;
import java.util.*;
/**
* 班级数据数据操作访问接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface StudentClassMapper extends BaseDaoMapper<StudentClass> {
/**
* 获取过滤后的对象列表。
*
* @param studentClassFilter 主表过滤对象。
* @param orderBy 排序字符串，order by从句的参数。
* @return 对象列表。
*/
List<StudentClass> getStudentClassList(
@Param("studentClassFilter") StudentClass studentClassFilter, @Param("orderBy") String orderBy);
}

52
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/StudentMapper.java Normal file
View File

@@ -0,0 +1,52 @@
package com.orange.demo.app.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.app.model.Student;
import org.apache.ibatis.annotations.Param;
import java.util.*;
/**
* 学生数据数据操作访问接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface StudentMapper extends BaseDaoMapper<Student> {
/**
* 获取过滤后的对象列表。
*
* @param studentFilter 主表过滤对象。
* @param orderBy 排序字符串，order by从句的参数。
* @return 对象列表。
*/
List<Student> getStudentList(
@Param("studentFilter") Student studentFilter, @Param("orderBy") String orderBy);
/**
* 根据关联主表Id，获取关联从表数据列表。
*
* @param classId 关联主表Id。
* @param studentFilter 从表过滤对象。
* @param orderBy 排序字符串，order by从句的参数。
* @return 从表数据列表。
*/
List<Student> getStudentListByClassId(
@Param("classId") Long classId,
@Param("studentFilter") Student studentFilter,
@Param("orderBy") String orderBy);
/**
* 根据关联主表Id，获取关联从表中没有和主表建立关联关系的数据列表。
*
* @param classId 关联主表Id。
* @param studentFilter 过滤对象。
* @param orderBy 排序字符串，order by从句的参数。
* @return 与主表没有建立关联的从表数据列表。
*/
List<Student> getNotInStudentListByClassId(
@Param("classId") Long classId,
@Param("studentFilter") Student studentFilter,
@Param("orderBy") String orderBy);
}

10
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/mapper/AreaCodeMapper.xml Normal file
View File

@@ -0,0 +1,10 @@
<?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.orange.demo.app.dao.AreaCodeMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.app.model.AreaCode">
<id column="area_id" jdbcType="BIGINT" property="areaId"/>
<result column="area_name" jdbcType="VARCHAR" property="areaName"/>
<result column="area_level" jdbcType="INTEGER" property="areaLevel"/>
<result column="parent_id" jdbcType="BIGINT" property="parentId"/>
</resultMap>
</mapper>

9
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/mapper/ClassCourseMapper.xml Normal file
View File

@@ -0,0 +1,9 @@
<?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.orange.demo.app.dao.ClassCourseMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.app.model.ClassCourse">
<id column="class_id" jdbcType="BIGINT" property="classId"/>
<id column="course_id" jdbcType="BIGINT" property="courseId"/>
<result column="course_order" jdbcType="TINYINT" property="courseOrder"/>
</resultMap>
</mapper>

8
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/mapper/ClassStudentMapper.xml Normal file
View File

@@ -0,0 +1,8 @@
<?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.orange.demo.app.dao.ClassStudentMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.app.model.ClassStudent">
<id column="class_id" jdbcType="BIGINT" property="classId"/>
<id column="student_id" jdbcType="BIGINT" property="studentId"/>
</resultMap>
</mapper>

95
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/mapper/CourseMapper.xml Normal file
View File

@@ -0,0 +1,95 @@
<?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.orange.demo.app.dao.CourseMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.app.model.Course">
<id column="course_id" jdbcType="BIGINT" property="courseId"/>
<result column="course_name" jdbcType="VARCHAR" property="courseName"/>
<result column="price" jdbcType="DECIMAL" property="price"/>
<result column="description" jdbcType="VARCHAR" property="description"/>
<result column="difficulty" jdbcType="INTEGER" property="difficulty"/>
<result column="grade_id" jdbcType="TINYINT" property="gradeId"/>
<result column="subject_id" jdbcType="TINYINT" property="subjectId"/>
<result column="class_hour" jdbcType="INTEGER" property="classHour"/>
<result column="picture_url" jdbcType="VARCHAR" property="pictureUrl"/>
<result column="create_user_id" jdbcType="BIGINT" property="createUserId"/>
<result column="create_time" jdbcType="TIMESTAMP" property="createTime"/>
<result column="update_time" jdbcType="TIMESTAMP" property="updateTime"/>
</resultMap>
<sql id="filterRef">
<if test="courseFilter != null">
<if test="courseFilter.courseName != null and courseFilter.courseName != ''">
<bind name = "safeCourseName" value = "'%' + courseFilter.courseName + '%'" />
AND zz_course.course_name LIKE #{safeCourseName}
</if>
<if test="courseFilter.priceStart != null">
AND zz_course.price &gt;= #{courseFilter.priceStart}
</if>
<if test="courseFilter.priceEnd != null">
AND zz_course.price &lt;= #{courseFilter.priceEnd}
</if>
<if test="courseFilter.difficulty != null">
AND zz_course.difficulty = #{courseFilter.difficulty}
</if>
<if test="courseFilter.gradeId != null">
AND zz_course.grade_id = #{courseFilter.gradeId}
</if>
<if test="courseFilter.subjectId != null">
AND zz_course.subject_id = #{courseFilter.subjectId}
</if>
<if test="courseFilter.classHourStart != null">
AND zz_course.class_hour &gt;= #{courseFilter.classHourStart}
</if>
<if test="courseFilter.classHourEnd != null">
AND zz_course.class_hour &lt;= #{courseFilter.classHourEnd}
</if>
<if test="courseFilter.createTimeStart != null and courseFilter.createTimeStart != ''">
AND zz_course.create_time &gt;= #{courseFilter.createTimeStart}
</if>
<if test="courseFilter.createTimeEnd != null and courseFilter.createTimeEnd != ''">
AND zz_course.create_time &lt;= #{courseFilter.createTimeEnd}
</if>
</if>
</sql>
<select id="getCourseList" resultMap="BaseResultMap" parameterType="com.orange.demo.app.model.Course">
SELECT * FROM zz_course
<where>
<include refid="filterRef"/>
</where>
<if test="orderBy != null">
ORDER BY ${orderBy}
</if>
</select>
<select id="getCourseListByClassId" resultMap="BaseResultMap">
SELECT
zz_course.*
FROM
zz_course,
zz_class_course
<where>
AND zz_class_course.class_id = #{classId}
AND zz_class_course.course_id = zz_course.course_id
<include refid="filterRef"/>
</where>
<if test="orderBy != null">
ORDER BY ${orderBy}
</if>
</select>
<select id="getNotInCourseListByClassId" resultMap="BaseResultMap">
SELECT
zz_course.*
FROM
zz_course
<where>
AND NOT EXISTS (SELECT * FROM zz_class_course
WHERE zz_class_course.class_id = #{classId} AND zz_class_course.course_id = zz_course.course_id)
<include refid="filterRef"/>
</where>
<if test="orderBy != null">
ORDER BY ${orderBy}
</if>
</select>
</mapper>

60
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/mapper/CourseTransStatsMapper.xml Normal file
View File

@@ -0,0 +1,60 @@
<?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.orange.demo.app.dao.CourseTransStatsMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.app.model.CourseTransStats">
<id column="stats_id" jdbcType="BIGINT" property="statsId"/>
<result column="stats_date" jdbcType="DATE" property="statsDate"/>
<result column="subject_id" jdbcType="TINYINT" property="subjectId"/>
<result column="grade_id" jdbcType="TINYINT" property="gradeId"/>
<result column="grade_name" jdbcType="VARCHAR" property="gradeName"/>
<result column="course_id" jdbcType="BIGINT" property="courseId"/>
<result column="course_name" jdbcType="VARCHAR" property="courseName"/>
<result column="student_attend_count" jdbcType="INTEGER" property="studentAttendCount"/>
<result column="student_flower_amount" jdbcType="INTEGER" property="studentFlowerAmount"/>
<result column="student_flower_count" jdbcType="INTEGER" property="studentFlowerCount"/>
</resultMap>
<sql id="filterRef">
<if test="courseTransStatsFilter != null">
<if test="courseTransStatsFilter.statsDateStart != null and courseTransStatsFilter.statsDateStart != ''">
AND zz_course_trans_stats.stats_date &gt;= #{courseTransStatsFilter.statsDateStart}
</if>
<if test="courseTransStatsFilter.statsDateEnd != null and courseTransStatsFilter.statsDateEnd != ''">
AND zz_course_trans_stats.stats_date &lt;= #{courseTransStatsFilter.statsDateEnd}
</if>
<if test="courseTransStatsFilter.subjectId != null">
AND zz_course_trans_stats.subject_id = #{courseTransStatsFilter.subjectId}
</if>
<if test="courseTransStatsFilter.gradeId != null">
AND zz_course_trans_stats.grade_id = #{courseTransStatsFilter.gradeId}
</if>
</if>
</sql>
<select id="getGroupedCourseTransStatsList" resultMap="BaseResultMap" parameterType="com.orange.demo.app.model.CourseTransStats">
SELECT * FROM
(SELECT
SUM(student_attend_count) student_attend_count,
SUM(student_flower_amount) student_flower_amount,
SUM(student_flower_count) student_flower_count,
${groupSelect}
FROM zz_course_trans_stats
<where>
<include refid="filterRef"/>
</where>
GROUP BY ${groupBy}) zz_course_trans_stats
<if test="orderBy != null">
ORDER BY ${orderBy}
</if>
</select>
<select id="getCourseTransStatsList" resultMap="BaseResultMap" parameterType="com.orange.demo.app.model.CourseTransStats">
SELECT * FROM zz_course_trans_stats
<where>
<include refid="filterRef"/>
</where>
<if test="orderBy != null">
ORDER BY ${orderBy}
</if>
</select>
</mapper>

9
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/mapper/GradeMapper.xml Normal file
View File

@@ -0,0 +1,9 @@
<?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.orange.demo.app.dao.GradeMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.app.model.Grade">
<id column="grade_id" jdbcType="INTEGER" property="gradeId"/>
<result column="grade_name" jdbcType="VARCHAR" property="gradeName"/>
<result column="status" jdbcType="INTEGER" property="status"/>
</resultMap>
</mapper>

9
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/mapper/MaterialEditionMapper.xml Normal file
View File

@@ -0,0 +1,9 @@
<?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.orange.demo.app.dao.MaterialEditionMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.app.model.MaterialEdition">
<id column="edition_id" jdbcType="INTEGER" property="editionId"/>
<result column="edition_name" jdbcType="VARCHAR" property="editionName"/>
<result column="status" jdbcType="INTEGER" property="status"/>
</resultMap>
</mapper>

35
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/mapper/SchoolInfoMapper.xml Normal file
View File

@@ -0,0 +1,35 @@
<?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.orange.demo.app.dao.SchoolInfoMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.app.model.SchoolInfo">
<id column="school_id" jdbcType="BIGINT" property="schoolId"/>
<result column="school_name" jdbcType="VARCHAR" property="schoolName"/>
<result column="province_id" jdbcType="BIGINT" property="provinceId"/>
<result column="city_id" jdbcType="BIGINT" property="cityId"/>
</resultMap>
<sql id="filterRef">
<if test="schoolInfoFilter != null">
<if test="schoolInfoFilter.schoolName != null and schoolInfoFilter.schoolName != ''">
<bind name = "safeSchoolName" value = "'%' + schoolInfoFilter.schoolName + '%'" />
AND zz_school_info.school_name LIKE #{safeSchoolName}
</if>
<if test="schoolInfoFilter.provinceId != null">
AND zz_school_info.province_id = #{schoolInfoFilter.provinceId}
</if>
<if test="schoolInfoFilter.cityId != null">
AND zz_school_info.city_id = #{schoolInfoFilter.cityId}
</if>
</if>
</sql>
<select id="getSchoolInfoList" resultMap="BaseResultMap" parameterType="com.orange.demo.app.model.SchoolInfo">
SELECT * FROM zz_school_info
<where>
<include refid="filterRef"/>
</where>
<if test="orderBy != null">
ORDER BY ${orderBy}
</if>
</select>
</mapper>

86
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/mapper/StudentActionStatsMapper.xml Normal file
View File

@@ -0,0 +1,86 @@
<?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.orange.demo.app.dao.StudentActionStatsMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.app.model.StudentActionStats">
<id column="stats_id" jdbcType="BIGINT" property="statsId"/>
<result column="stats_date" jdbcType="DATE" property="statsDate"/>
<result column="stats_month" jdbcType="DATE" property="statsMonth"/>
<result column="grade_id" jdbcType="INTEGER" property="gradeId"/>
<result column="province_id" jdbcType="BIGINT" property="provinceId"/>
<result column="city_id" jdbcType="BIGINT" property="cityId"/>
<result column="buy_course_amount" jdbcType="INTEGER" property="buyCourseAmount"/>
<result column="buy_course_count" jdbcType="INTEGER" property="buyCourseCount"/>
<result column="buy_video_amount" jdbcType="INTEGER" property="buyVideoAmount"/>
<result column="buy_video_count" jdbcType="INTEGER" property="buyVideoCount"/>
<result column="buy_paper_amount" jdbcType="INTEGER" property="buyPaperAmount"/>
<result column="buy_paper_count" jdbcType="INTEGER" property="buyPaperCount"/>
<result column="buy_flower_amount" jdbcType="INTEGER" property="buyFlowerAmount"/>
<result column="buy_flower_count" jdbcType="INTEGER" property="buyFlowerCount"/>
<result column="recharge_coin_amount" jdbcType="INTEGER" property="rechargeCoinAmount"/>
<result column="recharge_coin_count" jdbcType="INTEGER" property="rechargeCoinCount"/>
<result column="do_course_count" jdbcType="INTEGER" property="doCourseCount"/>
<result column="watch_video_count" jdbcType="INTEGER" property="watchVideoCount"/>
<result column="watch_video_total_second" jdbcType="INTEGER" property="watchVideoTotalSecond"/>
<result column="do_exercise_count" jdbcType="INTEGER" property="doExerciseCount"/>
<result column="do_exercise_correct_count" jdbcType="INTEGER" property="doExerciseCorrectCount"/>
</resultMap>
<sql id="filterRef">
<if test="studentActionStatsFilter != null">
<if test="studentActionStatsFilter.statsDateStart != null and studentActionStatsFilter.statsDateStart != ''">
AND zz_student_action_stats.stats_date &gt;= #{studentActionStatsFilter.statsDateStart}
</if>
<if test="studentActionStatsFilter.statsDateEnd != null and studentActionStatsFilter.statsDateEnd != ''">
AND zz_student_action_stats.stats_date &lt;= #{studentActionStatsFilter.statsDateEnd}
</if>
<if test="studentActionStatsFilter.gradeId != null">
AND zz_student_action_stats.grade_id = #{studentActionStatsFilter.gradeId}
</if>
<if test="studentActionStatsFilter.provinceId != null">
AND zz_student_action_stats.province_id = #{studentActionStatsFilter.provinceId}
</if>
<if test="studentActionStatsFilter.cityId != null">
AND zz_student_action_stats.city_id = #{studentActionStatsFilter.cityId}
</if>
</if>
</sql>
<select id="getGroupedStudentActionStatsList" resultMap="BaseResultMap" parameterType="com.orange.demo.app.model.StudentActionStats">
SELECT * FROM
(SELECT
SUM(buy_course_amount) buy_course_amount,
COUNT(buy_course_count) buy_course_count,
SUM(buy_video_amount) buy_video_amount,
COUNT(buy_video_count) buy_video_count,
SUM(buy_paper_amount) buy_paper_amount,
COUNT(buy_paper_count) buy_paper_count,
SUM(buy_flower_amount) buy_flower_amount,
COUNT(buy_flower_count) buy_flower_count,
SUM(recharge_coin_amount) recharge_coin_amount,
COUNT(recharge_coin_count) recharge_coin_count,
SUM(do_course_count) do_course_count,
SUM(watch_video_count) watch_video_count,
SUM(watch_video_total_second) watch_video_total_second,
SUM(do_exercise_count) do_exercise_count,
SUM(do_exercise_correct_count) do_exercise_correct_count,
${groupSelect}
FROM zz_student_action_stats
<where>
<include refid="filterRef"/>
</where>
GROUP BY ${groupBy}) zz_student_action_stats
<if test="orderBy != null">
ORDER BY ${orderBy}
</if>
</select>
<select id="getStudentActionStatsList" resultMap="BaseResultMap" parameterType="com.orange.demo.app.model.StudentActionStats">
SELECT * FROM zz_student_action_stats
<where>
<include refid="filterRef"/>
</where>
<if test="orderBy != null">
ORDER BY ${orderBy}
</if>
</select>
</mapper>

57
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/mapper/StudentActionTransMapper.xml Normal file
View File

@@ -0,0 +1,57 @@
<?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.orange.demo.app.dao.StudentActionTransMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.app.model.StudentActionTrans">
<id column="trans_id" jdbcType="BIGINT" property="transId"/>
<result column="student_id" jdbcType="BIGINT" property="studentId"/>
<result column="student_name" jdbcType="VARCHAR" property="studentName"/>
<result column="school_id" jdbcType="BIGINT" property="schoolId"/>
<result column="grade_id" jdbcType="INTEGER" property="gradeId"/>
<result column="action_type" jdbcType="TINYINT" property="actionType"/>
<result column="device_type" jdbcType="TINYINT" property="deviceType"/>
<result column="watch_video_seconds" jdbcType="INTEGER" property="watchVideoSeconds"/>
<result column="flower_count" jdbcType="INTEGER" property="flowerCount"/>
<result column="paper_count" jdbcType="INTEGER" property="paperCount"/>
<result column="video_count" jdbcType="INTEGER" property="videoCount"/>
<result column="course_count" jdbcType="INTEGER" property="courseCount"/>
<result column="coin_count" jdbcType="INTEGER" property="coinCount"/>
<result column="exercise_correct_flag" jdbcType="TINYINT" property="exerciseCorrectFlag"/>
<result column="create_time" jdbcType="TIMESTAMP" property="createTime"/>
</resultMap>
<sql id="filterRef">
<if test="studentActionTransFilter != null">
<if test="studentActionTransFilter.studentId != null">
AND zz_student_action_trans.student_id = #{studentActionTransFilter.studentId}
</if>
<if test="studentActionTransFilter.schoolId != null">
AND zz_student_action_trans.school_id = #{studentActionTransFilter.schoolId}
</if>
<if test="studentActionTransFilter.gradeId != null">
AND zz_student_action_trans.grade_id = #{studentActionTransFilter.gradeId}
</if>
<if test="studentActionTransFilter.actionType != null">
AND zz_student_action_trans.action_type = #{studentActionTransFilter.actionType}
</if>
<if test="studentActionTransFilter.deviceType != null">
AND zz_student_action_trans.device_type = #{studentActionTransFilter.deviceType}
</if>
<if test="studentActionTransFilter.createTimeStart != null and studentActionTransFilter.createTimeStart != ''">
AND zz_student_action_trans.create_time &gt;= #{studentActionTransFilter.createTimeStart}
</if>
<if test="studentActionTransFilter.createTimeEnd != null and studentActionTransFilter.createTimeEnd != ''">
AND zz_student_action_trans.create_time &lt;= #{studentActionTransFilter.createTimeEnd}
</if>
</if>
</sql>
<select id="getStudentActionTransList" resultMap="BaseResultMap" parameterType="com.orange.demo.app.model.StudentActionTrans">
SELECT * FROM zz_student_action_trans
<where>
<include refid="filterRef"/>
</where>
<if test="orderBy != null">
ORDER BY ${orderBy}
</if>
</select>
</mapper>

40
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/mapper/StudentClassMapper.xml Normal file
View File

@@ -0,0 +1,40 @@
<?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.orange.demo.app.dao.StudentClassMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.app.model.StudentClass">
<id column="class_id" jdbcType="BIGINT" property="classId"/>
<result column="class_name" jdbcType="VARCHAR" property="className"/>
<result column="school_id" jdbcType="BIGINT" property="schoolId"/>
<result column="leader_id" jdbcType="BIGINT" property="leaderId"/>
<result column="finish_class_hour" jdbcType="INTEGER" property="finishClassHour"/>
<result column="class_level" jdbcType="TINYINT" property="classLevel"/>
<result column="create_user_id" jdbcType="BIGINT" property="createUserId"/>
<result column="create_time" jdbcType="TIMESTAMP" property="createTime"/>
<result column="status" jdbcType="TINYINT" property="status"/>
</resultMap>
<sql id="filterRef">
<if test="studentClassFilter != null">
<if test="studentClassFilter.className != null and studentClassFilter.className != ''">
AND zz_class.class_name = #{studentClassFilter.className}
</if>
<if test="studentClassFilter.schoolId != null">
AND zz_class.school_id = #{studentClassFilter.schoolId}
</if>
<if test="studentClassFilter.classLevel != null">
AND zz_class.class_level = #{studentClassFilter.classLevel}
</if>
</if>
AND zz_class.status = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
</sql>
<select id="getStudentClassList" resultMap="BaseResultMap" parameterType="com.orange.demo.app.model.StudentClass">
SELECT * FROM zz_class
<where>
<include refid="filterRef"/>
</where>
<if test="orderBy != null">
ORDER BY ${orderBy}
</if>
</select>
</mapper>

101
orange-demo-single-service/application/src/main/java/com/orange/demo/app/dao/mapper/StudentMapper.xml Normal file
View File

@@ -0,0 +1,101 @@
<?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.orange.demo.app.dao.StudentMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.app.model.Student">
<id column="student_id" jdbcType="BIGINT" property="studentId"/>
<result column="login_mobile" jdbcType="VARCHAR" property="loginMobile"/>
<result column="student_name" jdbcType="VARCHAR" property="studentName"/>
<result column="province_id" jdbcType="BIGINT" property="provinceId"/>
<result column="city_id" jdbcType="BIGINT" property="cityId"/>
<result column="district_id" jdbcType="BIGINT" property="districtId"/>
<result column="gender" jdbcType="INTEGER" property="gender"/>
<result column="birthday" jdbcType="DATE" property="birthday"/>
<result column="experience_level" jdbcType="TINYINT" property="experienceLevel"/>
<result column="total_coin" jdbcType="INTEGER" property="totalCoin"/>
<result column="left_coin" jdbcType="INTEGER" property="leftCoin"/>
<result column="grade_id" jdbcType="INTEGER" property="gradeId"/>
<result column="school_id" jdbcType="BIGINT" property="schoolId"/>
<result column="register_time" jdbcType="TIMESTAMP" property="registerTime"/>
<result column="status" jdbcType="TINYINT" property="status"/>
</resultMap>
<sql id="filterRef">
<if test="studentFilter != null">
<if test="studentFilter.provinceId != null">
AND zz_student.province_id = #{studentFilter.provinceId}
</if>
<if test="studentFilter.cityId != null">
AND zz_student.city_id = #{studentFilter.cityId}
</if>
<if test="studentFilter.districtId != null">
AND zz_student.district_id = #{studentFilter.districtId}
</if>
<if test="studentFilter.birthdayStart != null and studentFilter.birthdayStart != ''">
AND zz_student.birthday &gt;= #{studentFilter.birthdayStart}
</if>
<if test="studentFilter.birthdayEnd != null and studentFilter.birthdayEnd != ''">
AND zz_student.birthday &lt;= #{studentFilter.birthdayEnd}
</if>
<if test="studentFilter.gradeId != null">
AND zz_student.grade_id = #{studentFilter.gradeId}
</if>
<if test="studentFilter.schoolId != null">
AND zz_student.school_id = #{studentFilter.schoolId}
</if>
<if test="studentFilter.registerTimeStart != null and studentFilter.registerTimeStart != ''">
AND zz_student.register_time &gt;= #{studentFilter.registerTimeStart}
</if>
<if test="studentFilter.registerTimeEnd != null and studentFilter.registerTimeEnd != ''">
AND zz_student.register_time &lt;= #{studentFilter.registerTimeEnd}
</if>
<if test="studentFilter.status != null">
AND zz_student.status = #{studentFilter.status}
</if>
<if test="studentFilter.searchString != null and studentFilter.searchString != ''">
<bind name = "safeSearchString" value = "'%' + studentFilter.searchString + '%'" />
AND CONCAT(IFNULL(zz_student.login_mobile,''), IFNULL(zz_student.student_name,'')) LIKE #{safeSearchString}
</if>
</if>
</sql>
<select id="getStudentList" resultMap="BaseResultMap" parameterType="com.orange.demo.app.model.Student">
SELECT * FROM zz_student
<where>
<include refid="filterRef"/>
</where>
<if test="orderBy != null">
ORDER BY ${orderBy}
</if>
</select>
<select id="getStudentListByClassId" resultMap="BaseResultMap">
SELECT
zz_student.*
FROM
zz_student,
zz_class_student
<where>
AND zz_class_student.class_id = #{classId}
AND zz_class_student.student_id = zz_student.student_id
<include refid="filterRef"/>
</where>
<if test="orderBy != null">
ORDER BY ${orderBy}
</if>
</select>
<select id="getNotInStudentListByClassId" resultMap="BaseResultMap">
SELECT
zz_student.*
FROM
zz_student
<where>
AND NOT EXISTS (SELECT * FROM zz_class_student
WHERE zz_class_student.class_id = #{classId} AND zz_class_student.student_id = zz_student.student_id)
<include refid="filterRef"/>
</where>
<if test="orderBy != null">
ORDER BY ${orderBy}
</if>
</select>
</mapper>

41
orange-demo-single-service/application/src/main/java/com/orange/demo/app/model/AreaCode.java Normal file
View File

@@ -0,0 +1,41 @@
package com.orange.demo.app.model;
import lombok.Data;
import javax.persistence.*;
/**
* 行政区划实体对象。
*
* @author Jerry
* @date 2020-09-25
*/
@Data
@Table(name = "zz_area_code")
public class AreaCode {
/**
* 行政区划主键Id
*/
@Id
@Column(name = "area_id")
private Long areaId;
/**
* 行政区划名称
*/
@Column(name = "area_name")
private String areaName;
/**
* 行政区划级别 (1: 省级别 2: 市级别 3: 区级别)
*/
@Column(name = "area_level")
private Integer areaLevel;
/**
* 父级行政区划Id
*/
@Column(name = "parent_id")
private Long parentId;
}

40
orange-demo-single-service/application/src/main/java/com/orange/demo/app/model/ClassCourse.java Normal file
View File

@@ -0,0 +1,40 @@
package com.orange.demo.app.model;
import com.orange.demo.common.core.validator.UpdateGroup;
import lombok.Data;
import javax.persistence.*;
import javax.validation.constraints.*;
/**
* ClassCourse实体对象。
*
* @author Jerry
* @date 2020-09-25
*/
@Data
@Table(name = "zz_class_course")
public class ClassCourse {
/**
* 班级Id。
*/
@NotNull(message = "数据验证失败，班级Id不能为空！", groups = {UpdateGroup.class})
@Id
@Column(name = "class_id")
private Long classId;
/**
* 课程Id。
*/
@NotNull(message = "数据验证失败，课程Id不能为空！", groups = {UpdateGroup.class})
@Id
@Column(name = "course_id")
private Long courseId;
/**
* 课程顺序(数值越小越靠前)。
*/
@NotNull(message = "数据验证失败，课程顺序(数值越小越靠前)不能为空！", groups = {UpdateGroup.class})
@Column(name = "course_order")
private Integer courseOrder;
}

33
orange-demo-single-service/application/src/main/java/com/orange/demo/app/model/ClassStudent.java Normal file
View File

@@ -0,0 +1,33 @@
package com.orange.demo.app.model;
import com.orange.demo.common.core.validator.UpdateGroup;
import lombok.Data;
import javax.persistence.*;
import javax.validation.constraints.*;
/**
* ClassStudent实体对象。
*
* @author Jerry
* @date 2020-09-25
*/
@Data
@Table(name = "zz_class_student")
public class ClassStudent {
/**
* 班级Id。
*/
@NotNull(message = "数据验证失败，班级Id不能为空！", groups = {UpdateGroup.class})
@Id
@Column(name = "class_id")
private Long classId;
/**
* 学生Id。
*/
@NotNull(message = "数据验证失败，学生Id不能为空！", groups = {UpdateGroup.class})
@Id
@Column(name = "student_id")
private Long studentId;
}

163
orange-demo-single-service/application/src/main/java/com/orange/demo/app/model/Course.java Normal file
View File

@@ -0,0 +1,163 @@
package com.orange.demo.app.model;
import com.orange.demo.app.model.constant.CourseDifficult;
import com.orange.demo.application.common.constant.Subject;
import com.orange.demo.common.core.annotation.RelationDict;
import com.orange.demo.common.core.annotation.RelationConstDict;
import com.orange.demo.common.core.validator.UpdateGroup;
import com.orange.demo.common.core.validator.ConstDictRef;
import lombok.Data;
import javax.persistence.*;
import javax.validation.constraints.*;
import java.math.BigDecimal;
import java.util.Date;
import java.util.Map;
/**
* Course实体对象。
*
* @author Jerry
* @date 2020-09-25
*/
@Data
@Table(name = "zz_course")
public class Course {
/**
* 主键Id。
*/
@NotNull(message = "数据验证失败，主键Id不能为空！", groups = {UpdateGroup.class})
@Id
@Column(name = "course_id")
private Long courseId;
/**
* 课程名称。
*/
@NotBlank(message = "数据验证失败，课程名称不能为空！")
@Column(name = "course_name")
private String courseName;
/**
* 课程价格。
*/
@NotNull(message = "数据验证失败，课程价格不能为空！")
private BigDecimal price;
/**
* 课程描述。
*/
private String description;
/**
* 课程难度(0: 容易 1: 普通 2: 很难)。
*/
@NotNull(message = "数据验证失败，课程难度不能为空！")
@ConstDictRef(constDictClass = CourseDifficult.class, message = "数据验证失败，课程难度为无效值！")
private Integer difficulty;
/**
* 年级Id。
*/
@NotNull(message = "数据验证失败，所属年级不能为空！")
@Column(name = "grade_id")
private Integer gradeId;
/**
* 学科Id。
*/
@NotNull(message = "数据验证失败，所属学科不能为空！")
@ConstDictRef(constDictClass = Subject.class, message = "数据验证失败，所属学科为无效值！")
@Column(name = "subject_id")
private Integer subjectId;
/**
* 课时数量。
*/
@NotNull(message = "数据验证失败，课时数量不能为空！")
@Column(name = "class_hour")
private Integer classHour;
/**
* 多张课程图片地址。
*/
@NotBlank(message = "数据验证失败，课程图片不能为空！")
@Column(name = "picture_url")
private String pictureUrl;
/**
* 创建用户Id。
*/
@Column(name = "create_user_id")
private Long createUserId;
/**
* 创建时间。
*/
@Column(name = "create_time")
private Date createTime;
/**
* 最后修改时间。
*/
@Column(name = "update_time")
private Date updateTime;
/**
* price 范围过滤起始值(>=)。
*/
@Transient
private BigDecimal priceStart;
/**
* price 范围过滤结束值(<=)。
*/
@Transient
private BigDecimal priceEnd;
/**
* classHour 范围过滤起始值(>=)。
*/
@Transient
private Integer classHourStart;
/**
* classHour 范围过滤结束值(<=)。
*/
@Transient
private Integer classHourEnd;
/**
* createTime 范围过滤起始值(>=)。
*/
@Transient
private String createTimeStart;
/**
* createTime 范围过滤结束值(<=)。
*/
@Transient
private String createTimeEnd;
@RelationDict(
masterIdField = "gradeId",
slaveServiceName = "gradeService",
slaveModelClass = Grade.class,
slaveIdField = "gradeId",
slaveNameField = "gradeName")
@Transient
private Map<String, Object> gradeIdDictMap;
@RelationConstDict(
masterIdField = "difficulty",
constantDictClass = CourseDifficult.class)
@Transient
private Map<String, Object> difficultyDictMap;
@RelationConstDict(
masterIdField = "subjectId",
constantDictClass = Subject.class)
@Transient
private Map<String, Object> subjectIdDictMap;
}

122
orange-demo-single-service/application/src/main/java/com/orange/demo/app/model/CourseTransStats.java Normal file
View File

@@ -0,0 +1,122 @@
package com.orange.demo.app.model;
import com.orange.demo.application.common.constant.Subject;
import com.orange.demo.common.core.annotation.RelationDict;
import com.orange.demo.common.core.annotation.RelationConstDict;
import com.orange.demo.common.core.validator.UpdateGroup;
import com.orange.demo.common.core.validator.ConstDictRef;
import lombok.Data;
import javax.persistence.*;
import javax.validation.constraints.*;
import java.util.Date;
import java.util.Map;
/**
* CourseTransStats实体对象。
*
* @author Jerry
* @date 2020-09-25
*/
@Data
@Table(name = "zz_course_trans_stats")
public class CourseTransStats {
/**
* 主键Id。
*/
@NotNull(message = "数据验证失败，主键Id不能为空！", groups = {UpdateGroup.class})
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "stats_id")
private Long statsId;
/**
* 统计日期。
*/
@NotNull(message = "数据验证失败，统计日期不能为空！")
@Column(name = "stats_date")
private Date statsDate;
/**
* 科目Id。
*/
@NotNull(message = "数据验证失败，所属科目不能为空！")
@ConstDictRef(constDictClass = Subject.class, message = "数据验证失败，所属科目为无效值！")
@Column(name = "subject_id")
private Integer subjectId;
/**
* 年级Id。
*/
@NotNull(message = "数据验证失败，所属年级不能为空！")
@Column(name = "grade_id")
private Integer gradeId;
/**
* 年级名称。
*/
@Column(name = "grade_name")
private String gradeName;
/**
* 课程Id。
*/
@NotNull(message = "数据验证失败，课程Id不能为空！")
@Column(name = "course_id")
private Long courseId;
/**
* 课程名称。
*/
@Column(name = "course_name")
private String courseName;
/**
* 学生上课次数。
*/
@NotNull(message = "数据验证失败，上课次数不能为空！")
@Column(name = "student_attend_count")
private Integer studentAttendCount;
/**
* 学生献花数量。
*/
@NotNull(message = "数据验证失败，献花数量不能为空！")
@Column(name = "student_flower_amount")
private Integer studentFlowerAmount;
/**
* 学生献花次数。
*/
@NotNull(message = "数据验证失败，献花次数不能为空！")
@Column(name = "student_flower_count")
private Integer studentFlowerCount;
/**
* statsDate 范围过滤起始值(>=)。
*/
@Transient
private String statsDateStart;
/**
* statsDate 范围过滤结束值(<=)。
*/
@Transient
private String statsDateEnd;
@RelationDict(
masterIdField = "gradeId",
slaveServiceName = "gradeService",
slaveModelClass = Grade.class,
slaveIdField = "gradeId",
slaveNameField = "gradeName")
@Transient
private Map<String, Object> gradeIdDictMap;
@RelationConstDict(
masterIdField = "subjectId",
constantDictClass = Subject.class)
@Transient
private Map<String, Object> subjectIdDictMap;
}

42
orange-demo-single-service/application/src/main/java/com/orange/demo/app/model/Grade.java Normal file
View File

@@ -0,0 +1,42 @@
package com.orange.demo.app.model;
import com.alibaba.fastjson.annotation.JSONField;
import com.orange.demo.common.core.annotation.DeletedFlagColumn;
import com.orange.demo.common.core.validator.UpdateGroup;
import lombok.Data;
import javax.persistence.*;
import javax.validation.constraints.*;
/**
* Grade实体对象。
*
* @author Jerry
* @date 2020-09-25
*/
@Data
@Table(name = "zz_grade")
public class Grade {
/**
* 主键Id。
*/
@NotNull(message = "数据验证失败，主键Id不能为空！", groups = {UpdateGroup.class})
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "grade_id")
private Integer gradeId;
/**
* 年级名称。
*/
@NotBlank(message = "数据验证失败，年级名称不能为空！")
@Column(name = "grade_name")
private String gradeName;
/**
* 逻辑删除标记字段(1: 正常 -1: 已删除)。
*/
@JSONField(serialize = false)
@DeletedFlagColumn
private Integer status;
}

39
orange-demo-single-service/application/src/main/java/com/orange/demo/app/model/MaterialEdition.java Normal file
View File

@@ -0,0 +1,39 @@
package com.orange.demo.app.model;
import com.orange.demo.common.core.validator.UpdateGroup;
import lombok.Data;
import javax.persistence.*;
import javax.validation.constraints.*;
/**
* MaterialEdition实体对象。
*
* @author Jerry
* @date 2020-09-25
*/
@Data
@Table(name = "zz_material_edition")
public class MaterialEdition {
/**
* 主键Id。
*/
@NotNull(message = "数据验证失败，主键Id不能为空！", groups = {UpdateGroup.class})
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "edition_id")
private Integer editionId;
/**
* 教材版本名称。
*/
@NotBlank(message = "数据验证失败，教材版本名称不能为空！")
@Column(name = "edition_name")
private String editionName;
/**
* 是否正在使用（0：不是，1：是）。
*/
@NotNull(message = "数据验证失败，是否正在使用（0：不是，1：是）不能为空！")
private Integer status;
}

67
orange-demo-single-service/application/src/main/java/com/orange/demo/app/model/SchoolInfo.java Normal file
View File

@@ -0,0 +1,67 @@
package com.orange.demo.app.model;
import com.orange.demo.common.core.annotation.RelationDict;
import com.orange.demo.common.core.validator.UpdateGroup;
import lombok.Data;
import javax.persistence.*;
import javax.validation.constraints.*;
import java.util.Map;
/**
* SchoolInfo实体对象。
*
* @author Jerry
* @date 2020-09-25
*/
@Data
@Table(name = "zz_school_info")
public class SchoolInfo {
/**
* 学校Id。
*/
@NotNull(message = "数据验证失败，学校Id不能为空！", groups = {UpdateGroup.class})
@Id
@Column(name = "school_id")
private Long schoolId;
/**
* 学校名称。
*/
@NotBlank(message = "数据验证失败，学校名称不能为空！")
@Column(name = "school_name")
private String schoolName;
/**
* 所在省Id。
*/
@NotNull(message = "数据验证失败，所在省份不能为空！")
@Column(name = "province_id")
private Long provinceId;
/**
* 所在城市Id。
*/
@NotNull(message = "数据验证失败，所在城市不能为空！")
@Column(name = "city_id")
private Long cityId;
@RelationDict(
masterIdField = "provinceId",
slaveServiceName = "areaCodeService",
slaveModelClass = AreaCode.class,
slaveIdField = "areaId",
slaveNameField = "areaName")
@Transient
private Map<String, Object> provinceIdDictMap;
@RelationDict(
masterIdField = "cityId",
slaveServiceName = "areaCodeService",
slaveModelClass = AreaCode.class,
slaveIdField = "areaId",
slaveNameField = "areaName")
@Transient
private Map<String, Object> cityIdDictMap;
}

224
orange-demo-single-service/application/src/main/java/com/orange/demo/app/model/Student.java Normal file
View File

@@ -0,0 +1,224 @@
package com.orange.demo.app.model;
import com.orange.demo.application.common.constant.Gender;
import com.orange.demo.application.common.constant.ExpLevel;
import com.orange.demo.application.common.constant.StudentStatus;
import com.orange.demo.common.core.annotation.RelationDict;
import com.orange.demo.common.core.annotation.RelationConstDict;
import com.orange.demo.common.core.validator.UpdateGroup;
import com.orange.demo.common.core.validator.ConstDictRef;
import lombok.Data;
import javax.persistence.*;
import javax.validation.constraints.*;
import java.util.Date;
import java.util.Map;
/**
* Student实体对象。
*
* @author Jerry
* @date 2020-09-25
*/
@Data
@Table(name = "zz_student")
public class Student {
/**
* 学生Id。
*/
@NotNull(message = "数据验证失败，学生Id不能为空！", groups = {UpdateGroup.class})
@Id
@Column(name = "student_id")
private Long studentId;
/**
* 登录手机。
*/
@NotBlank(message = "数据验证失败，手机号码不能为空！")
@Column(name = "login_mobile")
private String loginMobile;
/**
* 学生姓名。
*/
@NotBlank(message = "数据验证失败，学生姓名不能为空！")
@Column(name = "student_name")
private String studentName;
/**
* 所在省份Id。
*/
@NotNull(message = "数据验证失败，所在省份不能为空！")
@Column(name = "province_id")
private Long provinceId;
/**
* 所在城市Id。
*/
@NotNull(message = "数据验证失败，所在城市不能为空！")
@Column(name = "city_id")
private Long cityId;
/**
* 区县Id。
*/
@NotNull(message = "数据验证失败，所在区县不能为空！")
@Column(name = "district_id")
private Long districtId;
/**
* 学生性别 (0: 女生 1: 男生)。
*/
@NotNull(message = "数据验证失败，学生性别不能为空！")
@ConstDictRef(constDictClass = Gender.class, message = "数据验证失败，学生性别为无效值！")
private Integer gender;
/**
* 生日。
*/
@NotNull(message = "数据验证失败，出生日期不能为空！")
private Date birthday;
/**
* 经验等级 (0: 初级 1: 中级 2: 高级 3: 资深)。
*/
@NotNull(message = "数据验证失败，经验等级不能为空！")
@ConstDictRef(constDictClass = ExpLevel.class, message = "数据验证失败，经验等级为无效值！")
@Column(name = "experience_level")
private Integer experienceLevel;
/**
* 总共充值学币数量。
*/
@NotNull(message = "数据验证失败，充值学币不能为空！", groups = {UpdateGroup.class})
@Column(name = "total_coin")
private Integer totalCoin;
/**
* 可用学币数量。
*/
@NotNull(message = "数据验证失败，剩余学币不能为空！")
@Column(name = "left_coin")
private Integer leftCoin;
/**
* 年级Id。
*/
@NotNull(message = "数据验证失败，年级不能为空！")
@Column(name = "grade_id")
private Integer gradeId;
/**
* 校区Id。
*/
@NotNull(message = "数据验证失败，所属校区不能为空！")
@Column(name = "school_id")
private Long schoolId;
/**
* 注册时间。
*/
@Column(name = "register_time")
private Date registerTime;
/**
* 学生状态 (0: 正常 1: 锁定 2: 注销)。
*/
@NotNull(message = "数据验证失败，学生状态不能为空！", groups = {UpdateGroup.class})
@ConstDictRef(constDictClass = StudentStatus.class, message = "数据验证失败，学生状态为无效值！")
private Integer status;
/**
* birthday 范围过滤起始值(>=)。
*/
@Transient
private String birthdayStart;
/**
* birthday 范围过滤结束值(<=)。
*/
@Transient
private String birthdayEnd;
/**
* registerTime 范围过滤起始值(>=)。
*/
@Transient
private String registerTimeStart;
/**
* registerTime 范围过滤结束值(<=)。
*/
@Transient
private String registerTimeEnd;
/**
* login_mobile / student_name LIKE搜索字符串。
*/
@Transient
private String searchString;
@RelationDict(
masterIdField = "provinceId",
slaveServiceName = "areaCodeService",
slaveModelClass = AreaCode.class,
slaveIdField = "areaId",
slaveNameField = "areaName")
@Transient
private Map<String, Object> provinceIdDictMap;
@RelationDict(
masterIdField = "cityId",
slaveServiceName = "areaCodeService",
slaveModelClass = AreaCode.class,
slaveIdField = "areaId",
slaveNameField = "areaName")
@Transient
private Map<String, Object> cityIdDictMap;
@RelationDict(
masterIdField = "districtId",
slaveServiceName = "areaCodeService",
slaveModelClass = AreaCode.class,
slaveIdField = "areaId",
slaveNameField = "areaName")
@Transient
private Map<String, Object> districtIdDictMap;
@RelationDict(
masterIdField = "gradeId",
slaveServiceName = "gradeService",
slaveModelClass = Grade.class,
slaveIdField = "gradeId",
slaveNameField = "gradeName")
@Transient
private Map<String, Object> gradeIdDictMap;
@RelationDict(
masterIdField = "schoolId",
slaveServiceName = "schoolInfoService",
slaveModelClass = SchoolInfo.class,
slaveIdField = "schoolId",
slaveNameField = "schoolName")
@Transient
private Map<String, Object> schoolIdDictMap;
@RelationConstDict(
masterIdField = "gender",
constantDictClass = Gender.class)
@Transient
private Map<String, Object> genderDictMap;
@RelationConstDict(
masterIdField = "experienceLevel",
constantDictClass = ExpLevel.class)
@Transient
private Map<String, Object> experienceLevelDictMap;
@RelationConstDict(
masterIdField = "status",
constantDictClass = StudentStatus.class)
@Transient
private Map<String, Object> statusDictMap;
}

207
orange-demo-single-service/application/src/main/java/com/orange/demo/app/model/StudentActionStats.java Normal file
View File

@@ -0,0 +1,207 @@
package com.orange.demo.app.model;
import com.orange.demo.common.core.annotation.RelationDict;
import com.orange.demo.common.core.validator.UpdateGroup;
import lombok.Data;
import javax.persistence.*;
import javax.validation.constraints.*;
import java.util.Date;
import java.util.Map;
/**
* StudentActionStats实体对象。
*
* @author Jerry
* @date 2020-09-25
*/
@Data
@Table(name = "zz_student_action_stats")
public class StudentActionStats {
/**
* 主键Id。
*/
@NotNull(message = "数据验证失败，主键Id不能为空！", groups = {UpdateGroup.class})
@Id
@Column(name = "stats_id")
private Long statsId;
/**
* 统计日期。
*/
@NotNull(message = "数据验证失败，统计日期不能为空！")
@Column(name = "stats_date")
private Date statsDate;
/**
* 统计小时。
*/
@Column(name = "stats_month")
private Date statsMonth;
/**
* 年级Id。
*/
@NotNull(message = "数据验证失败，所属年级不能为空！")
@Column(name = "grade_id")
private Integer gradeId;
/**
* 学生所在省Id。
*/
@NotNull(message = "数据验证失败，所在省份不能为空！")
@Column(name = "province_id")
private Long provinceId;
/**
* 学生所在城市Id。
*/
@NotNull(message = "数据验证失败，所在城市不能为空！", groups = {UpdateGroup.class})
@Column(name = "city_id")
private Long cityId;
/**
* 购课学币数量。
*/
@NotNull(message = "数据验证失败，购课学币数量不能为空！", groups = {UpdateGroup.class})
@Column(name = "buy_course_amount")
private Integer buyCourseAmount;
/**
* 购买课程次数。
*/
@NotNull(message = "数据验证失败，购买课程次数不能为空！", groups = {UpdateGroup.class})
@Column(name = "buy_course_count")
private Integer buyCourseCount;
/**
* 购买视频学币数量。
*/
@NotNull(message = "数据验证失败，购买视频学币数量不能为空！", groups = {UpdateGroup.class})
@Column(name = "buy_video_amount")
private Integer buyVideoAmount;
/**
* 购买视频次数。
*/
@NotNull(message = "数据验证失败，购买视频次数不能为空！", groups = {UpdateGroup.class})
@Column(name = "buy_video_count")
private Integer buyVideoCount;
/**
* 购买作业学币数量。
*/
@NotNull(message = "数据验证失败，购买作业学币数量不能为空！", groups = {UpdateGroup.class})
@Column(name = "buy_paper_amount")
private Integer buyPaperAmount;
/**
* 购买作业次数。
*/
@NotNull(message = "数据验证失败，购买作业次数不能为空！", groups = {UpdateGroup.class})
@Column(name = "buy_paper_count")
private Integer buyPaperCount;
/**
* 购买献花数量。
*/
@NotNull(message = "数据验证失败，购买献花数量不能为空！", groups = {UpdateGroup.class})
@Column(name = "buy_flower_amount")
private Integer buyFlowerAmount;
/**
* 购买献花次数。
*/
@NotNull(message = "数据验证失败，购买献花次数不能为空！", groups = {UpdateGroup.class})
@Column(name = "buy_flower_count")
private Integer buyFlowerCount;
/**
* 充值学币数量。
*/
@NotNull(message = "数据验证失败，充值学币数量不能为空！", groups = {UpdateGroup.class})
@Column(name = "recharge_coin_amount")
private Integer rechargeCoinAmount;
/**
* 充值学币次数。
*/
@NotNull(message = "数据验证失败，充值学币次数不能为空！", groups = {UpdateGroup.class})
@Column(name = "recharge_coin_count")
private Integer rechargeCoinCount;
/**
* 线下课程上课次数。
*/
@NotNull(message = "数据验证失败，线下课程上课次数不能为空！")
@Column(name = "do_course_count")
private Integer doCourseCount;
/**
* 观看视频次数。
*/
@NotNull(message = "数据验证失败，观看视频次数不能为空！", groups = {UpdateGroup.class})
@Column(name = "watch_video_count")
private Integer watchVideoCount;
/**
* 购买献花消费学币数量。
*/
@NotNull(message = "数据验证失败，购买献花消费学币数量不能为空！")
@Column(name = "watch_video_total_second")
private Integer watchVideoTotalSecond;
/**
* 做题数量。
*/
@NotNull(message = "数据验证失败，做题数量不能为空！", groups = {UpdateGroup.class})
@Column(name = "do_exercise_count")
private Integer doExerciseCount;
/**
* 做题正确的数量。
*/
@NotNull(message = "数据验证失败，做题正确的数量不能为空！", groups = {UpdateGroup.class})
@Column(name = "do_exercise_correct_count")
private Integer doExerciseCorrectCount;
/**
* statsDate 范围过滤起始值(>=)。
*/
@Transient
private String statsDateStart;
/**
* statsDate 范围过滤结束值(<=)。
*/
@Transient
private String statsDateEnd;
@RelationDict(
masterIdField = "gradeId",
slaveServiceName = "gradeService",
slaveModelClass = Grade.class,
slaveIdField = "gradeId",
slaveNameField = "gradeName")
@Transient
private Map<String, Object> gradeIdDictMap;
@RelationDict(
masterIdField = "provinceId",
slaveServiceName = "areaCodeService",
slaveModelClass = AreaCode.class,
slaveIdField = "areaId",
slaveNameField = "areaName")
@Transient
private Map<String, Object> provinceIdDictMap;
@RelationDict(
masterIdField = "cityId",
slaveServiceName = "areaCodeService",
slaveModelClass = AreaCode.class,
slaveIdField = "areaId",
slaveNameField = "areaName")
@Transient
private Map<String, Object> cityIdDictMap;
}

168
orange-demo-single-service/application/src/main/java/com/orange/demo/app/model/StudentActionTrans.java Normal file
View File

@@ -0,0 +1,168 @@
package com.orange.demo.app.model;
import com.orange.demo.application.common.constant.StudentActionType;
import com.orange.demo.application.common.constant.DeviceType;
import com.orange.demo.common.core.annotation.RelationDict;
import com.orange.demo.common.core.annotation.RelationConstDict;
import com.orange.demo.common.core.validator.UpdateGroup;
import com.orange.demo.common.core.validator.ConstDictRef;
import lombok.Data;
import javax.persistence.*;
import javax.validation.constraints.*;
import java.util.Date;
import java.util.Map;
/**
* StudentActionTrans实体对象。
*
* @author Jerry
* @date 2020-09-25
*/
@Data
@Table(name = "zz_student_action_trans")
public class StudentActionTrans {
/**
* 主键Id。
*/
@NotNull(message = "数据验证失败，主键Id不能为空！", groups = {UpdateGroup.class})
@Id
@Column(name = "trans_id")
private Long transId;
/**
* 学生Id。
*/
@NotNull(message = "数据验证失败，学生Id不能为空！")
@Column(name = "student_id")
private Long studentId;
/**
* 学生名称。
*/
@NotBlank(message = "数据验证失败，学生名称不能为空！")
@Column(name = "student_name")
private String studentName;
/**
* 学生校区。
*/
@NotNull(message = "数据验证失败，学生校区不能为空！")
@Column(name = "school_id")
private Long schoolId;
/**
* 年级Id。
*/
@NotNull(message = "数据验证失败，学生年级不能为空！")
@Column(name = "grade_id")
private Integer gradeId;
/**
* 行为类型(0: 充值 1: 购课 2: 上课签到 3: 上课签退 4: 看视频课 5: 做作业 6: 刷题 7: 献花)。
*/
@NotNull(message = "数据验证失败，行为类型不能为空！")
@ConstDictRef(constDictClass = StudentActionType.class, message = "数据验证失败，行为类型为无效值！")
@Column(name = "action_type")
private Integer actionType;
/**
* 设备类型(0: iOS 1: Android 2: PC)。
*/
@NotNull(message = "数据验证失败，设备类型不能为空！")
@ConstDictRef(constDictClass = DeviceType.class, message = "数据验证失败，设备类型为无效值！")
@Column(name = "device_type")
private Integer deviceType;
/**
* 看视频秒数。
*/
@Column(name = "watch_video_seconds")
private Integer watchVideoSeconds;
/**
* 购买献花数量。
*/
@Column(name = "flower_count")
private Integer flowerCount;
/**
* 购买作业数量。
*/
@Column(name = "paper_count")
private Integer paperCount;
/**
* 购买视频数量。
*/
@Column(name = "video_count")
private Integer videoCount;
/**
* 购买课程数量。
*/
@Column(name = "course_count")
private Integer courseCount;
/**
* 充值学币数量。
*/
@Column(name = "coin_count")
private Integer coinCount;
/**
* 做题是否正确标记。
*/
@Column(name = "exercise_correct_flag")
private Integer exerciseCorrectFlag;
/**
* 发生时间。
*/
@NotNull(message = "数据验证失败，发生时间不能为空！")
@Column(name = "create_time")
private Date createTime;
/**
* createTime 范围过滤起始值(>=)。
*/
@Transient
private String createTimeStart;
/**
* createTime 范围过滤结束值(<=)。
*/
@Transient
private String createTimeEnd;
@RelationDict(
masterIdField = "schoolId",
slaveServiceName = "schoolInfoService",
slaveModelClass = SchoolInfo.class,
slaveIdField = "schoolId",
slaveNameField = "schoolName")
@Transient
private Map<String, Object> schoolIdDictMap;
@RelationDict(
masterIdField = "gradeId",
slaveServiceName = "gradeService",
slaveModelClass = Grade.class,
slaveIdField = "gradeId",
slaveNameField = "gradeName")
@Transient
private Map<String, Object> gradeIdDictMap;
@RelationConstDict(
masterIdField = "actionType",
constantDictClass = StudentActionType.class)
@Transient
private Map<String, Object> actionTypeDictMap;
@RelationConstDict(
masterIdField = "deviceType",
constantDictClass = DeviceType.class)
@Transient
private Map<String, Object> deviceTypeDictMap;
}

113
orange-demo-single-service/application/src/main/java/com/orange/demo/app/model/StudentClass.java Normal file
View File

@@ -0,0 +1,113 @@
package com.orange.demo.app.model;
import com.alibaba.fastjson.annotation.JSONField;
import com.orange.demo.app.model.constant.ClassLevel;
import com.orange.demo.common.core.annotation.RelationDict;
import com.orange.demo.common.core.annotation.RelationConstDict;
import com.orange.demo.common.core.annotation.DeletedFlagColumn;
import com.orange.demo.common.core.validator.UpdateGroup;
import com.orange.demo.common.core.validator.ConstDictRef;
import lombok.Data;
import javax.persistence.*;
import javax.validation.constraints.*;
import java.util.Date;
import java.util.Map;
/**
* StudentClass实体对象。
*
* @author Jerry
* @date 2020-09-25
*/
@Data
@Table(name = "zz_class")
public class StudentClass {
/**
* 班级Id。
*/
@NotNull(message = "数据验证失败，班级Id不能为空！", groups = {UpdateGroup.class})
@Id
@Column(name = "class_id")
private Long classId;
/**
* 班级名称。
*/
@NotBlank(message = "数据验证失败，班级名称不能为空！")
@Column(name = "class_name")
private String className;
/**
* 学校Id。
*/
@NotNull(message = "数据验证失败，所属校区不能为空！")
@Column(name = "school_id")
private Long schoolId;
/**
* 学生班长Id。
*/
@NotNull(message = "数据验证失败，学生班长不能为空！")
@Column(name = "leader_id")
private Long leaderId;
/**
* 已完成课时数量。
*/
@NotNull(message = "数据验证失败，已完成课时不能为空！", groups = {UpdateGroup.class})
@Column(name = "finish_class_hour")
private Integer finishClassHour;
/**
* 班级级别(0: 初级班 1: 培优班 2: 冲刺提分班 3: 竞赛班)。
*/
@NotNull(message = "数据验证失败，班级级别不能为空！")
@ConstDictRef(constDictClass = ClassLevel.class, message = "数据验证失败，班级级别为无效值！")
@Column(name = "class_level")
private Integer classLevel;
/**
* 创建用户。
*/
@Column(name = "create_user_id")
private Long createUserId;
/**
* 班级创建时间。
*/
@Column(name = "create_time")
private Date createTime;
/**
* 逻辑删除标记字段(1: 正常 -1: 已删除)。
*/
@JSONField(serialize = false)
@DeletedFlagColumn
private Integer status;
@RelationDict(
masterIdField = "schoolId",
slaveServiceName = "schoolInfoService",
slaveModelClass = SchoolInfo.class,
slaveIdField = "schoolId",
slaveNameField = "schoolName")
@Transient
private Map<String, Object> schoolIdDictMap;
@RelationDict(
masterIdField = "leaderId",
slaveServiceName = "studentService",
slaveModelClass = Student.class,
slaveIdField = "studentId",
slaveNameField = "studentName")
@Transient
private Map<String, Object> leaderIdDictMap;
@RelationConstDict(
masterIdField = "classLevel",
constantDictClass = ClassLevel.class)
@Transient
private Map<String, Object> classLevelDictMap;
}

49
orange-demo-single-service/application/src/main/java/com/orange/demo/app/model/constant/ClassLevel.java Normal file
View File

@@ -0,0 +1,49 @@
package com.orange.demo.app.model.constant;
import java.util.HashMap;
import java.util.Map;
/**
* 班级级别常量字典对象。
*
* @author Jerry
* @date 2020-09-25
*/
public final class ClassLevel {
/**
* 初级班。
*/
public static final int NORMAL = 0;
/**
* 中级班。
*/
public static final int MIDDLE = 1;
/**
* 高级班。
*/
public static final int HIGH = 2;
private static final Map<Object, String> DICT_MAP = new HashMap<>(3);
static {
DICT_MAP.put(NORMAL, "初级班");
DICT_MAP.put(MIDDLE, "中级班");
DICT_MAP.put(HIGH, "高级班");
}
/**
* 判断参数是否为当前常量字典的合法值。
*
* @param value 待验证的参数值。
* @return 合法返回true，否则false。
*/
public static boolean isValid(Integer value) {
return value != null && DICT_MAP.containsKey(value);
}
/**
* 私有构造函数，明确标识该常量类的作用。
*/
private ClassLevel() {
}
}

44
orange-demo-single-service/application/src/main/java/com/orange/demo/app/model/constant/ClassStatus.java Normal file
View File

@@ -0,0 +1,44 @@
package com.orange.demo.app.model.constant;
import java.util.HashMap;
import java.util.Map;
/**
* 班级状态常量字典对象。
*
* @author Jerry
* @date 2020-09-25
*/
public final class ClassStatus {
/**
* 正常。
*/
public static final int NORAML = 1;
/**
* 解散。
*/
public static final int DELETED = -1;
private static final Map<Object, String> DICT_MAP = new HashMap<>(2);
static {
DICT_MAP.put(NORAML, "正常");
DICT_MAP.put(DELETED, "解散");
}
/**
* 判断参数是否为当前常量字典的合法值。
*
* @param value 待验证的参数值。
* @return 合法返回true，否则false。
*/
public static boolean isValid(Integer value) {
return value != null && DICT_MAP.containsKey(value);
}
/**
* 私有构造函数，明确标识该常量类的作用。
*/
private ClassStatus() {
}
}

49
orange-demo-single-service/application/src/main/java/com/orange/demo/app/model/constant/CourseDifficult.java Normal file
View File

@@ -0,0 +1,49 @@
package com.orange.demo.app.model.constant;
import java.util.HashMap;
import java.util.Map;
/**
* 课程难度常量字典对象。
*
* @author Jerry
* @date 2020-09-25
*/
public final class CourseDifficult {
/**
* 容易。
*/
public static final int NORMAL = 0;
/**
* 普通。
*/
public static final int MIDDLE = 1;
/**
* 困难。
*/
public static final int HIGH = 2;
private static final Map<Object, String> DICT_MAP = new HashMap<>(3);
static {
DICT_MAP.put(NORMAL, "容易");
DICT_MAP.put(MIDDLE, "普通");
DICT_MAP.put(HIGH, "困难");
}
/**
* 判断参数是否为当前常量字典的合法值。
*
* @param value 待验证的参数值。
* @return 合法返回true，否则false。
*/
public static boolean isValid(Integer value) {
return value != null && DICT_MAP.containsKey(value);
}
/**
* 私有构造函数，明确标识该常量类的作用。
*/
private CourseDifficult() {
}
}

57
orange-demo-single-service/application/src/main/java/com/orange/demo/app/service/AreaCodeService.java Normal file
View File

@@ -0,0 +1,57 @@
package com.orange.demo.app.service;
import com.orange.demo.app.dao.AreaCodeMapper;
import com.orange.demo.app.model.AreaCode;
import com.orange.demo.common.core.cache.MapTreeDictionaryCache;
import com.orange.demo.common.core.base.service.BaseDictService;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import tk.mybatis.mapper.entity.Example;
import java.util.Collection;
import java.util.List;
/**
* 行政区划的Service类。
*
* @author Jerry
* @date 2020-09-25
*/
@Service
public class AreaCodeService extends BaseDictService<AreaCode, Long> {
@Autowired
private AreaCodeMapper areaCodeMapper;
public AreaCodeService() {
super();
this.dictionaryCache = MapTreeDictionaryCache.create(AreaCode::getAreaId, AreaCode::getParentId);
}
@Override
protected BaseDaoMapper<AreaCode> mapper() {
return areaCodeMapper;
}
/**
* 加载数据库数据到内存缓存。
*/
@Override
public void loadCachedData() {
Example e = new Example(AreaCode.class);
e.orderBy("areaLevel");
List<AreaCode> areaCodeList = areaCodeMapper.selectByExample(e);
dictionaryCache.putAll(areaCodeList);
}
/**
* 根据上级行政区划Id，获取其下级行政区划列表。
*
* @param parentId 上级行政区划Id。
* @return 下级行政区划列表。
*/
public Collection<AreaCode> getListByParentId(Long parentId) {
return ((MapTreeDictionaryCache<Long, AreaCode>) dictionaryCache).getListByParentId(parentId);
}
}

175
orange-demo-single-service/application/src/main/java/com/orange/demo/app/service/CourseService.java Normal file
View File

@@ -0,0 +1,175 @@
package com.orange.demo.app.service;
import com.orange.demo.app.dao.*;
import com.orange.demo.app.model.*;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.common.core.object.TokenData;
import com.orange.demo.common.core.object.MyWhereCriteria;
import com.orange.demo.common.core.object.MyRelationParam;
import com.orange.demo.common.core.object.CallResult;
import com.orange.demo.common.core.base.service.BaseService;
import com.orange.demo.common.sequence.wrapper.IdGeneratorWrapper;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.*;
/**
* 课程数据数据操作服务类。
*
* @author Jerry
* @date 2020-09-25
*/
@Service
public class CourseService extends BaseService<Course, Long> {
@Autowired
private CourseMapper courseMapper;
@Autowired
private ClassCourseMapper classCourseMapper;
@Autowired
private GradeService gradeService;
@Autowired
private IdGeneratorWrapper idGenerator;
/**
* 返回当前Service的主表Mapper对象。
*
* @return 主表Mapper对象。
*/
@Override
protected BaseDaoMapper<Course> mapper() {
return courseMapper;
}
/**
* 保存新增对象。
*
* @param course 新增对象。
* @return 返回新增对象。
*/
@Transactional(rollbackFor = Exception.class)
public Course saveNew(Course course) {
course.setCourseId(idGenerator.nextLongId());
TokenData tokenData = TokenData.takeFromRequest();
course.setCreateUserId(tokenData.getUserId());
Date now = new Date();
course.setCreateTime(now);
course.setUpdateTime(now);
courseMapper.insert(course);
return course;
}
/**
* 更新数据对象。
*
* @param course 更新的对象。
* @param originalCourse 原有数据对象。
* @return 成功返回true，否则false。
*/
@Transactional(rollbackFor = Exception.class)
public boolean update(Course course, Course originalCourse) {
course.setCreateUserId(originalCourse.getCreateUserId());
course.setCreateTime(originalCourse.getCreateTime());
course.setUpdateTime(new Date());
// 这里重点提示，在执行主表数据更新之前，如果有哪些字段不支持修改操作，请用原有数据对象字段替换当前数据字段。
return courseMapper.updateByPrimaryKey(course) == 1;
}
/**
* 删除指定数据。
*
* @param courseId 主键Id。
* @return 成功返回true，否则false。
*/
@Transactional(rollbackFor = Exception.class)
public boolean remove(Long courseId) {
// 这里先删除主数据
if (courseMapper.deleteByPrimaryKey(courseId) == 0) {
return false;
}
// 这里可继续删除关联数据。
// 开始删除多对多父表的关联
ClassCourse classCourse = new ClassCourse();
classCourse.setCourseId(courseId);
classCourseMapper.delete(classCourse);
return true;
}
/**
* 获取单表查询结果。由于没有关联数据查询，因此在仅仅获取单表数据的场景下，效率更高。
* 如果需要同时获取关联数据，请移步(getCourseListWithRelation)方法。
*
* @param filter 过滤对象。
* @param orderBy 排序参数。
* @return 查询结果集。
*/
public List<Course> getCourseList(Course filter, String orderBy) {
return courseMapper.getCourseList(filter, orderBy);
}
/**
* 获取主表的查询结果，以及主表关联的字典数据和一对一从表数据，以及一对一从表的字典数据。
* 如果仅仅需要获取主表数据，请移步(getCourseList)，以便获取更好的查询性能。
*
* @param filter 主表过滤对象。
* @param orderBy 排序参数。
* @return 查询结果集。
*/
public List<Course> getCourseListWithRelation(Course filter, String orderBy) {
List<Course> resultList = courseMapper.getCourseList(filter, orderBy);
Map<String, List<MyWhereCriteria>> criteriaMap = buildAggregationAdditionalWhereCriteria();
this.buildRelationForDataList(resultList, MyRelationParam.normal(), criteriaMap);
return resultList;
}
/**
* 在多对多关系中，当前Service的数据表为从表，返回不与指定主表主键Id存在对多对关系的列表。
*
* @param classId 主表主键Id。
* @param filter 从表的过滤对象。
* @param orderBy 排序参数。
* @return 查询结果集。
*/
public List<Course> getNotInCourseListByClassId(
Long classId, Course filter, String orderBy) {
List<Course> resultList =
courseMapper.getNotInCourseListByClassId(classId, filter, orderBy);
this.buildRelationForDataList(resultList, MyRelationParam.dictOnly(), null);
return resultList;
}
/**
* 在多对多关系中，当前Service的数据表为从表，返回与指定主表主键Id存在对多对关系的列表。
*
* @param classId 主表主键Id。
* @param filter 从表的过滤对象。
* @param orderBy 排序参数。
* @return 查询结果集。
*/
public List<Course> getCourseListByClassId(
Long classId, Course filter, String orderBy) {
List<Course> resultList =
courseMapper.getCourseListByClassId(classId, filter, orderBy);
this.buildRelationForDataList(resultList, MyRelationParam.dictOnly(), null);
return resultList;
}
/**
* 根据最新对象和原有对象的数据对比，判断关联的字典数据和多对一主表数据是否都是合法数据。
*
* @param course 最新数据对象。
* @param originalCourse 原有数据对象。
* @return 数据全部正确返回true，否则false。
*/
public CallResult verifyRelatedData(Course course, Course originalCourse) {
String errorMessageFormat = "数据验证失败，关联的%s并不存在，请刷新后重试！";
//这里是基于字典的验证。
if (this.needToVerify(course, originalCourse, Course::getGradeId)
&& !gradeService.existId(course.getGradeId())) {
return CallResult.error(String.format(errorMessageFormat, "所属年级"));
}
return CallResult.ok();
}
}

83
orange-demo-single-service/application/src/main/java/com/orange/demo/app/service/CourseTransStatsService.java Normal file
View File

@@ -0,0 +1,83 @@
package com.orange.demo.app.service;
import com.orange.demo.app.dao.*;
import com.orange.demo.app.model.*;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.common.core.object.MyWhereCriteria;
import com.orange.demo.common.core.object.MyRelationParam;
import com.orange.demo.common.core.base.service.BaseService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.*;
/**
* 课程统计数据操作服务类。
*
* @author Jerry
* @date 2020-09-25
*/
@Service
public class CourseTransStatsService extends BaseService<CourseTransStats, Long> {
@Autowired
private CourseTransStatsMapper courseTransStatsMapper;
@Autowired
private GradeService gradeService;
/**
* 返回当前Service的主表Mapper对象。
*
* @return 主表Mapper对象。
*/
@Override
protected BaseDaoMapper<CourseTransStats> mapper() {
return courseTransStatsMapper;
}
/**
* 获取单表查询结果。由于没有关联数据查询，因此在仅仅获取单表数据的场景下，效率更高。
* 如果需要同时获取关联数据，请移步(getCourseTransStatsListWithRelation)方法。
*
* @param filter 过滤对象。
* @param orderBy 排序参数。
* @return 查询结果集。
*/
public List<CourseTransStats> getCourseTransStatsList(CourseTransStats filter, String orderBy) {
return courseTransStatsMapper.getCourseTransStatsList(filter, orderBy);
}
/**
* 获取主表的查询结果，以及主表关联的字典数据和一对一从表数据，以及一对一从表的字典数据。
* 如果仅仅需要获取主表数据，请移步(getCourseTransStatsList)，以便获取更好的查询性能。
*
* @param filter 主表过滤对象。
* @param orderBy 排序参数。
* @return 查询结果集。
*/
public List<CourseTransStats> getCourseTransStatsListWithRelation(CourseTransStats filter, String orderBy) {
List<CourseTransStats> resultList = courseTransStatsMapper.getCourseTransStatsList(filter, orderBy);
Map<String, List<MyWhereCriteria>> criteriaMap = buildAggregationAdditionalWhereCriteria();
this.buildRelationForDataList(resultList, MyRelationParam.normal(), criteriaMap);
return resultList;
}
/**
* 获取分组过滤后的数据查询结果，以及关联的字典数据和一对一从表数据，以及一对一从表的字典数据。
*
* @param filter 过滤对象。
* @param groupSelect 分组显示列表参数。位于SQL语句SELECT的后面。
* @param groupBy 分组参数。位于SQL语句的GROUP BY后面。
* @param orderBy 排序字符串，ORDER BY从句的参数。
* @return 分组过滤结果集。
*/
public List<CourseTransStats> getGroupedCourseTransStatsListWithRelation(
CourseTransStats filter, String groupSelect, String groupBy, String orderBy) {
List<CourseTransStats> resultList =
courseTransStatsMapper.getGroupedCourseTransStatsList(filter, groupSelect, groupBy, orderBy);
// NOTE: 这里只是包含了关联数据，聚合计算数据没有包含。
// 主要原因是，由于聚合字段通常被视为普通字段使用，不会在group by的从句中出现，语义上也不会在此关联。
this.buildRelationForDataList(resultList, MyRelationParam.normal(), null);
return resultList;
}
}

88
orange-demo-single-service/application/src/main/java/com/orange/demo/app/service/GradeService.java Normal file
View File

@@ -0,0 +1,88 @@
package com.orange.demo.app.service;
import com.orange.demo.common.core.base.service.BaseDictService;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.common.core.cache.MapDictionaryCache;
import com.orange.demo.common.core.constant.GlobalDeletedFlag;
import com.orange.demo.app.dao.GradeMapper;
import com.orange.demo.app.model.Grade;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* 年级数据操作服务类。
*
* @author Jerry
* @date 2020-09-25
*/
@Service
public class GradeService extends BaseDictService<Grade, Integer> {
@Autowired
private GradeMapper gradeMapper;
public GradeService() {
super();
this.dictionaryCache = MapDictionaryCache.create(Grade::getGradeId);
}
/**
* 返回当前Service的主表Mapper对象。
*
* @return 主表Mapper对象。
*/
@Override
protected BaseDaoMapper<Grade> mapper() {
return gradeMapper;
}
/**
* 保存新增对象。
*
* @param grade 新增对象。
* @return 返回新增对象。
*/
@Transactional(rollbackFor = Exception.class)
public Grade saveNew(Grade grade) {
grade.setStatus(GlobalDeletedFlag.NORMAL);
gradeMapper.insert(grade);
dictionaryCache.put(grade.getGradeId(), grade);
return grade;
}
/**
* 更新数据对象。
*
* @param grade 更新的对象。
* @param originalGrade 原有数据对象。
* @return 成功返回true，否则false。
*/
@Transactional(rollbackFor = Exception.class)
public boolean update(Grade grade, Grade originalGrade) {
grade.setStatus(GlobalDeletedFlag.NORMAL);
if (gradeMapper.updateByPrimaryKey(grade) != 1) {
return false;
}
dictionaryCache.put(grade.getGradeId(), grade);
return true;
}
/**
* 删除指定数据。
*
* @param gradeId 主键Id。
* @return 成功返回true，否则false。
*/
@Transactional(rollbackFor = Exception.class)
public boolean remove(Integer gradeId) {
Grade deletedObject = new Grade();
deletedObject.setGradeId(gradeId);
deletedObject.setStatus(GlobalDeletedFlag.DELETED);
if (gradeMapper.updateByPrimaryKeySelective(deletedObject) != 1) {
return false;
}
dictionaryCache.invalidate(gradeId);
return true;
}
}

129
orange-demo-single-service/application/src/main/java/com/orange/demo/app/service/SchoolInfoService.java Normal file
View File

@@ -0,0 +1,129 @@
package com.orange.demo.app.service;
import com.orange.demo.app.dao.*;
import com.orange.demo.app.model.*;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.common.core.object.MyWhereCriteria;
import com.orange.demo.common.core.object.MyRelationParam;
import com.orange.demo.common.core.object.CallResult;
import com.orange.demo.common.core.base.service.BaseService;
import com.orange.demo.common.sequence.wrapper.IdGeneratorWrapper;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.*;
/**
* 校区数据数据操作服务类。
*
* @author Jerry
* @date 2020-09-25
*/
@Service
public class SchoolInfoService extends BaseService<SchoolInfo, Long> {
@Autowired
private SchoolInfoMapper schoolInfoMapper;
@Autowired
private AreaCodeService areaCodeService;
@Autowired
private IdGeneratorWrapper idGenerator;
/**
* 返回当前Service的主表Mapper对象。
*
* @return 主表Mapper对象。
*/
@Override
protected BaseDaoMapper<SchoolInfo> mapper() {
return schoolInfoMapper;
}
/**
* 保存新增对象。
*
* @param schoolInfo 新增对象。
* @return 返回新增对象。
*/
@Transactional(rollbackFor = Exception.class)
public SchoolInfo saveNew(SchoolInfo schoolInfo) {
schoolInfo.setSchoolId(idGenerator.nextLongId());
schoolInfoMapper.insert(schoolInfo);
return schoolInfo;
}
/**
* 更新数据对象。
*
* @param schoolInfo 更新的对象。
* @param originalSchoolInfo 原有数据对象。
* @return 成功返回true，否则false。
*/
@Transactional(rollbackFor = Exception.class)
public boolean update(SchoolInfo schoolInfo, SchoolInfo originalSchoolInfo) {
// 这里重点提示，在执行主表数据更新之前，如果有哪些字段不支持修改操作，请用原有数据对象字段替换当前数据字段。
return schoolInfoMapper.updateByPrimaryKey(schoolInfo) == 1;
}
/**
* 删除指定数据。
*
* @param schoolId 主键Id。
* @return 成功返回true，否则false。
*/
@Transactional(rollbackFor = Exception.class)
public boolean remove(Long schoolId) {
return schoolInfoMapper.deleteByPrimaryKey(schoolId) != 0;
// 这里可继续删除关联数据。
}
/**
* 获取单表查询结果。由于没有关联数据查询，因此在仅仅获取单表数据的场景下，效率更高。
* 如果需要同时获取关联数据，请移步(getSchoolInfoListWithRelation)方法。
*
* @param filter 过滤对象。
* @param orderBy 排序参数。
* @return 查询结果集。
*/
public List<SchoolInfo> getSchoolInfoList(SchoolInfo filter, String orderBy) {
return schoolInfoMapper.getSchoolInfoList(filter, orderBy);
}
/**
* 获取主表的查询结果，以及主表关联的字典数据和一对一从表数据，以及一对一从表的字典数据。
* 如果仅仅需要获取主表数据，请移步(getSchoolInfoList)，以便获取更好的查询性能。
*
* @param filter 主表过滤对象。
* @param orderBy 排序参数。
* @return 查询结果集。
*/
public List<SchoolInfo> getSchoolInfoListWithRelation(SchoolInfo filter, String orderBy) {
List<SchoolInfo> resultList = schoolInfoMapper.getSchoolInfoList(filter, orderBy);
Map<String, List<MyWhereCriteria>> criteriaMap = buildAggregationAdditionalWhereCriteria();
this.buildRelationForDataList(resultList, MyRelationParam.normal(), criteriaMap);
return resultList;
}
/**
* 根据最新对象和原有对象的数据对比，判断关联的字典数据和多对一主表数据是否都是合法数据。
*
* @param schoolInfo 最新数据对象。
* @param originalSchoolInfo 原有数据对象。
* @return 数据全部正确返回true，否则false。
*/
public CallResult verifyRelatedData(SchoolInfo schoolInfo, SchoolInfo originalSchoolInfo) {
String errorMessageFormat = "数据验证失败，关联的%s并不存在，请刷新后重试！";
//这里是基于字典的验证。
if (this.needToVerify(schoolInfo, originalSchoolInfo, SchoolInfo::getProvinceId)
&& !areaCodeService.existId(schoolInfo.getProvinceId())) {
return CallResult.error(String.format(errorMessageFormat, "所在省份"));
}
//这里是基于字典的验证。
if (this.needToVerify(schoolInfo, originalSchoolInfo, SchoolInfo::getCityId)
&& !areaCodeService.existId(schoolInfo.getCityId())) {
return CallResult.error(String.format(errorMessageFormat, "所在城市"));
}
return CallResult.ok();
}
}

85
orange-demo-single-service/application/src/main/java/com/orange/demo/app/service/StudentActionStatsService.java Normal file
View File

@@ -0,0 +1,85 @@
package com.orange.demo.app.service;
import com.orange.demo.app.dao.*;
import com.orange.demo.app.model.*;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.common.core.object.MyWhereCriteria;
import com.orange.demo.common.core.object.MyRelationParam;
import com.orange.demo.common.core.base.service.BaseService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.*;
/**
* 学生行为统计数据操作服务类。
*
* @author Jerry
* @date 2020-09-25
*/
@Service
public class StudentActionStatsService extends BaseService<StudentActionStats, Long> {
@Autowired
private StudentActionStatsMapper studentActionStatsMapper;
@Autowired
private GradeService gradeService;
@Autowired
private AreaCodeService areaCodeService;
/**
* 返回当前Service的主表Mapper对象。
*
* @return 主表Mapper对象。
*/
@Override
protected BaseDaoMapper<StudentActionStats> mapper() {
return studentActionStatsMapper;
}
/**
* 获取单表查询结果。由于没有关联数据查询，因此在仅仅获取单表数据的场景下，效率更高。
* 如果需要同时获取关联数据，请移步(getStudentActionStatsListWithRelation)方法。
*
* @param filter 过滤对象。
* @param orderBy 排序参数。
* @return 查询结果集。
*/
public List<StudentActionStats> getStudentActionStatsList(StudentActionStats filter, String orderBy) {
return studentActionStatsMapper.getStudentActionStatsList(filter, orderBy);
}
/**
* 获取主表的查询结果，以及主表关联的字典数据和一对一从表数据，以及一对一从表的字典数据。
* 如果仅仅需要获取主表数据，请移步(getStudentActionStatsList)，以便获取更好的查询性能。
*
* @param filter 主表过滤对象。
* @param orderBy 排序参数。
* @return 查询结果集。
*/
public List<StudentActionStats> getStudentActionStatsListWithRelation(StudentActionStats filter, String orderBy) {
List<StudentActionStats> resultList = studentActionStatsMapper.getStudentActionStatsList(filter, orderBy);
Map<String, List<MyWhereCriteria>> criteriaMap = buildAggregationAdditionalWhereCriteria();
this.buildRelationForDataList(resultList, MyRelationParam.normal(), criteriaMap);
return resultList;
}
/**
* 获取分组过滤后的数据查询结果，以及关联的字典数据和一对一从表数据，以及一对一从表的字典数据。
*
* @param filter 过滤对象。
* @param groupSelect 分组显示列表参数。位于SQL语句SELECT的后面。
* @param groupBy 分组参数。位于SQL语句的GROUP BY后面。
* @param orderBy 排序字符串，ORDER BY从句的参数。
* @return 分组过滤结果集。
*/
public List<StudentActionStats> getGroupedStudentActionStatsListWithRelation(
StudentActionStats filter, String groupSelect, String groupBy, String orderBy) {
List<StudentActionStats> resultList =
studentActionStatsMapper.getGroupedStudentActionStatsList(filter, groupSelect, groupBy, orderBy);
// NOTE: 这里只是包含了关联数据，聚合计算数据没有包含。
// 主要原因是，由于聚合字段通常被视为普通字段使用，不会在group by的从句中出现，语义上也不会在此关联。
this.buildRelationForDataList(resultList, MyRelationParam.normal(), null);
return resultList;
}
}

131
orange-demo-single-service/application/src/main/java/com/orange/demo/app/service/StudentActionTransService.java Normal file
View File

@@ -0,0 +1,131 @@
package com.orange.demo.app.service;
import com.orange.demo.app.dao.*;
import com.orange.demo.app.model.*;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.common.core.object.MyWhereCriteria;
import com.orange.demo.common.core.object.MyRelationParam;
import com.orange.demo.common.core.object.CallResult;
import com.orange.demo.common.core.base.service.BaseService;
import com.orange.demo.common.sequence.wrapper.IdGeneratorWrapper;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.*;
/**
* 学生行为流水数据操作服务类。
*
* @author Jerry
* @date 2020-09-25
*/
@Service
public class StudentActionTransService extends BaseService<StudentActionTrans, Long> {
@Autowired
private StudentActionTransMapper studentActionTransMapper;
@Autowired
private SchoolInfoService schoolInfoService;
@Autowired
private GradeService gradeService;
@Autowired
private IdGeneratorWrapper idGenerator;
/**
* 返回当前Service的主表Mapper对象。
*
* @return 主表Mapper对象。
*/
@Override
protected BaseDaoMapper<StudentActionTrans> mapper() {
return studentActionTransMapper;
}
/**
* 保存新增对象。
*
* @param studentActionTrans 新增对象。
* @return 返回新增对象。
*/
@Transactional(rollbackFor = Exception.class)
public StudentActionTrans saveNew(StudentActionTrans studentActionTrans) {
studentActionTrans.setTransId(idGenerator.nextLongId());
studentActionTransMapper.insert(studentActionTrans);
return studentActionTrans;
}
/**
* 更新数据对象。
*
* @param studentActionTrans 更新的对象。
* @param originalStudentActionTrans 原有数据对象。
* @return 成功返回true，否则false。
*/
@Transactional(rollbackFor = Exception.class)
public boolean update(StudentActionTrans studentActionTrans, StudentActionTrans originalStudentActionTrans) {
// 这里重点提示，在执行主表数据更新之前，如果有哪些字段不支持修改操作，请用原有数据对象字段替换当前数据字段。
return studentActionTransMapper.updateByPrimaryKey(studentActionTrans) == 1;
}
/**
* 删除指定数据。
*
* @param transId 主键Id。
* @return 成功返回true，否则false。
*/
@Transactional(rollbackFor = Exception.class)
public boolean remove(Long transId) {
return studentActionTransMapper.deleteByPrimaryKey(transId) != 0;
// 这里可继续删除关联数据。
}
/**
* 获取单表查询结果。由于没有关联数据查询，因此在仅仅获取单表数据的场景下，效率更高。
* 如果需要同时获取关联数据，请移步(getStudentActionTransListWithRelation)方法。
*
* @param filter 过滤对象。
* @param orderBy 排序参数。
* @return 查询结果集。
*/
public List<StudentActionTrans> getStudentActionTransList(StudentActionTrans filter, String orderBy) {
return studentActionTransMapper.getStudentActionTransList(filter, orderBy);
}
/**
* 获取主表的查询结果，以及主表关联的字典数据和一对一从表数据，以及一对一从表的字典数据。
* 如果仅仅需要获取主表数据，请移步(getStudentActionTransList)，以便获取更好的查询性能。
*
* @param filter 主表过滤对象。
* @param orderBy 排序参数。
* @return 查询结果集。
*/
public List<StudentActionTrans> getStudentActionTransListWithRelation(StudentActionTrans filter, String orderBy) {
List<StudentActionTrans> resultList = studentActionTransMapper.getStudentActionTransList(filter, orderBy);
Map<String, List<MyWhereCriteria>> criteriaMap = buildAggregationAdditionalWhereCriteria();
this.buildRelationForDataList(resultList, MyRelationParam.normal(), criteriaMap);
return resultList;
}
/**
* 根据最新对象和原有对象的数据对比，判断关联的字典数据和多对一主表数据是否都是合法数据。
*
* @param studentActionTrans 最新数据对象。
* @param originalStudentActionTrans 原有数据对象。
* @return 数据全部正确返回true，否则false。
*/
public CallResult verifyRelatedData(StudentActionTrans studentActionTrans, StudentActionTrans originalStudentActionTrans) {
String errorMessageFormat = "数据验证失败，关联的%s并不存在，请刷新后重试！";
//这里是基于字典的验证。
if (this.needToVerify(studentActionTrans, originalStudentActionTrans, StudentActionTrans::getSchoolId)
&& !schoolInfoService.existId(studentActionTrans.getSchoolId())) {
return CallResult.error(String.format(errorMessageFormat, "学生校区"));
}
//这里是基于字典的验证。
if (this.needToVerify(studentActionTrans, originalStudentActionTrans, StudentActionTrans::getGradeId)
&& !gradeService.existId(studentActionTrans.getGradeId())) {
return CallResult.error(String.format(errorMessageFormat, "学生年级"));
}
return CallResult.ok();
}
}

259
orange-demo-single-service/application/src/main/java/com/orange/demo/app/service/StudentClassService.java Normal file
View File

@@ -0,0 +1,259 @@
package com.orange.demo.app.service;
import com.orange.demo.app.dao.*;
import com.orange.demo.app.model.*;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.common.core.constant.GlobalDeletedFlag;
import com.orange.demo.common.core.object.TokenData;
import com.orange.demo.common.core.object.MyWhereCriteria;
import com.orange.demo.common.core.object.MyRelationParam;
import com.orange.demo.common.core.object.CallResult;
import com.orange.demo.common.core.base.service.BaseService;
import com.orange.demo.common.sequence.wrapper.IdGeneratorWrapper;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import tk.mybatis.mapper.entity.Example;
import java.util.*;
/**
* 班级数据数据操作服务类。
*
* @author Jerry
* @date 2020-09-25
*/
@Service
public class StudentClassService extends BaseService<StudentClass, Long> {
@Autowired
private StudentClassMapper studentClassMapper;
@Autowired
private ClassCourseMapper classCourseMapper;
@Autowired
private ClassStudentMapper classStudentMapper;
@Autowired
private SchoolInfoService schoolInfoService;
@Autowired
private StudentService studentService;
@Autowired
private IdGeneratorWrapper idGenerator;
/**
* 返回当前Service的主表Mapper对象。
*
* @return 主表Mapper对象。
*/
@Override
protected BaseDaoMapper<StudentClass> mapper() {
return studentClassMapper;
}
/**
* 保存新增对象。
*
* @param studentClass 新增对象。
* @return 返回新增对象。
*/
@Transactional(rollbackFor = Exception.class)
public StudentClass saveNew(StudentClass studentClass) {
studentClass.setClassId(idGenerator.nextLongId());
TokenData tokenData = TokenData.takeFromRequest();
studentClass.setCreateUserId(tokenData.getUserId());
studentClass.setCreateTime(new Date());
studentClass.setStatus(GlobalDeletedFlag.NORMAL);
if (studentClass.getFinishClassHour() == null) {
studentClass.setFinishClassHour(0);
}
if (studentClass.getStatus() == null) {
studentClass.setStatus(0);
}
studentClassMapper.insert(studentClass);
return studentClass;
}
/**
* 更新数据对象。
*
* @param studentClass 更新的对象。
* @param originalStudentClass 原有数据对象。
* @return 成功返回true，否则false。
*/
@Transactional(rollbackFor = Exception.class)
public boolean update(StudentClass studentClass, StudentClass originalStudentClass) {
studentClass.setCreateUserId(originalStudentClass.getCreateUserId());
studentClass.setCreateTime(originalStudentClass.getCreateTime());
studentClass.setStatus(GlobalDeletedFlag.NORMAL);
// 这里重点提示，在执行主表数据更新之前，如果有哪些字段不支持修改操作，请用原有数据对象字段替换当前数据字段。
return studentClassMapper.updateByPrimaryKey(studentClass) == 1;
}
/**
* 删除指定数据。
*
* @param classId 主键Id。
* @return 成功返回true，否则false。
*/
@Transactional(rollbackFor = Exception.class)
public boolean remove(Long classId) {
Example studentClassExample = new Example(StudentClass.class);
Example.Criteria c = studentClassExample.createCriteria();
c.andEqualTo(super.idFieldName, classId);
c.andEqualTo(super.deletedFlagFieldName, GlobalDeletedFlag.NORMAL);
// 这里先删除主数据
StudentClass deletedObject = new StudentClass();
deletedObject.setStatus(GlobalDeletedFlag.DELETED);
if (studentClassMapper.updateByExampleSelective(deletedObject, studentClassExample) == 0) {
return false;
}
// 这里可继续删除关联数据。
// 开始删除多对多子表的关联
ClassCourse classCourse = new ClassCourse();
classCourse.setClassId(classId);
classCourseMapper.delete(classCourse);
ClassStudent classStudent = new ClassStudent();
classStudent.setClassId(classId);
classStudentMapper.delete(classStudent);
return true;
}
/**
* 获取单表查询结果。由于没有关联数据查询，因此在仅仅获取单表数据的场景下，效率更高。
* 如果需要同时获取关联数据，请移步(getStudentClassListWithRelation)方法。
*
* @param filter 过滤对象。
* @param orderBy 排序参数。
* @return 查询结果集。
*/
public List<StudentClass> getStudentClassList(StudentClass filter, String orderBy) {
return studentClassMapper.getStudentClassList(filter, orderBy);
}
/**
* 获取主表的查询结果，以及主表关联的字典数据和一对一从表数据，以及一对一从表的字典数据。
* 如果仅仅需要获取主表数据，请移步(getStudentClassList)，以便获取更好的查询性能。
*
* @param filter 主表过滤对象。
* @param orderBy 排序参数。
* @return 查询结果集。
*/
public List<StudentClass> getStudentClassListWithRelation(StudentClass filter, String orderBy) {
List<StudentClass> resultList = studentClassMapper.getStudentClassList(filter, orderBy);
Map<String, List<MyWhereCriteria>> criteriaMap = buildAggregationAdditionalWhereCriteria();
this.buildRelationForDataList(resultList, MyRelationParam.normal(), criteriaMap);
return resultList;
}
/**
* 批量添加多对多关联关系。
*
* @param classCourseList 多对多关联表对象集合。
* @param classId 主表Id。
*/
@Transactional(rollbackFor = Exception.class)
public void addClassCourseList(List<ClassCourse> classCourseList, Long classId) {
for (ClassCourse classCourse : classCourseList) {
classCourse.setClassId(classId);
if (classCourse.getCourseOrder() == null) {
classCourse.setCourseOrder(0);
}
}
classCourseMapper.insertList(classCourseList);
}
/**
* 更新中间表数据。
*
* @param classCourse 中间表对象。
* @return 更新成功与否。
*/
@Transactional(rollbackFor = Exception.class)
public boolean updateClassCourse(ClassCourse classCourse) {
Example e = new Example(ClassCourse.class);
e.createCriteria()
.andEqualTo("classId", classCourse.getClassId())
.andEqualTo("courseId", classCourse.getCourseId());
return classCourseMapper.updateByExample(classCourse, e) > 0;
}
/**
* 获取中间表数据。
*
* @param classId 主表Id。
* @param courseId 从表Id。
* @return 中间表对象。
*/
public ClassCourse getClassCourse(Long classId, Long courseId) {
Example e = new Example(ClassCourse.class);
e.createCriteria()
.andEqualTo("classId", classId)
.andEqualTo("courseId", courseId);
return classCourseMapper.selectOneByExample(e);
}
/**
* 移除单条多对多关系。
*
* @param classId 主表Id。
* @param courseId 从表Id。
* @return 成功返回true，否则false。
*/
@Transactional(rollbackFor = Exception.class)
public boolean removeClassCourse(Long classId, Long courseId) {
ClassCourse classCourse = new ClassCourse();
classCourse.setClassId(classId);
classCourse.setCourseId(courseId);
return classCourseMapper.delete(classCourse) > 0;
}
/**
* 批量添加多对多关联关系。
*
* @param classStudentList 多对多关联表对象集合。
* @param classId 主表Id。
*/
@Transactional(rollbackFor = Exception.class)
public void addClassStudentList(List<ClassStudent> classStudentList, Long classId) {
for (ClassStudent classStudent : classStudentList) {
classStudent.setClassId(classId);
}
classStudentMapper.insertList(classStudentList);
}
/**
* 移除单条多对多关系。
*
* @param classId 主表Id。
* @param studentId 从表Id。
* @return 成功返回true，否则false。
*/
@Transactional(rollbackFor = Exception.class)
public boolean removeClassStudent(Long classId, Long studentId) {
ClassStudent classStudent = new ClassStudent();
classStudent.setClassId(classId);
classStudent.setStudentId(studentId);
return classStudentMapper.delete(classStudent) > 0;
}
/**
* 根据最新对象和原有对象的数据对比，判断关联的字典数据和多对一主表数据是否都是合法数据。
*
* @param studentClass 最新数据对象。
* @param originalStudentClass 原有数据对象。
* @return 数据全部正确返回true，否则false。
*/
public CallResult verifyRelatedData(StudentClass studentClass, StudentClass originalStudentClass) {
String errorMessageFormat = "数据验证失败，关联的%s并不存在，请刷新后重试！";
//这里是基于字典的验证。
if (this.needToVerify(studentClass, originalStudentClass, StudentClass::getSchoolId)
&& !schoolInfoService.existId(studentClass.getSchoolId())) {
return CallResult.error(String.format(errorMessageFormat, "所属校区"));
}
//这里是基于字典的验证。
if (this.needToVerify(studentClass, originalStudentClass, StudentClass::getLeaderId)
&& !studentService.existId(studentClass.getLeaderId())) {
return CallResult.error(String.format(errorMessageFormat, "学生班长"));
}
return CallResult.ok();
}
}

202
orange-demo-single-service/application/src/main/java/com/orange/demo/app/service/StudentService.java Normal file
View File

@@ -0,0 +1,202 @@
package com.orange.demo.app.service;
import com.orange.demo.application.common.constant.StudentStatus;
import com.orange.demo.app.dao.*;
import com.orange.demo.app.model.*;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.common.core.object.MyWhereCriteria;
import com.orange.demo.common.core.object.MyRelationParam;
import com.orange.demo.common.core.object.CallResult;
import com.orange.demo.common.core.base.service.BaseService;
import com.orange.demo.common.sequence.wrapper.IdGeneratorWrapper;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.*;
/**
* 学生数据数据操作服务类。
*
* @author Jerry
* @date 2020-09-25
*/
@Service
public class StudentService extends BaseService<Student, Long> {
@Autowired
private StudentMapper studentMapper;
@Autowired
private ClassStudentMapper classStudentMapper;
@Autowired
private AreaCodeService areaCodeService;
@Autowired
private GradeService gradeService;
@Autowired
private SchoolInfoService schoolInfoService;
@Autowired
private IdGeneratorWrapper idGenerator;
/**
* 返回当前Service的主表Mapper对象。
*
* @return 主表Mapper对象。
*/
@Override
protected BaseDaoMapper<Student> mapper() {
return studentMapper;
}
/**
* 保存新增对象。
*
* @param student 新增对象。
* @return 返回新增对象。
*/
@Transactional(rollbackFor = Exception.class)
public Student saveNew(Student student) {
student.setStudentId(idGenerator.nextLongId());
student.setRegisterTime(new Date());
if (student.getTotalCoin() == null) {
student.setTotalCoin(0);
}
if (student.getLeftCoin() == null) {
student.setLeftCoin(0);
}
if (student.getStatus() == null) {
student.setStatus(StudentStatus.NORMAL);
}
studentMapper.insert(student);
return student;
}
/**
* 更新数据对象。
*
* @param student 更新的对象。
* @param originalStudent 原有数据对象。
* @return 成功返回true，否则false。
*/
@Transactional(rollbackFor = Exception.class)
public boolean update(Student student, Student originalStudent) {
student.setRegisterTime(originalStudent.getRegisterTime());
// 这里重点提示，在执行主表数据更新之前，如果有哪些字段不支持修改操作，请用原有数据对象字段替换当前数据字段。
return studentMapper.updateByPrimaryKey(student) == 1;
}
/**
* 删除指定数据。
*
* @param studentId 主键Id。
* @return 成功返回true，否则false。
*/
@Transactional(rollbackFor = Exception.class)
public boolean remove(Long studentId) {
// 这里先删除主数据
if (studentMapper.deleteByPrimaryKey(studentId) == 0) {
return false;
}
// 这里可继续删除关联数据。
// 开始删除多对多父表的关联
ClassStudent classStudent = new ClassStudent();
classStudent.setStudentId(studentId);
classStudentMapper.delete(classStudent);
return true;
}
/**
* 获取单表查询结果。由于没有关联数据查询，因此在仅仅获取单表数据的场景下，效率更高。
* 如果需要同时获取关联数据，请移步(getStudentListWithRelation)方法。
*
* @param filter 过滤对象。
* @param orderBy 排序参数。
* @return 查询结果集。
*/
public List<Student> getStudentList(Student filter, String orderBy) {
return studentMapper.getStudentList(filter, orderBy);
}
/**
* 获取主表的查询结果，以及主表关联的字典数据和一对一从表数据，以及一对一从表的字典数据。
* 如果仅仅需要获取主表数据，请移步(getStudentList)，以便获取更好的查询性能。
*
* @param filter 主表过滤对象。
* @param orderBy 排序参数。
* @return 查询结果集。
*/
public List<Student> getStudentListWithRelation(Student filter, String orderBy) {
List<Student> resultList = studentMapper.getStudentList(filter, orderBy);
Map<String, List<MyWhereCriteria>> criteriaMap = buildAggregationAdditionalWhereCriteria();
this.buildRelationForDataList(resultList, MyRelationParam.normal(), criteriaMap);
return resultList;
}
/**
* 在多对多关系中，当前Service的数据表为从表，返回不与指定主表主键Id存在对多对关系的列表。
*
* @param classId 主表主键Id。
* @param filter 从表的过滤对象。
* @param orderBy 排序参数。
* @return 查询结果集。
*/
public List<Student> getNotInStudentListByClassId(
Long classId, Student filter, String orderBy) {
List<Student> resultList =
studentMapper.getNotInStudentListByClassId(classId, filter, orderBy);
this.buildRelationForDataList(resultList, MyRelationParam.dictOnly(), null);
return resultList;
}
/**
* 在多对多关系中，当前Service的数据表为从表，返回与指定主表主键Id存在对多对关系的列表。
*
* @param classId 主表主键Id。
* @param filter 从表的过滤对象。
* @param orderBy 排序参数。
* @return 查询结果集。
*/
public List<Student> getStudentListByClassId(
Long classId, Student filter, String orderBy) {
List<Student> resultList =
studentMapper.getStudentListByClassId(classId, filter, orderBy);
this.buildRelationForDataList(resultList, MyRelationParam.dictOnly(), null);
return resultList;
}
/**
* 根据最新对象和原有对象的数据对比，判断关联的字典数据和多对一主表数据是否都是合法数据。
*
* @param student 最新数据对象。
* @param originalStudent 原有数据对象。
* @return 数据全部正确返回true，否则false。
*/
public CallResult verifyRelatedData(Student student, Student originalStudent) {
String errorMessageFormat = "数据验证失败，关联的%s并不存在，请刷新后重试！";
//这里是基于字典的验证。
if (this.needToVerify(student, originalStudent, Student::getProvinceId)
&& !areaCodeService.existId(student.getProvinceId())) {
return CallResult.error(String.format(errorMessageFormat, "所在省份"));
}
//这里是基于字典的验证。
if (this.needToVerify(student, originalStudent, Student::getCityId)
&& !areaCodeService.existId(student.getCityId())) {
return CallResult.error(String.format(errorMessageFormat, "所在城市"));
}
//这里是基于字典的验证。
if (this.needToVerify(student, originalStudent, Student::getDistrictId)
&& !areaCodeService.existId(student.getDistrictId())) {
return CallResult.error(String.format(errorMessageFormat, "所在区县"));
}
//这里是基于字典的验证。
if (this.needToVerify(student, originalStudent, Student::getGradeId)
&& !gradeService.existId(student.getGradeId())) {
return CallResult.error(String.format(errorMessageFormat, "年级"));
}
//这里是基于字典的验证。
if (this.needToVerify(student, originalStudent, Student::getSchoolId)
&& !schoolInfoService.existId(student.getSchoolId())) {
return CallResult.error(String.format(errorMessageFormat, "所属校区"));
}
return CallResult.ok();
}
}

46
orange-demo-single-service/application/src/main/java/com/orange/demo/config/ApplicationConfig.java Normal file
View File

@@ -0,0 +1,46 @@
package com.orange.demo.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
/**
* 应用程序自定义的程序属性配置文件。
*
* @author Jerry
* @date 2020-09-25
*/
@Data
@Configuration
@ConfigurationProperties(prefix = "application")
public class ApplicationConfig {
/**
* token的Http Request Header的key
*/
private String tokenHeaderKey;
/**
* token在过期之前，但是已经需要被刷新时，response返回的header信息的key。
*/
private String refreshedTokenHeaderKey;
/**
* token 加密用的密钥
*/
private String tokenSigningKey;
/**
* 令牌的过期时间，单位毫秒
*/
private Long expiration;
/**
* 用户密码被重置之后的缺省密码
*/
private String defaultUserPassword;
/**
* 上传文件的基础目录
*/
private String uploadFileBaseDir;
/**
* 授信ip列表，没有填写表示全部信任。多个ip之间逗号分隔，如: http://10.10.10.1:8080,http://10.10.10.2:8080
*/
private String credentialIpList;
}

30
orange-demo-single-service/application/src/main/java/com/orange/demo/config/DataSourceConfig.java Normal file
View File

@@ -0,0 +1,30 @@
package com.orange.demo.config;
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import tk.mybatis.spring.annotation.MapperScan;
import javax.sql.DataSource;
/**
* 数据源配置Bean对象。
*
* @author Jerry
* @date 2020-09-25
*/
@Configuration
@EnableTransactionManagement
@MapperScan(value = {"com.orange.demo.*.dao"})
public class DataSourceConfig {
@Bean(initMethod = "init", destroyMethod = "close")
@Primary
@ConfigurationProperties(prefix = "spring.datasource.druid")
public DataSource druidDataSource() {
return DruidDataSourceBuilder.create().build();
}
}

57
orange-demo-single-service/application/src/main/java/com/orange/demo/config/FilterConfig.java Normal file
View File

@@ -0,0 +1,57 @@
package com.orange.demo.config;
import org.apache.commons.lang3.StringUtils;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
import javax.servlet.Filter;
import java.nio.charset.StandardCharsets;
/**
* 这里主要配置Web的各种过滤器和监听器等Servlet容器组件。
*
* @author Jerry
* @date 2020-09-25
*/
@Configuration
public class FilterConfig {
/**
* 配置Ajax跨域过滤器。
*/
@Bean
public CorsFilter corsFilterRegistration(ApplicationConfig applicationConfig) {
UrlBasedCorsConfigurationSource configSource = new UrlBasedCorsConfigurationSource();
CorsConfiguration corsConfiguration = new CorsConfiguration();
if (StringUtils.isNotBlank(applicationConfig.getCredentialIpList())) {
String[] credentialIpList = StringUtils.split(applicationConfig.getCredentialIpList(), ",");
if (credentialIpList.length > 0) {
for (String ip : credentialIpList) {
corsConfiguration.addAllowedOrigin(ip);
}
}
corsConfiguration.addAllowedHeader("*");
corsConfiguration.addAllowedMethod("*");
corsConfiguration.addExposedHeader(applicationConfig.getRefreshedTokenHeaderKey());
corsConfiguration.setAllowCredentials(true);
configSource.registerCorsConfiguration("/**", corsConfiguration);
}
return new CorsFilter(configSource);
}
@Bean
public FilterRegistrationBean<Filter> characterEncodingFilterRegistration() {
FilterRegistrationBean<Filter> filterRegistrationBean = new FilterRegistrationBean<>(
new org.springframework.web.filter.CharacterEncodingFilter());
filterRegistrationBean.addUrlPatterns("/*");
filterRegistrationBean.addInitParameter("encoding", StandardCharsets.UTF_8.name());
// forceEncoding强制response也被编码，另外即使request中已经设置encoding，forceEncoding也会重新设置
filterRegistrationBean.addInitParameter("forceEncoding", "true");
filterRegistrationBean.setAsyncSupported(true);
return filterRegistrationBean;
}
}

21
orange-demo-single-service/application/src/main/java/com/orange/demo/config/InterceptorConfig.java Normal file
View File

@@ -0,0 +1,21 @@
package com.orange.demo.config;
import com.orange.demo.interceptor.AuthenticationInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
/**
* 所有的项目拦截器都在这里集中配置
*
* @author Jerry
* @date 2020-09-25
*/
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new AuthenticationInterceptor()).addPathPatterns("/**");
}
}

134
orange-demo-single-service/application/src/main/java/com/orange/demo/interceptor/AuthenticationInterceptor.java Normal file
View File

@@ -0,0 +1,134 @@
package com.orange.demo.interceptor;
import com.orange.demo.config.ApplicationConfig;
import com.orange.demo.upms.model.SysPermWhitelist;
import com.orange.demo.upms.service.SysPermWhitelistService;
import com.orange.demo.upms.service.SysPermService;
import com.orange.demo.common.core.annotation.NoAuthInterface;
import com.orange.demo.common.core.constant.ErrorCodeEnum;
import com.orange.demo.common.core.object.ResponseResult;
import com.orange.demo.common.core.object.TokenData;
import com.orange.demo.common.core.util.ApplicationContextHolder;
import com.orange.demo.common.core.util.JwtUtil;
import com.orange.demo.common.core.cache.SessionCacheHelper;
import com.alibaba.fastjson.JSONObject;
import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Set;
import java.util.List;
import java.util.stream.Collectors;
/**
* 登录用户Token验证、生成和权限验证的拦截器。
*
* @author Jerry
* @date 2020-09-25
*/
@Slf4j
public class AuthenticationInterceptor implements HandlerInterceptor {
private ApplicationConfig appConfig =
ApplicationContextHolder.getBean("applicationConfig");
private SessionCacheHelper cacheHelper =
ApplicationContextHolder.getBean("sessionCacheHelper");
private SysPermService sysPermService =
ApplicationContextHolder.getBean("sysPermService");
private static SysPermWhitelistService sysPermWhilelistService =
ApplicationContextHolder.getBean("sysPermWhitelistService");
private static Set<String> whitelistPermSet;
static {
List<SysPermWhitelist> sysPermWhitelistList = sysPermWhilelistService.getAllList();
whitelistPermSet = sysPermWhitelistList.stream()
.map(SysPermWhitelist::getPermUrl).collect(Collectors.toSet());
}
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
String url = request.getRequestURI();
// 如果接口方法标记NoAuthInterface注解，可以直接跳过Token鉴权验证，这里主要为了测试接口方便
if (handler instanceof HandlerMethod) {
HandlerMethod hm = (HandlerMethod) handler;
if (hm.getBeanType().getAnnotation(NoAuthInterface.class) != null
|| hm.getMethodAnnotation(NoAuthInterface.class) != null) {
return true;
}
}
String token = request.getHeader(appConfig.getTokenHeaderKey());
if (StringUtils.isBlank(token)) {
token = request.getParameter(appConfig.getTokenHeaderKey());
}
Claims c = JwtUtil.parseToken(token, appConfig.getTokenSigningKey());
if (JwtUtil.isNullOrExpired(c)) {
response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
this.outputResponseMessage(response,
ResponseResult.error(ErrorCodeEnum.UNAUTHORIZED_LOGIN, "用户会话已过期，请重新登录！"));
return false;
}
String sessionId = (String) c.get("sessionId");
TokenData tokenData = cacheHelper.getTokenData(sessionId);
if (tokenData == null) {
response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
this.outputResponseMessage(response,
ResponseResult.error(ErrorCodeEnum.UNAUTHORIZED_LOGIN, "用户会话已失效，请重新登录！"));
return false;
}
TokenData.addToRequest(tokenData);
// 如果url在权限资源白名单中，则不需要进行鉴权操作
if (!tokenData.getIsAdmin() && !whitelistPermSet.contains(url)) {
Set<String> urlSet = sysPermService.getCacheableSysPermSetByUserId(
tokenData.getSessionId(), tokenData.getUserId());
if (!urlSet.contains(url)) {
response.setStatus(HttpServletResponse.SC_FORBIDDEN);
this.outputResponseMessage(response,
ResponseResult.error(ErrorCodeEnum.NO_OPERATION_PERMISSION));
return false;
}
}
if (JwtUtil.needToRefresh(c)) {
String refreshedToken = JwtUtil.generateToken(c, appConfig.getExpiration(), appConfig.getTokenSigningKey());
response.addHeader(appConfig.getRefreshedTokenHeaderKey(), refreshedToken);
}
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
ModelAndView modelAndView) throws Exception {
// 这里需要空注解，否则sonar会不happy。
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
throws Exception {
// 这里需要空注解，否则sonar会不happy。
}
private void outputResponseMessage(HttpServletResponse response, ResponseResult<Object> respObj) {
PrintWriter out;
try {
out = response.getWriter();
} catch (IOException e) {
log.error("Failed to call OutputResponseMessage.", e);
return;
}
response.setContentType("application/json; charset=utf-8");
out.print(JSONObject.toJSONString(respObj));
out.flush();
out.close();
}
}

151
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/controller/LoginController.java Normal file
View File

@@ -0,0 +1,151 @@
package com.orange.demo.upms.controller;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import com.orange.demo.config.ApplicationConfig;
import com.orange.demo.upms.service.*;
import com.orange.demo.upms.model.SysMenu;
import com.orange.demo.upms.model.SysUser;
import com.orange.demo.upms.model.constant.SysUserStatus;
import com.orange.demo.upms.model.constant.SysUserType;
import com.orange.demo.common.core.annotation.MyRequestBody;
import com.orange.demo.common.core.annotation.NoAuthInterface;
import com.orange.demo.common.core.constant.ApplicationConstant;
import com.orange.demo.common.core.constant.ErrorCodeEnum;
import com.orange.demo.common.core.object.ResponseResult;
import com.orange.demo.common.core.object.TokenData;
import com.orange.demo.common.core.util.*;
import com.orange.demo.common.core.cache.SessionCacheHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.*;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.util.*;
/**
* 登录接口控制器类。
*
* @author Jerry
* @date 2020-09-25
*/
@Slf4j
@RestController
@RequestMapping("/admin/login")
public class LoginController {
@Autowired
private SysUserService sysUserService;
@Autowired
private SysMenuService sysMenuService;
@Autowired
private SysPermCodeService sysPermCodeService;
@Autowired
private SysPermService sysPermService;
@Autowired
private ApplicationConfig appConfig;
@Autowired
private SessionCacheHelper cacheHelper;
@Autowired
private PasswordEncoder passwordEncoder;
/**
* 登录接口。
*
* @param loginName 登录名。
* @param password 密码。
* @return 应答结果对象，其中包括JWT的Token数据，以及菜单列表。
*/
@NoAuthInterface
@GetMapping("/doLogin")
public ResponseResult<JSONObject> doLogin(
@RequestParam String loginName, @RequestParam String password) throws Exception {
if (MyCommonUtil.existBlankArgument(loginName, password)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
SysUser user = sysUserService.getSysUserByLoginName(loginName);
password = URLDecoder.decode(password, StandardCharsets.UTF_8.name());
//NOTE: 第一次使用时，请务必阅读ApplicationConstant.PRIVATE_KEY的代码注释。
//执行RsaUtil工具类中的main函数，可以生成新的公钥和私钥。
password = RsaUtil.decrypt(password, ApplicationConstant.PRIVATE_KEY);
if (user == null || !passwordEncoder.matches(password, user.getPassword())) {
return ResponseResult.error(ErrorCodeEnum.INVALID_USERNAME_PASSWORD);
}
String errorMessage;
if (user.getUserStatus() == SysUserStatus.STATUS_LOCKED) {
errorMessage = "登录失败，用户账号被锁定！";
return ResponseResult.error(ErrorCodeEnum.INVALID_USER_STATUS, errorMessage);
}
boolean isAdmin = user.getUserType() == SysUserType.TYPE_ADMIN;
Map<String, Object> claims = new HashMap<>(3);
String sessionId = MyCommonUtil.generateUuid();
claims.put("sessionId", sessionId);
String token = JwtUtil.generateToken(claims, appConfig.getExpiration(), appConfig.getTokenSigningKey());
JSONObject jsonData = new JSONObject();
jsonData.put(TokenData.REQUEST_ATTRIBUTE_NAME, token);
jsonData.put("showName", user.getShowName());
jsonData.put("isAdmin", isAdmin);
TokenData tokenData = new TokenData();
tokenData.setSessionId(sessionId);
tokenData.setUserId(user.getUserId());
tokenData.setShowName(user.getShowName());
tokenData.setIsAdmin(isAdmin);
cacheHelper.putTokenData(sessionId, tokenData);
List<SysMenu> menuList;
if (isAdmin) {
menuList = sysMenuService.getAllMenuList();
} else {
menuList = sysMenuService.getMenuListByUserId(user.getUserId());
List<String> permCodeList = sysPermCodeService.getPermCodeListByUserId(user.getUserId());
jsonData.put("permCodeList", permCodeList);
}
jsonData.put("menuList", menuList);
if (user.getUserType() != SysUserType.TYPE_ADMIN) {
// 缓存用户的权限资源
sysPermService.putUserSysPermCache(sessionId, user.getUserId(), isAdmin);
}
return ResponseResult.success(jsonData);
}
/**
* 登出操作。同时将Session相关的信息从缓存中删除。
*
* @return 应答结果对象。
*/
@PostMapping("/doLogout")
public ResponseResult<Void> doLogout() {
cacheHelper.removeAllSessionCache();
return ResponseResult.success();
}
/**
* 用户修改自己的密码。
*
* @param oldPass 原有密码。
* @param newPass 新密码。
* @return 应答结果对象。
*/
@PostMapping("/changePassword")
public ResponseResult<Void> changePassword(
@MyRequestBody String oldPass, @MyRequestBody String newPass) throws Exception {
if (MyCommonUtil.existBlankArgument(oldPass, oldPass)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
TokenData tokenData = TokenData.takeFromRequest();
SysUser user = sysUserService.getById(tokenData.getUserId());
oldPass = URLDecoder.decode(oldPass, StandardCharsets.UTF_8.name());
//NOTE: 第一次使用时，请务必阅读ApplicationConstant.PRIVATE_KEY的代码注释。
//执行RsaUtil工具类中的main函数，可以生成新的公钥和私钥。
oldPass = RsaUtil.decrypt(oldPass, ApplicationConstant.PRIVATE_KEY);
if (user == null || !passwordEncoder.matches(oldPass, user.getPassword())) {
return ResponseResult.error(ErrorCodeEnum.INVALID_USERNAME_PASSWORD);
}
newPass = URLDecoder.decode(newPass, StandardCharsets.UTF_8.name());
newPass = RsaUtil.decrypt(newPass, ApplicationConstant.PRIVATE_KEY);
if (!sysUserService.changePassword(tokenData.getUserId(), newPass)) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success();
}
}

160
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/controller/SysMenuController.java Normal file
View File

@@ -0,0 +1,160 @@
package com.orange.demo.upms.controller;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import com.orange.demo.upms.model.SysMenu;
import com.orange.demo.upms.service.SysMenuService;
import com.orange.demo.upms.service.SysPermCodeService;
import com.orange.demo.common.core.constant.ErrorCodeEnum;
import com.orange.demo.common.core.object.CallResult;
import com.orange.demo.common.core.object.ResponseResult;
import com.orange.demo.common.core.object.MyRelationParam;
import com.orange.demo.common.core.util.MyCommonUtil;
import com.orange.demo.common.core.validator.UpdateGroup;
import com.orange.demo.common.core.annotation.MyRequestBody;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.groups.Default;
import java.util.*;
/**
* 菜单管理接口控制器类。
*
* @author Jerry
* @date 2020-09-25
*/
@Slf4j
@RestController
@RequestMapping("/admin/upms/sysMenu")
public class SysMenuController {
@Autowired
private SysMenuService sysMenuService;
@Autowired
private SysPermCodeService sysPermCodeService;
/**
* 添加新菜单操作。
*
* @param sysMenu 新菜单对象。
* @param permCodeIdListString 与当前菜单Id绑定的权限Id列表，多个权限之间逗号分隔。
* @return 应答结果对象，包含新增菜单的主键Id。
*/
@SuppressWarnings("unchecked")
@PostMapping("/add")
public ResponseResult<JSONObject> add(@MyRequestBody SysMenu sysMenu, @MyRequestBody String permCodeIdListString) {
String errorMessage = MyCommonUtil.getModelValidationError(sysMenu);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
CallResult result = sysMenuService.verifyRelatedData(sysMenu, null, permCodeIdListString);
if (!result.isSuccess()) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, result.getErrorMessage());
}
Set<Long> permCodeIdSet = null;
if (result.getData() != null) {
permCodeIdSet = (Set<Long>) result.getData().get("permCodeIdSet");
}
sysMenuService.saveNew(sysMenu, permCodeIdSet);
JSONObject responseData = new JSONObject();
responseData.put("sysMenuId", sysMenu.getMenuId());
return ResponseResult.success(responseData);
}
/**
* 更新菜单数据操作。
*
* @param sysMenu 更新菜单对象。
* @param permCodeIdListString 与当前菜单Id绑定的权限Id列表，多个权限之间逗号分隔。
* @return 应答结果对象。
*/
@SuppressWarnings("unchecked")
@PostMapping("/update")
public ResponseResult<Void> update(@MyRequestBody SysMenu sysMenu, @MyRequestBody String permCodeIdListString) {
String errorMessage = MyCommonUtil.getModelValidationError(sysMenu, Default.class, UpdateGroup.class);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
SysMenu originalSysMenu = sysMenuService.getById(sysMenu.getMenuId());
if (originalSysMenu == null) {
errorMessage = "数据验证失败，当前菜单并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
CallResult result = sysMenuService.verifyRelatedData(sysMenu, originalSysMenu, permCodeIdListString);
if (!result.isSuccess()) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, result.getErrorMessage());
}
Set<Long> permCodeIdSet = null;
if (result.getData() != null) {
permCodeIdSet = (Set<Long>) result.getData().get("permCodeIdSet");
}
if (!sysMenuService.update(sysMenu, originalSysMenu, permCodeIdSet)) {
errorMessage = "数据验证失败，当前权限字并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
return ResponseResult.success();
}
/**
* 删除指定菜单操作。
*
* @param menuId 指定菜单主键Id。
* @return 应答结果对象。
*/
@PostMapping("/delete")
public ResponseResult<Void> delete(@MyRequestBody Long menuId) {
if (MyCommonUtil.existBlankArgument(menuId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
String errorMessage;
if (sysMenuService.hasChildren(menuId)) {
errorMessage = "数据验证失败，当前菜单存在下级菜单！";
return ResponseResult.error(ErrorCodeEnum.HAS_CHILDREN_DATA, errorMessage);
}
if (!sysMenuService.remove(menuId)) {
errorMessage = "数据操作失败，菜单不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
return ResponseResult.success();
}
/**
* 获取全部菜单列表。
*
* @return 应答结果对象，包含全部菜单数据列表。
*/
@GetMapping("/list")
public ResponseResult<List<SysMenu>> list() {
return ResponseResult.success(sysMenuService.getAllListByOrder("showOrder"));
}
/**
* 查看指定菜单数据详情。
*
* @param menuId 指定菜单主键Id。
* @return 应答结果对象，包含菜单详情。
*/
@GetMapping("/view")
public ResponseResult<SysMenu> view(@RequestParam Long menuId) {
if (MyCommonUtil.existBlankArgument(menuId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
SysMenu sysMenu = sysMenuService.getByIdWithRelation(menuId, MyRelationParam.full());
if (sysMenu == null) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success(sysMenu);
}
/**
* 列出与指定菜单关联的权限字和权限资源，便于管理员排查配置中的错误。
*
* @param menuId 菜单Id。
* @return 与菜单关联的权限字和权限资源列表。
*/
@GetMapping("/listMenuPerm")
public ResponseResult<List<Map<String, Object>>> listMenuPerm(@RequestParam Long menuId) {
return ResponseResult.success(sysPermCodeService.getPermCodeListByMenuId(menuId));
}
}

180
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/controller/SysPermCodeController.java Normal file
View File

@@ -0,0 +1,180 @@
package com.orange.demo.upms.controller;
import com.alibaba.fastjson.JSONObject;
import com.github.pagehelper.page.PageMethod;
import lombok.extern.slf4j.Slf4j;
import com.orange.demo.upms.model.SysPermCode;
import com.orange.demo.upms.service.SysPermCodeService;
import com.orange.demo.common.core.constant.ErrorCodeEnum;
import com.orange.demo.common.core.object.ResponseResult;
import com.orange.demo.common.core.object.CallResult;
import com.orange.demo.common.core.object.MyPageParam;
import com.orange.demo.common.core.object.MyRelationParam;
import com.orange.demo.common.core.util.MyCommonUtil;
import com.orange.demo.common.core.util.MyPageUtil;
import com.orange.demo.common.core.validator.UpdateGroup;
import com.orange.demo.common.core.annotation.MyRequestBody;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.web.bind.annotation.*;
import javax.validation.groups.Default;
import java.util.*;
/**
* 权限字管理接口控制器类。
*
* @author Jerry
* @date 2020-09-25
*/
@Slf4j
@RestController
@RequestMapping("/admin/upms/sysPermCode")
public class SysPermCodeController {
@Autowired
private SysPermCodeService sysPermCodeService;
/**
* 新增权限字操作。
*
* @param sysPermCode 新增权限字对象。
* @param permIdListString 与当前权限Id绑定的权限资源Id列表，多个权限资源之间逗号分隔。
* @return 应答结果对象，包含新增权限字的主键Id。
*/
@SuppressWarnings("unchecked")
@PostMapping("/add")
public ResponseResult<JSONObject> add(@MyRequestBody SysPermCode sysPermCode, @MyRequestBody String permIdListString) {
String errorMessage = MyCommonUtil.getModelValidationError(sysPermCode);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED);
}
CallResult result = sysPermCodeService.verifyRelatedData(sysPermCode, null, permIdListString);
if (!result.isSuccess()) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, result.getErrorMessage());
}
Set<Long> permIdSet = null;
if (result.getData() != null) {
permIdSet = (Set<Long>) result.getData().get("permIdSet");
}
sysPermCode = sysPermCodeService.saveNew(sysPermCode, permIdSet);
JSONObject responseData = new JSONObject();
responseData.put("sysPermCodeId", sysPermCode.getPermCodeId());
return ResponseResult.success(responseData);
}
/**
* 更新权限字操作。
*
* @param sysPermCode 更新权限字对象。
* @param permIdListString 与当前权限Id绑定的权限资源Id列表，多个权限资源之间逗号分隔。
* @return 应答结果对象。
*/
@SuppressWarnings("unchecked")
@PostMapping("/update")
public ResponseResult<Void> update(@MyRequestBody SysPermCode sysPermCode, @MyRequestBody String permIdListString) {
String errorMessage = MyCommonUtil.getModelValidationError(sysPermCode, Default.class, UpdateGroup.class);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
SysPermCode originalSysPermCode = sysPermCodeService.getById(sysPermCode.getPermCodeId());
if (originalSysPermCode == null) {
errorMessage = "数据验证失败，当前权限字并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
CallResult result = sysPermCodeService.verifyRelatedData(sysPermCode, originalSysPermCode, permIdListString);
if (!result.isSuccess()) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, result.getErrorMessage());
}
Set<Long> permIdSet = null;
if (result.getData() != null) {
permIdSet = (Set<Long>) result.getData().get("permIdSet");
}
try {
if (!sysPermCodeService.update(sysPermCode, originalSysPermCode, permIdSet)) {
errorMessage = "数据验证失败，当前权限字并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
} catch (DuplicateKeyException e) {
errorMessage = "数据操作失败，权限字编码已经存在！";
return ResponseResult.error(ErrorCodeEnum.DUPLICATED_UNIQUE_KEY, errorMessage);
}
return ResponseResult.success();
}
/**
* 删除指定权限字操作。
*
* @param permCodeId 指定的权限字主键Id。
* @return 应答结果对象。
*/
@PostMapping("/delete")
public ResponseResult<Void> delete(@MyRequestBody Long permCodeId) {
if (MyCommonUtil.existBlankArgument(permCodeId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
String errorMessage;
if (sysPermCodeService.hasChildren(permCodeId)) {
errorMessage = "数据验证失败，当前权限字存在下级权限字！";
return ResponseResult.error(ErrorCodeEnum.HAS_CHILDREN_DATA, errorMessage);
}
if (!sysPermCodeService.remove(permCodeId)) {
errorMessage = "数据操作失败，权限字不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
return ResponseResult.success();
}
/**
* 查看权限字列表。
*
* @return 应答结果对象，包含权限字列表。
*/
@PostMapping("/list")
public ResponseResult<List<SysPermCode>> list() {
return ResponseResult.success(sysPermCodeService.getAllListByOrder("permCodeType", "showOrder"));
}
/**
* 查看权限字对象详情。
*
* @param permCodeId 指定权限字主键Id。
* @return 应答结果对象，包含权限字对象详情。
*/
@GetMapping("/view")
public ResponseResult<SysPermCode> view(@RequestParam Long permCodeId) {
if (MyCommonUtil.existBlankArgument(permCodeId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
SysPermCode sysPermCode = sysPermCodeService.getByIdWithRelation(permCodeId, MyRelationParam.full());
if (sysPermCode == null) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success(sysPermCode);
}
/**
* 查看用户关联的权限字列表。
*
* @param loginName 精确匹配用户登录名。
* @param permCode 模糊匹配的权限字名，LIKE %permCode%。
* @param pageParam 分页对象。
* @return 应答结果对象，包含该用户的全部权限资源列表。
*/
@PostMapping("/listAllPermCodesByUserFilter")
public ResponseResult<JSONObject> listAllPermCodesByUserFilter(
@MyRequestBody String loginName,
@MyRequestBody String permCode,
@MyRequestBody MyPageParam pageParam) {
if (MyCommonUtil.existBlankArgument(loginName)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
List<SysPermCode> permCodeList =
sysPermCodeService.getUserPermCodeListByFilter(loginName, permCode);
JSONObject responseData = MyPageUtil.makeResponseData(permCodeList);
return ResponseResult.success(responseData);
}
}

197
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/controller/SysPermController.java Normal file
View File

@@ -0,0 +1,197 @@
package com.orange.demo.upms.controller;
import com.alibaba.fastjson.JSONObject;
import com.github.pagehelper.page.PageMethod;
import lombok.extern.slf4j.Slf4j;
import com.orange.demo.upms.model.SysPerm;
import com.orange.demo.upms.model.SysPermModule;
import com.orange.demo.upms.service.SysPermService;
import com.orange.demo.common.core.constant.ErrorCodeEnum;
import com.orange.demo.common.core.object.ResponseResult;
import com.orange.demo.common.core.object.CallResult;
import com.orange.demo.common.core.object.MyPageParam;
import com.orange.demo.common.core.util.MyCommonUtil;
import com.orange.demo.common.core.util.MyPageUtil;
import com.orange.demo.common.core.validator.UpdateGroup;
import com.orange.demo.common.core.annotation.MyRequestBody;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.groups.Default;
import java.util.List;
import java.util.Map;
/**
* 权限资源管理接口控制器类。
*
* @author Jerry
* @date 2020-09-25
*/
@Slf4j
@RestController
@RequestMapping("/admin/upms/sysPerm")
public class SysPermController {
@Autowired
private SysPermService sysPermService;
/**
* 新增权限资源操作。
*
* @param sysPerm 新增权限资源对象。
* @return 应答结果对象，包含新增权限资源的主键Id。
*/
@PostMapping("/add")
public ResponseResult<JSONObject> add(@MyRequestBody SysPerm sysPerm) {
String errorMessage = MyCommonUtil.getModelValidationError(sysPerm);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
CallResult result = sysPermService.verifyRelatedData(sysPerm, null);
if (!result.isSuccess()) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, result.getErrorMessage());
}
sysPerm = sysPermService.saveNew(sysPerm);
JSONObject responseData = new JSONObject();
responseData.put("permId", sysPerm.getPermId());
return ResponseResult.success(responseData);
}
/**
* 更新权限资源操作。
*
* @param sysPerm 更新权限资源对象。
* @return 应答结果对象，包含更新权限资源的主键Id。
*/
@PostMapping("/update")
public ResponseResult<Void> update(@MyRequestBody SysPerm sysPerm) {
String errorMessage = MyCommonUtil.getModelValidationError(sysPerm, Default.class, UpdateGroup.class);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
SysPerm originalPerm = sysPermService.getById(sysPerm.getPermId());
if (originalPerm == null) {
errorMessage = "数据验证失败，当前权限资源并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
CallResult result = sysPermService.verifyRelatedData(sysPerm, originalPerm);
if (!result.isSuccess()) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, result.getErrorMessage());
}
if (result.getData() != null) {
SysPermModule permModule = (SysPermModule) result.getData().get("permModule");
sysPerm.setModuleId(permModule.getModuleId());
}
sysPermService.update(sysPerm, originalPerm);
return ResponseResult.success();
}
/**
* 删除指定权限资源操作。
*
* @param permId 指定的权限资源主键Id。
* @return 应答结果对象。
*/
@PostMapping("/delete")
public ResponseResult<Void> delete(@MyRequestBody Long permId) {
if (MyCommonUtil.existBlankArgument(permId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
if (!sysPermService.remove(permId)) {
String errorMessage = "数据操作失败，权限不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
return ResponseResult.success();
}
/**
* 查看权限资源对象详情。
*
* @param permId 指定权限资源主键Id。
* @return 应答结果对象，包含权限资源对象详情。
*/
@GetMapping("/view")
public ResponseResult<SysPerm> view(@RequestParam Long permId) {
if (MyCommonUtil.existBlankArgument(permId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
SysPerm perm = sysPermService.getById(permId);
if (perm == null) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success(perm);
}
/**
* 查看权限资源列表。
*
* @param sysPermFilter 过滤对象。
* @param pageParam 分页参数。
* @return 应答结果对象，包含权限资源列表。
*/
@PostMapping("/list")
public ResponseResult<JSONObject> list(@MyRequestBody SysPerm sysPermFilter, @MyRequestBody MyPageParam pageParam) {
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
List<SysPerm> resultList = sysPermService.getPermListWithRelation(sysPermFilter);
return ResponseResult.success(MyPageUtil.makeResponseData(resultList));
}
/**
* 查看用户关联的权限资源列表。
*
* @param loginName 精确匹配用户登录名。
* @param moduleId 精确匹配权限模块Id。
* @param url 模糊匹配的url过滤条件。
* @param pageParam 分页对象。
* @return 应答结果对象，包含该用户的全部权限资源列表。
*/
@PostMapping("/listAllPermsByUserFilter")
public ResponseResult<JSONObject> listAllPermsByUserFilter(
@MyRequestBody String loginName,
@MyRequestBody Long moduleId,
@MyRequestBody String url,
@MyRequestBody MyPageParam pageParam) {
if (MyCommonUtil.existBlankArgument(loginName)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
List<Map<String, Object>> userPermMapList =
sysPermService.getUserPermListByFilter(loginName, moduleId, url);
JSONObject responseData = MyPageUtil.makeResponseData(userPermMapList);
return ResponseResult.success(responseData);
}
/**
* 查看拥有指定权限资源的所有用户数据列表。
*
* @param permId 指定权限资源主键Id。
* @return 应答结果对象，包含用户数据列表。
*/
@PostMapping("/listAllUsers")
public ResponseResult<List<Map<String, Object>>> listAllUsers(@MyRequestBody Long permId) {
if (MyCommonUtil.existBlankArgument(permId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
List<Map<String, Object>> permUserMapList = sysPermService.getPermUserListById(permId);
return ResponseResult.success(permUserMapList);
}
/**
* 查看拥有指定权限资源的所有角色数据列表。
*
* @param permId 指定权限资源主键Id。
* @return 应答结果对象，包含角色数据列表。
*/
@PostMapping("/listAllRoles")
public ResponseResult<List<Map<String, Object>>> listAllRoles(@MyRequestBody Long permId) {
if (MyCommonUtil.existBlankArgument(permId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
List<Map<String, Object>> permRoleMapList = sysPermService.getPermRoleListById(permId);
return ResponseResult.success(permRoleMapList);
}
}

157
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/controller/SysPermModuleController.java Normal file
View File

@@ -0,0 +1,157 @@
package com.orange.demo.upms.controller;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import com.orange.demo.upms.model.SysPerm;
import com.orange.demo.upms.model.SysPermModule;
import com.orange.demo.upms.service.SysPermModuleService;
import com.orange.demo.common.core.constant.ErrorCodeEnum;
import com.orange.demo.common.core.object.ResponseResult;
import com.orange.demo.common.core.util.MyCommonUtil;
import com.orange.demo.common.core.validator.UpdateGroup;
import com.orange.demo.common.core.annotation.MyRequestBody;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.groups.Default;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
/**
* 权限资源模块管理接口控制器类。
*
* @author Jerry
* @date 2020-09-25
*/
@Slf4j
@RestController
@RequestMapping("/admin/upms/sysPermModule")
public class SysPermModuleController {
@Autowired
private SysPermModuleService sysPermModuleService;
/**
* 新增权限资源模块操作。
*
* @param sysPermModule 新增权限资源模块对象。
* @return 应答结果对象，包含新增权限资源模块的主键Id。
*/
@PostMapping("/add")
public ResponseResult<JSONObject> add(@MyRequestBody SysPermModule sysPermModule) {
String errorMessage = MyCommonUtil.getModelValidationError(sysPermModule);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
if (sysPermModule.getParentId() != null
&& sysPermModuleService.getById(sysPermModule.getParentId()) == null) {
errorMessage = "数据验证失败，关联的上级权限模块并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_PARENT_ID_NOT_EXIST, errorMessage);
}
sysPermModuleService.saveNew(sysPermModule);
JSONObject responseData = new JSONObject();
responseData.put("permModuleId", sysPermModule.getModuleId());
return ResponseResult.success(responseData);
}
/**
* 更新权限资源模块操作。
*
* @param sysPermModule 更新权限资源模块对象。
* @return 应答结果对象，包含新增权限资源模块的主键Id。
*/
@PostMapping("/update")
public ResponseResult<Void> update(@MyRequestBody SysPermModule sysPermModule) {
String errorMessage = MyCommonUtil.getModelValidationError(sysPermModule, Default.class, UpdateGroup.class);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
SysPermModule originalPermModule = sysPermModuleService.getById(sysPermModule.getModuleId());
if (originalPermModule == null) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
if (sysPermModule.getParentId() != null
&& !sysPermModule.getParentId().equals(originalPermModule.getParentId())) {
if (sysPermModuleService.getById(sysPermModule.getParentId()) == null) {
errorMessage = "数据验证失败，关联的上级权限模块并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_PARENT_ID_NOT_EXIST, errorMessage);
}
}
if (!sysPermModuleService.update(sysPermModule, originalPermModule)) {
errorMessage = "数据验证失败，当前模块并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
return ResponseResult.success();
}
/**
* 删除指定权限资源模块操作。
*
* @param moduleId 指定的权限资源模块主键Id。
* @return 应答结果对象。
*/
@PostMapping("/delete")
public ResponseResult<Void> delete(@MyRequestBody Long moduleId) {
if (MyCommonUtil.existBlankArgument(moduleId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
String errorMessage;
if (sysPermModuleService.hasChildren(moduleId)
|| sysPermModuleService.hasModulePerms(moduleId)) {
errorMessage = "数据验证失败，当前权限模块存在子模块或权限资源，请先删除关联数据！";
return ResponseResult.error(ErrorCodeEnum.HAS_CHILDREN_DATA, errorMessage);
}
if (!sysPermModuleService.remove(moduleId)) {
errorMessage = "数据操作失败，权限模块不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
return ResponseResult.success();
}
/**
* 查看全部权限资源模块列表。
*
* @return 应答结果对象，包含权限资源模块列表。
*/
@GetMapping("/list")
public ResponseResult<List<SysPermModule>> list() {
return ResponseResult.success(sysPermModuleService.getAllListByOrder("showOrder"));
}
/**
* 列出全部权限资源模块及其下级关联的权限资源列表。
*
* @return 应答结果对象，包含树状列表，结构为权限资源模块和权限资源之间的树状关系。
*/
@GetMapping("/listAll")
public ResponseResult<List<Map<String, Object>>> listAll() {
List<SysPermModule> sysPermModuleList = sysPermModuleService.getPermModuleAndPermList();
List<Map<String, Object>> resultList = new LinkedList<>();
for (SysPermModule sysPermModule : sysPermModuleList) {
Map<String, Object> permModuleMap = new HashMap<>(5);
permModuleMap.put("id", sysPermModule.getModuleId());
permModuleMap.put("name", sysPermModule.getModuleName());
permModuleMap.put("type", sysPermModule.getModuleType());
permModuleMap.put("isPerm", false);
if (MyCommonUtil.isNotBlankOrNull(sysPermModule.getParentId())) {
permModuleMap.put("parentId", sysPermModule.getParentId());
}
resultList.add(permModuleMap);
if (CollectionUtils.isNotEmpty(sysPermModule.getSysPermList())) {
for (SysPerm sysPerm : sysPermModule.getSysPermList()) {
Map<String, Object> permMap = new HashMap<>(4);
permMap.put("id", sysPerm.getPermId());
permMap.put("name", sysPerm.getPermName());
permMap.put("isPerm", true);
permMap.put("url", sysPerm.getUrl());
permMap.put("parentId", sysPermModule.getModuleId());
resultList.add(permMap);
}
}
}
return ResponseResult.success(resultList);
}
}

323
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/controller/SysRoleController.java Normal file
View File

@@ -0,0 +1,323 @@
package com.orange.demo.upms.controller;
import com.alibaba.fastjson.JSONObject;
import com.github.pagehelper.page.PageMethod;
import lombok.extern.slf4j.Slf4j;
import com.orange.demo.upms.model.SysRole;
import com.orange.demo.upms.model.SysUser;
import com.orange.demo.upms.model.SysUserRole;
import com.orange.demo.upms.service.SysRoleService;
import com.orange.demo.upms.service.SysUserService;
import com.orange.demo.common.core.validator.UpdateGroup;
import com.orange.demo.common.core.util.MyCommonUtil;
import com.orange.demo.common.core.constant.ErrorCodeEnum;
import com.orange.demo.common.core.object.MyOrderParam;
import com.orange.demo.common.core.object.MyPageParam;
import com.orange.demo.common.core.object.ResponseResult;
import com.orange.demo.common.core.object.CallResult;
import com.orange.demo.common.core.object.MyRelationParam;
import com.orange.demo.common.core.util.MyPageUtil;
import com.orange.demo.common.core.annotation.MyRequestBody;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.groups.Default;
import java.util.*;
import java.util.stream.Collectors;
/**
* 角色管理接口控制器类。
*
* @author Jerry
* @date 2020-09-25
*/
@Slf4j
@RestController
@RequestMapping("/admin/upms/sysRole")
public class SysRoleController {
@Autowired
private SysRoleService sysRoleService;
@Autowired
private SysUserService sysUserService;
/**
* 新增角色操作。
*
* @param sysRole 新增角色对象。
* @param menuIdListString 与当前角色Id绑定的menuId列表，多个menuId之间逗号分隔。
* @return 应答结果对象，包含新增角色的主键Id。
*/
@SuppressWarnings("unchecked")
@PostMapping("/add")
public ResponseResult<JSONObject> add(@MyRequestBody SysRole sysRole, @MyRequestBody String menuIdListString) {
String errorMessage = MyCommonUtil.getModelValidationError(sysRole);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
CallResult result = sysRoleService.verifyRelatedData(sysRole, null, menuIdListString);
if (!result.isSuccess()) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, result.getErrorMessage());
}
Set<Long> menuIdSet = null;
if (result.getData() != null) {
menuIdSet = (Set<Long>) result.getData().get("menuIdSet");
}
sysRoleService.saveNew(sysRole, menuIdSet);
JSONObject responseData = new JSONObject();
responseData.put("roleId", sysRole.getRoleId());
return ResponseResult.success(responseData);
}
/**
* 更新角色操作。
*
* @param sysRole 更新角色对象。
* @param menuIdListString 与当前角色Id绑定的menuId列表，多个menuId之间逗号分隔。
* @return 应答结果对象。
*/
@SuppressWarnings("unchecked")
@PostMapping("/update")
public ResponseResult<Void> update(@MyRequestBody SysRole sysRole, @MyRequestBody String menuIdListString) {
String errorMessage = MyCommonUtil.getModelValidationError(sysRole, Default.class, UpdateGroup.class);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
SysRole originalSysRole = sysRoleService.getById(sysRole.getRoleId());
if (originalSysRole == null) {
errorMessage = "数据验证失败，当前角色并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
CallResult result = sysRoleService.verifyRelatedData(sysRole, originalSysRole, menuIdListString);
if (!result.isSuccess()) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, result.getErrorMessage());
}
Set<Long> menuIdSet = null;
if (result.getData() != null) {
menuIdSet = (Set<Long>) result.getData().get("menuIdSet");
}
if (!sysRoleService.update(sysRole, originalSysRole, menuIdSet)) {
errorMessage = "更新失败，数据不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
return ResponseResult.success();
}
/**
* 删除指定角色操作。
*
* @param roleId 指定角色主键Id。
* @return 应答结果对象。
*/
@PostMapping("/delete")
public ResponseResult<Void> delete(@MyRequestBody Long roleId) {
if (MyCommonUtil.existBlankArgument(roleId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
if (!sysRoleService.remove(roleId)) {
String errorMessage = "数据操作失败，角色不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
return ResponseResult.success();
}
/**
* 查看角色列表。
*
* @param sysRoleFilter 角色过滤对象。
* @param orderParam 排序参数。
* @param pageParam 分页参数。
* @return 应答结果对象，包含角色列表。
*/
@PostMapping("/list")
public ResponseResult<JSONObject> list(
@MyRequestBody SysRole sysRoleFilter,
@MyRequestBody MyOrderParam orderParam,
@MyRequestBody MyPageParam pageParam) {
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
List<SysRole> roleList = sysRoleService.getSysRoleList(
sysRoleFilter, MyOrderParam.buildOrderBy(orderParam, SysRole.class));
return ResponseResult.success(MyPageUtil.makeResponseData(roleList));
}
/**
* 查看角色详情。
*
* @param roleId 指定角色主键Id。
* @return 应答结果对象，包含角色详情对象。
*/
@GetMapping("/view")
public ResponseResult<SysRole> view(@RequestParam Long roleId) {
if (MyCommonUtil.existBlankArgument(roleId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
SysRole sysRole = sysRoleService.getByIdWithRelation(roleId, MyRelationParam.full());
if (sysRole == null) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success(sysRole);
}
/**
* 获取不包含指定角色Id的用户列表。
* 用户和角色是多对多关系，当前接口将返回没有赋值指定RoleId的用户列表。可用于给角色添加新用户。
*
* @param roleId 角色主键Id。
* @param sysUserFilter 用户过滤对象。
* @param orderParam 排序参数。
* @param pageParam 分页参数。
* @return 应答结果对象，包含用户列表数据。
*/
@PostMapping("/listNotInUserRole")
public ResponseResult<JSONObject> listNotInUserRole(
@MyRequestBody Long roleId,
@MyRequestBody SysUser sysUserFilter,
@MyRequestBody MyOrderParam orderParam,
@MyRequestBody MyPageParam pageParam) {
ResponseResult<Void> verifyResult = this.doRoleUserVerify(roleId);
if (!verifyResult.isSuccess()) {
return ResponseResult.errorFrom(verifyResult);
}
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
String orderBy = MyOrderParam.buildOrderBy(orderParam, SysUser.class);
List<SysUser> resultList =
sysUserService.getNotInSysUserListByRoleId(roleId, sysUserFilter, orderBy);
JSONObject responseData = MyPageUtil.makeResponseData(resultList);
return ResponseResult.success(responseData);
}
/**
* 拥有指定角色的用户列表。
*
* @param roleId 角色主键Id。
* @param sysUserFilter 用户过滤对象。
* @param orderParam 排序参数。
* @param pageParam 分页参数。
* @return 应答结果对象，包含用户列表数据。
*/
@PostMapping("/listUserRole")
public ResponseResult<JSONObject> listUserRole(
@MyRequestBody Long roleId,
@MyRequestBody SysUser sysUserFilter,
@MyRequestBody MyOrderParam orderParam,
@MyRequestBody MyPageParam pageParam) {
ResponseResult<Void> verifyResult = this.doRoleUserVerify(roleId);
if (!verifyResult.isSuccess()) {
return ResponseResult.errorFrom(verifyResult);
}
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
String orderBy = MyOrderParam.buildOrderBy(orderParam, SysUser.class);
List<SysUser> resultList = sysUserService.getSysUserListByRoleId(roleId, sysUserFilter, orderBy);
JSONObject responseData = MyPageUtil.makeResponseData(resultList);
return ResponseResult.success(responseData);
}
private ResponseResult<Void> doRoleUserVerify(Long roleId) {
if (MyCommonUtil.existBlankArgument(roleId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
if (!sysRoleService.existId(roleId)) {
return ResponseResult.error(ErrorCodeEnum.INVALID_RELATED_RECORD_ID);
}
return ResponseResult.success();
}
/**
* 为指定角色添加用户列表。该操作可同时给一批用户赋值角色，并在同一事务内完成。
*
* @param roleId 角色主键Id。
* @param userIdListString 逗号分隔的用户Id列表。
* @return 应答结果对象。
*/
@PostMapping("/addUserRole")
public ResponseResult<Void> addUserRole(
@MyRequestBody Long roleId, @MyRequestBody String userIdListString) {
if (MyCommonUtil.existBlankArgument(roleId, userIdListString)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
Set<Long> userIdSet = Arrays.stream(
userIdListString.split(",")).map(Long::valueOf).collect(Collectors.toSet());
if (!sysRoleService.existId(roleId)
|| !sysUserService.existUniqueKeyList("userId", userIdSet)) {
return ResponseResult.error(ErrorCodeEnum.INVALID_RELATED_RECORD_ID);
}
List<SysUserRole> userRoleList = new LinkedList<>();
for (Long userId : userIdSet) {
SysUserRole userRole = new SysUserRole();
userRole.setRoleId(roleId);
userRole.setUserId(userId);
userRoleList.add(userRole);
}
sysRoleService.addUserRoleList(userRoleList);
return ResponseResult.success();
}
/**
* 为指定用户移除指定角色。
*
* @param roleId 指定角色主键Id。
* @param userId 指定用户主键Id。
* @return 应答数据结果。
*/
@PostMapping("/deleteUserRole")
public ResponseResult<Void> deleteUserRole(
@MyRequestBody Long roleId, @MyRequestBody Long userId) {
if (MyCommonUtil.existBlankArgument(roleId, userId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
if (!sysRoleService.removeUserRole(roleId, userId)) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success();
}
/**
* 通过权限字Id获取拥有改权限的所有角色。
* 开发人员调试用接口。
*
* @param permCodeId 查询的权限字Id。
* @param pageParam 分页对象。
* @return 符合条件的角色列表。
*/
@PostMapping("/listAllRolesByPermCode")
public ResponseResult<JSONObject> listAllRolesByPermCode(
@MyRequestBody Long permCodeId, @MyRequestBody MyPageParam pageParam) {
if (MyCommonUtil.existBlankArgument(permCodeId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
List<SysRole> roleList = sysRoleService.getSysRoleListByPermCodeId(permCodeId);
JSONObject responseData = MyPageUtil.makeResponseData(roleList);
return ResponseResult.success(responseData);
}
/**
* 通过权限资源url，模糊搜索拥有改权限的所有角色。
* 开发人员调试用接口。
*
* @param url 用于模糊搜索的url。
* @param pageParam 分页对象。
* @return 符合条件的角色列表。
*/
@PostMapping("/listAllRolesByPerm")
public ResponseResult<JSONObject> listAllRolesByPerm(
@MyRequestBody String url, @MyRequestBody MyPageParam pageParam) {
if (MyCommonUtil.existBlankArgument(url)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
List<SysRole> roleList = sysRoleService.getSysRoleListByPerm(url);
JSONObject responseData = MyPageUtil.makeResponseData(roleList);
return ResponseResult.success(responseData);
}
}

176
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/controller/SysUserController.java Normal file
View File

@@ -0,0 +1,176 @@
package com.orange.demo.upms.controller;
import com.github.pagehelper.page.PageMethod;
import com.orange.demo.upms.model.*;
import com.orange.demo.upms.service.*;
import com.orange.demo.common.core.object.*;
import com.orange.demo.common.core.util.*;
import com.orange.demo.common.core.constant.ErrorCodeEnum;
import com.orange.demo.common.core.annotation.MyRequestBody;
import com.orange.demo.common.core.validator.AddGroup;
import com.orange.demo.common.core.validator.UpdateGroup;
import com.orange.demo.config.ApplicationConfig;
import lombok.extern.slf4j.Slf4j;
import com.alibaba.fastjson.JSONObject;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.*;
import javax.validation.groups.Default;
/**
* 用户管理操作控制器类。
*
* @author Jerry
* @date 2020-09-25
*/
@Slf4j
@RestController
@RequestMapping("/admin/upms/sysUser")
public class SysUserController {
@Autowired
private SysUserService sysUserService;
@Autowired
private PasswordEncoder passwordEncoder;
@Autowired
private ApplicationConfig appConfig;
/**
* 新增用户操作。
*
* @param sysUser 新增用户对象。
* @param roleIdListString 逗号分隔的角色Id列表。
* @return 应答结果对象，包含新增用户的主键Id。
*/
@SuppressWarnings("unchecked")
@PostMapping("/add")
public ResponseResult<JSONObject> add(@MyRequestBody SysUser sysUser, @MyRequestBody String roleIdListString) {
String errorMessage = MyCommonUtil.getModelValidationError(sysUser, Default.class, AddGroup.class);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
CallResult result = sysUserService.verifyRelatedData(sysUser, null, roleIdListString);
if (!result.isSuccess()) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, result.getErrorMessage());
}
Set<Long> roleIdSet = (Set<Long>) result.getData().get("roleIdSet");
sysUserService.saveNew(sysUser, roleIdSet);
JSONObject responseData = new JSONObject();
responseData.put("userId", sysUser.getUserId());
return ResponseResult.success(responseData);
}
/**
* 更新用户操作。
*
* @param sysUser 更新用户对象。
* @param roleIdListString 逗号分隔的角色Id列表。
* @return 应答结果对象。
*/
@SuppressWarnings("unchecked")
@PostMapping("/update")
public ResponseResult<Void> update(@MyRequestBody SysUser sysUser, @MyRequestBody String roleIdListString) {
String errorMessage = MyCommonUtil.getModelValidationError(sysUser, Default.class, UpdateGroup.class);
if (errorMessage != null) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, errorMessage);
}
SysUser originalUser = sysUserService.getById(sysUser.getUserId());
if (originalUser == null) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
CallResult result = sysUserService.verifyRelatedData(sysUser, originalUser, roleIdListString);
if (!result.isSuccess()) {
return ResponseResult.error(ErrorCodeEnum.DATA_VALIDATAED_FAILED, result.getErrorMessage());
}
Set<Long> roleIdSet = (Set<Long>) result.getData().get("roleIdSet");
if (!sysUserService.update(sysUser, originalUser, roleIdSet)) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success();
}
/**
* 重置密码操作。
*
* @param userId 指定用户主键Id。
* @return 应答结果对象。
*/
@PostMapping("/resetPassword")
public ResponseResult<Void> resetPassword(@MyRequestBody Long userId) {
if (MyCommonUtil.existBlankArgument(userId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
if (!sysUserService.changePassword(userId, appConfig.getDefaultUserPassword())) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success();
}
/**
* 删除用户管理数据。
*
* @param userId 删除对象主键Id。
* @return 应答结果对象。
*/
@PostMapping("/delete")
public ResponseResult<Void> delete(@MyRequestBody Long userId) {
String errorMessage;
if (MyCommonUtil.existBlankArgument(userId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
// 验证关联Id的数据合法性
SysUser originalSysUser = sysUserService.getById(userId);
if (originalSysUser == null) {
// NOTE: 修改下面方括号中的话述
errorMessage = "数据验证失败，当前 [对象] 并不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
if (!sysUserService.remove(userId)) {
errorMessage = "数据操作失败，删除的对象不存在，请刷新后重试！";
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST, errorMessage);
}
return ResponseResult.success();
}
/**
* 列出符合过滤条件的用户管理列表。
*
* @param sysUserFilter 过滤对象。
* @param orderParam 排序参数。
* @param pageParam 分页参数。
* @return 应答结果对象，包含查询结果集。
*/
@PostMapping("/list")
public ResponseResult<JSONObject> list(
@MyRequestBody SysUser sysUserFilter,
@MyRequestBody MyOrderParam orderParam,
@MyRequestBody MyPageParam pageParam) {
if (pageParam != null) {
PageMethod.startPage(pageParam.getPageNum(), pageParam.getPageSize());
}
String orderBy = MyOrderParam.buildOrderBy(orderParam, SysUser.class);
List<SysUser> resultList = sysUserService.getSysUserListWithRelation(sysUserFilter, orderBy);
return ResponseResult.success(MyPageUtil.makeResponseData(resultList));
}
/**
* 查看指定用户管理对象详情。
*
* @param userId 指定对象主键Id。
* @return 应答结果对象，包含对象详情。
*/
@GetMapping("/view")
public ResponseResult<SysUser> view(@RequestParam Long userId) {
if (MyCommonUtil.existBlankArgument(userId)) {
return ResponseResult.error(ErrorCodeEnum.ARGUMENT_NULL_EXIST);
}
// 这里查看用户数据时候，需要把用户多对多关联的角色和数据权限Id一并查出。
SysUser sysUser = sysUserService.getByIdWithRelation(userId, MyRelationParam.full());
if (sysUser == null) {
return ResponseResult.error(ErrorCodeEnum.DATA_NOT_EXIST);
}
return ResponseResult.success(sysUser);
}
}

23
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/dao/SysMenuMapper.java Normal file
View File

@@ -0,0 +1,23 @@
package com.orange.demo.upms.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.upms.model.SysMenu;
import java.util.List;
/**
* 菜单数据访问操作接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface SysMenuMapper extends BaseDaoMapper<SysMenu> {
/**
* 获取登录用户的菜单列表。
*
* @param userId 登录用户。
* @return 菜单列表。
*/
List<SysMenu> getMenuListByUserId(Long userId);
}

13
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/dao/SysMenuPermCodeMapper.java Normal file
View File

@@ -0,0 +1,13 @@
package com.orange.demo.upms.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.upms.model.SysMenuPermCode;
/**
* 菜单与权限字关系数据访问操作接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface SysMenuPermCodeMapper extends BaseDaoMapper<SysMenuPermCode> {
}

43
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/dao/SysPermCodeMapper.java Normal file
View File

@@ -0,0 +1,43 @@
package com.orange.demo.upms.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.upms.model.SysPermCode;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
/**
* 权限字数据访问操作接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface SysPermCodeMapper extends BaseDaoMapper<SysPermCode> {
/**
* 获取用户的所有权限字列表。
*
* @param userId 用户Id。
* @return 该用户的权限字列表。
*/
List<String> getPermCodeListByUserId(Long userId);
/**
* 获取该菜单的权限字和关联的权限资源列表。
*
* @param menuId 菜单Id。
* @return 权限字和关联的权限资源列表。
*/
List<Map<String, Object>> getPermCodeListByMenuId(Long menuId);
/**
* 获取指定用户的权限字列表。
*
* @param loginName 精确匹配用户登录名。
* @param permCode 模糊匹配的权限字名，LIKE %permCode%。
* @return 权限字列表。
*/
List<SysPermCode> getUserPermCodeListByFilter(
@Param("loginName") String loginName, @Param("permCode") String permCode);
}

13
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/dao/SysPermCodePermMapper.java Normal file
View File

@@ -0,0 +1,13 @@
package com.orange.demo.upms.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.upms.model.SysPermCodePerm;
/**
* 权限字与权限资源关系数据访问操作接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface SysPermCodePermMapper extends BaseDaoMapper<SysPermCodePerm> {
}

61
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/dao/SysPermMapper.java Normal file
View File

@@ -0,0 +1,61 @@
package com.orange.demo.upms.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.upms.model.SysPerm;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
/**
* 权限资源数据访问操作接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface SysPermMapper extends BaseDaoMapper<SysPerm> {
/**
* 获取用户的权限列表。
*
* @param userId 用户Id。
* @return 该用户的权限标识列表。
*/
List<SysPerm> getPermListByUserId(@Param("userId") Long userId);
/**
* 获取指定用户Id的权限列表。
*
* @param loginName 精确匹配用户登录名。
* @param moduleId 精确匹配权限模块Id。
* @param url 权限的url过滤条件，LIKE %url%。
* @return 权限列表。
*/
List<Map<String, Object>> getUserPermListByFilter(
@Param("loginName") String loginName, @Param("moduleId") Long moduleId, @Param("url") String url);
/**
* 根据关联权限字主键Id，获取权限资源数据列表。
*
* @param permCodeId 关联权限字主键Id。
* @param orderBy 排序字符串，ORDER BY从句的参数。
* @return 从表数据列表。
*/
List<SysPerm> getPermListByPermCodeId(@Param("permCodeId") Long permCodeId, @Param("orderBy") String orderBy);
/**
* 获取指定权限的用户列表。
*
* @param permId 指定权限。
* @return 用户列表。
*/
List<Map<String, Object>> getPermUserListById(@Param("permId") Long permId);
/**
* 获取指定权限的角色列表。
*
* @param permId 指定权限。
* @return 角色列表。
*/
List<Map<String, Object>> getPermRoleListById(@Param("permId") Long permId);
}

22
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/dao/SysPermModuleMapper.java Normal file
View File

@@ -0,0 +1,22 @@
package com.orange.demo.upms.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.upms.model.SysPermModule;
import java.util.List;
/**
* 权限资源模块数据访问操作接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface SysPermModuleMapper extends BaseDaoMapper<SysPermModule> {
/**
* 获取整个权限模块和权限关联后的全部数据。
*
* @return 关联的权限模块和权限资源列表。
*/
List<SysPermModule> getPermModuleAndPermList();
}

13
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/dao/SysPermWhitelistMapper.java Normal file
View File

@@ -0,0 +1,13 @@
package com.orange.demo.upms.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.upms.model.SysPermWhitelist;
/**
* 权限资源白名单数据访问操作接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface SysPermWhitelistMapper extends BaseDaoMapper<SysPermWhitelist> {
}

41
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/dao/SysRoleMapper.java Normal file
View File

@@ -0,0 +1,41 @@
package com.orange.demo.upms.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.upms.model.SysRole;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 角色数据访问操作接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface SysRoleMapper extends BaseDaoMapper<SysRole> {
/**
* 获取对象列表，过滤条件中包含like和between条件。
*
* @param sysRoleFilter 过滤对象。
* @param orderBy 排序字符串，order by从句的参数。
* @return 对象列表。
*/
List<SysRole> getSysRoleList(@Param("sysRoleFilter") SysRole sysRoleFilter, @Param("orderBy") String orderBy);
/**
* 根据权限字Id获取关联的角色列表。
*
* @param permCodeId 权限字Id。
* @return 关联的角色列表。
*/
List<SysRole> getSysRoleListByPermCodeId(@Param("permCodeId") Long permCodeId);
/**
* 根据url模糊查询关联的角色列表。
*
* @param url url片段。
* @return 关联的角色列表。
*/
List<SysRole> getSysRoleListByPerm(@Param("url") String url);
}

13
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/dao/SysRoleMenuMapper.java Normal file
View File

@@ -0,0 +1,13 @@
package com.orange.demo.upms.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.upms.model.SysRoleMenu;
/**
* 角色与菜单操作关联关系数据访问操作接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface SysRoleMenuMapper extends BaseDaoMapper<SysRoleMenu> {
}

52
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/dao/SysUserMapper.java Normal file
View File

@@ -0,0 +1,52 @@
package com.orange.demo.upms.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.upms.model.SysUser;
import org.apache.ibatis.annotations.Param;
import java.util.*;
/**
* 用户管理数据操作访问接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface SysUserMapper extends BaseDaoMapper<SysUser> {
/**
* 获取过滤后的对象列表。
*
* @param sysUserFilter 主表过滤对象。
* @param orderBy 排序字符串，order by从句的参数。
* @return 对象列表。
*/
List<SysUser> getSysUserList(
@Param("sysUserFilter") SysUser sysUserFilter, @Param("orderBy") String orderBy);
/**
* 根据角色Id，获取关联的用户Id列表。
*
* @param roleId 关联的角色Id。
* @param sysUserFilter 用户过滤条件对象。
* @param orderBy order by从句的参数。
* @return 和RoleId关联的用户列表。
*/
List<SysUser> getSysUserListByRoleId(
@Param("roleId") Long roleId,
@Param("sysUserFilter") SysUser sysUserFilter,
@Param("orderBy") String orderBy);
/**
* 根据角色Id，获取和当前角色Id没有建立多对多关联关系的用户Id列表。
*
* @param roleId 关联的角色Id。
* @param sysUserFilter 用户过滤条件对象。
* @param orderBy order by从句的参数。
* @return 和RoleId没有建立关联关系的用户列表。
*/
List<SysUser> getNotInSysUserListByRoleId(
@Param("roleId") Long roleId,
@Param("sysUserFilter") SysUser sysUserFilter,
@Param("orderBy") String orderBy);
}

22
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/dao/SysUserRoleMapper.java Normal file
View File

@@ -0,0 +1,22 @@
package com.orange.demo.upms.dao;
import com.orange.demo.common.core.base.dao.BaseDaoMapper;
import com.orange.demo.upms.model.SysUserRole;
import java.util.List;
/**
* 用户与角色关联关系数据访问操作接口。
*
* @author Jerry
* @date 2020-09-25
*/
public interface SysUserRoleMapper extends BaseDaoMapper<SysUserRole> {
/**
* 批量插入用户角色信息，如果用户角色已经存在，则不会重复插入。
*
* @param userRoleList 待插入的角色用户列表。
*/
void addUserRoleList(List<SysUserRole> userRoleList);
}

35
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/dao/mapper/SysMenuMapper.xml Normal file
View File

@@ -0,0 +1,35 @@
<?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.orange.demo.upms.dao.SysMenuMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.upms.model.SysMenu">
<id column="menu_id" jdbcType="BIGINT" property="menuId"/>
<result column="parent_id" jdbcType="BIGINT" property="parentId"/>
<result column="menu_name" jdbcType="VARCHAR" property="menuName"/>
<result column="menu_type" jdbcType="INTEGER" property="menuType"/>
<result column="form_router_name" jdbcType="VARCHAR" property="formRouterName"/>
<result column="show_order" jdbcType="INTEGER" property="showOrder"/>
<result column="icon" jdbcType="VARCHAR" property="icon"/>
<result column="create_time" jdbcType="TIMESTAMP" property="createTime"/>
<result column="deleted_flag" jdbcType="INTEGER" property="deletedFlag"/>
</resultMap>
<select id="getMenuListByUserId" resultMap="BaseResultMap">
SELECT
DISTINCT m.*
FROM
zz_sys_user u,
zz_sys_user_role ur,
zz_sys_role_menu rm,
zz_sys_menu m
<where>
AND u.user_id = #{userId}
AND u.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
AND u.user_id = ur.user_id
AND ur.role_id = rm.role_id
AND rm.menu_id = m.menu_id
AND m.menu_type &lt;= ${@com.orange.demo.upms.model.constant.SysMenuType@TYPE_MENU}
AND m.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
</where>
ORDER BY m.show_order
</select>
</mapper>

8
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/dao/mapper/SysMenuPermCodeMapper.xml Normal file
View File

@@ -0,0 +1,8 @@
<?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.orange.demo.upms.dao.SysMenuPermCodeMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.upms.model.SysMenuPermCode">
<result column="menu_id" jdbcType="BIGINT" property="menuId"/>
<result column="perm_code_id" jdbcType="BIGINT" property="permCodeId"/>
</resultMap>
</mapper>

84
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/dao/mapper/SysPermCodeMapper.xml Normal file
View File

@@ -0,0 +1,84 @@
<?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.orange.demo.upms.dao.SysPermCodeMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.upms.model.SysPermCode">
<id column="perm_code_id" jdbcType="BIGINT" property="permCodeId"/>
<result column="parent_id" jdbcType="BIGINT" property="parentId"/>
<result column="perm_code" jdbcType="VARCHAR" property="permCode"/>
<result column="perm_code_type" jdbcType="INTEGER" property="permCodeType"/>
<result column="show_name" jdbcType="VARCHAR" property="showName"/>
<result column="show_order" jdbcType="INTEGER" property="showOrder"/>
<result column="create_time" jdbcType="TIMESTAMP" property="createTime"/>
<result column="deleted_flag" jdbcType="INTEGER" property="deletedFlag"/>
</resultMap>
<select id="getPermCodeListByUserId" resultType="java.lang.String">
SELECT
DISTINCT pc.perm_code
FROM
zz_sys_user u,
zz_sys_user_role ur,
zz_sys_role_menu rm,
zz_sys_menu_perm_code mpc,
zz_sys_perm_code pc
<where>
AND u.user_id = #{userId}
AND u.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
AND u.user_id = ur.user_id
AND ur.role_id = rm.role_id
AND rm.menu_id = mpc.menu_id
AND mpc.perm_code_id = pc.perm_code_id
AND pc.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
</where>
</select>
<select id="getUserPermCodeListByFilter" resultMap="BaseResultMap">
SELECT
DISTINCT pc.*
FROM
zz_sys_user u,
zz_sys_user_role ur,
zz_sys_role_menu rm,
zz_sys_menu_perm_code mpc,
zz_sys_perm_code pc
<where>
AND u.login_name = #{loginName}
AND u.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
AND u.user_id = ur.user_id
AND ur.role_id = rm.role_id
AND rm.menu_id = mpc.menu_id
AND mpc.perm_code_id = pc.perm_code_id
AND pc.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
<if test="permCode != null and permCode != ''">
<bind name= "safePermCode" value= "'%' + permCode + '%'" />
AND pc.perm_code LIKE #{safePermCode}
</if>
</where>
ORDER BY pc.create_time
</select>
<select id="getPermCodeListByMenuId" resultType="map">
SELECT
pc.perm_code_id permCodeId,
pc.show_name showName,
pc.perm_code_type permCodeType,
pc.perm_code permCode,
p.perm_id permId,
p.perm_name permName,
p.url
FROM
zz_sys_menu_perm_code mpc,
zz_sys_perm_code_perm pcp,
zz_sys_perm_code pc,
zz_sys_perm p
<where>
AND mpc.menu_id = #{menuId}
AND mpc.perm_code_id = pc.perm_code_id
AND mpc.perm_code_id = pcp.perm_code_id
AND pcp.perm_id = p.perm_id
AND pc.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
AND p.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
</where>
ORDER BY pc.perm_code_id, p.show_order
</select>
</mapper>

8
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/dao/mapper/SysPermCodePermMapper.xml Normal file
View File

@@ -0,0 +1,8 @@
<?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.orange.demo.upms.dao.SysPermCodePermMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.upms.model.SysPermCodePerm">
<id column="perm_code_id" jdbcType="BIGINT" property="permCodeId"/>
<id column="perm_id" jdbcType="BIGINT" property="permId"/>
</resultMap>
</mapper>

134
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/dao/mapper/SysPermMapper.xml Normal file
View File

@@ -0,0 +1,134 @@
<?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.orange.demo.upms.dao.SysPermMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.upms.model.SysPerm">
<id column="perm_id" jdbcType="BIGINT" property="permId"/>
<result column="module_id" jdbcType="BIGINT" property="moduleId"/>
<result column="perm_name" jdbcType="VARCHAR" property="permName"/>
<result column="url" jdbcType="VARCHAR" property="url"/>
<result column="show_order" jdbcType="INTEGER" property="showOrder"/>
<result column="create_time" jdbcType="TIMESTAMP" property="createTime"/>
<result column="deleted_flag" jdbcType="INTEGER" property="deletedFlag"/>
</resultMap>
<select id="getPermListByUserId" resultMap="BaseResultMap">
SELECT
p.*
FROM
zz_sys_user u,
zz_sys_user_role ur,
zz_sys_role_menu rm,
zz_sys_menu_perm_code mpc,
zz_sys_perm_code_perm pcp,
zz_sys_perm p
<where>
AND u.user_id = #{userId}
AND u.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
AND u.user_id = ur.user_id
AND ur.role_id = rm.role_id
AND rm.menu_id = mpc.menu_id
AND mpc.perm_code_id = pcp.perm_code_id
AND pcp.perm_id = p.perm_id
AND p.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
</where>
</select>
<select id="getUserPermListByFilter" resultType="map">
SELECT
pm.module_id moduleId,
pm.module_name moduleName,
p.perm_id permId,
p.perm_name permName,
p.create_time createTime,
p.url
FROM
zz_sys_user u,
zz_sys_user_role ur,
zz_sys_role_menu rm,
zz_sys_menu_perm_code mpc,
zz_sys_perm_code_perm pcp,
zz_sys_perm p,
zz_sys_perm_module pm
<where>
AND u.login_name = #{loginName}
AND u.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
AND u.user_id = ur.user_id
AND ur.role_id = rm.role_id
AND rm.menu_id = mpc.menu_id
AND mpc.perm_code_id = pcp.perm_code_id
AND pcp.perm_id = p.perm_id
AND p.module_id = pm.module_id
AND p.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
AND pm.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
<if test="url != null and url != ''">
<bind name= "safeUrl" value= "'%' + url + '%'" />
AND p.url LIKE #{safeUrl}
</if>
<if test="moduleId != null">
AND p.module_id = #{moduleId}
</if>
</where>
ORDER BY pm.module_id, p.create_time
</select>
<select id="getPermListByPermCodeId" resultMap="BaseResultMap">
SELECT
p.*
FROM
zz_sys_perm_code_perm pcp,
zz_sys_perm p
<where>
AND pcp.perm_code_id = #{permCodeId}
AND pcp.perm_id = p.perm_id
AND p.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
</where>
<if test="orderBy != null">
ORDER BY ${orderBy}
</if>
</select>
<select id="getPermUserListById" resultType="map">
SELECT
u.user_id,
u.login_name
u.show_name
FROM
zz_sys_perm p,
zz_sys_perm_code_perm pcp,
zz_sys_menu_perm_code mpc,
zz_sys_role_menu rm,
zz_sys_user_role ur,
zz_sys_user u
<where>
AND p.perm_id = #{permId}
AND p.perm_id = pcp.perm_id
AND pcp.perm_code_id = mpc.perm_code_id
AND mpc.menu_id = rm.menu_id
AND rm.role_id = ur.role_id
AND ur.user_id = u.user_id
AND u.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
AND p.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
</where>
</select>
<select id="getPermRoleListById" resultType="map">
SELECT
r.role_id,
r.role_name
FROM
zz_sys_perm p,
zz_sys_perm_code_perm pcp,
zz_sys_menu_perm_code mpc,
zz_sys_role_menu rm,
zz_sys_role r
<where>
AND p.perm_id = #{permId}
AND p.perm_id = pcp.perm_id
AND p.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
AND r.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
AND pcp.perm_code_id = mpc.perm_code_id
AND mpc.menu_id = rm.menu_id
AND rm.role_id = r.role_id
</where>
</select>
</mapper>

42
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/dao/mapper/SysPermModuleMapper.xml Normal file
View File

@@ -0,0 +1,42 @@
<?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.orange.demo.upms.dao.SysPermModuleMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.upms.model.SysPermModule">
<result column="module_id" jdbcType="BIGINT" property="moduleId"/>
<result column="parent_id" jdbcType="BIGINT" property="parentId"/>
<result column="module_name" jdbcType="VARCHAR" property="moduleName"/>
<result column="module_type" jdbcType="INTEGER" property="moduleType"/>
<result column="show_order" jdbcType="INTEGER" property="showOrder"/>
<result column="create_time" jdbcType="TIMESTAMP" property="createTime"/>
<result column="deleted_flag" jdbcType="INTEGER" property="deletedFlag"/>
</resultMap>
<resultMap id="BaseResultMapEx" type="com.orange.demo.upms.model.SysPermModule" extends="BaseResultMap">
<collection property="sysPermList" column="module_id" javaType="ArrayList"
ofType="com.orange.demo.upms.model.SysPerm" notNullColumn="perm_id"
resultMap="com.orange.demo.upms.dao.SysPermMapper.BaseResultMap">
</collection>
</resultMap>
<select id="getPermModuleAndPermList" resultMap="BaseResultMapEx">
SELECT
pm.module_id,
pm.module_name,
pm.parent_id,
pm.module_type,
p.perm_id,
p.perm_name,
p.module_id,
p.url
FROM
zz_sys_perm_module pm
LEFT JOIN
zz_sys_perm p ON pm.module_id = p.module_id
<where>
AND p.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
AND pm.deleted_flag = ${@com.orange.demo.common.core.constant.GlobalDeletedFlag@NORMAL}
</where>
ORDER BY
pm.show_order, p.show_order
</select>
</mapper>

9
orange-demo-single-service/application/src/main/java/com/orange/demo/upms/dao/mapper/SysPermWhitelistMapper.xml Normal file
View File

@@ -0,0 +1,9 @@
<?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.orange.demo.upms.dao.SysPermWhitelistMapper">
<resultMap id="BaseResultMap" type="com.orange.demo.upms.model.SysPermWhitelist">
<id column="perm_url" jdbcType="VARCHAR" property="permUrl"/>
<result column="module_name" jdbcType="VARCHAR" property="moduleName"/>
<result column="perm_name" jdbcType="VARCHAR" property="permName"/>
</resultMap>
</mapper>

Some files were not shown because too many files have changed in this diff Show More