DeXun/fad_oa
9
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

xg-v1.0

Browse Source
This commit is contained in:
huangxing123
2024-07-07 21:09:28 +08:00
parent 0d98d5fe14
commit fc04b10d4f
1279 changed files with 149420 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
ruoyi-oa/src/main/java/com/ruoyi/oa/service/ISysOaArticleService.java Normal file
View File

@@ -0,0 +1,52 @@
package com.ruoyi.oa.service;
import com.ruoyi.oa.domain.SysOaArticle;
import com.ruoyi.oa.domain.vo.SysOaArticleVo;
import com.ruoyi.oa.domain.bo.SysOaArticleBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 知识管理Service接口
*
* @author huangxing
* @date 2024-01-17
*/
public interface ISysOaArticleService {
/**
* 查询知识管理
*/
SysOaArticle selectArticleById(Long articleId);
/**
* 查询知识管理列表
*/
TableDataInfo<SysOaArticleVo> queryPageList(SysOaArticleBo bo, PageQuery pageQuery);
/**
* 查询知识管理列表
*/
List<SysOaArticleVo> queryList(SysOaArticleBo bo);
TableDataInfo<SysOaArticleVo> selectArticlePageList(SysOaArticleBo bo, PageQuery pageQuery);
/**
* 新增知识管理
*/
Boolean insertByBo(SysOaArticleBo bo);
/**
* 修改知识管理
*/
Boolean updateByBo(SysOaArticleBo bo);
/**
* 校验并批量删除知识管理信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

49
ruoyi-oa/src/main/java/com/ruoyi/oa/service/ISysOaBidService.java Normal file
View File

@@ -0,0 +1,49 @@
package com.ruoyi.oa.service;
import com.ruoyi.oa.domain.SysOaBid;
import com.ruoyi.oa.domain.vo.SysOaBidVo;
import com.ruoyi.oa.domain.bo.SysOaBidBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 投标管理Service接口
*
* @author huangxing
* @date 2024-02-23
*/
public interface ISysOaBidService {
/**
* 查询投标管理
*/
SysOaBidVo queryById(Long bidId);
/**
* 查询投标管理列表
*/
TableDataInfo<SysOaBidVo> queryPageList(SysOaBidBo bo, PageQuery pageQuery);
/**
* 查询投标管理列表
*/
List<SysOaBidVo> queryList(SysOaBidBo bo);
/**
* 新增投标管理
*/
Boolean insertByBo(SysOaBidBo bo);
/**
* 修改投标管理
*/
Boolean updateByBo(SysOaBidBo bo);
/**
* 校验并批量删除投标管理信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

43
ruoyi-oa/src/main/java/com/ruoyi/oa/service/ISysOaCategoryService.java Normal file
View File

@@ -0,0 +1,43 @@
package com.ruoyi.oa.service;
import com.ruoyi.oa.domain.SysOaCategory;
import com.ruoyi.oa.domain.vo.SysOaCategoryVo;
import com.ruoyi.oa.domain.bo.SysOaCategoryBo;
import java.util.Collection;
import java.util.List;
/**
* 知识分类Service接口
*
* @author huangxing
* @date 2024-01-17
*/
public interface ISysOaCategoryService {
/**
* 查询知识分类
*/
SysOaCategoryVo queryById(Long categoryId);
/**
* 查询知识分类列表
*/
List<SysOaCategoryVo> queryList(SysOaCategoryBo bo);
/**
* 新增知识分类
*/
Boolean insertByBo(SysOaCategoryBo bo);
/**
* 修改知识分类
*/
Boolean updateByBo(SysOaCategoryBo bo);
/**
* 校验并批量删除知识分类信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

71
ruoyi-oa/src/main/java/com/ruoyi/oa/service/ISysOaContractService.java Normal file
View File

@@ -0,0 +1,71 @@
package com.ruoyi.oa.service;
import com.ruoyi.oa.domain.SysOaContract;
import com.ruoyi.oa.domain.vo.SysOaContractVo;
import com.ruoyi.oa.domain.bo.SysOaContractBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
* 合同管理Service接口
*
* @author huangxing
* @date 2024-01-10
*/
public interface ISysOaContractService {
/**
* 查询合同管理
*/
SysOaContractVo queryById(Long contractId);
/**
* 查询合同管理列表
*/
TableDataInfo<SysOaContractVo> queryPageList(SysOaContractBo bo, PageQuery pageQuery);
/**
* 查询合同管理列表
*/
List<SysOaContractVo> queryList(SysOaContractBo bo);
/**
* 根据项目id查询合同管理
* @param bo
* @return
*/
SysOaContractVo findContractByProjectId(SysOaContractBo bo);
/**
* 根据项目id查询合同列表
* @param bo
* @return
*/
List<SysOaContractVo> selectContractByProjectId(SysOaContractBo bo);
/**
* 新增合同管理
*/
Boolean insertByBo(SysOaContractBo bo);
/**
* 合同流程结束自动保存
* @param param
* @return
*/
void inserByProcess(Map<String, Object> param);
/**
* 修改合同管理
*/
Boolean updateByBo(SysOaContractBo bo);
/**
* 校验并批量删除合同管理信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

49
ruoyi-oa/src/main/java/com/ruoyi/oa/service/ISysOaDetailService.java Normal file
View File

@@ -0,0 +1,49 @@
package com.ruoyi.oa.service;
import com.ruoyi.oa.domain.SysOaDetail;
import com.ruoyi.oa.domain.vo.SysOaDetailVo;
import com.ruoyi.oa.domain.bo.SysOaDetailBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 进出账明细Service接口
*
* @author huangxing
* @date 2024-01-17
*/
public interface ISysOaDetailService {
/**
* 查询进出账明细
*/
SysOaDetailVo queryById(Long detailId);
/**
* 查询进出账明细列表
*/
TableDataInfo<SysOaDetailVo> queryPageList(SysOaDetailBo bo, PageQuery pageQuery);
/**
* 查询进出账明细列表
*/
List<SysOaDetailVo> queryList(SysOaDetailBo bo);
/**
* 新增进出账明细
*/
Boolean insertByBo(SysOaDetailBo bo);
/**
* 修改进出账明细
*/
Boolean updateByBo(SysOaDetailBo bo);
/**
* 校验并批量删除进出账明细信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

92
ruoyi-oa/src/main/java/com/ruoyi/oa/service/ISysOaFinanceService.java Normal file
View File

@@ -0,0 +1,92 @@
package com.ruoyi.oa.service;
import com.ruoyi.oa.domain.SysOaFinance;
import com.ruoyi.oa.domain.vo.SysOaFinanceVo;
import com.ruoyi.oa.domain.bo.SysOaFinanceBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
* 进出账管理Service接口
*
* @author huangxing
* @date 2024-01-17
*/
public interface ISysOaFinanceService {
/**
* 根据分页查询列表
* @param bo
* @param pageQuery
* @return
*/
TableDataInfo<SysOaFinanceVo> selectPageFinanceList(SysOaFinanceBo bo, PageQuery pageQuery);
/**
* 项目进出账查询
* @param bo
* @param pageQuery
* @return
*/
TableDataInfo<SysOaFinanceVo> selectFinanceList(SysOaFinanceBo bo, PageQuery pageQuery);
/**
* 根据id查询详细信息
* @param financeId
* @return
*/
SysOaFinance selectFinanceById(Long financeId);
BigDecimal selectFinanceByProjectId(SysOaFinanceBo bo);
/**
* 查询进出账管理
*/
SysOaFinanceVo queryById(Long financeId);
/**
* 查询进出账管理列表
*/
TableDataInfo<SysOaFinanceVo> queryPageList(SysOaFinanceBo bo, PageQuery pageQuery);
/**
* 查询进出账管理列表
*/
List<SysOaFinanceVo> queryList(SysOaFinanceBo bo);
/**
* 根据时间范围查询列表
*/
BigDecimal findFinanceByTime(SysOaFinanceBo bo, Map paramsMap);
/**
* 新增进出账管理
*/
Boolean insertByBo(SysOaFinanceBo bo);
/**
* 修改进出账管理
*/
Boolean updateByBo(SysOaFinanceBo bo);
/**
* 校验并批量删除进出账管理信息
*/
// Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
/**
* 根据id删除单条数据，并删除关联数据
* @param financeId
* @return
*/
Boolean deleteSysOaFinanceById(Long financeId);
}

49
ruoyi-oa/src/main/java/com/ruoyi/oa/service/ISysOaProjectService.java Normal file
View File

@@ -0,0 +1,49 @@
package com.ruoyi.oa.service;
import com.ruoyi.oa.domain.SysOaProject;
import com.ruoyi.oa.domain.vo.SysOaProjectVo;
import com.ruoyi.oa.domain.bo.SysOaProjectBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 项目管理Service接口
*
* @author huangxing
* @date 2024-01-11
*/
public interface ISysOaProjectService {
/**
* 查询项目管理
*/
SysOaProjectVo queryById(Long projectId);
/**
* 查询项目管理列表
*/
TableDataInfo<SysOaProjectVo> queryPageList(SysOaProjectBo bo, PageQuery pageQuery);
/**
* 查询项目管理列表
*/
List<SysOaProjectVo> queryList(SysOaProjectBo bo);
/**
* 新增项目管理
*/
Boolean insertByBo(SysOaProjectBo bo);
/**
* 修改项目管理
*/
Boolean updateByBo(SysOaProjectBo bo);
/**
* 校验并批量删除项目管理信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

49
ruoyi-oa/src/main/java/com/ruoyi/oa/service/ISysOaPurposeService.java Normal file
View File

@@ -0,0 +1,49 @@
package com.ruoyi.oa.service;
import com.ruoyi.oa.domain.SysOaPurpose;
import com.ruoyi.oa.domain.vo.SysOaPurposeVo;
import com.ruoyi.oa.domain.bo.SysOaPurposeBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 采购意向Service接口
*
* @author huangxing
* @date 2024-03-31
*/
public interface ISysOaPurposeService {
/**
* 查询采购意向
*/
SysOaPurposeVo queryById(Long purposeId);
/**
* 查询采购意向列表
*/
TableDataInfo<SysOaPurposeVo> queryPageList(SysOaPurposeBo bo, PageQuery pageQuery);
/**
* 查询采购意向列表
*/
List<SysOaPurposeVo> queryList(SysOaPurposeBo bo);
/**
* 新增采购意向
*/
Boolean insertByBo(SysOaPurposeBo bo);
/**
* 修改采购意向
*/
Boolean updateByBo(SysOaPurposeBo bo);
/**
* 校验并批量删除采购意向信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

60
ruoyi-oa/src/main/java/com/ruoyi/oa/service/ISysOaRemindService.java Normal file
View File

@@ -0,0 +1,60 @@
package com.ruoyi.oa.service;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.oa.domain.SysOaRemind;
import com.ruoyi.oa.domain.vo.SysOaRemindVo;
import com.ruoyi.oa.domain.bo.SysOaRemindBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 事件提醒Service接口
*
* @author huangxing
* @date 2024-04-02
*/
public interface ISysOaRemindService {
/**
* 查询事件提醒
*/
SysOaRemindVo queryById(Long remindId);
/**
* 查询代办事件列表
* @param bo
* @return
*/
R<List<SysOaRemindVo>> queryRemindList(SysOaRemindBo bo);
Long queryRemindCount(SysOaRemindBo bo);
/**
* 查询事件提醒列表
*/
TableDataInfo<SysOaRemindVo> queryPageList(SysOaRemindBo bo, PageQuery pageQuery);
/**
* 查询事件提醒列表
*/
List<SysOaRemindVo> queryList(SysOaRemindBo bo);
/**
* 新增事件提醒
*/
Boolean insertByBo(SysOaRemindBo bo);
/**
* 修改事件提醒
*/
Boolean updateByBo(SysOaRemindBo bo);
/**
* 校验并批量删除事件提醒信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

64
ruoyi-oa/src/main/java/com/ruoyi/oa/service/ISysOaTaskService.java Normal file
View File

@@ -0,0 +1,64 @@
package com.ruoyi.oa.service;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.oa.domain.SysOaTask;
import com.ruoyi.oa.domain.vo.SysOaTaskVo;
import com.ruoyi.oa.domain.bo.SysOaTaskBo;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
* 任务管理Service接口
*
* @author huangxing
* @date 2024-01-11
*/
public interface ISysOaTaskService {
/**
* 查询任务管理
*/
SysOaTaskVo queryById(Long taskId);
/**
* 查询任务管理列表
*/
TableDataInfo<SysOaTaskVo> queryPageList(SysOaTaskBo bo, PageQuery pageQuery);
/**
* 查询任务管理列表
*/
List<SysOaTaskVo> queryList(SysOaTaskBo bo);
/****
* 据工作类型字典查询任务列表
* @param pid
* @return
*/
R queryTaskByDictList(Long pid);
/**
* 根据工作类型查询列表
* @param bo
* @return
*/
List<SysOaTaskVo> queryListByType(SysOaTaskBo bo);
/**
* 新增任务管理
*/
Boolean insertByBo(SysOaTaskBo bo);
/**
* 修改任务管理
*/
Boolean updateByBo(SysOaTaskBo bo);
/**
* 校验并批量删除任务管理信息
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

137
ruoyi-oa/src/main/java/com/ruoyi/oa/service/impl/SysOaArticleServiceImpl.java Normal file
View File

@@ -0,0 +1,137 @@
package com.ruoyi.oa.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.ruoyi.oa.domain.SysOaCategory;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.ruoyi.oa.domain.bo.SysOaArticleBo;
import com.ruoyi.oa.domain.vo.SysOaArticleVo;
import com.ruoyi.oa.domain.SysOaArticle;
import com.ruoyi.oa.mapper.SysOaArticleMapper;
import com.ruoyi.oa.service.ISysOaArticleService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 知识管理Service业务层处理
*
* @author huangxing
* @date 2024-01-17
*/
@RequiredArgsConstructor
@Service
public class SysOaArticleServiceImpl implements ISysOaArticleService {
private final SysOaArticleMapper baseMapper;
/**
* 查询知识管理
*/
@Override
public SysOaArticle selectArticleById(Long articleId){
SysOaArticle sysOaArticleInfo = baseMapper.selectArticleById(articleId);
//更新阅读数量
SysOaArticleBo sysOaArticleBo = new SysOaArticleBo();
sysOaArticleBo.setArticleId(articleId);
sysOaArticleBo.setCheckNum(sysOaArticleInfo.getCheckNum() + 1);
this.updateByBo(sysOaArticleBo);
return sysOaArticleInfo;
}
/**
* 查询知识管理列表
*/
@Override
public TableDataInfo<SysOaArticleVo> queryPageList(SysOaArticleBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<SysOaArticle> lqw = buildQueryWrapper(bo);
Page<SysOaArticleVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 自定义-查询知识管理列表
* @param bo
* @param pageQuery
* @return
*/
@Override
public TableDataInfo<SysOaArticleVo> selectArticlePageList(SysOaArticleBo bo, PageQuery pageQuery){
LambdaQueryWrapper<SysOaArticle> lqw = buildQueryWrapper(bo);
Page<SysOaArticleVo> articlePageList = baseMapper.selectArticlePageList(pageQuery.build(), lqw);
System.out.println(articlePageList);
return TableDataInfo.build(articlePageList);
}
/**
* 查询知识管理列表
*/
@Override
public List<SysOaArticleVo> queryList(SysOaArticleBo bo) {
LambdaQueryWrapper<SysOaArticle> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<SysOaArticle> buildQueryWrapper(SysOaArticleBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<SysOaArticle> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getCategoryId() != null, SysOaArticle::getCategoryId, bo.getCategoryId());
lqw.eq(StringUtils.isNotBlank(bo.getArticleTitle()), SysOaArticle::getArticleTitle, bo.getArticleTitle());
lqw.orderByDesc(SysOaArticle::getCreateTime);
return lqw;
}
/**
* 新增知识管理
*/
@Override
public Boolean insertByBo(SysOaArticleBo bo) {
SysOaArticle add = BeanUtil.toBean(bo, SysOaArticle.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setArticleId(add.getArticleId());
}
return flag;
}
/**
* 修改知识管理
*/
@Override
public Boolean updateByBo(SysOaArticleBo bo) {
SysOaArticle update = BeanUtil.toBean(bo, SysOaArticle.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(SysOaArticle entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除知识管理
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

116
ruoyi-oa/src/main/java/com/ruoyi/oa/service/impl/SysOaBidServiceImpl.java Normal file
View File

@@ -0,0 +1,116 @@
package com.ruoyi.oa.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.ruoyi.oa.domain.SysOaProject;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.ruoyi.oa.domain.bo.SysOaBidBo;
import com.ruoyi.oa.domain.vo.SysOaBidVo;
import com.ruoyi.oa.domain.SysOaBid;
import com.ruoyi.oa.mapper.SysOaBidMapper;
import com.ruoyi.oa.service.ISysOaBidService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 投标管理Service业务层处理
*
* @author huangxing
* @date 2024-02-23
*/
@RequiredArgsConstructor
@Service
public class SysOaBidServiceImpl implements ISysOaBidService {
private final SysOaBidMapper baseMapper;
/**
* 查询投标管理
*/
@Override
public SysOaBidVo queryById(Long bidId){
return baseMapper.selectVoById(bidId);
}
/**
* 查询投标管理列表
*/
@Override
public TableDataInfo<SysOaBidVo> queryPageList(SysOaBidBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<SysOaBid> lqw = buildQueryWrapper(bo);
Page<SysOaBidVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询投标管理列表
*/
@Override
public List<SysOaBidVo> queryList(SysOaBidBo bo) {
LambdaQueryWrapper<SysOaBid> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<SysOaBid> buildQueryWrapper(SysOaBidBo bo) {
Map<String, Object> params = bo.getParams();
// System.out.println("params===123==" + params);
LambdaQueryWrapper<SysOaBid> lqw = Wrappers.lambdaQuery();
lqw.like(StringUtils.isNotBlank(bo.getBidTitle()), SysOaBid::getBidTitle, bo.getBidTitle());
lqw.eq(StringUtils.isNotBlank(bo.getBidNumber()), SysOaBid::getBidNumber, bo.getBidNumber());
lqw.eq(StringUtils.isNotBlank(bo.getIsWin()), SysOaBid::getIsWin, bo.getIsWin());
lqw.between(params.get("beginCreateTime") != null && params.get("endCreateTime") != null,
SysOaBid::getCreateTime, params.get("beginCreateTime"), params.get("endCreateTime"));
lqw.orderByDesc(SysOaBid::getCreateTime);
return lqw;
}
/**
* 新增投标管理
*/
@Override
public Boolean insertByBo(SysOaBidBo bo) {
SysOaBid add = BeanUtil.toBean(bo, SysOaBid.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setBidId(add.getBidId());
}
return flag;
}
/**
* 修改投标管理
*/
@Override
public Boolean updateByBo(SysOaBidBo bo) {
SysOaBid update = BeanUtil.toBean(bo, SysOaBid.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(SysOaBid entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除投标管理
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

100
ruoyi-oa/src/main/java/com/ruoyi/oa/service/impl/SysOaCategoryServiceImpl.java Normal file
View File

@@ -0,0 +1,100 @@
package com.ruoyi.oa.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.utils.StringUtils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.ruoyi.oa.domain.SysOaTask;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.ruoyi.oa.domain.bo.SysOaCategoryBo;
import com.ruoyi.oa.domain.vo.SysOaCategoryVo;
import com.ruoyi.oa.domain.SysOaCategory;
import com.ruoyi.oa.mapper.SysOaCategoryMapper;
import com.ruoyi.oa.service.ISysOaCategoryService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 知识分类Service业务层处理
*
* @author huangxing
* @date 2024-01-17
*/
@RequiredArgsConstructor
@Service
public class SysOaCategoryServiceImpl implements ISysOaCategoryService {
private final SysOaCategoryMapper baseMapper;
/**
* 查询知识分类
*/
@Override
public SysOaCategoryVo queryById(Long categoryId){
return baseMapper.selectVoById(categoryId);
}
/**
* 查询知识分类列表
*/
@Override
public List<SysOaCategoryVo> queryList(SysOaCategoryBo bo) {
LambdaQueryWrapper<SysOaCategory> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<SysOaCategory> buildQueryWrapper(SysOaCategoryBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<SysOaCategory> lqw = Wrappers.lambdaQuery();
lqw.like(StringUtils.isNotBlank(bo.getCategoryName()), SysOaCategory::getCategoryName, bo.getCategoryName());
lqw.eq(StringUtils.isNotBlank(bo.getStatus()), SysOaCategory::getStatus, bo.getStatus());
lqw.orderByDesc(SysOaCategory::getCreateTime);
return lqw;
}
/**
* 新增知识分类
*/
@Override
public Boolean insertByBo(SysOaCategoryBo bo) {
SysOaCategory add = BeanUtil.toBean(bo, SysOaCategory.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setCategoryId(add.getCategoryId());
}
return flag;
}
/**
* 修改知识分类
*/
@Override
public Boolean updateByBo(SysOaCategoryBo bo) {
SysOaCategory update = BeanUtil.toBean(bo, SysOaCategory.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(SysOaCategory entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除知识分类
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

167
ruoyi-oa/src/main/java/com/ruoyi/oa/service/impl/SysOaContractServiceImpl.java Normal file
View File

@@ -0,0 +1,167 @@
package com.ruoyi.oa.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.ruoyi.oa.domain.SysOaBid;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.oa.domain.bo.SysOaContractBo;
import com.ruoyi.oa.domain.vo.SysOaContractVo;
import com.ruoyi.oa.domain.SysOaContract;
import com.ruoyi.oa.mapper.SysOaContractMapper;
import com.ruoyi.oa.service.ISysOaContractService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 合同管理Service业务层处理
*
* @author huangxing
* @date 2024-01-10
*/
@RequiredArgsConstructor
@Service
public class SysOaContractServiceImpl implements ISysOaContractService {
@Autowired
private SysOaContractMapper contractMapper;
/**
* 查询合同管理
*/
@Override
public SysOaContractVo queryById(Long contractId){
return contractMapper.selectVoById(contractId);
}
/**
* 查询合同管理列表
*/
@Override
public TableDataInfo<SysOaContractVo> queryPageList(SysOaContractBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<SysOaContract> lqw = buildQueryWrapper(bo);
Page<SysOaContractVo> result = contractMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询合同管理列表
*/
@Override
public List<SysOaContractVo> queryList(SysOaContractBo bo) {
LambdaQueryWrapper<SysOaContract> lqw = buildQueryWrapper(bo);
return contractMapper.selectVoList(lqw);
}
/**
* 根据项目id查询合同
* @param bo
* @return
*/
@Override
public SysOaContractVo findContractByProjectId(SysOaContractBo bo){
LambdaQueryWrapper<SysOaContract> sysOaContractLambdaQueryWrapper = buildContractWrapper(bo);
return contractMapper.selectVoOne(sysOaContractLambdaQueryWrapper);
}
/**
* 根据项目id查询合同列表
* @param bo
* @return
*/
@Override
public List<SysOaContractVo> selectContractByProjectId(SysOaContractBo bo){
LambdaQueryWrapper<SysOaContract> sysOaContractLambdaQueryWrapper = buildContractWrapper(bo); ;
return contractMapper.selectVoList(sysOaContractLambdaQueryWrapper);
}
private LambdaQueryWrapper<SysOaContract> buildQueryWrapper(SysOaContractBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<SysOaContract> lqw = Wrappers.lambdaQuery();
lqw.eq(SysOaContract::getContractType, '0');
lqw.eq(StringUtils.isNotBlank(bo.getContractNum()), SysOaContract::getContractNum, bo.getContractNum());
lqw.like(StringUtils.isNotBlank(bo.getContractName()), SysOaContract::getContractName, bo.getContractName());
lqw.between(params.get("beginCreateTime") != null && params.get("endCreateTime") != null,
SysOaContract::getCreateTime, params.get("beginCreateTime"), params.get("endCreateTime"));
lqw.orderByDesc(SysOaContract::getCreateTime);
return lqw;
}
private LambdaQueryWrapper<SysOaContract> buildContractWrapper(SysOaContractBo bo) {
LambdaQueryWrapper<SysOaContract> lqw = Wrappers.lambdaQuery();
lqw.eq(SysOaContract::getProjectId, bo.getProjectId());
lqw.eq(SysOaContract::getContractType, bo.getContractType());
return lqw;
}
/**
* 新增合同管理
*/
@Override
public Boolean insertByBo(SysOaContractBo bo) {
SysOaContract add = BeanUtil.toBean(bo, SysOaContract.class);
validEntityBeforeSave(add);
boolean flag = contractMapper.insert(add) > 0;
if (flag) {
bo.setContractId(add.getContractId());
}
return flag;
}
/**
* 合同流程结束自动保存
* @param param
* @return
*/
@Override
public void inserByProcess(Map<String, Object> param){
System.out.println("map=====" + param);
/*if(param.size() > 0){
return true;
}else {
return false;
}*/
}
/**
* 修改合同管理
*/
@Override
public Boolean updateByBo(SysOaContractBo bo) {
SysOaContract update = BeanUtil.toBean(bo, SysOaContract.class);
validEntityBeforeSave(update);
return contractMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(SysOaContract entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除合同管理
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return contractMapper.deleteBatchIds(ids) > 0;
}
}

110
ruoyi-oa/src/main/java/com/ruoyi/oa/service/impl/SysOaDetailServiceImpl.java Normal file
View File

@@ -0,0 +1,110 @@
package com.ruoyi.oa.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.ruoyi.oa.domain.bo.SysOaDetailBo;
import com.ruoyi.oa.domain.vo.SysOaDetailVo;
import com.ruoyi.oa.domain.SysOaDetail;
import com.ruoyi.oa.mapper.SysOaDetailMapper;
import com.ruoyi.oa.service.ISysOaDetailService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 进出账明细Service业务层处理
*
* @author huangxing
* @date 2024-01-17
*/
@RequiredArgsConstructor
@Service
public class SysOaDetailServiceImpl implements ISysOaDetailService {
private final SysOaDetailMapper baseMapper;
/**
* 查询进出账明细
*/
@Override
public SysOaDetailVo queryById(Long detailId){
return baseMapper.selectVoById(detailId);
}
/**
* 查询进出账明细列表
*/
@Override
public TableDataInfo<SysOaDetailVo> queryPageList(SysOaDetailBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<SysOaDetail> lqw = buildQueryWrapper(bo);
Page<SysOaDetailVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询进出账明细列表
*/
@Override
public List<SysOaDetailVo> queryList(SysOaDetailBo bo) {
LambdaQueryWrapper<SysOaDetail> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<SysOaDetail> buildQueryWrapper(SysOaDetailBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<SysOaDetail> lqw = Wrappers.lambdaQuery();
// lqw.eq(bo.getFinanceId() != null, SysOaDetail::getFinanceId, bo.getFinanceId());
lqw.eq(StringUtils.isNotBlank(bo.getDetailTitle()), SysOaDetail::getDetailTitle, bo.getDetailTitle());
return lqw;
}
/**
* 新增进出账明细
*/
@Override
public Boolean insertByBo(SysOaDetailBo bo) {
SysOaDetail add = BeanUtil.toBean(bo, SysOaDetail.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setDetailId(add.getDetailId());
}
return flag;
}
/**
* 修改进出账明细
*/
@Override
public Boolean updateByBo(SysOaDetailBo bo) {
SysOaDetail update = BeanUtil.toBean(bo, SysOaDetail.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(SysOaDetail entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除进出账明细
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

276
ruoyi-oa/src/main/java/com/ruoyi/oa/service/impl/SysOaFinanceServiceImpl.java Normal file
View File

@@ -0,0 +1,276 @@
package com.ruoyi.oa.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.ruoyi.oa.config.ContextUtil;
import com.ruoyi.oa.domain.SysOaDetail;
import com.ruoyi.oa.domain.bo.SysOaDetailBo;
import com.ruoyi.oa.mapper.SysOaDetailMapper;
import lombok.RequiredArgsConstructor;
import org.apache.ibatis.javassist.runtime.Desc;
import org.springframework.stereotype.Service;
import com.ruoyi.oa.domain.bo.SysOaFinanceBo;
import com.ruoyi.oa.domain.vo.SysOaFinanceVo;
import com.ruoyi.oa.domain.SysOaFinance;
import com.ruoyi.oa.mapper.SysOaFinanceMapper;
import com.ruoyi.oa.service.ISysOaFinanceService;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 进出账管理Service业务层处理
*
* @author huangxing
* @date 2024-01-17
*/
@RequiredArgsConstructor
@Service
public class SysOaFinanceServiceImpl implements ISysOaFinanceService {
private final SysOaFinanceMapper baseMapper;
private final SysOaDetailMapper sysOaDetailMapper;
/**
* 关联进出账明细查询列表
*
* @param bo
* @param pageQuery
* @return
*/
@Override
public TableDataInfo<SysOaFinanceVo> selectPageFinanceList(SysOaFinanceBo bo, PageQuery pageQuery) {
Page<SysOaFinanceVo> sysOaFinanceVoPage = baseMapper.selectPageFinanceList(pageQuery.build(), this.buildQueryWrapper(bo));
return TableDataInfo.build(sysOaFinanceVoPage);
}
/**
* 项目进出账查询
*
* @param bo
* @param pageQuery
* @return
*/
@Override
public TableDataInfo<SysOaFinanceVo> selectFinanceList(SysOaFinanceBo bo, PageQuery pageQuery) {
Page<SysOaFinanceVo> sysOaFinanceVoList = baseMapper.selectFinanceList(pageQuery.build(), this.buildQueryWrapperByFinance(bo));
return TableDataInfo.build(sysOaFinanceVoList);
}
private Wrapper<SysOaFinance> buildQueryWrapperByFinance(SysOaFinanceBo bo) {
Map<String, Object> params = bo.getParams();
QueryWrapper<SysOaFinance> lqw = Wrappers.query();
//前端设定了projectId的值为0和1，0：非项目进出账（添加时候默认为0），1：项目进出账（项目的id是数字串整数，添加时候该字段存储；gt大于0表示项目字段值
// lqw.ge("a.project_id ",bo.getProjectId());
lqw.eq(ObjectUtil.isNotNull(bo.getProjectId()), "a.project_id", bo.getProjectId());
lqw.eq(StringUtils.isNotBlank(bo.getFinanceType()), "a.finance_type", bo.getFinanceType());
lqw.orderByDesc("a.create_time");
return lqw;
}
/**
* 根据时间范围(非项目)查询进出账核算
*/
@Override
public BigDecimal findFinanceByTime(SysOaFinanceBo bo, Map params) {
//通过参数查询主表列表，同时一对多查出子表
Map<String, Object> paramsMap = bo.getParams();
paramsMap.put("financeType", params.get("financeType"));
paramsMap.put("beginTime", params.get("beginTime"));
paramsMap.put("endTime", params.get("endTime"));
List<SysOaFinance> financeByTime = baseMapper.findFinanceByTime(paramsMap);
//遍历子表，将价格遍历为数组并用map方法求和，该方法类型使用map比较妥当
ArrayList<BigDecimal> objects = new ArrayList<>();
financeByTime.forEach(v -> {
BigDecimal reduce = v.getDetailList().stream().map(s -> s.getPrice()).reduce(BigDecimal.ZERO, BigDecimal::add);
objects.add(reduce);
});
//主表再次求和
BigDecimal reduce = objects.stream().reduce(BigDecimal.ZERO, BigDecimal::add);
return reduce;
}
/**
* 根据id查询列表
*
* @param financeId
* @return
*/
@Override
public SysOaFinance selectFinanceById(Long financeId) {
return baseMapper.selectFinanceById(financeId);
}
/**
* 项目核算
*
* @param bo
* @return
*/
@Override
public BigDecimal selectFinanceByProjectId(SysOaFinanceBo bo) {
List<SysOaFinance> sysOaFinances = baseMapper.selectFinanceByProjectId(bo);
System.out.println("sysOaFinances===" + sysOaFinances);
System.out.println("sysOaFinances000===" + sysOaFinances.size());
if (sysOaFinances.size() > 0) {
ArrayList<BigDecimal> objects = new ArrayList<>();
sysOaFinances.forEach(v -> {
System.out.println("vvvv" + v.getDetailList());
BigDecimal reduce = v.getDetailList().stream().map(s -> s.getPrice() == null ? new BigDecimal(0) : s.getPrice()).reduce(BigDecimal.ZERO, BigDecimal::add);
objects.add(reduce);
});
//主表再次求和
BigDecimal reduce = objects.stream().reduce(BigDecimal.ZERO, BigDecimal::add);
System.out.println("hehehehe999===" + reduce);
return reduce;
} else {
BigDecimal reduce = new BigDecimal(0);
System.out.println("hehehehe===" + reduce);
return reduce;
}
}
/**
* 查询进出账管理
*/
@Override
public SysOaFinanceVo queryById(Long financeId) {
return baseMapper.selectVoById(financeId);
}
/**
* 查询进出账管理列表
*/
@Override
public TableDataInfo<SysOaFinanceVo> queryPageList(SysOaFinanceBo bo, PageQuery pageQuery) {
// LambdaQueryWrapper<SysOaFinance> lqw = buildQueryWrapper(bo);
Wrapper<SysOaFinance> lqw = buildQueryWrapper(bo);
Page<SysOaFinanceVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询进出账管理列表
*/
@Override
public List<SysOaFinanceVo> queryList(SysOaFinanceBo bo) {
Wrapper<SysOaFinance> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
// private LambdaQueryWrapper<SysOaFinance> buildQueryWrapper(SysOaFinanceBo bo) {
private Wrapper<SysOaFinance> buildQueryWrapper(SysOaFinanceBo bo) {
Map<String, Object> params = bo.getParams();
QueryWrapper<SysOaFinance> lqw = Wrappers.query();
//前端设定了projectId的值为0和1，0：非项目进出账（添加时候默认为0），1：项目进出账（项目的id是数字串整数，添加时候该字段存储；gt大于0表示项目字段值
lqw.eq("a.project_id", bo.getProjectId());
lqw.like(StringUtils.isNotBlank(bo.getFinanceTitle()), "a.finance_title", bo.getFinanceTitle());
lqw.like(StringUtils.isNotBlank(bo.getFinanceParties()), "a.finance_parties", bo.getFinanceParties());
lqw.eq(StringUtils.isNotBlank(bo.getFinanceType()), "a.finance_type", bo.getFinanceType());
lqw.between(params.get("beginCreateTime") != null && params.get("endCreateTime") != null,
"a.create_time", params.get("beginCreateTime"), params.get("endCreateTime"));
lqw.orderByDesc("create_time");
return lqw;
}
/**
* 新增进出账管理
*/
@Override
public Boolean insertByBo(SysOaFinanceBo bo) {
SysOaFinance add = BeanUtil.toBean(bo, SysOaFinance.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setFinanceId(add.getFinanceId());
}
//子表数据插入
insertSysOaDetail(bo);
return flag;
}
/**
* 修改进出账管理
*/
@Override
public Boolean updateByBo(SysOaFinanceBo bo) {
SysOaFinance update = BeanUtil.toBean(bo, SysOaFinance.class);
validEntityBeforeSave(update);
//先删除原来数据
sysOaDetailMapper.deleteSysOaDetailByfinanceId(bo.getFinanceId());
//再插入修改后的数据
insertSysOaDetail(bo);
return baseMapper.updateById(update) > 0;
}
/**
* 关联子表的数据新增和修改
*
* @param bo
*/
public void insertSysOaDetail(SysOaFinanceBo bo) {
List<SysOaDetail> detailList = bo.getDetailList();
Long financeId = bo.getFinanceId();
if (detailList.size() > 0) {
List<SysOaDetail> sysOaDetails = new ArrayList<>();
for (SysOaDetail list : detailList) {
list.setFinanceId(financeId);
sysOaDetails.add(list);
}
if (sysOaDetails.size() > 0) {
sysOaDetailMapper.batchSysOaDetail(sysOaDetails);
}
}
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(SysOaFinance entity) {
//TODO 做一些数据校验,如唯一约束
}
/**
* 根据id删除单条数据，并删除关联数据
*
* @param financeId
* @return
*/
@Override
public Boolean deleteSysOaFinanceById(Long financeId) {
sysOaDetailMapper.deleteSysOaDetailByfinanceId(financeId);
return baseMapper.deleteById(financeId) > 0;
}
/**
* 批量删除进出账管理
*/
/*@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}*/
}

114
ruoyi-oa/src/main/java/com/ruoyi/oa/service/impl/SysOaProjectServiceImpl.java Normal file
View File

@@ -0,0 +1,114 @@
package com.ruoyi.oa.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.ruoyi.oa.domain.SysOaContract;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.ruoyi.oa.domain.bo.SysOaProjectBo;
import com.ruoyi.oa.domain.vo.SysOaProjectVo;
import com.ruoyi.oa.domain.SysOaProject;
import com.ruoyi.oa.mapper.SysOaProjectMapper;
import com.ruoyi.oa.service.ISysOaProjectService;
import java.util.*;
/**
* 项目管理Service业务层处理
*
* @author huangxing
* @date 2024-01-11
*/
@RequiredArgsConstructor
@Service
public class SysOaProjectServiceImpl implements ISysOaProjectService {
private final SysOaProjectMapper baseMapper;
/**
* 查询项目管理
*/
@Override
public SysOaProjectVo queryById(Long projectId){
return baseMapper.selectVoById(projectId);
}
/**
* 查询项目管理列表
*/
@Override
public TableDataInfo<SysOaProjectVo> queryPageList(SysOaProjectBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<SysOaProject> lqw = buildQueryWrapper(bo);
Page<SysOaProjectVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询项目管理列表
*/
@Override
public List<SysOaProjectVo> queryList(SysOaProjectBo bo) {
LambdaQueryWrapper<SysOaProject> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<SysOaProject> buildQueryWrapper(SysOaProjectBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<SysOaProject> lqw = Wrappers.lambdaQuery();
lqw.like(StringUtils.isNotBlank(bo.getProjectName()), SysOaProject::getProjectName, bo.getProjectName());
lqw.eq(StringUtils.isNotBlank(bo.getProjectNum()), SysOaProject::getProjectNum, bo.getProjectNum());
lqw.eq(StringUtils.isNotBlank(bo.getProjectType()), SysOaProject::getProjectType, bo.getProjectType());
lqw.eq(StringUtils.isNotBlank(bo.getProjectStatus()), SysOaProject::getProjectStatus, bo.getProjectStatus());
lqw.between(params.get("beginCreateTime") != null && params.get("endCreateTime") != null,
SysOaProject::getCreateTime, params.get("beginCreateTime"), params.get("endCreateTime"));
lqw.orderByDesc(SysOaProject::getCreateTime);
return lqw;
}
/**
* 新增项目管理
*/
@Override
public Boolean insertByBo(SysOaProjectBo bo) {
SysOaProject add = BeanUtil.toBean(bo, SysOaProject.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setProjectId(add.getProjectId());
}
return flag;
}
/**
* 修改项目管理
*/
@Override
public Boolean updateByBo(SysOaProjectBo bo) {
SysOaProject update = BeanUtil.toBean(bo, SysOaProject.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(SysOaProject entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除项目管理
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

111
ruoyi-oa/src/main/java/com/ruoyi/oa/service/impl/SysOaPurposeServiceImpl.java Normal file
View File

@@ -0,0 +1,111 @@
package com.ruoyi.oa.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.ruoyi.oa.domain.bo.SysOaPurposeBo;
import com.ruoyi.oa.domain.vo.SysOaPurposeVo;
import com.ruoyi.oa.domain.SysOaPurpose;
import com.ruoyi.oa.mapper.SysOaPurposeMapper;
import com.ruoyi.oa.service.ISysOaPurposeService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 采购意向Service业务层处理
*
* @author huangxing
* @date 2024-03-31
*/
@RequiredArgsConstructor
@Service
public class SysOaPurposeServiceImpl implements ISysOaPurposeService {
private final SysOaPurposeMapper baseMapper;
/**
* 查询采购意向
*/
@Override
public SysOaPurposeVo queryById(Long purposeId){
return baseMapper.selectVoById(purposeId);
}
/**
* 查询采购意向列表
*/
@Override
public TableDataInfo<SysOaPurposeVo> queryPageList(SysOaPurposeBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<SysOaPurpose> lqw = buildQueryWrapper(bo);
Page<SysOaPurposeVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询采购意向列表
*/
@Override
public List<SysOaPurposeVo> queryList(SysOaPurposeBo bo) {
LambdaQueryWrapper<SysOaPurpose> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<SysOaPurpose> buildQueryWrapper(SysOaPurposeBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<SysOaPurpose> lqw = Wrappers.lambdaQuery();
lqw.like(StringUtils.isNotBlank(bo.getPurposeTitle()), SysOaPurpose::getPurposeTitle, bo.getPurposeTitle());
lqw.like(StringUtils.isNotBlank(bo.getSubhead()), SysOaPurpose::getSubhead, bo.getSubhead());
lqw.eq(StringUtils.isNotBlank(bo.getIsBid()), SysOaPurpose::getIsBid, bo.getIsBid());
return lqw;
}
/**
* 新增采购意向
*/
@Override
public Boolean insertByBo(SysOaPurposeBo bo) {
SysOaPurpose add = BeanUtil.toBean(bo, SysOaPurpose.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setPurposeId(add.getPurposeId());
}
return flag;
}
/**
* 修改采购意向
*/
@Override
public Boolean updateByBo(SysOaPurposeBo bo) {
SysOaPurpose update = BeanUtil.toBean(bo, SysOaPurpose.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(SysOaPurpose entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除采购意向
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

143
ruoyi-oa/src/main/java/com/ruoyi/oa/service/impl/SysOaRemindServiceImpl.java Normal file
View File

@@ -0,0 +1,143 @@
package com.ruoyi.oa.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.helper.LoginHelper;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.apache.catalina.security.SecurityUtil;
import org.springframework.stereotype.Service;
import com.ruoyi.oa.domain.bo.SysOaRemindBo;
import com.ruoyi.oa.domain.vo.SysOaRemindVo;
import com.ruoyi.oa.domain.SysOaRemind;
import com.ruoyi.oa.mapper.SysOaRemindMapper;
import com.ruoyi.oa.service.ISysOaRemindService;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 事件提醒Service业务层处理
*
* @author huangxing
* @date 2024-04-02
*/
@RequiredArgsConstructor
@Service
public class SysOaRemindServiceImpl implements ISysOaRemindService {
private final SysOaRemindMapper baseMapper;
/**
* 查询事件提醒
*/
@Override
public SysOaRemindVo queryById(Long remindId){
return baseMapper.selectVoById(remindId);
}
/**
* 查询代办事件列表
* @param bo
* @return
*/
@Override
public R<List<SysOaRemindVo>> queryRemindList(SysOaRemindBo bo){
LambdaQueryWrapper<SysOaRemind> lqw = buildQueryWrapper(bo);
List<SysOaRemindVo> sysOaRemindVos = baseMapper.selectVoList(lqw);
return R.ok(sysOaRemindVos);
}
@Override
public Long queryRemindCount(SysOaRemindBo bo){
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<SysOaRemind> lqw = Wrappers.lambdaQuery();
lqw.eq(StringUtils.isNotBlank(bo.getTaskStatus()), SysOaRemind::getTaskStatus, bo.getTaskStatus());
lqw.between(params.get("beginTime") != null && params.get("endTime") != null, SysOaRemind::getTaskTime, params.get("beginTime"), params.get("endTime"));
Long aLong = baseMapper.selectCount(lqw);
return aLong;
}
/**
* 查询事件提醒列表
*/
@Override
public TableDataInfo<SysOaRemindVo> queryPageList(SysOaRemindBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<SysOaRemind> lqw = buildQueryWrapper(bo);
Page<SysOaRemindVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询事件提醒列表
*/
@Override
public List<SysOaRemindVo> queryList(SysOaRemindBo bo) {
LambdaQueryWrapper<SysOaRemind> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<SysOaRemind> buildQueryWrapper(SysOaRemindBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<SysOaRemind> lqw = Wrappers.lambdaQuery();
lqw.like(StringUtils.isNotBlank(bo.getTaskTitle()), SysOaRemind::getTaskTitle, bo.getTaskTitle());
// lqw.eq(bo.getTaskTime() != null, SysOaRemind::getTaskTime, bo.getTaskTime());
lqw.eq(StringUtils.isNotBlank(bo.getTaskStatus()), SysOaRemind::getTaskStatus, bo.getTaskStatus());
lqw.between(params.get("beginTime") != null && params.get("endTime") != null, SysOaRemind::getTaskTime, params.get("beginTime"), params.get("endTime"));
lqw.orderByDesc(SysOaRemind::getCreateTime);
return lqw;
}
/**
* 新增事件提醒
*/
@Override
public Boolean insertByBo(SysOaRemindBo bo) {
bo.setCreateBy(LoginHelper.getUsername());
bo.setCreateTime(new Date());
SysOaRemind add = BeanUtil.toBean(bo, SysOaRemind.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setRemindId(add.getRemindId());
}
return flag;
}
/**
* 修改事件提醒
*/
@Override
public Boolean updateByBo(SysOaRemindBo bo) {
bo.setUpdateBy(LoginHelper.getUsername());
bo.setUpdateTime(new Date());
SysOaRemind update = BeanUtil.toBean(bo, SysOaRemind.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(SysOaRemind entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除事件提醒
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}

177
ruoyi-oa/src/main/java/com/ruoyi/oa/service/impl/SysOaTaskServiceImpl.java Normal file
View File

@@ -0,0 +1,177 @@
package com.ruoyi.oa.service.impl;
import cn.dev33.satoken.fun.SaParamRetFunction;
import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.common.core.domain.entity.SysDictType;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.helper.LoginHelper;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.domain.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.ruoyi.system.service.ISysDictTypeService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import com.ruoyi.oa.domain.bo.SysOaTaskBo;
import com.ruoyi.oa.domain.vo.SysOaTaskVo;
import com.ruoyi.oa.domain.SysOaTask;
import com.ruoyi.oa.mapper.SysOaTaskMapper;
import com.ruoyi.oa.service.ISysOaTaskService;
import java.util.*;
import java.util.stream.Collectors;
/**
* 任务管理Service业务层处理
*
* @author huangxing
* @date 2024-01-11
*/
@RequiredArgsConstructor
@Service
public class SysOaTaskServiceImpl implements ISysOaTaskService {
private final SysOaTaskMapper baseMapper;
private final ISysDictTypeService dictTypeService;
/**
* 查询任务管理
*/
@Override
public SysOaTaskVo queryById(Long taskId){
return baseMapper.selectVoById(taskId);
}
/**
* 查询任务管理列表
*/
@Override
public TableDataInfo<SysOaTaskVo> queryPageList(SysOaTaskBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<SysOaTask> lqw = buildQueryWrapper(bo);
//查询当前用户下的数据列表
lqw.eq(StringUtils.isNotBlank(LoginHelper.getLoginUser().getUsername()), SysOaTask::getCreateBy,LoginHelper.getLoginUser().getUsername());
Page<SysOaTaskVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 据工作类型字典查询任务列表
* @param pid
* @return
*/
@Override
public R queryTaskByDictList(Long pid){
List<Object> objects = new ArrayList<>();
List<SysDictData> sysWorkType = dictTypeService.selectDictDataByType("sys_work_type");
sysWorkType.forEach(item -> {
SysOaTaskBo sysOaTaskBo = new SysOaTaskBo();
sysOaTaskBo.setProjectId(pid);
sysOaTaskBo.setTaskType(item.getDictValue());
List<SysOaTaskVo> sysOaTaskVos = this.queryListByType(sysOaTaskBo);
Map<String, Object> ajax = new HashMap<>();
ajax.put("dictLabel", item.getDictLabel());
ajax.put("dictValue", item.getDictValue());
ajax.put("taskList", sysOaTaskVos);
ajax.put("size", "large");
ajax.put("type", "primary");
ajax.put("icon", "el-icon-more");
ajax.put("color", "#cccccc");
objects.add(ajax);
});
//根据项目id获取任务列表类型属性最大的值
SysOaTaskBo task = new SysOaTaskBo();
task.setProjectId(pid);
List<SysOaTaskVo> taskVos = this.queryListByType(task);
List<Integer> collect = taskVos.stream().map(v -> Integer.parseInt(v.getTaskType())).collect(Collectors.toList());
OptionalInt max = collect.stream().mapToInt(Integer::intValue).max();
Map<String, Object> map = new HashMap<>();
if(max.isPresent()){
map.put("active", max.getAsInt());
}else {
map.put("active", 0);
}
map.put("taskList", objects);
return R.ok(map);
}
/**
* 根据工作类型查询列表
* @param bo
* @return
*/
@Override
public List<SysOaTaskVo> queryListByType(SysOaTaskBo bo){
LambdaQueryWrapper<SysOaTask> lqw = buildQueryWrapper(bo);
lqw.eq(StringUtils.isNotEmpty(bo.getProjectId().toString()), SysOaTask::getProjectId, bo.getProjectId());
lqw.eq(StringUtils.isNotBlank(bo.getTaskType()),SysOaTask::getTaskType, bo.getTaskType());
return baseMapper.selectVoList(lqw);
}
/**
* 查询任务管理列表
*/
@Override
public List<SysOaTaskVo> queryList(SysOaTaskBo bo) {
LambdaQueryWrapper<SysOaTask> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<SysOaTask> buildQueryWrapper(SysOaTaskBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<SysOaTask> lqw = Wrappers.lambdaQuery();
lqw.eq(StringUtils.isNotBlank(bo.getProjectId().toString()), SysOaTask::getProjectId, bo.getProjectId());
lqw.eq(StringUtils.isNotBlank(bo.getTaskType()), SysOaTask::getTaskType, bo.getTaskType());
lqw.like(StringUtils.isNotBlank(bo.getTaskTitle()), SysOaTask::getTaskTitle, bo.getTaskTitle());
lqw.orderByDesc(SysOaTask::getCreateTime);
return lqw;
}
/**
* 新增任务管理
*/
@Override
public Boolean insertByBo(SysOaTaskBo bo) {
SysOaTask add = BeanUtil.toBean(bo, SysOaTask.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setTaskId(add.getTaskId());
}
return flag;
}
/**
* 修改任务管理
*/
@Override
public Boolean updateByBo(SysOaTaskBo bo) {
SysOaTask update = BeanUtil.toBean(bo, SysOaTask.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(SysOaTask entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 批量删除任务管理
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteBatchIds(ids) > 0;
}
}