资产管理

资产管理作为OA系统在相对重要的一部分，我们单独拿出来进行讲解。主要分为两大类，一类为办公用品，另外一类为固定资产。办公用品是指公司内存日常消耗品，例如笔记本、笔、A4纸、墨盒等等，而固定资产指的是办公电脑、打印机、饮水机等物品。固定资产相对复杂一点要经由申购-入库-领用-归还-报废等多项管理。以下为功能示例图：

办公用品管理

办公用品主要功能为公司内部消耗品的库存管理，用户可以直观的看到有哪些耗材需要采购，哪些耗材剩余较多。以下为相关实现代码：

controller

@RestController
@RequestMapping("oaofficesupplies/officesupplies")
@Api(tags="办公用品")
public class OfficesuppliesController {
    @Autowired
    private OfficesuppliesService officesuppliesService;

    @GetMapping("page")
    @ApiOperation("分页")
    @ApiImplicitParams({
        @ApiImplicitParam(name = Constant.PAGE, value = "当前页码，从1开始", paramType = "query", required = true, dataType="int") ,
        @ApiImplicitParam(name = Constant.LIMIT, value = "每页显示记录数", paramType = "query",required = true, dataType="int") ,
        @ApiImplicitParam(name = Constant.ORDER_FIELD, value = "排序字段", paramType = "query", dataType="String") ,
        @ApiImplicitParam(name = Constant.ORDER, value = "排序方式，可选值(asc、desc)", paramType = "query", dataType="String")
    })
    @RequiresPermissions("oaofficesupplies:officesupplies:page")
    public Result<PageData<OfficesuppliesDTO>> page(@ApiIgnore @RequestParam Map<String, Object> params){
        PageData<OfficesuppliesDTO> page = officesuppliesService.page(params);

        return new Result<PageData<OfficesuppliesDTO>>().ok(page);
    }
    
    @GetMapping("list")
	@ApiOperation("列表")
	public Result<List<OfficesuppliesDTO>> list(@ApiIgnore @RequestParam Map<String, Object> params){
		List<OfficesuppliesDTO> list = officesuppliesService.list(params);
		return new Result<List<OfficesuppliesDTO>>().ok(list);
	}

    @GetMapping("{id}")
    @ApiOperation("信息")
    @RequiresPermissions("oaofficesupplies:officesupplies:info")
    public Result<OfficesuppliesDTO> get(@PathVariable("id") Long id){
        OfficesuppliesDTO data = officesuppliesService.get(id);

        return new Result<OfficesuppliesDTO>().ok(data);
    }

    @PostMapping
    @ApiOperation("保存")
    @LogOperation("保存")
    @RequiresPermissions("oaofficesupplies:officesupplies:save")
    public Result save(@RequestBody OfficesuppliesDTO dto){
        //效验数据
        ValidatorUtils.validateEntity(dto, AddGroup.class, DefaultGroup.class);

        officesuppliesService.save(dto);

        return new Result();
    }

    @PutMapping
    @ApiOperation("修改")
    @LogOperation("修改")
    @RequiresPermissions("oaofficesupplies:officesupplies:update")
    public Result update(@RequestBody OfficesuppliesDTO dto){
        //效验数据
        ValidatorUtils.validateEntity(dto, UpdateGroup.class, DefaultGroup.class);

        officesuppliesService.update(dto);

        return new Result();
    }

    @DeleteMapping
    @ApiOperation("删除")
    @LogOperation("删除")
    @RequiresPermissions("oaofficesupplies:officesupplies:delete")
    public Result delete(@RequestBody Long[] ids){
        //效验数据
        AssertUtils.isArrayEmpty(ids, "id");

        officesuppliesService.delete(ids);

        return new Result();
    }

    @GetMapping("export")
    @ApiOperation("导出")
    @LogOperation("导出")
    @RequiresPermissions("oaofficesupplies:officesupplies:export")
    public Result<Map<String, Object>> export(@ApiIgnore @RequestParam Map<String, Object> params) throws Exception {
        List<OfficesuppliesDTO> list = officesuppliesService.list(params);

        String url = ExcelUtils.generateExcelFile(list,"oaofficesupplies/OfficesuppliesExportTemplate.xml");
        Map<String, Object> data = new HashMap<>(1);
        data.put("url", url);
        Result<Map<String, Object>> result = new Result<Map<String, Object>>().ok(data);
        return result;
    }

    /**
     * 导入excel
     */
    @PostMapping("/import")
    @ApiOperation("导入")
    @LogOperation("导入")
    @RequiresPermissions("oaofficesupplies:officesupplies:save")
    public Result importBatch(@RequestParam(value = "file", required = true) MultipartFile file) {
        Result result = null;
        if (file.getSize() > 0) {
            result = officesuppliesService.importExcel(file);
        } else {
            result = new Result<>().error("文件内容为空，请上传文件");
        }

        return result;
    }

}

