src/main/java/com/cfuv/olympus/controller/AdminController.java - master - setwind/olympiad

src/main/java/com/cfuv/olympus/controller/AdminController.java
246 строк13 KB
setwind
test and groups view
05 май 2025, 15:35
05 май 2025, 15:358e680ac
package com.cfuv.olympus.controller;

import com.cfuv.olympus.entity.domain.contest.Contest;
import com.cfuv.olympus.entity.domain.contest.Folder;
import com.cfuv.olympus.entity.domain.contest.Tasks;
import com.cfuv.olympus.entity.dto.contest.get.*;
import com.cfuv.olympus.entity.dto.contest.table.JudgeTableResponse;
import com.cfuv.olympus.entity.dto.contest.table.ResultTableRequest;
import com.cfuv.olympus.entity.dto.contest.table.ResultTableResponse;
import com.cfuv.olympus.entity.dto.contest.update.*;
import com.cfuv.olympus.service.ContestService;
import com.cfuv.olympus.service.TaskService;
import com.cfuv.olympus.service.TestService;
import com.cfuv.olympus.service.UserTaskService;
import com.cfuv.olympus.service.contest.checker.aspect.CheckContestState;
import com.cfuv.olympus.web.security.UserSession;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import jakarta.validation.constraints.Min;
import lombok.RequiredArgsConstructor;
import org.springdoc.api.ErrorMessage;
import org.springframework.http.MediaType;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.List;
import java.util.Set;

@Tag(name = "Admin controller", description = "Administrator management")
@RestController
@RequestMapping("/api/v1/admin")
@RequiredArgsConstructor
@Validated

public class AdminController {

    private final ContestService contestService;
    private final TaskService taskService;
    private final UserTaskService userTaskService;
    private final TestService testService;

