dianshang-houduan/src/main/java/com/sztzjy/linkCommerce/controller/schooladmin/SchoolAdminController.java

package com.sztzjy.linkCommerce.controller.schooladmin;

import com.alibaba.excel.EasyExcel;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.sztzjy.linkCommerce.config.security.JwtUser;
import com.sztzjy.linkCommerce.config.security.TokenProvider;
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.entity.importDto.SchoolAdminStudentImportDTO;
import com.sztzjy.linkCommerce.mapper.*;
import com.sztzjy.linkCommerce.service.SchoolAdminService;
import com.sztzjy.linkCommerce.service.SchoolProductConfigService;
import com.sztzjy.linkCommerce.service.SchoolService;
import com.sztzjy.linkCommerce.service.UserInfoService;
import com.sztzjy.linkCommerce.util.ResultEntity;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.UUID;

@Api(tags = "学校管理员管理")
@RequestMapping("api/school-admin")
@RestController
public class SchoolAdminController {
    @Autowired
    private SchoolAdminService schoolAdminService;
    @Autowired
    private SchoolService schoolService;
    @Autowired
    private UserInfoService userInfoService;
    @Autowired
    private SchoolMapper schoolMapper;
    @Autowired
    private SchoolFacultyMapper schoolFacultyMapper;
    @Autowired
    private SchoolMajorMapper schoolMajorMapper;
    @Autowired
    private SchoolClassMapper schoolClassMapper;
    @Autowired
    private UserinfoMapper userinfoMapper;
    @Autowired
    private TaskAllocationMapper taskAllocationMapper;
    @Autowired
    private SchoolProductConfigService schoolProductConfigService;

    @GetMapping("/school")
    @ApiOperation("学校管理员-当前学校详情")
    public ResultEntity<School> getSchool(HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        School school = schoolMapper.selectByPrimaryKey(schoolId);
        return new ResultEntity<>(HttpStatus.OK, "查询成功", school);
    }

    @PutMapping("/school")
    @ApiOperation("学校管理员-编辑当前学校")
    public ResultEntity updateSchool(@RequestBody School school, HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        school.setSchoolId(schoolId);
        int count = schoolMapper.updateByPrimaryKeySelective(school);
        return writeResult(count, "编辑成功", "编辑失败");
    }

    @GetMapping("/faculties")
    @ApiOperation("学校管理员-院系列表")
    public ResultEntity<PageInfo<SchoolFacultyDto>> listFaculties(@RequestParam Integer index,
                                                                  @RequestParam Integer size,
                                                                  @RequestParam(required = false) String schoolFacultyName,
                                                                  HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireAdministrativeOrganization(schoolId);
        PageInfo<SchoolFacultyDto> pageInfo = schoolService.seleteSchoolFaculty(index, size, schoolId, schoolFacultyName);
        return new ResultEntity<>(HttpStatus.OK, "查询成功", pageInfo);
    }

