CoursesController.java

package edu.ucsb.cs156.frontiers.controllers;

import com.fasterxml.jackson.core.JsonProcessingException;
import edu.ucsb.cs156.frontiers.entities.Course;
import edu.ucsb.cs156.frontiers.entities.CourseStaff;
import edu.ucsb.cs156.frontiers.entities.RosterStudent;
import edu.ucsb.cs156.frontiers.entities.User;
import edu.ucsb.cs156.frontiers.enums.OrgStatus;
import edu.ucsb.cs156.frontiers.enums.School;
import edu.ucsb.cs156.frontiers.errors.EntityNotFoundException;
import edu.ucsb.cs156.frontiers.errors.InvalidInstallationTypeException;
import edu.ucsb.cs156.frontiers.models.CourseWarning;
import edu.ucsb.cs156.frontiers.models.CurrentUser;
import edu.ucsb.cs156.frontiers.repositories.AdminRepository;
import edu.ucsb.cs156.frontiers.repositories.CourseRepository;
import edu.ucsb.cs156.frontiers.repositories.CourseStaffRepository;
import edu.ucsb.cs156.frontiers.repositories.InstructorRepository;
import edu.ucsb.cs156.frontiers.repositories.JobsRepository;
import edu.ucsb.cs156.frontiers.repositories.RosterStudentRepository;
import edu.ucsb.cs156.frontiers.repositories.UserRepository;
import edu.ucsb.cs156.frontiers.services.CanvasApiTokenSecurityService;
import edu.ucsb.cs156.frontiers.services.OrganizationLinkerService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

@Tag(name = "Course")
@RequestMapping("/api/courses")
@RestController
@Slf4j
public class CoursesController extends ApiController {

  @Autowired private CourseRepository courseRepository;

  @Autowired private UserRepository userRepository;

  @Autowired private RosterStudentRepository rosterStudentRepository;

  @Autowired private CourseStaffRepository courseStaffRepository;

  @Autowired private InstructorRepository instructorRepository;

  @Autowired private AdminRepository adminRepository;

  @Autowired private CanvasApiTokenSecurityService canvasApiTokenSecurityService;

  @Autowired private OrganizationLinkerService linkerService;

  @Autowired private JobsRepository jobsRepository;

  /**
   * This method creates a new Course.
   *
   * @param courseName the name of the course
   * @param term the term of the course
   * @param school the school of the course
   * @param canvasApiToken the Canvas API token (optional)
   * @param canvasCourseId the Canvas course ID (optional)
   */
  @Operation(summary = "Create a new course")
  @PreAuthorize("hasRole('ROLE_ADMIN') || hasRole('ROLE_INSTRUCTOR')")
  @PostMapping("/post")
  public InstructorCourseView postCourse(
      @Parameter(name = "courseName") @RequestParam String courseName,
      @Parameter(name = "term") @RequestParam String term,
      @Parameter(name = "school") @RequestParam School school,
      @Parameter(name = "canvasApiToken") @RequestParam(required = false) String canvasApiToken,
      @Parameter(name = "canvasCourseId") @RequestParam(required = false) String canvasCourseId) {
    // get current date right now and set status to pending
    CurrentUser currentUser = getCurrentUser();
    Course course =
        Course.builder()
            .courseName(courseName)
            .term(term)
            .school(school)
            .instructorEmail(currentUser.getUser().getEmail().strip())
            .canvasApiToken(canvasApiTokenSecurityService.encrypt(canvasApiToken))
            .canvasCourseId(canvasCourseId)
            .build();
    Course savedCourse = courseRepository.save(course);

    return new InstructorCourseView(savedCourse);
  }

  /** Projection of Course entity with fields that are relevant for instructors and admins */
  public static record InstructorCourseView(
      Long id,
      String installationId,
      String orgName,
      String courseName,
      String term,
      School school,
      String instructorEmail,
      boolean hideBasePermissionWarning,
      int numStudents,
      int numStaff) {

    // Creates view from Course entity
    public InstructorCourseView(Course c) {
      this(
          c.getId(),
          c.getInstallationId(),
          c.getOrgName(),
          c.getCourseName(),
          c.getTerm(),
          c.getSchool(),
          c.getInstructorEmail(),
          c.getHideBasePermissionWarning(),
          c.getRosterStudents() != null ? c.getRosterStudents().size() : 0,
          c.getCourseStaff() != null ? c.getCourseStaff().size() : 0);
    }
  }

