end7less
/
program_lcode_server
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

升级2.0.0

master
陈裕财 2 years ago
parent
fe8cc41061
commit
60c3151eac
8 changed files with 1202 additions and 1311 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 323
      mdp-form/src/main/java/com/mdp/form/ctrl/FormDataController.java
  2. 239
      mdp-form/src/main/java/com/mdp/form/ctrl/FormDataProcessApprovaController.java
  3. 301
      mdp-form/src/main/java/com/mdp/form/ctrl/FormDataTagController.java
  4. 261
      mdp-form/src/main/java/com/mdp/form/ctrl/FormDefController.java
  5. 279
      mdp-form/src/main/java/com/mdp/form/ctrl/FormDefTagController.java
  6. 229
      mdp-form/src/main/java/com/mdp/form/ctrl/FormFieldController.java
  7. 248
      mdp-form/src/main/java/com/mdp/form/ctrl/FormQxController.java
  8. 269
      mdp-form/src/main/java/com/mdp/form/ctrl/FormViewController.java

323
mdp-form/src/main/java/com/mdp/form/ctrl/FormDataController.java
View File

@ -1,19 +1,9 @@
package com.mdp.form.ctrl;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.mdp.form.entity.FormData;
import com.mdp.form.entity.FormDataProcessApprova;
import com.mdp.form.entity.FormDataVo;
import com.mdp.form.service.FormDataService;
import com.mdp.swagger.ApiEntityParams;
import jdk.nashorn.internal.ir.annotations.Ignore;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.util.*;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestBody;
@ -21,87 +11,67 @@ 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.RestController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
import com.mdp.mybatis.PageUtils;
import com.mdp.safe.client.entity.User;
import com.mdp.safe.client.utils.LoginUtils;
import com.mdp.core.utils.RequestUtils;
import io.swagger.annotations.*;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.mdp.core.entity.Result;
import com.mdp.core.query.QueryTools;
import static com.mdp.core.utils.BaseUtils.*;
import com.mdp.core.entity.Tips;
import com.mdp.core.entity.LangTips;
import com.mdp.core.err.BizException;
import com.mdp.core.utils.RequestUtils;
import com.mdp.core.utils.NumberUtil;
import com.mdp.safe.client.entity.User;
import com.mdp.safe.client.utils.LoginUtils;
import com.mdp.swagger.ApiEntityParams;
import io.swagger.annotations.*;
import springfox.documentation.annotations.ApiIgnore;
/**
* url编制采用rest风格,如对FORM.form_data form_data的操作有增删改查,对应的url分别为:<br>
* 新增: form/formData/add <br>
* 查询: form/formData/list<br>
* 模糊查询: form/formData/listKey<br>
* 修改: form/formData/edit <br>
* 删除: form/formData/del<br>
* 批量删除: form/formData/batchDel<br>
* 组织 com.qqkj 顶级模块 mdp 大模块 form 小模块 <br>
* 实体 FormData 表 FORM.form_data 当前主键(包括多主键): id;
***/
@RestController("mdp.form.formDataController")
import javax.servlet.http.HttpServletRequest;
import com.mdp.form.service.FormDataService;
import com.mdp.form.entity.FormData;
@RestController
@RequestMapping(value="/**/form/formData")
@Api(tags={"form_data操作接口"})
@Api(tags={"表单数据表-操作接口"})
public class FormDataController {
static Log logger=LogFactory.getLog(FormDataController.class);
static Logger logger =LoggerFactory.getLogger(FormDataController.class);
@Autowired
private FormDataService formDataService;
@ApiOperation( value = "查询form_data信息列表",notes="listFormData,条件之间是 and关系,模糊查询写法如 {studentName:'%才哥%'}")
@ApiOperation( value = "表单数据表-查询列表",notes=" ")
@ApiEntityParams(FormData.class)
@ApiResponses({
@ApiResponse(code = 200,response= FormData.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'错误码'},pageInfo:{total:总记录数},data:[数据对象1,数据对象2,...]}")
@ApiResponse(code = 200,response=FormData.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'错误码'},total:总记录数,data:[数据对象1,数据对象2,...]}")
})
@RequestMapping(value="/list",method=RequestMethod.GET)
public Map<String,Object> listFormData(@Ignore @RequestParam Map<String,Object> formData){
Map<String,Object> m = new HashMap<>();
RequestUtils.transformArray(formData, "ids");
RequestUtils.transformArray(formData, "tagIds");
RequestUtils.transformArray(formData, "cuserids");
RequestUtils.transformArray(formData, "userids");
RequestUtils.transformArray(formData, "deptids");
RequestUtils.transformArray(formData, "flowStates");
PageUtils.startPage(formData);
List<Map<String,Object>> formDataList = formDataService.selectListMapByWhere(formData); //列出FormData列表
PageUtils.responePage(m, formDataList);
m.put("data",formDataList);
Tips tips=new Tips("查询成功");
m.put("tips", tips);
return m;
public Result listFormData(@ApiIgnore @RequestParam Map<String,Object> params){
try {
User user=LoginUtils.getCurrentUserInfo();
QueryWrapper<FormData> qw = QueryTools.initQueryWrapper(FormData.class , params);
IPage page=QueryTools.initPage(params);
List<Map<String,Object>> datas = formDataService.selectListMapByWhere(page,qw,params);
return Result.ok("query-ok","查询成功").setData(datas).setTotal(page.getTotal());
}catch (BizException e) {
return Result.error(e);
}catch (Exception e) {
return Result.error(e);
}
}
/***/
@ApiOperation( value = "新增一条form_data信息",notes="addFormData,主键如果为空，后台自动生成")
@ApiOperation( value = "表单数据表-新增",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormData.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/add",method=RequestMethod.POST)
public Map<String,Object> addFormData(@RequestBody FormDataVo formData) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功新增一条数据");
try{
public Result addFormData(@RequestBody FormData formData) {
if(StringUtils.isEmpty(formData.getFlowState())) {
formData.setFlowState("0");
}
@ -113,106 +83,26 @@ public class FormDataController {
formData.setDeptName(user.getDeptName());
formData.setCreateTime(new Date());
formData.setLastTime(new Date());
formDataService.insertOrUpdate(formData,true);
m.put("data",formData);
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
}
m.put("tips", tips);
return m;
}
/**
* 流程审批过程中回调该接口，更新业务数据
* 如果发起流程时上送了restUrl，则无论流程中是否配置了监听器都会在流程发生以下事件时推送数据过来
* eventName: PROCESS_STARTED 流程启动完成 全局
* PROCESS_COMPLETED 流程正常结束 全局
* PROCESS_CANCELLED 流程删除 全局
* create 人工任务启动
* complete 人工任务完成
* assignment 人工任务分配给了具体的人
* delete 人工任务被删除
*
* 其中 create/complete/assignment/delete事件是需要在模型中人工节点上配置了委托代理表达式 ${taskBizCallListener}才会推送过来。
* 在人工任务节点上配置 任务监听器 建议事件为 complete,其它assignment/create/complete/delete也可以，一般建议在complete,委托代理表达式 ${taskBizCallListener}
*
* @param flowVars {flowBranchId,agree,procInstId,assignee,actId,taskName,mainTitle,branchId,bizKey,commentMsg,eventName,modelKey} 等
* @return 如果tips.isOk==false，将影响流程提交
**/
@RequestMapping(value="/processApprova",method=RequestMethod.POST)
public Map<String,Object> processApprova( @RequestBody Map<String,Object> flowVars){
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功新增一条数据");
try{
this.formDataService.processApprova(flowVars);
logger.debug("procInstId====="+flowVars.get("procInstId"));
}catch (BizException e) {
tips=e.getTips();
logger.error("执行异常",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("执行异常",e);
}
m.put("tips", tips);
return m;
formDataService.save(formData);
return Result.ok("add-ok","添加成功！");
}
/** */
@ApiOperation( value = "删除一条form_data信息",notes="delFormData,仅需要上传主键字段")
@ApiOperation( value = "表单数据表-删除",notes=" ")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}}")
})
@RequestMapping(value="/del",method=RequestMethod.POST)
public Map<String,Object> delFormData(@RequestBody FormData formData){
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功删除一条数据");
try{
FormData fd=formDataService.selectOneObject(formData);
if(fd==null) {
tips.setFailureMsg("数据不存在");
}else {
if("0".equals(fd.getFlowState())) {
formDataService.deleteByPk(formData);
}else {
if("1".equals(fd.getFlowState())) {
tips.setFailureMsg("flow-state-del-001","flowState","审核中的数据不允许删除");
}else if("2".equals(fd.getFlowState())) {
tips.setFailureMsg("flow-state-del-002","flowState","审核完毕的数据不允许删除");
}else {
tips.setFailureMsg("flow-state-del-003","数据状态不正确");
}
}
}
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
public Result delFormData(@RequestBody FormData formData){
formDataService.removeById(formData);
return Result.ok("del-ok","删除成功！");
}
m.put("tips", tips);
return m;
}
/***/
@ApiOperation( value = "根据主键修改一条form_data信息",notes="editFormData")
@ApiOperation( value = "表单数据表-修改",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormData.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/edit",method=RequestMethod.POST)
public Map<String,Object> editFormData(@RequestBody FormDataVo formData) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功更新一条数据");
try{
public Result editFormData(@RequestBody FormData formData) {
formData.setLastTime(new Date());
if(formData.getCreateTime()==null) {
formData.setCreateTime(new Date());
@ -224,42 +114,119 @@ public class FormDataController {
if(StringUtils.isEmpty(formData.getFlowState())) {
formData.setFlowState("0");
}
formDataService.insertOrUpdate(formData,true);
m.put("data",formData);
formDataService.updateById(formData);
return Result.ok("edit-ok","修改成功！");
}
@ApiOperation( value = "表单数据表-批量修改某些字段",notes="")
@ApiEntityParams( value = FormData.class, props={ }, remark = "表单数据表", paramType = "body" )
@ApiResponses({
@ApiResponse(code = 200,response=FormData.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/editSomeFields",method=RequestMethod.POST)
public Result editSomeFields( @ApiIgnore @RequestBody Map<String,Object> params) {
try{
User user= LoginUtils.getCurrentUserInfo();
formDataService.editSomeFields(params);
return Result.ok("edit-ok","更新成功");
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
return Result.error(e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
return Result.error(e);
}
m.put("tips", tips);
return m;
}
@ApiOperation( value = "表单数据表-批量删除",notes=" ")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}")
})
@RequestMapping(value="/batchDel",method=RequestMethod.POST)
public Result batchDelFormData(@RequestBody List<FormData> formDatas) {
User user= LoginUtils.getCurrentUserInfo();
try{
if(formDatas.size()<=0){
return Result.error("formData-batchDel-data-err-0","请上送待删除数据列表");
}
List<FormData> datasDb=formDataService.listByIds(formDatas.stream().map(i-> i.getId() ).collect(Collectors.toList()));
List<FormData> can=new ArrayList<>();
List<FormData> no=new ArrayList<>();
for (FormData data : datasDb) {
if(true){
can.add(data);
}else{
no.add(data);
}
}
List<String> msgs=new ArrayList<>();
if(can.size()>0){
formDataService.removeByIds(can);
msgs.add(LangTips.transMsg("del-ok-num","成功删除%s条数据.",can.size()));
}
if(no.size()>0){
msgs.add(LangTips.transMsg("not-allow-del-num","以下%s条数据不能删除:【%s】",no.size(),no.stream().map(i-> i.getId() ).collect(Collectors.joining(","))));
}
if(can.size()>0){
return Result.ok(msgs.stream().collect(Collectors.joining()));
}else {
return Result.error(msgs.stream().collect(Collectors.joining()));
}
}catch (BizException e) {
return Result.error(e);
}catch (Exception e) {
return Result.error(e);
}
/**
@ApiOperation( value = "根据主键列表批量删除form_data信息",notes="batchDelFormData,仅需要上传主键字段")
}
@ApiOperation( value = "表单数据表-根据主键查询一条数据",notes=" ")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}")
@ApiResponse(code = 200,response=FormData.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/batchDel",method=RequestMethod.POST)
public Map<String,Object> batchDelFormData(@RequestBody List<FormData> formDatas) {
@RequestMapping(value="/queryById",method=RequestMethod.GET)
public Result queryById(FormData formData) {
FormData data = (FormData) formDataService.getById(formData);
return Result.ok().setData(data);
}
/**
* 流程审批过程中回调该接口，更新业务数据
* 如果发起流程时上送了restUrl，则无论流程中是否配置了监听器都会在流程发生以下事件时推送数据过来
* eventName: PROCESS_STARTED 流程启动完成 全局
* PROCESS_COMPLETED 流程正常结束 全局
* PROCESS_CANCELLED 流程删除 全局
* create 人工任务启动
* complete 人工任务完成
* assignment 人工任务分配给了具体的人
* delete 人工任务被删除
*
* 其中 create/complete/assignment/delete事件是需要在模型中人工节点上配置了委托代理表达式 ${taskBizCallListener}才会推送过来。
* 在人工任务节点上配置 任务监听器 建议事件为 complete,其它assignment/create/complete/delete也可以，一般建议在complete,委托代理表达式 ${taskBizCallListener}
*
* @param flowVars {flowBranchId,agree,procInstId,assignee,actId,taskName,mainTitle,branchId,bizKey,commentMsg,eventName,modelKey} 等
* @return 如果tips.isOk==false，将影响流程提交
**/
@RequestMapping(value="/processApprova",method=RequestMethod.POST)
public Map<String,Object> processApprova( @RequestBody Map<String,Object> flowVars){
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功删除"+formDatas.size()+"条数据");
Tips tips=new Tips("成功新增一条数据");
try{
formDataService.batchDelete(formDatas);
this.formDataService.processApprova(flowVars);
logger.debug("procInstId====="+flowVars.get("procInstId"));
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
logger.error("执行异常",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
logger.error("执行异常",e);
}
m.put("tips", tips);
return m;
}
*/
}

239
mdp-form/src/main/java/com/mdp/form/ctrl/FormDataProcessApprovaController.java
View File

@ -1,181 +1,174 @@
package com.mdp.form.ctrl;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.mdp.form.entity.FormDataProcessApprova;
import com.mdp.form.entity.FormDataTag;
import com.mdp.form.service.FormDataProcessApprovaService;
import com.mdp.swagger.ApiEntityParams;
import jdk.nashorn.internal.ir.annotations.Ignore;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.util.*;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
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.RestController;
import io.swagger.annotations.*;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.mdp.core.entity.Result;
import com.mdp.core.query.QueryTools;
import static com.mdp.core.utils.BaseUtils.*;
import com.mdp.core.entity.Tips;
import com.mdp.core.entity.LangTips;
import com.mdp.core.err.BizException;
import com.mdp.core.utils.RequestUtils;
import com.mdp.core.utils.NumberUtil;
import com.mdp.safe.client.entity.User;
import com.mdp.safe.client.utils.LoginUtils;
import com.mdp.swagger.ApiEntityParams;
import io.swagger.annotations.*;
import springfox.documentation.annotations.ApiIgnore;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
import javax.servlet.http.HttpServletRequest;
import com.mdp.mybatis.PageUtils;
import com.mdp.core.utils.RequestUtils;
import com.mdp.core.entity.Tips;
import com.mdp.form.service.FormDataProcessApprovaService;
import com.mdp.form.entity.FormDataProcessApprova;
/**
* url编制采用rest风格,如对FORM.form_data_process_approva form_data_process_approva的操作有增删改查,对应的url分别为:<br>
* 新增: form/formDataProcessApprova/add <br>
* 查询: form/formDataProcessApprova/list<br>
* 模糊查询: form/formDataProcessApprova/listKey<br>
* 修改: form/formDataProcessApprova/edit <br>
* 删除: form/formDataProcessApprova/del<br>
* 批量删除: form/formDataProcessApprova/batchDel<br>
* 组织 com.qqkj 顶级模块 mdp 大模块 form 小模块 <br>
* 实体 FormDataProcessApprova 表 FORM.form_data_process_approva 当前主键(包括多主键): id;
***/
@RestController("mdp.form.formDataProcessApprovaController")
@RestController
@RequestMapping(value="/**/form/formDataProcessApprova")
@Api(tags={"form_data_process_approva操作接口"})
@Api(tags={"企业入驻审核流程-操作接口"})
public class FormDataProcessApprovaController {
static Log logger=LogFactory.getLog(FormDataProcessApprovaController.class);
static Logger logger =LoggerFactory.getLogger(FormDataProcessApprovaController.class);
@Autowired
private FormDataProcessApprovaService formDataProcessApprovaService;
@ApiOperation( value = "查询form_data_process_approva信息列表",notes="listFormDataProcessApprova,条件之间是 and关系,模糊查询写法如 {studentName:'%才哥%'}")
@ApiOperation( value = "企业入驻审核流程-查询列表",notes=" ")
@ApiEntityParams(FormDataProcessApprova.class)
@ApiResponses({
@ApiResponse(code = 200,response= FormDataProcessApprova.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'错误码'},pageInfo:{total:总记录数},data:[数据对象1,数据对象2,...]}")
@ApiResponse(code = 200,response=FormDataProcessApprova.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'错误码'},total:总记录数,data:[数据对象1,数据对象2,...]}")
})
@RequestMapping(value="/list",method=RequestMethod.GET)
public Map<String,Object> listFormDataProcessApprova(@Ignore @RequestParam Map<String,Object> formDataProcessApprova){
Map<String,Object> m = new HashMap<>();
RequestUtils.transformArray(formDataProcessApprova, "ids");
PageUtils.startPage(formDataProcessApprova);
List<Map<String,Object>> formDataProcessApprovaList = formDataProcessApprovaService.selectListMapByWhere(formDataProcessApprova); //列出FormDataProcessApprova列表
PageUtils.responePage(m, formDataProcessApprovaList);
m.put("data",formDataProcessApprovaList);
Tips tips=new Tips("查询成功");
m.put("tips", tips);
return m;
public Result listFormDataProcessApprova(@ApiIgnore @RequestParam Map<String,Object> params){
try {
User user=LoginUtils.getCurrentUserInfo();
QueryWrapper<FormDataProcessApprova> qw = QueryTools.initQueryWrapper(FormDataProcessApprova.class , params);
IPage page=QueryTools.initPage(params);
List<Map<String,Object>> datas = formDataProcessApprovaService.selectListMapByWhere(page,qw,params);
return Result.ok("query-ok","查询成功").setData(datas).setTotal(page.getTotal());
}catch (BizException e) {
return Result.error(e);
}catch (Exception e) {
return Result.error(e);
}
}
/**
@ApiOperation( value = "新增一条form_data_process_approva信息",notes="addFormDataProcessApprova,主键如果为空，后台自动生成")
@ApiOperation( value = "企业入驻审核流程-新增",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormDataProcessApprova.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/add",method=RequestMethod.POST)
public Map<String,Object> addFormDataProcessApprova(@RequestBody FormDataProcessApprova formDataProcessApprova) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功新增一条数据");
try{
if(StringUtils.isEmpty(formDataProcessApprova.getId())) {
formDataProcessApprova.setId(formDataProcessApprovaService.createKey("id"));
}else{
FormDataProcessApprova formDataProcessApprovaQuery = new FormDataProcessApprova(formDataProcessApprova.getId());
if(formDataProcessApprovaService.countByWhere(formDataProcessApprovaQuery)>0){
tips.setFailureMsg("编号重复，请修改编号再提交");
m.put("tips", tips);
return m;
public Result addFormDataProcessApprova(@RequestBody FormDataProcessApprova formDataProcessApprova) {
formDataProcessApprovaService.save(formDataProcessApprova);
return Result.ok("add-ok","添加成功！");
}
}
formDataProcessApprovaService.insert(formDataProcessApprova);
m.put("data",formDataProcessApprova);
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
}
m.put("tips", tips);
return m;
}
*/
/**
@ApiOperation( value = "删除一条form_data_process_approva信息",notes="delFormDataProcessApprova,仅需要上传主键字段")
@ApiOperation( value = "企业入驻审核流程-删除",notes=" ")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}}")
})
@RequestMapping(value="/del",method=RequestMethod.POST)
public Map<String,Object> delFormDataProcessApprova(@RequestBody FormDataProcessApprova formDataProcessApprova){
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功删除一条数据");
try{
formDataProcessApprovaService.deleteByPk(formDataProcessApprova);
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
}
m.put("tips", tips);
return m;
public Result delFormDataProcessApprova(@RequestBody FormDataProcessApprova formDataProcessApprova){
formDataProcessApprovaService.removeById(formDataProcessApprova);
return Result.ok("del-ok","删除成功！");
}
*/
/**
@ApiOperation( value = "根据主键修改一条form_data_process_approva信息",notes="editFormDataProcessApprova")
@ApiOperation( value = "企业入驻审核流程-修改",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormDataProcessApprova.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/edit",method=RequestMethod.POST)
public Map<String,Object> editFormDataProcessApprova(@RequestBody FormDataProcessApprova formDataProcessApprova) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功更新一条数据");
public Result editFormDataProcessApprova(@RequestBody FormDataProcessApprova formDataProcessApprova) {
formDataProcessApprovaService.updateById(formDataProcessApprova);
return Result.ok("edit-ok","修改成功！");
}
@ApiOperation( value = "企业入驻审核流程-批量修改某些字段",notes="")
@ApiEntityParams( value = FormDataProcessApprova.class, props={ }, remark = "企业入驻审核流程", paramType = "body" )
@ApiResponses({
@ApiResponse(code = 200,response=FormDataProcessApprova.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/editSomeFields",method=RequestMethod.POST)
public Result editSomeFields( @ApiIgnore @RequestBody Map<String,Object> params) {
try{
formDataProcessApprovaService.updateByPk(formDataProcessApprova);
m.put("data",formDataProcessApprova);
User user= LoginUtils.getCurrentUserInfo();
formDataProcessApprovaService.editSomeFields(params);
return Result.ok("edit-ok","更新成功");
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
return Result.error(e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
return Result.error(e);
}
m.put("tips", tips);
return m;
}
*/
/**
@ApiOperation( value = "根据主键列表批量删除form_data_process_approva信息",notes="batchDelFormDataProcessApprova,仅需要上传主键字段")
@ApiOperation( value = "企业入驻审核流程-批量删除",notes=" ")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}")
})
@RequestMapping(value="/batchDel",method=RequestMethod.POST)
public Map<String,Object> batchDelFormDataProcessApprova(@RequestBody List<FormDataProcessApprova> formDataProcessApprovas) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功删除"+formDataProcessApprovas.size()+"条数据");
public Result batchDelFormDataProcessApprova(@RequestBody List<FormDataProcessApprova> formDataProcessApprovas) {
User user= LoginUtils.getCurrentUserInfo();
try{
formDataProcessApprovaService.batchDelete(formDataProcessApprovas);
if(formDataProcessApprovas.size()<=0){
return Result.error("formDataProcessApprova-batchDel-data-err-0","请上送待删除数据列表");
}
List<FormDataProcessApprova> datasDb=formDataProcessApprovaService.listByIds(formDataProcessApprovas.stream().map(i-> i.getId() ).collect(Collectors.toList()));
List<FormDataProcessApprova> can=new ArrayList<>();
List<FormDataProcessApprova> no=new ArrayList<>();
for (FormDataProcessApprova data : datasDb) {
if(true){
can.add(data);
}else{
no.add(data);
}
}
List<String> msgs=new ArrayList<>();
if(can.size()>0){
formDataProcessApprovaService.removeByIds(can);
msgs.add(LangTips.transMsg("del-ok-num","成功删除%s条数据.",can.size()));
}
if(no.size()>0){
msgs.add(LangTips.transMsg("not-allow-del-num","以下%s条数据不能删除:【%s】",no.size(),no.stream().map(i-> i.getId() ).collect(Collectors.joining(","))));
}
if(can.size()>0){
return Result.ok(msgs.stream().collect(Collectors.joining()));
}else {
return Result.error(msgs.stream().collect(Collectors.joining()));
}
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
return Result.error(e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
return Result.error(e);
}
m.put("tips", tips);
return m;
}
*/
@ApiOperation( value = "企业入驻审核流程-根据主键查询一条数据",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormDataProcessApprova.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/queryById",method=RequestMethod.GET)
public Result queryById(FormDataProcessApprova formDataProcessApprova) {
FormDataProcessApprova data = (FormDataProcessApprova) formDataProcessApprovaService.getById(formDataProcessApprova);
return Result.ok().setData(data);
}
}

301
mdp-form/src/main/java/com/mdp/form/ctrl/FormDataTagController.java
View File

@ -1,53 +1,49 @@
package com.mdp.form.ctrl;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.stream.Collectors;
import com.mdp.form.entity.FormDataTagVo;
import com.mdp.form.entity.FormDef;
import com.mdp.form.service.FormDataService;
import com.mdp.form.service.FormDataTagService;
import com.mdp.swagger.ApiEntityParams;
import jdk.nashorn.internal.ir.annotations.Ignore;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
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.RestController;
import io.swagger.annotations.*;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.mdp.core.entity.Result;
import com.mdp.core.query.QueryTools;
import static com.mdp.core.utils.BaseUtils.*;
import com.mdp.core.entity.Tips;
import com.mdp.core.entity.LangTips;
import com.mdp.core.err.BizException;
import com.mdp.core.utils.RequestUtils;
import com.mdp.core.utils.NumberUtil;
import com.mdp.safe.client.entity.User;
import com.mdp.safe.client.utils.LoginUtils;
import com.mdp.swagger.ApiEntityParams;
import io.swagger.annotations.*;
import springfox.documentation.annotations.ApiIgnore;
import javax.servlet.http.HttpServletRequest;
import com.mdp.form.service.FormDataTagService;
import com.mdp.form.entity.FormDataTag;
import com.mdp.mybatis.PageUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
/**
* url编制采用rest风格,如对FORM.form_data_tag form_data_tag的操作有增删改查,对应的url分别为:<br>
* 新增: form/formDataTag/add <br>
* 查询: form/formDataTag/list<br>
* 模糊查询: form/formDataTag/listKey<br>
* 修改: form/formDataTag/edit <br>
* 删除: form/formDataTag/del<br>
* 批量删除: form/formDataTag/batchDel<br>
* 组织 com.qqkj 顶级模块 mdp 大模块 form 小模块 <br>
* 实体 FormDataTag 表 FORM.form_data_tag 当前主键(包括多主键): data_id;
***/
@RestController("mdp.form.formDataTagController")
@RestController
@RequestMapping(value="/**/form/formDataTag")
@Api(tags={"form_data_tag操作接口"})
@Api(tags={"form_data_tag-操作接口"})
public class FormDataTagController {
static Log logger=LogFactory.getLog(FormDataTagController.class);
static Logger logger =LoggerFactory.getLogger(FormDataTagController.class);
@Autowired
private FormDataTagService formDataTagService;
@ -56,24 +52,131 @@ public class FormDataTagController {
@Autowired
private FormDataService formDataService;
@ApiOperation( value = "查询form_data_tag信息列表",notes="listFormDataTag,条件之间是 and关系,模糊查询写法如 {studentName:'%才哥%'}")
@ApiOperation( value = "form_data_tag-查询列表",notes=" ")
@ApiEntityParams(FormDataTag.class)
@ApiResponses({
@ApiResponse(code = 200,response=FormDataTag.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'错误码'},pageInfo:{total:总记录数},data:[数据对象1,数据对象2,...]}")
@ApiResponse(code = 200,response=FormDataTag.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'错误码'},total:总记录数,data:[数据对象1,数据对象2,...]}")
})
@RequestMapping(value="/list",method=RequestMethod.GET)
public Map<String,Object> listFormDataTag(@Ignore @RequestParam Map<String,Object> formDataTag){
Map<String,Object> m = new HashMap<>();
RequestUtils.transformArray(formDataTag, "dataIds");
PageUtils.startPage(formDataTag);
List<Map<String,Object>> formDataTagList = formDataTagService.selectListMapByWhere(formDataTag); //列出FormDataTag列表
PageUtils.responePage(m, formDataTagList);
m.put("data",formDataTagList);
Tips tips=new Tips("查询成功");
m.put("tips", tips);
return m;
public Result listFormDataTag(@ApiIgnore @RequestParam Map<String,Object> params){
try {
User user=LoginUtils.getCurrentUserInfo();
QueryWrapper<FormDataTag> qw = QueryTools.initQueryWrapper(FormDataTag.class , params);
IPage page=QueryTools.initPage(params);
List<Map<String,Object>> datas = formDataTagService.selectListMapByWhere(page,qw,params);
return Result.ok("query-ok","查询成功").setData(datas).setTotal(page.getTotal());
}catch (BizException e) {
return Result.error(e);
}catch (Exception e) {
return Result.error(e);
}
}
@ApiOperation( value = "form_data_tag-新增",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormDataTag.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/add",method=RequestMethod.POST)
public Result addFormDataTag(@RequestBody FormDataTag formDataTag) {
formDataTagService.save(formDataTag);
return Result.ok("add-ok","添加成功！");
}
@ApiOperation( value = "form_data_tag-删除",notes=" ")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}}")
})
@RequestMapping(value="/del",method=RequestMethod.POST)
public Result delFormDataTag(@RequestBody FormDataTag formDataTag){
formDataTagService.removeById(formDataTag);
return Result.ok("del-ok","删除成功！");
}
@ApiOperation( value = "form_data_tag-修改",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormDataTag.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/edit",method=RequestMethod.POST)
public Result editFormDataTag(@RequestBody FormDataTag formDataTag) {
formDataTagService.updateById(formDataTag);
return Result.ok("edit-ok","修改成功！");
}
@ApiOperation( value = "form_data_tag-批量修改某些字段",notes="")
@ApiEntityParams( value = FormDataTag.class, props={ }, remark = "form_data_tag", paramType = "body" )
@ApiResponses({
@ApiResponse(code = 200,response=FormDataTag.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/editSomeFields",method=RequestMethod.POST)
public Result editSomeFields( @ApiIgnore @RequestBody Map<String,Object> params) {
try{
User user= LoginUtils.getCurrentUserInfo();
formDataTagService.editSomeFields(params);
return Result.ok("edit-ok","更新成功");
}catch (BizException e) {
logger.error("",e);
return Result.error(e);
}catch (Exception e) {
logger.error("",e);
return Result.error(e);
}
}
@ApiOperation( value = "form_data_tag-批量删除",notes=" ")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}")
})
@RequestMapping(value="/batchDel",method=RequestMethod.POST)
public Result batchDelFormDataTag(@RequestBody List<FormDataTag> formDataTags) {
User user= LoginUtils.getCurrentUserInfo();
try{
if(formDataTags.size()<=0){
return Result.error("formDataTag-batchDel-data-err-0","请上送待删除数据列表");
}
List<FormDataTag> datasDb=formDataTagService.listByIds(formDataTags.stream().map(i-> i.getId() ).collect(Collectors.toList()));
List<FormDataTag> can=new ArrayList<>();
List<FormDataTag> no=new ArrayList<>();
for (FormDataTag data : datasDb) {
if(true){
can.add(data);
}else{
no.add(data);
}
}
List<String> msgs=new ArrayList<>();
if(can.size()>0){
formDataTagService.removeByIds(can);
msgs.add(LangTips.transMsg("del-ok-num","成功删除%s条数据.",can.size()));
}
if(no.size()>0){
msgs.add(LangTips.transMsg("not-allow-del-num","以下%s条数据不能删除:【%s】",no.size(),no.stream().map(i-> i.getId() ).collect(Collectors.joining(","))));
}
if(can.size()>0){
return Result.ok(msgs.stream().collect(Collectors.joining()));
}else {
return Result.error(msgs.stream().collect(Collectors.joining()));
}
}catch (BizException e) {
return Result.error(e);
}catch (Exception e) {
return Result.error(e);
}
}
@ApiOperation( value = "form_data_tag-根据主键查询一条数据",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormDataTag.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/queryById",method=RequestMethod.GET)
public Result queryById(FormDataTag formDataTag) {
FormDataTag data = (FormDataTag) formDataTagService.getById(formDataTag);
return Result.ok().setData(data);
}
/**
* 批量打标签
@ -92,9 +195,9 @@ public class FormDataTagController {
Tips tips=new Tips("成功更新标签");
try{
if(tagsVos==null) {
tips.setFailureMsg("请上送参数列表");
return Result.error("params-required","请上送参数列表");
}else if(tagsVos.size()>10) {
tips.setFailureMsg("一次只能同时给十条数据打标签");
return Result.error("must-small-10","一次只能同时给十条数据打标签");
}else {
for (FormDataTagVo tagsVo : tagsVos) {
List<FormDataTag> tags=tagsVo.getTags();
@ -124,110 +227,4 @@ public class FormDataTagController {
m.put("tips", tips);
return m;
}
/**
@ApiOperation( value = "新增一条form_data_tag信息",notes="addFormDataTag,主键如果为空，后台自动生成")
@ApiResponses({
@ApiResponse(code = 200,response=FormDataTag.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/add",method=RequestMethod.POST)
public Map<String,Object> addFormDataTag(@RequestBody FormDataTag formDataTag) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功新增一条数据");
try{
if(StringUtils.isEmpty(formDataTag.getDataId())) {
formDataTag.setDataId(formDataTagService.createKey("dataId"));
}else{
FormDataTag formDataTagQuery = new FormDataTag(formDataTag.getDataId());
if(formDataTagService.countByWhere(formDataTagQuery)>0){
tips.setFailureMsg("编号重复，请修改编号再提交");
m.put("tips", tips);
return m;
}
}
formDataTagService.insert(formDataTag);
m.put("data",formDataTag);
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
}
m.put("tips", tips);
return m;
}
*/
/**
@ApiOperation( value = "删除一条form_data_tag信息",notes="delFormDataTag,仅需要上传主键字段")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}}")
})
@RequestMapping(value="/del",method=RequestMethod.POST)
public Map<String,Object> delFormDataTag(@RequestBody FormDataTag formDataTag){
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功删除一条数据");
try{
formDataTagService.deleteByPk(formDataTag);
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
}
m.put("tips", tips);
return m;
}
*/
/**
@ApiOperation( value = "根据主键修改一条form_data_tag信息",notes="editFormDataTag")
@ApiResponses({
@ApiResponse(code = 200,response=FormDataTag.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/edit",method=RequestMethod.POST)
public Map<String,Object> editFormDataTag(@RequestBody FormDataTag formDataTag) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功更新一条数据");
try{
formDataTagService.updateByPk(formDataTag);
m.put("data",formDataTag);
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
}
m.put("tips", tips);
return m;
}
*/
/**
@ApiOperation( value = "根据主键列表批量删除form_data_tag信息",notes="batchDelFormDataTag,仅需要上传主键字段")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}")
})
@RequestMapping(value="/batchDel",method=RequestMethod.POST)
public Map<String,Object> batchDelFormDataTag(@RequestBody List<FormDataTag> formDataTags) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功删除"+formDataTags.size()+"条数据");
try{
formDataTagService.batchDelete(formDataTags);
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
}
m.put("tips", tips);
return m;
}
*/
}

261
mdp-form/src/main/java/com/mdp/form/ctrl/FormDefController.java
View File

@ -1,119 +1,87 @@
package com.mdp.form.ctrl;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.stream.Collectors;
import com.mdp.form.entity.FormDef;
import com.mdp.form.entity.FormDefTag;
import com.mdp.form.entity.FormDefVo;
import com.mdp.form.service.FormDataService;
import com.mdp.form.service.FormDefService;
import com.mdp.swagger.ApiEntityParams;
import jdk.nashorn.internal.ir.annotations.Ignore;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
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.RestController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
import com.mdp.mybatis.PageUtils;
import com.mdp.core.utils.RequestUtils;
import io.swagger.annotations.*;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.mdp.core.entity.Result;
import com.mdp.core.query.QueryTools;
import static com.mdp.core.utils.BaseUtils.*;
import com.mdp.core.entity.Tips;
import com.mdp.core.entity.LangTips;
import com.mdp.core.err.BizException;
import com.mdp.form.entity.FormDefVo;
/**
* url编制采用rest风格,如对FORM.form_def form_def的操作有增删改查,对应的url分别为:<br>
* 新增: form/formDef/add <br>
* 查询: form/formDef/list<br>
* 模糊查询: form/formDef/listKey<br>
* 修改: form/formDef/edit <br>
* 删除: form/formDef/del<br>
* 批量删除: form/formDef/batchDel<br>
* 组织 com.qqkj 顶级模块 mdp 大模块 form 小模块 <br>
* 实体 FormDef 表 FORM.form_def 当前主键(包括多主键): id;
***/
@RestController("mdp.form.formDefController")
import com.mdp.core.utils.RequestUtils;
import com.mdp.core.utils.NumberUtil;
import com.mdp.safe.client.entity.User;
import com.mdp.safe.client.utils.LoginUtils;
import com.mdp.swagger.ApiEntityParams;
import io.swagger.annotations.*;
import springfox.documentation.annotations.ApiIgnore;
import javax.servlet.http.HttpServletRequest;
import com.mdp.form.service.FormDefService;
import com.mdp.form.entity.FormDef;
@RestController
@RequestMapping(value="/**/form/formDef")
@Api(tags={"form_def操作接口"})
@Api(tags={"表单定义-操作接口"})
public class FormDefController {
static Log logger=LogFactory.getLog(FormDefController.class);
static Logger logger =LoggerFactory.getLogger(FormDefController.class);
@Autowired
private FormDefService formDefService;
@Autowired
private FormDataService formDataService;
@ApiOperation( value = "查询form_def信息列表",notes="listFormDef,条件之间是 and关系,模糊查询写法如 {studentName:'%才哥%'}")
@ApiOperation( value = "表单定义-查询列表",notes=" ")
@ApiEntityParams(FormDef.class)
@ApiResponses({
@ApiResponse(code = 200,response= FormDef.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'错误码'},pageInfo:{total:总记录数},data:[数据对象1,数据对象2,...]}")
@ApiResponse(code = 200,response=FormDef.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'错误码'},total:总记录数,data:[数据对象1,数据对象2,...]}")
})
@RequestMapping(value="/list",method=RequestMethod.GET)
public Map<String,Object> listFormDef(@Ignore @RequestParam Map<String,Object> formDef){
Map<String,Object> m = new HashMap<>();
RequestUtils.transformArray(formDef, "ids");
RequestUtils.transformArray(formDef, "tagIds");
RequestUtils.transformArray(formDef, "categoryIds");
PageUtils.startPage(formDef);
List<Map<String,Object>> formDefList = formDefService.selectListMapByWhere(formDef); //列出FormDef列表
PageUtils.responePage(m, formDefList);
m.put("data",formDefList);
Tips tips=new Tips("查询成功");
m.put("tips", tips);
return m;
public Result listFormDef(@ApiIgnore @RequestParam Map<String,Object> params){
try {
User user=LoginUtils.getCurrentUserInfo();
QueryWrapper<FormDef> qw = QueryTools.initQueryWrapper(FormDef.class , params);
IPage page=QueryTools.initPage(params);
List<Map<String,Object>> datas = formDefService.selectListMapByWhere(page,qw,params);
return Result.ok("query-ok","查询成功").setData(datas).setTotal(page.getTotal());
}catch (BizException e) {
return Result.error(e);
}catch (Exception e) {
return Result.error(e);
}
}
/**
@ApiOperation( value = "新增一条form_def信息",notes="addFormDef,主键如果为空，后台自动生成")
@ApiOperation( value = "表单定义-新增",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormDef.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/add",method=RequestMethod.POST)
public Map<String,Object> addFormDef(@RequestBody FormDef formDef) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功新增一条数据");
try{
if(StringUtils.isEmpty(formDef.getId())) {
formDef.setId(formDefService.createKey("id"));
}else{
FormDef formDefQuery = new FormDef(formDef.getId());
if(formDefService.countByWhere(formDefQuery)>0){
tips.setFailureMsg("编号重复，请修改编号再提交");
m.put("tips", tips);
return m;
}
}
formDefService.insert(formDef);
m.put("data",formDef);
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
public Result addFormDef(@RequestBody FormDef formDef) {
formDefService.save(formDef);
return Result.ok("add-ok","添加成功！");
}
m.put("tips", tips);
return m;
}
*/
@RequestMapping(value="/addFormDefAndFields")
public Map<String,Object> addFormDefAndFields(@RequestBody FormDefVo formDefVo) {
Map<String,Object> m = new HashMap<>();
@ -130,7 +98,6 @@ public class FormDefController {
m.put("tips", tips);
return m;
}
@RequestMapping(value="/editFormDefAndFields")
public Map<String,Object> editFormDefAndFields(@RequestBody FormDefVo formDefVo) {
Map<String,Object> m = new HashMap<>();
@ -147,16 +114,12 @@ public class FormDefController {
m.put("tips", tips);
return m;
}
/**
* java.sql.SQLIntegrityConstraintViolationException
* 根据主键删除1条数据
*/
@RequestMapping(value="/del")
public Map<String,Object> delFormDef(@RequestBody FormDef formDef){
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功删除一条数据");
try{
@ApiOperation( value = "表单定义-删除",notes=" ")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}}")
})
@RequestMapping(value="/del",method=RequestMethod.POST)
public Result delFormDef(@RequestBody FormDef formDef){
Map<String,Object> p=new HashMap<>();
p.put("formId", formDef.getId());
long count=formDataService.selectOne("countByFormId", p);
@ -166,63 +129,93 @@ public class FormDefController {
int i =formDefService.deleteByPk(formDef);
tips.setOkMsg("成功删除"+i+"张表单");
}
}catch (BizException e) {
tips=e.getTips();
logger.error("执行异常",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("执行异常",e);
}
m.put("tips", tips);
return m;
formDefService.removeById(formDef);
return Result.ok("del-ok","删除成功！");
}
@ApiOperation( value = "表单定义-修改",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormDef.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/edit",method=RequestMethod.POST)
public Result editFormDef(@RequestBody FormDef formDef) {
formDefService.updateById(formDef);
return Result.ok("edit-ok","修改成功！");
}
/**
* 根据主键修改一条数据
*/
@RequestMapping(value="/edit")
public Map<String,Object> editFormDef(@RequestBody FormDef formDef) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功更新一条数据");
@ApiOperation( value = "表单定义-批量修改某些字段",notes="")
@ApiEntityParams( value = FormDef.class, props={ }, remark = "表单定义", paramType = "body" )
@ApiResponses({
@ApiResponse(code = 200,response=FormDef.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/editSomeFields",method=RequestMethod.POST)
public Result editSomeFields( @ApiIgnore @RequestBody Map<String,Object> params) {
try{
formDefService.updateByPk(formDef);
m.put("data",formDef);
User user= LoginUtils.getCurrentUserInfo();
formDefService.editSomeFields(params);
return Result.ok("edit-ok","更新成功");
}catch (BizException e) {
tips=e.getTips();
logger.error("执行异常",e);
logger.error("",e);
return Result.error(e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("执行异常",e);
logger.error("",e);
return Result.error(e);
}
m.put("tips", tips);
return m;
}
/**
@ApiOperation( value = "根据主键列表批量删除form_def信息",notes="batchDelFormDef,仅需要上传主键字段")
@ApiOperation( value = "表单定义-批量删除",notes=" ")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}")
})
@RequestMapping(value="/batchDel",method=RequestMethod.POST)
public Map<String,Object> batchDelFormDef(@RequestBody List<FormDef> formDefs) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功删除"+formDefs.size()+"条数据");
public Result batchDelFormDef(@RequestBody List<FormDef> formDefs) {
User user= LoginUtils.getCurrentUserInfo();
try{
formDefService.batchDelete(formDefs);
if(formDefs.size()<=0){
return Result.error("formDef-batchDel-data-err-0","请上送待删除数据列表");
}
List<FormDef> datasDb=formDefService.listByIds(formDefs.stream().map(i-> i.getId() ).collect(Collectors.toList()));
List<FormDef> can=new ArrayList<>();
List<FormDef> no=new ArrayList<>();
for (FormDef data : datasDb) {
if(true){
can.add(data);
}else{
no.add(data);
}
}
List<String> msgs=new ArrayList<>();
if(can.size()>0){
formDefService.removeByIds(can);
msgs.add(LangTips.transMsg("del-ok-num","成功删除%s条数据.",can.size()));
}
if(no.size()>0){
msgs.add(LangTips.transMsg("not-allow-del-num","以下%s条数据不能删除:【%s】",no.size(),no.stream().map(i-> i.getId() ).collect(Collectors.joining(","))));
}
if(can.size()>0){
return Result.ok(msgs.stream().collect(Collectors.joining()));
}else {
return Result.error(msgs.stream().collect(Collectors.joining()));
}
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
return Result.error(e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
return Result.error(e);
}
m.put("tips", tips);
return m;
}
**/
@ApiOperation( value = "表单定义-根据主键查询一条数据",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormDef.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/queryById",method=RequestMethod.GET)
public Result queryById(FormDef formDef) {
FormDef data = (FormDef) formDefService.getById(formDef);
return Result.ok().setData(data);
}
}

279
mdp-form/src/main/java/com/mdp/form/ctrl/FormDefTagController.java
View File

@ -1,232 +1,175 @@
package com.mdp.form.ctrl;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.stream.Collectors;
import com.mdp.form.entity.FormDefTag;
import com.mdp.form.entity.FormDefTagVo;
import com.mdp.form.entity.FormQx;
import com.mdp.form.service.FormDefService;
import com.mdp.form.service.FormDefTagService;
import com.mdp.swagger.ApiEntityParams;
import jdk.nashorn.internal.ir.annotations.Ignore;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
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.RestController;
import io.swagger.annotations.*;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.mdp.core.entity.Result;
import com.mdp.core.query.QueryTools;
import static com.mdp.core.utils.BaseUtils.*;
import com.mdp.core.entity.Tips;
import com.mdp.core.entity.LangTips;
import com.mdp.core.err.BizException;
import com.mdp.core.utils.RequestUtils;
import com.mdp.mybatis.PageUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
/**
* url编制采用rest风格,如对FORM.form_def_tag form_def_tag的操作有增删改查,对应的url分别为:<br>
* 新增: form/formDefTag/add <br>
* 查询: form/formDefTag/list<br>
* 模糊查询: form/formDefTag/listKey<br>
* 修改: form/formDefTag/edit <br>
* 删除: form/formDefTag/del<br>
* 批量删除: form/formDefTag/batchDel<br>
* 组织 com.qqkj 顶级模块 mdp 大模块 form 小模块 <br>
* 实体 FormDefTag 表 FORM.form_def_tag 当前主键(包括多主键): form_id;
***/
@RestController("mdp.form.formDefTagController")
import com.mdp.core.utils.NumberUtil;
import com.mdp.safe.client.entity.User;
import com.mdp.safe.client.utils.LoginUtils;
import com.mdp.swagger.ApiEntityParams;
import io.swagger.annotations.*;
import springfox.documentation.annotations.ApiIgnore;
import javax.servlet.http.HttpServletRequest;
import com.mdp.form.service.FormDefTagService;
import com.mdp.form.entity.FormDefTag;
@RestController
@RequestMapping(value="/**/form/formDefTag")
@Api(tags={"form_def_tag操作接口"})
@Api(tags={"form_def_tag-操作接口"})
public class FormDefTagController {
static Log logger=LogFactory.getLog(FormDefTagController.class);
static Logger logger =LoggerFactory.getLogger(FormDefTagController.class);
@Autowired
private FormDefTagService formDefTagService;
@Autowired
private FormDefService formDefService;
@ApiOperation( value = "查询form_def_tag信息列表",notes="listFormDefTag,条件之间是 and关系,模糊查询写法如 {studentName:'%才哥%'}")
@ApiOperation( value = "form_def_tag-查询列表",notes=" ")
@ApiEntityParams(FormDefTag.class)
@ApiResponses({
@ApiResponse(code = 200,response= FormDefTag.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'错误码'},pageInfo:{total:总记录数},data:[数据对象1,数据对象2,...]}")
@ApiResponse(code = 200,response=FormDefTag.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'错误码'},total:总记录数,data:[数据对象1,数据对象2,...]}")
})
@RequestMapping(value="/list",method=RequestMethod.GET)
public Map<String,Object> listFormDefTag(@Ignore @RequestParam Map<String,Object> formDefTag){
Map<String,Object> m = new HashMap<>();
RequestUtils.transformArray(formDefTag, "formIds");
PageUtils.startPage(formDefTag);
List<Map<String,Object>> formDefTagList = formDefTagService.selectListMapByWhere(formDefTag); //列出FormDefTag列表
PageUtils.responePage(m, formDefTagList);
m.put("data",formDefTagList);
Tips tips=new Tips("查询成功");
m.put("tips", tips);
return m;
}
/**
* 批量打标签
* [
* {formId:'':'',branchId:'',userid:'',tags:[
* {tagId:'',tagName:''}
* ]
* }
* ]
* @param tagsVos
* @return
*/
@RequestMapping(value="/batchInsertOrDeleteTags",method=RequestMethod.POST)
public Map<String,Object> batchDelFormDefTag(@RequestBody List<FormDefTagVo> tagsVos) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功更新标签");
public Result listFormDefTag(@ApiIgnore @RequestParam Map<String,Object> params){
try {
if(tagsVos==null) {
tips.setFailureMsg("请上送参数列表");
}else if(tagsVos.size()>10) {
tips.setFailureMsg("一次只能同时给十个表单打标签");
}else {
for (FormDefTagVo tagsVo : tagsVos) {
List<FormDefTag> tags=tagsVo.getTags();
String formId=tagsVo.getFormId();
String tagIds="";
String tagNames="";
if(tags!=null && tags.size()>0) {
for (FormDefTag tag : tags) {
tagIds=tagIds+","+tag.getTagId();
tagNames=tagNames+","+tag.getTagName();
}
tagIds=tagIds.substring(1);
tagNames=tagNames.substring(1);
}
formDefService.updateTagsByFormId(formId,tagIds,tagNames);
formDefTagService.batchInsertOrDeleteTags(formId,tags);
}
}
User user=LoginUtils.getCurrentUserInfo();
QueryWrapper<FormDefTag> qw = QueryTools.initQueryWrapper(FormDefTag.class , params);
IPage page=QueryTools.initPage(params);
List<Map<String,Object>> datas = formDefTagService.selectListMapByWhere(page,qw,params);
return Result.ok("query-ok","查询成功").setData(datas).setTotal(page.getTotal());
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
return Result.error(e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
return Result.error(e);
}
m.put("tips", tips);
return m;
}
/**
@ApiOperation( value = "新增一条form_def_tag信息",notes="addFormDefTag,主键如果为空，后台自动生成")
@ApiOperation( value = "form_def_tag-新增",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormDefTag.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/add",method=RequestMethod.POST)
public Map<String,Object> addFormDefTag(@RequestBody FormDefTag formDefTag) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功新增一条数据");
try{
if(StringUtils.isEmpty(formDefTag.getFormId())) {
formDefTag.setFormId(formDefTagService.createKey("formId"));
}else{
FormDefTag formDefTagQuery = new FormDefTag(formDefTag.getFormId());
if(formDefTagService.countByWhere(formDefTagQuery)>0){
tips.setFailureMsg("编号重复，请修改编号再提交");
m.put("tips", tips);
return m;
public Result addFormDefTag(@RequestBody FormDefTag formDefTag) {
formDefTagService.save(formDefTag);
return Result.ok("add-ok","添加成功！");
}
}
formDefTagService.insert(formDefTag);
m.put("data",formDefTag);
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
}
m.put("tips", tips);
return m;
}
*/
/**
@ApiOperation( value = "删除一条form_def_tag信息",notes="delFormDefTag,仅需要上传主键字段")
@ApiOperation( value = "form_def_tag-删除",notes=" ")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}}")
})
@RequestMapping(value="/del",method=RequestMethod.POST)
public Map<String,Object> delFormDefTag(@RequestBody FormDefTag formDefTag){
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功删除一条数据");
try{
formDefTagService.deleteByPk(formDefTag);
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
}
m.put("tips", tips);
return m;
public Result delFormDefTag(@RequestBody FormDefTag formDefTag){
formDefTagService.removeById(formDefTag);
return Result.ok("del-ok","删除成功！");
}
*/
/**
@ApiOperation( value = "根据主键修改一条form_def_tag信息",notes="editFormDefTag")
@ApiOperation( value = "form_def_tag-修改",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormDefTag.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/edit",method=RequestMethod.POST)
public Map<String,Object> editFormDefTag(@RequestBody FormDefTag formDefTag) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功更新一条数据");
public Result editFormDefTag(@RequestBody FormDefTag formDefTag) {
formDefTagService.updateById(formDefTag);
return Result.ok("edit-ok","修改成功！");
}
@ApiOperation( value = "form_def_tag-批量修改某些字段",notes="")
@ApiEntityParams( value = FormDefTag.class, props={ }, remark = "form_def_tag", paramType = "body" )
@ApiResponses({
@ApiResponse(code = 200,response=FormDefTag.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/editSomeFields",method=RequestMethod.POST)
public Result editSomeFields( @ApiIgnore @RequestBody Map<String,Object> params) {
try{
formDefTagService.updateByPk(formDefTag);
m.put("data",formDefTag);
User user= LoginUtils.getCurrentUserInfo();
formDefTagService.editSomeFields(params);
return Result.ok("edit-ok","更新成功");
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
return Result.error(e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
return Result.error(e);
}
m.put("tips", tips);
return m;
}
*/
/**
@ApiOperation( value = "根据主键列表批量删除form_def_tag信息",notes="batchDelFormDefTag,仅需要上传主键字段")
@ApiOperation( value = "form_def_tag-批量删除",notes=" ")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}")
})
@RequestMapping(value="/batchDel",method=RequestMethod.POST)
public Map<String,Object> batchDelFormDefTag(@RequestBody List<FormDefTag> formDefTags) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功删除"+formDefTags.size()+"条数据");
public Result batchDelFormDefTag(@RequestBody List<FormDefTag> formDefTags) {
User user= LoginUtils.getCurrentUserInfo();
try{
formDefTagService.batchDelete(formDefTags);
if(formDefTags.size()<=0){
return Result.error("formDefTag-batchDel-data-err-0","请上送待删除数据列表");
}
List<FormDefTag> datasDb=formDefTagService.listByIds(formDefTags.stream().map(i-> i.getId() ).collect(Collectors.toList()));
List<FormDefTag> can=new ArrayList<>();
List<FormDefTag> no=new ArrayList<>();
for (FormDefTag data : datasDb) {
if(true){
can.add(data);
}else{
no.add(data);
}
}
List<String> msgs=new ArrayList<>();
if(can.size()>0){
formDefTagService.removeByIds(can);
msgs.add(LangTips.transMsg("del-ok-num","成功删除%s条数据.",can.size()));
}
if(no.size()>0){
msgs.add(LangTips.transMsg("not-allow-del-num","以下%s条数据不能删除:【%s】",no.size(),no.stream().map(i-> i.getId() ).collect(Collectors.joining(","))));
}
if(can.size()>0){
return Result.ok(msgs.stream().collect(Collectors.joining()));
}else {
return Result.error(msgs.stream().collect(Collectors.joining()));
}
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
return Result.error(e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
return Result.error(e);
}
m.put("tips", tips);
return m;
}
*/
@ApiOperation( value = "form_def_tag-根据主键查询一条数据",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormDefTag.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/queryById",method=RequestMethod.GET)
public Result queryById(FormDefTag formDefTag) {
FormDefTag data = (FormDefTag) formDefTagService.getById(formDefTag);
return Result.ok().setData(data);
}
}

229
mdp-form/src/main/java/com/mdp/form/ctrl/FormFieldController.java
View File

@ -1,21 +1,15 @@
package com.mdp.form.ctrl;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.stream.Collectors;
import com.mdp.core.utils.ResponseHelper;
import com.mdp.form.entity.FormDef;
import com.mdp.form.entity.FormDefVo;
import com.mdp.form.entity.FormField;
import com.mdp.form.service.FormDefService;
import com.mdp.form.service.FormFieldCacheService;
import com.mdp.form.service.FormFieldService;
import com.mdp.swagger.ApiEntityParams;
import jdk.nashorn.internal.ir.annotations.Ignore;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestBody;
@ -23,35 +17,36 @@ 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.RestController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
import com.mdp.mybatis.PageUtils;
import io.swagger.annotations.*;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.mdp.core.entity.Result;
import com.mdp.core.query.QueryTools;
import static com.mdp.core.utils.BaseUtils.*;
import com.mdp.core.entity.Tips;
import com.mdp.core.entity.LangTips;
import com.mdp.core.err.BizException;
import com.mdp.core.utils.RequestUtils;
import com.mdp.core.utils.NumberUtil;
import com.mdp.safe.client.entity.User;
import com.mdp.safe.client.utils.LoginUtils;
import com.mdp.swagger.ApiEntityParams;
import io.swagger.annotations.*;
import springfox.documentation.annotations.ApiIgnore;
import javax.servlet.http.HttpServletRequest;
/**
* url编制采用rest风格,如对FORM.form_field form_field的操作有增删改查,对应的url分别为:<br>
* 新增: form/formField/add <br>
* 查询: form/formField/list<br>
* 模糊查询: form/formField/listKey<br>
* 修改: form/formField/edit <br>
* 删除: form/formField/del<br>
* 批量删除: form/formField/batchDel<br>
* 组织 com.qqkj 顶级模块 mdp 大模块 form 小模块 <br>
* 实体 FormField 表 FORM.form_field 当前主键(包括多主键): id;
***/
@RestController("mdp.form.formFieldController")
import com.mdp.form.service.FormFieldService;
import com.mdp.form.entity.FormField;
@RestController
@RequestMapping(value="/**/form/formField")
@Api(tags={"form_field操作接口"})
@Api(tags={"表单字段定义-操作接口"})
public class FormFieldController {
static Log logger=LogFactory.getLog(FormFieldController.class);
static Logger logger =LoggerFactory.getLogger(FormFieldController.class);
@Autowired
private FormFieldService formFieldService;
@ -62,17 +57,16 @@ public class FormFieldController {
@Autowired
FormFieldCacheService formFieldCacheService;
@ApiOperation( value = "查询form_field信息列表",notes="listFormField,条件之间是 and关系,模糊查询写法如 {studentName:'%才哥%'}")
@ApiOperation( value = "表单字段定义-查询列表",notes=" ")
@ApiEntityParams(FormField.class)
@ApiResponses({
@ApiResponse(code = 200,response= FormField.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'错误码'},pageInfo:{total:总记录数},data:[数据对象1,数据对象2,...]}")
@ApiResponse(code = 200,response=FormField.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'错误码'},total:总记录数,data:[数据对象1,数据对象2,...]}")
})
@RequestMapping(value="/list",method=RequestMethod.GET)
public Map<String,Object> listFormField(@Ignore @RequestParam Map<String,Object> formField){
Map<String,Object> m = new HashMap<>();
String formId=(String) formField.get("formId");
public Result listFormField(@ApiIgnore @RequestParam Map<String,Object> params){
try {
User user=LoginUtils.getCurrentUserInfo();
String formId=(String) params.get("formId");
if(!StringUtils.hasText(formId)){
return ResponseHelper.failed("formId-0","formId不能为空");
}
@ -90,119 +84,118 @@ public class FormFieldController {
formDefVo.setFormFields(formFields);
formFieldCacheService.putFormFields(formId, formDefVo);
}
m.put("data",formDefVo.getFormFields());
m.put("formDef",formDefVo.getFormDef());
Tips tips=new Tips("查询成功");
m.put("tips", tips);
return m;
return Result.ok("query-ok","查询成功").setData(formDefVo).setTotal(1).put("formDef",formDefVo.getFormDef());
}catch (BizException e) {
return Result.error(e);
}catch (Exception e) {
return Result.error(e);
}
}
/**
@ApiOperation( value = "新增一条form_field信息",notes="addFormField,主键如果为空，后台自动生成")
@ApiOperation( value = "表单字段定义-新增",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormField.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/add",method=RequestMethod.POST)
public Map<String,Object> addFormField(@RequestBody FormField formField) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功新增一条数据");
try{
if(StringUtils.isEmpty(formField.getId())) {
formField.setId(formFieldService.createKey("id"));
}else{
FormField formFieldQuery = new FormField(formField.getId());
if(formFieldService.countByWhere(formFieldQuery)>0){
tips.setFailureMsg("编号重复，请修改编号再提交");
m.put("tips", tips);
return m;
public Result addFormField(@RequestBody FormField formField) {
formFieldService.save(formField);
return Result.ok("add-ok","添加成功！");
}
}
formFieldService.insert(formField);
m.put("data",formField);
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
}
m.put("tips", tips);
return m;
}
*/
/**
@ApiOperation( value = "删除一条form_field信息",notes="delFormField,仅需要上传主键字段")
@ApiOperation( value = "表单字段定义-删除",notes=" ")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}}")
})
@RequestMapping(value="/del",method=RequestMethod.POST)
public Map<String,Object> delFormField(@RequestBody FormField formField){
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功删除一条数据");
try{
formFieldService.deleteByPk(formField);
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
}
m.put("tips", tips);
return m;
public Result delFormField(@RequestBody FormField formField){
formFieldService.removeById(formField);
return Result.ok("del-ok","删除成功！");
}
*/
/**
@ApiOperation( value = "根据主键修改一条form_field信息",notes="editFormField")
@ApiOperation( value = "表单字段定义-修改",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormField.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/edit",method=RequestMethod.POST)
public Map<String,Object> editFormField(@RequestBody FormField formField) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功更新一条数据");
public Result editFormField(@RequestBody FormField formField) {
formFieldService.updateById(formField);
return Result.ok("edit-ok","修改成功！");
}
@ApiOperation( value = "表单字段定义-批量修改某些字段",notes="")
@ApiEntityParams( value = FormField.class, props={ }, remark = "表单字段定义", paramType = "body" )
@ApiResponses({
@ApiResponse(code = 200,response=FormField.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/editSomeFields",method=RequestMethod.POST)
public Result editSomeFields( @ApiIgnore @RequestBody Map<String,Object> params) {
try{
formFieldService.updateByPk(formField);
m.put("data",formField);
User user= LoginUtils.getCurrentUserInfo();
formFieldService.editSomeFields(params);
return Result.ok("edit-ok","更新成功");
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
return Result.error(e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
return Result.error(e);
}
m.put("tips", tips);
return m;
}
*/
/***/
@ApiOperation( value = "根据主键列表批量删除form_field信息",notes="batchDelFormField,仅需要上传主键字段")
@ApiOperation( value = "表单字段定义-批量删除",notes=" ")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}")
})
@RequestMapping(value="/batchDel",method=RequestMethod.POST)
public Map<String,Object> batchDelFormField(@RequestBody List<FormField> formFields) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功删除"+formFields.size()+"条数据");
public Result batchDelFormField(@RequestBody List<FormField> formFields) {
User user= LoginUtils.getCurrentUserInfo();
try{
formFieldService.batchDelete(formFields);
if(formFields.size()<=0){
return Result.error("formField-batchDel-data-err-0","请上送待删除数据列表");
}
List<FormField> datasDb=formFieldService.listByIds(formFields.stream().map(i-> i.getId() ).collect(Collectors.toList()));
List<FormField> can=new ArrayList<>();
List<FormField> no=new ArrayList<>();
for (FormField data : datasDb) {
if(true){
can.add(data);
}else{
no.add(data);
}
}
List<String> msgs=new ArrayList<>();
if(can.size()>0){
formFieldService.removeByIds(can);
msgs.add(LangTips.transMsg("del-ok-num","成功删除%s条数据.",can.size()));
}
if(no.size()>0){
msgs.add(LangTips.transMsg("not-allow-del-num","以下%s条数据不能删除:【%s】",no.size(),no.stream().map(i-> i.getId() ).collect(Collectors.joining(","))));
}
if(can.size()>0){
return Result.ok(msgs.stream().collect(Collectors.joining()));
}else {
return Result.error(msgs.stream().collect(Collectors.joining()));
}
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
return Result.error(e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
return Result.error(e);
}
m.put("tips", tips);
return m;
}
@ApiOperation( value = "表单字段定义-根据主键查询一条数据",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormField.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/queryById",method=RequestMethod.GET)
public Result queryById(FormField formField) {
FormField data = (FormField) formFieldService.getById(formField);
return Result.ok().setData(data);
}
}

248
mdp-form/src/main/java/com/mdp/form/ctrl/FormQxController.java
View File

@ -1,18 +1,11 @@
package com.mdp.form.ctrl;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.stream.Collectors;
import com.mdp.form.entity.FormField;
import com.mdp.form.service.FormQxCacheService;
import com.mdp.form.service.FormQxService;
import com.mdp.swagger.ApiEntityParams;
import jdk.nashorn.internal.ir.annotations.Ignore;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestBody;
@ -20,69 +13,67 @@ 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.RestController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
import com.mdp.mybatis.PageUtils;
import com.mdp.core.utils.RequestUtils;
import io.swagger.annotations.*;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.mdp.core.entity.Result;
import com.mdp.core.query.QueryTools;
import static com.mdp.core.utils.BaseUtils.*;
import com.mdp.core.entity.Tips;
import com.mdp.core.entity.LangTips;
import com.mdp.core.err.BizException;
import com.mdp.core.utils.RequestUtils;
import com.mdp.core.utils.NumberUtil;
import com.mdp.safe.client.entity.User;
import com.mdp.safe.client.utils.LoginUtils;
import com.mdp.swagger.ApiEntityParams;
import io.swagger.annotations.*;
import springfox.documentation.annotations.ApiIgnore;
import javax.servlet.http.HttpServletRequest;
import com.mdp.form.service.FormQxService;
import com.mdp.form.entity.FormQx;
/**
* url编制采用rest风格,如对FORM.form_qx form_qx的操作有增删改查,对应的url分别为:<br>
* 新增: form/formQx/add <br>
* 查询: form/formQx/list<br>
* 模糊查询: form/formQx/listKey<br>
* 修改: form/formQx/edit <br>
* 删除: form/formQx/del<br>
* 批量删除: form/formQx/batchDel<br>
* 组织 com.qqkj 顶级模块 mdp 大模块 form 小模块 <br>
* 实体 FormQx 表 FORM.form_qx 当前主键(包括多主键): form_id;
***/
@RestController("mdp.form.formQxController")
@RestController
@RequestMapping(value="/**/form/formQx")
@Api(tags={"form_qx操作接口"})
@Api(tags={"表单权限-操作接口"})
public class FormQxController {
static Log logger=LogFactory.getLog(FormQxController.class);
static Logger logger =LoggerFactory.getLogger(FormQxController.class);
@Autowired
private FormQxService formQxService;
@Autowired
FormQxCacheService formQxCacheService;
@ApiOperation( value = "查询form_qx信息列表",notes="listFormQx,条件之间是 and关系,模糊查询写法如 {studentName:'%才哥%'}")
@ApiOperation( value = "表单权限-查询列表",notes=" ")
@ApiEntityParams(FormQx.class)
@ApiResponses({
@ApiResponse(code = 200,response=FormQx.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'错误码'},pageInfo:{total:总记录数},data:[数据对象1,数据对象2,...]}")
@ApiResponse(code = 200,response=FormQx.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'错误码'},total:总记录数,data:[数据对象1,数据对象2,...]}")
})
@RequestMapping(value="/list",method=RequestMethod.GET)
public Map<String,Object> listFormQx(@Ignore @RequestParam Map<String,Object> formQx){
Map<String,Object> m = new HashMap<>();
RequestUtils.transformArray(formQx, "formIds");
PageUtils.startPage(formQx);
List<FormQx> formQxList=new ArrayList<>();
if(formQx.containsKey("formId")) {
String formId=(String) formQx.get("formId");
public Result listFormQx(@ApiIgnore @RequestParam Map<String,Object> params){
try {
User user=LoginUtils.getCurrentUserInfo();
List<FormQx> datas=new ArrayList<>();
if(params.containsKey("formId")) {
String formId=(String) params.get("formId");
FormQx formQxObject=this.formQxCacheService.getFormQx(formId);
if(formQxObject==null) {
FormQx formQxObjectQuery=new FormQx();
formQxObjectQuery.setFormId(formId);
formQxObject= formQxService.selectOneObject(formQxObjectQuery); //列出FormQx列表
formQxCacheService.putFormQx(formId, formQxObject);
formQxList.add(formQxObject);
datas.add(formQxObject);
}
}else if(formQx.containsKey("formIds")){
String[] formIds=(String[]) formQx.get("formIds");
}else if(params.containsKey("formIds")){
String[] formIds=(String[]) params.get("formIds");
for (String formId : formIds) {
FormQx formQxObject=this.formQxCacheService.getFormQx(formId);
if(formQxObject==null) {
@ -90,125 +81,136 @@ public class FormQxController {
formQxObjectQuery.setFormId(formId);
formQxObject= formQxService.selectOneObject(formQxObjectQuery); //列出FormQx列表
formQxCacheService.putFormQx(formId, formQxObject);
formQxList.add(formQxObject);
datas.add(formQxObject);
}
}
}
PageUtils.responePage(m, formQxList);
m.put("data",formQxList);
Tips tips=new Tips("查询成功");
m.put("tips", tips);
return m;
return Result.ok("query-ok","查询成功").setData(datas).setTotal(datas.size());
}catch (BizException e) {
return Result.error(e);
}catch (Exception e) {
return Result.error(e);
}
}
@ApiOperation( value = "新增一条form_qx信息",notes="addFormQx,主键如果为空，后台自动生成")
@ApiOperation( value = "表单权限-新增",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormQx.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/add",method=RequestMethod.POST)
public Map<String,Object> addFormQx(@RequestBody FormQx formQx) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功新增一条数据");
try{
public Result addFormQx(@RequestBody FormQx formQx) {
if(StringUtils.isEmpty(formQx.getFormId())) {
formQx.setFormId(formQxService.createKey("formId"));
}else{
FormQx formQxQuery = new FormQx(formQx.getFormId());
if(formQxService.countByWhere(formQxQuery)>0){
tips.setFailureMsg("编号重复，请修改编号再提交");
m.put("tips", tips);
return m;
return Result.error("id-exists","编号重复");
}
}
formQxService.insert(formQx);
formQxCacheService.putFormQx(formQx.getFormId(), formQx);
m.put("data",formQx);
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
}
m.put("tips", tips);
return m;
formQxService.save(formQx);
return Result.ok("add-ok","添加成功！");
}
/**
@ApiOperation( value = "删除一条form_qx信息",notes="delFormQx,仅需要上传主键字段")
@ApiOperation( value = "表单权限-删除",notes=" ")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}}")
})
@RequestMapping(value="/del",method=RequestMethod.POST)
public Map<String,Object> delFormQx(@RequestBody FormQx formQx){
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功删除一条数据");
try{
formQxService.deleteByPk(formQx);
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
}
m.put("tips", tips);
return m;
public Result delFormQx(@RequestBody FormQx formQx){
formQxService.removeById(formQx);
return Result.ok("del-ok","删除成功！");
}
*/
@ApiOperation( value = "根据主键修改一条form_qx信息",notes="editFormQx")
@ApiOperation( value = "表单权限-修改",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormQx.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/edit",method=RequestMethod.POST)
public Map<String,Object> editFormQx(@RequestBody FormQx formQx) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功更新一条数据");
try{
formQxService.updateByPk(formQx);
public Result editFormQx(@RequestBody FormQx formQx) {
formQxService.updateById(formQx);
formQxCacheService.putFormQx(formQx.getFormId(), formQx);
m.put("data",formQx);
return Result.ok("edit-ok","修改成功！");
}
@ApiOperation( value = "表单权限-批量修改某些字段",notes="")
@ApiEntityParams( value = FormQx.class, props={ }, remark = "表单权限", paramType = "body" )
@ApiResponses({
@ApiResponse(code = 200,response=FormQx.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/editSomeFields",method=RequestMethod.POST)
public Result editSomeFields( @ApiIgnore @RequestBody Map<String,Object> params) {
try{
User user= LoginUtils.getCurrentUserInfo();
formQxService.editSomeFields(params);
return Result.ok("edit-ok","更新成功");
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
return Result.error(e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
return Result.error(e);
}
m.put("tips", tips);
return m;
}
/**
@ApiOperation( value = "根据主键列表批量删除form_qx信息",notes="batchDelFormQx,仅需要上传主键字段")
@ApiOperation( value = "表单权限-批量删除",notes=" ")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}")
})
@RequestMapping(value="/batchDel",method=RequestMethod.POST)
public Map<String,Object> batchDelFormQx(@RequestBody List<FormQx> formQxs) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功删除"+formQxs.size()+"条数据");
public Result batchDelFormQx(@RequestBody List<FormQx> formQxs) {
User user= LoginUtils.getCurrentUserInfo();
try{
formQxService.batchDelete(formQxs);
if(formQxs.size()<=0){
return Result.error("formQx-batchDel-data-err-0","请上送待删除数据列表");
}
List<FormQx> datasDb=formQxService.listByIds(formQxs.stream().map(i-> i.getFormId() ).collect(Collectors.toList()));
List<FormQx> can=new ArrayList<>();
List<FormQx> no=new ArrayList<>();
for (FormQx data : datasDb) {
if(true){
can.add(data);
}else{
no.add(data);
}
}
List<String> msgs=new ArrayList<>();
if(can.size()>0){
formQxService.removeByIds(can);
msgs.add(LangTips.transMsg("del-ok-num","成功删除%s条数据.",can.size()));
}
if(no.size()>0){
msgs.add(LangTips.transMsg("not-allow-del-num","以下%s条数据不能删除:【%s】",no.size(),no.stream().map(i-> i.getFormId() ).collect(Collectors.joining(","))));
}
if(can.size()>0){
return Result.ok(msgs.stream().collect(Collectors.joining()));
}else {
return Result.error(msgs.stream().collect(Collectors.joining()));
}
}catch (BizException e) {
tips=e.getTips();
logger.error("",e);
return Result.error(e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("",e);
return Result.error(e);
}
m.put("tips", tips);
return m;
}
@ApiOperation( value = "表单权限-根据主键查询一条数据",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormQx.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/queryById",method=RequestMethod.GET)
public Result queryById(FormQx formQx) {
FormQx data = (FormQx) formQxService.getById(formQx);
return Result.ok().setData(data);
}
*/
}

269
mdp-form/src/main/java/com/mdp/form/ctrl/FormViewController.java
View File

@ -1,171 +1,174 @@
package com.mdp.form.ctrl;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.mdp.form.service.FormViewService;
import jdk.nashorn.internal.ir.annotations.Ignore;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.util.*;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
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.RestController;
import io.swagger.annotations.*;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.mdp.core.entity.Result;
import com.mdp.core.query.QueryTools;
import static com.mdp.core.utils.BaseUtils.*;
import com.mdp.core.entity.Tips;
import com.mdp.core.service.SequenceService;
import com.mdp.mybatis.PageUtils;
/**
* url编制采用rest风格,如对FORM.form_view的操作有增删改查,对应的url分别为:<br>
* 新增: form/formView/add <br>
* 查询: form/formView/list<br>
* 模糊查询: form/formView/listKey<br>
* 修改: form/formView/edit <br>
* 删除: form/formView/del<br>
* 批量删除: form/formView/batchDel<br>
* 组织 com.qqkj 顶级模块 mdp 大模块 form 小模块 <br>
* 实体 FormView 表 FORM.form_view 当前主键(包括多主键): id;
***/
@RestController("mdp.form.formViewController")
import com.mdp.core.entity.LangTips;
import com.mdp.core.err.BizException;
import com.mdp.core.utils.RequestUtils;
import com.mdp.core.utils.NumberUtil;
import com.mdp.safe.client.entity.User;
import com.mdp.safe.client.utils.LoginUtils;
import com.mdp.swagger.ApiEntityParams;
import io.swagger.annotations.*;
import springfox.documentation.annotations.ApiIgnore;
import javax.servlet.http.HttpServletRequest;
import com.mdp.form.service.FormViewService;
import com.mdp.form.entity.FormView;
@RestController
@RequestMapping(value="/**/form/formView")
@Api(tags={"表单页面-操作接口"})
public class FormViewController {
static Log logger=LogFactory.getLog(FormViewController.class);
static Logger logger =LoggerFactory.getLogger(FormViewController.class);
@Autowired
private FormViewService formViewService;
@Autowired
private SequenceService seqService;
/**
* 请求,如list
* 分页参数 {currentPage:1,pageSize:10,total:0}
* 根据条件查询数据对象列表,如果不上传分页参数，将不会分页。后台自动分页，无需编程
*/
@RequestMapping(value="/list")
public Map<String,Object> listFormView(@Ignore @RequestParam Map<String,Object> formView){
Map<String,Object> m = new HashMap<>();
PageUtils.startPage(formView);
List<Map<String,Object>> formViewList = formViewService.selectListMapByWhere(formView); //列出FormView列表
m.put("data",formViewList);
PageUtils.responePage(m, formViewList);
Tips tips=new Tips("查询成功");
m.put("tips", tips);
return m;
}
/**
* 请求模糊查询、条件字段由上传的参数决定 ,如{字段1:v1,字段2:v1},代表字段1，字段2都以v1作为参数值进行模糊查询，两个条件是or的关系。需要驼峰命名字段名
* 根据条件查询数据对象列表
@RequestMapping(value="/listKey")
public Map<String,Object> listFormViewKey( @RequestParam Map<String,Object> formView){
Map<String,Object> m = new HashMap<>();
List<Map<String,Object>> formViewList = formViewService.selectListMapByKey(formView); //列出FormView列表
m.put("data",formViewList);
Tips tips=new Tips("查询成功");
m.put("tips", tips);
setPageInfo(m);
return m;
}
*/
/**
* 新增一条数据
@RequestMapping(value="/add")
public Map<String,Object> addFormView(@RequestBody FormView formView) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功新增一条数据");
@ApiOperation( value = "表单页面-查询列表",notes=" ")
@ApiEntityParams(FormView.class)
@ApiResponses({
@ApiResponse(code = 200,response=FormView.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'错误码'},total:总记录数,data:[数据对象1,数据对象2,...]}")
})
@RequestMapping(value="/list",method=RequestMethod.GET)
public Result listFormView(@ApiIgnore @RequestParam Map<String,Object> params){
try {
formView.setId(seqService.getTablePK("formView", "id"));
formViewService.insert(formView);
m.put("data",formView);
User user=LoginUtils.getCurrentUserInfo();
QueryWrapper<FormView> qw = QueryTools.initQueryWrapper(FormView.class , params);
IPage page=QueryTools.initPage(params);
List<Map<String,Object>> datas = formViewService.selectListMapByWhere(page,qw,params);
return Result.ok("query-ok","查询成功").setData(datas).setTotal(page.getTotal());
}catch (BizException e) {
tips=e.getTips();
logger.error("执行异常",e);
return Result.error(e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("执行异常",e);
return Result.error(e);
}
m.put("tips", tips);
return m;
}
*/
/**
* 根据主键删除1条数据
@RequestMapping(value="/del")
public Map<String,Object> delFormView(@RequestBody FormView formView){
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功删除一条数据");
try{
formViewService.deleteByPk(formView);
}catch (BizException e) {
tips=e.getTips();
logger.error("执行异常",e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("执行异常",e);
@ApiOperation( value = "表单页面-新增",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormView.class,message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/add",method=RequestMethod.POST)
public Result addFormView(@RequestBody FormView formView) {
formViewService.save(formView);
return Result.ok("add-ok","添加成功！");
}
m.put("tips", tips);
return m;
@ApiOperation( value = "表单页面-删除",notes=" ")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}}")
})
@RequestMapping(value="/del",method=RequestMethod.POST)
public Result delFormView(@RequestBody FormView formView){
formViewService.removeById(formView);
return Result.ok("del-ok","删除成功！");
}
*/
/**
* 根据主键修改一条数据
@ApiOperation( value = "表单页面-修改",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormView.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/edit",method=RequestMethod.POST)
public Result editFormView(@RequestBody FormView formView) {
formViewService.updateById(formView);
return Result.ok("edit-ok","修改成功！");
}
@RequestMapping(value="/edit")
public Map<String,Object> editFormView(@RequestBody FormView formView) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功更新一条数据");
@ApiOperation( value = "表单页面-批量修改某些字段",notes="")
@ApiEntityParams( value = FormView.class, props={ }, remark = "表单页面", paramType = "body" )
@ApiResponses({
@ApiResponse(code = 200,response=FormView.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/editSomeFields",method=RequestMethod.POST)
public Result editSomeFields( @ApiIgnore @RequestBody Map<String,Object> params) {
try{
formViewService.updateByPk(formView);
m.put("data",formView);
User user= LoginUtils.getCurrentUserInfo();
formViewService.editSomeFields(params);
return Result.ok("edit-ok","更新成功");
}catch (BizException e) {
tips=e.getTips();
logger.error("执行异常",e);
logger.error("",e);
return Result.error(e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("执行异常",e);
logger.error("",e);
return Result.error(e);
}
m.put("tips", tips);
return m;
}
*/
/**
* 批量删除
@RequestMapping(value="/batchDel")
public Map<String,Object> batchDelFormView(@RequestBody String[] ids) {
Map<String,Object> m = new HashMap<>();
Tips tips=new Tips("成功删除"+ids.length+"条数据");
List<FormView> list=new ArrayList<FormView>();
@ApiOperation( value = "表单页面-批量删除",notes=" ")
@ApiResponses({
@ApiResponse(code = 200, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'}")
})
@RequestMapping(value="/batchDel",method=RequestMethod.POST)
public Result batchDelFormView(@RequestBody List<FormView> formViews) {
User user= LoginUtils.getCurrentUserInfo();
try{
for(int i=0;i<ids.length;i++){
FormView formView=new FormView();
formView.setId(ids[i]);
list.add(formView);
if(formViews.size()<=0){
return Result.error("formView-batchDel-data-err-0","请上送待删除数据列表");
}
List<FormView> datasDb=formViewService.listByIds(formViews.stream().map(i-> i.getId() ).collect(Collectors.toList()));
List<FormView> can=new ArrayList<>();
List<FormView> no=new ArrayList<>();
for (FormView data : datasDb) {
if(true){
can.add(data);
}else{
no.add(data);
}
}
List<String> msgs=new ArrayList<>();
if(can.size()>0){
formViewService.removeByIds(can);
msgs.add(LangTips.transMsg("del-ok-num","成功删除%s条数据.",can.size()));
}
if(no.size()>0){
msgs.add(LangTips.transMsg("not-allow-del-num","以下%s条数据不能删除:【%s】",no.size(),no.stream().map(i-> i.getId() ).collect(Collectors.joining(","))));
}
if(can.size()>0){
return Result.ok(msgs.stream().collect(Collectors.joining()));
}else {
return Result.error(msgs.stream().collect(Collectors.joining()));
}
formViewService.batchDelete(list);
}catch (BizException e) {
tips=e.getTips();
logger.error("执行异常",e);
return Result.error(e);
}catch (Exception e) {
tips.setFailureMsg(e.getMessage());
logger.error("执行异常",e);
return Result.error(e);
}
}
m.put("tips", tips);
return m;
@ApiOperation( value = "表单页面-根据主键查询一条数据",notes=" ")
@ApiResponses({
@ApiResponse(code = 200,response=FormView.class, message = "{tips:{isOk:true/false,msg:'成功/失败原因',tipscode:'失败时错误码'},data:数据对象}")
})
@RequestMapping(value="/queryById",method=RequestMethod.GET)
public Result queryById(FormView formView) {
FormView data = (FormView) formViewService.getById(formView);
return Result.ok().setData(data);
}
*/
}
Write Preview
Loading…
Cancel
Save