feat: manage school default task allocations

main
chenyuan 1 month ago
parent b760a5cfee
commit 2b00d63a05

@ -0,0 +1,81 @@
package com.sztzjy.linkCommerce.controller.stu;
import com.sztzjy.linkCommerce.config.exception.UnAuthorizedException;
import com.sztzjy.linkCommerce.config.security.JwtUser;
import com.sztzjy.linkCommerce.config.security.TokenProvider;
import com.sztzjy.linkCommerce.entity.SchoolDefaultTaskInitialization;
import com.sztzjy.linkCommerce.entity.TaskAllocation;
import com.sztzjy.linkCommerce.entity.Userinfo;
import com.sztzjy.linkCommerce.mapper.UserinfoMapper;
import com.sztzjy.linkCommerce.service.SchoolDefaultTaskService;
import com.sztzjy.linkCommerce.util.ResultEntity;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Api(tags = "学校默认实训任务")
@RequestMapping("api/school-default-tasks")
@RestController
public class SchoolDefaultTaskController {
@Autowired
SchoolDefaultTaskService schoolDefaultTaskService;
@Autowired
UserinfoMapper userinfoMapper;
@GetMapping
@ApiOperation("查询学校默认实训任务")
public ResultEntity<Map<String, Object>> get(HttpServletRequest request) {
Userinfo operator = requireManagerTeacher(request);
SchoolDefaultTaskInitialization initialization = schoolDefaultTaskService.getInitialization(operator.getSchoolId());
List<TaskAllocation> tasks = schoolDefaultTaskService.getSchoolDefault(operator.getSchoolId());
String status = initialization == null ? (tasks.isEmpty() ? "INITIALIZING" : "READY") : initialization.getStatus();
if (tasks.isEmpty()) {
tasks = schoolDefaultTaskService.getPlatformDefault();
}
Map<String, Object> data = new HashMap<>();
data.put("status", status);
data.put("tasks", tasks);
data.put("lastError", initialization == null ? null : initialization.getLastError());
return new ResultEntity<>(HttpStatus.OK, "查询成功", data);
}
@PutMapping
@ApiOperation("保存学校默认实训任务")
public ResultEntity replace(@RequestBody List<TaskAllocation> tasks, HttpServletRequest request) {
Userinfo operator = requireManagerTeacher(request);
SchoolDefaultTaskInitialization initialization = schoolDefaultTaskService.getInitialization(operator.getSchoolId());
if (initialization != null && !"READY".equals(initialization.getStatus())) {
return new ResultEntity<>(HttpStatus.BAD_REQUEST, "默认实训任务尚未初始化完成");
}
schoolDefaultTaskService.replaceSchoolDefault(operator.getSchoolId(), tasks);
return new ResultEntity<>(HttpStatus.OK, "保存成功");
}
@PostMapping("/retry")
@ApiOperation("重试初始化学校默认实训任务")
public ResultEntity retry(HttpServletRequest request) {
Userinfo operator = requireManagerTeacher(request);
schoolDefaultTaskService.enqueueInitialization(operator.getSchoolId());
return new ResultEntity<>(HttpStatus.OK, "已提交初始化任务");
}
private Userinfo requireManagerTeacher(HttpServletRequest request) {
JwtUser currentUser = TokenProvider.getJWTUser(request);
if (currentUser == null || currentUser.getUserId() == null) {
throw new UnAuthorizedException("身份认证失败");
}
Userinfo operator = userinfoMapper.selectByPrimaryKey(currentUser.getUserId());
if (operator == null || !Integer.valueOf(3).equals(operator.getRole())
|| !Boolean.TRUE.equals(operator.getTeacherAdmin())) {
throw new UnAuthorizedException("仅管理员教师可维护学校默认实训任务");
}
return operator;
}
}

