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

package com.sztzjy.linkCommerce.service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.sztzjy.linkCommerce.entity.*;
import com.sztzjy.linkCommerce.entity.dto.SchoolClassDto;
import com.sztzjy.linkCommerce.entity.dto.SchoolFacultyDto;
import com.sztzjy.linkCommerce.entity.dto.SchoolMajorDto;
import com.sztzjy.linkCommerce.mapper.SchoolClassMapper;
import com.sztzjy.linkCommerce.mapper.SchoolFacultyMapper;
import com.sztzjy.linkCommerce.mapper.SchoolMajorMapper;
import com.sztzjy.linkCommerce.mapper.SchoolMapper;
import com.sztzjy.linkCommerce.mapper.UserinfoMapper;
import com.sztzjy.linkCommerce.service.SchoolService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


import java.util.Date;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;

@Service
public class SchoolServiceImpl implements SchoolService {
    @Autowired
    SchoolMapper schoolMapper;
    @Autowired
    SchoolFacultyMapper schoolFacultyMapper;
    @Autowired
    SchoolMajorMapper schoolMajorMapper;
    @Autowired
    SchoolClassMapper schoolClassMapper;
    @Autowired
    UserinfoMapper userinfoMapper;

    @Override
    public Integer addSchool(School school) {
        //新增院校
        String schoolId = UUID.randomUUID().toString();
        school.setCreateTime(new Date());
        school.setSchoolId(schoolId);
        int insert = schoolMapper.insert(school);
        return insert;
    }

    @Override
    public Integer updateSchool(School school) {
        int i = schoolMapper.updateByPrimaryKey(school);
        return i;
    }

    @Override
    public Integer deleteSchool(String schoolId) {
        int i = schoolMapper.deleteByPrimaryKey(schoolId);
        return i;
    }

    @Override
    public PageInfo<SchoolFacultyDto> seleteSchoolFaculty(Integer index, Integer size, String schoolId, String schoolFacultyName) {
        PageHelper.startPage(index, size);

        // 查询院系信息，假设您有相应的 DAO 或 Mapper 可以用来执行查询
        SchoolFacultyExample schoolFacultyExample = new SchoolFacultyExample();
        SchoolFacultyExample.Criteria criteria = schoolFacultyExample.createCriteria();
        if (schoolId != null) {
            criteria.andSchoolIdEqualTo(schoolId);
        }
        if (schoolFacultyName != null) {
            criteria.andSchoolFacultyNameLike("%" + schoolFacultyName + "%");
        }
        List<SchoolFaculty> schoolFaculties = schoolFacultyMapper.selectByExample(schoolFacultyExample);

        // 基于分页查询结果读取真实总数/页数，映射出的 DTO 列表最后再替换进去；
        // 直接包装 DTO 列表会把 total 错算成当页条数
        PageInfo<SchoolFaculty> sourcePage = new PageInfo<>(schoolFaculties);

        // 将院系信息转换为 DTO
        List<SchoolFacultyDto> dtoList = schoolFaculties.stream()
                .map(schoolFaculty -> {
                    SchoolFacultyDto dto = new SchoolFacultyDto();
                    dto.setSchoolFaculty(schoolFaculty);
                    // 设置信息学校名称，假设在 schoolFaculty 对象中有 school_id，您可以通过服务获取学校名称
                    String schoolName = schoolMapper.selectSchoolNameById(schoolFaculty.getSchoolId());
                    dto.setSchoolName(schoolName);
                    return dto;
                })
                .collect(Collectors.toList());

        PageInfo<SchoolFacultyDto> pageInfo = new PageInfo<>();
        pageInfo.setTotal(sourcePage.getTotal());
        pageInfo.setPageNum(sourcePage.getPageNum());
        pageInfo.setPageSize(sourcePage.getPageSize());
        pageInfo.setPages(sourcePage.getPages());
        pageInfo.setList(dtoList);
        return pageInfo;
    }

    @Override
    public PageInfo<SchoolMajorDto> seleteSchoolMajor(Integer index, Integer size, String schoolId, String schoolMajorName, String schoolFacultyId) {
        // 使用 PageHelper 进行分页
        PageHelper.startPage(index, size);
        // 调用 Mapper 查询数据
        List<SchoolMajorDto> schoolMajorList = schoolMajorMapper.findSchoolMajorList(schoolId,schoolMajorName, schoolFacultyId);
        // 返回分页结果
        return new PageInfo<>(schoolMajorList);
    }

