This commit is contained in:
ljl 2023-03-24 14:38:17 +08:00 committed by ljl
parent 6c41fd1cf3
commit 35f70e9cc8
100 changed files with 7308 additions and 10 deletions

View File

@ -120,6 +120,7 @@
### 其他
* 同步升级 RuoYi-Vue
* GitHub 地址 [RuoYi-Vue-Plus-github](https://github.com/dromara/RuoYi-Vue-Plus)
* 单模块 分支 [RuoYi-Vue-Plus-fast](https://gitee.com/dromara/RuoYi-Vue-Plus/tree/fast/)

14
pom.xml
View File

@ -321,6 +321,12 @@
<version>${ruoyi-vue-plus.version}</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-text</artifactId>
<version>1.9</version>
</dependency>
<!-- demo模块 -->
<dependency>
<groupId>com.ruoyi</groupId>
@ -328,6 +334,13 @@
<version>${ruoyi-vue-plus.version}</version>
</dependency>
<!-- 工作模块-->
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>ruoyi-work</artifactId>
<version>${ruoyi-vue-plus.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
@ -342,6 +355,7 @@
<module>ruoyi-extend</module>
<module>ruoyi-oss</module>
<module>ruoyi-sms</module>
<module>ruoyi-work</module>
</modules>
<packaging>pom</packaging>

View File

@ -78,6 +78,11 @@
<artifactId>ruoyi-demo</artifactId>
</dependency>
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>ruoyi-work</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>

View File

@ -0,0 +1,183 @@
package com.ruoyi.web.controller.house;
import cn.dev33.satoken.annotation.SaCheckPermission;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.annotation.RepeatSubmit;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.excel.ExcelResult;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.system.domain.BuyHouses;
import com.ruoyi.system.domain.HousesReview;
import com.ruoyi.system.domain.bo.HousesReviewBo;
import com.ruoyi.system.domain.vo.HousesReviewVo;
import com.ruoyi.system.mapper.BuyHousesMapper;
import com.ruoyi.system.service.IHousesReviewService;
import lombok.RequiredArgsConstructor;
import org.springframework.http.MediaType;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletResponse;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* 购房复审登记
*
* @author ruoyi
* @date 2023-03-08
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/house")
public class HousesReviewController extends BaseController {
private final IHousesReviewService iHousesReviewService;
private final BuyHousesMapper buyHousesMapper;
/**
* 查询购房复审登记列表
*/
@SaCheckPermission("system:review:list")
@GetMapping("/registrationManagement/list")
public TableDataInfo<HousesReviewVo> list(HousesReviewBo bo, PageQuery pageQuery) {
return iHousesReviewService.queryPageList(bo, pageQuery);
}
/**
* 导出购房复审登记列表
*/
@SaCheckPermission("system:review:export")
@Log(title = "购房复审登记", businessType = BusinessType.EXPORT)
@PostMapping("/registrationManagement/export")
public void export(HousesReviewBo bo, HttpServletResponse response) {
List<HousesReviewVo> list = iHousesReviewService.queryList(bo);
ExcelUtil.exportExcel(list, "购房复审登记", HousesReviewVo.class, response);
}
/**
* 获取购房复审登记详细信息
*
* @param id 主键
*/
@SaCheckPermission("system:review:query")
@GetMapping("/registrationManagement/{id}")
public R<HousesReviewVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(iHousesReviewService.queryById(id));
}
/**
* 新增购房复审登记
*/
@SaCheckPermission("system:review:add")
@Log(title = "购房复审登记", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping("/registrationManagement")
public R<Void> add(@Validated(AddGroup.class) @RequestBody HousesReviewBo bo) {
return toAjax(iHousesReviewService.insertByBo(bo));
}
/**
* 修改购房复审登记
*/
@SaCheckPermission("system:review:edit")
@Log(title = "购房复审登记", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping("/registrationManagement")
public R<Void> edit(@Validated(EditGroup.class) @RequestBody HousesReviewBo bo) {
return toAjax(iHousesReviewService.updateByBo(bo));
}
/**
* 删除购房复审登记
* @param ids 主键串
*/
@SaCheckPermission("system:review:remove")
@Log(title = "购房复审登记", businessType = BusinessType.DELETE)
@DeleteMapping("/registrationManagement/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(iHousesReviewService.deleteWithValidByIds(Arrays.asList(ids), true));
}
/**
* 导入
* @param file
* @return
* @throws Exception
*/
@Log(title = "购房复审导入", businessType = BusinessType.IMPORT)
@SaCheckPermission("system:review:import")
@PostMapping(value = "/review/importData", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
public R<Void> importData(@RequestPart("file") MultipartFile file) throws Exception {
ExcelResult<HousesReviewVo> result = ExcelUtil.importExcel(file.getInputStream(), HousesReviewVo.class, true);
List<HousesReviewVo> volist = result.getList();
List<HousesReview> list = BeanUtil.copyToList(volist, HousesReview.class);
//先获取到导入数据的身份证去购房一期数据库去查
//过滤出导入表中的身份证号码
List<String> collect = list.stream().filter( e ->ObjectUtil.isNotEmpty(e.getCard())).map(HousesReview::getCard).collect(Collectors.toList());
if (collect.size()>0 && list.size()>0) {
LambdaQueryWrapper<BuyHouses> queryWrapper = new LambdaQueryWrapper<BuyHouses>().in(BuyHouses::getCardId, collect);
//查询出导入数据中的身份证有那些是属于区级人才的
List<String> collect1 = buyHousesMapper.selectList(queryWrapper).stream().map(BuyHouses::getCardId).collect(Collectors.toList());
for (HousesReview housesReview : list) {
if ( collect1.size() > 0 && collect1.contains(housesReview.getCard()) ) {
housesReview.setSourceBy("1");
} else {
housesReview.setSourceBy("2");
}
}
}
iHousesReviewService.saveBatch(list);
return R.ok(result.getAnalysis());
}
/**
* 获取导入模板
*/
@Log(title = "获取导入模板", businessType = BusinessType.IMPORT)
@PostMapping("/review/importTemplate")
public void importTemplate(HttpServletResponse response) {
ExcelUtil.exportExcel(new ArrayList<>(), "用户数据", HousesReviewVo.class, response);
}
/**
* 获取申报材料
*/
@Log(title = "获取申报材料",businessType = BusinessType.OTHER)
@PostMapping("/review/material")
public R<?> getMaterialInfo(@RequestBody HousesReviewBo bo){
return iHousesReviewService.getMaterialInfo(bo);
}
/**
* 获取审核材料
*/
@Log(title = "审核时返回当前人材料",businessType = BusinessType.OTHER)
@GetMapping("/getMaterial/{id}")
public R<?> getMaterialByBusinessId(@PathVariable(value = "id") Long id){
return iHousesReviewService.getMaterialByBusinessId(id);
}
}

View File

@ -1,7 +1,7 @@
--- # 监控中心配置
spring.boot.admin.client:
# 增加客户端开关
enabled: true
enabled: false
url: http://localhost:9090/admin
instance:
service-host-type: IP
@ -11,7 +11,7 @@ spring.boot.admin.client:
--- # xxl-job 配置
xxl.job:
# 执行器开关
enabled: true
enabled: false
# 调度中心地址:如调度中心集群部署存在多个地址则用逗号分隔。
admin-addresses: http://localhost:9100/xxl-job-admin
# 执行器通讯TOKEN非空时启用
@ -49,9 +49,9 @@ spring:
driverClassName: com.mysql.cj.jdbc.Driver
# jdbc 所有参数配置参考 https://lionli.blog.csdn.net/article/details/122018562
# rewriteBatchedStatements=true 批处理优化 大幅提升批量插入更新删除性能(对数据库有性能损耗 使用批量操作应考虑性能问题)
url: jdbc:mysql://localhost:3306/ry-vue?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&autoReconnect=true&rewriteBatchedStatements=true
url: jdbc:mysql://182.150.40.133:3309/ry-vue-house?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&autoReconnect=true&rewriteBatchedStatements=true
username: root
password: root
password: 1234Qwer@
# 从库数据源
slave:
lazy: true
@ -102,13 +102,13 @@ spring:
spring:
redis:
# 地址
host: localhost
host: 119.96.86.131
# 端口默认为6379
port: 6379
# 数据库索引
database: 0
# 密码(如没有密码请注释掉)
# password:
password: 123456
# 连接超时时间
timeout: 10s
# 是否开启ssl

View File

@ -5,7 +5,7 @@ ruoyi:
# 版本
version: ${ruoyi-vue-plus.version}
# 版权年份
copyrightYear: 2022
copyrightYear: 2023
# 实例演示开关
demoEnabled: true
# 获取ip地址开关

View File

@ -1,11 +1,45 @@
package com.ruoyi.test;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.http.HttpUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.config.RuoYiConfig;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.helper.DataBaseHelper;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.system.domain.BuyHouses;
import com.ruoyi.system.domain.MaterialTalents;
import com.ruoyi.system.domain.vo.HousesReviewVo;
import com.ruoyi.system.domain.vo.MaterialTalentsVo;
import com.ruoyi.system.mapper.BuyHousesMapper;
import com.ruoyi.system.mapper.HousesReviewMapper;
import com.ruoyi.system.mapper.MaterialTalentsMapper;
import com.ruoyi.system.service.impl.SysConfigServiceImpl;
import com.ruoyi.work.domain.ActProcess;
import com.ruoyi.work.domain.HisProcess;
import com.ruoyi.work.domain.TProcess;
import com.ruoyi.work.domain.vo.ActProcessVo;
import com.ruoyi.work.domain.vo.ProcessVo;
import com.ruoyi.work.dto.BusinessDTO;
import com.ruoyi.work.mapper.ActProcessMapper;
import com.ruoyi.work.mapper.HisProcessMapper;
import com.ruoyi.work.mapper.ProcessMapper;
import com.ruoyi.work.service.impl.ProcessServiceImpl;
import com.ruoyi.work.utils.WorkComplyUtils;
import org.apache.commons.text.CaseUtils;
import org.junit.jupiter.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.util.ReflectionUtils;
import java.lang.reflect.Method;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
/**
* 单元测试案例
@ -19,6 +53,31 @@ public class DemoUnitTest {
@Autowired
private RuoYiConfig ruoYiConfig;
@Autowired
ProcessServiceImpl processService;
@Autowired
private BuyHousesMapper buyHousesMapper;
@Autowired
HisProcessMapper hisProcessMapper;
@Autowired
private ProcessMapper processMapper;
@Autowired
private ActProcessMapper actProcessMapper;
@Autowired
private HousesReviewMapper housesReviewMapper;
@Autowired
private MaterialTalentsMapper materialTalentsMapper;
@Autowired
private SysConfigServiceImpl sysConfigService;
@DisplayName("测试 @SpringBootTest @Test @DisplayName 注解")
@Test
public void testTest() {
@ -67,4 +126,182 @@ public class DemoUnitTest {
System.out.println("@AfterAll ==================");
}
@Test
public void test001() throws Exception {
//方法名
String methodName = "queryById";
//类名
Object beanName = SpringUtils.getBean("processServiceImpl");
//
String value ="1";
Class aClass = Long.valueOf(value).getClass();
System.out.println("stringClass = " + aClass);
Object params;
//将数值转类型
params=(Long.valueOf(value));
//调用方法
Method method = ReflectionUtils.findMethod(beanName.getClass(), methodName, aClass);
Object obj = ReflectionUtils.invokeMethod(method, beanName,params);
System.out.println("obj = " + obj.toString());
}
@Test
public void test002(){
ProcessVo processVo = new ProcessVo();
processVo.setProcessKey("apply_house");
processVo.setStep("1");
BuyHouses buyHouses = buyHousesMapper.selectById("2");
Map<String, Object> map = BeanUtil.beanToMap(buyHouses);
processVo.setParams(map);
processVo.setBusinessId("2");
processVo.setStartUser(buyHouses.getUserName());
WorkComplyUtils.comply(processVo);
}
@Test
public void test003(){
HisProcess hisProcess = new HisProcess();
hisProcess.setStatus("2");
BuyHouses buyHouses = buyHousesMapper.selectById("2");
Map<String, Object> map = BeanUtil.beanToMap(buyHouses);
hisProcess.setBusinessId(buyHouses.getId().toString());
hisProcess.setParams(map);
hisProcess.setProcessKey(buyHouses.getProcessKey());
hisProcess.setStartUser(buyHouses.getUserName());
String s = WorkComplyUtils.batchDeleted(hisProcess);
System.out.println("s = " + s);
}
@Test
public void test004(){
BusinessDTO businessDTO = new BusinessDTO();
BuyHouses buyHouses = buyHousesMapper.selectById("2");
Map<String, Object> map = BeanUtil.beanToMap(buyHouses);
businessDTO.setParams(map);
businessDTO.setBusinessId(buyHouses.getId().toString());
WorkComplyUtils.getStep(businessDTO);
}
@Test
public void test005(){
String s = "1";
LambdaQueryWrapper<TProcess> wrapper = new LambdaQueryWrapper<>();
wrapper.apply(ObjectUtil.isNotEmpty(s),"FIND_IN_SET('"+s+"',cc)");
List<TProcess> tProcesses = processMapper.selectList(wrapper);
List<Long> collect = tProcesses.stream().map(TProcess::getId).collect(Collectors.toList());
LambdaQueryWrapper<ActProcess> lqw = new LambdaQueryWrapper<>();
lqw.in(ActProcess::getProcessId,collect);
List<ActProcessVo> actProcessVoList = actProcessMapper.selectVoList(lqw);
System.out.println("actProcessVoList = " + actProcessVoList);
System.out.println("collect = " + collect);
PageQuery pageQuery = new PageQuery();
pageQuery.setPageNum(1);
pageQuery.setPageSize(10);
HisProcess hisProcess = new HisProcess();
hisProcess.setUserId("2");
hisProcess.setDeptId("103");
hisProcess.setRoleId("1");
Page<HisProcess> hisProcessPage = hisProcessMapper.selectVoListPage(pageQuery.build(), hisProcess);
List<HisProcess> records = hisProcessPage.getRecords();
System.out.println("records = " + records);
long total = hisProcessPage.getTotal();
System.out.println("total = " + total);
long size = hisProcessPage.getSize();
System.out.println("size = " + size);
}
@Test
public void test006(){
//先获取出顶级目录
HousesReviewVo housesReviewVo = housesReviewMapper.selectVoById("1633346490522927106");
Map<String, Object> map = BeanUtil.beanToMap(housesReviewVo);
Set<String> keys = map.keySet();
LambdaQueryWrapper<MaterialTalents> eq = new LambdaQueryWrapper<MaterialTalents>()
.eq(MaterialTalents::getTalentsValue, map.get("processKey"));
MaterialTalentsVo materialTalentsVo = materialTalentsMapper.selectVoOne(eq);
//根据id获取关于他下面的所有子集
LambdaQueryWrapper<MaterialTalents> wrapper = new LambdaQueryWrapper<MaterialTalents>()
.apply(DataBaseHelper.findInSet(materialTalentsVo.getId(), "selected"));
List<MaterialTalents> materialTalents = materialTalentsMapper.selectList(wrapper);
ArrayList<String> list = new ArrayList<>();
for (MaterialTalents materialTalent : materialTalents) {
if (keys.contains(materialTalent.getTalentsValue())){
//获取当前目录下的数据
Object value = map.get(materialTalent.getTalentsValue());
if (ObjectUtil.isNotNull(value)) {
List<String> collect = materialTalents.stream().filter(m -> m.getTalentsValue().equals(value) && materialTalent.getId().equals(m.getParentId())).map(MaterialTalents::getMaterials).collect(Collectors.toList());
System.out.println("collect = " + collect);
list.addAll(collect);
}
}
}
List<String> collect = list.stream().distinct().collect(Collectors.toList());
System.out.println("collect2 = " + collect);
}
@Test
public void test0007(){
/* String s1 = sysConfigService.selectConfigByKey("sys:preventing:hotlinking");
System.out.println("s1 = " + s1);
List<String> strings = Arrays.asList(s1.split(","));
System.out.println("strings = " + strings);*/
ActProcess actProcess = new ActProcess();
actProcess.setProcessKey("apply_house");
LambdaQueryWrapper<TProcess> wrapper = new LambdaQueryWrapper<TProcess>()
.eq(TProcess::getProcessKey, actProcess.getProcessKey());
List<TProcess> tProcesses = processMapper.selectList(wrapper);
System.out.println("tProcesses = " + tProcesses);
}
@Test
public void test0008(){
String host= "https://xyxtest.easyfees.cn/fcc";
String XYXMK ="54a321";
String qybh="XYX";
String account="XYX";
String key="5ee4adfedae1458a9ca040f06b416755";
Long timestamp=System.currentTimeMillis();
System.out.println("timestamp = " + timestamp);
String sign = SecureUtil.md5(qybh+"0001"+key+timestamp);
System.out.println("sign = " + sign);
HashMap<String, Object> hashMap = new HashMap<>();
hashMap.put("qybh",qybh);
hashMap.put("yhm","8401");
hashMap.put("sign",sign);
hashMap.put("timestamp",timestamp);
String s = HttpUtil.get(host, hashMap);
System.out.println("s = " + s);
}
@Test
public void test0009(){
String s ="buy_houses";
// BuyHouses buyHouses = buyHousesMapper.selectById("2");
String s1 = CaseUtils.toCamelCase(s,false,new char[]{'_'});
System.out.println("s1 = " + s1);
String s2 = s1+"ServiceImpl";
//类名
Object beanName = SpringUtils.getBean(s2);
String me = "queryById";
//调用方法
Method method = ReflectionUtils.findMethod(beanName.getClass(), me, Long.class);
Object obj = ReflectionUtils.invokeMethod(method, beanName,2L);
System.out.println("obj = " + obj);
// Map<String, Object> map = BeanUtil.beanToMap(buyHouses);
// System.out.println("map = " + map);
// ProcessVo processVo = new ProcessVo();
// processVo.setParams(map);
// processVo.setProcessKey("apply_house");
// List<ProcessVo> processPlan = WorkComplyUtils.getProcessPlan(processVo);
// System.out.println("processPlan = " +processPlan) ;
}
@Test
public void test00000(){
processMapper.updateCommonByBusinessId("buy_houses", Constants.FAILD,"2");
}
}

View File

@ -72,5 +72,25 @@ public interface Constants {
*/
String TOKEN = "token";
/**
* 审核等待中
*/
String WAIT = "wait";
/**
* 审核成功
*/
String SUCCEED = "succeed";
/**
* 审核失败
*/
String FAILD = "faild";
/**
* 数据不存在
*/
String NONENTITY = "nonentity";
}

View File

@ -35,6 +35,11 @@
<artifactId>ruoyi-sms</artifactId>
</dependency>
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>ruoyi-work</artifactId>
</dependency>
</dependencies>
</project>

View File

@ -0,0 +1,27 @@
package com.ruoyi.system.common;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.system.domain.BuyHouseCheck;
import com.ruoyi.system.domain.vo.BuyHouseCheckVo;
import com.ruoyi.system.mapper.BuyHouseCheckMapper;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
@Component
@RequiredArgsConstructor
public class WorkBusinessRule {
private static final BuyHouseCheckMapper buyHouseCheckMapper= SpringUtils.getBean(BuyHouseCheckMapper.class);
public String getDistrict(String district){
//先获取业务数据
QueryWrapper<BuyHouseCheck> qw = new QueryWrapper<>();
qw.eq("crux_key","buy_house_audit");
qw.eq("other_key",district);
BuyHouseCheckVo buyHouseCheckVo = buyHouseCheckMapper.selectVoOne(qw);
return buyHouseCheckVo.getPerson();
}
}

View File

@ -0,0 +1,42 @@
package com.ruoyi.system.domain;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
/**
* 购房审核人员不同类型需要的审核人员名单对象 buy_house_check
*
* @author ruoyi
* @date 2023-02-24
*/
@Data
@TableName("buy_house_check")
public class BuyHouseCheck{
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 描述
*/
private String remark;
/**
* 人员
*/
private String person;
/**
* 需要关联的key
*/
private String otherKey;
/**
* 关键key
*/
private String cruxKey;
}

View File

@ -0,0 +1,161 @@
package com.ruoyi.system.domain;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.util.Date;
/**
* 请填写功能名称对象 buy_houses
*
* @author ruoyi
* @date 2023-02-24
*/
@Data
@TableName("buy_houses")
public class BuyHouses {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 户口簿内页/护照内页
*/
private String insidepageUrl;
/**
* 身份证/护照
*/
private String cardId;
/**
* 承诺书
*/
private String commitmentUrl;
/**
* 单位地址
*/
private String companyAddress;
/**
* 工作单位
*/
private String companyName;
/**
*
*/
private Date createTime;
/**
* 申明书
*/
private String declarationUrl;
/**
* 企业所在地 1.新经济活力区 2.交子公园金融商务区 3.高新西区 4.生物城
*/
private String district;
/**
* 学历
*/
private String education;
/**
* 身份证正面
*/
private String frontUrl;
/**
* 公园城市局审核状态 1.待审核 2.退件 3.不通过 4.通过
*/
private String gyStatus;
/**
* 房屋记录
*/
private String homeRecordUrl;
/**
* 户口簿主页
*/
private String homepageUrl;
/**
* 劳动合同
*/
private String laborContractUrl;
/**
* 企业营业执照
*/
private String licenseUrl;
/**
* 婚姻状况 1.未婚 2.已婚 3.离异
*/
private String maritalStatus;
/**
* 婚姻证明材料
*/
private String maritalUrl;
/**
* 国籍
*/
private String nationality;
/**
* 手机号
*/
private String phone;
/**
* 区域部门审核状态 1.待审核 2.退件 3.不通过 4.通过
*/
private String qyStatus;
/**
* 身份证背面
*/
private String reverseUrl;
/**
* 性别
*/
private String sex;
/**
* 社会事业局审核状态 1.待审核 2.退件 3.不通过 4.通过
*/
private String shStatus;
/**
* 统一社会信用代码
*/
private String socialCode;
/**
* 社保证明
*/
private String socialSecurityUrl;
/**
* 状态 1.待提交 2.受理中 3.受理退件 4.受理驳回 5.初审中 6初审不通过 7.初审退件 8.审定中 9.审定不通过 10.审定通过
*/
private String status;
/**
* 类型 A B C D
*/
private String type;
/**
* 用户id
*/
private Long userId;
/**
* 姓名
*/
private String userName;
/**
*
*/
private Date affTime;
/**
*
*/
private String pictureInformationUrl;
/**
*
*/
private String workAddress;
public String processKey;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date updateTime;
}

View File

@ -0,0 +1,60 @@
package com.ruoyi.system.domain;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ruoyi.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* 购房家属关系对象 buy_houses_member
*
* @author ruoyi
* @date 2023-03-15
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("buy_houses_member")
public class BuyHousesMember extends BaseEntity {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 户口簿内页
*/
private String insidepageUrl;
/**
* 购房申报id
*/
private String buyHousesId;
/**
* 身份证正面
*/
private String frontUrl;
/**
* 关系
*/
private String relation;
/**
* 身份证背面
*/
private String reverseUrl;
/**
* 房屋记录
*/
private String homeRecordUrl;
/**
* 证件号
*/
private String cardId;
/**
* 姓名
*/
private String name;
}

View File

@ -0,0 +1,60 @@
package com.ruoyi.system.domain;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ruoyi.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* 购房复审家属关系对象 buy_houses_review_member
*
* @author ruoyi
* @date 2023-03-15
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("buy_houses_review_member")
public class BuyHousesReviewMember extends BaseEntity {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 户口簿内页
*/
private String insidepageUrl;
/**
* 购房申报id
*/
private String buyHousesId;
/**
* 身份证正面
*/
private String frontUrl;
/**
* 关系
*/
private String relation;
/**
* 身份证背面
*/
private String reverseUrl;
/**
* 房屋记录
*/
private String homeRecordUrl;
/**
* 证件号
*/
private String cardId;
/**
* 姓名
*/
private String name;
}

View File

@ -0,0 +1,130 @@
package com.ruoyi.system.domain;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ruoyi.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* 购房复审登记对象 houses_review
*
* @author ruoyi
* @date 2023-03-08
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("houses_review")
public class HousesReview extends BaseEntity {
private static final long serialVersionUID=1L;
/**
* id
*/
@TableId(value = "id")
private Long id;
/**
* 证件类型
*/
private String cardType;
/**
* 身份证号码
*/
private String card;
/**
* 姓名
*/
private String name;
/**
* 资格序号
*/
private String qualification;
/**
* 审核时间
*/
private String auditTime;
/**
* 预售证号
*/
private String presellCard;
/**
* 交易类型
*/
private String dealType;
/**
* 项目名称
*/
private String projectName;
/**
* 项目区域
*/
private String projectArea;
/**
* 资格确认时间
*/
private String qualificationConfirmTime;
/**
* 资格预申请时间
*/
private String qualificationPreApplyTime;
/**
* 家庭类型
*/
private String familyType;
/**
* 状态
*/
private String status;
/**
* 登记失效时间
*/
private String registerFailureTime;
/**
* 国籍
*/
private String nationality;
/**
* 婚姻状况
*/
private String maritalStatus;
/**
* 单位类型
*/
private String companyType;
/**
* 公司名称
*/
private String companyName;
/**
* 人才类型
*/
private String talentsType;
/**
* 统一社会信用代码
*/
private String creditCode;
/**
* 企业所在地
*/
private String companyAddress;
/**
* 来源
*/
private String sourceBy;
/**
* 流程key
*/
private String processKey;
/**
* 流程状态
*/
private String processStatus;
/**
* 工作单位所属区域
*/
private String companyAddressArea;
}

View File

@ -0,0 +1,57 @@
package com.ruoyi.system.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ruoyi.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* 材料模块对象 material_module
*
* @author ruoyi
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("material_module")
public class MaterialModule extends BaseEntity {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id",type = IdType.AUTO)
private Long id;
/**
* 材料名称
*/
private String materialName;
/**
* 材料key
*/
private String materialKey;
/**
* 审核部门
*/
private String auditDept;
/**
* 描述
*/
private String description;
/**
* 排序
*/
private Long sort;
/**
* 是否必填
*/
private String isMust;
@TableField(exist = false)
private String file;
}

View File

@ -0,0 +1,63 @@
package com.ruoyi.system.domain;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ruoyi.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* 材料对象 material_proof
*
* @author ruoyi
* @date 2023-03-15
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("material_proof")
public class MaterialProof extends BaseEntity {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 关联申请id
*/
private String houseId;
/**
* 0待审核1审核失败2审核成功
*/
private Long status;
/**
* 所对应材料的id
*/
private String modulePathId;
/**
* 数据
*/
private String file;
/**
* 对应module_paht的字段
*/
private String materialKey;
/**
* 对应module_path的描述
*/
private String description;
/**
* 审核人
*/
private String auditDept;
/**
* 审核人类型
*/
private String checkType;
private String materialName;
}

View File

@ -0,0 +1,61 @@
package com.ruoyi.system.domain;
import com.baomidou.mybatisplus.annotation.*;
import com.ruoyi.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* 材料关系对象 material_talents
*
* @author ruoyi
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("material_talents")
public class MaterialTalents extends BaseEntity {
private static final long serialVersionUID=1L;
/**
* 主键
*/
@TableId(value = "id")
private Long id;
/**
* 父id
*/
private Long parentId;
/**
*
*/
private String talentsValue;
/**
* 节点名称
*/
private String talentsName;
/**
* 版本
*/
@Version
private Long version;
/**
* 删除标志
*/
@TableLogic
private Long delFlag;
/**
* 是否选中
*/
private String selected;
/**
* 对应的材料
*/
private String materials;
@TableField(exist = false)
private Integer[] materialList;
}

View File

@ -0,0 +1,224 @@
package com.ruoyi.system.domain.bo;
import com.ruoyi.common.core.domain.BaseEntity;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.util.Date;
/**
* 请填写功能名称业务对象 buy_houses
*
* @author ruoyi
* @date 2023-02-24
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class BuyHousesBo extends BaseEntity {
/**
*
*/
@NotNull(message = "不能为空", groups = { EditGroup.class })
private Long id;
/**
* 户口簿内页/护照内页
*/
@NotBlank(message = "户口簿内页/护照内页不能为空", groups = { AddGroup.class, EditGroup.class })
private String insidepageUrl;
/**
* 身份证/护照
*/
@NotBlank(message = "身份证/护照不能为空", groups = { AddGroup.class, EditGroup.class })
private String cardId;
/**
* 承诺书
*/
@NotBlank(message = "承诺书不能为空", groups = { AddGroup.class, EditGroup.class })
private String commitmentUrl;
/**
* 单位地址
*/
@NotBlank(message = "单位地址不能为空", groups = { AddGroup.class, EditGroup.class })
private String companyAddress;
/**
* 工作单位
*/
@NotBlank(message = "工作单位不能为空", groups = { AddGroup.class, EditGroup.class })
private String companyName;
/**
*
*/
@NotNull(message = "不能为空", groups = { AddGroup.class, EditGroup.class })
private Date createTime;
/**
* 申明书
*/
@NotBlank(message = "申明书不能为空", groups = { AddGroup.class, EditGroup.class })
private String declarationUrl;
/**
* 企业所在地 1.新经济活力区 2.交子公园金融商务区 3.高新西区 4.生物城
*/
@NotBlank(message = "企业所在地 1.新经济活力区 2.交子公园金融商务区 3.高新西区 4.生物城不能为空", groups = { AddGroup.class, EditGroup.class })
private String district;
/**
* 学历
*/
@NotBlank(message = "学历不能为空", groups = { AddGroup.class, EditGroup.class })
private String education;
/**
* 身份证正面
*/
@NotBlank(message = "身份证正面不能为空", groups = { AddGroup.class, EditGroup.class })
private String frontUrl;
/**
* 公园城市局审核状态 1.待审核 2.退件 3.不通过 4.通过
*/
@NotBlank(message = "公园城市局审核状态 1.待审核 2.退件 3.不通过 4.通过不能为空", groups = { AddGroup.class, EditGroup.class })
private String gyStatus;
/**
* 房屋记录
*/
@NotBlank(message = "房屋记录不能为空", groups = { AddGroup.class, EditGroup.class })
private String homeRecordUrl;
/**
* 户口簿主页
*/
@NotBlank(message = "户口簿主页不能为空", groups = { AddGroup.class, EditGroup.class })
private String homepageUrl;
/**
* 劳动合同
*/
@NotBlank(message = "劳动合同不能为空", groups = { AddGroup.class, EditGroup.class })
private String laborContractUrl;
/**
* 企业营业执照
*/
@NotBlank(message = "企业营业执照不能为空", groups = { AddGroup.class, EditGroup.class })
private String licenseUrl;
/**
* 婚姻状况 1.未婚 2.已婚 3.离异
*/
@NotBlank(message = "婚姻状况 1.未婚 2.已婚 3.离异不能为空", groups = { AddGroup.class, EditGroup.class })
private String maritalStatus;
/**
* 婚姻证明材料
*/
@NotBlank(message = "婚姻证明材料不能为空", groups = { AddGroup.class, EditGroup.class })
private String maritalUrl;
/**
* 国籍
*/
@NotBlank(message = "国籍不能为空", groups = { AddGroup.class, EditGroup.class })
private String nationality;
/**
* 手机号
*/
@NotBlank(message = "手机号不能为空", groups = { AddGroup.class, EditGroup.class })
private String phone;
/**
* 区域部门审核状态 1.待审核 2.退件 3.不通过 4.通过
*/
@NotBlank(message = "区域部门审核状态 1.待审核 2.退件 3.不通过 4.通过不能为空", groups = { AddGroup.class, EditGroup.class })
private String qyStatus;
/**
* 身份证背面
*/
@NotBlank(message = "身份证背面不能为空", groups = { AddGroup.class, EditGroup.class })
private String reverseUrl;
/**
* 性别
*/
@NotBlank(message = "性别不能为空", groups = { AddGroup.class, EditGroup.class })
private String sex;
/**
* 社会事业局审核状态 1.待审核 2.退件 3.不通过 4.通过
*/
@NotBlank(message = "社会事业局审核状态 1.待审核 2.退件 3.不通过 4.通过不能为空", groups = { AddGroup.class, EditGroup.class })
private String shStatus;
/**
* 统一社会信用代码
*/
@NotBlank(message = "统一社会信用代码不能为空", groups = { AddGroup.class, EditGroup.class })
private String socialCode;
/**
* 社保证明
*/
@NotBlank(message = "社保证明不能为空", groups = { AddGroup.class, EditGroup.class })
private String socialSecurityUrl;
/**
* 状态 1.待提交 2.受理中 3.受理退件 4.受理驳回 5.初审中 6初审不通过 7.初审退件 8.审定中 9.审定不通过 10.审定通过
*/
@NotBlank(message = "状态 1.待提交 2.受理中 3.受理退件 4.受理驳回 5.初审中 6初审不通过 7.初审退件 8.审定中 9.审定不通过 10.审定通过不能为空", groups = { AddGroup.class, EditGroup.class })
private String status;
/**
* 类型 A B C D
*/
@NotBlank(message = "类型 A B C D不能为空", groups = { AddGroup.class, EditGroup.class })
private String type;
/**
* 用户id
*/
@NotNull(message = "用户id不能为空", groups = { AddGroup.class, EditGroup.class })
private Long userId;
/**
* 姓名
*/
@NotBlank(message = "姓名不能为空", groups = { AddGroup.class, EditGroup.class })
private String userName;
/**
*
*/
@NotNull(message = "不能为空", groups = { AddGroup.class, EditGroup.class })
private Date affTime;
/**
*
*/
@NotBlank(message = "不能为空", groups = { AddGroup.class, EditGroup.class })
private String pictureInformationUrl;
/**
*
*/
@NotBlank(message = "不能为空", groups = { AddGroup.class, EditGroup.class })
private String workAddress;
public String processKey;
}

View File

@ -0,0 +1,78 @@
package com.ruoyi.system.domain.bo;
import com.ruoyi.common.core.domain.BaseEntity;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
/**
* 购房家属关系业务对象 buy_houses_member
*
* @author ruoyi
* @date 2023-03-15
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class BuyHousesMemberBo extends BaseEntity {
/**
*
*/
@NotNull(message = "不能为空", groups = { EditGroup.class })
private Long id;
/**
* 户口簿内页
*/
@NotBlank(message = "户口簿内页不能为空", groups = { AddGroup.class, EditGroup.class })
private String insidepageUrl;
/**
* 购房申报id
*/
@NotNull(message = "购房申报id不能为空", groups = { AddGroup.class, EditGroup.class })
private String buyHousesId;
/**
* 身份证正面
*/
@NotBlank(message = "身份证正面不能为空", groups = { AddGroup.class, EditGroup.class })
private String frontUrl;
/**
* 关系
*/
@NotBlank(message = "关系不能为空", groups = { AddGroup.class, EditGroup.class })
private String relation;
/**
* 身份证背面
*/
@NotBlank(message = "身份证背面不能为空", groups = { AddGroup.class, EditGroup.class })
private String reverseUrl;
/**
* 房屋记录
*/
@NotBlank(message = "房屋记录不能为空", groups = { AddGroup.class, EditGroup.class })
private String homeRecordUrl;
/**
* 证件号
*/
@NotBlank(message = "证件号不能为空", groups = { AddGroup.class, EditGroup.class })
private String cardId;
/**
* 姓名
*/
@NotBlank(message = "姓名不能为空", groups = { AddGroup.class, EditGroup.class })
private String name;
}

View File

@ -0,0 +1,78 @@
package com.ruoyi.system.domain.bo;
import com.ruoyi.common.core.domain.BaseEntity;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
/**
* 购房复审家属关系业务对象 buy_houses_review_member
*
* @author ruoyi
* @date 2023-03-15
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class BuyHousesReviewMemberBo extends BaseEntity {
/**
*
*/
@NotNull(message = "不能为空", groups = { EditGroup.class })
private Long id;
/**
* 户口簿内页
*/
@NotBlank(message = "户口簿内页不能为空", groups = { AddGroup.class, EditGroup.class })
private String insidepageUrl;
/**
* 购房申报id
*/
@NotNull(message = "购房申报id不能为空", groups = { AddGroup.class, EditGroup.class })
private String buyHousesId;
/**
* 身份证正面
*/
@NotBlank(message = "身份证正面不能为空", groups = { AddGroup.class, EditGroup.class })
private String frontUrl;
/**
* 关系
*/
@NotBlank(message = "关系不能为空", groups = { AddGroup.class, EditGroup.class })
private String relation;
/**
* 身份证背面
*/
@NotBlank(message = "身份证背面不能为空", groups = { AddGroup.class, EditGroup.class })
private String reverseUrl;
/**
* 房屋记录
*/
@NotBlank(message = "房屋记录不能为空", groups = { AddGroup.class, EditGroup.class })
private String homeRecordUrl;
/**
* 证件号
*/
@NotBlank(message = "证件号不能为空", groups = { AddGroup.class, EditGroup.class })
private String cardId;
/**
* 姓名
*/
@NotBlank(message = "姓名不能为空", groups = { AddGroup.class, EditGroup.class })
private String name;
}

