Examples with TutorParticipation de.tum.in.www1.artemis.domain.participation.TutorParticipation used on opensource projects

Example 1 with TutorParticipation

use of de.tum.in.www1.artemis.domain.participation.TutorParticipation in project ArTEMiS by ls1intum.

the class DatabaseUtilService method createCoursesWithExercisesAndLectures.

public List<Course> createCoursesWithExercisesAndLectures(boolean withParticipations) throws Exception {
    ZonedDateTime pastTimestamp = ZonedDateTime.now().minusDays(5);
    ZonedDateTime futureTimestamp = ZonedDateTime.now().plusDays(5);
    ZonedDateTime futureFutureTimestamp = ZonedDateTime.now().plusDays(8);
    Course course1 = ModelFactory.generateCourse(null, pastTimestamp, futureTimestamp, new HashSet<>(), "tumuser", "tutor", "editor", "instructor");
    Course course2 = ModelFactory.generateCourse(null, ZonedDateTime.now().minusDays(8), pastTimestamp, new HashSet<>(), "tumuser", "tutor", "editor", "instructor");
    ModelingExercise modelingExercise = ModelFactory.generateModelingExercise(pastTimestamp, futureTimestamp, futureFutureTimestamp, DiagramType.ClassDiagram, course1);
    modelingExercise.setGradingInstructions("some grading instructions");
    modelingExercise.setExampleSolutionModel("Example solution model");
    modelingExercise.setExampleSolutionExplanation("Example Solution");
    addGradingInstructionsToExercise(modelingExercise);
    modelingExercise.getCategories().add("Modeling");
    modelingExercise.setKnowledge(modelAssessmentKnowledgeService.createNewKnowledge());
    course1.addExercises(modelingExercise);
    TextExercise textExercise = ModelFactory.generateTextExercise(pastTimestamp, futureTimestamp, futureFutureTimestamp, course1);
    textExercise.setGradingInstructions("some grading instructions");
    textExercise.setExampleSolution("Example Solution");
    addGradingInstructionsToExercise(textExercise);
    textExercise.getCategories().add("Text");
    textExercise.setKnowledge(textAssessmentKnowledgeService.createNewKnowledge());
    course1.addExercises(textExercise);
    FileUploadExercise fileUploadExercise = ModelFactory.generateFileUploadExercise(pastTimestamp, futureTimestamp, futureFutureTimestamp, "png", course1);
    fileUploadExercise.setGradingInstructions("some grading instructions");
    fileUploadExercise.setExampleSolution("Example Solution");
    addGradingInstructionsToExercise(fileUploadExercise);
    fileUploadExercise.getCategories().add("File");
    course1.addExercises(fileUploadExercise);
    ProgrammingExercise programmingExercise = ModelFactory.generateProgrammingExercise(pastTimestamp, futureTimestamp, course1);
    programmingExercise.setGradingInstructions("some grading instructions");
    addGradingInstructionsToExercise(programmingExercise);
    programmingExercise.getCategories().add("Programming");
    course1.addExercises(programmingExercise);
    QuizExercise quizExercise = ModelFactory.generateQuizExercise(pastTimestamp, futureTimestamp, course1);
    programmingExercise.getCategories().add("Quiz");
    course1.addExercises(quizExercise);
    Lecture lecture1 = ModelFactory.generateLecture(pastTimestamp, futureFutureTimestamp, course1);
    Attachment attachment1 = ModelFactory.generateAttachment(pastTimestamp, lecture1);
    lecture1.addAttachments(attachment1);
    course1.addLectures(lecture1);
    Lecture lecture2 = ModelFactory.generateLecture(pastTimestamp, futureFutureTimestamp, course1);
    Attachment attachment2 = ModelFactory.generateAttachment(pastTimestamp, lecture2);
    lecture2.addAttachments(attachment2);
    course1.addLectures(lecture2);
    course1 = courseRepo.save(course1);
    course2 = courseRepo.save(course2);
    lectureRepo.save(lecture1);
    lectureRepo.save(lecture2);
    attachmentRepo.save(attachment1);
    attachmentRepo.save(attachment2);
    modelingExercise = exerciseRepo.save(modelingExercise);
    textExercise = exerciseRepo.save(textExercise);
    exerciseRepo.save(fileUploadExercise);
    exerciseRepo.save(programmingExercise);
    exerciseRepo.save(quizExercise);
    if (withParticipations) {
        // create 5 tutor participations and 5 example submissions and connect all of them (to test the many-to-many relationship)
        var tutorParticipations = new ArrayList<TutorParticipation>();
        for (int i = 1; i < 6; i++) {
            var tutorParticipation = new TutorParticipation().tutor(getUserByLogin("tutor" + i));
            tutorParticipationRepo.save(tutorParticipation);
            tutorParticipations.add(tutorParticipation);
        }
        for (int i = 0; i < 5; i++) {
            String validModel = FileUtils.loadFileFromResources("test-data/model-submission/model.54727.json");
            var exampleSubmission = addExampleSubmission(generateExampleSubmission(validModel, modelingExercise, true));
            exampleSubmission.assessmentExplanation("exp");
            for (var tutorParticipation : tutorParticipations) {
                exampleSubmission.addTutorParticipations(tutorParticipation);
            }
            exampleSubmissionRepo.save(exampleSubmission);
        }
        User user = (userRepo.findOneByLogin("student1")).get();
        StudentParticipation participation1 = ModelFactory.generateStudentParticipation(InitializationState.INITIALIZED, modelingExercise, user);
        StudentParticipation participation2 = ModelFactory.generateStudentParticipation(InitializationState.FINISHED, textExercise, user);
        StudentParticipation participation3 = ModelFactory.generateStudentParticipation(InitializationState.UNINITIALIZED, modelingExercise, user);
        Submission modelingSubmission1 = ModelFactory.generateModelingSubmission("model1", true);
        Submission modelingSubmission2 = ModelFactory.generateModelingSubmission("model2", true);
        Submission textSubmission = ModelFactory.generateTextSubmission("text", Language.ENGLISH, true);
        Result result1 = ModelFactory.generateResult(true, 10D);
        Result result2 = ModelFactory.generateResult(true, 12D);
        Result result3 = ModelFactory.generateResult(false, 0D);
        participation1 = studentParticipationRepo.save(participation1);
        participation2 = studentParticipationRepo.save(participation2);
        participation3 = studentParticipationRepo.save(participation3);
        submissionRepository.save(modelingSubmission1);
        submissionRepository.save(modelingSubmission2);
        submissionRepository.save(textSubmission);
        modelingSubmission1.setParticipation(participation1);
        textSubmission.setParticipation(participation2);
        modelingSubmission2.setParticipation(participation3);
        result1.setParticipation(participation1);
        result2.setParticipation(participation3);
        result3.setParticipation(participation2);
        result1 = resultRepo.save(result1);
        result2 = resultRepo.save(result2);
        result3 = resultRepo.save(result3);
        result1.setSubmission(modelingSubmission1);
        result2.setSubmission(modelingSubmission2);
        result3.setSubmission(textSubmission);
        modelingSubmission1.addResult(result1);
        modelingSubmission2.addResult(result2);
        textSubmission.addResult(result3);
        submissionRepository.save(modelingSubmission1);
        submissionRepository.save(modelingSubmission2);
        submissionRepository.save(textSubmission);
    }
    return Arrays.asList(course1, course2);
}

