dianshang-houduan/src/main/java/com/sztzjy/linkCommerce/service/impl/UserInfoServiceImpl.java

package com.sztzjy.linkCommerce.service.impl;

import cn.hutool.core.lang.UUID;
import cn.hutool.core.util.IdUtil;
import com.sztzjy.linkCommerce.entity.*;
import com.sztzjy.linkCommerce.mapper.*;

import com.sztzjy.linkCommerce.service.UserInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.math.BigDecimal;
import java.util.*;


@Service
public class UserInfoServiceImpl implements UserInfoService {
    @Autowired
    UserinfoMapper userInfoMapper;
    @Autowired
    SchoolMapper schoolMapper;
    @Autowired
    SchoolFacultyMapper schoolFacultyMapper;
    @Autowired
    SchoolMajorMapper schoolMajorMapper;
    @Autowired
    SchoolClassMapper schoolClassMapper;

    @Override
    public boolean existsByUserName(String userName) {
        UserinfoExample userInfoExample = new UserinfoExample();
        userInfoExample.createCriteria().andUsernameEqualTo(userName);
        List<Userinfo> userInfos = userInfoMapper.selectByExample(userInfoExample);
        if(userInfos.isEmpty() || userInfos==null){
            return false;
        }else {
            return true;
        }
    }


    //根据学校ID查询该学校下的班级名
    @Override
    public List<String> getClassNameList(String userId) {
        Userinfo userinfo = userInfoMapper.selectByPrimaryKey(userId);
        String schoolMajorId = userinfo.getSchoolMajorId();
        SchoolClassExample schoolClassExample = new SchoolClassExample();
        schoolClassExample.createCriteria().andSchoolMajorIdEqualTo(schoolMajorId);
        List<SchoolClass> schoolClasses = schoolClassMapper.selectByExample(schoolClassExample);
        List<String> list=new ArrayList<>();
        for (int i = 0; i < schoolClasses.size(); i++) {
            list.add(schoolClasses.get(i).getClassName());
        }
        return list;
    }

    /**
        * 同步智云
        * @param zyUserInfoList
        * @return
    */

