Examples with ModelingExercise de.tum.in.www1.artemis.domain.modeling.ModelingExercise used on opensource projects

Example 31 with ModelingExercise

use of de.tum.in.www1.artemis.domain.modeling.ModelingExercise in project ArTEMiS by ls1intum.

the class ModelingSubmissionService method save.

/**
 * Saves the given submission and the corresponding model and creates the result if necessary. This method used for creating and updating modeling submissions.
 *
 * @param modelingSubmission the submission that should be saved
 * @param modelingExercise   the exercise the submission belongs to
 * @param username           the name of the corresponding user
 * @return the saved modelingSubmission entity
 */
public ModelingSubmission save(ModelingSubmission modelingSubmission, ModelingExercise modelingExercise, String username) {
    Optional<StudentParticipation> optionalParticipation = participationService.findOneByExerciseAndStudentLoginWithEagerSubmissionsAnyState(modelingExercise, username);
    if (optionalParticipation.isEmpty()) {
        throw new EntityNotFoundException("No participation found for " + username + " in exercise with id " + modelingExercise.getId());
    }
    StudentParticipation participation = optionalParticipation.get();
    final Optional<ZonedDateTime> dueDate = exerciseDateService.getDueDate(participation);
    if (dueDate.isPresent() && exerciseDateService.isAfterDueDate(participation) && participation.getInitializationDate().isBefore(dueDate.get())) {
        throw new ResponseStatusException(HttpStatus.FORBIDDEN);
    }
    // remove result from submission (in the unlikely case it is passed here), so that students cannot inject a result
    modelingSubmission.setResults(new ArrayList<>());
    // NOTE: from now on we always set submitted to true to prevent problems here! Except for late submissions of course exercises to prevent issues in auto-save
    if (modelingExercise.isExamExercise() || exerciseDateService.isBeforeDueDate(participation)) {
        modelingSubmission.setSubmitted(true);
    }
    modelingSubmission.setSubmissionDate(ZonedDateTime.now());
    modelingSubmission.setType(SubmissionType.MANUAL);
    modelingSubmission.setParticipation(participation);
    modelingSubmission = modelingSubmissionRepository.save(modelingSubmission);
    // versioning of submission
    try {
        if (modelingExercise.isTeamMode()) {
            submissionVersionService.saveVersionForTeam(modelingSubmission, username);
        } else if (modelingExercise.isExamExercise()) {
            submissionVersionService.saveVersionForIndividual(modelingSubmission, username);
        }
    } catch (Exception ex) {
        log.error("Modeling submission version could not be saved", ex);
    }
    participation.addSubmission(modelingSubmission);
    participation.setInitializationState(InitializationState.FINISHED);
    StudentParticipation savedParticipation = studentParticipationRepository.save(participation);
    if (modelingSubmission.getId() == null) {
        Optional<Submission> optionalSubmission = savedParticipation.findLatestSubmission();
        if (optionalSubmission.isPresent()) {
            modelingSubmission = (ModelingSubmission) optionalSubmission.get();
        }
    }
    log.debug("return model: {}", modelingSubmission.getModel());
    return modelingSubmission;
}

Example 32 with ModelingExercise

use of de.tum.in.www1.artemis.domain.modeling.ModelingExercise in project ArTEMiS by ls1intum.

the class ExampleSubmissionService method importStudentSubmissionAsExampleSubmission.

/**
 * Creates new example submission by copying the student submission with its assessments
 * calls copySubmission of required service depending on type of exercise
 *
 * @param submissionId The original student submission id to be copied
 * @param exercise   The exercise to which the example submission belongs
 * @return the exampleSubmission entity
 */
public ExampleSubmission importStudentSubmissionAsExampleSubmission(Long submissionId, Exercise exercise) {
    ExampleSubmission newExampleSubmission = new ExampleSubmission();
    newExampleSubmission.setExercise(exercise);
    if (exercise instanceof ModelingExercise) {
        ModelingSubmission modelingSubmission = (ModelingSubmission) submissionRepository.findOneWithEagerResultAndFeedback(submissionId);
        checkGivenExerciseIdSameForSubmissionParticipation(exercise.getId(), modelingSubmission.getParticipation().getExercise().getId());
        // example submission does not need participation
        modelingSubmission.setParticipation(null);
        newExampleSubmission.setSubmission(modelingExerciseImportService.copySubmission(modelingSubmission, new HashMap<>()));
    }
    if (exercise instanceof TextExercise) {
        TextSubmission textSubmission = textSubmissionRepository.findByIdWithEagerResultsAndFeedbackAndTextBlocksElseThrow(submissionId);
        checkGivenExerciseIdSameForSubmissionParticipation(exercise.getId(), textSubmission.getParticipation().getExercise().getId());
        // example submission does not need participation
        textSubmission.setParticipation(null);
        newExampleSubmission.setSubmission(textExerciseImportService.copySubmission(textSubmission));
    }
    return exampleSubmissionRepository.save(newExampleSubmission);
}

Example 33 with ModelingExercise

use of de.tum.in.www1.artemis.domain.modeling.ModelingExercise in project ArTEMiS by ls1intum.

the class ModelingPlagiarismDetectionService method checkPlagiarism.