办公用品申请管理

办公用品申请管理主要是实现了对公司内部人员耗材使用的管理，通过该功能模块选择办公用品并且申请完成之后，会从相应的办公用品库存当中扣除，超出数量是进行提示处理，请管理员及时补充耗材。以下为相关实现代码：

controller

@RestController
@RequestMapping("oaofficesupplies/officesuppliesreceiv")
@Api(tags="办公用品申请")
public class OfficesuppliesreceivController {
    @Autowired
    private OfficesuppliesreceivService officesuppliesreceivService;

    @GetMapping("page")
    @ApiOperation("分页")
    @ApiImplicitParams({
        @ApiImplicitParam(name = Constant.PAGE, value = "当前页码，从1开始", paramType = "query", required = true, dataType="int") ,
        @ApiImplicitParam(name = Constant.LIMIT, value = "每页显示记录数", paramType = "query",required = true, dataType="int") ,
        @ApiImplicitParam(name = Constant.ORDER_FIELD, value = "排序字段", paramType = "query", dataType="String") ,
        @ApiImplicitParam(name = Constant.ORDER, value = "排序方式，可选值(asc、desc)", paramType = "query", dataType="String")
    })
    @RequiresPermissions("oaofficesupplies:officesuppliesreceiv:page")
    public Result<PageData<OfficesuppliesreceivDTO>> page(@ApiIgnore @RequestParam Map<String, Object> params){
        PageData<OfficesuppliesreceivDTO> page = officesuppliesreceivService.page(params);

        return new Result<PageData<OfficesuppliesreceivDTO>>().ok(page);
    }

    @GetMapping("list")
    @ApiOperation("列表")
    @RequiresPermissions("oaofficesupplies:officesuppliesreceiv:page")
    public Result<List<OfficesuppliesreceivDTO>> list(@ApiIgnore @RequestParam Map<String, Object> params){
        List<OfficesuppliesreceivDTO> list = officesuppliesreceivService.list(params);
        return new Result<List<OfficesuppliesreceivDTO>>().ok(list);
    }

    @GetMapping("{id}")
    @ApiOperation("信息")
    @RequiresPermissions("oaofficesupplies:officesuppliesreceiv:info")
    public Result<OfficesuppliesreceivDTO> get(@PathVariable("id") Long id){
        OfficesuppliesreceivDTO data = officesuppliesreceivService.get(id);
        return new Result<OfficesuppliesreceivDTO>().ok(data);
    }

    @PostMapping
    @ApiOperation("保存")
    @LogOperation("保存")
    @RequiresPermissions("oaofficesupplies:officesuppliesreceiv:save")
    public Result save(@RequestBody OfficesuppliesreceivDTO dto){
        //效验数据
        ValidatorUtils.validateEntity(dto, AddGroup.class, DefaultGroup.class);

        officesuppliesreceivService.save(dto);

        return new Result();
    }

    @PutMapping
    @ApiOperation("修改")
    @LogOperation("修改")
    @RequiresPermissions("oaofficesupplies:officesuppliesreceiv:update")
    public Result update(@RequestBody OfficesuppliesreceivDTO dto){
        //效验数据
        ValidatorUtils.validateEntity(dto, UpdateGroup.class, DefaultGroup.class);

        officesuppliesreceivService.update(dto);

        return new Result();
    }

    @DeleteMapping
    @ApiOperation("删除")
    @LogOperation("删除")
    @RequiresPermissions("oaofficesupplies:officesuppliesreceiv:delete")
    public Result delete(@RequestBody Long[] ids){
        //效验数据
        AssertUtils.isArrayEmpty(ids, "id");

        officesuppliesreceivService.delete(ids);

        return new Result();
    }

    @GetMapping("export")
                @ApiOperation("导出")
                @LogOperation("导出")
                @RequiresPermissions("oaofficesupplies:officesuppliesreceiv:export")
                public void export(@ApiIgnore @RequestParam Map<String, Object> params, HttpServletResponse response) throws Exception {
                List<OfficesuppliesreceivDTO> list = officesuppliesreceivService.list(params);

                ExcelUtils.exportExcelToTarget(response, null, list, OfficesuppliesreceivExcel.class);
                }

                }

service

以上方法包含了常规的增删改，但是还有部分业务逻辑存在于service层，以下为service代码：

@Service
public class OfficesuppliesreceivServiceImpl extends CrudServiceImpl<OfficesuppliesreceivDao, OfficesuppliesreceivEntity, OfficesuppliesreceivDTO> implements OfficesuppliesreceivService {

    @Autowired
    private OfficesuppliesService officesuppliesService;

