open
/
open-dbtool
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

1、SpringBootService

Browse Source 
Former-commit-id: b1fa9bc0eb9b62a939d220e52bd84b84d70aeed2
master
wangbing 5 years ago
parent 8a951729a2
commit 2aa6b1c95a
28 changed files with 73 additions and 2760 deletions
Show Stats Download Patch File Download Diff File

7
src/main/java/xyz/wbsite/dbtool/javafx/JavaFxApplication.java
Unescape View File

@ -465,6 +465,12 @@ public class JavaFxApplication extends Application {
currentProject.setNeedCloud(newValue);
}
});
detailProjectController.getAsync().selectedProperty().addListener(new ChangeListener<Boolean>() {
@Override
public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
currentProject.setNeedAsync(newValue);
}
});
detailProjectController.getDatabase().selectedToggleProperty().addListener(new ChangeListener<Toggle>() {
@Override
public void changed(ObservableValue<? extends Toggle> observable, Toggle oldValue, Toggle newValue) {
@ -639,6 +645,7 @@ public class JavaFxApplication extends Application {
}
}
detailProjectController.getCloud().setSelected(currentProject.isNeedCloud());
detailProjectController.getAsync().setSelected(currentProject.isNeedAsync());
if (gridPane != null) {
mDetail.getChildren().clear();

10
src/main/java/xyz/wbsite/dbtool/javafx/ctrl/DetailProjectController.java
Unescape View File

@ -21,6 +21,8 @@ public class DetailProjectController {
private ToggleGroup database;
@FXML
private CheckBox cloud;
@FXML
private CheckBox async;
public CheckBox getSysMD() {
return sysMD;
@ -77,4 +79,12 @@ public class DetailProjectController {
public void setCloud(CheckBox cloud) {
this.cloud = cloud;
}
public CheckBox getAsync() {
return async;
}
public void setAsync(CheckBox async) {
this.async = async;
}
}

2
src/main/java/xyz/wbsite/dbtool/javafx/manger/callable/SpringBootCallable.java
Unescape View File

@ -259,7 +259,9 @@ public class SpringBootCallable implements Callable {
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "FreeMarkerConfig.java"), "SpringBoot/java/config/FreeMarkerConfig.java", ctx);
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "SecurityConfig.java"), "SpringBoot/java/config/SecurityConfig.java", ctx);
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "ScheduleConfig.java"), "SpringBoot/java/config/ScheduleConfig.java", ctx);
if (project.isNeedAsync()) {
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "ThreadPoolConfig.java"), "SpringBoot/java/config/ThreadPoolConfig.java", ctx);
}
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "WebMvcConfig.java"), "SpringBoot/java/config/WebMvcConfig.java", ctx);
if (project.getDatabase().name().equals(DataBase.SQLite.name())) {
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "SQLiteConfig.java"), "SpringBoot/java/config/SQLiteConfig.java", ctx);

92
src/main/java/xyz/wbsite/dbtool/javafx/manger/callable/SpringBootServiceCallable.java
Unescape View File

@ -76,10 +76,6 @@ public class SpringBootServiceCallable implements Callable {
generatePom(projectDir, project);
{//生成java文件
//生成 Controller
System.out.println("生成模块:action");
generateController(Tool.createPath(domainDir.getAbsolutePath(), "action"), project);
// 生成 Config
System.out.println("生成模块:config");
generateConfig(Tool.createPath(domainDir.getAbsolutePath(), "config"), project);
@ -155,61 +151,6 @@ public class SpringBootServiceCallable implements Callable {
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "pom.xml"), "SpringBootService/pom.ftl", ctx);
}
/**
* 生成Controller类
*
* @param root
* @param project
*/
public void generateController(File root, Project project) {
Tool.clear(root);
HashMap<String, Object> ctx = new HashMap<String, Object>();
ctx.put("basePackage", project.getProjectBasePackage());
ctx.put("author", project.getProjectAuthor());
ctx.put("date", new Date());
ctx.put("modules", project.getModules());
{
File ajax = Tool.createPath(root.getAbsolutePath(), "ajax");
if (project.isNeedSys()) {//生成系统模块
File system = Tool.createPath(ajax.getAbsolutePath(), "system");
for (String name : ResourceUtil.getResourceFiles("/modules/SpringBootService/java/action/ajax/system/")) {
freeMarkerManager.outputTemp(Tool.createFile(system.getAbsolutePath(), name), "SpringBootService/java/action/ajax/system/" + name, ctx);
}
}
}
{
File api = Tool.createPath(root.getAbsolutePath(), "api");
for (Module module : project.getModules()) {
File m = Tool.createPath(api.getAbsolutePath(), module.getModuleName());
for (Table table : module.getTables()) {
HashMap<String, Object> ctxss = new HashMap<String, Object>();
ctxss.put("basePackage", project.getProjectBasePackage());
ctxss.put("module", module.getModuleName());
ctxss.put("author", project.getProjectAuthor());
ctxss.put("date", new Date());
ctxss.put("table", table);
freeMarkerManager.outputTemp(Tool.createFile(m.getAbsolutePath(), table.getCName() + "Api.java"), "SpringBootService/java/action/api/Api.java", ctxss);
}
}
if (project.isNeedSys()) {//生成系统模块
File system = Tool.createPath(api.getAbsolutePath(), "system");
for (String name : ResourceUtil.getResourceFiles("/modules/SpringBootService/java/action/api/system/")) {
freeMarkerManager.outputTemp(Tool.createFile(system.getAbsolutePath(), name), "SpringBootService/java/action/api/system/" + name, ctx);
}
}
}
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "GlobalController.java"), "SpringBootService/java/action/GlobalController.java", ctx);
}
public void generateConfig(File root, Project project) {
if (!root.exists()) {
root.mkdirs();
@ -223,12 +164,7 @@ public class SpringBootServiceCallable implements Callable {
ctx.put("date", new Date());
//config
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "ActionConfig.java"), "SpringBootService/java/config/ActionConfig.java", ctx);
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "CacheConfig.java"), "SpringBootService/java/config/CacheConfig.java", ctx);
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "SecurityConfig.java"), "SpringBootService/java/config/SecurityConfig.java", ctx);
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "ScheduleConfig.java"), "SpringBootService/java/config/ScheduleConfig.java", ctx);
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "ThreadPoolConfig.java"), "SpringBootService/java/config/ThreadPoolConfig.java", ctx);
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "WebMvcConfig.java"), "SpringBootService/java/config/WebMvcConfig.java", ctx);
if (project.getDatabase().name().equals(DataBase.SQLite.name())) {
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "SQLiteConfig.java"), "SpringBootService/java/config/SQLiteConfig.java", ctx);
}
@ -691,33 +627,5 @@ public class SpringBootServiceCallable implements Callable {
freeMarkerManager.outputTemp(file, "SpringBootService/test/test.ftl", ctx);
}
}
if (project.isNeedSys()) {//生成系统模块
HashMap<String, Object> ctx = new HashMap<String, Object>();
ctx.put("tool", Tool.class);
ctx.put("basePackage", project.getProjectBasePackage());
ctx.put("moduleName", project.getProjectName());
ctx.put("author", project.getProjectAuthor());
ctx.put("date", new Date());
File system = Tool.createPath(root.getAbsolutePath(), "system");
for (String apiFile : ResourceUtil.getResourceFiles("/modules/SpringBootService/test/system/")) {
freeMarkerManager.outputTemp(Tool.createFile(system.getAbsolutePath(), apiFile), "SpringBootService/test/system/" + apiFile, ctx);
}
}
{//数据初始化
HashMap<String, Object> ctx = new HashMap<String, Object>();
ctx.put("tool", Tool.class);
ctx.put("basePackage", project.getProjectBasePackage());
ctx.put("moduleName", project.getProjectName());
ctx.put("author", project.getProjectAuthor());
ctx.put("date", new Date());
File system = Tool.createPath(root.getAbsolutePath(), "datainit");
for (String apiFile : ResourceUtil.getResourceFiles("/modules/SpringBootService/test/datainit/")) {
freeMarkerManager.outputTemp(Tool.createFile(system.getAbsolutePath(), apiFile), "SpringBootService/test/datainit/" + apiFile, ctx);
}
}
}
}

10
src/main/java/xyz/wbsite/dbtool/javafx/po/Project.java
Unescape View File

