opensource/RuoYi-Vue-Plus
2
0
Fork 1
mirror of https://gitee.com/dromara/RuoYi-Vue-Plus.git synced 2026-09-20 18:15:56 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

remove 移除动态表单

Browse Source
This commit is contained in:
songgaoshuai 2023-11-30 12:36:47 +08:00
parent e2ca080aea
commit 7fb78785ec
21 changed files with 0 additions and 1421 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

107
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/controller/WfBusinessFormController.java
View File

@ -1,107 +0,0 @@
package org.dromara.workflow.controller;
import cn.dev33.satoken.annotation.SaCheckPermission;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.RequiredArgsConstructor;
import org.dromara.common.core.domain.R;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.excel.utils.ExcelUtil;
import org.dromara.common.idempotent.annotation.RepeatSubmit;
import org.dromara.common.log.annotation.Log;
import org.dromara.common.log.enums.BusinessType;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.common.web.core.BaseController;
import org.dromara.workflow.domain.WfBusinessForm;
import org.dromara.workflow.domain.bo.WfBusinessFormBo;
import org.dromara.workflow.domain.vo.WfBusinessFormVo;
import org.dromara.workflow.service.IWfBusinessFormService;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 发起流程
*
* @author may
* @date 2023-09-16
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/workflow/businessForm")
public class WfBusinessFormController extends BaseController {
private final IWfBusinessFormService wfBusinessFormService;
/**
* 查询发起流程列表
*/
@SaCheckPermission("workflow:businessForm:list")
@GetMapping("/list")
public TableDataInfo<WfBusinessFormVo> list(WfBusinessFormBo bo, PageQuery pageQuery) {
return wfBusinessFormService.queryPageList(bo, pageQuery);
}
/**
* 导出发起流程列表
*/
@SaCheckPermission("workflow:businessForm:export")
@Log(title = "发起流程", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(WfBusinessFormBo bo, HttpServletResponse response) {
List<WfBusinessFormVo> list = wfBusinessFormService.queryList(bo);
ExcelUtil.exportExcel(list, "发起流程", WfBusinessFormVo.class, response);
}
/**
* 获取发起流程详细信息
*
* @param id 主键
*/
@SaCheckPermission("workflow:businessForm:query")
@GetMapping("/{id}")
public R<WfBusinessFormVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(wfBusinessFormService.queryById(id));
}
/**
* 新增发起流程
*/
@SaCheckPermission("workflow:businessForm:add")
@Log(title = "发起流程", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<WfBusinessForm> add(@Validated(AddGroup.class) @RequestBody WfBusinessFormBo bo) {
return R.ok(wfBusinessFormService.insertByBo(bo));
}
/**
* 修改发起流程
*/
@SaCheckPermission("workflow:businessForm:edit")
@Log(title = "发起流程", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<WfBusinessForm> edit(@Validated(EditGroup.class) @RequestBody WfBusinessFormBo bo) {
return R.ok(wfBusinessFormService.updateByBo(bo));
}
/**
* 删除发起流程
*
* @param ids 主键串
*/
@SaCheckPermission("workflow:businessForm:remove")
@Log(title = "发起流程", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(wfBusinessFormService.deleteWithValidByIds(List.of(ids)));
}
}

110
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/controller/WfFormController.java
View File

@ -1,110 +0,0 @@
package org.dromara.workflow.controller;
import cn.dev33.satoken.annotation.SaCheckPermission;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.RequiredArgsConstructor;
import org.dromara.common.core.domain.R;
import org.dromara.common.core.enums.UserStatus;
import org.dromara.common.core.validate.QueryGroup;
import org.dromara.common.excel.utils.ExcelUtil;
import org.dromara.common.log.annotation.Log;
import org.dromara.common.log.enums.BusinessType;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.common.web.core.BaseController;
import org.dromara.workflow.domain.bo.WfFormBo;
import org.dromara.workflow.domain.vo.WfFormVo;
import org.dromara.workflow.service.IWfFormService;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.Arrays;
import java.util.List;
/**
* 流程表单Controller
*
* @author KonBAI
*/
@RequiredArgsConstructor
@RestController
@RequestMapping("/workflow/form")
public class WfFormController extends BaseController {
private final IWfFormService formService;
/**
* 查询流程表单列表
*/
@SaCheckPermission("workflow:form:list")
@GetMapping("/list")
public TableDataInfo<WfFormVo> list(@Validated(QueryGroup.class) WfFormBo bo, PageQuery pageQuery) {
return formService.queryPageList(bo, pageQuery);
}
/**
* 查询流程表单列表
*/
@SaCheckPermission("workflow:form:list")
@GetMapping("/queryList")
public R<List<WfFormVo>> queryList(WfFormBo bo) {
bo.setStatus(UserStatus.OK.getCode());
return R.ok(formService.queryList(bo));
}
/**
* 导出流程表单列表
*/
@SaCheckPermission("workflow:form:export")
@Log(title = "流程表单", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(@Validated WfFormBo bo, HttpServletResponse response) {
List<WfFormVo> list = formService.queryList(bo);
ExcelUtil.exportExcel(list, "流程表单", WfFormVo.class, response);
}
/**
* 获取流程表单详细信息
*
* @param formId 主键
*/
@SaCheckPermission("workflow:form:query")
@GetMapping(value = "/{formId}")
public R<WfFormVo> getInfo(@NotNull(message = "主键不能为空") @PathVariable("formId") Long formId) {
return R.ok(formService.queryById(formId));
}
/**
* 新增流程表单
*/
@SaCheckPermission("workflow:form:add")
@Log(title = "流程表单", businessType = BusinessType.INSERT)
@PostMapping
public R<Void> add(@RequestBody WfFormBo bo) {
return toAjax(formService.insertForm(bo));
}
/**
* 修改流程表单
*/
@SaCheckPermission("workflow:form:edit")
@Log(title = "流程表单", businessType = BusinessType.UPDATE)
@PutMapping
public R<Void> edit(@RequestBody WfFormBo bo) {
return toAjax(formService.updateForm(bo));
}
/**
* 删除流程表单
*
* @param formIds 主键串
*/
@SaCheckPermission("workflow:form:remove")
@Log(title = "流程表单", businessType = BusinessType.DELETE)
@DeleteMapping("/{formIds}")
public R<Void> remove(@NotEmpty(message = "主键不能为空") @PathVariable Long[] formIds) {
return toAjax(formService.deleteWithValidByIds(Arrays.asList(formIds)));
}
}

42
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/controller/WfFormDefinitionController.java
View File

@ -1,42 +0,0 @@
package org.dromara.workflow.controller;
import lombok.RequiredArgsConstructor;
import org.dromara.common.core.domain.R;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.idempotent.annotation.RepeatSubmit;
import org.dromara.common.log.annotation.Log;
import org.dromara.common.log.enums.BusinessType;
import org.dromara.common.web.core.BaseController;
import org.dromara.workflow.domain.bo.WfFormDefinitionBo;
import org.dromara.workflow.service.IWfFormDefinitionService;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 动态单与流程定义关联信息
*
* @author may
* @date 2023-08-31
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/workflow/formDefinition")
public class WfFormDefinitionController extends BaseController {
private final IWfFormDefinitionService wfFormDefinitionService;
/**
* 新增动态单与流程定义关联信息
*/
@Log(title = "动态单与流程定义关联信息", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody WfFormDefinitionBo bo) {
return toAjax(wfFormDefinitionService.insertByBo(bo));
}
}

66
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/domain/WfBusinessForm.java
View File

@ -1,66 +0,0 @@
package org.dromara.workflow.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.tenant.core.TenantEntity;
import java.io.Serial;
import java.util.Map;
/**
* 发起流程对象 wf_business_form
*
* @author may
* @date 2023-09-16
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("wf_business_form")
public class WfBusinessForm extends TenantEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键
*/
@TableId(value = "id")
private Long id;
/**
* 申请编码
*/
private String applyCode;
/**
* 表单id
*/
private Long formId;
/**
* 表单名称
*/
private String formName;
/**
* 表单内容
*/
private String content;
/**
* 表单值
*/
private String contentValue;
/**
* 流程变量
*/
@JsonInclude(JsonInclude.Include.NON_EMPTY)
@TableField(exist = false)
private Map<String, Object> variable;
}

49
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/domain/WfForm.java
View File

@ -1,49 +0,0 @@
package org.dromara.workflow.domain;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.tenant.core.TenantEntity;
import java.io.Serial;
/**
* 流程表单对象 wf_form
*
* @author KonBAI
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("wf_form")
public class WfForm extends TenantEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 表单主键
*/
@TableId(value = "form_id")
private Long formId;
/**
* 表单名称
*/
private String formName;
/**
* 表单内容
*/
private String content;
/**
* 状态（0正常 1停用）
*/
private String status;
/**
* 备注
*/
private String remark;
}

57
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/domain/WfFormDefinition.java
View File

@ -1,57 +0,0 @@
package org.dromara.workflow.domain;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.tenant.core.TenantEntity;
import java.io.Serial;
/**
* 动态单与流程定义关联信息对象 wf_form_definition
*
* @author may
* @date 2023-08-31
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("wf_form_definition")
public class WfFormDefinition extends TenantEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键
*/
@TableId(value = "id")
private Long id;
/**
* 动态表单id
*/
private Long formId;
/**
* 流程定义key
*/
private String processDefinitionKey;
/**
* 流程定义名称
*/
private String processDefinitionName;
/**
* 流程定义id
*/
private String processDefinitionId;
/**
* 流程定义版本
*/
private Long processDefinitionVersion;
}