    //QueryWrapper方式分页查询
    @Override
    public QueryWrapper<OfficesuppliesreceivEntity> getWrapper(Map<String, Object> params){
        QueryWrapper<OfficesuppliesreceivEntity> wrapper = new QueryWrapper<>();

        String userId = (String)params.get("userId");
        if (!StrUtil.isEmptyIfStr(params.get("userId"))) {
        	wrapper.eq("user_id", userId);
        }
        String officeSuppliesId = (String)params.get("officeSuppliesId");
        if (!StrUtil.isEmptyIfStr(params.get("officeSuppliesId"))) {
        	wrapper.eq("office_supplies_id", officeSuppliesId);
        }
        
        return wrapper;
    }
    
    //sql方式分页查询
    @Override
    public PageData<OfficesuppliesreceivDTO> page(Map<String, Object> params) {
        // 分页
        IPage<OfficesuppliesreceivEntity> page = getPage(params, null, false);
        // 查询
        List<OfficesuppliesreceivEntity> list = baseDao.getList(params,page);
        return getPageData(list, page.getTotal(), OfficesuppliesreceivDTO.class);
    }

    @Override
    public OfficesuppliesreceivDTO get(Long id) {
        OfficesuppliesreceivEntity entity = baseDao.getById(id);
        return ConvertUtils.sourceToTarget(entity,OfficesuppliesreceivDTO.class);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void save(OfficesuppliesreceivDTO dto) {
        super.save(dto);
        //改库存
        OfficesuppliesDTO officesuppliesDTO = officesuppliesService.get(dto.getOfficeSuppliesId());
        if ((officesuppliesDTO.getStockNum() - dto.getNumber()) > 0) {
            officesuppliesDTO.setStockNum(officesuppliesDTO.getStockNum()-dto.getNumber());
            officesuppliesService.update(officesuppliesDTO);
        }
        throw new MyException("库存数量不足，请联系管理员！");
    }
}

其中我们主要重写了save方法，因为这个方法当中我们需要操作办公用品表的库存数量，首先我们需要查询出历史的库存数量，之后在去判断库存数量是否充足，如果库存不足，则需要抛出自定义异常进行用户端的提示，如果库存充足，那我们需要修改库存并更新数据。

资产管理

资产管理主要功能为公司内部固定资产的库存管理，通过资产申购、资产领用、资产报废来修改库存数量。以下是资产管理相关代码：

controller

@RestController
@RequestMapping("oaassets/assets")
@Api(tags="资产信息表")
public class AssetsController {
    @Autowired
    private AssetsService assetsService;

    @GetMapping("page")
    @ApiOperation("分页")
    @ApiImplicitParams({
        @ApiImplicitParam(name = Constant.PAGE, value = "当前页码，从1开始", paramType = "query", required = true, dataType="int") ,
        @ApiImplicitParam(name = Constant.LIMIT, value = "每页显示记录数", paramType = "query",required = true, dataType="int") ,
        @ApiImplicitParam(name = Constant.ORDER_FIELD, value = "排序字段", paramType = "query", dataType="String") ,
        @ApiImplicitParam(name = Constant.ORDER, value = "排序方式，可选值(asc、desc)", paramType = "query", dataType="String")
    })
    @RequiresPermissions("oaassets:assets:page")
    public Result<PageData<AssetsDTO>> page(@ApiIgnore @RequestParam Map<String, Object> params){
        PageData<AssetsDTO> page = assetsService.page(params);

        return new Result<PageData<AssetsDTO>>().ok(page);
    }

    @GetMapping("list")
    @ApiOperation("列表")
    public Result<List<AssetsDTO>> list(@ApiIgnore @RequestParam Map<String, Object> params){
        List<AssetsDTO> list = assetsService.list(params);
        return new Result<List<AssetsDTO>>().ok(list);
    }

    @GetMapping("{id}")
    @ApiOperation("信息")
    @RequiresPermissions("oaassets:assets:info")
    public Result<AssetsDTO> get(@PathVariable("id") Long id){
        AssetsDTO data = assetsService.get(id);

        return new Result<AssetsDTO>().ok(data);
    }

    @PostMapping
    @ApiOperation("保存")
    @LogOperation("保存")
    @RequiresPermissions("oaassets:assets:save")
    public Result save(@RequestBody AssetsDTO dto){
        //效验数据
        ValidatorUtils.validateEntity(dto, AddGroup.class, DefaultGroup.class);

        assetsService.save(dto);

        return new Result();
    }

    @PutMapping
    @ApiOperation("修改")
    @LogOperation("修改")
    @RequiresPermissions("oaassets:assets:update")
    public Result update(@RequestBody AssetsDTO dto){
        //效验数据
        ValidatorUtils.validateEntity(dto, UpdateGroup.class, DefaultGroup.class);

        assetsService.update(dto);

        return new Result();
    }