  /**
   * This method returns a list of courses.
   *
   * @return a list of all courses for an instructor.
   */
  @Operation(summary = "List all courses for an instructor")
  @PreAuthorize("hasRole('ROLE_INSTRUCTOR')")
  @GetMapping("/allForInstructors")
  public Iterable<InstructorCourseView> allForInstructors() {
    CurrentUser currentUser = getCurrentUser();
    String instructorEmail = currentUser.getUser().getEmail();
    List<Course> courses = courseRepository.findByInstructorEmail(instructorEmail);

    List<InstructorCourseView> courseViews =
        courses.stream().map(InstructorCourseView::new).collect(Collectors.toList());
    return courseViews;
  }

  /**
   * This method returns a list of courses.
   *
   * @return a list of all courses for an admin.
   */
  @Operation(summary = "List all courses for an admin")
  @PreAuthorize("hasRole('ROLE_ADMIN')")
  @GetMapping("/allForAdmins")
  public Iterable<InstructorCourseView> allForAdmins() {
    List<Course> courses = courseRepository.findAll();

    List<InstructorCourseView> courseViews =
        courses.stream().map(InstructorCourseView::new).collect(Collectors.toList());
    return courseViews;
  }

  /**
   * This method returns single course by its id
   *
   * @return a course
   */
  @Operation(summary = "Get course by id")
  @PreAuthorize("@CourseSecurity.hasManagePermissions(#root, #id)")
  @GetMapping("/{id}")
  public InstructorCourseView getCourseById(@Parameter(name = "id") @PathVariable Long id) {
    Course course =
        courseRepository
            .findById(id)
            .orElseThrow(() -> new EntityNotFoundException(Course.class, id));
    // Convert to InstructorCourseView
    InstructorCourseView courseView = new InstructorCourseView(course);
    return courseView;
  }

  /**
   * This method returns the Canvas course ID and partially obscured Canvas token for a course by
   * its id. If the token is less than or equal to 3 characters long, it is returned in full.
   * Otherwise, all but the last three characters are replaced with asterisks. This is okay because
   * such short tokens are not generated by Canvas.
   *
   * @param courseId the id of the course
   * @return a map with courseId, canvasCourseId, and obscured canvasApiToken
   */
  @Operation(summary = "Get course Canvas course ID and Canvas token (partially obscured)")
  @PreAuthorize("@CourseSecurity.hasManagePermissions(#root, #courseId)")
  @GetMapping("getCanvasInfo")
  public Map<String, String> getCourseCanvasInfo(
      @Parameter(name = "courseId") @RequestParam Long courseId) {
    Course course =
        courseRepository
            .findById(courseId)
            .orElseThrow(() -> new EntityNotFoundException(Course.class, courseId));

    String obscuredToken = null;

    if (course.getCanvasApiToken() != null) {
      String token = canvasApiTokenSecurityService.decrypt(course.getCanvasApiToken());
      if (token.length() < 4) {
        obscuredToken = token;
      } else {
        String lastThree = token.substring(token.length() - 3);
        obscuredToken = "*".repeat(token.length() - 3) + lastThree;
      }
    }
    return Map.of(
        "courseId", course.getId().toString(),
        "canvasCourseId", course.getCanvasCourseId() != null ? course.getCanvasCourseId() : "",
        "canvasApiToken", obscuredToken != null ? obscuredToken : "");
  }

