use of de.tum.in.www1.artemis.domain.modeling.ModelingExercise in project ArTEMiS by ls1intum.
the class DatabaseUtilService method addCourseWithDifferentModelingExercises.
public Course addCourseWithDifferentModelingExercises() {
Course course = ModelFactory.generateCourse(null, pastTimestamp, futureFutureTimestamp, new HashSet<>(), "tumuser", "tutor", "editor", "instructor");
ModelingExercise classExercise = ModelFactory.generateModelingExercise(pastTimestamp, futureTimestamp, futureFutureTimestamp, DiagramType.ClassDiagram, course);
classExercise.setTitle("ClassDiagram");
course.addExercises(classExercise);
ModelingExercise activityExercise = ModelFactory.generateModelingExercise(pastTimestamp, futureTimestamp, futureFutureTimestamp, DiagramType.ActivityDiagram, course);
activityExercise.setTitle("ActivityDiagram");
course.addExercises(activityExercise);
ModelingExercise objectExercise = ModelFactory.generateModelingExercise(pastTimestamp, futureTimestamp, futureFutureTimestamp, DiagramType.ObjectDiagram, course);
objectExercise.setTitle("ObjectDiagram");
course.addExercises(objectExercise);
ModelingExercise useCaseExercise = ModelFactory.generateModelingExercise(pastTimestamp, futureTimestamp, futureFutureTimestamp, DiagramType.UseCaseDiagram, course);
useCaseExercise.setTitle("UseCaseDiagram");
course.addExercises(useCaseExercise);
ModelingExercise communicationExercise = ModelFactory.generateModelingExercise(pastTimestamp, futureTimestamp, futureFutureTimestamp, DiagramType.CommunicationDiagram, course);
communicationExercise.setTitle("CommunicationDiagram");
course.addExercises(communicationExercise);
ModelingExercise componentExercise = ModelFactory.generateModelingExercise(pastTimestamp, futureTimestamp, futureFutureTimestamp, DiagramType.ComponentDiagram, course);
componentExercise.setTitle("ComponentDiagram");
course.addExercises(componentExercise);
ModelingExercise deploymentExercise = ModelFactory.generateModelingExercise(pastTimestamp, futureTimestamp, futureFutureTimestamp, DiagramType.DeploymentDiagram, course);
deploymentExercise.setTitle("DeploymentDiagram");
course.addExercises(deploymentExercise);
ModelingExercise petriNetExercise = ModelFactory.generateModelingExercise(pastTimestamp, futureTimestamp, futureFutureTimestamp, DiagramType.PetriNet, course);
petriNetExercise.setTitle("PetriNet");
course.addExercises(petriNetExercise);
ModelingExercise syntaxTreeExercise = ModelFactory.generateModelingExercise(pastTimestamp, futureTimestamp, futureFutureTimestamp, DiagramType.SyntaxTree, course);
syntaxTreeExercise.setTitle("SyntaxTree");
course.addExercises(syntaxTreeExercise);
ModelingExercise flowchartExercise = ModelFactory.generateModelingExercise(pastTimestamp, futureTimestamp, futureFutureTimestamp, DiagramType.Flowchart, course);
flowchartExercise.setTitle("Flowchart");
course.addExercises(flowchartExercise);
ModelingExercise finishedExercise = ModelFactory.generateModelingExercise(pastTimestamp, pastTimestamp, futureTimestamp, DiagramType.ClassDiagram, course);
finishedExercise.setTitle("finished");
course.addExercises(finishedExercise);
course = courseRepo.save(course);
exerciseRepo.save(classExercise);
exerciseRepo.save(activityExercise);
exerciseRepo.save(objectExercise);
exerciseRepo.save(useCaseExercise);
exerciseRepo.save(communicationExercise);
exerciseRepo.save(componentExercise);
exerciseRepo.save(deploymentExercise);
exerciseRepo.save(petriNetExercise);
exerciseRepo.save(syntaxTreeExercise);
exerciseRepo.save(flowchartExercise);
exerciseRepo.save(finishedExercise);
Course storedCourse = courseRepo.findByIdWithExercisesAndLecturesElseThrow(course.getId());
Set<Exercise> exercises = storedCourse.getExercises();
assertThat(exercises.size()).as("eleven exercises got stored").isEqualTo(11);
assertThat(exercises).as("Contains all exercises").containsExactlyInAnyOrder(course.getExercises().toArray(new Exercise[] {}));
return course;
}
use of de.tum.in.www1.artemis.domain.modeling.ModelingExercise in project ArTEMiS by ls1intum.
the class DatabaseUtilService method addModelingAssessmentForSubmission.
public Result addModelingAssessmentForSubmission(ModelingExercise exercise, ModelingSubmission submission, String path, String login, boolean submit) throws Exception {
List<Feedback> feedbackList = loadAssessmentFomResources(path);
Result result = assessmentService.saveManualAssessment(submission, feedbackList, null);
result.setParticipation(submission.getParticipation().results(null));
result.setAssessor(getUserByLogin(login));
resultRepo.save(result);
if (submit) {
assessmentService.submitManualAssessment(result.getId(), exercise, submission.getSubmissionDate());
}
return resultRepo.findWithEagerSubmissionAndFeedbackAndAssessorById(result.getId()).get();
}
use of de.tum.in.www1.artemis.domain.modeling.ModelingExercise in project ArTEMiS by ls1intum.
the class DatabaseUtilService method generateTestRunForInstructor.
public StudentExam generateTestRunForInstructor(Exam exam, User instructor, List<Exercise> exercises) {
var testRun = ModelFactory.generateExamTestRun(exam);
testRun.setUser(instructor);
examRepository.findWithExerciseGroupsAndExercisesById(exam.getId()).get();
for (final var exercise : exercises) {
testRun.addExercise(exercise);
assertThat(exercise.isExamExercise()).isTrue();
Submission submission;
if (exercise instanceof ModelingExercise) {
submission = addModelingSubmission((ModelingExercise) exercise, ModelFactory.generateModelingSubmission("", false), instructor.getLogin());
} else if (exercise instanceof TextExercise) {
submission = saveTextSubmission((TextExercise) exercise, ModelFactory.generateTextSubmission("", null, false), instructor.getLogin());
} else {
submission = new ProgrammingSubmission().submitted(true);
addProgrammingSubmission((ProgrammingExercise) exercise, (ProgrammingSubmission) submission, instructor.getLogin());
submission = submissionRepository.save(submission);
}
var studentParticipation = (StudentParticipation) submission.getParticipation();
studentParticipation.setTestRun(true);
studentParticipationRepo.save(studentParticipation);
}
return testRun;
}
use of de.tum.in.www1.artemis.domain.modeling.ModelingExercise in project ArTEMiS by ls1intum.
the class DatabaseUtilService method addCourseInOtherInstructionGroupAndExercise.
/**
* @param title The title reflect the genre of exercise that will be added to the course
*/
public void addCourseInOtherInstructionGroupAndExercise(String title) {
Course course = ModelFactory.generateCourse(null, pastTimestamp, futureFutureTimestamp, new HashSet<>(), "tumuser", "tutor", "editor", "other-instructors");
if ("Programming".equals(title)) {
course = courseRepo.save(course);
var programmingExercise = (ProgrammingExercise) new ProgrammingExercise().course(course);
populateProgrammingExercise(programmingExercise, "TSTEXC", "Programming", false);
programmingExercise.setPresentationScoreEnabled(course.getPresentationScore() != 0);
programmingExercise = programmingExerciseRepository.save(programmingExercise);
course.addExercises(programmingExercise);
programmingExercise = addSolutionParticipationForProgrammingExercise(programmingExercise);
programmingExercise = addTemplateParticipationForProgrammingExercise(programmingExercise);
assertThat(programmingExercise.getPresentationScoreEnabled()).as("presentation score is enabled").isTrue();
} else if ("Text".equals(title)) {
TextExercise textExercise = ModelFactory.generateTextExercise(pastTimestamp, futureTimestamp, futureFutureTimestamp, course);
textExercise.setTitle("Text");
course.addExercises(textExercise);
courseRepo.save(course);
exerciseRepo.save(textExercise);
} else if ("ClassDiagram".equals(title)) {
ModelingExercise modelingExercise = ModelFactory.generateModelingExercise(pastTimestamp, futureTimestamp, futureFutureTimestamp, DiagramType.ClassDiagram, course);
modelingExercise.setTitle("ClassDiagram");
course.addExercises(modelingExercise);
courseRepo.save(course);
exerciseRepo.save(modelingExercise);
}
}
use of de.tum.in.www1.artemis.domain.modeling.ModelingExercise 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);
}
Aggregations