package com.xjrsoft.module.textbook.service.impl; import cn.dev33.satoken.stp.StpUtil; import cn.hutool.core.bean.BeanUtil; import com.alibaba.excel.EasyExcel; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.core.toolkit.Wrappers; import com.github.yulichang.base.MPJBaseServiceImpl; import com.github.yulichang.wrapper.MPJLambdaWrapper; import com.xjrsoft.common.enums.DeleteMark; import com.xjrsoft.common.utils.VoToColumnUtil; import com.xjrsoft.module.base.entity.BaseClass; import com.xjrsoft.module.base.entity.BaseCourseSubject; import com.xjrsoft.module.base.mapper.BaseClassMapper; import com.xjrsoft.module.system.entity.DictionaryDetail; import com.xjrsoft.module.textbook.dto.*; import com.xjrsoft.module.textbook.entity.*; import com.xjrsoft.module.textbook.mapper.*; import com.xjrsoft.module.textbook.service.ITextbookService; import com.xjrsoft.module.textbook.service.IWfTextbookSubscriptionService; import com.xjrsoft.module.textbook.vo.TextbookInstockroomListVo; import com.xjrsoft.module.textbook.vo.TextbookSubscriptionExportQueryListVo; import com.xjrsoft.module.textbook.vo.WfTextbookSubscriptionItemVo; import com.xjrsoft.module.textbook.vo.WfTextbookSubscriptionVo; import lombok.AllArgsConstructor; import org.apache.commons.lang3.ObjectUtils; import org.springframework.beans.BeanUtils; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import java.io.InputStream; import java.util.*; import java.util.concurrent.atomic.AtomicReference; import java.util.regex.Matcher; import java.util.regex.Pattern; import java.util.stream.Collectors; /** * @title: 教材教辅征订 * @Author szs * @Date: 2024-06-04 * @Version 1.0 */ @Service @AllArgsConstructor public class WfTextbookSubscriptionServiceImpl extends MPJBaseServiceImpl implements IWfTextbookSubscriptionService { private final WfTextbookSubscriptionMapper wfTextbookSubscriptionWfTextbookSubscriptionMapper; private final WfTextbookSubscriptionItemMapper wfTextbookSubscriptionWfTextbookSubscriptionItemMapper; private final WfTextbookSubscriptionItemHistoryMapper wfTextbookSubscriptionItemHistoryMapper; private final TextbookSubscriptionMapper textbookSubscriptionMapper; private final TextbookSubscriptionItemMapper textbookSubscriptionItemMapper; private final TextbookSubscriptionClassMapper textbookSubscriptionClassMapper; private final ITextbookService textbookService; private final BaseClassMapper baseClassMapper; @Override @Transactional(rollbackFor = Exception.class) public Boolean add(TextbookSubscription textbookSubscription) { // 处理征订表 int sum = 0; for (TextbookSubscriptionItem textbookSubscriptionItem : textbookSubscription.getTextbookSubscriptionItemList()) { sum += (ObjectUtils.isNotEmpty(textbookSubscriptionItem.getStudentNum()) ? textbookSubscriptionItem.getStudentNum() : 0) + (ObjectUtils.isNotEmpty(textbookSubscriptionItem.getTeacherNum()) ? textbookSubscriptionItem.getTeacherNum() : 0) ; } textbookSubscriptionMapper.insert(textbookSubscription); // 处理征订和班级关联表 if(ObjectUtils.isNotEmpty(textbookSubscription.getSubscriptionMethod()) && textbookSubscription.getSubscriptionMethod() == 1 ){ TextbookSubscriptionClass textbookSubscriptionClass = new TextbookSubscriptionClass(); textbookSubscriptionClass.setTextbookSubscriptionId(textbookSubscription.getId()); textbookSubscriptionClassMapper.insert(textbookSubscriptionClass); } // 处理征订表子表 for (TextbookSubscriptionItem textbookSubscriptionItem : textbookSubscription.getTextbookSubscriptionItemList()) { textbookSubscriptionItem.setTextbookSubscriptionId(textbookSubscription.getId()); textbookSubscriptionItemMapper.insert(textbookSubscriptionItem); } return true; } @Override @Transactional(rollbackFor = Exception.class) public Boolean update(WfTextbookSubscription wfTextbookSubscription) { wfTextbookSubscriptionWfTextbookSubscriptionMapper.updateById(wfTextbookSubscription); //********************************* WfTextbookSubscriptionItem 增删改 开始 *******************************************/ { // 查出所有子级的id List wfTextbookSubscriptionItemList = wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.selectList(Wrappers.lambdaQuery(WfTextbookSubscriptionItem.class).eq(WfTextbookSubscriptionItem::getWfTextbookSubscriptionId, wfTextbookSubscription.getId()).select(WfTextbookSubscriptionItem::getId)); List wfTextbookSubscriptionItemIds = wfTextbookSubscriptionItemList.stream().map(WfTextbookSubscriptionItem::getId).collect(Collectors.toList()); //原有子表单 没有被删除的主键 List wfTextbookSubscriptionItemOldIds = wfTextbookSubscription.getWfTextbookSubscriptionItemList().stream().map(WfTextbookSubscriptionItem::getId).filter(Objects::nonNull).collect(Collectors.toList()); //找到需要删除的id List wfTextbookSubscriptionItemRemoveIds = wfTextbookSubscriptionItemIds.stream().filter(item -> !wfTextbookSubscriptionItemOldIds.contains(item)).collect(Collectors.toList()); for (WfTextbookSubscriptionItem wfTextbookSubscriptionItem : wfTextbookSubscription.getWfTextbookSubscriptionItemList()) { //如果不等于空则修改 if (wfTextbookSubscriptionItem.getId() != null) { wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.updateById(wfTextbookSubscriptionItem); } //如果等于空 则新增 else { //已经不存在的id 删除 wfTextbookSubscriptionItem.setWfTextbookSubscriptionId(wfTextbookSubscription.getId()); wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.insert(wfTextbookSubscriptionItem); } } //已经不存在的id 删除 if (wfTextbookSubscriptionItemRemoveIds.size() > 0) { wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.deleteBatchIds(wfTextbookSubscriptionItemRemoveIds); } } //********************************* WfTextbookSubscriptionItem 增删改 结束 *******************************************/ return true; } @Override @Transactional(rollbackFor = Exception.class) public Boolean alteration(UpdateWfTextbookSubscriptionItemDto dto) { WfTextbookSubscriptionItem old = wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.selectById(dto.getId()); if(old == null){ return false; } //将历史记录保存到历史变更记录表 LambdaQueryWrapper wfTextbookSubscriptionItemHistoryLambdaQueryWrapper = new LambdaQueryWrapper<>(); wfTextbookSubscriptionItemHistoryLambdaQueryWrapper .eq(WfTextbookSubscriptionItemHistory::getWfTextbookSubscriptionItemId, old.getId()) .orderByDesc(WfTextbookSubscriptionItemHistory::getHistoryVersion) .last("limit 1") ; WfTextbookSubscriptionItemHistory lastOne = wfTextbookSubscriptionItemHistoryMapper.selectOne(wfTextbookSubscriptionItemHistoryLambdaQueryWrapper); WfTextbookSubscriptionItemHistory wfTextbookSubscriptionItemHistory = new WfTextbookSubscriptionItemHistory(); BeanUtils.copyProperties(old, wfTextbookSubscriptionItemHistory); wfTextbookSubscriptionItemHistory.setId(null); wfTextbookSubscriptionItemHistory.setWfTextbookSubscriptionItemId(old.getId()); wfTextbookSubscriptionItemHistory.setCreateDate(new Date()); wfTextbookSubscriptionItemHistory.setCreateUserId(StpUtil.getLoginIdAsLong()); if(lastOne != null){ wfTextbookSubscriptionItemHistory.setHistoryVersion(lastOne.getHistoryVersion() + 1); } else { wfTextbookSubscriptionItemHistory.setHistoryVersion(1); } wfTextbookSubscriptionItemHistoryMapper.insert(wfTextbookSubscriptionItemHistory); //变更当前记录 WfTextbookSubscriptionItem updateItem = new WfTextbookSubscriptionItem(); BeanUtils.copyProperties(dto, updateItem); wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.updateById(updateItem); return true; } @Override @Transactional(rollbackFor = Exception.class) public Boolean delete(List ids) { wfTextbookSubscriptionWfTextbookSubscriptionMapper.deleteBatchIds(ids); wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.delete(Wrappers.lambdaQuery(WfTextbookSubscriptionItem.class).in(WfTextbookSubscriptionItem::getWfTextbookSubscriptionId, ids)); return true; } @Override @Transactional(rollbackFor = Exception.class) public Boolean changeStatus(UpdateWfTextbookSubscriptionDto dto) { TextbookSubscription textbookSubscription = textbookSubscriptionMapper.selectById(dto.getId()); if (textbookSubscription == null) { return false; } WfTextbookSubscription newW = new WfTextbookSubscription(); newW.setId(textbookSubscription.getId()); newW.setStatus(dto.getStatus()); return this.updateById(newW); } @Override public WfTextbookSubscriptionVo getInfo(WfTextbookSubscriptionDto dto) { WfTextbookSubscription wfTextbookSubscription = this.getById(dto.getId()); if (wfTextbookSubscription == null) { return null; } WfTextbookSubscriptionVo wfTextbookSubscriptionVo = BeanUtil.toBean(wfTextbookSubscription, WfTextbookSubscriptionVo.class); MPJLambdaWrapper mpjLambdaWrapper = new MPJLambdaWrapper<>(); mpjLambdaWrapper .select(WfTextbookSubscriptionItem::getId) .selectAs(BaseCourseSubject::getName, WfTextbookSubscriptionItemVo::getCourseSubjectIdCn) .select(Textbook.class, x -> VoToColumnUtil.fieldsToColumns(WfTextbookSubscriptionItemVo.class).contains(x.getProperty())) .select(WfTextbookSubscriptionItem.class, x -> VoToColumnUtil.fieldsToColumns(WfTextbookSubscriptionItemVo.class).contains(x.getProperty())) .leftJoin(Textbook.class, Textbook::getId, WfTextbookSubscriptionItem::getTextbookId) .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, Textbook::getTextbookType, ext -> ext.selectAs(DictionaryDetail::getName, WfTextbookSubscriptionItemVo::getTextbookTypeCn)) .leftJoin(BaseCourseSubject.class, BaseCourseSubject::getId, Textbook::getCourseSubjectId) .eq(WfTextbookSubscriptionItem::getWfTextbookSubscriptionId, wfTextbookSubscription.getId()) .eq(dto.getWfTextbookSubscriptionItemId() != null && dto.getWfTextbookSubscriptionItemId() > 0, WfTextbookSubscriptionItem::getId, dto.getWfTextbookSubscriptionItemId()) .eq(dto.getTextbookType() != null && !dto.getTextbookType().isEmpty(), Textbook::getTextbookType, dto.getTextbookType()) .like(dto.getBookName() != null && !dto.getBookName().isEmpty(), Textbook::getBookName, dto.getBookName()) .like(dto.getCourseSubjectIdCn() != null && !dto.getCourseSubjectIdCn().isEmpty(), BaseCourseSubject::getName, dto.getCourseSubjectIdCn()) ; List itemList = wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.selectJoinList(WfTextbookSubscriptionItemVo.class, mpjLambdaWrapper); //处理班级 String classIds = ""; List classIdList = new ArrayList<>(); StringBuilder sb = new StringBuilder(); if (!itemList.isEmpty() && itemList.get(0).getClassIds() != null && !itemList.get(0).getClassIds().equals("")) { classIds = itemList.get(0).getClassIds(); String[] classIdArr = classIds.split(","); classIdList = Arrays.asList(classIdArr); if (!classIdList.isEmpty()) { List baseClassList = baseClassMapper.selectList(Wrappers.query().lambda().in(BaseClass::getId, classIdList)); Map baseClassMap = baseClassList.stream() .collect(Collectors.toMap(BaseClass::getId, baseClass -> baseClass)); for (String classId : classIdList) { BaseClass baseClass = baseClassMap.get(Long.parseLong(classId)); if (baseClass != null) { sb.append(baseClass.getName()); sb.append(","); } } sb.deleteCharAt(sb.length() - 1); } } //遍历处理所有项 int stuSum = 0; int teaSum = 0; for (WfTextbookSubscriptionItemVo w : itemList) { int sum = 0; if (!classIdList.isEmpty()) { w.setClassNum(classIdList.size()); } if (w.getStudentSubscriptionNumber() != null) { stuSum += w.getStudentSubscriptionNumber(); sum += w.getStudentSubscriptionNumber(); } if (w.getTeacherSubscriptionNumber() != null) { teaSum += w.getTeacherSubscriptionNumber(); sum += w.getTeacherSubscriptionNumber(); } w.setSumNumber(sum); } wfTextbookSubscriptionVo.setClassIdsCn(sb.toString()); wfTextbookSubscriptionVo.setClassIds(classIds); wfTextbookSubscriptionVo.setStudentSubscriptionNumberSum(stuSum); wfTextbookSubscriptionVo.setTeacherSubscriptionNumberSum(teaSum); wfTextbookSubscriptionVo.setSum(stuSum + teaSum); wfTextbookSubscriptionVo.setWfTextbookSubscriptionItemList(itemList); return wfTextbookSubscriptionVo; } @Override public List textbookSubscriptionExportQuery(TextbookSubscriptionExportQueryListDto dto) { List itemList = new ArrayList<>(); // WfTextbookSubscription wfTextbookSubscription = this.getById(dto.getTextbookSubscriptionId()); // if (wfTextbookSubscription == null) { // return null; // } // // MPJLambdaWrapper mpjLambdaWrapper = new MPJLambdaWrapper<>(); // mpjLambdaWrapper // .selectAs(BaseCourseSubject::getName, TextbookSubscriptionExportQueryListVo::getCourseName) // .select(WfTextbookSubscriptionItem.class, x -> VoToColumnUtil.fieldsToColumns(TextbookSubscriptionExportQueryListVo.class).contains(x.getProperty())) // .select(Textbook.class, x -> VoToColumnUtil.fieldsToColumns(TextbookSubscriptionExportQueryListVo.class).contains(x.getProperty())) // .leftJoin(Textbook.class, Textbook::getId, WfTextbookSubscriptionItem::getTextbookId) // .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, Textbook::getTextbookType, // ext -> ext.selectAs(DictionaryDetail::getName, TextbookSubscriptionExportQueryListVo::getTextbookTypeCn)) // .leftJoin(BaseCourseSubject.class, BaseCourseSubject::getId, Textbook::getCourseSubjectId) // .eq(WfTextbookSubscriptionItem::getWfTextbookSubscriptionId, wfTextbookSubscription.getId()) // ; // List itemList = wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.selectJoinList(TextbookSubscriptionExportQueryListVo.class, mpjLambdaWrapper); // // //处理班级 // String classIds = ""; // List classIdList = new ArrayList<>(); // StringBuilder sb = new StringBuilder(); // if (!itemList.isEmpty() && itemList.get(0).getClassIds() != null && !itemList.get(0).getClassIds().equals("")) { // classIds = itemList.get(0).getClassIds(); // String[] classIdArr = classIds.split(","); // classIdList = Arrays.asList(classIdArr); // /*if(!classIdList.isEmpty()){ // List baseClassList = baseClassMapper.selectList(Wrappers.query().lambda().in(BaseClass::getId, classIdList)); // Map baseClassMap = baseClassList.stream() // .collect(Collectors.toMap(BaseClass::getId, baseClass -> baseClass)); // // for (String classId : classIdList){ // BaseClass baseClass = baseClassMap.get(Long.parseLong(classId)); // if(baseClass != null){ // sb.append(baseClass.getName()); // sb.append(","); // } // } // sb.deleteCharAt(sb.length() - 1); // }*/ // } // // for (TextbookSubscriptionExportQueryListVo w : itemList) { // w.setClassNum(classIdList.size()); // } return itemList; } @Override public List instockroomList(TextbookInstockroomListDto dto) { MPJLambdaWrapper queryWrapper = new MPJLambdaWrapper<>(); queryWrapper .select(WfTextbookSubscriptionItem::getId) .selectAs(BaseCourseSubject::getName, TextbookInstockroomListVo::getCourseName) .selectAs(DictionaryDetail::getName, TextbookInstockroomListVo::getTextbookTypeCn) .select("(t.student_subscription_number + t.teacher_subscription_number) as subscriptionNumber") .select(Textbook.class, x -> VoToColumnUtil.fieldsToColumns(TextbookInstockroomListVo.class).contains(x.getProperty())) .select(WfTextbookSubscriptionItem.class, x -> VoToColumnUtil.fieldsToColumns(TextbookInstockroomListVo.class).contains(x.getProperty())) .leftJoin(Textbook.class, Textbook::getId, WfTextbookSubscriptionItem::getTextbookId) .leftJoin(BaseCourseSubject.class, BaseCourseSubject::getId, Textbook::getCourseSubjectId) .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, Textbook::getTextbookType) .eq(WfTextbookSubscriptionItem::getWfTextbookSubscriptionId, dto.getTextbookSubscriptionId()) .orderByAsc(WfTextbookSubscriptionItem::getInStockroomNum) ; return wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.selectJoinList(TextbookInstockroomListVo.class, queryWrapper); } @Override @Transactional(rollbackFor = Exception.class) public Boolean instockroom(List dtos) { if (dtos.isEmpty()) { return false; } Map result = saveData(dtos); return result != null && (int) result.get("successNum") > 0; } @Override public String excelImport(InputStream inputStream, Long wfTextbookSubscriptionId) { AtomicReference> atomicMap = new AtomicReference<>(new HashMap<>()); List> excalDataList = EasyExcel.read(inputStream).sheet().headRowNumber(1).doReadSync(); String regex = "\\d+"; Pattern pattern = Pattern.compile(regex); List dataList = new ArrayList<>(); for (Map integerObjectMap : excalDataList) { Matcher matcher = pattern.matcher(integerObjectMap.get(11).toString()); int inNum = 0; if(matcher.find()){ inNum = Integer.parseInt(integerObjectMap.get(11).toString()); } TextbookInstockroomImportDto importDto = new TextbookInstockroomImportDto(); importDto.setInNum(inNum); importDto.setIssn(integerObjectMap.get(2).toString()); dataList.add(importDto); } List textbookInstockroomDtoList = new ArrayList<>(); for (TextbookInstockroomImportDto item : dataList){ textbookInstockroomDtoList.add(new TextbookInstockroomDto(){{ setTextbookSubscriptionId(wfTextbookSubscriptionId); // setIssn(item.getIssn()); setInNum(item.getInNum()); }}); } atomicMap.set(saveData(textbookInstockroomDtoList)); if(atomicMap.get() != null){ return "计划入库教材" + atomicMap.get().get("allNum") + "样，成功入库" + atomicMap.get().get("successNum") + "样，成功入库" + atomicMap.get().get("instockroomNum") + "本"; } return "计划入库教材0样，成功入库0样，成功入库0本"; } private Map saveData(List dtos) { Map result = new HashMap<>(); int successNum = 0; int instockroomNum = 0; //获取需要修改的list MPJLambdaWrapper queryWrapper = new MPJLambdaWrapper<>(); queryWrapper .select(WfTextbookSubscriptionItem::getId) .selectAs(Textbook::getIssn, WfTextbookSubscriptionItem::getIssn) .select(WfTextbookSubscriptionItem.class, x -> VoToColumnUtil.fieldsToColumns(WfTextbookSubscriptionItem.class).contains(x.getProperty())) .leftJoin(Textbook.class, Textbook::getId, WfTextbookSubscriptionItem::getTextbookId) .eq(WfTextbookSubscriptionItem::getWfTextbookSubscriptionId, dtos.get(0).getTextbookSubscriptionId()) .eq(WfTextbookSubscriptionItem::getDeleteMark, DeleteMark.NODELETE.getCode()) ; List wfTextbookSubscriptionItemList = wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.selectList(queryWrapper); if (wfTextbookSubscriptionItemList.isEmpty()) { return null; } Map itemByIdMap = new HashMap<>(); for (WfTextbookSubscriptionItem el : wfTextbookSubscriptionItemList) { itemByIdMap.put(el.getId(), el); } Map itemByIssnMap = new HashMap<>(); for (WfTextbookSubscriptionItem el : wfTextbookSubscriptionItemList) { itemByIssnMap.put(el.getIssn(), el); } Date now = new Date(); Long loginId = StpUtil.getLoginIdAsLong(); // for (TextbookInstockroomDto dto : dtos) { // WfTextbookSubscriptionItem old; // if(dto.getTextbookSubscriptionItemId() != null && dto.getTextbookSubscriptionItemId() > 0){ // old = itemByIdMap.get(dto.getTextbookSubscriptionItemId()); // } else { // old = itemByIssnMap.get(dto.getIssn()); // } // // if(old == null){ // continue; // } // // WfTextbookSubscriptionItem updateItem = new WfTextbookSubscriptionItem(); // updateItem.setId(old.getId()); // updateItem.setInStockroomNum(old.getInStockroomNum() + dto.getInNum()); // updateItem.setModifyDate(now); // updateItem.setModifyUserId(loginId); // wfTextbookSubscriptionWfTextbookSubscriptionItemMapper.updateById(updateItem); // // //新增入库记录 //// textbookService.deliverWarehouse(new AddTextbookWarehouseRecordDto() {{ //// setTextbookId(old.getTextbookId()); //// setWarehouseNumber(dto.getInNum()); //// setSource("wm_manual"); //// }}); //// successNum++; // instockroomNum += dto.getInNum(); // } result.put("allNum", dtos.size()); result.put("successNum", successNum); result.put("instockroomNum", instockroomNum); return result; } }