  /**
   * This is the outgoing method, redirecting from Frontiers to GitHub to allow a Course to be
   * linked to a GitHub Organization. It redirects from Frontiers to the GitHub app installation
   * process, and will return with the {@link #addInstallation(Optional, String, String, Long)
   * addInstallation()} endpoint
   *
   * @param courseId id of the course to be linked to
   * @return dynamically loaded url to install Frontiers to a Github Organization, with the courseId
   *     marked as the state parameter, which GitHub will return.
   */
  @Operation(summary = "Authorize Frontiers to a Github Course")
  @PreAuthorize("@CourseSecurity.hasManagePermissions(#root, #courseId)")
  @GetMapping("/redirect")
  public ResponseEntity<Void> linkCourse(@Parameter Long courseId)
      throws JsonProcessingException, NoSuchAlgorithmException, InvalidKeySpecException {
    String newUrl = linkerService.getRedirectUrl();
    newUrl += "/installations/new?state=" + courseId;
    // found this convenient solution here:
    // https://stackoverflow.com/questions/29085295/spring-mvc-restcontroller-and-redirect
    return ResponseEntity.status(HttpStatus.MOVED_PERMANENTLY)
        .header(HttpHeaders.LOCATION, newUrl)
        .build();
  }

  /**
   * @param installation_id id of the incoming GitHub Organization installation
   * @param setup_action whether the permissions are installed or updated. Required RequestParam but
   *     not used by the method.
   * @param code token to be exchanged with GitHub to ensure the request is legitimate and not
   *     spoofed.
   * @param state id of the Course to be linked with the GitHub installation.
   * @return ResponseEntity, returning /success if the course was successfully linked or /noperms if
   *     the user does not have the permission to install the application on GitHub. Alternately
   *     returns 403 Forbidden if the user is not the creator.
   */
  @Operation(summary = "Link a Course to a Github Organization by installing Github App")
  @PreAuthorize("hasRole('ROLE_ADMIN') || hasRole('ROLE_INSTRUCTOR')")
  @GetMapping("link")
  public ResponseEntity<Void> addInstallation(
      @Parameter(name = "installationId") @RequestParam Optional<String> installation_id,
      @Parameter(name = "setupAction") @RequestParam String setup_action,
      @Parameter(name = "code") @RequestParam String code,
      @Parameter(name = "state") @RequestParam Long state)
      throws NoSuchAlgorithmException, InvalidKeySpecException, JsonProcessingException {
    if (installation_id.isEmpty()) {
      return ResponseEntity.status(HttpStatus.MOVED_PERMANENTLY)
          .header(HttpHeaders.LOCATION, "/courses/nopermissions")
          .build();
    } else {
      Course course =
          courseRepository
              .findById(state)
              .orElseThrow(() -> new EntityNotFoundException(Course.class, state));
      if (!isCurrentUserAdmin()
          && !course.getInstructorEmail().equals(getCurrentUser().getUser().getEmail())) {
        return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
      } else {
        String orgName = linkerService.getOrgName(installation_id.get());
        course.setInstallationId(installation_id.get());
        course.setOrgName(orgName);
        course
            .getRosterStudents()
            .forEach(
                rs -> {
                  rs.setOrgStatus(OrgStatus.JOINCOURSE);
                });
        course
            .getCourseStaff()
            .forEach(
                cs -> {
                  cs.setOrgStatus(OrgStatus.JOINCOURSE);
                });
        courseRepository.save(course);
        return ResponseEntity.status(HttpStatus.MOVED_PERMANENTLY)
            .header(HttpHeaders.LOCATION, "/login/success")
            .build();
      }
    }
  }

  /**
   * This method handles the InvalidInstallationTypeException.
   *
   * @param e the exception
   * @return a map with the type and message of the exception
   */
  @ExceptionHandler({InvalidInstallationTypeException.class})
  @ResponseStatus(HttpStatus.BAD_REQUEST)
  public Object handleInvalidInstallationType(Throwable e) {
    return Map.of(
        "type", e.getClass().getSimpleName(),
        "message", e.getMessage());
  }

  public record RosterStudentCoursesDTO(
      Long id,
      String installationId,
      String orgName,
      String courseName,
      String term,
      String school,
      OrgStatus studentStatus,
      Long rosterStudentId) {}