    @Operation(summary = "Create contest", description = "Return created contest and users")
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200", description = "Successfully retrieved"),
            @ApiResponse(responseCode = "404", description = "Bad request - Contest already exists",
                    content = @Content(schema = @Schema(implementation = ErrorMessage.class)))
    })
    @PostMapping("/createContest")
    public ContestAndFileResponse createContest(@Valid @RequestBody final ContestRequest contestRequest) throws IOException {
        return contestService.create(contestRequest);
    }

    @CheckContestState
    @Operation(summary = "Create users for contest", description = "Return created users")
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200", description = "Successfully retrieved"),
            @ApiResponse(responseCode = "404", description = "Bad request - Contest does not exists",
                    content = @Content(schema = @Schema(implementation = ErrorMessage.class)))
    })
    @PostMapping("/createUsers")
    public FileResponse createUsers(@Valid @RequestBody final CreateUsersRequest createUsersRequest) throws IOException {
        return contestService.createUsers(createUsersRequest);
    }
    @PostMapping("/contest/groups")
    public Set<String> createUsers(@Valid @RequestParam @Min(value = 0, message = "Id cannot be less than 0") final Long id) throws IOException {
        return contestService.getGroupsById(id);
    }

    @Operation(summary = "Get contests by page and total count", description = "Return contests limited by page and total contests count")
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200", description = "Successfully retrieved")
    })
    @PostMapping("/contest/list")
    public GetAllContestsResponse getAllContests(@Valid @RequestBody final GetAllContestsRequest getAllContestsRequest) {
        return contestService.getAllContests(getAllContestsRequest);
    }

    @Operation(summary = "Find contests containing name or state", description = "Return contests limited by page and containing name or state")
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200", description = "Successfully retrieved")
    })
    @PostMapping("/contest/search")
    public GetAllContestsResponse getAllContestsContainingNameOrState(@Valid @RequestBody final GetAllContestsContainingNameRequest getAllContestsContainingNameRequest) {
        return contestService.getAllContestsContainingNameOrState(getAllContestsContainingNameRequest);
    }

    @Operation(summary = "Get contest by id", description = "Return contest by id")
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200", description = "Successfully retrieved"),
            @ApiResponse(responseCode = "404", description = "Bad request - Contest does not exists",
                    content = @Content(schema = @Schema(implementation = ErrorMessage.class)))
    })
    @GetMapping("/contest")
    public Contest getContestById(@RequestParam @Min(value = 0, message = "Id cannot be less than 0") Long id) {
        return contestService.getContestById(id);
    }

    @Operation(summary = "Get contest user tasks table", description = "Returns a contest user tasks table for admin")
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200", description = "Successfully retrieved")
    })
    @GetMapping("/contest/user-problems")
    public List<JudgeTableResponse> getContestTableById(@RequestParam @Min(value = 0, message = "Id cannot be less than 0") Long contestId,
                                                                        @AuthenticationPrincipal UserSession user) {
        return taskService.getJudgeTableByContestId(contestId, user.getId());
    }
    @Operation(summary = "Get user files", description = "Returns meta data about user answer")
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200", description = "Successfully retrieved")
    })
    @GetMapping("/contest/user-problems/files")
    public Folder getUserAnswerById(@RequestParam @Min(value = 0, message = "Id cannot be less than 0") Long id,
                                          @AuthenticationPrincipal UserSession user) {
        return userTaskService.getFileStructure(id);
    }
    @Operation(summary = "Get user answer", description = "Returns meta data about user answer")
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200", description = "Successfully retrieved")
    })
    @GetMapping("/contest/user-problems/tests")
    public TestResult getTestResult(@RequestParam @Min(value = 0, message = "Id cannot be less than 0") Long id,
                                          @AuthenticationPrincipal UserSession user) {
        return testService.getResult(id);
    }

    @Operation(summary = "Get contest user tasks result table", description = "Returns a contest user tasks result table for admin")
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200", description = "Successfully retrieved")
    })
    @PostMapping("/contest/user-problems/result")
    public ResultTableResponse getContestResultTableById(@RequestBody ResultTableRequest resultTableRequest) {
        return taskService.getResultTableResponse(resultTableRequest.getId());
    }

    @CheckContestState
    @Operation(summary = "Start contest", description = "Return contest start and end time")
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200", description = "Successfully retrieved"),
            @ApiResponse(responseCode = "404", description = "Bad request - Contest does not exists",
                    content = @Content(schema = @Schema(implementation = ErrorMessage.class)))
    })
    @PostMapping("/startContest")
    public GetStartAndEndContestTimeResponse startContest(@Valid @RequestBody final GetStartAndEndContestTimeRequest getStartAndEndContestTimeRequest) {
        return contestService
                .start(getStartAndEndContestTimeRequest.getId());
    }

    @CheckContestState
    @Operation(summary = "Change duration", description = "Change contest duration")
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200", description = "Successfully retrieved"),
            @ApiResponse(responseCode = "400", description = "ContestStartedYetException - contest started yet\"",
                    content = @Content(schema = @Schema(implementation = ErrorMessage.class)))
            ,
            @ApiResponse(responseCode = "404", description = "Bad request - Contest does not exists",
                    content = @Content(schema = @Schema(implementation = ErrorMessage.class)))
    })
    @PostMapping("/changeDuration")
    public String changeDuration(@Valid @RequestBody final ChangeDurationRequest changeDurationRequest) {
        return contestService
                .changeDuration(changeDurationRequest);
    }

    @CheckContestState
    @Operation(summary = "Change name", description = "Change contest name")
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200", description = "Successfully retrieved"),
            @ApiResponse(responseCode = "400", description = "ContestStartedYetException - contest started yet",
                    content = @Content(schema = @Schema(implementation = ErrorMessage.class)))
            ,
            @ApiResponse(responseCode = "404", description = "Bad request - Contest does not exists",
                    content = @Content(schema = @Schema(implementation = ErrorMessage.class)))
    })
    @PutMapping("/changeName")
    public void changeName(@Valid @RequestBody final ChangeNameRequest changeNameRequest) {
        contestService
                .changeName(changeNameRequest.getId(), changeNameRequest.getName());

    }

    @CheckContestState
    @Operation(summary = "Add problems", description = "Add problems to the contest")
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200", description = "Successfully retrieved"),
            @ApiResponse(responseCode = "404", description = "Bad request - Contest does not exists",
                    content = @Content(schema = @Schema(implementation = ErrorMessage.class)))
    })
    @PostMapping(value = "/addProblems", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public List<Tasks> addProblems(
            @Parameter(description = "Название задания", example = "Задача по верстке") @RequestParam(value = "name", required = false) String name,
            @Parameter(description = "Id олимпиады", example = "1") @RequestParam("contest-id") @Min(value = 0, message = "Id must be at least 0") Long contestId,
            @Parameter(description = "Содержимое задания", example = "pdf file") @RequestParam(value = "task") MultipartFile taskContent,
            @Parameter(description = "Zip файл с дополнениями") @RequestParam(value = "addition", required = false) MultipartFile addition,
            @Parameter(description = "Js/Ts файл для тестирования") @RequestParam(value = "test", required = false) MultipartFile test,
            @Parameter(description = "Макс. кол-во очков", example = "20") @RequestParam("points") @Min(value = 0, message = "Points must be at least 0") int points
    ) {
        AddProblemRequest addProblemRequest = new AddProblemRequest();
        addProblemRequest.setContestId(contestId);
        addProblemRequest.setName(name);
        addProblemRequest.setTaskContent(taskContent);
        if (addition != null) {
            addProblemRequest.setAdditionName(addition.getOriginalFilename());
            addProblemRequest.setAddition(addition);
        }
        if (test != null) {
            addProblemRequest.setTestName(test.getOriginalFilename());
            addProblemRequest.setTestContent(test);
        }
        addProblemRequest.setPoints(points);
        addProblemRequest.setPdfName(taskContent.getOriginalFilename());
        return contestService.addProblems(addProblemRequest);
    }

    @Operation(summary = "Delete problems", description = "Delete problems from the contest")
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200", description = "Successfully retrieved"),
            @ApiResponse(responseCode = "404", description = "Bad request - Contest does not exists",
                    content = @Content(schema = @Schema(implementation = ErrorMessage.class))),
            @ApiResponse(responseCode = "500", description = "Internal server error - File handling error",
                    content = @Content(schema = @Schema(implementation = ErrorMessage.class)))
    })
    @PostMapping("/deleteProblems")
    public List<Tasks> deleteProblems(@Valid @RequestBody final DeleteProblemRequest deleteProblemRequest) {
        return contestService.deleteProblem(deleteProblemRequest);
    }

    @Operation(summary = "Delete contest", description = "Return created users")
    @ApiResponses(value = {
            @ApiResponse(responseCode = "200", description = "Successfully retrieved"),
            @ApiResponse(responseCode = "404", description = "Bad request - Contest does not exists",
                    content = @Content(schema = @Schema(implementation = ErrorMessage.class)))
    })
    @PostMapping("/deleteContest")
    public void deleteContest(@RequestBody final DeleteContestRequest deleteContestRequest) {
        contestService.deleteContest(deleteContestRequest.getContestId());
    }
}