    @Override
    public PageInfo<SchoolClassDto> seleteSchoolClass(Integer index, Integer size, String schoolId, String className, String classSn, String schoolMajorId) {
        return seleteSchoolClass(index, size, schoolId, className, classSn, schoolMajorId, null, null);
    }

    @Override
    public PageInfo<SchoolClassDto> seleteSchoolClass(Integer index, Integer size, String schoolId, String className,
                                                       String classSn, String schoolMajorId, String createdBy, String classType) {
        PageHelper.startPage(index, size);

        // 查询院系信息，假设您有相应的 DAO 或 Mapper 可以用来执行查询
        SchoolClassExample schoolClassExample = new SchoolClassExample();
        SchoolClassExample.Criteria criteria = schoolClassExample.createCriteria();
        criteria.andSchoolIdEqualTo(schoolId);
        if (StringUtils.isNotBlank(className)) {
            criteria.andClassNameLike("%" + className + "%");
        }
        if (StringUtils.isNotBlank(classSn)) {
            criteria.andClassSnEqualTo(classSn);
        }
        if (StringUtils.isNotBlank(schoolMajorId)) {
            criteria.andSchoolMajorIdEqualTo(schoolMajorId);
        }
        if (StringUtils.isNotBlank(createdBy)) {
            criteria.andCreatedByEqualTo(createdBy);
        }
        if (StringUtils.isNotBlank(classType)) {
            criteria.andClassTypeEqualTo(classType);
        }
        List<SchoolClass> schoolClasses = schoolClassMapper.selectByExample(schoolClassExample);

        // 基于分页查询结果读取真实总数/页数，映射出的 DTO 列表最后再替换进去；
        // 直接包装 DTO 列表会把 total 错算成当页条数
        PageInfo<SchoolClass> sourcePage = new PageInfo<>(schoolClasses);

        // 将院系信息转换为 DTO
        String schoolName = schoolMapper.selectSchoolNameById(schoolId);
        List<String> schoolMajorIds = schoolClasses.stream()
                .map(SchoolClass::getSchoolMajorId)
                .filter(StringUtils::isNotBlank)
                .distinct()
                .collect(Collectors.toList());
        List<SchoolMajor> schoolMajors;
        if (schoolMajorIds.isEmpty()) {
            schoolMajors = Collections.emptyList();
        } else {
            SchoolMajorExample schoolMajorExample = new SchoolMajorExample();
            schoolMajorExample.createCriteria().andSchoolMajorIdIn(schoolMajorIds);
            schoolMajors = schoolMajorMapper.selectByExample(schoolMajorExample);
        }
        Map<String, SchoolMajor> schoolMajorMap = schoolMajors.stream()
                .collect(Collectors.toMap(SchoolMajor::getSchoolMajorId, schoolMajor -> schoolMajor, (left, right) -> left));
        List<String> schoolFacultyIds = schoolMajors.stream()
                .map(SchoolMajor::getSchoolFacultyId)
                .filter(StringUtils::isNotBlank)
                .distinct()
                .collect(Collectors.toList());
        List<SchoolFaculty> schoolFaculties;
        if (schoolFacultyIds.isEmpty()) {
            schoolFaculties = Collections.emptyList();
        } else {
            SchoolFacultyExample schoolFacultyExample = new SchoolFacultyExample();
            schoolFacultyExample.createCriteria().andSchoolFacultyIdIn(schoolFacultyIds);
            schoolFaculties = schoolFacultyMapper.selectByExample(schoolFacultyExample);
        }
        Map<String, SchoolFaculty> schoolFacultyMap = schoolFaculties.stream()
                .collect(Collectors.toMap(SchoolFaculty::getSchoolFacultyId, schoolFaculty -> schoolFaculty, (left, right) -> left));
        List<String> createdByIds = schoolClasses.stream()
                .map(SchoolClass::getCreatedBy)
                .filter(StringUtils::isNotBlank)
                .distinct()
                .collect(Collectors.toList());
        List<Userinfo> creators;
        if (createdByIds.isEmpty()) {
            creators = Collections.emptyList();
        } else {
            UserinfoExample userinfoExample = new UserinfoExample();
            userinfoExample.createCriteria().andUserIdIn(createdByIds);
            creators = userinfoMapper.selectByExample(userinfoExample);
        }
        Map<String, Userinfo> creatorMap = creators.stream()
                .collect(Collectors.toMap(Userinfo::getUserId, userinfo -> userinfo, (left, right) -> left));
        List<SchoolClassDto> dtoList = schoolClasses.stream()
                .map(schoolClass -> {
                    SchoolClassDto dto = new SchoolClassDto();
                    dto.setSchoolClass(schoolClass);
                    dto.setSchoolName(schoolName);
                    dto.setSchoolMajorId(schoolClass.getSchoolMajorId());
                    SchoolMajor schoolMajor = schoolMajorMap.get(schoolClass.getSchoolMajorId());
                    if (schoolMajor != null) {
                        dto.setSchoolMajorName(schoolMajor.getSchoolMajorName());
                        dto.setSchoolFacultyId(schoolMajor.getSchoolFacultyId());
                        SchoolFaculty schoolFaculty = schoolFacultyMap.get(schoolMajor.getSchoolFacultyId());
                        if (schoolFaculty != null) {
                            dto.setSchoolFacultyName(schoolFaculty.getSchoolFacultyName());
                        }
                    }
                    Userinfo creator = creatorMap.get(schoolClass.getCreatedBy());
                    if (creator != null) {
                        dto.setCreatedByName(StringUtils.defaultIfBlank(creator.getName(), creator.getUsername()));
                    }
                    return dto;
                })
                .collect(Collectors.toList());

        PageInfo<SchoolClassDto> pageInfo = new PageInfo<>();
        pageInfo.setTotal(sourcePage.getTotal());
        pageInfo.setPageNum(sourcePage.getPageNum());
        pageInfo.setPageSize(sourcePage.getPageSize());
        pageInfo.setPages(sourcePage.getPages());
        pageInfo.setList(dtoList);
        return pageInfo;
    }