    @DeleteMapping
    @ApiOperation("删除")
    @LogOperation("删除")
    @RequiresPermissions("oaassets:assets:delete")
    public Result delete(@RequestBody Long[] ids){
        //效验数据
        AssertUtils.isArrayEmpty(ids, "id");

        assetsService.delete(ids);

        return new Result();
    }
    @GetMapping("export")
    @ApiOperation("导出")
    @LogOperation("导出")
    @RequiresPermissions("oaassets:assets:export")
    public Result<Map<String, Object>> export(@ApiIgnore @RequestParam Map<String, Object> params) throws Exception {
        List<AssetsDTO> list = assetsService.list(params);

        String url = ExcelUtils.generateExcelFile(list,"oaassets/AssetsExportTemplate.xml");
        Map<String, Object> data = new HashMap<>(1);
        data.put("url", url);
        Result<Map<String, Object>> result = new Result<Map<String, Object>>().ok(data);
        return result;
    }

        /**
        * 导入excel
        */
        @PostMapping("/import")
        @ApiOperation("导入")
        @LogOperation("导入")
        @RequiresPermissions("oaassets:assets:save")
        public Result importBatch(@RequestParam(value = "file", required = true) MultipartFile file) {
        Result result = null;
        if (file.getSize() > 0) {
        result = assetsService.importExcel(file);
    } else {
        result = new Result<>().error("文件内容为空，请上传文件");
    }

        return result;
    }
    }

资产申购管理

资产申购管理是建立在资产管理之上的功能，首先我们需要选择需要申购的资产，模块设计时为了方便用户使用可以进行多条资产数据的添加，以下为实现代码：

controller

@RestController
@RequestMapping("oaassets/assetsbuy")
@Api(tags="资产申购表")
public class AssetsbuyController {
    @Autowired
    private AssetsbuyService assetsbuyService;
    @Autowired
    private DocNumberUtil docNumberUtil;

    @GetMapping("page")
    @ApiOperation("分页")
    @ApiImplicitParams({
        @ApiImplicitParam(name = Constant.PAGE, value = "当前页码，从1开始", paramType = "query", required = true, dataType="int") ,
        @ApiImplicitParam(name = Constant.LIMIT, value = "每页显示记录数", paramType = "query",required = true, dataType="int") ,
        @ApiImplicitParam(name = Constant.ORDER_FIELD, value = "排序字段", paramType = "query", dataType="String") ,
        @ApiImplicitParam(name = Constant.ORDER, value = "排序方式，可选值(asc、desc)", paramType = "query", dataType="String")
    })
    @RequiresPermissions("oaassets:assetsbuy:page")
    public Result<PageData<AssetsbuyDTO>> page(@ApiIgnore @RequestParam Map<String, Object> params){
        PageData<AssetsbuyDTO> page = assetsbuyService.page(params);

        return new Result<PageData<AssetsbuyDTO>>().ok(page);
    }
    
    @GetMapping("list")
	@ApiOperation("列表")
	@RequiresPermissions("oaassets:assetsbuy:page")
	public Result<List<AssetsbuyDTO>> list(@ApiIgnore @RequestParam Map<String, Object> params){
		List<AssetsbuyDTO> list = assetsbuyService.list(params);
		return new Result<List<AssetsbuyDTO>>().ok(list);
	}

    @GetMapping("{id}")
    @ApiOperation("信息")
    @RequiresPermissions("oaassets:assetsbuy:info")
    public Result<AssetsbuyDTO> get(@PathVariable("id") Long id){
        AssetsbuyDTO data = assetsbuyService.get(id);

        return new Result<AssetsbuyDTO>().ok(data);
    }

    @GetMapping("getByDocNumber/{docNumber}")
    @ApiOperation("信息")
    public Result<AssetsbuyDTO> getByDocNumber(@PathVariable("docNumber") String docNumber){
        AssetsbuyDTO data = assetsbuyService.getByDocNumber(docNumber);
        return new Result<AssetsbuyDTO>().ok(data);
    }

    @PostMapping
    @ApiOperation("保存")
    @LogOperation("保存")
    @RequiresPermissions("oaassets:assetsbuy:save")
    public Result save(@RequestBody AssetsbuyDTO dto){
        //效验数据
        ValidatorUtils.validateEntity(dto, AddGroup.class, DefaultGroup.class);
        dto.setDocumentNumber(docNumberUtil.createNumber("CG-"));
        if (ObjectUtil.isNull(dto.getStatus())){
            dto.setStatus(AssetsBuyStatusEnums.NEW_CREATE.getCode());
        }
        assetsbuyService.save(dto);
        Map<String, Object> map = new HashMap<>();
        map.put("businessKey", dto.getId().toString());
        return new Result().ok(map);
    }

    @PutMapping
    @ApiOperation("修改")
    @LogOperation("修改")
    @RequiresPermissions("oaassets:assetsbuy:update")
    public Result update(@RequestBody AssetsbuyDTO dto){
        //效验数据
        ValidatorUtils.validateEntity(dto, UpdateGroup.class, DefaultGroup.class);

        assetsbuyService.update(dto);

        Map<String, Object> map = new HashMap<>();
        map.put("businessKey", dto.getId().toString());
        return new Result().ok(map);
    }