@ -38,6 +38,8 @@ public class Project extends TreeItem {
private boolean needSys;
@Property("needCloud")
private boolean needCloud;
@Property("needAsync")
private boolean needAsync;
@Property(value = "database")
private DataBase database;
@ -124,4 +126,12 @@ public class Project extends TreeItem {
public void setNeedEMail(boolean needEMail) {
this.needEMail = needEMail;
}
public boolean isNeedAsync() {
return needAsync;
}
public void setNeedAsync(boolean needAsync) {
this.needAsync = needAsync;
}
}

1
src/main/resources/fxml/projectdetail.fxml
Unescape View File

@ -77,6 +77,7 @@
<CheckBox fx:id="sysMD" selected="true" text="系统模块"/>
<CheckBox fx:id="multiDB" text="多数据库"/>
<CheckBox fx:id="cloud" selected="false" text="添加Cloud"/>
<CheckBox fx:id="async" selected="false" text="异步编程"/>
</children>
</HBox>
</children>

454
src/main/resources/modules/SpringBootService/java/action/GlobalController.java
Unescape View File

@ -1,454 +0,0 @@
package ${basePackage}.action;
import com.fasterxml.jackson.core.TreeNode;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.servlet.error.ErrorController;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.DispatcherServlet;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.View;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
import org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver;
import ${basePackage}.config.ActionConfig;
import ${basePackage}.frame.auth.LocalData;
import ${basePackage}.frame.base.BaseRequest;
import ${basePackage}.frame.base.BaseResponse;
import ${basePackage}.frame.base.ErrorType;
import ${basePackage}.frame.base.Screen;
import ${basePackage}.frame.auth.Token;
import ${basePackage}.frame.utils.AESUtil;
import ${basePackage}.frame.utils.LogUtil;
import ${basePackage}.frame.utils.MD5Util;
import ${basePackage}.frame.utils.MapperUtil;
import ${basePackage}.frame.utils.RequestUtil;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.Locale;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 全局请求Controller，如果无特殊请求，则不需再增加其他Controller
* 全局htm后缀入口{@link GlobalController#action(Model, HttpServletRequest, HttpServletResponse)}
* 全局ajax入口{@link GlobalController#ajax(String, String, String, HttpServletRequest, HttpServletResponse, String, MultipartFile)}
* 全局异常捕捉{@link GlobalController#exceptionHandler(HttpServletRequest, HttpServletResponse, Model, Exception)}
* 全局消息订阅{@link GlobalController#sse(String)}
* <p>
* 说明Request命名规则，驼峰式命名
* Api#Example#Request ==> 目标#动作#Request
*
* @author author
* @version 0.0.1
* @since 2017-01-01
*/
@Controller
@ControllerAdvice
public class GlobalController implements ErrorController {
@Value("${r'${server.servlet.context-path}'}")
private String context;
@Value("${r'${web.url.index}'}")
private String homePage;
@Value("${r'${web.url.login}'}")
private String loginPage;
@Autowired
private FreeMarkerViewResolver viewResolver;
/**
* 全局异常捕捉
*
* @param request
* @param response
* @param exception 要捕获的异常
* @return
*/
@ExceptionHandler(Exception.class)
public String exceptionHandler(HttpServletRequest request, HttpServletResponse response, Model model, Exception exception) {
StringBuffer msg = new StringBuffer("");
if (exception != null) {
msg = new StringBuffer("");
String message = exception.toString();
int length = exception.getStackTrace().length;
if (length > 0) {
msg.append("<a>").append(message).append("</a><br>");
for (int i = 0; i < length; i++) {
msg.append("<a>").append(exception.getStackTrace()[i]).append("</a><br>");
}
} else {
msg.append(message);
}
}
response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
model.addAttribute("msg", msg.toString());
return "500";
}
private final static String ERROR_PATH = "/error";
@Override
public String getErrorPath() {
return ERROR_PATH;
}
@RequestMapping(value = ERROR_PATH)
public String error(HttpServletRequest request, HttpServletResponse response) {
switch (response.getStatus()) {
case 404:
return "404";
case 403:
String errorUrl = RequestUtil.getErrorUrl(request);
errorUrl = errorUrl.replaceFirst(context, "");
if ((errorUrl.equals(homePage) || errorUrl.equals("/")) && LocalData.getToken() == null) {
try {
response.sendRedirect(context + loginPage);
} catch (IOException e) {
e.printStackTrace();
}
}
return "403";
case 500:
return "500";
default:
return "403";
}
}
@RequestMapping("/")
public String home() {
Token token = LocalData.getToken();
if (token == null) {
return "redirect:" + loginPage;
} else {
return "redirect:" + homePage;
}
}
/**
* 当未明确指定控制器时，走该请求，默认返回对应的layout布局和screen视图
* 当需要使用layout时，不需要返回值，ViewNameTranslator会处理对应关系
*
* @param model
* @param request
*/
@RequestMapping({"/**/*.htm"})
public String action(Model model, HttpServletRequest request, HttpServletResponse response) {
String servletPath = request.getServletPath();// /**/*.htm
String layout = "/layout/default";
String action = LocalData.getAction();// **/*
Pattern compile = Pattern.compile("^/(.+)\\.htm");
Matcher matcher = compile.matcher(servletPath);
if (matcher.find()) {
action = matcher.group(1);
LocalData.setAction(action);
}
try {
LocaleResolver localeResolver = (LocaleResolver) request.getAttribute(DispatcherServlet.LOCALE_RESOLVER_ATTRIBUTE);
Locale locale = localeResolver.resolveLocale(request);
{//查询screen
String[] split = action.split("/");
StringBuilder sb = new StringBuilder("");
sb.append("screen");
for (int i = 0; i < split.length; i++) {
sb.append(File.separator);
sb.append(split[i]);
}
layout = sb.toString();
View view = viewResolver.resolveViewName(layout, locale);
if (view == null) {
response.sendError(HttpServletResponse.SC_NOT_FOUND,"");
return null;
}
// 尝试执行Screen执行器(服务器渲染)，并返回视图模板
try {
String beanClassName = (ActionConfig.SCREEN_PREFIX + action).toLowerCase();
Screen screenExec = LocalData.getApplicationContext().getBean(beanClassName, Screen.class);
screenExec.exec(model, request, response);
if (response.getStatus() != HttpServletResponse.SC_OK) {
response.sendError(response.getStatus(),"");
return null;
}
} catch (BeansException e) {
}
}
{//查找layout
String[] split = action.split("/");
int lt = split.length;
while (lt > 0) {
StringBuilder sb = new StringBuilder("");
sb.append("layout");
for (int i = 0; i < lt - 1; i++) {
sb.append(File.separator);
sb.append(split[i]);
}
layout = sb.toString() + File.separator + split[split.length - 1];
View view = viewResolver.resolveViewName(layout, locale);
//无法找到对应layout，使用默认layout
if (view == null) {
layout = sb.toString() + File.separator + "default";
View defaultView = viewResolver.resolveViewName(layout, locale);
if (null == defaultView && lt == 1) {
System.err.println("can not find layout/default.ftl");
} else if (null == defaultView) {
lt--;
} else {
break;
}
} else {
break;
}
}
}
} catch (Exception e) {
return exceptionHandler(request, response, model, e);
}
// todo 可在此获取共性数据(也可以在全局拦截器GlobalHandlerInterceptor、拦截器作用域比此更高)，
// todo 例如用户信息等。其他业务数据在页面渲染后通过Ajax请求
return layout;
}
@RequestMapping("/ajax/{module}/{target}/{method}")
@ResponseBody
public Object ajax(
@PathVariable String module,
@PathVariable String target,
@PathVariable String method,
HttpServletRequest httpServletRequest,
HttpServletResponse httpServletResponse,
@RequestBody(required = false) String data,
@RequestParam(name = "file", required = false) MultipartFile file) {
try {
String beanClassName = (ActionConfig.AJAX_PREFIX + module + "/" + target).toLowerCase();
Object ajax = LocalData.getApplicationContext().getBean(beanClassName);
Class ajaxClass = ajax.getClass();
Method[] methods = ajaxClass.getDeclaredMethods();
Method methodC = null;
for (Method meth : methods) {
if (meth.getName().equals(method)) {
methodC = meth;
}
}
if (methodC == null) {
BaseResponse baseResponse = new BaseResponse();
baseResponse.addError(ErrorType.BUSINESS_ERROR, "未找到对应的方法!");
return baseResponse;
}
Parameter[] parameters = methodC.getParameters();
Object[] arg = new Object[parameters.length];
for (int i = 0; i < parameters.length; i++) {
Parameter parameter = parameters[i];
if (parameter.getType() == HttpServletRequest.class) {
arg[i] = httpServletRequest;
} else if (parameter.getType() == HttpServletResponse.class) {
arg[i] = httpServletResponse;
} else if (parameter.getType() == TreeNode.class) {
arg[i] = MapperUtil.toTree(data);
} else if (parameter.getType() == String.class) {
arg[i] = data;
} else if (parameter.getType() == MultipartFile.class) {
arg[i] = file;
} else if (BaseRequest.class.isAssignableFrom(parameter.getType())) {
arg[i] = MapperUtil.toJava(data, parameter.getType());
} else if (parameter.getType() == Token.class) {
arg[i] = LocalData.getToken();
} else {
arg[i] = null;
}
}
return methodC.invoke(ajax, arg);
} catch (BeansException e) {
e.printStackTrace();
BaseResponse baseResponse = new BaseResponse();
baseResponse.addError(ErrorType.BUSINESS_ERROR, "未找到对应的目标!");
return baseResponse;
} catch (IllegalAccessException e) {
e.printStackTrace();
BaseResponse baseResponse = new BaseResponse();
baseResponse.addError(ErrorType.BUSINESS_ERROR, "方法执必须公开!");
return baseResponse;
} catch (InvocationTargetException e) {
e.getTargetException().printStackTrace();
BaseResponse baseResponse = new BaseResponse();
baseResponse.addError(ErrorType.BUSINESS_ERROR, "方法执行错误[" + e.getTargetException().getMessage() + "]");
return baseResponse;
}
}
@RequestMapping(path = "/api/{module}/{target}/{method}", method = RequestMethod.POST)
@ResponseBody
public String api(
@PathVariable String module,
@PathVariable String target,
@PathVariable String method,
@RequestParam(required = false) String appKey,
@RequestParam(required = false) String sign,
@RequestParam(required = false) Long timestamp,
@RequestParam(required = false) String token,
@RequestParam(required = false) String encryptData,
HttpServletRequest httpServletRequest,
HttpServletResponse httpServletResponse) {
BaseResponse response = new BaseResponse();
if (appKey == null) {
response.addError(ErrorType.BUSINESS_ERROR, "应用码参数[appKey]不存在!");
return MapperUtil.toJson(response);
} else if (sign == null) {
response.addError(ErrorType.BUSINESS_ERROR, "签名参数[sign]不存在!");
return MapperUtil.toJson(response);
} else if (timestamp == null) {
response.addError(ErrorType.BUSINESS_ERROR, "时间戳参数[timestamp]不存在!");
return MapperUtil.toJson(response);
}
String data = null;
String appSecret = "1234567890123456";
// 解码
try {
data = AESUtil.decrypt2String(encryptData, appSecret);
} catch (Exception e) {
response.addError(ErrorType.BUSINESS_ERROR, "解码失败,请确认编码是否正确!");
return MapperUtil.toJson(response);
}
// 验证签名
String sign_ = MD5Util.encode(appSecret + data + timestamp);
if (!sign_.equals(sign)) {
response.addError(ErrorType.BUSINESS_ERROR, "签名验证失败!");
return AESUtil.encrypt2Base64(MapperUtil.toJson(response).getBytes(), appSecret);
}
// 时效性验证
long currentTime = System.currentTimeMillis();
if (currentTime - timestamp > 2 * 60 * 1000) {
response.addError(ErrorType.BUSINESS_ERROR, "请求过期, 或本地时间错误!");
return AESUtil.encrypt2Base64(MapperUtil.toJson(response).getBytes(), appSecret);
}
// 权限验证
if (!LocalData.getToken().hasRes(httpServletRequest.getServletPath())) {
response.addError(ErrorType.BUSINESS_ERROR, "[" + httpServletRequest.getServletPath() + "]未授权的资源!");
return AESUtil.encrypt2Base64(MapperUtil.toJson(response).getBytes(), appSecret);
}
// 开始处理业务
try {
String beanClassName = (ActionConfig.API_PREFIX + module + "/" + target).toLowerCase();
Object ajax = LocalData.getApplicationContext().getBean(beanClassName);
Class ajaxClass = ajax.getClass();
Method[] methods = ajaxClass.getDeclaredMethods();
Method methodC = null;
for (Method meth : methods) {
if (meth.getName().equals(method)) {
methodC = meth;
}
}
if (methodC == null) {
response.addError(ErrorType.BUSINESS_ERROR, "未找到对应的方法!");
return AESUtil.encrypt2Base64(MapperUtil.toJson(response).getBytes(), appSecret);
}
Parameter[] parameters = methodC.getParameters();
Object[] arg = new Object[parameters.length];
for (int i = 0; i < parameters.length; i++) {
Parameter parameter = parameters[i];
if (parameter.getType() == HttpServletRequest.class) {
arg[i] = httpServletRequest;
} else if (parameter.getType() == HttpServletResponse.class) {
arg[i] = httpServletResponse;
} else if (BaseRequest.class.isAssignableFrom(parameter.getType())) {
arg[i] = MapperUtil.toJava(data, parameter.getType());
} else if (parameter.getType() == TreeNode.class) {
arg[i] = MapperUtil.toTree(data);
} else if (parameter.getType() == Token.class) {
arg[i] = LocalData.getToken();
} else {
arg[i] = null;
}
}
response = (BaseResponse) methodC.invoke(ajax, arg);
} catch (BeansException e) {
e.printStackTrace();
response.addError(ErrorType.BUSINESS_ERROR, "未找到对应的目标!");
} catch (IllegalAccessException e) {
e.printStackTrace();
response.addError(ErrorType.BUSINESS_ERROR, "方法执必须公开!");
} catch (InvocationTargetException e) {
LogUtil.dumpException(e.getTargetException());
e.getTargetException().printStackTrace();
response.addError(ErrorType.BUSINESS_ERROR, "方法执行错误[" + e.getTargetException().getMessage() + "]");
}
return AESUtil.encrypt2Base64(MapperUtil.toJson(response).getBytes(), appSecret);
}
private static ConcurrentHashMap<String, SseEmitter> sseMap = new ConcurrentHashMap();
/**
* Sse推送服务，服务器向js推送自定义消息
* Sse容器{@link GlobalController#sseMap}
* Sse批量推送{@link GlobalController#pushAll}
*/
@RequestMapping(value = "/sse/{userId}", produces = "text/event-stream;charset=UTF-8")
public SseEmitter sse(@PathVariable String userId) {
SseEmitter sseEmitter = new SseEmitter(10000000L);
if (sseMap.get(userId) != null) {
sseMap.remove(userId);
}
sseMap.put(userId, sseEmitter);
return sseEmitter;
}
/**
* Sse批量推送
*
* @param data 推送对象
*/
public static void pushAll(Object data) {
for (String s : sseMap.keySet()) {
try {
sseMap.get(s).send(MapperUtil.toJson(data), MediaType.APPLICATION_JSON);
} catch (IOException e) {
sseMap.remove(s);
}
}
}
}

49
src/main/resources/modules/SpringBootService/java/action/api/Api.java
Unescape View File

@ -1,49 +0,0 @@
package ${basePackage}.action.api.${module};
import ${basePackage}.frame.auth.LocalData;
import ${basePackage}.module.${module}.mgr.${table.getCName()}Manager;
import ${basePackage}.module.${module}.req.*;
import ${basePackage}.module.${module}.rsp.*;
import org.springframework.beans.factory.annotation.Autowired;
public class ${table.getCName()}Api{
@Autowired
private ${table.getCName()}Manager ${table.getFName()}Manager;
<#if table.getCreate()>
public ${table.getCName()}CreateResponse create(${table.getCName()}CreateRequest request) {
return ${table.getFName()}Manager.create(request, LocalData.getToken());
}
</#if>
<#if table.getDelete()>
public ${table.getCName()}DeleteResponse delete(${table.getCName()}DeleteRequest request) {
return ${table.getFName()}Manager.delete(request, LocalData.getToken());
}
</#if>
<#if table.getUpdate()>
public ${table.getCName()}UpdateResponse update(${table.getCName()}UpdateRequest request) {
return ${table.getFName()}Manager.update(request, LocalData.getToken());
}
</#if>
<#if table.getFind()>
public ${table.getCName()}FindResponse find(${table.getCName()}FindRequest request) {
return ${table.getFName()}Manager.find(request, LocalData.getToken());
}
</#if>
<#if table.getGet()>
public ${table.getCName()}GetResponse get(${table.getCName()}GetRequest request) {
return ${table.getFName()}Manager.get(request, LocalData.getToken());
}
</#if>
<#if table.getSearch()>
public ${table.getCName()}SearchResponse search(${table.getCName()}SearchRequest request) {
return ${table.getFName()}Manager.search(request, LocalData.getToken());
}
</#if>
}

75
src/main/resources/modules/SpringBootService/java/config/ActionConfig.java
Unescape View File

@ -1,75 +0,0 @@
package ${basePackage}.config;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.AssignableTypeFilter;
import org.springframework.core.type.filter.TypeFilter;
import ${basePackage}.frame.utils.LogUtil;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 请求处理器配置类，Screen及Control
* <p>
* 注册扫描Screen处理器 {@link ActionConfig#registryScreen}
* 注册扫描Control处理器 {@link ActionConfig#registryControl}
*
* @author wangbing
* @version 0.0.1
* @since 2017-01-01
*/
@Configuration
public class ActionConfig implements BeanDefinitionRegistryPostProcessor {
public static String AJAX_PREFIX = "/ajax/";
public static String API_PREFIX = "/api/";
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
String aPackage = this.getClass().getPackage().getName();
Pattern compile = Pattern.compile("(.*)\\.config");
Matcher matcher = compile.matcher(aPackage);
if (matcher.find()) {
String basePackage = matcher.group(1);
registryApi(basePackage + ".action.api", beanDefinitionRegistry);
}
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
}
private int registryApi(String basePackage, BeanDefinitionRegistry beanDefinitionRegistry) {
ClassPathBeanDefinitionScanner classPathBeanDefinitionScanner = new ClassPathBeanDefinitionScanner(beanDefinitionRegistry);
classPathBeanDefinitionScanner.addIncludeFilter(new TypeFilter() {
@Override
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
return true;
}
});
classPathBeanDefinitionScanner.setBeanNameGenerator(new BeanNameGenerator() {
@Override
public String generateBeanName(BeanDefinition beanDefinition, BeanDefinitionRegistry beanDefinitionRegistry) {
String beanClassName = beanDefinition.getBeanClassName();
if (beanClassName != null && beanClassName.endsWith("Api")) {
beanClassName = beanClassName.substring(0, beanClassName.length() - 3);
}
String beamName = beanClassName.replaceAll(basePackage + ".", API_PREFIX).replaceAll("\\.","/").toLowerCase();
LogUtil.i("registry api " + beamName);
return beamName;
}
});
return classPathBeanDefinitionScanner.scan(basePackage);
}
}

45
src/main/resources/modules/SpringBootService/java/config/CacheConfig.java
Unescape View File

@ -1,45 +0,0 @@
package ${basePackage}.config;
import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.config.CacheConfiguration;
import net.sf.ehcache.config.DiskStoreConfiguration;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@EnableCaching
public class CacheConfig {
public static final String TOKEN_CACHE = "tokenCache";
@Bean
public EhCacheCacheManager getCacheManager() {
net.sf.ehcache.config.Configuration configuration = new net.sf.ehcache.config.Configuration();
// todo 需根据服务器物理内存配置
configuration.setMaxBytesLocalHeap("128M");
configuration.updateCheck(false);
configuration.addDiskStore(new DiskStoreConfiguration().path("java.io.tmpdir"));
CacheManager cacheManager = CacheManager.create(configuration);
// 添加token缓存
cacheManager.addCache(buildTokenCache());
return new EhCacheCacheManager(cacheManager);
}
/**
* 构建TokenCache
*
* @return 缓存
*/
private Cache buildTokenCache() {
CacheConfiguration config = new CacheConfiguration();
config.setMemoryStoreEvictionPolicy("LFU");//最少使用
config.setTimeToLiveSeconds(60 * 60);//最长有效时间
config.setTimeToIdleSeconds(60 * 60);//无访问最长有效时间
config.setName(TOKEN_CACHE);
return new Cache(config);
}
}

137
src/main/resources/modules/SpringBootService/java/config/SecurityConfig.java
Unescape View File

@ -1,137 +0,0 @@
package ${basePackage}.config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.access.intercept.FilterSecurityInterceptor;
import ${basePackage}.frame.auth.LocalData;
import ${basePackage}.frame.auth.Token;
import ${basePackage}.frame.utils.CookieUtil;
import ${basePackage}.module.system.mgr.TokensManager;
import ${basePackage}.module.system.req.TokensBuildRequest;
import ${basePackage}.module.system.rsp.TokensBuildResponse;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@Configuration
@EnableGlobalMethodSecurity(securedEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Value("${r'${web.url.auth.included}'}")
private String[] included;
@Value("${r'${web.url.auth.excluded}'}")
private String[] excluded;
@Value("${r'${spring.mvc.static-path-pattern}'}")
private String[] staticPath;
@Value("${r'${web.url.login}'}")
private String loginPage;
@Override
public void configure(WebSecurity web) throws Exception {
web.ignoring().mvcMatchers(staticPath);
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.addFilterBefore(new TokenFilter(), FilterSecurityInterceptor.class)// 过滤器用于处理Token
.authorizeRequests()
.antMatchers(excluded).permitAll()// 放行排除的URL
.antMatchers(included).access("@Authorization.hasPermission(request,authentication)")// 需要权限的URL
.and().cors()
.and().headers().frameOptions().disable()
.and().csrf().disable();
}
/**
* 此方法不要删除 用于屏蔽默认用户密码生成
* <p>
* 例如 Using generated security password: f6b42a66-71b1-4c31-b6a8-942838c81408
*
* @return
* @throws Exception
*/
@Bean
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
public static class TokenFilter implements Filter {
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) servletRequest;
HttpServletResponse response = (HttpServletResponse) servletResponse;
String token = request.getParameter("token");
if (token == null || token.isEmpty()) {
token = CookieUtil.getCookieValue(request.getCookies(), "token");
}
// 组装Token ~ 这边根据实际的业务组装Token
if (token != null) {
TokensManager tokensManager = LocalData.getBean(TokensManager.class);
TokensBuildRequest tokensBuildRequest = new TokensBuildRequest();
tokensBuildRequest.setToken(token);
TokensBuildResponse tokensBuildResponse = tokensManager.build(tokensBuildRequest, LocalData.getSysToken());
LocalData.setToken(tokensBuildResponse.getToken());
} else {
LocalData.setToken(null);
}
// Action
String servletPath = request.getServletPath().toLowerCase();
Pattern compile = Pattern.compile("^/(.+)\\.htm");
Matcher matcher = compile.matcher(servletPath);
if (matcher.find()) {
LocalData.setAction(matcher.group(1));
}
try {
filterChain.doFilter(servletRequest, servletResponse);
} catch (AccessDeniedException e) {
response.sendError(HttpServletResponse.SC_FORBIDDEN);
} catch (Exception e) {
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
}
}
}
@Bean("Authorization")
public Object getAuthorization() {
return new Object() {
public boolean hasPermission(HttpServletRequest request, Authentication authentication) {
Token token_ = LocalData.getToken();
if (token_ == null) {
return false;
}
String path = request.getServletPath();
if (token_.hasRes(path)) {
return true;
}
return false;
}
};
}
}

56
src/main/resources/modules/SpringBootService/java/config/ThreadPoolConfig.java
Unescape View File

@ -1,56 +0,0 @@
package ${basePackage}.config;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Configuration;
import org.springframework.lang.Nullable;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.lang.reflect.Method;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;
@Configuration
@EnableAsync
public class ThreadPoolConfig implements AsyncConfigurer {
private ThreadPoolTaskExecutor executor;
private int corePoolSize = 10;//线程池维护线程的最少数量
private int maxPoolSize = 30;//线程池维护线程的最大数量
private int queueCapacity = 8; //缓存队列
private int keepAlive = 60;//允许的空闲时间
@Nullable
@Override
public Executor getAsyncExecutor() {
executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(corePoolSize);
executor.setMaxPoolSize(maxPoolSize);
executor.setQueueCapacity(queueCapacity);
executor.setThreadNamePrefix("mqExecutor-");
// rejection-policy：当pool已经达到max size的时候，如何处理新任务
// CALLER_RUNS：不在新线程中执行任务，而是由调用者所在的线程来执行
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); //对拒绝task的处理策略
executor.setKeepAliveSeconds(keepAlive);
executor.initialize();
return executor;
}
@Nullable
@Override
public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
return new AsyncUncaughtExceptionHandler() {
@Override
public void handleUncaughtException(Throwable throwable, Method method, Object... objects) {
System.out.println("-------------》》》捕获线程异常信息");
}
};
}
}

68
src/main/resources/modules/SpringBootService/java/config/WebMvcConfig.java
Unescape View File

@ -1,68 +0,0 @@
package ${basePackage}.config;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import ${basePackage}.frame.utils.LogUtil;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
@Value("${r'${web.url.index}'}")
private String homePage;
@Value("${r'${spring.mvc.static-path-pattern}'}")
private String[] staticPath;
/**
* 增加全局拦截器，可用于异常日志的收集
*
* @param registry
*/
@Override
public void addInterceptors(InterceptorRegistry registry) {
// 全局异常收集拦截器
registry.addInterceptor(new HandlerInterceptorAdapter() {
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
super.afterCompletion(request, response, handler, ex);
if (ex != null) {
LogUtil.dumpException(ex);
}
}
}).addPathPatterns("/**").excludePathPatterns(staticPath);
}
/**
* Jackson序列化时的转化规则配置
* <p>
* 1、Long或long类型在序列化时转String，防止出现javascript中Number精度丢失的情况。
*
* @param converters
*/
@Override
public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
for (HttpMessageConverter<?> converter : converters) {
if (converter instanceof MappingJackson2HttpMessageConverter) {
ObjectMapper objectMapper = ((MappingJackson2HttpMessageConverter) converter).getObjectMapper();
SimpleModule simpleModule = new SimpleModule();
simpleModule.addSerializer(Long.class, ToStringSerializer.instance);
simpleModule.addSerializer(Long.TYPE, ToStringSerializer.instance);
objectMapper.registerModule(simpleModule);
}
}
}
}