    @PostMapping("/faculties")
    @ApiOperation("学校管理员-新增院系")
    public ResultEntity addFaculty(@RequestBody SchoolFaculty faculty, HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireAdministrativeOrganization(schoolId);
        if (StringUtils.isBlank(faculty.getSchoolFacultyName())) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "院系名称不能为空");
        }
        faculty.setSchoolFacultyId(UUID.randomUUID().toString());
        faculty.setSchoolId(schoolId);
        faculty.setCreateTime(new Date());
        int count = schoolFacultyMapper.insertSelective(faculty);
        return writeResult(count, "新增成功", "新增失败");
    }

    @PutMapping("/faculties/{id}")
    @ApiOperation("学校管理员-编辑院系")
    public ResultEntity updateFaculty(@PathVariable String id,
                                      @RequestBody SchoolFaculty faculty,
                                      HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireAdministrativeOrganization(schoolId);
        SchoolFaculty existing = requireFaculty(id, schoolId);
        faculty.setSchoolFacultyId(existing.getSchoolFacultyId());
        faculty.setSchoolId(schoolId);
        int count = schoolFacultyMapper.updateByPrimaryKeySelective(faculty);
        return writeResult(count, "编辑成功", "编辑失败");
    }

    @DeleteMapping("/faculties/{id}")
    @ApiOperation("学校管理员-删除院系")
    public ResultEntity deleteFaculty(@PathVariable String id, HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireAdministrativeOrganization(schoolId);
        requireFaculty(id, schoolId);
        if (hasMajorInFaculty(id) || hasUserByFaculty(id)) {
            return new ResultEntity<>(HttpStatus.ACCEPTED, "院系下存在专业或用户，不能删除");
        }
        int count = schoolFacultyMapper.deleteByPrimaryKey(id);
        return writeResult(count, "删除成功", "删除失败");
    }

    @GetMapping("/majors")
    @ApiOperation("学校管理员-专业列表")
    public ResultEntity<PageInfo<SchoolMajorDto>> listMajors(@RequestParam Integer index,
                                                             @RequestParam Integer size,
                                                             @RequestParam(required = false) String schoolMajorName,
                                                             @RequestParam(required = false) String schoolFacultyId,
                                                             HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireAdministrativeOrganization(schoolId);
        if (StringUtils.isNotBlank(schoolFacultyId)) {
            requireFaculty(schoolFacultyId, schoolId);
        }
        PageInfo<SchoolMajorDto> pageInfo = schoolService.seleteSchoolMajor(index, size, schoolId, schoolMajorName, schoolFacultyId);
        return new ResultEntity<>(HttpStatus.OK, "查询成功", pageInfo);
    }

    @PostMapping("/majors")
    @ApiOperation("学校管理员-新增专业")
    public ResultEntity addMajor(@RequestBody SchoolMajor major, HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireAdministrativeOrganization(schoolId);
        if (StringUtils.isBlank(major.getSchoolMajorName())) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "专业名称不能为空");
        }
        requireFaculty(major.getSchoolFacultyId(), schoolId);
        major.setSchoolMajorId(UUID.randomUUID().toString());
        major.setCreateTime(new Date());
        int count = schoolMajorMapper.insertSelective(major);
        return writeResult(count, "新增成功", "新增失败");
    }

    @PutMapping("/majors/{id}")
    @ApiOperation("学校管理员-编辑专业")
    public ResultEntity updateMajor(@PathVariable String id,
                                    @RequestBody SchoolMajor major,
                                    HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireAdministrativeOrganization(schoolId);
        requireMajor(id, schoolId);
        if (StringUtils.isNotBlank(major.getSchoolFacultyId())) {
            requireFaculty(major.getSchoolFacultyId(), schoolId);
        }
        major.setSchoolMajorId(id);
        int count = schoolMajorMapper.updateByPrimaryKeySelective(major);
        return writeResult(count, "编辑成功", "编辑失败");
    }

    @DeleteMapping("/majors/{id}")
    @ApiOperation("学校管理员-删除专业")
    public ResultEntity deleteMajor(@PathVariable String id, HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireAdministrativeOrganization(schoolId);
        requireMajor(id, schoolId);
        if (hasClassInMajor(id) || hasUserByMajor(id)) {
            return new ResultEntity<>(HttpStatus.ACCEPTED, "专业下存在班级或用户，不能删除");
        }
        int count = schoolMajorMapper.deleteByPrimaryKey(id);
        return writeResult(count, "删除成功", "删除失败");
    }

    @GetMapping("/classes")
    @ApiOperation("学校管理员-班级列表")
    public ResultEntity<PageInfo<SchoolClassDto>> listClasses(@RequestParam Integer index,
                                                              @RequestParam Integer size,
                                                              @RequestParam(required = false) String className,
                                                              @RequestParam(required = false) String classSn,
                                                              @RequestParam(required = false) String schoolMajorId,
                                                              HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireAdministrativeOrganization(schoolId);
        if (StringUtils.isNotBlank(schoolMajorId)) {
            requireMajor(schoolMajorId, schoolId);
        }
        PageInfo<SchoolClassDto> pageInfo = schoolService.seleteSchoolClass(index, size, schoolId, className, classSn, schoolMajorId);
        return new ResultEntity<>(HttpStatus.OK, "查询成功", pageInfo);
    }

    @PostMapping("/classes")
    @ApiOperation("学校管理员-新增班级")
    public ResultEntity addClass(@RequestBody SchoolClass schoolClass, HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireAdministrativeOrganization(schoolId);
        if (StringUtils.isBlank(schoolClass.getClassName())) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "班级名称不能为空");
        }
        requireMajor(schoolClass.getSchoolMajorId(), schoolId);
        schoolClass.setSchoolClassId(UUID.randomUUID().toString());
        schoolClass.setSchoolId(schoolId);
        schoolClass.setCreateTime(new Date());
        int count = schoolClassMapper.insertSelective(schoolClass);
        return writeResult(count, "新增成功", "新增失败");
    }

    @PutMapping("/classes/{id}")
    @ApiOperation("学校管理员-编辑班级")
    public ResultEntity updateClass(@PathVariable String id,
                                    @RequestBody SchoolClass schoolClass,
                                    HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireAdministrativeOrganization(schoolId);
        requireClass(id, schoolId);
        if (StringUtils.isNotBlank(schoolClass.getSchoolMajorId())) {
            requireMajor(schoolClass.getSchoolMajorId(), schoolId);
        }
        schoolClass.setSchoolClassId(id);
        schoolClass.setSchoolId(schoolId);
        int count = schoolClassMapper.updateByPrimaryKeySelective(schoolClass);
        return writeResult(count, "编辑成功", "编辑失败");
    }

    @DeleteMapping("/classes/{id}")
    @ApiOperation("学校管理员-删除班级")
    public ResultEntity deleteClass(@PathVariable String id, HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireAdministrativeOrganization(schoolId);
        requireClass(id, schoolId);
        if (hasStudentInClass(id) || hasTaskInClass(id, schoolId)) {
            return new ResultEntity<>(HttpStatus.ACCEPTED, "班级下存在学生或任务，不能删除");
        }
        int count = schoolClassMapper.deleteByPrimaryKey(id);
        return writeResult(count, "删除成功", "删除失败");
    }

    @GetMapping("/teachers")
    @ApiOperation("学校管理员-教师列表")
    public ResultEntity<PageInfo<Userinfo>> listTeachers(@RequestParam Integer index,
                                                         @RequestParam Integer size,
                                                         @RequestParam(required = false) String name,
                                                         @RequestParam(required = false) String username,
                                                         HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        PageInfo<Userinfo> pageInfo = listUsers(index, size, schoolId, 3, name, username, null);
        return new ResultEntity<>(HttpStatus.OK, "查询成功", pageInfo);
    }

    @PostMapping("/teachers")
    @ApiOperation("学校管理员-新增教师")
    public ResultEntity addTeacher(@RequestBody Userinfo teacher, HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        if (StringUtils.isBlank(teacher.getUsername()) || StringUtils.isBlank(teacher.getName())) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "教师姓名和工号不能为空");
        }
        if (userInfoService.existsByUserName(teacher.getUsername())) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "账号已存在");
        }
        teacher.setUserId(UUID.randomUUID().toString());
        if (StringUtils.isBlank(teacher.getPassword())) {
            teacher.setPassword("123qwe");
        }
        teacher.setCreateTime(new Date());
        schoolAdminService.prepareTeacherForSave(teacher, schoolId);
        int count = userinfoMapper.insertSelective(teacher);
        return writeResult(count, "新增成功", "新增失败");
    }

    @PutMapping("/teachers/{id}")
    @ApiOperation("学校管理员-编辑教师")
    public ResultEntity updateTeacher(@PathVariable String id,
                                      @RequestBody Userinfo teacher,
                                      HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireUser(id, schoolId, 3);
        teacher.setUserId(id);
        schoolAdminService.prepareTeacherForSave(teacher, schoolId);
        int count = userinfoMapper.updateByPrimaryKeySelective(teacher);
        return writeResult(count, "编辑成功", "编辑失败");
    }

    @DeleteMapping("/teachers/{id}")
    @ApiOperation("学校管理员-删除教师")
    public ResultEntity deleteTeacher(@PathVariable String id, HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireUser(id, schoolId, 3);
        int count = userinfoMapper.deleteByPrimaryKey(id);
        return writeResult(count, "删除成功", "删除失败");
    }

    @GetMapping("/students")
    @ApiOperation("学校管理员-学生列表")
    public ResultEntity<PageInfo<Userinfo>> listStudents(@RequestParam Integer index,
                                                         @RequestParam Integer size,
                                                         @RequestParam(required = false) String name,
                                                         @RequestParam(required = false) String username,
                                                         @RequestParam(required = false) String schoolClassId,
                                                         HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireAdministrativeOrganization(schoolId);
        if (StringUtils.isNotBlank(schoolClassId)) {
            requireClass(schoolClassId, schoolId);
        }
        PageInfo<Userinfo> pageInfo = listUsers(index, size, schoolId, 4, name, username, schoolClassId);
        return new ResultEntity<>(HttpStatus.OK, "查询成功", pageInfo);
    }

    @PostMapping("/students")
    @ApiOperation("学校管理员-新增学生")
    public ResultEntity addStudent(@RequestBody Userinfo student, HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireAdministrativeOrganization(schoolId);
        if (StringUtils.isBlank(student.getUsername()) || StringUtils.isBlank(student.getName())) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "学生姓名和学号不能为空");
        }
        if (userInfoService.existsByUserName(student.getUsername())) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "账号已存在");
        }
        if (StringUtils.isNotBlank(student.getSchoolClassId())) {
            requireClass(student.getSchoolClassId(), schoolId);
        }
        student.setUserId(UUID.randomUUID().toString());
        if (StringUtils.isBlank(student.getPassword())) {
            student.setPassword("123qwe");
        }
        student.setCreateTime(new Date());
        schoolAdminService.prepareStudentForSave(student, schoolId);
        int count = userinfoMapper.insertSelective(student);
        return writeResult(count, "新增成功", "新增失败");
    }

    @PostMapping("/students/import")
    @ApiOperation("学校管理员-批量导入学生")
    @Transactional(rollbackFor = Exception.class)
    public ResultEntity importStudents(@RequestParam("file") MultipartFile file, HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireAdministrativeOrganization(schoolId);
        ResultEntity fileError = validateImportFile(file);
        if (fileError != null) {
            return fileError;
        }

        try (InputStream inputStream = file.getInputStream()) {
            List<SchoolAdminStudentImportDTO> rows = EasyExcel.read(inputStream)
                    .head(SchoolAdminStudentImportDTO.class)
                    .sheet()
                    .doReadSync();
            List<String> errors = new ArrayList<>();
            List<Userinfo> students = buildImportStudents(rows, schoolId, errors);
            if (!errors.isEmpty()) {
                return new ResultEntity<>(HttpStatus.BAD_REQUEST, "数据校验失败", errors);
            }
            if (students.isEmpty()) {
                return new ResultEntity<>(HttpStatus.BAD_REQUEST, "未读取到可导入的学生数据");
            }

            for (Userinfo student : students) {
                int count = userinfoMapper.insertSelective(student);
                if (count <= 0) {
                    throw new IllegalStateException("导入失败");
                }
            }
            return new ResultEntity<>(HttpStatus.OK, "导入成功，共 " + students.size() + " 条");
        } catch (IllegalArgumentException e) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, e.getMessage());
        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return new ResultEntity<>(HttpStatus.ACCEPTED, "导入失败：" + e.getMessage());
        }
    }

    @PutMapping("/students/{id}")
    @ApiOperation("学校管理员-编辑学生")
    public ResultEntity updateStudent(@PathVariable String id,
                                      @RequestBody Userinfo student,
                                      HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireAdministrativeOrganization(schoolId);
        requireUser(id, schoolId, 4);
        if (StringUtils.isNotBlank(student.getSchoolClassId())) {
            requireClass(student.getSchoolClassId(), schoolId);
        }
        student.setUserId(id);
        schoolAdminService.prepareStudentForSave(student, schoolId);
        int count = userinfoMapper.updateByPrimaryKeySelective(student);
        return writeResult(count, "编辑成功", "编辑失败");
    }

    @DeleteMapping("/students/{id}")
    @ApiOperation("学校管理员-删除学生")
    public ResultEntity deleteStudent(@PathVariable String id, HttpServletRequest request) {
        String schoolId = currentSchoolId(request);
        requireAdministrativeOrganization(schoolId);
        requireUser(id, schoolId, 4);
        int count = userinfoMapper.deleteByPrimaryKey(id);
        return writeResult(count, "删除成功", "删除失败");
    }

    private String currentSchoolId(HttpServletRequest request) {
        JwtUser user = TokenProvider.getJWTUser(request);
        return schoolAdminService.requireSchoolAdmin(user);
    }

    private void requireAdministrativeOrganization(String schoolId) {
        schoolProductConfigService.requireAdminClassEnabled(schoolId);
    }

    private ResultEntity writeResult(int count, String success, String fail) {
        if (count > 0) {
            return new ResultEntity<>(HttpStatus.OK, success);
        }
        return new ResultEntity<>(HttpStatus.ACCEPTED, fail);
    }

    private ResultEntity validateImportFile(MultipartFile file) {
        if (file == null || file.isEmpty()) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "请选择要导入的Excel文件");
        }
        String filename = StringUtils.defaultString(file.getOriginalFilename());
        if (!StringUtils.endsWithIgnoreCase(filename, ".xls") && !StringUtils.endsWithIgnoreCase(filename, ".xlsx")) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "仅支持xls或xlsx格式文件");
        }
        return null;
    }

    private List<Userinfo> buildImportStudents(List<SchoolAdminStudentImportDTO> rows, String schoolId, List<String> errors) {
        List<Userinfo> students = new ArrayList<>();
        Set<String> usernames = new HashSet<>();
        if (rows == null) {
            return students;
        }
        for (int i = 0; i < rows.size(); i++) {
            SchoolAdminStudentImportDTO row = rows.get(i);
            int rowNumber = i + 2;
            if (isBlankImportRow(row)) {
                continue;
            }

            String name = StringUtils.trimToEmpty(row.getName());
            String username = StringUtils.trimToEmpty(row.getUsername());
            String facultyName = StringUtils.trimToEmpty(row.getSchoolFacultyName());
            String majorName = StringUtils.trimToEmpty(row.getSchoolMajorName());
            String className = StringUtils.trimToEmpty(row.getSchoolClassName());
            String sex = normalizeImportSex(row.getSex());

            if (StringUtils.isBlank(name)) {
                errors.add("第 " + rowNumber + " 行：姓名不能为空");
            }
            if (StringUtils.isBlank(username)) {
                errors.add("第 " + rowNumber + " 行：学号不能为空");
            } else if (!usernames.add(username)) {
                errors.add("第 " + rowNumber + " 行：学号在导入文件中重复");
            } else if (userInfoService.existsByUserName(username)) {
                errors.add("第 " + rowNumber + " 行：账号已存在");
            }
            if (StringUtils.isBlank(row.getSex()) || sex != null) {
                // 性别允许为空；填写时仅允许男/女及常见数字写法。
            } else {
                errors.add("第 " + rowNumber + " 行：性别请填写男或女");
            }
            if (StringUtils.isBlank(facultyName)) {
                errors.add("第 " + rowNumber + " 行：所属院系不能为空");
            }
            if (StringUtils.isBlank(majorName)) {
                errors.add("第 " + rowNumber + " 行：所属专业不能为空");
            }
            if (StringUtils.isBlank(className)) {
                errors.add("第 " + rowNumber + " 行：所属班级不能为空");
            }

            SchoolFaculty faculty = StringUtils.isBlank(facultyName) ? null : findFacultyByName(schoolId, facultyName);
            SchoolMajor major = null;
            SchoolClass schoolClass = null;
            if (StringUtils.isNotBlank(facultyName) && faculty == null) {
                errors.add("第 " + rowNumber + " 行：未找到院系“" + facultyName + "”");
            }
            if (faculty != null && StringUtils.isNotBlank(majorName)) {
                major = findMajorByName(faculty.getSchoolFacultyId(), majorName);
                if (major == null) {
                    errors.add("第 " + rowNumber + " 行：院系“" + facultyName + "”下未找到专业“" + majorName + "”");
                }
            }
            if (major != null && StringUtils.isNotBlank(className)) {
                schoolClass = findClassByName(schoolId, major.getSchoolMajorId(), className);
                if (schoolClass == null) {
                    errors.add("第 " + rowNumber + " 行：专业“" + majorName + "”下未找到班级“" + className + "”");
                }
            }

            if (!hasRowError(errors, rowNumber)) {
                Userinfo student = new Userinfo();
                student.setUserId(UUID.randomUUID().toString());
                student.setName(name);
                student.setUsername(username);
                student.setPassword("123qwe");
                student.setSex(sex);
                student.setPhone(StringUtils.trimToEmpty(row.getPhone()));
                student.setEmail(StringUtils.trimToEmpty(row.getEmail()));
                student.setSchoolFacultyId(faculty.getSchoolFacultyId());
                student.setSchoolMajorId(major.getSchoolMajorId());
                student.setSchoolClassId(schoolClass.getSchoolClassId());
                student.setCreateTime(new Date());
                student.setCodeFrom("Excel导入");
                schoolAdminService.prepareStudentForSave(student, schoolId);
                students.add(student);
            }
        }
        return students;
    }

    private boolean isBlankImportRow(SchoolAdminStudentImportDTO row) {
        if (row == null) {
            return true;
        }
        return StringUtils.isBlank(row.getName())
                && StringUtils.isBlank(row.getUsername())
                && StringUtils.isBlank(row.getSex())
                && StringUtils.isBlank(row.getSchoolFacultyName())
                && StringUtils.isBlank(row.getSchoolMajorName())
                && StringUtils.isBlank(row.getSchoolClassName())
                && StringUtils.isBlank(row.getPhone())
                && StringUtils.isBlank(row.getEmail());
    }

    private String normalizeImportSex(String sex) {
        String value = StringUtils.trimToEmpty(sex);
        if (StringUtils.isBlank(value)) {
            return "";
        }
        if ("1".equals(value) || "男".equals(value) || "男性".equals(value)) {
            return "男";
        }
        if ("2".equals(value) || "女".equals(value) || "女性".equals(value)) {
            return "女";
        }
        return null;
    }

    private boolean hasRowError(List<String> errors, int rowNumber) {
        String prefix = "第 " + rowNumber + " 行：";
        for (String error : errors) {
            if (error.startsWith(prefix)) {
                return true;
            }
        }
        return false;
    }

    private SchoolFaculty findFacultyByName(String schoolId, String facultyName) {
        SchoolFacultyExample example = new SchoolFacultyExample();
        example.createCriteria()
                .andSchoolIdEqualTo(schoolId)
                .andSchoolFacultyNameEqualTo(facultyName);
        List<SchoolFaculty> faculties = schoolFacultyMapper.selectByExample(example);
        return faculties.isEmpty() ? null : faculties.get(0);
    }

    private SchoolMajor findMajorByName(String facultyId, String majorName) {
        SchoolMajorExample example = new SchoolMajorExample();
        example.createCriteria()
                .andSchoolFacultyIdEqualTo(facultyId)
                .andSchoolMajorNameEqualTo(majorName);
        List<SchoolMajor> majors = schoolMajorMapper.selectByExample(example);
        return majors.isEmpty() ? null : majors.get(0);
    }

    private SchoolClass findClassByName(String schoolId, String majorId, String className) {
        SchoolClassExample example = new SchoolClassExample();
        example.createCriteria()
                .andSchoolIdEqualTo(schoolId)
                .andSchoolMajorIdEqualTo(majorId)
                .andClassNameEqualTo(className);
        List<SchoolClass> classes = schoolClassMapper.selectByExample(example);
        return classes.isEmpty() ? null : classes.get(0);
    }

    private SchoolFaculty requireFaculty(String facultyId, String schoolId) {
        if (StringUtils.isBlank(facultyId)) {
            throw new IllegalArgumentException("院系ID不能为空");
        }
        SchoolFaculty faculty = schoolFacultyMapper.selectByPrimaryKey(facultyId);
        if (faculty == null || !schoolId.equals(faculty.getSchoolId())) {
            throw new IllegalArgumentException("院系不存在或无权限");
        }
        return faculty;
    }

    private SchoolMajor requireMajor(String majorId, String schoolId) {
        if (StringUtils.isBlank(majorId)) {
            throw new IllegalArgumentException("专业ID不能为空");
        }
        SchoolMajor major = schoolMajorMapper.selectByPrimaryKey(majorId);
        if (major == null) {
            throw new IllegalArgumentException("专业不存在");
        }
        requireFaculty(major.getSchoolFacultyId(), schoolId);
        return major;
    }

    private SchoolClass requireClass(String classId, String schoolId) {
        if (StringUtils.isBlank(classId)) {
            throw new IllegalArgumentException("班级ID不能为空");
        }
        SchoolClass schoolClass = schoolClassMapper.selectByPrimaryKey(classId);
        if (schoolClass == null || !schoolId.equals(schoolClass.getSchoolId())) {
            throw new IllegalArgumentException("班级不存在或无权限");
        }
        return schoolClass;
    }

    private Userinfo requireUser(String userId, String schoolId, int role) {
        Userinfo userinfo = userinfoMapper.selectByPrimaryKey(userId);
        if (userinfo == null || !schoolId.equals(userinfo.getSchoolId()) || userinfo.getRole() == null || userinfo.getRole() != role) {
            throw new IllegalArgumentException("用户不存在或无权限");
        }
        return userinfo;
    }

    private PageInfo<Userinfo> listUsers(Integer index, Integer size, String schoolId, int role, String name, String username, String classId) {
        PageHelper.startPage(index, size);
        UserinfoExample example = new UserinfoExample();
        UserinfoExample.Criteria criteria = example.createCriteria();
        criteria.andSchoolIdEqualTo(schoolId).andRoleEqualTo(role);
        if (StringUtils.isNotBlank(name)) {
            criteria.andNameLike("%" + name + "%");
        }
        if (StringUtils.isNotBlank(username)) {
            criteria.andUsernameLike("%" + username + "%");
        }
        if (StringUtils.isNotBlank(classId)) {
            criteria.andSchoolClassIdEqualTo(classId);
        }
        return new PageInfo<>(userinfoMapper.selectByExample(example));
    }

    private boolean hasMajorInFaculty(String facultyId) {
        SchoolMajorExample example = new SchoolMajorExample();
        example.createCriteria().andSchoolFacultyIdEqualTo(facultyId);
        return schoolMajorMapper.countByExample(example) > 0;
    }

    private boolean hasClassInMajor(String majorId) {
        SchoolClassExample example = new SchoolClassExample();
        example.createCriteria().andSchoolMajorIdEqualTo(majorId);
        return schoolClassMapper.countByExample(example) > 0;
    }

    private boolean hasStudentInClass(String classId) {
        UserinfoExample example = new UserinfoExample();
        example.createCriteria().andSchoolClassIdEqualTo(classId).andRoleEqualTo(4);
        return userinfoMapper.countByExample(example) > 0;
    }

    private boolean hasTaskInClass(String classId, String schoolId) {
        TaskAllocationExample example = new TaskAllocationExample();
        example.createCriteria().andClassIdEqualTo(classId).andSchoolIdEqualTo(schoolId);
        return taskAllocationMapper.countByExample(example) > 0;
    }

    private boolean hasUserByFaculty(String facultyId) {
        UserinfoExample example = new UserinfoExample();
        example.createCriteria().andSchoolFacultyIdEqualTo(facultyId);
        return userinfoMapper.countByExample(example) > 0;
    }

    private boolean hasUserByMajor(String majorId) {
        UserinfoExample example = new UserinfoExample();
        example.createCriteria().andSchoolMajorIdEqualTo(majorId);
        return userinfoMapper.countByExample(example) > 0;
    }
}