    @Override
    public String insertAllByAuto(List<ZYUserInfo> zyUserInfoList) {
        List<Userinfo> users = new ArrayList<>();

        // 用于存储已处理的学校、学院、专业、班级信息，避免重复插入
        Set<String> processedSchools = new HashSet<>();
        Set<String> processedFaculties = new HashSet<>();
        Set<String> processedMajors = new HashSet<>();
        Set<String> processedClasses = new HashSet<>();

        // 存储学院和专业的映射关系
        Map<String, String> facultyIdMap = new HashMap<>(); // collegeName -> facultyId
        Map<String, String> majorIdMap = new HashMap<>();   // majorName -> majorId

        for (int i = 0; i < zyUserInfoList.size(); i++) {
            ZYUserInfo zyUserInfo = zyUserInfoList.get(i);
            String username = zyUserInfo.getUsername();
            String name = zyUserInfo.getName();
            String password = zyUserInfo.getPassword();
            Integer roleId = zyUserInfo.getRoleId();

            // 检查用户是否已存在
            UserinfoExample userInfoExample = new UserinfoExample();
            userInfoExample.createCriteria().andUsernameEqualTo(username);
            List<Userinfo> userInfos = userInfoMapper.selectByExample(userInfoExample);

            if (userInfos.isEmpty() || userInfos == null) {
                // 处理学校信息
                String schoolId = zyUserInfo.getSchoolId().toString();
                if (!processedSchools.contains(schoolId)) {
                    // 检查数据库中是否已存在该学校
                    School existingSchool = schoolMapper.selectByPrimaryKey(schoolId);
                    if (existingSchool == null) {
                        School school = new School();
                        school.setSchoolId(schoolId);
                        school.setSchoolName(zyUserInfo.getSchoolName());
                        school.setStatus(false);
                        schoolMapper.insertSelective(school);
                    }
                    processedSchools.add(schoolId);
                }

                // 处理学院信息
                String collegeName = zyUserInfo.getCollegeName();
                String facultyId;
                if (!facultyIdMap.containsKey(collegeName)) {
                    facultyId = UUID.randomUUID().toString();
                    facultyIdMap.put(collegeName, facultyId);

                    if (!processedFaculties.contains(collegeName)) {
                        // 检查数据库中是否已存在该学院（通过学校ID和学院名称）
                        SchoolFacultyExample facultyExample = new SchoolFacultyExample();
                        facultyExample.createCriteria()
                                .andSchoolIdEqualTo(schoolId)
                                .andSchoolFacultyNameEqualTo(collegeName);
                        List<SchoolFaculty> existingFaculties = schoolFacultyMapper.selectByExample(facultyExample);

                        if (existingFaculties.isEmpty()) {
                            SchoolFaculty schoolFaculty = new SchoolFaculty();
                            schoolFaculty.setSchoolId(schoolId);
                            schoolFaculty.setSchoolFacultyId(facultyId);
                            schoolFaculty.setSchoolFacultyName(collegeName);
                            schoolFacultyMapper.insertSelective(schoolFaculty);
                        } else {
                            // 如果学院已存在，使用现有的学院ID
                            facultyId = existingFaculties.get(0).getSchoolFacultyId();
                            facultyIdMap.put(collegeName, facultyId);
                        }
                        processedFaculties.add(collegeName);
                    }
                } else {
                    facultyId = facultyIdMap.get(collegeName);
                }

                // 处理专业信息
                String majorName = zyUserInfo.getMajorName();
                String majorId;
                String majorKey = collegeName + "_" + majorName; // 组合键，因为不同学院可能有同名专业
                if (!majorIdMap.containsKey(majorKey)) {
                    majorId = UUID.randomUUID().toString();
                    majorIdMap.put(majorKey, majorId);

                    if (!processedMajors.contains(majorKey)) {
                        // 检查数据库中是否已存在该专业（通过学院ID和专业名称）
                        SchoolMajorExample majorExample = new SchoolMajorExample();
                        majorExample.createCriteria()
                                .andSchoolFacultyIdEqualTo(facultyId)
                                .andSchoolMajorNameEqualTo(majorName);
                        List<SchoolMajor> existingMajors = schoolMajorMapper.selectByExample(majorExample);

                        if (existingMajors.isEmpty()) {
                            SchoolMajor schoolMajor = new SchoolMajor();
                            schoolMajor.setSchoolFacultyId(facultyId);
                            schoolMajor.setSchoolMajorId(majorId);
                            schoolMajor.setSchoolMajorName(majorName);
                            schoolMajorMapper.insertSelective(schoolMajor);
                        } else {
                            // 如果专业已存在，使用现有的专业ID
                            majorId = existingMajors.get(0).getSchoolMajorId();
                            majorIdMap.put(majorKey, majorId);
                        }
                        processedMajors.add(majorKey);
                    }
                } else {
                    majorId = majorIdMap.get(majorKey);
                }

                // 处理班级信息
                String classId = zyUserInfo.getClassId().toString();
                String className = zyUserInfo.getClassName();
                if (!processedClasses.contains(classId)) {
                    // 检查数据库中是否已存在该班级
                    SchoolClass existingClass = schoolClassMapper.selectByPrimaryKey(classId);
                    if (existingClass == null) {
                        SchoolClass schoolClass = new SchoolClass();
                        schoolClass.setSchoolClassId(classId);
                        schoolClass.setSchoolMajorId(majorId);
                        schoolClass.setClassName(className);
                        schoolClassMapper.insertSelective(schoolClass);
                    }
                    processedClasses.add(classId);
                }

                // 创建用户信息
                Userinfo stuUser = new Userinfo();
                stuUser.setUserId(IdUtil.randomUUID());
                stuUser.setUsername(username);
                if (!StringUtils.hasText(name)) {
                    stuUser.setName(username);
                } else {
                    stuUser.setName(name);
                }
                stuUser.setPassword(password);
                stuUser.setRole(roleId);
                stuUser.setSchoolClassId(classId);
                stuUser.setPhone(zyUserInfo.getPhone());
                stuUser.setClassName(className);
                stuUser.setDisabledstatus(false);
                stuUser.setSchoolId(schoolId);
                stuUser.setSchoolName(zyUserInfo.getSchoolName());
                stuUser.setCodeFrom("智云同步");
                stuUser.setSchoolFacultyId(facultyId);
                stuUser.setSchoolMajorId(majorId);

                users.add(stuUser);
            }
        }

        if (users.isEmpty()) {
            return "账号已全部存在";
        }

        // 批量插入用户数据
        users.forEach(stuUser -> {
            userInfoMapper.insertSelective(stuUser);
        });

        return "自动同步学生信息成功！" + "同步" + users.size() + "条用户数据";
    }


}