View File

@ -0,0 +1,183 @@
package com.ruoyi.system.domain.bo;
import com.ruoyi.common.core.domain.BaseEntity;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import com.ruoyi.system.domain.BuyHousesReviewMember;
import com.ruoyi.system.domain.MaterialModule;
import com.ruoyi.system.domain.MaterialProof;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.util.List;
/**
* 购房复审登记业务对象 houses_review
*
* @author ruoyi
* @date 2023-03-08
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class HousesReviewBo extends BaseEntity {
/**
* id
*/
@NotNull(message = "id不能为空", groups = { EditGroup.class })
private Long id;
/**
* 证件类型
*/
@NotBlank(message = "证件类型不能为空", groups = { AddGroup.class, EditGroup.class })
private String cardType;
/**
* 身份证号码
*/
@NotBlank(message = "身份证号码不能为空", groups = { AddGroup.class, EditGroup.class })
private String card;
/**
* 姓名
*/
@NotBlank(message = "姓名不能为空", groups = { AddGroup.class, EditGroup.class })
private String name;
/**
* 资格序号
*/
@NotBlank(message = "资格序号不能为空", groups = { AddGroup.class, EditGroup.class })
private String qualification;
/**
* 审核时间
*/
@NotBlank(message = "审核时间不能为空", groups = { AddGroup.class, EditGroup.class })
private String auditTime;
/**
* 预售证号
*/
@NotBlank(message = "预售证号不能为空", groups = { AddGroup.class, EditGroup.class })
private String presellCard;
/**
* 交易类型
*/
@NotBlank(message = "交易类型不能为空", groups = { AddGroup.class, EditGroup.class })
private String dealType;
/**
* 项目名称
*/
@NotBlank(message = "项目名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String projectName;
/**
* 项目区域
*/
@NotBlank(message = "项目区域不能为空", groups = { AddGroup.class, EditGroup.class })
private String projectArea;
/**
* 资格确认时间
*/
@NotBlank(message = "资格确认时间不能为空", groups = { AddGroup.class, EditGroup.class })
private String qualificationConfirmTime;
/**
* 资格预申请时间
*/
@NotBlank(message = "资格预申请时间不能为空", groups = { AddGroup.class, EditGroup.class })
private String qualificationPreApplyTime;
/**
* 家庭类型
*/
@NotBlank(message = "家庭类型不能为空", groups = { AddGroup.class, EditGroup.class })
private String familyType;
/**
* 状态
*/
@NotBlank(message = "状态不能为空", groups = { AddGroup.class, EditGroup.class })
private String status;
/**
* 登记失效时间
*/
@NotBlank(message = "登记失效时间不能为空", groups = { AddGroup.class, EditGroup.class })
private String registerFailureTime;
/**
* 国籍
*/
@NotBlank(message = "国籍不能为空", groups = { AddGroup.class, EditGroup.class })
private String nationality;
/**
* 婚姻状况
*/
@NotBlank(message = "婚姻状况不能为空", groups = { AddGroup.class, EditGroup.class })
private String maritalStatus;
/**
* 单位类型
*/
@NotBlank(message = "单位类型不能为空", groups = { AddGroup.class, EditGroup.class })
private String companyType;
/**
* 公司名称
*/
@NotBlank(message = "公司名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String companyName;
/**
* 人才类型
*/
@NotBlank(message = "人才类型不能为空", groups = { AddGroup.class, EditGroup.class })
private String talentsType;
/**
* 统一社会信用代码
*/
@NotBlank(message = "统一社会信用代码不能为空", groups = { AddGroup.class, EditGroup.class })
private String creditCode;
/**
* 企业所在地
*/
@NotBlank(message = "企业所在地不能为空", groups = { AddGroup.class, EditGroup.class })
private String companyAddress;
/**
* 来源
*/
@NotBlank(message = "来源不能为空", groups = { AddGroup.class, EditGroup.class })
private String sourceBy;
/**
* 流程key
*/
@NotBlank(message = "流程key不能为空", groups = { AddGroup.class, EditGroup.class })
private String processKey;
private String processStatus;
private String companyAddressArea;
private List<BuyHousesReviewMember> buyHousesMemberList;
private List<MaterialModule> materialsList;
private List<MaterialProof> materialProofList;
}

View File

@ -0,0 +1,64 @@
package com.ruoyi.system.domain.bo;
import com.ruoyi.common.core.domain.BaseEntity;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
/**
* 材料模块业务对象 material_module
*
* @author ruoyi
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class MaterialModuleBo extends BaseEntity {
/**
*
*/
private Long id;
/**
* 材料名称
*/
@NotBlank(message = "材料名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String materialName;
/**
* 材料key
*/
@NotBlank(message = "材料key不能为空", groups = { AddGroup.class, EditGroup.class })
private String materialKey;
/**
* 审核部门
*/
@NotBlank(message = "审核部门不能为空", groups = { AddGroup.class, EditGroup.class })
private String auditDept;
/**
* 描述
*/
private String description;
/**
* 排序
*/
@NotNull(message = "排序不能为空", groups = { AddGroup.class, EditGroup.class })
private Long sort;
/**
* 是否必填
*/
@NotNull(message = "是否必填不能为空", groups = { AddGroup.class, EditGroup.class })
private String isMust;
}

View File

@ -0,0 +1,86 @@
package com.ruoyi.system.domain.bo;
import com.ruoyi.common.core.domain.BaseEntity;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.util.Date;
/**
* 材料业务对象 material_proof
*
* @author ruoyi
* @date 2023-03-15
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class MaterialProofBo extends BaseEntity {
/**
*
*/
@NotNull(message = "不能为空", groups = { EditGroup.class })
private Long id;
/**
* 关联申请id
*/
@NotBlank(message = "关联申请id不能为空", groups = { AddGroup.class, EditGroup.class })
private String houseId;
/**
* 创建时间
*/
@NotNull(message = "创建时间不能为空", groups = { AddGroup.class, EditGroup.class })
private Date createTime;
/**
* 0待审核1审核失败2审核成功
*/
@NotNull(message = "0待审核1审核失败2审核成功不能为空", groups = { AddGroup.class, EditGroup.class })
private Long status;
/**
* 所对应材料的id
*/
@NotBlank(message = "所对应材料的id不能为空", groups = { AddGroup.class, EditGroup.class })
private String modulePathId;
/**
* 数据
*/
@NotBlank(message = "数据不能为空", groups = { AddGroup.class, EditGroup.class })
private String file;
/**
* 对应module_paht的字段
*/
@NotBlank(message = "对应module_paht的字段不能为空", groups = { AddGroup.class, EditGroup.class })
private String materialKey;
/**
* 对应module_path的描述
*/
@NotBlank(message = "对应module_path的描述不能为空", groups = { AddGroup.class, EditGroup.class })
private String description;
/**
* 审核人
*/
@NotBlank(message = "审核人不能为空", groups = { AddGroup.class, EditGroup.class })
private String auditDept;
/**
* 审核人类型
*/
@NotBlank(message = "审核人类型不能为空", groups = { AddGroup.class, EditGroup.class })
private String checkType;
private String materialName;
}

View File

@ -0,0 +1,61 @@
package com.ruoyi.system.domain.bo;
import com.ruoyi.common.core.domain.BaseEntity;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
/**
* 材料关系业务对象 material_talents
*
* @author ruoyi
* @date 2023-03-09
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class MaterialTalentsBo extends BaseEntity {
/**
* 主键
*/
private Long id;
/**
* 父id
*/
@NotNull(message = "父id不能为空", groups = { AddGroup.class, EditGroup.class })
private Long parentId;
/**
*
*/
@NotNull(message = "值不能为空", groups = { AddGroup.class, EditGroup.class })
private String talentsValue;
/**
* 节点名称
*/
@NotBlank(message = "节点名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String talentsName;
/**
* 是否选中
*/
// @NotBlank(message = "是否选中不能为空", groups = { AddGroup.class, EditGroup.class })
private String selected;
/**
* 对应的材料
*/
// @NotBlank(message = "对应的材料不能为空", groups = { AddGroup.class, EditGroup.class })
private String materials;
private Integer[] materialList;
}

View File

@ -0,0 +1,52 @@
package com.ruoyi.system.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.Data;
/**
* 购房审核人员不同类型需要的审核人员名单视图对象 buy_house_check
*
* @author ruoyi
* @date 2023-02-24
*/
@Data
@ExcelIgnoreUnannotated
public class BuyHouseCheckVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 描述
*/
@ExcelProperty(value = "描述")
private String remark;
/**
* 人员
*/
@ExcelProperty(value = "人员")
private String person;
/**
* 需要关联的key
*/
@ExcelProperty(value = "需要关联的key")
private String otherKey;
/**
* 关键key
*/
@ExcelProperty(value = "关键key")
private String cruxKey;
}

View File

@ -0,0 +1,75 @@
package com.ruoyi.system.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.Data;
/**
* 购房家属关系视图对象 buy_houses_member
*
* @author ruoyi
* @date 2023-03-15
*/
@Data
@ExcelIgnoreUnannotated
public class BuyHousesMemberVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 户口簿内页
*/
@ExcelProperty(value = "户口簿内页")
private String insidepageUrl;
/**
* 购房申报id
*/
@ExcelProperty(value = "购房申报id")
private String buyHousesId;
/**
* 身份证正面
*/
@ExcelProperty(value = "身份证正面")
private String frontUrl;
/**
* 关系
*/
@ExcelProperty(value = "关系")
private String relation;
/**
* 身份证背面
*/
@ExcelProperty(value = "身份证背面")
private String reverseUrl;
/**
* 房屋记录
*/
@ExcelProperty(value = "房屋记录")
private String homeRecordUrl;
/**
* 证件号
*/
@ExcelProperty(value = "证件号")
private String cardId;
/**
* 姓名
*/
@ExcelProperty(value = "姓名")
private String name;
}

View File