59
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/domain/bo/WfBusinessFormBo.java
View File

@ -1,59 +0,0 @@
package org.dromara.workflow.domain.bo;
import io.github.linpeilie.annotations.AutoMapper;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import org.dromara.workflow.domain.WfBusinessForm;
/**
* 发起流程业务对象 wf_business_form
*
* @author may
* @date 2023-09-16
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = WfBusinessForm.class, reverseConvertGenerate = false)
public class WfBusinessFormBo extends BaseEntity {
/**
* 主键
*/
@NotNull(message = "主键不能为空", groups = {EditGroup.class})
private Long id;
/**
* 申请编码
*/
private String applyCode;
/**
* 表单id
*/
@NotNull(message = "表单id不能为空", groups = {AddGroup.class, EditGroup.class})
private Long formId;
/**
* 表单名称
*/
@NotBlank(message = "表单名称不能为空", groups = {AddGroup.class, EditGroup.class})
private String formName;
/**
* 表单内容
*/
@NotBlank(message = "表单内容不能为空", groups = {AddGroup.class, EditGroup.class})
private String content;
/**
* 表单值
*/
private String contentValue;
}

67
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/domain/bo/WfFormBo.java
View File

@ -1,67 +0,0 @@
package org.dromara.workflow.domain.bo;
import io.github.linpeilie.annotations.AutoMapper;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import org.dromara.workflow.domain.WfForm;
import java.io.Serial;
/**
* 流程表单业务对象
*
* @author KonBAI
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = WfForm.class, reverseConvertGenerate = false)
public class WfFormBo extends BaseEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 表单主键
*/
@NotNull(message = "表单ID不能为空", groups = {EditGroup.class})
private Long formId;
/**
* 表单名称
*/
@NotBlank(message = "表单名称不能为空", groups = {AddGroup.class, EditGroup.class})
private String formName;
/**
* 表单配置
*/
@NotBlank(message = "表单配置不能为空", groups = {AddGroup.class, EditGroup.class})
private String formConfig;
/**
* 表单内容
*/
@NotBlank(message = "表单内容不能为空", groups = {AddGroup.class, EditGroup.class})
private String content;
/**
* 状态（0正常 1停用）
*/
@NotBlank(message = "状态不能为空", groups = {AddGroup.class, EditGroup.class})
private String status;
/**
* 备注
*/
private String remark;
/**
* 动态单与流程定义关联信息业务对象
*/
private WfFormDefinitionBo wfFormDefinitionBo;
}

