CoursesController.java

package edu.ucsb.cs156.frontiers.controllers;

import java.security.NoSuchAlgorithmException;

import java.security.spec.InvalidKeySpecException;

import java.util.Map;

import java.util.Optional;

import java.util.List;

import java.util.stream.Collectors;

import java.util.stream.StreamSupport;

import java.util.stream.Collectors;

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.web.bind.annotation.ExceptionHandler;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.PostMapping;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.ResponseStatus;

import org.springframework.web.bind.annotation.RestController;

import com.fasterxml.jackson.core.JsonProcessingException;

import edu.ucsb.cs156.frontiers.entities.Course;

import edu.ucsb.cs156.frontiers.entities.RosterStudent;

import edu.ucsb.cs156.frontiers.errors.EntityNotFoundException;

import edu.ucsb.cs156.frontiers.errors.InvalidInstallationTypeException;

import edu.ucsb.cs156.frontiers.models.CurrentUser;

import edu.ucsb.cs156.frontiers.models.RosterStudentDTO;

import edu.ucsb.cs156.frontiers.repositories.CourseRepository;

import edu.ucsb.cs156.frontiers.repositories.RosterStudentRepository;

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 lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;

import java.util.List;

import java.util.stream.Collectors;

import edu.ucsb.cs156.frontiers.enums.OrgStatus;

@Tag(name = "Course")

@RequestMapping("/api/courses")

@RestController

    @Autowired

    private CourseRepository courseRepository;

    @Autowired private OrganizationLinkerService linkerService;

    @Autowired

    private RosterStudentRepository rosterStudentRepository;

     /**

     * This method creates a new Course.

     * 

    * @param orgName the name of the organization

    * @param courseName the name of the course

    * @param term the term of the course

    * @param school the school of the course

    * @return the created course

     */

    @Operation(summary = "Create a new course")

    @PreAuthorize("hasRole('ROLE_ADMIN')")

    @PostMapping("/post")

    public Course postCourse(

            @Parameter(name = "orgName") @RequestParam String orgName,

            @Parameter(name = "courseName") @RequestParam String courseName,

            @Parameter(name = "term") @RequestParam String term,

            @Parameter(name = "school") @RequestParam String school

           )

            {

        //get current date right now and set status to pending

    }

      /**

     * This method returns a list of courses.

     * @return a list of all courses.

     */

    @Operation(summary = "List all courses")

    @PreAuthorize("hasRole('ROLE_ADMIN')")

    @GetMapping("/all")

    public Iterable<Course> allCourses(

    ) {

    }

    /**

     * <p>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

     * </p>

     * @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("hasRole('ROLE_PROFESSOR')")

    @GetMapping("/redirect")

    public ResponseEntity<Void> linkCourse(@Parameter Long courseId) throws JsonProcessingException, NoSuchAlgorithmException, InvalidKeySpecException {

        //found this convenient solution here: https://stackoverflow.com/questions/29085295/spring-mvc-restcontroller-and-redirect

    }

    /**

     *

     * @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 Course")

    @PreAuthorize("hasRole('ROLE_PROFESSOR')")

    @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 {

        }else {

            }else{

            }

        }

    }

    /**

     * This method returns a list of students in the roster for a given course,

     * with each student represented as a RosterStudentDTO including GitHub org status.

     * 

     * @param courseId the ID of the course

     * @return a list of RosterStudentDTOs for the given course

     */

    @Operation(summary = "Get list of students in a course roster, including orgStatus")

    @PreAuthorize("hasRole('ROLE_ADMIN') or hasRole('ROLE_PROFESSOR')")

    @GetMapping("/roster")

    public List<RosterStudentDTO> getRosterForCourse(

            @Parameter(name = "courseId") @RequestParam Long courseId

    ) {

    }

    /**

     * 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) {

        );

    }

    /**

     * This method looks up a current user and gets their email.

     * With that email, it that email on every course roster,

     * and when it appears, notes/stores course id

     * We then return all courses for those course ids, with relevant

     * fields for the student.

     * 

     * Relevant fields are: id, installationId, orgName, courseName, term, school

     * For each course, return the status that the student is in

     */

    @Operation(summary = "Get all courses for a student")

    @PreAuthorize("hasRole('ROLE_USER')")

    @GetMapping("/student")

    public ResponseEntity<List<StudentCourseView>> getCoursesForStudent() {

    }

    // Lightweight projection of Course entity with only student-relevant fields

            Long id,

            String installationId,

            String orgName,

            String courseName,

            String term,

            String school,

            String status) {

        // Creates view from Course entity and student email

        public StudentCourseView(Course c, String email) {

        // Maps OrgStatus enum to human-readable status message

        private static String mapStatus(RosterStudent rs) {

            };

        }

    }

}

Mutations