package com.cloudroam.service.impl;
|
|
import cn.hutool.core.date.DateUtil;
|
import cn.hutool.core.util.IdUtil;
|
import cn.hutool.core.util.StrUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.cloudroam.bo.meeting.MeetingDateUserDaily;
|
import com.cloudroam.bo.meeting.MeetingUserDaily;
|
import com.cloudroam.bo.ProjectDailyBO;
|
import com.cloudroam.bo.ProjectStatisticsBO;
|
import com.cloudroam.bo.businessDaily.BusinessDailyBO;
|
import com.cloudroam.common.LocalUser;
|
import com.cloudroam.common.enumeration.*;
|
import com.cloudroam.dto.businessDaily.BusinessDailyPageDTO;
|
import com.cloudroam.dto.meeting.MeetingPageDTO;
|
import com.cloudroam.dto.projectDaily.*;
|
import com.cloudroam.dto.projectDailyMain.QueryProjectDailyMainDTO;
|
import com.cloudroam.dto.projectTask.QueryProjectTaskHoursDTO;
|
import com.cloudroam.dto.projectTask.QueryTaskDailyDTO;
|
import com.cloudroam.mapper.ProjectDailyMapperCustom;
|
import com.cloudroam.model.*;
|
import com.cloudroam.mapper.ProjectDailyMapper;
|
import com.cloudroam.service.*;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.cloudroam.util.DateUtils;
|
import com.cloudroam.util.JsonUtil;
|
import com.cloudroam.vo.projectDaily.ProjectDailyBoardVO;
|
import com.cloudroam.vo.projectDaily.ProjectDailyHourVO;
|
import com.cloudroam.vo.projectDaily.ProjectDailyStatisticsVO;
|
import io.github.talelin.autoconfigure.exception.ForbiddenException;
|
import io.github.talelin.autoconfigure.exception.NotFoundException;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
import org.springframework.util.StringUtils;
|
|
import javax.validation.ConstraintViolation;
|
import javax.validation.ConstraintViolationException;
|
import javax.validation.Validator;
|
import java.math.BigDecimal;
|
import java.time.LocalDateTime;
|
import java.time.ZoneId;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* <p>
|
* 服务实现类
|
* </p>
|
*
|
* @author generator@TaoJie
|
* @since 2023-08-09
|
*/
|
@Service
|
public class ProjectDailyServiceImpl extends ServiceImpl<ProjectDailyMapper, ProjectDailyDO> implements ProjectDailyService {
|
|
@Autowired
|
private ProjectDailyMapper projectDailyMapper;
|
|
@Autowired
|
private ProjectDailyMapperCustom projectDailyMapperCustom;
|
|
@Autowired
|
private UserService userService;
|
|
@Autowired
|
private ProjectDailyMainService projectDailyMainService;
|
|
@Autowired
|
private ProjectDailyService projectDailyService;
|
|
@Autowired
|
private AdminService adminService;
|
|
@Autowired
|
private BusinessDailyService businessDailyService;
|
|
@Autowired
|
private LinFileReService linFileReService;
|
|
@Autowired
|
private Validator validator; // 注入 Spring 的 Validator
|
|
@Autowired
|
private ProjectInfoService projectInfoService;
|
|
@Autowired
|
private ProjectModuleService projectModuleService;
|
|
@Autowired
|
private ProjectTaskDeveloperService projectTaskDeveloperService;
|
|
@Autowired
|
private ProjectTaskService projectTaskService;
|
|
|
@Override
|
@Transactional
|
public boolean createProjectDaily(CreateOrUpdateProjectDailyDTO validator) {
|
ProjectDailyDO projectDailyDO=new ProjectDailyDO();
|
UserDO user = LocalUser.getLocalUser();
|
|
BeanUtils.copyProperties(validator,projectDailyDO);
|
|
projectDailyDO.setId(IdUtil.simpleUUID());
|
|
projectDailyDO.create(String.valueOf(user.getId()),user.getNickname());
|
|
return projectDailyMapper.insert(projectDailyDO)>0;
|
}
|
|
@Override
|
public IPage<ProjectDailyBO> getProjectDailyPage(QueryProjectDailyDTO dto) {
|
// -1 代表所有人
|
if(dto.getCreateUserId().equals("-1")){
|
dto.setCreateUserId(null);
|
}
|
|
Page<ProjectDailyBO> page=new Page<ProjectDailyBO>(dto.getPage(),dto.getCount());
|
// return projectDailyMapperCustom.selectProjectDailyPage(page,dto.getKeyword()
|
// ,dto.getDailyDate(),dto.getDailyType(),dto.getDailyStatus(),dto.getProjectId()
|
// ,dto.getCreateUserId(),dto.getIsCommit(),dto.getIsConfirm());
|
|
if(com.baomidou.mybatisplus.core.toolkit.StringUtils.isNotBlank(dto.getModuleId())){
|
// 查看模块下的所有子模块
|
List<ProjectModuleDO> moduleIds=projectModuleService.getChildrenModuleIds(dto.getModuleId());
|
|
if(com.baomidou.mybatisplus.core.toolkit.CollectionUtils.isNotEmpty(moduleIds)&&moduleIds.size()>0){
|
List<String> moduleIdList=moduleIds.stream().map(ProjectModuleDO::getId).collect(Collectors.toList());
|
moduleIdList.add(dto.getModuleId());
|
// 查找所有模块下的id
|
dto.setModuleIds(moduleIdList);
|
}else{
|
List<String> moduleIdList=new ArrayList<>();
|
moduleIdList.add(dto.getModuleId());
|
dto.setModuleIds(moduleIdList);
|
}
|
|
}
|
return projectDailyMapperCustom.selectProjectDailyTaskPage(page,dto);
|
}
|
|
@Override
|
@Transactional
|
public boolean removeByIdLogic(String id, Date dailyDate) {
|
UserDO user = LocalUser.getLocalUser();
|
|
ProjectDailyDO projectDailyDO=new ProjectDailyDO();
|
projectDailyDO.setId(id);
|
projectDailyDO.setIsDeleted(DeletedEnum.DELETED_YES.getCode());
|
projectDailyDO.setDeleteTime(LocalDateTime.now());
|
projectDailyDO.setDeleteUserId(String.valueOf(user.getId()));
|
projectDailyDO.setDeleteUserName(user.getNickname());
|
|
// 将当天所有的日志列表都设置为未确认
|
this.unCommitProjectDaily(dailyDate,String.valueOf(user.getId()));
|
|
|
// 将projectDailyMain 的日志设置为未提交
|
projectDailyMainService.unCommitProjectDailyMain(dailyDate,String.valueOf(user.getId()));
|
|
|
return projectDailyMapper.updateById(projectDailyDO)>0;
|
}
|
|
@Override
|
public List<UserDO> getAllUsers(QueryProjectDailyDTO dto) {
|
|
|
// 过滤掉管理员账户
|
return userService.getAllUsers(dto);
|
|
}
|
|
@Override
|
public ProjectDailyBoardVO getProjectDailyBoardList(QueryProjectDailyBoardDTO dto) {
|
|
// 1.根据当前登录人所在的分组，根据分组来查看看板
|
UserDO userDO=LocalUser.getLocalUser();
|
|
List<GroupDO> groupDOList=userService.getUserGroups(userDO.getId());
|
|
|
// 2.获取所有分组下的人
|
Set<UserDO> userDOSet=new HashSet<>();
|
List<UserDO> groupUserList=new ArrayList<>();
|
boolean managerFlag=false;
|
for (GroupDO groupDO: groupDOList) {
|
List<UserDO> groupsUserList = adminService.getGroupsUserList(groupDO.getId());
|
userDOSet.addAll(groupsUserList);
|
if(!managerFlag && groupDO.getName().equals(GroupLevel2Enum.MANAGER.getName())){
|
managerFlag=true;
|
}
|
}
|
|
List<UserDO> userList =new ArrayList<>();
|
Integer rootUserId = userService.getRootUserId();
|
|
if(Objects.equals(rootUserId,userDO.getId())||managerFlag){
|
//root系统管理员或者项目经理可以查看所有用户的信息
|
// 获取所有人员列表
|
groupUserList=this.getAllUsers(new QueryProjectDailyDTO());
|
}else{
|
// 根据分组获取人员列表
|
userList = new ArrayList<>(userDOSet);
|
groupUserList=userList;
|
}
|
|
|
String startDate=dto.getStartDate();
|
String endDate = dto.getEndDate();
|
|
// 根据条件过滤，过滤掉不在不展示的人员,并且过滤掉离职日期不在查询的开始时间和结束时间之内
|
groupUserList = getDutyShowBoardUserDOs(groupUserList,startDate,endDate);
|
|
|
//获取开始时间和结束时间的时间范围
|
List<String> dateRangeDays = DateUtils.getDateRangeDays(startDate, endDate);
|
|
List<Map<String,String>> result=new ArrayList<>();
|
|
Map<String,String> tmpObj=new HashMap<String,String>();
|
|
List<UserDO> queryUserList =new ArrayList<>();
|
QueryProjectDailyDTO userDto=new QueryProjectDailyDTO();
|
if(StrUtil.isNotBlank(dto.getCreateUserId())){
|
userDto.setCreateUserId(dto.getCreateUserId());
|
queryUserList= this.getAllUsers(userDto);
|
}else{
|
queryUserList=groupUserList;
|
}
|
|
// 根据条件过滤，过滤掉不在不展示的人员,并且过滤掉离职日期不在查询的开始时间和结束时间之内
|
queryUserList = getDutyShowBoardUserDOs(queryUserList, startDate, endDate);
|
|
|
|
Set<String> daySet=new HashSet<>();
|
|
for(int i=0;i<queryUserList.size();i++) {
|
UserDO tmpUser=queryUserList.get(i);
|
String userId=String.valueOf(tmpUser.getId());
|
String username=tmpUser.getNickname();
|
tmpObj.put("user_id",userId);
|
tmpObj.put("user_name",username);
|
String dailyContent="";
|
for(int j=0;j<dateRangeDays.size();j++){
|
String currentDate=dateRangeDays.get(j);
|
List<ProjectDailyBO> list = projectDailyMapperCustom.selectProjectDailyList(String.valueOf(tmpUser.getId()), dateRangeDays.get(j), dto.getProjectId(), null, null);
|
dailyContent = formatDateDaily(list);
|
tmpObj.put(currentDate,dailyContent);
|
if(null!=list&& list.size()>0){
|
daySet.add(currentDate);
|
}
|
}
|
result.add(tmpObj);
|
tmpObj=new HashMap<String,String>();
|
}
|
|
System.out.println(daySet.toString());
|
// 过滤掉没有日志日期的日期数据
|
|
List<String> dateRangeDaysNew = new ArrayList<>();
|
for(String date:dateRangeDays){
|
if(daySet.contains(date)){
|
dateRangeDaysNew.add(date);
|
}
|
}
|
|
|
|
ProjectDailyBoardVO projectDailyBoardVO=new ProjectDailyBoardVO();
|
// 查询分组下的所有人的信息
|
projectDailyBoardVO.setUserList(groupUserList);
|
projectDailyBoardVO.setResultList(result);
|
|
// projectDailyBoardVO.setDateList(dateRangeDays);
|
// projectDailyBoardVO.setTableColumns(dateRangeDays);
|
projectDailyBoardVO.setDateList(dateRangeDaysNew);
|
projectDailyBoardVO.setTableColumns(dateRangeDaysNew);
|
|
return projectDailyBoardVO;
|
}
|
|
private static List<UserDO> getDutyShowBoardUserDOs(List<UserDO> queryUserList, String startDate, String endDate) {
|
List<UserDO> tmpList=new ArrayList<>();
|
queryUserList.forEach(queryUser->{
|
//查看用户那边是否是在看板中展示
|
if(Objects.equals(queryUser.getShowBoardFlag(),UserShowBoardEnum.SHOW.getCode())){
|
|
if(Objects.equals(queryUser.getStaffStatus(),UserStaffStatusEnum.ON_DUTY.getCode())){
|
//查看人员是否在职
|
tmpList.add(queryUser);
|
}else if(Objects.equals(queryUser.getStaffStatus(),UserStaffStatusEnum.UN_DUTY.getCode())
|
&& null!=queryUser.getUnhiredate()
|
// && DateUtils.isDateInRange(startDate, endDate,queryUser.getUnhiredate())
|
&& DateUtils.dateCompare(queryUser.getUnhiredate(),startDate)
|
){
|
// 如果不在职，则离职之前的看板是可以展示的
|
tmpList.add(queryUser);
|
}
|
|
}
|
});
|
return tmpList;
|
}
|
|
@Override
|
public List<ProjectDailyBO> getYesterdayUncommittedProjectDailys(String userId) {
|
return projectDailyMapperCustom.getYesterdayUncommittedProjectDailys(userId);
|
}
|
|
@Override
|
public List<UserDO> getTodayNoDailyPeoples() {
|
return projectDailyMapperCustom.getTodayNoDailyPeoples();
|
}
|
|
@Override
|
public List<ProjectDailyBO> getYesterdayUnconfirmedProjectDailys(String userId) {
|
return projectDailyMapperCustom.getYesterdayUnconfirmedProjectDailys(userId);
|
}
|
|
@Override
|
public List<UserDO> getYesterdayUncommittedProjectDailysPeoples() {
|
return projectDailyMapperCustom.getYesterdayUncommittedProjectDailysPeoples();
|
}
|
|
@Override
|
public List<UserDO> getYesterdayUncomfirmedProjectDailysPeoples() {
|
return projectDailyMapperCustom.getYesterdayUncomfirmedProjectDailysPeoples();
|
}
|
|
@Override
|
@Transactional
|
public boolean createProjectDailyBatch(List<ProjectDailyDO> dailyDOList) {
|
|
|
final UserDO user = LocalUser.getLocalUser();
|
projectDailyMapperCustom.deleteDailysByDateUser(String.valueOf(user.getId()),dailyDOList.get(0).getDailyDate());
|
|
|
|
List<ProjectDailyDO> createList=new ArrayList<>();
|
|
for(ProjectDailyDO projectDailyDO:dailyDOList){
|
ProjectDailyDO tmpProject=new ProjectDailyDO();
|
BeanUtils.copyProperties(projectDailyDO,tmpProject);
|
|
tmpProject.setIsCommit(DailyCommitEnum.UNCOMMITED.getCode());
|
tmpProject.setIsConfirm(DailyConfirmEnum.UNCONFIRM.getCode());
|
tmpProject.setSupplementaryFlag(SupplementaryEnum.NO.getCode());
|
|
tmpProject.setCreateTime(LocalDateTime.now());
|
tmpProject.setCreateUserId(String.valueOf(user.getId()));
|
tmpProject.setCreateUserName(user.getNickname());
|
|
tmpProject.setUpdateTime(LocalDateTime.now());
|
tmpProject.setUpdateUserId(String.valueOf(user.getId()));
|
tmpProject.setUpdateUserName(user.getNickname());
|
tmpProject.setIsDeleted(DeletedEnum.DELETED_NO.getCode());
|
if(StringUtils.isEmpty(projectDailyDO.getId())){
|
tmpProject.setId(IdUtil.simpleUUID());
|
}
|
createList.add(tmpProject);
|
|
}
|
boolean result=false;
|
|
if(!CollectionUtils.isEmpty(createList)){
|
result=this.saveBatch(createList);
|
}
|
|
return result;
|
|
// return projectDailyMapperCustom.insertBatch(resultList)>0;
|
|
|
}
|
|
@Override
|
public List<ProjectStatisticsBO> getActualHoursStatistic(String projectId) {
|
return projectDailyMapperCustom.getActualHoursStatistic(projectId);
|
}
|
|
|
@Override
|
@Transactional
|
public boolean commitBatch(CommitBatchDTO dto) {
|
|
// 查看当前是否有当天的主要日志，如没有则创建，有则更新，并发送邮件提醒
|
UserDO userDO=LocalUser.getLocalUser();
|
|
QueryProjectDailyMainDTO mainDTO=new QueryProjectDailyMainDTO();
|
mainDTO.setDailyDate(dto.getDailyDate());
|
mainDTO.setUseId(String.valueOf(userDO.getId()));
|
List<ProjectDailyMainDO> mainList= projectDailyMainService.getDailyMainList(mainDTO);
|
|
ProjectDailyMainDO projectDailyMainDO=new ProjectDailyMainDO();
|
|
// 先看这条记录是否存在，存在就提交，不存在则需要创建在提交
|
if(null!=mainList && !mainList.isEmpty()){
|
projectDailyMainDO=mainList.get(0);
|
}else {
|
projectDailyMainDO=new ProjectDailyMainDO();
|
projectDailyMainDO.setDailyDate(DateUtils.stringToLocalDateTime(dto.getDailyDate()));
|
projectDailyMainDO.setUseId(String.valueOf(userDO.getId()));
|
projectDailyMainDO.setUserName(userDO.getNickname());
|
|
//
|
projectDailyMainDO.setCreateTime(new Date());
|
projectDailyMainDO.setCreateUserId(String.valueOf(userDO.getId()));
|
projectDailyMainDO.setCreateUserName(userDO.getNickname());
|
projectDailyMainDO.setIsDeleted(DeletedEnum.DELETED_NO.getCode());
|
|
}
|
|
//提交设置
|
projectDailyMainDO.setIsCommit(DailyCommitEnum.COMMITED.getCode());
|
projectDailyMainDO.setCommitTime(LocalDateTime.now());
|
projectDailyMainDO.setCommitUserId(String.valueOf(userDO.getId()));
|
projectDailyMainDO.setCommitUserName(userDO.getNickname());
|
|
|
projectDailyMainDO.setIsConfirm(DailyConfirmEnum.UNCONFIRM.getCode());
|
projectDailyMainDO.setConfirmTime(LocalDateTime.now());
|
projectDailyMainDO.setConfirmUserId(String.valueOf(userDO.getId()));
|
projectDailyMainDO.setConfirmUserName(userDO.getNickname());
|
projectDailyMainDO.setConfirmContent("");
|
|
|
|
projectDailyMainDO.setUpdateTime(new Date());
|
projectDailyMainDO.setUpdateUserId(String.valueOf(userDO.getId()));
|
projectDailyMainDO.setUpdateUserName(userDO.getNickname());
|
|
|
if(StrUtil.isBlank(projectDailyMainDO.getId())){
|
//创建
|
projectDailyMainDO.setId(IdUtil.simpleUUID());
|
projectDailyMainService.save(projectDailyMainDO);
|
}else{
|
// 更新
|
projectDailyMainService.updateById(projectDailyMainDO);
|
}
|
|
// 批量更新单条日志表
|
QueryWrapper<ProjectDailyDO> dailyWrapper = new QueryWrapper<>();
|
dailyWrapper.eq("is_deleted",DeletedEnum.DELETED_NO.getCode());
|
dailyWrapper.eq("daily_date",dto.getDailyDate());
|
dailyWrapper.eq("create_user_id",String.valueOf(userDO.getId()));
|
|
ProjectDailyDO projectDailyDO=new ProjectDailyDO();
|
projectDailyDO.setIsCommit(DailyCommitEnum.COMMITED.getCode());
|
projectDailyDO.setCommitTime(new Date());
|
projectDailyDO.setCommitUserId(String.valueOf(userDO.getId()));
|
projectDailyDO.setCommitUserName(userDO.getNickname());
|
|
// 将确认标志设置为未确认
|
projectDailyDO.setIsConfirm(DailyConfirmEnum.UNCONFIRM.getCode());
|
projectDailyDO.setConfirmTime(new Date());
|
projectDailyDO.setConfirmUserId(String.valueOf(userDO.getId()));
|
projectDailyDO.setConfirmUserName(userDO.getNickname());
|
projectDailyDO.setConfirmContent("");
|
|
|
|
return projectDailyMapperCustom.update(projectDailyDO,dailyWrapper)>0;
|
}
|
|
@Override
|
public List<ProjectDailyDO> getProjectDailyList(QueryProjectDailyDTO dto) {
|
UserDO userDO = LocalUser.getLocalUser();
|
// QueryWrapper<ProjectDailyDO> wrapper = new QueryWrapper<>();
|
// wrapper.eq("is_deleted",DeletedEnum.DELETED_NO.getCode());
|
// if(StrUtil.isNotBlank(dto.getCreateUserId())){
|
// wrapper.eq("create_user_id",dto.getCreateUserId());
|
// }
|
// wrapper.eq(StringUtils.isEmpty(dto.getDailyDate())
|
//
|
// wrapper.eq("daily_date",dto.getDailyDate());
|
// if(null!=dto.getIsCommit()){
|
// wrapper.eq("is_commit",dto.getIsCommit());
|
// }
|
//
|
// if(null!=dto.getIsConfirm()){
|
// wrapper.eq("is_confirm",dto.getIsConfirm());
|
// }
|
|
LambdaQueryWrapper<ProjectDailyDO> lambdaQueryWrapper = new LambdaQueryWrapper<>();
|
lambdaQueryWrapper.eq(ProjectDailyDO::getIsDeleted, DeletedEnum.DELETED_NO.getCode())
|
.eq(StrUtil.isNotBlank(dto.getCreateUserId()), ProjectDailyDO::getCreateUserId, dto.getCreateUserId())
|
.eq(StrUtil.isNotBlank(dto.getDailyDate()), ProjectDailyDO::getDailyDate, dto.getDailyDate())
|
.eq(null != dto.getIsCommit(), ProjectDailyDO::getIsCommit, dto.getIsCommit())
|
.eq(null != dto.getIsConfirm(), ProjectDailyDO::getIsConfirm, dto.getIsConfirm())
|
.eq(StrUtil.isNotBlank(dto.getTaskId()), ProjectDailyDO::getTaskId, dto.getTaskId())
|
.orderByAsc(ProjectDailyDO::getDailyDate, ProjectDailyDO::getCreateUserId)
|
;
|
|
return baseMapper.selectList(lambdaQueryWrapper);
|
}
|
|
@Override
|
public boolean confirmBatch(ConfirmBatchDTO dto) {
|
UserDO userDO=LocalUser.getLocalUser();
|
|
QueryProjectDailyDTO queryDailyDO=new QueryProjectDailyDTO();
|
// queryDailyDO.setIsCommit(DailyCommitEnum.COMMITED.getCode());
|
queryDailyDO.setDailyDate(dto.getDailyDate());
|
queryDailyDO.setCreateUserId(dto.getCreateUserId());
|
if("-1".equals(queryDailyDO.getCreateUserId())){
|
queryDailyDO.setCreateUserId(null);
|
}else{
|
queryDailyDO.setCreateUserId(dto.getCreateUserId());
|
}
|
|
|
List<ProjectDailyDO> projectDailyList = getProjectDailyList(queryDailyDO);
|
if(null!=projectDailyList && !projectDailyList.isEmpty()){
|
// 如果当前有记录的话，则批量确认，并且更新queryDailyMain表中的内容
|
|
QueryWrapper<ProjectDailyDO> dailyWrapper = new QueryWrapper<>();
|
dailyWrapper.eq("is_deleted",DeletedEnum.DELETED_NO.getCode());
|
dailyWrapper.eq("daily_date",dto.getDailyDate());
|
if(!"-1".equals(dto.getCreateUserId())){
|
dailyWrapper.eq("create_user_id",dto.getCreateUserId());
|
}
|
|
|
|
// dailyWrapper.eq("is_commit",DailyCommitEnum.COMMITED.getCode());
|
|
|
ProjectDailyDO projectDailyDO=new ProjectDailyDO();
|
projectDailyDO.setIsConfirm(dto.getIsConfirm());
|
projectDailyDO.setConfirmTime(new Date());
|
projectDailyDO.setConfirmUserId(String.valueOf(userDO.getId()));
|
projectDailyDO.setConfirmUserName(userDO.getNickname());
|
projectDailyDO.setConfirmContent(dto.getConfirmContent());
|
|
//如果是不通过的情况下，设置成提交状态为未提交
|
if(Objects.equals(projectDailyDO.getIsConfirm(), DailyConfirmEnum.UNPASS.getCode())){
|
projectDailyDO.setIsCommit(DailyCommitEnum.UNCOMMITED.getCode());
|
projectDailyDO.setCommitTime(new Date());
|
projectDailyDO.setCommitUserId(String.valueOf(userDO.getId()));
|
projectDailyDO.setCommitUserName(userDO.getNickname());
|
|
}
|
|
|
baseMapper.update(projectDailyDO,dailyWrapper);
|
|
return projectDailyMainService.confirmProjectDailyMain(dto.getDailyDate(),dto.getCreateUserId(),dto.getIsConfirm(),dto.getConfirmContent());
|
|
}
|
|
return false;
|
|
}
|
|
@Override
|
public boolean unConfirmBatch(ConfirmBatchDTO dto) {
|
UserDO userDO=LocalUser.getLocalUser();
|
|
|
QueryProjectDailyDTO projectDailyDTO=new QueryProjectDailyDTO();
|
projectDailyDTO.setDailyDate(dto.getDailyDate());
|
projectDailyDTO.setIsConfirm(DailyConfirmEnum.CONFIRM.getCode());
|
List<ProjectDailyDO> projectDailyList = getProjectDailyList(projectDailyDTO);
|
if(null!=projectDailyList && !projectDailyList.isEmpty()){
|
// 如果当前有记录的话，则批量确认，并且更新queryDailyMain表中的内容
|
|
QueryWrapper<ProjectDailyDO> dailyWrapper = new QueryWrapper<>();
|
dailyWrapper.eq("is_deleted",DeletedEnum.DELETED_NO.getCode());
|
dailyWrapper.eq("daily_date",dto.getDailyDate());
|
if(!"-1".equals(dto.getCreateUserId())){
|
dailyWrapper.eq("create_user_id",dto.getCreateUserId());
|
}
|
|
// dailyWrapper.eq("is_commit",DailyCommitEnum.COMMITED.getCode());
|
dailyWrapper.eq("is_confirm",DailyConfirmEnum.CONFIRM.getCode());
|
|
|
ProjectDailyDO projectDailyDO=new ProjectDailyDO();
|
projectDailyDO.setIsCommit(DailyCommitEnum.UNCOMMITED.getCode());
|
projectDailyDO.setCommitTime(new Date());
|
projectDailyDO.setCommitUserId(String.valueOf(userDO.getId()));
|
projectDailyDO.setCommitUserName(userDO.getNickname());
|
|
projectDailyDO.setIsConfirm(DailyConfirmEnum.UNCONFIRM.getCode());
|
projectDailyDO.setConfirmTime(new Date());
|
projectDailyDO.setConfirmUserId(String.valueOf(userDO.getId()));
|
projectDailyDO.setConfirmUserName(userDO.getNickname());
|
|
|
|
|
baseMapper.update(projectDailyDO,dailyWrapper);
|
|
return projectDailyMainService.unConfirmProjectDailyMain(dto.getDailyDate(),dto.getCreateUserId());
|
|
}
|
|
return false;
|
}
|
|
@Override
|
@Transactional
|
public boolean unCommitProjectDaily(Date dailyDate, String createUserId) {
|
|
UserDO userDO = LocalUser.getLocalUser();
|
|
// 将queryMain 的记录设置成已经提交
|
ProjectDailyDO projectDailyDO=new ProjectDailyDO();
|
|
QueryWrapper<ProjectDailyDO> dailyMainWrapper = new QueryWrapper<ProjectDailyDO>();
|
dailyMainWrapper.eq("is_deleted",DeletedEnum.DELETED_NO.getCode());
|
dailyMainWrapper.eq("daily_date",dailyDate);
|
dailyMainWrapper.eq("create_user_id",createUserId);
|
|
projectDailyDO.setIsCommit(DailyCommitEnum.UNCOMMITED.getCode());
|
projectDailyDO.setCommitTime(new Date());
|
projectDailyDO.setCommitUserId(String.valueOf(userDO.getId()));
|
projectDailyDO.setCommitUserName(userDO.getNickname());
|
|
projectDailyDO.setIsConfirm(DailyConfirmEnum.UNCONFIRM.getCode());
|
projectDailyDO.setConfirmTime(new Date());
|
projectDailyDO.setConfirmUserId(String.valueOf(userDO.getId()));
|
projectDailyDO.setConfirmUserName(userDO.getNickname());
|
return baseMapper.update(projectDailyDO,dailyMainWrapper)>0;
|
}
|
|
@Override
|
public List<UserDO> getToadyUncomfirmedActualHoursProjectDailysPeoples(String dailyDate) {
|
|
|
return projectDailyMapperCustom.getToadyUncomfirmedActualHoursProjectDailysPeoples(dailyDate);
|
}
|
|
@Override
|
public List<ProjectDailyBO> getTodayUnConfirmedActualHours(String createUserId, String todayString) {
|
|
return projectDailyMapperCustom.getTodayUnConfirmedActualHours(createUserId,todayString);
|
|
}
|
|
@Override
|
public boolean supplementaryProjectDailyBatch(List<ProjectDailyDO> list) {
|
UserDO user = LocalUser.getLocalUser();
|
|
List<ProjectDailyDO> resultList=new ArrayList<>();
|
|
for(ProjectDailyDO projectDailyDO:list){
|
ProjectDailyDO tmpProject=new ProjectDailyDO();
|
BeanUtils.copyProperties(projectDailyDO,tmpProject);
|
|
tmpProject.setDailyDate(DateUtils.formatDateToDateYYYYMMDD(projectDailyDO.getDailyDate()));
|
|
tmpProject.setId(IdUtil.simpleUUID());
|
|
tmpProject.setIsCommit(DailyCommitEnum.COMMITED.getCode());
|
tmpProject.setIsConfirm(DailyConfirmEnum.CONFIRM.getCode());
|
tmpProject.setSupplementaryFlag(SupplementaryEnum.YES.getCode());
|
|
|
tmpProject.setCreateTime(LocalDateTime.now());
|
tmpProject.setCreateUserId(String.valueOf(user.getId()));
|
tmpProject.setCreateUserName(user.getNickname());
|
|
tmpProject.setUpdateTime(LocalDateTime.now());
|
tmpProject.setUpdateUserId(String.valueOf(user.getId()));
|
tmpProject.setUpdateUserName(user.getNickname());
|
tmpProject.setIsDeleted(DeletedEnum.DELETED_NO.getCode());
|
resultList.add(tmpProject);
|
|
}
|
|
return projectDailyMapperCustom.insertBatch(resultList)>0;
|
}
|
|
@Transactional
|
@Override
|
public boolean createProjectDailyWithInit(CreateOrUpdateProjectDailyDTO validator) {
|
UserDO user=LocalUser.getLocalUser();
|
// 将当天所有的日志列表都设置为未确认
|
projectDailyService.unCommitProjectDaily(validator.getDailyDate(),String.valueOf(user.getId()));
|
|
// 将projectDailyMain 的日志设置为未提交
|
projectDailyMainService.unCommitProjectDailyMain(validator.getDailyDate(),String.valueOf(user.getId()));
|
|
|
return createProjectDaily(validator);
|
}
|
|
@Override
|
@Transactional
|
public boolean updateProjectDailyWithValidator(CreateOrUpdateProjectDailyDTO validator) {
|
UserDO user = LocalUser.getLocalUser();
|
|
ProjectDailyDO projectDailyDO=new ProjectDailyDO();
|
BeanUtils.copyProperties(validator,projectDailyDO);
|
projectDailyDO.setUpdateTime(LocalDateTime.now());
|
projectDailyDO.setUpdateUserId(String.valueOf(user.getId()));
|
projectDailyDO.setUpdateUserName(user.getNickname());
|
|
//设置提交状态为未提交
|
projectDailyDO.setIsCommit(DailyCommitEnum.UNCOMMITED.getCode());
|
|
return projectDailyService.updateById(projectDailyDO);
|
|
}
|
|
@Override
|
@Transactional
|
public boolean updateProjectDailyWithInit(CreateOrUpdateProjectDailyDTO validator) {
|
|
UserDO user = LocalUser.getLocalUser();
|
|
|
boolean res = projectDailyService.updateProjectDailyWithValidator(validator);
|
|
|
// 将当天所有的日志列表都设置为未确认
|
projectDailyService.unCommitProjectDaily(validator.getDailyDate(),String.valueOf(user.getId()));
|
|
// 将projectDailyMain 的日志设置为未提交
|
projectDailyMainService.unCommitProjectDailyMain(validator.getDailyDate(),String.valueOf(user.getId()));
|
|
return res;
|
|
}
|
|
@Override
|
@Transactional
|
public boolean createProjectDailyBatchWithInit(CreateBatchDTO dto) {
|
|
UserDO userDO=LocalUser.getLocalUser();
|
|
// 将json串反序列化成数组
|
List<ProjectDailyDO> list= JsonUtil.json2List(dto.getDailyList(),ProjectDailyDO.class);
|
|
list.forEach(tmp->{
|
Date dailyDate = tmp.getDailyDate();
|
tmp.setDailyDate(DateUtils.formatDateToDateYYYYMMDD(dailyDate));
|
|
});
|
|
// 查看当天是否有Main的记录，如果没有的情况下则新建
|
QueryProjectDailyMainDTO mainDTO=new QueryProjectDailyMainDTO();
|
mainDTO.setDailyDate(DateUtil.format(list.get(0).getDailyDate(), "yyyy-MM-dd"));
|
mainDTO.setUseId(String.valueOf(userDO.getId()));
|
final List<ProjectDailyMainDO> dailyMainList = projectDailyMainService.getDailyMainList(mainDTO);
|
if(CollectionUtils.isEmpty(dailyMainList)){
|
projectDailyMainService.createDailyMainDefault(mainDTO);
|
}
|
|
boolean res=projectDailyService.createProjectDailyBatch(list);
|
|
ProjectDailyDO projectDailyDO = list.get(0);
|
|
// 将当天所有的日志列表都设置为未确认
|
projectDailyService.unCommitProjectDaily(projectDailyDO.getDailyDate(),String.valueOf(userDO.getId()));
|
|
// 将projectDailyMain 的日志设置为未提交
|
projectDailyMainService.unCommitProjectDailyMain(projectDailyDO.getDailyDate(),String.valueOf(userDO.getId()));
|
|
return res;
|
}
|
|
|
@Override
|
@Transactional
|
public boolean updateActualHours(CreateOrUpdateProjectDailyDTO validator) {
|
UserDO user = LocalUser.getLocalUser();
|
|
ProjectDailyDO projectDailyDO=new ProjectDailyDO();
|
projectDailyDO.setId(validator.getId());
|
projectDailyDO.setDailyStatus(validator.getDailyStatus());
|
projectDailyDO.setActualHours(validator.getActualHours());
|
projectDailyDO.setRemark(validator.getRemark());
|
|
projectDailyDO.setUpdateTime(LocalDateTime.now());
|
projectDailyDO.setUpdateUserId(String.valueOf(user.getId()));
|
projectDailyDO.setUpdateUserName(user.getNickname());
|
|
//设置提交状态为未提交
|
// projectDailyDO.setIsCommit(DailyCommitEnum.UNCOMMITED.getCode());
|
|
return projectDailyService.updateById(projectDailyDO);
|
}
|
|
@Override
|
public List<UserDO> getUnComfirmedPeoples(String dailyDate) {
|
|
return projectDailyMapperCustom.getUnComfirmedPeoples(dailyDate);
|
}
|
|
@Override
|
public List<ProjectDailyDO> getUncommitDailyList(ConfirmBatchDTO dto) {
|
QueryProjectDailyDTO projectDailyDTO=new QueryProjectDailyDTO();
|
BeanUtils.copyProperties(dto,projectDailyDTO);
|
|
QueryWrapper<ProjectDailyDO> wrapper=new QueryWrapper<>();
|
wrapper.eq("is_deleted",DeletedEnum.DELETED_NO.getCode());
|
wrapper.eq("daily_date",dto.getDailyDate());
|
wrapper.eq("is_commit",DailyCommitEnum.UNCOMMITED.getCode());
|
|
// 约定，如果create_user_id=-1的情况下，则全部更新
|
if(!"-1".equals(dto.getCreateUserId())&&StrUtil.isNotBlank(dto.getCreateUserId())){
|
wrapper.eq("create_user_id",dto.getCreateUserId());
|
}
|
|
return baseMapper.selectList(wrapper);
|
}
|
|
@Override
|
public List<ProjectDailyDO> getWaitConfirmDailyList(ConfirmBatchDTO dto) {
|
|
// 已提交，未确认的才需要确认
|
QueryWrapper<ProjectDailyDO> wrapper=new QueryWrapper<>();
|
wrapper.eq("is_deleted",DeletedEnum.DELETED_NO.getCode());
|
wrapper.eq("daily_date",dto.getDailyDate());
|
wrapper.eq("is_commit",DailyCommitEnum.COMMITED.getCode());
|
|
wrapper.eq("is_confirm",DailyConfirmEnum.UNCONFIRM.getCode());
|
|
|
// 约定，如果create_user_id=-1的情况下，则全部更新
|
if(!"-1".equals(dto.getCreateUserId())&&StrUtil.isNotBlank(dto.getCreateUserId())){
|
wrapper.eq("create_user_id",dto.getCreateUserId());
|
}
|
|
return baseMapper.selectList(wrapper);
|
}
|
|
@Override
|
public List<UserDO> getTodayUncommittedProjectDailysPeoples() {
|
return projectDailyMapperCustom.getTodayUncommittedProjectDailysPeoples();
|
}
|
|
@Override
|
public List<ProjectDailyBO> getTodayUncommittedProjectDailys(String createUserId) {
|
return projectDailyMapperCustom.getTodayUncommittedProjectDailys(createUserId);
|
}
|
|
@Override
|
@Transactional
|
public boolean commit(String id) {
|
UserDO user = LocalUser.getLocalUser();
|
|
ProjectDailyDO projectDailyDO=new ProjectDailyDO();
|
projectDailyDO.setId(id);
|
projectDailyDO.setIsCommit(DailyCommitEnum.COMMITED.getCode());
|
projectDailyDO.setCommitTime(new Date());
|
projectDailyDO.setCommitUserId(String.valueOf(user.getId()));
|
projectDailyDO.setCommitUserName(user.getNickname());
|
|
// 将确认标志设置为未确认
|
projectDailyDO.setIsConfirm(DailyConfirmEnum.UNCONFIRM.getCode());
|
|
boolean result=this.baseMapper.updateById(projectDailyDO)>0;
|
|
// 查看今日日志是否都已经提交，如果是的话，需要将总的main的日志设置为提交
|
|
ProjectDailyDO projectDailyDO1 = this.baseMapper.selectById(id);
|
|
QueryWrapper<ProjectDailyDO> wrapper=new QueryWrapper<>();
|
wrapper.eq("is_deleted",DeletedEnum.DELETED_NO.getCode());
|
wrapper.eq("daily_date",projectDailyDO1.getDailyDate());
|
wrapper.eq("create_user_id",projectDailyDO1.getCreateUserId());
|
wrapper.eq("is_commit",DailyCommitEnum.UNCOMMITED.getCode());
|
|
|
List<ProjectDailyDO> projectDailyDOS = this.baseMapper.selectList(wrapper);
|
if(projectDailyDOS==null || projectDailyDOS.size()==0){
|
QueryProjectDailyDTO queryProjectDailyDTO=new QueryProjectDailyDTO();
|
queryProjectDailyDTO.setDailyDate(DateUtils.dateToStr(projectDailyDO1.getDailyDate()));
|
queryProjectDailyDTO.setCreateUserId(projectDailyDO1.getCreateUserId());
|
projectDailyMainService.commit(queryProjectDailyDTO);
|
}
|
|
return result;
|
}
|
|
@Override
|
public Double getDailyDatePlanTime(WorkTimeDTO dto) {
|
UserDO userDO=LocalUser.getLocalUser();
|
if(StrUtil.isBlank(dto.getDailyDate())){
|
dto.setDailyDate(DateUtils.getTodayString());
|
}
|
if(StrUtil.isBlank(dto.getCreateUserId())){
|
dto.setCreateUserId(String.valueOf(userDO.getId()));
|
}
|
|
return projectDailyMapperCustom.getDailyDatePlanTime(dto.getDailyDate(),dto.getCreateUserId());
|
}
|
|
@Override
|
public Double getDailyDateActualTime(WorkTimeDTO dto) {
|
UserDO userDO=LocalUser.getLocalUser();
|
if(StrUtil.isBlank(dto.getDailyDate())){
|
dto.setDailyDate(DateUtils.getTodayString());
|
}
|
if(StrUtil.isBlank(dto.getCreateUserId())){
|
dto.setCreateUserId(String.valueOf(userDO.getId()));
|
}
|
return projectDailyMapperCustom.getDailyDateActualTime(dto.getDailyDate(),dto.getCreateUserId());
|
}
|
|
@Override
|
public ProjectDailyHourVO existsHours(DailyHourDTO dto) {
|
UserDO userDO=LocalUser.getLocalUser();
|
List<String> idList=new ArrayList<>();
|
if(!StringUtils.isEmpty(dto.getIds())){
|
String[] idsArray = dto.getIds().split(",");
|
idList = Arrays.asList(idsArray);
|
}
|
return projectDailyMapperCustom.existsHoursWithoutIds(String.valueOf(userDO.getId()),dto.getDailyDate(),idList);
|
}
|
|
@Override
|
public List<ProjectDailyDO> getByDailyDate(String dailyDate) {
|
UserDO user = LocalUser.getLocalUser();
|
|
QueryWrapper<ProjectDailyDO> wrapper=new QueryWrapper<>();
|
wrapper.eq("is_deleted",DeletedEnum.DELETED_NO.getCode());
|
wrapper.eq("daily_date",dailyDate);
|
wrapper.eq("create_user_id",user.getId());
|
|
List<ProjectDailyDO> projectDailyDOS = this.baseMapper.selectList(wrapper);
|
|
return projectDailyDOS;
|
|
|
}
|
|
@Override
|
@Transactional
|
public boolean updateActualHoursBatch(List<ActualHourProjectDailyDTO> dtoList) {
|
|
final List<ProjectDailyDO> actualHourList = dtoList.stream().map(actualHourDto -> {
|
ProjectDailyDO projectDailyDO = new ProjectDailyDO();
|
projectDailyDO.setId(actualHourDto.getId());
|
projectDailyDO.setDailyStatus(actualHourDto.getDailyStatus());
|
projectDailyDO.setActualHours(actualHourDto.getActualHours());
|
projectDailyDO.setRemark(actualHourDto.getRemark());
|
return projectDailyDO;
|
}).collect(Collectors.toList());
|
return this.updateBatchById(actualHourList);
|
}
|
|
@Override
|
public List<ProjectDailyStatisticsVO> getActualHourStatistics(QueryProjectHourStatisticsDTO dto) {
|
return projectDailyMapperCustom.getActualHourStatistics(dto);
|
}
|
|
@Override
|
public List<ProjectDailyStatisticsVO> getEvaluateiActualHourStatistics(QueryProjectHourStatisticsDTO dto) {
|
|
return projectDailyMapperCustom.getEvaluateiActualHourStatistics(dto);
|
}
|
|
@Override
|
public List<ProjectDailyStatisticsVO> getUserActualHourStatistics(QueryProjectHourStatisticsDTO dto) {
|
return projectDailyMapperCustom.getUserActualHourStatistics(dto);
|
}
|
|
@Override
|
public List<ProjectDailyStatisticsVO> getRoleHourStatistics(QueryProjectHourStatisticsDTO dto) {
|
return projectDailyMapperCustom.getRoleHourStatistics(dto);
|
}
|
|
@Override
|
public List<MeetingUserDaily> getProjectDailybyUserList(MeetingPageDTO dto) {
|
|
//
|
// final List<String> userIds = dto.getUserIds();
|
|
// 提取所有开发的项目日志
|
final List<String> userIds = getDeveloperIds();
|
|
final List<MeetingUserDaily> meettingUserDailyList = userIds.stream().map(userId -> {
|
// 获取上一周的且昨日进度状态为null的日志，并根据日期排序
|
|
QueryProjectDailyDTO queryProjectDailyDTO = new QueryProjectDailyDTO();
|
queryProjectDailyDTO.setDailyDate(dto.getMeetingDate());
|
queryProjectDailyDTO.setCreateUserId(userId);
|
queryProjectDailyDTO.setMeetingId(dto.getMeetingId());
|
List<ProjectDailyBO> projectDailyBOList = projectDailyMapperCustom.selectProjectDailyProcessList(queryProjectDailyDTO);
|
MeetingUserDaily meetingUserDaily = new MeetingUserDaily();
|
final UserDO user = userService.getUserById(userId);
|
meetingUserDaily.setUserId(String.valueOf(user.getId()));
|
meetingUserDaily.setName(user.getNickname());
|
meetingUserDaily.setProjectDailyBOList(projectDailyBOList);
|
|
|
return meetingUserDaily;
|
}).collect(Collectors.toList());
|
|
return meettingUserDailyList;
|
}
|
|
@Override
|
public List<BusinessDailyBO> getProjectBusinessDailybyMeetingId(MeetingPageDTO dto) {
|
if(StringUtils.isEmpty(dto.getMeetingId())){
|
return null;
|
}
|
BusinessDailyPageDTO businessDailyPageDTO=new BusinessDailyPageDTO();
|
businessDailyPageDTO.setPage(0);
|
businessDailyPageDTO.setCount(1000);
|
businessDailyPageDTO.setMeetingId(dto.getMeetingId());
|
|
List<BusinessDailyBO> result=businessDailyService.getBusinessDailyPage(businessDailyPageDTO).getRecords();
|
|
result.stream().forEach(businessDailyBO -> {
|
|
// 获取甘特图文件
|
List<FileDO> fileList=linFileReService.getFileByReIdType(businessDailyBO.getId(),FileReTypeEnum.BUSINESS_GANTT);
|
businessDailyBO.setGanteImgList(linFileReService.transFileToFileImageInfo(fileList));
|
});
|
|
return result;
|
}
|
|
@Override
|
public List<MeetingUserDaily> getProjectDailyMeetingbyUserList(MeetingPageDTO dto) {
|
// 提取所有开发的项目日志
|
final List<String> userIds = getDeveloperIds();
|
|
final List<MeetingUserDaily> meettingUserDailyList = userIds.stream().map(userId -> {
|
// 获取上一周的且昨日进度状态为null的日志，并根据日期排序
|
|
QueryProjectDailyDTO queryProjectDailyDTO = new QueryProjectDailyDTO();
|
queryProjectDailyDTO.setDailyDate(dto.getMeetingDate());
|
queryProjectDailyDTO.setCreateUserId(userId);
|
queryProjectDailyDTO.setMeetingId(dto.getMeetingId());
|
List<ProjectDailyBO> projectDailyBOList = projectDailyMapperCustom.selectProjectDailyProcessWithMeetingIdList(queryProjectDailyDTO);
|
MeetingUserDaily meetingUserDaily = new MeetingUserDaily();
|
final UserDO user = userService.getUserById(userId);
|
meetingUserDaily.setUserId(String.valueOf(user.getId()));
|
meetingUserDaily.setName(user.getNickname());
|
meetingUserDaily.setProjectDailyBOList(projectDailyBOList);
|
|
return meetingUserDaily;
|
}).collect(Collectors.toList());
|
|
return meettingUserDailyList;
|
}
|
|
private List<String> getDeveloperIds() {
|
IPage<UserDO> managerUserPage = adminService.getUserPageByGroupId(GroupLevel2Enum.DEVELOPER.getValue(), 1000, 0);
|
|
final List<String> userIds = managerUserPage.getRecords().stream().map(user -> String.valueOf(user.getId())).collect(Collectors.toList());
|
return userIds;
|
}
|
|
@Override
|
public List<MeetingDateUserDaily> getDateDailyList(MeetingPageDTO dto) {
|
// 遍历查询日期下的开发人员的日志
|
if(!CollectionUtils.isEmpty(dto.getDailyDateList())){
|
final List<MeetingDateUserDaily> list = dto.getDailyDateList().stream().map(date -> {
|
// 获取所有开发人员信息
|
final List<String> userIds = getDeveloperIds();
|
final List<MeetingUserDaily> userDailyList = userIds.stream().map(userId -> {
|
QueryProjectDailyDTO queryProjectDailyDTO = new QueryProjectDailyDTO();
|
queryProjectDailyDTO.setDailyDate(date);
|
queryProjectDailyDTO.setCreateUserId(userId);
|
List<ProjectDailyBO> projectDailyBOList = projectDailyMapperCustom.selectProjectDailyProcessWithMeetingIdList(queryProjectDailyDTO);
|
|
// 组装日期下的用户信息
|
MeetingUserDaily meetingUserDaily = new MeetingUserDaily();
|
final UserDO user = userService.getUserById(userId);
|
meetingUserDaily.setUserId(String.valueOf(user.getId()));
|
meetingUserDaily.setName(user.getNickname());
|
meetingUserDaily.setProjectDailyBOList(projectDailyBOList);
|
|
return meetingUserDaily;
|
|
}).collect(Collectors.toList());
|
|
MeetingDateUserDaily meetingDateUserDaily = new MeetingDateUserDaily();
|
meetingDateUserDaily.setDate(date);
|
meetingDateUserDaily.setUsersDailyList(userDailyList);
|
|
return meetingDateUserDaily;
|
|
}).collect(Collectors.toList());
|
return list;
|
|
}else{
|
return null;
|
}
|
|
}
|
|
@Override
|
public List<String> getDailyDateByMeetingId(MeetingPageDTO dto) {
|
return projectDailyMapperCustom.getDailyDateByMeetingId(dto);
|
}
|
|
@Transactional
|
@Override
|
public void createProjectDailyBatchWithTask(CreateBatchTaskDTO validator) {
|
|
UserDO curUser = LocalUser.getLocalUser();
|
|
validator.getDailyList().stream().forEach(this::validateTask);
|
|
List<ProjectDailyMainDO> mainDOList=new ArrayList<>();
|
List<ProjectDailyDO> projectDailyDOSList=new ArrayList<>();
|
List<ProjectTaskDeveloperDO> projectTaskDeveloperDOList=new ArrayList<>();
|
|
|
|
validator.getDailyList().stream().forEach(createBatchTaskDTO -> {
|
|
// 查找用户信息
|
UserDO user = userService.getUserById(createBatchTaskDTO.getUserId());
|
|
// 查找项目信息
|
if(!StringUtils.isEmpty(createBatchTaskDTO.getProjectId())){
|
ProjectInfoDO projectInfoDO = projectInfoService.getById(createBatchTaskDTO.getProjectId());
|
if(null!=projectInfoDO && !StringUtils.isEmpty(projectInfoDO.getProjectName())){
|
createBatchTaskDTO.setProjectName(projectInfoDO.getProjectName());
|
}
|
}
|
|
// 查找模块信息
|
if(!StringUtils.isEmpty(createBatchTaskDTO.getModuleId())){
|
ProjectModuleDO projectModuleDO = projectModuleService.getById(createBatchTaskDTO.getModuleId());
|
if(null!=projectModuleDO && !StringUtils.isEmpty(projectModuleDO.getModuleName())){
|
createBatchTaskDTO.setModuleName(projectModuleDO.getModuleName());
|
}
|
}
|
|
// 查看当前日期是否已经存在 main
|
ProjectDailyMainDO projectDailyMainByDate = projectDailyMainService.getProjectDailyMainByDate(createBatchTaskDTO);
|
if(null!=projectDailyMainByDate && projectDailyMainByDate.getIsCommit()==DailyCommitEnum.COMMITED.getCode()){
|
throw new ForbiddenException(20006);
|
}
|
|
if(!projectDailyMainService.existsProjectDailyMainByDate(createBatchTaskDTO)){
|
// 当前projectDailyMain 不存在，需要创建
|
ProjectDailyMainDO projectDailyMainDO=new ProjectDailyMainDO();
|
projectDailyMainDO.setId(UUID.randomUUID().toString().replace("-", ""));
|
LocalDateTime dailyDateLocalTimeTime = createBatchTaskDTO.getDailyDate().toInstant()
|
.atZone(ZoneId.systemDefault())
|
.toLocalDateTime();
|
projectDailyMainDO.setDailyDate(dailyDateLocalTimeTime);
|
projectDailyMainDO.setUseId(String.valueOf(user.getId()));
|
projectDailyMainDO.setUserName(user.getNickname());
|
|
projectDailyMainDO.setIsCommit(DailyCommitEnum.UNCOMMITED.getCode());
|
projectDailyMainDO.setIsConfirm(DailyConfirmEnum.UNCONFIRM.getCode());
|
|
projectDailyMainDO.create(String.valueOf(user.getId()), user.getNickname());
|
|
projectDailyMainService.save(projectDailyMainDO);
|
// mainDOList.add(projectDailyMainDO);
|
|
}
|
|
// 日志信息
|
ProjectDailyDO projectDailyDO=new ProjectDailyDO();
|
BeanUtils.copyProperties(createBatchTaskDTO,projectDailyDO);
|
projectDailyDO.create(String.valueOf(user.getId()), user.getNickname());
|
projectDailyDO.setId(IdUtil.simpleUUID());
|
// 查看当前开发当天是否已经安排过日志
|
if(projectDailyService.existsProjectDaily(createBatchTaskDTO.getTaskId(),user.getId(),createBatchTaskDTO.getDailyDate())){
|
throw new ForbiddenException(20001);
|
}
|
System.out.println(projectDailyDO.getId());
|
projectDailyService.save(projectDailyDO);
|
|
// projectDailyDOSList.add(projectDailyDO);
|
|
// 开发信息
|
if(!projectTaskDeveloperService.existsProjectTaskDeveloperByTaskId(createBatchTaskDTO)) {
|
ProjectTaskDeveloperDO projectTaskDeveloperDO = new ProjectTaskDeveloperDO();
|
projectTaskDeveloperDO.setId(UUID.randomUUID().toString().replace("-", ""));
|
projectTaskDeveloperDO.setTaskId(createBatchTaskDTO.getTaskId());
|
projectTaskDeveloperDO.setDeveloperId(createBatchTaskDTO.getUserId());
|
projectTaskDeveloperDO.setDeveloperName(user.getNickname());
|
// 日志的状态为未完成
|
projectTaskDeveloperDO.setDeveloperTaskStatus(ProjectTaskStatusEnum.FN.getCode());
|
projectTaskDeveloperDO.create(String.valueOf(curUser.getId()), curUser.getNickname());
|
projectTaskDeveloperService.save(projectTaskDeveloperDO);
|
// projectTaskDeveloperDOList.add(projectTaskDeveloperDO);
|
}
|
|
});
|
|
// 批量入库
|
// 日志-主
|
// if(!CollectionUtils.isEmpty(mainDOList))
|
// projectDailyMainService.saveOrUpdateBatch(mainDOList);
|
// // 日志-详
|
// if(!CollectionUtils.isEmpty(projectDailyDOSList))
|
// projectDailyService.saveOrUpdateBatch(projectDailyDOSList);
|
//// // 日志-开发
|
// if(!CollectionUtils.isEmpty(projectTaskDeveloperDOList))
|
// projectTaskDeveloperService.saveOrUpdateBatch(projectTaskDeveloperDOList);
|
|
// 查看当前任务的排配的总体时间是否大于任务的计划时间
|
projectDailyService.checkProjectDailyTaskPlanHours(validator.getDailyList().get(0).getTaskId());
|
|
// 更新任务为已排配
|
ProjectTaskDO projectTaskDO=new ProjectTaskDO();
|
projectTaskDO.setId(validator.getDailyList().get(0).getTaskId());
|
projectTaskDO.setAssignStatus(ProjectTaskAssignStatusEnum.AY.getCode());
|
projectTaskService.updateById(projectTaskDO);
|
|
}
|
|
@Override
|
public QueryTaskDailyDTO getProjectDailyTaskInfo(String taskId, String userId) {
|
|
List<QueryTaskDailyDTO> list = projectDailyMapperCustom.getProjectDailyTaskInfo(taskId,userId);
|
|
if(!CollectionUtils.isEmpty(list)){
|
return list.get(0);
|
}
|
return null;
|
}
|
|
@Override
|
public int getProjectTaskDailyUnCommited(String taskId, String userId) {
|
|
LambdaQueryWrapper<ProjectDailyDO> queryWrapper=new LambdaQueryWrapper<>();
|
queryWrapper
|
.eq(ProjectDailyDO::getIsDeleted,DeletedEnum.DELETED_NO.getCode())
|
.eq(ProjectDailyDO::getTaskId,taskId)
|
.eq(ProjectDailyDO::getCreateUserId,userId)
|
.eq(ProjectDailyDO::getIsCommit,DailyCommitEnum.UNCOMMITED.getCode());
|
return baseMapper.selectCount(queryWrapper);
|
}
|
@Override
|
public boolean existsProjectDaily(String taskId, Integer userId, Date dailyDate) {
|
LambdaQueryWrapper<ProjectDailyDO> queryWrapper=new LambdaQueryWrapper<>();
|
queryWrapper
|
.eq(ProjectDailyDO::getIsDeleted,DeletedEnum.DELETED_NO.getCode())
|
.eq(ProjectDailyDO::getTaskId,taskId)
|
.eq(ProjectDailyDO::getCreateUserId,userId)
|
.eq(ProjectDailyDO::getDailyDate,dailyDate);
|
return baseMapper.selectCount(queryWrapper)>0;
|
}
|
|
@Override
|
public void checkProjectDailyTaskPlanHours(String taskId) {
|
|
ProjectTaskDO projectTaskDO = projectTaskService.getById(taskId);
|
if(Objects.isNull(projectTaskDO)){
|
throw new NotFoundException("任务信息不存在！");
|
}
|
|
LambdaQueryWrapper<ProjectDailyDO> queryWrapper=new LambdaQueryWrapper<>();
|
queryWrapper
|
.eq(ProjectDailyDO::getIsDeleted,DeletedEnum.DELETED_NO.getCode())
|
.eq(ProjectDailyDO::getTaskId,taskId);
|
|
List<ProjectDailyDO> projectDailyDOS = baseMapper.selectList(queryWrapper);
|
// 遍历projectDailyDOS 相加plan_hour
|
BigDecimal totalPlanHour = projectDailyDOS.stream()
|
.map(ProjectDailyDO::getEstimatedHours) // 获取 BigDecimal 类型的 plan_hour
|
.reduce(BigDecimal.ZERO, BigDecimal::add); // 求和
|
|
// 检查排配时间是否大于计划时间
|
if(projectTaskDO.getPlanHour().compareTo(totalPlanHour)<0){
|
throw new ForbiddenException(20002);
|
}
|
|
}
|
|
@Override
|
public QueryProjectTaskHoursDTO getCommitedActualHoursStatisticByTaskId(String taskId) {
|
List<QueryProjectTaskHoursDTO> statisticByTaskId = projectDailyMapper.getCommitedActualHoursStatisticByTaskId(taskId);
|
if(!CollectionUtils.isEmpty(statisticByTaskId)){
|
return statisticByTaskId.get(0);
|
}
|
return null;
|
}
|
|
public void validateTask(CreateWithTaskDTO task) {
|
// 手动调用验证
|
Set<ConstraintViolation<CreateWithTaskDTO>> violations = validator.validate(task);
|
|
// 如果有验证错误
|
if (!violations.isEmpty()) {
|
StringBuilder errorMessage = new StringBuilder("批量任务保存失败： ");
|
for (ConstraintViolation<CreateWithTaskDTO> violation : violations) {
|
errorMessage.append(violation.getMessage()).append(", ");
|
}
|
throw new ConstraintViolationException(errorMessage.toString(),violations);
|
}
|
}
|
|
|
private String formatDateDaily(List<ProjectDailyBO> list){
|
|
String dailyTemplate="%d、【%s】 %s ( 计划：%.2f H , 实际：%.2f H , 状态：%s ,备注：%s ) ";
|
String dailyTemplate2="<span style='background-color:yellow'> %d、【%s】 %s ( 计划：%.2f H , 实际：%.2f H , 状态：%s ,备注：%s ) </span> ";
|
StringBuilder sb=new StringBuilder();
|
for(int i=0;i<list.size();i++){
|
ProjectDailyBO daily=list.get(i);
|
String singleDailyStr ="";
|
|
if(Objects.equals(daily.getSupplementaryFlag(),SupplementaryEnum.YES.getCode())){
|
singleDailyStr = String.format(dailyTemplate2,(i+1),
|
Objects.toString(daily.getProjectName2(), ""),
|
daily.getDailyContent(),
|
Objects.isNull(daily.getEstimatedHours())? BigDecimal.ZERO :daily.getEstimatedHours(),
|
Objects.isNull(daily.getActualHours())?BigDecimal.ZERO:daily.getActualHours(),
|
daily.getDailyStatusName(),
|
StringUtils.isEmpty(daily.getRemark())?"":daily.getRemark());
|
}else{
|
singleDailyStr = String.format(dailyTemplate,(i+1),
|
Objects.toString(daily.getProjectName2(), ""),
|
daily.getDailyContent(),
|
Objects.isNull(daily.getEstimatedHours())?BigDecimal.ZERO:daily.getEstimatedHours(),
|
Objects.isNull(daily.getActualHours())?BigDecimal.ZERO:daily.getActualHours(),
|
daily.getDailyStatusName(),
|
StringUtils.isEmpty(daily.getRemark())?"":daily.getRemark());
|
}
|
if(Objects.equals(daily.getIsConfirm(),DailyConfirmEnum.CONFIRM.getCode())){
|
singleDailyStr +=" √";
|
}
|
|
sb.append(singleDailyStr+"\n");
|
}
|
return sb.toString();
|
}
|
|
|
}
|