61
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/domain/bo/WfFormDefinitionBo.java
View File

@ -1,61 +0,0 @@
package org.dromara.workflow.domain.bo;
import io.github.linpeilie.annotations.AutoMapper;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
import org.dromara.common.mybatis.core.domain.BaseEntity;
import org.dromara.workflow.domain.WfFormDefinition;
/**
* 动态单与流程定义关联信息业务对象 wf_form_definition
*
* @author may
* @date 2023-08-31
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = WfFormDefinition.class, reverseConvertGenerate = false)
public class WfFormDefinitionBo extends BaseEntity {
/**
* 主键
*/
@NotNull(message = "主键不能为空", groups = {EditGroup.class})
private Long id;
/**
* 动态表单id
*/
@NotNull(message = "动态表单id不能为空", groups = {AddGroup.class, EditGroup.class})
private Long formId;
/**
* 流程定义id
*/
@NotBlank(message = "流程定义key不能为空", groups = {AddGroup.class, EditGroup.class})
private String processDefinitionKey;
/**
* 流程定义名称
*/
@NotBlank(message = "流程定义名称不能为空", groups = {AddGroup.class, EditGroup.class})
private String processDefinitionName;
/**
* 流程定义id
*/
@NotBlank(message = "流程定义id不能为空", groups = {AddGroup.class, EditGroup.class})
private String processDefinitionId;
/**
* 流程定义版本
*/
@NotNull(message = "流程定义版本不能为空", groups = {AddGroup.class, EditGroup.class})
private Long processDefinitionVersion;
}