@ -8,6 +8,7 @@ import com.sztzjy.linkCommerce.entity.TeachingClassStudent;
import com.sztzjy.linkCommerce.mapper.SchoolClassMapper;
import com.sztzjy.linkCommerce.mapper.TaskAllocationMapper;
import com.sztzjy.linkCommerce.mapper.TeachingClassStudentMapper;
import com.sztzjy.linkCommerce.service.SchoolDefaultTaskService;
import com.sztzjy.linkCommerce.util.ResultEntity;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
@ -30,11 +31,16 @@ public class TaskAllocationController {
SchoolClassMapper schoolClassMapper;
@Autowired
TeachingClassStudentMapper teachingClassStudentMapper;
@Autowired(required = false)
SchoolDefaultTaskService schoolDefaultTaskService;
@PostMapping("/selectTaskAllocationByClassId")
@ApiOperation("根据班级ID查询任务分配")
@AnonymousAccess
public ResultEntity<List<TaskAllocation>> selectTaskAllocationByClassId(@RequestParam String classId) {
if (schoolDefaultTaskService != null && !"999999999".equals(classId)) {
return new ResultEntity<>(HttpStatus.OK, "查询成功", schoolDefaultTaskService.resolveForTeachingClass(classId));
}
TaskAllocationExample taskAllocationExample = new TaskAllocationExample();
taskAllocationExample.createCriteria().andClassIdEqualTo(classId);
taskAllocationExample.setOrderByClause("sort asc");

@ -12,6 +12,8 @@ public interface SchoolDefaultTaskService {
List<TaskAllocation> getSchoolDefault(String schoolId);
List<TaskAllocation> getPlatformDefault();
SchoolDefaultTaskInitialization getInitialization(String schoolId);
void enqueueInitialization(String schoolId);

@ -61,6 +61,11 @@ public class SchoolDefaultTaskServiceImpl implements SchoolDefaultTaskService {
return listByClassId(schoolDefaultClassId(schoolId));
}
@Override
public List<TaskAllocation> getPlatformDefault() {
return listByClassId(PLATFORM_DEFAULT_CLASS_ID);
}
@Override
public SchoolDefaultTaskInitialization getInitialization(String schoolId) {
return initializationMapper == null || StringUtils.isBlank(schoolId)

@ -0,0 +1,80 @@
package com.sztzjy.linkCommerce.controller.stu;
import com.sztzjy.linkCommerce.config.exception.UnAuthorizedException;
import com.sztzjy.linkCommerce.config.security.JwtUser;
import com.sztzjy.linkCommerce.config.security.TokenProvider;
import com.sztzjy.linkCommerce.entity.TaskAllocation;
import com.sztzjy.linkCommerce.entity.Userinfo;
import com.sztzjy.linkCommerce.entity.SchoolDefaultTaskInitialization;
import com.sztzjy.linkCommerce.mapper.UserinfoMapper;
import com.sztzjy.linkCommerce.service.SchoolDefaultTaskService;
import org.junit.jupiter.api.Test;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.*;
class SchoolDefaultTaskControllerTest {
@Test
void managerTeacherCanSaveDefaultsForOwnSchool() {
SchoolDefaultTaskController controller = new SchoolDefaultTaskController();
SchoolDefaultTaskService service = mock(SchoolDefaultTaskService.class);
UserinfoMapper userinfoMapper = mock(UserinfoMapper.class);
ReflectionTestUtils.setField(controller, "schoolDefaultTaskService", service);
ReflectionTestUtils.setField(controller, "userinfoMapper", userinfoMapper);
when(userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1", "school-1", true));
SchoolDefaultTaskInitialization ready = new SchoolDefaultTaskInitialization();
ready.setStatus("READY");
when(service.getInitialization("school-1")).thenReturn(ready);
controller.replace(List.of(task("学校默认任务")), requestFor("teacher-1", "school-1"));
verify(service).replaceSchoolDefault(eq("school-1"), anyList());
}
@Test
void ordinaryTeacherCannotSaveDefaults() {
SchoolDefaultTaskController controller = new SchoolDefaultTaskController();
UserinfoMapper userinfoMapper = mock(UserinfoMapper.class);
ReflectionTestUtils.setField(controller, "userinfoMapper", userinfoMapper);
when(userinfoMapper.selectByPrimaryKey("teacher-2")).thenReturn(teacher("teacher-2", "school-1", false));
assertThrows(UnAuthorizedException.class,
() -> controller.replace(List.of(task("学校默认任务")), requestFor("teacher-2", "school-1")));
}
private Userinfo teacher(String userId, String schoolId, boolean teacherAdmin) {
Userinfo user = new Userinfo();
user.setUserId(userId);
user.setSchoolId(schoolId);
user.setRole(3);
user.setTeacherAdmin(teacherAdmin);
return user;
}
private TaskAllocation task(String module) {
TaskAllocation task = new TaskAllocation();
task.setModule(module);
task.setDisabledStatus((byte) 0);
return task;
}
private MockHttpServletRequest requestFor(String userId, String schoolId) {
JwtUser user = new JwtUser();
user.setUserId(userId);
user.setSchoolId(schoolId);
user.setRoleId(3);
user.setUsername(userId);
MockHttpServletRequest request = new MockHttpServletRequest();
request.setUserPrincipal(new UsernamePasswordAuthenticationToken(user, null));
request.addHeader("Authorization", "Bearer " + TokenProvider.createToken(user));
return request;
}
}

@ -4,12 +4,15 @@ import com.sztzjy.linkCommerce.entity.SchoolClass;
import com.sztzjy.linkCommerce.entity.TaskAllocation;
import com.sztzjy.linkCommerce.mapper.SchoolClassMapper;
import com.sztzjy.linkCommerce.mapper.TaskAllocationMapper;
import com.sztzjy.linkCommerce.service.SchoolDefaultTaskService;
import com.sztzjy.linkCommerce.util.ResultEntity;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.http.HttpStatus;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Collections;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
@ -75,6 +78,20 @@ class TaskAllocationControllerTest {
assertEquals("school-1", captor.getValue().getSchoolId());
}
@Test
void taskLookupUsesSchoolDefaultResolverForTeachingClass() {
TaskAllocationController controller = controllerWithMocks();
SchoolDefaultTaskService defaultTaskService = mock(SchoolDefaultTaskService.class);
ReflectionTestUtils.setField(controller, "schoolDefaultTaskService", defaultTaskService);
TaskAllocation allocation = new TaskAllocation();
allocation.setModule("学校默认任务");
when(defaultTaskService.resolveForTeachingClass("teaching-1")).thenReturn(List.of(allocation));
ResultEntity<List<TaskAllocation>> result = controller.selectTaskAllocationByClassId("teaching-1");
assertEquals(List.of(allocation), result.getBody().getData());
}
private TaskAllocationController controllerWithMocks() {
TaskAllocationController controller = new TaskAllocationController();
controller.taskAllocationMapper = mock(TaskAllocationMapper.class);

Loading…
Cancel
Save