package com.ruoyi.personnel.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
|
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.deepoove.poi.XWPFTemplate;
|
import com.deepoove.poi.config.Configure;
|
import com.ruoyi.common.core.domain.entity.User;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.framework.exception.ErrorException;
|
import com.ruoyi.framework.util.HackLoopTableRenderPolicy;
|
import com.ruoyi.performance.mapper.AuxiliaryWorkingHoursDayMapper;
|
import com.ruoyi.performance.mapper.PerformanceShiftMapper;
|
import com.ruoyi.performance.pojo.AuxiliaryWorkingHoursDay;
|
import com.ruoyi.performance.pojo.PerformanceShift;
|
import com.ruoyi.performance.service.AuxiliaryWorkingHoursDayService;
|
import com.ruoyi.personnel.dto.PersonTrainingRecordDto;
|
import com.ruoyi.personnel.dto.PersonTrainingRecordListDto;
|
import com.ruoyi.personnel.dto.TrainingRecordPersonDetailedDto;
|
import com.ruoyi.personnel.mapper.*;
|
import com.ruoyi.personnel.pojo.*;
|
import com.ruoyi.personnel.service.PersonTrainingDetailedService;
|
import com.ruoyi.personnel.service.PersonTrainingRecordService;
|
import com.ruoyi.system.mapper.UserMapper;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.annotation.Resource;
|
import javax.servlet.http.HttpServletResponse;
|
import java.io.InputStream;
|
import java.io.OutputStream;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.net.URLEncoder;
|
import java.text.SimpleDateFormat;
|
import java.time.*;
|
import java.time.temporal.TemporalField;
|
import java.time.temporal.WeekFields;
|
import java.util.*;
|
|
/**
|
* <p>
|
* 培训记录 服务实现类
|
* </p>
|
*
|
* @author 芯导软件（江苏）有限公司
|
* @since 2024-10-12 04:50:48
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
@Service
|
public class PersonTrainingRecordServiceImpl extends ServiceImpl<PersonTrainingRecordMapper, PersonTrainingRecord> implements PersonTrainingRecordService {
|
|
@Resource
|
private UserMapper userMapper;
|
|
@Resource
|
private PersonTrainingDetailedService personTrainingDetailedService;
|
|
@Resource
|
private PersonTrainingDetailedMapper personTrainingDetailedMapper;
|
|
@Resource
|
private AuxiliaryWorkingHoursDayMapper auxiliaryWorkingHoursDayMapper;
|
|
@Resource
|
private PerformanceShiftMapper shiftMapper;
|
|
@Autowired
|
private AuxiliaryWorkingHoursDayService auxiliaryWorkingHoursDayService;
|
|
|
@Override
|
public List<PersonTrainingRecordDto> trainingAndAssessmentRecordsPage(Integer trainingDetailedId, String userName) {
|
return baseMapper.trainingAndAssessmentRecordsPage(trainingDetailedId, userName);
|
}
|
|
@Override
|
public void deleteTrainingAndAssessmentRecords(String ids) {
|
String[] split = ids.split(",");
|
if (split.length > 0) {
|
for (String s : split) {
|
baseMapper.deleteById(s);
|
}
|
}
|
}
|
|
@Override
|
public IPage<PersonTrainingRecordListDto> personnelTrainingPersonnel(Page page, String userName, Integer userId, Integer departLimsId) {
|
return baseMapper.personnelTrainingPersonnel(page, userName, userId, departLimsId);
|
}
|
|
@Override
|
public IPage<TrainingRecordPersonDetailedDto> queryPersonnelDetails(Page page, Integer userId) {
|
return baseMapper.queryPersonnelDetails(page, userId);
|
}
|
|
@Override
|
public void claimOfTrainingAndAssessmentRecords(Boolean claimAndClaim, Integer courseId) {
|
int userId = SecurityUtils.getUserId().intValue();
|
// 1、查询培训课程，取培训日期与开始日期，与当前时间比较，判断是否超出，如果超出不允许认领
|
Boolean doesItExceedState = doesItExceed(courseId);
|
if (!doesItExceedState) {
|
throw new ErrorException("当前课程状态无法认领！");
|
}
|
// 2、判断是否重复
|
PersonTrainingRecord personTrainingRecord1 = baseMapper.selectOne(Wrappers.<PersonTrainingRecord>lambdaQuery()
|
.eq(PersonTrainingRecord::getCourseId, courseId)
|
.eq(PersonTrainingRecord::getUserId, userId));
|
if (ObjectUtils.isNotEmpty(personTrainingRecord1)) {
|
throw new ErrorException("请勿重复认领！");
|
}
|
// 3、如果未重复新增培训记录
|
// true 认领
|
if (claimAndClaim) {
|
PersonTrainingRecord personTrainingRecord = new PersonTrainingRecord();
|
personTrainingRecord.setUserId(userId);
|
personTrainingRecord.setCourseId(courseId);
|
baseMapper.insert(personTrainingRecord);
|
// 取消认领
|
} else {
|
baseMapper.delete(Wrappers.<PersonTrainingRecord>lambdaQuery()
|
.eq(PersonTrainingRecord::getUserId, userId)
|
.eq(PersonTrainingRecord::getCourseId, courseId));
|
}
|
}
|
|
/**
|
* 导出人员培训记录
|
* @param userId
|
* @param response
|
*/
|
@Override
|
public void exportTrainingRecord(Integer userId, HttpServletResponse response) {
|
// 查询人员人信息
|
PersonTrainingRecordListDto trainingRecordListDto = baseMapper.selectUserTraining(userId);
|
|
// 查询培训记录
|
List<TrainingRecordPersonDetailedDto> personDetailedDtos = baseMapper.selectPersonDetailedDtos(userId);
|
|
|
// 获取路径
|
InputStream inputStream = this.getClass().getResourceAsStream("/static/training-record.docx");
|
Configure configure = Configure.builder()
|
.bind("personnelDetailsLisat", new HackLoopTableRenderPolicy())
|
.build();
|
XWPFTemplate template = XWPFTemplate.compile(inputStream, configure).render(
|
new HashMap<String, Object>() {{
|
put("traning", trainingRecordListDto);
|
put("personnelDetailsLisat", personDetailedDtos);
|
}});
|
try {
|
response.setContentType("application/msword");
|
String fileName = URLEncoder.encode(
|
"人员培训记录导出", "UTF-8");
|
response.setHeader("Content-disposition",
|
"attachment;filename=" + fileName + ".docx");
|
OutputStream os = response.getOutputStream();
|
template.write(os);
|
os.flush();
|
os.close();
|
} catch (Exception e) {
|
e.printStackTrace();
|
throw new RuntimeException("导出失败");
|
}
|
|
|
}
|
|
@Override
|
public IPage<TrainingRecordPersonDetailedDto> queryPersonnelDetailsOfUserIdAndYear(Page page, Integer userId, Integer year) {
|
return baseMapper.queryPersonnelDetailsOfUserIdAndYear(page, userId, year);
|
}
|
|
@Override
|
public void exportTrainingRecordAddTrainingDate(Integer userId, Integer trainingDate, HttpServletResponse response) {
|
// 查询人员人信息
|
PersonTrainingRecordListDto trainingRecordListDto = baseMapper.selectUserTraining(userId);
|
|
// 查询培训记录
|
List<TrainingRecordPersonDetailedDto> personDetailedDtos = baseMapper.selectPersonDetailedDtosByTrainingDate(userId, trainingDate);
|
|
|
// 获取路径
|
InputStream inputStream = this.getClass().getResourceAsStream("/static/training-record.docx");
|
Configure configure = Configure.builder()
|
.bind("personnelDetailsLisat", new HackLoopTableRenderPolicy())
|
.build();
|
XWPFTemplate template = XWPFTemplate.compile(inputStream, configure).render(
|
new HashMap<String, Object>() {{
|
put("traning", trainingRecordListDto);
|
put("personnelDetailsLisat", personDetailedDtos);
|
}});
|
try {
|
response.setContentType("application/msword");
|
String fileName = URLEncoder.encode(
|
"人员培训记录导出", "UTF-8");
|
response.setHeader("Content-disposition",
|
"attachment;filename=" + fileName + ".docx");
|
OutputStream os = response.getOutputStream();
|
template.write(os);
|
os.flush();
|
os.close();
|
} catch (Exception e) {
|
e.printStackTrace();
|
throw new RuntimeException("导出失败");
|
}
|
}
|
|
@Override
|
public void outOfFocusPreservation(PersonTrainingRecord personTrainingRecord) {
|
int userId = SecurityUtils.getUserId().intValue();
|
// 培训通过了，培训课时计入到当天的辅助工时 (辅助工时 以及 核准工时都添加)
|
baseMapper.updateById(personTrainingRecord);
|
PersonTrainingDetailed personTrainingDetailed = personTrainingDetailedMapper.selectById(personTrainingRecord.getCourseId());
|
if(Objects.nonNull(personTrainingDetailed)) {
|
Double classHour = personTrainingDetailed.getClassHour(); // 课时
|
String trainingDateTwo = personTrainingDetailed.getTrainingDateTwo(); // 培训日期
|
if(StringUtils.isEmpty(trainingDateTwo)) {
|
throw new ErrorException("没有设置培训日期无法添加辅助工时");
|
}
|
// 是否以及添加过了
|
List<AuxiliaryWorkingHoursDay> auxiliaryWorkingHoursDays = auxiliaryWorkingHoursDayMapper.selectList(new LambdaQueryWrapper<AuxiliaryWorkingHoursDay>()
|
.eq(AuxiliaryWorkingHoursDay::getNameUser, personTrainingRecord.getUserId())
|
.eq(AuxiliaryWorkingHoursDay::getAuxiliaryProject, personTrainingDetailed.getTrainingContent())
|
.eq(AuxiliaryWorkingHoursDay::getCreateUser, userId)
|
.eq(AuxiliaryWorkingHoursDay::getDateTime, trainingDateTwo + " 00:00:00"));
|
// 如果有数据 合格就不做处理 不合格就删除
|
if(CollectionUtils.isNotEmpty(auxiliaryWorkingHoursDays)) {
|
if(personTrainingRecord.getExaminationResults().equals("不合格")) {
|
auxiliaryWorkingHoursDayMapper.delete(new LambdaQueryWrapper<AuxiliaryWorkingHoursDay>()
|
.eq(AuxiliaryWorkingHoursDay::getNameUser, personTrainingRecord.getUserId())
|
.eq(AuxiliaryWorkingHoursDay::getAuxiliaryProject, personTrainingDetailed.getTrainingContent())
|
.eq(AuxiliaryWorkingHoursDay::getCreateUser, userId)
|
.eq(AuxiliaryWorkingHoursDay::getDateTime, trainingDateTwo + " 00:00:00"));
|
}
|
}
|
// 是否通过
|
if(personTrainingRecord.getExaminationResults().equals("合格") && CollectionUtils.isEmpty(auxiliaryWorkingHoursDays)) {
|
// 如果是检测办的人就不用加
|
User user = userMapper.selectById(personTrainingRecord.getUserId());
|
if(user.getDepartLimsId().contains("22")) {
|
return;
|
}
|
// 一节课45分钟 工时60分钟
|
BigDecimal minute = BigDecimal.valueOf(classHour).multiply(new BigDecimal("45")); // 具体分钟
|
BigDecimal divide = minute.divide(new BigDecimal("60"),4, RoundingMode.HALF_UP); // 工时
|
// 添加数据
|
AuxiliaryWorkingHoursDay a = new AuxiliaryWorkingHoursDay();
|
a.setNameUser(personTrainingRecord.getUserId()); // 姓名id
|
// 项目名称
|
a.setRemarks(personTrainingDetailed.getTrainingContent()); // 辅助说明
|
a.setNumber("401"); // 编号
|
AuxiliaryWorkingHoursDay auxiliaryWorkingHoursDay = auxiliaryWorkingHoursDayService.selectAuxiliaryWorkingHoursByNumber("401");
|
a.setAuxiliaryProject(auxiliaryWorkingHoursDay.getAuxiliaryProject()); // 辅助项目名称
|
a.setNonproductiveTime(Double.parseDouble(divide.toString())); // 辅助工时
|
a.setApprovedWorkingHour(auxiliaryWorkingHoursDay.getApprovedWorkingHour()); // 核准工时
|
a.setAmount(Double.parseDouble(divide.toString())); // 数量
|
String year = trainingDateTwo.split("-")[0];
|
a.setYear(year); // 年
|
a.setCreateTime(LocalDateTime.now());
|
a.setUpdateTime(LocalDateTime.now());
|
a.setCreateUser(userId); // 创建人id
|
a.setUpdateUser(userId); // 修改人id
|
a.setState("已提交"); // 状态
|
a.setDateTime(trainingDateTwo + " 00:00:00"); // 日期
|
// 获取当前日期
|
LocalDate today = LocalDate.now();
|
// 获取当前日期的周次（一年中的第几周）
|
TemporalField weekOfYear = WeekFields.of(Locale.getDefault()).weekOfYear();
|
int weekNumber = today.get(weekOfYear);
|
// 获取当前日期的星期（一周中的第几天）
|
DayOfWeek dayOfWeek = today.getDayOfWeek();
|
int dayOfWeekNumber = dayOfWeek.getValue();
|
LocalDate now = LocalDate.now();
|
LocalTime parse = LocalTime.parse("00:00:00");
|
LocalDateTime of = LocalDateTime.of(now, parse);
|
PerformanceShift performanceShift = shiftMapper.selectOne(new LambdaQueryWrapper<PerformanceShift>().eq(PerformanceShift::getWorkTime, of)
|
.eq(PerformanceShift::getUserId, personTrainingRecord.getUserId()));
|
if(Objects.nonNull(performanceShift)) {
|
a.setShift(performanceShift.getShift()); // 班次
|
}
|
a.setWeek(weekNumber+""); // 周次
|
a.setWeekDay(dayOfWeekNumber == 7 ? 0+"" : dayOfWeekNumber+""); // 星期
|
auxiliaryWorkingHoursDayMapper.insert(a);
|
}
|
}
|
|
}
|
|
/**
|
* 检验该培训课程是否允许认领
|
* @param courseId 该课程的id
|
* @return
|
*/
|
public Boolean doesItExceed(Integer courseId) {
|
PersonTrainingDetailed personTrainingDetailed = personTrainingDetailedService.getById(courseId);
|
// 只有状态为3可以认领
|
if (!personTrainingDetailed.getState().equals(3)) {
|
return false;
|
}
|
SimpleDateFormat sdfWithoutTime = new SimpleDateFormat("yyyy-MM-dd");
|
if(Objects.isNull(personTrainingDetailed.getTrainingDateTwo()) || StringUtils.isEmpty(personTrainingDetailed.getTrainingDateTwo())) {
|
throw new ErrorException("未配置培训日期,无法报名");
|
}
|
LocalDate parse = LocalDate.parse(personTrainingDetailed.getTrainingDateTwo());
|
Date from = Date.from(parse.atStartOfDay(ZoneId.systemDefault()).toInstant());
|
String originalDateStr = sdfWithoutTime.format(from);
|
SimpleDateFormat sdfWithTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
try {
|
if(Objects.isNull(personTrainingDetailed.getOpeningTime()) || StringUtils.isEmpty(personTrainingDetailed.getOpeningTime())) {
|
throw new ErrorException("未配置具体时间,无法报名");
|
}
|
// 添加时分秒后的日期
|
Date addedDate = sdfWithTime.parse(originalDateStr + " " + personTrainingDetailed.getOpeningTime());
|
// 获取当前时间
|
Date currentDate = new Date();
|
// 日期未超出当前时间。
|
if (addedDate.after(currentDate) || addedDate.equals(currentDate)) {
|
return true;
|
// 日期已超出当前时间
|
} else {
|
// 如果日期超出 更新课程状态为已结束
|
personTrainingDetailedService.update(Wrappers.<PersonTrainingDetailed>lambdaUpdate()
|
.eq(PersonTrainingDetailed::getId, courseId)
|
.set(PersonTrainingDetailed::getState, 2));
|
return false;
|
}
|
} catch (Exception e) {
|
throw new ErrorException("时间格式错误！");
|
}
|
}
|
}
|