Example 2 with TutorParticipation

use of de.tum.in.www1.artemis.domain.participation.TutorParticipation in project ArTEMiS by ls1intum.

the class AssessmentDashboardService method generateStatisticsForExercisesForAssessmentDashboard.

/**
 * Prepares the exercises for the assessment dashboard by setting the tutor participations and statistics
 * This is very slow as each iteration takes about 2.5 s
 * @param exercises exercises to be prepared for the assessment dashboard
 * @param tutorParticipations participations of the tutors
 * @param examMode flag should be set for exam dashboard
 */
public void generateStatisticsForExercisesForAssessmentDashboard(Set<Exercise> exercises, List<TutorParticipation> tutorParticipations, boolean examMode) {
    log.debug("generateStatisticsForExercisesForAssessmentDashboard invoked");
    // start measures performance of each individual query, start2 measures performance of one loop iteration
    long start = System.nanoTime();
    long start2 = System.nanoTime();
    long startComplete = System.nanoTime();
    Set<Exercise> programmingExerciseIds = exercises.stream().filter(exercise -> exercise instanceof ProgrammingExercise).collect(Collectors.toSet());
    Set<Exercise> nonProgrammingExerciseIds = exercises.stream().filter(exercise -> !(exercise instanceof ProgrammingExercise)).collect(Collectors.toSet());
    complaintService.calculateNrOfOpenComplaints(exercises, examMode);
    log.debug("Finished >> complaintService.calculateNrOfOpenComplaints all << in {}", TimeLogUtil.formatDurationFrom(start));
    start = System.nanoTime();
    calculateNumberOfSubmissions(programmingExerciseIds, nonProgrammingExerciseIds, examMode);
    log.debug("Finished >> assessmentDashboardService.calculateNumberOfSubmissions all << in {}", TimeLogUtil.formatDurationFrom(start));
    start = System.nanoTime();
    // parts of this loop can possibly still be extracted
    for (Exercise exercise : exercises) {
        DueDateStat totalNumberOfAssessments;
        if (exercise instanceof ProgrammingExercise) {
            totalNumberOfAssessments = new DueDateStat(programmingExerciseRepository.countAssessmentsByExerciseIdSubmitted(exercise.getId(), examMode), 0L);
            log.debug("Finished >> programmingExerciseRepository.countAssessmentsByExerciseIdSubmitted << call for exercise {} in {}", exercise.getId(), TimeLogUtil.formatDurationFrom(start));
        } else {
            totalNumberOfAssessments = resultRepository.countNumberOfFinishedAssessmentsForExercise(exercise.getId(), examMode);
            log.debug("Finished >> resultRepository.countNumberOfFinishedAssessmentsForExercise << call for exercise {} in {}", exercise.getId(), TimeLogUtil.formatDurationFrom(start));
        }
        start = System.nanoTime();
        final DueDateStat[] numberOfAssessmentsOfCorrectionRounds;
        if (examMode) {
            // set number of corrections specific to each correction round
            int numberOfCorrectionRounds = exercise.getExerciseGroup().getExam().getNumberOfCorrectionRoundsInExam();
            numberOfAssessmentsOfCorrectionRounds = resultRepository.countNumberOfFinishedAssessmentsForExamExerciseForCorrectionRounds(exercise, numberOfCorrectionRounds);
            log.debug("Finished >> resultRepository.countNumberOfFinishedAssessmentsForExamExerciseForCorrectionRounds << call for exercise {} in {}", exercise.getId(), TimeLogUtil.formatDurationFrom(start));
        } else {
            // no examMode here, so correction rounds defaults to 1 and is the same as totalNumberOfAssessments
            numberOfAssessmentsOfCorrectionRounds = new DueDateStat[] { totalNumberOfAssessments };
        }
        exercise.setNumberOfAssessmentsOfCorrectionRounds(numberOfAssessmentsOfCorrectionRounds);
        exercise.setTotalNumberOfAssessments(numberOfAssessmentsOfCorrectionRounds[0]);
        start = System.nanoTime();
        Set<ExampleSubmission> exampleSubmissions = exampleSubmissionRepository.findAllWithResultByExerciseId(exercise.getId());
        log.debug("Finished >> exampleSubmissionRepository.findAllWithResultByExerciseId << call for course {} in {}", exercise.getId(), TimeLogUtil.formatDurationFrom(start));
        start = System.nanoTime();
        // Do not provide example submissions without any assessment
        exampleSubmissions.removeIf(exampleSubmission -> exampleSubmission.getSubmission() == null || exampleSubmission.getSubmission().getLatestResult() == null);
        exercise.setExampleSubmissions(exampleSubmissions);
        TutorParticipation tutorParticipation = tutorParticipations.stream().filter(participation -> participation.getAssessedExercise().getId().equals(exercise.getId())).findFirst().orElseGet(() -> {
            TutorParticipation emptyTutorParticipation = new TutorParticipation();
            emptyTutorParticipation.setStatus(TutorParticipationStatus.NOT_PARTICIPATED);
            return emptyTutorParticipation;
        });
        exercise.setTutorParticipations(Collections.singleton(tutorParticipation));
        var exerciseRating = ratingService.averageRatingByExerciseId(exercise.getId());
        exercise.setAverageRating(exerciseRating.averageRating());
        exercise.setNumberOfRatings(exerciseRating.numberOfRatings());
        log.debug("Finished >> assessmentDashboardLoopIteration << call for exercise {} in {}", exercise.getId(), TimeLogUtil.formatDurationFrom(start2));
    }
    log.debug("Finished >> generateStatisticsForExercisesForAssessmentDashboard << call in {}", TimeLogUtil.formatDurationFrom(startComplete));
}

