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.map.MapUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.extra.pinyin.PinyinUtil;
import cn.hutool.extra.spring.SpringUtil;
import com.alibaba.fastjson.JSONObject;
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.util.BXApiUtil;
import com.ibeetl.jlw.util.BxJDBCUtil;
import com.ibeetl.jlw.util.HttpJsonRequest;
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 javax.validation.constraints.NotNull;
import java.util.*;
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 && orgId != 1) {
            query.setOrgId(orgId);
        }
        return getFirst(getValuesByQueryNotWithPermission(query));
    }


    public SchoolClass getByNameAndCollegeIdAndMajorId(String name,Long majorId,Long collegeId, Long orgId) {
        SchoolClassQuery query = new SchoolClassQuery();
//        query.setClassStatus(1);
        query.setClassName(name.trim());
        query.setUniversitySystemId(majorId);
        query.setUniversityFacultyId(collegeId);
        if (orgId != null && orgId != 1) {
            query.setOrgId(orgId);
        }
        return getFirst(getValuesByQueryNotWithPermission(query));
    }

    public SchoolClass getByOldId(Long oldClassId){
        SchoolClassQuery query = new SchoolClassQuery();
        query.setOldClassId(oldClassId);
        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查询院校信息
        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(buildClassSnEnsureUnique(universitiesColleges, name));
        insertSchoolClass.setClassStatus(1);
        insertSchoolClass.setAddTime(new Date());
        insertSchoolClass.setOrgId(orgId);
        insertSchoolClass.setUserId(userId);
        Integer icibtClassId = BXApiUtil.createBxClass(insertSchoolClass.getClassName(), universitiesColleges.getIcibtSchoolId());
        insertSchoolClass.setIcibtClassId(icibtClassId);
        insert(insertSchoolClass);
        SchoolClass s = new SchoolClass();
        s.setClassId(insertSchoolClass.getClassId());
        s.setOldClassId(insertSchoolClass.getClassId()+1500);
        schoolClassDao.updateTemplateById(s);
        insertSchoolClass.setOldClassId(s.getOldClassId());
        return insertSchoolClass;
    }





    /**
     * 构建一个确保全局唯一的班级编号
     *
     * @return
     */
    public String buildClassSnEnsureUnique(@NotNull(message = "院校不能为空！") UniversitiesColleges universitiesColleges, @NotNull(message = "班级名称不能为空！") String className) {

        // 左侧的名称
        String leftName = universitiesColleges != null ? universitiesColleges.getUniversitiesCollegesName() : (RandomUtil.randomInt(6) + "");

        // 初步生成的班级编号
        String classSnBefore = StrUtil.format("{}_{}_{}", leftName, replaceAllByClassNameRule(className), RandomUtil.randomNumbers(6));

        // 中文的部分取拼音首字母
        String classSnPinyin = PinyinUtil.getFirstLetter(classSnBefore, "");

        if (countByClassSn(classSnPinyin) > 0L) {
            return buildClassSnEnsureUnique(universitiesColleges, className);
        }

        return classSnPinyin;
    }

    /**
     * 查询班级编号的数量
     *
     * @param classSn
     * @return
     */
    public long countByClassSn(String classSn) {
        return schoolClassDao.createLambdaQuery().andEq(SchoolClass::getClassSn, classSn)
                .count();
    }

    /**
     * 班级的一些命名规则
     */
    public final static Map<String, String> SCHOOL_CLASS_NAME_RULE = MapUtil.unmodifiable(new HashMap<String, String>() {{
        put("第_?", "NO_");
    }});

    /**
     * 功能描述: <br>
     * 通过规则替换字符串
     *
     * @param name
     * @return {@link String}
     * @Author: lx
     * @Date: 2023/3/23 22:00
     */
    public String replaceAllByClassNameRule(String name) {
        // 暂存name
        String nowName = null;
        for (String key : SCHOOL_CLASS_NAME_RULE.keySet()) {
            nowName = defaultIfBlank(nowName, name).replaceAll(key, SCHOOL_CLASS_NAME_RULE.get(key));
        }
        return nowName;
    }


    public List<Map<String, Object>> findClassByOrgId(Long orgId) {
        return schoolClassDao.getClassesByOrgId(orgId);
    }

    public List<Map<String,Object>> findClassesByTeacherId(Long teacherId){
        return schoolClassDao.findClassesByTeacherId(teacherId);
    }

    public List<Map<String,Object>> getClassesBySchoolId(Long schoolId){
        return schoolClassDao.getClassesBySchoolId(schoolId);
    }

    public List<Map<String,Object>> userClassDalGetClassListById(){
        return schoolClassDao.userClassDalGetClassListById();
    }

    public List<Map<String, Object>> getClassListByMajorId(String majorId) {
        return schoolClassDao.getClassListByMajorId(majorId);
    }

    public SchoolClass getByNameAndMajorId(String name, Long majorId,Long collegeId,Long facultyId) {
        SchoolClassQuery query = new SchoolClassQuery();
        query.setClassName(name);
        query.setUniversitySystemId(majorId);
//        query.setClassStatus(1);
        query.setUniversitiesCollegesId(collegeId);
        query.setUniversityFacultyId(facultyId);
        return getFirst(getValuesByQueryNotWithPermission(query));
    }

    public List<SchoolClass> getAll(){
        return schoolClassDao.all();
    }


    public List<SchoolClass> getClassesByOldSchoolId(Long oldSchoolId){
        return schoolClassDao.getClassesByOldSchoolId(oldSchoolId);
    }

    public List<Map<String,Object>> getClassIdsByZhiyun(Long userId){
        return schoolClassDao.getClassIdsByZhiyun(userId);
    }

    public List<Map<String,Object>> findAllClass(){

        return schoolClassDao.findAllClass();
    }

    public List<Map<String,Object>> getClassIdsByZhiyunAndUserIdIsNull(){
        return schoolClassDao.getClassIdsByZhiyunAndUserIdIsNull();
    }

    public String findClassNameByClassId(Long classId){
        return schoolClassDao.findClassNameByClassId(classId);
    }
}