Skip to content

荆蔚杰 / java.archive

Go to a project
Toggle navigation
Toggle navigation pinning
db661717 by 夏齐
Options

首次提交

1 parent 9545f232
Inline Side-by-side
Showing 244 changed files with 2678 additions and 17478 deletions
......@@ -5,7 +5,7 @@
<modelVersion>4.0.0</modelVersion>
<groupId>com.pashanhoo</groupId>
<artifactId>archive-system</artifactId>
<artifactId>hzbdcsyn</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
......@@ -63,6 +63,11 @@
<artifactId>spring-boot-starter-web</artifactId>
<version>${org.spring.boot.version}</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.3.2</version>
</dependency>
<!--<dependency>-->
<!-- <groupId>org.springframework.session</groupId>-->
......@@ -129,7 +134,7 @@
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
<version>1.18.8</version>
<version>1.16.20</version>
</dependency>
<dependency>
......@@ -220,12 +225,12 @@
<artifactId>mapstruct-processor</artifactId>
<version>${mapstruct.version}</version>
</dependency>
<dependency>
<!-- <dependency>
<groupId>polaris</groupId>
<artifactId>polaris-fileattachment</artifactId>
<version>1.0</version>
<scope>compile</scope>
</dependency>
</dependency>-->
<dependency>
<groupId>io.minio</groupId>
<artifactId>minio</artifactId>
......@@ -267,6 +272,16 @@
<artifactId>tess4j</artifactId>
<version>4.5.3</version>
</dependency>
<dependency>
<groupId>net.glxn.qrgen</groupId>
<artifactId>javase</artifactId>
<version>2.0</version>
</dependency>
<dependency>
<groupId>org.ofdrw</groupId>
<artifactId>ofdrw-full</artifactId>
<version>1.8.6</version>
</dependency>
</dependencies>
......@@ -275,6 +290,7 @@
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>2.2.8.RELEASE</version>
<executions>
<execution>
<goals>
......@@ -291,6 +307,14 @@
<skip>true</skip>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>8</source>
<target>8</target>
</configuration>
</plugin>
</plugins>
<resources>
......@@ -298,7 +322,7 @@
<directory>src/main/resources</directory>
<excludes>
<!--使用通配符，当然可以定义多个exclude标签进行排除-->
<exclude>application*.yaml</exclude>
<exclude>application*.yml</exclude>
</excludes>
</resource>
......@@ -338,8 +362,6 @@
</profiles>
<properties>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
<oracle.version>11.2.0.4</oracle.version>
<geotools.version>24-SNAPSHOT</geotools.version>
<org.springframework.version>5.1.8.RELEASE</org.springframework.version>
......@@ -354,8 +376,6 @@
<springfox.swagger2.version>2.9.2</springfox.swagger2.version>
<mapstruct.version>1.3.0.Final</mapstruct.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
</properties>
</project>
......
......@@ -23,7 +23,7 @@ public class SwaggerConfig {
.apiInfo(apiInfo())
.select()
// 为当前包路径
// .apis(RequestHandlerSelectors.basePackage("com.pashanhoo"))
.apis(RequestHandlerSelectors.basePackage("com.pashanhoo"))
.apis(RequestHandlerSelectors.withClassAnnotation(Api.class))
.paths(PathSelectors.any())
.build();
......@@ -33,7 +33,7 @@ public class SwaggerConfig {
private ApiInfo apiInfo() {
return new ApiInfoBuilder()
// 页面标题
.title("档案系统 接口文档")
.title("接口文档")
// 版本号
.version("1.0")
// 描述
......
package com.pashanhoo.archive.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.pashanhoo.archive.entity.vo.*;
import com.pashanhoo.archive.service.DgArchivesService;
import com.pashanhoo.catalog.entity.vo.DgArchivesCatalogListVO;
import com.pashanhoo.catalog.entity.vo.UpdateDgArchivesCatalogRequest;
import com.pashanhoo.common.Result;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
/**
* <p>
* 案卷基本信息 前端控制器
* </p>
*
* @author
* @since 2021-11-05
*/
@RestController
@RequestMapping("/system/dgArchives/")
@Api(tags = "案卷基本信息接口")
public class DgArchivesController {
@Autowired
private DgArchivesService dgarchivesService;
@PostMapping("insertDgArchives")
@ApiOperation("新增案卷基本信息")
public Result insertDgArchives(@RequestBody AddDgArchivesRequest request) {
if (dgarchivesService.insertDgArchives(request)) {
return Result.ok();
}
return Result.error("新增失败");
}
@DeleteMapping("deleteDgArchivesByIds")
@ApiOperation(value = "批量删除案卷基本信息")
public Result deleteDgArchivesByIds(@ApiParam("案卷基本信息ID列表") @RequestParam(value = "idList") List<String> idList) {
if (dgarchivesService.removeByIds(idList)) {
return Result.ok("删除成功");
}
return Result.error("删除失败");
}
@PutMapping("updateDgArchives")
@ApiOperation("修改案卷基本信息,业务信息,不动产信息")
public Result updateDgArchives(@RequestBody UpdateArchiveAndOtherInfoRequest request) {
if (dgarchivesService.updateDgArchivesReplenish(request)) {
return Result.ok("修改成功");
}
return Result.error("修改失败");
}
@GetMapping("getDgArchivesDetailById")
@ApiOperation(value = "案卷基本信息")
public Result<ArchiveDetailAndCoverVO> getDgArchivesDetailById(@ApiParam("案卷标识码") @RequestParam String bsmArchive) {
return Result.ok(dgarchivesService.getDgArchivesDetailById(bsmArchive));
}
@PostMapping("searchArchives")
@ApiOperation(value = "档案查找")
public Result<IPage<SearchArchiveVO>> searchArchives(@RequestBody SearchArchiveRequest request) {
return Result.ok(dgarchivesService.searchArchive(request));
}
@GetMapping("searchArchivesCover")
@ApiOperation(value = "案卷封皮信息查找")
public Result<ArchiveDetailAndCoverVO> searchArchivesCover(@ApiParam("档案标识码") @RequestParam String bsmArchive) {
return Result.ok(dgarchivesService.searchArchivesCover(bsmArchive));
}
/**
* 通过案卷标识码加载左菜单目录
*
* @param bsmArchives 案卷标识码
* @return
*/
@GetMapping("getLifeMenu")
@ApiOperation(value = "通过案卷标识码加载左菜单目录")
public Result getArchiveLiftMenu(@ApiParam("案卷标识码") @RequestParam String bsmArchives) {
return Result.ok(dgarchivesService.getArchiveLiftMenu(bsmArchives));
}
/**
* 目录修改保存
* 1.比对新增的记录数据库是否存在，如果不存在则新增
* 2.比对数据库的数据是否存在前端传递的集合中，不存在则删除，并且删除对应的电子附件数据
* 3.如果目录记录标识码与数据库一致，直接更新当前的记录
*
* @param requests
* @return
*/
@PostMapping("saveCatalogs")
@ApiOperation(value = "目录修改保存")
public Result saveCatalogs(@RequestBody List<UpdateDgArchivesCatalogRequest> requests) {
if (dgarchivesService.updateCatalog(requests)) {
return Result.ok("修改成功");
}
return Result.error("修改失败");
}
/**
* 档案目录查找
*
* @param bsmArchive
* @return
*/
@GetMapping("searchCatalog")
@ApiOperation(value = "查询档案目录")
public Result<List<DgArchivesCatalogListVO>> searchCatalog(@RequestParam String bsmArchive) {
return Result.ok(dgarchivesService.searchCatalog(bsmArchive));
}
}
package com.pashanhoo.archive.entity;
public enum ArchiveStatus {
//档案状态（1：正在接收；2：正在补录；3：正在修改；4：在库；5：正在销毁；6：已销毁；7：正在借阅；8：已借阅）
/**
* 正在接收
*/
RECEIVING(1,"正在接收"),
/**
* 正在补录
*/
REPLENISHING(2,"正在补录"),
/**
* 正在修改
*/
MODIFYING(3,"正在修改"),
/**
* 在库
*/
STORED(4,"在库"),
/**
* 正在销毁
*/
DESTROYING(5,"正在销毁"),
/**
* 已销毁
*/
DESTROYED(6,"已销毁"),
/**
* 正在借阅
*/
LENDING(7,"正在借阅"),
/**
* 已借阅
*/
LENDED(8,"已借阅");
private Integer code;
private String description;
ArchiveStatus(Integer code,String description) {
this.code = code;
this.description = description;
}
public Integer getCode() {
return this.code;
}
}
package com.pashanhoo.archive.entity;
import java.util.List;
import com.pashanhoo.archive.entity.vo.AddDgArchivesRequest;
import com.pashanhoo.archive.entity.vo.DgArchivesDetailVO;
import com.pashanhoo.archive.entity.vo.DgArchivesListVO;
import com.pashanhoo.archive.entity.vo.UpdateDgArchivesRequest;
import org.mapstruct.Mapper;
/**
* @author
* @since 2021-11-05
*/
@Mapper(componentModel = "spring")
public interface DgArchivesConverter{
DgArchivesDO addRequest2DO(AddDgArchivesRequest request);
DgArchivesDetailVO do2DetailVO(DgArchivesDO dgarchivesDO);
DgArchivesDO updateRequest2DO(UpdateDgArchivesRequest request);
DgArchivesListVO do2ListVO(DgArchivesDO dgarchivesDO);
List<DgArchivesListVO> doList2ListVOList(List<DgArchivesDO> dgarchivesDOList);
List<DgArchivesDO> addArchivesList(List<AddDgArchivesRequest> request);
}
package com.pashanhoo.archive.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 案卷基本信息
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("DG_ARCHIVES")
public class DgArchivesDO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 档案标识码
*/
@TableId(value = "BSM_ARCHIVES", type = IdType.UUID)
private String bsmArchives;
/**
* 案卷标题
*/
@TableField("AJBT")
private String ajbt;
/**
* 主题词
*/
@TableField("ZTC")
private String ztc;
/**
* 分类号
*/
@TableField("FLH")
private String flh;
/**
* 目录号
*/
@TableField("MLH")
private String mlh;
/**
* 案卷号
*/
@TableField("AJH")
private String ajh;
/**
* 年度
*/
@TableField("ND")
private Integer nd;
/**
* 件数
*/
@TableField("JS")
private Integer js;
/**
* 页数
*/
@TableField("YS")
private Integer ys;
/**
* 保管期限
*/
@TableField("BGQX")
private String bgqx;
/**
* 起始日期
*/
@TableField("QSRQ")
private Date qsrq;
/**
* 终止日期
*/
@TableField("ZZRQ")
private Date zzrq;
/**
* 保密级别
*/
@TableField("MJ")
private String mj;
/**
* 盒号
*/
@TableField("HH")
private String hh;
/**
* 存放位置
*/
@TableField("CFWZ")
private String cfwz;
/**
* 创建人
*/
@TableField("CJR")
private String cjr;
/**
* 创建日期
*/
@TableField("CJRQ")
private Date cjrq;
/**
* 核查人
*/
@TableField("HCR")
private String hcr;
/**
* 备注
*/
@TableField("BZ")
private String bz;
/**
* 扫描状态
*/
@TableField("SMZT")
private Integer smzt;
/**
* 档案状态
*/
@TableField("DAZT")
private Integer dazt;
/**
* 存档机构编码
*/
@TableField("CDJGBM")
private String cdjgbm;
/**
* 档案来源（1：不动产归档，2：存量档案补录）
*/
@TableField("DALY")
private String daly;
}
package com.pashanhoo.archive.entity.vo;
import java.math.BigDecimal;
import java.util.Date;
import java.io.Serializable;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 案卷基本信息新增请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="案卷基本信息新增请求实体")
public class AddDgArchivesRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 案卷标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "案卷标识码")
private String bsmArchives;
/**
* 案卷标题
*/
@ApiModelProperty(name = "ajbt", value = "案卷标题")
private String ajbt;
/**
* 主题词
*/
@ApiModelProperty(name = "ztc", value = "主题词")
private String ztc;
/**
* 分类号
*/
@ApiModelProperty(name = "flh", value = "分类号")
private String flh;
/**
* 目录号
*/
@ApiModelProperty(name = "mlh", value = "目录号")
private String mlh;
/**
* 案卷号
*/
@ApiModelProperty(name = "ajh", value = "案卷号")
private String ajh;
/**
* 年度
*/
@ApiModelProperty(name = "nd", value = "年度")
private Integer nd;
/**
* 件数
*/
@ApiModelProperty(name = "js", value = "件数")
private Integer js;
/**
* 页数
*/
@ApiModelProperty(name = "ys", value = "页数")
private Integer ys;
/**
* 保管期限
*/
@ApiModelProperty(name = "bgqx", value = "保管期限")
private String bgqx;
/**
* 起始日期
*/
@ApiModelProperty(name = "qsrq", value = "起始日期")
private Date qsrq;
/**
* 终止日期
*/
@ApiModelProperty(name = "zzrq", value = "终止日期")
private Date zzrq;
/**
* 保密级别
*/
@ApiModelProperty(name = "mj", value = "保密级别")
private String mj;
/**
* 盒号
*/
@ApiModelProperty(name = "hh", value = "盒号")
private String hh;
/**
* 存放位置
*/
@ApiModelProperty(name = "cfwz", value = "存放位置")
private String cfwz;
/**
* 创建人
*/
@ApiModelProperty(name = "cjr", value = "创建人")
private String cjr;
/**
* 创建日期
*/
@ApiModelProperty(name = "cjrq", value = "创建日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date cjrq;
/**
* 核查人
*/
@ApiModelProperty(name = "hcr", value = "核查人")
private String hcr;
/**
* 备注
*/
@ApiModelProperty(name = "bz", value = "备注")
private String bz;
/**
* 扫描状态
*/
@ApiModelProperty(name = "smzt", value = "扫描状态")
private Integer smzt;
/**
* 档案状态
*/
@ApiModelProperty(name = "dazt", value = "档案状态")
private Integer dazt;
/**
* 存档机构编码
*/
@ApiModelProperty(name = "cdjgbm", value = "存档机构编码")
private String cdjgbm;
/**
* 档案来源（1：不动产归档，2：存量档案补录）
*/
@ApiModelProperty(name = "daly", value = "档案来源（1：不动产归档，2：存量档案补录）")
private String daly;
}
package com.pashanhoo.archive.entity.vo;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.pashanhoo.bdcdy.entity.vo.DgBdcdyDetailVO;
import com.pashanhoo.business.entity.vo.DgBusinessDetailVO;
import io.swagger.annotations.ApiModel;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.List;
/**
* 档案封皮返回实体
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value = "档案封皮和案卷信息返回实体")
@JsonInclude()
public class ArchiveDetailAndCoverVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 案卷基本信息实体
*/
private DgArchivesDetailVO dgArchivesDetailVO;
/**
* 不动产信息实体集合
*/
private List<DgBdcdyDetailVO> dgBdcdyDetailVOList;
/**
* 业务信息实体
*/
private DgBusinessDetailVO dgBusinessDetailVO;
}
package com.pashanhoo.archive.entity.vo;
import java.math.BigDecimal;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 案卷基本信息明细实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="案卷基本信息明细实体")
public class DgArchivesDetailVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 案卷标题
*/
@ApiModelProperty(name = "ajbt", value = "案卷标题")
private String ajbt;
/**
* 主题词
*/
@ApiModelProperty(name = "ztc", value = "主题词")
private String ztc;
/**
* 分类号
*/
@ApiModelProperty(name = "flh", value = "分类号")
private String flh;
/**
* 目录号
*/
@ApiModelProperty(name = "mlh", value = "目录号")
private String mlh;
/**
* 案卷号
*/
@ApiModelProperty(name = "ajh", value = "案卷号")
private String ajh;
/**
* 年度
*/
@ApiModelProperty(name = "nd", value = "年度")
private Integer nd;
/**
* 件数
*/
@ApiModelProperty(name = "js", value = "件数")
private Integer js;
/**
* 页数
*/
@ApiModelProperty(name = "ys", value = "页数")
private Integer ys;
/**
* 保管期限
*/
@ApiModelProperty(name = "bgqx", value = "保管期限")
private String bgqx;
/**
* 起始日期
*/
@ApiModelProperty(name = "qsrq", value = "起始日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date qsrq;
/**
* 终止日期
*/
@ApiModelProperty(name = "zzrq", value = "终止日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date zzrq;
/**
* 保密级别
*/
@ApiModelProperty(name = "mj", value = "保密级别")
private String mj;
/**
* 盒号
*/
@ApiModelProperty(name = "hh", value = "盒号")
private String hh;
/**
* 存放位置
*/
@ApiModelProperty(name = "cfwz", value = "存放位置")
private String cfwz;
/**
* 创建人
*/
@ApiModelProperty(name = "cjr", value = "创建人")
private String cjr;
/**
* 创建日期
*/
@ApiModelProperty(name = "cjrq", value = "创建日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date cjrq;
/**
* 核查人
*/
@ApiModelProperty(name = "hcr", value = "核查人")
private String hcr;
/**
* 备注
*/
@ApiModelProperty(name = "bz", value = "备注")
private String bz;
/**
* 扫描状态
*/
@ApiModelProperty(name = "smzt", value = "扫描状态")
private Integer smzt;
/**
* 档案状态
*/
@ApiModelProperty(name = "dazt", value = "档案状态")
private Integer dazt;
/**
* 存档机构编码
*/
@ApiModelProperty(name = "cdjgbm", value = "存档机构编码")
private String cdjgbm;
/**
* 档案来源（1：不动产归档，2：存量档案补录）
*/
@ApiModelProperty(name = "daly", value = "档案来源（1：不动产归档，2：存量档案补录）")
private String daly;
}
package com.pashanhoo.archive.entity.vo;
import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 案卷基本信息列表VO
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="案卷基本信息列表VO")
//TODO 该类属性暂时是完整的全部属性，需进行个性化的增删
public class DgArchivesListVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 案卷标题
*/
@ApiModelProperty(name = "ajbt", value = "案卷标题")
private String ajbt;
/**
* 主题词
*/
@ApiModelProperty(name = "ztc", value = "主题词")
private String ztc;
/**
* 分类号
*/
@ApiModelProperty(name = "flh", value = "分类号")
private String flh;
/**
* 目录号
*/
@ApiModelProperty(name = "mlh", value = "目录号")
private String mlh;
/**
* 案卷号
*/
@ApiModelProperty(name = "ajh", value = "案卷号")
private String ajh;
/**
* 年度
*/
@ApiModelProperty(name = "nd", value = "年度")
private Integer nd;
/**
* 件数
*/
@ApiModelProperty(name = "js", value = "件数")
private Integer js;
/**
* 页数
*/
@ApiModelProperty(name = "ys", value = "页数")
private Integer ys;
/**
* 保管期限
*/
@ApiModelProperty(name = "bgqx", value = "保管期限")
private String bgqx;
/**
* 起始日期
*/
@ApiModelProperty(name = "qsrq", value = "起始日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date qsrq;
/**
* 终止日期
*/
@ApiModelProperty(name = "zzrq", value = "终止日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date zzrq;
/**
* 保密级别
*/
@ApiModelProperty(name = "mj", value = "保密级别")
private String mj;
/**
* 盒号
*/
@ApiModelProperty(name = "hh", value = "盒号")
private String hh;
/**
* 存放位置
*/
@ApiModelProperty(name = "cfwz", value = "存放位置")
private String cfwz;
/**
* 创建人
*/
@ApiModelProperty(name = "cjr", value = "创建人")
private String cjr;
/**
* 创建日期
*/
@ApiModelProperty(name = "cjrq", value = "创建日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date cjrq;
/**
* 核查人
*/
@ApiModelProperty(name = "hcr", value = "核查人")
private String hcr;
/**
* 备注
*/
@ApiModelProperty(name = "bz", value = "备注")
private String bz;
/**
* 扫描状态
*/
@ApiModelProperty(name = "smzt", value = "扫描状态")
private Integer smzt;
/**
* 档案状态
*/
@ApiModelProperty(name = "dazt", value = "档案状态")
private Integer dazt;
/**
* 存档机构编码
*/
@ApiModelProperty(name = "cdjgbm", value = "存档机构编码")
private String cdjgbm;
/**
* 档案来源（1：不动产归档，2：存量档案补录）
*/
@ApiModelProperty(name = "daly", value = "档案来源（1：不动产归档，2：存量档案补录）")
private String daly;
}
package com.pashanhoo.archive.entity.vo;
import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import com.pashanhoo.common.PageInfo;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 案卷基本信息列表查询请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="案卷基本信息列表查询请求实体")
//TODO 初始查询条件是全部，需要根据情况自行删减
public class DgArchivesSearchRequest extends PageInfo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 案卷标题
*/
@ApiModelProperty(name = "ajbt", value = "案卷标题")
private String ajbt;
/**
* 主题词
*/
@ApiModelProperty(name = "ztc", value = "主题词")
private String ztc;
/**
* 分类号
*/
@ApiModelProperty(name = "flh", value = "分类号")
private String flh;
/**
* 目录号
*/
@ApiModelProperty(name = "mlh", value = "目录号")
private String mlh;
/**
* 案卷号
*/
@ApiModelProperty(name = "ajh", value = "案卷号")
private String ajh;
/**
* 年度
*/
@ApiModelProperty(name = "nd", value = "年度")
private Integer nd;
/**
* 件数
*/
@ApiModelProperty(name = "js", value = "件数")
private Integer js;
/**
* 页数
*/
@ApiModelProperty(name = "ys", value = "页数")
private Integer ys;
/**
* 保管期限
*/
@ApiModelProperty(name = "bgqx", value = "保管期限")
private String bgqx;
/**
* 起始日期
*/
@ApiModelProperty(name = "qsrq", value = "起始日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date qsrq;
/**
* 终止日期
*/
@ApiModelProperty(name = "zzrq", value = "终止日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date zzrq;
/**
* 保密级别
*/
@ApiModelProperty(name = "mj", value = "保密级别")
private String mj;
/**
* 盒号
*/
@ApiModelProperty(name = "hh", value = "盒号")
private String hh;
/**
* 存放位置
*/
@ApiModelProperty(name = "cfwz", value = "存放位置")
private String cfwz;
/**
* 创建人
*/
@ApiModelProperty(name = "cjr", value = "创建人")
private String cjr;
/**
* 创建日期
*/
@ApiModelProperty(name = "cjrq", value = "创建日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date cjrq;
/**
* 核查人
*/
@ApiModelProperty(name = "hcr", value = "核查人")
private String hcr;
/**
* 备注
*/
@ApiModelProperty(name = "bz", value = "备注")
private String bz;
/**
* 扫描状态
*/
@ApiModelProperty(name = "smzt", value = "扫描状态")
private Integer smzt;
/**
* 档案状态
*/
@ApiModelProperty(name = "dazt", value = "档案状态")
private Integer dazt;
/**
* 存档机构编码
*/
@ApiModelProperty(name = "cdjgbm", value = "存档机构编码")
private String cdjgbm;
/**
* 档案来源（1：不动产归档，2：存量档案补录）
*/
@ApiModelProperty(name = "daly", value = "档案来源（1：不动产归档，2：存量档案补录）")
private String daly;
}
package com.pashanhoo.archive.entity.vo;
import com.pashanhoo.common.PageInfo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
/**
* 档案查找请求实体
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案查找请求实体")
public class SearchArchiveRequest extends PageInfo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 档案号
*/
@ApiModelProperty(name = "ajh", value = "档案号")
private String ajh;
/**
* 目录号
*/
@ApiModelProperty(name = "mlh", value = "目录号")
private String mlh;
/**
* 盒号
*/
@ApiModelProperty(name = "hh", value = "盒号")
private String hh;
/**
* 档案状态
* (1：正在接收；2：正在补录；3：正在修改；4：在库；5：正在销毁；6：已销毁；7：正在借阅；8：已借阅)
*/
@ApiModelProperty(name = "dazt", value = "档案状态.1：正在接收；2：正在补录；3：正在修改；4：在库；5：正在销毁；6：已销毁；7：正在借阅；8：已借阅")
private String dazt;
/**
* 业务号
*/
@ApiModelProperty(name = "ywh", value = "业务号")
private String ywh;
/**
* 不动产权证号
*/
@ApiModelProperty(name = "bdcqzh", value = "不动产权证号")
private String bdcqzh;
/**
* 不动产单元号
*/
@ApiModelProperty(name = "bdcdyh", value = "不动产单元号")
private String bdcdyh;
/**
* 权利类型
*/
@ApiModelProperty(name = "qllx", value = "权利类型")
private String qllx;
/**
* 权利人
*/
@ApiModelProperty(name = "qlr",value = "权利人")
private String qlr;
}
package com.pashanhoo.archive.entity.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
/**
* 档案查找返回实体
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案查找返回实体")
public class SearchArchiveVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 序号
*/
@ApiModelProperty(name = "xh", value = "序号")
private String xh;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 档案状态
* (1：正在接收；2：正在补录；3：正在修改；4：在库；5：正在销毁；6：已销毁；7：正在借阅；8：已借阅)
*/
@ApiModelProperty(name = "dazt", value = "档案状态.1：正在接收；2：正在补录；3：正在修改；4：在库；5：正在销毁；6：已销毁；7：正在借阅；8：已借阅")
private String dazt;
/**
* 档案来源
* 1:不动产归档.2:存量档案补录
*/
@ApiModelProperty(name = "daly", value = "档案来源")
private String daly;
/**
* 档案号
*/
@ApiModelProperty(name = "ajh", value = "档案号")
private String ajh;
/**
* 存放位置
*/
@ApiModelProperty(name = "cfwz", value = "存放位置")
private String cfwz;
/**
* 盒号
*/
@ApiModelProperty(name = "hh", value = "盒号")
private String hh;
/**
* 不动产权证号
*/
@ApiModelProperty(name = "bdcqzh", value = "不动产权证号")
private String bdcqzh;
/**
* 权利人
*/
@ApiModelProperty(name = "qlr", value = "权利人")
private String qlr;
/**
* 义务人
*/
@ApiModelProperty(name = "ywr", value = "义务人")
private String ywr;
/**
* 业务号
*/
@ApiModelProperty(name = "ywh", value = "业务号")
private String ywh;
/**
* 不动产单元号
*/
@ApiModelProperty(name = "bdcdyh", value = "不动产单元号")
private String bdcdyh;
/**
* 权利类型
*/
@ApiModelProperty(name = "qllx", value = "权利类型")
private String qllx;
}
package com.pashanhoo.archive.entity.vo;
import java.io.Serializable;
import java.util.List;
import com.pashanhoo.bdcdy.entity.vo.UpdateDgBdcdyRequest;
import com.pashanhoo.business.entity.vo.UpdateDgBusinessRequest;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案信息,业务信息,不动产单元修改请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value = "档案信息,业务信息,不动产单元修改请求实体")
public class UpdateArchiveAndOtherInfoRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 更新案卷基本信息
*/
@ApiModelProperty(name = "updateDgArchivesRequest", value = "更新案卷基本信息")
private UpdateDgArchivesRequest updateDgArchivesRequest;
/**
* 更新业务信息
*/
@ApiModelProperty(name = "updateDgBusinessRequest", value = "更新业务信息")
private UpdateDgBusinessRequest updateDgBusinessRequest;
/**
* 更新不动产单元信息
*/
@ApiModelProperty(name = "updateDgBdcdyRequests", value = "更新不动产单元信息")
private List<UpdateDgBdcdyRequest> updateDgBdcdyRequests;
}
package com.pashanhoo.archive.entity.vo;
import java.util.Date;
import java.io.Serializable;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 案卷基本信息修改请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="案卷基本信息修改请求实体")
public class UpdateDgArchivesRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 案卷标题
*/
@ApiModelProperty(name = "ajbt", value = "案卷标题")
private String ajbt;
/**
* 主题词
*/
@ApiModelProperty(name = "ztc", value = "主题词")
private String ztc;
/**
* 分类号
*/
@ApiModelProperty(name = "flh", value = "分类号")
private String flh;
/**
* 目录号
*/
@ApiModelProperty(name = "mlh", value = "目录号")
private String mlh;
/**
* 案卷号
*/
@ApiModelProperty(name = "ajh", value = "案卷号")
private String ajh;
/**
* 年度
*/
@ApiModelProperty(name = "nd", value = "年度")
private Integer nd;
/**
* 件数
*/
@ApiModelProperty(name = "js", value = "件数")
private Integer js;
/**
* 页数
*/
@ApiModelProperty(name = "ys", value = "页数")
private Integer ys;
/**
* 保管期限
*/
@ApiModelProperty(name = "bgqx", value = "保管期限")
private String bgqx;
/**
* 起始日期
*/
@ApiModelProperty(name = "qsrq", value = "起始日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date qsrq;
/**
* 终止日期
*/
@ApiModelProperty(name = "zzrq", value = "终止日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date zzrq;
/**
* 保密级别
*/
@ApiModelProperty(name = "mj", value = "保密级别")
private String mj;
/**
* 盒号
*/
@ApiModelProperty(name = "hh", value = "盒号")
private String hh;
/**
* 存放位置
*/
@ApiModelProperty(name = "cfwz", value = "存放位置")
private String cfwz;
/**
* 创建人
*/
@ApiModelProperty(name = "cjr", value = "创建人")
private String cjr;
/**
* 创建日期
*/
@ApiModelProperty(name = "cjrq", value = "创建日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date cjrq;
/**
* 核查人
*/
@ApiModelProperty(name = "hcr", value = "核查人")
private String hcr;
/**
* 备注
*/
@ApiModelProperty(name = "bz", value = "备注")
private String bz;
/**
* 扫描状态
*/
@ApiModelProperty(name = "smzt", value = "扫描状态")
private Integer smzt;
/**
* 档案状态
*/
@ApiModelProperty(name = "dazt", value = "档案状态")
private Integer dazt;
/**
* 存档机构编码
*/
@ApiModelProperty(name = "cdjgbm", value = "存档机构编码")
private String cdjgbm;
/**
* 档案来源（1：不动产归档，2：存量档案补录）
*/
@ApiModelProperty(name = "daly", value = "档案来源（1：不动产归档，2：存量档案补录）")
private String daly;
}
package com.pashanhoo.archive.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.pashanhoo.archive.entity.DgArchivesDO;
import com.pashanhoo.archive.entity.vo.SearchArchiveRequest;
import com.pashanhoo.archive.entity.vo.SearchArchiveVO;
import com.pashanhoo.catalog.entity.vo.DgArchivesCatalogWithFileVO;
import com.pashanhoo.file.entity.vo.DgFileSearchRequest;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* <p>
* 案卷基本信息 Mapper 接口
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgArchivesMapper extends BaseMapper<DgArchivesDO> {
boolean updateArchivesInfoByReceiveIdList(@Param("idList") List<String> idList,@Param("dazt") String dazt);
IPage<SearchArchiveVO> searchArchive(@Param("pageParam") IPage<SearchArchiveVO> pageParam, @Param("request") SearchArchiveRequest request);
/**
* 查询附件以及名称和排序
* @param request
* @return
*/
List<DgArchivesCatalogWithFileVO> selectCatalogWithFile(@Param("request") DgFileSearchRequest request);
}
package com.pashanhoo.archive.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.IService;
import com.pashanhoo.archive.entity.DgArchivesDO;
import com.pashanhoo.archive.entity.vo.*;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.pashanhoo.catalog.entity.vo.DgArchivesCatalogListVO;
import com.pashanhoo.catalog.entity.vo.DgArchivesCatalogWithFileVO;
import com.pashanhoo.catalog.entity.vo.UpdateDgArchivesCatalogRequest;
import com.pashanhoo.file.entity.vo.DgFileSearchRequest;
import java.util.List;
/**
* <p>
* 案卷基本信息 服务类
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgArchivesService extends IService<DgArchivesDO> {
/**
* 新增记录
*
* @param request
* @return
*/
boolean insertDgArchives(AddDgArchivesRequest request);
/**
* 查询案卷基本信息
*
* @param bsmArchive
* @return
*/
ArchiveDetailAndCoverVO getDgArchivesDetailById(String bsmArchive);
/**
* 修改案卷基本信息,业务信息,不动产信息
*
* @param request
* @return
*/
boolean updateDgArchivesReplenish(UpdateArchiveAndOtherInfoRequest request);
/**
* 根据条件进行列表查询
*
* @param request
* @return
*/
Page searchDgArchivesList(DgArchivesSearchRequest request);
/**
* 根据档案标识码加载左侧菜单
*
* @param bsmArchives 档案标识码
* @return
*/
List getArchiveLiftMenu(String bsmArchives);
/**
* 档案查找
*
* @param request
* @return
*/
IPage<SearchArchiveVO> searchArchive(SearchArchiveRequest request);
/**
* 档案封皮查找
*
* @param bsmArchive
* @return
*/
ArchiveDetailAndCoverVO searchArchivesCover(String bsmArchive);
/**
* 1.比对新增的记录数据库是否存在，如果不存在则新增
* 2.比对数据库的数据是否存在前端传递的集合中，不存在则删除，并且删除对应的电子附件数据
* 3.如果目录记录标识码与数据库一致，直接更新当前的记录
*
* @param requests
* @return
*/
boolean updateCatalog(List<UpdateDgArchivesCatalogRequest> requests);
/**
* 根据条件进行列表查询
* @param request
* @return
*/
List<DgArchivesCatalogWithFileVO> searchDgFileList(DgFileSearchRequest request);
/**
* 档案目录查找
* @param bsmArchive
* @return
*/
List<DgArchivesCatalogListVO> searchCatalog(String bsmArchive);
}
package com.pashanhoo.archive.service.impl;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pashanhoo.archive.entity.DgArchivesConverter;
import com.pashanhoo.archive.entity.DgArchivesDO;
import com.pashanhoo.archive.entity.vo.*;
import com.pashanhoo.archive.mapper.DgArchivesMapper;
import com.pashanhoo.archive.service.DgArchivesService;
import com.pashanhoo.bdcdy.entity.DgBdcdyConverter;
import com.pashanhoo.bdcdy.entity.DgBdcdyDO;
import com.pashanhoo.bdcdy.entity.vo.DgBdcdyDetailVO;
import com.pashanhoo.bdcdy.entity.vo.UpdateDgBdcdyRequest;
import com.pashanhoo.bdcdy.mapper.DgBdcdyMapper;
import com.pashanhoo.bdcdy.service.DgBdcdyService;
import com.pashanhoo.business.entity.DgBusinessConverter;
import com.pashanhoo.business.entity.DgBusinessDO;
import com.pashanhoo.business.entity.vo.DgBusinessDetailVO;
import com.pashanhoo.business.entity.vo.UpdateDgBusinessRequest;
import com.pashanhoo.business.service.DgBusinessService;
import com.pashanhoo.catalog.entity.DgArchivesCatalogConverter;
import com.pashanhoo.catalog.entity.DgArchivesCatalogDO;
import com.pashanhoo.catalog.entity.vo.DgArchivesCatalogListVO;
import com.pashanhoo.catalog.entity.vo.DgArchivesCatalogWithFileVO;
import com.pashanhoo.catalog.entity.vo.UpdateDgArchivesCatalogRequest;
import com.pashanhoo.catalog.service.DgArchivesCatalogService;
import com.pashanhoo.common.util.fileupload.MinioUtil;
import com.pashanhoo.file.entity.DgFileDO;
import com.pashanhoo.file.entity.vo.DgFileSearchRequest;
import com.pashanhoo.file.service.DgFileService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.stream.Collectors;
/**
* <p>
* 案卷基本信息 服务实现类
* </p>
*
* @author
* @since 2021-11-05
*/
@Service
public class DgArchivesServiceImpl extends ServiceImpl<DgArchivesMapper, DgArchivesDO> implements DgArchivesService {
@Autowired
private DgArchivesConverter dgarchivesConverter;
@Autowired
private DgArchivesMapper dgarchivesMapper;
@Autowired
private DgBdcdyService dgBdcdyService;
@Autowired
private DgBdcdyMapper dgBdcdyMapper;
@Autowired
private DgBdcdyConverter dgBdcdyConverter;
@Autowired
private DgBusinessService dgBusinessService;
@Autowired
private DgBusinessConverter dgBusinessConverter;
@Autowired
private DgArchivesCatalogService catalogService;
@Autowired
private DgArchivesCatalogConverter catalogConverter;
@Autowired
private DgFileService dgFileService;
@Autowired
private MinioUtil minioUtil;
/**
* 新增记录
*
* @param request
* @return
*/
@Override
public boolean insertDgArchives(AddDgArchivesRequest request) {
DgArchivesDO dgarchivesDO = dgarchivesConverter.addRequest2DO(request);
return this.save(dgarchivesDO);
}
/**
* 查询案卷基本信息
*
* @param bsmArchive
* @return
*/
@Override
public ArchiveDetailAndCoverVO getDgArchivesDetailById(String bsmArchive) {
ArchiveDetailAndCoverVO detailAndCoverVO = getCover(bsmArchive);
//查询业务信息
QueryWrapper<DgBusinessDO> businessWrapper = new QueryWrapper<>();
businessWrapper.lambda().eq(DgBusinessDO::getBsmArchives, bsmArchive);
DgBusinessDO businessDO = dgBusinessService.getOne(businessWrapper);
DgBusinessDetailVO dgBusinessDetailVO = dgBusinessConverter.do2DetailVO(businessDO);
detailAndCoverVO.setDgBusinessDetailVO(dgBusinessDetailVO);
return detailAndCoverVO;
}
/**
* 修改案卷基本信息,业务信息,不动产信息
*
* @param request
* @return
*/
@Override
@Transactional(rollbackFor = Exception.class)
public boolean updateDgArchivesReplenish(UpdateArchiveAndOtherInfoRequest request) {
//修改案卷基本信息
UpdateDgArchivesRequest updateDgArchivesRequest = request.getUpdateDgArchivesRequest();
DgArchivesDO dgArchivesDO = dgarchivesConverter.updateRequest2DO(updateDgArchivesRequest);
String bsmArchives = dgArchivesDO.getBsmArchives();
this.updateById(dgArchivesDO);
//修改不动产信息,先删除.后插入
List<UpdateDgBdcdyRequest> updateDgBdcdyRequests = request.getUpdateDgBdcdyRequests();
List<DgBdcdyDO> dgBdcdyDOS = dgBdcdyConverter.voList2DoList(updateDgBdcdyRequests);
//删除
QueryWrapper<DgBdcdyDO> wrapper = new QueryWrapper<>();
wrapper.lambda().eq(DgBdcdyDO::getBsmArchives, bsmArchives);
dgBdcdyService.remove(wrapper);
//插入
dgBdcdyService.saveBatch(dgBdcdyDOS);
//修改业务信息
UpdateDgBusinessRequest updateDgBusinessRequest = request.getUpdateDgBusinessRequest();
DgBusinessDO dgBusinessDO = dgBusinessConverter.updateRequest2DO(updateDgBusinessRequest);
QueryWrapper<DgBusinessDO> queryWrapper = new QueryWrapper<>();
queryWrapper.lambda().eq(DgBusinessDO::getBsmArchives, bsmArchives);
return dgBusinessService.update(dgBusinessDO, queryWrapper);
}
/**
* 根据条件进行列表查询
*
* @param request
* @return
*/
@Override
public Page searchDgArchivesList(DgArchivesSearchRequest request) {
Page<DgArchivesDO> pageParam = new Page<DgArchivesDO>(request.getCurrentPage(), request.getPageSize());
QueryWrapper<DgArchivesDO> wrapper = new QueryWrapper<>();
//设置默认排序
wrapper = "desc".equals(request.getSortOrder()) ? wrapper.orderByDesc(request.getSortField()) : wrapper.orderByAsc(request.getSortField());
//增加条件
// lt：less than 小于
// le：less than or equal to 小于等于
// eq：equal to 等于
// ne：not equal to 不等于
// ge：greater than or equal to 大于等于
// gt：greater than 大于
wrapper = "desc".equals(request.getSortOrder()) ? wrapper.orderByDesc(request.getSortField()) : wrapper.orderByAsc(request.getSortField());
wrapper.eq(request.getAjbt() != null, "AJBT", request.getAjbt());
wrapper.eq(request.getFlh() != null, "FLH", request.getFlh());
wrapper.eq(request.getMlh() != null, "MLH", request.getMlh());
wrapper.eq(request.getAjh() != null, "AJH", request.getAjh());
wrapper.eq(request.getNd() != null, "ND", request.getNd());
wrapper.eq(request.getDazt() != null, "DAZT", request.getDazt());
wrapper.eq(request.getMj() != null, "MJ", request.getMj());
wrapper.ge(request.getQsrq() != null, "QSRQ", request.getQsrq());
wrapper.le(request.getZzrq() != null, "ZZRQ", request.getZzrq());
wrapper.eq(request.getHh() != null, "HH", request.getHh());
wrapper.eq(request.getCfwz() != null, "CFWZ", request.getCfwz());
wrapper.eq(request.getZtc() != null, "ZTC", request.getZtc());
Page page = this.page(pageParam, wrapper);
//将查询出来的DO List转为 ListVO List并重新设置到page对象中，并返回page对象
return page.setRecords(dgarchivesConverter.doList2ListVOList(page.getRecords()));
}
/**
* 根据档案标识码加载左侧菜单
*
* @param bsmArchives 档案标识码
* @return
*/
@Override
public List getArchiveLiftMenu(String bsmArchives) {
DgArchivesDO archivesDO = this.getById(bsmArchives);
Integer status = archivesDO.getDazt().intValue();
/*状态判断.如果状态为:1,2,3显示为不动产单元号
如果状态为:4,5,6,7,8显示为档案号
*/
List<DgBdcdyDO> dgBdcdyDOS = null;
if (status.equals(1) || status.equals(2) || status.equals(3)) {
QueryWrapper<DgBdcdyDO> bdcdyWrapper = new QueryWrapper<>();
bdcdyWrapper.lambda().eq(DgBdcdyDO::getBsmArchives, bsmArchives);
dgBdcdyDOS = dgBdcdyMapper.selectList(bdcdyWrapper);
return dgBdcdyDOS;
}
return dgBdcdyDOS;
}
/**
* 档案查找
*
* @param request
* @return
*/
@Override
public IPage<SearchArchiveVO> searchArchive(SearchArchiveRequest request) {
IPage<SearchArchiveVO> pageParam = new Page<>(request.getCurrentPage(), request.getPageSize());
return dgarchivesMapper.searchArchive(pageParam, request);
}
/**
* 档案封皮查找
*
* @param bsmArchive
* @return
*/
@Override
public ArchiveDetailAndCoverVO searchArchivesCover(String bsmArchive) {
return getCover(bsmArchive);
}
/**
* 1.比对新增的记录数据库是否存在，如果不存在则新增
* 2.比对数据库的数据是否存在前端传递的集合中，不存在则删除，并且删除对应的电子附件数据
* 3.如果目录记录标识码与数据库一致，直接更新当前的记录
*
* @param requests
* @return
*/
@Override
@Transactional(rollbackFor = Exception.class)
public boolean updateCatalog(List<UpdateDgArchivesCatalogRequest> requests) {
List<UpdateDgArchivesCatalogRequest> updateCatalogs = requests.stream().filter(item -> !StrUtil.isNullOrUndefined(item.getBsmCatalog())).collect(Collectors.toList());
List<UpdateDgArchivesCatalogRequest> addCatalogs = requests.stream().filter(item -> StrUtil.isNullOrUndefined(item.getBsmCatalog())).collect(Collectors.toList());
boolean flag = false;
//存量数据更新.
if (updateCatalogs.size() != 0) {
String bsmArchive = updateCatalogs.stream().map(UpdateDgArchivesCatalogRequest::getBsmArchives).findFirst().orElse(null);
QueryWrapper<DgArchivesCatalogDO> catalogWrapper = new QueryWrapper<>();
catalogWrapper.lambda().eq(DgArchivesCatalogDO::getBsmArchives, bsmArchive);
List<DgArchivesCatalogDO> catalogsAlreadyExist = catalogService.list(catalogWrapper);
//入参的存量数据小于数据库内数据,删除数据库内多余数据
if (updateCatalogs.size() < catalogsAlreadyExist.size()) {
List<String> updateBsmCatalogs = updateCatalogs.stream().map(UpdateDgArchivesCatalogRequest::getBsmCatalog).collect(Collectors.toList());
List<String> alreadyExistBsmCatalogs = catalogsAlreadyExist.stream().map(DgArchivesCatalogDO::getBsmCatalog).collect(Collectors.toList());
//过滤数据
List<String> deleteBsmCatalogs = alreadyExistBsmCatalogs.stream().filter(item -> !updateBsmCatalogs.contains(item)).collect(Collectors.toList());
//删除附件表数据
QueryWrapper<DgFileDO> fileWrapper = new QueryWrapper<>();
fileWrapper.lambda().in(DgFileDO::getBsmCatalog, deleteBsmCatalogs);
dgFileService.remove(fileWrapper);
//删除目录表多余数据
catalogWrapper.lambda().in(DgArchivesCatalogDO::getBsmCatalog,deleteBsmCatalogs);
catalogService.remove(catalogWrapper);
}
List<DgArchivesCatalogDO> updateCatalogDOs = catalogConverter.updateList2DO(updateCatalogs);
flag = catalogService.updateBatchById(updateCatalogDOs);
}
if (addCatalogs.size() != 0) {
//新增数据
List<DgArchivesCatalogDO> addCatalogDOs = catalogConverter.updateList2DO(addCatalogs);
flag = catalogService.saveBatch(addCatalogDOs);
}
return flag;
}
/**
* 查找档案目录和对应的附件列表
* @param request
* @return
*/
@Override
public List<DgArchivesCatalogWithFileVO> searchDgFileList(DgFileSearchRequest request) {
List<DgArchivesCatalogWithFileVO> fileListVOS = dgarchivesMapper.selectCatalogWithFile(request);
for (DgArchivesCatalogWithFileVO fileListVO : fileListVOS) {
for (DgFileDO dgFileDO : fileListVO.getDgFileDOS()) {
if (dgFileDO.getFjurl() != null) {
String previewUrl = minioUtil.getPreviewUrl(dgFileDO.getFjurl());
dgFileDO.setFjurl(previewUrl);
}
}
}
return fileListVOS;
}
/**
* 档案目录查找
*
* @param bsmArchive
* @return
*/
@Override
public List<DgArchivesCatalogListVO> searchCatalog(String bsmArchive) {
QueryWrapper<DgArchivesCatalogDO> catalogWrapper = new QueryWrapper<>();
catalogWrapper.lambda().eq(DgArchivesCatalogDO::getBsmArchives, bsmArchive).orderByAsc(DgArchivesCatalogDO::getXh);
List<DgArchivesCatalogDO> list = catalogService.list(catalogWrapper);
return catalogConverter.doList2ListVOList(list);
}
private ArchiveDetailAndCoverVO getCover(String bsmArchive) {
DgArchivesDO archivesDO = this.getById(bsmArchive);
DgArchivesDetailVO dgArchivesDetailVO = dgarchivesConverter.do2DetailVO(archivesDO);
QueryWrapper<DgBdcdyDO> bdcdyWrapper = new QueryWrapper<>();
bdcdyWrapper.lambda().eq(DgBdcdyDO::getBsmArchives, bsmArchive);
List<DgBdcdyDO> bdcdyDOS = dgBdcdyService.list(bdcdyWrapper);
List<DgBdcdyDetailVO> bdcdyDetailVOList = dgBdcdyConverter.do2DetailVOList(bdcdyDOS);
ArchiveDetailAndCoverVO archiveDetailAndCoverVO = new ArchiveDetailAndCoverVO();
archiveDetailAndCoverVO.setDgArchivesDetailVO(dgArchivesDetailVO);
archiveDetailAndCoverVO.setDgBdcdyDetailVOList(bdcdyDetailVOList);
return archiveDetailAndCoverVO;
}
}
package com.pashanhoo.bdcdy.controller;
import com.pashanhoo.common.Result;
import com.pashanhoo.bdcdy.entity.vo.AddDgBdcdyRequest;
import com.pashanhoo.bdcdy.entity.vo.UpdateDgBdcdyRequest;
import com.pashanhoo.bdcdy.entity.vo.DgBdcdySearchRequest;
import com.pashanhoo.bdcdy.service.DgBdcdyService;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
/**
* <p>
* 档案不动产信息 前端控制器
* </p>
*
* @author
* @since 2021-11-05
*/
@RestController
@RequestMapping("/system/dgBdcdy/")
@Api(tags = "档案不动产信息接口")
public class DgBdcdyController {
@Autowired
private DgBdcdyService dgbdcdyService;
@PostMapping("insertDgBdcdy")
@ApiOperation("新增档案不动产信息")
public Result insertDgBdcdy(@RequestBody AddDgBdcdyRequest request){
if(dgbdcdyService.insertDgBdcdy(request)){
return Result.ok();
}
return Result.error("新增失败");
}
@DeleteMapping("deleteDgBdcdyByIds")
@ApiOperation(value = "批量删除档案不动产信息")
public Result deleteDgBdcdyByIds(@ApiParam("档案不动产信息ID列表") @RequestParam(value = "idList") List<String> idList) {
if(dgbdcdyService.removeByIds(idList)) {
return Result.ok("删除成功");
}
return Result.error("删除失败");
}
@PutMapping("updateDgBdcdy")
@ApiOperation("修改档案不动产信息")
public Result updateDgBdcdy(@RequestBody UpdateDgBdcdyRequest request){
if(dgbdcdyService.updateDgBdcdy(request)) {
return Result.ok("修改成功");
}
return Result.error("修改失败");
}
@GetMapping("getDgBdcdyDetailById")
@ApiOperation(value = "读取明细")
public Result getDgBdcdyDetailById(@ApiParam("档案不动产信息ID") @RequestParam String id){
return Result.ok(dgbdcdyService.getDgBdcdyDetailById(id));
}
@PostMapping("search")
@ApiOperation(value = "根据条件进行列表查询")
public Result searchDgBdcdyList(@RequestBody DgBdcdySearchRequest request) {
//TODO 默认排序条件设置
request.defaultFillPageProp("","");
return Result.ok(dgbdcdyService.searchDgBdcdyList(request));
}
}
package com.pashanhoo.bdcdy.entity;
import java.util.List;
import com.pashanhoo.bdcdy.entity.vo.AddDgBdcdyRequest;
import com.pashanhoo.bdcdy.entity.vo.DgBdcdyDetailVO;
import com.pashanhoo.bdcdy.entity.vo.DgBdcdyListVO;
import com.pashanhoo.bdcdy.entity.vo.UpdateDgBdcdyRequest;
import org.mapstruct.Mapper;
/**
* @author
* @since 2021-11-05
*/
@Mapper(componentModel = "spring")
public interface DgBdcdyConverter{
DgBdcdyDO addRequest2DO(AddDgBdcdyRequest request);
DgBdcdyDetailVO do2DetailVO(DgBdcdyDO dgbdcdyDO);
DgBdcdyDO updateRequest2DO(UpdateDgBdcdyRequest request);
DgBdcdyListVO do2ListVO(DgBdcdyDO dgbdcdyDO);
List<DgBdcdyListVO> doList2ListVOList(List<DgBdcdyDO> dgbdcdyDOList);
List<DgBdcdyDO> addRequestListDO(List<AddDgBdcdyRequest> request);
List<DgBdcdyDO> voList2DoList(List<UpdateDgBdcdyRequest> requests);
List<DgBdcdyDetailVO> do2DetailVOList(List<DgBdcdyDO> bdcdyDOS);
}
package com.pashanhoo.bdcdy.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案不动产信息
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("DG_BDCDY")
public class DgBdcdyDO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 单元标识码
*/
@TableId(value = "BSM_BDCDY", type = IdType.UUID)
private String bsmBdcdy;
/**
* 档案标识码
*/
@TableField("BSM_ARCHIVES")
private String bsmArchives;
/**
* 权利标识码
*/
@TableField("BSM_QL")
private String bsmQl;
/**
* 不动产单元ID
*/
@TableField("BDCDYID")
private String bdcdyid;
/**
* 不动产单元号
*/
@TableField("BDCDYH")
private String bdcdyh;
/**
* 坐落
*/
@TableField("ZL")
private String zl;
/**
* 权利人
*/
@TableField("QLR")
private String qlr;
/**
* 权利人证件号
*/
@TableField("ZJHM")
private String zjhm;
/**
* 义务人
*/
@TableField("YWR")
private String ywr;
/**
* 不动产权证号
*/
@TableField("BDCQZH")
private String bdcqzh;
/**
* 登记时间
*/
@TableField("DJSJ")
private Date djsj;
/**
* 注销时间
*/
@TableField("ZXSJ")
private Date zxsj;
/**
* 不动产单元类型
*/
@TableField("BDCDYLX")
private String bdcdylx;
/**
* 是否挂接
*/
@TableField("SFGJ")
private String sfgj;
}
package com.pashanhoo.bdcdy.entity.vo;
import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
import javax.validation.constraints.NotEmpty;
/**
* <p>
* 档案不动产信息新增请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案不动产信息新增请求实体")
public class AddDgBdcdyRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 权利标识码
*/
@NotEmpty(message = "权利标识码【bsmQl】不能为空")
@ApiModelProperty(name = "bsmQl", value = "权利标识码")
private String bsmQl;
/**
* 不动产单元ID
*/
@NotEmpty(message = "不动产单元ID【bdcdyid】不能为空")
@ApiModelProperty(name = "bdcdyid", value = "不动产单元ID")
private String bdcdyid;
/**
* 不动产单元号
*/
@NotEmpty(message = "不动产单元号【bdcdyh】不能为空")
@ApiModelProperty(name = "bdcdyh", value = "不动产单元号")
private String bdcdyh;
/**
* 坐落
*/
@NotEmpty(message = "坐落【zl】不能为空")
@ApiModelProperty(name = "zl", value = "坐落")
private String zl;
/**
* 权利人
*/
@NotEmpty(message = "权利人【qlr】不能为空")
@ApiModelProperty(name = "qlr", value = "权利人")
private String qlr;
/**
* 权利人证件号
*/
@NotEmpty(message = "权利人证件号【zjhm】不能为空")
@ApiModelProperty(name = "zjhm", value = "权利人证件号")
private String zjhm;
/**
* 义务人
*/
@ApiModelProperty(name = "ywr", value = "义务人")
private String ywr;
/**
* 不动产权证号
*/
@NotEmpty(message = "不动产权证号【bdcqzh】不能为空")
@ApiModelProperty(name = "bdcqzh", value = "不动产权证号")
private String bdcqzh;
/**
* 登记时间
*/
@NotEmpty(message = "登记时间【djsj】不能为空")
@ApiModelProperty(name = "djsj", value = "登记时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date djsj;
/**
* 注销时间
*/
@ApiModelProperty(name = "zxsj", value = "注销时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date zxsj;
/**
* 不动产单元类型
*/
@NotEmpty(message = "不动产单元类型【bdcdylx】不能为空")
@ApiModelProperty(name = "bdcdylx", value = "不动产单元类型")
private String bdcdylx;
/**
* 是否挂接
*/
@ApiModelProperty(name = "sfgj", value = "是否挂接")
private String sfgj;
}
package com.pashanhoo.bdcdy.entity.vo;
import java.util.Date;
import java.io.Serializable;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案不动产信息明细实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案不动产信息明细实体")
public class DgBdcdyDetailVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 单元标识码
*/
@ApiModelProperty(name = "bsmBdcdy", value = "单元标识码")
private String bsmBdcdy;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 权利标识码
*/
@ApiModelProperty(name = "bsmQl", value = "权利标识码")
private String bsmQl;
/**
* 不动产单元ID
*/
@ApiModelProperty(name = "bdcdyid", value = "不动产单元ID")
private String bdcdyid;
/**
* 不动产单元号
*/
@ApiModelProperty(name = "bdcdyh", value = "不动产单元号")
private String bdcdyh;
/**
* 坐落
*/
@ApiModelProperty(name = "zl", value = "坐落")
private String zl;
/**
* 权利人
*/
@ApiModelProperty(name = "qlr", value = "权利人")
private String qlr;
/**
* 权利人证件号
*/
@ApiModelProperty(name = "zjhm", value = "权利人证件号")
private String zjhm;
/**
* 义务人
*/
@ApiModelProperty(name = "ywr", value = "义务人")
private String ywr;
/**
* 不动产权证号
*/
@ApiModelProperty(name = "bdcqzh", value = "不动产权证号")
private String bdcqzh;
/**
* 登记时间
*/
@ApiModelProperty(name = "djsj", value = "登记时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date djsj;
/**
* 注销时间
*/
@ApiModelProperty(name = "zxsj", value = "注销时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date zxsj;
}
package com.pashanhoo.bdcdy.entity.vo;
import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案不动产信息列表VO
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案不动产信息列表VO")
//TODO 该类属性暂时是完整的全部属性，需进行个性化的增删
public class DgBdcdyListVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 单元标识码
*/
@ApiModelProperty(name = "bsmBdcdy", value = "单元标识码")
private String bsmBdcdy;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 权利标识码
*/
@ApiModelProperty(name = "bsmQl", value = "权利标识码")
private String bsmQl;
/**
* 不动产单元ID
*/
@ApiModelProperty(name = "bdcdyid", value = "不动产单元ID")
private String bdcdyid;
/**
* 不动产单元号
*/
@ApiModelProperty(name = "bdcdyh", value = "不动产单元号")
private String bdcdyh;
/**
* 坐落
*/
@ApiModelProperty(name = "zl", value = "坐落")
private String zl;
/**
* 权利人
*/
@ApiModelProperty(name = "qlr", value = "权利人")
private String qlr;
/**
* 权利人证件号
*/
@ApiModelProperty(name = "zjhm", value = "权利人证件号")
private String zjhm;
/**
* 义务人
*/
@ApiModelProperty(name = "ywr", value = "义务人")
private String ywr;
/**
* 不动产权证号
*/
@ApiModelProperty(name = "bdcqzh", value = "不动产权证号")
private String bdcqzh;
/**
* 登记时间
*/
@ApiModelProperty(name = "djsj", value = "登记时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date djsj;
/**
* 注销时间
*/
@ApiModelProperty(name = "zxsj", value = "注销时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date zxsj;
}
package com.pashanhoo.bdcdy.entity.vo;
import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import com.pashanhoo.common.PageInfo;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案不动产信息列表查询请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案不动产信息列表查询请求实体")
//TODO 初始查询条件是全部，需要根据情况自行删减
public class DgBdcdySearchRequest extends PageInfo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 单元标识码
*/
@ApiModelProperty(name = "bsmBdcdy", value = "单元标识码")
private String bsmBdcdy;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 权利标识码
*/
@ApiModelProperty(name = "bsmQl", value = "权利标识码")
private String bsmQl;
/**
* 不动产单元ID
*/
@ApiModelProperty(name = "bdcdyid", value = "不动产单元ID")
private String bdcdyid;
/**
* 不动产单元号
*/
@ApiModelProperty(name = "bdcdyh", value = "不动产单元号")
private String bdcdyh;
/**
* 坐落
*/
@ApiModelProperty(name = "zl", value = "坐落")
private String zl;
/**
* 权利人
*/
@ApiModelProperty(name = "qlr", value = "权利人")
private String qlr;
/**
* 权利人证件号
*/
@ApiModelProperty(name = "zjhm", value = "权利人证件号")
private String zjhm;
/**
* 义务人
*/
@ApiModelProperty(name = "ywr", value = "义务人")
private String ywr;
/**
* 不动产权证号
*/
@ApiModelProperty(name = "bdcqzh", value = "不动产权证号")
private String bdcqzh;
/**
* 登记时间
*/
@ApiModelProperty(name = "djsj", value = "登记时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date djsj;
/**
* 注销时间
*/
@ApiModelProperty(name = "zxsj", value = "注销时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date zxsj;
}
package com.pashanhoo.bdcdy.entity.vo;
import java.util.Date;
import java.io.Serializable;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案不动产信息修改请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案不动产信息修改请求实体")
public class UpdateDgBdcdyRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 单元标识码
*/
@ApiModelProperty(name = "bsmBdcdy", value = "单元标识码")
private String bsmBdcdy;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 权利标识码
*/
@ApiModelProperty(name = "bsmQl", value = "权利标识码")
private String bsmQl;
/**
* 不动产单元ID
*/
@ApiModelProperty(name = "bdcdyid", value = "不动产单元ID")
private String bdcdyid;
/**
* 不动产单元号
*/
@ApiModelProperty(name = "bdcdyh", value = "不动产单元号")
private String bdcdyh;
/**
* 坐落
*/
@ApiModelProperty(name = "zl", value = "坐落")
private String zl;
/**
* 权利人
*/
@ApiModelProperty(name = "qlr", value = "权利人")
private String qlr;
/**
* 权利人证件号
*/
@ApiModelProperty(name = "zjhm", value = "权利人证件号")
private String zjhm;
/**
* 义务人
*/
@ApiModelProperty(name = "ywr", value = "义务人")
private String ywr;
/**
* 不动产权证号
*/
@ApiModelProperty(name = "bdcqzh", value = "不动产权证号")
private String bdcqzh;
/**
* 登记时间
*/
@ApiModelProperty(name = "djsj", value = "登记时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date djsj;
/**
* 注销时间
*/
@ApiModelProperty(name = "zxsj", value = "注销时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date zxsj;
}
package com.pashanhoo.bdcdy.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.pashanhoo.bdcdy.entity.DgBdcdyDO;
/**
* <p>
* 档案不动产信息 Mapper 接口
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgBdcdyMapper extends BaseMapper<DgBdcdyDO> {
}
package com.pashanhoo.bdcdy.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.pashanhoo.bdcdy.entity.DgBdcdyDO;
import com.pashanhoo.bdcdy.entity.vo.AddDgBdcdyRequest;
import com.pashanhoo.bdcdy.entity.vo.DgBdcdyDetailVO;
import com.pashanhoo.bdcdy.entity.vo.UpdateDgBdcdyRequest;
import com.pashanhoo.bdcdy.entity.vo.DgBdcdySearchRequest;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.pashanhoo.common.Result;
/**
* <p>
* 档案不动产信息 服务类
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgBdcdyService extends IService<DgBdcdyDO> {
/**
* 新增记录
* @param request
* @return
*/
boolean insertDgBdcdy(AddDgBdcdyRequest request);
/**
* 根据主键查询记录详情
* @param id
* @return
*/
DgBdcdyDetailVO getDgBdcdyDetailById(String id);
/**
* 修改单条记录
* @param request
* @return
*/
boolean updateDgBdcdy(UpdateDgBdcdyRequest request);
/**
* 根据条件进行列表查询
* @param request
* @return
*/
Page searchDgBdcdyList(DgBdcdySearchRequest request);
/**
* 非主键修改单元信息
* @param request
* @return
*/
Result updateDgBdcdyByArchive(UpdateDgBdcdyRequest request);
}
package com.pashanhoo.bdcdy.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pashanhoo.bdcdy.entity.DgBdcdyConverter;
import com.pashanhoo.bdcdy.entity.DgBdcdyDO;
import com.pashanhoo.bdcdy.entity.vo.AddDgBdcdyRequest;
import com.pashanhoo.bdcdy.entity.vo.DgBdcdyDetailVO;
import com.pashanhoo.bdcdy.entity.vo.UpdateDgBdcdyRequest;
import com.pashanhoo.bdcdy.entity.vo.DgBdcdySearchRequest;
import com.pashanhoo.bdcdy.mapper.DgBdcdyMapper;
import com.pashanhoo.bdcdy.service.DgBdcdyService;
import com.pashanhoo.common.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
/**
* <p>
* 档案不动产信息 服务实现类
* </p>
*
* @author
* @since 2021-11-05
*/
@Service
public class DgBdcdyServiceImpl extends ServiceImpl<DgBdcdyMapper, DgBdcdyDO> implements DgBdcdyService {
@Autowired
private DgBdcdyConverter dgbdcdyConverter;
@Autowired
private DgBdcdyMapper dgbdcdyMapper;
/**
* 新增记录
* @param request
* @return
*/
@Override
public boolean insertDgBdcdy(AddDgBdcdyRequest request) {
DgBdcdyDO dgbdcdyDO = dgbdcdyConverter.addRequest2DO(request);
return this.save(dgbdcdyDO);
}
/**
* 根据主键查询记录详情
* @param id
* @return
*/
@Override
public DgBdcdyDetailVO getDgBdcdyDetailById(String id) {
DgBdcdyDO dgbdcdyDO = this.getById(id);
return dgbdcdyConverter.do2DetailVO(dgbdcdyDO);
}
/**
* 修改单条记录
* @param request
* @return
*/
@Override
public boolean updateDgBdcdy(UpdateDgBdcdyRequest request) {
DgBdcdyDO dgbdcdyDO = dgbdcdyConverter.updateRequest2DO(request);
return this.updateById(dgbdcdyDO);
}
/**
* 根据条件进行列表查询
* @param request
* @return
*/
@Override
public Page searchDgBdcdyList(DgBdcdySearchRequest request) {
Page<DgBdcdyDO> pageParam = new Page<DgBdcdyDO>(request.getCurrentPage(), request.getPageSize());
QueryWrapper<DgBdcdyDO> wrapper = new QueryWrapper<>();
//设置默认排序
wrapper = "desc".equals(request.getSortOrder()) ? wrapper.orderByDesc(request.getSortField()) : wrapper.orderByAsc(request.getSortField());
//TODO 根据当前情况设置wrapper条件
Page page = this.page(pageParam, wrapper);
//将查询出来的DO List转为 ListVO List并重新设置到page对象中，并返回page对象
return page.setRecords(dgbdcdyConverter.doList2ListVOList(page.getRecords()));
}
@Override
public Result updateDgBdcdyByArchive(UpdateDgBdcdyRequest request) {
QueryWrapper<DgBdcdyDO> wrapper = new QueryWrapper<>();
wrapper.eq(request.getBsmArchives()!=null && !"".equals(request.getBsmArchives()),"BSM_ARCHIVES",request.getBsmArchives());
DgBdcdyDO bdcdyDO=dgbdcdyConverter.updateRequest2DO(request);
dgbdcdyMapper.update(bdcdyDO,wrapper);
return Result.ok();
}
}
package com.pashanhoo.business.controller;
import com.pashanhoo.common.Result;
import com.pashanhoo.business.entity.vo.AddDgBusinessRequest;
import com.pashanhoo.business.entity.vo.UpdateDgBusinessRequest;
import com.pashanhoo.business.entity.vo.DgBusinessSearchRequest;
import com.pashanhoo.business.service.DgBusinessService;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
/**
* <p>
* 档案业务信息 前端控制器
* </p>
*
* @author
* @since 2021-11-05
*/
@RestController
@RequestMapping("/system/dgBusiness/")
@Api(tags = "档案业务信息接口")
public class DgBusinessController {
@Autowired
private DgBusinessService dgbusinessService;
@PostMapping("insertDgBusiness")
@ApiOperation("新增档案业务信息")
public Result insertDgBusiness(@RequestBody AddDgBusinessRequest request){
if(dgbusinessService.insertDgBusiness(request)){
return Result.ok();
}
return Result.error("新增失败");
}
@DeleteMapping("deleteDgBusinessByIds")
@ApiOperation(value = "批量删除档案业务信息")
public Result deleteDgBusinessByIds(@ApiParam("档案业务信息ID列表") @RequestParam(value = "idList") List<String> idList) {
if(dgbusinessService.removeByIds(idList)) {
return Result.ok("删除成功");
}
return Result.error("删除失败");
}
@PutMapping("updateDgBusiness")
@ApiOperation("修改档案业务信息")
public Result updateDgBusiness(@RequestBody UpdateDgBusinessRequest request){
if(dgbusinessService.updateDgBusiness(request)) {
return Result.ok("修改成功");
}
return Result.error("修改失败");
}
@GetMapping("getDgBusinessDetailById")
@ApiOperation(value = "读取明细")
public Result getDgBusinessDetailById(@ApiParam("档案业务信息ID") @RequestParam String id){
return Result.ok(dgbusinessService.getDgBusinessDetailById(id));
}
@PostMapping("search")
@ApiOperation(value = "根据条件进行列表查询")
public Result searchDgBusinessList(@RequestBody DgBusinessSearchRequest request) {
//TODO 默认排序条件设置
request.defaultFillPageProp("","");
return Result.ok(dgbusinessService.searchDgBusinessList(request));
}
}
package com.pashanhoo.business.entity;
import java.util.List;
import com.pashanhoo.business.entity.vo.AddDgBusinessRequest;
import com.pashanhoo.business.entity.vo.DgBusinessDetailVO;
import com.pashanhoo.business.entity.vo.DgBusinessListVO;
import com.pashanhoo.business.entity.vo.UpdateDgBusinessRequest;
import org.mapstruct.Mapper;
/**
* @author
* @since 2021-11-05
*/
@Mapper(componentModel = "spring")
public interface DgBusinessConverter{
DgBusinessDO addRequest2DO(AddDgBusinessRequest request);
DgBusinessDetailVO do2DetailVO(DgBusinessDO dgbusinessDO);
DgBusinessDO updateRequest2DO(UpdateDgBusinessRequest request);
DgBusinessListVO do2ListVO(DgBusinessDO dgbusinessDO);
List<DgBusinessListVO> doList2ListVOList(List<DgBusinessDO> dgbusinessDOList);
}
package com.pashanhoo.business.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import java.util.Date;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案业务信息
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("DG_BUSINESS")
public class DgBusinessDO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 业务标识码
*/
@TableId(value = "BSM_BUSINESS", type = IdType.UUID)
private String bsmBusiness;
/**
* 档案标识码
*/
@TableField("BSM_ARCHIVES")
private String bsmArchives;
/**
* 业务号
*/
@TableField("YWH")
private String ywh;
/**
* 登记类型
*/
@TableField("DJLX")
private String djlx;
/**
* 权利类型
*/
@TableField("QLLX")
private String qllx;
/**
* 登记机构编码
*/
@TableField("DJJGBM")
private String djjgbm;
/**
* 登记机构名称
*/
@TableField("DJJGMC")
private String djjgmc;
/**
* 登记业务名称
*/
@TableField("DJYWMC")
private String djywmc;
/**
* 注销业务号
*/
@TableField("ZXYWH")
private String zxywh;
/**
* 注销类型
*/
@TableField("ZXLX")
private String zxlx;
/**
* 收件时间
*/
@TableField("SJSJ")
private Date sjsj;
/**
* 收件人员
*/
@TableField("SJRY")
private String sjry;
/**
* 原业务标识码
*/
@TableField("BSM_YW")
private String bsmYw;
}
package com.pashanhoo.business.entity.vo;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.TableField;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
import javax.validation.constraints.NotEmpty;
/**
* <p>
* 档案业务信息新增请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案业务信息新增请求实体")
public class AddDgBusinessRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 业务号
*/
@NotEmpty(message = "业务号【ywh】不能为空")
@ApiModelProperty(name = "ywh", value = "业务号")
private String ywh;
/**
* 登记类型
*/
@NotEmpty(message = "登记类型【djlx】不能为空")
@ApiModelProperty(name = "djlx", value = "登记类型")
private String djlx;
/**
* 权利类型
*/
@NotEmpty(message = "权利类型【qllx】不能为空")
@ApiModelProperty(name = "qllx", value = "权利类型")
private String qllx;
/**
* 登记机构编码
*/
@NotEmpty(message = "登记机构编码【djjgbm】不能为空")
@ApiModelProperty(name = "djjgbm", value = "登记机构编码")
private String djjgbm;
/**
* 登记机构名称
*/
@NotEmpty(message = "登记机构名称【djjgmc】不能为空")
@ApiModelProperty(name = "djjgmc", value = "登记机构名称")
private String djjgmc;
/**
* 注销业务号
*/
@ApiModelProperty(name = "zxywh", value = "注销业务号")
private String zxywh;
/**
* 注销类型
*/
@ApiModelProperty(name = "zxlx", value = "注销类型")
private String zxlx;
/**
* 收件时间
*/
@NotEmpty(message = "收件时间【sjsj】不能为空")
@ApiModelProperty(name = "sjsj", value = "收件时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date sjsj;
/**
* 收件人员
*/
@NotEmpty(message = "收件人员【sjry】不能为空")
@ApiModelProperty(name = "sjry", value = "收件人员")
private String sjry;
/**
* 原业务标识码
*/
@NotEmpty(message = "原业务标识码【bsmYw】不能为空")
@ApiModelProperty(name = "bsmYw", value = "原业务标识码")
private String bsmYw;
}
package com.pashanhoo.business.entity.vo;
import java.io.Serializable;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案业务信息明细实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案业务信息明细实体")
public class DgBusinessDetailVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 业务标识码
*/
@ApiModelProperty(name = "bsmBusiness", value = "业务标识码")
private String bsmBusiness;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 业务号
*/
@ApiModelProperty(name = "ywh", value = "业务号")
private String ywh;
/**
* 登记类型
*/
@ApiModelProperty(name = "djlx", value = "登记类型")
private String djlx;
/**
* 权利类型
*/
@ApiModelProperty(name = "qllx", value = "权利类型")
private String qllx;
/**
* 登记机构编码
*/
@ApiModelProperty(name = "djjgbm", value = "登记机构编码")
private String djjgbm;
/**
* 登记机构名称
*/
@ApiModelProperty(name = "djjgmc", value = "登记机构名称")
private String djjgmc;
/**
* 登记业务名称
*/
@ApiModelProperty(name = "djywmc", value = "登记业务名称")
private String djywmc;
/**
* 收件时间
*/
@ApiModelProperty(name = "sjsj", value = "收件时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date sjsj;
/**
* 注销业务号
*/
@ApiModelProperty(name = "zxywh", value = "注销业务号")
private String zxywh;
/**
* 注销类型
*/
@ApiModelProperty(name = "zxlx", value = "注销类型")
private String zxlx;
/**
* 收件人员
*/
@ApiModelProperty(name = "sjry", value = "收件人员")
private String sjry;
/**
* 原业务标识码
*/
@ApiModelProperty(name = "bsmYw", value = "原业务标识码")
private String bsmYw;
}
package com.pashanhoo.business.entity.vo;
import java.io.Serializable;
import java.util.Date;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案业务信息列表VO
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案业务信息列表VO")
//TODO 该类属性暂时是完整的全部属性，需进行个性化的增删
public class DgBusinessListVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 业务标识码
*/
@ApiModelProperty(name = "bsmBusiness", value = "业务标识码")
private String bsmBusiness;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 业务号
*/
@ApiModelProperty(name = "ywh", value = "业务号")
private String ywh;
/**
* 登记类型
*/
@ApiModelProperty(name = "djlx", value = "登记类型")
private String djlx;
/**
* 权利类型
*/
@ApiModelProperty(name = "qllx", value = "权利类型")
private String qllx;
/**
* 登记机构编码
*/
@ApiModelProperty(name = "djjgbm", value = "登记机构编码")
private String djjgbm;
/**
* 登记机构名称
*/
@ApiModelProperty(name = "djjgmc", value = "登记机构名称")
private String djjgmc;
/**
* 登记业务名称
*/
@ApiModelProperty(name = "djywmc", value = "登记业务名称")
private String djywmc;
/**
* 收件时间
*/
@ApiModelProperty(name = "sjsj", value = "收件时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date sjsj;
/**
* 注销业务号
*/
@ApiModelProperty(name = "zxywh", value = "注销业务号")
private String zxywh;
/**
* 注销类型
*/
@ApiModelProperty(name = "zxlx", value = "注销类型")
private String zxlx;
/**
* 收件人员
*/
@ApiModelProperty(name = "sjry", value = "收件人员")
private String sjry;
/**
* 原业务标识码
*/
@ApiModelProperty(name = "bsmYw", value = "原业务标识码")
private String bsmYw;
}
package com.pashanhoo.business.entity.vo;
import java.io.Serializable;
import java.util.Date;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import com.pashanhoo.common.PageInfo;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案业务信息列表查询请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案业务信息列表查询请求实体")
public class DgBusinessSearchRequest extends PageInfo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 业务标识码
*/
@ApiModelProperty(name = "bsmBusiness", value = "业务标识码")
private String bsmBusiness;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 业务号
*/
@ApiModelProperty(name = "ywh", value = "业务号")
private String ywh;
/**
* 登记类型
*/
@ApiModelProperty(name = "djlx", value = "登记类型")
private String djlx;
/**
* 权利类型
*/
@ApiModelProperty(name = "qllx", value = "权利类型")
private String qllx;
/**
* 登记机构编码
*/
@ApiModelProperty(name = "djjgbm", value = "登记机构编码")
private String djjgbm;
/**
* 登记机构名称
*/
@ApiModelProperty(name = "djjgmc", value = "登记机构名称")
private String djjgmc;
/**
* 注销业务号
*/
@ApiModelProperty(name = "zxywh", value = "注销业务号")
private String zxywh;
/**
* 注销类型
*/
@ApiModelProperty(name = "zxlx", value = "注销类型")
private String zxlx;
/**
* 收件人员
*/
@ApiModelProperty(name = "sjry", value = "收件人员")
private String sjry;
/**
* 登记业务名称
*/
@ApiModelProperty(name = "djywmc", value = "登记业务名称")
private String djywmc;
/**
* 收件时间
*/
@ApiModelProperty(name = "sjsj", value = "收件时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date sjsj;
/**
* 原业务标识码
*/
@ApiModelProperty(name = "bsmYw", value = "原业务标识码")
private String bsmYw;
}
package com.pashanhoo.business.entity.vo;
import java.io.Serializable;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案业务信息修改请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案业务信息修改请求实体")
public class UpdateDgBusinessRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 业务标识码
*/
@ApiModelProperty(name = "bsmBusiness", value = "业务标识码")
private String bsmBusiness;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 业务号
*/
@ApiModelProperty(name = "ywh", value = "业务号")
private String ywh;
/**
* 登记类型
*/
@ApiModelProperty(name = "djlx", value = "登记类型")
private String djlx;
/**
* 权利类型
*/
@ApiModelProperty(name = "qllx", value = "权利类型")
private String qllx;
/**
* 登记机构编码
*/
@ApiModelProperty(name = "djjgbm", value = "登记机构编码")
private String djjgbm;
/**
* 登记机构名称
*/
@ApiModelProperty(name = "djjgmc", value = "登记机构名称")
private String djjgmc;
/**
* 登记业务名称
*/
@ApiModelProperty(name = "djywmc", value = "登记业务名称")
private String djywmc;
/**
* 收件时间
*/
@ApiModelProperty(name = "sjsj", value = "收件时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date sjsj;
/**
* 注销业务号
*/
@ApiModelProperty(name = "zxywh", value = "注销业务号")
private String zxywh;
/**
* 注销类型
*/
@ApiModelProperty(name = "zxlx", value = "注销类型")
private String zxlx;
/**
* 收件人员
*/
@ApiModelProperty(name = "sjry", value = "收件人员")
private String sjry;
/**
* 原业务标识码
*/
@ApiModelProperty(name = "bsmYw", value = "原业务标识码")
private String bsmYw;
}
package com.pashanhoo.business.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.pashanhoo.business.entity.DgBusinessDO;
/**
* <p>
* 档案业务信息 Mapper 接口
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgBusinessMapper extends BaseMapper<DgBusinessDO> {
}
package com.pashanhoo.business.service;
import com.pashanhoo.business.entity.DgBusinessDO;
import com.pashanhoo.business.entity.vo.AddDgBusinessRequest;
import com.pashanhoo.business.entity.vo.DgBusinessDetailVO;
import com.pashanhoo.business.entity.vo.UpdateDgBusinessRequest;
import com.pashanhoo.business.entity.vo.DgBusinessSearchRequest;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 档案业务信息 服务类
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgBusinessService extends IService<DgBusinessDO> {
/**
* 新增记录
* @param request
* @return
*/
boolean insertDgBusiness(AddDgBusinessRequest request);
/**
* 根据主键查询记录详情
* @param id
* @return
*/
DgBusinessDetailVO getDgBusinessDetailById(String id);
/**
* 修改单条记录
* @param request
* @return
*/
boolean updateDgBusiness(UpdateDgBusinessRequest request);
/**
* 根据条件进行列表查询
* @param request
* @return
*/
Page searchDgBusinessList(DgBusinessSearchRequest request);
/**
*
* @param request
* @return
*/
DgBusinessDO searchDgBusiness(DgBusinessSearchRequest request);
}
package com.pashanhoo.business.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pashanhoo.business.entity.DgBusinessConverter;
import com.pashanhoo.business.entity.DgBusinessDO;
import com.pashanhoo.business.entity.vo.AddDgBusinessRequest;
import com.pashanhoo.business.entity.vo.DgBusinessDetailVO;
import com.pashanhoo.business.entity.vo.UpdateDgBusinessRequest;
import com.pashanhoo.business.entity.vo.DgBusinessSearchRequest;
import com.pashanhoo.business.mapper.DgBusinessMapper;
import com.pashanhoo.business.service.DgBusinessService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
/**
* <p>
* 档案业务信息 服务实现类
* </p>
*
* @author
* @since 2021-11-05
*/
@Service
public class DgBusinessServiceImpl extends ServiceImpl<DgBusinessMapper, DgBusinessDO> implements DgBusinessService {
@Autowired
private DgBusinessConverter dgbusinessConverter;
@Autowired
private DgBusinessMapper dgbusinessMapper;
/**
* 新增记录
* @param request
* @return
*/
@Override
public boolean insertDgBusiness(AddDgBusinessRequest request) {
DgBusinessDO dgbusinessDO = dgbusinessConverter.addRequest2DO(request);
return this.save(dgbusinessDO);
}
/**
* 根据主键查询记录详情
* @param id
* @return
*/
@Override
public DgBusinessDetailVO getDgBusinessDetailById(String id) {
DgBusinessDO dgbusinessDO = this.getById(id);
return dgbusinessConverter.do2DetailVO(dgbusinessDO);
}
/**
* 修改单条记录
* @param request
* @return
*/
@Override
public boolean updateDgBusiness(UpdateDgBusinessRequest request) {
DgBusinessDO dgbusinessDO = dgbusinessConverter.updateRequest2DO(request);
return this.updateById(dgbusinessDO);
}
/**
* 根据条件进行列表查询
* @param request
* @return
*/
@Override
public Page searchDgBusinessList(DgBusinessSearchRequest request) {
Page<DgBusinessDO> pageParam = new Page<DgBusinessDO>(request.getCurrentPage(), request.getPageSize());
QueryWrapper<DgBusinessDO> wrapper = new QueryWrapper<>();
//设置默认排序
wrapper = "desc".equals(request.getSortOrder()) ? wrapper.orderByDesc(request.getSortField()) : wrapper.orderByAsc(request.getSortField());
Page page = this.page(pageParam, wrapper);
//将查询出来的DO List转为 ListVO List并重新设置到page对象中，并返回page对象
return page.setRecords(dgbusinessConverter.doList2ListVOList(page.getRecords()));
}
@Override
public DgBusinessDO searchDgBusiness(DgBusinessSearchRequest request) {
QueryWrapper<DgBusinessDO> wrapper = new QueryWrapper<>();
wrapper.eq(request.getYwh()!=null && !"".equals(request.getYwh()),"YWH",request.getYwh());
wrapper.eq(request.getZxywh()!=null && !"".equals(request.getZxywh()),"ZXYWH",request.getZxywh());
DgBusinessDO businessDO= dgbusinessMapper.selectOne(wrapper);
return businessDO;
}
}
package com.pashanhoo.catalog.controller;
import com.pashanhoo.catalog.entity.vo.AddDgArchivesCatalogRequest;
import com.pashanhoo.catalog.entity.vo.DgArchivesCatalogListVO;
import com.pashanhoo.catalog.entity.vo.UpdateDgArchivesCatalogRequest;
import com.pashanhoo.catalog.service.DgArchivesCatalogService;
import com.pashanhoo.common.Result;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
/**
* <p>
* 档案目录信息 前端控制器
* </p>
*
* @author
* @since 2021-11-05
*/
@RestController
@RequestMapping("/system/dgArchivesCatalog/")
@Api(tags = "档案目录信息接口")
public class DgArchivesCatalogController {
@Autowired
private DgArchivesCatalogService dgarchivescatalogService;
@PostMapping("insertDgArchivesCatalog")
@ApiOperation("新增档案目录信息")
public Result insertDgArchivesCatalog(@RequestBody AddDgArchivesCatalogRequest request){
if(dgarchivescatalogService.insertDgArchivesCatalog(request)){
return Result.ok();
}
return Result.error("新增失败");
}
@DeleteMapping("deleteDgArchivesCatalogByIds")
@ApiOperation(value = "批量删除档案目录信息")
public Result deleteDgArchivesCatalogByIds(@ApiParam("档案目录信息ID列表") @RequestParam(value = "idList") List<String> idList) {
if(dgarchivescatalogService.removeByIds(idList)) {
return Result.ok("删除成功");
}
return Result.error("删除失败");
}
@PutMapping("updateDgArchivesCatalog")
@ApiOperation("修改档案目录信息")
public Result updateDgArchivesCatalog(@RequestBody UpdateDgArchivesCatalogRequest request){
if(dgarchivescatalogService.updateDgArchivesCatalog(request)) {
return Result.ok("修改成功");
}
return Result.error("修改失败");
}
@GetMapping("getDgArchivesCatalogDetailById")
@ApiOperation(value = "读取明细")
public Result getDgArchivesCatalogDetailById(@ApiParam("档案目录信息ID") @RequestParam String id){
return Result.ok(dgarchivescatalogService.getDgArchivesCatalogDetailById(id));
}
@PostMapping("search")
@ApiOperation(value = "获取档案目录和不动产信息")
public Result<List<DgArchivesCatalogListVO>> searchDgArchivesCatalogList(@ApiParam("档案标识码集合") @RequestBody List<String> bsmArchives) {
return Result.ok(dgarchivescatalogService.searchDgArchivesCatalogList(bsmArchives));
}
}
package com.pashanhoo.catalog.entity;
import java.util.List;
import com.pashanhoo.catalog.entity.vo.AddDgArchivesCatalogRequest;
import com.pashanhoo.catalog.entity.vo.DgArchivesCatalogDetailVO;
import com.pashanhoo.catalog.entity.vo.DgArchivesCatalogListVO;
import com.pashanhoo.catalog.entity.vo.UpdateDgArchivesCatalogRequest;
import org.mapstruct.Mapper;
/**
* @author
* @since 2021-11-05
*/
@Mapper(componentModel = "spring")
public interface DgArchivesCatalogConverter{
DgArchivesCatalogDO addRequest2DO(AddDgArchivesCatalogRequest request);
DgArchivesCatalogDetailVO do2DetailVO(DgArchivesCatalogDO dgarchivescatalogDO);
DgArchivesCatalogDO updateRequest2DO(UpdateDgArchivesCatalogRequest request);
DgArchivesCatalogListVO do2ListVO(DgArchivesCatalogDO dgarchivescatalogDO);
List<DgArchivesCatalogListVO> doList2ListVOList(List<DgArchivesCatalogDO> dgarchivescatalogDOList);
List<DgArchivesCatalogDO> addcataListDO(List<AddDgArchivesCatalogRequest> request);
List<DgArchivesCatalogDO> updateList2DO(List<UpdateDgArchivesCatalogRequest> request);
}
package com.pashanhoo.catalog.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案目录信息
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("DG_ARCHIVES_CATALOG")
public class DgArchivesCatalogDO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 目录标识码
*/
@TableId(value = "BSM_CATALOG", type = IdType.UUID)
private String bsmCatalog;
/**
* 档案标识码
*/
@TableField("BSM_ARCHIVES")
private String bsmArchives;
/**
* 序号
*/
@TableField("XH")
private Integer xh;
/**
* 材料编码
*/
@TableField("WJBM")
private String wjbm;
/**
* 材料名称
*/
@TableField("WJMC")
private String wjmc;
/**
* 材料类型编码
*/
@TableField("CLLXBM")
private String cllxbm;
/**
* 材料类型名称
*/
@TableField("CLLXMC")
private String cllxmc;
/**
* 页数
*/
@TableField("YS")
private String ys;
/**
* 页号
*/
@TableField("YH")
private String yh;
/**
* 份数
*/
@TableField("FS")
private String fs;
/**
* 文号
*/
@TableField("WH")
private String wh;
/**
* 备注
*/
@TableField("BZ")
private String bz;
/**
* 附件来源（1：业务附件，2：补录附件）
*/
@TableField("FJLY")
private String fjly;
}
package com.pashanhoo.catalog.entity.vo;
import java.io.Serializable;
import java.util.List;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案目录信息新增请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案目录信息新增请求实体")
public class AddDgArchivesCatalogRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 目录标识码
*/
@ApiModelProperty(name = "bsm_catalog", value = "目录标识码")
private String bsm_catalog;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 序号
*/
@ApiModelProperty(name = "xh", value = "序号")
private Integer xh;
/**
* 材料编码
*/
@ApiModelProperty(name = "wjbm", value = "材料编码")
private String wjbm;
/**
* 材料名称
*/
@ApiModelProperty(name = "wjmc", value = "材料名称")
private String wjmc;
/**
* 材料类型编码
*/
@ApiModelProperty(name = "cllxbm", value = "材料类型编码")
private String cllxbm;
/**
* 材料类型名称
*/
@ApiModelProperty(name = "cllxmc", value = "材料类型名称")
private String cllxmc;
/**
* 页数
*/
@ApiModelProperty(name = "ys", value = "页数")
private String ys;
/**
* 页号
*/
@ApiModelProperty(name = "yh", value = "页号")
private String yh;
/**
* 份数
*/
@ApiModelProperty(name = "fs", value = "份数")
private String fs;
/**
* 文号
*/
@ApiModelProperty(name = "wh", value = "文号")
private String wh;
/**
* 备注
*/
@ApiModelProperty(name = "bz", value = "备注")
private String bz;
/**
* 附件来源（1：业务附件，2：补录附件）
*/
@ApiModelProperty(name = "fjly", value = "附件来源（1：业务附件，2：补录附件）")
private String fjly;
/**
* 文件访问地址列表
*/
@ApiModelProperty(name = "fileList", value = "文件访问地址列表")
private List<String> fileList;
}
package com.pashanhoo.catalog.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案目录信息明细实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案目录信息明细实体")
public class DgArchivesCatalogDetailVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 目录标识码
*/
@ApiModelProperty(name = "bsmCatalog", value = "目录标识码")
private String bsmCatalog;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 序号
*/
@ApiModelProperty(name = "xh", value = "序号")
private Integer xh;
/**
* 材料编码
*/
@ApiModelProperty(name = "wjbm", value = "材料编码")
private String wjbm;
/**
* 材料名称
*/
@ApiModelProperty(name = "wjmc", value = "材料名称")
private String wjmc;
/**
* 材料类型编码
*/
@ApiModelProperty(name = "cllxbm", value = "材料类型编码")
private String cllxbm;
/**
* 材料类型名称
*/
@ApiModelProperty(name = "cllxmc", value = "材料类型名称")
private String cllxmc;
/**
* 页数
*/
@ApiModelProperty(name = "ys", value = "页数")
private String ys;
/**
* 页号
*/
@ApiModelProperty(name = "yh", value = "页号")
private String yh;
/**
* 份数
*/
@ApiModelProperty(name = "fs", value = "份数")
private String fs;
/**
* 文号
*/
@ApiModelProperty(name = "wh", value = "文号")
private String wh;
/**
* 备注
*/
@ApiModelProperty(name = "bz", value = "备注")
private String bz;
/**
* 附件来源（1：业务附件，2：补录附件）
*/
@ApiModelProperty(name = "fjly", value = "附件来源（1：业务附件，2：补录附件）")
private String fjly;
}
package com.pashanhoo.catalog.entity.vo;
import java.io.Serializable;
import com.pashanhoo.bdcdy.entity.DgBdcdyDO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案目录信息列表VO
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案目录信息列表VO")
public class DgArchivesCatalogListVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 目录标识码
*/
@ApiModelProperty(name = "bsmCatalog", value = "目录标识码")
private String bsmCatalog;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 序号
*/
@ApiModelProperty(name = "xh", value = "序号")
private Integer xh;
/**
* 材料编码
*/
@ApiModelProperty(name = "wjbm", value = "材料编码")
private String wjbm;
/**
* 材料名称
*/
@ApiModelProperty(name = "wjmc", value = "材料名称")
private String wjmc;
/**
* 材料类型编码
*/
@ApiModelProperty(name = "cllxbm", value = "材料类型编码")
private String cllxbm;
/**
* 材料类型名称
*/
@ApiModelProperty(name = "cllxmc", value = "材料类型名称")
private String cllxmc;
/**
* 页数
*/
@ApiModelProperty(name = "ys", value = "页数")
private String ys;
/**
* 页号
*/
@ApiModelProperty(name = "yh", value = "页号")
private String yh;
/**
* 份数
*/
@ApiModelProperty(name = "fs", value = "份数")
private String fs;
/**
* 文号
*/
@ApiModelProperty(name = "wh", value = "文号")
private String wh;
/**
* 备注
*/
@ApiModelProperty(name = "bz", value = "备注")
private String bz;
/**
* 附件来源（1：业务附件，2：补录附件）
*/
@ApiModelProperty(name = "fjly", value = "附件来源（1：业务附件，2：补录附件）")
private String fjly;
/**
* 不动产单元
*/
@ApiModelProperty(name = "bdcdyDO",value = "不动产单元")
private DgBdcdyDO bdcdyDO;
}
package com.pashanhoo.catalog.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import com.pashanhoo.common.PageInfo;
/**
* <p>
* 档案目录信息列表查询请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案目录信息列表查询请求实体")
//TODO 初始查询条件是全部，需要根据情况自行删减
public class DgArchivesCatalogSearchRequest extends PageInfo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 目录标识码
*/
@ApiModelProperty(name = "bsmCatalog", value = "目录标识码")
private String bsmCatalog;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 序号
*/
@ApiModelProperty(name = "xh", value = "序号")
private Integer xh;
/**
* 材料编码
*/
@ApiModelProperty(name = "wjbm", value = "材料编码")
private String wjbm;
/**
* 材料名称
*/
@ApiModelProperty(name = "wjmc", value = "材料名称")
private String wjmc;
/**
* 材料类型编码
*/
@ApiModelProperty(name = "cllxbm", value = "材料类型编码")
private String cllxbm;
/**
* 材料类型名称
*/
@ApiModelProperty(name = "cllxmc", value = "材料类型名称")
private String cllxmc;
/**
* 页数
*/
@ApiModelProperty(name = "ys", value = "页数")
private String ys;
/**
* 页号
*/
@ApiModelProperty(name = "yh", value = "页号")
private String yh;
/**
* 份数
*/
@ApiModelProperty(name = "fs", value = "份数")
private String fs;
/**
* 文号
*/
@ApiModelProperty(name = "wh", value = "文号")
private String wh;
/**
* 备注
*/
@ApiModelProperty(name = "bz", value = "备注")
private String bz;
/**
* 附件来源（1：业务附件，2：补录附件）
*/
@ApiModelProperty(name = "fjly", value = "附件来源（1：业务附件，2：补录附件）")
private String fjly;
}
package com.pashanhoo.catalog.entity.vo;
import com.pashanhoo.file.entity.DgFileDO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.List;
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value = "档案目录信息列表对应附件列表VO")
public class DgArchivesCatalogWithFileVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 目录标识码
*/
@ApiModelProperty(name = "bsmCatalog", value = "目录标识码")
private String bsmCatalog;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 序号
*/
@ApiModelProperty(name = "xh", value = "序号")
private Integer xh;
/**
* 材料编码
*/
@ApiModelProperty(name = "wjbm", value = "材料编码")
private String wjbm;
/**
* 材料名称
*/
@ApiModelProperty(name = "wjmc", value = "材料名称")
private String wjmc;
/**
* 材料类型编码
*/
@ApiModelProperty(name = "cllxbm", value = "材料类型编码")
private String cllxbm;
/**
* 材料类型名称
*/
@ApiModelProperty(name = "cllxmc", value = "材料类型名称")
private String cllxmc;
/**
* 页数
*/
@ApiModelProperty(name = "ys", value = "页数")
private String ys;
/**
* 页号
*/
@ApiModelProperty(name = "yh", value = "页号")
private String yh;
/**
* 份数
*/
@ApiModelProperty(name = "fs", value = "份数")
private String fs;
/**
* 文号
*/
@ApiModelProperty(name = "wh", value = "文号")
private String wh;
/**
* 备注
*/
@ApiModelProperty(name = "bz", value = "备注")
private String bz;
/**
* 附件来源（1：业务附件，2：补录附件）
*/
@ApiModelProperty(name = "fjly", value = "附件来源（1：业务附件，2：补录附件）")
private String fjly;
/**
* 附件对象集合
*/
@ApiModelProperty(name = "dgFileDOS", value = "附件对象集合")
private List<DgFileDO> dgFileDOS;
}
package com.pashanhoo.catalog.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案目录信息修改请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案目录信息修改请求实体")
public class UpdateDgArchivesCatalogRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 目录标识码
*/
@ApiModelProperty(name = "bsmCatalog", value = "目录标识码")
private String bsmCatalog;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 序号
*/
@ApiModelProperty(name = "xh", value = "序号")
private Integer xh;
/**
* 材料编码
*/
@ApiModelProperty(name = "wjbm", value = "材料编码")
private String wjbm;
/**
* 材料名称
*/
@ApiModelProperty(name = "wjmc", value = "材料名称")
private String wjmc;
/**
* 材料类型编码
*/
@ApiModelProperty(name = "cllxbm", value = "材料类型编码")
private String cllxbm;
/**
* 材料类型名称
*/
@ApiModelProperty(name = "cllxmc", value = "材料类型名称")
private String cllxmc;
/**
* 页数
*/
@ApiModelProperty(name = "ys", value = "页数")
private String ys;
/**
* 页号
*/
@ApiModelProperty(name = "yh", value = "页号")
private String yh;
/**
* 份数
*/
@ApiModelProperty(name = "fs", value = "份数")
private String fs;
/**
* 文号
*/
@ApiModelProperty(name = "wh", value = "文号")
private String wh;
/**
* 备注
*/
@ApiModelProperty(name = "bz", value = "备注")
private String bz;
/**
* 附件来源（1：业务附件，2：补录附件）
*/
@ApiModelProperty(name = "fjly", value = "附件来源（1：业务附件，2：补录附件）")
private String fjly;
}
package com.pashanhoo.catalog.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.pashanhoo.catalog.entity.DgArchivesCatalogDO;
import com.pashanhoo.catalog.entity.vo.DgArchivesCatalogListVO;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* <p>
* 档案目录信息 Mapper 接口
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgArchivesCatalogMapper extends BaseMapper<DgArchivesCatalogDO> {
/**
* 获取目录和不动产信息
*
* @param bsmArchives 档案标识码集合
* @return
*/
List<DgArchivesCatalogListVO> getCatalog(@Param("bsmArchives") List<String> bsmArchives);
}
package com.pashanhoo.catalog.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.pashanhoo.catalog.entity.*;
import com.pashanhoo.catalog.entity.vo.*;
import java.util.List;
/**
* <p>
* 档案目录信息 服务类
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgArchivesCatalogService extends IService<DgArchivesCatalogDO> {
/**
* 新增记录
* @param request
* @return
*/
boolean insertDgArchivesCatalog(AddDgArchivesCatalogRequest request);
/**
* 根据主键查询记录详情
* @param id
* @return
*/
DgArchivesCatalogDetailVO getDgArchivesCatalogDetailById(String id);
/**
* 修改单条记录
* @param request
* @return
*/
boolean updateDgArchivesCatalog(UpdateDgArchivesCatalogRequest request);
/**
* 根据条件进行列表查询
* @param bsmArchives 档案标识码
* @return
*/
List<DgArchivesCatalogListVO> searchDgArchivesCatalogList(List<String> bsmArchives);
}
package com.pashanhoo.catalog.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pashanhoo.catalog.entity.*;
import com.pashanhoo.catalog.entity.vo.*;
import com.pashanhoo.catalog.mapper.DgArchivesCatalogMapper;
import com.pashanhoo.catalog.service.DgArchivesCatalogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* <p>
* 档案目录信息 服务实现类
* </p>
*
* @author
* @since 2021-11-05
*/
@Service
public class DgArchivesCatalogServiceImpl extends ServiceImpl<DgArchivesCatalogMapper, DgArchivesCatalogDO> implements DgArchivesCatalogService {
@Autowired
private DgArchivesCatalogConverter dgarchivescatalogConverter;
@Autowired
private DgArchivesCatalogMapper dgarchivescatalogMapper;
/**
* 新增记录
* @param request
* @return
*/
@Override
public boolean insertDgArchivesCatalog(AddDgArchivesCatalogRequest request) {
DgArchivesCatalogDO dgarchivescatalogDO = dgarchivescatalogConverter.addRequest2DO(request);
return this.save(dgarchivescatalogDO);
}
/**
* 根据主键查询记录详情
* @param id
* @return
*/
@Override
public DgArchivesCatalogDetailVO getDgArchivesCatalogDetailById(String id) {
DgArchivesCatalogDO dgarchivescatalogDO = this.getById(id);
return dgarchivescatalogConverter.do2DetailVO(dgarchivescatalogDO);
}
/**
* 修改单条记录
* @param request
* @return
*/
@Override
public boolean updateDgArchivesCatalog(UpdateDgArchivesCatalogRequest request) {
DgArchivesCatalogDO dgarchivescatalogDO = dgarchivescatalogConverter.updateRequest2DO(request);
return this.updateById(dgarchivescatalogDO);
}
/**
* 根据条件进行列表查询
* @param bsmArchives 档案标识码集合
* @return
*/
@Override
public List<DgArchivesCatalogListVO> searchDgArchivesCatalogList(List<String> bsmArchives) {
return dgarchivescatalogMapper.getCatalog(bsmArchives);
}
}
package com.pashanhoo.common;
import com.alibaba.fastjson.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
@Component
public class EciHttpUtil {
private static Logger logger = LoggerFactory.getLogger(EciHttpUtil.class);
@Value("${app.AppToken}")
private String appToken;
@Value("${app.AppSecret}")
private String appSecret;
@Value("${app.hostUrl}")
private String hostUrl;
public Map doPostForNew(String url, String params) {
logger.info("http request url:" + url);
logger.info("http request url:" + params);
PrintWriter out = null;
BufferedReader in = null;
Map jsonObject = new HashMap();
try{
URL url1=new URL(url);
HttpURLConnection conn= (HttpURLConnection) url1.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("accept","*/*");
conn.setRequestProperty("connection","Keep-Alive");
conn.setDoInput(true);
conn.setDoOutput(true);
conn.setRequestProperty("Content-Type", "application/json;charset=utf-8");
//x-qys-signature生成方式：Md5(AppToken + AppSecret + timestamp)，获取32位小写值
long times=System.currentTimeMillis();
String unSignature = appToken + appSecret + times;
String signature = MD5Util.getMD5(unSignature);
conn.setRequestProperty("x-qys-accesstoken", appToken);
conn.setRequestProperty("x-qys-signature", signature);
conn.setRequestProperty("x-qys-timestamp", String.valueOf(times));
logger.info("x-qys-accesstoken==="+appToken);
logger.info("x-qys-signature==="+signature);
logger.info("x-qys-timestamp==="+System.currentTimeMillis());
out=new PrintWriter(new OutputStreamWriter(conn.getOutputStream(),"utf-8"));
out.print(params);
out.flush();
in = new BufferedReader(new InputStreamReader(conn.getInputStream(),"UTF-8"));
String result="";
String line;
while ((line = in.readLine()) != null) {
result += line;
}
jsonObject = JSONObject.parseObject(result, Map.class);
}catch (Exception ex){
logger.info("发送 POST 请求出现异常！" + ex);
ex.printStackTrace();
}finally {
try {
if (out != null) {
out.close();
}
if (in != null) {
in.close();
}
} catch (IOException ex) {
ex.printStackTrace();
}
}
return jsonObject;
}
public Map doGetForNew(String url) {
logger.info("http request url:" + url);
BufferedReader in = null;
String result = "";
Map jsonObject = new HashMap();
try{
URL url1=new URL(url);
HttpURLConnection conn= (HttpURLConnection) url1.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("accept","*/*");
conn.setRequestProperty("connection","Keep-Alive");
conn.setRequestProperty("Charset", "utf-8");
conn.setDoInput(true);
conn.setDoOutput(false);
//x-qys-signature生成方式：Md5(AppToken + AppSecret + timestamp)，获取32位小写值
long times=System.currentTimeMillis();
String unSignature = appToken +appSecret + times;
String signature = MD5Util.getMD5(unSignature);
conn.setRequestProperty("x-qys-accesstoken", appToken);
conn.setRequestProperty("x-qys-signature", signature);
conn.setRequestProperty("x-qys-timestamp", String.valueOf(times));
logger.info("x-qys-accesstoken==="+appToken);
logger.info("x-qys-signature==="+signature);
logger.info("x-qys-timestamp==="+System.currentTimeMillis());
conn.connect();
in = new BufferedReader(new InputStreamReader(conn.getInputStream(),"UTF-8"));
String line;
while ((line = in.readLine()) != null) {
result += line;
}
jsonObject = JSONObject.parseObject(result, Map.class);
}catch (Exception ex){
logger.info("发送 POST 请求出现异常！" + ex);
ex.printStackTrace();
}finally {
try {
if (in != null) {
in.close();
}
} catch (IOException ex) {
ex.printStackTrace();
}
}
return jsonObject;
}
/**
* 文件下载
*
* @param documentId 合同文档ID
* @return
*/
public String download(String documentId,String bh) {
String url = hostUrl + "/document/download" + "?documentId=" + documentId;
InputStream in = null;
String absolutePath = "";
OutputStream out = null;
try{
URL url1=new URL(url);
HttpURLConnection conn= (HttpURLConnection) url1.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("accept","*/*");
conn.setRequestProperty("connection","Keep-Alive");
conn.setRequestProperty("Charset", "utf-8");
conn.setDoInput(true);
conn.setDoOutput(true);
long times=System.currentTimeMillis();
//x-qys-signature生成方式：Md5(AppToken + AppSecret + timestamp)，获取32位小写值
String unSignature = appToken + appSecret + times;
String signature = MD5Util.getMD5(unSignature);
conn.setRequestProperty("x-qys-accesstoken", appToken);
conn.setRequestProperty("x-qys-signature", signature);
conn.setRequestProperty("x-qys-timestamp", String.valueOf(times));
logger.info("x-qys-accesstoken==="+appToken);
logger.info("x-qys-signature==="+signature);
logger.info("x-qys-timestamp==="+System.currentTimeMillis());
conn.connect();
in =conn.getInputStream();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy");
String dateDir = simpleDateFormat.format(new Date());
File savePath = new File("D:\\ECI\\" + dateDir+bh);
if (!savePath.exists()) {
savePath.mkdirs();
}
File filePath = new File(savePath + "\\" + documentId+".ofd");
if (!filePath.exists()){
filePath.createNewFile();
}
out = new FileOutputStream(filePath);
byte[] buffer = new byte[4096];
int readLength = 0;
while ((readLength = in.read(buffer)) != -1) {
out.write(buffer, 0, readLength);
}
absolutePath = filePath.getAbsolutePath();
out.flush();
}catch (Exception ex){
logger.info("发送 POST 请求出现异常！" + ex);
ex.printStackTrace();
}finally {
try {
if (in != null) {
in.close();
}
if(out != null) {
out.close();
}
} catch (IOException ex) {
ex.printStackTrace();
}
}
return absolutePath;
}
}
package com.pashanhoo.common;
import java.security.MessageDigest;
public class MD5Util {
public static String getMD5(String unEncryption) {
char[] hexDigits = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
try {
byte[] btInput = unEncryption.getBytes();
// 获得MD5摘要算法的 MessageDigest 对象
MessageDigest mdInst = MessageDigest.getInstance("MD5");
// 使用指定的字节更新摘要
mdInst.update(btInput);
// 获得密文
byte[] md = mdInst.digest();
// 把密文转换成十六进制的字符串形式
char[] str = new char[md.length * 2];
int k = 0;
for (byte byte0 : md) {
str[k++] = hexDigits[byte0 >>> 4 & 0xf];
str[k++] = hexDigits[byte0 & 0xf];
}
return new String(str).toLowerCase();
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}
package com.pashanhoo.common;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import org.apache.commons.codec.binary.Base64;
import java.io.*;
public class PdfUtil {
/**
* 获取文件base64
*
*/
public static String fileToBase64(InputStream in) {
String base64String="";
try {
byte[] bytes = toByteArray(in);
in.read(bytes);
base64String = Base64.encodeBase64String(bytes);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != in) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return base64String;
}
}
public static byte[] toByteArray(InputStream input) throws IOException {
ByteArrayOutputStream output = new ByteArrayOutputStream();
byte[] buffer = new byte[1024*4];
int n = 0;
while (-1 != (n = input.read(buffer))) {
output.write(buffer, 0, n);
}
return output.toByteArray();
}
}
package com.pashanhoo.common;
import net.glxn.qrgen.core.image.ImageType;
import net.glxn.qrgen.javase.QRCode;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class QRCodeUtil {
public static void imgUrl(String url,String fileName) {
try{
ByteArrayOutputStream out= QRCode.from(url).to(ImageType.PNG).stream();
byte[] data = out.toByteArray();
OutputStream oute = new FileOutputStream(new File("E:\\ewm\\"+fileName));
oute.write(data);
oute.flush();
oute.close();
}catch(Exception ex){
ex.printStackTrace();
}
}
}
package com.pashanhoo.common;
import com.pashanhoo.qys.service.EciService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
@Configuration
@EnableScheduling
public class QysTask {
@Autowired
private EciService eciService;
@Scheduled(cron="0 0/5 * * * ?")
public void accessCreateContract() {
System.out.println("===========创建合同定时任务进来了=========");
eciService.accessCreateContract();
System.out.println("===========创建合同定时任务走了=========");
}
}
package com.pashanhoo.common;
import com.pashanhoo.zhj.service.ZhjDatasSynService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
@Configuration
@EnableScheduling
public class ZhjTask {
@Autowired
private ZhjDatasSynService zhjDatasSynService;
//@Scheduled(cron="0 0 21 * * ? ")
public void execute() {
System.out.println("===========每天晚上九点定时任务进来了=========");
zhjDatasSynService.send_bdcYwInfo();
System.out.println("===========每天晚上九点定时任务走了=========");
}
}
package com.pashanhoo.common.util;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.pashanhoo.common.util.mybatisplus.MyFreemarkerTemplateEngine;
/**
* 代码自动生成器
*/
public class CodeGenerator {
public static void main(String[] args) {
// 需要构建一个 代码自动生成器 对象
AutoGenerator mpg = new AutoGenerator();
// 配置策略
// 1、全局配置
GlobalConfig gc = new GlobalConfig();
String projectPath = System.getProperty("user.dir");
gc.setOutputDir(projectPath + "/src/main/java");
gc.setAuthor("");
gc.setOpen(false);
// 是否覆盖
gc.setFileOverride(false);
// 去Service的I前缀
// gc.setEntityName("%sDO");
gc.setServiceName("%sService");
gc.setServiceImplName("%sServiceImpl");
gc.setControllerName("%sController");
gc.setDateType(DateType.ONLY_DATE);
gc.setIdType(IdType.UUID);
// gc.setSwagger2(true); 实体属性 Swagger2 注解
mpg.setGlobalConfig(gc);
//2、设置数据源
DataSourceConfig dsc = new DataSourceConfig();
dsc.setUrl("jdbc:oracle:thin:@192.168.2.218:1521:orcl");
dsc.setDriverName("oracle.jdbc.driver.OracleDriver");
dsc.setUsername("bdcdangan");
dsc.setPassword("bdcdangan");
dsc.setDbType(DbType.ORACLE);
mpg.setDataSource(dsc);
//3、包的配置
PackageConfig pc = new PackageConfig();
//TODO
pc.setModuleName("system");
pc.setParent("com");
pc.setEntity("entity");
pc.setMapper("mapper");
pc.setService("service");
pc.setController("controller");
mpg.setPackageInfo(pc);
// 配置模板
TemplateConfig templateConfig = new TemplateConfig();
// 配置自定义输出模板
//指定自定义模板路径，注意不要带上.ftl/.vm, 会根据使用的模板引擎自动识别
templateConfig.setEntity("templates/entity2.java");
templateConfig.setMapper("templates/mapper2.java");
templateConfig.setService("templates/service2.java");
templateConfig.setServiceImpl("templates/serviceImpl2.java");
templateConfig.setController("templates/controller2.java");
templateConfig.setXml("templates/mapper2.xml");
mpg.setTemplate(templateConfig);
//4、策略配置
StrategyConfig strategy = new StrategyConfig();
// 设置要映射的表名
strategy.setInclude("DG_RECEIVE_RELATION");
strategy.setNaming(NamingStrategy.underline_to_camel);
strategy.setColumnNaming(NamingStrategy.underline_to_camel);
// 自动lombok；
strategy.setEntityLombokModel(true);
mpg.setStrategy(strategy);
//设置Freemarker模板引擎
mpg.setTemplateEngine(new MyFreemarkerTemplateEngine());
mpg.execute(); //执行
}
}
package com.pashanhoo.common.util.SysCode;
import org.mapstruct.Mapper;
/**
* @author
* @since 2021-11-05
*/
@Mapper(componentModel = "spring")
public interface SysCodeConverter {
SysCodeDO addRequest2DO(SysCodeVO request);
}
package com.pashanhoo.common.util.SysCode;
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 lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("SYS_CODE")
public class SysCodeDO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键
*/
@TableId(value = "CID", type = IdType.UUID)
private String cid;
/**
* 类型
*/
@TableField("CTYPE")
private String ctype;
/**
* 任务编码
*/
@TableField("TASKNO")
private String taskno;
/**
* 任务名称
*/
@TableField("TASKNAME")
private String taskname;
/**
* 状态
*/
@TableField("STATE")
private String state;
/**
* 任务值
*/
@TableField("TASKVALUE")
private String taskvalue;
/**
* 任务子类
*/
@TableField("TASKCHILD")
private String taskchild;
}
package com.pashanhoo.common.util.SysCode;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface SysCodeMapper extends BaseMapper<SysCodeDO> {
}
package com.pashanhoo.common.util.SysCode;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
@Component
public class SysCodeUtil {
@Autowired
private SysCodeMapper sysCodeMapper;
/**
* 编号生成规则
*
* @param sysCodeVO
* @return
*/
public String getSequence(SysCodeVO sysCodeVO) {
//1、查询数据是否存在
SysCodeDO sysCodeDO = queryInfoByCondition(sysCodeVO);
String taskValue;
if (sysCodeDO != null) {
String lastString = sysCodeDO.getTaskvalue().substring(2);
int code = Integer.parseInt(lastString) + 1;
taskValue = "BL" + code;
sysCodeDO.setTaskvalue(taskValue);
sysCodeMapper.updateById(sysCodeDO);
} else {
//3、不存在则新增
SysCodeDO newSysCode = new SysCodeDO();
newSysCode.setCtype(sysCodeVO.getCtype());
newSysCode.setState("1");
newSysCode.setTaskno(sysCodeVO.getTaskno());
newSysCode.setTaskname(sysCodeVO.getTaskname());
// taskValue = getTaskValue(sysCodeVO.getTaskchild());
taskValue = sysCodeVO.getTaskno() + "00000";
newSysCode.setTaskvalue(taskValue);
newSysCode.setTaskchild(sysCodeVO.getTaskchild() + "");
sysCodeMapper.insert(newSysCode);
}
return taskValue;
}
private SysCodeDO queryInfoByCondition(SysCodeVO sysCodeVO) {
QueryWrapper<SysCodeDO> wrapper = new QueryWrapper<>();
wrapper.lambda().eq(SysCodeDO::getCtype, sysCodeVO.getCtype()).eq(SysCodeDO::getTaskno, sysCodeVO.getTaskno()).eq(SysCodeDO::getTaskchild, sysCodeVO.getTaskchild());
return sysCodeMapper.selectOne(wrapper);
}
private String getTaskValue(int length) {
List<String> list = new ArrayList<String>(length - 1);
String num = "";
for (int i = 0; i < list.size(); i++) {
num += "0";
}
num = num + 1;
return num;
}
}
package com.pashanhoo.common.util.SysCode;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="编号公共类VO实体")
public class SysCodeVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 类型
*/
@ApiModelProperty(name = "ctype", value = "类型")
private String ctype;
/**
* 任务编码
*/
@ApiModelProperty(name = "taskno", value = "任务编码")
private String taskno;
/**
* 任务名称
*/
@ApiModelProperty(name = "taskname", value = "任务名称")
private String taskname;
/**
* 状态
*/
@ApiModelProperty(name = "state", value = "状态")
private String state;
/**
* 任务值
*/
@ApiModelProperty(name = "taskvalue", value = "任务值")
private String taskvalue;
/**
* 任务子类
*/
@ApiModelProperty(name = "taskchild", value = "任务子类")
private Integer taskchild;
}
package com.pashanhoo.common.util;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;
import org.apache.commons.collections.CollectionUtils;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class TreeUtil {
/**
* 比较规则
*/
private static Comparator comparator;
/**
* 树节点Class类型
*/
private static Class<?> treeNodeClass;
/**
* 主键的get方法对应的Method对象
*/
private static Method getKeyMethod;
/**
* 获取父节点id的get方法对应的Method对象
*/
private static Method getParentIdMethod;
/**
* 设置子元素对应的方法的Method对象
*/
private static Method setChildrenMethod;
/**
* @param comparator
* @param treeNodeClass
* @param key 首字母大写的主键字段名称
*/
public static void setRule(Comparator comparator, Class<?> treeNodeClass, String key) {
TreeUtil.comparator = comparator;
TreeUtil.treeNodeClass = treeNodeClass;
try {
TreeUtil.getKeyMethod = treeNodeClass.getMethod("get" + key);
TreeUtil.getParentIdMethod = treeNodeClass.getMethod("getParentId");
TreeUtil.setChildrenMethod = treeNodeClass.getMethod("setChildren", List.class);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
/**
* 将符合条件的List转为Tree
*
* @param
* @param rootId
* @return
*/
public static <TreeNode> List<TreeNode> listToTree(List<TreeNode> treeNodes, String rootId) {
if (CollectionUtils.isEmpty(treeNodes)) {
return Lists.newArrayList();
}
//parent -> [data1, data2 ...]
Multimap<String, TreeNode> parentMap = ArrayListMultimap.create();
//记录parentMap
List<TreeNode> rootList = Lists.newArrayList();
for (TreeNode treeNode : treeNodes) {
String parentId = null;
try {
parentId = (String) getParentIdMethod.invoke(treeNode);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
parentMap.put(parentId, treeNode);
//从根节点的下一级构造树
//rootId为null，从最顶部构造整棵树
if (rootId == null) {
if (parentId == null) {
rootList.add(treeNode);
}
}
if (StringUtils.isNotBlank(parentId) && parentId.equals(rootId)) {
rootList.add(treeNode);
}
}
// 对树节点进行排序
Collections.sort(rootList, comparator);
// 递归生成树
transformTree(rootList, parentMap);
return rootList;
}
private static <TreeNode> void transformTree(List<TreeNode> treeNodeList, Multimap<String, TreeNode> parentMap) {
for (int i = 0; i < treeNodeList.size(); i++) {
// 遍历该层的每个元素
TreeNode treeNode = treeNodeList.get(i);
//获取当前节点下一层节点的List数据
List<TreeNode> tempList = null;
try {
tempList = (List<TreeNode>) parentMap.get((String) getKeyMethod.invoke(treeNode));
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
if (CollectionUtils.isNotEmpty(tempList)) {
//首先排序下一层节点
Collections.sort(tempList, comparator);
//将下一层节点数据设置为当前节点的Children数据
try {
setChildrenMethod.invoke(treeNode, tempList);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
// 进入到下一层处理
transformTree(tempList, parentMap);
}
}
}
}
package com.pashanhoo.common.util.fileupload;
import polaris.fileattachment.AttachmentService;
import polaris.fileattachment.models.FileUrl;
import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class FileAttachmentUtil {
private static final String FILE_URL_PATTERN = "^[^\\\\/:*?\"<>|\r\n]+?:[^\\\\/:*?\"<>|\r\n]+(/[^\\\\/:*?\"<>|\r\n]+)*$";
private static final Pattern DIRECTORY_NAME_PATTERN = Pattern.compile("([^/]*)[/]?$");
private static final Pattern SERVER_REGEX = Pattern.compile("^[^\\\\/:*?\"<>|\r\n]+?:");
private static final Pattern FILE_REGEX = Pattern.compile("[/:]([^\\\\/:*?\"<>|\r\n]+)$");
@Resource
private AttachmentService attachmentService;
public FileAttachmentUtil() {
}
public static FileUrl parseFileUrl(String fileUrl) throws RuntimeException {
int index1 = 0;
int index2 = 0;
if (fileUrl != null && fileUrl.matches(FILE_URL_PATTERN)) {
Matcher regexMatcher = SERVER_REGEX.matcher(fileUrl);
if (regexMatcher.find()) {
index1 = regexMatcher.end();
}
regexMatcher = FILE_REGEX.matcher(fileUrl);
if (regexMatcher.find()) {
index2 = regexMatcher.start(1);
}
if (index1 != 0 && index2 != 0 && index1 <= index2) {
return new FileUrl(fileUrl.substring(0, index1 - 1), fileUrl.substring(index1, index2), fileUrl.substring(index2));
} else {
throw new RuntimeException("附件url格式错误，fileUrl = " + fileUrl);
}
} else {
throw new RuntimeException("附件url格式错误，fileUrl = " + (fileUrl == null ? "null" : fileUrl));
}
}
public static String getServerNameFromFileUrl(String fileUrl) {
if (fileUrl != null && fileUrl.matches(FILE_URL_PATTERN)) {
Matcher regexMatcher = SERVER_REGEX.matcher(fileUrl);
if (regexMatcher.find()) {
int index = regexMatcher.end();
return fileUrl.substring(0, index - 1);
}
}
throw new RuntimeException("附件url格式错误，fileUrl = " + (fileUrl == null ? "null" : fileUrl));
}
public static String generateFileUrl(String serverName, String path, String fileId) throws RuntimeException {
if (serverName != null && !serverName.isEmpty()) {
if (path != null && !path.isEmpty()) {
if (fileId != null && !fileId.isEmpty()) {
StringBuilder result = new StringBuilder();
result.append(serverName);
result.append(":");
result.append(path);
if (!path.endsWith("/")) {
result.append("/");
}
result.append(fileId);
return result.toString();
} else {
throw new RuntimeException("创建附件服务器自定义格式的FileUrl地址时附件名称(ID)为null");
}
} else {
throw new RuntimeException("创建附件服务器自定义格式的FileUrl地址时附件路径为null");
}
} else {
throw new RuntimeException("创建附件服务器自定义格式的FileUrl地址时附件服务器名为null");
}
}
public static boolean isFileUrl(String fileUrl) {
return fileUrl.matches(FILE_URL_PATTERN);
}
public static String getParentPath(String path) {
Matcher m = DIRECTORY_NAME_PATTERN.matcher(path);
m.find();
return m.replaceAll("");
}
public static String getPathName(String path) {
Matcher m = DIRECTORY_NAME_PATTERN.matcher(path);
m.find();
return m.group(1);
}
public static String getSavePath(String bsm) {
String date = new SimpleDateFormat("yyyyMMdd").format(new Date());
String path = filterString(bsm);
return date + "/" + path;
}
public static String filterString(String str) {
StringBuffer s = new StringBuffer(str.length());
for (int i = 0; i < str.length(); i++) {
if (!hasFullChar(String.valueOf(str.charAt(i)))) {
s.append(str.charAt(i));
}
}
return s.toString();
}
public static boolean hasFullChar(String str) {
return str.getBytes().length != str.length();
}
public static String getFileNameNoEx(String filename) {
if ((filename != null) && (filename.length() > 0)) {
int dot = filename.lastIndexOf('.');
if ((dot > -1) && (dot < (filename.length()))) {
return filename.substring(0, dot);
}
}
return filename;
}
}
package com.pashanhoo.common.util.fileupload;
import com.pashanhoo.common.Result;
import io.minio.messages.DeleteError;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/**
* 文件上传
*/
@Api(tags = "文件控制器")
@RequestMapping("/file")
@RestController
public class FileController {
@Autowired
MinioUtil minioUtil;
@Autowired
MinioConfig minioConfig;
@RequestMapping(value = "/upload", method = RequestMethod.POST)
@ApiOperation("上传单个文件")
public Result upload(@RequestPart("file") MultipartFile file, HttpServletResponse response) {
try {
return Result.ok(minioUtil.upload(file));
} catch (Exception e) {
return Result.exception(e.getMessage());
}
}
@RequestMapping(value = "/batchUpload", method = RequestMethod.POST,headers = "content-type=multipart/form-data")
@ApiOperation("上传多个文件")
public Result upload(@RequestPart("file") MultipartFile[] files, HttpServletResponse response) {
try {
return Result.ok(minioUtil.batchUpload(files));
} catch (Exception e) {
return Result.exception(e.getMessage());
}
}
@DeleteMapping("/deleteFile")
@ApiOperation("删除文件")
public Result deleteFile(@ApiParam("存储url") @RequestParam("saveUrl") String saveUrl){
try {
minioUtil.removeObject(minioConfig.getBucket(), saveUrl);
return Result.ok();
} catch (Exception e) {
return Result.exception(e.getMessage());
}
}
@DeleteMapping("/batchDeleteFile")
@ApiOperation("批量删除文件")
public Result batchDeleteFile(@ApiParam("存储url集合") @RequestBody List<String> saveUrls){
try {
List<String> msg = new ArrayList<>();
Iterable<io.minio.Result<DeleteError>> results = minioUtil.batchRemove(minioConfig.getBucket(), saveUrls);
for (io.minio.Result<DeleteError> result : results) {
DeleteError deleteError = result.get();
msg.add("Error in deleting object " + deleteError.objectName() + ":" + deleteError.message());
}
return Result.ok(msg.toString());
} catch (Exception e) {
return Result.exception(e.getMessage());
}
}
}
package com.pashanhoo.common.util.fileupload;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* minio配置类
*/
@Data
@Component
@ConfigurationProperties(prefix = "minio.params")
public class MinioConfig {
/**
* 链接类型
*/
private String type;
/**
* 桶名称
*/
private String bucket;
/**
* 服务地址
*/
private String endpoint;
/**
* 端口
*/
private String port;
/**
* 用户
*/
private String accessKeyId;
/**
* 密码
*/
private String accessKeySecret;
}
package com.pashanhoo.common.util.fileupload;
import com.pashanhoo.file.entity.vo.FileAttribute;
import io.minio.*;
import io.minio.messages.DeleteError;
import io.minio.messages.DeleteObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.PostConstruct;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;
/**
* minio工具类
*/
@Component
public class MinioUtil {
private MinioClient minioClient;
@Autowired
MinioConfig minioConfig;
@PostConstruct
public void init() {
try {
minioClient = MinioClient.builder().endpoint(String.format("http://%s:%s", minioConfig.getEndpoint(), minioConfig.getPort())).credentials(minioConfig.getAccessKeyId(), minioConfig.getAccessKeySecret()).build();
boolean isExist = minioClient.bucketExists(BucketExistsArgs.builder().bucket(minioConfig.getBucket()).build());
if (!isExist) {
minioClient.makeBucket(MakeBucketArgs.builder().bucket(minioConfig.getBucket()).build());
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 文件上传
*
* @param file
* @return minio文件路径
* @throws IOException
*/
public FileAttribute upload(MultipartFile file) throws IOException {
Assert.notNull(file, "上传文件为空");
// 上传地址
String savePath = FileAttachmentUtil.getSavePath(UUID.randomUUID().toString());
// 预览地址
String preViewPath = FileAttachmentUtil.getSavePath(UUID.randomUUID().toString());
// 文件带后缀名
String originalFilename = file.getOriginalFilename();
// 后缀名
String expandName = StringUtils.getFilenameExtension(file.getOriginalFilename());
// 文件名
String fileName = originalFilename.substring(0, originalFilename.indexOf("."));
String contentType = CONTENT_TYPE_MAP.get(expandName.toLowerCase());
// 下载地址
String saveUrl = savePath + "/" + originalFilename;
// 浏览器直接预览地址，针对图片
String pUrl = minioConfig.getType() + minioConfig.getEndpoint() + "/file/" + saveUrl;
try {
minioClient.putObject(PutObjectArgs.builder().bucket(minioConfig.getBucket()).object(saveUrl).stream(file.getInputStream(), file.getSize(), -1).contentType(contentType).build());
} catch (Exception e) {
e.printStackTrace();
}
FileAttribute fileAttribute = new FileAttribute();
fileAttribute.setFileName(fileName);
fileAttribute.setFileSize(Long.toString(file.getSize()));
fileAttribute.setSaveUrl(saveUrl);
fileAttribute.setPreviewUrl(pUrl);
fileAttribute.setExpandName(expandName);
return fileAttribute;
}
/**
* 批量上传
*
* @param files
* @return
* @throws IOException
*/
public List<FileAttribute> batchUpload(MultipartFile[] files) throws IOException {
Assert.notNull(files, "上传文件为空");
List<FileAttribute> list = new ArrayList<>();
for (MultipartFile file : files) {
FileAttribute result = this.upload(file);
list.add(result);
}
return list;
}
/**
* 删除附件
*
* @param bucketName 存储桶名称
* @param objectName 附件存储路径
* @throws Exception
*/
public void removeObject(String bucketName, String objectName) throws Exception {
minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(objectName).build());
}
/**
* 批量删除附件
*
* @param bucketName 存储桶名称
* @param objectNames 附件存储路径集合
*/
public Iterable<Result<DeleteError>> batchRemove(String bucketName, List<String> objectNames) {
List<DeleteObject> objects = new ArrayList<>(objectNames.size());
for (String objectName : objectNames) {
objects.add(new DeleteObject(objectName));
}
Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucketName).objects(objects).build());
return results;
}
/**
* 通过输入流上传到minio
*
* @param inputStream 文件输入流
* @param fileName 文件名,去除后缀名
* @param expandName 带.后缀名
* @param fileSize 文件大小
* @return
* @throws IOException
*/
public FileAttribute transferToMinio(InputStream inputStream, String fileName, String expandName, String fileSize) throws IOException {
String savePath = FileAttachmentUtil.getSavePath(UUID.randomUUID().toString());
String contentType = CONTENT_TYPE_MAP.get(expandName.toLowerCase());
// 下载地址
String saveUrl = savePath + "/" + fileName + expandName;
// 浏览器直接预览地址，针对图片
String pUrl = minioConfig.getType() + minioConfig.getEndpoint() + "/file/" + saveUrl;
try {
minioClient.putObject(PutObjectArgs.builder().bucket(minioConfig.getBucket()).object(saveUrl).stream(inputStream, Long.parseLong(fileSize),-1).contentType(contentType).build());
// minioClient.putObject(minioConfig.getBucket(), saveUrl, inputStream, contentType);
} catch (Exception e) {
e.printStackTrace();
}
FileAttribute fileAttribute = new FileAttribute();
fileAttribute.setFileName(fileName);
fileAttribute.setFileSize(fileSize);
fileAttribute.setSaveUrl(saveUrl);
fileAttribute.setPreviewUrl(pUrl);
return fileAttribute;
}
/**
* 根据存储路径组装下载预览路径
*
* @param saveUrl
* @return
*/
public String getPreviewUrl(String saveUrl) {
return minioConfig.getType() + minioConfig.getEndpoint() + "/file/" + saveUrl;
}
public InputStream getObject(String objectName) throws Exception{
return minioClient.getObject(GetObjectArgs.builder().bucket(minioConfig.getBucket()).object(objectName).build());
}
private static final Map<String, String> CONTENT_TYPE_MAP = new HashMap<>() {
{
put("323", "text/h323");
put("3gp", "video/3gpp");
put("aab", "application/x-authoware-bin");
put("aam", "application/x-authoware-map");
put("aas", "application/x-authoware-seg");
put("acx", "application/internet-property-stream");
put("ai", "application/postscript");
put("aif", "audio/x-aiff");
put("aifc", "audio/x-aiff");
put("aiff", "audio/x-aiff");
put("als", "audio/X-Alpha5");
put("amc", "application/x-mpeg");
put("ani", "application/octet-stream");
put("apk", "application/vnd.android.package-archive");
put("asc", "text/plain");
put("asd", "application/astound");
put("asf", "video/x-ms-asf");
put("asn", "application/astound");
put("asp", "application/x-asap");
put("asr", "video/x-ms-asf");
put("asx", "video/x-ms-asf");
put("au", "audio/basic");
put("avb", "application/octet-stream");
put("avi", "video/x-msvideo");
put("awb", "audio/amr-wb");
put("axs", "application/olescript");
put("bas", "text/plain");
put("bcpio", "application/x-bcpio");
put("bin ", "application/octet-stream");
put("bld", "application/bld");
put("bld2", "application/bld2");
put("bmp", "image/bmp");
put("bpk", "application/octet-stream");
put("bz2", "application/x-bzip2");
put("c", "text/plain");
put("cal", "image/x-cals");
put("cat", "application/vnd.ms-pkiseccat");
put("ccn", "application/x-cnc");
put("cco", "application/x-cocoa");
put("cdf", "application/x-cdf");
put("cer", "application/x-x509-ca-cert");
put("cgi", "magnus-internal/cgi");
put("chat", "application/x-chat");
put("class", "application/octet-stream");
put("clp", "application/x-msclip");
put("cmx", "image/x-cmx");
put("co", "application/x-cult3d-object");
put("cod", "image/cis-cod");
put("conf", "text/plain");
put("cpio", "application/x-cpio");
put("cpp", "text/plain");
put("cpt", "application/mac-compactpro");
put("crd", "application/x-mscardfile");
put("crl", "application/pkix-crl");
put("crt", "application/x-x509-ca-cert");
put("csh", "application/x-csh");
put("csm", "chemical/x-csml");
put("csml", "chemical/x-csml");
put("css", "text/css");
put("cur", "application/octet-stream");
put("dcm", "x-lml/x-evm");
put("dcr", "application/x-director");
put("dcx", "image/x-dcx");
put("der", "application/x-x509-ca-cert");
put("dhtml", "text/html");
put("dir", "application/x-director");
put("dll", "application/x-msdownload");
put("dmg", "application/octet-stream");
put("dms", "application/octet-stream");
put("doc", "application/msword");
put("docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document");
put("dot", "application/msword");
put("dvi", "application/x-dvi");
put("dwf", "drawing/x-dwf");
put("dwg", "application/x-autocad");
put("dxf", "application/x-autocad");
put("dxr", "application/x-director");
put("ebk", "application/x-expandedbook");
put("emb", "chemical/x-embl-dl-nucleotide");
put("embl", "chemical/x-embl-dl-nucleotide");
put("eps", "application/postscript");
put("epub", "application/epub+zip");
put("eri", "image/x-eri");
put("es", "audio/echospeech");
put("esl", "audio/echospeech");
put("etc", "application/x-earthtime");
put("etx", "text/x-setext");
put("evm", "x-lml/x-evm");
put("evy", "application/envoy");
put("exe", "application/octet-stream");
put("fh4", "image/x-freehand");
put("fh5", "image/x-freehand");
put("fhc", "image/x-freehand");
put("fif", "application/fractals");
put("flr", "x-world/x-vrml");
put("flv", "flv-application/octet-stream");
put("fm", "application/x-maker");
put("fpx", "image/x-fpx");
put("fvi", "video/isivideo");
put("gau", "chemical/x-gaussian-input");
put("gca", "application/x-gca-compressed");
put("gdb", "x-lml/x-gdb");
put("gif", "image/gif");
put("gps", "application/x-gps");
put("gtar", "application/x-gtar");
put("gz", "application/x-gzip");
put("h", "text/plain");
put("hdf", "application/x-hdf");
put("hdm", "text/x-hdml");
put("hdml", "text/x-hdml");
put("hlp", "application/winhlp");
put("hqx", "application/mac-binhex40");
put("hta", "application/hta");
put("htc", "text/x-component");
put("htm", "text/html");
put("html", "text/html");
put("hts", "text/html");
put("htt", "text/webviewhtml");
put("ice", "x-conference/x-cooltalk");
put("ico", "image/x-icon");
put("ief", "image/ief");
put("ifm", "image/gif");
put("ifs", "image/ifs");
put("iii", "application/x-iphone");
put("imy", "audio/melody");
put("ins", "application/x-internet-signup");
put("ips", "application/x-ipscript");
put("ipx", "application/x-ipix");
put("isp", "application/x-internet-signup");
put("it", "audio/x-mod");
put("itz", "audio/x-mod");
put("ivr", "i-world/i-vrml");
put("j2k", "image/j2k");
put("jad", "text/vnd.sun.j2me.app-descriptor");
put("jam", "application/x-jam");
put("jar", "application/java-archive");
put("java", "text/plain");
put("jfif", "image/pipeg");
put("jnlp", "application/x-java-jnlp-file");
put("jpe", "image/jpeg");
put("jpeg", "image/jpeg");
put("jpg", "image/jpeg");
put("jpz", "image/jpeg");
put("js", "application/x-javascript");
put("jwc", "application/jwc");
put("kjx", "application/x-kjx");
put("lak", "x-lml/x-lak");
put("latex", "application/x-latex");
put("lcc", "application/fastman");
put("lcl", "application/x-digitalloca");
put("lcr", "application/x-digitalloca");
put("lgh", "application/lgh");
put("lha", "application/octet-stream");
put("lml", "x-lml/x-lml");
put("lmlpack", "x-lml/x-lmlpack");
put("log", "text/plain");
put("lsf", "video/x-la-asf");
put("lsx", "video/x-la-asf");
put("lzh", "application/octet-stream");
put("m13", "application/x-msmediaview");
put("m14", "application/x-msmediaview");
put("m15", "audio/x-mod");
put("m3u", "audio/x-mpegurl");
put("m3url", "audio/x-mpegurl");
put("m4a", "audio/mp4a-latm");
put("m4b", "audio/mp4a-latm");
put("m4p", "audio/mp4a-latm");
put("m4u", "video/vnd.mpegurl");
put("m4v", "video/x-m4v");
put("ma1", "audio/ma1");
put("ma2", "audio/ma2");
put("ma3", "audio/ma3");
put("ma5", "audio/ma5");
put("man", "application/x-troff-man");
put("map", "magnus-internal/imagemap");
put("mbd", "application/mbedlet");
put("mct", "application/x-mascot");
put("mdb", "application/x-msaccess");
put("mdz", "audio/x-mod");
put("me", "application/x-troff-me");
put("mel", "text/x-vmel");
put("mht", "message/rfc822");
put("mhtml", "message/rfc822");
put("mi", "application/x-mif");
put("mid", "audio/mid");
put("midi", "audio/midi");
put("mif", "application/x-mif");
put("mil", "image/x-cals");
put("mio", "audio/x-mio");
put("mmf", "application/x-skt-lbs");
put("mng", "video/x-mng");
put("mny", "application/x-msmoney");
put("moc", "application/x-mocha");
put("mocha", "application/x-mocha");
put("mod", "audio/x-mod");
put("mof", "application/x-yumekara");
put("mol", "chemical/x-mdl-molfile");
put("mop", "chemical/x-mopac-input");
put("mov", "video/quicktime");
put("movie", "video/x-sgi-movie");
put("mp2", "video/mpeg");
put("mp3", "audio/mpeg");
put("mp4", "video/mp4");
put("mpa", "video/mpeg");
put("mpc", "application/vnd.mpohun.certificate");
put("mpe", "video/mpeg");
put("mpeg", "video/mpeg");
put("mpg", "video/mpeg");
put("mpg4", "video/mp4");
put("mpga", "audio/mpeg");
put("mpn", "application/vnd.mophun.application");
put("mpp", "application/vnd.ms-project");
put("mps", "application/x-mapserver");
put("mpv2", "video/mpeg");
put("mrl", "text/x-mrml");
put("mrm", "application/x-mrm");
put("ms", "application/x-troff-ms");
put("msg", "application/vnd.ms-outlook");
put("mts", "application/metastream");
put("mtx", "application/metastream");
put("mtz", "application/metastream");
put("mvb", "application/x-msmediaview");
put("mzv", "application/metastream");
put("nar", "application/zip");
put("nbmp", "image/nbmp");
put("nc", "application/x-netcdf");
put("ndb", "x-lml/x-ndb");
put("ndwn", "application/ndwn");
put("nif", "application/x-nif");
put("nmz", "application/x-scream");
put("nokia-op-logo", "image/vnd.nok-oplogo-color");
put("npx", "application/x-netfpx");
put("nsnd", "audio/nsnd");
put("nva", "application/x-neva1");
put("nws", "message/rfc822");
put("oda", "application/oda");
put("ogg", "audio/ogg");
put("oom", "application/x-AtlasMate-Plugin");
put("p10", "application/pkcs10");
put("p12", "application/x-pkcs12");
put("p7b", "application/x-pkcs7-certificates");
put("p7c", "application/x-pkcs7-mime");
put("p7m", "application/x-pkcs7-mime");
put("p7r", "application/x-pkcs7-certreqresp");
put("p7s", "application/x-pkcs7-signature");
put("pac", "audio/x-pac");
put("pae", "audio/x-epac");
put("pan", "application/x-pan");
put("pbm", "image/x-portable-bitmap");
put("pcx", "image/x-pcx");
put("pda", "image/x-pda");
put("pdb", "chemical/x-pdb");
put("pdf", "application/pdf");
put("pfr", "application/font-tdpfr");
put("pfx", "application/x-pkcs12");
put("pgm", "image/x-portable-graymap");
put("pict", "image/x-pict");
put("pko", "application/ynd.ms-pkipko");
put("pm", "application/x-perl");
put("pma", "application/x-perfmon");
put("pmc", "application/x-perfmon");
put("pmd", "application/x-pmd");
put("pml", "application/x-perfmon");
put("pmr", "application/x-perfmon");
put("pmw", "application/x-perfmon");
put("png", "image/png");
put("pnm", "image/x-portable-anymap");
put("pnz", "image/png");
put("pot ", "application/vnd.ms-powerpoint");
put("ppm", "image/x-portable-pixmap");
put("pps", "application/vnd.ms-powerpoint");
put("ppt", "application/vnd.ms-powerpoint");
put("pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation");
put("pqf", "application/x-cprplayer");
put("pqi", "application/cprplayer");
put("prc", "application/x-prc");
put("prf", "application/pics-rules");
put("prop", "text/plain");
put("proxy", "application/x-ns-proxy-autoconfig");
put("ps", "application/postscript");
put("ptlk", "application/listenup");
put("pub", "application/x-mspublisher");
put("pvx", "video/x-pv-pvx");
put("qcp", "audio/vnd.qcelp");
put("qt", "video/quicktime");
put("qti", "image/x-quicktime");
put("qtif", "image/x-quicktime");
put("r3t", "text/vnd.rn-realtext3d");
put("ra", "audio/x-pn-realaudio");
put("ram", "audio/x-pn-realaudio");
put("rar", "application/octet-stream");
put("ras", "image/x-cmu-raster");
put("rc", "text/plain");
put("rdf", "application/rdf+xml");
put("rf", "image/vnd.rn-realflash");
put("rgb", "image/x-rgb");
put("rlf", "application/x-richlink");
put("rm", "audio/x-pn-realaudio");
put("rmf", "audio/x-rmf");
put("rmi", "audio/mid");
put("rmm", "audio/x-pn-realaudio");
put("rmvb", "audio/x-pn-realaudio");
put("rnx", "application/vnd.rn-realplayer");
put("roff", "application/x-troff");
put("rp", "image/vnd.rn-realpix");
put("rpm", "audio/x-pn-realaudio-plugin");
put("rt", "text/vnd.rn-realtext");
put("rte", "x-lml/x-gps");
put("rtf", "application/rtf");
put("rtg", "application/metastream");
put("rtx", "text/richtext");
put("rv", "video/vnd.rn-realvideo");
put("rwc", "application/x-rogerwilco");
put("s3m", "audio/x-mod");
put("s3z", "audio/x-mod");
put("sca", "application/x-supercard");
put("scd", "application/x-msschedule");
put("sct", "text/scriptlet");
put("sdf", "application/e-score");
put("sea", "application/x-stuffit");
put("setpay", "application/set-payment-initiation");
put("setreg", "application/set-registration-initiation");
put("sgm", "text/x-sgml");
put("sgml", "text/x-sgml");
put("sh", "application/x-sh");
put("shar", "application/x-shar");
put("shtml", "magnus-internal/parsed-html");
put("shw", "application/presentations");
put("si6", "image/si6");
put("si7", "image/vnd.stiwap.sis");
put("si9", "image/vnd.lgtwap.sis");
put("sis", "application/vnd.symbian.install");
put("sit", "application/x-stuffit");
put("skd", "application/x-Koan");
put("skm", "application/x-Koan");
put("skp", "application/x-Koan");
put("skt", "application/x-Koan");
put("slc", "application/x-salsa");
put("smd", "audio/x-smd");
put("smi", "application/smil");
put("smil", "application/smil");
put("smp", "application/studiom");
put("smz", "audio/x-smd");
put("snd", "audio/basic");
put("spc", "application/x-pkcs7-certificates");
put("spl", "application/futuresplash");
put("spr", "application/x-sprite");
put("sprite", "application/x-sprite");
put("sdp", "application/sdp");
put("spt", "application/x-spt");
put("src", "application/x-wais-source");
put("sst", "application/vnd.ms-pkicertstore");
put("stk", "application/hyperstudio");
put("stl", "application/vnd.ms-pkistl");
put("stm", "text/html");
put("svg", "image/svg+xml");
put("sv4cpio", "application/x-sv4cpio");
put("sv4crc", "application/x-sv4crc");
put("svf", "image/vnd");
put("svh", "image/svh");
put("svr", "x-world/x-svr");
put("swf", "application/x-shockwave-flash");
put("swfl", "application/x-shockwave-flash");
put("t", "application/x-troff");
put("tad", "application/octet-stream");
put("talk", "text/x-speech");
put("tar", "application/x-tar");
put("taz", "application/x-tar");
put("tbp", "application/x-timbuktu");
put("tbt", "application/x-timbuktu");
put("tcl", "application/x-tcl");
put("tex", "application/x-tex");
put("texi", "application/x-texinfo");
put("texinfo", "application/x-texinfo");
put("tgz", "application/x-compressed");
put("thm", "application/vnd.eri.thm");
put("tif", "image/tiff");
put("tiff", "image/tiff");
put("tki", "application/x-tkined");
put("tkined", "application/x-tkined");
put("toc", "application/toc");
put("toy", "image/toy");
put("tr", "application/x-troff");
put("trk", "x-lml/x-gps");
put("trm", "application/x-msterminal");
put("tsi", "audio/tsplayer");
put("tsp", "application/dsptype");
put("tsv", "text/tab-separated-values");
put("ttf", "application/octet-stream");
put("ttz", "application/t-time");
put("txt", "text/plain");
put("uls", "text/iuls");
put("ult", "audio/x-mod");
put("ustar", "application/x-ustar");
put("uu", "application/x-uuencode");
put("uue", "application/x-uuencode");
put("vcd", "application/x-cdlink");
put("vcf", "text/x-vcard");
put("vdo", "video/vdo");
put("vib", "audio/vib");
put("viv", "video/vivo");
put("vivo", "video/vivo");
put("vmd", "application/vocaltec-media-desc");
put("vmf", "application/vocaltec-media-file");
put("vmi", "application/x-dreamcast-vms-info");
put("vms", "application/x-dreamcast-vms");
put("vox", "audio/voxware");
put("vqe", "audio/x-twinvq-plugin");
put("vqf", "audio/x-twinvq");
put("vql", "audio/x-twinvq");
put("vre", "x-world/x-vream");
put("vrml", "x-world/x-vrml");
put("vrt", "x-world/x-vrt");
put("vrw", "x-world/x-vream");
put("vts", "workbook/formulaone");
put("wav", "audio/x-wav");
put("wax", "audio/x-ms-wax");
put("wbmp", "image/vnd.wap.wbmp");
put("wcm", "application/vnd.ms-works");
put("wdb", "application/vnd.ms-works");
put("web", "application/vnd.xara");
put("wi", "image/wavelet");
put("wis", "application/x-InstallShield");
put("wks", "application/vnd.ms-works");
put("wm", "video/x-ms-wm");
put("wma", "audio/x-ms-wma");
put("wmd", "application/x-ms-wmd");
put("wmf", "application/x-msmetafile");
put("wml", "text/vnd.wap.wml");
put("wmlc", "application/vnd.wap.wmlc");
put("wmls", "text/vnd.wap.wmlscript");
put("wmlsc", "application/vnd.wap.wmlscriptc");
put("wmlscript", "text/vnd.wap.wmlscript");
put("wmv", "audio/x-ms-wmv");
put("wmx", "video/x-ms-wmx");
put("wmz", "application/x-ms-wmz");
put("wpng", "image/x-up-wpng");
put("wps", "application/vnd.ms-works");
put("wpt", "x-lml/x-gps");
put("wri", "application/x-mswrite");
put("wrl", "x-world/x-vrml");
put("wrz", "x-world/x-vrml");
put("ws", "text/vnd.wap.wmlscript");
put("wsc", "application/vnd.wap.wmlscriptc");
put("wv", "video/wavelet");
put("wvx", "video/x-ms-wvx");
put("wxl", "application/x-wxl");
put("x-gzip", "application/x-gzip");
put("xaf", "x-world/x-vrml");
put("xar", "application/vnd.xara");
put("xbm", "image/x-xbitmap");
put("xdm", "application/x-xdma");
put("xdma", "application/x-xdma");
put("xdw", "application/vnd.fujixerox.docuworks");
put("xht", "application/xhtml+xml");
put("xhtm", "application/xhtml+xml");
put("xhtml", "application/xhtml+xml");
put("xla", "application/vnd.ms-excel");
put("xlc", "application/vnd.ms-excel");
put("xll", "application/x-excel");
put("xlm", "application/vnd.ms-excel");
put("xls", "application/vnd.ms-excel");
put("xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
put("xlt", "application/vnd.ms-excel");
put("xlw", "application/vnd.ms-excel");
put("xm", "audio/x-mod");
/* put("xml", "text/plain");*/
put("xml", "application/xml");
put("xmz", "audio/x-mod");
put("xof", "x-world/x-vrml");
put("xpi", "application/x-xpinstall");
put("xpm", "image/x-xpixmap");
put("xsit", "text/xml");
put("xsl", "text/xml");
put("xul", "text/xul");
put("xwd", "image/x-xwindowdump");
put("xyz", "chemical/x-pdb");
put("yz1", "application/x-yz1");
put("z", "application/x-compress");
put("zac", "application/x-zaurus-zac");
put("zip", "application/zip");
put("json", "application/json");
}
};
}
package com.pashanhoo.common.util.mybatisplus;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.ConstVal;
import com.baomidou.mybatisplus.generator.config.FileOutConfig;
import com.baomidou.mybatisplus.generator.config.TemplateConfig;
import com.baomidou.mybatisplus.generator.config.po.TableField;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.FileType;
import com.baomidou.mybatisplus.generator.engine.AbstractTemplateEngine;
import java.io.File;
import java.util.*;
public abstract class AbstractTemplateEngineLocal extends AbstractTemplateEngine {
private void fitAddEntityRequest(List<TableField> tableFields, TableInfo tableInfo) {
for(Iterator<TableField> it = tableFields.iterator(); it.hasNext();){
TableField tableField =it.next();
if(tableField.isKeyIdentityFlag() || "ADDTIME".equals(tableField.getName()) || "EDITTIME".equals(tableField.getName())) {
it.remove();
}
}
Set<String> importPacks = tableInfo.getImportPackages();
for(Iterator<String> it = importPacks.iterator(); it.hasNext();){
String importPack = it.next();
if(importPack.indexOf("baomidou") > 0){
it.remove();
}
}
}
private void fillEntityProp(Map<String, Object> objectMap) {
TableInfo tableInfo = (TableInfo) objectMap.get("table");
int addFieldFillPacCount = 0;
for(TableField tableField : tableInfo.getFields()) {
tableField.setConvert(true);
if("ADDTIME".equals(tableField.getName())) {
tableField.setFill("INSERT");
if(addFieldFillPacCount == 0) {
tableInfo.getImportPackages().add("com.baomidou.mybatisplus.annotation.FieldFill");
addFieldFillPacCount++;
}
}
if("UPDATETIME".equals(tableField.getName())) {
tableField.setFill("INSERT_UPDATE");
}
}
}
/**
* list深度拷贝
* @param list
* @return
*/
public List copyList(List list) {
//list深度拷贝
List<Integer> newList = new ArrayList<>();
org.apache.commons.collections.CollectionUtils.addAll(newList, new Object[list.size()]);
Collections.copy(newList, list);
return newList;
}
/**
* 输出 java xml 文件
*/
@Override
public AbstractTemplateEngine batchOutput() {
try {
List<TableInfo> tableInfoList = getConfigBuilder().getTableInfoList();
for (TableInfo tableInfo : tableInfoList) {
Map<String, Object> objectMap = getObjectMap(tableInfo);
Map<String, String> pathInfo = getConfigBuilder().getPathInfo();
TemplateConfig template = getConfigBuilder().getTemplate();
// 自定义内容
InjectionConfig injectionConfig = getConfigBuilder().getInjectionConfig();
if (null != injectionConfig) {
injectionConfig.initTableMap(tableInfo);
objectMap.put("cfg", injectionConfig.getMap());
List<FileOutConfig> focList = injectionConfig.getFileOutConfigList();
if (CollectionUtils.isNotEmpty(focList)) {
for (FileOutConfig foc : focList) {
if (isCreate(FileType.OTHER, foc.outputFile(tableInfo))) {
writer(objectMap, foc.getTemplatePath(), foc.outputFile(tableInfo));
}
}
}
}
// Mp.java
String entityName = tableInfo.getEntityName();
List<TableField> originalTableFieldList = tableInfo.getFields();
if (null != entityName && null != pathInfo.get(ConstVal.ENTITY_PATH)) {
fillEntityProp(objectMap);
String entityFile = String.format((pathInfo.get(ConstVal.ENTITY_PATH) + File.separator + "%s" + "DO" + suffixJavaOrKt()), entityName) ;
if (isCreate(FileType.ENTITY, entityFile)) {
writer(objectMap, templateFilePath(template.getEntity(getConfigBuilder().getGlobalConfig().isKotlin())), entityFile);
}
List<TableField> originalTableFields = tableInfo.getFields();
List<TableField> addEntityTableFieldList = copyList(tableInfo.getFields());
fitAddEntityRequest(addEntityTableFieldList, tableInfo);
tableInfo.setFields(addEntityTableFieldList);
//向ObjectMap中添加首字母小写的实体对象名
String entity = (String) objectMap.get("entity");
objectMap.put("lowerEntity", entity.toLowerCase());
//AddEntityRequest.java
fitAddEntityRequest(tableInfo.getFields(), tableInfo);
String addEntityRequestFile = String.format((pathInfo.get(ConstVal.ENTITY_PATH) + File.separator + "%s" + suffixJavaOrKt()), "Add" + entityName + "Request");
if (isCreate(FileType.ENTITY, addEntityRequestFile)) {
writer(objectMap, "templates/AddEntityRequest.java.ftl", addEntityRequestFile);
}
//UpdateEntityRequest.java
fitAddEntityRequest(tableInfo.getFields(), tableInfo);
String updateEntityRequestFile = String.format((pathInfo.get(ConstVal.ENTITY_PATH) + File.separator + "%s" + suffixJavaOrKt()), "Update" + entityName + "Request");
if (isCreate(FileType.ENTITY, updateEntityRequestFile)) {
writer(objectMap, "templates/UpdateEntityRequest.java.ftl", updateEntityRequestFile);
}
//EntitySearchRequest.java
String entitySearchRequestFile = String.format((pathInfo.get(ConstVal.ENTITY_PATH) + File.separator + "%s" + suffixJavaOrKt()), entityName + "SearchRequest");
if (isCreate(FileType.ENTITY, entitySearchRequestFile)) {
writer(objectMap, "templates/EntitySearchRequest.java.ftl", entitySearchRequestFile);
}
tableInfo.setFields(originalTableFields);
//EntityListVO.java
String entityListVOFile = String.format((pathInfo.get(ConstVal.ENTITY_PATH) + File.separator + "%s" + suffixJavaOrKt()), entityName + "ListVO");
if (isCreate(FileType.ENTITY, entityListVOFile)) {
writer(objectMap, "templates/EntityListVO.java.ftl", entityListVOFile);
}
//EntityDetailVO.java
String entityDetailVOFile = String.format((pathInfo.get(ConstVal.ENTITY_PATH) + File.separator + "%s" + suffixJavaOrKt()), entityName + "DetailVO");
if (isCreate(FileType.ENTITY, entityDetailVOFile)) {
writer(objectMap, "templates/EntityDetailVO.java.ftl", entityDetailVOFile);
}
}
//converter.java
String entityConverterFile = String.format((pathInfo.get(ConstVal.ENTITY_PATH) + File.separator + "%s" + suffixJavaOrKt()), entityName + "Converter");
if (isCreate(FileType.ENTITY, entityConverterFile)) {
writer(objectMap, "templates/entityConverter.java.ftl", entityConverterFile);
}
// MpMapper.java
if (null != tableInfo.getMapperName() && null != pathInfo.get(ConstVal.MAPPER_PATH)) {
String mapperFile = String.format((pathInfo.get(ConstVal.MAPPER_PATH) + File.separator + tableInfo.getMapperName() + suffixJavaOrKt()), entityName);
if (isCreate(FileType.MAPPER, mapperFile)) {
writer(objectMap, templateFilePath(template.getMapper()), mapperFile);
}
}
// MpMapper.xml
if (null != tableInfo.getXmlName() && null != pathInfo.get(ConstVal.XML_PATH)) {
String xmlFile = String.format((pathInfo.get(ConstVal.XML_PATH) + File.separator + tableInfo.getXmlName() + ConstVal.XML_SUFFIX), entityName);
if (isCreate(FileType.XML, xmlFile)) {
writer(objectMap, templateFilePath(template.getXml()), xmlFile);
}
}
// IMpService.java
if (null != tableInfo.getServiceName() && null != pathInfo.get(ConstVal.SERVICE_PATH)) {
String serviceFile = String.format((pathInfo.get(ConstVal.SERVICE_PATH) + File.separator + tableInfo.getServiceName() + suffixJavaOrKt()), entityName);
if (isCreate(FileType.SERVICE, serviceFile)) {
writer(objectMap, templateFilePath(template.getService()), serviceFile);
}
}
// MpServiceImpl.java
if (null != tableInfo.getServiceImplName() && null != pathInfo.get(ConstVal.SERVICE_IMPL_PATH)) {
String implFile = String.format((pathInfo.get(ConstVal.SERVICE_IMPL_PATH) + File.separator + tableInfo.getServiceImplName() + suffixJavaOrKt()), entityName);
if (isCreate(FileType.SERVICE_IMPL, implFile)) {
writer(objectMap, templateFilePath(template.getServiceImpl()), implFile);
}
}
// MpController.java
if (null != tableInfo.getControllerName() && null != pathInfo.get(ConstVal.CONTROLLER_PATH)) {
String controllerFile = String.format((pathInfo.get(ConstVal.CONTROLLER_PATH) + File.separator + tableInfo.getControllerName() + suffixJavaOrKt()), entityName);
if (isCreate(FileType.CONTROLLER, controllerFile)) {
writer(objectMap, templateFilePath(template.getController()), controllerFile);
}
}
}
} catch (Exception e) {
logger.error("无法创建文件，请检查配置信息！", e);
}
return this;
}
}
package com.pashanhoo.common.util.mybatisplus;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.generator.config.ConstVal;
import com.baomidou.mybatisplus.generator.config.builder.ConfigBuilder;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
import freemarker.template.Configuration;
import freemarker.template.Template;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.util.Map;
public class MyFreemarkerTemplateEngine extends AbstractTemplateEngineLocal {
private Configuration configuration;
@Override
public MyFreemarkerTemplateEngine init(ConfigBuilder configBuilder) {
super.init(configBuilder);
configuration = new Configuration(Configuration.DEFAULT_INCOMPATIBLE_IMPROVEMENTS);
configuration.setDefaultEncoding(ConstVal.UTF8);
configuration.setClassForTemplateLoading(FreemarkerTemplateEngine.class, StringPool.SLASH);
return this;
}
@Override
public void writer(Map<String, Object> objectMap, String templatePath, String outputFile) throws Exception {
Template template = configuration.getTemplate(templatePath);
try (FileOutputStream fileOutputStream = new FileOutputStream(outputFile)) {
template.process(objectMap, new OutputStreamWriter(fileOutputStream, ConstVal.UTF8));
}
logger.debug("模板:" + templatePath + "; 文件:" + outputFile);
}
@Override
public String templateFilePath(String filePath) {
return filePath + ".ftl";
}
}
package com.pashanhoo.destroy.controller;
import com.pashanhoo.archive.entity.vo.DgArchivesSearchRequest;
import com.pashanhoo.common.Result;
import com.pashanhoo.destroy.entity.vo.AddDgArchivesDestructionRequest;
import com.pashanhoo.destroy.entity.vo.DgArchivesDestructionSearchRequest;
import com.pashanhoo.destroy.entity.vo.UpdateDgArchivesDestructionRequest;
import com.pashanhoo.destroy.service.DgArchivesDestructionService;
import com.pashanhoo.destroycatalog.entity.vo.AddDgDestructionCatalogRequest;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
/**
* <p>
* 档案销毁 前端控制器
* </p>
*
* @author
* @since 2021-11-05
*/
@RestController
@RequestMapping("/system/dgArchivesDestruction/")
@Api(tags = "档案销毁接口")
public class DgArchivesDestructionController {
@Autowired
private DgArchivesDestructionService dgarchivesdestructionService;
@PostMapping("search")
@ApiOperation(value = "根据条件进行列表查询")
public Result searchDgArchivesDestructionList(@RequestBody DgArchivesDestructionSearchRequest request) {
return dgarchivesdestructionService.searchDgArchivesDestructionList(request);
}
@GetMapping("deleteDgArchivesDestructionByIds")
@ApiOperation(value = "根据销毁记录标识码删除档案销毁记录")
public Result deleteDgArchivesDestructionByIds(@ApiParam("档案销毁ID") @RequestParam(value = "bsm_destruction") String bsm_destruction) {
return dgarchivesdestructionService.deleteDgArchivesDestruction(bsm_destruction);
}
@GetMapping("getDgArchivesDestructionDetailById")
@ApiOperation(value = "查询档案销毁信息")
public Result getDgArchivesDestructionDetailById(@ApiParam("档案销毁ID") @RequestParam String bsm_destruction) {
return Result.ok(dgarchivesdestructionService.getDgArchivesDestructionDetailById(bsm_destruction));
}
@PostMapping("showArchivesForDestruction")
@ApiOperation("展示可以选择销毁的列表")
public Result showArchivesForDestruction(@RequestBody DgArchivesSearchRequest request) {
return dgarchivesdestructionService.showArchivesForDestruction(request);
}
@PostMapping("addDestructionArchivesInfo")
@ApiOperation(value = "选择销毁档案List")
public Result addDestructionArchivesInfo(@ApiParam("案卷基本信息ID列表") @RequestParam(value = "idList") List<String> idList) {
return dgarchivesdestructionService.addDestructionArchivesInfo(idList);
}
@PostMapping("updateDgArchivesDestruction")
@ApiOperation("修改档案销毁记录信息")
public Result updateDgArchivesDestruction(@RequestBody UpdateDgArchivesDestructionRequest request) {
if (dgarchivesdestructionService.updateDgArchivesDestruction(request)) {
return Result.ok("修改成功");
}
return Result.error("修改失败");
}
@GetMapping("deleteArchivesInfo")
@ApiOperation(value = "删除档案列表中的档案信息")
public Result deleteArchivesInfo(@ApiParam("档案ID") @RequestParam(value = "bsmArchives") String bsmArchives) {
return dgarchivesdestructionService.deleteDestructionArchivescataLog(bsmArchives);
}
@GetMapping("getDestructionArchivescataLog")
@ApiOperation(value = "查询档案销毁目录信息")
public Result getDestructionArchivescataLog(@ApiParam("档案销毁ID") @RequestParam(value = "bsm_destruction") String bsm_destruction) {
return dgarchivesdestructionService.queryArchivesInfo(bsm_destruction);
}
@GetMapping("deleteDestructionArchivescataLog")
@ApiOperation(value = "删除档案销毁目录信息")
public Result deleteDestructionArchivescataLog(@ApiParam("档案销毁ID") @RequestParam(value = "bsm_destruction") String bsm_destruction) {
return dgarchivesdestructionService.deleteDestructionArchivescataLog(bsm_destruction);
}
@GetMapping("updateArchivesStateByDestruction")
@ApiOperation(value = "销毁操作")
public Result updateArchivesStateByDestruction(@ApiParam("档案销毁记录ID") @RequestParam(value = "bsm_destruction") String bsm_destruction) {
return dgarchivesdestructionService.updateArchivesStateByDestruction(bsm_destruction);
}
@GetMapping("getDestroyLeftMenu")
@ApiOperation(value = "根据销毁清册编号获取左侧档案号菜单")
public Result getDestroyLeftMenu(@ApiParam("销毁清册编号") @RequestParam String xhqcbh) {
return Result.ok(dgarchivesdestructionService.getDestroyLeftMenu(xhqcbh));
}
}
package com.pashanhoo.destroy.entity;
import java.util.List;
import com.pashanhoo.destroy.entity.vo.AddDgArchivesDestructionRequest;
import com.pashanhoo.destroy.entity.vo.DgArchivesDestructionDetailVO;
import com.pashanhoo.destroy.entity.vo.DgArchivesDestructionListVO;
import com.pashanhoo.destroy.entity.vo.UpdateDgArchivesDestructionRequest;
import org.mapstruct.Mapper;
/**
* @author
* @since 2021-11-05
*/
@Mapper(componentModel = "spring")
public interface DgArchivesDestructionConverter{
DgArchivesDestructionDO addRequest2DO(AddDgArchivesDestructionRequest request);
DgArchivesDestructionDetailVO do2DetailVO(DgArchivesDestructionDO dgarchivesdestructionDO);
DgArchivesDestructionDO updateRequest2DO(UpdateDgArchivesDestructionRequest request);
DgArchivesDestructionListVO do2ListVO(DgArchivesDestructionDO dgarchivesdestructionDO);
List<DgArchivesDestructionListVO> doList2ListVOList(List<DgArchivesDestructionDO> dgarchivesdestructionDOList);
}
package com.pashanhoo.destroy.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案销毁
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("DG_ARCHIVES_DESTRUCTION")
public class DgArchivesDestructionDO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 销毁标识码
*/
@TableId(value = "BSM_DESTRUCTION", type = IdType.UUID)
private String bsmDestruction;
/**
* 销毁清册编号
*/
@TableField("XHQCBH")
private String xhqcbh;
/**
* 发起人
*/
@TableField("FQR")
private String fqr;
/**
* 发起日期
*/
@TableField("FQRQ")
private Date fqrq;
/**
* 销毁原因
*/
@TableField("XHYY")
private String xhyy;
/**
* 审核人
*/
@TableField("SHRY")
private String shry;
/**
* 审批意见
*/
@TableField("SHYJ")
private String shyj;
/**
* 监销人
*/
@TableField("XHR")
private String xhr;
/**
* 销毁日期
*/
@TableField("XHRQ")
private Date xhrq;
/**
* 状态 1：销毁中，2：已销毁
*/
@TableField("STATE")
private String state;
}
package com.pashanhoo.destroy.entity.vo;
import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案销毁新增请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案销毁新增请求实体")
public class AddDgArchivesDestructionRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 销毁清册编号
*/
@ApiModelProperty(name = "xhqcbh", value = "销毁清册编号")
private String xhqcbh;
/**
* 发起人
*/
@ApiModelProperty(name = "fqr", value = "发起人")
private String fqr;
/**
* 发起日期
*/
@ApiModelProperty(name = "fqrq", value = "发起日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date fqrq;
/**
* 销毁原因
*/
@ApiModelProperty(name = "xhyy", value = "销毁原因")
private String xhyy;
/**
* 审核人
*/
@ApiModelProperty(name = "shry", value = "审核人")
private String shry;
/**
* 审批意见
*/
@ApiModelProperty(name = "shyj", value = "审批意见")
private String shyj;
/**
* 监销人
*/
@ApiModelProperty(name = "xhr", value = "监销人")
private String xhr;
/**
* 销毁日期
*/
@ApiModelProperty(name = "xhrq", value = "销毁日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date xhrq;
}
package com.pashanhoo.destroy.entity.vo;
import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案销毁明细实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案销毁明细实体")
public class DgArchivesDestructionDetailVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 销毁标识码
*/
@ApiModelProperty(name = "bsmDestruction", value = "销毁标识码")
private String bsmDestruction;
/**
* 销毁清册编号
*/
@ApiModelProperty(name = "xhqcbh", value = "销毁清册编号")
private String xhqcbh;
/**
* 发起人
*/
@ApiModelProperty(name = "fqr", value = "发起人")
private String fqr;
/**
* 发起日期
*/
@ApiModelProperty(name = "fqrq", value = "发起日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date fqrq;
/**
* 销毁原因
*/
@ApiModelProperty(name = "xhyy", value = "销毁原因")
private String xhyy;
/**
* 审核人
*/
@ApiModelProperty(name = "shry", value = "审核人")
private String shry;
/**
* 审批意见
*/
@ApiModelProperty(name = "shyj", value = "审批意见")
private String shyj;
/**
* 监销人
*/
@ApiModelProperty(name = "xhr", value = "监销人")
private String xhr;
/**
* 销毁日期
*/
@ApiModelProperty(name = "xhrq", value = "销毁日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date xhrq;
}
package com.pashanhoo.destroy.entity.vo;
import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案销毁列表VO
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案销毁列表VO")
public class DgArchivesDestructionListVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 销毁标识码
*/
@ApiModelProperty(name = "bsmDestruction", value = "销毁标识码")
private String bsmDestruction;
/**
* 销毁清册编号
*/
@ApiModelProperty(name = "xhqcbh", value = "销毁清册编号")
private String xhqcbh;
/**
* 发起人
*/
@ApiModelProperty(name = "fqr", value = "发起人")
private String fqr;
/**
* 发起日期
*/
@ApiModelProperty(name = "fqrq", value = "发起日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date fqrq;
/**
* 销毁原因
*/
@ApiModelProperty(name = "xhyy", value = "销毁原因")
private String xhyy;
/**
* 审核人
*/
@ApiModelProperty(name = "shry", value = "审核人")
private String shry;
/**
* 审批意见
*/
@ApiModelProperty(name = "shyj", value = "审批意见")
private String shyj;
/**
* 监销人
*/
@ApiModelProperty(name = "xhr", value = "监销人")
private String xhr;
/**
* 销毁日期
*/
@ApiModelProperty(name = "xhrq", value = "销毁日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date xhrq;
/**
* 数量（卷）
*/
@ApiModelProperty(name = "ajNum", value = "数量（卷）")
private String ajNum;
}
package com.pashanhoo.destroy.entity.vo;
import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import com.pashanhoo.common.PageInfo;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案销毁列表查询请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案销毁列表查询请求实体")
public class DgArchivesDestructionSearchRequest extends PageInfo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 销毁清册编号
*/
@ApiModelProperty(name = "xhqcbh", value = "销毁清册编号")
private String xhqcbh;
/**
* 档案号
*/
@ApiModelProperty(name = "ajh", value = "档案号")
private String ajh;
/**
* 销毁日期
*/
@ApiModelProperty(name = "xhrq", value = "销毁日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date xhrq;
}
package com.pashanhoo.destroy.entity.vo;
import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案销毁修改请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案销毁修改请求实体")
public class UpdateDgArchivesDestructionRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 销毁标识码
*/
@ApiModelProperty(name = "bsmDestruction", value = "销毁标识码")
private String bsmDestruction;
/**
* 销毁清册编号
*/
@ApiModelProperty(name = "xhqcbh", value = "销毁清册编号")
private String xhqcbh;
/**
* 发起人
*/
@ApiModelProperty(name = "fqr", value = "发起人")
private String fqr;
/**
* 发起日期
*/
@ApiModelProperty(name = "fqrq", value = "发起日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date fqrq;
/**
* 销毁原因
*/
@ApiModelProperty(name = "xhyy", value = "销毁原因")
private String xhyy;
/**
* 审核人
*/
@ApiModelProperty(name = "shry", value = "审核人")
private String shry;
/**
* 审批意见
*/
@ApiModelProperty(name = "shyj", value = "审批意见")
private String shyj;
/**
* 监销人
*/
@ApiModelProperty(name = "xhr", value = "监销人")
private String xhr;
/**
* 销毁日期
*/
@ApiModelProperty(name = "xhrq", value = "销毁日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date xhrq;
}
package com.pashanhoo.destroy.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.pashanhoo.archive.entity.DgArchivesDO;
import com.pashanhoo.archive.entity.vo.DgArchivesListVO;
import com.pashanhoo.destroy.entity.DgArchivesDestructionDO;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import com.pashanhoo.destroy.entity.vo.DgArchivesDestructionListVO;
import com.pashanhoo.destroy.entity.vo.DgArchivesDestructionSearchRequest;
/**
* <p>
* 档案销毁 Mapper 接口
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgArchivesDestructionMapper extends BaseMapper<DgArchivesDestructionDO> {
/**
* 根据销毁清册编号获取左侧档案号菜单
*
* @param xhqcbh 销毁清册编号
* @return
*/
List<DgArchivesDO> getDestroyLeftMenu(@Param("xhqcbh") String xhqcbh);
List<DgArchivesDestructionListVO> selectXhResult(DgArchivesDestructionSearchRequest request);
boolean updateArchivesStatus(@Param("bsm_destruction") String bsm_destruction,@Param("dazt") String dazt);
List<DgArchivesListVO> queryArchivesInfo(@Param("bsm_destruction") String bsm_destruction);
boolean updateArchivesStatusBatch(@Param("idList") List<String> idList,@Param("dazt") String dazt);
boolean updateDestructionArchivesStatus(@Param("bsm_destruction") String bsm_destruction,@Param("dazt") String dazt);
}
package com.pashanhoo.destroy.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.pashanhoo.archive.entity.vo.DgArchivesSearchRequest;
import com.pashanhoo.common.Result;
import com.pashanhoo.destroy.entity.DgArchivesDestructionDO;
import com.pashanhoo.destroy.entity.vo.AddDgArchivesDestructionRequest;
import com.pashanhoo.destroy.entity.vo.DgArchivesDestructionDetailVO;
import com.pashanhoo.destroy.entity.vo.DgArchivesDestructionSearchRequest;
import com.pashanhoo.destroy.entity.vo.UpdateDgArchivesDestructionRequest;
import com.pashanhoo.destroycatalog.entity.vo.AddDgDestructionCatalogRequest;
import java.util.List;
/**
* <p>
* 档案销毁 服务类
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgArchivesDestructionService extends IService<DgArchivesDestructionDO> {
/**
* 根据条件进行列表查询
* @param request
* @return
*/
Result searchDgArchivesDestructionList(DgArchivesDestructionSearchRequest request);
/**
* 删除记录
* @param bsm_destruction
* @return
*/
Result deleteDgArchivesDestruction(String bsm_destruction);
/**
* 根据条件进行列表查询
* @param bsm_destruction
* @return
*/
Result queryArchivesInfo(String bsm_destruction);
/**
* 根据条件进行列表查询
* @param bsmArchives
* @return
*/
Result deleteDestructionArchivescataLog(String bsmArchives);
/**
* 选择销毁档案List
* @param idList
* @return
*/
Result addDestructionArchivesInfo(List<String> idList);
/**
* 销毁接口
* @param bsm_destruction
* @return
*/
Result updateArchivesStateByDestruction(String bsm_destruction);
/**
* 新增档案销毁列表中的档案销毁操作
* @param idList
* @return
*/
Result updateStateByArchives(List<String> idList);
/**
/**
* 新增记录
*
* @param request
* @return
*/
Result insertDgArchivesDestruction(AddDgArchivesDestructionRequest request);
/**
* 展示可以销毁的档案列表
* @param request
* @return
*/
Result showArchivesForDestruction( DgArchivesSearchRequest request);
/**
* 根据主键查询记录详情
*
* @param id
* @return
*/
DgArchivesDestructionDetailVO getDgArchivesDestructionDetailById(String id);
/**
* 修改单条记录
*
* @param request
* @return
*/
boolean updateDgArchivesDestruction(UpdateDgArchivesDestructionRequest request);
/**
* 根据销毁清册编号获取左侧档案号菜单
*
* @param xhqcbh 销毁清册编号
* @return
*/
List getDestroyLeftMenu(String xhqcbh);
}
package com.pashanhoo.destroy.service.impl;
import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.pashanhoo.archive.entity.DgArchivesDO;
import com.pashanhoo.archive.entity.vo.DgArchivesSearchRequest;
import com.pashanhoo.archive.service.DgArchivesService;
import com.pashanhoo.common.Result;
import com.pashanhoo.common.util.SysCode.SysCodeUtil;
import com.pashanhoo.common.util.SysCode.SysCodeVO;
import com.pashanhoo.destroy.entity.DgArchivesDestructionConverter;
import com.pashanhoo.destroy.entity.DgArchivesDestructionDO;
import com.pashanhoo.destroy.entity.vo.*;
import com.pashanhoo.destroy.mapper.DgArchivesDestructionMapper;
import com.pashanhoo.destroy.service.DgArchivesDestructionService;
import com.pashanhoo.destroycatalog.entity.DgDestructionCatalogConverter;
import com.pashanhoo.destroycatalog.service.DgDestructionCatalogService;
import com.pashanhoo.lend.mapper.DgLendMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
* <p>
* 档案销毁 服务实现类
* </p>
*
* @author
* @since 2021-11-05
*/
@Service
public class DgArchivesDestructionServiceImpl extends ServiceImpl<DgArchivesDestructionMapper, DgArchivesDestructionDO> implements DgArchivesDestructionService {
@Autowired
private DgArchivesDestructionConverter dgarchivesdestructionConverter;
@Autowired
private DgArchivesDestructionMapper dgarchivesdestructionMapper;
@Autowired
private DgDestructionCatalogService catalogService;
@Autowired
private DgDestructionCatalogConverter catalogConverter;
@Autowired
private DgArchivesService archivesService;
@Autowired
SysCodeUtil sysCodeUtil;
@Autowired
private DgLendMapper dglendMapper;
/**
* 新增记录
* @param request
* @return
*/
@Override
public Result insertDgArchivesDestruction(AddDgArchivesDestructionRequest request) {
DgArchivesDestructionDO dgarchivesdestructionDO = dgarchivesdestructionConverter.addRequest2DO(request);
String id= IdWorker.get32UUID();
dgarchivesdestructionDO.setBsmDestruction(id);
this.save(dgarchivesdestructionDO);
return Result.ok(id);
}
@Override
public Result showArchivesForDestruction(DgArchivesSearchRequest request) {
request.setDazt(4);
return Result.ok(archivesService.searchDgArchivesList(request));
}
/**
* 根据主键查询记录详情
* @param id
* @return
*/
@Override
public DgArchivesDestructionDetailVO getDgArchivesDestructionDetailById(String id) {
DgArchivesDestructionDO dgarchivesdestructionDO = this.getById(id);
return dgarchivesdestructionConverter.do2DetailVO(dgarchivesdestructionDO);
}
/**
* 修改单条记录
* @param request
* @return
*/
@Override
public boolean updateDgArchivesDestruction(UpdateDgArchivesDestructionRequest request) {
DgArchivesDestructionDO dgarchivesdestructionDO = dgarchivesdestructionConverter.updateRequest2DO(request);
return this.updateById(dgarchivesdestructionDO);
}
/**
* 根据条件进行列表查询
* @param request
* @return
*/
@Override
public Result searchDgArchivesDestructionList(DgArchivesDestructionSearchRequest request) {
PageHelper.startPage(request.getCurrentPage(), request.getPageSize());
List<DgArchivesDestructionListVO> jyListVOList = dgarchivesdestructionMapper.selectXhResult(request);
PageInfo<DgArchivesDestructionListVO> pageInfo = new PageInfo<DgArchivesDestructionListVO>(jyListVOList);
return Result.ok(pageInfo);
}
@Override
@Transactional(rollbackFor = Exception.class)
public Result deleteDgArchivesDestruction(String bsm_destruction) {
//删除销毁记录表数据
dgarchivesdestructionMapper.deleteById(bsm_destruction);
//删除档案销毁目录数据
catalogService.deleteDestructionCatalog(bsm_destruction);
//修改档案信息表状态
dgarchivesdestructionMapper.updateArchivesStatus(bsm_destruction,"4");
return Result.ok();
}
@Override
public Result queryArchivesInfo(String bsm_destruction) {
return Result.ok(dgarchivesdestructionMapper.queryArchivesInfo(bsm_destruction));
}
@Override
public Result deleteDestructionArchivescataLog(String bsmArchives) {
catalogService.deleteDestructionCatalog(bsmArchives);
return Result.ok();
}
@Override
@Transactional(rollbackFor = Exception.class)
public Result addDestructionArchivesInfo(List<String> idList) {
//获取补录编号
SysCodeVO sysCodeVO = new SysCodeVO();
sysCodeVO.setTaskno("XH" + DateUtil.year(DateUtil.date()));
sysCodeVO.setCtype("sequence");
sysCodeVO.setTaskname("补录序列号");
sysCodeVO.setTaskchild(5);
String xhbh = sysCodeUtil.getSequence(sysCodeVO);
//1.新增销毁案卷信息表数据
String archivesUuid=IdWorker.get32UUID();
DgArchivesDestructionDO destructionDO=new DgArchivesDestructionDO();
destructionDO.setBsmDestruction(archivesUuid);
destructionDO.setXhqcbh(xhbh);
destructionDO.setFqr("admin");
destructionDO.setShyj("同意");
destructionDO.setState("1");
dgarchivesdestructionMapper.insert(destructionDO);
//2.新增销毁目录信息表
catalogService.saveBatchDestructionCatalog(idList,archivesUuid);
//3.档案信息修改状态为修改中
dglendMapper.updateArchivesStatusBatch(idList,"5");
return Result.ok();
}
@Override
public Result updateArchivesStateByDestruction(String bsm_destruction) {
//1.修改档案信息表状态
dgarchivesdestructionMapper.updateArchivesStatus(bsm_destruction,"6");
//2.修改档案销毁信息表中的状态
dgarchivesdestructionMapper.updateDestructionArchivesStatus(bsm_destruction,"2");
return Result.ok();
}
@Override
public Result updateStateByArchives(List<String> idList) {
//1.修改档案基本信息表中的状态
dgarchivesdestructionMapper.updateArchivesStatusBatch(idList,"6");
return Result.ok();
}
/**
* 根据销毁清册编号获取左侧档案号菜单
*
* @param xhqcbh 销毁清册编号
* @return
*/
@Override
public List getDestroyLeftMenu(String xhqcbh) {
List<DgArchivesDO> dgArchivesDestructionDOS = dgarchivesdestructionMapper.getDestroyLeftMenu(xhqcbh);
return dgArchivesDestructionDOS;
}
}
package com.pashanhoo.destroycatalog.controller;
import com.pashanhoo.common.Result;
import com.pashanhoo.destroycatalog.entity.vo.AddDgDestructionCatalogRequest;
import com.pashanhoo.destroycatalog.entity.vo.UpdateDgDestructionCatalogRequest;
import com.pashanhoo.destroycatalog.entity.vo.DgDestructionCatalogSearchRequest;
import com.pashanhoo.destroycatalog.service.DgDestructionCatalogService;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
/**
* <p>
* 档案销毁目录 前端控制器
* </p>
*
* @author
* @since 2021-11-05
*/
@RestController
@RequestMapping("/system/dgDestructionCatalog/")
public class DgDestructionCatalogController {
@Autowired
private DgDestructionCatalogService dgdestructioncatalogService;
@PostMapping("saveBatchDestructionCatalog")
@ApiOperation("新增档案销毁目录")
public Result saveBatchDestructionCatalog(@ApiParam("档案销毁目录ID列表") @RequestParam(value = "idList") List<String> idList,@ApiParam("档案销毁信息ID") String bsm_destruction){
boolean flag=dgdestructioncatalogService.saveBatchDestructionCatalog(idList,bsm_destruction);
if(flag){
return Result.ok("批量新增目录成功");
}else{
return Result.error("批量新增目录失败");
}
}
@DeleteMapping("deleteDgDestructionCatalogByIds")
@ApiOperation(value = "批量删除档案销毁目录")
public Result deleteDgDestructionCatalogByIds(@ApiParam("档案销毁目录ID列表") @RequestParam(value = "idList") List<String> idList) {
if(dgdestructioncatalogService.removeByIds(idList)) {
return Result.ok("删除成功");
}
return Result.error("删除失败");
}
@PutMapping("updateDgDestructionCatalog")
@ApiOperation("修改档案销毁目录")
public Result updateDgDestructionCatalog(@RequestBody UpdateDgDestructionCatalogRequest request){
if(dgdestructioncatalogService.updateDgDestructionCatalog(request)) {
return Result.ok("修改成功");
}
return Result.error("修改失败");
}
@GetMapping("getDgDestructionCatalogDetailById")
@ApiOperation(value = "读取明细")
public Result getDgDestructionCatalogDetailById(@ApiParam("档案销毁目录ID") @RequestParam String id){
return Result.ok(dgdestructioncatalogService.getDgDestructionCatalogDetailById(id));
}
@PostMapping("search")
@ApiOperation(value = "根据条件进行列表查询")
public Result searchDgDestructionCatalogList(@RequestBody DgDestructionCatalogSearchRequest request) {
//TODO 默认排序条件设置
request.defaultFillPageProp("","");
return Result.ok(dgdestructioncatalogService.searchDgDestructionCatalogList(request));
}
}
package com.pashanhoo.destroycatalog.entity;
import java.util.List;
import com.pashanhoo.destroycatalog.entity.vo.AddDgDestructionCatalogRequest;
import com.pashanhoo.destroycatalog.entity.vo.DgDestructionCatalogDetailVO;
import com.pashanhoo.destroycatalog.entity.vo.DgDestructionCatalogListVO;
import com.pashanhoo.destroycatalog.entity.vo.UpdateDgDestructionCatalogRequest;
import org.mapstruct.Mapper;
/**
* @author
* @since 2021-11-05
*/
@Mapper(componentModel = "spring")
public interface DgDestructionCatalogConverter{
DgDestructionCatalogDO addRequest2DO(AddDgDestructionCatalogRequest request);
DgDestructionCatalogDetailVO do2DetailVO(DgDestructionCatalogDO dgdestructioncatalogDO);
DgDestructionCatalogDO updateRequest2DO(UpdateDgDestructionCatalogRequest request);
DgDestructionCatalogListVO do2ListVO(DgDestructionCatalogDO dgdestructioncatalogDO);
List<DgDestructionCatalogListVO> doList2ListVOList(List<DgDestructionCatalogDO> dgdestructioncatalogDOList);
List<DgDestructionCatalogDO> addRequestList2DO(List<AddDgDestructionCatalogRequest> request);
}
package com.pashanhoo.destroycatalog.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案销毁目录
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("DG_DESTRUCTION_CATALOG")
public class DgDestructionCatalogDO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 销毁目录标识码
*/
@TableId(value = "BSM_DESTRUCTIONCATALOG", type = IdType.UUID)
private String bsmDestructioncatalog;
/**
* 档案标识码
*/
@TableField("BSM_ARCHIVES")
private String bsmArchives;
/**
* 销毁标识码
*/
@TableField("BSM_DESTRUCTION")
private String bsmDestruction;
}
package com.pashanhoo.destroycatalog.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案销毁目录新增请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案销毁目录新增请求实体")
public class AddDgDestructionCatalogRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 销毁标识码
*/
@ApiModelProperty(name = "bsmDestruction", value = "销毁标识码")
private String bsmDestruction;
}
package com.pashanhoo.destroycatalog.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案销毁目录明细实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案销毁目录明细实体")
public class DgDestructionCatalogDetailVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 销毁目录标识码
*/
@ApiModelProperty(name = "bsmLendcatalog", value = "销毁目录标识码")
private String bsmLendcatalog;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 销毁标识码
*/
@ApiModelProperty(name = "bsmDestruction", value = "销毁标识码")
private String bsmDestruction;
}
package com.pashanhoo.destroycatalog.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案销毁目录列表VO
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案销毁目录列表VO")
//TODO 该类属性暂时是完整的全部属性，需进行个性化的增删
public class DgDestructionCatalogListVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 销毁目录标识码
*/
@ApiModelProperty(name = "bsmLendcatalog", value = "销毁目录标识码")
private String bsmLendcatalog;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 销毁标识码
*/
@ApiModelProperty(name = "bsmDestruction", value = "销毁标识码")
private String bsmDestruction;
}
package com.pashanhoo.destroycatalog.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import com.pashanhoo.common.PageInfo;
/**
* <p>
* 档案销毁目录列表查询请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案销毁目录列表查询请求实体")
//TODO 初始查询条件是全部，需要根据情况自行删减
public class DgDestructionCatalogSearchRequest extends PageInfo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 销毁目录标识码
*/
@ApiModelProperty(name = "bsmLendcatalog", value = "销毁目录标识码")
private String bsmLendcatalog;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 销毁标识码
*/
@ApiModelProperty(name = "bsmDestruction", value = "销毁标识码")
private String bsmDestruction;
}
package com.pashanhoo.destroycatalog.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案销毁目录修改请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案销毁目录修改请求实体")
public class UpdateDgDestructionCatalogRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 销毁目录标识码
*/
@ApiModelProperty(name = "bsmLendcatalog", value = "销毁目录标识码")
private String bsmLendcatalog;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 销毁标识码
*/
@ApiModelProperty(name = "bsmDestruction", value = "销毁标识码")
private String bsmDestruction;
}
package com.pashanhoo.destroycatalog.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.pashanhoo.archive.entity.DgArchivesDO;
import com.pashanhoo.destroycatalog.entity.DgDestructionCatalogDO;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* <p>
* 档案销毁目录 Mapper 接口
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgDestructionCatalogMapper extends BaseMapper<DgDestructionCatalogDO> {
List<DgArchivesDO> getDestructionCatalog(@Param("bsmDestruction") String bsmDestruction);
}
package com.pashanhoo.destroycatalog.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.pashanhoo.common.Result;
import com.pashanhoo.destroycatalog.entity.DgDestructionCatalogDO;
import com.pashanhoo.destroycatalog.entity.vo.AddDgDestructionCatalogRequest;
import com.pashanhoo.destroycatalog.entity.vo.DgDestructionCatalogDetailVO;
import com.pashanhoo.destroycatalog.entity.vo.UpdateDgDestructionCatalogRequest;
import com.pashanhoo.destroycatalog.entity.vo.DgDestructionCatalogSearchRequest;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.ApiParam;
import java.util.List;
/**
* <p>
* 档案销毁目录 服务类
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgDestructionCatalogService extends IService<DgDestructionCatalogDO> {
/**
* 批量销毁目录新增记录
* @param idList,bsm_destruction
* @return
*/
boolean saveBatchDestructionCatalog(List<String> idList,String bsm_destruction);
/**
* 根据主键查询记录详情
* @param id
* @return
*/
DgDestructionCatalogDetailVO getDgDestructionCatalogDetailById(String id);
/**
* 修改单条记录
* @param request
* @return
*/
boolean updateDgDestructionCatalog(UpdateDgDestructionCatalogRequest request);
/**
* 根据条件进行列表查询
* @param request
* @return
*/
Page searchDgDestructionCatalogList(DgDestructionCatalogSearchRequest request);
/**
* 通过销毁标识码删除档案销毁目录数据
*/
Result deleteDestructionCatalog(String bsmArchives);
/**
* 通过档案标识码删除档案销毁目录数据
*/
Result deleteCatalogByarchiveId(String bsm_archives);
/**
* 通过档案标识码查询档案销毁目录数据
*/
Result getDestructionCatalog(String bsm_archives);
}
package com.pashanhoo.destroycatalog.service.impl;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pashanhoo.common.Result;
import com.pashanhoo.destroycatalog.entity.DgDestructionCatalogConverter;
import com.pashanhoo.destroycatalog.entity.DgDestructionCatalogDO;
import com.pashanhoo.destroycatalog.entity.vo.AddDgDestructionCatalogRequest;
import com.pashanhoo.destroycatalog.entity.vo.DgDestructionCatalogDetailVO;
import com.pashanhoo.destroycatalog.entity.vo.UpdateDgDestructionCatalogRequest;
import com.pashanhoo.destroycatalog.entity.vo.DgDestructionCatalogSearchRequest;
import com.pashanhoo.destroycatalog.mapper.DgDestructionCatalogMapper;
import com.pashanhoo.destroycatalog.service.DgDestructionCatalogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import java.util.ArrayList;
import java.util.List;
/**
* <p>
* 档案销毁目录 服务实现类
* </p>
*
* @author
* @since 2021-11-05
*/
@Service
public class DgDestructionCatalogServiceImpl extends ServiceImpl<DgDestructionCatalogMapper, DgDestructionCatalogDO> implements DgDestructionCatalogService {
@Autowired
private DgDestructionCatalogConverter dgdestructioncatalogConverter;
@Autowired
private DgDestructionCatalogMapper dgdestructioncatalogMapper;
/**
* 新增记录
* @param idList,bsm_destruction
* @return
*/
@Override
public boolean saveBatchDestructionCatalog(List<String> idList, String bsm_destruction) {
List<DgDestructionCatalogDO> list=new ArrayList<DgDestructionCatalogDO>();
DgDestructionCatalogDO catalogDO=null;
for (int i = 0; i < idList.size(); i++) {
catalogDO=new DgDestructionCatalogDO();
catalogDO.setBsmDestructioncatalog(IdWorker.get32UUID());
catalogDO.setBsmDestruction(bsm_destruction);
catalogDO.setBsmArchives(idList.get(i));
list.add(catalogDO);
}
return this.saveBatch(list);
}
/**
* 根据主键查询记录详情
* @param id
* @return
*/
@Override
public DgDestructionCatalogDetailVO getDgDestructionCatalogDetailById(String id) {
DgDestructionCatalogDO dgdestructioncatalogDO = this.getById(id);
return dgdestructioncatalogConverter.do2DetailVO(dgdestructioncatalogDO);
}
/**
* 修改单条记录
* @param request
* @return
*/
@Override
public boolean updateDgDestructionCatalog(UpdateDgDestructionCatalogRequest request) {
DgDestructionCatalogDO dgdestructioncatalogDO = dgdestructioncatalogConverter.updateRequest2DO(request);
return this.updateById(dgdestructioncatalogDO);
}
/**
* 根据条件进行列表查询
* @param request
* @return
*/
@Override
public Page searchDgDestructionCatalogList(DgDestructionCatalogSearchRequest request) {
Page<DgDestructionCatalogDO> pageParam = new Page<DgDestructionCatalogDO>(request.getCurrentPage(), request.getPageSize());
QueryWrapper<DgDestructionCatalogDO> wrapper = new QueryWrapper<>();
//设置默认排序
wrapper = "desc".equals(request.getSortOrder()) ? wrapper.orderByDesc(request.getSortField()) : wrapper.orderByAsc(request.getSortField());
//TODO 根据当前情况设置wrapper条件
Page page = this.page(pageParam, wrapper);
//将查询出来的DO List转为 ListVO List并重新设置到page对象中，并返回page对象
return page.setRecords(dgdestructioncatalogConverter.doList2ListVOList(page.getRecords()));
}
@Override
public Result deleteDestructionCatalog(String bsmArchives) {
QueryWrapper<DgDestructionCatalogDO> wrapper = new QueryWrapper<>();
wrapper.eq(bsmArchives!=null && !"".equals(bsmArchives),"BSM_ARCHIVES",bsmArchives);
int result=dgdestructioncatalogMapper.delete(wrapper);
if(result!=0){
return Result.ok();
}else{
return Result.error("操作失败");
}
}
@Override
public Result deleteCatalogByarchiveId(String bsm_archives) {
QueryWrapper<DgDestructionCatalogDO> wrapper = new QueryWrapper<>();
wrapper.eq(bsm_archives!=null && !"".equals(bsm_archives),"BSM_ARCHIVES",bsm_archives);
int result=dgdestructioncatalogMapper.delete(wrapper);
if(result!=0){
return Result.ok();
}else{
return Result.error("操作失败");
}
}
@Override
public Result getDestructionCatalog(String bsm_archives) {
QueryWrapper<DgDestructionCatalogDO> wrapper = new QueryWrapper<>();
wrapper.eq(bsm_archives!=null && !"".equals(bsm_archives),"BSM_ARCHIVES",bsm_archives);
dgdestructioncatalogMapper.selectOne(wrapper);
return null;
}
}
package com.pashanhoo.dictionary.controller;
import com.github.pagehelper.PageInfo;
import com.pashanhoo.common.Result;
import com.pashanhoo.common.util.TreeUtil;
import com.pashanhoo.dictionary.model.dto.SysDict;
import com.pashanhoo.dictionary.model.vo.EditDictVo;
import com.pashanhoo.dictionary.model.vo.GetSysDictParentVo;
import com.pashanhoo.dictionary.model.vo.SysDictVo;
import com.pashanhoo.dictionary.service.SysDictService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Api(tags = "字典表")
@RestController
@RequestMapping("/SysDict")
public class SysDictController {
@Autowired
SysDictService sysDictService;
@ApiOperation("根据父级编码查询子集编码和名称")
@GetMapping ("getSysDictChildByParentCode")
public Result getSysDictChildByParentCode(@ApiParam("父级编码") @RequestParam String dcode) {
return sysDictService.getSysDictChildByParentCode(dcode);
}
@ApiOperation("获取字典表父级集合")
@PostMapping("getSysDictParent")
public Result<PageInfo<GetSysDictParentVo>> getSysDictParent(@RequestBody SysDictVo request) {
return Result.ok(sysDictService.getSysDictParent(request));
}
@ApiOperation("编辑界面获取指定字典编码子集")
@GetMapping("getSysDictByTypeId")
public Result<List<SysDict>> getSysDictByTypeId(@ApiParam("类型ID") @RequestParam String typeId) {
List<SysDict> dicts = sysDictService.getSysDictByTypeId(typeId);
// TreeUtil.setRule((o1, o2) -> 0, SysDict.class,"DictId");
TreeUtil.setRule(new Comparator<SysDict>() {
@Override
public int compare(SysDict o1, SysDict o2) {
if (o1.getSort() == null) {
o1.setSort((short) 0);
}
if (o2.getSort() == null) {
o2.setSort((short) 0);
}
return o1.getSort() - o2.getSort();
}
},SysDict.class,"DictId");
List<SysDict> tree = TreeUtil.listToTree(dicts, typeId);
return Result.ok(tree);
}
@ApiOperation("编辑")
@PostMapping("editSysDictByTypeId")
public Result editSysDictByTypeId(@RequestBody EditDictVo request) {
int row = sysDictService.editSysDict(request);
if (row != 0) {
return Result.ok("修改成功");
} else {
return Result.ok("修改失败");
}
}
@ApiOperation("返回json")
@GetMapping("getJson")
public Result getJson() {
List<SysDict> dicts = sysDictService.selectAll();
TreeUtil.setRule(new Comparator<SysDict>() {
@Override
public int compare(SysDict o1, SysDict o2) {
if (o1.getSort() == null) {
o1.setSort((short) 0);
}
if (o2.getSort() == null) {
o2.setSort((short) 0);
}
return o1.getSort() - o2.getSort();
}
}, SysDict.class, "DictId");
List<SysDict> tree = TreeUtil.listToTree(dicts, null);
Map<String, List<SysDict>> map = new HashMap<>();
for (SysDict SYSDICT : tree) {
map.put(SYSDICT.getDcode(), SYSDICT.getChildren());
}
return Result.ok(map);
}
}
package com.pashanhoo.dictionary.dao;
import com.pashanhoo.dictionary.model.dto.SysDict;
import com.pashanhoo.dictionary.model.vo.GetSysDictParentVo;
import com.pashanhoo.dictionary.model.vo.SysDictVo;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
@Mapper
public interface SysDictMapper {
/**
* delete by primary key
*
* @param dictid primaryKey
* @return deleteCount
*/
int deleteByPrimaryKey(String dictid);
/**
* insert record to table
*
* @param record the record
* @return insert count
*/
int insert(SysDict record);
/**
* insert record to table selective
*
* @param record the record
* @return insert count
*/
int insertSelective(SysDict record);
/**
* select by primary key
*
* @param dictid primary key
* @return object by primary key
*/
SysDict selectByPrimaryKey(String dictid);
/**
* update record selective
*
* @param record the updated record
* @return update count
*/
int updateByPrimaryKeySelective(SysDict record);
/**
* update record
*
* @param record the updated record
* @return update count
*/
int updateByPrimaryKey(SysDict record);
int updateBatch(List<SysDict> list);
int updateBatchSelective(List<SysDict> list);
int batchInsert(@Param("list") List<SysDict> list);
List<GetSysDictParentVo> getSysDictParent(@Param("request") SysDictVo request);
List<SysDict> getSysDictByTypeId(@Param("typeId") String typeId);
int deleteListByPrimaryKey(@Param("dictWithoutParent") List<SysDict> dictWithoutParent);
List<SysDict> selectAll();
int deleteByTypeId(@Param("typeid") String typeid);
List<SysDict> getSysDictChildByParentCode(@Param("dcode") String dcode);
}
package com.pashanhoo.dictionary.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
import java.util.List;
/**
* 字典表
*/
@ApiModel(value = "extraction-model-SysDict")
@Data
public class SysDict implements Serializable {
/**
* 字典主键
*/
@ApiModelProperty(value = "字典主键")
private String dictId;
/**
* 父级ID
*/
@ApiModelProperty(value = "父级ID")
private String parentId;
/**
* 字典编码
*/
@ApiModelProperty(value = "字典编码")
private String dcode;
/**
* 字典名称
*/
@ApiModelProperty(value = "字典名称")
private String dname;
/**
* 排序号
*/
@ApiModelProperty(value = "排序号")
private Short sort;
/**
* 是否树形
*/
@ApiModelProperty(value = "是否树形")
private String isTree;
/**
* 类型ID
*/
@ApiModelProperty(value = "类型ID")
private String typeId;
/**
* 状态（0:禁用 1:启用）默认1
*/
@ApiModelProperty(value = "状态（0:禁用 1:启用）默认1")
private String state;
private List<SysDict> children;
private static final long serialVersionUID = 1L;
}
package com.pashanhoo.dictionary.model.vo;
import com.pashanhoo.dictionary.model.dto.SysDict;
import io.swagger.annotations.ApiModel;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.List;
@Data
@ApiModel("字典表编辑请求实体")
@EqualsAndHashCode(callSuper = false)
public class EditDictVo {
List<SysDict> editDicts;
}
package com.pashanhoo.dictionary.model.vo;
import com.pashanhoo.dictionary.model.dto.SysDict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.List;
@Data
@ApiModel("获取字典表父级集合实体")
@EqualsAndHashCode(callSuper = false)
public class GetSysDictParentVo {
/**
* 字典主键
*/
@ApiModelProperty(value = "字典主键")
private String dictId;
/**
* 父级ID
*/
@ApiModelProperty(value = "父级ID")
private String parentId;
/**
* 字典编码
*/
@ApiModelProperty(value = "字典编码")
private String dcode;
/**
* 字典名称
*/
@ApiModelProperty(value = "字典名称")
private String dname;
/**
* 排序号
*/
@ApiModelProperty(value = "排序号")
private Short sort;
/**
* 是否树形
*/
@ApiModelProperty(value = "是否树形")
private String isTree;
/**
* 类型ID
*/
@ApiModelProperty(value = "类型ID")
private String typeId;
/**
* 序号
*/
@ApiModelProperty(value = "序号")
private Integer rowNum;
/**
* 状态（0:禁用 1:启用）默认1
*/
@ApiModelProperty(value = "状态（0:禁用 1:启用）默认1")
private String state;
private List<SysDict> children;
private static final long serialVersionUID = 1L;
}
package com.pashanhoo.dictionary.model.vo;
import com.pashanhoo.common.PageInfo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
@Data
@ApiModel("字典表请求实体")
@EqualsAndHashCode(callSuper = false)
public class SysDictVo extends PageInfo implements Serializable {
/**
* 字典编码
*/
@ApiModelProperty(value = "字典编码")
private String dcode;
/**
* 字典名称
*/
@ApiModelProperty(value = "字典名称")
private String dname;
/**
* 类型ID
*/
@ApiModelProperty(value = "类型ID")
private String typeId;
}
package com.pashanhoo.dictionary.service;
import com.github.pagehelper.PageInfo;
import com.pashanhoo.common.Result;
import com.pashanhoo.dictionary.model.dto.SysDict;
import com.pashanhoo.dictionary.model.vo.EditDictVo;
import com.pashanhoo.dictionary.model.vo.GetSysDictParentVo;
import com.pashanhoo.dictionary.model.vo.SysDictVo;
import java.util.List;
public interface SysDictService {
/**
* 删除
* @param dictid
* @return
*/
int deleteByPrimaryKey(String dictid);
/**
* 插入
* @param record
* @return
*/
int insert(SysDict record);
/**
* 插入
* @param record
* @return
*/
int insertSelective(SysDict record);
/**
* 查询
* @param dictid
* @return
*/
SysDict selectByPrimaryKey(String dictid);
/**
* 更新
* @param record
* @return
*/
int updateByPrimaryKeySelective(SysDict record);
/**
* 更新
* @param record
* @return
*/
int updateByPrimaryKey(SysDict record);
/**
* 批量更新
* @param list
* @return
*/
int updateBatch(List<SysDict> list);
/**
* 批量更新
* @param list
* @return
*/
int updateBatchSelective(List<SysDict> list);
/**
* 批量插入
* @param list
* @return
*/
int batchInsert(List<SysDict> list);
/**
* 获取父级字典表
* @param request
* @return
*/
PageInfo<GetSysDictParentVo> getSysDictParent(SysDictVo request);
/**
* 根据typeId查询
* @param typeId
* @return
*/
List<SysDict> getSysDictByTypeId(String typeId);
/**
* 编辑字典表
* @param request
* @return
*/
int editSysDict(EditDictVo request);
/**
* 查询全部
* @return
*/
List<SysDict> selectAll();
/**
* 根据复机编码查询子集编码和名称
* @param dcode
* @return
*/
Result getSysDictChildByParentCode(String dcode);
}
package com.pashanhoo.dictionary.service.impl;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.pashanhoo.common.Result;
import com.pashanhoo.dictionary.dao.SysDictMapper;
import com.pashanhoo.dictionary.model.dto.SysDict;
import com.pashanhoo.dictionary.model.vo.EditDictVo;
import com.pashanhoo.dictionary.model.vo.GetSysDictParentVo;
import com.pashanhoo.dictionary.model.vo.SysDictVo;
import com.pashanhoo.dictionary.service.SysDictService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
@Service
public class SysDictServiceImpl implements SysDictService {
@Resource
private SysDictMapper sysDictMapper;
/**
* 查询
* @param dictid
* @return
*/
@Override
public int deleteByPrimaryKey(String dictid) {
return sysDictMapper.deleteByPrimaryKey(dictid);
}
/**
* 插入
* @param record
* @return
*/
@Override
public int insert(SysDict record) {
return sysDictMapper.insert(record);
}
/**
* 插入
* @param record
* @return
*/
@Override
public int insertSelective(SysDict record) {
return sysDictMapper.insertSelective(record);
}
/**
* 查询
* @param dictid
* @return
*/
@Override
public SysDict selectByPrimaryKey(String dictid) {
return sysDictMapper.selectByPrimaryKey(dictid);
}
/**
* 更新
* @param record
* @return
*/
@Override
public int updateByPrimaryKeySelective(SysDict record) {
return sysDictMapper.updateByPrimaryKeySelective(record);
}
/**
* 更新
* @param record
* @return
*/
@Override
public int updateByPrimaryKey(SysDict record) {
return sysDictMapper.updateByPrimaryKey(record);
}
/**
* 批量更新
* @param list
* @return
*/
@Override
public int updateBatch(List<SysDict> list) {
return sysDictMapper.updateBatch(list);
}
/**
* 批量更新
* @param list
* @return
*/
@Override
public int updateBatchSelective(List<SysDict> list) {
return sysDictMapper.updateBatchSelective(list);
}
/**
* 批量插入
* @param list
* @return
*/
@Override
public int batchInsert(List<SysDict> list) {
return sysDictMapper.batchInsert(list);
}
/**
* 获取父级字典表
* @param request
* @return
*/
@Override
public PageInfo<GetSysDictParentVo> getSysDictParent(SysDictVo request) {
PageHelper.startPage(request.getCurrentPage(), request.getPageSize());
List<GetSysDictParentVo> list = sysDictMapper.getSysDictParent(request);
return new PageInfo<>(list);
}
/**
* 根据typeId查询字典表
* @param typeId
* @return
*/
@Override
public List<SysDict> getSysDictByTypeId(String typeId) {
return sysDictMapper.getSysDictByTypeId(typeId);
}
/**
* root节点只做更新,子节点全部删除再批量插入
* @param request
* @return
*/
@Override
@Transactional(rollbackFor = Exception.class)
public int editSysDict(EditDictVo request) {
List<SysDict> editDicts = request.getEditDicts();
List<SysDict> parent = editDicts.stream().filter(item -> item.getParentId() == null).collect(Collectors.toList());
sysDictMapper.updateByPrimaryKey(parent.get(0));
List<SysDict> dictWithoutParent = editDicts.stream().filter(item -> item.getParentId() != null).collect(Collectors.toList());
List<SysDict> result = new ArrayList<>();
//递归所有子集
List<SysDict> resultList = getAllSysDict(dictWithoutParent,result);
//删除除了根目录的所有子集
sysDictMapper.deleteByTypeId(resultList.get(0).getTypeId());
return sysDictMapper.batchInsert(resultList);
}
/**
* 查询所有字典表
* @return
*/
@Override
public List<SysDict> selectAll() {
return sysDictMapper.selectAll();
}
@Override
public Result getSysDictChildByParentCode(String dcode) {
List<SysDict> list=sysDictMapper.getSysDictChildByParentCode(dcode);
return Result.ok(list);
}
private List<SysDict> getAllSysDict(List<SysDict> dicts, List<SysDict> result) {
for (SysDict SYSDICT : dicts) {
List<SysDict> children = SYSDICT.getChildren();
result.add(SYSDICT);
if (children != null) {
getAllSysDict(children, result);
}
}
return result;
}
}
package com.pashanhoo.file.controller;
import cn.hutool.core.util.StrUtil;
import com.pashanhoo.common.Result;
import com.pashanhoo.file.entity.vo.AddDgFileRequest;
import com.pashanhoo.file.entity.vo.DgCatalogWithFileVO;
import com.pashanhoo.file.entity.vo.UpdateDgFileRequest;
import com.pashanhoo.file.service.DgFileService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.util.List;
/**
* <p>
* 档案文件信息 前端控制器
* </p>
*
* @author
* @since 2021-11-05
*/
@RestController
@RequestMapping("/system/dgFile/")
@Api(tags = "档案文件信息接口")
public class DgFileController {
@Autowired
private DgFileService dgfileService;
@PostMapping("insertDgFile")
@ApiOperation("新增档案文件信息")
public Result insertDgFile(@RequestBody List<AddDgFileRequest> request) {
if (dgfileService.insertDgFile(request)) {
return Result.ok();
}
return Result.error("新增失败");
}
@DeleteMapping("deleteDgFileByIds")
@ApiOperation(value = "批量删除档案文件信息和附件")
public Result deleteDgFileByIds(@ApiParam("档案文件信息ID列表") @RequestBody List<String> bsmFileList) {
try {
if (dgfileService.deleteFile(bsmFileList)) {
return Result.ok("删除成功");
}
} catch (Exception e) {
return Result.exception(e.getMessage());
}
return Result.error("删除失败");
}
@PutMapping("updateDgFile")
@ApiOperation("修改档案文件信息")
public Result updateDgFile(@RequestBody UpdateDgFileRequest request) {
if (dgfileService.updateDgFile(request)) {
return Result.ok("修改成功");
}
return Result.error("修改失败");
}
@GetMapping("getDgFileDetailById")
@ApiOperation(value = "获取附件列表")
public Result<List<DgCatalogWithFileVO>> getDgFileDetailById(@ApiParam("档案标识码") @RequestParam String bsmArchive) {
return Result.ok(dgfileService.getFileList(bsmArchive));
}
@PutMapping("updateFileSort")
@ApiOperation("附件排序")
public Result updateFileSort(@RequestBody List<UpdateDgFileRequest> requests) {
if (dgfileService.updateFileSort(requests)) {
return Result.ok("修改成功");
}
return Result.error("修改失败");
}
@RequestMapping(value = "/upload", method = RequestMethod.POST)
@ApiOperation("上传材料附件")
public Result upload(@RequestPart("file") MultipartFile file, AddDgFileRequest fileRequest) {
if (StrUtil.isEmpty(fileRequest.getBsmArchive()) || StrUtil.isEmpty(fileRequest.getBsmCatalog())) {
return Result.error("请先新增档案基本信息和目录");
}
try {
return Result.ok(dgfileService.upload(file, fileRequest));
} catch (Exception e) {
return Result.exception(e.getMessage());
}
}
}
package com.pashanhoo.file.entity;
import java.util.List;
import com.pashanhoo.file.entity.vo.AddDgFileRequest;
import com.pashanhoo.file.entity.vo.DgFileDetailVO;
import com.pashanhoo.file.entity.vo.DgFileListVO;
import com.pashanhoo.file.entity.vo.UpdateDgFileRequest;
import org.mapstruct.Mapper;
/**
* @author
* @since 2021-11-05
*/
@Mapper(componentModel = "spring")
public interface DgFileConverter{
DgFileDO addRequest2DO(AddDgFileRequest request);
DgFileDetailVO do2DetailVO(DgFileDO dgfileDO);
DgFileDO updateRequest2DO(UpdateDgFileRequest request);
DgFileListVO do2ListVO(DgFileDO dgfileDO);
List<DgFileListVO> doList2ListVOList(List<DgFileDO> dgfileDOList);
List<DgFileDO> voList2ListDO(List<AddDgFileRequest> addDgFileRequestList);
List<DgFileDO> updateList2DOList(List<UpdateDgFileRequest> requests);
}
package com.pashanhoo.file.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案文件信息
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("DG_FILE")
public class DgFileDO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 文件标识码
*/
@TableId(value = "BSM_FILE", type = IdType.UUID)
private String bsmFile;
/**
* 目录标识码
*/
@TableField("BSM_CATALOG")
private String bsmCatalog;
/**
* 文件类型
*/
@TableField("KZM")
private String kzm;
/**
* 上传日期
*/
@TableField("SCRQ")
private Date scrq;
/**
* 上传人
*/
@TableField("SCR")
private String scr;
/**
* 附件路径
*/
@TableField("FJURL")
private String fjurl;
/**
* 附件大小
*/
@TableField("FJSIZE")
private String fjsize;
/**
* 序号
*/
@TableField("XH")
private Integer xh;
}
package com.pashanhoo.file.entity.vo;
import java.util.Date;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.TableField;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案文件信息新增请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案文件信息新增请求实体")
public class AddDgFileRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 目录标识码
*/
@ApiModelProperty(name = "bsmCatalog", value = "目录标识码")
private String bsmCatalog;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchive", value = "档案标识码")
private String bsmArchive;
/**
* 文件类型
*/
@ApiModelProperty(name = "kzm", value = "文件类型")
private String kzm;
/**
* 上传日期
*/
@ApiModelProperty(name = "scrq", value = "上传日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date scrq;
/**
* 上传人
*/
@ApiModelProperty(name = "scr", value = "上传人")
private String scr;
/**
* 附件路径
*/
@ApiModelProperty(name = "fjurl", value = "附件路径")
private String fjurl;
/**
* 附件大小
*/
@ApiModelProperty(name = "fjsize", value = "附件大小")
private String fjsize;
/**
* 序号
*/
@ApiModelProperty(name = "xh", value = "序号")
private Integer xh;
}
package com.pashanhoo.file.entity.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.List;
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案目录对应文件信息列表VO")
public class DgCatalogWithFileVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchive", value = "档案标识码")
private String bsmArchive;
/**
* 目录标识码
*/
@ApiModelProperty(name = "bsmCatalog", value = "目录标识码")
private String bsmCatalog;
/**
* 文件名称
*/
@ApiModelProperty(name = "wjmc", value = "档案目录信息")
private String wjmc;
/**
* 序号
*/
@ApiModelProperty(name = "catalogXh", value = "目录序号")
private Integer catalogXh;
/**
* 档案文件信息列表VO
*/
@ApiModelProperty(name = "fileLists", value = "档案文件信息列表VO")
private List<DgFileListVO> fileLists;
}
package com.pashanhoo.file.entity.vo;
import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案文件信息明细实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案文件信息明细实体")
public class DgFileDetailVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 文件标识码
*/
@ApiModelProperty(name = "bsmFile", value = "文件标识码")
private String bsmFile;
/**
* 目录标识码
*/
@ApiModelProperty(name = "bsmCatalog", value = "目录标识码")
private String bsmCatalog;
/**
* 文件类型
*/
@ApiModelProperty(name = "kzm", value = "文件类型")
private String kzm;
/**
* 上传日期
*/
@ApiModelProperty(name = "scrq", value = "上传日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date scrq;
/**
* 上传人
*/
@ApiModelProperty(name = "scr", value = "上传人")
private String scr;
/**
* 附件路径
*/
@ApiModelProperty(name = "fjurl", value = "附件路径")
private String fjurl;
/**
* 附件大小
*/
@ApiModelProperty(name = "fjsize", value = "附件大小")
private String fjsize;
/**
* 序号
*/
@ApiModelProperty(name = "xh", value = "序号")
private Integer xh;
}
package com.pashanhoo.file.entity.vo;
import java.util.Date;
import java.io.Serializable;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案文件信息列表VO
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案文件信息列表VO")
public class DgFileListVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 文件标识码
*/
@ApiModelProperty(name = "bsmFile", value = "文件标识码")
private String bsmFile;
/**
* 目录标识码
*/
@ApiModelProperty(name = "bsmCatalog", value = "目录标识码")
private String bsmCatalog;
/**
* 文件类型
*/
@ApiModelProperty(name = "kzm", value = "文件类型")
private String kzm;
/**
* 上传日期
*/
@ApiModelProperty(name = "scrq", value = "上传日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date scrq;
/**
* 上传人
*/
@ApiModelProperty(name = "scr", value = "上传人")
private String scr;
/**
* 附件路径
*/
@ApiModelProperty(name = "fjurl", value = "附件路径")
private String fjurl;
/**
* 附件大小
*/
@ApiModelProperty(name = "fjsize", value = "附件大小")
private String fjsize;
/**
* 序号
*/
@ApiModelProperty(name = "xh", value = "序号")
private Integer xh;
/**
* 存储url
*/
@ApiModelProperty(name = "saveUrl", value = "存储url")
private String saveUrl;
}
package com.pashanhoo.file.entity.vo;
import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import com.pashanhoo.common.PageInfo;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案文件信息列表查询请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案文件信息列表查询请求实体")
public class DgFileSearchRequest extends PageInfo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 文件标识码
*/
@ApiModelProperty(name = "bsmFile", value = "文件标识码")
private String bsmFile;
/**
* 目录标识码
*/
@ApiModelProperty(name = "bsmCatalog", value = "目录标识码")
private String bsmCatalog;
/**
* 文件类型
*/
@ApiModelProperty(name = "kzm", value = "文件类型")
private String kzm;
/**
* 上传日期
*/
@ApiModelProperty(name = "scrq", value = "上传日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date scrq;
/**
* 上传人
*/
@ApiModelProperty(name = "scr", value = "上传人")
private String scr;
/**
* 附件路径
*/
@ApiModelProperty(name = "fjurl", value = "附件路径")
private String fjurl;
/**
* 附件大小
*/
@ApiModelProperty(name = "fjsize", value = "附件大小")
private String fjsize;
/**
* 序号
*/
@ApiModelProperty(name = "xh", value = "序号")
private Integer xh;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
}
package com.pashanhoo.file.entity.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="文件上传实体")
public class FileAttribute implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 文件名
*/
@ApiModelProperty(name = "fileName", value = "文件名")
private String fileName;
/**
* 文件大小
*/
@ApiModelProperty(name = "fileSize", value = "文件大小")
private String fileSize;
/**
* 文件存储url
*/
@ApiModelProperty(name = "saveUrl", value = "文件url")
private String saveUrl;
/**
* 下载URL
*/
@ApiModelProperty(name = "previewUrl", value = "下载URL")
private String previewUrl;
/**
* 扩展名
*/
@ApiModelProperty(name = "expandName", value = "扩展名")
private String expandName;
}
package com.pashanhoo.file.entity.vo;
import java.util.Date;
import java.io.Serializable;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案文件信息修改请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案文件信息修改请求实体")
public class UpdateDgFileRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 文件标识码
*/
@ApiModelProperty(name = "bsmFile", value = "文件标识码")
private String bsmFile;
/**
* 目录标识码
*/
@ApiModelProperty(name = "bsmCatalog", value = "目录标识码")
private String bsmCatalog;
/**
* 文件类型
*/
@ApiModelProperty(name = "kzm", value = "文件类型")
private String kzm;
/**
* 上传日期
*/
@ApiModelProperty(name = "scrq", value = "上传日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date scrq;
/**
* 上传人
*/
@ApiModelProperty(name = "scr", value = "上传人")
private String scr;
/**
* 附件路径
*/
@ApiModelProperty(name = "fjurl", value = "附件路径")
private String fjurl;
/**
* 附件大小
*/
@ApiModelProperty(name = "fjsize", value = "附件大小")
private String fjsize;
/**
* 序号
*/
@ApiModelProperty(name = "xh", value = "序号")
private Integer xh;
}
package com.pashanhoo.file.entity.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="附件列表排序修改实体")
public class UpdateFileSortRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 目录标识码
*/
@ApiModelProperty(name = "bsmCatalog", value = "目录标识码")
private String bsmCatalog;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 序号
*/
@ApiModelProperty(name = "xh", value = "序号")
private Integer xh;
}
package com.pashanhoo.file.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.pashanhoo.file.entity.DgFileDO;
import com.pashanhoo.file.entity.vo.DgCatalogWithFileVO;
import com.pashanhoo.file.entity.vo.UpdateDgFileRequest;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* <p>
* 档案文件信息 Mapper 接口
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgFileMapper extends BaseMapper<DgFileDO> {
/**
* 获取附件列表
*
* @param bsmArchive
* @return
*/
List<DgCatalogWithFileVO> getFileList(@Param("bsmArchive") String bsmArchive);
List<DgFileDO> getFilesById(@Param("bsmFiles") List<String> bsmFiles);
}
package com.pashanhoo.file.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.pashanhoo.file.entity.DgFileDO;
import com.pashanhoo.file.entity.vo.*;
import org.springframework.web.multipart.MultipartFile;
import java.util.List;
/**
* <p>
* 档案文件信息 服务类
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgFileService extends IService<DgFileDO> {
/**
* 新增记录
* @param request
* @return
*/
boolean insertDgFile(List<AddDgFileRequest> request);
/**
* 根据主键查询记录详情
* @param id
* @return
*/
DgFileDetailVO getDgFileDetailById(String id);
/**
* 修改单条记录
* @param request
* @return
*/
boolean updateDgFile(UpdateDgFileRequest request);
/**
* 获取附件列表
* @param bsmArchive
* @return
*/
List<DgCatalogWithFileVO> getFileList(String bsmArchive);
/**
* 修改文件排序
* @param requests
* @return
*/
boolean updateFileSort(List<UpdateDgFileRequest> requests);
/**
* 批量删除档案文件信息
* @param bsmFileList
* @return
*/
boolean deleteFile(List<String> bsmFileList) throws Exception;
/**
* 上传材料附件.材料附件信息入库
* @param file
* @param fileRequest
* @return
*/
List<DgCatalogWithFileVO> upload(MultipartFile file, AddDgFileRequest fileRequest) throws Exception;
}
package com.pashanhoo.file.service.impl;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pashanhoo.common.util.fileupload.MinioConfig;
import com.pashanhoo.common.util.fileupload.MinioUtil;
import com.pashanhoo.file.entity.DgFileConverter;
import com.pashanhoo.file.entity.DgFileDO;
import com.pashanhoo.file.entity.vo.*;
import com.pashanhoo.file.mapper.DgFileMapper;
import com.pashanhoo.file.service.DgFileService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import java.util.List;
import java.util.stream.Collectors;
/**
* <p>
* 档案文件信息 服务实现类
* </p>
*
* @author
* @since 2021-11-05
*/
@Service
public class DgFileServiceImpl extends ServiceImpl<DgFileMapper, DgFileDO> implements DgFileService {
@Autowired
private DgFileConverter dgfileConverter;
@Autowired
private DgFileMapper dgfileMapper;
@Autowired
MinioUtil minioUtil;
@Autowired
MinioConfig minioConfig;
/**
* 新增记录
* @param request
* @return
*/
@Override
public boolean insertDgFile(List<AddDgFileRequest> request) {
List<DgFileDO> dgFileDOS = dgfileConverter.voList2ListDO(request);
return this.saveBatch(dgFileDOS);
}
/**
* 根据主键查询记录详情
* @param id
* @return
*/
@Override
public DgFileDetailVO getDgFileDetailById(String id) {
DgFileDO dgfileDO = this.getById(id);
DgFileDetailVO dgFileDetailVO = dgfileConverter.do2DetailVO(dgfileDO);
String previewUrl = minioUtil.getPreviewUrl(dgFileDetailVO.getFjurl());
dgFileDetailVO.setFjurl(previewUrl);
return dgFileDetailVO;
}
/**
* 修改单条记录
* @param request
* @return
*/
@Override
public boolean updateDgFile(UpdateDgFileRequest request) {
DgFileDO dgfileDO = dgfileConverter.updateRequest2DO(request);
return this.updateById(dgfileDO);
}
/**
* 获取附件列表
* @param bsmArchive
* @return
*/
@Override
public List<DgCatalogWithFileVO> getFileList(String bsmArchive) {
List<DgCatalogWithFileVO> fileList = dgfileMapper.getFileList(bsmArchive);
fileList.forEach(item->item.getFileLists().forEach(file->file.setSaveUrl(file.getFjurl())));
fileList.forEach(catalogWithFiles->catalogWithFiles.getFileLists().forEach(file->file.setFjurl(minioUtil.getPreviewUrl(file.getFjurl()))));
return fileList;
}
/**
* 修改文件排序
*
* @param requests
* @return
*/
@Override
public boolean updateFileSort(List<UpdateDgFileRequest> requests) {
List<DgFileDO> fileList = dgfileConverter.updateList2DOList(requests);
return this.updateBatchById(fileList);
}
/**
* 批量删除档案文件信息
* @param bsmFileList
* @return
*/
@Override
public boolean deleteFile(List<String> bsmFileList) throws Exception {
//删除minio文件
List<DgFileDO> fileDOList = dgfileMapper.getFilesById(bsmFileList);
List<String> urls = fileDOList.stream().map(DgFileDO::getFjurl).collect(Collectors.toList());
for (String url : urls) {
minioUtil.removeObject(minioConfig.getBucket(), url);
}
//删除数据库记录
return this.removeByIds(bsmFileList);
}
/**
* 上传材料附件.材料附件信息入库
*
* @param uploadFile
* @param fileRequest
* @return
*/
@Override
@Transactional(rollbackFor = Exception.class)
public List<DgCatalogWithFileVO> upload(MultipartFile uploadFile, AddDgFileRequest fileRequest) throws Exception {
//文件上传
FileAttribute fileAttribute = minioUtil.upload(uploadFile);
Integer firstXh = fileRequest.getXh();
//如果序号不为空
if (!StrUtil.isEmptyIfStr(firstXh)) {
String firstBsmCatalog = fileRequest.getBsmCatalog();
QueryWrapper<DgFileDO> fileWrapper = new QueryWrapper<>();
//重新排序
fileWrapper.lambda().eq(DgFileDO::getBsmCatalog, firstBsmCatalog).ge(DgFileDO::getXh, firstXh + 1);
List<DgFileDO> list = this.list(fileWrapper);
list.forEach(item -> item.setXh(item.getXh() + 1));
this.updateBatchById(list);
}
//文件信息入库
DgFileDO fileDO = new DgFileDO();
fileDO.setBsmCatalog(fileRequest.getBsmCatalog());
fileDO.setFjurl(fileAttribute.getSaveUrl());
fileDO.setFjsize(fileAttribute.getFileSize());
fileDO.setKzm(fileAttribute.getExpandName());
fileDO.setScrq(DateTime.now());
fileDO.setScr(null);
if (StrUtil.isEmptyIfStr(firstXh)) {
fileDO.setXh(1);
}else {
fileDO.setXh(firstXh + 1);
}
this.save(fileDO);
List<DgCatalogWithFileVO> fileList = dgfileMapper.getFileList(fileRequest.getBsmArchive());
if (fileList.size() > 0) {
fileList.forEach(item->item.getFileLists().forEach(file->file.setSaveUrl(file.getFjurl())));
fileList.forEach(catalogWithFiles->catalogWithFiles.getFileLists().forEach(file->file.setFjurl(minioUtil.getPreviewUrl(file.getFjurl()))));
}
return fileList;
}
}
package com.pashanhoo.lend.controller;
import com.pashanhoo.common.Result;
import com.pashanhoo.lend.entity.vo.AddDgLendRequest;
import com.pashanhoo.lend.entity.vo.ArchiveLendSearchRequest;
import com.pashanhoo.lend.entity.vo.DgLendSearchRequest;
import com.pashanhoo.lend.entity.vo.UpdateDgLendRequest;
import com.pashanhoo.lend.service.DgLendService;
import com.pashanhoo.lendcatalog.entity.vo.AddDgLendCatalogRequest;
import com.pashanhoo.lendfile.entity.vo.AddDgLendFileRequest;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* <p>
* 档案借阅 前端控制器
* </p>
*
* @author
* @since 2021-11-05
*/
@RestController
@RequestMapping("/system/dgLend/")
@Api(tags = "档案借阅接口")
public class DgLendController {
@Autowired
private DgLendService dglendService;
@PostMapping("search")
@ApiOperation(value = "根据条件进行列表查询")
public Result searchDgLendList(@RequestBody DgLendSearchRequest request) {
return dglendService.searchDgLendList(request);
}
@PostMapping("deleteDanganJyInfo")
@ApiOperation("通过借阅标识码删除借阅记录信息")
public Result deleteDanganJyInfo(@ApiParam("档案借阅记录ID") @RequestParam String lendBsm){
return dglendService.deleteDanganJyInfo(lendBsm);
}
@PostMapping("danganGh")
@ApiOperation("档案归还")
public Result danganGh(@RequestBody UpdateDgLendRequest ghRequest){
return dglendService.danganGh(ghRequest);
}
@PostMapping("showArchivesForLend")
@ApiOperation("展示可以选择借阅的列表")
public Result showArchivesForLend(@RequestBody ArchiveLendSearchRequest request) {
return dglendService.showArchivesForLend(request);
}
@PostMapping("insertDgLend")
@ApiOperation("新增档案借阅")
public Result insertDgLend(@RequestBody AddDgLendRequest request){
if(dglendService.insertDgLend(request)){
return Result.ok();
}
return Result.error("新增失败");
}
@PostMapping("addLendArchivesInfo")
@ApiOperation(value = "选择要借阅档案List")
public Result addLendArchivesInfo(@RequestBody List<AddDgLendCatalogRequest> archivesList) {
return dglendService.addDestructionArchivesInfo(archivesList);
}
@PostMapping("insertDanganJyFile")
@ApiOperation("批量借阅文件信息")
public Result insertDanganJyFile(@RequestBody List<AddDgLendFileRequest> request){
return dglendService.insertDanganJyFile(request);
}
@PostMapping("queryArchivesInfo")
@ApiOperation(value = "档案列表信息展示")
public Result queryArchivesInfo(@ApiParam("档案借阅记录ID") @RequestParam(value = "bsm_lend") String bsm_lend) {
return dglendService.queryArchivesInfo(bsm_lend);
}
@GetMapping("deleteArchivesInfo")
@ApiOperation(value = "删除档案列表中的档案信息")
public Result deleteArchivesInfo(@ApiParam("档案ID") @RequestParam(value = "bsm_lendcatalog") String bsm_lendcatalog) {
return dglendService.deleteArchivesInfo(bsm_lendcatalog);
}
@GetMapping("getDgLendDetailById")
@ApiOperation(value = "读取明细")
public Result getDgLendDetailById(@ApiParam("档案借阅ID") @RequestParam String id){
return Result.ok(dglendService.getDgLendDetailById(id));
}
@PostMapping("updateDgLend")
@ApiOperation("修改档案借阅")
public Result updateDgLend(@RequestBody UpdateDgLendRequest request){
if(dglendService.updateDgLend(request)) {
return Result.ok("修改成功");
}
return Result.error("修改失败");
}
@PostMapping("updateStateByArchives")
@ApiOperation(value = "新增档案借阅列表中的借阅操作")
public Result updateStateByArchives(@ApiParam("档案业务信息ID列表") @RequestParam(value = "idList") List<String> idList) {
return dglendService.updateStateByArchives(idList);
}
@GetMapping("updateArchivesStateByLend")
@ApiOperation(value = "编辑中的借阅操作")
public Result updateArchivesStateByLend(@ApiParam("档案借阅记录ID") @RequestParam(value = "bsm_lend") String bsm_lend) {
return dglendService.updateArchivesStateByLend(bsm_lend);
}
}
package com.pashanhoo.lend.entity;
import java.util.List;
import com.pashanhoo.lend.entity.vo.AddDgLendRequest;
import com.pashanhoo.lend.entity.vo.DgLendDetailVO;
import com.pashanhoo.lend.entity.vo.DgLendListVO;
import com.pashanhoo.lend.entity.vo.UpdateDgLendRequest;
import org.mapstruct.Mapper;
/**
* @author
* @since 2021-11-05
*/
@Mapper(componentModel = "spring")
public interface DgLendConverter{
DgLendDO addRequest2DO(AddDgLendRequest request);
DgLendDetailVO do2DetailVO(DgLendDO dglendDO);
DgLendDO updateRequest2DO(UpdateDgLendRequest request);
DgLendListVO do2ListVO(DgLendDO dglendDO);
List<DgLendListVO> doList2ListVOList(List<DgLendDO> dglendDOList);
}
package com.pashanhoo.lend.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案借阅
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("DG_LEND")
public class DgLendDO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 借阅标识码
*/
@TableId(value = "BSM_LEND", type = IdType.UUID)
private String bsmLend;
/**
* 借阅人
*/
@TableField("JYR")
private String jyr;
/**
* 借阅单位
*/
@TableField("JYDW")
private String jydw;
/**
* 联系电话
*/
@TableField("LXDW")
private String lxdw;
/**
* 通讯地址
*/
@TableField("TXDZ")
private String txdz;
/**
* 借阅日期
*/
@TableField("QSSJ")
private Date qssj;
/**
* 归还日期
*/
@TableField("GHRQ")
private Date ghrq;
/**
* 批准人
*/
@TableField("PZR")
private String pzr;
/**
* 借阅截止日期
*/
@TableField("JZRQ")
private Date jzrq;
/**
* 借出理由
*/
@TableField("JCLY")
private String jcly;
/**
* 利用目的
*/
@TableField("LYMD")
private String lymd;
/**
* 备注
*/
@TableField("BZ")
private String bz;
/**
* 批准时间
*/
@TableField("PZSJ")
private Date pzsj;
/**
* 归还人
*/
@TableField("GHR")
private String ghr;
/**
* 归还人联系电话
*/
@TableField("GHRDH")
private String ghrdh;
}
package com.pashanhoo.lend.entity.vo;
import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案借阅新增请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案借阅新增请求实体")
public class AddDgLendRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 借阅人
*/
@ApiModelProperty(name = "jyr", value = "借阅人")
private String jyr;
/**
* 借阅单位
*/
@ApiModelProperty(name = "jydw", value = "借阅单位")
private String jydw;
/**
* 联系电话
*/
@ApiModelProperty(name = "lxdw", value = "联系电话")
private String lxdw;
/**
* 通讯地址
*/
@ApiModelProperty(name = "txdz", value = "通讯地址")
private String txdz;
/**
* 借阅日期
*/
@ApiModelProperty(name = "jyrq", value = "借阅日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date jyrq;
/**
* 归还日期
*/
@ApiModelProperty(name = "ghrq", value = "归还日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date ghrq;
/**
* 批准人
*/
@ApiModelProperty(name = "pzr", value = "批准人")
private String pzr;
/**
* 借阅期限
*/
@ApiModelProperty(name = "jyqx", value = "借阅期限")
private String jyqx;
/**
* 借出理由
*/
@ApiModelProperty(name = "jcly", value = "借出理由")
private String jcly;
/**
* 利用目的
*/
@ApiModelProperty(name = "lymd", value = "利用目的")
private String lymd;
/**
* 备注
*/
@ApiModelProperty(name = "bz", value = "备注")
private String bz;
/**
* 批准时间
*/
@ApiModelProperty(name = "pzsj", value = "批准时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date pzsj;
/**
* 归还人
*/
@ApiModelProperty(name = "ghr", value = "归还人")
private String ghr;
/**
* 归还人联系电话
*/
@ApiModelProperty(name = "ghrdh", value = "归还人联系电话")
private String ghrdh;
}
package com.pashanhoo.lend.entity.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="可以借阅的档案列表VO")
public class ArchiveLendInfoRequestVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsm_archives", value = "档案标识码")
private String bsm_archives;
/**
* 档案状态
*/
@ApiModelProperty(name = "dazt", value = "档案状态")
private String dazt;
/**
* 案卷号
*/
@ApiModelProperty(name = "ajh", value = "案卷号")
private String ajh;
/**
* 不动产单元号
*/
@ApiModelProperty(name = "bdcdyh", value = "不动产单元号")
private String bdcdyh;
/**
* 权利类型
*/
@ApiModelProperty(name = "qllx", value = "权利类型")
private String qllx;
/**
* 登记类型
*/
@ApiModelProperty(name = "djlx", value = "登记类型")
private String djlx;
/**
* 权利人
*/
@ApiModelProperty(name = "qlr", value = "权利人")
private String qlr;
/**
* 义务人
*/
@ApiModelProperty(name = "ywr", value = "义务人")
private String ywr;
/**
* 证件号码
*/
@ApiModelProperty(name = "zjhm", value = "证件号码")
private String zjhm;
/**
* 不动产单元数量
*/
@ApiModelProperty(name = "bdcdy_num", value = "不动产单元数量")
private String bdcdy_num;
}
package com.pashanhoo.lend.entity.vo;
import com.pashanhoo.common.PageInfo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="可以借阅的档案列表请求类")
public class ArchiveLendSearchRequest extends PageInfo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 档案号
*/
@ApiModelProperty(name = "ajh", value = "档案号")
private String ajh;
/**
* 业务号
*/
@ApiModelProperty(name = "ywh", value = "业务号")
private String ywh;
/**
* 不动产单元号
*/
@ApiModelProperty(name = "bdcdyh", value = "不动产单元号")
private String bdcdyh;
/**
* 不动产权证号
*/
@ApiModelProperty(name = "zjhm", value = "不动产权证号")
private String zjhm;
/**
* 权利人
*/
@ApiModelProperty(name = "qlr", value = "权利人")
private String qlr;
/**
* 义务人
*/
@ApiModelProperty(name = "ywr", value = "义务人")
private String ywr;
/**
* 查封文号
*/
@ApiModelProperty(name = "cfwh", value = "查封文号")
private String cfwh;
/**
* 权利类型
*/
@ApiModelProperty(name = "qllx", value = "权利类型")
private String qllx;
}
package com.pashanhoo.lend.entity.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
/**
* <p>
* 档案借阅明细实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案借阅明细实体")
public class DgLendDetailVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 借阅标识码
*/
@ApiModelProperty(name = "bsm_lend", value = "借阅标识码")
private String bsm_lend;
/**
* 借阅时效
*/
@ApiModelProperty(name = "jysx", value = "借阅时效")
private String jysx;
/**
* 借阅单号
*/
@ApiModelProperty(name = "jydh", value = "借阅单号")
private String jydh;
/**
* 档案号
*/
@ApiModelProperty(name = "ajh", value = "案卷号")
private String ajh;
/**
* 借阅方式
*/
@ApiModelProperty(name = "jyfs", value = "借阅方式")
private String jyfs;
/**
* 借阅单位
*/
@ApiModelProperty(name = "jydw", value = "借阅单位")
private String jydw;
/**
* 借阅人
*/
@ApiModelProperty(name = "jyr", value = "借阅人")
private String jyr;
/**
* 起始时间
*/
@ApiModelProperty(name = "qssj", value = "起始时间")
private String qssj;
/**
* 截止时间
*/
@ApiModelProperty(name = "jzrq", value = "截止时间")
private String jzrq;
/**
* 归还人
*/
@ApiModelProperty(name = "ghr", value = "归还人")
private String ghr;
/**
* 归还日期
*/
@ApiModelProperty(name = "ghrq", value = "归还日期")
private String ghrq;
/**
* 借阅状态
*/
@ApiModelProperty(name = "jyzt", value = "借阅状态")
private String jyzt;
/**
* 档案数量
*/
@ApiModelProperty(name = "da_num", value = "档案数量")
private String da_num;
}
package com.pashanhoo.lend.entity.vo;
import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案借阅列表VO
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案借阅列表VO")
//TODO 该类属性暂时是完整的全部属性，需进行个性化的增删
public class DgLendListVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 借阅标识码
*/
@ApiModelProperty(name = "bsmLend", value = "借阅标识码")
private String bsmLend;
/**
* 借阅人
*/
@ApiModelProperty(name = "jyr", value = "借阅人")
private String jyr;
/**
* 借阅单位
*/
@ApiModelProperty(name = "jydw", value = "借阅单位")
private String jydw;
/**
* 联系电话
*/
@ApiModelProperty(name = "lxdw", value = "联系电话")
private String lxdw;
/**
* 通讯地址
*/
@ApiModelProperty(name = "txdz", value = "通讯地址")
private String txdz;
/**
* 借阅日期
*/
@ApiModelProperty(name = "jyrq", value = "借阅日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date jyrq;
/**
* 归还日期
*/
@ApiModelProperty(name = "ghrq", value = "归还日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date ghrq;
/**
* 批准人
*/
@ApiModelProperty(name = "pzr", value = "批准人")
private String pzr;
/**
* 借阅期限
*/
@ApiModelProperty(name = "jyqx", value = "借阅期限")
private String jyqx;
/**
* 借出理由
*/
@ApiModelProperty(name = "jcly", value = "借出理由")
private String jcly;
/**
* 利用目的
*/
@ApiModelProperty(name = "lymd", value = "利用目的")
private String lymd;
/**
* 备注
*/
@ApiModelProperty(name = "bz", value = "备注")
private String bz;
/**
* 批准时间
*/
@ApiModelProperty(name = "pzsj", value = "批准时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date pzsj;
}
package com.pashanhoo.lend.entity.vo;
import com.pashanhoo.common.PageInfo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
/**
* <p>
* 档案借阅列表查询请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案借阅列表查询请求实体")
public class DgLendSearchRequest extends PageInfo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 档案号
*/
@ApiModelProperty(name = "ajh", value = "档案号")
private String ajh;
/**
* 不动产单元号
*/
@ApiModelProperty(name = "bdcdyh", value = "不动产单元号")
private String bdcdyh;
/**
* 业务号
*/
@ApiModelProperty(name = "ywh", value = "业务号")
private String ywh;
/**
* 不动产权证号
*/
@ApiModelProperty(name = "bdcqzh", value = "不动产权证号")
private String bdcqzh;
/**
* 借阅人
*/
@ApiModelProperty(name = "jyr", value = "借阅人")
private String jyr;
/**
* 借阅状态
*/
@ApiModelProperty(name = "jyzt", value = "借阅状态")
private String jyzt;
}
package com.pashanhoo.lend.entity.vo;
import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案借阅修改请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案借阅修改请求实体")
public class UpdateDgLendRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 借阅标识码
*/
@ApiModelProperty(name = "bsmLend", value = "借阅标识码")
private String bsmLend;
/**
* 借阅人
*/
@ApiModelProperty(name = "jyr", value = "借阅人")
private String jyr;
/**
* 借阅单位
*/
@ApiModelProperty(name = "jydw", value = "借阅单位")
private String jydw;
/**
* 联系电话
*/
@ApiModelProperty(name = "lxdh", value = "联系电话")
private String lxdh;
/**
* 通讯地址
*/
@ApiModelProperty(name = "txdz", value = "通讯地址")
private String txdz;
/**
* 借阅日期
*/
@ApiModelProperty(name = "jyrq", value = "借阅日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date jyrq;
/**
* 归还日期
*/
@ApiModelProperty(name = "ghrq", value = "归还日期")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date ghrq;
/**
* 批准人
*/
@ApiModelProperty(name = "pzr", value = "批准人")
private String pzr;
/**
* 借阅期限
*/
@ApiModelProperty(name = "jyqx", value = "借阅期限")
private String jyqx;
/**
* 借出理由
*/
@ApiModelProperty(name = "jcly", value = "借出理由")
private String jcly;
/**
* 利用目的
*/
@ApiModelProperty(name = "lymd", value = "利用目的")
private String lymd;
/**
* 备注
*/
@ApiModelProperty(name = "bz", value = "备注")
private String bz;
/**
* 批准时间
*/
@ApiModelProperty(name = "pzsj", value = "批准时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date pzsj;
/**
* 归还人
*/
@ApiModelProperty(name = "ghr", value = "归还人")
private String ghr;
/**
* 归还人联系电话
*/
@ApiModelProperty(name = "ghrdh", value = "归还人联系电话")
private String ghrdh;
}
package com.pashanhoo.lend.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.pashanhoo.archive.entity.vo.DgArchivesListVO;
import com.pashanhoo.lend.entity.DgLendDO;
import com.pashanhoo.lend.entity.vo.ArchiveLendInfoRequestVO;
import com.pashanhoo.lend.entity.vo.ArchiveLendSearchRequest;
import com.pashanhoo.lend.entity.vo.DgLendDetailVO;
import com.pashanhoo.lend.entity.vo.DgLendSearchRequest;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* <p>
* 档案借阅 Mapper 接口
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgLendMapper extends BaseMapper<DgLendDO> {
List<DgLendDetailVO> getDanganJyDetail(DgLendSearchRequest request);
boolean updateArchivesStatus(@Param("lendBsm") String lendBsm, @Param("dazt") String dazt);
List<DgArchivesListVO> queryArchivesInfo(@Param("bsm_lend") String bsm_lend);
boolean updateArchivesStatusBatch(@Param("idList") List<String> idList,@Param("dazt") String dazt);
List<ArchiveLendInfoRequestVO> getArchiveLendInfo(ArchiveLendSearchRequest request);
}
package com.pashanhoo.lend.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.pashanhoo.archive.entity.vo.DgArchivesSearchRequest;
import com.pashanhoo.common.Result;
import com.pashanhoo.lend.entity.DgLendDO;
import com.pashanhoo.lend.entity.vo.*;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.pashanhoo.lendcatalog.entity.vo.AddDgLendCatalogRequest;
import com.pashanhoo.lendfile.entity.vo.AddDgLendFileRequest;
import java.util.List;
/**
* <p>
* 档案借阅 服务类
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgLendService extends IService<DgLendDO> {
/**
* 根据条件进行列表查询
* @param request
* @return
*/
Result searchDgLendList(DgLendSearchRequest request);
/**
* 删除借阅记录
* @param lendBsm
* @return
*/
Result deleteDanganJyInfo(String lendBsm);
/**
* 档案归还
*/
Result danganGh(UpdateDgLendRequest ghRequest);
/**
* 展示可以选择借阅的列表
* @param request
* @return
*/
Result showArchivesForLend(ArchiveLendSearchRequest request);
/**
* 新增记录
* @param request
* @return
*/
boolean insertDgLend(AddDgLendRequest request);
/**
* 根据主键查询记录详情
* @param id
* @return
*/
DgLendDetailVO getDgLendDetailById(String id);
/**
* 修改单条记录
* @param request
* @return
*/
boolean updateDgLend(UpdateDgLendRequest request);
/**
* 选择要借阅档案List
* @param archivesList
* @return
*/
Result addDestructionArchivesInfo(List<AddDgLendCatalogRequest> archivesList);
/**
* 根据条件进行列表查询
* @param bsm_lend
* @return
*/
Result queryArchivesInfo(String bsm_lend);
/**
*删除档案列表中的档案信息
*/
Result deleteArchivesInfo(String bsm_lendcatalog);
/**
* 新增档案借阅列表中的借阅操作
* @param idList
* @return
*/
Result updateStateByArchives(List<String> idList);
/**
* 借阅接口
* @param bsm_lend
* @return
*/
Result updateArchivesStateByLend(String bsm_lend);
/**
* 批量借阅文件接口
* @param request
* @return
*/
Result insertDanganJyFile(List<AddDgLendFileRequest> request);
}
package com.pashanhoo.lend.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.pashanhoo.archive.entity.vo.DgArchivesSearchRequest;
import com.pashanhoo.common.Result;
import com.pashanhoo.lend.entity.DgLendConverter;
import com.pashanhoo.lend.entity.DgLendDO;
import com.pashanhoo.lend.entity.vo.*;
import com.pashanhoo.lend.mapper.DgLendMapper;
import com.pashanhoo.lend.service.DgLendService;
import com.pashanhoo.lendcatalog.entity.DgLendCatalogConverter;
import com.pashanhoo.lendcatalog.entity.DgLendCatalogDO;
import com.pashanhoo.lendcatalog.entity.vo.AddDgLendCatalogRequest;
import com.pashanhoo.lendcatalog.entity.vo.UpdateDgLendCatalogRequest;
import com.pashanhoo.lendcatalog.service.DgLendCatalogService;
import com.pashanhoo.lendfile.entity.DgLendFileConverter;
import com.pashanhoo.lendfile.entity.DgLendFileDO;
import com.pashanhoo.lendfile.entity.vo.AddDgLendFileRequest;
import com.pashanhoo.lendfile.service.DgLendFileService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
/**
* <p>
* 档案借阅 服务实现类
* </p>
*
* @author
* @since 2021-11-05
*/
@Service
public class DgLendServiceImpl extends ServiceImpl<DgLendMapper, DgLendDO> implements DgLendService {
@Autowired
private DgLendConverter dglendConverter;
@Autowired
private DgLendCatalogConverter catalogConverter;
@Autowired
private DgLendMapper dglendMapper;
@Autowired
private DgLendCatalogService catalogService;
@Autowired
private DgLendFileService fileService;
@Autowired
private DgLendFileConverter fileConverter;
/**
* 根据条件进行列表查询
* @param request
* @return
*/
@Override
public Result searchDgLendList(DgLendSearchRequest request) {
PageHelper.startPage(request.getCurrentPage(), request.getPageSize());
List<DgLendDetailVO> jyListVOList = dglendMapper.getDanganJyDetail(request);
PageInfo<DgLendDetailVO> pageInfo = new PageInfo<DgLendDetailVO>(jyListVOList);
return Result.ok(pageInfo);
}
@Override
@Transactional(rollbackFor = Exception.class)
public Result deleteDanganJyInfo(String lendBsm) {
//查询销毁记录是否存在，存在则删除
if(getDgLendDetailById(lendBsm)!=null){
dglendMapper.deleteById(lendBsm);
}
//查询销毁目录记录是否存在，存在则删除
List<String> jnmlList=new ArrayList<String>();
List<DgLendCatalogDO> catalogDOList= (List<DgLendCatalogDO>) catalogService.getJyMlInfo(lendBsm).getResult();
if(catalogDOList!=null){
catalogService.deleteJyMlInfo(lendBsm);
for (int i = 0; i <catalogDOList.size() ; i++) {
jnmlList.add(catalogDOList.get(i).getBsmLendcatalog());
}
}
//查询销毁目录文件记录是否存在，存在则删除
List<DgLendCatalogDO> list= (List<DgLendCatalogDO>) catalogService.getJyFileInfoByjybsm(jnmlList).getResult();
if(list!=null){
catalogService.deleteDanganJyBatch(list);
}
//修改档案信息表状态
dglendMapper.updateArchivesStatus(lendBsm,"4");
return Result.ok();
}
@Override
@Transactional(rollbackFor = Exception.class)
public Result danganGh(UpdateDgLendRequest ghRequest) {
//新增借阅记录表归还信息数据
DgLendDO lendDO=dglendConverter.updateRequest2DO(ghRequest);
dglendMapper.updateById(lendDO);
//修改档案信息表状态
dglendMapper.updateArchivesStatus(ghRequest.getBsmLend(),"4");
return Result.ok();
}
@Override
public Result showArchivesForLend(ArchiveLendSearchRequest request) {
List<ArchiveLendInfoRequestVO> list=dglendMapper.getArchiveLendInfo(request);
return Result.ok(list);
}
/**
* 新增记录
* @param request
* @return
*/
@Override
public boolean insertDgLend(AddDgLendRequest request) {
DgLendDO dglendDO = dglendConverter.addRequest2DO(request);
return this.save(dglendDO);
}
/**
* 根据主键查询记录详情
* @param id
* @return
*/
@Override
public DgLendDetailVO getDgLendDetailById(String id) {
DgLendDO dglendDO = this.getById(id);
return dglendConverter.do2DetailVO(dglendDO);
}
/**
* 修改单条记录
* @param request
* @return
*/
@Override
public boolean updateDgLend(UpdateDgLendRequest request) {
DgLendDO dglendDO = dglendConverter.updateRequest2DO(request);
return this.updateById(dglendDO);
}
@Override
public Result addDestructionArchivesInfo(List<AddDgLendCatalogRequest> archivesList) {
List<DgLendCatalogDO> lendCatalogDOS=catalogConverter.addCataLogListDO(archivesList);
catalogService.saveBatch(lendCatalogDOS);
return Result.ok();
}
@Override
public Result queryArchivesInfo(String bsm_lend) {
return Result.ok(dglendMapper.queryArchivesInfo(bsm_lend));
}
@Override
public Result deleteArchivesInfo(String bsm_lendcatalog) {
//删除目录信息
catalogService.deleteJyMlInfoByDA(bsm_lendcatalog);
//删除目录文件信息
fileService.deleteJyFile(bsm_lendcatalog);
return Result.ok();
}
@Override
public Result updateStateByArchives(List<String> idList) {
dglendMapper.updateArchivesStatusBatch(idList,"8");
return Result.ok();
}
@Override
public Result updateArchivesStateByLend(String bsm_destruction) {
//修改档案信息表状态
dglendMapper.updateArchivesStatus(bsm_destruction,"8");
return Result.ok();
}
@Override
public Result insertDanganJyFile(List<AddDgLendFileRequest> request) {
List<DgLendFileDO> list=fileConverter.addLendFileList(request);
fileService.saveBatch(list);
//通过目录标识修改目录表记录
UpdateDgLendCatalogRequest catalogRequest=new UpdateDgLendCatalogRequest();
catalogRequest.setBsmLendcatalog(request.get(0).getBsmLendcatalog());
catalogRequest.setJycllx(request.get(0).getJycllx());
catalogService.updateDgLendCatalog(catalogRequest);
return Result.ok();
}
}
package com.pashanhoo.lendcatalog.controller;
import com.pashanhoo.common.Result;
import com.pashanhoo.lendcatalog.entity.vo.AddDgLendCatalogRequest;
import com.pashanhoo.lendcatalog.entity.vo.UpdateDgLendCatalogRequest;
import com.pashanhoo.lendcatalog.service.DgLendCatalogService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* <p>
* 档案借阅目录 前端控制器
* </p>
*
* @author
* @since 2021-11-05
*/
@RestController
@RequestMapping("/system/dgLendCatalog/")
@Api(tags = "档案借阅目录接口")
public class DgLendCatalogController {
@Autowired
private DgLendCatalogService dglendcatalogService;
@PostMapping("insertDgLendCatalog")
@ApiOperation("新增档案借阅目录")
public Result insertDgLendCatalog(@RequestBody AddDgLendCatalogRequest request){
if(dglendcatalogService.insertDgLendCatalog(request)){
return Result.ok();
}
return Result.error("新增失败");
}
@DeleteMapping("deleteDgLendCatalogByIds")
@ApiOperation(value = "批量删除档案借阅目录")
public Result deleteDgLendCatalogByIds(@ApiParam("档案借阅目录ID列表") @RequestParam(value = "idList") List<String> idList) {
if(dglendcatalogService.removeByIds(idList)) {
return Result.ok("删除成功");
}
return Result.error("删除失败");
}
@PutMapping("updateDgLendCatalog")
@ApiOperation("修改档案借阅目录")
public Result updateDgLendCatalog(@RequestBody UpdateDgLendCatalogRequest request){
if(dglendcatalogService.updateDgLendCatalog(request)) {
return Result.ok("修改成功");
}
return Result.error("修改失败");
}
@GetMapping("getDgLendCatalogDetailById")
@ApiOperation(value = "读取明细")
public Result getDgLendCatalogDetailById(@ApiParam("档案借阅目录ID") @RequestParam String id){
return Result.ok(dglendcatalogService.getDgLendCatalogDetailById(id));
}
}
package com.pashanhoo.lendcatalog.entity;
import java.util.List;
import com.pashanhoo.lendcatalog.entity.vo.AddDgLendCatalogRequest;
import com.pashanhoo.lendcatalog.entity.vo.DgLendCatalogDetailVO;
import com.pashanhoo.lendcatalog.entity.vo.DgLendCatalogListVO;
import com.pashanhoo.lendcatalog.entity.vo.UpdateDgLendCatalogRequest;
import org.mapstruct.Mapper;
/**
* @author
* @since 2021-11-05
*/
@Mapper(componentModel = "spring")
public interface DgLendCatalogConverter{
DgLendCatalogDO addRequest2DO(AddDgLendCatalogRequest request);
DgLendCatalogDetailVO do2DetailVO(DgLendCatalogDO dglendcatalogDO);
DgLendCatalogDO updateRequest2DO(UpdateDgLendCatalogRequest request);
DgLendCatalogListVO do2ListVO(DgLendCatalogDO dglendcatalogDO);
List<DgLendCatalogListVO> doList2ListVOList(List<DgLendCatalogDO> dglendcatalogDOList);
List<DgLendCatalogDO> addCataLogListDO(List<AddDgLendCatalogRequest> request);
}
package com.pashanhoo.lendcatalog.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案借阅目录
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("DG_LEND_CATALOG")
public class DgLendCatalogDO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 借阅目录标识码
*/
@TableId(value = "BSM_LENDCATALOG", type = IdType.UUID)
private String bsmLendcatalog;
/**
* 档案标识码
*/
@TableField("BSM_ARCHIVES")
private String bsmArchives;
/**
* 借阅标识码
*/
@TableField("BSM_LEND")
private String bsmLend;
/**
* 借阅材料类型
*/
@TableField("JYCLLX")
private String jycllx;
}
package com.pashanhoo.lendcatalog.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案借阅目录新增请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案借阅目录新增请求实体")
public class AddDgLendCatalogRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 借阅标识码
*/
@ApiModelProperty(name = "bsmLend", value = "借阅标识码")
private String bsmLend;
/**
* 借阅材料类型
*/
@ApiModelProperty(name = "jycllx", value = "借阅材料类型")
private String jycllx;
}
package com.pashanhoo.lendcatalog.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案借阅目录明细实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案借阅目录明细实体")
public class DgLendCatalogDetailVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 借阅目录标识码
*/
@ApiModelProperty(name = "bsmLendcatalog", value = "借阅目录标识码")
private String bsmLendcatalog;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 借阅标识码
*/
@ApiModelProperty(name = "bsmLend", value = "借阅标识码")
private String bsmLend;
/**
* 借阅材料类型
*/
@ApiModelProperty(name = "jycllx", value = "借阅材料类型")
private String jycllx;
}
package com.pashanhoo.lendcatalog.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案借阅目录列表VO
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案借阅目录列表VO")
//TODO 该类属性暂时是完整的全部属性，需进行个性化的增删
public class DgLendCatalogListVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 借阅目录标识码
*/
@ApiModelProperty(name = "bsmLendcatalog", value = "借阅目录标识码")
private String bsmLendcatalog;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 借阅标识码
*/
@ApiModelProperty(name = "bsmLend", value = "借阅标识码")
private String bsmLend;
/**
* 借阅材料类型
*/
@ApiModelProperty(name = "jycllx", value = "借阅材料类型")
private String jycllx;
}
package com.pashanhoo.lendcatalog.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import com.pashanhoo.common.PageInfo;
/**
* <p>
* 档案借阅目录列表查询请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案借阅目录列表查询请求实体")
//TODO 初始查询条件是全部，需要根据情况自行删减
public class DgLendCatalogSearchRequest extends PageInfo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 借阅目录标识码
*/
@ApiModelProperty(name = "bsmLendcatalog", value = "借阅目录标识码")
private String bsmLendcatalog;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 借阅标识码
*/
@ApiModelProperty(name = "bsmLend", value = "借阅标识码")
private String bsmLend;
/**
* 借阅材料类型
*/
@ApiModelProperty(name = "jycllx", value = "借阅材料类型")
private String jycllx;
}
package com.pashanhoo.lendcatalog.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案借阅目录修改请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案借阅目录修改请求实体")
public class UpdateDgLendCatalogRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 借阅目录标识码
*/
@ApiModelProperty(name = "bsmLendcatalog", value = "借阅目录标识码")
private String bsmLendcatalog;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 借阅标识码
*/
@ApiModelProperty(name = "bsmLend", value = "借阅标识码")
private String bsmLend;
/**
* 借阅材料类型
*/
@ApiModelProperty(name = "jycllx", value = "借阅材料类型")
private String jycllx;
}
package com.pashanhoo.lendcatalog.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.pashanhoo.lendcatalog.entity.DgLendCatalogDO;
/**
* <p>
* 档案借阅目录 Mapper 接口
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgLendCatalogMapper extends BaseMapper<DgLendCatalogDO> {
}
package com.pashanhoo.lendcatalog.service;
import com.pashanhoo.common.Result;
import com.pashanhoo.lendcatalog.entity.DgLendCatalogDO;
import com.pashanhoo.lendcatalog.entity.vo.AddDgLendCatalogRequest;
import com.pashanhoo.lendcatalog.entity.vo.DgLendCatalogDetailVO;
import com.pashanhoo.lendcatalog.entity.vo.UpdateDgLendCatalogRequest;
import com.pashanhoo.lendcatalog.entity.vo.DgLendCatalogSearchRequest;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* <p>
* 档案借阅目录 服务类
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgLendCatalogService extends IService<DgLendCatalogDO> {
/**
* 新增记录
* @param request
* @return
*/
boolean insertDgLendCatalog(AddDgLendCatalogRequest request);
/**
* 根据主键查询记录详情
* @param id
* @return
*/
DgLendCatalogDetailVO getDgLendCatalogDetailById(String id);
/**
* 修改单条记录
* @param request
* @return
*/
boolean updateDgLendCatalog(UpdateDgLendCatalogRequest request);
/**
* 查询借阅目录信息
* @param lendBsm
* @return
*/
Result getJyMlInfo(String lendBsm);
/**
* 删除借阅目录信息
* @param lendBsm
* @return
*/
Result deleteJyMlInfo(String lendBsm);
/**
* 通过借阅目录查询借阅的文件目录
* @param jnmlList
* @return
*/
Result getJyFileInfoByjybsm(List<String> jnmlList);
/**
* 批量删除借阅文件记录
* @param jywjDOList
* @return
*/
Result deleteDanganJyBatch(List<DgLendCatalogDO> jywjDOList);
/**
* 删除借阅目录信息
* @param bsm_lendcatalog
* @return
*/
Result deleteJyMlInfoByDA(String bsm_lendcatalog);
}
package com.pashanhoo.lendcatalog.service.impl;
import com.pashanhoo.common.Result;
import com.pashanhoo.lendcatalog.entity.DgLendCatalogConverter;
import com.pashanhoo.lendcatalog.entity.DgLendCatalogDO;
import com.pashanhoo.lendcatalog.entity.vo.AddDgLendCatalogRequest;
import com.pashanhoo.lendcatalog.entity.vo.DgLendCatalogDetailVO;
import com.pashanhoo.lendcatalog.entity.vo.UpdateDgLendCatalogRequest;
import com.pashanhoo.lendcatalog.entity.vo.DgLendCatalogSearchRequest;
import com.pashanhoo.lendcatalog.mapper.DgLendCatalogMapper;
import com.pashanhoo.lendcatalog.service.DgLendCatalogService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import java.util.ArrayList;
import java.util.List;
/**
* <p>
* 档案借阅目录 服务实现类
* </p>
*
* @author
* @since 2021-11-05
*/
@Service
public class DgLendCatalogServiceImpl extends ServiceImpl<DgLendCatalogMapper, DgLendCatalogDO> implements DgLendCatalogService {
@Autowired
private DgLendCatalogConverter dglendcatalogConverter;
@Autowired
private DgLendCatalogMapper dglendcatalogMapper;
/**
* 新增记录
* @param request
* @return
*/
@Override
public boolean insertDgLendCatalog(AddDgLendCatalogRequest request) {
DgLendCatalogDO dglendcatalogDO = dglendcatalogConverter.addRequest2DO(request);
return this.save(dglendcatalogDO);
}
/**
* 根据主键查询记录详情
* @param id
* @return
*/
@Override
public DgLendCatalogDetailVO getDgLendCatalogDetailById(String id) {
DgLendCatalogDO dglendcatalogDO = this.getById(id);
return dglendcatalogConverter.do2DetailVO(dglendcatalogDO);
}
/**
* 修改单条记录
* @param request
* @return
*/
@Override
public boolean updateDgLendCatalog(UpdateDgLendCatalogRequest request) {
DgLendCatalogDO dglendcatalogDO = dglendcatalogConverter.updateRequest2DO(request);
return this.updateById(dglendcatalogDO);
}
@Override
public Result getJyMlInfo(String lendBsm){
QueryWrapper<DgLendCatalogDO> wrapper = new QueryWrapper<>();
wrapper.eq(lendBsm!=null && !"".equals(lendBsm),"BSM_LEND",lendBsm);
List<DgLendCatalogDO> jymlDOListt=dglendcatalogMapper.selectList(wrapper);
return Result.ok(jymlDOListt);
}
@Override
public Result deleteJyMlInfo(String lendBsm){
QueryWrapper<DgLendCatalogDO> wrapper = new QueryWrapper<>();
wrapper.eq(lendBsm!=null && !"".equals(lendBsm),"BSM_LEND",lendBsm);
dglendcatalogMapper.delete(wrapper);
return Result.ok();
}
@Override
public Result getJyFileInfoByjybsm(List<String> jnmlList) {
QueryWrapper<DgLendCatalogDO> wrapper = new QueryWrapper<>();
wrapper.in("BSM_LENDCATALOG",jnmlList);
List<DgLendCatalogDO> list=dglendcatalogMapper.selectList(wrapper);
return Result.ok(list);
}
@Override
public Result deleteDanganJyBatch(List<DgLendCatalogDO> jywjDOList) {
QueryWrapper<DgLendCatalogDO> wrapper = new QueryWrapper<>();
wrapper.in("BSM_LENDCATALOG",jywjDOList);
dglendcatalogMapper.delete(wrapper);
return Result.ok();
}
@Override
public Result deleteJyMlInfoByDA(String bsm_lendcatalog) {
dglendcatalogMapper.deleteById(bsm_lendcatalog);
return Result.ok();
}
}
package com.pashanhoo.lendfile.controller;
import com.pashanhoo.common.Result;
import com.pashanhoo.lendfile.entity.vo.AddDgLendFileRequest;
import com.pashanhoo.lendfile.entity.vo.UpdateDgLendFileRequest;
import com.pashanhoo.lendfile.entity.vo.DgLendFileSearchRequest;
import com.pashanhoo.lendfile.service.DgLendFileService;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
/**
* <p>
* 档案借阅文件 前端控制器
* </p>
*
* @author
* @since 2021-11-09
*/
@RestController
@RequestMapping("/system/dgLendFile/")
@Api(tags = "档案借阅文件接口")
public class DgLendFileController {
@Autowired
private DgLendFileService dglendfileService;
@PostMapping("insertDgLendFile")
@ApiOperation("新增档案借阅文件")
public Result insertDgLendFile(@RequestBody AddDgLendFileRequest request){
if(dglendfileService.insertDgLendFile(request)){
return Result.ok();
}
return Result.error("新增失败");
}
@DeleteMapping("deleteDgLendFileByIds")
@ApiOperation(value = "批量删除档案借阅文件")
public Result deleteDgLendFileByIds(@ApiParam("档案借阅文件ID列表") @RequestParam(value = "idList") List<String> idList) {
if(dglendfileService.removeByIds(idList)) {
return Result.ok("删除成功");
}
return Result.error("删除失败");
}
@PutMapping("updateDgLendFile")
@ApiOperation("修改档案借阅文件")
public Result updateDgLendFile(@RequestBody UpdateDgLendFileRequest request){
if(dglendfileService.updateDgLendFile(request)) {
return Result.ok("修改成功");
}
return Result.error("修改失败");
}
@GetMapping("getDgLendFileDetailById")
@ApiOperation(value = "读取明细")
public Result getDgLendFileDetailById(@ApiParam("档案借阅文件ID") @RequestParam String id){
return Result.ok(dglendfileService.getDgLendFileDetailById(id));
}
@PostMapping("search")
@ApiOperation(value = "根据条件进行列表查询")
public Result searchDgLendFileList(@RequestBody DgLendFileSearchRequest request) {
//TODO 默认排序条件设置
request.defaultFillPageProp("","");
return Result.ok(dglendfileService.searchDgLendFileList(request));
}
}
package com.pashanhoo.lendfile.entity;
import java.util.List;
import com.pashanhoo.lendfile.entity.vo.AddDgLendFileRequest;
import com.pashanhoo.lendfile.entity.vo.DgLendFileDetailVO;
import com.pashanhoo.lendfile.entity.vo.DgLendFileListVO;
import com.pashanhoo.lendfile.entity.vo.UpdateDgLendFileRequest;
import org.mapstruct.Mapper;
/**
* @author
* @since 2021-11-09
*/
@Mapper(componentModel = "spring")
public interface DgLendFileConverter{
DgLendFileDO addRequest2DO(AddDgLendFileRequest request);
DgLendFileDetailVO do2DetailVO(DgLendFileDO dglendfileDO);
DgLendFileDO updateRequest2DO(UpdateDgLendFileRequest request);
DgLendFileListVO do2ListVO(DgLendFileDO dglendfileDO);
List<DgLendFileListVO> doList2ListVOList(List<DgLendFileDO> dglendfileDOList);
List<DgLendFileDO> addLendFileList(List<AddDgLendFileRequest> request);
}
package com.pashanhoo.lendfile.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案借阅文件
* </p>
*
* @author
* @since 2021-11-09
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("DG_LEND_FILE")
public class DgLendFileDO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 借阅文件标识码
*/
@TableId(value = "BSM_LENDFILE", type = IdType.UUID)
private String bsmLendfile;
/**
* 借阅目录标识码
*/
@TableField("BSM_LENDCATALOG")
private String bsmLendcatalog;
/**
* 目录标识码
*/
@TableField("BSM_CATALOG")
private String bsmCatalog;
}
package com.pashanhoo.lendfile.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案借阅文件新增请求实体
* </p>
*
* @author
* @since 2021-11-09
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案借阅文件新增请求实体")
public class AddDgLendFileRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 借阅目录标识码
*/
@ApiModelProperty(name = "bsmLendcatalog", value = "借阅目录标识码")
private String bsmLendcatalog;
/**
* 目录标识码
*/
@ApiModelProperty(name = "bsmCatalog", value = "目录标识码")
private String bsmCatalog;
/**
* 借阅材料类型
*/
@ApiModelProperty(name = "jycllx", value = "借阅材料类型")
private String jycllx;
}
package com.pashanhoo.lendfile.entity.vo;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案借阅文件明细实体
* </p>
*
* @author
* @since 2021-11-09
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案借阅文件明细实体")
public class DgLendFileDetailVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 借阅文件标识码
*/
@ApiModelProperty(name = "bsmLendfile", value = "借阅文件标识码")
private String bsmLendfile;
/**
* 借阅目录标识码
*/
@ApiModelProperty(name = "bsmLendcatalog", value = "借阅目录标识码")
private String bsmLendcatalog;
/**
* 目录标识码
*/
@ApiModelProperty(name = "bsmCatalog", value = "目录标识码")
private String bsmCatalog;
}
package com.pashanhoo.lendfile.entity.vo;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案借阅文件列表VO
* </p>
*
* @author
* @since 2021-11-09
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案借阅文件列表VO")
//TODO 该类属性暂时是完整的全部属性，需进行个性化的增删
public class DgLendFileListVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 借阅文件标识码
*/
@ApiModelProperty(name = "bsmLendfile", value = "借阅文件标识码")
private String bsmLendfile;
/**
* 借阅目录标识码
*/
@ApiModelProperty(name = "bsmLendcatalog", value = "借阅目录标识码")
private String bsmLendcatalog;
/**
* 目录标识码
*/
@ApiModelProperty(name = "bsmCatalog", value = "目录标识码")
private String bsmCatalog;
}
package com.pashanhoo.lendfile.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import com.pashanhoo.common.PageInfo;
/**
* <p>
* 档案借阅文件列表查询请求实体
* </p>
*
* @author
* @since 2021-11-09
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案借阅文件列表查询请求实体")
//TODO 初始查询条件是全部，需要根据情况自行删减
public class DgLendFileSearchRequest extends PageInfo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 借阅文件标识码
*/
@ApiModelProperty(name = "bsmLendfile", value = "借阅文件标识码")
private String bsmLendfile;
/**
* 借阅目录标识码
*/
@ApiModelProperty(name = "bsmLendcatalog", value = "借阅目录标识码")
private String bsmLendcatalog;
/**
* 目录标识码
*/
@ApiModelProperty(name = "bsmCatalog", value = "目录标识码")
private String bsmCatalog;
}
package com.pashanhoo.lendfile.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案借阅文件修改请求实体
* </p>
*
* @author
* @since 2021-11-09
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案借阅文件修改请求实体")
public class UpdateDgLendFileRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 借阅文件标识码
*/
@ApiModelProperty(name = "bsmLendfile", value = "借阅文件标识码")
private String bsmLendfile;
/**
* 借阅目录标识码
*/
@ApiModelProperty(name = "bsmLendcatalog", value = "借阅目录标识码")
private String bsmLendcatalog;
/**
* 目录标识码
*/
@ApiModelProperty(name = "bsmCatalog", value = "目录标识码")
private String bsmCatalog;
}
package com.pashanhoo.lendfile.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.pashanhoo.lendfile.entity.DgLendFileDO;
/**
* <p>
* 档案借阅文件 Mapper 接口
* </p>
*
* @author
* @since 2021-11-09
*/
public interface DgLendFileMapper extends BaseMapper<DgLendFileDO> {
}
package com.pashanhoo.lendfile.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.pashanhoo.common.Result;
import com.pashanhoo.lendfile.entity.DgLendFileDO;
import com.pashanhoo.lendfile.entity.vo.AddDgLendFileRequest;
import com.pashanhoo.lendfile.entity.vo.DgLendFileDetailVO;
import com.pashanhoo.lendfile.entity.vo.UpdateDgLendFileRequest;
import com.pashanhoo.lendfile.entity.vo.DgLendFileSearchRequest;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
/**
* <p>
* 档案借阅文件 服务类
* </p>
*
* @author
* @since 2021-11-09
*/
public interface DgLendFileService extends IService<DgLendFileDO> {
/**
* 新增记录
* @param request
* @return
*/
boolean insertDgLendFile(AddDgLendFileRequest request);
/**
* 根据主键查询记录详情
* @param id
* @return
*/
DgLendFileDetailVO getDgLendFileDetailById(String id);
/**
* 修改单条记录
* @param request
* @return
*/
boolean updateDgLendFile(UpdateDgLendFileRequest request);
/**
* 根据条件进行列表查询
* @param request
* @return
*/
Page searchDgLendFileList(DgLendFileSearchRequest request);
/**
* 通过借阅目录标识码删除借阅文件信息
* @param bsm_lendcatalog
* @return
*/
Result deleteJyFile(String bsm_lendcatalog);
}
package com.pashanhoo.lendfile.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pashanhoo.common.Result;
import com.pashanhoo.destroycatalog.entity.DgDestructionCatalogDO;
import com.pashanhoo.lendfile.entity.DgLendFileConverter;
import com.pashanhoo.lendfile.entity.DgLendFileDO;
import com.pashanhoo.lendfile.entity.vo.AddDgLendFileRequest;
import com.pashanhoo.lendfile.entity.vo.DgLendFileDetailVO;
import com.pashanhoo.lendfile.entity.vo.UpdateDgLendFileRequest;
import com.pashanhoo.lendfile.entity.vo.DgLendFileSearchRequest;
import com.pashanhoo.lendfile.mapper.DgLendFileMapper;
import com.pashanhoo.lendfile.service.DgLendFileService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
/**
* <p>
* 档案借阅文件 服务实现类
* </p>
*
* @author
* @since 2021-11-09
*/
@Service
public class DgLendFileServiceImpl extends ServiceImpl<DgLendFileMapper, DgLendFileDO> implements DgLendFileService {
@Autowired
private DgLendFileConverter dglendfileConverter;
@Autowired
private DgLendFileMapper dglendfileMapper;
/**
* 新增记录
* @param request
* @return
*/
@Override
public boolean insertDgLendFile(AddDgLendFileRequest request) {
DgLendFileDO dglendfileDO = dglendfileConverter.addRequest2DO(request);
return this.save(dglendfileDO);
}
/**
* 根据主键查询记录详情
* @param id
* @return
*/
@Override
public DgLendFileDetailVO getDgLendFileDetailById(String id) {
DgLendFileDO dglendfileDO = this.getById(id);
return dglendfileConverter.do2DetailVO(dglendfileDO);
}
/**
* 修改单条记录
* @param request
* @return
*/
@Override
public boolean updateDgLendFile(UpdateDgLendFileRequest request) {
DgLendFileDO dglendfileDO = dglendfileConverter.updateRequest2DO(request);
return this.updateById(dglendfileDO);
}
/**
* 根据条件进行列表查询
* @param request
* @return
*/
@Override
public Page searchDgLendFileList(DgLendFileSearchRequest request) {
Page<DgLendFileDO> pageParam = new Page<DgLendFileDO>(request.getCurrentPage(), request.getPageSize());
QueryWrapper<DgLendFileDO> wrapper = new QueryWrapper<>();
//设置默认排序
wrapper = "desc".equals(request.getSortOrder()) ? wrapper.orderByDesc(request.getSortField()) : wrapper.orderByAsc(request.getSortField());
//TODO 根据当前情况设置wrapper条件
Page page = this.page(pageParam, wrapper);
//将查询出来的DO List转为 ListVO List并重新设置到page对象中，并返回page对象
return page.setRecords(dglendfileConverter.doList2ListVOList(page.getRecords()));
}
@Override
public Result deleteJyFile(String bsm_lendcatalog) {
QueryWrapper<DgLendFileDO> wrapper = new QueryWrapper<>();
wrapper.eq(bsm_lendcatalog!=null && !"".equals(bsm_lendcatalog),"BSM_LENDCATALOG",bsm_lendcatalog);
int result=dglendfileMapper.delete(wrapper);
if(result!=0){
return Result.ok();
}else{
return Result.error("操作失败");
}
}
}
package com.pashanhoo.modify.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.pashanhoo.common.Result;
import com.pashanhoo.modify.entity.vo.*;
import com.pashanhoo.modify.service.DgArchivesModifyService;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
/**
* <p>
* 档案修改信息 前端控制器
* </p>
*
* @author
* @since 2021-11-05
*/
@RestController
@RequestMapping("/system/dgArchivesModify/")
@Api(tags = "档案修改信息接口")
public class DgArchivesModifyController {
@Autowired
private DgArchivesModifyService dgarchivesmodifyService;
@GetMapping("insertDgArchivesModify")
@ApiOperation("档案修改记录新增")
public Result insertDgArchivesModify(@ApiParam("档案标识码") @RequestParam String bsmArchive){
if(dgarchivesmodifyService.insertDgArchivesModify(bsmArchive)){
return Result.ok();
}
return Result.error("新增失败");
}
@DeleteMapping("deleteDgArchivesModifyByIds")
@ApiOperation(value = "批量删除档案修改信息")
public Result deleteDgArchivesModifyByIds(@ApiParam("档案修改标识码") @RequestParam(value = "bsmModify") String bsmModify) {
if(dgarchivesmodifyService.delete(bsmModify)) {
return Result.ok("删除成功");
}
return Result.error("删除失败");
}
@PutMapping("updateDgArchivesModify")
@ApiOperation("修改档案修改状态--归档操作")
public Result updateDgArchivesModify(@RequestBody UpdateDgArchivesModifyRequest request){
if(dgarchivesmodifyService.updateDgArchivesModify(request)) {
return Result.ok("修改成功");
}
return Result.error("修改失败");
}
@GetMapping("getDgArchivesModifyDetailById")
@ApiOperation(value = "读取明细")
public Result getDgArchivesModifyDetailById(@ApiParam("档案修改信息ID") @RequestParam String id){
return Result.ok(dgarchivesmodifyService.getDgArchivesModifyDetailById(id));
}
@PostMapping("searchDgArchivesModifyList")
@ApiOperation(value = "修改列表查询")
public Result<IPage<DgArchivesModifyListVO>> searchDgArchivesModifyList(@RequestBody DgArchivesModifySearchRequest request) {
return Result.ok(dgarchivesmodifyService.searchDgArchivesModifyList(request));
}
@GetMapping("getArchiveWithModify")
@ApiOperation(value = "一个档案对应的修改列表查询")
public Result<List<DgArchivesModifyDetailVO>> getArchiveWithModify(@ApiParam("档案标识码") @RequestParam String bsmArchive) {
return Result.ok(dgarchivesmodifyService.getArchiveWithModify(bsmArchive));
}
}
package com.pashanhoo.modify.entity;
import java.util.List;
import com.pashanhoo.modify.entity.vo.AddDgArchivesModifyRequest;
import com.pashanhoo.modify.entity.vo.DgArchivesModifyDetailVO;
import com.pashanhoo.modify.entity.vo.DgArchivesModifyListVO;
import com.pashanhoo.modify.entity.vo.UpdateDgArchivesModifyRequest;
import org.mapstruct.Mapper;
/**
* @author
* @since 2021-11-05
*/
@Mapper(componentModel = "spring")
public interface DgArchivesModifyConverter{
DgModifyDO addRequest2DO(AddDgArchivesModifyRequest request);
DgArchivesModifyDetailVO do2DetailVO(DgModifyDO dgarchivesmodifyDO);
DgModifyDO updateRequest2DO(UpdateDgArchivesModifyRequest request);
DgArchivesModifyListVO do2ListVO(DgModifyDO dgarchivesmodifyDO);
List<DgArchivesModifyListVO> doList2ListVOList(List<DgModifyDO> dgarchivesmodifyDOList);
List<DgArchivesModifyDetailVO> doList2DetailVOList(List<DgModifyDO> dgarchivesmodifyDOList);
}
package com.pashanhoo.modify.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案修改信息
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("DG_MODIFY")
public class DgModifyDO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 修改标识码
*/
@TableId(value = "BSM_MODIFY", type = IdType.UUID)
private String bsmModify;
/**
* 档案标识码
*/
@TableField("BSM_ARCHIVES")
private String bsmArchives;
/**
* 修改编号
*/
@TableField("XGBH")
private String xgbh;
/**
* 原档案信息
*/
@TableField("YDAXX")
private String ydaxx;
/**
* 修改内容
*/
@TableField("XGNR")
private String xgnr;
/**
* 创建时间
*/
@TableField("createTime")
@DateTimeFormat(pattern = "yyyy-MM-dd")
@JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
private Date createTime;
/**
* 修改人
*/
@TableField("CREATER")
private String creater;
/**
* 备注
*/
@TableField("BZ")
private String bz;
/**
* 状态1:修改中,2:已归档
*/
@TableField("STATE")
private String state;
/**
* 归档时间
*/
@TableField("GDSJ")
@DateTimeFormat(pattern = "yyyy-MM-dd")
@JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
private Date gdsj;
}
package com.pashanhoo.modify.entity.vo;
import java.util.Date;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.TableField;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案修改信息新增请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案修改信息新增请求实体")
public class AddDgArchivesModifyRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 修改编号
*/
@ApiModelProperty(name = "xgbh", value = "修改编号")
private String xgbh;
/**
* 原档案信息
*/
@ApiModelProperty(name = "ydaxx", value = "原档案信息")
private String ydaxx;
/**
* 修改内容
*/
@ApiModelProperty(name = "xgnr", value = "修改内容")
private String xgnr;
/**
* 创建时间
*/
@ApiModelProperty(name="createTime" ,value = "创建时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 修改人
*/
@ApiModelProperty(name = "CREATER",value = "创建人")
private String creater;
/**
* 备注
*/
@ApiModelProperty(name = "bz", value = "备注")
private String bz;
/**
* 状态1:修改中,2:已归档
*/
@ApiModelProperty(name = "state", value = "状态1:修改中,2:已归档")
private String state;
/**
* 归档时间
*/
@ApiModelProperty(name = "gdsj", value = "归档时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date gdsj;
}
package com.pashanhoo.modify.entity.vo;
import java.util.Date;
import java.io.Serializable;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案修改信息明细实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案修改信息明细实体")
public class DgArchivesModifyDetailVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 修改标识码
*/
@ApiModelProperty(name = "bsmModify", value = "修改标识码")
private String bsmModify;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 修改编号
*/
@ApiModelProperty(name = "xgbh", value = "修改编号")
private String xgbh;
/**
* 原档案信息
*/
@ApiModelProperty(name = "ydaxx", value = "原档案信息")
private String ydaxx;
/**
* 修改内容
*/
@ApiModelProperty(name = "xgnr", value = "修改内容")
private String xgnr;
/**
* 创建时间
*/
@ApiModelProperty(name="createTime" ,value = "创建时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 修改人
*/
@ApiModelProperty(name = "CREATER",value = "创建人")
private String creater;
/**
* 备注
*/
@ApiModelProperty(name = "bz", value = "备注")
private String bz;
/**
* 状态1:修改中,2:已归档
*/
@ApiModelProperty(name = "state", value = "状态1:修改中,2:已归档")
private String state;
/**
* 归档时间
*/
@ApiModelProperty(name = "gdsj", value = "归档时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date gdsj;
}
package com.pashanhoo.modify.entity.vo;
import java.util.Date;
import java.io.Serializable;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案修改信息列表VO
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案修改信息列表VO")
public class DgArchivesModifyListVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 修改标识码
*/
@ApiModelProperty(name = "bsmModify",value = "修改标识码")
private String bsmModify;
/**
* 案卷标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "案卷标识码")
private String bsmArchives;
/**
* 权利类型
*/
@ApiModelProperty(name = "qllx", value = "权利类型")
private String qllx;
/**
* 登记类型
*/
@ApiModelProperty(name = "djlx", value = "登记类型")
private String djlx;
/**
* 档案号
*/
@ApiModelProperty(name = "ajh", value = "档案号")
private String ajh;
/**
* 业务号
*/
@ApiModelProperty(name = "ywh", value = "业务号")
private String ywh;
/**
* 不动产单元号
*/
@ApiModelProperty(name = "bdcdyh", value = "不动产单元号")
private String bdcdyh;
/**
* 权利人
*/
@ApiModelProperty(name = "qlr", value = "权利人")
private String qlr;
/**
* 义务人
*/
@ApiModelProperty(name = "ywr", value = "义务人")
private String ywr;
/**
* 不动产证件号码
*/
@ApiModelProperty(name = "bdcqzh", value = "不动产证件号码")
private String bdcqzh;
/**
* 修改时间
*/
@ApiModelProperty(name = "createTime", value = "修改时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 修改人
*/
@ApiModelProperty(name = "creater", value = "修改人")
private String creater;
/**
* 不动产单元号数量
*/
@ApiModelProperty(name = "bdcdyNum", value = "不动产单元号数量")
private String bdcdyNum;
/**
* 状态 1:修改中.2:已归档
*/
@ApiModelProperty(name = "state", value = "状态 1:修改中.2:已归档")
private String state;
}
package com.pashanhoo.modify.entity.vo;
import java.util.Date;
import java.io.Serializable;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import com.pashanhoo.common.PageInfo;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案修改信息列表查询请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案修改信息列表查询请求实体")
public class DgArchivesModifySearchRequest extends PageInfo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 登记业务名称
*/
@ApiModelProperty(name = "djywmc", value = "登记业务名称")
private String djywmc;
/**
* 登记类型
*/
@ApiModelProperty(name = "djlx", value = "登记类型")
private String djlx;
/**
* 修改人
*/
@ApiModelProperty(name = "creater", value = "修改人")
private String creater;
/**
* 修改起始时间
*/
@ApiModelProperty(name = "xgqssj", value = "修改起始时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date xgqssj;
/**
* 修改截止时间
*/
@ApiModelProperty(name = "xgjzsj", value = "修改截止时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date xgjzsj;
/**
* 档案号
*/
@ApiModelProperty(name = "ajh", value = "档案号")
private String ajh;
/**
* 业务号
*/
@ApiModelProperty(name = "ywh", value = "业务号")
private String ywh;
/**
* 不动产单元号
*/
@ApiModelProperty(name = "bdcdyh", value = "不动产单元号")
private String bdcdyh;
/**
* 不动产权证号
*/
@ApiModelProperty(name = "bdcqzh", value = "不动产权证号")
private String bdcqzh;
}
package com.pashanhoo.modify.entity.vo;
import com.pashanhoo.archive.entity.DgArchivesDO;
import com.pashanhoo.bdcdy.entity.DgBdcdyDO;
import com.pashanhoo.business.entity.DgBusinessDO;
import com.pashanhoo.catalog.entity.DgArchivesCatalogDO;
import com.pashanhoo.file.entity.DgFileDO;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.List;
/**
* 修改记录实体
*/
@Data
@EqualsAndHashCode(callSuper = false)
public class ModifyRecord implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 案卷基本信息
*/
DgArchivesDO archivesDO;
/**
* 业务信息
*/
DgBusinessDO dgBusinessDO;
/**
* 不动产单元信息
*/
List<DgBdcdyDO> dgBdcdyDOList;
/**
* 卷内目录
*/
List<DgArchivesCatalogDO> catalogDOList;
/**
* 附件
*/
List<DgFileDO> dgFileDOList;
}
package com.pashanhoo.modify.entity.vo;
import java.util.Date;
import java.io.Serializable;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案修改信息修改请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案修改信息修改请求实体")
public class UpdateDgArchivesModifyRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 修改标识码
*/
@ApiModelProperty(name = "bsmModify", value = "修改标识码")
private String bsmModify;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 修改编号
*/
@ApiModelProperty(name = "xgbh", value = "修改编号")
private String xgbh;
/**
* 原档案信息
*/
@ApiModelProperty(name = "ydaxx", value = "原档案信息")
private String ydaxx;
/**
* 创建时间
*/
@ApiModelProperty(name="createTime" ,value = "创建时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 修改人
*/
@ApiModelProperty(name = "CREATER",value = "创建人")
private String creater;
/**
* 修改人
*/
@ApiModelProperty(name = "xgr", value = "修改人")
private String xgr;
/**
* 备注
*/
@ApiModelProperty(name = "bz", value = "备注")
private String bz;
/**
* 状态1:修改中,2:已归档
*/
@ApiModelProperty(name = "state", value = "状态1:修改中,2:已归档")
private String state;
/**
* 归档时间
*/
@ApiModelProperty(name = "gdsj", value = "归档时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date gdsj;
}
package com.pashanhoo.modify.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.pashanhoo.modify.entity.DgModifyDO;
import com.pashanhoo.modify.entity.vo.DgArchivesModifyListVO;
import com.pashanhoo.modify.entity.vo.DgArchivesModifySearchRequest;
import org.apache.ibatis.annotations.Param;
/**
* <p>
* 档案修改信息 Mapper 接口
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgArchivesModifyMapper extends BaseMapper<DgModifyDO> {
/**
* 修改列表查询
* @param pageParam
* @param request
* @return
*/
IPage<DgArchivesModifyListVO> searchDgArchivesModifyList(@Param("pageParam") IPage<DgArchivesModifyListVO> pageParam, @Param("request") DgArchivesModifySearchRequest request);
}
package com.pashanhoo.modify.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.IService;
import com.pashanhoo.modify.entity.DgModifyDO;
import com.pashanhoo.modify.entity.vo.*;
import java.util.List;
/**
* <p>
* 档案修改信息 服务类
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgArchivesModifyService extends IService<DgModifyDO> {
/**
* 新增记录
* 1.档案修改记录并把原有的档案信息存入clob字段
* 2.修改案卷基本信息状态为正在修改
*
* @param bsmArchive
* @return
*/
boolean insertDgArchivesModify(String bsmArchive);
/**
* 根据主键查询记录详情
*
* @param id
* @return
*/
DgArchivesModifyDetailVO getDgArchivesModifyDetailById(String id);
/**
* 修改记录状态为已归档和归档日期，一并修改档案记录的状态为在库
*
* @param request
* @return
*/
boolean updateDgArchivesModify(UpdateDgArchivesModifyRequest request);
/**
* 修改列表查询
*
* @param request
* @return
*/
IPage<DgArchivesModifyListVO> searchDgArchivesModifyList(DgArchivesModifySearchRequest request);
/**
* 一个档案对应的修改列表查询
*
* @param bsmArchive
* @return
*/
List<DgArchivesModifyDetailVO> getArchiveWithModify(String bsmArchive);
/**
* 删除修改记录，并回滚档案信息和修改档案状态在库
* @param bsmModify
* @return
*/
boolean delete(String bsmModify);
}
package com.pashanhoo.modify.service.impl;
import cn.hutool.core.date.DateTime;
import cn.hutool.json.JSON;
import cn.hutool.json.JSONConfig;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pashanhoo.archive.entity.ArchiveStatus;
import com.pashanhoo.archive.entity.DgArchivesDO;
import com.pashanhoo.archive.service.DgArchivesService;
import com.pashanhoo.bdcdy.entity.DgBdcdyDO;
import com.pashanhoo.bdcdy.service.DgBdcdyService;
import com.pashanhoo.business.entity.DgBusinessDO;
import com.pashanhoo.business.service.DgBusinessService;
import com.pashanhoo.catalog.entity.DgArchivesCatalogDO;
import com.pashanhoo.catalog.service.DgArchivesCatalogService;
import com.pashanhoo.file.entity.DgFileDO;
import com.pashanhoo.file.service.DgFileService;
import com.pashanhoo.modify.entity.DgArchivesModifyConverter;
import com.pashanhoo.modify.entity.DgModifyDO;
import com.pashanhoo.modify.entity.vo.*;
import com.pashanhoo.modify.mapper.DgArchivesModifyMapper;
import com.pashanhoo.modify.service.DgArchivesModifyService;
import com.pashanhoo.replenish.service.impl.DgArchivesReplenishServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
import java.util.stream.Collectors;
/**
* <p>
* 档案修改信息 服务实现类
* </p>
*
* @author
* @since 2021-11-05
*/
@Service
public class DgArchivesModifyServiceImpl extends ServiceImpl<DgArchivesModifyMapper, DgModifyDO> implements DgArchivesModifyService {
@Autowired
private DgArchivesModifyConverter dgarchivesmodifyConverter;
@Autowired
private DgArchivesModifyMapper dgarchivesmodifyMapper;
@Autowired
DgArchivesService archivesService;
@Autowired
DgBusinessService businessService;
@Autowired
DgBdcdyService bdcdyService;
@Autowired
DgArchivesCatalogService catalogService;
@Autowired
DgFileService fileService;
/**
* 新增记录
* 1.档案修改记录并把原有的档案信息存入clob字段
* 2.修改案卷基本信息状态为正在修改
*
* @param bsmArchive
* @return
*/
@Override
@Transactional(rollbackFor = Exception.class)
public boolean insertDgArchivesModify(String bsmArchive) {
//获取案卷基本信息
DgArchivesDO archive = archivesService.getById(bsmArchive);
//获取业务信息
QueryWrapper<DgBusinessDO> businessWrapper = new QueryWrapper<>();
businessWrapper.lambda().eq(DgBusinessDO::getBsmArchives, bsmArchive);
DgBusinessDO business = businessService.getOne(businessWrapper);
//获取不动产信息
QueryWrapper<DgBdcdyDO> bdcdyWrapper = new QueryWrapper<>();
bdcdyWrapper.lambda().eq(DgBdcdyDO::getBsmArchives, bsmArchive);
List<DgBdcdyDO> bdcdyList = bdcdyService.list(bdcdyWrapper);
//获取卷内目录
QueryWrapper<DgArchivesCatalogDO> catalogWrapper = new QueryWrapper<>();
catalogWrapper.lambda().eq(DgArchivesCatalogDO::getBsmArchives, bsmArchive);
List<DgArchivesCatalogDO> catalogList = catalogService.list(catalogWrapper);
//获取案卷附件
List<String> catalogIdList = catalogList.stream().map(DgArchivesCatalogDO::getBsmCatalog).collect(Collectors.toList());
QueryWrapper<DgFileDO> fileWrapper = new QueryWrapper<>();
fileWrapper.lambda().in(DgFileDO::getBsmCatalog, catalogIdList);
List<DgFileDO> fileList = fileService.list(fileWrapper);
ModifyRecord modifyRecord = new ModifyRecord();
modifyRecord.setArchivesDO(archive);
modifyRecord.setDgBusinessDO(business);
modifyRecord.setDgBdcdyDOList(bdcdyList);
modifyRecord.setCatalogDOList(catalogList);
modifyRecord.setDgFileDOList(fileList);
JSONConfig jsonConfig = JSONConfig.create().setIgnoreNullValue(false).setOrder(true).setDateFormat("yyyy-MM-dd HH:mm:ss");
JSON modifyRecordJson = JSONUtil.parse(modifyRecord, jsonConfig);
String modifyRecordStr = JSONUtil.toJsonStr(modifyRecordJson);
DgModifyDO modifyDO = new DgModifyDO();
modifyDO.setBsmArchives(bsmArchive);
modifyDO.setXgbh(IdWorker.get32UUID());
modifyDO.setYdaxx(modifyRecordStr);
// TODO: 2021/11/23/0023 暂时填null
modifyDO.setXgnr(null);
modifyDO.setCreateTime(DateTime.now());
// TODO: 2021/11/23/0023 暂时填null
modifyDO.setCreater(null);
modifyDO.setState("1");
modifyDO.setGdsj(null);
//修改档案状态
UpdateWrapper<DgArchivesDO> archiveUpdateWrapper = new UpdateWrapper<>();
archiveUpdateWrapper.lambda().set(DgArchivesDO::getDazt, ArchiveStatus.MODIFYING.getCode()).eq(DgArchivesDO::getBsmArchives,bsmArchive);
archivesService.update(archiveUpdateWrapper);
return this.save(modifyDO);
}
/**
* 根据主键查询记录详情
*
* @param id
* @return
*/
@Override
public DgArchivesModifyDetailVO getDgArchivesModifyDetailById(String id) {
DgModifyDO dgarchivesmodifyDO = this.getById(id);
return dgarchivesmodifyConverter.do2DetailVO(dgarchivesmodifyDO);
}
/**
* 修改记录状态为已归档和归档日期，一并修改档案记录的状态为在库
*
* @param request
* @return
*/
@Override
@Transactional(rollbackFor = Exception.class)
public boolean updateDgArchivesModify(UpdateDgArchivesModifyRequest request) {
DgModifyDO dgarchivesmodifyDO = dgarchivesmodifyConverter.updateRequest2DO(request);
UpdateWrapper<DgModifyDO> modifyWrapper = new UpdateWrapper<>();
modifyWrapper.lambda().set(DgModifyDO::getState, "2").set(DgModifyDO::getGdsj, DateTime.now());
this.update(dgarchivesmodifyDO, modifyWrapper);
//修改档案记录状态
UpdateWrapper<DgArchivesDO> archivesWrapper = new UpdateWrapper<>();
archivesWrapper.lambda().set(DgArchivesDO::getDazt, ArchiveStatus.STORED.getCode()).eq(DgArchivesDO::getBsmArchives, request.getBsmArchives());
return archivesService.update(archivesWrapper);
}
/**
* 根据条件进行列表查询
*
* @param request
* @return
*/
@Override
public IPage<DgArchivesModifyListVO> searchDgArchivesModifyList(DgArchivesModifySearchRequest request) {
IPage<DgArchivesModifyListVO> pageParam = new Page<>(request.getCurrentPage(), request.getPageSize());
IPage<DgArchivesModifyListVO> list = dgarchivesmodifyMapper.searchDgArchivesModifyList(pageParam, request);
List<DgArchivesModifyListVO> records = list.getRecords();
List<DgArchivesModifyListVO> clean = records.stream().filter(DgArchivesReplenishServiceImpl.distinctByKey(DgArchivesModifyListVO::getBsmModify)).collect(Collectors.toList());
list.setRecords(clean).setTotal(clean.size());
return list;
}
/**
* 一个档案对应的修改列表查询
*
* @param bsmArchive
* @return
*/
@Override
public List<DgArchivesModifyDetailVO> getArchiveWithModify(String bsmArchive) {
QueryWrapper<DgModifyDO> modifyWrapper = new QueryWrapper<>();
modifyWrapper.lambda().eq(DgModifyDO::getBsmArchives, bsmArchive);
List<DgModifyDO> modifyDOS = this.list(modifyWrapper);
return dgarchivesmodifyConverter.doList2DetailVOList(modifyDOS);
}
/**
* 删除修改记录，并回滚档案信息和修改档案状态在库
* @param bsmModify
* @return
*/
@Override
@Transactional(rollbackFor = Exception.class)
public boolean delete(String bsmModify) {
//获取修改前信息
DgModifyDO modifyDO = this.getById(bsmModify);
String bsmArchives = modifyDO.getBsmArchives();
//获取原档案信息json字段
String ydaxxJson = modifyDO.getYdaxx();
ModifyRecord modifyRecord = JSONUtil.toBean(ydaxxJson, ModifyRecord.class);
//删除修改记录表数据
this.removeById(bsmModify);
//删除案卷附件
QueryWrapper<DgArchivesCatalogDO> catalogWrapper = new QueryWrapper<>();
catalogWrapper.lambda().eq(DgArchivesCatalogDO::getBsmArchives, bsmArchives);
List<DgArchivesCatalogDO> catalogDOList = catalogService.list(catalogWrapper);
List<String> bsmCatalogList = catalogDOList.stream().map(DgArchivesCatalogDO::getBsmCatalog).collect(Collectors.toList());
QueryWrapper<DgFileDO> fileWrapper = new QueryWrapper<>();
fileWrapper.lambda().in(DgFileDO::getBsmCatalog, bsmCatalogList);
fileService.remove(fileWrapper);
//插入原案卷附件
fileService.saveBatch(modifyRecord.getDgFileDOList());
//删除案卷目录
catalogService.removeByIds(bsmCatalogList);
//插入原案卷目录
catalogService.saveBatch(modifyRecord.getCatalogDOList());
//删除不动产信息
QueryWrapper<DgBdcdyDO> bdcdyWrapper = new QueryWrapper<>();
bdcdyWrapper.lambda().eq(DgBdcdyDO::getBsmArchives, bsmArchives);
bdcdyService.remove(bdcdyWrapper);
//插入原不动产信息
bdcdyService.saveBatch(modifyRecord.getDgBdcdyDOList());
//删除业务信息
QueryWrapper<DgBusinessDO> businessWrapper = new QueryWrapper<>();
businessWrapper.lambda().eq(DgBusinessDO::getBsmArchives, bsmArchives);
businessService.remove(businessWrapper);
//插入原业务信息
businessService.save(modifyRecord.getDgBusinessDO());
//更新档案信息
DgArchivesDO archivesDO = modifyRecord.getArchivesDO();
archivesDO.setDazt(ArchiveStatus.STORED.getCode());
return archivesService.updateById(archivesDO);
}
}
package com.pashanhoo.qys.controller;
import com.pashanhoo.common.Result;
import com.pashanhoo.qys.service.EciService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/eci/")
@Api(tags = "电子证照相关接口")
public class EciController {
@Autowired
private EciService eciService;
@PostMapping("accessCreateContract")
@ApiOperation("创建合同接口")
public Result accessCreateContract(@ApiParam("不动产权基本信息id")@RequestParam String zsbs,@ApiParam("证件号码")@RequestParam String qlrzjh,@ApiParam("证书编号")@RequestParam String bh) {
eciService.createContractForHandle(zsbs,qlrzjh,bh);
return Result.ok();
}
@GetMapping("accessDetails")
@ApiOperation("合同详情接口")
public Result accessDetails(@ApiParam("电子证照表主键ID")@RequestParam String biz_id) {
eciService.accessDetailsForHandle(biz_id);
return Result.ok();
}
@GetMapping("accessDownload")
@ApiOperation("下载合同文档接口")
public Result accessDownload(@ApiParam("电子证照表主键ID")@RequestParam String biz_id) {
eciService.accessDownloadForHandle(biz_id);
return Result.ok();
}
@GetMapping("convert")
@ApiOperation("ofd转换服务接口")
public Result convert(@ApiParam("电子证照表主键ID")@RequestParam String biz_id) {
eciService.convertElecForHandle(biz_id);
return Result.ok();
}
}
package com.pashanhoo.qys.entity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
@Data
@EqualsAndHashCode(callSuper = false)
public class ActionRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 是
* 签署动作类型：CORPORATE（企业签章），PERSONAL（个人签字），LP（法定代表人签字），AUDIT（审批）
*/
private String type;
/**
* 是
* 签署动作名称
*/
private String name;
/**
* 是
* 签署动作名称
*/
private String autoSign;
/**
* 是
* 签署顺序（从1开始)；如果想按顺序签署，则分别设置签署动作的serialNo为1,2,3；如果想无序签署，则设置签署动作的serialNo为1,1,1；设置签署动作顺序为1,2,2时，表示第一个先签署，后两个同时签署。
*/
private Integer serialNo;
}
package com.pashanhoo.qys.entity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.web.multipart.MultipartFile;
import java.io.Serializable;
import java.util.List;
/**
* 创建合同请求实体
*/
@Data
@EqualsAndHashCode(callSuper = false)
public class CreateContractRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 是
* 合同名称
*/
private String subject;
/**
* 否
* 合同编号，对接方系统中的业务编号
*/
private String sn;
/**
* 否
* 用印流程ID
*/
private String categoryId;
/**
* 否
* 是否发起合同，默认true。（true：立即发起；false：保存为草稿）
*/
private boolean send;
/**
* 否
* 合同创建人姓名
*/
private String creatorName;
/**
* 否
* 合同创建人手机号码
*/
private String creatorContact;
/**
* 否
* 发起方名称
*/
private String tenantName;
/**
* 受理申请pdf文件
*/
private MultipartFile file;
/**
* title
*/
private String title;
/**
* title
*/
private String fileType;
/**
* 否
* 签署方，为空时在合同签署完成后需要调用接口“封存合同”主动结束合同
*/
private List<SignatoryRequest> signatories;
/**
* 否
* 模板参数
*/
private List<DocumentParam> documentParams;
}
package com.pashanhoo.qys.entity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
@Data
@EqualsAndHashCode(callSuper = false)
public class DocumentParam implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 是
* 模板参数名称
*/
private String name;
/**
* 是
* 模板参数值
*/
private String value;
}
package com.pashanhoo.qys.entity;
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 lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.Date;
/**
* 电子证照表实体
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("ELEC_LICENSE_INFO")
public class ElecLicenseInfoDo {
/**
* 合同标识,主键,自己生成
*/
/**
* 主键
*/
@TableId(value = "BIZ_ID", type = IdType.UUID)
private String bizId;
/**
* 合同ID
*/
@TableField("CONTRACT_ID")
private Long contractId;
/**
* 模板参数
*/
@TableField("DOCUMENT_PARAM")
private String documentParam;
/**
* 合同文档ID
*/
@TableField("DOCUMENT_ID")
private String documentId;
/**
* 合同类型.1:不动产登记证明.2:不动产权证书.3:不动产查询证明
*/
@TableField("HTLX")
private String htlx;
/**
* 业务号
*/
@TableField("YWH")
private String ywh;
/**
* 证书标识
*/
@TableField("ZSBS")
private String zsbs;
/**
* 提交参数
*/
@TableField("TJCS")
private String tjcs;
/**
* 返回结果
*/
@TableField("FHJG")
private String fhjg;
/**
* 推送状态
*/
@TableField("TSZT")
private String tszt;
/**
* 合同状态（DRAFT：草稿，FILLING：拟定中，SIGNING：签署中，COMPLETE：已完成，REJECTED：已退回，RECALLED：已撤回，EXPIRED：已过期，TERMINATING：作废中，TERMINATED：已作废，DELETE：已删除，FINISHED：强制完成）
*/
@TableField("HTZT")
private String htzt;
/**
* 推送时间
*/
@TableField("TSSJ")
private Date tssj;
/**
* 是否下载 1是2否
*/
@TableField("SFXZ")
private String sfxz;
/**
* ofd文件地址
*/
@TableField("OFD_WJDZ")
private String ofdWjdz;
/**
* 是否转换1是2否
*/
@TableField("SFZH")
private String sfzh;
/**
* jpg文件地址
*/
@TableField("JPG_WJDZ")
private String jpgWjdz;
/**
* jpg文件地址
*/
@TableField("SIGN_URL")
private String signUrl;
/**
* 备注
*/
@TableField("BZ")
private String bz;
/**
* 二维码图片
*/
@TableField("EWMIMAGE")
private byte[] ewmimage;
/**
* 0：临时状态，1：现势，2：历史状态
*/
@TableField("DZZZ_STATE")
private String dzzz_state;
/**
* 0：正常，1：创建合同接口报错，2：合同详情接口报错，3：下载ofd接口报错，4：ofd转换接口报错
*/
@TableField("ERR_STATE")
private String err_state;
/**
* 证书编号
*/
@TableField("ZSBH")
private String zsbh;
/**
* 权利人名称
*/
@TableField("QLRMC")
private String qlrmc;
/**
* 证件号
*/
@TableField("ZJH")
private String zjh;
}
package com.pashanhoo.qys.entity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.List;
@Data
@EqualsAndHashCode(callSuper = false)
public class SignatoryRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 是
* 签约主体类型：COMPANY（外部企业），PERSONAL（个人）
*/
private String tenantType;
/**
* 是
* 签约主体名称
*/
private String tenantName;
/**
* 是
* 签署顺序（从1开始)；如果想按顺序签署，则分别设置签署方的serialNo为1,2,3；如果想无序签署，则设置签署方的serialNo为1,1,1；设置签署方顺序为1,2,2时，表示第一个先签署，后两个同时签署。
*/
private Integer serialNo;
/**
* 是
* 签约主体名称
*/
private String contact;
/**
* 否
* 签署动作,用印流程非预设且签署方为发起方时，使用用户传入的签署动作，其余情况使用用印流程的配置
*/
private List<ActionRequest> actions;
}
package com.pashanhoo.qys.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.pashanhoo.qys.entity.ElecLicenseInfoDo;
import org.apache.ibatis.annotations.Param;
import java.util.List;
public interface ElecLicenseInfoMapper extends BaseMapper<ElecLicenseInfoDo> {
List<ElecLicenseInfoDo> getEciInfoByZsbs(String zsbs);
List<ElecLicenseInfoDo> getDocumentIdIsNull(String ywh);
/**
* 获取合同文档ID已经入库并且还未下载集合
*
* @return
*/
List<ElecLicenseInfoDo> getWaitForDownload(String ywh);
/**
* 获取已经下载还未转换的集合
*
* @return
*/
List<ElecLicenseInfoDo> getWaitForConvert(String ywh);
/**
* 根据业务号和不动产单元号查询义务人名称
*/
List<String> getYwrMcByCOnditon(@Param("ywh")String ywh, @Param("bdcdyh")String bdcdyh);
void updateEciInfo(@Param("bizId")String bizId);
ElecLicenseInfoDo getElecLicenseInfo(ElecLicenseInfoDo elecLicenseInfoDo);
}
package com.pashanhoo.qys.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.pashanhoo.common.Result;
import com.pashanhoo.qys.entity.ElecLicenseInfoDo;
public interface EciService extends IService<ElecLicenseInfoDo> {
/**
* 定时任务执行接口
*/
void accessCreateContract();
/**
* 手动执行创建合同
*/
Result createContractForHandle(String zsbs,String qlrzjh,String bh);
/**
* 手动执行获取详情
*/
Result accessDetailsForHandle(String biz_id);
/**
* 手动执行下载合同
*/
Result accessDownloadForHandle(String biz_id);
/**
* 手动执行ofd转换
*/
Result convertElecForHandle(String biz_id);
}
package com.pashanhoo.qys.service.impl;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pashanhoo.common.EciHttpUtil;
import com.pashanhoo.common.Result;
import com.pashanhoo.qys.entity.ElecLicenseInfoDo;
import com.pashanhoo.qys.mapper.ElecLicenseInfoMapper;
import com.pashanhoo.qys.service.EciService;
import com.pashanhoo.zhj.mapper.RegBusBdcqzsdjxxMapper;
import net.glxn.qrgen.core.image.ImageType;
import net.glxn.qrgen.javase.QRCode;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.StringUtils;
import org.ofdrw.converter.ImageMaker;
import org.ofdrw.reader.OFDReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.net.URLEncoder;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.SimpleDateFormat;
import java.util.*;
@Service
public class EciServiceImpl extends ServiceImpl<ElecLicenseInfoMapper, ElecLicenseInfoDo> implements EciService {
private static Logger logger = LoggerFactory.getLogger(EciServiceImpl.class);
@Value("${app.hostUrl}")
private String hostUrl;
@Value("${app.bdcdjzmlc}")
private String bdcdjzmlc;
@Value("${app.bdcqzslc}")
private String bdcqzslc;
@Autowired
private RegBusBdcqzsdjxxMapper regBusBdcqzsdjxxMapper;
@Autowired
private ElecLicenseInfoMapper elecLicenseInfoMapper;
@Autowired
private EciHttpUtil eciHttpUtil;
@Override
public void accessCreateContract() {
try{
List<Map> list=assemblyInfo();
if(list!=null && list.size()>0){
for (int i = 0; i < list.size(); i++) {
//=========创建合同t==============
ElecLicenseInfoDo elecLicenseInfo=createContract(list.get(i));
if(null==elecLicenseInfo || !"0".equals(elecLicenseInfo.getErr_state())){
continue;
}
//=========合同详情==============
ElecLicenseInfoDo details=accessDetails(elecLicenseInfo);
if(null==details || !"0".equals(details.getErr_state())){
continue;
}
//=========证照下载==============
ElecLicenseInfoDo download=accessDownload(details);
if(null==download || !"0".equals(download.getErr_state())){
continue;
}
//=========ofd转换==============
ElecLicenseInfoDo ofdzh=convertElec(download);
if(null==ofdzh || !"0".equals(ofdzh.getErr_state())){
continue;
}
//修改电子证书标识
elecLicenseInfoMapper.updateEciInfo(ofdzh.getBizId());
}
}
}catch (Exception ex){
ex.printStackTrace();
}
}
@Override
public Result createContractForHandle(String zsbs, String qlrzjh, String bh) {
List<Map> list=createInfoByHandle(zsbs,qlrzjh,bh);
if(list!=null && list.size()>0){
for (int i = 0; i < list.size(); i++) {
createContract(list.get(i));
}
}
return Result.ok();
}
@Override
public Result accessDetailsForHandle(String biz_id) {
ElecLicenseInfoDo elecLicenseInfoDo=this.getById(biz_id);
if(elecLicenseInfoDo!=null){
accessDetails(elecLicenseInfoDo);
}
return Result.ok();
}
@Override
public Result accessDownloadForHandle(String biz_id) {
ElecLicenseInfoDo elecLicenseInfoDo=this.getById(biz_id);
if(elecLicenseInfoDo!=null){
accessDownload(elecLicenseInfoDo);
}
return Result.ok();
}
@Override
public Result convertElecForHandle(String biz_id) {
ElecLicenseInfoDo elecLicenseInfoDo=this.getById(biz_id);
if(elecLicenseInfoDo!=null){
convertElec(elecLicenseInfoDo);
elecLicenseInfoMapper.updateEciInfo(biz_id);
}
return Result.ok();
}
/**
*插入电子证照表记录
* @param tjcs
* @param documentParam
* @param backjson
* @param jbxxmap
*/
public ElecLicenseInfoDo insertEciInfo(String tjcs,String documentParam, Map backjson,Map jbxxmap){
ElecLicenseInfoDo elecLicenseInfoDo=new ElecLicenseInfoDo();
elecLicenseInfoDo.setTjcs(tjcs);
elecLicenseInfoDo.setDocumentParam(documentParam);
elecLicenseInfoDo.setZsbh((String) jbxxmap.get("BH"));
elecLicenseInfoDo.setQlrmc((String) jbxxmap.get("QLRMC"));
elecLicenseInfoDo.setZjh((String) jbxxmap.get("ZJH"));
if(backjson.isEmpty()){
elecLicenseInfoDo.setErr_state("1");
}else{
if ((Integer)backjson.get("code")==0) {
Long contractId = Long.valueOf((String) backjson.get("contractId"));
//合同ID入库
elecLicenseInfoDo.setContractId(contractId);
elecLicenseInfoDo.setErr_state("0");
regBusBdcqzsdjxxMapper.updateBdcqzsjbxxInfo((String) jbxxmap.get("ID"));
}else{
elecLicenseInfoDo.setErr_state("1");
}
}
elecLicenseInfoDo.setYwh((String) jbxxmap.get("YWH"));
if(((String)jbxxmap.get("BDCQZH")).contains("证明")){
elecLicenseInfoDo.setHtlx("1");
}else{
elecLicenseInfoDo.setHtlx("2");
}
elecLicenseInfoDo.setZsbs((String) jbxxmap.get("ID"));
elecLicenseInfoDo.setEwmimage(getImage((String) jbxxmap.get("ID"),(String) jbxxmap.get("QLRMC"),(String) jbxxmap.get("ZJH")));
//返回结果入库
elecLicenseInfoDo.setFhjg(JSON.toJSONString(backjson));
//未下载
elecLicenseInfoDo.setSfxz("2");
//未转换
elecLicenseInfoDo.setSfzh("2");
this.save(elecLicenseInfoDo);
return elecLicenseInfoDo;
}
/**
*修改电子证照表记录
* @param tjcs
* @param documentParam
* @param backjson
* @param
*/
public ElecLicenseInfoDo updateEciInfo(String tjcs,String documentParam, Map backjson,ElecLicenseInfoDo elecLicenseInfoDo){
elecLicenseInfoDo.setTjcs(tjcs);
elecLicenseInfoDo.setDocumentParam(documentParam);
if(backjson.isEmpty()){
elecLicenseInfoDo.setErr_state("1");
}else{
if ((Integer)backjson.get("code")==0) {
Long contractId = Long.valueOf((String) backjson.get("contractId"));
//合同ID入库
elecLicenseInfoDo.setContractId(contractId);
elecLicenseInfoDo.setErr_state("0");
regBusBdcqzsdjxxMapper.updateBdcqzsjbxxInfo(elecLicenseInfoDo.getZsbs());
}else{
elecLicenseInfoDo.setErr_state("1");
}
}
//返回结果入库
elecLicenseInfoDo.setFhjg(JSON.toJSONString(backjson));
//未下载
elecLicenseInfoDo.setSfxz("2");
//未转换
elecLicenseInfoDo.setSfzh("2");
this.updateById(elecLicenseInfoDo);
return elecLicenseInfoDo;
}
/**
* 生成文件流
* @param jbxxId
* @return
*/
public byte[] getImage(String jbxxId,String qlr,String zjh){
byte[] data=null;
try{
String imageurl="https://www.hzbdcdj.com/api?scene="+jbxxId+"&qlr="+ URLEncoder.encode(qlr,"UTF-8")+"&zjh="+zjh;
logger.info("55555555============"+imageurl);
ByteArrayOutputStream out= QRCode.from(imageurl).to(ImageType.PNG).stream();
data = out.toByteArray();
}catch (Exception ex){
ex.printStackTrace();
}
return data;
}
/**
* 根据基本信息id生成二维码图片加密字符串
* @param jbxxId
* @return
*/
public String getBase64ewm(String jbxxId,String qlr,String zjh){
byte[] data=getImage(jbxxId,qlr,zjh);
String base64ewm =Base64.encodeBase64String(data);
return base64ewm;
}
/**
* 创建合同
* @param map
*/
public ElecLicenseInfoDo createContract(Map map){
String url=hostUrl + "/contract/createbycategory";
ElecLicenseInfoDo elecLicenseInfo=null;
try{
String ywh = (String) map.get("YWH");
Map jsonMap = new HashMap();
jsonMap.put("sn", ywh);
jsonMap.put("send", "true");
jsonMap.put("creatorName", "");
jsonMap.put("creatorContact", "");
jsonMap.put("tenantName", "汉中市不动产登记交易服务中心");
String zsbh= (String) map.get("BH");//去掉汉字的证书编号，数字组合
Map<String, String> documentMap = new HashMap<String, String>();
String bdcqzh = (String) map.get("BDCQZH");
if (bdcqzh.contains("证明")) {
jsonMap.put("subject", "不动产登记证明");
jsonMap.put("categoryId", bdcdjzmlc);
List<String> ywrmcList=elecLicenseInfoMapper.getYwrMcByCOnditon(ywh,(String) map.get("BDCDYH"));
documentMap.put("bdczmh", zsbh);
documentMap.put("zmqlhsx",getzmsx((String) map.get("DJLX"),(String) map.get("BDCDYH")));
documentMap.put("ywr", StringUtils.join(ywrmcList.toArray(), ","));
documentMap.put("qt", map.get("QT")==null ? "无": (String) map.get("QT"));
} else {
jsonMap.put("subject", "不动产登记证书");
jsonMap.put("categoryId", bdcqzslc);
documentMap.put("bdcqzh",zsbh);
documentMap.put("gyqk", map.get("GYQK")==null ? "": (String) map.get("GYQK"));
documentMap.put("qllx", map.get("QLLX")==null ? "": (String) map.get("QLLX"));
documentMap.put("qlxz", map.get("QLXZ")==null ? "": (String) map.get("QLXZ"));
documentMap.put("yt", map.get("YT")==null ? "": (String) map.get("YT"));
documentMap.put("mj", map.get("MJ")==null ? "": (String) map.get("MJ"));
documentMap.put("syqx", map.get("SYQX")==null ? "": (String) map.get("SYQX"));
documentMap.put("qlqtzk", map.get("QLQTZK")==null ? "": (String) map.get("QLQTZK"));
}
List list2 = new ArrayList();
Map map2 = new HashMap();
map2.put("type", "CORPORATE");
map2.put("name", "汉中市不动产登记交易服务中心");
map2.put("serialNo", "1");
list2.add(map2);
List list1 = new ArrayList();
Map map1 = new HashMap();
map1.put("tenantType", "CORPORATE");
map1.put("tenantName", "汉中市不动产登记交易服务中心");
map1.put("serialNo", "1");
map1.put("actions", list2);
list1.add(map1);
jsonMap.put("signatories", list1);
documentMap.put("djsj", map.get("Y")==null ? "":(String) map.get("Y"));
documentMap.put("y", map.get("Y")==null ? "":(String) map.get("Y"));
documentMap.put("m", map.get("M")==null ? "":(String) map.get("M"));
documentMap.put("d", map.get("D")==null ? "":(String) map.get("D"));
documentMap.put("qlr", map.get("QLRMC")==null ? "":(String) map.get("QLRMC"));
documentMap.put("zl", map.get("ZL")==null ? "":(String) map.get("ZL"));
documentMap.put("bdcdyh", map.get("BDCDYH")==null ? "":(String) map.get("BDCDYH"));
documentMap.put("fj", "业务号："+ywh);
documentMap.put("qx", "汉台区");
String base64ewm =getBase64ewm((String) map.get("ID"),(String) map.get("QLRMC"),(String) map.get("ZJH"));
Map ewmMap = new HashMap();
ewmMap.put("fileName", map.get("ID")+".png");
ewmMap.put("value", "data:image/png;base64,"+base64ewm);
documentMap.put("ewm", JSON.toJSONString(ewmMap));
List<Map> arryList = new ArrayList<Map>();
for (Map.Entry<String, String> entry : documentMap.entrySet()) {
convert(arryList, entry.getKey(), entry.getValue());
}
jsonMap.put("documentParams", arryList);
String inparam=JSON.toJSONString(jsonMap);
Map jsonObject =eciHttpUtil.doPostForNew(url, inparam);
elecLicenseInfo =new ElecLicenseInfoDo();
elecLicenseInfo.setYwh((String) map.get("YWH"));
elecLicenseInfo.setZsbs((String) map.get("ID"));
elecLicenseInfo.setZsbh(zsbh);
elecLicenseInfo.setZjh((String) map.get("ZJH"));
elecLicenseInfo =elecLicenseInfoMapper.getElecLicenseInfo(elecLicenseInfo);
if(elecLicenseInfo==null){
//电子证照表记录
elecLicenseInfo=insertEciInfo(inparam,JSON.toJSONString(documentMap),jsonObject,map);
}else{
elecLicenseInfo=updateEciInfo(inparam,JSON.toJSONString(documentMap),jsonObject,elecLicenseInfo);
}
}catch (Exception ex){
ex.printStackTrace();
}
return elecLicenseInfo;
}
public void convert(List arryList,String name,String value){
Map map=new HashMap();
map.put("name",name);
map.put("value",value);
arryList.add(map);
}
public ElecLicenseInfoDo accessDetails(ElecLicenseInfoDo waitForDetail) {
ElecLicenseInfoDo elecLicenseInfoDo=null;
try {
Long contractId = waitForDetail.getContractId();
String url = hostUrl+ "/contract/detail?contractId=" + contractId;
logger.info("请求合同详情接口url:" + url);
Map jsonObject = eciHttpUtil.doGetForNew(url);
if(jsonObject.isEmpty()){
waitForDetail.setErr_state("2");
}else{
Integer code = (Integer) jsonObject.get("code");
logger.info("合同详情接口请求结果:" + jsonObject);
if (code==0) {
Map obj1= (Map) jsonObject.get("contract");
List list= (List) obj1.get("documents");
Map map= (Map) list.get(0);
waitForDetail.setErr_state("0");
waitForDetail.setDocumentId((String) map.get("id"));
}else{
waitForDetail.setErr_state("2");
}
}
//文档ID入库
this.updateById(waitForDetail);
elecLicenseInfoDo=waitForDetail;
} catch (Exception e) {
e.printStackTrace();
}
return elecLicenseInfoDo;
}
/**
* 下载合同方法
* @return
*/
public ElecLicenseInfoDo accessDownload(ElecLicenseInfoDo waitForDownload) {
ElecLicenseInfoDo downloadInfo=null;
try{
String documentId = waitForDownload.getDocumentId();
String bh=waitForDownload.getZsbh();
String ofdPath = eciHttpUtil.download(documentId,bh);
if (StringUtils.isNotBlank(ofdPath)) {
//入库ofd文件地址
waitForDownload.setSfxz("1");
waitForDownload.setOfdWjdz(ofdPath);
waitForDownload.setErr_state("0");
}else{
waitForDownload.setErr_state("3");
}
this.updateById(waitForDownload);
downloadInfo=waitForDownload;
}catch (Exception ex){
ex.printStackTrace();
}
return downloadInfo;
}
public ElecLicenseInfoDo convertElec(ElecLicenseInfoDo waitForConvert) {
//转换后文件输出路径
ElecLicenseInfoDo convert=null;
try {
String ofdPath = waitForConvert.getOfdWjdz();
String id=waitForConvert.getDocumentId();
String bh=waitForConvert.getZsbh();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy");
String dateDir = simpleDateFormat.format(new Date());
String url=ofdToImg(ofdPath,"D:\\ECI\\"+ dateDir+bh+"\\",id);
if(StringUtils.isNotBlank(url)){
waitForConvert.setSfzh("1");
waitForConvert.setJpgWjdz(url);
waitForConvert.setErr_state("0");
}else{
waitForConvert.setErr_state("4");
}
this.updateById(waitForConvert);
convert=waitForConvert;
} catch (Exception e) {
e.printStackTrace();
}
return convert;
}
/**
* 将ofd转换为图片
* @param
* @param imgPath 目标文件路径
*/
public String ofdToImg(String ofdPath, String imgPath,String id) {
File savePath = new File(imgPath);
if (!savePath.exists()) {
savePath.mkdirs();
}
// 1. 文件输入路径
Path src = Paths.get(ofdPath);
// 2. 加载指定目录字体(非必须)
// FontLoader.getInstance().scanFontDir(new File("src/test/resources/fonts"));
// 3. 创建转换转换对象，设置 每毫米像素数量(Pixels per millimeter)
try(OFDReader reader = new OFDReader(src);) {
ImageMaker imageMaker = new ImageMaker(reader, 15);
for (int i = 0; i < imageMaker.pageSize(); i++) {
// 4. 指定页码转换图片
BufferedImage image = imageMaker.makePage(i);
Path dist = Paths.get( imgPath+ id + ".jpg");
// 5. 存储为指定格式图片
ImageIO.write(image, "JPG", dist.toFile());
return imgPath + id + ".jpg";
}
} catch (IOException e) {
e.printStackTrace();
}
return "";
}
/**
*根据缮证类型决定生成对应的权利相关信息
*/
public List<Map> assemblyInfo(){
List<Map> oldlist=regBusBdcqzsdjxxMapper.getBdcqzsjbxxInfo();
List<Map> list=new ArrayList<Map>();
if(oldlist!=null && oldlist.size()>0){
for (int i = 0; i < oldlist.size(); i++) {
Map map=oldlist.get(i);
String bh= (String)map.get("BH");
String zsbh[]=bh.split(",");
if(zsbh!=null && zsbh.length>0){
String qlqtzk=(String)map.get("QLQTZK");
Map qrlInfoMap=regBusBdcqzsdjxxMapper.getQlrInfoByYwh((String) map.get("YWH"));
String allQlrmc=(String)qrlInfoMap.get("QLRMC");
String allZjh=(String)qrlInfoMap.get("ZJH");
if(StringUtils.isNotBlank(allQlrmc)){
for (int k = 0; k < zsbh.length; k++) {
String qlr[]=allQlrmc.split(",");
String zjh[]=allZjh.split(",");
Map hashMap=new HashMap(map);
hashMap.put("QLRMC",qlr[k]);
hashMap.put("BH",zsbh[k]);
hashMap.put("ZJH",zjh[k]);
List list1= Arrays.asList(qlr);
List arrList = new ArrayList(list1);
arrList.remove(qlr[k]);
String gyr=StringUtils.join(arrList.toArray(),",");
if(StringUtils.isNotBlank(qlqtzk)){
qlqtzk=qlqtzk.substring(0, qlqtzk.length() - 1);
hashMap.put("QLQTZK",qlqtzk+hashMap.get("GYQK")+";共有人："+gyr);
}
list.add(hashMap);
}
}
}
}
}
return list;
}
/**
* 手动版创建合同组件信息
* @return
*/
public List<Map> createInfoByHandle(String zsbs,String qlrzjh,String bh){
List<Map> list=new ArrayList<Map>();
Map map=regBusBdcqzsdjxxMapper.getBdcqzsJbxxById(zsbs);
if(map!=null){
Map qrlInfoMap=regBusBdcqzsdjxxMapper.getQlrInfoByYwh((String) map.get("YWH"));
String allQlrmc=(String)qrlInfoMap.get("QLRMC");
if(StringUtils.isNotBlank(allQlrmc)){
String allZjh=(String)qrlInfoMap.get("ZJH");
if(StringUtils.isNotBlank(allZjh)){
String zjh[]=allZjh.split(",");
String qlqtzk=(String)map.get("QLQTZK");
for (int k = 0; k < zjh.length; k++) {
if(StringUtils.equals(qlrzjh,zjh[k])){
String qlr[]=allQlrmc.split(",");
Map hashMap=new HashMap(map);
hashMap.put("QLRMC",qlr[k]);
hashMap.put("BH",bh);
hashMap.put("ZJH",qlrzjh);
List list1= Arrays.asList(qlr);
List arrList = new ArrayList(list1);
arrList.remove(qlr[k]);
String gyr=StringUtils.join(arrList.toArray(),",");
if(StringUtils.isNotBlank(qlqtzk)){
qlqtzk=qlqtzk.substring(0, qlqtzk.length() - 1);
hashMap.put("QLQTZK",qlqtzk+hashMap.get("GYQK")+";共有人："+gyr);
}
list.add(hashMap);
}
}
}
}
}
return list;
}
public String getzmsx(String djxl,String bdcdyh){
//证明权利或事项
if(djxl.equals("214") || djxl.equals("215")
|| djxl.equals("213") || djxl.equals("209")
|| djxl.equals("315") || djxl.equals("605")
|| djxl.equals("430") || djxl.equals("316")
|| djxl.equals("606") || djxl.equals("431")
|| djxl.equals("427") || djxl.equals("428")
|| djxl.equals("317") || djxl.equals("318")
|| djxl.equals("608") || djxl.equals("433")
|| djxl.equals("422") || djxl.equals("217")){
if(djxl.equals("213") || djxl.equals("316")
|| djxl.equals("606") || djxl.equals("431")
|| djxl.equals("427") || djxl.equals("428")){
return "在建工程抵押权";
}else {
return "抵押权";
}
}else {
//预抵押变更事项可以修改期房和现房的预抵押所以应取上一笔的预抵押信息，获取上一笔抵押登记小类
if (djxl.equals("818") || djxl.equals("607")
|| djxl.equals("432")){
Map rightsInfo= regBusBdcqzsdjxxMapper.getRightsInfo(bdcdyh);
if(rightsInfo!=null){
return regBusBdcqzsdjxxMapper.getInfoByValue((String) rightsInfo.get("REMARKS"),"reg_bus_djxl");
}
}else {
if(djxl.equals("609") || djxl.equals("812") || djxl.equals("809") || djxl.equals("810") || djxl.equals("811")){
return regBusBdcqzsdjxxMapper.getInfoByValue("803","reg_bus_djxl");
}else{
return regBusBdcqzsdjxxMapper.getInfoByValue(djxl,"reg_bus_djxl");
}
}
}
return "";
}
}
package com.pashanhoo.receive.controller;
import com.pashanhoo.common.Result;
import com.pashanhoo.receive.entity.vo.AddDgReceiveRequest;
import com.pashanhoo.receive.entity.vo.DgReceiveSearchRequest;
import com.pashanhoo.receive.service.DgReceiveService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.List;
/**
* <p>
* 档案接收记录 前端控制器
* </p>
*
* @author
* @since 2021-11-05
*/
@RestController
@RequestMapping("/system/dgReceive/")
@Api(tags = "档案接收记录接口")
public class DgReceiveController {
@Autowired
private DgReceiveService dgreceiveService;
@PostMapping("insertDgReceive")
@ApiOperation("新增接收记录接口")
public Result insertDgReceive(@Valid @RequestBody AddDgReceiveRequest request, BindingResult bindingResult) {
if (bindingResult.hasErrors()){
return Result.checkError(bindingResult.getAllErrors().get(0).getDefaultMessage());
}
try {
dgreceiveService.insertDgReceive(request);
}catch (Exception ex){
return Result.error(ex.getMessage());
}
return Result.ok();
}
@PostMapping("search")
@ApiOperation(value = "根据条件进行列表查询")
public Result searchDgReceiveList(@RequestBody DgReceiveSearchRequest request) {
return dgreceiveService.searchDgReceiveList(request);
}
@PostMapping("addBatchArchies")
@ApiOperation("批量归档")
public Result addBatchArchies(@ApiParam("接收记录ID列表") @RequestParam(value = "idList") List<String> idList){
return dgreceiveService.addBatchArchies(idList);
}
}
package com.pashanhoo.receive.entity;
import java.util.List;
import com.pashanhoo.receive.entity.vo.AddDgReceiveRequest;
import com.pashanhoo.receive.entity.vo.DgReceiveDetailVO;
import com.pashanhoo.receive.entity.vo.DgReceiveListVO;
import com.pashanhoo.receive.entity.vo.UpdateDgReceiveRequest;
import org.mapstruct.Mapper;
/**
* @author
* @since 2021-11-05
*/
@Mapper(componentModel = "spring")
public interface DgReceiveConverter{
DgReceiveDO addRequest2DO(AddDgReceiveRequest request);
DgReceiveDetailVO do2DetailVO(DgReceiveDO dgreceiveDO);
DgReceiveDO updateRequest2DO(UpdateDgReceiveRequest request);
DgReceiveListVO do2ListVO(DgReceiveDO dgreceiveDO);
List<DgReceiveListVO> doList2ListVOList(List<DgReceiveDO> dgreceiveDOList);
}
package com.pashanhoo.receive.entity;
import java.math.BigDecimal;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案接收记录
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("DG_RECEIVE")
public class DgReceiveDO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 接收标识码
*/
@TableId(value = "BMS_RECEIVE", type = IdType.UUID)
private String bmsReceive;
/**
* 业务来源编码
*/
@TableField("YWLYJBM")
private String ywlyjbm;
/**
* 权利类型
*/
@TableField("QLLX")
private String qllx;
/**
* 登记类型
*/
@TableField("DJLX")
private String djlx;
/**
* 收件人员
*/
@TableField("SJRY")
private String sjry;
/**
* 收件时间
*/
@TableField("SJSJ")
private Date sjsj;
/**
* 业务号
*/
@TableField("YWH")
private String ywh;
/**
* 不动产单元号
*/
@TableField("BDCDYH")
private String bdcdyh;
/**
* 单元总数
*/
@TableField("DYZS")
private BigDecimal dyzs;
/**
* 不动产权证号
*/
@TableField("BDCQZH")
private String bdcqzh;
/**
* 权利人
*/
@TableField("QLR")
private String qlr;
/**
* 权利人证件号码
*/
@TableField("ZJHM")
private String zjhm;
/**
* 义务人
*/
@TableField("YWR")
private String ywr;
/**
* 坐落
*/
@TableField("ZL")
private String zl;
/**
* 登记时间
*/
@TableField("DJSJ")
private Date djsj;
/**
* 接收时间
*/
@TableField("JSSJ")
private Date jssj;
/**
* 推送机构编码
*/
@TableField("TSJGBM")
private String tsjgbm;
/**
* 归档方式(1：按业务归档，2：按单元归档，3：档案补充归档)
*/
@TableField("GDFS")
private String gdfs;
/**
* 归档时间
*/
@TableField("GDSJ")
private Date gdsj;
/**
* 整理状态(0：待处理，1：已归档)
*/
@TableField("STATE")
private String state;
/**
* 登记业务编码
*/
@TableField("DJYWBM")
private String djywbm;
/**
* 登记业务名称
*/
@TableField("DJYWMC")
private String djywmc;
/**
* 业务标识码
*/
@TableField("BSM_YW")
private String bsm_yw;
}
package com.pashanhoo.receive.entity.vo;
import java.math.BigDecimal;
import java.util.Date;
import java.io.Serializable;
import java.util.List;
import com.pashanhoo.bdcdy.entity.vo.AddDgBdcdyRequest;
import com.pashanhoo.business.entity.vo.AddDgBusinessRequest;
import com.pashanhoo.catalog.entity.vo.AddDgArchivesCatalogRequest;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
import javax.validation.constraints.NotEmpty;
/**
* <p>
* 档案接收记录新增请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案接收记录新增请求实体")
public class AddDgReceiveRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键
*/
@ApiModelProperty(name = "bms_receive", value = "主键")
private String bms_receive;
/**
* 业务来源编码
*/
@NotEmpty(message = "业务来源编码【ywlyjbm】不能为空")
@ApiModelProperty(name = "ywlyjbm", value = "业务来源编码")
private String ywlyjbm;
/**
* 权利类型
*/
@NotEmpty(message = "权利类型【qllx】不能为空")
@ApiModelProperty(name = "qllx", value = "权利类型")
private String qllx;
/**
* 登记类型
*/
@NotEmpty(message = "登记类型【djlx】不能为空")
@ApiModelProperty(name = "djlx", value = "登记类型")
private String djlx;
/**
* 收件人员
*/
@NotEmpty(message = "收件人员【sjry】不能为空")
@ApiModelProperty(name = "sjry", value = "收件人员")
private String sjry;
/**
* 收件时间
*/
@NotEmpty(message = "收件时间【sjsj】不能为空")
@ApiModelProperty(name = "sjsj", value = "收件时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date sjsj;
/**
* 业务号
*/
@NotEmpty(message = "业务号【ywh】不能为空")
@ApiModelProperty(name = "ywh", value = "业务号")
private String ywh;
/**
* 不动产单元号
*/
@NotEmpty(message = "不动产单元号【bdcdyh】不能为空")
@ApiModelProperty(name = "bdcdyh", value = "不动产单元号")
private String bdcdyh;
/**
* 单元总数
*/
@NotEmpty(message = "单元总数【dyzs】不能为空")
@ApiModelProperty(name = "dyzs", value = "单元总数")
private Integer dyzs;
/**
* 不动产权证号
*/
@NotEmpty(message = "不动产权证号【bdcqzh】不能为空")
@ApiModelProperty(name = "bdcqzh", value = "不动产权证号")
private String bdcqzh;
/**
* 权利人
*/
@NotEmpty(message = "权利人【qlr】不能为空")
@ApiModelProperty(name = "qlr", value = "权利人")
private String qlr;
/**
* 权利人证件号码
*/
@NotEmpty(message = "权利人证件号码【zjhm】不能为空")
@ApiModelProperty(name = "zjhm", value = "权利人证件号码")
private String zjhm;
/**
* 义务人
*/
@ApiModelProperty(name = "ywr", value = "义务人")
private String ywr;
/**
* 坐落
*/
@NotEmpty(message = "坐落【zl】不能为空")
@ApiModelProperty(name = "zl", value = "坐落")
private String zl;
/**
* 登记时间
*/
@NotEmpty(message = "登记时间【djsj】不能为空")
@ApiModelProperty(name = "djsj", value = "登记时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date djsj;
/**
* 接收时间
*/
@NotEmpty(message = "接收时间【jssj】不能为空")
@ApiModelProperty(name = "jssj", value = "接收时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date jssj;
/**
* 推送机构编码
*/
@NotEmpty(message = "推送机构编码【tsjgbm】不能为空")
@ApiModelProperty(name = "tsjgbm", value = "推送机构编码")
private String tsjgbm;
/**
* 登记业务编码
*/
@NotEmpty(message = "登记业务编码【djywbm】不能为空")
@ApiModelProperty(name = "djywbm", value = "登记业务编码")
private String djywbm;
/**
* 登记业务名称
*/
@NotEmpty(message = "登记业务名称【djywmc】不能为空")
@ApiModelProperty(name = "djywmc", value = "登记业务名称")
private String djywmc;
/**
* 业务标识码
*/
@NotEmpty(message = "业务标识码【bsm_yw】不能为空")
@ApiModelProperty(name = "bsm_yw", value = "业务标识码")
private String bsm_yw;
/**
* 推送业务信息
*/
@ApiModelProperty(name = "businessRequest", value = "推送业务信息")
private AddDgBusinessRequest businessRequest;
/**
* 不动产单元信息
*/
@ApiModelProperty(name = "businessRequest", value = "推送不动产单元信息")
private List<AddDgBdcdyRequest> bdcdyRequestList;
/**
* 目录信息列表
*/
@ApiModelProperty(name = "catalogRequests", value = "推送目录信息列表")
private List<AddDgArchivesCatalogRequest> catalogRequests;
}
package com.pashanhoo.receive.entity.vo;
import java.math.BigDecimal;
import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案接收记录明细实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案接收记录明细实体")
public class DgReceiveDetailVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 接收标识码
*/
@ApiModelProperty(name = "bmsReceive", value = "接收标识码")
private String bmsReceive;
/**
* 业务来源编码
*/
@ApiModelProperty(name = "ywlyjbm", value = "业务来源编码")
private String ywlyjbm;
/**
* 权利类型
*/
@ApiModelProperty(name = "qllx", value = "权利类型")
private String qllx;
/**
* 登记类型
*/
@ApiModelProperty(name = "djlx", value = "登记类型")
private String djlx;
/**
* 收件人员
*/
@ApiModelProperty(name = "sjry", value = "收件人员")
private String sjry;
/**
* 收件时间
*/
@ApiModelProperty(name = "sjsj", value = "收件时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date sjsj;
/**
* 业务号
*/
@ApiModelProperty(name = "ywh", value = "业务号")
private String ywh;
/**
* 不动产单元号
*/
@ApiModelProperty(name = "bdcdyh", value = "不动产单元号")
private String bdcdyh;
/**
* 单元总数
*/
@ApiModelProperty(name = "dyzs", value = "单元总数")
private Integer dyzs;
/**
* 不动产权证号
*/
@ApiModelProperty(name = "bdcqzh", value = "不动产权证号")
private String bdcqzh;
/**
* 权利人
*/
@ApiModelProperty(name = "qlr", value = "权利人")
private String qlr;
/**
* 权利人证件号码
*/
@ApiModelProperty(name = "zjhm", value = "权利人证件号码")
private String zjhm;
/**
* 义务人
*/
@ApiModelProperty(name = "ywr", value = "义务人")
private String ywr;
/**
* 坐落
*/
@ApiModelProperty(name = "zl", value = "坐落")
private String zl;
/**
* 登记时间
*/
@ApiModelProperty(name = "djsj", value = "登记时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date djsj;
/**
* 接收时间
*/
@ApiModelProperty(name = "jssj", value = "接收时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date jssj;
/**
* 推送机构编码
*/
@ApiModelProperty(name = "tsjgbm", value = "推送机构编码")
private String tsjgbm;
/**
* 归档方式(1：按业务归档，2：按单元归档，3：档案补充归档)
*/
@ApiModelProperty(name = "gdfs", value = "归档方式(1：按业务归档，2：按单元归档，3：档案补充归档)")
private String gdfs;
/**
* 归档时间
*/
@ApiModelProperty(name = "gdsj", value = "归档时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date gdsj;
/**
* 整理状态(0：待处理，1：已归档)
*/
@ApiModelProperty(name = "state", value = "整理状态(0：待处理，1：已归档)")
private String state;
}
package com.pashanhoo.receive.entity.vo;
import java.math.BigDecimal;
import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案接收记录列表VO
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案接收记录列表VO")
//TODO 该类属性暂时是完整的全部属性，需进行个性化的增删
public class DgReceiveListVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 接收标识码
*/
@ApiModelProperty(name = "bmsReceive", value = "接收标识码")
private String bmsReceive;
/**
* 业务来源编码
*/
@ApiModelProperty(name = "ywlyjbm", value = "业务来源编码")
private String ywlyjbm;
/**
* 权利类型
*/
@ApiModelProperty(name = "qllx", value = "权利类型")
private String qllx;
/**
* 登记类型
*/
@ApiModelProperty(name = "djlx", value = "登记类型")
private String djlx;
/**
* 收件人员
*/
@ApiModelProperty(name = "sjry", value = "收件人员")
private String sjry;
/**
* 收件时间
*/
@ApiModelProperty(name = "sjsj", value = "收件时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date sjsj;
/**
* 业务号
*/
@ApiModelProperty(name = "ywh", value = "业务号")
private String ywh;
/**
* 不动产单元号
*/
@ApiModelProperty(name = "bdcdyh", value = "不动产单元号")
private String bdcdyh;
/**
* 单元总数
*/
@ApiModelProperty(name = "dyzs", value = "单元总数")
private Integer dyzs;
/**
* 不动产权证号
*/
@ApiModelProperty(name = "bdcqzh", value = "不动产权证号")
private String bdcqzh;
/**
* 权利人
*/
@ApiModelProperty(name = "qlr", value = "权利人")
private String qlr;
/**
* 权利人证件号码
*/
@ApiModelProperty(name = "zjhm", value = "权利人证件号码")
private String zjhm;
/**
* 义务人
*/
@ApiModelProperty(name = "ywr", value = "义务人")
private String ywr;
/**
* 坐落
*/
@ApiModelProperty(name = "zl", value = "坐落")
private String zl;
/**
* 登记时间
*/
@ApiModelProperty(name = "djsj", value = "登记时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date djsj;
/**
* 接收时间
*/
@ApiModelProperty(name = "jssj", value = "接收时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date jssj;
/**
* 推送机构编码
*/
@ApiModelProperty(name = "tsjgbm", value = "推送机构编码")
private String tsjgbm;
/**
* 归档方式(1：按业务归档，2：按单元归档，3：档案补充归档)
*/
@ApiModelProperty(name = "gdfs", value = "归档方式(1：按业务归档，2：按单元归档，3：档案补充归档)")
private String gdfs;
/**
* 归档时间
*/
@ApiModelProperty(name = "gdsj", value = "归档时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date gdsj;
/**
* 整理状态(0：待处理，1：已归档)
*/
@ApiModelProperty(name = "state", value = "整理状态(0：待处理，1：已归档)")
private String state;
}
package com.pashanhoo.receive.entity.vo;
import com.pashanhoo.common.PageInfo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
/**
* <p>
* 档案接收记录列表查询请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案接收记录列表查询请求实体")
public class DgReceiveSearchRequest extends PageInfo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 业务号
*/
@ApiModelProperty(name = "ywh", value = "业务号")
private String ywh;
/**
* 权利类型
*/
@ApiModelProperty(name = "qllx", value = "权利类型")
private String qllx;
/**
* 登记类型
*/
@ApiModelProperty(name = "djlx", value = "登记类型")
private String djlx;
/**
* 业务来源编码
*/
@ApiModelProperty(name = "ywlyjbm", value = "业务来源编码")
private String ywlyjbm;
}
package com.pashanhoo.receive.entity.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="登记业务编码请求实体")
public class DjywbmVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 原登记业务编码
*/
@ApiModelProperty(name = "oncedjywbm", value = "原登记业务编码")
private String oncedjywbm;
/**
* 原登记业务名称
*/
@ApiModelProperty(name = "oncedjywmc", value = "原登记业务名称")
private String oncedjywmc;
/**
* 登记业务编码
*/
@ApiModelProperty(name = "djywbm", value = "登记业务编码")
private String djywbm;
/**
* 登记业务名称
*/
@ApiModelProperty(name = "djywmc", value = "登记业务名称")
private String djywmc;
/**
* 状态
*/
@ApiModelProperty(name = "state", value = "状态")
private String state;
/**
* 归档方式(1：按业务归档，2：按单元归档，3：档案补充归档)
*/
@ApiModelProperty(name = "gdfs", value = "归档方式(1：按业务归档，2：按单元归档，3：档案补充归档)")
private String gdfs;
}
package com.pashanhoo.receive.entity.vo;
import java.math.BigDecimal;
import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案接收记录修改请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案接收记录修改请求实体")
public class UpdateDgReceiveRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 接收标识码
*/
@ApiModelProperty(name = "bmsReceive", value = "接收标识码")
private String bmsReceive;
/**
* 业务来源编码
*/
@ApiModelProperty(name = "ywlyjbm", value = "业务来源编码")
private String ywlyjbm;
/**
* 权利类型
*/
@ApiModelProperty(name = "qllx", value = "权利类型")
private String qllx;
/**
* 登记类型
*/
@ApiModelProperty(name = "djlx", value = "登记类型")
private String djlx;
/**
* 收件人员
*/
@ApiModelProperty(name = "sjry", value = "收件人员")
private String sjry;
/**
* 收件时间
*/
@ApiModelProperty(name = "sjsj", value = "收件时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date sjsj;
/**
* 业务号
*/
@ApiModelProperty(name = "ywh", value = "业务号")
private String ywh;
/**
* 不动产单元号
*/
@ApiModelProperty(name = "bdcdyh", value = "不动产单元号")
private String bdcdyh;
/**
* 单元总数
*/
@ApiModelProperty(name = "dyzs", value = "单元总数")
private Integer dyzs;
/**
* 不动产权证号
*/
@ApiModelProperty(name = "bdcqzh", value = "不动产权证号")
private String bdcqzh;
/**
* 权利人
*/
@ApiModelProperty(name = "qlr", value = "权利人")
private String qlr;
/**
* 权利人证件号码
*/
@ApiModelProperty(name = "zjhm", value = "权利人证件号码")
private String zjhm;
/**
* 义务人
*/
@ApiModelProperty(name = "ywr", value = "义务人")
private String ywr;
/**
* 坐落
*/
@ApiModelProperty(name = "zl", value = "坐落")
private String zl;
/**
* 登记时间
*/
@ApiModelProperty(name = "djsj", value = "登记时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date djsj;
/**
* 接收时间
*/
@ApiModelProperty(name = "jssj", value = "接收时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date jssj;
/**
* 推送机构编码
*/
@ApiModelProperty(name = "tsjgbm", value = "推送机构编码")
private String tsjgbm;
/**
* 归档方式(1：按业务归档，2：按单元归档，3：档案补充归档)
*/
@ApiModelProperty(name = "gdfs", value = "归档方式(1：按业务归档，2：按单元归档，3：档案补充归档)")
private String gdfs;
/**
* 归档时间
*/
@ApiModelProperty(name = "gdsj", value = "归档时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date gdsj;
/**
* 整理状态(0：待处理，1：已归档)
*/
@ApiModelProperty(name = "state", value = "整理状态(0：待处理，1：已归档)")
private String state;
}
package com.pashanhoo.receive.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.pashanhoo.receive.entity.DgReceiveDO;
import com.pashanhoo.receive.entity.vo.DjywbmVO;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* <p>
* 档案接收记录 Mapper 接口
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgReceiveMapper extends BaseMapper<DgReceiveDO> {
boolean updateReceiveBatch(@Param("idList") List<String> idList,@Param("state") String state);
DjywbmVO getDjywbmInfo(@Param("oncedjywbm") String oncedjywbm);
}
package com.pashanhoo.receive.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.pashanhoo.common.Result;
import com.pashanhoo.receive.entity.DgReceiveDO;
import com.pashanhoo.receive.entity.vo.AddDgReceiveRequest;
import com.pashanhoo.receive.entity.vo.DgReceiveDetailVO;
import com.pashanhoo.receive.entity.vo.UpdateDgReceiveRequest;
import com.pashanhoo.receive.entity.vo.DgReceiveSearchRequest;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import java.util.List;
/**
* <p>
* 档案接收记录 服务类
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgReceiveService extends IService<DgReceiveDO> {
/**
* 根据条件进行列表查询
* @param request
* @return
*/
Result searchDgReceiveList(DgReceiveSearchRequest request);
/**
* 批量归档
* @param idList
* @return
*/
Result addBatchArchies(List<String> idList);
/**
* 新增接收记录接口
* @param request
* @return
*/
Result insertDgReceive(AddDgReceiveRequest request) throws Exception;
}
package com.pashanhoo.receive.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pashanhoo.archive.entity.DgArchivesConverter;
import com.pashanhoo.archive.entity.DgArchivesDO;
import com.pashanhoo.archive.entity.vo.AddDgArchivesRequest;
import com.pashanhoo.archive.mapper.DgArchivesMapper;
import com.pashanhoo.archive.service.DgArchivesService;
import com.pashanhoo.bdcdy.entity.DgBdcdyConverter;
import com.pashanhoo.bdcdy.entity.DgBdcdyDO;
import com.pashanhoo.bdcdy.entity.vo.AddDgBdcdyRequest;
import com.pashanhoo.bdcdy.entity.vo.UpdateDgBdcdyRequest;
import com.pashanhoo.bdcdy.service.DgBdcdyService;
import com.pashanhoo.business.entity.DgBusinessDO;
import com.pashanhoo.business.entity.vo.AddDgBusinessRequest;
import com.pashanhoo.business.entity.vo.DgBusinessSearchRequest;
import com.pashanhoo.business.mapper.DgBusinessMapper;
import com.pashanhoo.business.service.DgBusinessService;
import com.pashanhoo.catalog.entity.DgArchivesCatalogConverter;
import com.pashanhoo.catalog.entity.DgArchivesCatalogDO;
import com.pashanhoo.catalog.entity.vo.AddDgArchivesCatalogRequest;
import com.pashanhoo.catalog.service.DgArchivesCatalogService;
import com.pashanhoo.common.Result;
import com.pashanhoo.common.util.fileupload.MinioUtil;
import com.pashanhoo.file.entity.DgFileConverter;
import com.pashanhoo.file.entity.DgFileDO;
import com.pashanhoo.file.entity.vo.FileAttribute;
import com.pashanhoo.file.service.DgFileService;
import com.pashanhoo.receive.entity.DgReceiveConverter;
import com.pashanhoo.receive.entity.DgReceiveDO;
import com.pashanhoo.receive.entity.vo.AddDgReceiveRequest;
import com.pashanhoo.receive.entity.vo.DgReceiveListVO;
import com.pashanhoo.receive.entity.vo.DgReceiveSearchRequest;
import com.pashanhoo.receive.entity.vo.DjywbmVO;
import com.pashanhoo.receive.mapper.DgReceiveMapper;
import com.pashanhoo.receive.service.DgReceiveService;
import com.pashanhoo.receiverelation.entity.DgReceiveRelationConverter;
import com.pashanhoo.receiverelation.entity.DgReceiveRelationDO;
import com.pashanhoo.receiverelation.entity.vo.AddDgReceiveRelationRequest;
import com.pashanhoo.receiverelation.service.DgReceiveRelationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* <p>
* 档案接收记录 服务实现类
* </p>
*
* @author
* @since 2021-11-05
*/
@Service
public class DgReceiveServiceImpl extends ServiceImpl<DgReceiveMapper, DgReceiveDO> implements DgReceiveService {
@Autowired
private DgReceiveConverter dgreceiveConverter;
@Autowired
private DgBdcdyConverter bdcdyConverter;
@Autowired
private DgReceiveMapper dgreceiveMapper;
@Autowired
private DgBusinessService businessService;
@Autowired
private DgBusinessMapper businessMapper;
@Autowired
private DgBdcdyService bdcdyService;
@Autowired
private DgArchivesService archivesService;
@Autowired
private DgArchivesMapper dgarchivesMapper;
@Autowired
private DgArchivesConverter archivesConverter;
@Autowired
private DgReceiveRelationService relationService;
@Autowired
private DgReceiveRelationConverter relationConverter;
@Autowired
private DgArchivesCatalogConverter catalogConverter;
@Autowired
private DgArchivesCatalogService catalogService;
@Autowired
private DgFileConverter fileConverter;
@Autowired
private DgFileService fileService;
@Autowired
private MinioUtil minioUtil;
/**
* 新增记录
* @param request
* @return
*/
@Override
@Transactional(rollbackFor = Exception.class)
public Result insertDgReceive(AddDgReceiveRequest request) throws Exception{
long starttime=System.currentTimeMillis();
//TODO字段值校验
//新增接收表信息=============start===========
//获取接收编码
String receiveBsm= IdWorker.get32UUID();
request.setBms_receive(receiveBsm);
DjywbmVO djywbmVO=dgreceiveMapper.getDjywbmInfo(request.getDjywbm());
DgReceiveDO dgreceiveDO = dgreceiveConverter.addRequest2DO(request);
if(djywbmVO!=null){
dgreceiveDO.setDjywbm(djywbmVO.getDjywbm());
dgreceiveDO.setDjywmc(djywbmVO.getDjywmc());
dgreceiveDO.setGdfs(djywbmVO.getGdfs());
}
this.save(dgreceiveDO);
//新增接收表信息=============end===========
//获取登记传入的不动产单元List集合数据
List<AddDgBdcdyRequest> bdcdyRequestList=request.getBdcdyRequestList();
//获取登记传入的业务数据
AddDgBusinessRequest businessRequest=request.getBusinessRequest();
//获取目录信息
List<AddDgArchivesCatalogRequest> catalogRequestList=request.getCatalogRequests();
//归档方式(1：按业务归档，2：按单元归档，3：档案补充归档)
if("1".equals(dgreceiveDO.getGdfs())){
//新增档案表基础信息
AddDgArchivesRequest archivesRequest=new AddDgArchivesRequest();
String bsm_archives= IdWorker.get32UUID();
archivesRequest.setBsmArchives(bsm_archives);
archivesRequest.setDazt(1);
archivesService.insertDgArchives(archivesRequest);
//新增接收表和档案表关联关系表
AddDgReceiveRelationRequest relationRequest=new AddDgReceiveRelationRequest();
relationRequest.setBmsReceive(receiveBsm);
relationRequest.setBsmArchives(bsm_archives);
relationService.insertDgReceiveRelation(relationRequest);
//新增目录和文件信息
dealCatalogAndFile(catalogRequestList,bsm_archives);
}else if("2".equals(dgreceiveDO.getGdfs())){
List<AddDgReceiveRelationRequest> relationRequestList=new ArrayList<AddDgReceiveRelationRequest>();
List<AddDgArchivesRequest> archivesRequest=new ArrayList<AddDgArchivesRequest>(bdcdyRequestList.size());
AddDgArchivesRequest archivesRequest1=null;
AddDgReceiveRelationRequest receiveRelationRequest=null;
for (int i = 0; i < bdcdyRequestList.size(); i++) {
//组装档案表基础信息
String bsm_archives= IdWorker.get32UUID();
archivesRequest1=new AddDgArchivesRequest();
archivesRequest1.setBsmArchives(bsm_archives);
archivesRequest1.setDazt(1);
archivesRequest.add(archivesRequest1);
//组装接收表和档案表关联关系表
receiveRelationRequest=new AddDgReceiveRelationRequest();
receiveRelationRequest.setBmsReceive(receiveBsm);
receiveRelationRequest.setBsmArchives(bsm_archives);
relationRequestList.add(receiveRelationRequest);
//新增目录和文件信息
dealCatalogAndFile(catalogRequestList,bsm_archives);
}
//批量新增接收表和档案表关联关系表
List<DgReceiveRelationDO> receiveRelationDOList=relationConverter.addReceiveRelationList(relationRequestList);
relationService.saveBatch(receiveRelationDOList);
//批量新增档案表基础信息
List<DgArchivesDO> archivesDOList=archivesConverter.addArchivesList(archivesRequest);
archivesService.saveBatch(archivesDOList);
}else if("3".equals(dgreceiveDO.getGdfs())){
//通过业务号和注销业务号查询业务表是否有数据，有数据则修改
DgBusinessSearchRequest searchRequest=new DgBusinessSearchRequest();
searchRequest.setYwh(businessRequest.getYwh());
searchRequest.setZxywh(businessRequest.getZxywh());
DgBusinessDO businessDO=businessService.searchDgBusiness(searchRequest);
if(businessDO!=null){
businessDO.setZxlx(businessRequest.getZxlx());
//更新业务表中的注销类型
businessMapper.updateById(businessDO);
Date zxsj=null;
for (int i = 0; i < bdcdyRequestList.size(); i++) {
if(businessDO.getBsmArchives().equals(bdcdyRequestList.get(i).getBsmArchives())){
zxsj=bdcdyRequestList.get(i).getZxsj();
break;
}
}
//更新不动产单元表中的注销时间
UpdateDgBdcdyRequest updateDgBdcdyRequest=new UpdateDgBdcdyRequest();
updateDgBdcdyRequest.setBsmArchives(businessDO.getBsmArchives());
updateDgBdcdyRequest.setZxsj(zxsj);
bdcdyService.updateDgBdcdyByArchive(updateDgBdcdyRequest);
}
}
//新增业务表
businessService.insertDgBusiness(businessRequest);
//批量新增不动产单元号表
List<DgBdcdyDO> bdcdyDOList=bdcdyConverter.addRequestListDO(bdcdyRequestList);
bdcdyService.saveBatch(bdcdyDOList);
long endtime=System.currentTimeMillis();
System.out.println("===================该方法总共耗时："+(endtime-starttime)/1000+"秒");
return Result.ok();
}
/**
* 公共增加目录表和文件表信息
* @param catalogRequestList
* @param bsm_archives
*/
private void dealCatalogAndFile(List<AddDgArchivesCatalogRequest> catalogRequestList,String bsm_archives) throws Exception{
try {
//批量组装文件信息=======start=========
List<DgFileDO> fileDOList=new ArrayList<DgFileDO>();
DgFileDO fileDO=null;
for (int j = 0; j < catalogRequestList.size(); j++) {
catalogRequestList.get(j).setBsmArchives(bsm_archives);
String cataLogBsm= IdWorker.get32UUID();
catalogRequestList.get(j).setBsm_catalog(cataLogBsm);
List<String> fileList=catalogRequestList.get(j).getFileList();
for (int k = 0; k <fileList.size() ; k++) {
fileDO=new DgFileDO();
File file=new File(fileList.get(k));
InputStream is =new FileInputStream(file);
String filetype=file.getName().substring(file.getName().lastIndexOf("."));
//文件上传
FileAttribute attribute=minioUtil.transferToMinio(is,file.getName(),filetype,String.valueOf(file.length()));
fileDO.setBsmCatalog(cataLogBsm);
fileDO.setKzm(attribute.getExpandName());
fileDO.setScr("admin");
fileDO.setFjurl(attribute.getSaveUrl());
fileDO.setFjsize(attribute.getFileSize());
fileDOList.add(fileDO);
}
}
//批量组装文件信息=======end=========
//批量组装目录信息
List<DgArchivesCatalogDO> catalogDOList=catalogConverter.addcataListDO(catalogRequestList);
//批量新增目录信息
catalogService.saveBatch(catalogDOList);
//批量新增对应文件信息
fileService.saveBatch(fileDOList);
}catch (Exception ex){
throw ex;
}
}
/**
* 根据条件进行列表查询
* @param request
* @return
*/
@Override
public Result searchDgReceiveList(DgReceiveSearchRequest request) {
Page<DgReceiveDO> pageParam = new Page<DgReceiveDO>(request.getCurrentPage(), request.getPageSize());
QueryWrapper<DgReceiveDO> wrapper = new QueryWrapper<>();
wrapper.eq(request.getYwh()!=null && !"".equals(request.getYwh()),"YWH",request.getYwh());
wrapper.eq(request.getQllx()!=null && !"".equals(request.getQllx()),"QLLX",request.getQllx());
wrapper.eq(request.getDjlx()!=null && !"".equals(request.getDjlx()),"DJLX",request.getDjlx());
wrapper.eq(request.getYwlyjbm()!=null && !"".equals(request.getYwlyjbm()),"YWLYJBM",request.getYwlyjbm());
wrapper.eq("STATE","0");
Page page = this.page(pageParam, wrapper);
List<DgReceiveListVO> list=dgreceiveConverter.doList2ListVOList(page.getRecords());
return Result.ok(list);
}
@Override
@Transactional(rollbackFor = Exception.class)
public Result addBatchArchies(List<String> idList) {
//更新接收表归档时间和归档状态
boolean receiveFlag=dgreceiveMapper.updateReceiveBatch(idList,"1");//整理状态(0：待处理，1：已归档)
//查询接收表和档案表的关联关系表找出对应的档案
//档案状态（1：正在接收；2：正在补录；3：正在修改；4：在库；5：正在销毁；6：已销毁；7：正在借阅；8：已借阅）
boolean archivesFlag=dgarchivesMapper.updateArchivesInfoByReceiveIdList(idList,"4");
if(receiveFlag && archivesFlag){
return Result.ok("操作成功");
}else{
return Result.ok("操作失败");
}
}
}
package com.pashanhoo.receiverelation.entity;
import java.util.List;
import com.pashanhoo.receiverelation.entity.vo.AddDgReceiveRelationRequest;
import com.pashanhoo.receiverelation.entity.vo.DgReceiveRelationDetailVO;
import com.pashanhoo.receiverelation.entity.vo.DgReceiveRelationListVO;
import com.pashanhoo.receiverelation.entity.vo.UpdateDgReceiveRelationRequest;
import org.mapstruct.Mapper;
/**
* @author
* @since 2021-11-10
*/
@Mapper(componentModel = "spring")
public interface DgReceiveRelationConverter{
DgReceiveRelationDO addRequest2DO(AddDgReceiveRelationRequest request);
DgReceiveRelationDetailVO do2DetailVO(DgReceiveRelationDO dgreceiverelationDO);
DgReceiveRelationDO updateRequest2DO(UpdateDgReceiveRelationRequest request);
DgReceiveRelationListVO do2ListVO(DgReceiveRelationDO dgreceiverelationDO);
List<DgReceiveRelationListVO> doList2ListVOList(List<DgReceiveRelationDO> dgreceiverelationDOList);
List<DgReceiveRelationDO> addReceiveRelationList(List<AddDgReceiveRelationRequest> request);
}
package com.pashanhoo.receiverelation.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案接收关联表
* </p>
*
* @author
* @since 2021-11-10
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("DG_RECEIVE_RELATION")
public class DgReceiveRelationDO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 关联标识码
*/
@TableField("BSM_RELATION")
private String bsmRelation;
/**
* 档案标识码
*/
@TableField("BSM_ARCHIVES")
private String bsmArchives;
/**
* 接收标识码
*/
@TableField("BMS_RECEIVE")
private String bmsReceive;
}
package com.pashanhoo.receiverelation.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案接收关联表新增请求实体
* </p>
*
* @author
* @since 2021-11-10
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案接收关联表新增请求实体")
public class AddDgReceiveRelationRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 关联标识码
*/
@ApiModelProperty(name = "bsmRelation", value = "关联标识码")
private String bsmRelation;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 接收标识码
*/
@ApiModelProperty(name = "bmsReceive", value = "接收标识码")
private String bmsReceive;
}
package com.pashanhoo.receiverelation.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案接收关联表明细实体
* </p>
*
* @author
* @since 2021-11-10
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案接收关联表明细实体")
public class DgReceiveRelationDetailVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 关联标识码
*/
@ApiModelProperty(name = "bsmRelation", value = "关联标识码")
private String bsmRelation;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 接收标识码
*/
@ApiModelProperty(name = "bmsReceive", value = "接收标识码")
private String bmsReceive;
}
package com.pashanhoo.receiverelation.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案接收关联表列表VO
* </p>
*
* @author
* @since 2021-11-10
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案接收关联表列表VO")
//TODO 该类属性暂时是完整的全部属性，需进行个性化的增删
public class DgReceiveRelationListVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 关联标识码
*/
@ApiModelProperty(name = "bsmRelation", value = "关联标识码")
private String bsmRelation;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 接收标识码
*/
@ApiModelProperty(name = "bmsReceive", value = "接收标识码")
private String bmsReceive;
}
package com.pashanhoo.receiverelation.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import com.pashanhoo.common.PageInfo;
/**
* <p>
* 档案接收关联表列表查询请求实体
* </p>
*
* @author
* @since 2021-11-10
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案接收关联表列表查询请求实体")
public class DgReceiveRelationSearchRequest extends PageInfo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 关联标识码
*/
@ApiModelProperty(name = "bsmRelation", value = "关联标识码")
private String bsmRelation;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 接收标识码
*/
@ApiModelProperty(name = "bmsReceive", value = "接收标识码")
private String bmsReceive;
}
package com.pashanhoo.receiverelation.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案接收关联表修改请求实体
* </p>
*
* @author
* @since 2021-11-10
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案接收关联表修改请求实体")
public class UpdateDgReceiveRelationRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 关联标识码
*/
@ApiModelProperty(name = "bsmRelation", value = "关联标识码")
private String bsmRelation;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 接收标识码
*/
@ApiModelProperty(name = "bmsReceive", value = "接收标识码")
private String bmsReceive;
}
package com.pashanhoo.receiverelation.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.pashanhoo.receiverelation.entity.DgReceiveRelationDO;
/**
* <p>
* 档案接收关联表 Mapper 接口
* </p>
*
* @author
* @since 2021-11-10
*/
public interface DgReceiveRelationMapper extends BaseMapper<DgReceiveRelationDO> {
}
package com.pashanhoo.receiverelation.service;
import com.pashanhoo.receiverelation.entity.DgReceiveRelationDO;
import com.pashanhoo.receiverelation.entity.vo.AddDgReceiveRelationRequest;
import com.pashanhoo.receiverelation.entity.vo.DgReceiveRelationDetailVO;
import com.pashanhoo.receiverelation.entity.vo.UpdateDgReceiveRelationRequest;
import com.pashanhoo.receiverelation.entity.vo.DgReceiveRelationSearchRequest;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* <p>
* 档案接收关联表 服务类
* </p>
*
* @author
* @since 2021-11-10
*/
public interface DgReceiveRelationService extends IService<DgReceiveRelationDO> {
/**
* 新增记录
* @param request
* @return
*/
boolean insertDgReceiveRelation(AddDgReceiveRelationRequest request);
/**
* 根据主键查询记录详情
* @param id
* @return
*/
DgReceiveRelationDetailVO getDgReceiveRelationDetailById(String id);
/**
* 修改单条记录
* @param request
* @return
*/
boolean updateDgReceiveRelation(UpdateDgReceiveRelationRequest request);
/**
* 根据条件进行列表查询
* @param request
* @return
*/
Page searchDgReceiveRelationList(DgReceiveRelationSearchRequest request);
}
package com.pashanhoo.receiverelation.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pashanhoo.receiverelation.entity.DgReceiveRelationConverter;
import com.pashanhoo.receiverelation.entity.DgReceiveRelationDO;
import com.pashanhoo.receiverelation.entity.vo.AddDgReceiveRelationRequest;
import com.pashanhoo.receiverelation.entity.vo.DgReceiveRelationDetailVO;
import com.pashanhoo.receiverelation.entity.vo.UpdateDgReceiveRelationRequest;
import com.pashanhoo.receiverelation.entity.vo.DgReceiveRelationSearchRequest;
import com.pashanhoo.receiverelation.mapper.DgReceiveRelationMapper;
import com.pashanhoo.receiverelation.service.DgReceiveRelationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
/**
* <p>
* 档案接收关联表 服务实现类
* </p>
*
* @author
* @since 2021-11-10
*/
@Service
public class DgReceiveRelationServiceImpl extends ServiceImpl<DgReceiveRelationMapper, DgReceiveRelationDO> implements DgReceiveRelationService {
@Autowired
private DgReceiveRelationConverter dgreceiverelationConverter;
@Autowired
private DgReceiveRelationMapper dgreceiverelationMapper;
/**
* 新增记录
* @param request
* @return
*/
@Override
public boolean insertDgReceiveRelation(AddDgReceiveRelationRequest request) {
DgReceiveRelationDO dgreceiverelationDO = dgreceiverelationConverter.addRequest2DO(request);
return this.save(dgreceiverelationDO);
}
/**
* 根据主键查询记录详情
* @param id
* @return
*/
@Override
public DgReceiveRelationDetailVO getDgReceiveRelationDetailById(String id) {
DgReceiveRelationDO dgreceiverelationDO = this.getById(id);
return dgreceiverelationConverter.do2DetailVO(dgreceiverelationDO);
}
/**
* 修改单条记录
* @param request
* @return
*/
@Override
public boolean updateDgReceiveRelation(UpdateDgReceiveRelationRequest request) {
DgReceiveRelationDO dgreceiverelationDO = dgreceiverelationConverter.updateRequest2DO(request);
return this.updateById(dgreceiverelationDO);
}
/**
* 根据条件进行列表查询
* @param request
* @return
*/
@Override
public Page searchDgReceiveRelationList(DgReceiveRelationSearchRequest request) {
Page<DgReceiveRelationDO> pageParam = new Page<DgReceiveRelationDO>(request.getCurrentPage(), request.getPageSize());
QueryWrapper<DgReceiveRelationDO> wrapper = new QueryWrapper<>();
//设置默认排序
wrapper = "desc".equals(request.getSortOrder()) ? wrapper.orderByDesc(request.getSortField()) : wrapper.orderByAsc(request.getSortField());
//TODO 根据当前情况设置wrapper条件
Page page = this.page(pageParam, wrapper);
//将查询出来的DO List转为 ListVO List并重新设置到page对象中，并返回page对象
return page.setRecords(dgreceiverelationConverter.doList2ListVOList(page.getRecords()));
}
}
package com.pashanhoo.replenish.controller;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.pashanhoo.common.Result;
import com.pashanhoo.replenish.entity.vo.AddDgArchivesReplenishRequest;
import com.pashanhoo.replenish.entity.vo.DgArchivesReplenishListVO;
import com.pashanhoo.replenish.entity.vo.DgArchivesReplenishSearchRequest;
import com.pashanhoo.replenish.service.DgArchivesReplenishService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* <p>
* 档案补录信息 前端控制器
* </p>
*
* @author
* @since 2021-11-05
*/
@RestController
@RequestMapping("/system/dgArchivesReplenish/")
@Api(tags = "档案补录信息接口")
public class DgArchivesReplenishController {
@Autowired
private DgArchivesReplenishService dgarchivesreplenishService;
@PostMapping("insertDgArchivesReplenish")
@ApiOperation("新增档案补录信息")
public Result insertDgArchivesReplenish(@RequestBody AddDgArchivesReplenishRequest request){
//生成案卷标识码
String bsmArchive = IdWorker.get32UUID();
if(dgarchivesreplenishService.insertDgArchivesReplenish(request,bsmArchive)){
return Result.ok(bsmArchive);
}
return Result.error("新增失败");
}
@DeleteMapping("deleteDgArchivesReplenishByIds")
@ApiOperation(value = "批量删除档案补录信息")
public Result deleteDgArchivesReplenishByIds(@ApiParam("档案标识码") @RequestParam(value = "bsmArchives") List<String> bsmArchives) {
try {
if(dgarchivesreplenishService.delete(bsmArchives)) {
return Result.ok("删除成功");
}
} catch (Exception e) {
return Result.exception(e.getMessage());
}
return Result.ok("删除失败");
}
@GetMapping("getDgArchivesReplenishDetailById")
@ApiOperation(value = "读取明细")
public Result getDgArchivesReplenishDetailById(@ApiParam("档案补录信息ID") @RequestParam String id){
return Result.ok(dgarchivesreplenishService.getDgArchivesReplenishDetailById(id));
}
@PostMapping("search")
@ApiOperation(value = "补录列表根据条件查询")
public Result<IPage<DgArchivesReplenishListVO>> searchDgArchivesReplenishList(@RequestBody DgArchivesReplenishSearchRequest request) {
return Result.ok(dgarchivesreplenishService.searchDgArchivesReplenishList(request));
}
@GetMapping("doReplenishArchive")
@ApiOperation(value = "归档")
public Result doReplenishArchive(@ApiParam("档案补录标识码") @RequestParam String bsmModify,@ApiParam("档案标识码") @RequestParam String bsmArchive){
boolean flag = dgarchivesreplenishService.doReplenishArchive(bsmModify, bsmArchive);
if (flag) {
return Result.ok("归档成功");
} else {
return Result.error("归档失败");
}
}
}
package com.pashanhoo.replenish.entity;
import java.util.List;
import com.pashanhoo.archive.entity.vo.UpdateArchiveAndOtherInfoRequest;
import com.pashanhoo.replenish.entity.vo.AddDgArchivesReplenishRequest;
import com.pashanhoo.replenish.entity.vo.DgArchivesReplenishDetailVO;
import com.pashanhoo.replenish.entity.vo.DgArchivesReplenishListVO;
import org.mapstruct.Mapper;
/**
* @author
* @since 2021-11-05
*/
@Mapper(componentModel = "spring")
public interface DgArchivesReplenishConverter{
DgArchivesReplenishDO addRequest2DO(AddDgArchivesReplenishRequest request);
DgArchivesReplenishDetailVO do2DetailVO(DgArchivesReplenishDO dgarchivesreplenishDO);
DgArchivesReplenishDO updateRequest2DO(UpdateArchiveAndOtherInfoRequest request);
DgArchivesReplenishListVO do2ListVO(DgArchivesReplenishDO dgarchivesreplenishDO);
List<DgArchivesReplenishListVO> doList2ListVOList(List<DgArchivesReplenishDO> dgarchivesreplenishDOList);
}
package com.pashanhoo.replenish.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案补录信息
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("DG_REPLENISH")
public class DgArchivesReplenishDO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 修改标识码
*/
@TableId(value = "BSM_MODIFY", type = IdType.UUID)
private String bsmModify;
/**
* 档案标识码
*/
@TableField("BSM_ARCHIVES")
private String bsmArchives;
/**
* 原档案信息
*/
@TableField("BLBH")
private String blbh;
/**
* 创建时间
*/
@TableField("CREATETIME")
private Date createTime;
/**
* 修改人
*/
@TableField("CREATER")
private String creater;
/**
* 备注
*/
@TableField("BZ")
private String bz;
/**
* 状态1:补录中,2:已归档
*/
@TableField("STATE")
@DateTimeFormat(pattern = "yyyy-MM-dd")
@JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
private String state;
/**
* 归档时间
*/
@TableField("GDSJ")
@DateTimeFormat(pattern = "yyyy-MM-dd")
@JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
private Date gdsj;
}
package com.pashanhoo.replenish.entity.vo;
import java.io.Serializable;
import java.util.List;
import com.pashanhoo.archive.entity.vo.AddDgArchivesRequest;
import com.pashanhoo.bdcdy.entity.vo.AddDgBdcdyRequest;
import com.pashanhoo.business.entity.vo.AddDgBusinessRequest;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 档案补录信息新增请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案补录信息新增请求实体")
public class AddDgArchivesReplenishRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 新增案卷基本信息
*/
@ApiModelProperty(name = "addDgArchivesRequest", value = "新增案卷基本信息")
private AddDgArchivesRequest addDgArchivesRequest;
/**
* 新增业务信息
*/
@ApiModelProperty(name = "addDgBusinessRequest",value = "新增业务信息")
private AddDgBusinessRequest addDgBusinessRequest;
/**
* 新增不动产单元信息
*/
@ApiModelProperty(name = "addDgBdcdyRequests",value = "新增不动产单元信息")
private List<AddDgBdcdyRequest> addDgBdcdyRequests;
}
package com.pashanhoo.replenish.entity.vo;
import java.util.Date;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.TableField;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案补录信息明细实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案补录信息明细实体")
public class DgArchivesReplenishDetailVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 修改标识码
*/
@ApiModelProperty(name = "bsmModify", value = "修改标识码")
private String bsmModify;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 原档案信息
*/
@ApiModelProperty(name = "blbh", value = "原档案信息")
private String blbh;
/**
*补录人
*/
@ApiModelProperty(name = "creater", value = "补录人")
private String creater;
/**
* 创建时间
*/
@ApiModelProperty(name = "createTime", value = "创建时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 备注
*/
@ApiModelProperty(name = "bz", value = "备注")
private String bz;
/**
* 状态1:补录中,2:已归档
*/
@ApiModelProperty(name = "state", value = "状态1:补录中,2:已归档")
private String state;
/**
* 归档时间
*/
@ApiModelProperty(name = "gdsj", value = "归档时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date gdsj;
}
package com.pashanhoo.replenish.entity.vo;
import java.util.Date;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.TableField;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案补录信息列表VO
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案补录信息列表VO")
public class DgArchivesReplenishListVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 档案标识码
*/
@ApiModelProperty(name = "bsmArchives", value = "档案标识码")
private String bsmArchives;
/**
* 补录标识码
*/
@ApiModelProperty(name = "bsmModify", value = "补录标识码")
private String bsmModify;
/**
* 业务类型名称
*/
@ApiModelProperty(name = "qllx", value = "业务类型名称")
private String qllx;
/**
* 登记类型
*/
@ApiModelProperty(name = "djlx", value = "登记类型")
private String djlx;
/**
* 档案号
*/
@ApiModelProperty(name = "ajh", value = "档案号")
private String ajh;
/**
* 业务号
*/
@ApiModelProperty(name = "ywh", value = "业务号")
private String ywh;
/**
* 不动产单元号数量
*/
@ApiModelProperty(name = "bdcdyNum", value = "不动产单元号数量")
private String bdcdyNum;
/**
* 权利人
*/
@ApiModelProperty(name = "qlr", value = "权利人")
private String qlr;
/**
* 义务人
*/
@ApiModelProperty(name = "ywr", value = "义务人")
private String ywr;
/**
* 不动产证件号码
*/
@ApiModelProperty(name = "bdcqzh", value = "不动产证件号码")
private String bdcqzh;
/**
* 创建时间
*/
@ApiModelProperty(name = "createTime", value = "创建时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 补录人
*/
@ApiModelProperty(name = "creater", value = "补录人")
private String creater;
/**
* 不动产单元号
*/
@ApiModelProperty(name = "bdcdyh", value = "不动产单元号")
private String bdcdyh;
/**
* 状态1:补录中,2:已归档
*/
@ApiModelProperty(name = "state", value = "状态1:补录中,2:已归档")
private String state;
/**
* 归档时间
*/
@TableField("GDSJ")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date gdsj;
}
package com.pashanhoo.replenish.entity.vo;
import java.util.Date;
import java.io.Serializable;
import com.baomidou.mybatisplus.annotation.TableField;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import com.pashanhoo.common.PageInfo;
import org.springframework.format.annotation.DateTimeFormat;
/**
* <p>
* 档案补录信息列表查询请求实体
* </p>
*
* @author
* @since 2021-11-05
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="档案补录信息列表查询请求实体")
public class DgArchivesReplenishSearchRequest extends PageInfo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 业务号
*/
@ApiModelProperty(name = "ywh", value = "业务号")
private String ywh;
/**
* 权利类型
*/
@ApiModelProperty(name = "qllx", value = "权利类型")
private String qllx;
/**
* 登记类型
*/
@ApiModelProperty(name = "djlx", value = "登记类型")
private String djlx;
/**
*补录人
*/
@ApiModelProperty(name = "creater", value = "补录人")
private String creater;
/**
* 创建时间
*/
@ApiModelProperty(name = "createTime", value = "创建时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;
/**
* 状态1:补录中,2:已归档
*/
@ApiModelProperty(name = "state", value = "状态1:补录中,2:已归档")
private String state;
/**
* 归档时间
*/
@ApiModelProperty(name = "gdsj", value = "归档时间")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date gdsj;
}
package com.pashanhoo.replenish.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.pashanhoo.replenish.entity.DgArchivesReplenishDO;
import com.pashanhoo.replenish.entity.vo.DgArchivesReplenishListVO;
import com.pashanhoo.replenish.entity.vo.DgArchivesReplenishSearchRequest;
import org.apache.ibatis.annotations.Param;
/**
* <p>
* 档案补录信息 Mapper 接口
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgArchivesReplenishMapper extends BaseMapper<DgArchivesReplenishDO> {
/**
* 补录列表根据条件查询
* @param pageParam
* @param request
* @return
*/
IPage<DgArchivesReplenishListVO> search(@Param("pageParam") IPage<DgArchivesReplenishListVO> pageParam, @Param("request") DgArchivesReplenishSearchRequest request);
}
package com.pashanhoo.replenish.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.IService;
import com.pashanhoo.replenish.entity.*;
import com.pashanhoo.replenish.entity.vo.*;
import java.util.List;
/**
* <p>
* 档案补录信息 服务类
* </p>
*
* @author
* @since 2021-11-05
*/
public interface DgArchivesReplenishService extends IService<DgArchivesReplenishDO> {
/**
* 新增记录
*
* @param request
* @param bsmArchive 主键
* @return
*/
boolean insertDgArchivesReplenish(AddDgArchivesReplenishRequest request,String bsmArchive);
/**
* 根据主键查询记录详情
*
* @param id
* @return
*/
DgArchivesReplenishDetailVO getDgArchivesReplenishDetailById(String id);
/**
* 补录列表根据条件查询
*
* @param request
* @return
*/
IPage<DgArchivesReplenishListVO> searchDgArchivesReplenishList(DgArchivesReplenishSearchRequest request);
/**
* 删除补录信息
*
* @param bsmArchives 档案标识码
* @return
*/
boolean delete(List<String> bsmArchives) throws Exception;
/**
* 补录归档
* 补录记录的状态为已归档和归档日期，一并修改档案记录的状态为在库,判断卷内目录和每个卷内目录对应的附件列表是否为空,如果为空不能归档
*
* @param bsmModify 补录标识码
* @param bsmArchive 档案标识码
* @return
*/
boolean doReplenishArchive(String bsmModify,String bsmArchive);
}
package com.pashanhoo.replenish.service.impl;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pashanhoo.archive.entity.ArchiveStatus;
import com.pashanhoo.archive.entity.DgArchivesConverter;
import com.pashanhoo.archive.entity.DgArchivesDO;
import com.pashanhoo.archive.entity.vo.AddDgArchivesRequest;
import com.pashanhoo.archive.service.DgArchivesService;
import com.pashanhoo.bdcdy.entity.DgBdcdyConverter;
import com.pashanhoo.bdcdy.entity.DgBdcdyDO;
import com.pashanhoo.bdcdy.entity.vo.AddDgBdcdyRequest;
import com.pashanhoo.bdcdy.service.DgBdcdyService;
import com.pashanhoo.business.entity.DgBusinessConverter;
import com.pashanhoo.business.entity.DgBusinessDO;
import com.pashanhoo.business.entity.vo.AddDgBusinessRequest;
import com.pashanhoo.business.service.DgBusinessService;
import com.pashanhoo.catalog.entity.DgArchivesCatalogDO;
import com.pashanhoo.catalog.service.DgArchivesCatalogService;
import com.pashanhoo.common.util.SysCode.SysCodeUtil;
import com.pashanhoo.common.util.SysCode.SysCodeVO;
import com.pashanhoo.common.util.fileupload.MinioConfig;
import com.pashanhoo.common.util.fileupload.MinioUtil;
import com.pashanhoo.file.entity.DgFileDO;
import com.pashanhoo.file.service.DgFileService;
import com.pashanhoo.replenish.entity.DgArchivesReplenishConverter;
import com.pashanhoo.replenish.entity.DgArchivesReplenishDO;
import com.pashanhoo.replenish.entity.vo.AddDgArchivesReplenishRequest;
import com.pashanhoo.replenish.entity.vo.DgArchivesReplenishDetailVO;
import com.pashanhoo.replenish.entity.vo.DgArchivesReplenishListVO;
import com.pashanhoo.replenish.entity.vo.DgArchivesReplenishSearchRequest;
import com.pashanhoo.replenish.mapper.DgArchivesReplenishMapper;
import com.pashanhoo.replenish.service.DgArchivesReplenishService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
/**
* <p>
* 档案补录信息 服务实现类
* </p>
*
* @author
* @since 2021-11-05
*/
@Service
public class DgArchivesReplenishServiceImpl extends ServiceImpl<DgArchivesReplenishMapper, DgArchivesReplenishDO> implements DgArchivesReplenishService {
@Autowired
private DgArchivesReplenishConverter dgarchivesreplenishConverter;
@Autowired
private DgArchivesReplenishMapper dgarchivesreplenishMapper;
@Autowired
private DgArchivesService dgArchivesService;
@Autowired
private DgArchivesConverter dgArchivesConverter;
@Autowired
private DgBusinessService dgBusinessService;
@Autowired
private DgBusinessConverter dgBusinessConverter;
@Autowired
private DgBdcdyService dgBdcdyService;
@Autowired
private DgBdcdyConverter dgBdcdyConverter;
@Autowired
SysCodeUtil sysCodeUtil;
@Autowired
DgArchivesCatalogService dgArchivesCatalogService;
@Autowired
DgFileService dgFileService;
@Autowired
MinioUtil minioUtil;
@Autowired
MinioConfig minioConfig;
/**
* 新增记录
*
* @param request
* @param bsmArchive 生成主键
* @return
*/
@Override
@Transactional(rollbackFor = Exception.class)
public boolean insertDgArchivesReplenish(AddDgArchivesReplenishRequest request,String bsmArchive) {
//案卷基本信息
AddDgArchivesRequest addDgArchivesRequest = request.getAddDgArchivesRequest();
addDgArchivesRequest.setBsmArchives(bsmArchive);
addDgArchivesRequest.setDazt(ArchiveStatus.REPLENISHING.getCode());
DgArchivesDO dgArchivesDO = dgArchivesConverter.addRequest2DO(addDgArchivesRequest);
dgArchivesService.save(dgArchivesDO);
//业务信息
AddDgBusinessRequest addDgBusinessRequest = request.getAddDgBusinessRequest();
addDgBusinessRequest.setBsmArchives(bsmArchive);
DgBusinessDO dgBusinessDO = dgBusinessConverter.addRequest2DO(addDgBusinessRequest);
dgBusinessService.save(dgBusinessDO);
//不动产单元信息
List<AddDgBdcdyRequest> addDgBdcdyRequests = request.getAddDgBdcdyRequests();
for (AddDgBdcdyRequest addDgBdcdyRequest : addDgBdcdyRequests) {
addDgBdcdyRequest.setBsmArchives(bsmArchive);
}
List<DgBdcdyDO> dgBdcdyDOS = dgBdcdyConverter.addRequestListDO(addDgBdcdyRequests);
dgBdcdyService.saveBatch(dgBdcdyDOS);
//档案补录记录
DgArchivesReplenishDO dgArchivesReplenishDO = new DgArchivesReplenishDO();
dgArchivesReplenishDO.setBsmArchives(bsmArchive);
//获取补录编号
SysCodeVO sysCodeVO = new SysCodeVO();
sysCodeVO.setTaskno("BL" + DateUtil.year(DateUtil.date()));
sysCodeVO.setCtype("sequence");
sysCodeVO.setTaskname("补录序列号");
sysCodeVO.setTaskchild(5);
String blbh = sysCodeUtil.getSequence(sysCodeVO);
dgArchivesReplenishDO.setBlbh(blbh);
/******************************************************/
dgArchivesReplenishDO.setCreateTime(DateTime.now());
dgArchivesReplenishDO.setCreater(null);
dgArchivesReplenishDO.setBz(null);
dgArchivesReplenishDO.setState("1");
dgArchivesReplenishDO.setGdsj(null);
return this.save(dgArchivesReplenishDO);
}
/**
* 根据主键查询记录详情
*
* @param id
* @return
*/
@Override
public DgArchivesReplenishDetailVO getDgArchivesReplenishDetailById(String id) {
DgArchivesReplenishDO dgarchivesreplenishDO = this.getById(id);
return dgarchivesreplenishConverter.do2DetailVO(dgarchivesreplenishDO);
}
/**
* 补录列表根据条件查询
*
* @param request
* @return
*/
@Override
public IPage<DgArchivesReplenishListVO> searchDgArchivesReplenishList(DgArchivesReplenishSearchRequest request) {
IPage<DgArchivesReplenishListVO> pageParam = new Page<>(request.getCurrentPage(), request.getPageSize());
IPage<DgArchivesReplenishListVO> result = dgarchivesreplenishMapper.search(pageParam, request);
List<DgArchivesReplenishListVO> records = result.getRecords();
List<DgArchivesReplenishListVO> clean = records.stream().filter(distinctByKey(DgArchivesReplenishListVO::getBsmArchives)).collect(Collectors.toList());
result.setTotal(clean.size());
return result.setRecords(clean);
}
public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
ConcurrentHashMap<Object, Boolean> hashMap = new ConcurrentHashMap<>();
return t -> hashMap.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
}
/**
* 删除补录信息和对应档案资料
*
* @param bsmArchives 档案标识码
* @return
*/
@Override
@Transactional(rollbackFor = Exception.class)
public boolean delete(List<String> bsmArchives) throws Exception {
//删除补录记录
QueryWrapper<DgArchivesReplenishDO> replenishWrapper = new QueryWrapper<>();
replenishWrapper.lambda().in(DgArchivesReplenishDO::getBsmArchives, bsmArchives);
this.remove(replenishWrapper);
//删除不动产信息
QueryWrapper<DgBdcdyDO> bdcdyWrapper = new QueryWrapper<>();
bdcdyWrapper.lambda().in(DgBdcdyDO::getBsmArchives, bsmArchives);
dgBdcdyService.remove(bdcdyWrapper);
//删除档案业务信息
QueryWrapper<DgBusinessDO> businessWrapper = new QueryWrapper<>();
businessWrapper.lambda().in(DgBusinessDO::getBsmArchives, bsmArchives);
dgBusinessService.remove(businessWrapper);
//删除卷内目录信息
QueryWrapper<DgArchivesCatalogDO> catalogWrapper = new QueryWrapper<>();
catalogWrapper.lambda().in(DgArchivesCatalogDO::getBsmArchives, bsmArchives);
List<DgArchivesCatalogDO> catalogList = dgArchivesCatalogService.list(catalogWrapper);
// TODO: 2021/11/16/0016 删除卷内目录操作移动到删除附件表之后
//删除附件表信息
List<String> bsmCatalogs = new ArrayList<>();
for (DgArchivesCatalogDO dgArchivesCatalogDO : catalogList) {
bsmCatalogs.add(dgArchivesCatalogDO.getBsmCatalog());
}
QueryWrapper<DgFileDO> fileWrapper = new QueryWrapper<>();
fileWrapper.lambda().select(DgFileDO::getFjurl).in(DgFileDO::getBsmCatalog, bsmCatalogs);
//获取文件存储路径
List<DgFileDO> files = dgFileService.list(fileWrapper);
QueryWrapper<DgFileDO> deleteWrapper = new QueryWrapper<>();
deleteWrapper.lambda().in(DgFileDO::getBsmCatalog, bsmCatalogs);
dgFileService.remove(deleteWrapper);
//删除卷内目录.测试环境主外键约束需要先删除附件表再删除卷内目录表.所以代码移动到这里
dgArchivesCatalogService.remove(catalogWrapper);
//删除档案信息表
QueryWrapper<DgArchivesDO> archivesWrapper = new QueryWrapper<>();
archivesWrapper.lambda().in(DgArchivesDO::getBsmArchives, bsmArchives);
boolean flag = dgArchivesService.remove(archivesWrapper);
//删除文件服务器附件
List<String> fileUrls = files.stream().map(DgFileDO::getFjurl).collect(Collectors.toList());
for (String fileUrl : fileUrls) {
minioUtil.removeObject(minioConfig.getBucket(), fileUrl);
}
return flag;
}
/**
* 补录归档
* 补录记录的状态为已归档和归档日期，一并修改档案记录的状态为在库,判断卷内目录和每个卷内目录对应的附件列表是否为空,如果为空不能归档.
*
* @param bsmModify 补录标识码
* @param bsmArchive 档案标识码
* @return
*/
@Override
@Transactional(rollbackFor = Exception.class)
public boolean doReplenishArchive(String bsmModify, String bsmArchive) {
//判断卷内目录和附件是否有数据
QueryWrapper<DgArchivesCatalogDO> catalogWrapper = new QueryWrapper<>();
QueryWrapper<DgFileDO> fileWrapper = new QueryWrapper<>();
catalogWrapper.lambda().eq(DgArchivesCatalogDO::getBsmArchives, bsmArchive);
//目录集合
List<DgArchivesCatalogDO> catalogDOList = dgArchivesCatalogService.list(catalogWrapper);
//获取附件集合
List<String> bsmCatalogs = catalogDOList.stream().map(DgArchivesCatalogDO::getBsmCatalog).collect(Collectors.toList());
if (CollUtil.isEmpty(catalogDOList)) {
return false;
}
for (String bsmCatalog : bsmCatalogs) {
fileWrapper.lambda().eq(DgFileDO::getBsmCatalog, bsmCatalog);
List<DgFileDO> fileDOList = dgFileService.list(fileWrapper);
if (CollUtil.isEmpty(fileDOList)) {
return false;
}
}
//更新补录表归档信息
UpdateWrapper<DgArchivesReplenishDO> replenishUpdateWrapper = new UpdateWrapper<>();
DgArchivesReplenishDO replenishDO = new DgArchivesReplenishDO();
replenishDO.setBsmModify(bsmModify);
replenishUpdateWrapper.lambda().set(DgArchivesReplenishDO::getCreateTime, DateUtil.date()).set(DgArchivesReplenishDO::getState, "2").eq(DgArchivesReplenishDO::getBsmModify, bsmModify);
this.update(replenishDO, replenishUpdateWrapper);
//更新档案表状态
UpdateWrapper<DgArchivesDO> archiveUpdateWrapper = new UpdateWrapper<>();
DgArchivesDO archivesDO = new DgArchivesDO();
archivesDO.setBsmArchives(bsmArchive);
archiveUpdateWrapper.lambda().set(DgArchivesDO::getDazt, ArchiveStatus.STORED.getCode()).eq(DgArchivesDO::getBsmArchives, bsmArchive);
return dgArchivesService.update(archivesDO, archiveUpdateWrapper);
}
}
package com.pashanhoo.staff.controller;
import com.pashanhoo.common.Result;
import com.pashanhoo.staff.entity.vo.AddDgStaffRequest;
import com.pashanhoo.staff.entity.vo.UpdateDgStaffRequest;
import com.pashanhoo.staff.entity.vo.DgStaffSearchRequest;
import com.pashanhoo.staff.service.DgStaffService;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
/**
* <p>
* 员工登录表 前端控制器
* </p>
*
* @author
* @since 2021-11-08
*/
@RestController
@RequestMapping("/system/dgStaff/")
@Api(tags = "员工登录表接口")
public class DgStaffController {
@Autowired
private DgStaffService dgstaffService;
@PostMapping("insertDgStaff")
@ApiOperation("新增员工登录表")
public Result insertDgStaff(@RequestBody AddDgStaffRequest request){
if(dgstaffService.insertDgStaff(request)){
return Result.ok();
}
return Result.error("新增失败");
}
@DeleteMapping("deleteDgStaffByIds")
@ApiOperation(value = "批量删除员工登录表")
public Result deleteDgStaffByIds(@ApiParam("员工登录表ID列表") @RequestParam(value = "idList") List<String> idList) {
if(dgstaffService.removeByIds(idList)) {
return Result.ok("删除成功");
}
return Result.error("删除失败");
}
@PutMapping("updateDgStaff")
@ApiOperation("修改员工登录表")
public Result updateDgStaff(@RequestBody UpdateDgStaffRequest request){
if(dgstaffService.updateDgStaff(request)) {
return Result.ok("修改成功");
}
return Result.error("修改失败");
}
@GetMapping("getDgStaffDetailById")
@ApiOperation(value = "读取明细")
public Result getDgStaffDetailById(@ApiParam("员工登录表ID") @RequestParam String id){
return Result.ok(dgstaffService.getDgStaffDetailById(id));
}
@PostMapping("search")
@ApiOperation(value = "根据条件进行列表查询")
public Result searchDgStaffList(@RequestBody DgStaffSearchRequest request) {
//TODO 默认排序条件设置
request.defaultFillPageProp("","");
return Result.ok(dgstaffService.searchDgStaffList(request));
}
}
package com.pashanhoo.staff.entity;
import java.util.List;
import com.pashanhoo.staff.entity.vo.AddDgStaffRequest;
import com.pashanhoo.staff.entity.vo.DgStaffDetailVO;
import com.pashanhoo.staff.entity.vo.DgStaffListVO;
import com.pashanhoo.staff.entity.vo.UpdateDgStaffRequest;
import org.mapstruct.Mapper;
/**
* @author
* @since 2021-11-08
*/
@Mapper(componentModel = "spring")
public interface DgStaffConverter{
DgStaffDO addRequest2DO(AddDgStaffRequest request);
DgStaffDetailVO do2DetailVO(DgStaffDO dgstaffDO);
DgStaffDO updateRequest2DO(UpdateDgStaffRequest request);
DgStaffListVO do2ListVO(DgStaffDO dgstaffDO);
List<DgStaffListVO> doList2ListVOList(List<DgStaffDO> dgstaffDOList);
}
package com.pashanhoo.staff.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 员工登录表
* </p>
*
* @author
* @since 2021-11-08
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("DG_STAFF")
public class DgStaffDO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@TableId(value = "BSM_STAFF", type = IdType.UUID)
private String bsmStaff;
/**
* 员工编码
*/
@TableField("STAFF_ID")
private String staffId;
/**
* 员工名称
*/
@TableField("STAFF_NAME")
private String staffName;
/**
* 登录密码
*/
@TableField("STAFF_PASSWORD")
private String staffPassword;
/**
* 角色编码
*/
@TableField("STAFF_ROLE_CODE")
private String staffRoleCode;
/**
* 角色名称
*/
@TableField("STAFF_ROLE_NAME")
private String staffRoleName;
/**
* 部门编码
*/
@TableField("STAFF_DEART_ID")
private String staffDeartId;
/**
* 部门名称
*/
@TableField("STAFF_DEART_NAME")
private String staffDeartName;
/**
* 备注
*/
@TableField("REMARK")
private String remark;
}
package com.pashanhoo.staff.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 员工登录表新增请求实体
* </p>
*
* @author
* @since 2021-11-08
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="员工登录表新增请求实体")
public class AddDgStaffRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 员工编码
*/
@ApiModelProperty(name = "staffId", value = "员工编码")
private String staffId;
/**
* 员工名称
*/
@ApiModelProperty(name = "staffName", value = "员工名称")
private String staffName;
/**
* 登录密码
*/
@ApiModelProperty(name = "staffPassword", value = "登录密码")
private String staffPassword;
/**
* 角色编码
*/
@ApiModelProperty(name = "staffRoleCode", value = "角色编码")
private String staffRoleCode;
/**
* 角色名称
*/
@ApiModelProperty(name = "staffRoleName", value = "角色名称")
private String staffRoleName;
/**
* 部门编码
*/
@ApiModelProperty(name = "staffDeartId", value = "部门编码")
private String staffDeartId;
/**
* 部门名称
*/
@ApiModelProperty(name = "staffDeartName", value = "部门名称")
private String staffDeartName;
/**
* 备注
*/
@ApiModelProperty(name = "remark", value = "备注")
private String remark;
}
package com.pashanhoo.staff.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 员工登录表明细实体
* </p>
*
* @author
* @since 2021-11-08
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="员工登录表明细实体")
public class DgStaffDetailVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@ApiModelProperty(name = "bsmStaff", value = "主键ID")
private String bsmStaff;
/**
* 员工编码
*/
@ApiModelProperty(name = "staffId", value = "员工编码")
private String staffId;
/**
* 员工名称
*/
@ApiModelProperty(name = "staffName", value = "员工名称")
private String staffName;
/**
* 登录密码
*/
@ApiModelProperty(name = "staffPassword", value = "登录密码")
private String staffPassword;
/**
* 角色编码
*/
@ApiModelProperty(name = "staffRoleCode", value = "角色编码")
private String staffRoleCode;
/**
* 角色名称
*/
@ApiModelProperty(name = "staffRoleName", value = "角色名称")
private String staffRoleName;
/**
* 部门编码
*/
@ApiModelProperty(name = "staffDeartId", value = "部门编码")
private String staffDeartId;
/**
* 部门名称
*/
@ApiModelProperty(name = "staffDeartName", value = "部门名称")
private String staffDeartName;
/**
* 备注
*/
@ApiModelProperty(name = "remark", value = "备注")
private String remark;
}
package com.pashanhoo.staff.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 员工登录表列表VO
* </p>
*
* @author
* @since 2021-11-08
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="员工登录表列表VO")
//TODO 该类属性暂时是完整的全部属性，需进行个性化的增删
public class DgStaffListVO implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@ApiModelProperty(name = "bsmStaff", value = "主键ID")
private String bsmStaff;
/**
* 员工编码
*/
@ApiModelProperty(name = "staffId", value = "员工编码")
private String staffId;
/**
* 员工名称
*/
@ApiModelProperty(name = "staffName", value = "员工名称")
private String staffName;
/**
* 登录密码
*/
@ApiModelProperty(name = "staffPassword", value = "登录密码")
private String staffPassword;
/**
* 角色编码
*/
@ApiModelProperty(name = "staffRoleCode", value = "角色编码")
private String staffRoleCode;
/**
* 角色名称
*/
@ApiModelProperty(name = "staffRoleName", value = "角色名称")
private String staffRoleName;
/**
* 部门编码
*/
@ApiModelProperty(name = "staffDeartId", value = "部门编码")
private String staffDeartId;
/**
* 部门名称
*/
@ApiModelProperty(name = "staffDeartName", value = "部门名称")
private String staffDeartName;
/**
* 备注
*/
@ApiModelProperty(name = "remark", value = "备注")
private String remark;
}
package com.pashanhoo.staff.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import com.pashanhoo.common.PageInfo;
/**
* <p>
* 员工登录表列表查询请求实体
* </p>
*
* @author
* @since 2021-11-08
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="员工登录表列表查询请求实体")
//TODO 初始查询条件是全部，需要根据情况自行删减
public class DgStaffSearchRequest extends PageInfo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@ApiModelProperty(name = "bsmStaff", value = "主键ID")
private String bsmStaff;
/**
* 员工编码
*/
@ApiModelProperty(name = "staffId", value = "员工编码")
private String staffId;
/**
* 员工名称
*/
@ApiModelProperty(name = "staffName", value = "员工名称")
private String staffName;
/**
* 登录密码
*/
@ApiModelProperty(name = "staffPassword", value = "登录密码")
private String staffPassword;
/**
* 角色编码
*/
@ApiModelProperty(name = "staffRoleCode", value = "角色编码")
private String staffRoleCode;
/**
* 角色名称
*/
@ApiModelProperty(name = "staffRoleName", value = "角色名称")
private String staffRoleName;
/**
* 部门编码
*/
@ApiModelProperty(name = "staffDeartId", value = "部门编码")
private String staffDeartId;
/**
* 部门名称
*/
@ApiModelProperty(name = "staffDeartName", value = "部门名称")
private String staffDeartName;
/**
* 备注
*/
@ApiModelProperty(name = "remark", value = "备注")
private String remark;
}
package com.pashanhoo.staff.entity.vo;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* <p>
* 员工登录表修改请求实体
* </p>
*
* @author
* @since 2021-11-08
*/
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="员工登录表修改请求实体")
public class UpdateDgStaffRequest implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@ApiModelProperty(name = "bsmStaff", value = "主键ID")
private String bsmStaff;
/**
* 员工编码
*/
@ApiModelProperty(name = "staffId", value = "员工编码")
private String staffId;
/**
* 员工名称
*/
@ApiModelProperty(name = "staffName", value = "员工名称")
private String staffName;
/**
* 登录密码
*/
@ApiModelProperty(name = "staffPassword", value = "登录密码")
private String staffPassword;
/**
* 角色编码
*/
@ApiModelProperty(name = "staffRoleCode", value = "角色编码")
private String staffRoleCode;
/**
* 角色名称
*/
@ApiModelProperty(name = "staffRoleName", value = "角色名称")
private String staffRoleName;
/**
* 部门编码
*/
@ApiModelProperty(name = "staffDeartId", value = "部门编码")
private String staffDeartId;
/**
* 部门名称
*/
@ApiModelProperty(name = "staffDeartName", value = "部门名称")
private String staffDeartName;
/**
* 备注
*/
@ApiModelProperty(name = "remark", value = "备注")
private String remark;
}
package com.pashanhoo.staff.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.pashanhoo.staff.entity.DgStaffDO;
/**
* <p>
* 员工登录表 Mapper 接口
* </p>
*
* @author
* @since 2021-11-08
*/
public interface DgStaffMapper extends BaseMapper<DgStaffDO> {
}
package com.pashanhoo.staff.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.pashanhoo.staff.entity.DgStaffDO;
import com.pashanhoo.staff.entity.vo.AddDgStaffRequest;
import com.pashanhoo.staff.entity.vo.DgStaffDetailVO;
import com.pashanhoo.staff.entity.vo.UpdateDgStaffRequest;
import com.pashanhoo.staff.entity.vo.DgStaffSearchRequest;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
/**
* <p>
* 员工登录表 服务类
* </p>
*
* @author
* @since 2021-11-08
*/
public interface DgStaffService extends IService<DgStaffDO> {
/**
* 新增记录
* @param request
* @return
*/
boolean insertDgStaff(AddDgStaffRequest request);
/**
* 根据主键查询记录详情
* @param id
* @return
*/
DgStaffDetailVO getDgStaffDetailById(String id);
/**
* 修改单条记录
* @param request
* @return
*/
boolean updateDgStaff(UpdateDgStaffRequest request);
/**
* 根据条件进行列表查询
* @param request
* @return
*/
Page searchDgStaffList(DgStaffSearchRequest request);
}
package com.pashanhoo.staff.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pashanhoo.staff.entity.DgStaffConverter;
import com.pashanhoo.staff.entity.DgStaffDO;
import com.pashanhoo.staff.entity.vo.AddDgStaffRequest;
import com.pashanhoo.staff.entity.vo.DgStaffDetailVO;
import com.pashanhoo.staff.entity.vo.UpdateDgStaffRequest;
import com.pashanhoo.staff.entity.vo.DgStaffSearchRequest;
import com.pashanhoo.staff.mapper.DgStaffMapper;
import com.pashanhoo.staff.service.DgStaffService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
/**
* <p>
* 员工登录表 服务实现类
* </p>
*
* @author
* @since 2021-11-08
*/
@Service
public class DgStaffServiceImpl extends ServiceImpl<DgStaffMapper, DgStaffDO> implements DgStaffService {
@Autowired
private DgStaffConverter dgstaffConverter;
@Autowired
private DgStaffMapper dgstaffMapper;
/**
* 新增记录
* @param request
* @return
*/
@Override
public boolean insertDgStaff(AddDgStaffRequest request) {
DgStaffDO dgstaffDO = dgstaffConverter.addRequest2DO(request);
return this.save(dgstaffDO);
}
/**
* 根据主键查询记录详情
* @param id
* @return
*/
@Override
public DgStaffDetailVO getDgStaffDetailById(String id) {
DgStaffDO dgstaffDO = this.getById(id);
return dgstaffConverter.do2DetailVO(dgstaffDO);
}
/**
* 修改单条记录
* @param request
* @return
*/
@Override
public boolean updateDgStaff(UpdateDgStaffRequest request) {
DgStaffDO dgstaffDO = dgstaffConverter.updateRequest2DO(request);
return this.updateById(dgstaffDO);
}
/**
* 根据条件进行列表查询
* @param request
* @return
*/
@Override
public Page searchDgStaffList(DgStaffSearchRequest request) {
Page<DgStaffDO> pageParam = new Page<DgStaffDO>(request.getCurrentPage(), request.getPageSize());
QueryWrapper<DgStaffDO> wrapper = new QueryWrapper<>();
wrapper.eq(request.getStaffId()!=null && !"".equals(request.getStaffId()),"STAFF_ID",request.getStaffId());
wrapper.eq(request.getStaffPassword()!=null && !"".equals(request.getStaffPassword()),"STAFF_PASSWORD",request.getStaffPassword());
Page page = this.page(pageParam, wrapper);
//将查询出来的DO List转为 ListVO List并重新设置到page对象中，并返回page对象
return page.setRecords(dgstaffConverter.doList2ListVOList(page.getRecords()));
}
}
package com.pashanhoo.zhj.controller;
import com.pashanhoo.common.Result;
import com.pashanhoo.zhj.service.ZhjDatasSynService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/zhj/")
@Api(tags = "智慧局信息同步相关接口")
public class SynZhjInfoController {
@Autowired
private ZhjDatasSynService zhjDatasSynService;
@PostMapping("ZhjDatasSynInfo")
@ApiOperation("定时智慧局数据同步接口")
public Result ZhjDatasSynInfo() {
zhjDatasSynService.send_bdcYwInfo();
return Result.ok();
}
@PostMapping("synZdInfoByywh")
@ApiOperation("手动执行智慧局数据同步接口")
public Result synZdInfoByywh(@ApiParam("业务号")@RequestParam String ywh) {
zhjDatasSynService.synZdInfoByywh(ywh);
return Result.ok();
}
@PostMapping("synHInfoByYwh")
@ApiOperation("手动执行智慧局数据同步接口")
public Result synHInfoByYwh(@ApiParam("业务号")@RequestParam String ywh) {
zhjDatasSynService.synHInfoByYwh(ywh);
return Result.ok();
}
@PostMapping("synQSZTInfoByYwh")
@ApiOperation("手动执行智慧局数据同步接口")
public Result synQSZTInfoByYwh(@ApiParam("业务号")@RequestParam String ywh) {
zhjDatasSynService.synQSZTInfoByYwh(ywh);
return Result.ok();
}
}
package com.pashanhoo.zhj.entity;
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 lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.Date;
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("REG_BUS_BDCQZSDJXX")
public class RegBusBdcqzsdjxxDo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键
*/
@TableId(value = "ID", type = IdType.UUID)
private String id;
/**
* 业务号
*/
@TableField("YWH")
private String ywh;
/**
* 不动产权证号
*/
@TableField("BDCQZH")
private String bdcqzh;
/**
* 不动产权证编号
*/
@TableField("BDCQZBH")
private String bdcqzbh;
/**
* 印刷序列号
*/
@TableField("YSXLH")
private String ysxlh;
/**
* 登簿时间
*/
@TableField("DBSJ")
private String dbsj;
/**
* 权利人名称
*/
@TableField("QLRMC")
private String qlrmc;
/**
* 共有情况
*/
@TableField("GYQK")
private String gyqk;
/**
* 坐落
*/
@TableField("ZL")
private String zl;
/**
* 宗地代码
*/
@TableField("ZDDM")
private String zddm;
/**
* 不动产单元号
*/
@TableField("BDCDYH")
private String bdcdyh;
/**
* 权利类型
*/
@TableField("QLLX")
private String qllx;
/**
* 权利性质
*/
@TableField("QLXZ")
private String qlxz;
/**
* 用途
*/
@TableField("YT")
private String yt;
/**
* 面积
*/
@TableField("MJ")
private String mj;
/**
* 使用期限
*/
@TableField("SYQX")
private String syqx;
/**
* 权利其他状况
*/
@TableField("QLQTZK")
private String qlqtzk;
/**
* 附记
*/
@TableField("FJ")
private String fj;
/**
* 抵押登记信息
*/
@TableField("DYDJXX")
private String dydjxx;
/**
* 解除抵押登记信息
*/
@TableField("JCDYDJXX")
private String jcdydjxx;
/**
* 查封情况
*/
@TableField("CFQK")
private String cfqk;
/**
* 解除查封
*/
@TableField("JCCF")
private String jccf;
/**
* 图号
*/
@TableField("TH")
private String th;
/**
* 批文号
*/
@TableField("PWH")
private String pwh;
/**
* 划拨价款
*/
@TableField("HBJK")
private String hbjk;
/**
* 划拨合同号
*/
@TableField("HBHTH")
private String hbhth;
/**
* 发证时间
*/
@TableField("FZSJ")
private String fzsj;
/**
* 终止时间
*/
@TableField("ZZSJ")
private String zzsj;
/**
* 登记类型
*/
@TableField("DJLX")
private String djlx;
/**
* 当前土地或者房屋登记状态
*/
@TableField("STATUS")
private String status;
/**
* 是否注销 分割合并后原数据注销
*/
@TableField("ISLOGOUT")
private String islogout;
/**
* 0:正常办理，1：分割合并变更更正附带确权产生数据
*/
@TableField("ISFDSJ")
private Integer isfdsj;
/**
* 是否历史数据手工录入
*/
@TableField("ISHISTORY")
private String ishistory;
/**
* 是否打印出证
*/
@TableField("ISPRINT")
private String isprint;
/**
* 确权类型
*/
@TableField("RIGHTS")
private String rights;
/**
* 创建者
*/
@TableField("CREATE_BY")
private String create_by;
/**
* 创建日期
*/
@TableField("CREATE_DATE")
private Date create_date;
/**
* 更新者
*/
@TableField("UPDATE_BY")
private String update_by;
/**
* 更新日期
*/
@TableField("UPDATE_DATE")
private Date update_date;
/**
* 备注
*/
@TableField("REMARKS")
protected String remarks;
/**
* 删除标记（0：正常；1：删除；2：审核）
*/
@TableField("DEL_FLAG")
protected String del_flag;
/**
* 上手id（原业务id）
*/
@TableField("OLDID")
private String oldid;
}
package com.pashanhoo.zhj.entity;
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 lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.Date;
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("SYN_ZHJINFO")
public class SynZhjInfoDo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键
*/
@TableId(value = "ID", type = IdType.UUID)
private String id;
/**
* 业务号
*/
@TableField("YWH")
private String ywh;
/**
* 宗地表同步状态0：未同步 1：已同步
*/
@TableField("ZD_STATE")
private String zd_state;
/**
* 户表同步状态0：未同步 1：已同步
*/
@TableField("H_STATE")
private String h_state;
/**
* 户权属表同步状态0：未同步 1：已同步
*/
@TableField("HQS_STATE")
private String hqs_state;
/**
* 创建者
*/
@TableField("CREATE_BY")
private String create_by;
/**
* 创建日期
*/
@TableField("CREATE_DATE")
private Date create_date;
/**
* 更新者
*/
@TableField("UPDATE_BY")
private String update_by;
/**
* 更新日期
*/
@TableField("UPDATE_DATE")
private Date update_date;
/**
* 删除标记（0：正常；1：删除；2：审核）
*/
@TableField("DEL_FLAG")
protected String del_flag;
}
package com.pashanhoo.zhj.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.pashanhoo.zhj.entity.RegBusBdcqzsdjxxDo;
import com.pashanhoo.zhj.entity.SynZhjInfoDo;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
public interface RegBusBdcqzsdjxxMapper extends BaseMapper<RegBusBdcqzsdjxxDo> {
/**
* 批量业务号查询登记信息表数据
* @param selectAllListInfo
* @return
*/
List<RegBusBdcqzsdjxxDo> getZsdjInfoList(List<SynZhjInfoDo> selectAllListInfo);
/**
* 业务号查询登记信息表数据
* @param ywh
* @return
*/
List<RegBusBdcqzsdjxxDo> getZsdjInfoListByYwh(String ywh);
/**
* 根据宗地代码查询宗地信息
* @param regBusBdcqzsdjxxDo
* @return
*/
public List<Map> getZdInfoByZddm(RegBusBdcqzsdjxxDo regBusBdcqzsdjxxDo);
/**
* 根据宗地代码查询户信息
* @param regBusBdcqzsdjxxDo
* @return
*/
public List<Map> getHQSInfoByZddm(RegBusBdcqzsdjxxDo regBusBdcqzsdjxxDo);
/**
* 根据宗地代码查询户权属状态信息
* @param regBusBdcqzsdjxxDo
* @return
*/
public List<Map> getQSZTInfoByZddm(RegBusBdcqzsdjxxDo regBusBdcqzsdjxxDo);
/**
* 查询所有需要创建电子证照并且已经登簿的业务信息
* @return
*/
public List<Map> getBdcqzsjbxxInfo();
/**
* 查询所有需要创建电子证照并且已经登簿的业务信息
* @return
*/
public List<Map> getBdcqzsjbxxInfoByYwh(String ywh);
public List<Map> getUserInfo();
public void updateBdcqzsjbxxInfo(String id);
public Map getQlrInfoByYwh(String ywh);
public String getQlrInfoByYwhAndqlr(@Param("ywh") String ywh, @Param("qlrmc") String qlrmc);
public Map getBdcqzsJbxxById(String id);
public String getInfoByValue(@Param("value") String value, @Param("type") String type);
Map getRightsInfo(@Param("bdcdyh")String bdcdyh);
Map getDyqqInfo(@Param("ywh")String ywh,@Param("bdcdyh")String bdcdyh);
String getHtbhInfo(@Param("ywh")String ywh);
Map getBdcjbxxInfo(@Param("bdcdyh")String bdcdyh);
Map getJbxxInfoByYwhAndBdcdyh(@Param("ywh")String ywh,@Param("bdcdyh")String bdcdyh);
Map getJbxxById(@Param("id")String id);
Map getZdjbxxByZddm(@Param("zddm")String zddm);
Map getZrzInfo(@Param("bdcdyh")String bdcdyh);
Map getHInfo(@Param("bdcdyh")String bdcdyh);
}
package com.pashanhoo.zhj.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.pashanhoo.zhj.entity.SynZhjInfoDo;
import java.util.List;
public interface SynZhjInfoMapper extends BaseMapper<SynZhjInfoDo> {
List<SynZhjInfoDo> selectAllInfo();
void updatezdzt(String ywh);
void updateHzt(String ywh);
void updateHqszt(String ywh);
}
package com.pashanhoo.zhj.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.pashanhoo.zhj.entity.RegBusBdcqzsdjxxDo;
public interface ZhjDatasSynService extends IService<RegBusBdcqzsdjxxDo> {
public void send_bdcYwInfo();
public void synZdInfoByywh(String ywh);
public void synHInfoByYwh(String ywh);
public void synQSZTInfoByYwh(String ywh);
}
package com.pashanhoo.zhj.service.impl;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pashanhoo.zhj.entity.RegBusBdcqzsdjxxDo;
import com.pashanhoo.zhj.entity.SynZhjInfoDo;
import com.pashanhoo.zhj.mapper.RegBusBdcqzsdjxxMapper;
import com.pashanhoo.zhj.mapper.SynZhjInfoMapper;
import com.pashanhoo.zhj.service.ZhjDatasSynService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* <p>
* 案卷基本信息 服务实现类
* </p>
*
* @author
* @since 2021-11-05
*/
@Service
public class ZhjDatasSynServiceImpl extends ServiceImpl<RegBusBdcqzsdjxxMapper, RegBusBdcqzsdjxxDo> implements ZhjDatasSynService {
private static Logger logger = LoggerFactory.getLogger(ZhjDatasSynServiceImpl.class);
@Autowired
private SynZhjInfoMapper synZhjInfoMapper;
@Autowired
private RegBusBdcqzsdjxxMapper regBusBdcqzsdjxxMapper;
//智慧局内网ip
private String zhjurl="http://172.16.56.10:7050";
//认证令牌
private String appkey="3cd832c411238faa1df46d532a21bfcd";
private String appSecret="ee7612083f63c2ce0d016c2aefd0a8d2";
public void send_bdcYwInfo() {
List<SynZhjInfoDo> selectAllListInfo=synZhjInfoMapper.selectAllInfo();
if(selectAllListInfo!=null && selectAllListInfo.size()>0){
final List<RegBusBdcqzsdjxxDo> zsdjInfoList=regBusBdcqzsdjxxMapper.getZsdjInfoList(selectAllListInfo);
if(zsdjInfoList!=null && zsdjInfoList.size()>0){
String url=zhjurl+"/dclp/hzapi/token?appKey="+appkey+"&appSecret="+appSecret;
Map map1=doGetForNew(url);
if(map1!=null && (Integer)map1.get("code")==200){
final Map map2= (Map) map1.get("data");
final String token= (String) map2.get("token");
//组装宗地基本信息
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("===============当前线程是:"+Thread.currentThread().getName());
synZdInfo(zsdjInfoList,token);
}
}).start();
//组装户信息
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("===============当前线程是:"+Thread.currentThread().getName());
synHInfo(zsdjInfoList,token);
}
}).start();
//组装权属状态
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("===============当前线程是:"+Thread.currentThread().getName());
synQSZTInfo(zsdjInfoList,token);
}
}).start();
}
}
}
}
/**
*根据业务通过swagger接口手动推送宗地基本信息
* @param ywh
* @param
*/
public void synZdInfoByywh(String ywh){
List<RegBusBdcqzsdjxxDo> zsdjInfoList =regBusBdcqzsdjxxMapper.getZsdjInfoListByYwh(ywh);
if(zsdjInfoList!=null && zsdjInfoList.size()>0){
String url=zhjurl+"/dclp/hzapi/token?appKey="+appkey+"&appSecret="+appSecret;
Map map1=doGetForNew(url);
if(map1!=null && (Integer)map1.get("code")==200){
Map map2= (Map) map1.get("data");
String token= (String) map2.get("token");
synZdInfo(zsdjInfoList,token);
}
}
}
/**
* 给智慧局推送宗地基本信息
* @param zsdjInfoList
* @param token
*/
public void synZdInfo(List<RegBusBdcqzsdjxxDo> zsdjInfoList,String token) {
try{
if(zsdjInfoList!=null && zsdjInfoList.size()>0){
for (int i = 0; i < zsdjInfoList.size(); i++) {
RegBusBdcqzsdjxxDo busBdcqzsdjxxDo= zsdjInfoList.get(i);
List<Map> zdjglist = regBusBdcqzsdjxxMapper.getZdInfoByZddm(busBdcqzsdjxxDo);
if(zdjglist!=null && zdjglist.size()>0){
for (int j = 0; j < zdjglist.size(); j++) {
Map map=zdjglist.get(j);
StringBuilder params = new StringBuilder();
params.append("?").append("DJQDM=").append(map.get("DJQDM")).append("&")
.append("DJQMC=").append(URLEncoder.encode((String) map.get("DJQMC"),"UTF-8")).append("&")
.append("DJZQDM=").append(map.get("DJZQDM")).append("&")
.append("DJZQMC=").append(URLEncoder.encode((String) map.get("DJZQMC"),"UTF-8")).append("&")
.append("BDCDYH=").append(map.get("BDCDYH")).append("&")
.append("ZL=").append(URLEncoder.encode((String) map.get("ZL"),"UTF-8")).append("&")
.append("ZDMJ=").append(map.get("ZDMJ")).append("&")
.append("YT=").append(URLEncoder.encode((String) map.get("YT"),"UTF-8"));
String url1=zhjurl+"/dclp/hzapi/ZDJGMS"+params.toString();
Integer code=doPostForNew(url1,"", token);
if(code==200){
synZhjInfoMapper.updatezdzt(busBdcqzsdjxxDo.getYwh());
}
}
}
}
}
}catch (Exception ex){
ex.printStackTrace();
}
}
/**
* 根据业务通过swagger接口手动推送户信息
* @param ywh
* @param
*/
public void synHInfoByYwh(String ywh){
List<RegBusBdcqzsdjxxDo> zsdjInfoList =regBusBdcqzsdjxxMapper.getZsdjInfoListByYwh(ywh);
if(zsdjInfoList!=null && zsdjInfoList.size()>0){
String url=zhjurl+"/dclp/hzapi/token?appKey="+appkey+"&appSecret="+appSecret;
Map map1=doGetForNew(url);
if(map1!=null && (Integer)map1.get("code")==200){
Map map2= (Map) map1.get("data");
String token= (String) map2.get("token");
synHInfo(zsdjInfoList,token);
}
}
}
/**
* 给智慧局推送户基本信息
* @param zsdjInfoList
* @param token
*/
public void synHInfo(List<RegBusBdcqzsdjxxDo> zsdjInfoList,String token){
try{
if(zsdjInfoList!=null && zsdjInfoList.size()>0){
for (int i = 0; i < zsdjInfoList.size(); i++) {
RegBusBdcqzsdjxxDo busBdcqzsdjxxDo= zsdjInfoList.get(i);
List<Map> hlist = regBusBdcqzsdjxxMapper.getHQSInfoByZddm(busBdcqzsdjxxDo);
if(hlist!=null && hlist.size()>0){
for (int j = 0; j < hlist.size(); j++) {
Map map=hlist.get(j);
StringBuilder params = new StringBuilder();
params.append("?").append("BDCDYH=").append(map.get("BDCDYH")).append("&")
.append("ZRZH=").append(map.get("ZRZH")).append("&")
.append("CH=").append(map.get("CH")).append("&")
.append("ZL=").append(URLEncoder.encode((String) map.get("ZL"),"UTF-8")).append("&")
.append("SJCS=").append(map.get("SJCS")).append("&")
.append("SHBW=").append(URLEncoder.encode((String) map.get("SHBW"),"UTF-8")).append("&")
.append("HX=").append(map.get("HX")).append("&")
.append("HXJG=").append(map.get("HXJG")).append("&")
.append("FWYT1=").append(map.get("FWYT1")).append("&")
.append("SCJZMJ=").append(map.get("SCJZMJ")).append("&")
.append("SCTNJZMJ=").append(map.get("SCTNJZMJ")).append("&")
.append("SCDXBFJZMJ=").append(map.get("SCDXBFJZMJ")).append("&")
.append("FTTDMJ=").append(map.get("FTTDMJ")).append("&")
.append("FWLX=").append(map.get("FWLX")).append("&")
.append("FWXZ=").append(map.get("FWXZ")).append("&")
.append("QLLX=").append(map.get("QLLX")).append("&")
.append("DJLX=").append(map.get("DJLX")).append("&")
.append("SYQMJ=").append(map.get("SYQMJ")).append("&")
.append("SYQQSSJ=").append(map.get("SYQQSSJ")).append("&")
.append("SYQJSSJ=").append(map.get("SYQJSSJ")).append("&")
.append("BDCQZH=").append(URLEncoder.encode((String) map.get("BDCQZH"),"UTF-8")).append("&")
.append("QXDM=").append(map.get("QXDM")).append("&")
.append("DJSJ=").append(map.get("DJSJ")).append("&")
.append("QSZT=").append(map.get("QSZT")).append("&")
.append("ZT=").append(map.get("ZT"));
String url1=zhjurl+"/dclp/hzapi/HQSJGMS"+params.toString();
Integer code=doPostForNew(url1,"", token);
if(code==200){
synZhjInfoMapper.updatezdzt(busBdcqzsdjxxDo.getYwh());
}
}
}
}
}
}catch (Exception ex){
ex.printStackTrace();
}
}
/**
* 给智慧局推送权属状态基本信息
* @param ywh
* @param
*/
public void synQSZTInfoByYwh(String ywh){
List<RegBusBdcqzsdjxxDo> zsdjInfoList =regBusBdcqzsdjxxMapper.getZsdjInfoListByYwh(ywh);
if(zsdjInfoList!=null && zsdjInfoList.size()>0){
String url=zhjurl+"/dclp/hzapi/token?appKey="+appkey+"&appSecret="+appSecret;
Map map1=doGetForNew(url);
if(map1!=null && (Integer)map1.get("code")==200){
Map map2= (Map) map1.get("data");
String token= (String) map2.get("token");
synQSZTInfo(zsdjInfoList,token);
}
}
}
/**
* 给智慧局推送权属状态基本信息
* @param zsdjInfoList
* @param token
*/
public void synQSZTInfo(List<RegBusBdcqzsdjxxDo> zsdjInfoList,String token){
if(zsdjInfoList!=null && zsdjInfoList.size()>0){
for (int i = 0; i < zsdjInfoList.size(); i++) {
RegBusBdcqzsdjxxDo busBdcqzsdjxxDo= zsdjInfoList.get(i);
List<Map> qsztList = regBusBdcqzsdjxxMapper.getQSZTInfoByZddm(busBdcqzsdjxxDo);
if(qsztList!=null && qsztList.size()>0){
for (int j = 0; j < qsztList.size(); j++) {
Map map=qsztList.get(j);
StringBuilder params = new StringBuilder();
params.append("?").append("BDCDYH=").append(map.get("BDCDYH")).append("&")
.append("DYQSZT=").append(map.get("DYQSZT")).append("&")
.append("YYQSZT=").append(map.get("YYQSZT")).append("&")
.append("CFQSZT=").append(map.get("CFQSZT")).append("&")
.append("YGQSZT=").append(map.get("YGQSZT"));
String url1=zhjurl+"/dclp/hzapi/QSZT"+params.toString();
Integer code=doPostForNew(url1,"", token);
if(code==200){
synZhjInfoMapper.updatezdzt(busBdcqzsdjxxDo.getYwh());
}
}
}
}
}
}
public Map doGetForNew(String url) {
logger.info("http request url:" + url);
BufferedReader in = null;
String result = "";
Map jsonObject=new HashMap();
try{
URL url1=new URL(url);
HttpURLConnection conn= (HttpURLConnection) url1.openConnection();
conn.setRequestMethod("GET");
conn.setRequestProperty("accept","*/*");
conn.setRequestProperty("connection","Keep-Alive");
conn.setRequestProperty("Charset", "utf-8");
conn.setDoInput(true);
conn.setDoOutput(false);
//x-qys-signature生成方式：Md5(AppToken + AppSecret + timestamp)，获取32位小写值
conn.connect();
in = new BufferedReader(new InputStreamReader(conn.getInputStream(),"UTF-8"));
String line;
while ((line = in.readLine()) != null) {
result += line;
}
jsonObject=JSONObject.parseObject(result,Map.class);
logger.info("http request back:" + jsonObject);
}catch (Exception ex){
logger.info("发送 POST 请求出现异常！" + ex);
ex.printStackTrace();
}finally {
try {
if (in != null) {
in.close();
}
} catch (IOException ex) {
ex.printStackTrace();
}
}
return jsonObject;
}
public Integer doPostForNew(String url, String params,String token) {
logger.info("http request url:" + url);
logger.info("http request params:" + params);
PrintWriter out = null;
BufferedReader in = null;
String result = "";
Map jsonObject=new HashMap();
Integer code=200;
try{
URL url1=new URL(url);
HttpURLConnection conn= (HttpURLConnection) url1.openConnection();
conn.setRequestMethod("POST");
conn.setRequestProperty("accept","*/*");
conn.setRequestProperty("connection","Keep-Alive");
conn.setDoInput(true);
conn.setDoOutput(true);
conn.setRequestProperty("Content-Type", "application/json;charset=utf-8");
conn.setRequestProperty("X-Access-Token", token);
out=new PrintWriter(new OutputStreamWriter(conn.getOutputStream(),"utf-8"));
out.print(params);
out.flush();
in = new BufferedReader(new InputStreamReader(conn.getInputStream(),"UTF-8"));
String line;
while ((line = in.readLine()) != null) {
result += line;
}
jsonObject=JSONObject.parseObject(result,Map.class);
logger.info("http request back:" + jsonObject);
code= (Integer) jsonObject.get("code");
}catch (Exception ex){
logger.info("发送 POST 请求出现异常！" + ex);
ex.printStackTrace();
code=-1;
}finally {
try {
if (out != null) {
out.close();
}
if (in != null) {
in.close();
}
} catch (IOException ex) {
ex.printStackTrace();
}
}
return code;
}
}
server:
port: 8866
servlet:
session:
timeout: 43200
spring:
servlet:
multipart:
maxFileSize: 10MB
maxRequestSize: 10MB
application:
name: archive-system
profiles:
active: dev
jackson:
time-zone: GMT+8
date-format: yyyy-MM-dd HH:mm:ss
default-property-inclusion: always
datasource:
dynamic:
primary: master
datasource:
master:
url: jdbc:oracle:thin:@192.168.2.218:1521:orcl
driver-class-name: oracle.jdbc.driver.OracleDriver
username: bdcdangan
password: bdcdangan
slave_1:
url: jdbc:oracle:thin:@192.168.2.218:1521:orcl
driver-class-name: oracle.jdbc.driver.OracleDriver
username: bdcdj
password: bdcdj
mybatis-plus:
mapper-locations: classpath:mapper/**/*.xml
typeAliasesPackage: com.pashanhoo
global-config:
#主键类型 0:"数据库ID自增", 1:"用户输入ID",2:"全局唯一ID (数字类型唯一ID)", 3:"全局唯一ID UUID";
id-type: 2
#字段策略 0:"忽略判断",1:"非 NULL 判断"),2:"非空判断"
field-strategy: 1
#驼峰下划线转换
db-column-underline: true
#刷新mapper 调试神器
refresh-mapper: true
#数据库大写下划线转换
#capital-mode: true
#序列接口实现类配置
#key-generator: com.baomidou.springboot.xxx
#逻辑删除配置
logic-delete-value: -1
logic-not-delete-0: 0
#自定义填充策略接口实现
#meta-object-handler: com.baomidou.springboot.xxx
#自定义SQL注入器
# sql-injector: com.baomidou.mybatisplus.mapper.LogicSqlInjector
configuration:
map-underscore-to-camel-case: true
cache-enabled: false
call-setters-on-nulls: true
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
management:
endpoints:
web:
exposure:
include: "*"
logging:
config: "classpath:logback-spring.xml"
minio:
params:
type: http://
bucket: archive
endpoint: 192.168.2.218
port: 8989
accessKeyId: minioadmin
accessKeySecret: minioadmin
server:
port: 8011
servlet:
session:
timeout: 43200
spring:
profiles:
active: @profile.active@
servlet:
multipart:
maxFileSize: 10MB
maxRequestSize: 10MB
application:
name: hzbdcsyn
jackson:
time-zone: GMT+8
date-format: yyyy-MM-dd HH:mm:ss
default-property-inclusion: always
datasource:
dynamic:
primary: master
datasource:
master:
url: jdbc:oracle:thin:@172.16.56.21:1521:orcl
driver-class-name: oracle.jdbc.driver.OracleDriver
username: regs
password: root1234
mybatis-plus:
mapper-locations: classpath:mapper/**/*.xml
typeAliasesPackage: com.pashanhoo
global-config:
#主键类型 0:"数据库ID自增", 1:"用户输入ID",2:"全局唯一ID (数字类型唯一ID)", 3:"全局唯一ID UUID";
id-type: 2
#字段策略 0:"忽略判断",1:"非 NULL 判断"),2:"非空判断"
field-strategy: 1
#驼峰下划线转换
db-column-underline: true
#刷新mapper 调试神器
refresh-mapper: true
#数据库大写下划线转换
#capital-mode: true
#序列接口实现类配置
#key-generator: com.baomidou.springboot.xxx
#逻辑删除配置
logic-delete-value: -1
logic-not-delete-0: 0
#自定义填充策略接口实现
#meta-object-handler: com.baomidou.springboot.xxx
#自定义SQL注入器
# sql-injector: com.baomidou.mybatisplus.mapper.LogicSqlInjector
configuration:
map-underscore-to-camel-case: true
cache-enabled: false
call-setters-on-nulls: true
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
app:
hostUrl: http://172.16.56.41:9182
bdcdjzmlc: 2890537670326468622
bdcqzslc: 2890537800123400234
AppToken: OAduCx5qJD
AppSecret: DifsZNwDnamuRh9jS0gSOTJFvmmKtT
management:
endpoints:
web:
exposure:
include: "*"
logging:
config: "classpath:logback-spring.xml"
......
......@@ -10,7 +10,7 @@
<contextName>logback</contextName>
<!-- name的值是变量的名称，value的值时变量定义的值。通过定义的值会被插入到logger上下文中。定义变量后，可以使“${}”来使用变量。 -->
<property name="log.path" value="/home/project/logs"/>
<property name="log.path" value="D:/home/project/logs"/>
<!-- 彩色日志 -->
<!-- 彩色日志依赖的渲染类 -->
......@@ -160,7 +160,7 @@
第一种把<root level="info">改成<root level="DEBUG">这样就会打印sql，不过这样日志那边会出现很多其他消息
第二种就是单独给dao下目录配置debug模式，代码如下，这样配置sql语句会打印，其他还是正常info级别：
-->
<!--<logger name="com.pashanhoo.*" level="DEBUG" />-->
<!--开发环境:打印控制台-->
<springProfile name="dev">
......@@ -183,21 +183,21 @@
-->
<root level="INFO">
<appender-ref ref="CONSOLE"/>
<!-- <appender-ref ref="DEBUG_FILE" />-->
<appender-ref ref="DEBUG_FILE" />
<appender-ref ref="INFO_FILE"/>
<appender-ref ref="WARN_FILE"/>
<appender-ref ref="ERROR_FILE"/>
</root>
<!--生产环境:输出到文件-->
<!--<springProfile name="pro">-->
<!--<root level="info">-->
<!--<appender-ref ref="CONSOLE" />-->
<!--<appender-ref ref="DEBUG_FILE" />-->
<!--<appender-ref ref="INFO_FILE" />-->
<!--<appender-ref ref="ERROR_FILE" />-->
<!--<appender-ref ref="WARN_FILE" />-->
<!--</root>-->
<!--</springProfile>-->
<!-- &lt;!&ndash;生产环境:输出到文件&ndash;&gt;
<springProfile name="pro">
<root level="info">
<appender-ref ref="CONSOLE" />
<appender-ref ref="DEBUG_FILE" />
<appender-ref ref="INFO_FILE" />
<appender-ref ref="ERROR_FILE" />
<appender-ref ref="WARN_FILE" />
</root>
</springProfile>-->
</configuration>
......
<?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.pashanhoo.qys.mapper.ElecLicenseInfoMapper">
<update id="updateEciInfo">
update ELEC_LICENSE_INFO set ERR_STATE='0',DZZZ_STATE='1' where biz_id=#{bizId}
</update>
<select id="getEciInfoByZsbs" resultType="com.pashanhoo.qys.entity.ElecLicenseInfoDo">
select * from ELEC_LICENSE_INFO where zsbs=#{zsbs}
</select>
<select id="getDocumentIdIsNull" resultType="com.pashanhoo.qys.entity.ElecLicenseInfoDo">
select *
from ELEC_LICENSE_INFO
where DOCUMENT_ID is null and htzt='COMPLETE' and ywh = #{ywh}
</select>
<select id="getWaitForDownload" resultType="com.pashanhoo.qys.entity.ElecLicenseInfoDo">
select *
from ELEC_LICENSE_INFO
where DOCUMENT_ID is not null
and SFXZ = '2' and ywh = #{ywh}
</select>
<select id="getWaitForConvert" resultType="com.pashanhoo.qys.entity.ElecLicenseInfoDo">
select *
from ELEC_LICENSE_INFO
where SFXZ = '1'
and SFZH = '2'
and ofd_wjdz is not null and ywh = #{ywh}
</select>
<select id="getYwrMcByCOnditon" resultType="java.lang.String">
select qlrmc as ywr
from reg_bus_ywr c
where ywh = #{ywh}
and bdcdyh = #{bdcdyh}
and del_flag = '0'
and qszt = '1'
</select>
<select id="getElecLicenseInfo" resultType="com.pashanhoo.qys.entity.ElecLicenseInfoDo">
select *
from ELEC_LICENSE_INFO
where ywh = #{ywh} and zsbs=#{zsbs} and zsbh=#{zsbh} and zjh=#{zjh}
</select>
</mapper>
<?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.pashanhoo.zhj.mapper.RegBusBdcqzsdjxxMapper">
<update id="updateBdcqzsjbxxInfo">
update reg_bus_bdcqzsdjxx set ISCJDZZZ='1' where ID=#{id}
</update>
<select id="getZsdjInfoList" resultType="com.pashanhoo.zhj.entity.RegBusBdcqzsdjxxDo" parameterType="com.pashanhoo.zhj.entity.SynZhjInfoDo">
select * from reg_bus_bdcqzsdjxx where
del_flag='0'
and
ywh in
<foreach collection="list" item="selectAllListInfo" open="(" close=")" separator=",">
#{selectAllListInfo.ywh,jdbcType=VARCHAR}
</foreach>
</select>
<select id="getZsdjInfoListByYwh" resultType="com.pashanhoo.zhj.entity.RegBusBdcqzsdjxxDo" parameterType="java.lang.String">
select * from reg_bus_bdcqzsdjxx where
del_flag='0'
and ywh=#{ywh}
</select>
<select id="getZdInfoByZddm" parameterType="string" resultType="java.util.Map">
select c.seachcity as djqdm,
(select label
from sys_dict b
where type = 'reg_bus_djq'
and b.value = c.seachcity) as djqmc,
c.seachdistrict as djzqdm,
(select label
from sys_dict b
where type = 'reg_bus_djzq'
and b.value = c.seachdistrict) as djzqmc,
c.bdcdyh,
c.zl,
c.zdmj,
c.yt
from reg_base_zdjbxx c,reg_bus_bdcqzsdjxx a
where a.del_flag = '0'
and a.islogout = '0'
and a.bdcdyh = c.bdcdyh
and a.bdcdyh=#{bdcdyh}
and a.ywh=#{ywh}
and c.del_flag = '0'
</select>
<select id="getHQSInfoByZddm" parameterType="string" resultType="java.util.Map">
select c.bdcdyh,
c.zrzh,
c.ch,
c.zl,
c.sjcs,
c.shbw,
c.hx,
c.hxjg,
c.fwyt1,
c.scjzmj,
c.sctnjzmj,
c.scdxbfjzmj,
c.fttdmj,
c.fwlx,
c.fwxz,
b.qllx,
b.djlx,
b.syqmj,
to_char(trunc(b.syqqssj),'yyyy-mm-dd') as syqqssj,
to_char(trunc(b.syqjssj),'yyyy-mm-dd') as syqjssj,
b.bdcqzh,
b.qxdm,
to_char(trunc(b.djsj),'yyyy-mm-dd') as djsj,
b.qszt,
c.zt
from reg_base_h c, reg_bus_jsydsyq b
where c.del_flag = '0'
and c.rights != '3'
and exists (select 1
from reg_bus_bdcqzsdjxx a
where a.del_flag = '0'
and a.islogout = '0'
and a.bdcdyh = c.bdcdyh
and a.ywh=#{ywh}
and a.bdcdyh =#{bdcdyh})
and c.zddm=b.zddm
and b.del_flag = '0'
</select>
<select id="getQSZTInfoByZddm" parameterType="string" resultType="java.util.Map">
select #{bdcdyh} as bdcdyh,
nvl((select decode(qszt,'1','0','1') from reg_bus_dyaq where ywh=#{ywh} and bdcdyh=#{bdcdyh} and del_flag='0' and qszt=1),'0') as dyqszt,
nvl((select decode(qszt,'1','0','1') from reg_bus_ygdj where ywh=#{ywh} and bdcdyh=#{bdcdyh} and del_flag='0' and qszt=1),'0') as ygqszt,
nvl((select decode(qszt,'1','0','1') from reg_bus_yydj where ywh=#{ywh} and bdcdyh=#{bdcdyh} and del_flag='0' and qszt=1),'0') as yyqszt,
nvl((select decode(qszt,'1','0','1') from reg_bus_cfdj where ywh=#{ywh} and bdcdyh=#{bdcdyh} and del_flag='0' and qszt=1),'0') as cfqszt
from dual
</select>
<select id="getBdcqzsjbxxInfo" resultType="java.util.Map">
select c.id,
c.ywh,
c.bdcdyh,
c.bdcqzh,
c.create_date,
c.qlrmc,
c.gyqk,
c.zl,
(select label from sys_dict c where type ='reg_bus_qllx' and value= c.qllx and del_flag='0') qllx,
c.djlx,
c.qlxz,
c.qt,
c.yt,
c.mj,
c.syqx,
c.qlqtzk,
c.fj,
c.rights,
REPLACE(c.dbsj,'-','') as djsj,
to_char(to_date(c.dbsj, 'yyyy-mm-dd'),'YYYY') as y,
to_char(to_date(c.dbsj, 'yyyy-mm-dd'),'MM') as m,
to_char(to_date(c.dbsj, 'yyyy-mm-dd'),'dd') as d,
c.bdcqzbh as bh
from reg_bus_bdcqzsdjxx c
where c.del_flag = '0'
and c.isxydzzz = '1'
and c.iscjdzzz = '0'
and dbsj is not null
</select>
<select id="getBdcqzsjbxxInfoByYwh" resultType="java.util.Map">
select c.id,
c.ywh,
c.bdcdyh,
c.bdcqzh,
c.create_date,
c.qlrmc,
c.gyqk,
c.zl,
(select label from sys_dict c where type ='reg_bus_qllx' and value= c.qllx and del_flag='0') qllx,
c.djlx,
c.qlxz,
c.qt,
c.yt,
c.mj,
c.syqx,
c.qlqtzk,
c.fj,
c.rights,
REPLACE(c.dbsj,'-','') as djsj,
to_char(to_date(c.dbsj, 'yyyy-mm-dd'),'YYYY') as y,
to_char(to_date(c.dbsj, 'yyyy-mm-dd'),'MM') as m,
to_char(to_date(c.dbsj, 'yyyy-mm-dd'),'dd') as d,
c.bdcqzbh as bh
from reg_bus_bdcqzsdjxx c
where c.del_flag = '0'
and c.isxydzzz = '1'
and c.iscjdzzz = '0'
and c.ywh=#{ywh}
and dbsj is not null
</select>
<select id="getQlrInfoByYwh" resultType="java.util.Map">
select wm_concat(qlrmc) as qlrmc,wm_concat(zjh) as zjh from reg_bus_qlr c where ywh =#{ywh} and del_flag='0' and qszt='1' order by sxh
</select>
<select id="getQlrInfoByYwhAndqlr" resultType="java.lang.String">
select zjh from reg_bus_qlr c where ywh =#{ywh} and qlrmc=#{qlrmc} and del_flag='0' and qszt='1' order by sxh
</select>
<select id="getBdcqzsJbxxById" resultType="java.util.Map">
select c.id,
c.ywh,
c.bdcdyh,
c.bdcqzh,
c.create_date,
c.qlrmc,
c.gyqk,
c.zl,
(select label from sys_dict c where type ='reg_bus_qllx' and value= c.qllx and del_flag='0') qllx,
c.djlx,
c.qlxz,
c.qt,
c.yt,
c.mj,
c.syqx,
c.qlqtzk,
c.fj,
c.rights,
REPLACE(c.dbsj,'-','') as djsj,
to_char(to_date(c.dbsj, 'yyyy-mm-dd'),'YYYY') as y,
to_char(to_date(c.dbsj, 'yyyy-mm-dd'),'MM') as m,
to_char(to_date(c.dbsj, 'yyyy-mm-dd'),'dd') as d,
c.bdcqzbh as bh
from reg_bus_bdcqzsdjxx c
where c.id=#{id}
</select>
<select id="getInfoByValue" resultType="java.lang.String">
select label from sys_dict c where del_flag='0' and type=#{type} and value=#{value}
</select>
<select id="getRightsInfo" resultType="java.util.Map">
select * from ( SELECT * FROM reg_bus_rights a WHERE a.bdcdyh = #{bdcdyh} order by del_flag ) where rownum=1
</select>
<select id="getDyqqInfo" resultType="java.util.Map">
select c.bdbzzqse,to_char(c.zwlxqssj,'yyyymmdd') as zwlxqssj,to_char(c.zwlxjssj,'yyyymmdd') as zwlxjssj from reg_bus_dyaq c where ywh=#{ywh} and bdcdyh=#{bdcdyh} and qszt='1'
</select>
<select id="getHtbhInfo" resultType="java.lang.String">
select htbh from reg_bus_ygdj c where qszt='1' and del_flag='0' and ywh=#{ywh}
</select>
<select id="getBdcjbxxInfo" resultType="java.util.Map">
select * from reg_bus_bdcqzsdjxx c where bdcdyh=#{bdcdyh} and islogout='0' and dbsj is not null and del_flag='0'
</select>
<select id="getJbxxInfoByYwhAndBdcdyh" resultType="java.util.Map">
select * from reg_bus_bdcqzsdjxx c where ywh=#{ywh} and bdcdyh=#{bdcdyh} and islogout='0' and dbsj is not null and del_flag='0'
</select>
<select id="getJbxxById" resultType="java.util.Map">
select * from reg_bus_bdcqzsdjxx c where id=#{id}
</select>
<select id="getZdjbxxByZddm" resultType="java.util.Map">
select * from reg_base_zdjbxx where del_flag='0' and zddm=#{zddm} and islogout='0'
</select>
<select id="getZrzInfo" resultType="java.util.Map">
select * from reg_base_zrz where bdcdyh=#{bdcdyh} and del_flag='0'
</select>
<select id="getHInfo" resultType="java.util.Map">
select * from reg_base_h c where bdcdyh=#{bdcdyh} and islogout='0' and del_flag='0'
</select>
</mapper>
<?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.pashanhoo.zhj.mapper.SynZhjInfoMapper">
<select id="selectAllInfo" resultType="com.pashanhoo.zhj.entity.SynZhjInfoDo">
select * from syn_zhjinfo where ZD_STATE='0' and H_STATE='0' and HQS_STATE='0' and del_flag='0'
</select>
<update id="updatezdzt">
update syn_zhjinfo set ZD_STATE='1' where ywh=#{ywh}
</update>
<update id="updateHzt">
update syn_zhjinfo set H_STATE='1' where ywh=#{ywh}
</update>
<update id="updateHqszt">
update syn_zhjinfo set HQS_STATE='1' where ywh=#{ywh}
</update>
</mapper>
<?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.pashanhoo.catalog.mapper.DgArchivesCatalogMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.pashanhoo.catalog.entity.DgArchivesCatalogDO">
<result column="bsm_catalog" property="bsmCatalog"/>
<result column="bsm_archives" property="bsmArchives"/>
<result column="xh" property="xh"/>
<result column="wjbm" property="wjbm"/>
<result column="wjmc" property="wjmc"/>
<result column="cllxbm" property="cllxbm"/>
<result column="cllxmc" property="cllxmc"/>
<result column="ys" property="ys"/>
<result column="yh" property="yh"/>
<result column="fs" property="fs"/>
<result column="wh" property="wh"/>
<result column="bz" property="bz"/>
<result column="fjly" property="fjly"/>
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
BSM_CATALOG, BSM_ARCHIVES, XH, WJBM, WJMC, CLLXBM, CLLXMC, YS, YH, FS, WH, BZ,FJLY
</sql>
<resultMap id="getCatalogAndBDCDY" type="com.pashanhoo.catalog.entity.vo.DgArchivesCatalogListVO">
<result column="bsm_catalog" property="bsmCatalog"/>
<result column="bsm_archives" property="bsmArchives"/>
<result column="xh" property="xh"/>
<result column="wjbm" property="wjbm"/>
<result column="wjmc" property="wjmc"/>
<result column="cllxbm" property="cllxbm"/>
<result column="cllxmc" property="cllxmc"/>
<result column="ys" property="ys"/>
<result column="yh" property="yh"/>
<result column="fs" property="fs"/>
<result column="wh" property="wh"/>
<result column="bz" property="bz"/>
<result column="FJLY" property="fjly"/>
<association property="bdcdyDO" javaType="com.pashanhoo.bdcdy.entity.DgBdcdyDO">
<result column="BSM_BDCDY" property="bsmBdcdy"/>
<result column="BSM_ARCHIVES" property="bsmArchives"/>
<result column="BSM_QL" property="bsmQl"/>
<result column="bdcdyid" property="bdcdyid"/>
<result column="bdcdyh" property="bdcdyh"/>
<result column="zl" property="zl"/>
<result column="qlr" property="qlr"/>
<result column="zjhm" property="zjhm"/>
<result column="ywr" property="ywr"/>
<result column="bdcqzh" property="bdcqzh"/>
<result column="djsj" property="djsj"/>
<result column="zxsj" property="zxsj"/>
</association>
</resultMap>
<select id="getCatalog" resultMap="getCatalogAndBDCDY">
select DAC.*,db.* from DG_ARCHIVES_CATALOG DAC join DG_BDCDY DB on DAC.BSM_ARCHIVES = DB.BSM_ARCHIVES
<where>
<if test="bsmArchives != null and bsmArchives.size() != 0">
DAC.BSM_ARCHIVES in
<foreach collection="bsmArchives" item="bsmArchive" separator="," open="(" close=")">
#{bsmArchive,jdbcType=VARCHAR}
</foreach>
</if>
</where>
</select>
</mapper>
<?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.pashanhoo.destroy.mapper.DgArchivesDestructionMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.pashanhoo.destroy.entity.DgArchivesDestructionDO">
<id column="BSM_DESTRUCTION" property="bsmDestruction"/>
<result column="XHQCBH" property="xhqcbh"/>
<result column="FQR" property="fqr"/>
<result column="FQRQ" property="fqrq"/>
<result column="XHYY" property="xhyy"/>
<result column="SHRY" property="shry"/>
<result column="SHYJ" property="shyj"/>
<result column="XHR" property="xhr"/>
<result column="XHRQ" property="xhrq"/>
</resultMap>
<!-- 销毁页面记录查询 -->
<resultMap id="ShowDestructionResultMap" type="com.pashanhoo.destroy.entity.vo.DgArchivesDestructionListVO">
<id column="BSM_DESTRUCTION" property="bsmDestruction" />
<result column="XHQCBH" property="xhqcbh" />
<result column="FQR" property="fqr" />
<result column="FQRQ" property="fqrq" />
<result column="XHYY" property="xhyy" />
<result column="SHRY" property="shry" />
<result column="SHYJ" property="shyj" />
<result column="XHR" property="xhr" />
<result column="XHRQ" property="xhrq" />
<result column="AJ_NUM" property="ajNum" />
</resultMap>
<!-- 档案列表记录查询 -->
<resultMap id="ShowArchivesInfoResultMap" type="com.pashanhoo.archive.entity.vo.DgArchivesListVO">
<id column="BSM_ARCHIVES" property="bsmArchives" />
<result column="AJBT" property="ajbt" />
<result column="ZTC" property="ztc" />
<result column="FLH" property="flh" />
<result column="MLH" property="mlh" />
<result column="AJH" property="ajh" />
<result column="ND" property="nd" />
<result column="JS" property="js" />
<result column="YS" property="ys" />
<result column="BGQX" property="bgqx" />
<result column="QSRQ" property="qsrq" />
<result column="ZZRQ" property="zzrq" />
<result column="MJ" property="mj" />
<result column="HH" property="hh" />
<result column="CFWZ" property="cfwz" />
<result column="CJR" property="cjr" />
<result column="CJRQ" property="cjrq" />
<result column="HCR" property="hcr" />
<result column="BZ" property="bz" />
<result column="SMZT" property="smzt" />
<result column="DAZT" property="dazt" />
<result column="CDJGBM" property="cdjgbm" />
<result column="DALY" property="daly" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
BSM_DESTRUCTION,
XHQCBH,
FQR,
FQRQ,
XHYY,
SHRY,
SHYJ,
XHR,
XHRQ
</sql>
<update id="updateArchivesStatus" parameterType="java.lang.String">
update dg_archives b
set b.dazt = #{dazt,jdbcType=VARCHAR}
where exists (select 1
from DG_DESTRUCTION_CATALOG a
where a.bsm_destruction = #{bsm_destruction,jdbcType=VARCHAR}
and b.bsm_archives = a.bsm_archives)
</update>
<update id="updateArchivesStatusBatch">
update dg_archives b
set b.dazt = #{dazt,jdbcType=VARCHAR} where bsm_archives in
<foreach collection="idList" index="index" item="item"
separator="," open="(" close=")">
#{item,jdbcType=VARCHAR}
</foreach>
</update>
<update id="updateDestructionArchivesStatus">
update DG_DESTRUCTION b
set b.dazt = #{dazt,jdbcType=VARCHAR}
where bsm_destruction=#{bsm_destruction,jdbcType=VARCHAR}
</update>
<select id="selectXhResult" resultMap="ShowDestructionResultMap">
select a.BSM_DESTRUCTION,
a.XHQCBH,
a.FQR,
a.FQRQ,
a.XHYY,
a.SHRY,
a.SHYJ,
a.XHR,
a.XHRQ,
count(1) over(partition by b.bsm_destruction, b.bsm_archives) aj_num
from dg_archives_destruction a, dg_destruction_catalog b
where a.bsm_destruction = b.bsm_destruction
and exists
(select 1 from dg_archives c where c.bsm_archives = b.bsm_archives
<if test="ajh!=null and ajh!='' ">
and c.ajh=#{ajh,jdbcType=VARCHAR}
</if>
)
<if test="xhqcbh!=null and xhqcbh!='' ">
and a.xhqcbh=#{xhqcbh,jdbcType=VARCHAR}
</if>
<if test="xhrq!=null and xhrq!='' ">
and a.XHRQ=#{xhrq,jdbcType=TIMESTAMP}
</if>
order by a.XHRQ desc
</select>
<select id="queryArchivesInfo" resultMap="ShowArchivesInfoResultMap">
select * from dg_archives b
where exists (select 1
from DG_DESTRUCTION_CATALOG a
where a.BSM_LEND = #{bsm_destruction,jdbcType=VARCHAR}
and b.bsm_archives = a.bsm_archives)
</select>
<select id="getDestroyLeftMenu" resultType="com.pashanhoo.archive.entity.DgArchivesDO">
select DA.*
from DG_ARCHIVES DA
join DG_DESTRUCTION_CATALOG DDC on DA.BSM_ARCHIVES = DDC.BSM_ARCHIVES
join DG_ARCHIVES_DESTRUCTION DAD on DDC.BSM_DESTRUCTION = DAD.BSM_DESTRUCTION
where DAD.XHQCBH = #{xhqcbh,jdbcType=VARCHAR}
</select>
</mapper>
<?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.pashanhoo.archive.mapper.DgArchivesMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.pashanhoo.archive.entity.DgArchivesDO">
<id column="BSM_ARCHIVES" property="bsmArchives" />
<result column="AJBT" property="ajbt" />
<result column="ZTC" property="ztc" />
<result column="FLH" property="flh" />
<result column="MLH" property="mlh" />
<result column="AJH" property="ajh" />
<result column="ND" property="nd" />
<result column="JS" property="js" />
<result column="YS" property="ys" />
<result column="BGQX" property="bgqx" />
<result column="QSRQ" property="qsrq" />
<result column="ZZRQ" property="zzrq" />
<result column="MJ" property="mj" />
<result column="HH" property="hh" />
<result column="CFWZ" property="cfwz" />
<result column="CJR" property="cjr" />
<result column="CJRQ" property="cjrq" />
<result column="HCR" property="hcr" />
<result column="BZ" property="bz" />
<result column="SMZT" property="smzt" />
<result column="DAZT" property="dazt" />
<result column="CDJGBM" property="cdjgbm" />
<result column="DALY" property="daly" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
BSM_ARCHIVES, AJBT, ZTC, FLH, MLH, AJH, ND, JS, YS, BGQX, QSRQ, ZZRQ, MJ, HH, CFWZ, CJR, CJRQ, HCR, BZ, SMZT, DAZT, CDJGBM, DALY
</sql>
<update id="updateArchivesInfoByReceiveIdList">
update DG_ARCHIVES a set a.dazt=#{dazt,jdbcType=VARCHAR} where exists (
select 1 from dg_receive_relation b where a.BSM_ARCHIVES=b.BSM_ARCHIVES
and b.bms_receive in
<foreach collection="idList" index="index" item="item"
separator="," open="(" close=")">
#{item,jdbcType=VARCHAR}
</foreach>
)
</update>
<select id="searchArchive" resultType="com.pashanhoo.archive.entity.vo.SearchArchiveVO">
select rownum as xh,
DA.BSM_ARCHIVES,
DA.DAZT,
DA.DALY,
DA.AJH,
DA.CFWZ,
DA.HH,
D.BDCQZH,
D.QLR,
D.YWR,
DB.YWH,
D.BDCDYH,
DB.QLLX
from DG_ARCHIVES DA
join DG_BUSINESS DB on DA.BSM_ARCHIVES = DB.BSM_ARCHIVES
join DG_BDCDY D on DA.BSM_ARCHIVES = D.BSM_ARCHIVES
<where>
<if test="request.ajh != null and request.ajh != ''">
AJH = #{request.ajh,jdbcType=VARCHAR}
</if>
<if test="request.mlh != null and request.mlh != ''">
and MLH = #{request.mlh,jdbcType=VARCHAR}
</if>
<if test="request.hh != null and request.hh != ''">
and HH = #{request.hh,jdbcType=VARCHAR}
</if>
<if test="request.dazt != null and request.dazt != ''">
and DAZT = #{request.dazt,jdbcType=VARCHAR}
</if>
<if test="request.ywh != null and request.ywh != ''">
and YWH = #{request.ywh,jdbcType=VARCHAR}
</if>
<if test="request.bdcqzh != null and request.bdcqzh != ''">
and BDCQZH = #{request.bdcqzh,jdbcType=VARCHAR}
</if>
<if test="request.bdcdyh != null and request.bdcdyh != ''">
and BDCDYH = #{request.bdcdyh,jdbcType=VARCHAR}
</if>
<if test="request.qllx != null and request.qllx != ''">
and QLLX = #{request.qllx,jdbcType=VARCHAR}
</if>
<if test="request.qlr != null and request.qlr != ''">
and QLR = #{request.qlr,jdbcType=VARCHAR}
</if>
</where>
</select>
<resultMap id="CatalogWithFile" type="com.pashanhoo.catalog.entity.vo.DgArchivesCatalogWithFileVO">
<result column="bsm_catalog" property="bsmCatalog"/>
<result column="bsm_archives" property="bsmArchives"/>
<result column="xh" property="xh"/>
<result column="wjbm" property="wjbm"/>
<result column="wjmc" property="wjmc"/>
<result column="cllxbm" property="cllxbm"/>
<result column="cllxmc" property="cllxmc"/>
<result column="ys" property="ys"/>
<result column="yh" property="yh"/>
<result column="fs" property="fs"/>
<result column="wh" property="wh"/>
<result column="bz" property="bz"/>
<collection property="dgFileDOS" ofType="com.pashanhoo.file.entity.DgFileDO">
<result column="BSM_FILE" property="bsmFile"/>
<result column="DF_BSM_CATALOG" property="bsmCatalog"/>
<result column="KZM" property="kzm"/>
<result column="SCRQ" property="scrq"/>
<result column="SCR" property="scr"/>
<result column="FJURL" property="fjurl"/>
<result column="FJSIZE" property="fjsize"/>
</collection>
</resultMap>
<select id="selectCatalogWithFile" resultMap="CatalogWithFile">
select DAC.*, DF.BSM_FILE as BSM_FILE, DF.BSM_CATALOG as DF_BSM_CATALOG, DF.KZM as KZM,DF.SCRQ as SCRQ,DF.SCR as SCR,DF.FJURL as FJURL,DF.FJSIZE as FJSIZE
from DG_FILE DF
left join DG_ARCHIVES_CATALOG DAC on DAC.BSM_CATALOG =
DF.BSM_CATALOG
<where>
<if test="request.bsmArchives != null and request.bsmArchives != ''">
BSM_ARCHIVES = #{request.bsmArchives,jdbcType=VARCHAR}
</if>
</where>
order by XH
</select>
</mapper>
<?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.pashanhoo.modify.mapper.DgArchivesModifyMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.pashanhoo.modify.entity.DgModifyDO">
<id column="BSM_MODIFY" property="bsmModify"/>
<result column="BSM_ARCHIVES" property="bsmArchives"/>
<result column="XGBH" property="xgbh"/>
<result column="YDAXX" property="ydaxx"/>
<result column="XDAXX" property="xdaxx"/>
<result column="XGNR" property="xgnr"/>
<result column="XGSJ" property="xgsj"/>
<result column="XGR" property="xgr"/>
<result column="BZ" property="bz"/>
</resultMap>
<!--&lt;!&ndash; 通用查询映射结果 &ndash;&gt;-->
<!--<resultMap id="SearchResultMap" type="com.pashanhoo.modify.entity.vo.DgArchivesModifyListVO">-->
<!-- <id column="BSM_ARCHIVES" property="bsmArchives" />-->
<!-- <result column="XGSJ" property="xgsj" />-->
<!-- <result column="CREATER" property="creater" />-->
<!-- <result column="DJLX" property="djlx" />-->
<!-- <result column="DJJGMC" property="djjgmc" />-->
<!-- <result column="AJH" property="ajh" />-->
<!-- <result column="YWH" property="ywh" />-->
<!-- <result column="BDCDYH" property="bdcdyh" />-->
<!-- <result column="QLR" property="qlr" />-->
<!-- <result column="YWR" property="ywr" />-->
<!-- <result column="BDCQZH" property="bdcqzh" />-->
<!-- <result column="BDCDY_NUM" property="bdcdyNum" />-->
<!--</resultMap>-->
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
BSM_MODIFY,
BSM_ARCHIVES,
XGBH,
YDAXX,
XDAXX,
XGNR,
XGSJ,
XGR,
BZ
</sql>
<select id="searchDgArchivesModifyList" resultType="com.pashanhoo.modify.entity.vo.DgArchivesModifyListVO">
select DA.BSM_ARCHIVES,
DM.BSM_MODIFY,
DB.QLLX,
DB.DJLX,
DA.AJH,
DB.YWH,
BDCDY.BDCDYH,
BDCDY.QLR,
BDCDY.YWR,
BDCDY.BDCQZH,
DM.CREATETIME,
DM.CREATER,
DM.STATE,
count(1) over (partition by DM.BSM_MODIFY) as bdcdyNum
from DG_MODIFY DM
join DG_BUSINESS DB on DM.BSM_ARCHIVES = DB.BSM_ARCHIVES
join DG_BDCDY BDCDY on DM.BSM_ARCHIVES = BDCDY.BSM_ARCHIVES
join DG_ARCHIVES DA on DM.BSM_ARCHIVES = DA.BSM_ARCHIVES
<where>
<if test="request.djywmc != null and request.djywmc != ''">
DB.DJYWMC = #{request.djywmc,jdbcType=VARCHAR}
</if>
<if test="request.djlx != null and request.djlx != ''">
and DB.DJLX = #{request.djlx,jdbcType=VARCHAR}
</if>
<if test="request.creater != null and request.creater != ''">
and DM.CREATER = #{request.creater,jdbcType=VARCHAR}
</if>
<if test="request.xgqssj != null">
<![CDATA[
and DM.CREATETIME >= #{request.xgqssj,jdbcType=TIMESTAMP}
]]>
</if>
<if test="request.xgjzsj != null">
<![CDATA[
and DM.CREATETIME <= #{request.xgjzsj,jdbcType=TIMESTAMP}
]]>
</if>
<if test="request.ajh != null and request.ajh != ''">
and DA.AJH = #{request.ajh,jdbcType=VARCHAR}
</if>
<if test="request.ywh != null and request.ywh != ''">
and DB.YWH = #{request.ywh,jdbcType=VARCHAR}
</if>
<if test="request.bdcdyh != null and request.bdcdyh != ''">
and BDCDY.BDCDYH = #{request.bdcdyh,jdbcType=VARCHAR}
</if>
<if test="request.bdcqzh != null and request.bdcqzh != ''">
and BDCDY.BDCQZH = #{request.bdcqzh,jdbcType=VARCHAR}
</if>
</where>
</select>
</mapper>
<?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.pashanhoo.replenish.mapper.DgArchivesReplenishMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.pashanhoo.replenish.entity.DgArchivesReplenishDO">
<id column="BSM_MODIFY" property="bsmModify"/>
<result column="BSM_ARCHIVES" property="bsmArchives"/>
<result column="BLBH" property="blbh"/>
<result column="CREATETIME" property="createTime"/>
<result column="CREATER" property="creater"/>
<result column="BZ" property="bz"/>
</resultMap>
<select id="search" resultType="com.pashanhoo.replenish.entity.vo.DgArchivesReplenishListVO">
select DGR.BSM_ARCHIVES,
DGR.BSM_MODIFY,
DB.QLLX,
DB.DJLX,
DA.AJH,
DB.YWH,
BDCDY.BDCDYH,
BDCDY.QLR,
BDCDY.YWR,
BDCDY.BDCQZH,
DGR.CREATETIME,
DGR.CREATER,
DGR.STATE,
count(1) over (partition by BDCDY.BSM_ARCHIVES) as bdcdyNum
from DG_REPLENISH DGR
join DG_ARCHIVES DA on DA.BSM_ARCHIVES = DGR.BSM_ARCHIVES
join DG_BDCDY BDCDY on BDCDY.BSM_ARCHIVES = DGR.BSM_ARCHIVES
join DG_BUSINESS DB on DB.BSM_ARCHIVES = DGR.BSM_ARCHIVES
<where>
<if test="request.ywh != null and request.ywh != ''">
DB.YWH = #{request.ywh,jdbcType=VARCHAR}
</if>
<if test="request.qllx != null and request.qllx != ''">
and DB.QLLX = #{request.qllx,jdbcType=VARCHAR}
</if>
<if test="request.djlx != null and request.djlx != ''">
and DB.DJLX = #{request.djlx,jdbcType=VARCHAR}
</if>
<if test="request.creater != null and request.creater != ''">
and DGR.CREATER = #{request.creater,jdbcType=VARCHAR}
</if>
<if test="request.createTime != null">
and DGR.CREATETIME = #{request.createTime,jdbcType=TIMESTAMP}
</if>
</where>
</select>
</mapper>
<?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.pashanhoo.bdcdy.mapper.DgBdcdyMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.pashanhoo.bdcdy.entity.DgBdcdyDO">
<id column="BSM_BDCDY" property="bsmBdcdy" />
<result column="BSM_ARCHIVES" property="bsmArchives" />
<result column="BSM_QL" property="bsmQl" />
<result column="BDCDYID" property="bdcdyid" />
<result column="BDCDYH" property="bdcdyh" />
<result column="ZL" property="zl" />
<result column="QLR" property="qlr" />
<result column="ZJHM" property="zjhm" />
<result column="YWR" property="ywr" />
<result column="BDCQZH" property="bdcqzh" />
<result column="DJSJ" property="djsj" />
<result column="ZXSJ" property="zxsj" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
BSM_BDCDY, BSM_ARCHIVES, BSM_QL, BDCDYID, BDCDYH, ZL, QLR, ZJHM, YWR, BDCQZH, DJSJ, ZXSJ
</sql>
</mapper>
<?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.pashanhoo.business.mapper.DgBusinessMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.pashanhoo.business.entity.DgBusinessDO">
<id column="BSM_BUSINESS" property="bsmBusiness" />
<result column="BSM_ARCHIVES" property="bsmArchives" />
<result column="YWH" property="ywh" />
<result column="DJLX" property="djlx" />
<result column="QLLX" property="qllx" />
<result column="DJJGBM" property="djjgbm" />
<result column="DJJGMC" property="djjgmc" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
BSM_BUSINESS, BSM_ARCHIVES, YWH, DJLX, QLLX, DJJGBM, DJJGMC
</sql>
</mapper>
<?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.pashanhoo.destroycatalog.mapper.DgDestructionCatalogMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.pashanhoo.destroycatalog.entity.DgDestructionCatalogDO">
<id column="BSM_DESTRUCTIONCATALOG" property="bsmDestructioncatalog" />
<result column="BSM_ARCHIVES" property="bsmArchives" />
<result column="BSM_DESTRUCTION" property="bsmDestruction" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
BSM_DESTRUCTIONCATALOG, BSM_ARCHIVES, BSM_DESTRUCTION
</sql>
<select id="getDestructionCatalog" resultType="com.pashanhoo.archive.entity.DgArchivesDO">
</select>
</mapper>
<?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.pashanhoo.file.mapper.DgFileMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.pashanhoo.file.entity.DgFileDO">
<result column="bsm_file" property="bsmFile"/>
<result column="bsm_catalog" property="bsmCatalog"/>
<result column="kzm" property="kzm"/>
<result column="scrq" property="scrq"/>
<result column="scr" property="scr"/>
<result column="fjurl" property="fjurl"/>
<result column="fjsize" property="fjsize"/>
<result column="xh" property="xh"/>
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
BSM_FILE,
BSM_CATALOG,
KZM,
SCRQ,
SCR,
FJURL,
FJSIZE,
XH
</sql>
<resultMap id="result" type="com.pashanhoo.file.entity.vo.DgCatalogWithFileVO">
<result column="bsm_archives" property="bsmArchive"/>
<result column="bsmCatalog" property="bsmCatalog"/>
<result column="wjmc" property="wjmc"/>
<result column="catalogXh" property="catalogXh"/>
<collection property="fileLists" ofType="com.pashanhoo.file.entity.vo.DgFileListVO">
<result column="bsm_file" property="bsmFile"/>
<result column="bsm_catalog" property="bsmCatalog"/>
<result column="kzm" property="kzm"/>
<result column="scrq" property="scrq"/>
<result column="scr" property="scr"/>
<result column="fjurl" property="fjurl"/>
<result column="fjsize" property="fjsize"/>
<result column="XH" property="xh"/>
</collection>
</resultMap>
<select id="getFileList" resultMap="result">
select DF.*, DAC.XH as catalogXh, DAC.WJMC, DAC.BSM_CATALOG as bsmCatalog, DA.BSM_ARCHIVES
from DG_FILE DF
right join DG_ARCHIVES_CATALOG DAC on DAC.BSM_CATALOG = DF.BSM_CATALOG
join DG_ARCHIVES DA on DAC.BSM_ARCHIVES = DA.BSM_ARCHIVES
<where>
<if test="bsmArchive != null and bsmArchive != ''">
DAC.BSM_ARCHIVES = #{bsmArchive,jdbcType=VARCHAR}
</if>
</where>
order by DF.XH, DAC.XH
</select>
<select id="getFilesById" resultMap="BaseResultMap">
select *
from DG_FILE
where
BSM_FILE in
<if test="bsmFiles != null and bsmFiles.size() != 0">
<foreach collection="bsmFiles" item="bsmFile" open="(" close=")" separator=",">
#{bsmFile,jdbcType=VARCHAR}
</foreach>
</if>
</select>
<!--<update id="updateFileSort">-->
<!-- update DG_FILE set-->
<!--</update>-->
</mapper>
<?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.pashanhoo.lendcatalog.mapper.DgLendCatalogMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.pashanhoo.lendcatalog.entity.DgLendCatalogDO">
<id column="BSM_LENDCATALOG" property="bsmLendcatalog" />
<result column="BSM_ARCHIVES" property="bsmArchives" />
<result column="BSM_LEND" property="bsmLend" />
<result column="借阅材料类型" property="借阅材料类型" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
BSM_LENDCATALOG, BSM_ARCHIVES, BSM_LEND, 借阅材料类型
</sql>
</mapper>
<?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.pashanhoo.lendfile.mapper.DgLendFileMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.pashanhoo.lendfile.entity.DgLendFileDO">
<id column="BSM_LENDFILE" property="bsmLendfile" />
<result column="BSM_LENDCATALOG" property="bsmLendcatalog" />
<result column="BSM_CATALOG" property="bsmCatalog" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
BSM_LENDFILE, BSM_LENDCATALOG, BSM_CATALOG
</sql>
</mapper>
<?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.pashanhoo.lend.mapper.DgLendMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.pashanhoo.lend.entity.vo.DgLendDetailVO">
<id column="BSM_LEND" property="bsm_lend" />
<result column="JYSX" property="jyr" />
<result column="JYDH" property="jydw" />
<result column="AJH" property="ajh" />
<result column="JYFS" property="jyfs" />
<result column="JYDW" property="jydw" />
<result column="JYR" property="jyr" />
<result column="QSSJ" property="qssj" />
<result column="JZRQ" property="jzrq" />
<result column="GHR" property="ghr" />
<result column="GHRQ" property="ghrq" />
<result column="JYZT" property="jyzt" />
<result column="DA_NUM" property="da_num" />
</resultMap>
<!-- 档案列表记录查询 -->
<resultMap id="ShowArchivesInfoResultMap" type="com.pashanhoo.archive.entity.vo.DgArchivesListVO">
<id column="BSM_ARCHIVES" property="bsmArchives" />
<result column="AJBT" property="ajbt" />
<result column="ZTC" property="ztc" />
<result column="FLH" property="flh" />
<result column="MLH" property="mlh" />
<result column="AJH" property="ajh" />
<result column="ND" property="nd" />
<result column="JS" property="js" />
<result column="YS" property="ys" />
<result column="BGQX" property="bgqx" />
<result column="QSRQ" property="qsrq" />
<result column="ZZRQ" property="zzrq" />
<result column="MJ" property="mj" />
<result column="HH" property="hh" />
<result column="CFWZ" property="cfwz" />
<result column="CJR" property="cjr" />
<result column="CJRQ" property="cjrq" />
<result column="HCR" property="hcr" />
<result column="BZ" property="bz" />
<result column="SMZT" property="smzt" />
<result column="DAZT" property="dazt" />
<result column="CDJGBM" property="cdjgbm" />
<result column="DALY" property="daly" />
</resultMap>
<!-- 通用查询映射结果 -->
<resultMap id="ArchiveLendInfoResultMap" type="com.pashanhoo.lend.entity.vo.ArchiveLendInfoRequestVO">
<id column="BSM_ARCHIVES" property="bsm_archives" />
<result column="DAZT" property="dazt" />
<result column="AJH" property="ajh" />
<result column="BDCDYH" property="bdcdyh" />
<result column="QLLX" property="qllx" />
<result column="DJLX" property="djlx" />
<result column="QLR" property="qlr" />
<result column="YWR" property="ywr" />
<result column="ZJHM" property="zjhm" />
<result column="BDCDY_NUM" property="bdcdy_num" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
BSM_LEND, JYR, JYDW, LXDW, TXDZ, JYRQ, GHRQ, PZR, JZRQ, JCLY, LYMD, BZ, PZSJ
</sql>
<update id="updateArchivesStatus">
update dg_archives b
set b.dazt = #{dazt,jdbcType=VARCHAR}
where exists (select 1
from DG_LEND_CATALOG a
where a.BSM_LENDCATALOG = #{lendBsm,jdbcType=VARCHAR}
and b.bsm_archives = a.bsm_archives)
</update>
<update id="updateArchivesStatusBatch">
update dg_archives b
set b.dazt = #{dazt,jdbcType=VARCHAR} where bsm_archives in
<foreach collection="idList" index="index" item="item"
separator="," open="(" close=")">
#{item,jdbcType=VARCHAR}
</foreach>
</update>
<select id="getDanganJyDetail" resultMap="BaseResultMap">
select d.BSM_LEND,
d.jysx,
d.jydh,
d.ajh,
d.jyfs,
d.jydw,
d.jyr,
d.qssj,
d.jzrq,
d.ghr,
d.ghsj,
d.jyzt,count(1) over(partition by d.BSM_LEND order by d.jysx asc, d.jzrq asc, d.jyzt asc) da_num
from (select a.jy_bsm,
case
when a.jzrq &lt; sysdate and a.JYZT = '8' then
'0'
else
'1'
end as jysx,
a.jydh,
b.ajh,
a.jyfs,
a.jydw,
a.jyr,
a.qssj,
a.jzrq,
a.ghr,
a.ghrq,
a.jyzt
from dg_lend a, dg_archives b,dg_lend_catalog c,dg_bdcdy e,dg_business f
where b.BSM_ARCHIVES=c.BSM_ARCHIVES
and a.BSM_LEND=c.BSM_LEND
and e.BSM_ARCHIVES=b.BSM_ARCHIVES
and f.BSM_ARCHIVES=b.BSM_ARCHIVES
<if test="ajh != null and ajh!='' ">
and b.ajh=#{ajh,jdbcType=VARCHAR}
</if>
<if test="bdcdyh != null and bdcdyh!='' ">
and e.bdcdyh=#{bdcdyh,jdbcType=VARCHAR}
</if>
<if test="ywh != null and ywh!=''">
and f.ywh=#{ywh,jdbcType=VARCHAR}
</if>
<if test="bdcqzh != null and bdcqzh !='' ">
and e.zjhm=#{bdcqzh,jdbcType=VARCHAR}
</if>
<if test="jyr != null and jyr!='' ">
and a.jyr=#{jyr,jdbcType=VARCHAR}
</if>
<if test="jyzt != null and jyzt != '' ">
and a.jyzt=#{jyzt,jdbcType=VARCHAR}
</if>
) d
</select>
<select id="queryArchivesInfo" resultMap="ShowArchivesInfoResultMap">
select * from dg_archives b
where exists (select 1
from DG_LEND_CATALOG a
where a.BSM_LENDCATALOG = #{bsm_lend,jdbcType=VARCHAR}
and b.bsm_archives = a.bsm_archives)
</select>
<select id="getArchiveLendInfo" resultType="com.pashanhoo.lend.entity.vo.ArchiveLendInfoRequestVO">
select a.bsm_archives,a.dazt,a.ajh,c.bdcdyh,b.qllx,b.djlx,c.qlr,c.ywr,c.zjhm,count(1) over (partition by a.bsm_archives) bdcdy_num
from dg_archives a, dg_business b, dg_bdcdy c
where a.bsm_archives = b.bsm_archives
and a.bsm_archives=c.bsm_archives
and a.dazt='4'
<if test="ajh != null and ajh != '' ">
and a.ajh=#{ajh,jdbcType=VARCHAR}
</if>
<if test="ywh != null and ywh != '' ">
and b.ywh=#{ywh,jdbcType=VARCHAR}
</if>
<if test="bdcdyh != null and bdcdyh != '' ">
and c.bdcdyh=#{bdcdyh,jdbcType=VARCHAR}
</if>
<if test="zjhm != null and zjhm != '' ">
and c.zjhm=#{zjhm,jdbcType=VARCHAR}
</if>
<if test="qlr != null and qlr != '' ">
and c.qlr=#{qlr,jdbcType=VARCHAR}
</if>
<if test="ywr != null and ywr != '' ">
and c.ywr=#{ywr,jdbcType=VARCHAR}
</if>
<if test="cfwh != null and cfwh != '' ">
and c.zjhm=#{cfwh,jdbcType=VARCHAR}
</if>
<if test="qllx != null and qllx != '' ">
and c.qllx=#{qllx,jdbcType=VARCHAR}
</if>
</select>
</mapper>
<?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.pashanhoo.receive.mapper.DgReceiveMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.pashanhoo.receive.entity.DgReceiveDO">
<id column="BMS_RECEIVE" property="bmsReceive" />
<result column="YWLYJBM" property="ywlyjbm" />
<result column="QLLX" property="qllx" />
<result column="DJLX" property="djlx" />
<result column="SJRY" property="sjry" />
<result column="SJSJ" property="sjsj" />
<result column="YWH" property="ywh" />
<result column="BDCDYH" property="bdcdyh" />
<result column="DYZS" property="dyzs" />
<result column="BDCQZH" property="bdcqzh" />
<result column="QLR" property="qlr" />
<result column="ZJHM" property="zjhm" />
<result column="YWR" property="ywr" />
<result column="ZL" property="zl" />
<result column="DJSJ" property="djsj" />
<result column="JSSJ" property="jssj" />
<result column="TSJGBM" property="tsjgbm" />
<result column="GDFS" property="gdfs" />
<result column="GDSJ" property="gdsj" />
<result column="STATE" property="state" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
BMS_RECEIVE, YWLYJBM, QLLX, DJLX, SJRY, SJSJ, YWH, BDCDYH, DYZS, BDCQZH, QLR, ZJHM, YWR, ZL, DJSJ, JSSJ, TSJGBM, GDFS, GDSJ, STATE
</sql>
<update id="updateReceiveBatch">
update dg_receive b
set b.state = #{state,jdbcType=VARCHAR},b.gdsj=sysdate
where BMS_RECEIVE in
<foreach collection="idList" index="index" item="item"
separator="," open="(" close=")">
#{item,jdbcType=VARCHAR}
</foreach>
</update>
<select id="getDjywbmInfo" resultType="com.pashanhoo.receive.entity.vo.DjywbmVO">
select * from SYS_CONVERT_DJYWBM t where oncedjywbm=#{oncedjywbm,jdbcType=VARCHAR} and state='1'
</select>
</mapper>
<?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.pashanhoo.receiverelation.mapper.DgReceiveRelationMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.pashanhoo.receiverelation.entity.DgReceiveRelationDO">
<result column="BSM_RELATION" property="bsmRelation" />
<result column="BSM_ARCHIVES" property="bsmArchives" />
<result column="BMS_RECEIVE" property="bmsReceive" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
BSM_RELATION, BSM_ARCHIVES, BMS_RECEIVE
</sql>
</mapper>
<?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.pashanhoo.staff.mapper.DgStaffMapper">
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.pashanhoo.staff.entity.DgStaffDO">
<id column="BSM_STAFF" property="bsmStaff" />
<result column="STAFF_ID" property="staffId" />
<result column="STAFF_NAME" property="staffName" />
<result column="STAFF_PASSWORD" property="staffPassword" />
<result column="STAFF_ROLE_CODE" property="staffRoleCode" />
<result column="STAFF_ROLE_NAME" property="staffRoleName" />
<result column="STAFF_DEART_ID" property="staffDeartId" />
<result column="STAFF_DEART_NAME" property="staffDeartName" />
<result column="REMARK" property="remark" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
BSM_STAFF, STAFF_ID, STAFF_NAME, STAFF_PASSWORD, STAFF_ROLE_CODE, STAFF_ROLE_NAME, STAFF_DEART_ID, STAFF_DEART_NAME, REMARK
</sql>
</mapper>
<?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.pashanhoo.common.util.SysCode.SysCodeMapper">
</mapper>
\ No newline at end of file
<?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.pashanhoo.dictionary.dao.SysDictMapper">
<resultMap id="BaseResultMap" type="com.pashanhoo.dictionary.model.dto.SysDict">
<!--@mbg.generated-->
<!--@Table SYS_DICT-->
<id column="DICTID" jdbcType="VARCHAR" property="dictId"/>
<result column="PARENTID" jdbcType="VARCHAR" property="parentId"/>
<result column="DCODE" jdbcType="VARCHAR" property="dcode"/>
<result column="DNAME" jdbcType="VARCHAR" property="dname"/>
<result column="SORT" jdbcType="DECIMAL" property="sort"/>
<result column="ISTREE" jdbcType="CHAR" property="isTree"/>
<result column="TYPEID" jdbcType="VARCHAR" property="typeId"/>
</resultMap>
<sql id="Base_Column_List">
<!--@mbg.generated-->
DICTID, PARENTID, DCODE, DNAME, SORT, ISTREE, TYPEID
</sql>
<select id="selectByPrimaryKey" parameterType="java.lang.String" resultMap="BaseResultMap">
<!--@mbg.generated-->
select
<include refid="Base_Column_List"/>
from SYS_DICT
where DICTID = #{dictid,jdbcType=VARCHAR}
</select>
<delete id="deleteByPrimaryKey" parameterType="java.lang.String">
<!--@mbg.generated-->
delete
from SYS_DICT
where DICTID = #{dictid,jdbcType=VARCHAR}
</delete>
<insert id="insert" parameterType="com.pashanhoo.dictionary.model.dto.SysDict">
<!--@mbg.generated-->
insert into SYS_DICT (DICTID, PARENTID, DCODE,
DNAME, SORT, ISTREE, TYPEID)
values (#{dictId,jdbcType=VARCHAR}, #{parentId,jdbcType=VARCHAR}, #{dcode,jdbcType=VARCHAR},
#{dname,jdbcType=VARCHAR}, #{sort,jdbcType=DECIMAL}, #{isTree,jdbcType=CHAR},
#{typeId,jdbcType=VARCHAR})
</insert>
<insert id="insertSelective" parameterType="com.pashanhoo.dictionary.model.dto.SysDict">
<!--@mbg.generated-->
insert into SYS_DICT
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="dictId != null">
DICTID,
</if>
<if test="parentId != null">
PARENTID,
</if>
<if test="dcode != null">
DCODE,
</if>
<if test="dname != null">
DNAME,
</if>
<if test="sort != null">
SORT,
</if>
<if test="isTree != null">
ISTREE,
</if>
<if test="typeId != null">
TYPEID,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="dictId != null">
#{dictId,jdbcType=VARCHAR},
</if>
<if test="parentId != null">
#{parentId,jdbcType=VARCHAR},
</if>
<if test="dcode != null">
#{dcode,jdbcType=VARCHAR},
</if>
<if test="dname != null">
#{dname,jdbcType=VARCHAR},
</if>
<if test="sort != null">
#{sort,jdbcType=DECIMAL},
</if>
<if test="isTree != null">
#{isTree,jdbcType=CHAR},
</if>
<if test="typeId != null">
#{typeId,jdbcType=VARCHAR},
</if>
</trim>
</insert>
<update id="updateByPrimaryKeySelective" parameterType="com.pashanhoo.dictionary.model.dto.SysDict">
<!--@mbg.generated-->
update SYS_DICT
<set>
<if test="parentId != null">
PARENTID = #{parentId,jdbcType=VARCHAR},
</if>
<if test="dcode != null">
DCODE = #{dcode,jdbcType=VARCHAR},
</if>
<if test="dname != null">
DNAME = #{dname,jdbcType=VARCHAR},
</if>
<if test="sort != null">
SORT = #{sort,jdbcType=DECIMAL},
</if>
<if test="isTree != null">
ISTREE = #{isTree,jdbcType=CHAR},
</if>
<if test="typeId != null">
TYPEID = #{typeId,jdbcType=VARCHAR},
</if>
</set>
where DICTID = #{dictId,jdbcType=VARCHAR}
</update>
<update id="updateByPrimaryKey" parameterType="com.pashanhoo.dictionary.model.dto.SysDict">
<!--@mbg.generated-->
update SYS_DICT
set PARENTID = #{parentId,jdbcType=VARCHAR},
DCODE = #{dcode,jdbcType=VARCHAR},
DNAME = #{dname,jdbcType=VARCHAR},
SORT = #{sort,jdbcType=DECIMAL},
ISTREE = #{isTree,jdbcType=CHAR},
TYPEID = #{typeId,jdbcType=VARCHAR}
where DICTID = #{dictId,jdbcType=VARCHAR}
</update>
<update id="updateBatch" parameterType="java.util.List">
<!--@mbg.generated-->
update SYS_DICT
<trim prefix="set" suffixOverrides=",">
<trim prefix="PARENTID = case" suffix="end,">
<foreach collection="list" index="index" item="item">
when DICTID = #{item.dictId,jdbcType=VARCHAR} then #{item.parentId,jdbcType=VARCHAR}
</foreach>
</trim>
<trim prefix="DCODE = case" suffix="end,">
<foreach collection="list" index="index" item="item">
when DICTID = #{item.dictId,jdbcType=VARCHAR} then #{item.dcode,jdbcType=VARCHAR}
</foreach>
</trim>
<trim prefix="DNAME = case" suffix="end,">
<foreach collection="list" index="index" item="item">
when DICTID = #{item.dictId,jdbcType=VARCHAR} then #{item.dname,jdbcType=VARCHAR}
</foreach>
</trim>
<trim prefix="SORT = case" suffix="end,">
<foreach collection="list" index="index" item="item">
when DICTID = #{item.dictId,jdbcType=VARCHAR} then #{item.sort,jdbcType=DECIMAL}
</foreach>
</trim>
<trim prefix="ISTREE = case" suffix="end,">
<foreach collection="list" index="index" item="item">
when DICTID = #{item.dictId,jdbcType=VARCHAR} then #{item.isTree,jdbcType=CHAR}
</foreach>
</trim>
<trim prefix="TYPEID = case" suffix="end,">
<foreach collection="list" index="index" item="item">
when DICTID = #{item.dictId,jdbcType=VARCHAR} then #{item.typeId,jdbcType=VARCHAR}
</foreach>
</trim>
</trim>
where DICTID in
<foreach close=")" collection="list" item="item" open="(" separator=", ">
#{item.dictId,jdbcType=VARCHAR}
</foreach>
</update>
<update id="updateBatchSelective" parameterType="java.util.List">
<!--@mbg.generated-->
update SYS_DICT
<trim prefix="set" suffixOverrides=",">
<trim prefix="PARENTID = case" suffix="end,">
<foreach collection="list" index="index" item="item">
<if test="item.parentId != null">
when DICTID = #{item.dictId,jdbcType=VARCHAR} then #{item.parentId,jdbcType=VARCHAR}
</if>
</foreach>
</trim>
<trim prefix="DCODE = case" suffix="end,">
<foreach collection="list" index="index" item="item">
<if test="item.dcode != null">
when DICTID = #{item.dictId,jdbcType=VARCHAR} then #{item.dcode,jdbcType=VARCHAR}
</if>
</foreach>
</trim>
<trim prefix="DNAME = case" suffix="end,">
<foreach collection="list" index="index" item="item">
<if test="item.dname != null">
when DICTID = #{item.dictId,jdbcType=VARCHAR} then #{item.dname,jdbcType=VARCHAR}
</if>
</foreach>
</trim>
<trim prefix="SORT = case" suffix="end,">
<foreach collection="list" index="index" item="item">
<if test="item.sort != null">
when DICTID = #{item.dictId,jdbcType=VARCHAR} then #{item.sort,jdbcType=DECIMAL}
</if>
</foreach>
</trim>
<trim prefix="ISTREE = case" suffix="end,">
<foreach collection="list" index="index" item="item">
<if test="item.isTree != null">
when DICTID = #{item.dictId,jdbcType=VARCHAR} then #{item.isTree,jdbcType=CHAR}
</if>
</foreach>
</trim>
<trim prefix="TYPEID = case" suffix="end,">
<foreach collection="list" index="index" item="item">
<if test="item.typeId != null">
when DICTID = #{item.dictId,jdbcType=VARCHAR} then #{item.typeId,jdbcType=VARCHAR}
</if>
</foreach>
</trim>
</trim>
where DICTID in
<foreach close=")" collection="list" item="item" open="(" separator=", ">
#{item.dictId,jdbcType=VARCHAR}
</foreach>
</update>
<insert id="batchInsert" parameterType="map">
<!--@mbg.generated-->
insert into SYS_DICT
(DICTID, PARENTID, DCODE, DNAME, SORT, ISTREE, TYPEID)
<foreach collection="list" item="item" index="index" separator="union all">
(select #{item.dictId,jdbcType=VARCHAR},
#{item.parentId,jdbcType=VARCHAR},
#{item.dcode,jdbcType=VARCHAR},
#{item.dname,jdbcType=VARCHAR},
#{item.sort,jdbcType=DECIMAL},
#{item.isTree,jdbcType=CHAR},
#{item.typeId,jdbcType=VARCHAR}
from dual)
</foreach>
</insert>
<select id="getSysDictParent" resultType="com.pashanhoo.dictionary.model.vo.GetSysDictParentVo">
select rownum,SD.*
from SYS_DICT SD
<where>
PARENTID is null
<if test="request.dcode != null and request.dcode != ''">
and DCODE like '%'||#{request.dcode,jdbcType=VARCHAR}||'%'
</if>
<if test="request.dname != null and request.dname != ''">
and DNAME like '%'||#{request.dname,jdbcType=VARCHAR}||'%'
</if>
</where>
</select>
<select id="getSysDictByTypeId" resultMap="BaseResultMap">
select *
from SYS_DICT
where TYPEID = #{typeId,jdbcType=VARCHAR}
and PARENTID is not null
</select>
<delete id="deleteListByPrimaryKey">
delete
from SYS_DICT
where
DICTID in
<foreach collection="dictWithoutParent" index="index" item="item" open="(" close=")" separator=",">
#{item.dictId,jdbcType=VARCHAR}
</foreach>
</delete>
<select id="selectAll" resultMap="BaseResultMap">
select *
from SYS_DICT
</select>
<select id="getSysDictChildByParentCode" resultType="com.pashanhoo.dictionary.model.dto.SysDict">
select dcode,dname
from sys_dict t where parentid =(select dictid from sys_dict where dcode = #{dcode,jdbcType=VARCHAR} )
CONNECT by PRIOR t.dictid = t.parentid
start with dcode = #{dcode,jdbcType=VARCHAR}
ORDER siblings BY t.sort
</select>
<delete id="deleteByTypeId">
delete from SYS_DICT where TYPEID = #{typeid,jdbcType=VARCHAR} and PARENTID is not null
</delete>
</mapper>