Example 3 with TutorParticipation

use of de.tum.in.www1.artemis.domain.participation.TutorParticipation in project ArTEMiS by ls1intum.

the class ExampleSubmissionIntegrationTest method createAndDeleteExampleModelingSubmissionWithResult.

@ParameterizedTest(name = "{displayName} [{index}] {argumentsWithNames}")
@ValueSource(booleans = { true, false })
@WithMockUser(username = "instructor1", roles = "INSTRUCTOR")
public void createAndDeleteExampleModelingSubmissionWithResult(boolean usedForTutorial) throws Exception {
    exampleSubmission = database.generateExampleSubmission(validModel, modelingExercise, false, usedForTutorial);
    exampleSubmission.addTutorParticipations(new TutorParticipation());
    ExampleSubmission returnedExampleSubmission = request.postWithResponseBody("/api/exercises/" + modelingExercise.getId() + "/example-submissions", exampleSubmission, ExampleSubmission.class, HttpStatus.OK);
    Long submissionId = returnedExampleSubmission.getSubmission().getId();
    database.checkModelingSubmissionCorrectlyStored(submissionId, validModel);
    Optional<ExampleSubmission> storedExampleSubmission = exampleSubmissionRepo.findBySubmissionId(submissionId);
    assertThat(storedExampleSubmission).as("example submission correctly stored").isPresent();
    assertThat(storedExampleSubmission.get().getSubmission().isExampleSubmission()).as("submission flagged as example submission").isTrue();
    request.delete("/api/example-submissions/" + storedExampleSubmission.get().getId(), HttpStatus.OK);
    assertThat(exampleSubmissionRepo.findAllByExerciseId(submissionId)).isEmpty();
}