  /**
   * This method returns a list of courses that the current user is enrolled.
   *
   * @return a list of courses in the DTO form along with the student status in the organization.
   */
  @Operation(summary = "List all courses for the current student, including their org status")
  @PreAuthorize("hasRole('ROLE_USER')")
  @GetMapping("/list")
  public List<RosterStudentCoursesDTO> listCoursesForCurrentUser() {
    String email = getCurrentUser().getUser().getEmail();
    Iterable<RosterStudent> rosterStudentsIterable = rosterStudentRepository.findAllByEmail(email);
    List<RosterStudent> rosterStudents = new ArrayList<>();
    rosterStudentsIterable.forEach(rosterStudents::add);
    return rosterStudents.stream()
        .map(
            rs -> {
              Course course = rs.getCourse();
              RosterStudentCoursesDTO rsDto =
                  new RosterStudentCoursesDTO(
                      course.getId(),
                      course.getInstallationId(),
                      course.getOrgName(),
                      course.getCourseName(),
                      course.getTerm(),
                      course.getSchool().getDisplayName(),
                      rs.getOrgStatus(),
                      rs.getId());
              return rsDto;
            })
        .collect(Collectors.toList());
  }

  public record StaffCoursesDTO(
      Long id,
      String installationId,
      String orgName,
      String courseName,
      String term,
      School school,
      OrgStatus studentStatus,
      Long staffId) {}

  public enum EmailTypes {
    STUDENTS,
    STAFF,
    ALL
  }

  public enum EmailFormats {
    COMMA_SEPARATED,
    ONE_PER_LINE
  }

  /**
   * student see what courses they appear as staff in
   *
   * @param studentId the id of the student making request
   * @return a list of all courses student is staff in
   */
  @Operation(summary = "Student see what courses they appear as staff in")
  @PreAuthorize("hasRole('ROLE_USER')")
  @GetMapping("/staffCourses")
  public List<StaffCoursesDTO> staffCourses() {
    CurrentUser currentUser = getCurrentUser();
    User user = currentUser.getUser();

    String email = user.getEmail();

    List<CourseStaff> staffMembers = courseStaffRepository.findAllByEmail(email);
    return staffMembers.stream()
        .map(
            s -> {
              Course course = s.getCourse();
              StaffCoursesDTO sDto =
                  new StaffCoursesDTO(
                      course.getId(),
                      course.getInstallationId(),
                      course.getOrgName(),
                      course.getCourseName(),
                      course.getTerm(),
                      course.getSchool(),
                      s.getOrgStatus(),
                      s.getId());
              return sDto;
            })
        .collect(Collectors.toList());
  }

  @Operation(summary = "Update instructor email for a course (admin only)")
  @PreAuthorize("hasRole('ROLE_ADMIN')")
  @PutMapping("/updateInstructor")
  public InstructorCourseView updateInstructorEmail(
      @Parameter(name = "courseId") @RequestParam Long courseId,
      @Parameter(name = "instructorEmail") @RequestParam String instructorEmail) {

    instructorEmail = instructorEmail.strip();

    Course course =
        courseRepository
            .findById(courseId)
            .orElseThrow(() -> new EntityNotFoundException(Course.class, courseId));

    // Validate that the email exists in either instructor or admin table
    boolean isInstructor = instructorRepository.existsByEmail(instructorEmail);
    boolean isAdmin = adminRepository.existsByEmail(instructorEmail);

    if (!isInstructor && !isAdmin) {
      throw new IllegalArgumentException("Email must belong to either an instructor or admin");
    }

    course.setInstructorEmail(instructorEmail);
    Course savedCourse = courseRepository.save(course);

    return new InstructorCourseView(savedCourse);
  }