@ -0,0 +1,75 @@
package com.ruoyi.system.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.Data;
/**
* 购房复审家属关系视图对象 buy_houses_review_member
*
* @author ruoyi
* @date 2023-03-15
*/
@Data
@ExcelIgnoreUnannotated
public class BuyHousesReviewMemberVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 户口簿内页
*/
@ExcelProperty(value = "户口簿内页")
private String insidepageUrl;
/**
* 购房申报id
*/
@ExcelProperty(value = "购房申报id")
private String buyHousesId;
/**
* 身份证正面
*/
@ExcelProperty(value = "身份证正面")
private String frontUrl;
/**
* 关系
*/
@ExcelProperty(value = "关系")
private String relation;
/**
* 身份证背面
*/
@ExcelProperty(value = "身份证背面")
private String reverseUrl;
/**
* 房屋记录
*/
@ExcelProperty(value = "房屋记录")
private String homeRecordUrl;
/**
* 证件号
*/
@ExcelProperty(value = "证件号")
private String cardId;
/**
* 姓名
*/
@ExcelProperty(value = "姓名")
private String name;
}

View File

@ -0,0 +1,222 @@
package com.ruoyi.system.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.Data;
import java.util.Date;
/**
* 请填写功能名称视图对象 buy_houses
*
* @author ruoyi
* @date 2023-02-24
*/
@Data
@ExcelIgnoreUnannotated
public class BuyHousesVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 户口簿内页/护照内页
*/
@ExcelProperty(value = "户口簿内页/护照内页")
private String insidepageUrl;
/**
* 身份证/护照
*/
@ExcelProperty(value = "身份证/护照")
private String cardId;
/**
* 承诺书
*/
@ExcelProperty(value = "承诺书")
private String commitmentUrl;
/**
* 单位地址
*/
@ExcelProperty(value = "单位地址")
private String companyAddress;
/**
* 工作单位
*/
@ExcelProperty(value = "工作单位")
private String companyName;
/**
*
*/
@ExcelProperty(value = "")
private Date createTime;
/**
* 申明书
*/
@ExcelProperty(value = "申明书")
private String declarationUrl;
/**
* 企业所在地 1.新经济活力区 2.交子公园金融商务区 3.高新西区 4.生物城
*/
@ExcelProperty(value = "企业所在地 1.新经济活力区 2.交子公园金融商务区 3.高新西区 4.生物城")
private String district;
/**
* 学历
*/
@ExcelProperty(value = "学历")
private String education;
/**
* 身份证正面
*/
@ExcelProperty(value = "身份证正面")
private String frontUrl;
/**
* 公园城市局审核状态 1.待审核 2.退件 3.不通过 4.通过
*/
@ExcelProperty(value = "公园城市局审核状态 1.待审核 2.退件 3.不通过 4.通过")
private String gyStatus;
/**
* 房屋记录
*/
@ExcelProperty(value = "房屋记录")
private String homeRecordUrl;
/**
* 户口簿主页
*/
@ExcelProperty(value = "户口簿主页")
private String homepageUrl;
/**
* 劳动合同
*/
@ExcelProperty(value = "劳动合同")
private String laborContractUrl;
/**
* 企业营业执照
*/
@ExcelProperty(value = "企业营业执照")
private String licenseUrl;
/**
* 婚姻状况 1.未婚 2.已婚 3.离异
*/
@ExcelProperty(value = "婚姻状况 1.未婚 2.已婚 3.离异")
private String maritalStatus;
/**
* 婚姻证明材料
*/
@ExcelProperty(value = "婚姻证明材料")
private String maritalUrl;
/**
* 国籍
*/
@ExcelProperty(value = "国籍")
private String nationality;
/**
* 手机号
*/
@ExcelProperty(value = "手机号")
private String phone;
/**
* 区域部门审核状态 1.待审核 2.退件 3.不通过 4.通过
*/
@ExcelProperty(value = "区域部门审核状态 1.待审核 2.退件 3.不通过 4.通过")
private String qyStatus;
/**
* 身份证背面
*/
@ExcelProperty(value = "身份证背面")
private String reverseUrl;
/**
* 性别
*/
@ExcelProperty(value = "性别")
private String sex;
/**
* 社会事业局审核状态 1.待审核 2.退件 3.不通过 4.通过
*/
@ExcelProperty(value = "社会事业局审核状态 1.待审核 2.退件 3.不通过 4.通过")
private String shStatus;
/**
* 统一社会信用代码
*/
@ExcelProperty(value = "统一社会信用代码")
private String socialCode;
/**
* 社保证明
*/
@ExcelProperty(value = "社保证明")
private String socialSecurityUrl;
/**
* 状态 1.待提交 2.受理中 3.受理退件 4.受理驳回 5.初审中 6初审不通过 7.初审退件 8.审定中 9.审定不通过 10.审定通过
*/
@ExcelProperty(value = "状态 1.待提交 2.受理中 3.受理退件 4.受理驳回 5.初审中 6初审不通过 7.初审退件 8.审定中 9.审定不通过 10.审定通过")
private String status;
/**
* 类型 A B C D
*/
@ExcelProperty(value = "类型 A B C D")
private String type;
/**
* 用户id
*/
@ExcelProperty(value = "用户id")
private Long userId;
/**
* 姓名
*/
@ExcelProperty(value = "姓名")
private String userName;
/**
*
*/
@ExcelProperty(value = "")
private Date affTime;
/**
*
*/
@ExcelProperty(value = "")
private String pictureInformationUrl;
/**
*
*/
@ExcelProperty(value = "")
private String workAddress;
public String processKey;
}

View File

@ -0,0 +1,176 @@
package com.ruoyi.system.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.system.domain.BuyHousesReviewMember;
import lombok.Data;
import java.util.List;
/**
* 购房复审登记视图对象 houses_review
*
* @author ruoyi
* @date 2023-03-08
*/
@Data
@ExcelIgnoreUnannotated
public class HousesReviewVo {
private static final long serialVersionUID = 1L;
/**
* id
*/
// @ExcelProperty(value = "id")
private Long id;
/**
* 证件类型
*/
@ExcelProperty(value = "证件类型")
private String cardType;
/**
* 身份证号码
*/
@ExcelProperty(value = "身份证号码")
private String card;
/**
* 姓名
*/
@ExcelProperty(value = "姓名")
private String name;
/**
* 资格序号
*/
@ExcelProperty(value = "资格序号")
private String qualification;
/**
* 审核时间
*/
@ExcelProperty(value = "审核时间")
private String auditTime;
/**
* 预售证号
*/
@ExcelProperty(value = "预售证号")
private String presellCard;
/**
* 交易类型
*/
@ExcelProperty(value = "交易类型")
private String dealType;
/**
* 项目名称
*/
@ExcelProperty(value = "项目名称")
private String projectName;
/**
* 项目区域
*/
@ExcelProperty(value = "项目区域")
private String projectArea;
/**
* 资格确认时间
*/
@ExcelProperty(value = "资格确认时间")
private String qualificationConfirmTime;
/**
* 资格预申请时间
*/
@ExcelProperty(value = "资格预申请时间")
private String qualificationPreApplyTime;
/**
* 家庭类型
*/
@ExcelProperty(value = "家庭类型")
private String familyType;
/**
* 状态
*/
@ExcelProperty(value = "状态")
private String status;
/**
* 登记失效时间
*/
@ExcelProperty(value = "登记失效时间")
private String registerFailureTime;
/**
* 国籍
*/
// @ExcelProperty(value = "国籍")
private String nationality;
/**
* 婚姻状况
*/
// @ExcelProperty(value = "婚姻状况")
private String maritalStatus;
/**
* 单位类型
*/
// @ExcelProperty(value = "单位类型")
private String companyType;
/**
* 公司名称
*/
// @ExcelProperty(value = "公司名称")
private String companyName;
/**
* 人才类型
*/
// @ExcelProperty(value = "人才类型")
private String talentsType;
/**
* 统一社会信用代码
*/
// @ExcelProperty(value = "统一社会信用代码")
private String creditCode;
/**
* 企业所在地
*/
// @ExcelProperty(value = "企业所在地")
private String companyAddress;
/**
* 来源
*/
// @ExcelProperty(value = "来源")
private String sourceBy;
/**
* 流程key
*/
private String processKey;
private String processStatus;
private String companyAddressArea;
private List<BuyHousesReviewMember> buyHousesMemberList;
}

View File

@ -0,0 +1,68 @@
package com.ruoyi.system.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.annotation.ExcelDictFormat;
import com.ruoyi.common.convert.ExcelDictConvert;
import lombok.Data;
/**
* 材料模块视图对象 material_module
*
* @author ruoyi
* @date 2023-03-09
*/
@Data
@ExcelIgnoreUnannotated
public class MaterialModuleVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 材料名称
*/
@ExcelProperty(value = "材料名称")
private String materialName;
/**
* 材料key
*/
@ExcelProperty(value = "材料key")
private String materialKey;
/**
* 审核部门
*/
@ExcelProperty(value = "审核部门")
private String auditDept;
/**
* 描述
*/
@ExcelProperty(value = "描述")
private String description;
/**
* 排序
*/
@ExcelProperty(value = "排序")
private Long sort;
/**
* 是否必填
*/
@ExcelProperty(value = "是否必填", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "sys_yes_no")
private String isMust;
private String file;
}

View File

@ -0,0 +1,85 @@
package com.ruoyi.system.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.Data;
import java.util.Date;
/**
* 材料视图对象 material_proof
*
* @author ruoyi
* @date 2023-03-15
*/
@Data
@ExcelIgnoreUnannotated
public class MaterialProofVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 关联申请id
*/
@ExcelProperty(value = "关联申请id")
private String houseId;
/**
* 创建时间
*/
@ExcelProperty(value = "创建时间")
private Date createTime;
/**
* 0待审核1审核失败2审核成功
*/
@ExcelProperty(value = "0待审核1审核失败2审核成功")
private Long status;
/**
* 所对应材料的id
*/
@ExcelProperty(value = "所对应材料的id")
private String modulePathId;
/**
* 数据
*/
@ExcelProperty(value = "数据")
private String file;
/**
* 对应module_paht的字段
*/
@ExcelProperty(value = "对应module_paht的字段")
private String materialKey;
/**
* 对应module_path的描述
*/
@ExcelProperty(value = "对应module_path的描述")
private String description;
/**
* 审核人
*/
@ExcelProperty(value = "审核人")
private String auditDept;
/**
* 审核人类型
*/
@ExcelProperty(value = "审核人类型")
private String checkType;
private String materialName;
}

View File

@ -0,0 +1,59 @@
package com.ruoyi.system.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.Data;
/**
* 材料关系视图对象 material_talents
*
* @author ruoyi
* @date 2023-03-09
*/
@Data
@ExcelIgnoreUnannotated
public class MaterialTalentsVo {
private static final long serialVersionUID = 1L;
/**
* 主键
*/
@ExcelProperty(value = "主键")
private Long id;
/**
* 父id
*/
@ExcelProperty(value = "父id")
private Long parentId;
/**
*
*/
@ExcelProperty(value = "")
private String talentsValue;
/**
* 节点名称
*/
@ExcelProperty(value = "节点名称")
private String talentsName;
/**
* 是否选中
*/
@ExcelProperty(value = "是否选中")
private String selected;
/**
* 对应的材料
*/
@ExcelProperty(value = "对应的材料")
private String materials;
private Integer[] materialList;
private String step;
}

View File

@ -0,0 +1,15 @@
package com.ruoyi.system.mapper;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
import com.ruoyi.system.domain.BuyHouseCheck;
import com.ruoyi.system.domain.vo.BuyHouseCheckVo;
/**
* 购房审核人员不同类型需要的审核人员名单Mapper接口
*
* @author ruoyi
* @date 2023-02-24
*/
public interface BuyHouseCheckMapper extends BaseMapperPlus<BuyHouseCheckMapper, BuyHouseCheck, BuyHouseCheckVo> {
}

View File

@ -0,0 +1,15 @@
package com.ruoyi.system.mapper;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
import com.ruoyi.system.domain.BuyHouses;
import com.ruoyi.system.domain.vo.BuyHousesVo;
/**
* 请填写功能名称Mapper接口
*
* @author ruoyi
* @date 2023-02-24
*/
public interface BuyHousesMapper extends BaseMapperPlus<BuyHousesMapper, BuyHouses, BuyHousesVo> {
}

View File

@ -0,0 +1,15 @@
package com.ruoyi.system.mapper;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
import com.ruoyi.system.domain.BuyHousesMember;
import com.ruoyi.system.domain.vo.BuyHousesMemberVo;
/**
* 购房家属关系Mapper接口
*
* @author ruoyi
* @date 2023-03-15
*/
public interface BuyHousesMemberMapper extends BaseMapperPlus<BuyHousesMemberMapper, BuyHousesMember, BuyHousesMemberVo> {
}

View File

@ -0,0 +1,15 @@
package com.ruoyi.system.mapper;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
import com.ruoyi.system.domain.BuyHousesReviewMember;
import com.ruoyi.system.domain.vo.BuyHousesReviewMemberVo;
/**
* 购房复审家属关系Mapper接口
*
* @author ruoyi
* @date 2023-03-15
*/
public interface BuyHousesReviewMemberMapper extends BaseMapperPlus<BuyHousesReviewMemberMapper, BuyHousesReviewMember, BuyHousesReviewMemberVo> {
}

View File

@ -0,0 +1,15 @@
package com.ruoyi.system.mapper;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
import com.ruoyi.system.domain.HousesReview;
import com.ruoyi.system.domain.vo.HousesReviewVo;
/**
* 购房复审登记Mapper接口
*
* @author ruoyi
* @date 2023-03-08
*/
public interface HousesReviewMapper extends BaseMapperPlus<HousesReviewMapper, HousesReview, HousesReviewVo> {
}

View File

@ -0,0 +1,22 @@
package com.ruoyi.system.mapper;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
import com.ruoyi.system.domain.MaterialModule;
import com.ruoyi.system.domain.vo.MaterialModuleVo;
import org.apache.ibatis.annotations.Param;
/**
* 材料模块Mapper接口
*
* @author ruoyi
* @date 2023-03-09
*/
public interface MaterialModuleMapper extends BaseMapperPlus<MaterialModuleMapper, MaterialModule, MaterialModuleVo> {
Page<MaterialModuleVo> selectVoPageList(@Param("page") Page<SysUser> page, @Param(Constants.WRAPPER) Wrapper<MaterialModule> queryWrapper);
}

View File

@ -0,0 +1,15 @@
package com.ruoyi.system.mapper;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
import com.ruoyi.system.domain.MaterialProof;
import com.ruoyi.system.domain.vo.MaterialProofVo;
/**
* 材料Mapper接口
*
* @author ruoyi
* @date 2023-03-15
*/
public interface MaterialProofMapper extends BaseMapperPlus<MaterialProofMapper, MaterialProof, MaterialProofVo> {
}

View File

@ -0,0 +1,19 @@
package com.ruoyi.system.mapper;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
import com.ruoyi.system.domain.MaterialTalents;
import com.ruoyi.system.domain.bo.MaterialTalentsBo;
import com.ruoyi.system.domain.vo.MaterialTalentsVo;
import java.util.List;
/**
* 材料关系Mapper接口
*
* @author ruoyi
* @date 2023-03-09
*/
public interface MaterialTalentsMapper extends BaseMapperPlus<MaterialTalentsMapper, MaterialTalents, MaterialTalentsVo> {
List<MaterialTalentsVo> selectVoListSpecial(MaterialTalentsBo materialTalents);
}

View File