Example 4 with TutorParticipation

use of de.tum.in.www1.artemis.domain.participation.TutorParticipation in project ArTEMiS by ls1intum.

the class TutorParticipationService method findByExerciseAndTutor.

/**
 * Given an exercise and a tutor, it retrieves the participation of the tutor for that exercise. If there isn't any participation in the database, it returns a participation
 * with status NOT_PARTICIPATED
 *
 * @param exercise the exercise we want to retrieve the tutor participation
 * @param tutor    the tutor of whom we want to retrieve the participation
 * @return a tutor participation object for the pair (exercise, tutor) passed as argument
 */
public TutorParticipation findByExerciseAndTutor(Exercise exercise, User tutor) {
    TutorParticipation participation = tutorParticipationRepository.findWithEagerExampleSubmissionAndResultsByAssessedExerciseAndTutor(exercise, tutor);
    if (participation == null) {
        participation = new TutorParticipation();
        participation.setStatus(NOT_PARTICIPATED);
    }
    return participation;
}

Example 5 with TutorParticipation

use of de.tum.in.www1.artemis.domain.participation.TutorParticipation in project ArTEMiS by ls1intum.

the class ExamResource method getExamForAssessmentDashboard.

/**
 * GET /courses/:courseId/exams/:examId/exam-for-assessment-dashboard
 *
 * @param courseId the id of the course to retrieve
 * @param examId   the id of the exam that contains the exercises
 * @return data about a course including all exercises, plus some data for the tutor as tutor status for assessment
 */
@GetMapping("/courses/{courseId}/exams/{examId}/exam-for-assessment-dashboard")
@PreAuthorize("hasRole('TA')")
public ResponseEntity<Exam> getExamForAssessmentDashboard(@PathVariable long courseId, @PathVariable long examId) {
    log.debug("REST request /courses/{courseId}/exams/{examId}/exam-for-assessment-dashboard");
    Exam exam = examService.findByIdWithExerciseGroupsAndExercisesElseThrow(examId);
    Course course = exam.getCourse();
    checkExamCourseIdElseThrow(courseId, exam);
    User user = userRepository.getUserWithGroupsAndAuthorities();
    authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.TEACHING_ASSISTANT, course, user);
    if (ZonedDateTime.now().isBefore(exam.getEndDate()) && authCheckService.isTeachingAssistantInCourse(course, user)) {
        // tutors cannot access the exercises before the exam ends
        throw new AccessForbiddenException("exam", examId);
    }
    Set<Exercise> exercises = new HashSet<>();
    // extract all exercises for all the exam
    for (ExerciseGroup exerciseGroup : exam.getExerciseGroups()) {
        exerciseGroup.setExercises(courseRepository.getInterestingExercisesForAssessmentDashboards(exerciseGroup.getExercises()));
        exercises.addAll(exerciseGroup.getExercises());
    }
    List<TutorParticipation> tutorParticipations = tutorParticipationRepository.findAllByAssessedExercise_ExerciseGroup_Exam_IdAndTutor_Id(examId, user.getId());
    assessmentDashboardService.generateStatisticsForExercisesForAssessmentDashboard(exercises, tutorParticipations, true);
    return ResponseEntity.ok(exam);
}