  @Operation(summary = "Get course emails")
  @PreAuthorize("@CourseSecurity.hasManagePermissions(#root, #courseId)")
  @GetMapping("/emails")
  public String getCourseEmails(
      @Parameter(name = "courseId") @RequestParam Long courseId,
      @Parameter(name = "type") @RequestParam(defaultValue = "STUDENTS") EmailTypes type,
      @Parameter(name = "team") @RequestParam(required = false) String team,
      @Parameter(name = "format") @RequestParam(defaultValue = "ONE_PER_LINE")
          EmailFormats format) {

    List<String> staffEmails =
        StreamSupport.stream(courseStaffRepository.findByCourseId(courseId).spliterator(), false)
            .map(CourseStaff::getEmail)
            .filter(Objects::nonNull)
            .sorted()
            .collect(Collectors.toList());

    List<String> studentEmails =
        StreamSupport.stream(rosterStudentRepository.findByCourseId(courseId).spliterator(), false)
            .filter(student -> team == null || team.isBlank() || student.getTeams().contains(team))
            .map(RosterStudent::getEmail)
            .filter(Objects::nonNull)
            .sorted()
            .collect(Collectors.toList());

    List<String> emails = studentEmails;
    if (type == EmailTypes.STAFF) {
      emails = staffEmails;
    } else if (type == EmailTypes.ALL) {
      emails = new ArrayList<>(staffEmails);
      emails.addAll(studentEmails);
    }

    String separator = format == EmailFormats.COMMA_SEPARATED ? "," : "\r\n";
    return String.join(separator, emails);
  }

  @Operation(summary = "Delete a course")
  @PreAuthorize("hasRole('ROLE_ADMIN')")
  @DeleteMapping("")
  @Transactional
  public Object deleteCourse(@RequestParam Long courseId)
      throws NoSuchAlgorithmException, InvalidKeySpecException {
    Course course =
        courseRepository
            .findById(courseId)
            .orElseThrow(() -> new EntityNotFoundException(Course.class, courseId));

    // Check if course has roster students or staff
    if (!course.getRosterStudents().isEmpty() || !course.getCourseStaff().isEmpty()) {
      throw new IllegalArgumentException("Cannot delete course with students or staff");
    }

    linkerService.unenrollOrganization(course);
    jobsRepository.deleteByCourse_Id(courseId);
    courseRepository.delete(course);
    return genericMessage("Course with id %s deleted".formatted(course.getId()));
  }

  /**
   * This method updates an existing course.
   *
   * @param courseId the id of the course to update
   * @param courseName the new name of the course
   * @param term the new term of the course
   * @param school the new school of the course
   * @return the updated course
   */
  @Operation(summary = "Update an existing course")
  @PreAuthorize("@CourseSecurity.hasManagePermissions(#root, #courseId)")
  @PutMapping("")
  public InstructorCourseView updateCourse(
      @Parameter(name = "courseId") @RequestParam Long courseId,
      @Parameter(name = "courseName") @RequestParam String courseName,
      @Parameter(name = "term") @RequestParam String term,
      @Parameter(name = "school") @RequestParam School school) {
    Course course =
        courseRepository
            .findById(courseId)
            .orElseThrow(() -> new EntityNotFoundException(Course.class, courseId));

    course.setCourseName(courseName);
    course.setTerm(term);
    course.setSchool(school);

    Course savedCourse = courseRepository.save(course);

    return new InstructorCourseView(savedCourse);
  }

  /**
   * This method updates an existing course.
   *
   * @param courseId the id of the course to update
   * @param courseName the new name of the course
   * @param term the new term of the course
   * @param school the new school of the course
   * @param canvasApiToken the new Canvas API token for the course
   * @param canvasCourseId the new Canvas course ID
   * @return the updated course
   */
  @Operation(summary = "Update an existing course with Canvas token and course ID")
  @PreAuthorize("@CourseSecurity.hasManagePermissions(#root, #courseId)")
  @PutMapping("/updateCourseCanvasToken")
  public InstructorCourseView updateCourseWithCanvasToken(
      @Parameter(name = "courseId") @RequestParam Long courseId,
      @Parameter(name = "canvasApiToken") @RequestParam(required = false) String canvasApiToken,
      @Parameter(name = "canvasCourseId") @RequestParam(required = false) String canvasCourseId) {
    Course course =
        courseRepository
            .findById(courseId)
            .orElseThrow(() -> new EntityNotFoundException(Course.class, courseId));

    String existingCanvasToken = canvasApiTokenSecurityService.decrypt(course.getCanvasApiToken());
    if (canvasApiToken != null
        && !canvasApiToken.isEmpty()
        && !canvasApiToken.equals(existingCanvasToken)) {
      course.setCanvasApiToken(canvasApiTokenSecurityService.encrypt(canvasApiToken));
    }

    if (canvasCourseId != null
        && !canvasCourseId.isEmpty()
        && !canvasCourseId.equals(course.getCanvasCourseId())) {
      course.setCanvasCourseId(canvasCourseId);
    }

    Course savedCourse = courseRepository.save(course);

    return new InstructorCourseView(savedCourse);
  }