73
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/domain/vo/WfBusinessFormVo.java
View File

@ -1,73 +0,0 @@
package org.dromara.workflow.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import org.dromara.workflow.domain.WfBusinessForm;
import java.io.Serial;
import java.io.Serializable;
/**
* 发起流程视图对象 wf_business_form
*
* @author may
* @date 2023-09-16
*/
@Data
@ExcelIgnoreUnannotated
@AutoMapper(target = WfBusinessForm.class)
public class WfBusinessFormVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键
*/
@ExcelProperty(value = "主键")
private Long id;
/**
* 申请编码
*/
@ExcelProperty(value = "申请编码")
private String applyCode;
/**
* 表单id
*/
@ExcelProperty(value = "表单id")
private Long formId;
/**
* 表单名称
*/
@ExcelProperty(value = "表单名称")
private String formName;
/**
* 表单内容
*/
@ExcelProperty(value = "表单内容")
private String content;
/**
* 表单值
*/
@ExcelProperty(value = "表单值")
private String contentValue;
/**
* 动态单与流程定义关联信息业务对象
*/
private WfFormDefinitionVo wfFormDefinitionVo;
/**
* 流程实例对象
*/
private ProcessInstanceVo processInstanceVo;
}

64
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/domain/vo/WfFormDefinitionVo.java
View File

@ -1,64 +0,0 @@
package org.dromara.workflow.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import org.dromara.workflow.domain.WfFormDefinition;
import java.io.Serial;
import java.io.Serializable;
/**
* 动态单与流程定义关联信息视图对象 wf_form_definition
*
* @author may
* @date 2023-08-31
*/
@Data
@ExcelIgnoreUnannotated
@AutoMapper(target = WfFormDefinition.class)
public class WfFormDefinitionVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键
*/
@ExcelProperty(value = "主键")
private Long id;
/**
* 动态表单id
*/
@ExcelProperty(value = "动态表单id")
private Long formId;
/**
* 流程定义id
*/
@ExcelProperty(value = "流程定义key")
private String processDefinitionKey;
/**
* 流程定义名称
*/
@ExcelProperty(value = "流程定义名称")
private String processDefinitionName;
/**
* 流程定义id
*/
@ExcelProperty(value = "流程定义id")
private String processDefinitionId;
/**
* 流程定义版本
*/
@ExcelProperty(value = "流程定义版本")
private Long processDefinitionVersion;
}

67
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/domain/vo/WfFormVo.java
View File

@ -1,67 +0,0 @@
package org.dromara.workflow.domain.vo;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import org.dromara.workflow.domain.WfForm;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
/**
* 流程分类视图对象
*
* @author KonBAI
*/
@Data
@AutoMapper(target = WfForm.class)
public class WfFormVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 表单主键
*/
private Long formId;
/**
* 表单名称
*/
private String formName;
/**
* 表单配置
*/
private String formConfig;
/**
* 表单内容
*/
private String content;
/**
* 状态（0正常 1停用）
*/
private String status;
/**
* 备注
*/
private String remark;
/**
* 创建时间
*/
private Date createTime;
/**
* 修改时间
*/
private Date updateTime;
/**
* 动态单与流程定义关联信息业务对象
*/
private WfFormDefinitionVo wfFormDefinitionVo;
}

15
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/mapper/WfBusinessFormMapper.java
View File

@ -1,15 +0,0 @@
package org.dromara.workflow.mapper;
import org.dromara.common.mybatis.core.mapper.BaseMapperPlus;
import org.dromara.workflow.domain.WfBusinessForm;
import org.dromara.workflow.domain.vo.WfBusinessFormVo;
/**
* 发起流程Mapper接口
*
* @author may
* @date 2023-09-16
*/
public interface WfBusinessFormMapper extends BaseMapperPlus<WfBusinessForm, WfBusinessFormVo> {
}

15
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/mapper/WfFormDefinitionMapper.java
View File