    @Override
    public boolean existsBySchoolMajorName(String schoolName, String schoolMajorName, String schoolFacultyName) {
        SchoolExample schoolExample = new SchoolExample();
        schoolExample.createCriteria().andSchoolNameEqualTo(schoolName);
        List<School> schoolList = schoolMapper.selectByExample(schoolExample);
        if (schoolList.isEmpty() || schoolList == null) {
            return false;
        } else {
            School school = schoolList.get(0);
            String schoolId = school.getSchoolId();
            SchoolFacultyExample schoolFacultyExample = new SchoolFacultyExample();
            schoolFacultyExample.createCriteria().andSchoolIdEqualTo(schoolId).andSchoolFacultyNameEqualTo(schoolFacultyName);
            List<SchoolFaculty> schoolFacultyList = schoolFacultyMapper.selectByExample(schoolFacultyExample);
            if (schoolFacultyList.isEmpty() || schoolFacultyList == null) {
                return false;
            } else {
                SchoolFaculty schoolFaculty = schoolFacultyList.get(0);
                String schoolFacultyId = schoolFaculty.getSchoolFacultyId();
                SchoolMajorExample schoolMajorExample = new SchoolMajorExample();
                schoolMajorExample.createCriteria().andSchoolMajorNameEqualTo(schoolMajorName).andSchoolFacultyIdEqualTo(schoolFacultyId);
                List<SchoolMajor> schoolMajorList = schoolMajorMapper.selectByExample(schoolMajorExample);
                if (schoolMajorList.isEmpty() || schoolMajorList == null) {
                    return false;
                } else {
                    return true;
                }
            }
        }
    }

