dianshang-houduan/src/main/java/com/sztzjy/linkCommerce/controller/stu/UserController.java

package com.sztzjy.linkCommerce.controller.stu;


import com.alibaba.excel.EasyExcel;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.sztzjy.linkCommerce.annotation.AnonymousAccess;
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.StudentImportDTO;
import com.sztzjy.linkCommerce.entity.importDto.TeacherImportDTO;
import com.sztzjy.linkCommerce.mapper.*;
import com.sztzjy.linkCommerce.service.ImportService;
import com.sztzjy.linkCommerce.service.SchoolService;
import com.sztzjy.linkCommerce.service.UserInfoService;
import com.sztzjy.linkCommerce.service.ValidateService;
import com.sztzjy.linkCommerce.util.*;
import com.sztzjy.linkCommerce.util.excel.FilePortUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.util.*;


@Api(tags = "用户管理")
@RequestMapping("api/user")
@RestController
public class UserController {
    @Autowired
    SchoolService schoolService;
    @Autowired
    SchoolMapper schoolMapper;
    @Autowired
    UserinfoMapper userinfoMapper;
    @Autowired
    SchoolMajorMapper schoolMajorMapper;
    @Autowired
    SchoolClassMapper schoolClassMapper;
    @Autowired
    Pinyin4jUtil pinyin4jUtil;
    @Autowired
    UserInfoService userInfoService;
    @Autowired
    ValidateService validateService;
    @Autowired
    ImportService importService;