39
src/main/resources/modules/SpringBootService/java/frame/auth/Token.java
Unescape View File

@ -1,12 +1,5 @@
package ${basePackage}.frame.auth;
import ${basePackage}.frame.utils.IDgenerator;
import ${basePackage}.module.system.ent.Res;
import ${basePackage}.module.system.mgr.ResManager;
import ${basePackage}.module.system.req.ResCreateRequest;
import ${basePackage}.module.system.req.ResFindRequest;
import ${basePackage}.module.system.rsp.ResFindResponse;
import java.io.Serializable;
import java.util.HashSet;
import java.util.List;
@ -41,30 +34,6 @@ public class Token implements Serializable {
private Set<String> resSet = new HashSet<>();
public boolean hasRes(String res) {
{// todo 开发初期收集资源，后期删除
String[] profiles = LocalData.getEnvironment().getActiveProfiles();
for (String profile : profiles) {
if (profile.contains("dev")) {//测试环境捕获资源
ResFindRequest resFindRequest = new ResFindRequest();
resFindRequest.setPageSize(0);
resFindRequest.setResValue(res);
ResManager resManager = LocalData.getBean(ResManager.class);
ResFindResponse resFindResponse = resManager.find(resFindRequest, LocalData.getSysToken());
if (resFindResponse.getResult().size() == 0) {//资源不存在，主动收集资源
ResCreateRequest resCreateRequest = new ResCreateRequest();
resCreateRequest.setResCode(IDgenerator.nextUUID());
resCreateRequest.setResName("默认");
resCreateRequest.setResValue(res);
resCreateRequest.setValid(true);
resCreateRequest.setResType("");
resManager.create(resCreateRequest, LocalData.getSysToken());
}
}
}
}
for (String s : resSet) {
if (res.matches(s)) {
return true;
@ -82,18 +51,10 @@ public class Token implements Serializable {
this.resSet.addAll(resourceSet);
}
public void putRes(List<Res> resList) {
if (resList == null) return;
for (Res res : resList) {
this.resSet.add(res.getResValue());
}
}
public Set<String> getResSet() {
return resSet;
}
public long getId() {
return id;
}

5
src/main/resources/modules/SpringBootService/java/task/ExampleTask.java
Unescape View File

@ -1,11 +1,8 @@
package ${basePackage}.task;
import ${basePackage}.frame.auth.LocalData;
import ${basePackage}.frame.schedule.RunDelayRepeatTask;
import ${basePackage}.module.system.ent.Tokens;
import java.time.Duration;
import java.util.Date;
public class ExampleTask extends RunDelayRepeatTask {
@ -21,6 +18,6 @@ public class ExampleTask extends RunDelayRepeatTask {
@Override
public void run() {
System.out.print("task ...");
System.out.println("task ...");
}
}

86
src/main/resources/modules/SpringBootService/test/UtilTest.java
Unescape View File

@ -6,9 +6,6 @@ import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;
import ${basePackage}.frame.excel.WExcel;
import ${basePackage}.frame.excel.exception.ReadErrorException;
import ${basePackage}.frame.excel.exception.TemplateNotMatchException;
import ${basePackage}.frame.utils.AESUtil;
import ${basePackage}.frame.utils.Base64Util;
import ${basePackage}.frame.utils.IDgenerator;
@ -16,7 +13,6 @@ import ${basePackage}.frame.utils.MD5Util;
import ${basePackage}.frame.utils.MapperUtil;
import ${basePackage}.frame.utils.ProcessUtil;
import ${basePackage}.frame.utils.RSAUtil;
import ${basePackage}.module.system.ent.Dept;
import java.io.File;
import java.io.IOException;
@ -111,46 +107,46 @@ public class UtilTest {
@Test
public void testExcel() {
// 准备导出数据
Dept dept = new Dept();
dept.setDeptCode("A000101");
dept.setDeptName("人事部");
dept.setDeptAlias("人事部");
dept.setSupCode("A0001");
dept.setSupName("董事会");
dept.setValid(true);
ArrayList<Dept> depts = new ArrayList<Dept>();
depts.add(dept);
// 设置文件地址及导出
try {
File file = new File("E:\\E.xlsx");
new WExcel<Dept>(Dept.class).loadData(depts).toFile(file);
} catch (IOException e) {
e.printStackTrace();
}
// 导入数据
try {
File file = new File("E:\\E.xlsx");
WExcel.Processor<Dept> processor = new WExcel.Processor<Dept>() {
@Override
public List<String> exec(Dept o) {
System.out.println("从Excel中读取对象:" + MapperUtil.toJson(o));
return Arrays.asList("模拟处理对象业务时出现的错误信息1","模拟处理对象业务时出现的错误信息2");
}
};
WExcel check = new WExcel<Dept>(Dept.class).loadData(file, processor);
if (check.hasError()) {
System.out.println("导入或处理有错误.");
check.toFile(new File("E:\\E_err.xlsx"));
}
} catch (TemplateNotMatchException e) {
Assert.assertTrue("导入文件与模板不匹配，请重新下载模板！", false);
} catch (ReadErrorException e) {
Assert.assertTrue("导入文件错误，请检查格式或文件是否被破坏！", false);
} catch (IOException e) {
Assert.assertTrue("读取错误！", false);
}
// // 准备导出数据
// Dept dept = new Dept();
// dept.setDeptCode("A000101");
// dept.setDeptName("人事部");
// dept.setDeptAlias("人事部");
// dept.setSupCode("A0001");
// dept.setSupName("董事会");
// dept.setValid(true);
// ArrayList<Dept> depts = new ArrayList<Dept>();
// depts.add(dept);
//
// // 设置文件地址及导出
// try {
// File file = new File("E:\\E.xlsx");
// new WExcel<Dept>(Dept.class).loadData(depts).toFile(file);
// } catch (IOException e) {
// e.printStackTrace();
// }
//
// // 导入数据
// try {
// File file = new File("E:\\E.xlsx");
// WExcel.Processor<Dept> processor = new WExcel.Processor<Dept>() {
// @Override
// public List<String> exec(Dept o) {
// System.out.println("从Excel中读取对象:" + MapperUtil.toJson(o));
// return Arrays.asList("模拟处理对象业务时出现的错误信息1","模拟处理对象业务时出现的错误信息2");
// }
// };
// WExcel check = new WExcel<Dept>(Dept.class).loadData(file, processor);
// if (check.hasError()) {
// System.out.println("导入或处理有错误.");
// check.toFile(new File("E:\\E_err.xlsx"));
// }
// } catch (TemplateNotMatchException e) {
// Assert.assertTrue("导入文件与模板不匹配，请重新下载模板！", false);
// } catch (ReadErrorException e) {
// Assert.assertTrue("导入文件错误，请检查格式或文件是否被破坏！", false);
// } catch (IOException e) {
// Assert.assertTrue("读取错误！", false);
// }
}
}

102
src/main/resources/modules/SpringBootService/test/datainit/DictInit.java
Unescape View File

@ -1,102 +0,0 @@
package ${basePackage}.datainit;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;
import ${basePackage}.frame.auth.Token;
import ${basePackage}.module.system.mgr.DictItemManager;
import ${basePackage}.module.system.mgr.DictManager;
import ${basePackage}.module.system.req.DictCreateRequest;
import ${basePackage}.module.system.req.DictItemCreateRequest;
import ${basePackage}.module.system.rsp.DictCreateResponse;
import ${basePackage}.module.system.rsp.DictItemCreateResponse;
import java.text.SimpleDateFormat;
import java.util.Date;
import static org.junit.Assert.assertTrue;
@RunWith(SpringRunner.class)
@SpringBootTest
@Transactional
public class DictInit {
@Autowired
private DictManager dictManager;
@Autowired
private DictItemManager dictItemManager;
@Autowired
private Token token;
@Test
@Rollback(false)
public void init() {
{// 终端类型
createDict("TERMINAL_TYPE", "终端类型", new String[][]{
{"WEB", "游览器端"},
{"API", "接口端"},
{"PHONE", "手机端"},
});
}
{// 错误日志结果
createDict("LOG_ERR_RESULT", "错误日志结果", new String[][]{
{"未处理", "未处理"},
{"已处理", "已处理"},
{"搁置", "搁置"},
});
}
{// 资源类型
createDict("RES_TYPE", "资源类型", new String[][]{
{"网页地址", "网页地址"},
{"异步请求", "异步请求"},
});
}
{// 用户状态
createDict("USER_STATUS", "用户状态", new String[][]{
{"正常", "正常"},
{"初始密码", "初始密码"},
{"锁定/注销", "锁定/注销"},
});
}
{// 日志错误类型
createDict("LOG_ERR_TYPE", "日志错误类型", new String[][]{
{"系统错误", "系统错误"},
{"业务错误", "业务错误"},
});
}
{// 文件类型
createDict("FILE_TYPE", "文件类型", new String[][]{
{"IMG", "图片"},
});
}
}
private void createDict(String name, String comment, String[][] items) {
DictCreateRequest dictCreateRequest = new DictCreateRequest();
dictCreateRequest.setDictName(name);
dictCreateRequest.setDictComment(comment);
dictCreateRequest.setVersion(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
dictCreateRequest.setValid(true);
DictCreateResponse dictCreateResponse = dictManager.create(dictCreateRequest, token);
assertTrue(!dictCreateResponse.hasError());
for (int i = 0; i < items.length; i++) {
String[] item = items[i];
DictItemCreateRequest dictItemCreateRequest = new DictItemCreateRequest();
dictItemCreateRequest.setDictName(name);
dictItemCreateRequest.setKey(item[0]);
dictItemCreateRequest.setValue(item[1]);
dictItemCreateRequest.setSort(i);
dictItemCreateRequest.setValid(true);
DictItemCreateResponse dictItemCreateResponse = dictItemManager.create(dictItemCreateRequest, token);
assertTrue(!dictItemCreateResponse.hasError());
}
}
}

148
src/main/resources/modules/SpringBootService/test/system/DeptTest.java
Unescape View File

@ -1,148 +0,0 @@
package ${basePackage}.system;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;
import ${basePackage}.frame.auth.Token;
import ${basePackage}.module.system.mgr.DeptManager;
import ${basePackage}.module.system.req.DeptCreateRequest;
import ${basePackage}.module.system.req.DeptDeleteRequest;
import ${basePackage}.module.system.req.DeptFindRequest;
import ${basePackage}.module.system.req.DeptGetRequest;
import ${basePackage}.module.system.req.DeptUpdateRequest;
import ${basePackage}.module.system.rsp.DeptCreateResponse;
import ${basePackage}.module.system.rsp.DeptDeleteResponse;
import ${basePackage}.module.system.rsp.DeptFindResponse;
import ${basePackage}.module.system.rsp.DeptGetResponse;
import ${basePackage}.module.system.rsp.DeptUpdateResponse;
import static org.junit.Assert.assertTrue;
/**
* DeptTest - - 部门测试用例
*
* @author wangbing
* @version 0.0.1
* @since 2019-12-27
*/
@RunWith(SpringRunner.class)
@SpringBootTest
@Transactional
public class DeptTest {
@Autowired
private Token token;
@Autowired
private DeptManager deptManager;
@Test
@Rollback(false)
public void testCreate() {
{
DeptCreateRequest request = new DeptCreateRequest();
request.setDeptCode("A00");
request.setDeptName("开发部");
request.setDeptAlias("开发部");
request.setValid(true);
DeptCreateResponse response = deptManager.create(request, token);
assertTrue(!response.hasError());
}
{
DeptCreateRequest request = new DeptCreateRequest();
request.setDeptCode("A00_B00");
request.setDeptName("开发部开发一组");
request.setDeptAlias("开发一组");
request.setValid(true);
DeptCreateResponse response = deptManager.create(request, token);
assertTrue(!response.hasError());
}
}
@Test
public void testDelete() {
//创建数据
DeptCreateRequest createRequest = new DeptCreateRequest();
createRequest.setDeptCode("A00");
createRequest.setDeptName("开发部");
createRequest.setDeptAlias("开发部");
createRequest.setValid(true);
DeptCreateResponse createResponse = deptManager.create(createRequest, token);
assertTrue(!createResponse.hasError() && createResponse.getId() > 0);
//删除数据
DeptDeleteRequest request = new DeptDeleteRequest();
request.setId(createResponse.getId());
DeptDeleteResponse response = deptManager.delete(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testUpdate() {
//创建数据
DeptCreateRequest createRequest = new DeptCreateRequest();
createRequest.setDeptCode("A00");
createRequest.setDeptName("开发部");
createRequest.setDeptAlias("开发部");
createRequest.setValid(true);
DeptCreateResponse createResponse = deptManager.create(createRequest, token);
assertTrue(!createResponse.hasError());
//更新数据
DeptUpdateRequest request = new DeptUpdateRequest();
request.setId(createResponse.getId());
request.setDeptCode("A00");
request.setDeptName("开发部");
request.setDeptAlias("开发部");
request.setValid(true);
DeptUpdateResponse response = deptManager.update(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testFind() {
DeptFindRequest request = new DeptFindRequest();
request.setDeptCode("A00");
request.setDeptName("开发部");
request.setDeptAlias("开发部");
request.setValid(true);
DeptFindResponse response = deptManager.find(request, token);
assertTrue(!response.hasError());
}
@Test
public void testGet() {
//创建数据
DeptCreateRequest createRequest = new DeptCreateRequest();
createRequest.setDeptCode("A00");
createRequest.setDeptName("开发部");
createRequest.setDeptAlias("开发部");
createRequest.setValid(true);
DeptCreateResponse createResponse = deptManager.create(createRequest, token);
assertTrue(!createResponse.hasError());
//获得数据
DeptGetRequest request = new DeptGetRequest();
request.setId(createResponse.getId());
DeptGetResponse response = deptManager.get(request, token);
assertTrue(!response.hasError() && response.getDept() != null);
}
}

138
src/main/resources/modules/SpringBootService/test/system/DictItemTest.java
Unescape View File

@ -1,138 +0,0 @@
package ${basePackage}.system;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;
import ${basePackage}.frame.auth.Token;
import ${basePackage}.module.system.mgr.DictItemManager;
import ${basePackage}.module.system.req.DictItemCreateRequest;
import ${basePackage}.module.system.req.DictItemDeleteRequest;
import ${basePackage}.module.system.req.DictItemFindRequest;
import ${basePackage}.module.system.req.DictItemGetRequest;
import ${basePackage}.module.system.req.DictItemUpdateRequest;
import ${basePackage}.module.system.rsp.DictItemCreateResponse;
import ${basePackage}.module.system.rsp.DictItemDeleteResponse;
import ${basePackage}.module.system.rsp.DictItemFindResponse;
import ${basePackage}.module.system.rsp.DictItemGetResponse;
import ${basePackage}.module.system.rsp.DictItemUpdateResponse;
import static org.junit.Assert.assertTrue;
/**
* DictItemTest - - 字典项测试用例
*
* @author wangbing
* @version 0.0.1
* @since 2017-01-01
*/
@RunWith(SpringRunner.class)
@SpringBootTest
@Transactional
public class DictItemTest {
@Autowired
private Token token;
@Autowired
private DictItemManager dictItemManager;
@Test
public void testCreate() {
DictItemCreateRequest request = new DictItemCreateRequest();
request.setDictName("字典名称");
request.setKey("字典KEY");
request.setValue("字典VALUE");
request.setSort(1);
request.setValid(true);
DictItemCreateResponse response = dictItemManager.create(request, token);
assertTrue(!response.hasError());
}
@Test
public void testDelete() {
//创建数据
DictItemCreateRequest createRequest = new DictItemCreateRequest();
createRequest.setDictName("字典名称");
createRequest.setKey("字典KEY");
createRequest.setValue("字典VALUE");
createRequest.setSort(1);
createRequest.setValid(true);
DictItemCreateResponse createResponse = dictItemManager.create(createRequest, token);
assertTrue(!createResponse.hasError() && createResponse.getId() > 0);
//删除数据
DictItemDeleteRequest request = new DictItemDeleteRequest();
request.setId(createResponse.getId());
DictItemDeleteResponse response = dictItemManager.delete(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testUpdate() {
//创建数据
DictItemCreateRequest createRequest = new DictItemCreateRequest();
createRequest.setDictName("字典名称");
createRequest.setKey("字典KEY");
createRequest.setValue("字典VALUE");
createRequest.setSort(1);
createRequest.setValid(true);
DictItemCreateResponse createResponse = dictItemManager.create(createRequest, token);
//更新数据
DictItemUpdateRequest request = new DictItemUpdateRequest();
request.setId(createResponse.getId());
request.setKey("字典KEY");
request.setValue("字典VALUE");
request.setSort(1);
request.setValid(true);
DictItemUpdateResponse response = dictItemManager.update(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testFind() {
DictItemFindRequest request = new DictItemFindRequest();
request.setDictName("字典名称");
request.setKey("字典KEY");
request.setValue("字典VALUE");
request.setSort(1);
request.setValid(true);
DictItemFindResponse response = dictItemManager.find(request, token);
assertTrue(!response.hasError());
}
@Test
public void testGet() {
//创建数据
DictItemCreateRequest createRequest = new DictItemCreateRequest();
createRequest.setDictName("字典名称");
createRequest.setKey("字典KEY");
createRequest.setValue("字典VALUE");
createRequest.setSort(1);
createRequest.setValid(true);
DictItemCreateResponse createResponse = dictItemManager.create(createRequest, token);
//获得数据
DictItemGetRequest request = new DictItemGetRequest();
request.setId(createResponse.getId());
DictItemGetResponse response = dictItemManager.get(request, token);
assertTrue(!response.hasError() && response.getDictItem() != null);
}
}

168
src/main/resources/modules/SpringBootService/test/system/DictTest.java
Unescape View File

@ -1,168 +0,0 @@
package ${basePackage}.system;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;
import ${basePackage}.frame.auth.Token;
import ${basePackage}.module.system.mgr.DictItemManager;
import ${basePackage}.module.system.mgr.DictManager;
import ${basePackage}.module.system.req.DictCreateRequest;
import ${basePackage}.module.system.req.DictDeleteRequest;
import ${basePackage}.module.system.req.DictFindRequest;
import ${basePackage}.module.system.req.DictGetRequest;
import ${basePackage}.module.system.req.DictItemCreateRequest;
import ${basePackage}.module.system.req.DictLoadRequest;
import ${basePackage}.module.system.req.DictUpdateRequest;
import ${basePackage}.module.system.rsp.DictCreateResponse;
import ${basePackage}.module.system.rsp.DictDeleteResponse;
import ${basePackage}.module.system.rsp.DictFindResponse;
import ${basePackage}.module.system.rsp.DictGetResponse;
import ${basePackage}.module.system.rsp.DictItemCreateResponse;
import ${basePackage}.module.system.rsp.DictLoadResponse;
import ${basePackage}.module.system.rsp.DictUpdateResponse;
import static org.junit.Assert.assertTrue;
/**
* DictTest - - 字典测试用例
*
* @author wangbing
* @version 0.0.1
* @since 2017-01-01
*/
@RunWith(SpringRunner.class)
@SpringBootTest
@Transactional
public class DictTest {
@Autowired
private Token token;
@Autowired
private DictManager dictManager;
@Autowired
private DictItemManager dictItemManager;
@Test
public void testCreate() {
DictCreateRequest request = new DictCreateRequest();
request.setDictName("字典名称");
request.setDictComment("字典描述");
request.setVersion("字典版本号");
request.setValid(true);
DictCreateResponse response = dictManager.create(request, token);
assertTrue(!response.hasError());
}
@Test
public void testDelete() {
//创建数据
DictCreateRequest createRequest = new DictCreateRequest();
createRequest.setDictName("字典名称");
createRequest.setDictComment("字典描述");
createRequest.setVersion("字典版本号");
createRequest.setValid(true);
DictCreateResponse createResponse = dictManager.create(createRequest, token);
assertTrue(!createResponse.hasError() && createResponse.getId() > 0);
//删除数据
DictDeleteRequest request = new DictDeleteRequest();
request.setId(createResponse.getId());
DictDeleteResponse response = dictManager.delete(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testUpdate() {
//创建数据
DictCreateRequest createRequest = new DictCreateRequest();
createRequest.setDictName("字典名称");
createRequest.setDictComment("字典描述");
createRequest.setVersion("字典版本号");
createRequest.setValid(true);
DictCreateResponse createResponse = dictManager.create(createRequest, token);
//更新数据
DictUpdateRequest request = new DictUpdateRequest();
request.setId(createResponse.getId());
request.setDictName("字典名称");
request.setDictComment("字典描述");
request.setVersion("字典版本号");
request.setValid(true);
DictUpdateResponse response = dictManager.update(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testFind() {
DictFindRequest request = new DictFindRequest();
request.setDictName("字典名称");
request.setDictComment("字典描述");
request.setValid(true);
DictFindResponse response = dictManager.find(request, token);
assertTrue(!response.hasError());
}
@Test
public void testGet() {
//创建数据
DictCreateRequest createRequest = new DictCreateRequest();
createRequest.setDictName("字典名称");
createRequest.setDictComment("字典描述");
createRequest.setVersion("字典版本号");
createRequest.setValid(true);
DictCreateResponse createResponse = dictManager.create(createRequest, token);
//获得数据
DictGetRequest request = new DictGetRequest();
request.setId(createResponse.getId());
DictGetResponse response = dictManager.get(request, token);
assertTrue(!response.hasError() && response.getDict() != null);
}
@Test
public void testLoad() {
//创建数据
DictCreateRequest createRequest = new DictCreateRequest();
createRequest.setDictName("字典名称");
createRequest.setDictComment("字典描述");
createRequest.setVersion("字典版本号");
createRequest.setValid(true);
DictCreateResponse createResponse = dictManager.create(createRequest, token);
assertTrue(!createResponse.hasError() && createResponse.getId() > 0);
DictItemCreateRequest dictItemCreateRequest = new DictItemCreateRequest();
dictItemCreateRequest.setDictName("字典名称");
dictItemCreateRequest.setKey("1");
dictItemCreateRequest.setValue("1");
dictItemCreateRequest.setSort(1);
dictItemCreateRequest.setValid(true);
DictItemCreateResponse dictItemCreateResponse = dictItemManager.create(dictItemCreateRequest, token);
assertTrue(!dictItemCreateResponse.hasError() && dictItemCreateResponse.getId() > 0);
//获取字典及字典项数据
DictLoadRequest request = new DictLoadRequest();
request.setDictName("字典名称");
DictLoadResponse response = dictManager.load(request, token);
assertTrue(!response.hasError() && response.getDict() != null && response.getDictItems().size() > 0);
}
}

117
src/main/resources/modules/SpringBootService/test/system/FileTest.java
Unescape View File

@ -1,117 +0,0 @@
package ${basePackage}.system;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;
import ${basePackage}.frame.auth.Token;
import ${basePackage}.module.system.mgr.FileManager;
import ${basePackage}.module.system.req.FileCreateRequest;
import ${basePackage}.module.system.req.FileDeleteRequest;
import ${basePackage}.module.system.req.FileFindRequest;
import ${basePackage}.module.system.req.FileGetRequest;
import ${basePackage}.module.system.rsp.FileCreateResponse;
import ${basePackage}.module.system.rsp.FileDeleteResponse;
import ${basePackage}.module.system.rsp.FileFindResponse;
import ${basePackage}.module.system.rsp.FileGetResponse;
import static org.junit.Assert.assertTrue;
/**
* FileTest - - 字典测试用例
*
* @author wangbing
* @version 0.0.1
* @since 2017-01-01
*/
@RunWith(SpringRunner.class)
@SpringBootTest
@Transactional
public class FileTest {
@Autowired
private Token token;
@Autowired
private FileManager fileManager;
@Test
public void testCreate() {
FileCreateRequest request = new FileCreateRequest();
request.setName("字文件名称");
request.setFileType(null);
request.setUrl("http://example.com/a.zip");
request.setUrlDownload("http://example.com/a.zip");
request.setAttribute1("Attribute1");
request.setAttribute2("Attribute2");
request.setAttribute2("Attribute3");
FileCreateResponse response = fileManager.create(request, token);
assertTrue(!response.hasError());
}
@Test
public void testDelete() {
//创建数据
FileCreateRequest createRequest = new FileCreateRequest();
createRequest.setName("字文件名称");
createRequest.setFileType(null);
createRequest.setUrl("http://example.com/a.zip");
createRequest.setUrlDownload("http://example.com/a.zip");
createRequest.setAttribute1("Attribute1");
createRequest.setAttribute2("Attribute2");
createRequest.setAttribute2("Attribute3");
FileCreateResponse createResponse = fileManager.create(createRequest, token);
assertTrue(!createResponse.hasError() && createResponse.getId() > 0);
//删除数据
FileDeleteRequest request = new FileDeleteRequest();
request.setId(createResponse.getId());
FileDeleteResponse response = fileManager.delete(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testFind() {
FileFindRequest request = new FileFindRequest();
request.setName("字文件名称");
request.setFileType(null);
request.setAttribute1("Attribute1");
request.setAttribute2("Attribute2");
request.setAttribute2("Attribute3");
FileFindResponse response = fileManager.find(request, token);
assertTrue(!response.hasError());
}
@Test
public void testGet() {
//创建数据
FileCreateRequest createRequest = new FileCreateRequest();
createRequest.setName("字文件名称");
createRequest.setFileType(null);
createRequest.setUrl("http://example.com/a.zip");
createRequest.setUrlDownload("http://example.com/a.zip");
createRequest.setAttribute1("Attribute1");
createRequest.setAttribute2("Attribute2");
createRequest.setAttribute2("Attribute3");
FileCreateResponse createResponse = fileManager.create(createRequest, token);
//获得数据
FileGetRequest request = new FileGetRequest();
request.setId(createResponse.getId());
FileGetResponse response = fileManager.get(request, token);
assertTrue(!response.hasError() && response.getFile() != null);
}
}

154
src/main/resources/modules/SpringBootService/test/system/LogErrTest.java
Unescape View File

@ -1,154 +0,0 @@
package ${basePackage}.system;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;
import ${basePackage}.frame.auth.Token;
import ${basePackage}.module.system.mgr.LogErrManager;
import ${basePackage}.module.system.req.LogErrCreateRequest;
import ${basePackage}.module.system.req.LogErrDeleteRequest;
import ${basePackage}.module.system.req.LogErrFindRequest;
import ${basePackage}.module.system.req.LogErrGetRequest;
import ${basePackage}.module.system.req.LogErrUpdateRequest;
import ${basePackage}.module.system.rsp.LogErrCreateResponse;
import ${basePackage}.module.system.rsp.LogErrDeleteResponse;
import ${basePackage}.module.system.rsp.LogErrFindResponse;
import ${basePackage}.module.system.rsp.LogErrGetResponse;
import ${basePackage}.module.system.rsp.LogErrUpdateResponse;
import static junit.framework.TestCase.assertTrue;
/**
* LogErrTest - - 错误日志测试用例
*
* @author wangbing
* @version 0.0.1
* @since 2020-01-29
*/
@RunWith(SpringRunner.class)
@SpringBootTest
@Transactional
public class LogErrTest {
@Autowired
private Token token;
@Autowired
private LogErrManager logErrManager;
@Test
public void testCreate() {
LogErrCreateRequest request = new LogErrCreateRequest();
request.setLogErrType("code");
request.setTitle("错误标题");
request.setContent("content");
request.setLogErrResult("code");
request.setAttribute1("属性1");
request.setAttribute2("属性2");
request.setAttribute3("属性3");
LogErrCreateResponse response = logErrManager.create(request,token);
assertTrue(!response.hasError());
}
@Test
public void testDelete() {
//创建数据
LogErrCreateRequest createRequest = new LogErrCreateRequest();
createRequest.setLogErrType("code");
createRequest.setTitle("错误标题");
createRequest.setContent("content");
createRequest.setLogErrResult("code");
createRequest.setAttribute1("属性1");
createRequest.setAttribute2("属性2");
createRequest.setAttribute3("属性3");
LogErrCreateResponse createResponse = logErrManager.create(createRequest,token);
assertTrue(!createResponse.hasError() && createResponse.getId() > 0);
//删除数据
LogErrDeleteRequest request = new LogErrDeleteRequest();
request.setId(createResponse.getId());
LogErrDeleteResponse response = logErrManager.delete(request,token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testUpdate() {
//创建数据
LogErrCreateRequest createRequest = new LogErrCreateRequest();
createRequest.setLogErrType("code");
createRequest.setTitle("错误标题");
createRequest.setContent("content");
createRequest.setLogErrResult("code");
createRequest.setAttribute1("属性1");
createRequest.setAttribute2("属性2");
createRequest.setAttribute3("属性3");
LogErrCreateResponse createResponse = logErrManager.create(createRequest, token);
assertTrue(!createResponse.hasError());
//更新数据
LogErrUpdateRequest request = new LogErrUpdateRequest();
request.setId(createResponse.getId());
request.setLogErrType("code");
request.setTitle("错误标题");
request.setContent("content");
request.setLogErrResult("code");
request.setAttribute1("属性1");
request.setAttribute2("属性2");
request.setAttribute3("属性3");
LogErrUpdateResponse response = logErrManager.update(request,token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testFind() {
LogErrFindRequest request = new LogErrFindRequest();
request.setLogErrType("code");
request.setTitle("错误标题");
request.setLogErrResult("code");
request.setAttribute1("属性1");
request.setAttribute2("属性2");
request.setAttribute3("属性3");
LogErrFindResponse response = logErrManager.find(request,token);
assertTrue(!response.hasError());
}
@Test
public void testGet() {
//创建数据
LogErrCreateRequest createRequest = new LogErrCreateRequest();
createRequest.setLogErrType("code");
createRequest.setTitle("错误标题");
createRequest.setContent("content");
createRequest.setLogErrResult("code");
createRequest.setAttribute1("属性1");
createRequest.setAttribute2("属性2");
createRequest.setAttribute3("属性3");
LogErrCreateResponse createResponse = logErrManager.create(createRequest, token);
assertTrue(!createResponse.hasError());
//获得数据
LogErrGetRequest request = new LogErrGetRequest();
request.setId(createResponse.getId());
LogErrGetResponse response = logErrManager.get(request,token);
assertTrue(!response.hasError() && response.getLogErr() != null);
}
}

145
src/main/resources/modules/SpringBootService/test/system/ResTest.java
Unescape View File

@ -1,145 +0,0 @@
package ${basePackage}.system;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;
import ${basePackage}.frame.auth.Token;
import ${basePackage}.module.system.mgr.ResManager;
import ${basePackage}.module.system.req.ResCreateRequest;
import ${basePackage}.module.system.req.ResDeleteRequest;
import ${basePackage}.module.system.req.ResFindRequest;
import ${basePackage}.module.system.req.ResGetRequest;
import ${basePackage}.module.system.req.ResUpdateRequest;
import ${basePackage}.module.system.rsp.ResCreateResponse;
import ${basePackage}.module.system.rsp.ResDeleteResponse;
import ${basePackage}.module.system.rsp.ResFindResponse;
import ${basePackage}.module.system.rsp.ResGetResponse;
import ${basePackage}.module.system.rsp.ResUpdateResponse;
import static org.junit.Assert.assertTrue;
/**
* ResTest - - 资源测试用例
*
* @author wangbing
* @version 0.0.1
* @since 2020-01-05
*/
@RunWith(SpringRunner.class)
@SpringBootTest
@Transactional
public class ResTest {
@Autowired
private Token token;
@Autowired
private ResManager resManager;
@Test
public void testCreate() {
ResCreateRequest request = new ResCreateRequest();
request.setResCode("资源代码");
request.setResName("资源名称");
request.setResType("code");
request.setResValue("资源内容");
request.setValid(true);
ResCreateResponse response = resManager.create(request, token);
assertTrue(!response.hasError());
}
@Test
public void testDelete() {
//创建数据
ResCreateRequest createRequest = new ResCreateRequest();
createRequest.setResCode("资源代码");
createRequest.setResName("资源名称");
createRequest.setResType("code");
createRequest.setResValue("资源内容");
createRequest.setValid(true);
ResCreateResponse createResponse = resManager.create(createRequest, token);
assertTrue(!createResponse.hasError() && createResponse.getId() > 0);
//删除数据
ResDeleteRequest request = new ResDeleteRequest();
request.setId(createResponse.getId());
ResDeleteResponse response = resManager.delete(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testUpdate() {
//创建数据
ResCreateRequest createRequest = new ResCreateRequest();
createRequest.setResCode("资源代码");
createRequest.setResName("资源名称");
createRequest.setResType("code");
createRequest.setResValue("资源内容");
createRequest.setValid(true);
ResCreateResponse createResponse = resManager.create(createRequest, token);
assertTrue(!createResponse.hasError());
//更新数据
ResUpdateRequest request = new ResUpdateRequest();
request.setId(createResponse.getId());
request.setResCode("资源代码");
request.setResName("资源名称");
request.setResType("code");
request.setResValue("资源内容");
request.setValid(true);
ResUpdateResponse response = resManager.update(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testFind() {
ResFindRequest request = new ResFindRequest();
request.setResCode("资源代码");
request.setResName("资源名称");
request.setResType("code");
request.setResValue("资源内容");
request.setSupCode("上级代码");
request.setSupName("上级名称");
request.setValid(true);
ResFindResponse response = resManager.find(request, token);
assertTrue(!response.hasError());
}
@Test
public void testGet() {
//创建数据
ResCreateRequest createRequest = new ResCreateRequest();
createRequest.setResCode("资源代码");
createRequest.setResName("资源名称");
createRequest.setResType("code");
createRequest.setResValue("资源内容");
createRequest.setValid(true);
ResCreateResponse createResponse = resManager.create(createRequest, token);
assertTrue(!createResponse.hasError());
//获得数据
ResGetRequest request = new ResGetRequest();
request.setId(createResponse.getId());
ResGetResponse response = resManager.get(request, token);
assertTrue(!response.hasError() && response.getRes() != null);
}
}

137
src/main/resources/modules/SpringBootService/test/system/RoleResTest.java
Unescape View File

@ -1,137 +0,0 @@
package ${basePackage}.system;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;
import ${basePackage}.frame.auth.Token;
import ${basePackage}.module.system.mgr.RoleResManager;
import ${basePackage}.module.system.req.RoleResCreateRequest;
import ${basePackage}.module.system.req.RoleResDeleteRequest;
import ${basePackage}.module.system.req.RoleResFindRequest;
import ${basePackage}.module.system.req.RoleResGetRequest;
import ${basePackage}.module.system.req.RoleResUpdateRequest;
import ${basePackage}.module.system.rsp.RoleResCreateResponse;
import ${basePackage}.module.system.rsp.RoleResDeleteResponse;
import ${basePackage}.module.system.rsp.RoleResFindResponse;
import ${basePackage}.module.system.rsp.RoleResGetResponse;
import ${basePackage}.module.system.rsp.RoleResUpdateResponse;
import static org.junit.Assert.assertTrue;
/**
* RoleResTest - - 角色资源关系测试用例
*
* @author wangbing
* @version 0.0.1
* @since 2020-01-05
*/
@RunWith(SpringRunner.class)
@SpringBootTest
@Transactional
public class RoleResTest {
@Autowired
private Token token;
@Autowired
private RoleResManager roleResManager;
@Test
public void testCreate() {
RoleResCreateRequest request = new RoleResCreateRequest();
request.setRoleId(1L);
request.setRoleCode("角色代码");
request.setResId(1L);
request.setResCode("资源代码");
RoleResCreateResponse response = roleResManager.create(request, token);
assertTrue(!response.hasError());
}
@Test
public void testDelete() {
//创建数据
RoleResCreateRequest createRequest = new RoleResCreateRequest();
createRequest.setRoleId(1L);
createRequest.setRoleCode("角色代码");
createRequest.setResId(1L);
createRequest.setResCode("资源代码");
RoleResCreateResponse createResponse = roleResManager.create(createRequest, token);
assertTrue(!createResponse.hasError() && createResponse.getId() > 0);
//删除数据
RoleResDeleteRequest request = new RoleResDeleteRequest();
request.setId(createResponse.getId());
RoleResDeleteResponse response = roleResManager.delete(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testUpdate() {
//创建数据
RoleResCreateRequest createRequest = new RoleResCreateRequest();
createRequest.setRoleId(1L);
createRequest.setRoleCode("角色代码");
createRequest.setResId(1L);
createRequest.setResCode("资源代码");
RoleResCreateResponse createResponse = roleResManager.create(createRequest, token);
assertTrue(!createResponse.hasError());
//更新数据
RoleResUpdateRequest request = new RoleResUpdateRequest();
request.setId(createResponse.getId());
request.setRoleId(1L);
request.setRoleCode("角色代码");
request.setResId(1L);
request.setResCode("资源代码");
RoleResUpdateResponse response = roleResManager.update(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testFind() {
RoleResFindRequest request = new RoleResFindRequest();
request.setRoleId(1L);
request.setRoleCode("角色代码");
request.setResId(1L);
request.setResCode("资源代码");
RoleResFindResponse response = roleResManager.find(request, token);
assertTrue(!response.hasError());
}
@Test
public void testGet() {
//创建数据
RoleResCreateRequest createRequest = new RoleResCreateRequest();
createRequest.setRoleId(1L);
createRequest.setRoleCode("角色代码");
createRequest.setResId(1L);
createRequest.setResCode("资源代码");
RoleResCreateResponse createResponse = roleResManager.create(createRequest, token);
assertTrue(!createResponse.hasError());
//获得数据
RoleResGetRequest request = new RoleResGetRequest();
request.setId(createResponse.getId());
RoleResGetResponse response = roleResManager.get(request, token);
assertTrue(!response.hasError() && response.getRoleRes() != null);
}
}

131
src/main/resources/modules/SpringBootService/test/system/RoleTest.java
Unescape View File

@ -1,131 +0,0 @@
package ${basePackage}.system;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;
import ${basePackage}.frame.auth.Token;
import ${basePackage}.module.system.mgr.RoleManager;
import ${basePackage}.module.system.req.RoleCreateRequest;
import ${basePackage}.module.system.req.RoleDeleteRequest;
import ${basePackage}.module.system.req.RoleFindRequest;
import ${basePackage}.module.system.req.RoleGetRequest;
import ${basePackage}.module.system.req.RoleUpdateRequest;
import ${basePackage}.module.system.rsp.RoleCreateResponse;
import ${basePackage}.module.system.rsp.RoleDeleteResponse;
import ${basePackage}.module.system.rsp.RoleFindResponse;
import ${basePackage}.module.system.rsp.RoleGetResponse;
import ${basePackage}.module.system.rsp.RoleUpdateResponse;
import static org.junit.Assert.assertTrue;
/**
* RoleTest - - 角色测试用例
*
* @author wangbing
* @version 0.0.1
* @since 2019-12-27
*/
@RunWith(SpringRunner.class)
@SpringBootTest
@Transactional
public class RoleTest {
@Autowired
private Token token;
@Autowired
private RoleManager roleManager;
@Test
public void testCreate() {
RoleCreateRequest request = new RoleCreateRequest();
request.setCode("角色代码");
request.setName("角色名称");
request.setComment("角色描述");
RoleCreateResponse response = roleManager.create(request, token);
assertTrue(!response.hasError());
}
@Test
public void testDelete() {
//创建数据
RoleCreateRequest createRequest = new RoleCreateRequest();
createRequest.setCode("角色代码");
createRequest.setName("角色名称");
createRequest.setComment("角色描述");
RoleCreateResponse createResponse = roleManager.create(createRequest, token);
assertTrue(!createResponse.hasError() && createResponse.getId() > 0);
//删除数据
RoleDeleteRequest request = new RoleDeleteRequest();
request.setId(createResponse.getId());
RoleDeleteResponse response = roleManager.delete(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testUpdate() {
//创建数据
RoleCreateRequest createRequest = new RoleCreateRequest();
createRequest.setCode("角色代码");
createRequest.setName("角色名称");
createRequest.setComment("角色描述");
RoleCreateResponse createResponse = roleManager.create(createRequest, token);
assertTrue(!createResponse.hasError());
//更新数据
RoleUpdateRequest request = new RoleUpdateRequest();
request.setId(createResponse.getId());
request.setCode("角色代码");
request.setName("角色名称");
request.setComment("角色描述");
RoleUpdateResponse response = roleManager.update(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testFind() {
RoleFindRequest request = new RoleFindRequest();
request.setCode("角色代码");
request.setName("角色名称");
request.setComment("角色描述");
RoleFindResponse response = roleManager.find(request, token);
assertTrue(!response.hasError());
}
@Test
public void testGet() {
//创建数据
RoleCreateRequest createRequest = new RoleCreateRequest();
createRequest.setCode("角色代码");
createRequest.setName("角色名称");
createRequest.setComment("角色描述");
RoleCreateResponse createResponse = roleManager.create(createRequest, token);
assertTrue(!createResponse.hasError());
//获得数据
RoleGetRequest request = new RoleGetRequest();
request.setId(createResponse.getId());
RoleGetResponse response = roleManager.get(request, token);
assertTrue(!response.hasError() && response.getRole() != null);
}
}

185
src/main/resources/modules/SpringBootService/test/system/TokensTest.java
Unescape View File

@ -1,185 +0,0 @@
package ${basePackage}.system;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;
import ${basePackage}.frame.auth.Token;
import ${basePackage}.frame.utils.IDgenerator;
import ${basePackage}.module.system.mgr.TokensManager;
import ${basePackage}.module.system.req.TokensCreateRequest;
import ${basePackage}.module.system.req.TokensFindRequest;
import ${basePackage}.module.system.req.TokensGetRequest;
import ${basePackage}.module.system.req.TokensUpdateRequest;
import ${basePackage}.module.system.rsp.TokensCreateResponse;
import ${basePackage}.module.system.rsp.TokensDeleteResponse;
import ${basePackage}.module.system.rsp.TokensFindResponse;
import ${basePackage}.module.system.rsp.TokensGetResponse;
import ${basePackage}.module.system.rsp.TokensUpdateResponse;
import java.util.Date;
import static org.junit.Assert.assertTrue;
/**
* TokensTest - - 通行证测试用例
*
* @author author
* @version 0.0.1
* @since 2017-01-01
*/
@RunWith(SpringRunner.class)
@SpringBootTest
@Transactional
public class TokensTest {
@Autowired
private Token token;
@Autowired
private TokensManager tokensManager;
@Test
public void testCreate() {
TokensCreateRequest request = new TokensCreateRequest();
request.setToken(IDgenerator.nextUUID());
request.setUserId(1L);
request.setUserName("用户名称");
request.setLoginTime(new Date());
request.setValidTime(new Date());
request.setValid(true);
request.setDeptId(1L);
request.setDeptCode("部门代码");
request.setDeptName("部门名称");
request.setTerminalType("code");
request.setTerminalIp("终端地址");
request.setTerminalInfo("终端信息");
TokensCreateResponse response = tokensManager.create(request, token);
assertTrue(!response.hasError());
}
@Test
public void testDelete() {
//创建数据
TokensCreateRequest createRequest = new TokensCreateRequest();
createRequest.setToken(IDgenerator.nextUUID());
createRequest.setUserId(1L);
createRequest.setUserName("用户名称");
createRequest.setLoginTime(new Date());
createRequest.setValidTime(new Date());
createRequest.setValid(true);
createRequest.setDeptId(1L);
createRequest.setDeptCode("部门代码");
createRequest.setDeptName("部门名称");
createRequest.setTerminalType("code");
createRequest.setTerminalIp("终端地址");
createRequest.setTerminalInfo("终端信息");
TokensCreateResponse createResponse = tokensManager.create(createRequest, token);
assertTrue(!createResponse.hasError() && createResponse.getId() > 0);
//删除数据
${basePackage}.module.system.req.TokensDeleteRequest request = new ${basePackage}.module.system.req.TokensDeleteRequest();
request.setToken(createRequest.getToken());
TokensDeleteResponse response = tokensManager.delete(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testUpdate() {
//创建数据
TokensCreateRequest createRequest = new TokensCreateRequest();
createRequest.setToken(IDgenerator.nextUUID());
createRequest.setUserId(1L);
createRequest.setUserName("用户名称");
createRequest.setLoginTime(new Date());
createRequest.setValidTime(new Date());
createRequest.setValid(true);
createRequest.setDeptId(1L);
createRequest.setDeptCode("部门代码");
createRequest.setDeptName("部门名称");
createRequest.setTerminalType("code");
createRequest.setTerminalIp("终端地址");
createRequest.setTerminalInfo("终端信息");
TokensCreateResponse createResponse = tokensManager.create(createRequest, token);
assertTrue(!createResponse.hasError());
//更新数据
TokensUpdateRequest request = new TokensUpdateRequest();
request.setId(createResponse.getId());
request.setUserId(1L);
request.setUserName("用户名称");
request.setLoginTime(new Date());
request.setValidTime(new Date());
request.setValid(true);
request.setDeptId(1L);
request.setDeptCode("部门代码");
request.setDeptName("部门名称");
request.setTerminalType("code");
request.setTerminalIp("终端地址");
request.setTerminalInfo("终端信息");
TokensUpdateResponse response = tokensManager.update(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testFind() {
TokensFindRequest request = new TokensFindRequest();
request.setUserId(1L);
request.setUserName("用户名称");
request.setLoginTime(new Date());
request.setValidTime(new Date());
request.setValid(true);
request.setDeptId(1L);
request.setDeptCode("部门代码");
request.setDeptName("部门名称");
request.setTerminalType("code");
request.setTerminalIp("终端地址");
request.setTerminalInfo("终端信息");
TokensFindResponse response = tokensManager.find(request, token);
assertTrue(!response.hasError());
}
@Test
public void testGet() {
//创建数据
TokensCreateRequest createRequest = new TokensCreateRequest();
createRequest.setToken(IDgenerator.nextUUID());
createRequest.setUserId(1L);
createRequest.setUserName("用户名称");
createRequest.setLoginTime(new Date());
createRequest.setValidTime(new Date());
createRequest.setValid(true);
createRequest.setDeptId(1L);
createRequest.setDeptCode("部门代码");
createRequest.setDeptName("部门名称");
createRequest.setTerminalType("code");
createRequest.setTerminalIp("终端地址");
createRequest.setTerminalInfo("终端信息");
TokensCreateResponse createResponse = tokensManager.create(createRequest, token);
assertTrue(!createResponse.hasError());
//获得数据
TokensGetRequest request = new TokensGetRequest();
request.setId(createResponse.getId());
TokensGetResponse response = tokensManager.get(request, token);
assertTrue(!response.hasError() && response.getTokens() != null);
}
}

125
src/main/resources/modules/SpringBootService/test/system/UserRoleTest.java
Unescape View File

@ -1,125 +0,0 @@
package ${basePackage}.system;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;
import ${basePackage}.frame.auth.Token;
import ${basePackage}.module.system.mgr.UserRoleManager;
import ${basePackage}.module.system.req.UserRoleCreateRequest;
import ${basePackage}.module.system.req.UserRoleDeleteRequest;
import ${basePackage}.module.system.req.UserRoleFindRequest;
import ${basePackage}.module.system.req.UserRoleGetRequest;
import ${basePackage}.module.system.req.UserRoleUpdateRequest;
import ${basePackage}.module.system.rsp.UserRoleCreateResponse;
import ${basePackage}.module.system.rsp.UserRoleDeleteResponse;
import ${basePackage}.module.system.rsp.UserRoleFindResponse;
import ${basePackage}.module.system.rsp.UserRoleGetResponse;
import ${basePackage}.module.system.rsp.UserRoleUpdateResponse;
import static org.junit.Assert.assertTrue;
/**
* UserRoleTest - - 用户角色授权测试用例
*
* @author wangbing
* @version 0.0.1
* @since 2019-12-27
*/
@RunWith(SpringRunner.class)
@SpringBootTest
@Transactional
public class UserRoleTest {
@Autowired
private Token token;
@Autowired
private UserRoleManager userRoleManager;
@Test
public void testCreate() {
UserRoleCreateRequest request = new UserRoleCreateRequest();
request.setUserId(1L);
request.setRoleId(1L);
UserRoleCreateResponse response = userRoleManager.create(request, token);
assertTrue(!response.hasError());
}
@Test
public void testDelete() {
//创建数据
UserRoleCreateRequest createRequest = new UserRoleCreateRequest();
createRequest.setUserId(1L);
createRequest.setRoleId(1L);
UserRoleCreateResponse createResponse = userRoleManager.create(createRequest, token);
assertTrue(!createResponse.hasError() && createResponse.getId() > 0);
//删除数据
UserRoleDeleteRequest request = new UserRoleDeleteRequest();
request.setId(createResponse.getId());
UserRoleDeleteResponse response = userRoleManager.delete(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testUpdate() {
//创建数据
UserRoleCreateRequest createRequest = new UserRoleCreateRequest();
createRequest.setUserId(1L);
createRequest.setRoleId(1L);
UserRoleCreateResponse createResponse = userRoleManager.create(createRequest, token);
assertTrue(!createResponse.hasError());
//更新数据
UserRoleUpdateRequest request = new UserRoleUpdateRequest();
request.setId(createResponse.getId());
request.setUserId(1L);
request.setRoleId(1L);
UserRoleUpdateResponse response = userRoleManager.update(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testFind() {
UserRoleFindRequest request = new UserRoleFindRequest();
request.setUserId(1L);
request.setRoleId(1L);
UserRoleFindResponse response = userRoleManager.find(request, token);
assertTrue(!response.hasError());
}
@Test
public void testGet() {
//创建数据
UserRoleCreateRequest createRequest = new UserRoleCreateRequest();
createRequest.setUserId(1L);
createRequest.setRoleId(1L);
UserRoleCreateResponse createResponse = userRoleManager.create(createRequest, token);
assertTrue(!createResponse.hasError());
//获得数据
UserRoleGetRequest request = new UserRoleGetRequest();
request.setId(createResponse.getId());
UserRoleGetResponse response = userRoleManager.get(request, token);
assertTrue(!response.hasError() && response.getUserRole() != null);
}
}

145
src/main/resources/modules/SpringBootService/test/system/UserTest.java
Unescape View File

@ -1,145 +0,0 @@
package ${basePackage}.system;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;
import ${basePackage}.frame.auth.Token;
import ${basePackage}.module.system.mgr.UserManager;
import ${basePackage}.module.system.req.UserCreateRequest;
import ${basePackage}.module.system.req.UserDeleteRequest;
import ${basePackage}.module.system.req.UserFindRequest;
import ${basePackage}.module.system.req.UserGetRequest;
import ${basePackage}.module.system.req.UserUpdateRequest;
import ${basePackage}.module.system.rsp.UserCreateResponse;
import ${basePackage}.module.system.rsp.UserDeleteResponse;
import ${basePackage}.module.system.rsp.UserFindResponse;
import ${basePackage}.module.system.rsp.UserGetResponse;
import ${basePackage}.module.system.rsp.UserUpdateResponse;
import static org.junit.Assert.assertTrue;
/**
* UserTest - - 用户测试用例
*
* @author wangbing
* @version 0.0.1
* @since 2019-12-27
*/
@RunWith(SpringRunner.class)
@SpringBootTest
@Transactional
public class UserTest {
@Autowired
private Token token;
@Autowired
private UserManager userManager;
@Test
public void testCreate() {
UserCreateRequest request = new UserCreateRequest();
request.setUserName("test");
request.setUserCode("");
request.setUserAlias("test");
request.setUserPwd("123456");
request.setUserStatus("code");
request.setDeptCode("A01");
UserCreateResponse response = userManager.create(request, token);
assertTrue(!response.hasError());
}
@Test
public void testDelete() {
//创建数据
UserCreateRequest createRequest = new UserCreateRequest();
createRequest.setUserName("test");
createRequest.setUserCode("");
createRequest.setUserAlias("test");
createRequest.setUserPwd("123456");
createRequest.setUserStatus("code");
createRequest.setDeptCode("A01");
UserCreateResponse createResponse = userManager.create(createRequest, token);
assertTrue(!createResponse.hasError() && createResponse.getId() > 0);
//删除数据
UserDeleteRequest request = new UserDeleteRequest();
request.setId(createResponse.getId());
UserDeleteResponse response = userManager.delete(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testUpdate() {
//创建数据
UserCreateRequest createRequest = new UserCreateRequest();
createRequest.setUserName("test");
createRequest.setUserCode("");
createRequest.setUserAlias("test");
createRequest.setUserPwd("123456");
createRequest.setUserStatus("code");
createRequest.setDeptCode("A01");
UserCreateResponse createResponse = userManager.create(createRequest, token);
assertTrue(!createResponse.hasError());
//更新数据
UserUpdateRequest request = new UserUpdateRequest();
request.setId(createResponse.getId());
request.setUserAlias("test");
request.setUserStatus("code");
request.setDeptCode("A01");
UserUpdateResponse response = userManager.update(request, token);
assertTrue(!response.hasError() && response.getResult() == 1L);
}
@Test
public void testFind() {
UserFindRequest request = new UserFindRequest();
request.setUserName("test");
request.setUserCode("");
request.setUserAlias("test");
request.setUserStatus("code");
request.setDeptCode("A01");
UserFindResponse response = userManager.find(request, token);
assertTrue(!response.hasError());
}
@Test
public void testGet() {
//创建数据
UserCreateRequest createRequest = new UserCreateRequest();
createRequest.setUserName("test");
createRequest.setUserCode("");
createRequest.setUserAlias("test");
createRequest.setUserPwd("123456");
createRequest.setUserStatus("code");
createRequest.setDeptCode("A01");
UserCreateResponse createResponse = userManager.create(createRequest, token);
assertTrue(!createResponse.hasError());
//获得数据
UserGetRequest request = new UserGetRequest();
request.setId(createResponse.getId());
UserGetResponse response = userManager.get(request, token);
assertTrue(!response.hasError() && response.getUser() != null);
}
}
Write Preview
Loading…
Cancel
Save

Powered by TurnKey Linux.