tianze-pro/web/src/main/java/com/ibeetl/jlw/service/SchoolClassService.java

package com.ibeetl.jlw.service;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.extra.spring.SpringUtil;
import com.ibeetl.admin.core.service.CoreBaseService;
import com.ibeetl.admin.core.util.PlatformException;
import com.ibeetl.jlw.dao.SchoolClassDao;
import com.ibeetl.jlw.entity.SchoolClass;
import com.ibeetl.jlw.entity.UniversitiesColleges;
import com.ibeetl.jlw.web.query.SchoolClassQuery;
import org.beetl.sql.core.SqlId;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.core.query.interfacer.StrongValue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

import static cn.hutool.core.collection.CollUtil.getFirst;
import static cn.hutool.core.util.ObjectUtil.defaultIfBlank;
import static com.ibeetl.admin.core.util.ListUtils.getDuplicateElements;


/**
 * SchoolClass Service
 */

@Service
@Transactional
public class SchoolClassService extends CoreBaseService<SchoolClass>{

    @Autowired private SchoolClassDao schoolClassDao;
    @Autowired
    @Lazy
    private UniversitiesCollegesService universitiesCollegesService;

    public PageQuery<SchoolClass>queryByCondition(PageQuery query){
        PageQuery ret =  schoolClassDao.queryByCondition(query);
        queryListAfter(ret.getList());
        return ret;
    }

    public void deleteSchoolClass(String ids){
        try {
            schoolClassDao.deleteSchoolClassByIds(ids);
        } catch (Exception e) {
            throw new PlatformException("批量删除SchoolClass失败", e);
        }
    }

    public List<SchoolClass> getValues (Object paras){
        return sqlManager.select(SqlId.of("jlw.schoolClass.getSchoolClassValues"),SchoolClass.class,paras);
    }

    public List<SchoolClass> getValuesByQuery (SchoolClassQuery schoolClassQuery){
        return schoolClassDao.getValuesByQuery(schoolClassQuery);
    }
    public List<SchoolClass> getValuesByQueryNotWithPermission (SchoolClassQuery schoolClassQuery){
        return schoolClassDao.getValuesByQueryNotWithPermission(schoolClassQuery);
    }

    /**
     * 获取不重复的班级编号
     * @param prefix    自定义前缀 （非必传）
     * @return
     */
    public String randomClassSn(String prefix) {
        String classSn = defaultIfBlank(prefix, "") + RandomUtil.randomNumbers(6);
        long count = schoolClassDao.createLambdaQuery().andEq(SchoolClass::getClassSn, classSn).count();

        if (count > 0) {
            return randomClassSn(prefix);
        }
        return classSn;
    }

    /**
     * 验证班级编号数据，是否已经存在
     * @param classList
     */
    public void validateClassSnListIsExistsThrow(List<SchoolClass> classList, String orgIds) {
        if (CollectionUtil.isEmpty(classList)) {
            return;
        }
        // 查询所有的班级编号
        List<String> classSnList = classList.stream().map(SchoolClass::getClassSn).collect(Collectors.toList());
        // 获取重复的元素
        List<String> duplicateElements = getDuplicateElements(classSnList);
        // 构建异常信息，传给前端
        String duplicateElementsAsString = CollectionUtil.emptyIfNull(duplicateElements).stream().collect(Collectors.joining(","));
        Assert.isTrue(CollectionUtil.isEmpty(duplicateElements), "本次上传的文件中,存在重复的的班级编号：\"{}\"，请修改后再进行提交！", duplicateElementsAsString);
        // 查询库里已经存在的编号
        List<String> existsList = schoolClassDao.createLambdaQuery()
                .andIsNotNull(SchoolClass::getClassSn)
                .andIn(SchoolClass::getClassSn, classSnList)
                .andIn(SchoolClass::getOrgId, new StrongValue() {
                    @Override
                    public boolean isEffective() {
                        return StrUtil.isNotBlank(orgIds);
                    }

                    @Override
                    public Object getValue() {
                        return Arrays.asList(orgIds.split(","));
                    }
                })
                .andEq(SchoolClass::getClassStatus, 1).select(String.class,"class_sn");
        // 如果存在的话，属于异常数据
        String errorClassSns = CollectionUtil.emptyIfNull(existsList).stream().collect(Collectors.joining(","));
        // 构建异常信息，传给前端
        Assert.isTrue(StrUtil.isBlank(errorClassSns), "已存在的班级编号：\"{}\"，请修改后再进行提交！", errorClassSns);
    }