  @Operation(summary = "Get course warnings")
  @GetMapping("/warnings/{courseId}")
  @PreAuthorize("@CourseSecurity.hasManagePermissions(#root, #courseId)")
  public CourseWarning warnings(@PathVariable @Parameter Long courseId) throws Exception {
    Course course =
        courseRepository
            .findById(courseId)
            .orElseThrow(() -> new EntityNotFoundException(Course.class, courseId));
    return linkerService.checkCourseWarnings(course);
  }

  @Operation(summary = "Hide base permission warning for a course")
  @PreAuthorize("@CourseSecurity.hasManagePermissions(#root, #courseId)")
  @PostMapping("/warnings/hideBasePermissionWarning/{courseId}")
  public Object hideBasePermissionWarning(@PathVariable @Parameter Long courseId) {
    Course course =
        courseRepository
            .findById(courseId)
            .orElseThrow(() -> new EntityNotFoundException(Course.class, courseId));

    course.setHideBasePermissionWarning(true);
    courseRepository.save(course);

    return genericMessage(
        "hideBasePermissionWarning set to true for course with id %s".formatted(courseId));
  }
}








































































Active mutators

CONDITIONALS_BOUNDARY
EMPTY_RETURNS
FALSE_RETURNS
INCREMENTS
INVERT_NEGS
MATH
NEGATE_CONDITIONALS
NULL_RETURNS
PRIMITIVE_RETURNS
TRUE_RETURNS
VOID_METHOD_CALLS

Tests examined

edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testCourseLinkSuccessWhenAdminNotCreator()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testLinkCourseSuccessfullyProfessorCreator()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testLinkCourseSuccessfully()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:getCanvasInfo_obscuresCorrectlyForLessThanThreeCharacters()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:getCanvasInfo_returnsCorrectOutput()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:getCanvasInfo_obscuresCorrectlyForThreeCharacters()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:getCanvasInfo_obscuresCorrectlyForFourCharacters()] (6 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:updateCourseCanvasToken_success_admin()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:updateCourseCanvasToken_null_params_no_change()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:updateCourseCanvasToken_same_value_does_not_change()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:updateCourseCanvasToken_empty_string_no_change()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:updateCourseCanvasToken_encryptsBeforeSaving()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:admin_can_updateCourseCanvasToken_created_by_someone_else()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:updateCourseCanvasToken_success_returns_ok()] (14 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:delete_success_returns_ok()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:test_warnings_not_found()] (9 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:getCanvasInfo_obscuresCorrectlyForNoChars()] (7 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:updateCourse_success_admin()] (6 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:admin_can_update_course_created_by_someone_else()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:update_course_success_returns_ok()] (11 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testGetCourseById()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testGetCourseById_AdminCanGetCourseCreatedBySomeoneElse()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testUpdateInstructorEmail_courseDoesNotExist()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testStudenIsStaffInCourse()] (13 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:update_course_not_found_returns_not_found()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:delete_not_found_returns_not_found()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testNotCreator()] (7 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:updateCourseCanvasToken_not_found_returns_not_found()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testUpdateInstructorEmail_emailNotFound()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testUpdateInstructorEmail_byAdmin_email_is_instructor()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testUpdateInstructorEmail_byAdmin_email_is_admin()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testUpdateInstructorEmail_byAdmin_email_is_sanitized()] (7 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:getCourseEmails_students_blank_team_is_unfiltered()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:getCourseEmails_staff_only_sorted_lexicographically()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:getCourseEmails_defaults_to_students_one_per_line()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:getCourseEmails_all_comma_separated_staff_first()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:getCourseEmails_students_explicit_type_comma_separated()] (6 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:getCourseEmails_students_filtered_by_team()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:getCourseEmails_all_filters_students_by_team_but_keeps_all_staff()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:getCourseEmails_staff_ignores_team_filter()] (6 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testPostCourse_byInstructor()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testPostCourse_byAdmin()] (6 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testListCoursesForCurrentUser()] (53 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testCourseLinkNotFound()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testAllCourses_ROLE_ADMIN()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testAllCourses_ROLE_INSTRUCTOR()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:hideBasePermissionWarning_setsFieldTrue()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:delete_course_with_staff_throws_illegal_argument()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testInstructorCourseView_withNullRosterStudents()] (1 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testInstructorCourseView_withNullCourseStaff()] (1 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testInstructorCourseView_withBothCollectionsNull()] (2 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testInstructorCourseView_countsStudentsAndStaff()] (1 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testInstructorCourseView_withNonNullCollections()] (2 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:hideBasePermissionWarning_notFound()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testGetCanvasInfo_courseDoesNotExist()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testNotOrganization()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:delete_course_with_students_throws_illegal_argument()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:delete_course_with_students_and_staff_throws_illegal_argument()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:calls_org_service_for_warnings()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testNoPerms()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testGetCourseById_courseDoesNotExist()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.CoursesControllerTests]/[method:testRedirect()] (4 ms)

