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.Wrappers;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.common.core.domain.entity.DepartmentLims;
|
import com.ruoyi.common.core.domain.entity.User;
|
import com.ruoyi.common.numgen.NumberGenerator;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.framework.exception.ErrorException;
|
import com.ruoyi.personnel.dto.PersonTrainingDetailedDto;
|
import com.ruoyi.personnel.enumeration.AttachmentType;
|
import com.ruoyi.personnel.excel.PersonTrainingDetailedUpload;
|
import com.ruoyi.personnel.mapper.*;
|
import com.ruoyi.personnel.pojo.*;
|
import com.ruoyi.personnel.service.PersonTrainingDetailedService;
|
import com.ruoyi.system.mapper.DepartmentLimsMapper;
|
import com.ruoyi.system.mapper.UserMapper;
|
import com.ruoyi.system.service.DepartmentLimsService;
|
import lombok.AllArgsConstructor;
|
import org.apache.commons.math3.analysis.function.Power;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.multipart.MultipartFile;
|
|
import javax.annotation.Resource;
|
import javax.servlet.ServletOutputStream;
|
import javax.servlet.http.HttpServletResponse;
|
import java.io.File;
|
import java.io.FileInputStream;
|
import java.io.IOException;
|
import java.net.URLEncoder;
|
import java.text.SimpleDateFormat;
|
import java.time.LocalDateTime;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* <p>
|
* 培训计划详情 服务实现类
|
* </p>
|
*
|
* @author 芯导软件（江苏）有限公司
|
* @since 2024-10-11 01:46:27
|
*/
|
@Service
|
@Transactional(rollbackFor = Exception.class)
|
public class PersonTrainingDetailedServiceImpl extends ServiceImpl<PersonTrainingDetailedMapper, PersonTrainingDetailed> implements PersonTrainingDetailedService {
|
|
@Resource
|
private DepartmentLimsService departmentLimsService;
|
|
@Resource
|
private UserMapper userMapper;
|
|
@Resource
|
private PersonTrainingRecordMapper personTrainingRecordMapper;
|
|
@Resource
|
private PersonTrainingMapper personTrainingMapper;
|
|
// private PowerMapper powerMapper;
|
|
@Resource
|
private PersonTrainingFileMapper personTrainingFileMapper;
|
|
@Resource
|
private NumberGenerator<PersonTrainingDetailed> numberGenerator;
|
|
@Resource
|
private DepartmentLimsMapper departmentLimsMapper;
|
|
@Value("${file.path}")
|
private String imgUrl;
|
|
@Value("${excelUrl}")
|
private String excelUrl;
|
|
@Value("${wordUrl}")
|
private String wordUrl;
|
|
/**
|
*
|
* @param file
|
* @param id 年度计划明细表id
|
*/
|
@Override
|
public Map<String,Object> fileUpload(MultipartFile file, Integer id) {
|
HashMap<String, Object> map = new HashMap<>();
|
String fileName = file.getOriginalFilename();
|
|
try {
|
UUID uuid = UUID.randomUUID();
|
String uuidString = uuid.toString();
|
int i = fileName.indexOf(".");
|
String suffix = fileName.substring(i); //文件后缀
|
String url = uuidString + suffix;
|
String OriginalFileName = fileName.substring(0,i); // 文件原名称
|
// 存放路径
|
String path = "";
|
// 根据不同的后缀存放在不同的路径下
|
if(suffix.toLowerCase().contains("xls")) {
|
path = excelUrl;
|
} else if (suffix.toLowerCase().contains("doc") || suffix.toLowerCase().contains("pdf")) {
|
path = wordUrl;
|
}else {
|
path = imgUrl;
|
}
|
File uploadDir = new File(path);
|
if(!uploadDir.exists()){
|
uploadDir.mkdir();
|
}
|
File destFile = new File(uploadDir , url);
|
file.transferTo(destFile);
|
// 将文件路径存储到数据库
|
PersonTrainingFile personTrainingFile = new PersonTrainingFile();
|
personTrainingFile.setDetailId(id);
|
personTrainingFile.setFileName(OriginalFileName + suffix);
|
personTrainingFile.setFileUrl("/"+url);
|
personTrainingFile.setCreateUser(SecurityUtils.getUserId().intValue());
|
personTrainingFile.setCreateTime(LocalDateTime.now());
|
personTrainingFileMapper.insert(personTrainingFile);
|
|
|
map.put("fileName",OriginalFileName + suffix);
|
map.put("url","/"+url);
|
} catch (IOException e) {
|
throw new ErrorException("上传失败");
|
}
|
return map;
|
}
|
|
@Override
|
public List<DepartmentLims> selectDepartLims() {
|
List<DepartmentLims> departmentLims = departmentLimsMapper.selectList(null);
|
return departmentLims;
|
|
|
}
|
|
@Override
|
public void importExcel(List<PersonTrainingDetailedUpload> list, Integer planId) {
|
List<PersonTrainingDetailed> personTrainingDetailedList = new ArrayList<>();
|
list.forEach(i -> {
|
PersonTrainingDetailed personTrainingDetailed = new PersonTrainingDetailed();
|
BeanUtils.copyProperties(i, personTrainingDetailed);
|
personTrainingDetailed.setClassHour(Double.parseDouble( i.getClassHour()));
|
// 匹配举办部门
|
DepartmentLims departmentLims = departmentLimsService.getOne(Wrappers.<DepartmentLims>lambdaQuery()
|
.eq(DepartmentLims::getName, i.getHoldingDepartment()));
|
if (ObjectUtils.isEmpty(departmentLims)) {
|
throw new ErrorException("未匹配到举办部门：" + i.getHoldingDepartment());
|
}
|
personTrainingDetailed.setHoldingDepartment(departmentLims.getId());
|
|
// // 匹配讲师
|
// String[] names = i.getTrainingLecturerName().split("、|，|,|\\s+");
|
// ArrayList<Integer> ids = new ArrayList<>();
|
// for(String name : names) {
|
// if(StringUtils.isNotEmpty(name)) {
|
// User user = userMapper.selectOne(Wrappers.<User>lambdaQuery()
|
// .eq(User::getName, name));
|
// if(Objects.isNull(user)) {
|
// throw new ErrorException("未找到该讲师：" + name);
|
// }
|
// ids.add(user.getId());
|
// }
|
// }
|
// String collect = ids.stream().map(item -> item.toString()).collect(Collectors.joining(","));
|
personTrainingDetailed.setTrainingLecturerId(i.getTrainingLecturerName());
|
personTrainingDetailed.setPlanId(planId);
|
personTrainingDetailed.setState(3);
|
|
String year = new SimpleDateFormat("yy", Locale.CHINESE).format(new Date());
|
String month = new SimpleDateFormat("MM", Locale.CHINESE).format(new Date());
|
String processNumber = numberGenerator.generateNumberWithPrefix(4, "KC" + month + "-" + year + month, PersonTrainingDetailed::getCourseCode);
|
personTrainingDetailed.setCourseCode(processNumber);
|
personTrainingDetailedList.add(personTrainingDetailed);
|
});
|
// 批量新增
|
if (CollectionUtils.isNotEmpty(personTrainingDetailedList)) {
|
baseMapper.insertBatchSomeColumn(personTrainingDetailedList);
|
}
|
}
|
|
@Override
|
public void deleteAnnualPlanDetailTable(String ids) {
|
String[] split = ids.split(",");
|
if (split.length > 0) {
|
for (String s : split) {
|
baseMapper.deleteById(s);
|
}
|
}
|
}
|
|
@Override
|
public IPage<PersonTrainingDetailedDto> queryTheAnnualPlanDetailsTable(Page page, String trainingLecturerName, String courseCode, String trainingDate,
|
Integer id, Integer userId,Integer departId,Integer state) {
|
// 判断当前人是否有权限查看年度计划主表
|
Integer userId1 = SecurityUtils.getUserId().intValue();
|
User user = userMapper.selectById(userId1);
|
String name1 = user.getName();
|
Integer currentUserId = user.getId();
|
//todo 权限待完成
|
// List<Power> powers = powerMapper.selectList(new LambdaQueryWrapper<Power>()
|
// .eq(Power::getRoleId, user.getRoleId())
|
// .eq(Power::getMenuMethod,"personTrainingSelect"));
|
// if(CollectionUtils.isEmpty(powers)) {
|
// if(Objects.isNull(departId) || departId == 1) {
|
// // 没有权限 就默认查看自己部门最新的年度计划 18 通信产品实验室 19 电力产品实验室
|
// if(user.getDepartLimsId().contains("18")) {
|
// List<PersonTraining> personTrainings = personTrainingMapper.selectList(new LambdaQueryWrapper<PersonTraining>()
|
// .eq(PersonTraining::getDepartId, 18)
|
// .orderByDesc(PersonTraining::getId));
|
// if(CollectionUtils.isNotEmpty(personTrainings)) {
|
// id = personTrainings.get(0).getId();
|
// }
|
// }else if(user.getDepartLimsId().contains("19")) {
|
// List<PersonTraining> personTrainings = personTrainingMapper.selectList(new LambdaQueryWrapper<PersonTraining>()
|
// .eq(PersonTraining::getDepartId, 19)
|
// .orderByDesc(PersonTraining::getId));
|
// if(CollectionUtils.isNotEmpty(personTrainings)) {
|
// id = personTrainings.get(0).getId();
|
// }
|
// }
|
// }else {
|
// List<PersonTraining> personTrainings = personTrainingMapper.selectList(new LambdaQueryWrapper<PersonTraining>()
|
// .eq(PersonTraining::getDepartId, departId)
|
// .orderByDesc(PersonTraining::getId));
|
// if(CollectionUtils.isNotEmpty(personTrainings)) {
|
// id = personTrainings.get(0).getId();
|
// }
|
// }
|
// }
|
if(Objects.nonNull(state)) {
|
if(state == -1) {
|
state = null;
|
}
|
}
|
IPage<PersonTrainingDetailedDto> list = baseMapper.queryTheAnnualPlanDetailsTable(page, trainingLecturerName, courseCode, trainingDate, id, userId, userId1,state);
|
// 报名人数
|
List<PersonTrainingDetailedDto> records = list.getRecords();
|
for(PersonTrainingDetailedDto a : records) {
|
// 报名的人数
|
List<PersonTrainingRecord> personTrainingRecords = personTrainingRecordMapper.selectList(new LambdaQueryWrapper<PersonTrainingRecord>()
|
.eq(PersonTrainingRecord::getCourseId, a.getId()));
|
a.setEnrollment(CollectionUtils.isNotEmpty(personTrainingRecords) ? personTrainingRecords.size() : 0);
|
List<Integer> collect = personTrainingRecords.stream().map(PersonTrainingRecord::getUserId).collect(Collectors.toList());
|
if(collect.contains(SecurityUtils.getUserId().intValue())) {
|
a.setWhetherClaim(true);
|
}else {
|
a.setWhetherClaim(false);
|
}
|
//前端权限需要 是否可以操作按钮
|
// if(a.getTrainingLecturerId().contains(name1) || CollectionUtils.isNotEmpty(powers) ||
|
// (Objects.nonNull(a.getAssessmentUserId()) && a.getAssessmentUserId().equals(currentUserId)) || Arrays.asList(16,36,35).contains(currentUserId)) {
|
// a.setIsDisabled(1); // 1不禁用
|
// }else{
|
// a.setIsDisabled(0);
|
// }
|
}
|
return list;
|
}
|
|
@Override
|
public List<PersonTrainingFile> getFileData(Integer detailedId) {
|
List<PersonTrainingFile> personTrainingFiles = personTrainingFileMapper.selectList(new LambdaQueryWrapper<PersonTrainingFile>()
|
.eq(PersonTrainingFile::getDetailId, detailedId)
|
.eq(PersonTrainingFile::getEnumAttachmentType, AttachmentType.getTypeValue(2)));
|
if(CollectionUtils.isNotEmpty(personTrainingFiles)) {
|
for(PersonTrainingFile a : personTrainingFiles) {
|
// 设置mime
|
int i = a.getFileUrl().indexOf(".");
|
String contentType = getContentType(a.getFileUrl().substring(i + 1));
|
a.setMime(contentType);
|
}
|
}
|
return personTrainingFiles;
|
}
|
|
@Override
|
public void deleteFile(Integer id) {
|
personTrainingFileMapper.deleteById(id);
|
}
|
|
@Override
|
public void fileDownLoad(Integer id, HttpServletResponse response) {
|
// 根据id查询下载的文件
|
PersonTrainingFile personTrainingFile = personTrainingFileMapper.selectById(id);
|
if(Objects.nonNull(personTrainingFile)) {
|
// 拿到文件路径
|
String fileUrl = personTrainingFile.getFileUrl();
|
int i = fileUrl.indexOf(".");
|
String suffix = fileUrl.substring(i); // 文件后缀
|
String url = "";
|
if(suffix.toLowerCase().contains("xls")) {
|
url = excelUrl + File.separator + fileUrl;
|
} else if (suffix.toLowerCase().contains("doc") || suffix.toLowerCase().contains("pdf")) {
|
url = wordUrl + File.separator + fileUrl;
|
}else {
|
url = imgUrl + File.separator + fileUrl;
|
}
|
File file = new File(url);
|
if(!file.exists()) {
|
throw new ErrorException("文件不存在或损坏");
|
}
|
// 获取文件输入流
|
try(FileInputStream fileInputStream = new FileInputStream(file); ServletOutputStream outputStream = response.getOutputStream()) {
|
String contentType = getContentType(fileUrl.substring(i + 1));
|
// 设置响应头
|
response.setContentType(contentType);
|
int i1 = personTrainingFile.getFileName().indexOf(".");
|
String fileName = URLEncoder.encode(personTrainingFile.getFileName().substring(0, i1), "UTF-8");
|
response.setHeader("Content-disposition", "attachment;filename=" + fileName + suffix);
|
byte[] bytes = new byte[1024];
|
int bytesRead;
|
while ((bytesRead = fileInputStream.read(bytes)) != -1 ){
|
outputStream.write(bytes,0,bytesRead);
|
}
|
outputStream.flush();
|
} catch (Exception e) {
|
throw new RuntimeException(e);
|
}
|
}
|
}
|
// 根据文件扩展名获取 MIME 类型
|
private String getContentType(String fileExtension) {
|
switch (fileExtension) {
|
case "jpg":
|
case "jpeg":
|
return "image/jpeg";
|
case "png":
|
return "image/png";
|
case "gif":
|
return "image/gif";
|
case "pdf":
|
return "application/pdf";
|
case "doc":
|
return "application/msword";
|
case "docx":
|
return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
|
case "xls":
|
return "application/vnd.ms-excel";
|
case "xlsx":
|
return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
|
case "ppt":
|
case "pptx":
|
return "application/vnd.ms-powerpoint";
|
default:
|
return "application/octet-stream"; // 默认二进制流
|
}
|
}
|
|
|
|
}
|
