|
|
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.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.entity.importDto.StudentImportDTO;
|
|
|
import com.sztzjy.linkCommerce.entity.importDto.TeachingClassStudentImportDTO;
|
|
|
import com.sztzjy.linkCommerce.entity.importDto.TeacherRosterStudentImportDTO;
|
|
|
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.StudentTeachingClassResolver;
|
|
|
import com.sztzjy.linkCommerce.service.SchoolProductConfigService;
|
|
|
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.transaction.annotation.Transactional;
|
|
|
import org.springframework.web.bind.annotation.*;
|
|
|
import org.springframework.web.multipart.MultipartFile;
|
|
|
|
|
|
import javax.servlet.http.HttpServletResponse;
|
|
|
import javax.servlet.http.HttpServletRequest;
|
|
|
import java.io.InputStream;
|
|
|
import java.util.*;
|
|
|
|
|
|
|
|
|
@Api(tags = "用户管理")
|
|
|
@RequestMapping("api/user")
|
|
|
@RestController
|
|
|
public class UserController {
|
|
|
@Autowired
|
|
|
SchoolService schoolService;
|
|
|
@Autowired
|
|
|
SchoolProductConfigService schoolProductConfigService;
|
|
|
@Autowired
|
|
|
SchoolMapper schoolMapper;
|
|
|
@Autowired
|
|
|
UserinfoMapper userinfoMapper;
|
|
|
@Autowired
|
|
|
SchoolMajorMapper schoolMajorMapper;
|
|
|
@Autowired
|
|
|
SchoolClassMapper schoolClassMapper;
|
|
|
@Autowired
|
|
|
TeachingClassStudentMapper teachingClassStudentMapper;
|
|
|
@Autowired
|
|
|
CptfController cptfController;
|
|
|
@Autowired
|
|
|
Pinyin4jUtil pinyin4jUtil;
|
|
|
@Autowired
|
|
|
UserInfoService userInfoService;
|
|
|
@Autowired
|
|
|
ValidateService validateService;
|
|
|
@Autowired
|
|
|
ImportService importService;
|
|
|
@Autowired(required = false)
|
|
|
StudentTeachingClassResolver studentTeachingClassResolver;
|
|
|
|
|
|
|
|
|
@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,
|
|
|
@RequestParam(required = false) String userId) {
|
|
|
//先根据schoolId进行查询 如果不存在则返回
|
|
|
School school = schoolMapper.selectByPrimaryKey(schoolId);
|
|
|
if (school == null) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该学校不存在");
|
|
|
}
|
|
|
if (!canManageFaculty(userId, schoolId)) {
|
|
|
return noManagePermission();
|
|
|
}
|
|
|
//查询该学校下院系下 专业名称是否重复
|
|
|
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) {
|
|
|
SchoolFaculty schoolFaculty = schoolFacultyMapper.selectByPrimaryKey(schoolFacultyId);
|
|
|
if (schoolFaculty == null) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "院系不存在");
|
|
|
}
|
|
|
if (!canManageFaculty(userId, schoolFaculty.getSchoolId())) {
|
|
|
return noManagePermission();
|
|
|
}
|
|
|
if (hasMajorUnderFaculty(schoolFacultyId)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "院系下存在专业，不能删除");
|
|
|
}
|
|
|
int i = schoolFacultyMapper.deleteByPrimaryKey(schoolFacultyId);
|
|
|
if (i == 1) {
|
|
|
return new ResultEntity<>(HttpStatus.OK, "院系管理-删除成功");
|
|
|
}
|
|
|
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缺失");
|
|
|
}
|
|
|
SchoolFaculty existing = schoolFacultyMapper.selectByPrimaryKey(schoolFaculty.getSchoolFacultyId());
|
|
|
if (existing == null) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "院系不存在");
|
|
|
}
|
|
|
if (!canManageFaculty(userId, existing.getSchoolId())) {
|
|
|
return noManagePermission();
|
|
|
}
|
|
|
int i = schoolFacultyMapper.updateByPrimaryKey(schoolFaculty);
|
|
|
if (i == 1) {
|
|
|
return new ResultEntity<>(HttpStatus.OK, "院系管理-编辑成功");
|
|
|
}
|
|
|
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,
|
|
|
@RequestParam(required = false) String userId) {
|
|
|
//先根据schoolId进行查询 如果不存在则返回
|
|
|
School school = schoolMapper.selectByPrimaryKey(schoolId);
|
|
|
if (school == null) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该学校不存在");
|
|
|
}
|
|
|
if (!canManageMajorStructure(userId, schoolId)) {
|
|
|
return noManagePermission();
|
|
|
}
|
|
|
//再根据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) {
|
|
|
if (!canManageMajor(userId, schoolMajorId)) {
|
|
|
return noManagePermission();
|
|
|
}
|
|
|
if (hasClassUnderMajor(schoolMajorId)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "专业下存在班级，不能删除");
|
|
|
}
|
|
|
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, @RequestParam(required = false) String userId) {
|
|
|
if (StringUtils.isBlank(schoolMajor.getSchoolMajorId())) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "专业管理-编辑失败-主键ID缺失");
|
|
|
}
|
|
|
if (!canManageMajor(userId, schoolMajor.getSchoolMajorId())) {
|
|
|
return noManagePermission();
|
|
|
}
|
|
|
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(required = false) String schoolFacultyId,
|
|
|
@ApiParam("专业ID") @RequestParam(required = false) String schoolMajorId,
|
|
|
@ApiParam("班级名称") @RequestParam String className,
|
|
|
@RequestParam(required = false) String userId,
|
|
|
@RequestParam(required = false) String classType,
|
|
|
@RequestParam(required = false) String sourceClassIds,
|
|
|
@RequestParam(required = false, defaultValue = "false") Boolean confirmMultiTeachingClass) {
|
|
|
//先根据schoolId进行查询 如果不存在则返回
|
|
|
School school = schoolMapper.selectByPrimaryKey(schoolId);
|
|
|
if (school == null) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该学校不存在");
|
|
|
}
|
|
|
String requestedClassType = StringUtils.defaultIfBlank(classType, StringUtils.isBlank(userId) ? "ADMIN" : "TEACHING");
|
|
|
boolean majorManagementEnabled = isMajorManagementEnabled(schoolId);
|
|
|
if (!isAdminClassManagementEnabled(schoolId) && !"TEACHING".equals(requestedClassType)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "当前学校只支持教学班");
|
|
|
}
|
|
|
if (majorManagementEnabled) {
|
|
|
SchoolFaculty schoolFaculty = schoolFacultyMapper.selectByPrimaryKey(schoolFacultyId);
|
|
|
if (schoolFaculty == null) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该院系不存在");
|
|
|
}
|
|
|
SchoolMajor schoolMajor = schoolMajorMapper.selectByPrimaryKey(schoolMajorId);
|
|
|
if (schoolMajor == null) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该专业不存在");
|
|
|
}
|
|
|
}
|
|
|
//查询班级名称是否存在
|
|
|
if (!canCreateSchoolClass(userId, schoolId, requestedClassType)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "No permission to add this class type");
|
|
|
}
|
|
|
SchoolClassExample schoolClassExample = new SchoolClassExample();
|
|
|
schoolClassExample.createCriteria().andSchoolIdEqualTo(schoolId).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);
|
|
|
schoolClass.setCreatedBy(userId);
|
|
|
schoolClass.setClassType(requestedClassType);
|
|
|
schoolClass.setDataSource("LOCAL");
|
|
|
schoolClass.setSourceClassIds(sourceClassIds);
|
|
|
|
|
|
if ("TEACHING".equals(schoolClass.getClassType()) && !Boolean.TRUE.equals(confirmMultiTeachingClass)) {
|
|
|
ResultEntity conflict = buildMultiTeachingClassConflict(
|
|
|
findStudentsByAdminClassIds(parseSourceClassIds(sourceClassIds)), "");
|
|
|
if (conflict != null) {
|
|
|
return conflict;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
int insert = schoolClassMapper.insert(schoolClass);
|
|
|
if (insert == 1) {
|
|
|
createTeachingClassMembersFromSourceClasses(schoolClass);
|
|
|
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,
|
|
|
@RequestParam(required = false) String operatorId) {
|
|
|
Userinfo operator = StringUtils.isBlank(operatorId) ? null : userinfoMapper.selectByPrimaryKey(operatorId);
|
|
|
if (isSchoolTeacher(operator) && isTeacherRosterMode(operator.getSchoolId())) {
|
|
|
PageInfo<SchoolClassDto> pageInfo = schoolService.seleteSchoolClass(index, size, operator.getSchoolId(),
|
|
|
className, classSn, null, operatorId, "TEACHING");
|
|
|
return new ResultEntity<>(HttpStatus.OK, "班级管理-查询成功", pageInfo);
|
|
|
}
|
|
|
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 == null) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "班级管理-删除失败-权限不足");
|
|
|
}
|
|
|
SchoolClass schoolClass = schoolClassMapper.selectByPrimaryKey(schoolClassId);
|
|
|
if (!canModifySchoolClass(userInfo, schoolClass)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "班级管理-删除失败-权限不足");
|
|
|
}
|
|
|
if (classHasStudents(schoolClass)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "班级下存在学生，不能删除");
|
|
|
}
|
|
|
int i = schoolClassMapper.deleteByPrimaryKey(schoolClassId);
|
|
|
if (i == 1) {
|
|
|
return new ResultEntity<>(HttpStatus.OK, "班级管理-删除成功");
|
|
|
}
|
|
|
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 == null) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "班级管理-编辑失败-权限不足");
|
|
|
}
|
|
|
SchoolClass existingClass = schoolClassMapper.selectByPrimaryKey(schoolClass.getSchoolClassId());
|
|
|
if (!canModifySchoolClass(userInfo, existingClass)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "班级管理-编辑失败-权限不足");
|
|
|
}
|
|
|
schoolClass.setCreatedBy(existingClass.getCreatedBy());
|
|
|
if (isClassOwner(existingClass, userId)) {
|
|
|
schoolClass.setCreatedBy(userId);
|
|
|
}
|
|
|
int i = schoolClassMapper.updateByPrimaryKeySelective(schoolClass);
|
|
|
if (i == 1) {
|
|
|
return new ResultEntity<>(HttpStatus.OK, "班级管理-编辑成功");
|
|
|
}
|
|
|
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,
|
|
|
@RequestParam(required = false) String operatorId) {
|
|
|
//先根据schoolId进行查询 如果不存在则返回
|
|
|
School school = schoolMapper.selectByPrimaryKey(schoolId);
|
|
|
if (school == null) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该学校不存在");
|
|
|
}
|
|
|
if (!canManageSchoolStructure(operatorId, schoolId)) {
|
|
|
return noManagePermission();
|
|
|
}
|
|
|
//再根据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.setTeacherAdmin(false);
|
|
|
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,
|
|
|
@RequestParam(required = false) String operatorId) {
|
|
|
if (StringUtils.isNotBlank(operatorId)) {
|
|
|
Userinfo operator = userinfoMapper.selectByPrimaryKey(operatorId);
|
|
|
if (!isSchoolTeacher(operator)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "无权查询教师账号信息");
|
|
|
}
|
|
|
schoolId = operator.getSchoolId();
|
|
|
}
|
|
|
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());
|
|
|
}
|
|
|
}
|
|
|
markTeachersWithCreatedClasses(userInfoList);
|
|
|
PageInfo<Userinfo> pageInfo = new PageInfo<>(userInfoList);
|
|
|
return new ResultEntity<>(HttpStatus.OK, "查询教师账号信息成功！", pageInfo);
|
|
|
}
|
|
|
|
|
|
//编辑
|
|
|
@PostMapping("/updateTeacher")
|
|
|
@ApiOperation("教师管理-编辑教师账号信息")
|
|
|
@AnonymousAccess
|
|
|
public ResultEntity updateTeacher(@RequestBody Userinfo userInfo, @RequestParam(required = false) String operatorId) {
|
|
|
Userinfo existing = userinfoMapper.selectByPrimaryKey(userInfo.getUserId());
|
|
|
if (existing == null || !Integer.valueOf(3).equals(existing.getRole())) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "教师账号不存在");
|
|
|
}
|
|
|
if (teacherHasCreatedClass(existing.getUserId())) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该教师已创建班级，不允许编辑或删除");
|
|
|
}
|
|
|
String schoolId = existing.getSchoolId();
|
|
|
if (!canManageSchoolStructure(operatorId, schoolId)) {
|
|
|
return noManagePermission();
|
|
|
}
|
|
|
Userinfo operator = userinfoMapper.selectByPrimaryKey(operatorId);
|
|
|
if (!isPlatformAdmin(operator)) {
|
|
|
userInfo.setTeacherAdmin(false);
|
|
|
}
|
|
|
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, @RequestParam(required = false) String operatorId) {
|
|
|
Userinfo userInfo = userinfoMapper.selectByPrimaryKey(userId);
|
|
|
if (userInfo == null) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "教师账号不存在");
|
|
|
}
|
|
|
if (!canManageSchoolStructure(operatorId, userInfo.getSchoolId())) {
|
|
|
return noManagePermission();
|
|
|
}
|
|
|
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, @RequestParam(required = false) String operatorId) {
|
|
|
Userinfo userInfo = userinfoMapper.selectByPrimaryKey(userId);
|
|
|
if (userInfo == null) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "教师账号不存在");
|
|
|
}
|
|
|
if (!canManageSchoolStructure(operatorId, userInfo.getSchoolId())) {
|
|
|
return noManagePermission();
|
|
|
}
|
|
|
if (teacherHasCreatedClass(userId)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该教师已创建班级，不允许编辑或删除");
|
|
|
}
|
|
|
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,
|
|
|
@RequestParam(required = false) String operatorId) {
|
|
|
// 基本校验
|
|
|
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);
|
|
|
}
|
|
|
for (TeacherImportDTO teacher : teacherList) {
|
|
|
String schoolId = schoolService.selectSchoolIdBySchoolName(teacher.getSchoolName());
|
|
|
if (!canManageSchoolStructure(operatorId, schoolId)) {
|
|
|
return noManagePermission();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 异步处理导入*****
|
|
|
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,
|
|
|
@RequestParam(required = false) String userId) {
|
|
|
//先根据schoolId进行查询 如果不存在则返回
|
|
|
Userinfo operator = StringUtils.isBlank(userId) ? null : userinfoMapper.selectByPrimaryKey(userId);
|
|
|
String effectiveSchoolId = isSchoolTeacher(operator) ? operator.getSchoolId() : schoolId;
|
|
|
School school = schoolMapper.selectByPrimaryKey(effectiveSchoolId);
|
|
|
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, "该班级不存在");
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(userId) && !canOperateClass(userId, schoolClassId)) {
|
|
|
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.setTeacherAdmin(false);
|
|
|
userInfo.setSchoolId(effectiveSchoolId);
|
|
|
userInfo.setSchoolFacultyId(schoolFacultyId);
|
|
|
userInfo.setSchoolMajorId(schoolMajorId);
|
|
|
String adminClassId = "TEACHING".equals(schoolClass.getClassType())
|
|
|
? resolveAdminClassIdForTeachingClass(schoolClass)
|
|
|
: schoolClassId;
|
|
|
userInfo.setSchoolClassId(adminClassId);
|
|
|
userInfo.setCodeFrom("添加");
|
|
|
|
|
|
int insert = userinfoMapper.insert(userInfo);
|
|
|
if (insert == 1) {
|
|
|
if ("TEACHING".equals(schoolClass.getClassType()) && teachingClassStudentMapper != null) {
|
|
|
upsertActiveTeachingClassMember(schoolClassId, userInfo, adminClassId, "MANUAL");
|
|
|
}
|
|
|
return new ResultEntity<>(HttpStatus.OK, "学生管理-添加学生账号成功");
|
|
|
} else {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "学生管理-添加学生账号失败");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@PostMapping("/teacher-roster/students")
|
|
|
@ApiOperation("教师维护名单模式-新增学生档案")
|
|
|
@AnonymousAccess
|
|
|
public ResultEntity addTeacherRosterStudent(@RequestParam String name,
|
|
|
@RequestParam String userName,
|
|
|
@RequestParam String teachingClassId,
|
|
|
@RequestParam String operatorId) {
|
|
|
Userinfo operator = userinfoMapper.selectByPrimaryKey(operatorId);
|
|
|
if (!isSchoolTeacher(operator) || !isTeacherRosterMode(operator.getSchoolId())) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "无权维护学生名单");
|
|
|
}
|
|
|
SchoolClass teachingClass = schoolClassMapper.selectByPrimaryKey(teachingClassId);
|
|
|
if (!canManageTeachingClass(operator, teachingClass)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "只能选择可维护的教学班");
|
|
|
}
|
|
|
if (StringUtils.isAnyBlank(StringUtils.trimToNull(name), StringUtils.trimToNull(userName))) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "学生姓名和学号不能为空");
|
|
|
}
|
|
|
String normalizedUserName = StringUtils.trim(userName);
|
|
|
if (userinfoMapper.selectBySchoolIdAndUsername(operator.getSchoolId(), normalizedUserName) != null
|
|
|
|| userInfoService.existsByUserName(normalizedUserName)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "账号已存在");
|
|
|
}
|
|
|
Userinfo student = new Userinfo();
|
|
|
student.setUserId(UUID.randomUUID().toString());
|
|
|
student.setName(StringUtils.trim(name));
|
|
|
student.setUsername(normalizedUserName);
|
|
|
student.setPassword("123qwe");
|
|
|
student.setRole(4);
|
|
|
student.setTeacherAdmin(false);
|
|
|
student.setSchoolId(operator.getSchoolId());
|
|
|
student.setCreateTime(new Date());
|
|
|
student.setCodeFrom("教师名单添加");
|
|
|
if (userinfoMapper.insertSelective(student) <= 0) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "新增学生失败");
|
|
|
}
|
|
|
teachingClassStudentMapper.exitActiveByStudentUserIdExceptClass(student.getUserId(), teachingClassId);
|
|
|
upsertActiveTeachingClassMember(teachingClassId, student, null, "TEACHER_ROSTER_MANUAL");
|
|
|
return new ResultEntity<>(HttpStatus.OK, "新增学生成功");
|
|
|
}
|
|
|
|
|
|
@PostMapping("/teacher-roster/students/{studentUserId}")
|
|
|
@ApiOperation("教师维护名单模式-编辑学生档案")
|
|
|
@AnonymousAccess
|
|
|
public ResultEntity updateTeacherRosterStudent(@PathVariable String studentUserId,
|
|
|
@RequestParam String name,
|
|
|
@RequestParam String userName,
|
|
|
@RequestParam String teachingClassId,
|
|
|
@RequestParam String operatorId) {
|
|
|
Userinfo operator = userinfoMapper.selectByPrimaryKey(operatorId);
|
|
|
Userinfo existingStudent = userinfoMapper.selectByPrimaryKey(studentUserId);
|
|
|
if (!isSchoolTeacher(operator) || !isTeacherRosterMode(operator.getSchoolId())
|
|
|
|| existingStudent == null || !Integer.valueOf(4).equals(existingStudent.getRole())
|
|
|
|| !StringUtils.equals(operator.getSchoolId(), existingStudent.getSchoolId())) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "无权维护该学生名单");
|
|
|
}
|
|
|
SchoolClass teachingClass = schoolClassMapper.selectByPrimaryKey(teachingClassId);
|
|
|
if (!canManageTeachingClass(operator, teachingClass)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "只能选择可维护的教学班");
|
|
|
}
|
|
|
if (StringUtils.isAnyBlank(StringUtils.trimToNull(name), StringUtils.trimToNull(userName))) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "学生姓名和学号不能为空");
|
|
|
}
|
|
|
String normalizedUserName = StringUtils.trim(userName);
|
|
|
if (!StringUtils.equals(normalizedUserName, existingStudent.getUsername())
|
|
|
&& userInfoService.existsByUserName(normalizedUserName)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "账号已存在");
|
|
|
}
|
|
|
Userinfo update = new Userinfo();
|
|
|
update.setUserId(studentUserId);
|
|
|
update.setName(StringUtils.trim(name));
|
|
|
update.setUsername(normalizedUserName);
|
|
|
if (userinfoMapper.updateByPrimaryKeySelective(update) <= 0) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "编辑学生失败");
|
|
|
}
|
|
|
teachingClassStudentMapper.exitActiveByStudentUserIdExceptClass(studentUserId, teachingClassId);
|
|
|
upsertActiveTeachingClassMember(teachingClassId, existingStudent, null, "TEACHER_ROSTER_MANUAL");
|
|
|
return new ResultEntity<>(HttpStatus.OK, "编辑学生成功");
|
|
|
}
|
|
|
|
|
|
//查询
|
|
|
ResultEntity<PageInfo<Userinfo>> selectStudent(String schoolId,
|
|
|
String schoolClassId,
|
|
|
String name,
|
|
|
String userName,
|
|
|
Integer index,
|
|
|
Integer size) {
|
|
|
return selectStudent(schoolId, schoolClassId, name, userName, index, size, null);
|
|
|
}
|
|
|
|
|
|
@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,
|
|
|
@RequestParam(required = false) String operatorId) {
|
|
|
Userinfo operator = StringUtils.isBlank(operatorId) ? null : userinfoMapper.selectByPrimaryKey(operatorId);
|
|
|
boolean teacherRosterScope = isSchoolTeacher(operator) && isTeacherRosterMode(operator.getSchoolId());
|
|
|
if (teacherRosterScope) {
|
|
|
schoolId = operator.getSchoolId();
|
|
|
}
|
|
|
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 (teacherRosterScope) {
|
|
|
List<String> managedStudentIds = resolveManagedRosterStudentIds(operator, schoolClassId);
|
|
|
if (managedStudentIds == null) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "无权查看该教学班内的学生");
|
|
|
}
|
|
|
criteria.andUserIdIn(managedStudentIds.isEmpty() ? Collections.singletonList("__empty__") : managedStudentIds);
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(schoolClassId)) {
|
|
|
schoolClass = schoolClassMapper.selectByPrimaryKey(schoolClassId);
|
|
|
if (schoolClass != null && "TEACHING".equals(schoolClass.getClassType()) && teachingClassStudentMapper != null) {
|
|
|
List<TeachingClassStudent> members = teachingClassStudentMapper.selectByTeachingClassId(schoolClassId);
|
|
|
List<String> studentIds = new ArrayList<>();
|
|
|
for (TeachingClassStudent member : members) {
|
|
|
studentIds.add(member.getStudentUserId());
|
|
|
}
|
|
|
criteria.andUserIdIn(studentIds.isEmpty() ? Collections.singletonList("__empty__") : studentIds);
|
|
|
} else {
|
|
|
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 {
|
|
|
Userinfo student = userInfoList.get(i);
|
|
|
if (!populateTeacherRosterTeachingClass(student, schoolId)) {
|
|
|
student.setClassName(safeClassName(student.getSchoolClassId()));
|
|
|
}
|
|
|
}
|
|
|
} 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 {
|
|
|
Userinfo student = userInfoList.get(i);
|
|
|
if (!populateTeacherRosterTeachingClass(student, schoolId1)) {
|
|
|
student.setClassName(safeClassName(student.getSchoolClassId()));
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
PageInfo<Userinfo> pageInfo = new PageInfo<>(userInfoList);
|
|
|
return new ResultEntity<>(HttpStatus.OK, "查询学生账号信息成功！", pageInfo);
|
|
|
}
|
|
|
|
|
|
//编辑
|
|
|
private List<String> resolveManagedRosterStudentIds(Userinfo operator, String teachingClassId) {
|
|
|
if (!isSchoolTeacher(operator) || teachingClassStudentMapper == null) {
|
|
|
return Collections.emptyList();
|
|
|
}
|
|
|
List<SchoolClass> teachingClasses;
|
|
|
if (StringUtils.isNotBlank(teachingClassId)) {
|
|
|
SchoolClass teachingClass = schoolClassMapper.selectByPrimaryKey(teachingClassId);
|
|
|
if (!canManageTeachingClass(operator, teachingClass)) {
|
|
|
return null;
|
|
|
}
|
|
|
teachingClasses = Collections.singletonList(teachingClass);
|
|
|
} else {
|
|
|
SchoolClassExample example = new SchoolClassExample();
|
|
|
SchoolClassExample.Criteria criteria = example.createCriteria()
|
|
|
.andSchoolIdEqualTo(operator.getSchoolId())
|
|
|
.andClassTypeEqualTo("TEACHING");
|
|
|
if (!isTeacherAdmin(operator)) {
|
|
|
criteria.andCreatedByEqualTo(operator.getUserId());
|
|
|
}
|
|
|
teachingClasses = schoolClassMapper.selectByExample(example);
|
|
|
}
|
|
|
Set<String> studentIds = new LinkedHashSet<>();
|
|
|
for (SchoolClass teachingClass : teachingClasses == null ? Collections.<SchoolClass>emptyList() : teachingClasses) {
|
|
|
List<TeachingClassStudent> members = teachingClassStudentMapper.selectByTeachingClassId(teachingClass.getSchoolClassId());
|
|
|
for (TeachingClassStudent member : members == null ? Collections.<TeachingClassStudent>emptyList() : members) {
|
|
|
if (member != null && StringUtils.isNotBlank(member.getStudentUserId())) {
|
|
|
studentIds.add(member.getStudentUserId());
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return new ArrayList<>(studentIds);
|
|
|
}
|
|
|
|
|
|
@PostMapping("/updateStudent")
|
|
|
@ApiOperation("学生管理-编辑学生账号信息")
|
|
|
@AnonymousAccess
|
|
|
public ResultEntity updateStudent(@RequestBody Userinfo userInfo,
|
|
|
@RequestParam(required = false) String operatorId,
|
|
|
@RequestParam(required = false) String teachingClassId) {
|
|
|
String targetClassId = userInfo.getSchoolClassId();
|
|
|
if (StringUtils.isBlank(targetClassId) && StringUtils.isNotBlank(userInfo.getUserId())) {
|
|
|
Userinfo existing = userinfoMapper.selectByPrimaryKey(userInfo.getUserId());
|
|
|
targetClassId = existing == null ? null : existing.getSchoolClassId();
|
|
|
}
|
|
|
boolean canOperate = StringUtils.isNotBlank(teachingClassId)
|
|
|
? canOperateStudent(operatorId, userInfo.getUserId(), teachingClassId)
|
|
|
: canOperateClass(operatorId, targetClassId);
|
|
|
if (!canOperate) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "只能维护自己创建班级的学生");
|
|
|
}
|
|
|
userInfo.setRole(4);
|
|
|
userInfo.setTeacherAdmin(false);
|
|
|
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,
|
|
|
@RequestParam(required = false) String operatorId,
|
|
|
@RequestParam(required = false) String teachingClassId) {
|
|
|
if (!canOperateStudent(operatorId, userId, teachingClassId)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "只能维护自己创建班级的学生");
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(teachingClassId)) {
|
|
|
int removed = teachingClassStudentMapper.deleteByStudentUserIdAndTeachingClassId(userId, teachingClassId);
|
|
|
if (removed >= 1) {
|
|
|
return new ResultEntity<>(HttpStatus.OK, "删除成功！");
|
|
|
}
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "删除失败！");
|
|
|
}
|
|
|
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,
|
|
|
@RequestParam(required = false) String operatorId,
|
|
|
@RequestParam(required = false) String teachingClassId) {
|
|
|
if (!canOperateStudent(operatorId, userId, teachingClassId)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "只能维护自己创建班级的学生");
|
|
|
}
|
|
|
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("/initializeTeachingClassTrainingData")
|
|
|
@ApiOperation("教学班-全班实训数据初始化")
|
|
|
@AnonymousAccess
|
|
|
public ResultEntity initializeTeachingClassTrainingData(@RequestParam String teachingClassId,
|
|
|
@RequestParam String operatorId) {
|
|
|
SchoolClass schoolClass = schoolClassMapper.selectByPrimaryKey(teachingClassId);
|
|
|
Userinfo operator = userinfoMapper.selectByPrimaryKey(operatorId);
|
|
|
if (!canManageTeachingClass(operator, schoolClass)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "无权初始化该教学班");
|
|
|
}
|
|
|
List<TeachingClassStudent> members = teachingClassStudentMapper.selectByTeachingClassId(teachingClassId);
|
|
|
if (members == null) {
|
|
|
members = Collections.emptyList();
|
|
|
}
|
|
|
for (TeachingClassStudent member : members) {
|
|
|
if (member != null && StringUtils.isNotBlank(member.getStudentUserId())) {
|
|
|
cptfController.restartByUserId(member.getStudentUserId());
|
|
|
}
|
|
|
}
|
|
|
return new ResultEntity<>(HttpStatus.OK, "教学班实训数据初始化成功");
|
|
|
}
|
|
|
|
|
|
@PostMapping("/initializeTeachingClassStudentTrainingData")
|
|
|
@ApiOperation("教学班-单个学生实训数据初始化")
|
|
|
@AnonymousAccess
|
|
|
public ResultEntity initializeTeachingClassStudentTrainingData(@RequestParam String teachingClassId,
|
|
|
@RequestParam String studentUserId,
|
|
|
@RequestParam String operatorId) {
|
|
|
SchoolClass schoolClass = schoolClassMapper.selectByPrimaryKey(teachingClassId);
|
|
|
Userinfo operator = userinfoMapper.selectByPrimaryKey(operatorId);
|
|
|
if (!canManageTeachingClass(operator, schoolClass)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "无权初始化该教学班内的学生");
|
|
|
}
|
|
|
if (teachingClassStudentMapper != null
|
|
|
&& teachingClassStudentMapper.countByStudentUserIdAndTeachingClassId(studentUserId, teachingClassId) <= 0) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "学生不属于该教学班");
|
|
|
}
|
|
|
cptfController.restartByUserId(studentUserId);
|
|
|
return new ResultEntity<>(HttpStatus.OK, "学生实训数据初始化成功");
|
|
|
}
|
|
|
|
|
|
@PostMapping("/uploadTeachingClassStudentMembers")
|
|
|
@ApiOperation("教学班-导入学生成员")
|
|
|
@AnonymousAccess
|
|
|
public ResultEntity uploadTeachingClassStudentMembers(@RequestParam MultipartFile file,
|
|
|
@RequestParam String teachingClassId,
|
|
|
@RequestParam String operatorId,
|
|
|
@RequestParam(required = false, defaultValue = "false") Boolean confirmMultiTeachingClass) {
|
|
|
if (file.isEmpty()) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "上传文件不能为空！");
|
|
|
}
|
|
|
String originalFilename = file.getOriginalFilename();
|
|
|
if (StringUtils.isBlank(originalFilename)
|
|
|
|| (!originalFilename.endsWith(".xls") && !originalFilename.endsWith(".xlsx"))) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "请上传Excel文件！");
|
|
|
}
|
|
|
if (file.getSize() > 10 * 1024 * 1024) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "文件大小不能超过10MB！");
|
|
|
}
|
|
|
try (InputStream inputStream = file.getInputStream()) {
|
|
|
List<TeachingClassStudentImportDTO> rows = EasyExcel.read(inputStream)
|
|
|
.head(TeachingClassStudentImportDTO.class)
|
|
|
.sheet()
|
|
|
.doReadSync();
|
|
|
return importTeachingClassStudentRows(rows, teachingClassId, operatorId, confirmMultiTeachingClass);
|
|
|
} catch (Exception e) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "数据校验失败！", e.getMessage());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@PostMapping("/importTeacherStudents")
|
|
|
@ApiOperation("教师端-批量导入学生账号")
|
|
|
@AnonymousAccess
|
|
|
@Transactional(rollbackFor = Exception.class)
|
|
|
public ResultEntity importTeacherStudents(@RequestParam MultipartFile file,
|
|
|
@RequestParam String operatorId) {
|
|
|
ResultEntity fileError = validateTeacherStudentImportFile(file);
|
|
|
if (fileError != null) {
|
|
|
return fileError;
|
|
|
}
|
|
|
try (InputStream inputStream = file.getInputStream()) {
|
|
|
List<SchoolAdminStudentImportDTO> rows = EasyExcel.read(inputStream)
|
|
|
.head(SchoolAdminStudentImportDTO.class)
|
|
|
.sheet()
|
|
|
.doReadSync();
|
|
|
return importTeacherStudentRows(rows, operatorId);
|
|
|
} catch (Exception e) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "数据校验失败：", e.getMessage());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
ResultEntity importTeacherStudentRows(List<SchoolAdminStudentImportDTO> rows, String operatorId) {
|
|
|
Userinfo operator = userinfoMapper.selectByPrimaryKey(operatorId);
|
|
|
if (!isSchoolTeacher(operator)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "权限不足");
|
|
|
}
|
|
|
List<String> errors = new ArrayList<>();
|
|
|
List<Userinfo> students = buildTeacherImportStudents(rows, operator, 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 inserted = userinfoMapper.insertSelective(student);
|
|
|
if (inserted <= 0) {
|
|
|
throw new IllegalStateException("导入失败");
|
|
|
}
|
|
|
}
|
|
|
return new ResultEntity<>(HttpStatus.OK, "导入成功，共 " + students.size() + " 条");
|
|
|
}
|
|
|
|
|
|
ResultEntity importTeacherRosterRows(List<TeacherRosterStudentImportDTO> rows,
|
|
|
String teachingClassId,
|
|
|
String operatorId) {
|
|
|
Userinfo operator = userinfoMapper.selectByPrimaryKey(operatorId);
|
|
|
if (!isSchoolTeacher(operator) || !schoolProductConfigService.isTeacherRosterManaged(operator.getSchoolId())) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "无权维护该教学班名单");
|
|
|
}
|
|
|
if (rows == null || rows.isEmpty()) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "未读取到可导入的学生数据");
|
|
|
}
|
|
|
Map<String, SchoolClass> managedClassesByName = new HashMap<>();
|
|
|
if (StringUtils.isNotBlank(teachingClassId)) {
|
|
|
SchoolClass teachingClass = schoolClassMapper.selectByPrimaryKey(teachingClassId);
|
|
|
if (!canManageTeachingClass(operator, teachingClass)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "无权维护该教学班名单");
|
|
|
}
|
|
|
managedClassesByName.put(teachingClass.getClassName(), teachingClass);
|
|
|
} else {
|
|
|
SchoolClassExample example = new SchoolClassExample();
|
|
|
SchoolClassExample.Criteria criteria = example.createCriteria()
|
|
|
.andSchoolIdEqualTo(operator.getSchoolId())
|
|
|
.andClassTypeEqualTo("TEACHING");
|
|
|
if (!isTeacherAdmin(operator)) {
|
|
|
criteria.andCreatedByEqualTo(operator.getUserId());
|
|
|
}
|
|
|
List<SchoolClass> teachingClasses = schoolClassMapper.selectByExample(example);
|
|
|
for (SchoolClass teachingClass : teachingClasses == null ? Collections.<SchoolClass>emptyList() : teachingClasses) {
|
|
|
managedClassesByName.put(teachingClass.getClassName(), teachingClass);
|
|
|
}
|
|
|
}
|
|
|
List<TeacherRosterImportRecord> importRecords = new ArrayList<>();
|
|
|
Set<String> usernames = new HashSet<>();
|
|
|
for (TeacherRosterStudentImportDTO row : rows) {
|
|
|
String name = row == null ? "" : StringUtils.trimToEmpty(row.getName());
|
|
|
String username = row == null ? "" : StringUtils.trimToEmpty(row.getUsername());
|
|
|
String className = row == null ? "" : StringUtils.trimToEmpty(row.getClassName());
|
|
|
if (StringUtils.isBlank(name) || StringUtils.isBlank(username) || (StringUtils.isBlank(teachingClassId) && StringUtils.isBlank(className))) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "学生姓名或学号无效");
|
|
|
}
|
|
|
SchoolClass targetClass = StringUtils.isNotBlank(teachingClassId)
|
|
|
? managedClassesByName.values().iterator().next()
|
|
|
: managedClassesByName.get(className);
|
|
|
if (targetClass == null) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "班级不存在或无管理权限：" + className);
|
|
|
}
|
|
|
if (!usernames.add(username)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "导入文件中学号重复：" + username);
|
|
|
}
|
|
|
Userinfo existingStudent = userinfoMapper.selectBySchoolIdAndUsername(operator.getSchoolId(), username);
|
|
|
if (existingStudent != null) {
|
|
|
if (!Integer.valueOf(4).equals(existingStudent.getRole()) || !StringUtils.equals(existingStudent.getName(), name)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "学号与已有学生信息冲突");
|
|
|
}
|
|
|
importRecords.add(new TeacherRosterImportRecord(targetClass.getSchoolClassId(), existingStudent, false));
|
|
|
continue;
|
|
|
}
|
|
|
if (userInfoService.existsByUserName(username)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "学号已被其他学校使用");
|
|
|
}
|
|
|
Userinfo student = new Userinfo();
|
|
|
student.setUserId(UUID.randomUUID().toString());
|
|
|
student.setName(name);
|
|
|
student.setUsername(username);
|
|
|
student.setPassword("123qwe");
|
|
|
student.setRole(4);
|
|
|
student.setTeacherAdmin(false);
|
|
|
student.setSchoolId(operator.getSchoolId());
|
|
|
student.setCreateTime(new Date());
|
|
|
student.setCodeFrom("教师教学班导入");
|
|
|
importRecords.add(new TeacherRosterImportRecord(targetClass.getSchoolClassId(), student, true));
|
|
|
}
|
|
|
for (TeacherRosterImportRecord record : importRecords) {
|
|
|
Userinfo student = record.student;
|
|
|
if (record.needsInsert && userinfoMapper.insertSelective(student) <= 0) {
|
|
|
throw new IllegalStateException("学生导入失败");
|
|
|
}
|
|
|
upsertActiveTeachingClassMember(record.teachingClassId, student, null, "TEACHER_ROSTER_IMPORT");
|
|
|
}
|
|
|
return new ResultEntity<>(HttpStatus.OK, "导入成功");
|
|
|
}
|
|
|
|
|
|
private static class TeacherRosterImportRecord {
|
|
|
private final String teachingClassId;
|
|
|
private final Userinfo student;
|
|
|
private final boolean needsInsert;
|
|
|
|
|
|
private TeacherRosterImportRecord(String teachingClassId, Userinfo student, boolean needsInsert) {
|
|
|
this.teachingClassId = teachingClassId;
|
|
|
this.student = student;
|
|
|
this.needsInsert = needsInsert;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@PostMapping("/teaching-classes/{teachingClassId}/students/import")
|
|
|
@ApiOperation("教师教学班-导入学生名单")
|
|
|
@Transactional(rollbackFor = Exception.class)
|
|
|
public ResultEntity importTeacherRoster(@PathVariable String teachingClassId,
|
|
|
@RequestParam MultipartFile file,
|
|
|
HttpServletRequest request) {
|
|
|
JwtUser user = TokenProvider.getJWTUser(request);
|
|
|
if (user == null || StringUtils.isBlank(user.getUserId())) {
|
|
|
return new ResultEntity<>(HttpStatus.UNAUTHORIZED, "请先登录");
|
|
|
}
|
|
|
if (file == null || file.isEmpty()) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "请选择要导入的Excel文件");
|
|
|
}
|
|
|
try (InputStream inputStream = file.getInputStream()) {
|
|
|
List<TeacherRosterStudentImportDTO> rows = EasyExcel.read(inputStream)
|
|
|
.head(TeacherRosterStudentImportDTO.class).sheet().doReadSync();
|
|
|
return importTeacherRosterRows(rows, teachingClassId, user.getUserId());
|
|
|
} catch (Exception exception) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "数据校验失败", exception.getMessage());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@PostMapping("/teaching-classes/students/import")
|
|
|
@ApiOperation("教师教学班-按班级名称导入学生名单")
|
|
|
@Transactional(rollbackFor = Exception.class)
|
|
|
public ResultEntity importTeacherRosterByClassName(@RequestParam MultipartFile file,
|
|
|
HttpServletRequest request) {
|
|
|
JwtUser user = TokenProvider.getJWTUser(request);
|
|
|
if (user == null || StringUtils.isBlank(user.getUserId())) {
|
|
|
return new ResultEntity<>(HttpStatus.UNAUTHORIZED, "请先登录");
|
|
|
}
|
|
|
if (file == null || file.isEmpty()) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "请选择要导入的Excel文件");
|
|
|
}
|
|
|
try (InputStream inputStream = file.getInputStream()) {
|
|
|
List<TeacherRosterStudentImportDTO> rows = EasyExcel.read(inputStream)
|
|
|
.head(TeacherRosterStudentImportDTO.class).sheet().doReadSync();
|
|
|
return importTeacherRosterRows(rows, null, user.getUserId());
|
|
|
} catch (Exception exception) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "数据校验失败", exception.getMessage());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
ResultEntity addSchoolClass(String schoolId,
|
|
|
String schoolFacultyId,
|
|
|
String schoolMajorId,
|
|
|
String className,
|
|
|
String userId,
|
|
|
String classType,
|
|
|
String sourceClassIds) {
|
|
|
return addSchoolClass(schoolId, schoolFacultyId, schoolMajorId, className,
|
|
|
userId, classType, sourceClassIds, false);
|
|
|
}
|
|
|
|
|
|
@PostMapping("/uploadTeachingClassByStudentMembers")
|
|
|
@ApiOperation("教学班-导入名单创建教学班")
|
|
|
@AnonymousAccess
|
|
|
public ResultEntity uploadTeachingClassByStudentMembers(@RequestParam MultipartFile file,
|
|
|
@RequestParam String schoolId,
|
|
|
@RequestParam String schoolFacultyId,
|
|
|
@RequestParam String schoolMajorId,
|
|
|
@RequestParam String className,
|
|
|
@RequestParam String operatorId,
|
|
|
@RequestParam(required = false) String sourceClassIds,
|
|
|
@RequestParam(required = false, defaultValue = "false") Boolean confirmMultiTeachingClass) {
|
|
|
if (file.isEmpty()) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "上传文件不能为空！");
|
|
|
}
|
|
|
String originalFilename = file.getOriginalFilename();
|
|
|
if (StringUtils.isBlank(originalFilename)
|
|
|
|| (!originalFilename.endsWith(".xls") && !originalFilename.endsWith(".xlsx"))) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "请上传Excel文件！");
|
|
|
}
|
|
|
if (file.getSize() > 10 * 1024 * 1024) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "文件大小不能超过10MB！");
|
|
|
}
|
|
|
try (InputStream inputStream = file.getInputStream()) {
|
|
|
List<TeachingClassStudentImportDTO> rows = EasyExcel.read(inputStream)
|
|
|
.head(TeachingClassStudentImportDTO.class)
|
|
|
.sheet()
|
|
|
.doReadSync();
|
|
|
return createTeachingClassByImportRows(rows, schoolId, schoolFacultyId, schoolMajorId, className, operatorId, sourceClassIds, confirmMultiTeachingClass);
|
|
|
} catch (Exception e) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "数据校验失败！", e.getMessage());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
ResultEntity importTeachingClassStudentRows(List<TeachingClassStudentImportDTO> rows,
|
|
|
String teachingClassId,
|
|
|
String operatorId) {
|
|
|
return importTeachingClassStudentRows(rows, teachingClassId, operatorId, false);
|
|
|
}
|
|
|
|
|
|
ResultEntity importTeachingClassStudentRows(List<TeachingClassStudentImportDTO> rows,
|
|
|
String teachingClassId,
|
|
|
String operatorId,
|
|
|
Boolean confirmMultiTeachingClass) {
|
|
|
SchoolClass teachingClass = schoolClassMapper.selectByPrimaryKey(teachingClassId);
|
|
|
if (!isOwnedTeachingClass(teachingClass, operatorId)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "只能导入自己创建教学班的学生");
|
|
|
}
|
|
|
List<String> sourceClassIds = parseSourceClassIds(teachingClass.getSourceClassIds());
|
|
|
SchoolMajor teachingMajor = schoolMajorMapper.selectByPrimaryKey(teachingClass.getSchoolMajorId());
|
|
|
String teachingFacultyId = teachingMajor == null ? null : teachingMajor.getSchoolFacultyId();
|
|
|
List<String> errors = sourceClassIds.isEmpty()
|
|
|
? validateTeachingClassImportRowsByMajor(rows, teachingClass.getSchoolId(), teachingFacultyId, teachingClass.getSchoolMajorId())
|
|
|
: validateTeachingClassStudentRows(rows, teachingClass, sourceClassIds);
|
|
|
if (!errors.isEmpty()) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "数据校验失败！", errors);
|
|
|
}
|
|
|
List<Userinfo> studentsToAdd = new ArrayList<>();
|
|
|
for (TeachingClassStudentImportDTO row : rows) {
|
|
|
Userinfo student = sourceClassIds.isEmpty()
|
|
|
? findAdminClassStudent(row, teachingClass.getSchoolId(), teachingFacultyId, teachingClass.getSchoolMajorId())
|
|
|
: findAdminClassStudent(row, teachingClass, sourceClassIds);
|
|
|
if (student == null) {
|
|
|
continue;
|
|
|
}
|
|
|
studentsToAdd.add(student);
|
|
|
}
|
|
|
for (Userinfo student : studentsToAdd) {
|
|
|
upsertActiveTeachingClassMember(teachingClassId, student, student.getSchoolClassId(), "IMPORT");
|
|
|
}
|
|
|
return new ResultEntity<>(HttpStatus.OK, "导入成功！");
|
|
|
}
|
|
|
|
|
|
ResultEntity createTeachingClassByImportRows(List<TeachingClassStudentImportDTO> rows,
|
|
|
String schoolId,
|
|
|
String schoolFacultyId,
|
|
|
String schoolMajorId,
|
|
|
String className,
|
|
|
String operatorId) {
|
|
|
return createTeachingClassByImportRows(rows, schoolId, schoolFacultyId, schoolMajorId, className, operatorId, false);
|
|
|
}
|
|
|
|
|
|
ResultEntity createTeachingClassByImportRows(List<TeachingClassStudentImportDTO> rows,
|
|
|
String schoolId,
|
|
|
String schoolFacultyId,
|
|
|
String schoolMajorId,
|
|
|
String className,
|
|
|
String operatorId,
|
|
|
Boolean confirmMultiTeachingClass) {
|
|
|
return createTeachingClassByImportRows(rows, schoolId, schoolFacultyId, schoolMajorId, className, operatorId, null, confirmMultiTeachingClass);
|
|
|
}
|
|
|
|
|
|
ResultEntity createTeachingClassByImportRows(List<TeachingClassStudentImportDTO> rows,
|
|
|
String schoolId,
|
|
|
String schoolFacultyId,
|
|
|
String schoolMajorId,
|
|
|
String className,
|
|
|
String operatorId,
|
|
|
String selectedSourceClassIds,
|
|
|
Boolean confirmMultiTeachingClass) {
|
|
|
School school = schoolMapper.selectByPrimaryKey(schoolId);
|
|
|
if (school == null) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该学校不存在");
|
|
|
}
|
|
|
SchoolFaculty schoolFaculty = schoolFacultyMapper.selectByPrimaryKey(schoolFacultyId);
|
|
|
if (schoolFaculty == null) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该院系不存在");
|
|
|
}
|
|
|
SchoolMajor schoolMajor = schoolMajorMapper.selectByPrimaryKey(schoolMajorId);
|
|
|
if (schoolMajor == null) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "该专业不存在");
|
|
|
}
|
|
|
if (StringUtils.isBlank(className)) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "班级名称不能为空");
|
|
|
}
|
|
|
SchoolClassExample duplicateExample = new SchoolClassExample();
|
|
|
duplicateExample.createCriteria().andSchoolIdEqualTo(schoolId).andClassNameEqualTo(className);
|
|
|
if (!schoolClassMapper.selectByExample(duplicateExample).isEmpty()) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "班级名称重复");
|
|
|
}
|
|
|
List<String> selectedSourceClassIdList = parseSourceClassIds(selectedSourceClassIds);
|
|
|
List<String> errors = selectedSourceClassIdList.isEmpty()
|
|
|
? validateTeachingClassImportRowsByMajor(rows, schoolId, schoolFacultyId, schoolMajorId)
|
|
|
: validateTeachingClassImportRowsBySourceClasses(rows, schoolId, schoolFacultyId, schoolMajorId, selectedSourceClassIdList);
|
|
|
if (!errors.isEmpty()) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "数据校验失败！", errors);
|
|
|
}
|
|
|
|
|
|
List<Userinfo> importedStudents = new ArrayList<>();
|
|
|
LinkedHashSet<String> sourceClassIds = new LinkedHashSet<>();
|
|
|
SchoolClass importScope = new SchoolClass();
|
|
|
importScope.setSchoolId(schoolId);
|
|
|
for (TeachingClassStudentImportDTO row : rows) {
|
|
|
Userinfo student = selectedSourceClassIdList.isEmpty()
|
|
|
? findAdminClassStudent(row, schoolId, schoolFacultyId, schoolMajorId)
|
|
|
: findAdminClassStudent(row, importScope, selectedSourceClassIdList);
|
|
|
if (student == null) {
|
|
|
continue;
|
|
|
}
|
|
|
importedStudents.add(student);
|
|
|
if (StringUtils.isNotBlank(student.getSchoolClassId())) {
|
|
|
sourceClassIds.add(student.getSchoolClassId());
|
|
|
}
|
|
|
}
|
|
|
if (!selectedSourceClassIdList.isEmpty()) {
|
|
|
sourceClassIds.clear();
|
|
|
sourceClassIds.addAll(selectedSourceClassIdList);
|
|
|
}
|
|
|
|
|
|
SchoolClass teachingClass = new SchoolClass();
|
|
|
teachingClass.setSchoolClassId(UUID.randomUUID().toString());
|
|
|
teachingClass.setSchoolId(schoolId);
|
|
|
teachingClass.setSchoolMajorId(schoolMajorId);
|
|
|
teachingClass.setClassName(className);
|
|
|
teachingClass.setClassSn(pinyin4jUtil.convertToPinyin(school.getSchoolName()) + "_" + pinyin4jUtil.convertToPinyin(className));
|
|
|
teachingClass.setCreateTime(new Date());
|
|
|
teachingClass.setCreatedBy(operatorId);
|
|
|
teachingClass.setClassType("TEACHING");
|
|
|
teachingClass.setDataSource("LOCAL");
|
|
|
teachingClass.setSourceClassIds(String.join(",", sourceClassIds));
|
|
|
int insert = schoolClassMapper.insert(teachingClass);
|
|
|
if (insert != 1) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "新增班级失败");
|
|
|
}
|
|
|
|
|
|
for (Userinfo student : importedStudents) {
|
|
|
upsertActiveTeachingClassMember(teachingClass.getSchoolClassId(), student, student.getSchoolClassId(), "IMPORT_CREATE");
|
|
|
}
|
|
|
return new ResultEntity<>(HttpStatus.OK, "导入创建教学班成功");
|
|
|
}
|
|
|
|
|
|
//微信绑定*****
|
|
|
//导入 ***** 创建资金账户
|
|
|
@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,
|
|
|
@RequestParam(required = false) String operatorId,
|
|
|
@RequestParam(required = false) String schoolClassId) {
|
|
|
Userinfo operator = StringUtils.isBlank(operatorId) ? null : userinfoMapper.selectByPrimaryKey(operatorId);
|
|
|
boolean teacherRosterScope = isSchoolTeacher(operator) && isTeacherRosterMode(operator.getSchoolId());
|
|
|
if (teacherRosterScope) {
|
|
|
schoolId = operator.getSchoolId();
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(schoolId)) {
|
|
|
UserinfoExample userInfoExample = new UserinfoExample();
|
|
|
userInfoExample.createCriteria().andSchoolIdEqualTo(schoolId).andRoleEqualTo(4);
|
|
|
if (teacherRosterScope) {
|
|
|
List<String> managedStudentIds = resolveManagedRosterStudentIds(operator, schoolClassId);
|
|
|
if (managedStudentIds == null) {
|
|
|
response.setStatus(HttpStatus.BAD_REQUEST.value());
|
|
|
return;
|
|
|
}
|
|
|
userInfoExample.getOredCriteria().get(0)
|
|
|
.andUserIdIn(managedStudentIds.isEmpty() ? Collections.singletonList("__empty__") : managedStudentIds);
|
|
|
}
|
|
|
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 = safeSchoolName(schoolId);
|
|
|
String schoolFacultyName = safeFacultyName(schoolFacultyId);
|
|
|
String schoolMajorName = safeMajorName(schoolMajorId);
|
|
|
|
|
|
userInfo.setSchoolId(schoolName);
|
|
|
userInfo.setSchoolName(schoolName);
|
|
|
userInfo.setSchoolFacultyId(schoolFacultyName);
|
|
|
userInfo.setSchoolMajorId(schoolMajorName);
|
|
|
if (Integer.valueOf(4).equals(userInfo.getRole())) { //查看学生信息
|
|
|
String schoolClassId = userInfo.getSchoolClassId();
|
|
|
String className = safeClassName(schoolClassId);
|
|
|
userInfo.setSchoolClassId(className);
|
|
|
userInfo.setClassName(className);
|
|
|
}
|
|
|
|
|
|
return new ResultEntity<>(HttpStatus.OK, "个人中心-查看用户数据成功！",userInfo);
|
|
|
}
|
|
|
|
|
|
private String safeSchoolName(String schoolId) {
|
|
|
if (StringUtils.isBlank(schoolId)) {
|
|
|
return "";
|
|
|
}
|
|
|
String schoolName = schoolMapper.selectSchoolNameById(schoolId);
|
|
|
return schoolName == null ? "" : schoolName;
|
|
|
}
|
|
|
|
|
|
private String safeFacultyName(String schoolFacultyId) {
|
|
|
if (StringUtils.isBlank(schoolFacultyId)) {
|
|
|
return "";
|
|
|
}
|
|
|
SchoolFaculty schoolFaculty = schoolFacultyMapper.selectByPrimaryKey(schoolFacultyId);
|
|
|
return schoolFaculty == null ? "" : schoolFaculty.getSchoolFacultyName();
|
|
|
}
|
|
|
|
|
|
private String safeMajorName(String schoolMajorId) {
|
|
|
if (StringUtils.isBlank(schoolMajorId)) {
|
|
|
return "";
|
|
|
}
|
|
|
SchoolMajor schoolMajor = schoolMajorMapper.selectByPrimaryKey(schoolMajorId);
|
|
|
return schoolMajor == null ? "" : schoolMajor.getSchoolMajorName();
|
|
|
}
|
|
|
|
|
|
private String safeClassName(String schoolClassId) {
|
|
|
if (StringUtils.isBlank(schoolClassId)) {
|
|
|
return "";
|
|
|
}
|
|
|
SchoolClass schoolClass = schoolClassMapper.selectByPrimaryKey(schoolClassId);
|
|
|
return schoolClass == null ? "" : schoolClass.getClassName();
|
|
|
}
|
|
|
|
|
|
private boolean populateTeacherRosterTeachingClass(Userinfo student, String schoolId) {
|
|
|
if (!isTeacherRosterMode(schoolId) || teachingClassStudentMapper == null || student == null) {
|
|
|
return false;
|
|
|
}
|
|
|
TeachingClassStudent membership = teachingClassStudentMapper.selectActiveByStudentUserId(student.getUserId());
|
|
|
if (membership == null || StringUtils.isBlank(membership.getTeachingClassId())) {
|
|
|
return false;
|
|
|
}
|
|
|
SchoolClass teachingClass = schoolClassMapper.selectByPrimaryKey(membership.getTeachingClassId());
|
|
|
if (teachingClass == null || !"TEACHING".equals(teachingClass.getClassType())) {
|
|
|
return false;
|
|
|
}
|
|
|
student.setTeachingClassId(teachingClass.getSchoolClassId());
|
|
|
student.setClassName(teachingClass.getClassName());
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
private boolean hasMajorUnderFaculty(String schoolFacultyId) {
|
|
|
SchoolMajorExample example = new SchoolMajorExample();
|
|
|
example.createCriteria().andSchoolFacultyIdEqualTo(schoolFacultyId);
|
|
|
return !schoolMajorMapper.selectByExample(example).isEmpty();
|
|
|
}
|
|
|
|
|
|
private boolean hasClassUnderMajor(String schoolMajorId) {
|
|
|
SchoolClassExample example = new SchoolClassExample();
|
|
|
example.createCriteria().andSchoolMajorIdEqualTo(schoolMajorId);
|
|
|
return !schoolClassMapper.selectByExample(example).isEmpty();
|
|
|
}
|
|
|
|
|
|
private boolean classHasStudents(SchoolClass schoolClass) {
|
|
|
if (schoolClass == null) {
|
|
|
return false;
|
|
|
}
|
|
|
if ("TEACHING".equals(schoolClass.getClassType()) && teachingClassStudentMapper != null) {
|
|
|
return teachingClassStudentMapper.countByTeachingClassId(schoolClass.getSchoolClassId()) > 0;
|
|
|
}
|
|
|
UserinfoExample example = new UserinfoExample();
|
|
|
example.createCriteria().andSchoolClassIdEqualTo(schoolClass.getSchoolClassId()).andRoleEqualTo(4);
|
|
|
return !userinfoMapper.selectByExample(example).isEmpty();
|
|
|
}
|
|
|
|
|
|
private String resolveAdminClassIdForTeachingClass(SchoolClass teachingClass) {
|
|
|
if (StringUtils.isBlank(teachingClass.getSourceClassIds())) {
|
|
|
return teachingClass.getSchoolClassId();
|
|
|
}
|
|
|
String sourceClassIds = teachingClass.getSourceClassIds()
|
|
|
.replace("[", "")
|
|
|
.replace("]", "")
|
|
|
.replace("\"", "");
|
|
|
String[] ids = sourceClassIds.split(",");
|
|
|
return StringUtils.trimToEmpty(ids[0]);
|
|
|
}
|
|
|
|
|
|
private boolean isOwnedTeachingClass(SchoolClass schoolClass, String operatorId) {
|
|
|
return schoolClass != null
|
|
|
&& "TEACHING".equals(schoolClass.getClassType())
|
|
|
&& isClassOwner(schoolClass, operatorId);
|
|
|
}
|
|
|
|
|
|
private boolean canManageTeachingClass(Userinfo operator, SchoolClass teachingClass) {
|
|
|
return isSchoolTeacher(operator)
|
|
|
&& teachingClass != null
|
|
|
&& "TEACHING".equals(teachingClass.getClassType())
|
|
|
&& StringUtils.equals(operator.getSchoolId(), teachingClass.getSchoolId())
|
|
|
&& (isTeacherAdmin(operator) || isClassOwner(teachingClass, operator.getUserId()));
|
|
|
}
|
|
|
|
|
|
private boolean isClassOwner(SchoolClass schoolClass, String userId) {
|
|
|
return schoolClass != null
|
|
|
&& StringUtils.isNotBlank(userId)
|
|
|
&& StringUtils.equals(schoolClass.getCreatedBy(), userId);
|
|
|
}
|
|
|
|
|
|
private boolean isAdminClass(SchoolClass schoolClass) {
|
|
|
return schoolClass != null
|
|
|
&& ("ADMIN".equals(schoolClass.getClassType())
|
|
|
|| (StringUtils.isBlank(schoolClass.getClassType()) && StringUtils.isBlank(schoolClass.getCreatedBy())));
|
|
|
}
|
|
|
|
|
|
private void upsertActiveTeachingClassMember(String teachingClassId,
|
|
|
Userinfo student,
|
|
|
String adminClassId,
|
|
|
String joinReason) {
|
|
|
if (teachingClassStudentMapper == null
|
|
|
|| StringUtils.isBlank(teachingClassId)
|
|
|
|| student == null
|
|
|
|| StringUtils.isBlank(student.getUserId())) {
|
|
|
return;
|
|
|
}
|
|
|
TeachingClassStudent existing = teachingClassStudentMapper
|
|
|
.selectByStudentUserIdAndTeachingClassId(student.getUserId(), teachingClassId);
|
|
|
if (existing != null) {
|
|
|
teachingClassStudentMapper.updateMembershipToActive(
|
|
|
student.getUserId(),
|
|
|
teachingClassId,
|
|
|
adminClassId,
|
|
|
joinReason);
|
|
|
return;
|
|
|
}
|
|
|
TeachingClassStudent member = new TeachingClassStudent();
|
|
|
Date now = new Date();
|
|
|
member.setId(UUID.randomUUID().toString());
|
|
|
member.setTeachingClassId(teachingClassId);
|
|
|
member.setStudentUserId(student.getUserId());
|
|
|
member.setAdminClassId(adminClassId);
|
|
|
member.setStatus("IN_PROGRESS");
|
|
|
member.setJoinReason(joinReason);
|
|
|
member.setJoinTime(now);
|
|
|
member.setCreateTime(now);
|
|
|
teachingClassStudentMapper.insertSelective(member);
|
|
|
}
|
|
|
|
|
|
private boolean canModifySchoolClass(Userinfo operator, SchoolClass schoolClass) {
|
|
|
if (operator == null || schoolClass == null) {
|
|
|
return false;
|
|
|
}
|
|
|
if ("ZHIYUN".equals(schoolClass.getDataSource())) {
|
|
|
return false;
|
|
|
}
|
|
|
if (isPlatformAdmin(operator)) {
|
|
|
return true;
|
|
|
}
|
|
|
if (!Integer.valueOf(3).equals(operator.getRole())) {
|
|
|
return false;
|
|
|
}
|
|
|
if (isAdminClass(schoolClass)) {
|
|
|
return canManageAdminClass(operator, schoolClass);
|
|
|
}
|
|
|
return isClassOwner(schoolClass, operator.getUserId());
|
|
|
}
|
|
|
|
|
|
private ResultEntity buildMultiTeachingClassConflict(List<Userinfo> students, String targetTeachingClassId) {
|
|
|
if (students == null || students.isEmpty()) {
|
|
|
return null;
|
|
|
}
|
|
|
List<String> conflicts = new ArrayList<>();
|
|
|
Set<String> studentIds = new HashSet<>();
|
|
|
for (Userinfo student : students) {
|
|
|
if (student == null || StringUtils.isBlank(student.getUserId()) || !studentIds.add(student.getUserId())) {
|
|
|
continue;
|
|
|
}
|
|
|
if (teachingClassStudentMapper.countByStudentUserIdExcludingTeachingClass(
|
|
|
student.getUserId(), StringUtils.trimToEmpty(targetTeachingClassId)) > 0) {
|
|
|
conflicts.add(formatStudentConflict(student));
|
|
|
}
|
|
|
}
|
|
|
if (conflicts.isEmpty()) {
|
|
|
return null;
|
|
|
}
|
|
|
return new ResultEntity<>(HttpStatus.CONFLICT, "部分学生已在其他教学班，确认后可继续操作", conflicts);
|
|
|
}
|
|
|
|
|
|
private String formatStudentConflict(Userinfo student) {
|
|
|
String name = StringUtils.defaultIfBlank(student.getName(), "未命名学生");
|
|
|
String username = StringUtils.defaultIfBlank(student.getUsername(), "-");
|
|
|
return name + "(" + username + ")";
|
|
|
}
|
|
|
|
|
|
private List<Userinfo> findStudentsByAdminClassIds(List<String> sourceClassIds) {
|
|
|
if (sourceClassIds == null || sourceClassIds.isEmpty()) {
|
|
|
return Collections.emptyList();
|
|
|
}
|
|
|
UserinfoExample example = new UserinfoExample();
|
|
|
example.createCriteria()
|
|
|
.andRoleEqualTo(4)
|
|
|
.andSchoolClassIdIn(sourceClassIds);
|
|
|
List<Userinfo> students = userinfoMapper.selectByExample(example);
|
|
|
return students == null ? Collections.emptyList() : students;
|
|
|
}
|
|
|
|
|
|
private void createTeachingClassMembersFromSourceClasses(SchoolClass teachingClass) {
|
|
|
if (teachingClassStudentMapper == null
|
|
|
|| teachingClass == null
|
|
|
|| !"TEACHING".equals(teachingClass.getClassType())
|
|
|
|| StringUtils.isBlank(teachingClass.getSourceClassIds())) {
|
|
|
return;
|
|
|
}
|
|
|
List<String> sourceClassIds = parseSourceClassIds(teachingClass.getSourceClassIds());
|
|
|
if (sourceClassIds.isEmpty()) {
|
|
|
return;
|
|
|
}
|
|
|
List<Userinfo> students = findStudentsByAdminClassIds(sourceClassIds);
|
|
|
for (Userinfo student : students) {
|
|
|
if (student == null || StringUtils.isBlank(student.getUserId())) {
|
|
|
continue;
|
|
|
}
|
|
|
upsertActiveTeachingClassMember(teachingClass.getSchoolClassId(), student, student.getSchoolClassId(), "ADMIN_CLASS_MERGE");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private List<String> validateTeachingClassStudentRows(List<TeachingClassStudentImportDTO> rows,
|
|
|
SchoolClass teachingClass,
|
|
|
List<String> sourceClassIds) {
|
|
|
List<String> errors = new ArrayList<>();
|
|
|
if (rows == null || rows.isEmpty()) {
|
|
|
errors.add("Excel中没有数据");
|
|
|
return errors;
|
|
|
}
|
|
|
Set<String> rowKeys = new HashSet<>();
|
|
|
for (int i = 0; i < rows.size(); i++) {
|
|
|
TeachingClassStudentImportDTO row = rows.get(i);
|
|
|
int rowNum = i + 2;
|
|
|
String studentName = row == null ? "" : StringUtils.trimToEmpty(row.getStudentName());
|
|
|
String userName = row == null ? "" : StringUtils.trimToEmpty(row.getUserName());
|
|
|
if (StringUtils.isBlank(studentName)) {
|
|
|
errors.add("第" + rowNum + "行 学生姓名不能为空");
|
|
|
}
|
|
|
if (StringUtils.isBlank(userName)) {
|
|
|
errors.add("第" + rowNum + "行 学号不能为空");
|
|
|
}
|
|
|
if (StringUtils.isBlank(studentName) || StringUtils.isBlank(userName)) {
|
|
|
continue;
|
|
|
}
|
|
|
String rowKey = studentName + "#" + userName;
|
|
|
if (!rowKeys.add(rowKey)) {
|
|
|
errors.add("第" + rowNum + "行 学生姓名和学号重复");
|
|
|
continue;
|
|
|
}
|
|
|
Userinfo student = findAdminClassStudent(row, teachingClass, sourceClassIds);
|
|
|
if (student == null) {
|
|
|
errors.add("第" + rowNum + "行 学生姓名与学号未匹配到来源行政班学生");
|
|
|
}
|
|
|
}
|
|
|
return errors;
|
|
|
}
|
|
|
|
|
|
private Userinfo findAdminClassStudent(TeachingClassStudentImportDTO row,
|
|
|
SchoolClass teachingClass,
|
|
|
List<String> sourceClassIds) {
|
|
|
if (row == null || teachingClass == null || sourceClassIds == null || sourceClassIds.isEmpty()) {
|
|
|
return null;
|
|
|
}
|
|
|
UserinfoExample example = new UserinfoExample();
|
|
|
example.createCriteria()
|
|
|
.andRoleEqualTo(4)
|
|
|
.andSchoolIdEqualTo(teachingClass.getSchoolId())
|
|
|
.andNameEqualTo(StringUtils.trimToEmpty(row.getStudentName()))
|
|
|
.andUsernameEqualTo(StringUtils.trimToEmpty(row.getUserName()))
|
|
|
.andSchoolClassIdIn(sourceClassIds);
|
|
|
List<Userinfo> students = userinfoMapper.selectByExample(example);
|
|
|
if (students == null || students.isEmpty()) {
|
|
|
return null;
|
|
|
}
|
|
|
return students.get(0);
|
|
|
}
|
|
|
|
|
|
private List<String> validateTeachingClassImportRowsByMajor(List<TeachingClassStudentImportDTO> rows,
|
|
|
String schoolId,
|
|
|
String schoolFacultyId,
|
|
|
String schoolMajorId) {
|
|
|
List<String> errors = new ArrayList<>();
|
|
|
if (rows == null || rows.isEmpty()) {
|
|
|
errors.add("Excel中没有数据");
|
|
|
return errors;
|
|
|
}
|
|
|
Set<String> rowKeys = new HashSet<>();
|
|
|
for (int i = 0; i < rows.size(); i++) {
|
|
|
TeachingClassStudentImportDTO row = rows.get(i);
|
|
|
int rowNum = i + 2;
|
|
|
String studentName = row == null ? "" : StringUtils.trimToEmpty(row.getStudentName());
|
|
|
String userName = row == null ? "" : StringUtils.trimToEmpty(row.getUserName());
|
|
|
if (StringUtils.isBlank(studentName)) {
|
|
|
errors.add("第" + rowNum + "行 学生姓名不能为空");
|
|
|
}
|
|
|
if (StringUtils.isBlank(userName)) {
|
|
|
errors.add("第" + rowNum + "行 学号不能为空");
|
|
|
}
|
|
|
if (StringUtils.isBlank(studentName) || StringUtils.isBlank(userName)) {
|
|
|
continue;
|
|
|
}
|
|
|
String rowKey = studentName + "#" + userName;
|
|
|
if (!rowKeys.add(rowKey)) {
|
|
|
errors.add("第" + rowNum + "行 学生姓名和学号重复");
|
|
|
continue;
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(row.getSchoolClassName())) {
|
|
|
SchoolClass adminClass = findTeacherImportClass(schoolId, schoolMajorId, StringUtils.trimToEmpty(row.getSchoolClassName()));
|
|
|
if (adminClass == null || !"ADMIN".equals(adminClass.getClassType())) {
|
|
|
errors.add("第" + rowNum + "行 未匹配到行政班：" + row.getSchoolClassName());
|
|
|
continue;
|
|
|
}
|
|
|
}
|
|
|
Userinfo student = findAdminClassStudent(row, schoolId, schoolFacultyId, schoolMajorId);
|
|
|
if (student == null) {
|
|
|
errors.add("第" + rowNum + "行 学生姓名与学号未匹配到该专业下的行政班学生");
|
|
|
}
|
|
|
}
|
|
|
return errors;
|
|
|
}
|
|
|
|
|
|
private List<String> validateTeachingClassImportRowsBySourceClasses(List<TeachingClassStudentImportDTO> rows,
|
|
|
String schoolId,
|
|
|
String schoolFacultyId,
|
|
|
String schoolMajorId,
|
|
|
List<String> sourceClassIds) {
|
|
|
List<String> errors = new ArrayList<>();
|
|
|
if (sourceClassIds == null || sourceClassIds.isEmpty()) {
|
|
|
errors.add("请选择来源行政班");
|
|
|
return errors;
|
|
|
}
|
|
|
for (String sourceClassId : sourceClassIds) {
|
|
|
SchoolClass sourceClass = schoolClassMapper.selectByPrimaryKey(sourceClassId);
|
|
|
if (sourceClass == null) {
|
|
|
errors.add("来源行政班不存在");
|
|
|
continue;
|
|
|
}
|
|
|
if (!"ADMIN".equals(sourceClass.getClassType())
|
|
|
|| !schoolId.equals(sourceClass.getSchoolId())
|
|
|
|| !schoolMajorId.equals(sourceClass.getSchoolMajorId())) {
|
|
|
errors.add("来源行政班不属于当前学校和专业");
|
|
|
}
|
|
|
}
|
|
|
if (!errors.isEmpty()) {
|
|
|
return errors;
|
|
|
}
|
|
|
SchoolClass importScope = new SchoolClass();
|
|
|
importScope.setSchoolId(schoolId);
|
|
|
List<String> rowErrors = validateTeachingClassStudentRows(rows, importScope, sourceClassIds);
|
|
|
for (String rowError : rowErrors) {
|
|
|
errors.add(rowError.replace("来源行政班学生", "所选来源行政班学生"));
|
|
|
}
|
|
|
return errors;
|
|
|
}
|
|
|
|
|
|
private Userinfo findAdminClassStudent(TeachingClassStudentImportDTO row,
|
|
|
String schoolId,
|
|
|
String schoolFacultyId,
|
|
|
String schoolMajorId) {
|
|
|
if (row == null) {
|
|
|
return null;
|
|
|
}
|
|
|
UserinfoExample example = new UserinfoExample();
|
|
|
UserinfoExample.Criteria criteria = example.createCriteria()
|
|
|
.andRoleEqualTo(4)
|
|
|
.andSchoolIdEqualTo(schoolId)
|
|
|
.andSchoolFacultyIdEqualTo(schoolFacultyId)
|
|
|
.andSchoolMajorIdEqualTo(schoolMajorId)
|
|
|
.andNameEqualTo(StringUtils.trimToEmpty(row.getStudentName()))
|
|
|
.andUsernameEqualTo(StringUtils.trimToEmpty(row.getUserName()));
|
|
|
if (StringUtils.isNotBlank(row.getSchoolClassName())) {
|
|
|
SchoolClass adminClass = findTeacherImportClass(schoolId, schoolMajorId, StringUtils.trimToEmpty(row.getSchoolClassName()));
|
|
|
criteria.andSchoolClassIdEqualTo(adminClass == null ? "__missing__" : adminClass.getSchoolClassId());
|
|
|
}
|
|
|
List<Userinfo> students = userinfoMapper.selectByExample(example);
|
|
|
if (students == null || students.isEmpty()) {
|
|
|
return null;
|
|
|
}
|
|
|
return students.get(0);
|
|
|
}
|
|
|
|
|
|
private ResultEntity validateTeacherStudentImportFile(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格式文件");
|
|
|
}
|
|
|
if (file.getSize() > 10 * 1024 * 1024) {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "文件大小不能超过10MB");
|
|
|
}
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
private List<Userinfo> buildTeacherImportStudents(List<SchoolAdminStudentImportDTO> rows,
|
|
|
Userinfo operator,
|
|
|
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 (isBlankTeacherStudentImportRow(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 = normalizeTeacherImportSex(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.isNotBlank(row.getSex()) && sex == null) {
|
|
|
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 : findTeacherImportFaculty(operator.getSchoolId(), facultyName);
|
|
|
SchoolMajor major = null;
|
|
|
SchoolClass schoolClass = null;
|
|
|
if (StringUtils.isNotBlank(facultyName) && faculty == null) {
|
|
|
errors.add("第" + rowNumber + "行：未找到院系“" + facultyName + "”");
|
|
|
}
|
|
|
if (faculty != null && StringUtils.isNotBlank(majorName)) {
|
|
|
major = findTeacherImportMajor(faculty.getSchoolFacultyId(), majorName);
|
|
|
if (major == null) {
|
|
|
errors.add("第" + rowNumber + "行：院系“" + facultyName + "”下未找到专业“" + majorName + "”");
|
|
|
}
|
|
|
}
|
|
|
if (major != null && StringUtils.isNotBlank(className)) {
|
|
|
schoolClass = findTeacherImportClass(operator.getSchoolId(), major.getSchoolMajorId(), className);
|
|
|
if (schoolClass == null) {
|
|
|
errors.add("第" + rowNumber + "行：专业“" + majorName + "”下未找到班级“" + className + "”");
|
|
|
} else if (!isAdminClass(schoolClass)) {
|
|
|
errors.add("第" + rowNumber + "行：学生账号只能导入行政班");
|
|
|
} else if (!canManageAdminClass(operator, schoolClass)) {
|
|
|
errors.add("第" + rowNumber + "行：只能导入本校行政班");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (!hasTeacherImportRowError(errors, rowNumber)) {
|
|
|
Userinfo student = new Userinfo();
|
|
|
student.setUserId(UUID.randomUUID().toString());
|
|
|
student.setName(name);
|
|
|
student.setUsername(username);
|
|
|
student.setPassword("123qwe");
|
|
|
student.setSex(StringUtils.defaultString(sex));
|
|
|
student.setPhone(StringUtils.trimToEmpty(row.getPhone()));
|
|
|
student.setEmail(StringUtils.trimToEmpty(row.getEmail()));
|
|
|
student.setRole(4);
|
|
|
student.setTeacherAdmin(false);
|
|
|
student.setSchoolId(operator.getSchoolId());
|
|
|
student.setSchoolFacultyId(faculty.getSchoolFacultyId());
|
|
|
student.setSchoolMajorId(major.getSchoolMajorId());
|
|
|
student.setSchoolClassId(schoolClass.getSchoolClassId());
|
|
|
student.setCreateTime(new Date());
|
|
|
student.setCodeFrom("Excel导入");
|
|
|
students.add(student);
|
|
|
}
|
|
|
}
|
|
|
return students;
|
|
|
}
|
|
|
|
|
|
private boolean isBlankTeacherStudentImportRow(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 normalizeTeacherImportSex(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 hasTeacherImportRowError(List<String> errors, int rowNumber) {
|
|
|
String prefix = "第" + rowNumber + "行：";
|
|
|
for (String error : errors) {
|
|
|
if (error.startsWith(prefix)) {
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
private SchoolFaculty findTeacherImportFaculty(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 findTeacherImportMajor(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 findTeacherImportClass(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 List<String> parseSourceClassIds(String sourceClassIds) {
|
|
|
List<String> ids = new ArrayList<>();
|
|
|
if (StringUtils.isBlank(sourceClassIds)) {
|
|
|
return ids;
|
|
|
}
|
|
|
for (String sourceClassId : sourceClassIds.split(",")) {
|
|
|
String trimmed = StringUtils.trimToEmpty(sourceClassId);
|
|
|
if (StringUtils.isNotBlank(trimmed) && !ids.contains(trimmed)) {
|
|
|
ids.add(trimmed);
|
|
|
}
|
|
|
}
|
|
|
return ids;
|
|
|
}
|
|
|
|
|
|
private ResultEntity noManagePermission() {
|
|
|
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "权限不足");
|
|
|
}
|
|
|
|
|
|
private boolean isPlatformAdmin(Userinfo userInfo) {
|
|
|
return userInfo != null && Integer.valueOf(1).equals(userInfo.getRole());
|
|
|
}
|
|
|
|
|
|
private boolean canCreateSchoolClass(String operatorId, String schoolId, String classType) {
|
|
|
if (StringUtils.isAnyBlank(operatorId, schoolId, classType)) {
|
|
|
return false;
|
|
|
}
|
|
|
Userinfo operator = userinfoMapper.selectByPrimaryKey(operatorId);
|
|
|
if (isPlatformAdmin(operator)) {
|
|
|
return !"ADMIN".equals(classType) || isAdminClassManagementEnabled(schoolId);
|
|
|
}
|
|
|
if (!Integer.valueOf(3).equals(operator == null ? null : operator.getRole())
|
|
|
|| !StringUtils.equals(operator.getSchoolId(), schoolId)) {
|
|
|
return false;
|
|
|
}
|
|
|
if ("TEACHING".equals(classType)) {
|
|
|
return true;
|
|
|
}
|
|
|
if ("ADMIN".equals(classType)) {
|
|
|
return isAdminClassManagementEnabled(schoolId);
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
private boolean isTeacherAdmin(Userinfo userInfo) {
|
|
|
return userInfo != null
|
|
|
&& Integer.valueOf(3).equals(userInfo.getRole())
|
|
|
&& Boolean.TRUE.equals(userInfo.getTeacherAdmin());
|
|
|
}
|
|
|
|
|
|
private boolean isSchoolTeacher(Userinfo userInfo) {
|
|
|
return userInfo != null
|
|
|
&& Integer.valueOf(3).equals(userInfo.getRole())
|
|
|
&& StringUtils.isNotBlank(userInfo.getSchoolId());
|
|
|
}
|
|
|
|
|
|
private boolean canManageAdminClass(Userinfo operator, SchoolClass schoolClass) {
|
|
|
if (operator == null || !isAdminClass(schoolClass)) {
|
|
|
return false;
|
|
|
}
|
|
|
if (isPlatformAdmin(operator)) {
|
|
|
return isAdminClassManagementEnabled(schoolClass.getSchoolId());
|
|
|
}
|
|
|
return isSchoolTeacher(operator)
|
|
|
&& StringUtils.equals(operator.getSchoolId(), schoolClass.getSchoolId())
|
|
|
&& isAdminClassManagementEnabled(schoolClass.getSchoolId());
|
|
|
}
|
|
|
|
|
|
private boolean canManageSchoolStructure(String operatorId, String schoolId) {
|
|
|
if (StringUtils.isAnyBlank(operatorId, schoolId)) {
|
|
|
return false;
|
|
|
}
|
|
|
Userinfo operator = userinfoMapper.selectByPrimaryKey(operatorId);
|
|
|
if (isPlatformAdmin(operator)) {
|
|
|
return true;
|
|
|
}
|
|
|
return isTeacherAdmin(operator)
|
|
|
&& StringUtils.equals(operator.getSchoolId(), schoolId)
|
|
|
&& !isTeacherRosterMode(schoolId);
|
|
|
}
|
|
|
|
|
|
private boolean canManageFaculty(String operatorId, String schoolId) {
|
|
|
return hasSchoolStructureAuthority(operatorId, schoolId) && isFacultyManagementEnabled(schoolId);
|
|
|
}
|
|
|
|
|
|
private boolean canManageMajorStructure(String operatorId, String schoolId) {
|
|
|
return hasSchoolStructureAuthority(operatorId, schoolId) && isMajorManagementEnabled(schoolId);
|
|
|
}
|
|
|
|
|
|
private boolean hasSchoolStructureAuthority(String operatorId, String schoolId) {
|
|
|
if (StringUtils.isAnyBlank(operatorId, schoolId)) {
|
|
|
return false;
|
|
|
}
|
|
|
Userinfo operator = userinfoMapper.selectByPrimaryKey(operatorId);
|
|
|
return isPlatformAdmin(operator)
|
|
|
|| (isTeacherAdmin(operator) && StringUtils.equals(operator.getSchoolId(), schoolId));
|
|
|
}
|
|
|
|
|
|
private boolean isFacultyManagementEnabled(String schoolId) {
|
|
|
return schoolProductConfigService != null && schoolProductConfigService.isFacultyManagementEnabled(schoolId);
|
|
|
}
|
|
|
|
|
|
private boolean isMajorManagementEnabled(String schoolId) {
|
|
|
return schoolProductConfigService != null && schoolProductConfigService.isMajorManagementEnabled(schoolId);
|
|
|
}
|
|
|
|
|
|
private boolean isAdminClassManagementEnabled(String schoolId) {
|
|
|
return schoolProductConfigService != null && schoolProductConfigService.isAdminClassManagementEnabled(schoolId);
|
|
|
}
|
|
|
|
|
|
private boolean isTeacherRosterMode(String schoolId) {
|
|
|
return schoolProductConfigService != null
|
|
|
&& schoolProductConfigService.isTeacherRosterManaged(schoolId);
|
|
|
}
|
|
|
|
|
|
private boolean canManageMajor(String operatorId, String schoolMajorId) {
|
|
|
if (StringUtils.isBlank(schoolMajorId)) {
|
|
|
return false;
|
|
|
}
|
|
|
SchoolMajor major = schoolMajorMapper.selectByPrimaryKey(schoolMajorId);
|
|
|
if (major == null || StringUtils.isBlank(major.getSchoolFacultyId())) {
|
|
|
return false;
|
|
|
}
|
|
|
SchoolFaculty faculty = schoolFacultyMapper.selectByPrimaryKey(major.getSchoolFacultyId());
|
|
|
return faculty != null && canManageMajorStructure(operatorId, faculty.getSchoolId());
|
|
|
}
|
|
|
|
|
|
private boolean teacherHasCreatedClass(String teacherId) {
|
|
|
SchoolClassExample example = new SchoolClassExample();
|
|
|
example.createCriteria().andCreatedByEqualTo(teacherId);
|
|
|
List<SchoolClass> classes = schoolClassMapper.selectByExample(example);
|
|
|
return classes != null && !classes.isEmpty();
|
|
|
}
|
|
|
|
|
|
private void markTeachersWithCreatedClasses(List<Userinfo> teachers) {
|
|
|
if (teachers == null || teachers.isEmpty()) {
|
|
|
return;
|
|
|
}
|
|
|
List<String> teacherIds = teachers.stream()
|
|
|
.map(Userinfo::getUserId)
|
|
|
.filter(StringUtils::isNotBlank)
|
|
|
.collect(java.util.stream.Collectors.toList());
|
|
|
if (teacherIds.isEmpty()) {
|
|
|
return;
|
|
|
}
|
|
|
SchoolClassExample example = new SchoolClassExample();
|
|
|
example.createCriteria().andCreatedByIn(teacherIds);
|
|
|
Set<String> classOwnerIds = schoolClassMapper.selectByExample(example).stream()
|
|
|
.map(SchoolClass::getCreatedBy)
|
|
|
.filter(StringUtils::isNotBlank)
|
|
|
.collect(java.util.stream.Collectors.toSet());
|
|
|
teachers.forEach(teacher -> teacher.setHasCreatedClass(classOwnerIds.contains(teacher.getUserId())));
|
|
|
}
|
|
|
|
|
|
private boolean canOperateClass(String operatorId, String schoolClassId) {
|
|
|
Userinfo operator = userinfoMapper.selectByPrimaryKey(operatorId);
|
|
|
if (operator == null) {
|
|
|
return false;
|
|
|
}
|
|
|
if (Integer.valueOf(1).equals(operator.getRole())) {
|
|
|
return true;
|
|
|
}
|
|
|
if (!Integer.valueOf(3).equals(operator.getRole())) {
|
|
|
return false;
|
|
|
}
|
|
|
SchoolClass schoolClass = schoolClassMapper.selectByPrimaryKey(schoolClassId);
|
|
|
if (canManageTeachingClass(operator, schoolClass)) {
|
|
|
return true;
|
|
|
}
|
|
|
if (canManageAdminClass(operator, schoolClass)) {
|
|
|
return true;
|
|
|
}
|
|
|
return isClassOwner(schoolClass, operatorId);
|
|
|
}
|
|
|
|
|
|
private boolean canOperateStudent(String operatorId, String studentId) {
|
|
|
return canOperateStudent(operatorId, studentId, null);
|
|
|
}
|
|
|
|
|
|
private boolean canOperateStudent(String operatorId, String studentId, String teachingClassId) {
|
|
|
Userinfo student = userinfoMapper.selectByPrimaryKey(studentId);
|
|
|
if (student == null || !Integer.valueOf(4).equals(student.getRole())) {
|
|
|
return false;
|
|
|
}
|
|
|
if (StringUtils.isNotBlank(teachingClassId)) {
|
|
|
SchoolClass teachingClass = schoolClassMapper.selectByPrimaryKey(teachingClassId);
|
|
|
return "TEACHING".equals(teachingClass == null ? null : teachingClass.getClassType())
|
|
|
&& canOperateClass(operatorId, teachingClassId)
|
|
|
&& teachingClassStudentMapper != null
|
|
|
&& teachingClassStudentMapper.countByStudentUserIdAndTeachingClassId(studentId, teachingClassId) > 0;
|
|
|
}
|
|
|
return canOperateClass(operatorId, student.getSchoolClassId());
|
|
|
}
|
|
|
|
|
|
@PostMapping("/selectCurrentTeachingClass")
|
|
|
@ApiOperation("学生-查询当前在读教学班")
|
|
|
@AnonymousAccess
|
|
|
public ResultEntity<SchoolClass> selectCurrentTeachingClass(@RequestParam String userId, HttpServletRequest request) {
|
|
|
try {
|
|
|
JwtUser currentUser = TokenProvider.getJWTUser(request);
|
|
|
if (currentUser != null && currentUser.getRoleId() == 4 && studentTeachingClassResolver != null) {
|
|
|
SchoolClass teachingClass = schoolClassMapper.selectByPrimaryKey(studentTeachingClassResolver.resolveRequired(currentUser));
|
|
|
return new ResultEntity<>(HttpStatus.OK, "查询成功", teachingClass);
|
|
|
}
|
|
|
} catch (RuntimeException ignored) {
|
|
|
// 保留旧版匿名调用的兼容路径。
|
|
|
}
|
|
|
TeachingClassStudent member = teachingClassStudentMapper == null
|
|
|
? null
|
|
|
: teachingClassStudentMapper.selectActiveByStudentUserId(userId);
|
|
|
if (member == null || StringUtils.isBlank(member.getTeachingClassId())) {
|
|
|
return new ResultEntity<>(HttpStatus.OK, "当前学生未分配在读教学班");
|
|
|
}
|
|
|
SchoolClass teachingClass = schoolClassMapper.selectByPrimaryKey(member.getTeachingClassId());
|
|
|
return new ResultEntity<>(HttpStatus.OK, "查询成功", teachingClass);
|
|
|
}
|
|
|
|
|
|
@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);
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|