    @PostMapping("/addSchool")
    @ApiOperation("院校管理-院校新增")
    @AnonymousAccess
    public ResultEntity addSchool(@RequestBody School school) {
        //参数校验
        if (org.apache.commons.lang3.StringUtils.isBlank(school.getSchoolName())) {
            return new ResultEntity<>(HttpStatus.ACCEPTED, "院校名称不能为空");
        }
        if (org.apache.commons.lang3.StringUtils.isBlank(school.getSchoolGrade())) {
            return new ResultEntity<>(HttpStatus.ACCEPTED, "院校层次不能为空");
        }
        if (org.apache.commons.lang3.StringUtils.isBlank(school.getSchoolProvince())) {
            return new ResultEntity<>(HttpStatus.ACCEPTED, "所属省不能为空");
        }
        if (org.apache.commons.lang3.StringUtils.isBlank(school.getSchoolCity())) {
            return new ResultEntity<>(HttpStatus.ACCEPTED, "所属城市不能为空");
        }
        if (org.apache.commons.lang3.StringUtils.isBlank(school.getSchoolContacts())) {
            return new ResultEntity<>(HttpStatus.ACCEPTED, "院校联系人不能为空");
        }
        Integer result = schoolService.addSchool(school);
        if (result > 0) {
            return new ResultEntity<>(HttpStatus.OK, "新增成功");
        } else {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "新增失败");
        }
    }

    @PostMapping("/updateSchool")
    @ApiOperation("院校管理-院校编辑")
    @AnonymousAccess
    public ResultEntity updateSchool(@RequestBody School school) {

        Integer result = schoolService.updateSchool(school);
        if (result > 0) {
            return new ResultEntity<>(HttpStatus.OK, "编辑成功");
        } else {
            return new ResultEntity<>(HttpStatus.ACCEPTED, "编辑失败");
        }
    }

    @GetMapping("/deleteSchool")
    @ApiOperation("院校管理-院校删除")
    public ResultEntity deleteSchool(String schoolId) {

        Integer result = schoolService.deleteSchool(schoolId);
        if (result > 0) {
            return new ResultEntity<>(HttpStatus.OK, "删除成功");
        } else {
            return new ResultEntity<>(HttpStatus.ACCEPTED, "删除失败");
        }
    }

    @GetMapping("/getSchoolList")
    @ApiOperation("院校管理-院校列表查询")
    @AnonymousAccess
    public ResultEntity<PageInfo<School>> getSchoolList(@ApiParam("当前页") Integer index,
                                                        @ApiParam("每页条数") Integer size,
                                                        @ApiParam("院校名称") @RequestParam(required = false) String schoolName) {

        PageHelper.startPage(index, size);
        SchoolExample schoolExample = new SchoolExample();
        SchoolExample.Criteria criteria = schoolExample.createCriteria();

        if (StringUtils.isNotEmpty(schoolName)) {
            criteria.andSchoolNameLike("%" + schoolName + "%");
        }
        List<School> schools = schoolMapper.selectByExample(schoolExample);
        PageInfo<School> schoolPageInfo = new PageInfo<>(schools);
        return new ResultEntity<>(HttpStatus.OK, "院校列表查询-查询成功", schoolPageInfo);
    }


    //*****************************************院系管理*********************************************
    //*****************************************院系管理*********************************************
    //*****************************************院系管理*********************************************
    @Autowired
    SchoolFacultyMapper schoolFacultyMapper;

    @PostMapping("/addSchoolFaculty")
    @ApiOperation("院系管理-添加院系")
    @AnonymousAccess
    public ResultEntity addSchoolFaculty(@ApiParam("学校ID") @RequestParam String schoolId,
                                         @ApiParam("院系名称") @RequestParam String schoolFacultyName,
                                         @ApiParam("联系人") @RequestParam(required = false) String schoolFacultyContact,
                                         @ApiParam("联系人电话") @RequestParam(required = false) String schoolFacultyContactTel,
                                         @ApiParam("联系人地址") @RequestParam(required = false) String schoolFacultyContactAddress) {
        //先根据schoolId进行查询 如果不存在则返回
        School school = schoolMapper.selectByPrimaryKey(schoolId);
        if (school == null) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该学校不存在");
        }
        //查询该学校下院系下 专业名称是否重复
        SchoolFacultyExample schoolFacultyExample = new SchoolFacultyExample();
        schoolFacultyExample.createCriteria().andSchoolIdEqualTo(schoolId).andSchoolFacultyNameEqualTo(schoolFacultyName);
        List<SchoolFaculty> schoolFaculties = schoolFacultyMapper.selectByExample(schoolFacultyExample);
        if (!schoolFaculties.isEmpty()) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "院系名称重复");
        }
        SchoolFaculty schoolFaculty = new SchoolFaculty();
        schoolFaculty.setSchoolFacultyId(String.valueOf(UUID.randomUUID()));
        schoolFaculty.setSchoolId(schoolId);
        schoolFaculty.setSchoolFacultyName(schoolFacultyName);
        schoolFaculty.setSchoolFacultyContact(schoolFacultyContact);
        schoolFaculty.setSchoolFacultyContactTel(schoolFacultyContactTel);
        schoolFaculty.setSchoolFacultyContactAddress(schoolFacultyContactAddress);
        schoolFaculty.setCreateTime(new Date());
        int insert = schoolFacultyMapper.insert(schoolFaculty);
        if (insert == 1) {
            return new ResultEntity<>(HttpStatus.OK, "新增院系成功");
        } else {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "新增院系失败");
        }
    }

    @PostMapping("/seleteSchoolFaculty")
    @ApiOperation("院系管理-查询")
    @AnonymousAccess
    public ResultEntity<PageInfo<SchoolFacultyDto>> seleteSchoolFaculty(@ApiParam("当前页") @RequestParam Integer index,
                                                                        @ApiParam("每页条数") @RequestParam Integer size,
                                                                        @ApiParam("学校ID") @RequestParam(required = false) String schoolId,
                                                                        @ApiParam("院系名称") @RequestParam(required = false) String schoolFacultyName) {
        PageInfo<SchoolFacultyDto> pageInfo = schoolService.seleteSchoolFaculty(index, size, schoolId, schoolFacultyName);
        return new ResultEntity<>(HttpStatus.OK, "院系管理-查询成功", pageInfo);
    }

    @PostMapping("/seleteSchoolFacultyList")
    @ApiOperation("院系管理-院系列表查询")
    @AnonymousAccess
    public ResultEntity<List<SchoolFaculty>> seleteSchoolFacultyList(@ApiParam("学校ID") @RequestParam String schoolId) {
        SchoolFacultyExample schoolFacultyExample = new SchoolFacultyExample();
        schoolFacultyExample.createCriteria().andSchoolIdEqualTo(schoolId);
        List<SchoolFaculty> schoolFacultyList = schoolFacultyMapper.selectByExample(schoolFacultyExample);
        return new ResultEntity<>(HttpStatus.OK, "院系管理-院系列表查询查询", schoolFacultyList);
    }


    @PostMapping("/deleteSchoolFaculty")
    @ApiOperation("院系管理-删除")
    @AnonymousAccess
    public ResultEntity deleteSchoolFaculty(@ApiParam("院系ID") @RequestParam String schoolFacultyId, @RequestParam String userId) {
        //先查询useriD 是否够权限
        Userinfo userInfo = userinfoMapper.selectByPrimaryKey(userId);
        if (userInfo.getRole() == 3) {
            SchoolFaculty schoolFaculty = schoolFacultyMapper.selectByPrimaryKey(schoolFacultyId);
            if (!schoolFaculty.getSchoolId().equals(userInfo.getSchoolId())) {
                return new ResultEntity<>(HttpStatus.BAD_REQUEST, "院系管理-删除失败-权限不足");
            } else {
                int i = schoolFacultyMapper.deleteByPrimaryKey(schoolFacultyId);
                if (i == 1) {
                    return new ResultEntity<>(HttpStatus.OK, "院系管理-删除成功");
                } else {
                    return new ResultEntity<>(HttpStatus.BAD_REQUEST, "院系管理-删除失败");
                }
            }
        }
        if (userInfo.getRole() == 1) {
            int i = schoolFacultyMapper.deleteByPrimaryKey(schoolFacultyId);
            if (i == 1) {
                return new ResultEntity<>(HttpStatus.OK, "院系管理-删除成功");
            } else {
                return new ResultEntity<>(HttpStatus.BAD_REQUEST, "院系管理-删除失败");
            }
        }
        return new ResultEntity<>(HttpStatus.BAD_REQUEST, "院系管理-删除失败-权限不足");
    }

    @PostMapping("/updateSchoolFaculty")
    @ApiOperation("院系管理-编辑")
    @AnonymousAccess
    public ResultEntity updateSchoolFaculty(@RequestBody SchoolFaculty schoolFaculty, @RequestParam String userId) {
        if (StringUtils.isBlank(schoolFaculty.getSchoolFacultyId())) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "院系管理-编辑失败-主键ID缺失");
        }
        //先查询useriD 是否够权限
        Userinfo userInfo = userinfoMapper.selectByPrimaryKey(userId);
        if (userInfo.getRole() == 3) {
            SchoolFaculty schoolFacultyT = schoolFacultyMapper.selectByPrimaryKey(schoolFaculty.getSchoolFacultyId());
            if (!schoolFacultyT.getSchoolId().equals(userInfo.getSchoolId())) {
                return new ResultEntity<>(HttpStatus.BAD_REQUEST, "院系管理-编辑失败-权限不足");
            } else {
                int i = schoolFacultyMapper.updateByPrimaryKey(schoolFaculty);
                if (i == 1) {
                    return new ResultEntity<>(HttpStatus.OK, "院系管理-编辑成功");
                } else {
                    return new ResultEntity<>(HttpStatus.BAD_REQUEST, "院系管理-编辑失败");
                }
            }
        }
        if (userInfo.getRole() == 1) {
            int i = schoolFacultyMapper.updateByPrimaryKey(schoolFaculty);
            if (i == 1) {
                return new ResultEntity<>(HttpStatus.OK, "院系管理-编辑成功");
            } else {
                return new ResultEntity<>(HttpStatus.BAD_REQUEST, "院系管理-编辑失败");
            }
        }
        return new ResultEntity<>(HttpStatus.BAD_REQUEST, "院系管理-编辑失败-权限不足");
    }

    //*****************************************专业管理*********************************************
    //*****************************************专业管理*********************************************
    //*****************************************专业管理*********************************************

    @PostMapping("/addSchoolMajor")
    @ApiOperation("专业管理-添加专业")
    @AnonymousAccess
    public ResultEntity addSchoolMajor(@ApiParam("学校ID") @RequestParam String schoolId,
                                       @ApiParam("院系ID") @RequestParam String schoolFacultyId,
                                       @ApiParam("专业名称") @RequestParam String schoolMajorName,
                                       @ApiParam("联系人") @RequestParam(required = false) String schoolMajorContact,
                                       @ApiParam("联系人电话") @RequestParam(required = false) String schoolMajorContactTel) {
        //先根据schoolId进行查询 如果不存在则返回
        School school = schoolMapper.selectByPrimaryKey(schoolId);
        if (school == null) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该学校不存在");
        }
        //再根据schoolFacultyId查询 如果不存在则返回
        SchoolFaculty schoolFaculty = schoolFacultyMapper.selectByPrimaryKey(schoolFacultyId);
        if (schoolFaculty == null) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该院系不存在");
        }
        //查询该学校下院系下 专业名称是否重复
        SchoolMajorExample schoolMajorExample = new SchoolMajorExample();
        schoolMajorExample.createCriteria().andSchoolFacultyIdEqualTo(schoolFacultyId).andSchoolMajorNameEqualTo(schoolMajorName);
        List<SchoolMajor> schoolMajors = schoolMajorMapper.selectByExample(schoolMajorExample);
        if (!schoolMajors.isEmpty()) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "专业名称重复");
        }
        SchoolMajor schoolMajor = new SchoolMajor();
        schoolMajor.setSchoolMajorId(String.valueOf(UUID.randomUUID()));
        schoolMajor.setSchoolFacultyId(schoolFacultyId);
        schoolMajor.setSchoolMajorName(schoolMajorName);
        schoolMajor.setSchoolMajorContact(schoolMajorContact);
        schoolMajor.setSchoolMajorContactTel(schoolMajorContactTel);
        schoolMajor.setCreateTime(new Date());
        int insert = schoolMajorMapper.insert(schoolMajor);
        if (insert == 1) {
            return new ResultEntity<>(HttpStatus.OK, "新增专业成功");
        } else {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "新增专业失败");
        }
    }

    @PostMapping("/selectSchoolMajor")
    @ApiOperation("专业管理-查询")
    @AnonymousAccess
    public ResultEntity<PageInfo<SchoolMajorDto>> selectSchoolMajor(@ApiParam("当前页") @RequestParam Integer index,
                                                                    @ApiParam("每页条数") @RequestParam Integer size,
                                                                    @ApiParam("学校ID") @RequestParam(required = false) String schoolId,
                                                                    @ApiParam("院系ID-学校管理员使用") @RequestParam(required = false) String schoolFacultyId,
                                                                    @ApiParam("专业名称") @RequestParam(required = false) String schoolMajorName) {
        PageInfo<SchoolMajorDto> pageInfo = schoolService.seleteSchoolMajor(index, size, schoolId, schoolMajorName, schoolFacultyId);
        return new ResultEntity<>(HttpStatus.OK, "专业管理-查询成功", pageInfo);
    }

    @PostMapping("/selectSchoolMajorList")
    @ApiOperation("专业管理-列表查询")
    @AnonymousAccess
    public ResultEntity<List<SchoolMajor>> selectSchoolMajorList(@ApiParam("院系ID") @RequestParam String schoolFacultyId) {
        if (StringUtils.isBlank(schoolFacultyId)) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "院系ID为null");
        }
        SchoolMajorExample schoolMajorExample = new SchoolMajorExample();
        SchoolMajorExample.Criteria criteria = schoolMajorExample.createCriteria();
        criteria.andSchoolFacultyIdEqualTo(schoolFacultyId);
        List<SchoolMajor> schoolMajorList = schoolMajorMapper.selectByExample(schoolMajorExample);
        return new ResultEntity<>(HttpStatus.OK, "专业管理-查询成功", schoolMajorList);
    }

    @PostMapping("/deleteSchoolMajor")
    @ApiOperation("专业管理-删除")
    @AnonymousAccess
    public ResultEntity deleteSchoolMajor(@ApiParam("专业ID") @RequestParam String schoolMajorId, @RequestParam String userId) {
        int i = schoolMajorMapper.deleteByPrimaryKey(schoolMajorId);
        if (i == 1) {
            return new ResultEntity<>(HttpStatus.OK, "专业管理-删除成功");
        } else {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "专业管理-删除失败");
        }
    }


    @PostMapping("/updateSchoolMajor")
    @ApiOperation("专业管理-编辑")
    @AnonymousAccess
    public ResultEntity updateSchoolMajor(@RequestBody SchoolMajor schoolMajor) {
        if (StringUtils.isBlank(schoolMajor.getSchoolMajorId())) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "专业管理-编辑失败-主键ID缺失");
        }
        int i = schoolMajorMapper.updateByPrimaryKey(schoolMajor);
        if (i == 1) {
            return new ResultEntity<>(HttpStatus.OK, "专业管理-编辑成功");
        } else {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "专业管理-编辑失败");
        }
    }

    //*****************************************班级管理*********************************************
    //*****************************************班级管理*********************************************
    //*****************************************班级管理*********************************************


    @PostMapping("/addSchoolClass")
    @ApiOperation("班级管理-添加班级")
    @AnonymousAccess
    public ResultEntity addSchoolClass(@ApiParam("学校ID") @RequestParam String schoolId,
                                       @ApiParam("院系ID") @RequestParam String schoolFacultyId,
                                       @ApiParam("专业ID") @RequestParam String schoolMajorId,
                                       @ApiParam("班级名称") @RequestParam String className) {
        //先根据schoolId进行查询 如果不存在则返回
        School school = schoolMapper.selectByPrimaryKey(schoolId);
        if (school == null) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该学校不存在");
        }
        //再根据schoolFacultyId查询 如果不存在则返回
        SchoolFaculty schoolFaculty = schoolFacultyMapper.selectByPrimaryKey(schoolFacultyId);
        if (schoolFaculty == null) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该院系不存在");
        }
        //再根据schoolMajorId查询 如果不存在则返回
        SchoolMajor schoolMajor = schoolMajorMapper.selectByPrimaryKey(schoolMajorId);
        if (schoolMajor == null) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该专业不存在");
        }
        //查询班级名称是否存在
        SchoolClassExample schoolClassExample = new SchoolClassExample();
        schoolClassExample.createCriteria().andSchoolMajorIdEqualTo(schoolMajorId).andClassNameEqualTo(className);
        List<SchoolClass> schoolClasses = schoolClassMapper.selectByExample(schoolClassExample);
        if (!schoolClasses.isEmpty()) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "班级名称重复");
        }
        SchoolClass schoolClass = new SchoolClass();
        schoolClass.setSchoolClassId(String.valueOf(UUID.randomUUID()));
        schoolClass.setSchoolMajorId(schoolMajorId);
        schoolClass.setClassName(className);
        //设置classSn 先获取学校名称
        String schoolName = school.getSchoolName();
        String schoolNamePY = pinyin4jUtil.convertToPinyin(schoolName);
        String classNamePY = pinyin4jUtil.convertToPinyin(className);
        schoolClass.setClassSn(schoolNamePY + "_" + classNamePY);
        schoolClass.setCreateTime(new Date());
        schoolClass.setSchoolId(schoolId);

        int insert = schoolClassMapper.insert(schoolClass);
        if (insert == 1) {
            return new ResultEntity<>(HttpStatus.OK, "新增班级成功");
        } else {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "新增班级失败");
        }
    }

    @PostMapping("/seleteSchoolClass")
    @ApiOperation("班级管理-查询")
    @AnonymousAccess
    public ResultEntity<PageInfo<SchoolClassDto>> seleteSchoolClass(@ApiParam("当前页") @RequestParam Integer index,
                                                                    @ApiParam("每页条数") @RequestParam Integer size,
                                                                    @ApiParam("学校ID") @RequestParam(required = false) String schoolId,
                                                                    @ApiParam("专业ID-学校管理员使用") @RequestParam(required = false) String schoolMajorId,
                                                                    @ApiParam("班级名称") @RequestParam(required = false) String className,
                                                                    @ApiParam("班级编号") @RequestParam(required = false) String classSn) {
        PageInfo<SchoolClassDto> pageInfo = schoolService.seleteSchoolClass(index, size, schoolId, className, classSn, schoolMajorId);
        return new ResultEntity<>(HttpStatus.OK, "班级管理-查询成功", pageInfo);
    }

    @PostMapping("/seleteSchoolFacultyNameAndMajorName")
    @ApiOperation("班级管理-查询院系名称和专业名称")
    @AnonymousAccess
    public ResultEntity<Map<String, String>> seleteSchoolFacultyNameAndMajorName(@RequestParam String schoolMajorId) {
        SchoolMajor schoolMajor = schoolMajorMapper.selectByPrimaryKey(schoolMajorId);
        String schoolFacultyId = schoolMajor.getSchoolFacultyId();
        SchoolFaculty schoolFaculty = schoolFacultyMapper.selectByPrimaryKey(schoolFacultyId);
        Map<String, String> map = new HashMap<>();
        map.put(schoolFaculty.getSchoolFacultyName(), schoolMajor.getSchoolMajorName());
        return new ResultEntity<>(HttpStatus.OK, "班级管理-院系名称和专业名称查询成功", map);
    }

    @PostMapping("/seleteSchoolClassList")
    @ApiOperation("班级管理-列表查询")
    @AnonymousAccess
    public ResultEntity<List<SchoolClass>> seleteSchoolClassList(@RequestParam String schoolMajorId) {
        SchoolClassExample schoolClassExample = new SchoolClassExample();
        SchoolClassExample.Criteria criteria = schoolClassExample.createCriteria();
        criteria.andSchoolMajorIdEqualTo(schoolMajorId);
        List<SchoolClass> schoolClasses = schoolClassMapper.selectByExample(schoolClassExample);
        return new ResultEntity<>(HttpStatus.OK, "班级管理-列表查询成功", schoolClasses);
    }

    @PostMapping("/seleteSchoolClassListBySchoolId")
    @ApiOperation("班级管理-列表查询通过学校ID")
    @AnonymousAccess
    public ResultEntity<List<SchoolClass>> seleteSchoolClassListBySchoolId(@RequestParam String schoolId) {
        SchoolClassExample schoolClassExample = new SchoolClassExample();
        SchoolClassExample.Criteria criteria = schoolClassExample.createCriteria();
        criteria.andSchoolIdEqualTo(schoolId);
        List<SchoolClass> schoolClasses = schoolClassMapper.selectByExample(schoolClassExample);
        return new ResultEntity<>(HttpStatus.OK, "班级管理-列表查询通过学校ID查询成功", schoolClasses);
    }

    @PostMapping("/deleteSchoolClass")
    @ApiOperation("班级管理-删除")
    @AnonymousAccess
    public ResultEntity deleteSchoolClass(@ApiParam("班级ID") @RequestParam String schoolClassId, @RequestParam String userId) {
        //先查询useriD 是否够权限
        Userinfo userInfo = userinfoMapper.selectByPrimaryKey(userId);
        if (userInfo.getRole() == 1) {
            int i = schoolClassMapper.deleteByPrimaryKey(schoolClassId);
            if (i == 1) {
                return new ResultEntity<>(HttpStatus.OK, "班级管理-删除成功");
            }
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "班级管理-删除失败");
        }
        if (userInfo.getRole() == 3) {
            SchoolClass schoolClass = schoolClassMapper.selectByPrimaryKey(schoolClassId);
            String schoolId = schoolClass.getSchoolId();
            String userInfoSchoolId = userInfo.getSchoolId();
            if (schoolId.equals(userInfoSchoolId)) {
                int i = schoolClassMapper.deleteByPrimaryKey(schoolClassId);
                if (i == 1) {
                    return new ResultEntity<>(HttpStatus.OK, "班级管理-删除成功");
                }
                return new ResultEntity<>(HttpStatus.BAD_REQUEST, "班级管理-删除失败");
            }
        }
        return new ResultEntity<>(HttpStatus.BAD_REQUEST, "班级管理-删除失败-权限不足");
    }


    @PostMapping("/updateSchoolClass")
    @ApiOperation("班级管理-编辑")
    @AnonymousAccess
    public ResultEntity updateSchoolClass(@RequestBody SchoolClass schoolClass, @RequestParam String userId) {
        if (StringUtils.isBlank(schoolClass.getSchoolClassId())) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "班级管理-编辑失败-主键ID缺失");
        }
        //先查询useriD 是否够权限
        Userinfo userInfo = userinfoMapper.selectByPrimaryKey(userId);
        if (userInfo.getRole() == 1) {
            int i = schoolClassMapper.updateByPrimaryKey(schoolClass);
            if (i == 1) {
                return new ResultEntity<>(HttpStatus.OK, "班级管理-编辑成功");
            }
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "班级管理-编辑成功");
        }
        if (userInfo.getRole() == 3) {
            String schoolId = userInfo.getSchoolId();
            SchoolClass schoolClass1 = schoolClassMapper.selectByPrimaryKey(schoolClass.getSchoolClassId());
            if (schoolId.equals(schoolClass1.getSchoolId())) {
                int i = schoolClassMapper.deleteByPrimaryKey(schoolClass.getSchoolClassId());
                if (i == 1) {
                    return new ResultEntity<>(HttpStatus.OK, "班级管理-删除成功");
                }
                return new ResultEntity<>(HttpStatus.BAD_REQUEST, "班级管理-删除失败");
            }
        }
        return new ResultEntity<>(HttpStatus.BAD_REQUEST, "班级管理-编辑失败-权限不足");
    }

    //新增  同步子系统账户
    @PostMapping("/addTeacherAccount")
    @ApiOperation("教师管理-添加教师账号")
    @AnonymousAccess
    public ResultEntity addTeacherAccount(@ApiParam("学校ID") @RequestParam String schoolId,
                                          @ApiParam("学校名称") @RequestParam String schoolName,
                                          @ApiParam("院系ID") @RequestParam String schoolFacultyId,
                                          @ApiParam("专业ID") @RequestParam String schoolMajorId,
                                          @ApiParam("专业名称") @RequestParam String schoolMajorName,
                                          @ApiParam("教师名称") @RequestParam String name,
                                          @ApiParam("教师工号") @RequestParam String userName,
                                          @ApiParam("电话号码") @RequestParam(required = false) String phone,
                                          @ApiParam("电子邮箱") @RequestParam(required = false) String email) {
        //先根据schoolId进行查询 如果不存在则返回
        School school = schoolMapper.selectByPrimaryKey(schoolId);
        if (school == null) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该学校不存在");
        }
        //再根据schoolFacultyId查询 如果不存在则返回
        SchoolFaculty schoolFaculty = schoolFacultyMapper.selectByPrimaryKey(schoolFacultyId);
        if (schoolFaculty == null) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该院系不存在");
        }
        //再根据schoolMajorId查询 如果不存在则返回
        SchoolMajor schoolMajor = schoolMajorMapper.selectByPrimaryKey(schoolMajorId);
        if (schoolMajor == null) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该专业不存在");
        }
        //检查userName是否已经存在
        boolean b = userInfoService.existsByUserName(userName);
        if (b) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "账号已存在");
        }
        Userinfo userInfo = new Userinfo();
        userInfo.setUserId(UUID.randomUUID().toString());
        userInfo.setName(name);
        userInfo.setUsername(userName);
        userInfo.setPassword("123qwe");
        userInfo.setPhone(phone);
        userInfo.setEmail(email);
        userInfo.setCreateTime(new Date());
        userInfo.setRole(3);
        userInfo.setSchoolId(schoolId);
        userInfo.setSchoolFacultyId(schoolFacultyId);
        userInfo.setSchoolMajorId(schoolMajorId);
        userInfo.setSchoolClassId(null);
        userInfo.setCodeFrom("添加");

        int insert = userinfoMapper.insert(userInfo);
        if (insert == 1) {
            return new ResultEntity<>(HttpStatus.OK, "教师管理-添加教师账号成功");
        } else {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "教师管理-添加教师账号失败");
        }
    }

    //分页条件查询
    @PostMapping("/selectTeacher")
    @ApiOperation("教师管理-查询教师账号信息")
    @AnonymousAccess
    public ResultEntity<PageInfo<Userinfo>> selectTeacher(@ApiParam("学校ID") @RequestParam(required = false) String schoolId,
                                                          @ApiParam("教师名称") @RequestParam(required = false) String name,
                                                          @ApiParam("教师工号") @RequestParam(required = false) String userName,
                                                          @RequestParam Integer index,
                                                          @RequestParam Integer size) {
        PageHelper.startPage(index, size);
        UserinfoExample userInfoExample = new UserinfoExample();
        UserinfoExample.Criteria criteria = userInfoExample.createCriteria();
        School school = new School();
        if (StringUtils.isNotBlank(schoolId)) {
            school = schoolMapper.selectByPrimaryKey(schoolId);
            criteria.andSchoolIdEqualTo(schoolId);
        }
        if (StringUtils.isNotBlank(name)) {
            criteria.andNameEqualTo(name);
        }
        if (StringUtils.isNotBlank(userName)) {
            criteria.andUsernameEqualTo(userName);
        }
        criteria.andRoleEqualTo(3);
        List<Userinfo> userInfoList = userinfoMapper.selectByExample(userInfoExample);
        for (int i = 0; i < userInfoList.size(); i++) {
            if (StringUtils.isNotBlank(schoolId)) {
                userInfoList.get(i).setSchoolName(school.getSchoolName());
            } else {
                String schoolId1 = userInfoList.get(i).getSchoolId();
                school = schoolMapper.selectByPrimaryKey(schoolId1);
                userInfoList.get(i).setSchoolName(school.getSchoolName());
            }
        }
        PageInfo<Userinfo> pageInfo = new PageInfo<>(userInfoList);
        return new ResultEntity<>(HttpStatus.OK, "查询教师账号信息成功！", pageInfo);
    }

    //编辑
    @PostMapping("/updateTeacher")
    @ApiOperation("教师管理-编辑教师账号信息")
    @AnonymousAccess
    public ResultEntity updateTeacher(@RequestBody Userinfo userInfo) {
        int i = userinfoMapper.updateByPrimaryKey(userInfo);
        if (i == 1) {
            return new ResultEntity<>(HttpStatus.OK, "编辑教师账号信息成功！");
        }
        return new ResultEntity<>(HttpStatus.BAD_REQUEST, "编辑教师账号信息失败！");
    }

    //初始化密码
    @PostMapping("/updateTeacherPassword")
    @ApiOperation("教师管理-初始化密码")
    @AnonymousAccess
    public ResultEntity updateTeacher(@RequestParam String userId) {
        Userinfo userInfo = userinfoMapper.selectByPrimaryKey(userId);
        userInfo.setPassword("123qwe");
        int i = userinfoMapper.updateByPrimaryKey(userInfo);
        if (i == 1) {
            return new ResultEntity<>(HttpStatus.OK, "初始化密码成功！");
        }
        return new ResultEntity<>(HttpStatus.BAD_REQUEST, "初始化密码失败！");
    }

    //微信绑定 *****

    //删除
    @PostMapping("/deleteTeacher")
    @ApiOperation("教师管理-删除")
    @AnonymousAccess
    public ResultEntity deleteTeacher(@RequestParam String userId) {
        int i = userinfoMapper.deleteByPrimaryKey(userId);
        if (i == 1) {
            return new ResultEntity<>(HttpStatus.OK, "删除成功！");
        }
        return new ResultEntity<>(HttpStatus.BAD_REQUEST, "删除失败！");
    }

    //导入 同步子系统账户
    @PostMapping("/uploadTeacherUserInfo")
    @ApiOperation("教师管理-导入教师账号")
    @AnonymousAccess
    public ResultEntity uploadTeacherUserInfo(@RequestParam MultipartFile file) {
        // 基本校验
        if (file.isEmpty()) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "上传文件不能为空！");
        }

        String originalFilename = file.getOriginalFilename();
        if (!originalFilename.endsWith(".xls") && !originalFilename.endsWith(".xlsx")) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "请上传Excel文件！");
        }
        if (file.getSize() > 10 * 1024 * 1024) { // 10MB限制
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "文件大小不能超过10MB！");
        }

        try (InputStream inputStream = file.getInputStream()) {
            // 解析Excel
            List<TeacherImportDTO> teacherList = EasyExcel.read(inputStream)
                    .head(TeacherImportDTO.class)
                    .sheet()
                    .doReadSync();

            // 数据校验
            List<String> errorMessages = validateService.validateTeacherData(teacherList);
            if (!errorMessages.isEmpty()) {
                return new ResultEntity<>(HttpStatus.BAD_REQUEST, "数据校验失败！", errorMessages);
            }

            // 异步处理导入*****
            importService.processTeacherImport(teacherList);
            return new ResultEntity<>(HttpStatus.OK, "导入成功！");

        } catch (Exception e) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "数据校验失败！", e.getMessage());
        }
    }

    //导出
    @PostMapping("/exportTeacherUserInfo")
    @ApiOperation("教师管理-导出")
    @AnonymousAccess
    public void exportTeacherUserInfo(HttpServletResponse response,
                                      @RequestParam String schoolId) {
        if (StringUtils.isNotBlank(schoolId)) {
            UserinfoExample userInfoExample = new UserinfoExample();
            userInfoExample.createCriteria().andSchoolIdEqualTo(schoolId).andRoleEqualTo(3);
            List<Userinfo> list = userinfoMapper.selectByExample(userInfoExample);
            //导出的表名
            String title = "老师账号汇总";
            //表中第一行表头字段
            String[] headers = {"姓名", "工号", "性别", "手机号", "邮箱"};

            //具体需要写入excel需要哪些字段，这些字段取自UserReward类，也就是上面的实际数据结果集的泛型
            List<String> listColumn = Arrays.asList("name", "username", "sex", "phone", "email");
            try {
                FilePortUtil.exportExcel(response, title, headers, list, listColumn);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    //*****************************************学生管理*********************************************
    //*****************************************学生管理*********************************************
    //*****************************************学生管理*********************************************
    //新增  *****创建资金账户
    @PostMapping("/addStudentAccount")
    @ApiOperation("学生管理-添加学生账号")
    @AnonymousAccess
    public ResultEntity addStudentAccount(@ApiParam("学校ID") @RequestParam String schoolId,
                                          @ApiParam("学校名称") @RequestParam String schoolName,
                                          @ApiParam("院系ID") @RequestParam String schoolFacultyId,
                                          @ApiParam("专业ID") @RequestParam String schoolMajorId,
                                          @ApiParam("专业名称") @RequestParam String schoolMajorName,
                                          @ApiParam("班级名称") @RequestParam String schoolClassName,
                                          @ApiParam("班级Id") @RequestParam String schoolClassId,
                                          @ApiParam("学生姓名") @RequestParam String name,
                                          @ApiParam("学号") @RequestParam String userName,
                                          @ApiParam("电话号码") @RequestParam(required = false) String phone,
                                          @ApiParam("电子邮箱") @RequestParam(required = false) String email) {
        //先根据schoolId进行查询 如果不存在则返回
        School school = schoolMapper.selectByPrimaryKey(schoolId);
        if (school == null) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该学校不存在");
        }
        //再根据schoolFacultyId查询 如果不存在则返回
        SchoolFaculty schoolFaculty = schoolFacultyMapper.selectByPrimaryKey(schoolFacultyId);
        if (schoolFaculty == null) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该院系不存在");
        }
        //再根据schoolMajorId查询 如果不存在则返回
        SchoolMajor schoolMajor = schoolMajorMapper.selectByPrimaryKey(schoolMajorId);
        if (schoolMajor == null) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该专业不存在");
        }
        SchoolClass schoolClass = schoolClassMapper.selectByPrimaryKey(schoolClassId);
        if (schoolClass == null) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该班级不存在");
        }
        //检查userName是否已经存在
        boolean b = userInfoService.existsByUserName(userName);
        if (b) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "账号已存在");
        }
        Userinfo userInfo = new Userinfo();
        userInfo.setUserId(UUID.randomUUID().toString());
        userInfo.setName(name);
        userInfo.setUsername(userName);
        userInfo.setPassword("123qwe");
        userInfo.setPhone(phone);
        userInfo.setEmail(email);
        userInfo.setCreateTime(new Date());
        userInfo.setRole(4);
        userInfo.setSchoolId(schoolId);
        userInfo.setSchoolFacultyId(schoolFacultyId);
        userInfo.setSchoolMajorId(schoolMajorId);
        userInfo.setSchoolClassId(schoolClassId);
        userInfo.setCodeFrom("添加");

        int insert = userinfoMapper.insert(userInfo);
        if (insert == 1) {
            return new ResultEntity<>(HttpStatus.OK, "学生管理-添加学生账号成功");
        } else {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "学生管理-添加学生账号失败");
        }
    }

    //查询
    @PostMapping("/selectStudent")
    @ApiOperation("学生管理-查询学生账号信息")
    @AnonymousAccess
    public ResultEntity<PageInfo<Userinfo>> selectStudent(@ApiParam("学校ID") @RequestParam(required = false) String schoolId,
                                                          @ApiParam("班级ID") @RequestParam(required = false) String schoolClassId,
                                                          @ApiParam("学生姓名") @RequestParam(required = false) String name,
                                                          @ApiParam("学生学号") @RequestParam(required = false) String userName,
                                                          @RequestParam Integer index,
                                                          @RequestParam Integer size) {
        PageHelper.startPage(index, size);
        UserinfoExample userInfoExample = new UserinfoExample();
        UserinfoExample.Criteria criteria = userInfoExample.createCriteria();
        School school = new School();
        SchoolClass schoolClass = new SchoolClass();
        if (StringUtils.isNotBlank(schoolId)) {
            school = schoolMapper.selectByPrimaryKey(schoolId);
            criteria.andSchoolIdEqualTo(schoolId);
        }
        if (StringUtils.isNotBlank(name)) {
            criteria.andNameEqualTo(name);
        }
        if (StringUtils.isNotBlank(userName)) {
            criteria.andUsernameEqualTo(userName);
        }
        if (StringUtils.isNotBlank(schoolClassId)) {
            schoolClass = schoolClassMapper.selectByPrimaryKey(schoolClassId);
            criteria.andSchoolClassIdEqualTo(schoolClassId);
        }
        criteria.andRoleEqualTo(4);
        List<Userinfo> userInfoList = userinfoMapper.selectByExample(userInfoExample);
        for (int i = 0; i < userInfoList.size(); i++) {
            if (StringUtils.isNotBlank(schoolId)) {
                userInfoList.get(i).setSchoolName(school.getSchoolName());
                if (StringUtils.isNotBlank(schoolClassId)) {
                    userInfoList.get(i).setClassName(schoolClass.getClassName());
                } else {
                    String schoolClassId1 = userInfoList.get(i).getSchoolClassId();
                    schoolClass = schoolClassMapper.selectByPrimaryKey(schoolClassId1);
                    userInfoList.get(i).setClassName(schoolClass.getClassName());
                }
            } else {
                String schoolId1 = userInfoList.get(i).getSchoolId();
                school = schoolMapper.selectByPrimaryKey(schoolId1);
                userInfoList.get(i).setSchoolName(school.getSchoolName());
                if (StringUtils.isNotBlank(schoolClassId)) {
                    userInfoList.get(i).setClassName(schoolClass.getClassName());
                } else {
                    String schoolClassId1 = userInfoList.get(i).getSchoolClassId();
                    schoolClass = schoolClassMapper.selectByPrimaryKey(schoolClassId1);
                    userInfoList.get(i).setClassName(schoolClass.getClassName());
                }
            }
        }
        PageInfo<Userinfo> pageInfo = new PageInfo<>(userInfoList);
        return new ResultEntity<>(HttpStatus.OK, "查询学生账号信息成功！", pageInfo);
    }

    //编辑
    @PostMapping("/updateStudent")
    @ApiOperation("学生管理-编辑学生账号信息")
    @AnonymousAccess
    public ResultEntity updateStudent(@RequestBody Userinfo userInfo) {
        int i = userinfoMapper.updateByPrimaryKey(userInfo);
        if (i == 1) {
            return new ResultEntity<>(HttpStatus.OK, "编辑学生账号信息成功！");
        }
        return new ResultEntity<>(HttpStatus.BAD_REQUEST, "编辑学生账号信息失败！");
    }

    //删除
    @PostMapping("/deleteStudent")
    @ApiOperation("学生管理-删除")
    @AnonymousAccess
    public ResultEntity deleteStudent(@RequestParam String userId) {
        int i = userinfoMapper.deleteByPrimaryKey(userId);
        if (i == 1) {
            return new ResultEntity<>(HttpStatus.OK, "删除成功！");
        }
        return new ResultEntity<>(HttpStatus.BAD_REQUEST, "删除失败！");
    }

    //初始化密码
    @PostMapping("/updateStudentPassword")
    @ApiOperation("学生管理-初始化密码")
    @AnonymousAccess
    public ResultEntity updateStudentPassword(@RequestParam String userId) {
        Userinfo userInfo = userinfoMapper.selectByPrimaryKey(userId);
        userInfo.setPassword("123qwe");
        int i = userinfoMapper.updateByPrimaryKey(userInfo);
        if (i == 1) {
            return new ResultEntity<>(HttpStatus.OK, "初始化密码成功！");
        }
        return new ResultEntity<>(HttpStatus.BAD_REQUEST, "初始化密码失败！");
    }

    //微信绑定*****
    //导入 ***** 创建资金账户
    @PostMapping("/uploadStudentUserInfo")
    @ApiOperation("学生管理-导入学生账号")
    @AnonymousAccess
    public ResultEntity uploadStudentUserInfo(@RequestParam MultipartFile file) {
        // 基本校验
        if (file.isEmpty()) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "上传文件不能为空！");
        }

        String originalFilename = file.getOriginalFilename();
        if (!originalFilename.endsWith(".xls") && !originalFilename.endsWith(".xlsx")) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "请上传Excel文件！");
        }
        if (file.getSize() > 10 * 1024 * 1024) { // 10MB限制
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "文件大小不能超过10MB！");
        }

        try (InputStream inputStream = file.getInputStream()) {
            // 解析Excel
            List<StudentImportDTO> studentList = EasyExcel.read(inputStream)
                    .head(StudentImportDTO.class)
                    .sheet()
                    .doReadSync();

            // 数据校验
            List<String> errorMessages = validateService.validateStudentData(studentList);
            if (!errorMessages.isEmpty()) {
                return new ResultEntity<>(HttpStatus.BAD_REQUEST, "数据校验失败！", errorMessages);
            }

            // 异步处理导入*****
            importService.processStudentImport(studentList);
            return new ResultEntity<>(HttpStatus.OK, "导入成功！");

        } catch (Exception e) {
            return new ResultEntity<>(HttpStatus.BAD_REQUEST, "数据校验失败！", e.getMessage());
        }
    }

    //导出
    @PostMapping("/exportStudentUserInfo")
    @ApiOperation("学生管理-导出")
    @AnonymousAccess
    public void exportStudentUserInfo(HttpServletResponse response,
                                      @RequestParam String schoolId) {
        if (StringUtils.isNotBlank(schoolId)) {
            UserinfoExample userInfoExample = new UserinfoExample();
            userInfoExample.createCriteria().andSchoolIdEqualTo(schoolId).andRoleEqualTo(4);
            List<Userinfo> list = userinfoMapper.selectByExample(userInfoExample);
            //导出的表名
            String title = "学生账号汇总";
            //表中第一行表头字段
            String[] headers = {"姓名", "学号", "性别", "手机号", "邮箱"};

            //具体需要写入excel需要哪些字段，这些字段取自UserReward类，也就是上面的实际数据结果集的泛型
            List<String> listColumn = Arrays.asList("name", "username", "sex", "phone", "email");
            try {
                FilePortUtil.exportExcel(response, title, headers, list, listColumn);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }


    //修改密码
    @PostMapping("/updatePassword")
    @ApiOperation("个人中心-修改密码")
    @AnonymousAccess
    public ResultEntity updatePassword(@RequestParam String userId, @RequestParam String password) {
        Userinfo userInfo = userinfoMapper.selectByPrimaryKey(userId);
        userInfo.setPassword(password);
        int i = userinfoMapper.updateByPrimaryKey(userInfo);
        if (i == 1) {
            return new ResultEntity<>(HttpStatus.OK, "修改密码成功！");
        }
        return new ResultEntity<>(HttpStatus.BAD_REQUEST, "修改密码失败！");
    }

    @PostMapping("/selectPersonInfo")
    @ApiOperation("个人中心-查看用户数据")
    @AnonymousAccess
    public ResultEntity<Userinfo> selectPersonInfo(@RequestParam String userId) {
        Userinfo userInfo = userinfoMapper.selectByPrimaryKey(userId);
        String schoolId = userInfo.getSchoolId();
        String schoolFacultyId = userInfo.getSchoolFacultyId();
        String schoolMajorId = userInfo.getSchoolMajorId();

        String schoolName = schoolMapper.selectSchoolNameById(schoolId);
        String schoolFacultyName = schoolFacultyMapper.selectByPrimaryKey(schoolFacultyId).getSchoolFacultyName();
        String schoolMajorName = schoolMajorMapper.selectByPrimaryKey(schoolMajorId).getSchoolMajorName();

        userInfo.setSchoolId(schoolName);
        userInfo.setSchoolName(schoolName);
        userInfo.setSchoolFacultyId(schoolFacultyName);
        userInfo.setSchoolMajorId(schoolMajorName);
        if (userInfo.getRole() == 4) { //查看学生信息
            String schoolClassId = userInfo.getSchoolClassId();
            String className = schoolClassMapper.selectByPrimaryKey(schoolClassId).getClassName();
            userInfo.setSchoolClassId(className);
            userInfo.setClassName(className);
        }

        return new ResultEntity<>(HttpStatus.OK, "个人中心-查看用户数据成功！",userInfo);
    }

    @ApiOperation("开放接口,自动同步学生信息")
    @PostMapping("synchronizationStudentInfoByAuto")
    @AnonymousAccess
    public String synchronizationStudentInfoByAuto(@RequestBody List<ZYUserInfo> studentList) {
//        JwtUser user = TokenProvider.getJWTUser(request);
        return userInfoService.insertAllByAuto(studentList);
        //return new ResultDataEntity(HttpStatus.OK);
    }


}