    @GetMapping("submitApprovalHandle/{id}")
    @ApiOperation("提交审批")
    @Transactional(rollbackFor = Exception.class)
    public Result<AssetsbuyDTO> submitApprovalHandle(@PathVariable("id") Long id){
        AssetsbuyDTO dto = new AssetsbuyDTO();
        dto.setId(id);
        dto.setStatus(AssetsBuyStatusEnums.UNDER_APPROVAL.getCode());
        assetsbuyService.updateById(ConvertUtils.sourceToTarget(dto, AssetsbuyEntity.class));
        return new Result<AssetsbuyDTO>();
    }

    @GetMapping("approvalHandle/{id}")
    @ApiOperation("审批")
    @Transactional(rollbackFor = Exception.class)
    public Result<AssetsbuyDTO> approvalHandle(@PathVariable("id") Long id){
        AssetsbuyDTO dto = new AssetsbuyDTO();
        dto.setId(id);
        dto.setStatus(AssetsBuyStatusEnums.PENDING_STORAGE.getCode());
        assetsbuyService.updateById(ConvertUtils.sourceToTarget(dto, AssetsbuyEntity.class));
        return new Result<AssetsbuyDTO>();
    }

    @DeleteMapping
    @ApiOperation("删除")
    @LogOperation("删除")
    @RequiresPermissions("oaassets:assetsbuy:delete")
    public Result delete(@RequestBody Long[] ids){
        //效验数据
        AssertUtils.isArrayEmpty(ids, "id");

        assetsbuyService.delete(ids);

        return new Result();
    }

    @GetMapping("export")
    @ApiOperation("导出")
    @LogOperation("导出")
    @RequiresPermissions("oaassets:assetsbuy:export")
    public void export(@ApiIgnore @RequestParam Map<String, Object> params, HttpServletResponse response) throws Exception {
        List<AssetsbuyDTO> list = assetsbuyService.list(params);

        ExcelUtils.exportExcelToTarget(response, null, list, AssetsbuyExcel.class);
    }

    @PostMapping("updateInstanceId")
    @ApiOperation("更新实例ID和审核状态")
    @LogOperation("更新实例ID")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "businessKey", value = "业务KEY", paramType = "query", required = true, dataType = "String"),
            @ApiImplicitParam(name = "processInstanceId", value = "实例ID", paramType = "query", required = true, dataType = "String")
    })
    public void updateInstanceId(String businessKey, String processInstanceId) {
        AssetsbuyEntity entity = new AssetsbuyEntity();
        entity.setId(Long.valueOf(businessKey));
        entity.setInstanceId(processInstanceId);
        entity.setStatus(AssetsBuyStatusEnums.UNDER_APPROVAL.getCode());
        assetsbuyService.updateById(entity);
    }

    @GetMapping("endWorkflowAfter/{id}")
    @ApiOperation("流程结束")
    @LogOperation("更新状态")
    public void updateStatus(@PathVariable("id") Long id) {
        AssetsbuyEntity entity = new AssetsbuyEntity();
        entity.setId(id);
        entity.setStatus(AssetsBuyStatusEnums.PENDING_STORAGE.getCode());
        assetsbuyService.updateById(entity);
    }

}

service

@Service
public class AssetsbuyServiceImpl extends CrudServiceImpl<AssetsbuyDao, AssetsbuyEntity, AssetsbuyDTO> implements AssetsbuyService {

    //QueryWrapper方式分页查询
    @Override
    public QueryWrapper<AssetsbuyEntity> getWrapper(Map<String, Object> params){
        QueryWrapper<AssetsbuyEntity> wrapper = new QueryWrapper<>();

        String assetsId = (String)params.get("assetsId");
        if (!StrUtil.isEmptyIfStr(params.get("assetsId"))) {
        	wrapper.eq("assets_id", assetsId);
        }
        String status = (String)params.get("status");
        if (!StrUtil.isEmptyIfStr(params.get("status"))) {
        	wrapper.eq("status", status);
        }	
        
        return wrapper;
    }
    
    //sql方式分页查询
    @Override
    public PageData<AssetsbuyDTO> page(Map<String, Object> params) {
        // 分页
        IPage<AssetsbuyEntity> page = getPage(params, null, false);
        // 查询
        List<AssetsbuyEntity> list = baseDao.getList(params);
        return getPageData(list, page.getTotal(), AssetsbuyDTO.class);
    }
    
    @Override
	public List<AssetsbuyDTO> list(Map<String, Object> params) {
		List<AssetsbuyEntity> entityList = baseDao.getList(params);
		List<AssetsbuyDTO> dtoList = ConvertUtils.sourceToTarget(entityList, AssetsbuyDTO.class);
		return dtoList;
	}

    @Override
    public AssetsbuyDTO get(Long id) {
        AssetsbuyEntity entity = baseDao.getById(id);
        return ConvertUtils.sourceToTarget(entity,AssetsbuyDTO.class);
    }