    @Override
    public boolean existsBySchoolClassName(String schoolName, String schoolMajorName, String schoolFacultyName, String schoolClassName) {
        SchoolExample schoolExample = new SchoolExample();
        schoolExample.createCriteria().andSchoolNameEqualTo(schoolName);
        List<School> schoolList = schoolMapper.selectByExample(schoolExample);
        if (schoolList.isEmpty() || schoolList == null) {
            return false;
        } else {
            School school = schoolList.get(0);
            String schoolId = school.getSchoolId();
            SchoolFacultyExample schoolFacultyExample = new SchoolFacultyExample();
            schoolFacultyExample.createCriteria().andSchoolIdEqualTo(schoolId).andSchoolFacultyNameEqualTo(schoolFacultyName);
            List<SchoolFaculty> schoolFacultyList = schoolFacultyMapper.selectByExample(schoolFacultyExample);
            if (schoolFacultyList.isEmpty() || schoolFacultyList == null) {
                return false;
            } else {
                SchoolFaculty schoolFaculty = schoolFacultyList.get(0);
                String schoolFacultyId = schoolFaculty.getSchoolFacultyId();
                SchoolMajorExample schoolMajorExample = new SchoolMajorExample();
                schoolMajorExample.createCriteria().andSchoolMajorNameEqualTo(schoolMajorName).andSchoolFacultyIdEqualTo(schoolFacultyId);
                List<SchoolMajor> schoolMajorList = schoolMajorMapper.selectByExample(schoolMajorExample);
                if (schoolMajorList.isEmpty() || schoolMajorList == null) {
                    return false;
                } else {
                    SchoolMajor schoolMajor = schoolMajorList.get(0);
                    String schoolMajorId = schoolMajor.getSchoolMajorId();
                    SchoolClassExample schoolClassExample = new SchoolClassExample();
                    schoolClassExample.createCriteria().andClassNameEqualTo(schoolClassName).andSchoolMajorIdEqualTo(schoolMajorId);
                    List<SchoolClass> schoolClasseList = schoolClassMapper.selectByExample(schoolClassExample);
                    if(schoolClasseList.isEmpty() || schoolClasseList==null){
                        return false;
                    }else {
                        return true;
                    }
                }
            }
        }
    }

    //根据学校名称查询学校ID
    @Override
    public String selectSchoolIdBySchoolName(String schoolName) {
        SchoolExample schoolExample = new SchoolExample();
        schoolExample.createCriteria().andSchoolNameEqualTo(schoolName);
        List<School> schoolList = schoolMapper.selectByExample(schoolExample);
        if (schoolList.isEmpty() || schoolList == null) {
            return null;
        } else {
            return schoolList.get(0).getSchoolId();
        }
    }

    //根据学校ID和院系名查询院系ID
    @Override
    public String selectFacultyIdBySchoolIdAndFacultyName(String schoolId, String schoolFacultyName) {
        SchoolFacultyExample schoolFacultyExample = new SchoolFacultyExample();
        schoolFacultyExample.createCriteria().andSchoolIdEqualTo(schoolId).andSchoolFacultyNameEqualTo(schoolFacultyName);
        List<SchoolFaculty> schoolFacultyList = schoolFacultyMapper.selectByExample(schoolFacultyExample);
        if (schoolFacultyList.isEmpty() || schoolFacultyList == null) {
            return null;
        } else {
            return schoolFacultyList.get(0).getSchoolFacultyId();
        }
    }

    //根据院系ID和专业名称查询专业ID
    @Override
    public String selectMajorIdByFacultyIdAndMajorName(String schoolFacultyId, String schoolMajorName) {
        SchoolMajorExample schoolMajorExample = new SchoolMajorExample();
        schoolMajorExample.createCriteria().andSchoolMajorNameEqualTo(schoolMajorName).andSchoolFacultyIdEqualTo(schoolFacultyId);
        List<SchoolMajor> schoolMajorList = schoolMajorMapper.selectByExample(schoolMajorExample);
        if (schoolMajorList.isEmpty() || schoolMajorList == null) {
            return null;
        } else {
            return schoolMajorList.get(0).getSchoolMajorId();
        }
    }

    @Override
    public String selectClassIdByClassName(String schoolClassName, String schoolId) {
        SchoolClassExample schoolClassExample = new SchoolClassExample();
        schoolClassExample.createCriteria().andSchoolIdEqualTo(schoolId).andClassNameEqualTo(schoolClassName);
        List<SchoolClass> schoolClassList = schoolClassMapper.selectByExample(schoolClassExample);
        if(schoolClassList.isEmpty() || schoolClassList==null){
            return null;
        }else {
            return schoolClassList.get(0).getSchoolClassId();
        }
    }


}