浪潮对接单点登录:mis管理系统配置修改

zouyu

18 小时以前 75b7a414ef821a07426790cb79c37811ae2f07ac

 src/main/java/com/ruoyi/staff/service/impl/StaffJoinLeaveRecordServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,169 @@
package com.ruoyi.staff.service.impl;


import com.baomidou.mybatisplus.core.metadata.IPage;
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.exception.base.BaseException;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.staff.mapper.StaffJoinLeaveRecordMapper;
import com.ruoyi.staff.mapper.StaffOnJobMapper;
import com.ruoyi.staff.pojo.StaffJoinLeaveRecord;
import com.ruoyi.staff.pojo.StaffOnJob;
import com.ruoyi.staff.service.IStaffJoinLeaveRecordService;
import lombok.AllArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletResponse;
import java.util.*;
import java.util.function.Function;

@Service
@AllArgsConstructor
@Transactional(rollbackFor = Exception.class)
public class StaffJoinLeaveRecordServiceImpl extends ServiceImpl<StaffJoinLeaveRecordMapper, StaffJoinLeaveRecord>  implements IStaffJoinLeaveRecordService {

    private StaffJoinLeaveRecordMapper staffJoinLeaveRecordMapper;
    private StaffOnJobMapper staffOnJobMapper;


    //分页查询
    @Override
    public IPage<StaffJoinLeaveRecord> staffJoinLeaveRecordListPage(Page page, StaffJoinLeaveRecord staffJoinLeaveRecord) {
        return staffJoinLeaveRecordMapper.staffJoinLeaveRecordListPage(page,staffJoinLeaveRecord);
    }

    //导出
    @Override
    public void staffJoinLeaveRecordExport(HttpServletResponse response, StaffJoinLeaveRecord staffJoinLeaveRecord) {
        List<StaffJoinLeaveRecord> staffJoinLeaveRecords =staffJoinLeaveRecordMapper.staffJoinLeaveRecordList(staffJoinLeaveRecord);
        ExcelUtil<StaffJoinLeaveRecord> util = new ExcelUtil<StaffJoinLeaveRecord>(StaffJoinLeaveRecord.class);
        util.exportExcel(response, staffJoinLeaveRecords, staffJoinLeaveRecord.getStaffState()==0?"员工离职":"员工入职"+"导出");
    }

    //新增入职/离职
    @Override
    public int add(StaffJoinLeaveRecord staffJoinLeaveRecord) {
        String[] ignoreProperties = {"id"};//排除id属性
        List<StaffOnJob> staffOnJobs = staffOnJobMapper.selectList(Wrappers.<StaffOnJob>lambdaQuery().eq(StaffOnJob::getStaffNo, staffJoinLeaveRecord.getStaffNo()));
        if (staffJoinLeaveRecord.getStaffState()==1){
            /*入职*/
            //(根据员工编号判断是否已经新增到在职表里面,如果已经有就更新,没有就新增)
            if (staffOnJobs.size()>0){
                StaffOnJob staffOnJob = staffOnJobs.get(0);
                //先比较到期日期,这里选用到期日期最久的
                if (staffJoinLeaveRecord.getContractEndTime().compareTo(staffOnJob.getContractExpireTime())>0) {
                    BeanUtils.copyProperties(staffJoinLeaveRecord,staffOnJob,ignoreProperties);
                    staffOnJobMapper.updateById(staffOnJob);
                }
            }else {
                StaffOnJob staffOnJob = new StaffOnJob();
                BeanUtils.copyProperties(staffJoinLeaveRecord,staffOnJob,ignoreProperties);
                staffOnJob.setContractExpireTime(staffJoinLeaveRecord.getContractEndTime());
                staffOnJobMapper.insert(staffOnJob);
            }
        }else {
            /*离职*/
            //根据员工编号找到对应的数据将状态变更
            if (staffOnJobs.size()>0){
                StaffOnJob staffOnJob = staffOnJobs.get(0);
                staffOnJob.setStaffState(staffJoinLeaveRecord.getStaffState());
                staffOnJobMapper.updateById(staffOnJob);
            }else {
                throw new BaseException("没有找到"+staffJoinLeaveRecord.getStaffNo()+"编号的员工,无法新增离职!!!");
            }
        }
        return staffJoinLeaveRecordMapper.insert(staffJoinLeaveRecord);
    }