    /**
     * 没有传递机构ID的验证方法
     * @param classList
     */
    public void validateClassSnListIsExistsThrow(List<SchoolClass> classList) {
        validateClassSnListIsExistsThrow(classList, null);
    }

    /**
     * 查询所有的班级
     *
     * @return 结果
     */
    public static List<String> getAllSchoolClassWithOrgId() {
//        Long currentOrgId = SpringUtil.getBean(CorePlatformService.class).getCurrentOrgId();
        return SpringUtil.getBean(SchoolClassDao.class).getAllSchoolClass(null);
    }

    public SchoolClass getByName(String name, Long orgId) {
        SchoolClassQuery query = new SchoolClassQuery();
        query.setClassStatus(1);
        query.setClassName(name.trim());

        if (orgId != null) {
            query.setOrgId(orgId);
        }
        return getFirst(getValuesByQueryNotWithPermission(query));
    }

    public SchoolClass getByName (String name){
        return getByName(name, null);
    }

    /**
     * 通过名称查询数据，没有查询到的话，则插入数据，并返回给前端这条插入的数据
     * @param name
     * @param orgId
     * @return
     */
    public SchoolClass getByNameOrCreate(String name, Long orgId, Long userId, Long universityFacultyId, Long universitySystemId) {
        SchoolClass schoolClass = getByName(name, orgId);

        if (schoolClass != null) {
            return schoolClass;
        }

        // 根据机构ID查找是否已经创建过的班级，直接取之前的部分数据，作为插入的数据
        SchoolClassQuery schoolClassQuery = new SchoolClassQuery();
        schoolClassQuery.setOrgId(orgId);
        SchoolClass anyOne = getFirst(getValuesByQueryNotWithPermission(schoolClassQuery));

        // 根据名字未查询到数据的话，就插入院系表
        if (anyOne != null) {
            SchoolClass insertSchoolClass = new SchoolClass();
            insertSchoolClass.setUniversitiesCollegesId(anyOne.getUniversitiesCollegesId());
            insertSchoolClass.setUniversityFacultyId(anyOne.getUniversityFacultyId());
            insertSchoolClass.setUniversitySystemId(anyOne.getUniversitySystemId());
            insertSchoolClass.setClassName(name);
            insertSchoolClass.setClassSn(RandomUtil.randomNumbers(6));
            insertSchoolClass.setClassStatus(1);
            insertSchoolClass.setAddTime(new Date());
            insertSchoolClass.setOrgId(orgId);
            insertSchoolClass.setUserId(userId);

            insert(insertSchoolClass);
            return insertSchoolClass;
        }
        // 如果没有老数据，则就按照最简单的数据进行插入，后期再进各个模块修改详细数据
        else {

            // 通过机构ID查询院校信息
            UniversitiesColleges universitiesColleges = universitiesCollegesService.getByOrgId(orgId);

            SchoolClass insertSchoolClass = new SchoolClass();

            if (universitiesColleges != null) {
                insertSchoolClass.setUniversitiesCollegesId(universitiesColleges.getUniversitiesCollegesId());
            }
            insertSchoolClass.setUniversityFacultyId(universityFacultyId);
            insertSchoolClass.setUniversitySystemId(universitySystemId);
            insertSchoolClass.setClassName(name);
            insertSchoolClass.setClassSn(RandomUtil.randomNumbers(6));
            insertSchoolClass.setClassStatus(1);
            insertSchoolClass.setAddTime(new Date());
            insertSchoolClass.setOrgId(orgId);
            insertSchoolClass.setUserId(userId);

            insert(insertSchoolClass);
            return insertSchoolClass;
        }
    }
}