    @Override
    public AssetsbuyDTO getByDocNumber(String docNumber) {
        AssetsbuyEntity entity = baseDao.getByDocNumber(docNumber);
        return ConvertUtils.sourceToTarget(entity,AssetsbuyDTO.class);
    }

    @Override
    @Transactional
    public void save(AssetsbuyDTO dto) {
        super.save(dto);
        dto.getAssetsList().forEach(sonMap -> {
            sonMap.put("assetsBuyId", dto.getId());
        });
        baseDao.saveBatchSon(dto.getAssetsList());
    }

    @Override
    @Transactional
    public void update(AssetsbuyDTO dto) {
        super.update(dto);
        Long[] ids = {dto.getId()};
        baseDao.delSon(ids);
        dto.getAssetsList().forEach(sonMap -> {
            sonMap.put("assetsBuyId", dto.getId());
        });
        baseDao.saveBatchSon(dto.getAssetsList());
    }

    @Override
    public void delete(Long[] ids) {
        super.delete(ids);
        baseDao.delSon(ids);
    }

    @Override
    public AssetsbuyDTO getByInstanceId(String instanceId) {
        QueryWrapper<AssetsbuyEntity> wrapper = new QueryWrapper<>();
        wrapper.eq("instance_id", instanceId);
        AssetsbuyEntity entity = baseDao.selectOne(wrapper);
        return ConvertUtils.sourceToTarget(entity,AssetsbuyDTO.class);
    }
}

由于实现了一个申请单可以包含多个资产申购，我们在这里使用了一个字表，在保存申请单的同时我们需要把申购的资产放入子表进行存储，以实现一个申请单对应多个申购资产的功能。从以上代码可以看出我们在save方法和update方法中都有申购记录子表的操作，在update方法当中我们需要先去除原有的资产记录，在进行新的记录的插入，为了防止数据的重复。

资产入库管理

实现资产入库功能，包含了资产入库的查看、新增、修改、删除、导出等功能。以下是实现代码:

controller

@RestController
@RequestMapping("oaassets/assetswarehousing")
@Api(tags="资产入库记录")
public class AssetswarehousingController {
    @Autowired
    private AssetswarehousingService assetswarehousingService;
    @Autowired
    private DocNumberUtil docNumberUtil;

    @GetMapping("page")
    @ApiOperation("分页")
    @ApiImplicitParams({
        @ApiImplicitParam(name = Constant.PAGE, value = "当前页码，从1开始", paramType = "query", required = true, dataType="int") ,
        @ApiImplicitParam(name = Constant.LIMIT, value = "每页显示记录数", paramType = "query",required = true, dataType="int") ,
        @ApiImplicitParam(name = Constant.ORDER_FIELD, value = "排序字段", paramType = "query", dataType="String") ,
        @ApiImplicitParam(name = Constant.ORDER, value = "排序方式，可选值(asc、desc)", paramType = "query", dataType="String")
    })
    @RequiresPermissions("oaassets:assetswarehousing:page")
    public Result<PageData<AssetswarehousingDTO>> page(@ApiIgnore @RequestParam Map<String, Object> params){
        PageData<AssetswarehousingDTO> page = assetswarehousingService.page(params);

        return new Result<PageData<AssetswarehousingDTO>>().ok(page);
    }

    @GetMapping("list")
    @ApiOperation("列表")
    @RequiresPermissions("oaassets:assetswarehousing:page")
    public Result<List<AssetswarehousingDTO>> list(@ApiIgnore @RequestParam Map<String, Object> params){
        List<AssetswarehousingDTO> list = assetswarehousingService.list(params);
        return new Result<List<AssetswarehousingDTO>>().ok(list);
    }

    @GetMapping("{id}")
    @ApiOperation("信息")
    @RequiresPermissions("oaassets:assetswarehousing:info")
    public Result<AssetswarehousingDTO> get(@PathVariable("id") Long id){
        AssetswarehousingDTO data = assetswarehousingService.get(id);

        return new Result<AssetswarehousingDTO>().ok(data);
    }

    @GetMapping("submitApprovalHandle/{id}")
    @ApiOperation("提交审批")
    @Transactional(rollbackFor = Exception.class)
    public Result submitApprovalHandle(@PathVariable("id") Long id){
        AssetswarehousingDTO dto = new AssetswarehousingDTO();
        dto.setId(id);
        dto.setReceiveStatus(AssetsWarehousingEnums.UNDER_APPROVAL.getCode());
        assetswarehousingService.updateById(ConvertUtils.sourceToTarget(dto, AssetswarehousingEntity.class));
        return new Result();
    }