Report generated by PIT 1.17.0

1		package edu.ucsb.cs156.frontiers.controllers;
2
3		import com.fasterxml.jackson.core.JsonProcessingException;
4		import edu.ucsb.cs156.frontiers.entities.Course;
5		import edu.ucsb.cs156.frontiers.entities.CourseStaff;
6		import edu.ucsb.cs156.frontiers.entities.RosterStudent;
7		import edu.ucsb.cs156.frontiers.entities.User;
8		import edu.ucsb.cs156.frontiers.enums.OrgStatus;
9		import edu.ucsb.cs156.frontiers.enums.School;
10		import edu.ucsb.cs156.frontiers.errors.EntityNotFoundException;
11		import edu.ucsb.cs156.frontiers.errors.InvalidInstallationTypeException;
12		import edu.ucsb.cs156.frontiers.models.CourseWarning;
13		import edu.ucsb.cs156.frontiers.models.CurrentUser;
14		import edu.ucsb.cs156.frontiers.repositories.AdminRepository;
15		import edu.ucsb.cs156.frontiers.repositories.CourseRepository;
16		import edu.ucsb.cs156.frontiers.repositories.CourseStaffRepository;
17		import edu.ucsb.cs156.frontiers.repositories.InstructorRepository;
18		import edu.ucsb.cs156.frontiers.repositories.JobsRepository;
19		import edu.ucsb.cs156.frontiers.repositories.RosterStudentRepository;
20		import edu.ucsb.cs156.frontiers.repositories.UserRepository;
21		import edu.ucsb.cs156.frontiers.services.CanvasApiTokenSecurityService;
22		import edu.ucsb.cs156.frontiers.services.OrganizationLinkerService;
23		import io.swagger.v3.oas.annotations.Operation;
24		import io.swagger.v3.oas.annotations.Parameter;
25		import io.swagger.v3.oas.annotations.tags.Tag;
26		import java.security.NoSuchAlgorithmException;
27		import java.security.spec.InvalidKeySpecException;
28		import java.util.ArrayList;
29		import java.util.List;
30		import java.util.Map;
31		import java.util.Objects;
32		import java.util.Optional;
33		import java.util.stream.Collectors;
34		import java.util.stream.StreamSupport;
35		import lombok.extern.slf4j.Slf4j;
36		import org.springframework.beans.factory.annotation.Autowired;
37		import org.springframework.http.HttpHeaders;
38		import org.springframework.http.HttpStatus;
39		import org.springframework.http.ResponseEntity;
40		import org.springframework.security.access.prepost.PreAuthorize;

CoursesController.java

Mutations

Active mutators

Tests examined