@ -0,0 +1,48 @@
package com.ruoyi.system.service;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.system.domain.bo.BuyHousesMemberBo;
import com.ruoyi.system.domain.vo.BuyHousesMemberVo;
import java.util.Collection;
import java.util.List;
/**
* 购房家属关系Service接口
*
* @author ruoyi
* @date 2023-03-15
*/
public interface IBuyHousesMemberService {
/**
* 查询购房家属关系
*/
BuyHousesMemberVo queryById(Long id);
/**
* 查询购房家属关系列表
*/
TableDataInfo<BuyHousesMemberVo> queryPageList(BuyHousesMemberBo bo, PageQuery pageQuery);
/**
* 查询购房家属关系列表
*/
List<BuyHousesMemberVo> queryList(BuyHousesMemberBo bo);
/**
* 新增购房家属关系
*/
Boolean insertByBo(BuyHousesMemberBo bo);
/**
* 修改购房家属关系
*/
Boolean updateByBo(BuyHousesMemberBo bo);
/**
* 校验并批量删除购房家属关系信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

View File

@ -0,0 +1,48 @@
package com.ruoyi.system.service;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.system.domain.bo.BuyHousesReviewMemberBo;
import com.ruoyi.system.domain.vo.BuyHousesReviewMemberVo;
import java.util.Collection;
import java.util.List;
/**
* 购房复审家属关系Service接口
*
* @author ruoyi
* @date 2023-03-15
*/
public interface IBuyHousesReviewMemberService {
/**
* 查询购房复审家属关系
*/
BuyHousesReviewMemberVo queryById(Long id);
/**
* 查询购房复审家属关系列表
*/
TableDataInfo<BuyHousesReviewMemberVo> queryPageList(BuyHousesReviewMemberBo bo, PageQuery pageQuery);
/**
* 查询购房复审家属关系列表
*/
List<BuyHousesReviewMemberVo> queryList(BuyHousesReviewMemberBo bo);
/**
* 新增购房复审家属关系
*/
Boolean insertByBo(BuyHousesReviewMemberBo bo);
/**
* 修改购房复审家属关系
*/
Boolean updateByBo(BuyHousesReviewMemberBo bo);
/**
* 校验并批量删除购房复审家属关系信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

View File

@ -0,0 +1,48 @@
package com.ruoyi.system.service;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.system.domain.bo.BuyHousesBo;
import com.ruoyi.system.domain.vo.BuyHousesVo;
import java.util.Collection;
import java.util.List;
/**
* 请填写功能名称Service接口
*
* @author ruoyi
* @date 2023-02-24
*/
public interface IBuyHousesService {
/**
* 查询请填写功能名称
*/
BuyHousesVo queryById(Long id);
/**
* 查询请填写功能名称列表
*/
TableDataInfo<BuyHousesVo> queryPageList(BuyHousesBo bo, PageQuery pageQuery);
/**
* 查询请填写功能名称列表
*/
List<BuyHousesVo> queryList(BuyHousesBo bo);
/**
* 新增请填写功能名称
*/
Boolean insertByBo(BuyHousesBo bo);
/**
* 修改请填写功能名称
*/
Boolean updateByBo(BuyHousesBo bo);
/**
* 校验并批量删除请填写功能名称信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

View File

@ -0,0 +1,58 @@
package com.ruoyi.system.service;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.system.domain.HousesReview;
import com.ruoyi.system.domain.bo.HousesReviewBo;
import com.ruoyi.system.domain.vo.HousesReviewVo;
import java.util.Collection;
import java.util.List;
/**
* 购房复审登记Service接口
*
* @author ruoyi
* @date 2023-03-08
*/
public interface IHousesReviewService {
/**
* 查询购房复审登记
*/
HousesReviewVo queryById(Long id);
/**
* 查询购房复审登记列表
*/
TableDataInfo<HousesReviewVo> queryPageList(HousesReviewBo bo, PageQuery pageQuery);
/**
* 查询购房复审登记列表
*/
List<HousesReviewVo> queryList(HousesReviewBo bo);
/**
* 新增购房复审登记
*/
Boolean insertByBo(HousesReviewBo bo);
/**
* 修改购房复审登记
*/
Boolean updateByBo(HousesReviewBo bo);
/**
* 校验并批量删除购房复审登记信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
Boolean saveBatch(List<HousesReview> list);
R<?> getMaterialInfo(HousesReviewBo bo);
HousesReviewVo queryByIdOne(Long id);
R<?> getMaterialByBusinessId(Long id);
}

View File

@ -0,0 +1,51 @@
package com.ruoyi.system.service;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.system.domain.bo.MaterialModuleBo;
import com.ruoyi.system.domain.vo.MaterialModuleVo;
import java.util.Collection;
import java.util.List;
/**
* 材料模块Service接口
*
* @author ruoyi
* @date 2023-03-09
*/
public interface IMaterialModuleService {
/**
* 查询材料模块
*/
MaterialModuleVo queryById(Long id);
/**
* 查询材料模块列表
*/
TableDataInfo<MaterialModuleVo> queryPageList(MaterialModuleBo bo, PageQuery pageQuery);
/**
* 查询材料模块列表
*/
List<MaterialModuleVo> queryList(MaterialModuleBo bo);
/**
* 新增材料模块
*/
Boolean insertByBo(MaterialModuleBo bo);
/**
* 修改材料模块
*/
Boolean updateByBo(MaterialModuleBo bo);
/**
* 校验并批量删除材料模块信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
R selectMaterialList(MaterialModuleBo bo);
}

View File

@ -0,0 +1,48 @@
package com.ruoyi.system.service;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.system.domain.bo.MaterialProofBo;
import com.ruoyi.system.domain.vo.MaterialProofVo;
import java.util.Collection;
import java.util.List;
/**
* 材料Service接口
*
* @author ruoyi
* @date 2023-03-15
*/
public interface IMaterialProofService {
/**
* 查询材料
*/
MaterialProofVo queryById(Long id);
/**
* 查询材料列表
*/
TableDataInfo<MaterialProofVo> queryPageList(MaterialProofBo bo, PageQuery pageQuery);
/**
* 查询材料列表
*/
List<MaterialProofVo> queryList(MaterialProofBo bo);
/**
* 新增材料
*/
Boolean insertByBo(MaterialProofBo bo);
/**
* 修改材料
*/
Boolean updateByBo(MaterialProofBo bo);
/**
* 校验并批量删除材料信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

View File

@ -0,0 +1,42 @@
package com.ruoyi.system.service;
import com.ruoyi.system.domain.bo.MaterialTalentsBo;
import com.ruoyi.system.domain.vo.MaterialTalentsVo;
import java.util.Collection;
import java.util.List;
/**
* 材料关系Service接口
*
* @author ruoyi
* @date 2023-03-09
*/
public interface IMaterialTalentsService {
/**
* 查询材料关系
*/
MaterialTalentsVo queryById(Long id);
/**
* 查询材料关系列表
*/
List<MaterialTalentsVo> queryList(MaterialTalentsBo bo);
/**
* 新增材料关系
*/
Boolean insertByBo(MaterialTalentsBo bo);
/**
* 修改材料关系
*/
Boolean updateByBo(MaterialTalentsBo bo);
/**
* 校验并批量删除材料关系信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

View File

@ -0,0 +1,116 @@
package com.ruoyi.system.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.BuyHousesMember;
import com.ruoyi.system.domain.bo.BuyHousesMemberBo;
import com.ruoyi.system.domain.vo.BuyHousesMemberVo;
import com.ruoyi.system.mapper.BuyHousesMemberMapper;
import com.ruoyi.system.service.IBuyHousesMemberService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
* 购房家属关系Service业务层处理
*
* @author ruoyi
* @date 2023-03-15
*/
@RequiredArgsConstructor
@Service
public class BuyHousesMemberServiceImpl implements IBuyHousesMemberService {
private final BuyHousesMemberMapper baseMapper;
/**
* 查询购房家属关系
*/
@Override
public BuyHousesMemberVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 查询购房家属关系列表
*/
@Override
public TableDataInfo<BuyHousesMemberVo> queryPageList(BuyHousesMemberBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<BuyHousesMember> lqw = buildQueryWrapper(bo);
Page<BuyHousesMemberVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询购房家属关系列表
*/
@Override
public List<BuyHousesMemberVo> queryList(BuyHousesMemberBo bo) {
LambdaQueryWrapper<BuyHousesMember> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<BuyHousesMember> buildQueryWrapper(BuyHousesMemberBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<BuyHousesMember> lqw = Wrappers.lambdaQuery();
lqw.eq(StringUtils.isNotBlank(bo.getInsidepageUrl()), BuyHousesMember::getInsidepageUrl, bo.getInsidepageUrl());
lqw.eq(bo.getBuyHousesId() != null, BuyHousesMember::getBuyHousesId, bo.getBuyHousesId());
lqw.eq(StringUtils.isNotBlank(bo.getFrontUrl()), BuyHousesMember::getFrontUrl, bo.getFrontUrl());
lqw.eq(StringUtils.isNotBlank(bo.getRelation()), BuyHousesMember::getRelation, bo.getRelation());
lqw.eq(StringUtils.isNotBlank(bo.getReverseUrl()), BuyHousesMember::getReverseUrl, bo.getReverseUrl());
lqw.eq(StringUtils.isNotBlank(bo.getHomeRecordUrl()), BuyHousesMember::getHomeRecordUrl, bo.getHomeRecordUrl());
lqw.eq(StringUtils.isNotBlank(bo.getCardId()), BuyHousesMember::getCardId, bo.getCardId());
lqw.like(StringUtils.isNotBlank(bo.getName()), BuyHousesMember::getName, bo.getName());
return lqw;
}
/**
* 新增购房家属关系
*/
@Override
public Boolean insertByBo(BuyHousesMemberBo bo) {
BuyHousesMember add = BeanUtil.toBean(bo, BuyHousesMember.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改购房家属关系
*/
@Override
public Boolean updateByBo(BuyHousesMemberBo bo) {
BuyHousesMember update = BeanUtil.toBean(bo, BuyHousesMember.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(BuyHousesMember entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除购房家属关系
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

View File

@ -0,0 +1,116 @@
package com.ruoyi.system.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.BuyHousesReviewMember;
import com.ruoyi.system.domain.bo.BuyHousesReviewMemberBo;
import com.ruoyi.system.domain.vo.BuyHousesReviewMemberVo;
import com.ruoyi.system.mapper.BuyHousesReviewMemberMapper;
import com.ruoyi.system.service.IBuyHousesReviewMemberService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
* 购房复审家属关系Service业务层处理
*
* @author ruoyi
* @date 2023-03-15
*/
@RequiredArgsConstructor
@Service
public class BuyHousesReviewMemberServiceImpl implements IBuyHousesReviewMemberService {
private final BuyHousesReviewMemberMapper baseMapper;
/**
* 查询购房复审家属关系
*/
@Override
public BuyHousesReviewMemberVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 查询购房复审家属关系列表
*/
@Override
public TableDataInfo<BuyHousesReviewMemberVo> queryPageList(BuyHousesReviewMemberBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<BuyHousesReviewMember> lqw = buildQueryWrapper(bo);
Page<BuyHousesReviewMemberVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询购房复审家属关系列表
*/
@Override
public List<BuyHousesReviewMemberVo> queryList(BuyHousesReviewMemberBo bo) {
LambdaQueryWrapper<BuyHousesReviewMember> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<BuyHousesReviewMember> buildQueryWrapper(BuyHousesReviewMemberBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<BuyHousesReviewMember> lqw = Wrappers.lambdaQuery();
lqw.eq(StringUtils.isNotBlank(bo.getInsidepageUrl()), BuyHousesReviewMember::getInsidepageUrl, bo.getInsidepageUrl());
lqw.eq(bo.getBuyHousesId() != null, BuyHousesReviewMember::getBuyHousesId, bo.getBuyHousesId());
lqw.eq(StringUtils.isNotBlank(bo.getFrontUrl()), BuyHousesReviewMember::getFrontUrl, bo.getFrontUrl());
lqw.eq(StringUtils.isNotBlank(bo.getRelation()), BuyHousesReviewMember::getRelation, bo.getRelation());
lqw.eq(StringUtils.isNotBlank(bo.getReverseUrl()), BuyHousesReviewMember::getReverseUrl, bo.getReverseUrl());
lqw.eq(StringUtils.isNotBlank(bo.getHomeRecordUrl()), BuyHousesReviewMember::getHomeRecordUrl, bo.getHomeRecordUrl());
lqw.eq(StringUtils.isNotBlank(bo.getCardId()), BuyHousesReviewMember::getCardId, bo.getCardId());
lqw.like(StringUtils.isNotBlank(bo.getName()), BuyHousesReviewMember::getName, bo.getName());
return lqw;
}
/**
* 新增购房复审家属关系
*/
@Override
public Boolean insertByBo(BuyHousesReviewMemberBo bo) {
BuyHousesReviewMember add = BeanUtil.toBean(bo, BuyHousesReviewMember.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改购房复审家属关系
*/
@Override
public Boolean updateByBo(BuyHousesReviewMemberBo bo) {
BuyHousesReviewMember update = BeanUtil.toBean(bo, BuyHousesReviewMember.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(BuyHousesReviewMember entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除购房复审家属关系
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

View File

@ -0,0 +1,140 @@
package com.ruoyi.system.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.BuyHouses;
import com.ruoyi.system.domain.bo.BuyHousesBo;
import com.ruoyi.system.domain.vo.BuyHousesVo;
import com.ruoyi.system.mapper.BuyHousesMapper;
import com.ruoyi.system.service.IBuyHousesService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
* 请填写功能名称Service业务层处理
*
* @author ruoyi
* @date 2023-02-24
*/
@RequiredArgsConstructor
@Service
public class BuyHousesServiceImpl implements IBuyHousesService {
private final BuyHousesMapper baseMapper;
/**
* 查询请填写功能名称
*/
@Override
public BuyHousesVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 查询请填写功能名称列表
*/
@Override
public TableDataInfo<BuyHousesVo> queryPageList(BuyHousesBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<BuyHouses> lqw = buildQueryWrapper(bo);
Page<BuyHousesVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询请填写功能名称列表
*/
@Override
public List<BuyHousesVo> queryList(BuyHousesBo bo) {
LambdaQueryWrapper<BuyHouses> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<BuyHouses> buildQueryWrapper(BuyHousesBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<BuyHouses> lqw = Wrappers.lambdaQuery();
lqw.eq(StringUtils.isNotBlank(bo.getInsidepageUrl()), BuyHouses::getInsidepageUrl, bo.getInsidepageUrl());
lqw.eq(StringUtils.isNotBlank(bo.getCardId()), BuyHouses::getCardId, bo.getCardId());
lqw.eq(StringUtils.isNotBlank(bo.getCommitmentUrl()), BuyHouses::getCommitmentUrl, bo.getCommitmentUrl());
lqw.eq(StringUtils.isNotBlank(bo.getCompanyAddress()), BuyHouses::getCompanyAddress, bo.getCompanyAddress());
lqw.like(StringUtils.isNotBlank(bo.getCompanyName()), BuyHouses::getCompanyName, bo.getCompanyName());
lqw.eq(bo.getCreateTime() != null, BuyHouses::getCreateTime, bo.getCreateTime());
lqw.eq(StringUtils.isNotBlank(bo.getDeclarationUrl()), BuyHouses::getDeclarationUrl, bo.getDeclarationUrl());
lqw.eq(StringUtils.isNotBlank(bo.getDistrict()), BuyHouses::getDistrict, bo.getDistrict());
lqw.eq(StringUtils.isNotBlank(bo.getEducation()), BuyHouses::getEducation, bo.getEducation());
lqw.eq(StringUtils.isNotBlank(bo.getFrontUrl()), BuyHouses::getFrontUrl, bo.getFrontUrl());
lqw.eq(StringUtils.isNotBlank(bo.getGyStatus()), BuyHouses::getGyStatus, bo.getGyStatus());
lqw.eq(StringUtils.isNotBlank(bo.getHomeRecordUrl()), BuyHouses::getHomeRecordUrl, bo.getHomeRecordUrl());
lqw.eq(StringUtils.isNotBlank(bo.getHomepageUrl()), BuyHouses::getHomepageUrl, bo.getHomepageUrl());
lqw.eq(StringUtils.isNotBlank(bo.getLaborContractUrl()), BuyHouses::getLaborContractUrl, bo.getLaborContractUrl());
lqw.eq(StringUtils.isNotBlank(bo.getLicenseUrl()), BuyHouses::getLicenseUrl, bo.getLicenseUrl());
lqw.eq(StringUtils.isNotBlank(bo.getMaritalStatus()), BuyHouses::getMaritalStatus, bo.getMaritalStatus());
lqw.eq(StringUtils.isNotBlank(bo.getMaritalUrl()), BuyHouses::getMaritalUrl, bo.getMaritalUrl());
lqw.eq(StringUtils.isNotBlank(bo.getNationality()), BuyHouses::getNationality, bo.getNationality());
lqw.eq(StringUtils.isNotBlank(bo.getPhone()), BuyHouses::getPhone, bo.getPhone());
lqw.eq(StringUtils.isNotBlank(bo.getQyStatus()), BuyHouses::getQyStatus, bo.getQyStatus());
lqw.eq(StringUtils.isNotBlank(bo.getReverseUrl()), BuyHouses::getReverseUrl, bo.getReverseUrl());
lqw.eq(StringUtils.isNotBlank(bo.getSex()), BuyHouses::getSex, bo.getSex());
lqw.eq(StringUtils.isNotBlank(bo.getShStatus()), BuyHouses::getShStatus, bo.getShStatus());
lqw.eq(StringUtils.isNotBlank(bo.getSocialCode()), BuyHouses::getSocialCode, bo.getSocialCode());
lqw.eq(StringUtils.isNotBlank(bo.getSocialSecurityUrl()), BuyHouses::getSocialSecurityUrl, bo.getSocialSecurityUrl());
lqw.eq(StringUtils.isNotBlank(bo.getStatus()), BuyHouses::getStatus, bo.getStatus());
lqw.eq(StringUtils.isNotBlank(bo.getType()), BuyHouses::getType, bo.getType());
lqw.eq(bo.getUserId() != null, BuyHouses::getUserId, bo.getUserId());
lqw.like(StringUtils.isNotBlank(bo.getUserName()), BuyHouses::getUserName, bo.getUserName());
lqw.eq(bo.getAffTime() != null, BuyHouses::getAffTime, bo.getAffTime());
lqw.eq(StringUtils.isNotBlank(bo.getPictureInformationUrl()), BuyHouses::getPictureInformationUrl, bo.getPictureInformationUrl());
lqw.eq(StringUtils.isNotBlank(bo.getWorkAddress()), BuyHouses::getWorkAddress, bo.getWorkAddress());
return lqw;
}
/**
* 新增请填写功能名称
*/
@Override
public Boolean insertByBo(BuyHousesBo bo) {
BuyHouses add = BeanUtil.toBean(bo, BuyHouses.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改请填写功能名称
*/
@Override
public Boolean updateByBo(BuyHousesBo bo) {
BuyHouses update = BeanUtil.toBean(bo, BuyHouses.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(BuyHouses entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除请填写功能名称
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

View File

@ -0,0 +1,331 @@
package com.ruoyi.system.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.BuyHousesReviewMember;
import com.ruoyi.system.domain.HousesReview;
import com.ruoyi.system.domain.MaterialModule;
import com.ruoyi.system.domain.MaterialProof;
import com.ruoyi.system.domain.bo.HousesReviewBo;
import com.ruoyi.system.domain.vo.HousesReviewVo;
import com.ruoyi.system.domain.vo.MaterialModuleVo;
import com.ruoyi.system.mapper.BuyHousesReviewMemberMapper;
import com.ruoyi.system.mapper.HousesReviewMapper;
import com.ruoyi.system.mapper.MaterialProofMapper;
import com.ruoyi.system.service.IHousesReviewService;
import com.ruoyi.work.domain.vo.ProcessVo;
import com.ruoyi.work.utils.WorkComplyUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* 购房复审登记Service业务层处理
*
* @author ruoyi
* @date 2023-03-08
*/
@RequiredArgsConstructor
@Service
@Transactional
public class HousesReviewServiceImpl implements IHousesReviewService {
private final HousesReviewMapper baseMapper;
private final MaterialModuleServiceImpl materialModuleService;
private final MaterialProofMapper materialProofMapper;
private final BuyHousesReviewMemberMapper buyHousesReviewMemberMapper;
private final SysOssServiceImpl sysOssService;
/**
* 查询购房复审登记
*/
@Override
public HousesReviewVo queryById(Long id){
HousesReviewVo housesReviewVo = baseMapper.selectVoById(id);
LambdaQueryWrapper<BuyHousesReviewMember> queryWrapper = new LambdaQueryWrapper<BuyHousesReviewMember>()
.eq(BuyHousesReviewMember::getBuyHousesId, housesReviewVo.getId());
List<BuyHousesReviewMember> buyHousesReviewMembers = buyHousesReviewMemberMapper.selectList(queryWrapper);
housesReviewVo.setBuyHousesMemberList(buyHousesReviewMembers);
if (buyHousesReviewMembers.size()==0){
housesReviewVo.setBuyHousesMemberList(new ArrayList<>());
}
return housesReviewVo;
}
/**
* 查询购房复审登记列表
*/
@Override
public TableDataInfo<HousesReviewVo> queryPageList(HousesReviewBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<HousesReview> lqw = buildQueryWrapper(bo);
Page<HousesReviewVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询购房复审登记列表
*/
@Override
public List<HousesReviewVo> queryList(HousesReviewBo bo) {
LambdaQueryWrapper<HousesReview> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<HousesReview> buildQueryWrapper(HousesReviewBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<HousesReview> lqw = Wrappers.lambdaQuery();
lqw.eq(StringUtils.isNotBlank(bo.getCardType()), HousesReview::getCardType, bo.getCardType());
lqw.eq(StringUtils.isNotBlank(bo.getCard()), HousesReview::getCard, bo.getCard());
lqw.like(StringUtils.isNotBlank(bo.getName()), HousesReview::getName, bo.getName());
lqw.eq(StringUtils.isNotBlank(bo.getQualification()), HousesReview::getQualification, bo.getQualification());
lqw.eq(StringUtils.isNotBlank(bo.getAuditTime()), HousesReview::getAuditTime, bo.getAuditTime());
lqw.eq(StringUtils.isNotBlank(bo.getPresellCard()), HousesReview::getPresellCard, bo.getPresellCard());
lqw.eq(StringUtils.isNotBlank(bo.getDealType()), HousesReview::getDealType, bo.getDealType());
lqw.like(StringUtils.isNotBlank(bo.getProjectName()), HousesReview::getProjectName, bo.getProjectName());
lqw.eq(StringUtils.isNotBlank(bo.getProjectArea()), HousesReview::getProjectArea, bo.getProjectArea());
lqw.eq(StringUtils.isNotBlank(bo.getQualificationConfirmTime()), HousesReview::getQualificationConfirmTime, bo.getQualificationConfirmTime());
lqw.eq(StringUtils.isNotBlank(bo.getQualificationPreApplyTime()), HousesReview::getQualificationPreApplyTime, bo.getQualificationPreApplyTime());
lqw.eq(StringUtils.isNotBlank(bo.getFamilyType()), HousesReview::getFamilyType, bo.getFamilyType());
lqw.eq(StringUtils.isNotBlank(bo.getStatus()), HousesReview::getStatus, bo.getStatus());
lqw.eq(StringUtils.isNotBlank(bo.getRegisterFailureTime()), HousesReview::getRegisterFailureTime, bo.getRegisterFailureTime());
lqw.eq(StringUtils.isNotBlank(bo.getNationality()), HousesReview::getNationality, bo.getNationality());
lqw.eq(StringUtils.isNotBlank(bo.getMaritalStatus()), HousesReview::getMaritalStatus, bo.getMaritalStatus());
lqw.eq(StringUtils.isNotBlank(bo.getCompanyType()), HousesReview::getCompanyType, bo.getCompanyType());
lqw.like(StringUtils.isNotBlank(bo.getCompanyName()), HousesReview::getCompanyName, bo.getCompanyName());
lqw.eq(StringUtils.isNotBlank(bo.getTalentsType()), HousesReview::getTalentsType, bo.getTalentsType());
lqw.eq(StringUtils.isNotBlank(bo.getCreditCode()), HousesReview::getCreditCode, bo.getCreditCode());
lqw.eq(StringUtils.isNotBlank(bo.getCompanyAddress()), HousesReview::getCompanyAddress, bo.getCompanyAddress());
lqw.eq(StringUtils.isNotBlank(bo.getSourceBy()), HousesReview::getSourceBy, bo.getSourceBy());
lqw.eq(StringUtils.isNotBlank(bo.getProcessKey()), HousesReview::getProcessKey, bo.getProcessKey());
return lqw;
}
/**
* 新增购房复审登记
*/
@Override
public Boolean insertByBo(HousesReviewBo bo) {
//先判断是否存在数据
HousesReview add = BeanUtil.toBean(bo, HousesReview.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
if (bo.getBuyHousesMemberList().size()>0){
bo.getBuyHousesMemberList().stream().forEach( e ->{
e.setBuyHousesId(add.getId().toString());
});
buyHousesReviewMemberMapper.insertBatch(bo.getBuyHousesMemberList());
}
bo.setId(add.getId());
}
return flag;
}
/**
* 修改购房复审登记
*/
@Override
public Boolean updateByBo(HousesReviewBo bo) {
//先删除存在的关系表
LambdaQueryWrapper<BuyHousesReviewMember> wrapper = new LambdaQueryWrapper<BuyHousesReviewMember>()
.eq(BuyHousesReviewMember::getBuyHousesId, bo.getId());
List<BuyHousesReviewMember> buyHousesReviewMembers = buyHousesReviewMemberMapper.selectList(wrapper);
if (ObjectUtil.isNotNull(buyHousesReviewMembers) && buyHousesReviewMembers.size()>0) {
List<BuyHousesReviewMember> buyHousesMemberList = bo.getBuyHousesMemberList();
//先删除minio的图片
List<Long> list = new ArrayList<>();
if (ObjectUtil.isNotNull(buyHousesMemberList) && buyHousesMemberList.size()>0) {
buyHousesReviewMembers.forEach(e -> {
/*boolean b1 = buyHousesMemberList.stream().noneMatch(b -> b.getFrontUrl().equals(e.getFrontUrl()));
boolean b1 = buyHousesMemberList.stream().noneMatch(b -> b.getInsidepageUrl().equals(e.getInsidepageUrl()));
boolean b1 = buyHousesMemberList.stream().noneMatch(b -> b.getHomeRecordUrl().equals(e.getHomeRecordUrl()));
boolean b1 = buyHousesMemberList.stream().noneMatch(b -> b.getReverseUrl().equals(e.getReverseUrl()));*/
if (ObjectUtil.isNotNull(e.getFrontUrl())){
if (!buyHousesMemberList.stream().anyMatch(b -> e.getFrontUrl().equals(b.getFrontUrl()))){
list.add(new Long(e.getFrontUrl()));
}
}
if (ObjectUtil.isNotNull(e.getInsidepageUrl())) {
if (!buyHousesMemberList.stream().anyMatch(b -> e.getInsidepageUrl().equals(b.getInsidepageUrl()))) {
list.add(new Long(e.getFrontUrl()));
}
}
if (ObjectUtil.isNotNull(e.getHomeRecordUrl())) {
if (!buyHousesMemberList.stream().anyMatch(b -> ObjectUtil.isNotNull(e.getHomeRecordUrl()) && e.getHomeRecordUrl().equals(b.getHomeRecordUrl()))) {
list.add(new Long(e.getFrontUrl()));
}
}
if (ObjectUtil.isNotNull(e.getReverseUrl())) {
if (!buyHousesMemberList.stream().anyMatch(b -> ObjectUtil.isNotNull(e.getReverseUrl()) && e.getReverseUrl().equals(b.getReverseUrl()))) {
list.add(new Long(e.getFrontUrl()));
}
}
});
}else {
List<Long> insidepageUrl = buyHousesReviewMembers.stream().filter(s ->ObjectUtil.isNotNull(s.getInsidepageUrl())).map(s -> Long.parseLong(s.getInsidepageUrl())).collect(Collectors.toList());
if (ObjectUtil.isNotNull(insidepageUrl)&& insidepageUrl.size()>0){
list.addAll(insidepageUrl);
}
List<Long> homeRecordUrl = buyHousesReviewMembers.stream().filter(s ->ObjectUtil.isNotNull(s.getHomeRecordUrl())).map(s -> Long.parseLong(s.getHomeRecordUrl())).collect(Collectors.toList());
if (ObjectUtil.isNotNull(homeRecordUrl)&& homeRecordUrl.size()>0){
list.addAll(homeRecordUrl);
}
List<Long> reverseUrl = buyHousesReviewMembers.stream().filter(s ->ObjectUtil.isNotNull(s.getReverseUrl())).map(s -> Long.parseLong(s.getReverseUrl())).collect(Collectors.toList());
if (ObjectUtil.isNotNull(reverseUrl)&& reverseUrl.size()>0){
list.addAll(reverseUrl);
}
List<Long> frontUrl = buyHousesReviewMembers.stream().filter(s ->ObjectUtil.isNotNull(s.getFrontUrl())).map(s -> Long.parseLong(s.getFrontUrl())).collect(Collectors.toList());
if (ObjectUtil.isNotNull(frontUrl)&& frontUrl.size()>0){
list.addAll(frontUrl);
}
}
if (list.size()>0){
sysOssService.deleteWithValidByIds(list,true);
}
List<Long> collect = buyHousesReviewMembers.stream().map(BuyHousesReviewMember::getId).collect(Collectors.toList());
if (collect.size()>0) {
buyHousesReviewMemberMapper.deleteBatchIds(collect);
}
}
LambdaQueryWrapper<MaterialProof> queryWrapper = new LambdaQueryWrapper<MaterialProof>()
.eq(MaterialProof::getHouseId, bo.getId());
List<MaterialProof> materialProofs = materialProofMapper.selectList(queryWrapper);
if (ObjectUtil.isNotNull(materialProofs) && materialProofs.size()>0) {
List<Long> list = new ArrayList<>();
List<MaterialModule> materialsList = bo.getMaterialsList();
if (ObjectUtil.isNotNull(materialsList) && materialsList.size() > 0){
materialProofs.forEach(mp ->{
boolean b = materialsList.stream().anyMatch(e -> ObjectUtil.isNotNull(mp.getFile()) && mp.getFile().equals(e.getFile()));
if (!b){
Long aLong = new Long(mp.getFile());
list.add(aLong);
}
});
}else {
list.addAll(materialProofs.stream().filter(s ->ObjectUtil.isNotNull(s.getFile())).map(s -> Long.parseLong(s.getFile())).collect(Collectors.toList()));
}
if (list.size()>0) {
sysOssService.deleteWithValidByIds(list, true);
}
List<Long> collect = materialProofs.stream().map(MaterialProof::getId).collect(Collectors.toList());
if (collect.size()>0) {
materialProofMapper.deleteBatchIds(collect);
}
}
if (ObjectUtil.isNotNull(bo.getBuyHousesMemberList()) && bo.getBuyHousesMemberList().size()>0){
bo.getBuyHousesMemberList().stream().forEach( e ->{
e.setBuyHousesId(bo.getId().toString());
});
buyHousesReviewMemberMapper.insertBatch(bo.getBuyHousesMemberList());
}
if(ObjectUtil.isNotNull(bo.getMaterialsList()) && bo.getMaterialsList().size()>0){
ArrayList<MaterialProof> list = new ArrayList<>();
bo.getMaterialsList().forEach(e ->{
MaterialProof materialProof = BeanUtil.toBean(e, MaterialProof.class);
materialProof.setHouseId(bo.getId().toString());
materialProof.setStatus(0L);
materialProof.setModulePathId(e.getId().toString());
materialProof.setId(null);
list.add(materialProof);
});
materialProofMapper.insertBatch(list);
}
bo.setProcessKey("house_review");
HousesReview update = BeanUtil.toBean(bo, HousesReview.class);
validEntityBeforeSave(update);
int i = baseMapper.updateById(update);
if (i>0) {
ProcessVo processVo = new ProcessVo();
processVo.setProcessKey("house_review");
processVo.setStep("1");
Map<String, Object> map = BeanUtil.beanToMap(bo);
processVo.setParams(map);
processVo.setBusinessId(bo.getId().toString());
processVo.setStartUser(bo.getName());
WorkComplyUtils.comply(processVo);
}
return i>0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(HousesReview entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除购房复审登记
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
@Override
public Boolean saveBatch(List<HousesReview> list) {
return baseMapper.insertBatch(list);
}
/**
* 获取材料接口
* @param bo
* @return
*/
@Override
public R<?> getMaterialInfo(HousesReviewBo bo) {
List<MaterialModuleVo> materialInfo = materialModuleService.getMaterialInfo(bo);
return R.ok(materialInfo);
}
@Override
public HousesReviewVo queryByIdOne(Long id) {
HousesReviewVo housesReviewVo = baseMapper.selectVoById(id);
LambdaQueryWrapper<BuyHousesReviewMember> queryWrapper = new LambdaQueryWrapper<BuyHousesReviewMember>()
.eq(BuyHousesReviewMember::getBuyHousesId, housesReviewVo.getId());
List<BuyHousesReviewMember> buyHousesReviewMembers = buyHousesReviewMemberMapper.selectList(queryWrapper);
housesReviewVo.setBuyHousesMemberList(buyHousesReviewMembers);
if (buyHousesReviewMembers.size()==0){
housesReviewVo.setBuyHousesMemberList(new ArrayList<>());
}
return housesReviewVo;
}
/**
* 获取材料
* @param id
* @return
*/
@Override
public R<?> getMaterialByBusinessId(Long id) {
LambdaQueryWrapper<MaterialProof> wrapper = new LambdaQueryWrapper<MaterialProof>()
.eq(MaterialProof::getHouseId, id);
return R.ok(materialProofMapper.selectList(wrapper));
}
}

View File

@ -0,0 +1,168 @@
package com.ruoyi.system.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.helper.DataBaseHelper;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.MaterialModule;
import com.ruoyi.system.domain.MaterialProof;
import com.ruoyi.system.domain.MaterialTalents;
import com.ruoyi.system.domain.bo.HousesReviewBo;
import com.ruoyi.system.domain.bo.MaterialModuleBo;
import com.ruoyi.system.domain.vo.MaterialModuleVo;
import com.ruoyi.system.domain.vo.MaterialTalentsVo;
import com.ruoyi.system.mapper.MaterialModuleMapper;
import com.ruoyi.system.mapper.MaterialProofMapper;
import com.ruoyi.system.mapper.MaterialTalentsMapper;
import com.ruoyi.system.service.IMaterialModuleService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.stream.Collectors;
/**
* 材料模块Service业务层处理
*
* @author ruoyi
* @date 2023-03-09
*/
@RequiredArgsConstructor
@Service
public class MaterialModuleServiceImpl implements IMaterialModuleService {
private final MaterialModuleMapper baseMapper;
private final MaterialTalentsMapper materialTalentsMapper;
private final MaterialProofMapper materialProofMapper;
/**
* 查询材料模块
*/
@Override
public MaterialModuleVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 查询材料模块列表
*/
@Override
public TableDataInfo<MaterialModuleVo> queryPageList(MaterialModuleBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<MaterialModule> lqw = buildQueryWrapper(bo);
Page<MaterialModuleVo> result = baseMapper.selectVoPageList(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询材料模块列表
*/
@Override
public List<MaterialModuleVo> queryList(MaterialModuleBo bo) {
LambdaQueryWrapper<MaterialModule> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<MaterialModule> buildQueryWrapper(MaterialModuleBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<MaterialModule> lqw = Wrappers.lambdaQuery();
lqw.like(StringUtils.isNotBlank(bo.getMaterialName()), MaterialModule::getMaterialName, bo.getMaterialName());
lqw.like(StringUtils.isNotBlank(bo.getMaterialKey()), MaterialModule::getMaterialKey, bo.getMaterialKey());
return lqw;
}
/**
* 新增材料模块
*/
@Override
public Boolean insertByBo(MaterialModuleBo bo) {
MaterialModule add = BeanUtil.toBean(bo, MaterialModule.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改材料模块
*/
@Override
public Boolean updateByBo(MaterialModuleBo bo) {
MaterialModule update = BeanUtil.toBean(bo, MaterialModule.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(MaterialModule entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除材料模块
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
@Override
public R selectMaterialList(MaterialModuleBo bo) {
LambdaQueryWrapper<MaterialModule> lqw = buildQueryWrapper(bo);
return R.ok(baseMapper.selectVoList(lqw));
}
public List<MaterialModuleVo> getMaterialInfo(HousesReviewBo bo){
Map<String, Object> map = BeanUtil.beanToMap(bo);
Set<String> keys = map.keySet();
LambdaQueryWrapper<MaterialTalents> eq = new LambdaQueryWrapper<MaterialTalents>()
.eq(MaterialTalents::getTalentsValue, map.get("processKey"));
MaterialTalentsVo materialTalentsVo = materialTalentsMapper.selectVoOne(eq);
//根据id获取关于他下面的所有子集
LambdaQueryWrapper<MaterialTalents> wrapper = new LambdaQueryWrapper<MaterialTalents>()
.apply(DataBaseHelper.findInSet(materialTalentsVo.getId(), "selected"));
List<MaterialTalents> materialTalents = materialTalentsMapper.selectList(wrapper);
ArrayList<String> list = new ArrayList<>();
for (MaterialTalents materialTalent : materialTalents) {
if (keys.contains(materialTalent.getTalentsValue())){
//获取当前目录下的数据
Object value = map.get(materialTalent.getTalentsValue());
if (ObjectUtil.isNotNull(value)) {
List<String> collect = materialTalents.stream().filter(m -> m.getTalentsValue().equals(value) && materialTalent.getId().equals(m.getParentId()) && ObjectUtil.isNotEmpty(m.getMaterials())).map(MaterialTalents::getMaterials).collect(Collectors.toList());
System.out.println("collect = " + collect);
list.addAll(collect);
}
}
}
List<Long> collect = list.stream().distinct().map(Long ::parseLong).collect(Collectors.toList());
List<MaterialModuleVo> materialTalentsVos = baseMapper.selectVoBatchIds(collect);
LambdaQueryWrapper<MaterialProof> queryWrapper = new LambdaQueryWrapper<MaterialProof>()
.eq(MaterialProof::getHouseId, bo.getId());
List<MaterialProof> materialProofs = materialProofMapper.selectList(queryWrapper);
materialTalentsVos.forEach(e -> {
materialProofs.forEach(m ->{
if (e.getId().toString().equals(m.getModulePathId())){
e.setFile(m.getFile());
}
});
});
return materialTalentsVos;
}
}

View File

@ -0,0 +1,117 @@
package com.ruoyi.system.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.MaterialProof;
import com.ruoyi.system.domain.bo.MaterialProofBo;
import com.ruoyi.system.domain.vo.MaterialProofVo;
import com.ruoyi.system.mapper.MaterialProofMapper;
import com.ruoyi.system.service.IMaterialProofService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
* 材料Service业务层处理
*
* @author ruoyi
* @date 2023-03-15
*/
@RequiredArgsConstructor
@Service
public class MaterialProofServiceImpl implements IMaterialProofService {
private final MaterialProofMapper baseMapper;
/**
* 查询材料
*/
@Override
public MaterialProofVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 查询材料列表
*/
@Override
public TableDataInfo<MaterialProofVo> queryPageList(MaterialProofBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<MaterialProof> lqw = buildQueryWrapper(bo);
Page<MaterialProofVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询材料列表
*/
@Override
public List<MaterialProofVo> queryList(MaterialProofBo bo) {
LambdaQueryWrapper<MaterialProof> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<MaterialProof> buildQueryWrapper(MaterialProofBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<MaterialProof> lqw = Wrappers.lambdaQuery();
lqw.eq(StringUtils.isNotBlank(bo.getHouseId()), MaterialProof::getHouseId, bo.getHouseId());
lqw.eq(bo.getCreateTime() != null, MaterialProof::getCreateTime, bo.getCreateTime());
lqw.eq(bo.getStatus() != null, MaterialProof::getStatus, bo.getStatus());
lqw.eq(StringUtils.isNotBlank(bo.getModulePathId()), MaterialProof::getModulePathId, bo.getModulePathId());
lqw.eq(StringUtils.isNotBlank(bo.getFile()), MaterialProof::getFile, bo.getFile());
lqw.eq(StringUtils.isNotBlank(bo.getMaterialKey()), MaterialProof::getMaterialKey, bo.getMaterialKey());
lqw.eq(StringUtils.isNotBlank(bo.getDescription()), MaterialProof::getDescription, bo.getDescription());
lqw.eq(StringUtils.isNotBlank(bo.getAuditDept()), MaterialProof::getAuditDept, bo.getAuditDept());
lqw.eq(StringUtils.isNotBlank(bo.getCheckType()), MaterialProof::getCheckType, bo.getCheckType());
return lqw;
}
/**
* 新增材料
*/
@Override
public Boolean insertByBo(MaterialProofBo bo) {
MaterialProof add = BeanUtil.toBean(bo, MaterialProof.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改材料
*/
@Override
public Boolean updateByBo(MaterialProofBo bo) {
MaterialProof update = BeanUtil.toBean(bo, MaterialProof.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(MaterialProof entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除材料
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

View File

@ -0,0 +1,130 @@
package com.ruoyi.system.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.MaterialTalents;
import com.ruoyi.system.domain.bo.MaterialTalentsBo;
import com.ruoyi.system.domain.vo.MaterialTalentsVo;
import com.ruoyi.system.mapper.MaterialTalentsMapper;
import com.ruoyi.system.service.IMaterialTalentsService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.*;
/**
* 材料关系Service业务层处理
*
* @author ruoyi
* @date 2023-03-09
*/
@RequiredArgsConstructor
@Service
public class MaterialTalentsServiceImpl implements IMaterialTalentsService {
private final MaterialTalentsMapper baseMapper;
/**
* 查询材料关系
*/
@Override
public MaterialTalentsVo queryById(Long id){
MaterialTalentsVo materialTalentsVo = baseMapper.selectVoById(id);
return materialTalentsVo;
}
/**
* 查询材料关系列表
*/
@Override
public List<MaterialTalentsVo> queryList(MaterialTalentsBo bo) {
return baseMapper.selectVoListSpecial (bo);
}
private LambdaQueryWrapper<MaterialTalents> buildQueryWrapper(MaterialTalentsBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<MaterialTalents> lqw = Wrappers.lambdaQuery();
lqw.like(StringUtils.isNotBlank(bo.getTalentsName()), MaterialTalents::getTalentsName, bo.getTalentsName());
return lqw;
}
/**
* 新增材料关系
*/
@Override
public Boolean insertByBo(MaterialTalentsBo bo) {
if (!bo.getParentId().equals(0)){
//获取它父类的关系级
LambdaQueryWrapper<MaterialTalents> wrapper = new LambdaQueryWrapper<MaterialTalents>()
.eq(MaterialTalents::getId, bo.getParentId());
MaterialTalents materialTalents = baseMapper.selectOne(wrapper);
String selected = materialTalents.getSelected();
if (ObjectUtil.isNull(selected)){
bo.setSelected(materialTalents.getId().toString());
}else {
ArrayList<String> list = new ArrayList<>();
List<String> strings = Arrays.asList(materialTalents.getSelected().split(","));
list.addAll(strings);
list.add(materialTalents.getId().toString());
String join = StringUtils.join(list, ",");
bo.setSelected(join);
}
}
MaterialTalents add = BeanUtil.toBean(bo, MaterialTalents.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改材料关系
*/
@Override
public Boolean updateByBo(MaterialTalentsBo bo) {
if (!bo.getParentId().equals(0L)){
//获取它父类的关系级
LambdaQueryWrapper<MaterialTalents> wrapper = new LambdaQueryWrapper<MaterialTalents>()
.eq(MaterialTalents::getId, bo.getParentId());
MaterialTalents materialTalents = baseMapper.selectOne(wrapper);
String selected = materialTalents.getSelected();
if (ObjectUtil.isEmpty(selected)){
bo.setSelected(materialTalents.getId().toString());
}else {
ArrayList<String> list = new ArrayList<>();
List<String> strings = Arrays.asList(materialTalents.getSelected().split(","));
list.addAll(strings);
list.add(materialTalents.getId().toString());
String join = StringUtils.join(list, ",");
bo.setSelected(join);
}
}
MaterialTalents update = BeanUtil.toBean(bo, MaterialTalents.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(MaterialTalents entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除材料关系
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

View File

@ -23,6 +23,7 @@ import com.ruoyi.system.mapper.SysDeptMapper;
import com.ruoyi.system.mapper.SysRoleMapper;
import com.ruoyi.system.mapper.SysUserMapper;
import com.ruoyi.system.service.ISysDeptService;
import com.ruoyi.work.service.IWorkSysDeptService;
import lombok.RequiredArgsConstructor;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
@ -39,7 +40,7 @@ import java.util.List;
*/
@RequiredArgsConstructor
@Service
public class SysDeptServiceImpl implements ISysDeptService, DeptService {
public class SysDeptServiceImpl implements ISysDeptService, DeptService, IWorkSysDeptService {
private final SysDeptMapper baseMapper;
private final SysRoleMapper roleMapper;

View File

@ -23,6 +23,7 @@ import com.ruoyi.system.mapper.SysRoleMapper;
import com.ruoyi.system.mapper.SysRoleMenuMapper;
import com.ruoyi.system.mapper.SysUserRoleMapper;
import com.ruoyi.system.service.ISysRoleService;
import com.ruoyi.work.service.IWorkSysRoleService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@ -36,7 +37,7 @@ import java.util.*;
*/
@RequiredArgsConstructor
@Service
public class SysRoleServiceImpl implements ISysRoleService {
public class SysRoleServiceImpl implements ISysRoleService, IWorkSysRoleService {
private final SysRoleMapper baseMapper;
private final SysRoleMenuMapper roleMenuMapper;

View File

@ -27,6 +27,7 @@ import com.ruoyi.system.domain.SysUserPost;
import com.ruoyi.system.domain.SysUserRole;
import com.ruoyi.system.mapper.*;
import com.ruoyi.system.service.ISysUserService;
import com.ruoyi.work.service.IWorkSysUserService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.annotation.Cacheable;
@ -45,7 +46,7 @@ import java.util.Map;
@Slf4j
@RequiredArgsConstructor
@Service
public class SysUserServiceImpl implements ISysUserService, UserService {
public class SysUserServiceImpl implements ISysUserService, UserService, IWorkSysUserService {
private final SysUserMapper baseMapper;
private final SysDeptMapper deptMapper;

View File

@ -0,0 +1,149 @@
package com.ruoyi.work.controller;
import cn.dev33.satoken.annotation.SaCheckPermission;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.work.domain.ActProcess;
import com.ruoyi.work.domain.HisProcess;
import com.ruoyi.work.domain.TProcess;
import com.ruoyi.work.domain.vo.ProcessVo;
import com.ruoyi.work.dto.BusinessDTO;
import com.ruoyi.work.dto.ProcessVoResultDto;
import com.ruoyi.work.mapper.ProcessMapper;
import com.ruoyi.work.utils.WorkComplyUtils;
import com.ruoyi.work.utils.WorkUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
/**
* 流程相关
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/work")
@Transactional
public class WorkController extends BaseController {
private final ProcessMapper processMapper;
/**
* 获取待办
*/
@Log(title = "获取待办数据",businessType = BusinessType.OTHER)
@SaCheckPermission("work:task:taskList")
@GetMapping("/getWaitTaskList")
public TableDataInfo<ActProcess> getWaitTaskList(ActProcess actProcess, PageQuery pageQuery){
return WorkComplyUtils.getWaitTaskList(actProcess,pageQuery);
}
/**
* 获取已办
*/
@Log(title = "获取已办数据",businessType = BusinessType.OTHER)
@SaCheckPermission("work:task:historyList")
@GetMapping("/getHistoryList")
public TableDataInfo<HisProcess> getHistoryList(HisProcess hisProcess, PageQuery pageQuery){
return WorkComplyUtils.getHistoryList(hisProcess,pageQuery);
}
/**
* 获取当前业务进行步骤
*/
@Log(title = "获取当前业务运行到那一步",businessType = BusinessType.OTHER)
@SaCheckPermission("work:task:processPlan")
@PostMapping("/processPlan")
public R<?> processPlan(@RequestBody ActProcess actProcess){
LambdaQueryWrapper<TProcess> wrapper = new LambdaQueryWrapper<TProcess>()
.eq(TProcess::getProcessKey, actProcess.getProcessKey());
List<TProcess> tProcesses = processMapper.selectList(wrapper);
if (tProcesses.size()==0){
throw new ServiceException("当前流程不存在");
}
Map<String, Object> map = WorkUtils.getInfoToMap(tProcesses.get(0).getBean(), actProcess.getBusinessId());
ProcessVo processVo = new ProcessVo();
processVo.setBusinessId(actProcess.getBusinessId());
processVo.setParams(map);
List<ProcessVoResultDto> processPlan= WorkComplyUtils.getProcessPlan(processVo);
return R.ok(processPlan);
}
/**
* 获取可退回步骤
*/
@Log(title = "获取可退回步骤",businessType = BusinessType.OTHER)
@PostMapping("/getStep")
public void getStep(@RequestBody BusinessDTO businessDTO){
LambdaQueryWrapper<TProcess> wrapper = new LambdaQueryWrapper<TProcess>()
.eq(TProcess::getProcessKey, businessDTO.getProcessKey());
List<TProcess> tProcesses = processMapper.selectList(wrapper);
if (tProcesses.size()==0){
throw new ServiceException("当前流程不存在");
}
Map<String, Object> map = WorkUtils.getInfoToMap(tProcesses.get(0).getBean(),businessDTO.getBusinessId());
businessDTO.setParams(map);
WorkComplyUtils.getStep(businessDTO);
}
/**
* 流程办理
*/
@Log(title = "流程办理",businessType = BusinessType.OTHER)
@SaCheckPermission("work:task:batchDeleted")
@PostMapping("/batchDeleted")
public R<?> batchDeleted(@RequestBody HisProcess hisProcess){
LambdaQueryWrapper<TProcess> wrapper = new LambdaQueryWrapper<TProcess>()
.eq(TProcess::getProcessKey, hisProcess.getProcessKey());
List<TProcess> tProcesses = processMapper.selectList(wrapper);
if (tProcesses.size()==0){
throw new ServiceException("当前流程不存在");
}
Map<String, Object> map = WorkUtils.getInfoToMap(tProcesses.get(0).getBean(),hisProcess.getBusinessId());
hisProcess.setParams(map);
String s = WorkComplyUtils.batchDeleted(hisProcess);
if (s.equals(Constants.NONENTITY)){
return R.fail("暂无审核");
}else{
processMapper.updateCommonByBusinessId(tProcesses.get(0).getBean(),s, hisProcess.getBusinessId());
}
System.out.println("s = " + s);
return R.ok();
}
/**
* 获取业务id详情数据
* @param actProcess
* @return
*/
@Log(title = "获取业务id详情数据",businessType = BusinessType.OTHER)
@SaCheckPermission("work:task:taskInfo")
@PostMapping("/taskInfo")
public R<?> getInfoById(@RequestBody ActProcess actProcess){
LambdaQueryWrapper<TProcess> wrapper = new LambdaQueryWrapper<TProcess>()
.eq(TProcess::getProcessKey, actProcess.getProcessKey());
List<TProcess> tProcesses = processMapper.selectList(wrapper);
Map<String, Object> map = WorkUtils.getInfoToMap(tProcesses.get(0).getBean(),actProcess.getBusinessId());
return R.ok(map);
}
@Log(title = "获取审核日志",businessType = BusinessType.OTHER)
@PostMapping("/auditLogList")
public R<?> getAuditLogListByOtherId(@RequestBody BusinessDTO businessDTO){
return WorkComplyUtils.getAuditLogListByOtherId(businessDTO);
}
}

View File

@ -0,0 +1,50 @@
package com.ruoyi.work.domain;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ruoyi.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* 业务规则对象 act_business_rule
*
* @author gssong
* @date 2021-12-16
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("act_business_rule")
public class ActBusinessRule extends BaseEntity {
private static final long serialVersionUID=1L;
/**
* id
*/
@TableId(value = "id")
private Long id;
/**
* bean名称
*/
private String beanName;
/**
* 方法名
*/
private String method;
/**
* 参数
*/
private String param;
private String paramType;
/**
* 备注
*/
private String remark;
}

View File

@ -0,0 +1,86 @@
package com.ruoyi.work.domain;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.Data;
import java.util.Date;
/**
* 业务规则视图对象 act_business_rule
*
* @author gssong
* @date 2021-12-16
*/
@Data
@ExcelIgnoreUnannotated
public class ActBusinessRuleVo {
private static final long serialVersionUID = 1L;
/**
* 主键
*/
@ExcelProperty(value = "主键")
private Long id;
/**
* bean名称
*/
@ExcelProperty(value = "bean名称")
private String beanName;
/**
* 方法名
*/
@ExcelProperty(value = "方法名")
private String method;
/**
* 参数
*/
@ExcelProperty(value = "参数")
private String param;
@ExcelProperty(value = "参数类型")
private String paramType;
/**
* 备注
*/
@ExcelProperty(value = "备注")
private String remark;
/**
* 创建时间
*/
@ExcelProperty(value = "创建时间")
private Date createTime;
/**
* 更新时间
*/
@ExcelProperty(value = "更新时间")
private Date updateTime;
/**
* 创建人
*/
@ExcelProperty(value = "创建人")
private String createBy;
/**
* 更新人
*/
@ExcelProperty(value = "更新人")
private String updateBy;
/**
* 参数
*/
// private List<ActBusinessRuleParam> businessRuleParams;
}

View File

@ -0,0 +1,90 @@
package com.ruoyi.work.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.util.Date;
/**
* 流程运作对象 act_process
*
* @author ruoyi
* @date 2023-02-03
*/
@Data
@TableName("act_process")
public class ActProcess {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 流程表id
*/
private String processId;
/**
* 业务id
*/
private String businessId;
/**
* 审核
*/
private String audit;
/**
* 审核类型1人员2.部门3角色
*/
private String checkType;
/**
* 步骤
*/
private String step;
private Date createTime;
/**
* 是由存在下一步骤
*/
private Boolean isNext;
private String type;
private String startUser;
@TableField(exist = false)
private String userId;
@TableField(exist = false)
private String roleId;
@TableField(exist = false)
private String deptId;
@TableField(exist = false)
private String name;
@TableField(exist = false)
private String description;
@TableField(exist = false)
private String bean;
@TableField(exist = false)
private String companyUserId;
private String companyName;
@TableField(exist = false)
private String timeout;
@TableField(exist = false)
private String processKey;
}

View File

@ -0,0 +1,69 @@
package com.ruoyi.work.domain;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.Date;
import java.math.BigDecimal;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 审核日志对象 audit_log
*
* @author ruoyi
* @date 2023-03-22
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("audit_log")
public class AuditLog extends BaseEntity {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 审核员id
*/
private String auditId;
/**
* 审核员姓名
*/
private String adminUserName;
/**
* 关联表id
*/
private String otherId;
/**
* 回复
*/
private String reply;
/**
* 状态 1.待提交 2.受理中 3.受理退件 4.受理驳回 5.初审中 6初审不通过 7.初审退件 8.审定中 9.审定不通过 10.审定通过
*/
private String status;
/**
* 部门角色
*/
private String roleName;
/**
* 推送记录
*/
private String pushLog;
/**
* 审核员类型(1人员,2部门,3角色,4公司)
*/
private String auditType;
private String processKey;
private String audit;
private String step;
}

View File

@ -0,0 +1,92 @@
package com.ruoyi.work.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import java.util.Date;
import java.util.Map;
/**
* 历史运作对象 his_process
*
* @author ruoyi
* @date 2023-02-03
*/
@Data
@TableName("his_process")
public class HisProcess{
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 流程表id
*/
private String processId;
/**
* 业务id
*/
private String businessId;
/**
* 审核
*/
private String audit;
/**
* 审核类型1人员2.部门3角色,4公司
*/
private String checkType;
/**
* 1fail(失败)2success成功
*/
private String status;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
@TableField(exist = false)
private String processKey;
@TableField(exist = false)
private Map params;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date endTime;
private String step;
private String type;
private String startUser;
private String userId;
private String roleId;
private String deptId;
private String companyUserId;
/**
* 相隔时间差
*/
private String timeBetween;
private String companyName;
@TableField(exist = false)
private String reply;
@TableField(exist = false)
private String name;
}

View File

@ -0,0 +1,51 @@
package com.ruoyi.work.domain;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.ruoyi.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* 撤销记录对象 roll_back_log
*
* @author ruoyi
* @date 2023-03-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("roll_back_log")
public class RollBackLog extends BaseEntity {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 是后台撤回还是前台撤回
*/
private String type;
/**
* 撤销原因
*/
private String reply;
/**
* 将运行表中的数据保存
*/
private String param;
private String businessId;
private String step;
private String checked;
private String checkType;
private String audit;
}

View File

@ -0,0 +1,84 @@
package com.ruoyi.work.domain;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.util.Date;
/**
* 流程对象 process
*
* @author ruoyi
* @date 2023-02-03
*/
@Data
@TableName("process")
public class TProcess {
private static final long serialVersionUID=1L;
/**
*
*/
@TableId(value = "id")
private Long id;
/**
* 流程名称
*/
private String name;
/**
* 流程key
*/
private String processKey;
/**
* 流程步骤
*/
private String step;
/**
* 流程类型(1,普通类型2会签3根据接口获取审核部门)
*/
private String type;
/**
* 审核类型1人员2.部门3角色
*/
private String checkType;
/**
* 审核人员
*/
private Long processCheck;
/**
* 抄送人员
*/
private String cc;
/**
* 是由存在下一步骤
*/
private Boolean isNext;
/**
* 创建时间
*/
private Date createTime;
/**
* 业务规则接口id
*/
private Long ruleId;
/**
* 如果不是根据接口获取人员此处就是人员id获取部门,角色id,否则就是空的
*/
private String audit;
private String param;
private String timeout;
private String paramName;
private String bean;
private String description;
}

View File

@ -0,0 +1,57 @@
package com.ruoyi.work.domain.bo;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
/**
* 流程运作业务对象 act_process
*
* @author ruoyi
* @date 2023-02-03
*/
@Data
public class ActProcessBo {
/**
*
*/
@NotNull(message = "不能为空", groups = { EditGroup.class })
private Long id;
/**
* 流程表id
*/
@NotBlank(message = "流程表id不能为空", groups = { AddGroup.class, EditGroup.class })
private String processId;
/**
* 业务id
*/
@NotBlank(message = "业务id不能为空", groups = { AddGroup.class, EditGroup.class })
private String businessId;
/**
* 审核
*/
@NotBlank(message = "审核不能为空", groups = { AddGroup.class, EditGroup.class })
private String audit;
/**
* 审核类型1人员2.部门3角色
*/
@NotBlank(message = "审核类型1人员2.部门3角色不能为空", groups = { AddGroup.class, EditGroup.class })
private String checkType;
/**
* 步骤
*/
@NotBlank(message = "步骤不能为空", groups = { AddGroup.class, EditGroup.class })
private String step;
}

View File

@ -0,0 +1,85 @@
package com.ruoyi.work.domain.bo;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.*;
import java.util.Date;
import com.ruoyi.common.core.domain.BaseEntity;
/**
* 审核日志业务对象 audit_log
*
* @author ruoyi
* @date 2023-03-22
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class AuditLogBo extends BaseEntity {
/**
*
*/
@NotNull(message = "不能为空", groups = { EditGroup.class })
private Long id;
/**
* 审核员id
*/
@NotNull(message = "审核员id不能为空", groups = { AddGroup.class, EditGroup.class })
private String auditId;
/**
* 审核员姓名
*/
@NotBlank(message = "审核员姓名不能为空", groups = { AddGroup.class, EditGroup.class })
private String adminUserName;
/**
* 关联表id
*/
@NotNull(message = "关联表id不能为空", groups = { AddGroup.class, EditGroup.class })
private String otherId;
/**
* 回复
*/
@NotBlank(message = "回复不能为空", groups = { AddGroup.class, EditGroup.class })
private String reply;
/**
* 状态 1.待提交 2.受理中 3.受理退件 4.受理驳回 5.初审中 6初审不通过 7.初审退件 8.审定中 9.审定不通过 10.审定通过
*/
@NotBlank(message = "状态 1.待提交 2.受理中 3.受理退件 4.受理驳回 5.初审中 6初审不通过 7.初审退件 8.审定中 9.审定不通过 10.审定通过不能为空", groups = { AddGroup.class, EditGroup.class })
private String status;
/**
* 部门角色
*/
@NotBlank(message = "部门角色不能为空", groups = { AddGroup.class, EditGroup.class })
private String roleName;
/**
* 推送记录
*/
@NotBlank(message = "推送记录不能为空", groups = { AddGroup.class, EditGroup.class })
private String pushLog;
/**
* 审核员类型(1人员,2部门,3角色,4公司)
*/
@NotBlank(message = "审核员类型(1人员,2部门,3角色,4公司)不能为空", groups = { AddGroup.class, EditGroup.class })
private String auditType;
private String processKey;
private String audit;
private String step;
}

View File

@ -0,0 +1,62 @@
package com.ruoyi.work.domain.bo;
import com.ruoyi.common.core.domain.BaseEntity;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
/**
* 历史运作业务对象 his_process
*
* @author ruoyi
* @date 2023-02-03
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class HisProcessBo extends BaseEntity {
/**
*
*/
@NotNull(message = "不能为空", groups = { EditGroup.class })
private Long id;
/**
* 流程表id
*/
@NotBlank(message = "流程表id不能为空", groups = { AddGroup.class, EditGroup.class })
private String processId;
/**
* 业务id
*/
@NotBlank(message = "业务id不能为空", groups = { AddGroup.class, EditGroup.class })
private String businessId;
/**
* 审核
*/
@NotBlank(message = "审核不能为空", groups = { AddGroup.class, EditGroup.class })
private String check;
/**
* 审核类型1人员2.部门3角色
*/
@NotBlank(message = "审核类型1人员2.部门3角色不能为空", groups = { AddGroup.class, EditGroup.class })
private String checkType;
/**
* 1fail(失败)2success成功
*/
@NotBlank(message = "1fail(失败)2success成功不能为空", groups = { AddGroup.class, EditGroup.class })
private String status;
private String companyName;
}

View File

@ -0,0 +1,96 @@
package com.ruoyi.work.domain.bo;
import com.ruoyi.common.core.domain.BaseEntity;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
/**
* 流程业务对象 process
*
* @author ruoyi
* @date 2023-02-03
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class ProcessBo extends BaseEntity {
/**
*
*/
@NotNull(message = "不能为空", groups = { EditGroup.class })
private Long id;
/**
* 流程名称
*/
@NotBlank(message = "流程名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String name;
/**
* 流程key
*/
@NotBlank(message = "流程key不能为空", groups = { AddGroup.class, EditGroup.class })
private String ProcessKey;
/**
* 流程步骤
*/
@NotBlank(message = "流程步骤不能为空", groups = { AddGroup.class, EditGroup.class })
private String step;
/**
* 流程类型(1,普通类型2会签3根据接口获取审核部门)
*/
@NotBlank(message = "流程类型(1,普通类型2会签3根据接口获取审核部门)不能为空", groups = { AddGroup.class, EditGroup.class })
private String type;
/**
* 审核类型1人员2.部门3角色
*/
@NotBlank(message = "审核类型1人员2.部门3角色不能为空", groups = { AddGroup.class, EditGroup.class })
private String checkType;
/**
* 审核人员
*/
@NotBlank(message = "审核人员不能为空", groups = { AddGroup.class, EditGroup.class })
private Long processCheck;
/**
* 抄送人员
*/
@NotBlank(message = "抄送人员不能为空", groups = { AddGroup.class, EditGroup.class })
private String cc;
/**
* 是由存在下一步骤
*/
@NotNull(message = "是由存在下一步骤不能为空", groups = { AddGroup.class, EditGroup.class })
private Boolean isNext;
/**
* 业务规则接口id
*/
private Long ruleId;
/**
* 如果不是根据接口获取人员此处就是人员id获取部门,角色id,否则就是空的
*/
private String audit;
private String timeout;
private String paramName;
private String bean;
private String description;
}

View File

@ -0,0 +1,9 @@
package com.ruoyi.work.domain.bo;
import lombok.Data;
@Data
public class ReturnBean {
private String name;
private String processKey;
}

View File

@ -0,0 +1,49 @@
package com.ruoyi.work.domain.bo;
import com.ruoyi.common.core.domain.BaseEntity;
import com.ruoyi.common.core.validate.AddGroup;
import com.ruoyi.common.core.validate.EditGroup;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
/**
* 撤销记录业务对象 roll_back_log
*
* @author ruoyi
* @date 2023-03-07
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class RollBackLogBo extends BaseEntity {
/**
*
*/
@NotNull(message = "不能为空", groups = { EditGroup.class })
private Long id;
/**
* 是后台撤回还是前台撤回
*/
@NotBlank(message = "是后台撤回还是前台撤回不能为空", groups = { AddGroup.class, EditGroup.class })
private String type;
/**
* 撤销原因
*/
@NotBlank(message = "撤销原因不能为空", groups = { AddGroup.class, EditGroup.class })
private String reply;
/**
* 将运行表中的数据保存
*/
@NotBlank(message = "将运行表中的数据保存不能为空", groups = { AddGroup.class, EditGroup.class })
private String param;
}

View File

@ -0,0 +1,75 @@
package com.ruoyi.work.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.annotation.ExcelDictFormat;
import com.ruoyi.common.convert.ExcelDictConvert;
import lombok.Data;
import java.util.Date;
/**
* 流程运作视图对象 act_process
*
* @author ruoyi
* @date 2023-02-03
*/
@Data
@ExcelIgnoreUnannotated
public class ActProcessVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 流程表id
*/
@ExcelProperty(value = "流程表id")
private String processId;
/**
* 业务id
*/
@ExcelProperty(value = "业务id")
private String businessId;
/**
* 审核
*/
@ExcelProperty(value = "审核")
private String audit;
/**
* 审核类型1人员2.部门3角色
*/
@ExcelProperty(value = "审核类型", converter = ExcelDictConvert.class)
@ExcelDictFormat(readConverterExp = "1=人员2.部门3角色")
private String checkType;
/**
* 步骤
*/
@ExcelProperty(value = "步骤")
private String step;
private Date createTime=new Date();
/**
* 是由存在下一步骤
*/
@ExcelProperty(value = "是由存在下一步骤")
private Boolean isNext;
private String type;
private String startUser;
}

View File

@ -0,0 +1,86 @@
package com.ruoyi.work.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.annotation.ExcelDictFormat;
import com.ruoyi.common.convert.ExcelDictConvert;
import lombok.Data;
import java.util.Date;
/**
* 审核日志视图对象 audit_log
*
* @author ruoyi
* @date 2023-03-22
*/
@Data
@ExcelIgnoreUnannotated
public class AuditLogVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 审核员id
*/
@ExcelProperty(value = "审核员id")
private String auditId;
/**
* 审核员姓名
*/
@ExcelProperty(value = "审核员姓名")
private String adminUserName;
/**
* 关联表id
*/
@ExcelProperty(value = "关联表id")
private String otherId;
/**
* 回复
*/
@ExcelProperty(value = "回复")
private String reply;
/**
* 状态 1.待提交 2.受理中 3.受理退件 4.受理驳回 5.初审中 6初审不通过 7.初审退件 8.审定中 9.审定不通过 10.审定通过
*/
@ExcelProperty(value = "状态 1.待提交 2.受理中 3.受理退件 4.受理驳回 5.初审中 6初审不通过 7.初审退件 8.审定中 9.审定不通过 10.审定通过")
private String status;
/**
* 部门角色
*/
@ExcelProperty(value = "部门角色")
private String roleName;
/**
* 推送记录
*/
@ExcelProperty(value = "推送记录")
private String pushLog;
/**
* 审核员类型(1人员,2部门,3角色,4公司)
*/
@ExcelProperty(value = "审核员类型(1人员,2部门,3角色,4公司)")
private String auditType;
private String processKey;
private String audit;
private String step;
}

View File

@ -0,0 +1,78 @@
package com.ruoyi.work.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.baomidou.mybatisplus.annotation.TableField;
import com.ruoyi.common.annotation.ExcelDictFormat;
import com.ruoyi.common.convert.ExcelDictConvert;
import lombok.Data;
import java.util.Date;
/**
* 历史运作视图对象 his_process
*
* @author ruoyi
* @date 2023-02-03
*/
@Data
@ExcelIgnoreUnannotated
public class HisProcessVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 流程表id
*/
@ExcelProperty(value = "流程表id")
private String processId;
/**
* 业务id
*/
@ExcelProperty(value = "业务id")
private String businessId;
/**
* 审核
*/
@ExcelProperty(value = "审核")
private String audit;
@TableField(exist = false)
private String audit1;
/**
* 审核类型1人员2.部门3角色
*/
@ExcelProperty(value = "审核类型", converter = ExcelDictConvert.class)
@ExcelDictFormat(readConverterExp = "1=人员2.部门3角色")
private String checkType;
/**
* 1fail(失败)2success成功
*/
@ExcelProperty(value = "1fail(失败)2success", converter = ExcelDictConvert.class)
@ExcelDictFormat(readConverterExp = "成=功")
private String status;
private String step;
private String type;
private String companyName;
private Date createTime;
private String startUser;
}

View File

@ -0,0 +1,117 @@
package com.ruoyi.work.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import com.baomidou.mybatisplus.annotation.TableField;
import com.ruoyi.common.annotation.ExcelDictFormat;
import com.ruoyi.common.convert.ExcelDictConvert;
import com.ruoyi.work.domain.AuditLog;
import lombok.Data;
import java.util.List;
import java.util.Map;
/**
* 流程视图对象 process
*
* @author ruoyi
* @date 2023-02-03
*/
@Data
@ExcelIgnoreUnannotated
public class ProcessVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 流程名称
*/
@ExcelProperty(value = "流程名称")
private String name;
/**
* 流程key
*/
@ExcelProperty(value = "流程key")
private String processKey;
/**
* 流程步骤
*/
@ExcelProperty(value = "流程步骤")
private String step;
/**
* 流程类型(1,普通类型2会签3根据接口获取审核部门)
*/
@ExcelProperty(value = "流程类型(1,普通类型2会签3根据接口获取审核部门)")
private String type;
/**
* 审核类型1人员2.部门3角色
*/
@ExcelProperty(value = "审核类型", converter = ExcelDictConvert.class)
@ExcelDictFormat(readConverterExp = "1=人员2.部门3角色")
private String checkType;
/**
* 审核人员
*/
@ExcelProperty(value = "审核人员类型(1普通,2根据接口获取人员)")
private Long processCheck;
/**
* 抄送人员
*/
@ExcelProperty(value = "抄送人员")
private String cc;
/**
* 是由存在下一步骤
*/
@ExcelProperty(value = "是由存在下一步骤")
private Boolean isNext;
/**
* 如果不是根据接口获取人员此处就是人员id获取部门,角色id,否则就是空的
*/
private String audit;
/**
* 接口所需参数
*/
private String param;
private String paramName;
private Map params;
private Long ruleId;
private String businessId;
private String startUser;
private String timeout;
@TableField(exist = false)
private String checked;
private String bean;
private String description;
@TableField(exist = false)
private List<AuditLog> auditLogList;
}

View File

@ -0,0 +1,60 @@
package com.ruoyi.work.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.Data;
import java.util.Date;
/**
* 撤销记录视图对象 roll_back_log
*
* @author ruoyi
* @date 2023-03-07
*/
@Data
@ExcelIgnoreUnannotated
public class RollBackLogVo {
private static final long serialVersionUID = 1L;
/**
*
*/
@ExcelProperty(value = "")
private Long id;
/**
* 撤销时间
*/
@ExcelProperty(value = "撤销时间")
private Date createTime;
/**
* 是后台撤回还是前台撤回
*/
@ExcelProperty(value = "是后台撤回还是前台撤回")
private String type;
/**
* 撤销原因
*/
@ExcelProperty(value = "撤销原因")
private String reply;
/**
* 撤销人id
*/
@ExcelProperty(value = "撤销人id")
private String createBy;
/**
* 将运行表中的数据保存
*/
@ExcelProperty(value = "将运行表中的数据保存")
private String param;
}

View File

@ -0,0 +1,18 @@
package com.ruoyi.work.dto;
import lombok.Data;
import java.io.Serializable;
import java.util.Map;
@Data
public class BusinessDTO implements Serializable {
private String businessId;
private Map params;
private String processKey;
}

View File

@ -0,0 +1,19 @@
package com.ruoyi.work.dto;
import com.ruoyi.work.domain.vo.HisProcessVo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import java.util.List;
@Data
@EqualsAndHashCode
@AllArgsConstructor
@NoArgsConstructor
public class HisProcessVoResultDto {
private String step;
private List<HisProcessVo> hisProcessVoList;
}

View File

@ -0,0 +1,19 @@
package com.ruoyi.work.dto;
import com.ruoyi.work.domain.vo.ProcessVo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import java.util.List;
@Data
@EqualsAndHashCode
@AllArgsConstructor
@NoArgsConstructor
public class ProcessVoResultDto {
private String step;
private List<ProcessVo> processVoList;
}

View File

@ -0,0 +1,15 @@
package com.ruoyi.work.mapper;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
import com.ruoyi.work.domain.ActBusinessRule;
import com.ruoyi.work.domain.ActBusinessRuleVo;
/**
* 业务规则Mapper接口
*
* @author gssong
* @date 2021-12-16
*/
public interface ActBusinessRuleMapper extends BaseMapperPlus<ActBusinessRuleMapper, ActBusinessRule, ActBusinessRuleVo> {
}

View File

@ -0,0 +1,24 @@
package com.ruoyi.work.mapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
import com.ruoyi.work.domain.ActProcess;
import com.ruoyi.work.domain.vo.ActProcessVo;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* 流程运作Mapper接口
*
* @author ruoyi
* @date 2023-02-03
*/
@Mapper
public interface ActProcessMapper extends BaseMapperPlus<ActProcessMapper, ActProcess, ActProcessVo> {
Page<ActProcess> selectVoListPage(@Param("page") Page<ActProcess> page, @Param("actProcess") ActProcess actProcess);
Page<ActProcess> selectCCList(@Param("page") Page<ActProcess> page, @Param("actProcess") ActProcess actProcess);
ActProcess selectByIdResultBean2BusinessId(@Param("id") Long id);
}

View File

@ -0,0 +1,15 @@
package com.ruoyi.work.mapper;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
import com.ruoyi.work.domain.AuditLog;
import com.ruoyi.work.domain.vo.AuditLogVo;
/**
* 审核日志Mapper接口
*
* @author ruoyi
* @date 2023-03-22
*/
public interface AuditLogMapper extends BaseMapperPlus<AuditLogMapper, AuditLog, AuditLogVo> {
}

View File

@ -0,0 +1,19 @@
package com.ruoyi.work.mapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
import com.ruoyi.work.domain.HisProcess;
import com.ruoyi.work.domain.vo.HisProcessVo;
import org.apache.ibatis.annotations.Param;
/**
* 历史运作Mapper接口
*
* @author ruoyi
* @date 2023-02-03
*/
public interface HisProcessMapper extends BaseMapperPlus<HisProcessMapper, HisProcess, HisProcessVo> {
Page<HisProcess> selectVoListPage(@Param("page") Page<HisProcess> page, @Param("hisProcess") HisProcess hisProcess);
}

View File

@ -0,0 +1,18 @@
package com.ruoyi.work.mapper;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
import com.ruoyi.work.domain.TProcess;
import com.ruoyi.work.domain.vo.ProcessVo;
import org.apache.ibatis.annotations.Param;
/**
* 流程Mapper接口
*
* @author ruoyi
* @date 2023-02-03
*/
public interface ProcessMapper extends BaseMapperPlus<ProcessMapper, TProcess, ProcessVo> {
boolean updateCommonByBusinessId(@Param("bean") String bean, @Param("processStatus") String processStatus, @Param("businessId") String businessId);
}

View File

@ -0,0 +1,15 @@
package com.ruoyi.work.mapper;
import com.ruoyi.common.core.mapper.BaseMapperPlus;
import com.ruoyi.work.domain.RollBackLog;
import com.ruoyi.work.domain.vo.RollBackLogVo;
/**
* 撤销记录Mapper接口
*
* @author ruoyi
* @date 2023-03-07
*/
public interface RollBackLogMapper extends BaseMapperPlus<RollBackLogMapper, RollBackLog, RollBackLogVo> {
}

View File

@ -0,0 +1,48 @@
package com.ruoyi.work.service;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.work.domain.bo.ProcessBo;
import com.ruoyi.work.domain.vo.ProcessVo;
import java.util.Collection;
import java.util.List;
/**
* 流程Service接口
*
* @author ruoyi
* @date 2023-02-03
*/
public interface IProcessService {
/**
* 查询流程
*/
ProcessVo queryById(Long id);
/**
* 查询流程列表
*/
TableDataInfo<ProcessVo> queryPageList(ProcessBo bo, PageQuery pageQuery);
/**
* 查询流程列表
*/
List<ProcessVo> queryList(ProcessBo bo);
/**
* 新增流程
*/
Boolean insertByBo(ProcessBo bo);
/**
* 修改流程
*/
Boolean updateByBo(ProcessBo bo);
/**
* 校验并批量删除流程信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

View File

@ -0,0 +1,62 @@
package com.ruoyi.work.service;
import cn.hutool.core.lang.tree.Tree;
import com.ruoyi.common.core.domain.entity.SysDept;
import java.util.List;
/**
* 部门管理 服务层
*
* @author Lion Li
*/
public interface IWorkSysDeptService {
/**
* 查询部门管理数据
*
* @param dept 部门信息
* @return 部门信息集合
*/
List<SysDept> selectDeptList(SysDept dept);
/**
* 查询部门树结构信息
*
* @param dept 部门信息
* @return 部门树信息集合
*/
List<Tree<Long>> selectDeptTreeList(SysDept dept);
/**
* 构建前端所需要下拉树结构
*
* @param depts 部门列表
* @return 下拉树结构列表
*/
List<Tree<Long>> buildDeptTreeSelect(List<SysDept> depts);
/**
* 根据角色ID查询部门树信息
*
* @param roleId 角色ID
* @return 选中部门列表
*/
List<Long> selectDeptListByRoleId(Long roleId);
/**
* 根据部门ID查询信息
*
* @param deptId 部门ID
* @return 部门信息
*/
SysDept selectDeptById(Long deptId);
/**
* 根据ID查询所有子部门数正常状态
*
* @param deptId 部门ID
* @return 子部门数
*/
long selectNormalChildrenDeptById(Long deptId);
}

View File

@ -0,0 +1,63 @@
package com.ruoyi.work.service;
import com.ruoyi.common.core.domain.entity.SysRole;
import java.util.List;
import java.util.Set;
/**
* 角色业务层
*
* @author Lion Li
*/
public interface IWorkSysRoleService {
/**
* 根据条件分页查询角色数据
*
* @param role 角色信息
* @return 角色数据集合信息
*/
List<SysRole> selectRoleList(SysRole role);
/**
* 根据用户ID查询角色列表
*
* @param userId 用户ID
* @return 角色列表
*/
List<SysRole> selectRolesByUserId(Long userId);
/**
* 根据用户ID查询角色权限
*
* @param userId 用户ID
* @return 权限列表
*/
Set<String> selectRolePermissionByUserId(Long userId);
/**
* 查询所有角色
*
* @return 角色列表
*/
List<SysRole> selectRoleAll();
/**
* 根据用户ID获取角色选择框列表
*
* @param userId 用户ID
* @return 选中角色ID列表
*/
List<Long> selectRoleListByUserId(Long userId);
/**
* 通过角色ID查询角色
*
* @param roleId 角色ID
* @return 角色对象信息
*/
SysRole selectRoleById(Long roleId);
}

View File

@ -0,0 +1,54 @@
package com.ruoyi.work.service;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.page.TableDataInfo;
import java.util.List;
/**
* 用户 业务层
*
* @author Lion Li
*/
public interface IWorkSysUserService {
/**
* 根据条件分页查询用户列表
*
* @param user 用户信息
* @return 用户信息集合信息
*/
List<SysUser> selectUserList(SysUser user);
/**
* 通过用户名查询用户
*
* @param userName 用户名
* @return 用户对象信息
*/
SysUser selectUserByUserName(String userName);
/**
* 通过手机号查询用户
*
* @param phonenumber 手机号
* @return 用户对象信息
*/
SysUser selectUserByPhonenumber(String phonenumber);
/**
* 通过用户ID查询用户
*
* @param userId 用户ID
* @return 用户对象信息
*/
SysUser selectUserById(Long userId);
}

View File

@ -0,0 +1,122 @@
package com.ruoyi.work.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.work.domain.TProcess;
import com.ruoyi.work.domain.bo.ProcessBo;
import com.ruoyi.work.domain.vo.ProcessVo;
import com.ruoyi.work.mapper.ProcessMapper;
import com.ruoyi.work.service.IProcessService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.Collection;
import java.util.List;
/**
* 流程Service业务层处理
*
* @author ruoyi
* @date 2023-02-03
*/
@RequiredArgsConstructor
@Service
public class ProcessServiceImpl implements IProcessService {
private final ProcessMapper baseMapper;
/**
* 查询流程
*/
@Override
public ProcessVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 查询流程列表
*/
@Override
public TableDataInfo<ProcessVo> queryPageList(ProcessBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<TProcess> lqw = buildQueryWrapper(bo);
Page<ProcessVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询流程列表
*/
@Override
public List<ProcessVo> queryList(ProcessBo bo) {
LambdaQueryWrapper<TProcess> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<TProcess> buildQueryWrapper(ProcessBo bo) {
LambdaQueryWrapper<TProcess> lqw = Wrappers.lambdaQuery();
lqw.like(StringUtils.isNotBlank(bo.getName()), TProcess::getName, bo.getName());
lqw.eq(StringUtils.isNotBlank(bo.getProcessKey()), TProcess::getProcessKey, bo.getProcessKey());
lqw.eq(StringUtils.isNotBlank(bo.getStep()), TProcess::getStep, bo.getStep());
lqw.eq(StringUtils.isNotBlank(bo.getType()), TProcess::getType, bo.getType());
lqw.eq(StringUtils.isNotBlank(bo.getCheckType()), TProcess::getCheckType, bo.getCheckType());
lqw.eq(StringUtils.isNotBlank(bo.getProcessCheck().toString()), TProcess::getProcessCheck, bo.getProcessCheck());
lqw.eq(StringUtils.isNotBlank(bo.getCc()), TProcess::getCc, bo.getCc());
lqw.eq(bo.getIsNext() != null, TProcess::getIsNext, bo.getIsNext());
return lqw;
}
/**
* 新增流程
*/
@Override
public Boolean insertByBo(ProcessBo bo) {
TProcess add = BeanUtil.toBean(bo, TProcess.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改流程
*/
@Override
public Boolean updateByBo(ProcessBo bo) {
TProcess update = BeanUtil.toBean(bo, TProcess.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(TProcess entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除流程
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
/**
* 通过流程表将人员添加到运行流程表中
*/
}

View File

@ -0,0 +1,736 @@
package com.ruoyi.work.utils;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.date.BetweenFormatter;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUnit;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.core.domain.PageQuery;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.core.domain.entity.SysRole;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.helper.LoginHelper;
import com.ruoyi.common.utils.BeanCopyUtils;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.JsonUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.work.domain.*;
import com.ruoyi.work.domain.vo.ActProcessVo;
import com.ruoyi.work.domain.vo.HisProcessVo;
import com.ruoyi.work.domain.vo.ProcessVo;
import com.ruoyi.work.dto.BusinessDTO;
import com.ruoyi.work.dto.ProcessVoResultDto;
import com.ruoyi.work.mapper.*;
import com.ruoyi.work.service.IWorkSysDeptService;
import com.ruoyi.work.service.IWorkSysRoleService;
import com.ruoyi.work.service.IWorkSysUserService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import java.util.stream.Collectors;
/**
* 流程相关工具类
*/
@Component
@RequiredArgsConstructor
@Transactional
public class WorkComplyUtils {
private static final ProcessMapper processMapper = SpringUtils.getBean(ProcessMapper.class);
private static final ActProcessMapper actProcessMapper = SpringUtils.getBean(ActProcessMapper.class);
private static final HisProcessMapper hisProcessMapper = SpringUtils.getBean(HisProcessMapper.class);
private static final IWorkSysRoleService sysRoleMapper= SpringUtils.getBean(IWorkSysRoleService.class);
private static final RollBackLogMapper rollBackLogMapper= SpringUtils.getBean(RollBackLogMapper.class);
private static final IWorkSysUserService sysUserMapper = SpringUtils.getBean(IWorkSysUserService.class);
private static final IWorkSysDeptService sysDeptMapper = SpringUtils.getBean(IWorkSysDeptService.class);
private static final AuditLogMapper auditLogMapper =SpringUtils.getBean(AuditLogMapper.class);
/**
* 任务创建
* @param processVo
*/
public static void comply(ProcessVo processVo){
ActProcess actProcessVo = new ActProcess();
LambdaQueryWrapper<TProcess> lqw = Wrappers.lambdaQuery();
lqw.eq( TProcess::getProcessKey, processVo.getProcessKey());
lqw.eq(TProcess::getStep, processVo.getStep());
//判断这条业务是否在进行中
LambdaQueryWrapper<ActProcess> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(ActProcess::getBusinessId,processVo.getBusinessId());
List<ActProcessVo> actProcessVos = actProcessMapper.selectVoList(queryWrapper);
if (actProcessVos.size()>0){
throw new ServiceException("当前业务正在审核中,请耐心等待");
}
ProcessVo tProcessByKey = processMapper.selectVoOne(lqw);
actProcessVo.setCreateTime(DateUtils.getNowDate());
actProcessVo.setCheckType(tProcessByKey.getCheckType());
actProcessVo.setStep(tProcessByKey.getStep());
actProcessVo.setStartUser(processVo.getStartUser());
actProcessVo.setProcessId(tProcessByKey.getId().toString());
actProcessVo.setBusinessId(processVo.getBusinessId());
actProcessVo.setIsNext(tProcessByKey.getIsNext());
if ("1".equals(tProcessByKey.getType())){//普通流程,只需要将人员设置到运行流程中即可
actProcessVo.setType(tProcessByKey.getType());
if (1L==tProcessByKey.getProcessCheck()) {
if("4".equals(tProcessByKey.getCheckType())){//企业审核
String audit = processVo.getParams().get(tProcessByKey.getParam()).toString();
actProcessVo.setAudit(audit);
}else {
actProcessVo.setAudit(tProcessByKey.getAudit());
}
}else if (2==tProcessByKey.getProcessCheck()){
// 根据接口获取
List<String> personByRule = WorkUtils.getPersonByRule(tProcessByKey.getRuleId(),processVo.getParams());
actProcessVo.setAudit(personByRule.get(0));
}
actProcessMapper.insert(actProcessVo);
}else if ("2".equals(tProcessByKey.getType())){//会签
actProcessVo.setType(tProcessByKey.getType());
//将check以逗号拆分
List<ActProcess> list = new ArrayList<>();
if (1L==tProcessByKey.getProcessCheck()) {
String[] split = tProcessByKey.getAudit().split(",");
for (String s : split) {
ActProcess actProcess = new ActProcess();
BeanCopyUtils.copy(actProcessVo,actProcess);
actProcess.setAudit(s);
list.add(actProcess);
}
}else if (2L==tProcessByKey.getProcessCheck()){
//根据接口获取
ArrayList<String> personByRule = WorkUtils.getPersonByRule(tProcessByKey.getRuleId(),processVo.getParams());
//将某些固定的审核人员添加进去
if (ObjectUtil.isNotEmpty(tProcessByKey.getAudit())){
String[] split = tProcessByKey.getAudit().split(",");
Collections.addAll(personByRule,split);
}
for (String s : personByRule) {
ActProcess actProcess = new ActProcess();
BeanUtil.copyProperties(actProcessVo,actProcess);
actProcessVo.setAudit(s);
list.add(actProcess);
}
}
boolean b = actProcessMapper.insertBatch(list);
System.out.println("b = " + b);
}
}
/**
* 业务办理
* wait,等待,success成功,fail失败
* 状态:1已提交待审核,2审核成功,3失败
* 1.往hisProcess添加数据
* 2.根据businessId删除actProcess
*/
public static String batchDeleted(HisProcess hisProcess){
hisProcess.setEndTime(DateUtils.getNowDate());
//获取当前购房信息
//1.得到当前这条运行任务
LambdaQueryWrapper<ActProcess> lqw = new LambdaQueryWrapper<>();
lqw.eq(ActProcess::getBusinessId,hisProcess.getBusinessId());
List<ActProcessVo> actProcessVos = actProcessMapper.selectVoList(lqw);
LoginUser loginUser = LoginHelper.getLoginUser();
if (actProcessVos.size()>0){
//根据审核人员类型判断流程中那条数据属于当前人的
String checkType = actProcessVos.get(0).getCheckType();
String audit ="";
if ("1".equals(checkType) || "4".equals(checkType)){
audit=loginUser.getUserId().toString();
}else if ("2".equals(checkType)){
audit = loginUser.getDeptId().toString();
}else if ("3".equals(checkType)){
audit = loginUser.getRoleId().toString();
}
String finalAudit = audit;
List<ActProcessVo> collect = actProcessVos.stream().filter(e -> checkType.equals(e.getCheckType()) && finalAudit.equals(e.getAudit())).collect(Collectors.toList());
if (collect.size()>0) {
ActProcessVo actProcessVo = collect.get(0);
hisProcess.setCheckType(actProcessVo.getCheckType());
//往历史表里面添加当前数据
hisProcess.setProcessId(actProcessVo.getProcessId());
hisProcess.setCreateTime(actProcessVo.getCreateTime());
hisProcess.setStep(actProcessVo.getStep());
hisProcess.setType(actProcessVo.getType());
hisProcess.setStartUser(actProcessVo.getStartUser());
if ("1".equals(actProcessVo.getCheckType())) {//人员id
Long userId = loginUser.getUserId();
hisProcess.setAudit(ObjectUtil.isNotEmpty(userId) ? userId.toString() : "");
} else if ("2".equals(actProcessVo.getCheckType())) {//部门
Long deptId = loginUser.getDeptId();
hisProcess.setAudit(ObjectUtil.isNotEmpty(deptId) ? deptId.toString() : "");
} else if ("3".equals(actProcessVo.getCheckType())) {//角色
Long roleId = loginUser.getRoleId();
hisProcess.setAudit(ObjectUtil.isNotEmpty(roleId) ? roleId.toString() : "");
} else if ("4".equals(actProcessVo.getCheckType())) {//企业
Long userId = loginUser.getUserId();
hisProcess.setCompanyName(hisProcess.getParams().get("companyName").toString());
hisProcess.setAudit(ObjectUtil.isNotEmpty(userId) ? userId.toString() : "");
}
//先添加一个属于当前用户的记录
hisProcessMapper.insert(hisProcess);
//todo 保存一条审核日志
AuditLog auditLog = new AuditLog();
auditLog.setOtherId(hisProcess.getBusinessId());//业务id
auditLog.setProcessKey(hisProcess.getProcessKey());//流程key
auditLog.setAuditId(loginUser.getUserId().toString());//审核人id
auditLog.setAuditType(checkType);//审核类型
auditLog.setStatus(hisProcess.getStatus());//审核状态
auditLog.setReply(hisProcess.getReply());//原因
auditLog.setAudit(hisProcess.getAudit());
auditLog.setAdminUserName(loginUser.getUsername());
auditLog.setStep(actProcessVo.getStep());
auditLogMapper.insert(auditLog);
//如果成功就删除当前条0
if ("1".equals(hisProcess.getStatus())) {//失败删除全部当前业务相关数据
//删除当前业务的数据
List<Long> collect1 = actProcessVos.stream().map(ActProcessVo::getId).collect(Collectors.toList());
actProcessMapper.deleteBatchIds(collect1);
return Constants.FAILD;
} else if ("2".equals(hisProcess.getStatus())) {//审核成功
//修改业务表的状态,0保持,1提交,审核中,2成功,3失败
//判断是否只剩最后一条记录
//删除当前运行数据
actProcessMapper.deleteById(actProcessVo.getId());
if (actProcessVos.size() == 1) {//只存在当前流程的最后一条业务
//判断是否还有下一步
if (actProcessVo.getIsNext()) {//存在下一级
ProcessVo processVo = new ProcessVo();
processVo.setProcessKey(hisProcess.getProcessKey());
Integer step = new Integer(actProcessVo.getStep()) + 1;
processVo.setStep(step.toString());
processVo.setParams(hisProcess.getParams());
processVo.setBusinessId(hisProcess.getBusinessId());
processVo.setStartUser(actProcessVo.getStartUser());
comply(processVo);
return Constants.WAIT;
} else {
//业务办结
return Constants.SUCCEED;
}
}
return Constants.WAIT;
}
}else {
throw new ServiceException("当前不具备审核资格");
}
}
return Constants.NONENTITY;
}
/**
* 业务撤回
* 后台人员执行撤销,可以撤销到任何地步
*/
public static int rollBack(RollBackLog rollBackLog){
Long userId = LoginHelper.getUserId();
if (ObjectUtil.isNull(userId)){
throw new ServiceException("请先登录");
}
//获取到历史表中的需要回退到那一步的最新数据
LambdaQueryWrapper<HisProcess> lqw = new LambdaQueryWrapper<HisProcess>()
.eq(HisProcess::getStep,rollBackLog.getStep())
.eq(HisProcess::getBusinessId,rollBackLog.getBusinessId())
.eq(HisProcess::getCheckType,rollBackLog.getCheckType())
.eq(HisProcess::getAudit,rollBackLog.getAudit())
.orderByDesc(HisProcess::getEndTime);
List<HisProcessVo> hisProcessVos = hisProcessMapper.selectVoList(lqw);
String param ="";
//获取当前流程的数据
LambdaQueryWrapper<ActProcess> eq = new LambdaQueryWrapper<ActProcess>()
.eq(ObjectUtil.isNotEmpty(rollBackLog.getBusinessId()), ActProcess::getBusinessId, rollBackLog.getBusinessId());
ActProcess actProcesses = actProcessMapper.selectList(eq).get(0);
//如果选择回退的步骤在历史表之前,将流程表中的流程替换为当前历史表中的数据
if (!rollBackLog.getStep().equals(actProcesses.getStep())){
LambdaQueryWrapper<ActProcess> eq1 = new LambdaQueryWrapper<ActProcess>()
.eq(ObjectUtil.isNotNull(rollBackLog.getBusinessId()), ActProcess::getBusinessId, rollBackLog.getBusinessId());
List<ActProcess> actProcesses1 = actProcessMapper.selectList(eq1);
List<Long> collect = actProcesses1.stream().map(ActProcess::getId).collect(Collectors.toList());
param = JsonUtils.toJsonString(actProcesses1);
actProcessMapper.deleteBatchIds(collect);
}else {
param = JsonUtils.toJsonString(hisProcessVos.get(0));
}
//如果回退的是当前流程中的步骤(会签),当前会签流程已走了一半,将流程历史表中的记录返回到流程表中
HisProcessVo hisProcessVo = hisProcessVos.get(0);
ActProcess actProcess = new ActProcess();
actProcess.setIsNext(actProcesses.getIsNext());
actProcess.setType(hisProcessVo.getType());
actProcess.setCheckType(hisProcessVo.getCheckType());
actProcess.setCompanyName(hisProcessVo.getCompanyName());
actProcess.setCreateTime(hisProcessVo.getCreateTime());
actProcess.setStep(hisProcessVo.getStep());
actProcess.setStartUser(hisProcessVo.getStartUser());
actProcess.setBusinessId(hisProcessVo.getBusinessId());
actProcess.setAudit(hisProcessVo.getAudit());
actProcess.setProcessId(hisProcessVo.getProcessId());
int insert = actProcessMapper.insert(actProcess);
rollBackLog.setCreateTime(DateUtils.getNowDate());
rollBackLog.setParam(param);
rollBackLog.setUpdateBy(userId.toString());
rollBackLogMapper.insert(rollBackLog);
return insert;
}
/**
* 申请人业务撤回
*/
public static void businessRollBack(RollBackLog rollBackLog){
Long userId = LoginHelper.getUserId();
if (ObjectUtil.isNull(userId)){
throw new ServiceException("请先登录");
}
//判断当前业务是否可以撤销(如果正在运行表中已无业务id则该条业务已完成)
LambdaQueryWrapper<ActProcess> eq = new LambdaQueryWrapper<ActProcess>()
.eq(ActProcess::getBusinessId, rollBackLog.getBusinessId());
List<ActProcess> actProcesses = actProcessMapper.selectList(eq);
if (actProcesses.size()==0){
throw new ServiceException("当前业务不允许撤销");
}
//创建一条撤销记录,
String param = JsonUtils.toJsonString(actProcesses);
rollBackLog.setCreateTime(DateUtils.getNowDate());
rollBackLog.setParam(param);
rollBackLog.setType("1");
rollBackLog.setUpdateBy(userId.toString());
rollBackLogMapper.insert(rollBackLog);
//删除正在运行的流程记录
List<Long> collect = actProcesses.stream().map(ActProcess::getId).collect(Collectors.toList());
actProcessMapper.deleteBatchIds(collect);
}
/**获取已办步骤
* 获取可以撤销的步骤以及人员,需要判断是后台还是申请人
* 先判断这条流程走到那一步了,可以撤回到那几步
*/
public static Map<String, List<HisProcessVo>>getStep(BusinessDTO businessDTO){
//获取当前任务执行到那一步了
LambdaQueryWrapper<ActProcess> lwq = new LambdaQueryWrapper<>();
lwq.eq(ActProcess::getBusinessId,businessDTO.getBusinessId());
List<ActProcessVo> actProcessVos = actProcessMapper.selectVoList(lwq);
if (actProcessVos.size()==0){
throw new ServiceException("当前任务已完结");
}else {
ActProcessVo actProcessVo = actProcessVos.get(0);
String step = actProcessVo.getStep();
//如果当前业务就是在第一步,则不返回数据
if (!"1".equals(step)){
//获取历史表中在该业务流程步骤之前的人员数据,根据业务表的更新时间为节点
Object updateTime = businessDTO.getParams().get("updateTime");
LambdaQueryWrapper<HisProcess> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(HisProcess::getBusinessId,businessDTO.getBusinessId());
wrapper.ge(HisProcess::getStep,"1");
wrapper.lt(HisProcess::getStep,step);
wrapper.ge(HisProcess::getCreateTime,updateTime);
wrapper.orderByAsc(HisProcess::getStep);
List<HisProcessVo> hisProcessVos = hisProcessMapper.selectVoList(wrapper);
for (HisProcessVo hisProcessVo : hisProcessVos) {
if ("4".equals(hisProcessVo)){//企业
String companyName = businessDTO.getParams().get("companyName").toString();
hisProcessVo.setAudit(companyName);
}else{
if ("1".equals(hisProcessVo.getCheckType())){//人才
String username = LoginHelper.getUsername();
hisProcessVo.setAudit1(username);
}else if ("2".equals(hisProcessVo.getCheckType())){//部门
String deptName = LoginHelper.getLoginUser().getDeptName();
hisProcessVo.setAudit1(deptName);
}else if ("3".equals(hisProcessVo.getCheckType())){//角色
Long roleId = LoginHelper.getLoginUser().getRoleId();
SysRole sysRole = sysRoleMapper.selectRoleById(roleId);
hisProcessVo.setAudit1(sysRole.getRoleName());
}else if ("4".equals(hisProcessVo.getCheckType())){//公司
hisProcessVo.setAudit1(hisProcessVo.getCompanyName());
}
}
}
//将每个步骤处理为单个对象
Map<String, List<HisProcessVo>> collect = hisProcessVos.stream().collect(Collectors.groupingBy(HisProcessVo::getStep));
System.out.println("collect = " + collect);
/* List<HisProcessVoResultDto> collect1 = collect.entrySet()
.stream()
.map(e -> new HisProcessVoResultDto(e.getKey(), e.getValue()))
.collect(Collectors.toList());
collect1.forEach(e ->{
String s = e.getHisProcessVoList().stream().map(ProcessVo::getDescription).collect(Collectors.toList()).get(0);
e.setStep(s);
});*/
return collect;
}
}
return null;
}
/**
* 获取已办任务
*/
public static TableDataInfo<HisProcess> getHistoryList(HisProcess hisProcess,PageQuery pageQuery){
LoginUser loginUser = LoginHelper.getLoginUser();
hisProcess.setUserId(ObjectUtil.isNotNull(loginUser.getUserId())?loginUser.getUserId().toString():"");
hisProcess.setRoleId(ObjectUtil.isNotNull(loginUser.getRoleId())?loginUser.getRoleId().toString():"");
hisProcess.setDeptId(ObjectUtil.isNotNull(loginUser.getDeptId())?loginUser.getDeptId().toString():"");
if ("4".equals(hisProcess.getCheckType())){
hisProcess.setCompanyUserId(ObjectUtil.isNotNull(loginUser.getUserId())?loginUser.getUserId().toString():"");
}
Page<HisProcess> hisProcessPage = hisProcessMapper.selectVoListPage(pageQuery.build(), hisProcess);
List<HisProcess> records = hisProcessPage.getRecords();
for (HisProcess record : records) {
if("4".equals(record.getCheckType())){//企业审核
record.setAudit(record.getCompanyName());
}else if("1".equals(record.getCheckType())) {
//根据id获取人员信息
SysUser sysUser = sysUserMapper.selectUserById(new Long( record.getAudit()));
record.setAudit(sysUser.getUserName());
}else if ("2".equals(record.getCheckType())){
SysDept sysDept = sysDeptMapper.selectDeptById(new Long(record.getAudit()));
record.setAudit(sysDept.getDeptName());
}else if ("3".equals(record.getCheckType())){
SysRole sysRole = sysRoleMapper.selectRoleById(new Long(record.getAudit()));
record.setAudit(sysRole.getRoleName());
}
switch (record.getType()){
case "1" :record.setType("基本类型");
break;
case "2" : record.setType("会签");
break;
default:record.setType("未知类型");
break;
}
//获取当前业务处理耗时
Date date1 = record.getCreateTime();
Date date2 = record.getEndTime();
//精确到秒
String formatBetween = DateUtil.formatBetween(date1, date2, BetweenFormatter.Level.SECOND);
record.setTimeBetween(formatBetween);
}
return TableDataInfo.build(hisProcessPage);
}
/**
* 获取待办业务
*/
public static TableDataInfo<ActProcess> getWaitTaskList(ActProcess actProcess,PageQuery pageQuery){
LoginUser loginUser = LoginHelper.getLoginUser();
if (ObjectUtil.isNull(loginUser.getUserId())){
throw new ServiceException("请先登录");
}
actProcess.setUserId(loginUser.getUserId().toString());
//获取所有流程中的抄送人员
//后台查看待审核页面
if (!"4".equals(actProcess)) {
Page<ActProcess> actProcessVoCCList = actProcessMapper.selectCCList(pageQuery.build(), actProcess);
if (actProcessVoCCList.getRecords().size() > 0) {
for (ActProcess record : actProcessVoCCList.getRecords()) {
if ("1".equals(record.getCheckType())){//人员
String username = loginUser.getUsername();
record.setAudit(username);
}
if ("2".equals(record.getCheckType())){//部门
String deptName = loginUser.getDeptName();
record.setAudit(deptName);
}
if ("3".equals(record.getCheckType())){//角色
Long roleId = loginUser.getRoleId();
SysRole sysRole = sysRoleMapper.selectRoleById(roleId);
record.setAudit(sysRole.getRoleName());
}
if ("4".equals(record.getCheckType())){//公司
record.setAudit(record.getCompanyName());
}
if (ObjectUtil.isNotEmpty(record.getTimeout())&& ObjectUtil.isNotNull(record.getTimeout())){
DateTime beforeTime = DateUtil.offsetDay(record.getCreateTime(), new Integer(record.getTimeout()));
Date nowDate = DateUtils.getNowDate();
long between = DateUtil.between(nowDate, beforeTime, DateUnit.DAY);
if (between<0){
long abs = Math.abs(between);
record.setTimeout("超时"+abs+"");
}else {
record.setTimeout("剩余"+between+"");
}
}
switch (record.getType()){
case "1" :record.setType("基本类型");
break;
case "2" : record.setType("会签");
break;
default:record.setType("未知类型");
break;
}
}
return TableDataInfo.build(actProcessVoCCList);
}
}
if ("4".equals(actProcess.getCheckType())){
actProcess.setCompanyUserId(ObjectUtil.isNotNull(loginUser.getUserId())?loginUser.getUserId().toString():"");
Page<ActProcess> actProcessVoList = actProcessMapper.selectVoListPage(pageQuery.build(),actProcess);
List<ActProcess> records = actProcessVoList.getRecords();
for (ActProcess record : records) {
if ("4".equals(record.getCheckType())){//公司
record.setAudit(record.getCompanyName());
}
if (ObjectUtil.isNotEmpty(record.getTimeout())&& ObjectUtil.isNotNull(record.getTimeout())){
DateTime beforeTime = DateUtil.offsetDay(record.getCreateTime(), new Integer(record.getTimeout()));
Date nowDate = DateUtils.getNowDate();
long between = DateUtil.between(nowDate, beforeTime, DateUnit.DAY);
if (between<0){
long abs = Math.abs(between);
record.setTimeout("超时"+abs+"");
}else {
record.setTimeout("剩余"+between+"");
}
}
switch (record.getType()){
case "1" :record.setType("基本类型");
break;
case "2" : record.setType("会签");
break;
default:record.setType("未知类型");
break;
}
}
return TableDataInfo.build(actProcessVoList);
}
actProcess.setUserId(ObjectUtil.isNotNull(loginUser.getUserId())?loginUser.getUserId().toString():"");
actProcess.setRoleId(ObjectUtil.isNotNull(loginUser.getRoleId())?loginUser.getRoleId().toString():"");
actProcess.setDeptId(ObjectUtil.isNotNull(loginUser.getDeptId())?loginUser.getDeptId().toString():"");
Page<ActProcess> actProcessVoList = actProcessMapper.selectVoListPage(pageQuery.build(),actProcess);
List<ActProcess> records = actProcessVoList.getRecords();
for (ActProcess record : records) {
if ("1".equals(record.getCheckType())){//人员
String username = loginUser.getUsername();
record.setAudit(username);
}
if ("2".equals(record.getCheckType())){//部门
String deptName = loginUser.getDeptName();
record.setAudit(deptName);
}
if ("3".equals(record.getCheckType())){//角色
Long roleId = loginUser.getRoleId();
SysRole sysRole = sysRoleMapper.selectRoleById(roleId);
record.setAudit(sysRole.getRoleName());
}
switch (record.getType()){
case "1" :record.setType("基本类型");
break;
case "2" : record.setType("会签");
break;
default:record.setType("未知类型");
break;
}
if (ObjectUtil.isNotEmpty(record.getTimeout())&& ObjectUtil.isNotNull(record.getTimeout())){
DateTime beforeTime = DateUtil.offsetDay(record.getCreateTime(), new Integer(record.getTimeout()));
Date nowDate = DateUtils.getNowDate();
long between = DateUtil.between(nowDate, beforeTime, DateUnit.DAY);
if (between<0){
long abs = Math.abs(between);
record.setTimeout("超时"+abs+"");
}else {
record.setTimeout("剩余"+between+"");
}
}
}
return TableDataInfo.build(actProcessVoList);
}
/**
* 获取流程进度
*/
public static List<ProcessVoResultDto>getProcessPlan(ProcessVo processVo){
//获取当前业务运行到那一步
String businessId = processVo.getBusinessId();
if (ObjectUtil.isNull(businessId)){
throw new ServiceException("业务id不可为空");
}
Map params = processVo.getParams();
if (ObjectUtil.isEmpty(params)){
throw new ServiceException("params不可为空");
}
LambdaQueryWrapper<TProcess> wrapper = new LambdaQueryWrapper<TProcess>()
.eq(TProcess::getProcessKey, params.get("processKey"))
.orderByAsc(TProcess::getStep);
List<ProcessVo> processVos = processMapper.selectVoList(wrapper);
List<ProcessVo> list1 = new ArrayList<>();
processVos.forEach(e ->{
e.setBusinessId(businessId);
e.setParams(params);
//遍历出他每一步所需要的审核人
if ("1".equals(e.getType())){//普通流程,只需查出将人员设置到运行流程中即可
if (1L==e.getProcessCheck()) {
//获取根据当前审核人的流程给前端判断是否需要点亮操作
dd(e);
ProcessVo processVo1 = new ProcessVo();
BeanCopyUtils.copy(e,processVo1);
list1.add(processVo1);
}else if (2L==e.getProcessCheck()) {
// 根据接口获取
List<String> personByRule = WorkUtils.getPersonByRule(e.getRuleId(), e.getParams());
e.setAudit(personByRule.get(0));
dd(e);
ProcessVo processVo1 = new ProcessVo();
BeanCopyUtils.copy(e,processVo1);
list1.add(processVo1);
}
}else if ("2".equals(e.getType())) {//会签
//将check以逗号拆分
List<ProcessVo> list = new ArrayList<>();
if (1L == e.getProcessCheck()) {
String[] split = e.getAudit().split(",");
for (String s : split) {
e.setAudit(s);
dd(e);
ProcessVo processVo1 = new ProcessVo();
BeanCopyUtils.copy(e,processVo1);
list.add(processVo1);
}
list1.addAll(list);
} else if (2L == e.getProcessCheck()) {
//根据接口获取
List<String> personByRule = WorkUtils.getPersonByRule(e.getRuleId(), e.getParams());
//将某些固定的审核人员添加进去
if (ObjectUtil.isNotEmpty(e.getAudit())) {
String[] split = e.getAudit().split(",");
Collections.addAll(personByRule, split);
}
for (String s : personByRule) {
e.setAudit(s);
dd(e);
ProcessVo processVo1 = new ProcessVo();
BeanCopyUtils.copy(e,processVo1);
list.add(processVo1);
}
list1.addAll(list);
}
}
});
list1.forEach(e ->{
e.setParams(null);
});
Map<String, List<ProcessVo>> collect = list1.stream().collect(Collectors.groupingBy(ProcessVo::getStep));
List<ProcessVoResultDto> collect1 = collect.entrySet()
.stream()
.map(e -> new ProcessVoResultDto(e.getKey(), e.getValue()))
.collect(Collectors.toList());
collect1.forEach(e ->{
String s = e.getProcessVoList().stream().map(ProcessVo::getDescription).collect(Collectors.toList()).get(0);
e.setStep(s);
});
System.out.println("collect = " + collect1);
return collect1;
}
/**
* 返回审核人公共类
* @param e
*/
public static void dd(ProcessVo e){
LambdaQueryWrapper<ActProcess> queryWrapper = new LambdaQueryWrapper<ActProcess>()
.eq(ActProcess::getBusinessId, e.getBusinessId());
List<ActProcessVo> actProcessVoList = actProcessMapper.selectVoList(queryWrapper);
if (actProcessVoList.size()>0){
actProcessVoList.forEach(a ->{
if ( new Integer(e.getStep())< new Integer(a.getStep())){
e.setChecked("1");
}else if ( new Integer(e.getStep()).equals(new Integer(a.getStep()))){
e.setChecked("2");
}else {
e.setChecked("3");
}
});
}else {
Map map = e.getParams();
Object process_status = map.get("processStatus");
if (ObjectUtil.isNotNull(process_status)){
if (Constants.SUCCEED.equals(process_status.toString())){
e.setChecked("1");
}
}else {
e.setChecked("3");
}
}
e.setAuditLogList(null);
LambdaQueryWrapper<AuditLog> wrapper = new LambdaQueryWrapper<AuditLog>()
.eq(ObjectUtil.isNotNull(e.getProcessKey()) && StringUtils.isNotEmpty(e.getProcessKey()),AuditLog::getProcessKey, e.getProcessKey())
.eq(AuditLog::getOtherId, e.getBusinessId())
.orderByAsc(AuditLog::getCreateTime);
List<AuditLog> auditLogs = auditLogMapper.selectList(wrapper);
if (auditLogs.size()>0) {
List<AuditLog> collect = auditLogs.stream().filter(a -> e.getStep().equals(a.getStep()) && e.getAudit().equals(a.getAudit())).collect(Collectors.toList());
collect.forEach(a -> {
switch (a.getStatus()) {
case "1":
a.setStatus("审核失败");
break;
case "2":
a.setStatus("审核成功");
break;
default:
a.setStatus("未知状态");
break;
} });
e.setAuditLogList(collect);
}
if("4".equals(e.getCheckType())){//企业审核
Map params = e.getParams();
if (ObjectUtil.isNull(e.getParamName())){
throw new ServiceException("param_name不可为空");
}
String o = params.get(e.getParamName()).toString();
e.setAudit(o);
}else if("1".equals(e.getCheckType())) {
//根据id获取人员信息
SysUser sysUser = sysUserMapper.selectUserById(new Long( e.getAudit()));
e.setAudit(sysUser.getUserName());
}else if ("2".equals(e.getCheckType())){
SysDept sysDept = sysDeptMapper.selectDeptById(new Long(e.getAudit()));
e.setAudit(sysDept.getDeptName());
}else if ("3".equals(e.getCheckType())){
SysRole sysRole = sysRoleMapper.selectRoleById(new Long(e.getAudit()));
e.setAudit(sysRole.getRoleName());
}
}
/**
* 获取审核日志
* @param businessDTO
* @return
*/
public static R<?> getAuditLogListByOtherId(BusinessDTO businessDTO){
LambdaQueryWrapper<AuditLog> wrapper = new LambdaQueryWrapper<AuditLog>()
.eq(StringUtils.isNotEmpty(businessDTO.getProcessKey()),AuditLog::getProcessKey, businessDTO.getProcessKey())
.eq(AuditLog::getOtherId, businessDTO.getBusinessId());
List<AuditLog> auditLogs = auditLogMapper.selectList(wrapper);
return R.ok(auditLogs);
}
}

View File

@ -0,0 +1,92 @@
package com.ruoyi.work.utils;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.work.domain.ActBusinessRuleVo;
import com.ruoyi.work.mapper.ActBusinessRuleMapper;
import lombok.AccessLevel;
import lombok.RequiredArgsConstructor;
import org.apache.commons.text.CaseUtils;
import org.springframework.util.ReflectionUtils;
import java.lang.reflect.Method;
import java.util.*;
@RequiredArgsConstructor
public class WorkUtils {
private static final ActBusinessRuleMapper actBusinessRuleMapper=SpringUtils.getBean(ActBusinessRuleMapper.class);
/**
* 根据bean获取审核人员
*/
public static ArrayList<String> getPersonByRule(Long id, Map paramMap){
ArrayList<String> list = new ArrayList<>();
//获取业务规则信息
ActBusinessRuleVo actBusinessRuleVo = actBusinessRuleMapper.selectVoById(id);
String param =paramMap.get(actBusinessRuleVo.getParam()).toString();
//方法名
String methodName = actBusinessRuleVo.getMethod();
//类名
Object beanName = SpringUtils.getBean(actBusinessRuleVo.getBeanName());
//
Class aClass;
Object params="";
switch (actBusinessRuleVo.getParamType()){
case "String":
aClass= String.valueOf(param).getClass();
//将数值转类型
params = String.valueOf(param);
break;
case "Integer":
aClass= Integer.valueOf(param).getClass();
//将数值转类型
params = Integer.valueOf(param);
break;
case "Long":
aClass= Long.valueOf(param).getClass();
//将数值转类型
params = Long.valueOf(param);
break;
case "Float":
aClass= Float.valueOf(param).getClass();
//将数值转类型
params = Float.valueOf(param);
break;
case "Double":
aClass= Double.valueOf(param).getClass();
//将数值转类型
params = Double.valueOf(param);
break;
default:
aClass=String.valueOf(param).getClass();
break;
}
//调用方法
Method method = ReflectionUtils.findMethod(beanName.getClass(), methodName, aClass);
Object obj = ReflectionUtils.invokeMethod(method, beanName,params);
System.out.println("obj = " + obj.toString());
String[] split = obj.toString().split(",");
Collections.addAll(list,split);
return list;
}
/**
*根据业务id获取用户信息
*/
public static Map<String,Object> getInfoToMap( String bean,String businessId){
String s1 = CaseUtils.toCamelCase(bean,false,new char[]{'_'});
System.out.println("s1 = " + s1);
String s2 = s1+"ServiceImpl";
//类名
Object beanName = SpringUtils.getBean(s2);
String me = "queryById";
//调用方法
Method method = ReflectionUtils.findMethod(beanName.getClass(), me, Long.class);
Object obj = ReflectionUtils.invokeMethod(method, beanName,new Long(businessId));
Map<String, Object> map = BeanUtil.beanToMap(obj);
System.out.println("obj = " + obj);
return map;
}
}

View File

@ -0,0 +1,21 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ruoyi.work.mapper.ActBusinessRuleMapper">
<resultMap type="com.ruoyi.work.domain.ActBusinessRule" id="ActFullClassResult">
<result property="id" column="id"/>
<result property="beanName" column="bean_name"/>
<result property="method" column="method"/>
<result property="param" column="param"/>
<result property="paramType" column="param_type"/>
<result property="remark" column="remark"/>
<result property="createTime" column="create_time"/>
<result property="updateTime" column="update_time"/>
<result property="createBy" column="create_by"/>
<result property="updateBy" column="update_by"/>
</resultMap>
</mapper>

View File

@ -0,0 +1,61 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ruoyi.work.mapper.ActProcessMapper">
<resultMap type="com.ruoyi.work.domain.ActProcess" id="ActProcessResult">
<result property="id" column="id"/>
<result property="processId" column="process_id"/>
<result property="createTime" column="create_time"/>
<result property="businessId" column="business_id"/>
<result property="audit" column="audit"/>
<result property="checkType" column="check_type"/>
<result property="step" column="step"/>
<result property="isNext" column="is_next"/>
<result property="type" column="type"/>
<result property="startUser" column="start_user"/>
<result property="companyName" column="company_name"/>
<result property="name" column="name"/>
<result property="description" column="description"/>
<result property="bean" column="bean"/>
<result property="timeout" column="timeout"/>
</resultMap>
<select id="selectVoListPage" resultType="com.ruoyi.work.domain.ActProcess" parameterType="com.ruoyi.work.domain.ActProcess">
SELECT a.create_time AS createTime,a.business_id AS businessId,a.audit, a.step ,a.start_user AS startUser,a.id,p.process_key AS processKey,
p.`name`,p.description,p.bean,p.timeout,a.check_type AS checkType,a.company_name AS companyName,a.process_id,a.type
FROM `act_process` a INNER JOIN process p ON a.process_id= p.id
<where>
<if test="actProcess.startUser !='' and actProcess.startUser !=null"> and a.start_user= #{actProcess.startUser}</if>
and
(
(a.check_type= 1 AND a.audit = #{actProcess.userId} )
OR
(a.check_type = 2 AND a.audit =#{actProcess.deptId})
OR
(a.check_type = 3 AND a.audit = #{actProcess.roleId})
OR
(a.check_type = 4 AND a.audit = #{actProcess.companyUserId})
)
</where>
ORDER BY a.create_time
</select>
<select id="selectCCList" resultType="com.ruoyi.work.domain.ActProcess">
SELECT a.create_time AS createTime,a.business_id AS businessId,a.process_id AS processId,a.audit,a.company_name AS companyName
,a.step,a.start_user AS startUser,p.description,p.bean,p.`name`,p.timeout,a.check_type AS checkType,a.type,a.id,p.process_key AS processKey
FROM
( SELECT DISTINCT(id),process_id,company_name,create_time,business_id,audit,step,start_user,check_type,type
FROM act_process
WHERE process_id IN
(SELECT id FROM `process` WHERE FIND_IN_SET(#{actProcess.userId},cc))
GROUP BY business_id ) AS a
INNER JOIN process p ON p.id = a.process_id
ORDER BY a.create_time
</select>
<select id="selectByIdResultBean2BusinessId" resultType="com.ruoyi.work.domain.ActProcess"
parameterType="java.lang.Long">
SELECT p.bean,a.business_id AS businessId ,p.process_key processKey ,a.start_user startUser FROM process p INNER JOIN act_process a ON a.process_id = p.id WHERE a.id = #{id}
</select>
</mapper>

View File

@ -0,0 +1,27 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ruoyi.work.mapper.AuditLogMapper">
<resultMap type="com.ruoyi.work.domain.AuditLog" id="AuditLogResult">
<result property="id" column="id"/>
<result property="auditId" column="audit_id"/>
<result property="adminUserName" column="admin_user_name"/>
<result property="createTime" column="create_time"/>
<result property="otherId" column="other_id"/>
<result property="reply" column="reply"/>
<result property="status" column="status"/>
<result property="roleName" column="role_name"/>
<result property="pushLog" column="push_log"/>
<result property="createBy" column="create_by"/>
<result property="updateTime" column="update_time"/>
<result property="updateBy" column="update_by"/>
<result property="auditType" column="audit_type"/>
<result property="processKey" column="process_key"/>
<result property="audit" column="audit"/>
<result property="step" column="step"/>
</resultMap>
</mapper>

View File

@ -0,0 +1,50 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ruoyi.work.mapper.HisProcessMapper">
<resultMap type="com.ruoyi.work.domain.HisProcess" id="HisProcessResult">
<result property="id" column="id"/>
<result property="processId" column="process_id"/>
<result property="createTime" column="create_time"/>
<result property="businessId" column="business_id"/>
<result property="audit" column="audit"/>
<result property="checkType" column="check_type"/>
<result property="status" column="status"/>
<result property="endTime" column="end_time"/>
<result property="step" column="step"/>
<result property="type" column="type"/>
<result property="startUser" column="start_user"/>
<result property="companyName" column="companyName"/>
</resultMap>
<resultMap id="ReturnBeanResult" type="com.ruoyi.work.domain.bo.ReturnBean">
</resultMap>
<select id="selectVoListPage" resultType="com.ruoyi.work.domain.HisProcess" parameterType="com.ruoyi.work.domain.HisProcess">
SELECT p.`name` ,process_key AS processKey,d.audit,d.check_type AS checkType ,d.type,p.bean,d.`status`,d.create_time AS createTime,d.end_time AS endTime ,
d.business_id AS businessId,d.start_user AS startUser,p.cc,p.description,d.step
FROM
(SELECT process_id,h.create_time,business_id,h.audit,h.check_type,h.`status`,end_time,h.step,h.type,h.start_user
FROM
`his_process` h
WHERE h.id IN (SELECT MAX(id) FROM his_process
where ((audit = #{hisProcess.userId} AND check_type= 1)
OR
(check_type = 2 AND audit =#{hisProcess.deptId})
OR
(check_type = 3 AND audit = #{hisProcess.roleId})
OR
(check_type = 4 AND audit = #{hisProcess.companyUserId})
)
GROUP BY business_id) ) d
INNER JOIN process p ON p.id = d.process_id
<where>
<if test="hisProcess.startUser !='' and hisProcess.startUser !=null"> and d.start_user= #{hisProcess.startUser}</if>
</where>
ORDER BY d.end_time DESC
</select>
</mapper>

View File

@ -0,0 +1,31 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ruoyi.work.mapper.ProcessMapper">
<resultMap type="com.ruoyi.work.domain.TProcess" id="ProcessResult">
<result property="id" column="id"/>
<result property="createTime" column="create_time"/>
<result property="name" column="name"/>
<result property="processKey" column="process_key"/>
<result property="step" column="step"/>
<result property="type" column="`type`"/>
<result property="checkType" column="check_type"/>
<result property="processCheck" column="process_check"/>
<result property="cc" column="cc"/>
<result property="isNext" column="is_next"/>
<result property="audit" column="audit"/>
<result property="ruleId" column="rule_id"/>
<result property="param" column="param"/>
<result property="timeout" column="timeout"/>
<result property="paramName" column="param_name"/>
<result property="description" column="description"/>
</resultMap>
<update id="updateCommonByBusinessId">
update ${bean} set process_status = #{processStatus} where id = #{businessId}
</update>
</mapper>

View File

@ -0,0 +1,17 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ruoyi.work.mapper.RollBackLogMapper">
<resultMap type="com.ruoyi.work.domain.RollBackLog" id="RollBackLogResult">
<result property="id" column="id"/>
<result property="createTime" column="createTime"/>
<result property="type" column="type"/>
<result property="reply" column="reply"/>
<result property="createBy" column="create_by"/>
<result property="param" column="param"/>
</resultMap>
</mapper>