    @GetMapping("approvalHandle/{id}")
    @ApiOperation("审批")
    @Transactional(rollbackFor = Exception.class)
    public Result approvalHandle(@PathVariable("id") Long id){
        AssetswarehousingDTO dto = new AssetswarehousingDTO();
        dto.setId(id);
        dto.setReceiveUserId(SecurityUser.getUser().getId());
        dto.setReceiveStatus(AssetsWarehousingEnums.IN_STOCK.getCode());
        assetswarehousingService.updateById(ConvertUtils.sourceToTarget(dto, AssetswarehousingEntity.class));
        return new Result();
    }

    @PostMapping
    @ApiOperation("保存")
    @LogOperation("保存")
    @RequiresPermissions("oaassets:assetswarehousing:save")
    public Result save(@RequestBody AssetswarehousingDTO dto){
    //效验数据
    ValidatorUtils.validateEntity(dto, AddGroup.class, DefaultGroup.class);
    dto.setDocumentNumber(docNumberUtil.createNumber("RK-"));
    if (ObjectUtil.isNull(dto.getReceiveStatus())){
    dto.setReceiveStatus(AssetsWarehousingEnums.DRAFT.getCode());
    }
    assetswarehousingService.save(dto);

    return new Result();
    }

    @PutMapping
    @ApiOperation("修改")
    @LogOperation("修改")
    @RequiresPermissions("oaassets:assetswarehousing:update")
    public Result update(@RequestBody AssetswarehousingDTO dto){
    //效验数据
    ValidatorUtils.validateEntity(dto, UpdateGroup.class, DefaultGroup.class);

    assetswarehousingService.update(dto);

    return new Result();
    }

    @DeleteMapping
    @ApiOperation("删除")
    @LogOperation("删除")
    @RequiresPermissions("oaassets:assetswarehousing:delete")
    public Result delete(@RequestBody Long[] ids){
    //效验数据
    AssertUtils.isArrayEmpty(ids, "id");

    assetswarehousingService.delete(ids);

    return new Result();
    }

    @GetMapping("export")
    @ApiOperation("导出")
    @LogOperation("导出")
    @RequiresPermissions("oaassets:assetswarehousing:export")
    public void export(@ApiIgnore @RequestParam Map<String, Object> params, HttpServletResponse response) throws Exception {
    List<AssetswarehousingDTO> list = assetswarehousingService.list(params);

    ExcelUtils.exportExcelToTarget(response, null, list, AssetswarehousingExcel.class);
    }

    }

submitApprovalHandle函数

submitApprovalHandle函数主要用于资产入库审批流程当中，它起到一个提交审批，并且启动审批流程的功能。

approvalHandle函数

approvalHandle函数主要用于资产入库审批流程当中的审批步骤。

service

public class AssetswarehousingServiceImpl extends CrudServiceImpl<AssetswarehousingDao, AssetswarehousingEntity, AssetswarehousingDTO> implements AssetswarehousingService {

    //QueryWrapper方式分页查询
    @Override
    public QueryWrapper<AssetswarehousingEntity> getWrapper(Map<String, Object> params){
        QueryWrapper<AssetswarehousingEntity> wrapper = new QueryWrapper<>();

        String receiveStatus = (String)params.get("receiveStatus");
        if (!StrUtil.isEmptyIfStr(params.get("receiveStatus"))) {
            wrapper.eq("receive_status", receiveStatus);
        }  
        String receiveUserId = (String)params.get("receiveUserId");
        if (!StrUtil.isEmptyIfStr(params.get("receiveUserId"))) {
            wrapper.eq("receive_user_id", receiveUserId);
        }

        return wrapper;
    }

    //sql方式分页查询
    @Override
    public PageData<AssetswarehousingDTO> page(Map<String, Object> params) {
        // 分页
        IPage<AssetswarehousingEntity> page = getPage(params, null, false);
        // 查询
        List<AssetswarehousingEntity> list = baseDao.getList(params);
        return getPageData(list, page.getTotal(), AssetswarehousingDTO.class);
    }

    @Override
    public List<AssetswarehousingDTO> list(Map<String, Object> params) {
        List<AssetswarehousingEntity> entityList = baseDao.getList(params);
        List<AssetswarehousingDTO> dtoList = ConvertUtils.sourceToTarget(entityList, AssetswarehousingDTO.class);
        return dtoList;
    }

    @Override
    public AssetswarehousingDTO get(Long id) {
        AssetswarehousingEntity entity = baseDao.getById(id);
        return ConvertUtils.sourceToTarget(entity, AssetswarehousingDTO.class);
    }

    @Override
    @Transactional
    public void save(AssetswarehousingDTO dto) {
        super.save(dto);
        dto.getAssetsList().forEach(sonMap -> {
            sonMap.put("assetsWarehousingId", dto.getId());
        });
        baseDao.saveBatchSon(dto.getAssetsList());
    }

    @Override
    @Transactional
    public void update(AssetswarehousingDTO dto) {
        super.update(dto);
        Long[] ids = {dto.getId()};
        baseDao.delSon(ids);
        dto.getAssetsList().forEach(sonMap -> {
            sonMap.put("assetsWarehousingId", dto.getId());
        });
        baseDao.saveBatchSon(dto.getAssetsList());
    }