/**
 * Convenience method to extract all latest submissions from a ModelingExercise and compute pair-wise distances.
 *
 * @param exerciseWithParticipationsSubmissionsResults Text Exercise with fetched participations and submissions
 * @param minimumSimilarity                            the minimum similarity so that the result is considered
 * @param minimumModelSize                             the minimum number of model elements to be considered as plagiarism
 * @param minimumScore                                 the minimum result score (if available) to be considered as plagiarism
 * @return List of submission id pairs and similarity score
 */
public ModelingPlagiarismResult checkPlagiarism(ModelingExercise exerciseWithParticipationsSubmissionsResults, double minimumSimilarity, int minimumModelSize, int minimumScore) {
    final List<ModelingSubmission> modelingSubmissions = modelingSubmissionsForComparison(exerciseWithParticipationsSubmissionsResults);
    log.info("Found {} modeling submissions in exercise {}", modelingSubmissions.size(), exerciseWithParticipationsSubmissionsResults.getId());
    Long exerciseId = exerciseWithParticipationsSubmissionsResults.getId();
    ModelingPlagiarismResult result = checkPlagiarism(modelingSubmissions, minimumSimilarity, minimumModelSize, minimumScore, exerciseId);
    result.setExercise(exerciseWithParticipationsSubmissionsResults);
    return result;
}

Example 34 with ModelingExercise

use of de.tum.in.www1.artemis.domain.modeling.ModelingExercise in project ArTEMiS by ls1intum.

the class ExamIntegrationTest method testStartExercisesWithModelingExercise.

@Test
@WithMockUser(username = "instructor1", roles = "INSTRUCTOR")
public void testStartExercisesWithModelingExercise() throws Exception {
    // TODO IMPORTANT test more complex exam configurations (mixed exercise type, more variants and more registered students)
    // registering users
    var student1 = database.getUserByLogin("student1");
    var student2 = database.getUserByLogin("student2");
    var registeredUsers = Set.of(student1, student2);
    exam2.setRegisteredUsers(registeredUsers);
    // setting dates
    exam2.setStartDate(now().plusHours(2));
    exam2.setEndDate(now().plusHours(3));
    exam2.setVisibleDate(now().plusHours(1));
    // creating exercise
    ModelingExercise modelingExercise = ModelFactory.generateModelingExerciseForExam(DiagramType.ClassDiagram, exam2.getExerciseGroups().get(0));
    exam2.getExerciseGroups().get(0).addExercise(modelingExercise);
    exerciseGroupRepository.save(exam2.getExerciseGroups().get(0));
    modelingExercise = exerciseRepo.save(modelingExercise);
    List<StudentExam> createdStudentExams = new ArrayList<>();
    // creating student exams
    for (User user : registeredUsers) {
        StudentExam studentExam = new StudentExam();
        studentExam.addExercise(modelingExercise);
        studentExam.setUser(user);
        exam2.addStudentExam(studentExam);
        createdStudentExams.add(studentExamRepository.save(studentExam));
    }
    exam2 = examRepository.save(exam2);
    // invoke start exercises
    Integer noGeneratedParticipations = request.postWithResponseBody("/api/courses/" + course1.getId() + "/exams/" + exam2.getId() + "/student-exams/start-exercises", Optional.empty(), Integer.class, HttpStatus.OK);
    assertThat(noGeneratedParticipations).isEqualTo(exam2.getStudentExams().size());
    List<Participation> studentParticipations = participationTestRepository.findAllWithSubmissions();
    for (Participation participation : studentParticipations) {
        assertThat(participation.getExercise()).isEqualTo(modelingExercise);
        assertThat(participation.getExercise().getCourseViaExerciseGroupOrCourseMember()).isNotNull();
        assertThat(participation.getExercise().getExerciseGroup()).isEqualTo(exam2.getExerciseGroups().get(0));
        assertThat(participation.getSubmissions()).hasSize(1);
        var textSubmission = (ModelingSubmission) participation.getSubmissions().iterator().next();
        assertThat(textSubmission.getModel()).isNull();
        assertThat(textSubmission.getExplanationText()).isNull();
    }
    // Cleanup of Bidirectional Relationships
    for (StudentExam studentExam : createdStudentExams) {
        exam2.removeStudentExam(studentExam);
    }
    examRepository.save(exam2);
}

Example 35 with ModelingExercise

use of de.tum.in.www1.artemis.domain.modeling.ModelingExercise in project ArTEMiS by ls1intum.

the class ExampleSubmissionIntegrationTest method importExampleSubmissionWithModelingSubmission_exerciseIdNotMatched.

@Test
@WithMockUser(username = "instructor1", roles = "INSTRUCTOR")
public void importExampleSubmissionWithModelingSubmission_exerciseIdNotMatched() throws Exception {
    Submission submission = ModelFactory.generateModelingSubmission(validModel, true);
    submission = database.addModelingSubmission(modelingExercise, (ModelingSubmission) submission, "student1");
    Exercise modelingExerciseToBeConflicted = new ModelingExercise();
    modelingExerciseToBeConflicted.setCourse(course);
    Exercise exercise = exerciseRepository.save(modelingExerciseToBeConflicted);
    importExampleSubmission(exercise.getId(), submission.getId(), HttpStatus.BAD_REQUEST);
}