    //删除入职/离职
    @Override
    public int delStaffJoinLeaveRecord(List<Integer> ids) {
        List<StaffJoinLeaveRecord> staffJoinLeaveRecords = staffJoinLeaveRecordMapper.selectBatchIds(ids);
        for (StaffJoinLeaveRecord staffJoinLeaveRecord : staffJoinLeaveRecords) {
            //先判断是入职还是离职
            if (staffJoinLeaveRecord.getStaffState()==1){
                /*入职*/
                //如果是入职,需要先根据员工编号判断该员工是否还有其他入职信息
                List<StaffJoinLeaveRecord> joinLeaveRecords = staffJoinLeaveRecordMapper.selectList(Wrappers.<StaffJoinLeaveRecord>lambdaQuery()
                        .eq(StaffJoinLeaveRecord::getStaffState, 1)
                        .eq(StaffJoinLeaveRecord::getStaffNo, staffJoinLeaveRecord.getStaffNo())
                        .ne(StaffJoinLeaveRecord::getId, staffJoinLeaveRecord.getId()));
                if (joinLeaveRecords.size()>0){
                    //还需要判断该员工是否有离职信息
                    List<StaffJoinLeaveRecord> leaveRecords = staffJoinLeaveRecordMapper.selectList(Wrappers.<StaffJoinLeaveRecord>lambdaQuery()
                            .eq(StaffJoinLeaveRecord::getStaffState, 0)
                            .eq(StaffJoinLeaveRecord::getStaffNo, staffJoinLeaveRecord.getStaffNo()));
                    // å¦‚果有那在职表仅做更新不删除,如果没有其他入职信息,那么在职表需同步删除
                    if (leaveRecords.size()>0){
                        //如果有离职信息,判断离职数量和入职数量毕竟,如果入职数量大于离职
                        if (joinLeaveRecords.size()>leaveRecords.size()){
                            //该员工就还是在职
                            //先比较到期日期,这里选用到期日期最久的
                            Optional<StaffJoinLeaveRecord> max = joinLeaveRecords.stream().max(Comparator.comparing(StaffJoinLeaveRecord::getContractEndTime));
                            staffOnJobMapper.update(null,Wrappers.<StaffOnJob>lambdaUpdate()
                                    .eq(StaffOnJob::getStaffNo, staffJoinLeaveRecord.getStaffNo())
                                    .set(StaffOnJob::getContractTerm, max.get().getContractTerm())
                                    .set(StaffOnJob::getContractExpireTime, max.get().getContractEndTime()));
                        }else {
                            //该员工属于离职
                            staffOnJobMapper.update(null,Wrappers.<StaffOnJob>lambdaUpdate()
                                    .eq(StaffOnJob::getStaffNo, staffJoinLeaveRecord.getStaffNo())
                                    .set(StaffOnJob::getStaffState, 0));
                        }
                    }else {
                        //如果没有离职信息那么就比较到期日期,这里选用到期日期最久的
                        Optional<StaffJoinLeaveRecord> max = joinLeaveRecords.stream().max(Comparator.comparing(StaffJoinLeaveRecord::getContractEndTime));
                        staffOnJobMapper.update(null,Wrappers.<StaffOnJob>lambdaUpdate()
                                .eq(StaffOnJob::getStaffNo, staffJoinLeaveRecord.getStaffNo())
                                .set(StaffOnJob::getContractTerm, max.get().getContractTerm())
                                .set(StaffOnJob::getContractExpireTime, max.get().getContractEndTime()));
                    }
                }else {
                    staffOnJobMapper.delete(Wrappers.<StaffOnJob>lambdaQuery().eq(StaffOnJob::getStaffNo,staffJoinLeaveRecord.getStaffNo()));
                }
            }else {
                /*离职*/
                //先查询在职表是否有这个,如果有,就将该员工的状态变更为在职
                List<StaffOnJob> staffOnJobs = staffOnJobMapper.selectList(Wrappers.<StaffOnJob>lambdaQuery().eq(StaffOnJob::getStaffNo, staffJoinLeaveRecord.getStaffNo()));
                if (staffOnJobs.size()>0){
                    StaffOnJob staffOnJob = staffOnJobs.get(0);
                    staffOnJob.setStaffState(1);
                    staffOnJobMapper.updateById(staffOnJob);
                }else {
                    throw new BaseException("没有找到"+staffJoinLeaveRecord.getStaffNo()+"编号的员工,请检查是否有脏数据!!!");
                }
            }
            staffJoinLeaveRecordMapper.deleteById(staffJoinLeaveRecord);
        }
        return 0;
    }

    //修改入职/离职
    @Override
    public int updateStaffJoinLeaveRecord(StaffJoinLeaveRecord staffJoinLeaveRecord) {
        String[] ignoreProperties = {"id"};//排除id属性
        List<StaffOnJob> staffOnJobs = staffOnJobMapper.selectList(Wrappers.<StaffOnJob>lambdaQuery().eq(StaffOnJob::getStaffNo, staffJoinLeaveRecord.getStaffNo()));
        if (staffJoinLeaveRecord.getStaffState()==1){
            /*入职*/
            StaffOnJob job = staffOnJobMapper.selectList(Wrappers.<StaffOnJob>lambdaQuery()
                    .eq(StaffOnJob::getStaffNo, staffJoinLeaveRecord.getStaffNo())).get(0);
            //如果更改的合同到期时间更久则更新,如果没有就不用更新
            if (staffJoinLeaveRecord.getContractEndTime().compareTo(job.getContractExpireTime())>0) {
                BeanUtils.copyProperties(staffJoinLeaveRecord,job,ignoreProperties);
                staffOnJobMapper.updateById(job);
            }
        }else {
            /*离职*/
            //离职的编辑不会影响在职表
        }
        return staffJoinLeaveRecordMapper.updateById(staffJoinLeaveRecord);
    }
}