    @Override
    @Transactional
    public void delete(Long[] ids) {
        super.delete(ids);
        baseDao.delSon(ids);
    }

文档管理

实现了文档管理功能，包含了文档的查看、新增、修改、删除等功能。以下是controller代码:

@RestController
@RequestMapping("oadocument/document")
@Api(tags="文档")
public class DocumentController {
    @Autowired
    private DocumentService documentService;

    /**
     * 通过PID获取所有数据
     * @param params
     * @return
     */
    @GetMapping("list")
    @ApiOperation("list")
    public Result<List<DocumentDTO>> list(@ApiIgnore @RequestParam Map<String, Object> params){
        List<DocumentDTO> list = documentService.list(params);
        return new Result<List<DocumentDTO>>().ok(list);
    }

    /**
     *
     * @param params
     * @return
     */
    @GetMapping("getFolderList")
    @ApiOperation("getFolderList")
    public Result<List<DocumentDTO>> getFolderList(@ApiIgnore @RequestParam Map<String, Object> params){
        List<DocumentDTO> list = documentService.getFolderList(params);
        for (DocumentDTO dto : list) {
            String s = ",";
            List<Long> parentIdList = new ArrayList<>();
            getParentIds(list,dto.getId(),parentIdList);
            Collections.reverse(parentIdList);
            s = s+StringUtils.join(parentIdList, ",")+",";
            dto.setParentIds(s);
        }
        return new Result<List<DocumentDTO>>().ok(list);
    }

    /**
     * 递归获取父级ids
     * @param documentDTOList
     * @param id
     * @param parentIds
     */
    private void getParentIds(List<DocumentDTO> documentDTOList, Long id, List<Long> parentIds) {
        for (DocumentDTO dto : documentDTOList) {
            if (ObjectUtil.isEmpty(dto.getPid())) {
                continue;
            }
            //判断是否有父节点
            if (id.equals(dto.getId()) && dto.getPid() != 0) {
                parentIds.add(dto.getPid());
                getParentIds(documentDTOList, dto.getPid(), parentIds);
            }
        }
    }

    @GetMapping("{id}")
    @ApiOperation("信息")
    @RequiresPermissions("oadocument:document:info")
    public Result<DocumentDTO> get(@PathVariable("id") Long id){
        DocumentDTO data = documentService.get(id);

        return new Result<DocumentDTO>().ok(data);
    }

    @PostMapping("saveOrUpdateFolder")
    @ApiOperation("保存")
    @LogOperation("保存")
    public Result<Map<String, Object>> saveOrUpdateFolder(@RequestBody Map<String, Object> params){
        DocumentDTO dto = new DocumentDTO();
        dto.setName(params.get("Name").toString());
        dto.setType(1);
        dto.setRemarks(params.get("Describe").toString());
        if (params.containsKey("ParentId")){
            List<Map<String, Object>> list = (List<Map<String, Object>>) params.get("ParentId");
            dto.setPid(Long.valueOf(list.get(0).get("id").toString()));
        }else {
            dto.setPid(0L);
        }
        documentService.save(dto);
        return new Result<Map<String, Object>>().ok(params);
    }

    @PostMapping("saveDoc")
    @ApiOperation("保存")
    @LogOperation("保存")
    public Result saveDoc(@RequestBody DocumentDTO dto){
        dto.setType(4);
        documentService.save(dto);
        return new Result();
    }

    @PostMapping
    @ApiOperation("保存")
    @LogOperation("保存")
    @RequiresPermissions("oadocument:document:save")
    public Result save(@RequestBody DocumentDTO dto){
        //效验数据
        ValidatorUtils.validateEntity(dto, AddGroup.class, DefaultGroup.class);

        documentService.save(dto);

        return new Result();
    }

    @PostMapping("moveUpdate")
    @ApiOperation("修改")
    @LogOperation("修改")
    @RequiresPermissions("oadocument:document:update")
    public Result moveUpdate(@RequestBody DocumentDTO dto){
        //效验数据
        ValidatorUtils.validateEntity(dto, UpdateGroup.class, DefaultGroup.class);

        documentService.update(dto);

        return new Result();
    }

    @DeleteMapping("{id}")
    @ApiOperation("删除")
    @LogOperation("删除")
    @RequiresPermissions("oadocument:document:delete")
    public Result delete(@PathVariable("id") Long id){
        //效验数据
        AssertUtils.isNull(id, "id");

        documentService.deleteById(id);

        return new Result();
    }

}

getFolderList函数

getFolderList函数主要实现了获取所有文件夹并跟进parentId进行处理。

getParentIds函数

getParentIds函数实现了以递归的方式获取文件夹的所有父id。

saveOrUpdateFolder函数

saveOrUpdateFolder函数主要实现了对文档管理中的文件夹新增或者修改的业务。