@ -1,15 +0,0 @@
package org.dromara.workflow.mapper;
import org.dromara.common.mybatis.core.mapper.BaseMapperPlus;
import org.dromara.workflow.domain.WfFormDefinition;
import org.dromara.workflow.domain.vo.WfFormDefinitionVo;
/**
* 动态单与流程定义关联信息Mapper接口
*
* @author may
* @date 2023-08-31
*/
public interface WfFormDefinitionMapper extends BaseMapperPlus<WfFormDefinition, WfFormDefinitionVo> {
}

13
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/mapper/WfFormMapper.java
View File

@ -1,13 +0,0 @@
package org.dromara.workflow.mapper;
import org.dromara.common.mybatis.core.mapper.BaseMapperPlus;
import org.dromara.workflow.domain.WfForm;
import org.dromara.workflow.domain.vo.WfFormVo;
/**
* 流程表单Mapper接口
*
* @author KonBAI
*/
public interface WfFormMapper extends BaseMapperPlus<WfForm, WfFormVo> {
}

49
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/service/IWfBusinessFormService.java
View File

@ -1,49 +0,0 @@
package org.dromara.workflow.service;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.workflow.domain.WfBusinessForm;
import org.dromara.workflow.domain.bo.WfBusinessFormBo;
import org.dromara.workflow.domain.vo.WfBusinessFormVo;
import java.util.Collection;
import java.util.List;
/**
* 发起流程Service接口
*
* @author may
* @date 2023-09-16
*/
public interface IWfBusinessFormService {
/**
* 查询发起流程
*/
WfBusinessFormVo queryById(Long id);
/**
* 查询发起流程列表
*/
TableDataInfo<WfBusinessFormVo> queryPageList(WfBusinessFormBo bo, PageQuery pageQuery);
/**
* 查询发起流程列表
*/
List<WfBusinessFormVo> queryList(WfBusinessFormBo bo);
/**
* 新增发起流程
*/
WfBusinessForm insertByBo(WfBusinessFormBo bo);
/**
* 修改发起流程
*/
WfBusinessForm updateByBo(WfBusinessFormBo bo);
/**
* 校验并批量删除发起流程信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids);
}

48
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/service/IWfFormDefinitionService.java
View File

@ -1,48 +0,0 @@
package org.dromara.workflow.service;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.workflow.domain.bo.WfFormDefinitionBo;
import org.dromara.workflow.domain.vo.WfFormDefinitionVo;
import java.util.Collection;
import java.util.List;
/**
* 动态单与流程定义关联信息Service接口
*
* @author may
* @date 2023-08-31
*/
public interface IWfFormDefinitionService {
/**
* 查询动态单与流程定义关联信息
*/
WfFormDefinitionVo queryById(Long id);
/**
* 查询动态单与流程定义关联信息列表
*/
TableDataInfo<WfFormDefinitionVo> queryPageList(WfFormDefinitionBo bo, PageQuery pageQuery);
/**
* 查询动态单与流程定义关联信息列表
*/
List<WfFormDefinitionVo> queryList(WfFormDefinitionBo bo);
/**
* 新增动态单与流程定义关联信息
*/
Boolean insertByBo(WfFormDefinitionBo bo);
/**
* 修改动态单与流程定义关联信息
*/
Boolean updateByBo(WfFormDefinitionBo bo);
/**
* 校验并批量删除动态单与流程定义关联信息信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

64
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/service/IWfFormService.java
View File

@ -1,64 +0,0 @@
package org.dromara.workflow.service;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.workflow.domain.bo.WfFormBo;
import org.dromara.workflow.domain.vo.WfFormVo;
import java.util.Collection;
import java.util.List;
/**
* 流程表单 服务层
*
* @author KonBAI
*/
public interface IWfFormService {
/**
* 查询流程表单
*
* @param formId 流程表单ID
* @return 流程表单
*/
WfFormVo queryById(Long formId);
/**
* 查询流程表单列表
*
* @param bo 流程表单
* @return 流程表单集合
*/
TableDataInfo<WfFormVo> queryPageList(WfFormBo bo, PageQuery pageQuery);
/**
* 查询流程表单列表
*
* @param bo 流程表单
* @return 流程表单集合
*/
List<WfFormVo> queryList(WfFormBo bo);
/**
* 新增流程表单
*
* @param bo 流程表单
* @return 结果
*/
int insertForm(WfFormBo bo);
/**
* 修改流程表单
*
* @param bo 流程表单
* @return 结果
*/
int updateForm(WfFormBo bo);
/**
* 批量删除流程表单
*
* @param formIds 需要删除的流程表单ID
* @return 结果
*/
Boolean deleteWithValidByIds(Collection<Long> formIds);
}

138
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/service/impl/WfBusinessFormServiceImpl.java
View File

@ -1,138 +0,0 @@
package org.dromara.workflow.service.impl;
import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.RequiredArgsConstructor;
import org.dromara.common.core.utils.DateUtils;
import org.dromara.common.core.utils.MapstructUtils;
import org.dromara.common.core.utils.StreamUtils;
import org.dromara.common.core.utils.StringUtils;
import org.dromara.common.json.utils.JsonUtils;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.workflow.domain.ActHiProcinst;
import org.dromara.workflow.domain.WfBusinessForm;
import org.dromara.workflow.domain.WfFormDefinition;
import org.dromara.workflow.domain.bo.WfBusinessFormBo;
import org.dromara.workflow.domain.vo.WfBusinessFormVo;
import org.dromara.workflow.domain.vo.WfFormDefinitionVo;
import org.dromara.workflow.mapper.WfBusinessFormMapper;
import org.dromara.workflow.mapper.WfFormDefinitionMapper;
import org.dromara.workflow.service.IActHiProcinstService;
import org.dromara.workflow.service.IActProcessInstanceService;
import org.dromara.workflow.service.IWfBusinessFormService;
import org.dromara.workflow.utils.WorkflowUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* 发起流程Service业务层处理
*
* @author may
* @date 2023-09-16
*/
@RequiredArgsConstructor
@Service
public class WfBusinessFormServiceImpl implements IWfBusinessFormService {
private final WfBusinessFormMapper baseMapper;
private final WfFormDefinitionMapper wfFormDefinitionMapper;
private final IActProcessInstanceService actProcessInstanceService;
private final IActHiProcinstService actHiProcinstService;
/**
* 查询发起流程
*/
@Override
public WfBusinessFormVo queryById(Long id) {
WfBusinessFormVo wfBusinessFormVo = baseMapper.selectVoById(id);
if (wfBusinessFormVo != null) {
WfFormDefinitionVo wfFormDefinitionVo = wfFormDefinitionMapper.selectVoOne(
new LambdaQueryWrapper<WfFormDefinition>().eq(WfFormDefinition::getFormId, wfBusinessFormVo.getFormId())
);
wfBusinessFormVo.setWfFormDefinitionVo(wfFormDefinitionVo);
}
return wfBusinessFormVo;
}
/**
* 查询发起流程列表
*/
@Override
public TableDataInfo<WfBusinessFormVo> queryPageList(WfBusinessFormBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<WfBusinessForm> lqw = buildQueryWrapper(bo);
Page<WfBusinessFormVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
List<WfBusinessFormVo> records = result.getRecords();
WorkflowUtils.setProcessInstanceListVo(records, StreamUtils.toList(records, e -> String.valueOf(e.getId())), "id");
return TableDataInfo.build(result);
}
/**
* 查询发起流程列表
*/
@Override
public List<WfBusinessFormVo> queryList(WfBusinessFormBo bo) {
LambdaQueryWrapper<WfBusinessForm> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<WfBusinessForm> buildQueryWrapper(WfBusinessFormBo bo) {
LambdaQueryWrapper<WfBusinessForm> lqw = Wrappers.lambdaQuery();
lqw.eq(StringUtils.isNotBlank(bo.getApplyCode()), WfBusinessForm::getApplyCode, bo.getApplyCode());
lqw.like(StringUtils.isNotBlank(bo.getFormName()), WfBusinessForm::getFormName, bo.getFormName());
return lqw;
}
/**
* 新增发起流程
*/
@Override
public WfBusinessForm insertByBo(WfBusinessFormBo bo) {
WfBusinessForm add = MapstructUtils.convert(bo, WfBusinessForm.class);
//规则自行修改
add.setApplyCode(DateUtils.dateTimeNow());
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
if (StringUtils.isNotBlank(add.getContentValue())) {
Map<String, Object> variable = JsonUtils.parseMap(add.getContentValue());
add.setVariable(variable);
}
return add;
}
/**
* 修改发起流程
*/
@Override
public WfBusinessForm updateByBo(WfBusinessFormBo bo) {
WfBusinessForm update = MapstructUtils.convert(bo, WfBusinessForm.class);
baseMapper.updateById(update);
if (StringUtils.isNotBlank(update.getContentValue())) {
Map<String, Object> variable = JsonUtils.parseMap(update.getContentValue());
update.setVariable(variable);
}
return update;
}
/**
* 批量删除发起流程
*/
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean deleteWithValidByIds(Collection<Long> ids) {
List<ActHiProcinst> actHiProcinsts = actHiProcinstService.selectByBusinessKeyIn(StreamUtils.toList(ids, String::valueOf));
if (CollUtil.isNotEmpty(actHiProcinsts)) {
actProcessInstanceService.deleteRuntimeProcessAndHisInst(actHiProcinsts.stream().map(ActHiProcinst::getId).collect(Collectors.toList()));
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

117
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/service/impl/WfFormDefinitionServiceImpl.java
View File

@ -1,117 +0,0 @@
package org.dromara.workflow.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.RequiredArgsConstructor;
import org.dromara.common.core.utils.MapstructUtils;
import org.dromara.common.core.utils.StringUtils;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.workflow.domain.WfFormDefinition;
import org.dromara.workflow.domain.bo.WfFormDefinitionBo;
import org.dromara.workflow.domain.vo.WfFormDefinitionVo;
import org.dromara.workflow.mapper.WfFormDefinitionMapper;
import org.dromara.workflow.service.IWfFormDefinitionService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
* 动态单与流程定义关联信息Service业务层处理
*
* @author may
* @date 2023-08-31
*/
@RequiredArgsConstructor
@Service
public class WfFormDefinitionServiceImpl implements IWfFormDefinitionService {
private final WfFormDefinitionMapper baseMapper;
/**
* 查询动态单与流程定义关联信息
*/
@Override
public WfFormDefinitionVo queryById(Long id) {
return baseMapper.selectVoById(id);
}
/**
* 查询动态单与流程定义关联信息列表
*/
@Override
public TableDataInfo<WfFormDefinitionVo> queryPageList(WfFormDefinitionBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<WfFormDefinition> lqw = buildQueryWrapper(bo);
Page<WfFormDefinitionVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询动态单与流程定义关联信息列表
*/
@Override
public List<WfFormDefinitionVo> queryList(WfFormDefinitionBo bo) {
LambdaQueryWrapper<WfFormDefinition> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<WfFormDefinition> buildQueryWrapper(WfFormDefinitionBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<WfFormDefinition> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getFormId() != null, WfFormDefinition::getFormId, bo.getFormId());
lqw.eq(StringUtils.isNotBlank(bo.getProcessDefinitionKey()), WfFormDefinition::getProcessDefinitionKey, bo.getProcessDefinitionKey());
lqw.like(StringUtils.isNotBlank(bo.getProcessDefinitionName()), WfFormDefinition::getProcessDefinitionName, bo.getProcessDefinitionName());
lqw.eq(StringUtils.isNotBlank(bo.getProcessDefinitionId()), WfFormDefinition::getProcessDefinitionId, bo.getProcessDefinitionId());
lqw.eq(bo.getProcessDefinitionVersion() != null, WfFormDefinition::getProcessDefinitionVersion, bo.getProcessDefinitionVersion());
return lqw;
}
/**
* 新增动态单与流程定义关联信息
*/
@Override
@Transactional(rollbackFor = Exception.class)
public Boolean insertByBo(WfFormDefinitionBo bo) {
WfFormDefinition add = MapstructUtils.convert(bo, WfFormDefinition.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改动态单与流程定义关联信息
*/
@Override
public Boolean updateByBo(WfFormDefinitionBo bo) {
WfFormDefinition update = MapstructUtils.convert(bo, WfFormDefinition.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(WfFormDefinition entity) {
LambdaQueryWrapper<WfFormDefinition> wrapper = Wrappers.lambdaQuery();
wrapper.eq(WfFormDefinition::getFormId, entity.getFormId());
baseMapper.delete(wrapper);
}
/**
* 批量删除动态单与流程定义关联信息
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if (isValid) {
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

140
ruoyi-modules/ruoyi-workflow/src/main/java/org/dromara/workflow/service/impl/WfFormServiceImpl.java
View File

@ -1,140 +0,0 @@
package org.dromara.workflow.service.impl;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.RequiredArgsConstructor;
import org.dromara.common.core.utils.MapstructUtils;
import org.dromara.common.core.utils.StreamUtils;
import org.dromara.common.core.utils.StringUtils;
import org.dromara.common.mybatis.core.page.PageQuery;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.workflow.domain.WfForm;
import org.dromara.workflow.domain.WfFormDefinition;
import org.dromara.workflow.domain.bo.WfFormBo;
import org.dromara.workflow.domain.vo.WfFormDefinitionVo;
import org.dromara.workflow.domain.vo.WfFormVo;
import org.dromara.workflow.mapper.WfFormDefinitionMapper;
import org.dromara.workflow.mapper.WfFormMapper;
import org.dromara.workflow.service.IWfFormService;
import org.springframework.stereotype.Service;
import java.util.Collection;
import java.util.List;
/**
* 流程表单Service业务层处理
*
* @author KonBAI
*/
@RequiredArgsConstructor
@Service
public class WfFormServiceImpl implements IWfFormService {
private final WfFormMapper baseMapper;
private final WfFormDefinitionMapper wfFormDefinitionMapper;
/**
* 查询流程表单
*
* @param formId 流程表单ID
* @return 流程表单
*/
@Override
public WfFormVo queryById(Long formId) {
WfFormVo wfFormVo = baseMapper.selectVoById(formId);
if (wfFormVo != null) {
WfFormDefinitionVo wfFormDefinitionVo = wfFormDefinitionMapper.selectVoOne(
new LambdaQueryWrapper<WfFormDefinition>().eq(WfFormDefinition::getFormId, wfFormVo.getFormId())
);
wfFormVo.setWfFormDefinitionVo(wfFormDefinitionVo);
}
return wfFormVo;
}
/**
* 查询流程表单列表
*
* @param bo 流程表单
* @return 流程表单
*/
@Override
public TableDataInfo<WfFormVo> queryPageList(WfFormBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<WfForm> lqw = buildQueryWrapper(bo);
Page<WfFormVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
List<WfFormVo> records = result.getRecords();
if (CollUtil.isNotEmpty(records)) {
List<Long> formIds = StreamUtils.toList(records, WfFormVo::getFormId);
List<WfFormDefinitionVo> wfFormDefinitionVos = wfFormDefinitionMapper.selectVoList(
new LambdaQueryWrapper<WfFormDefinition>().in(WfFormDefinition::getFormId, formIds)
);
for (WfFormVo record : records) {
if (CollUtil.isNotEmpty(wfFormDefinitionVos)) {
wfFormDefinitionVos.stream().filter(e -> String.valueOf(e.getFormId()).equals(String.valueOf(record.getFormId()))).findFirst().ifPresent(record::setWfFormDefinitionVo);
}
}
}
return TableDataInfo.build(result);
}
/**
* 查询流程表单列表
*
* @param bo 流程表单
* @return 流程表单
*/
@Override
public List<WfFormVo> queryList(WfFormBo bo) {
LambdaQueryWrapper<WfForm> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
/**
* 新增流程表单
*
* @param bo 流程表单
* @return 结果
*/
@Override
public int insertForm(WfFormBo bo) {
WfForm WfForm = MapstructUtils.convert(bo, WfForm.class);
return baseMapper.insert(WfForm);
}
/**
* 修改流程表单
*
* @param bo 流程表单
* @return 结果
*/
@Override
public int updateForm(WfFormBo bo) {
return baseMapper.update(new WfForm(), new LambdaUpdateWrapper<WfForm>()
.set(StrUtil.isNotBlank(bo.getFormName()), WfForm::getFormName, bo.getFormName())
.set(StrUtil.isNotBlank(bo.getContent()), WfForm::getContent, bo.getContent())
.set(StrUtil.isNotBlank(bo.getRemark()), WfForm::getRemark, bo.getRemark())
.set(StrUtil.isNotBlank(bo.getStatus()), WfForm::getStatus, bo.getStatus())
.eq(WfForm::getFormId, bo.getFormId()));
}
/**
* 批量删除流程表单
*
* @param ids 需要删除的流程表单ID
* @return 结果
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids) {
return baseMapper.deleteBatchIds(ids) > 0;
}
private LambdaQueryWrapper<WfForm> buildQueryWrapper(WfFormBo bo) {
LambdaQueryWrapper<WfForm> lqw = Wrappers.lambdaQuery();
lqw.like(StringUtils.isNotBlank(bo.getFormName()), WfForm::getFormName, bo.getFormName());
return lqw;
}
}