From bd57610cd5245b473207649c246920e20f7105be Mon Sep 17 00:00:00 2001 From: yetju000 Date: Sat, 23 Nov 2019 13:32:20 +0100 Subject: [PATCH] added test controller --- .../controller/TestController.java | 449 ++++++++++++++++++ .../model/studyGroup/GroupRepository.java | 14 + .../studycaverestservice/model/test/Test.java | 21 +- .../model/test/TestRepository.java | 19 + .../model/test/dto/AnswerChoicesSolveDTO.java | 19 + .../test/dto/AnswerChoicesVerifyDTO.java | 14 + .../model/test/dto/AnswerGapsSolveDTO.java | 16 + .../model/test/dto/AnswerGapsVerifyDTO.java | 11 + .../model/test/dto/AnswerPairsSolveDTO.java | 44 ++ .../model/test/dto/AnswerPairsVerifyDTO.java | 11 + .../model/test/dto/AnswerPuzzleSolveDTO.java | 30 ++ .../model/test/dto/AnswerPuzzleVerifyDTO.java | 14 + .../model/test/dto/AnswerVerifyDTO.java | 13 + .../model/test/dto/GetResultDTO.java | 16 + .../model/test/dto/QuestionVerifyDTO.java | 28 ++ .../model/test/dto/Result.java | 19 + .../model/test/dto/ResultPairs.java | 23 + .../model/test/dto/ResultResponse.java | 19 + .../model/test/dto/SaveTestResultDTO.java | 36 ++ .../model/test/dto/TestCreateDTO.java | 38 ++ .../model/test/dto/TestEditDTO.java | 40 ++ .../model/test/dto/TestOwnerDTO.java | 38 ++ .../model/test/question/Answer.java | 32 ++ .../model/test/question/AnswerChoices.java | 24 + .../model/test/question/AnswerGaps.java | 23 + .../model/test/question/AnswerPairs.java | 19 + .../model/test/question/AnswerPuzzle.java | 17 + .../model/test/question/AnswerRepository.java | 6 + .../model/test/question/Question.java | 67 +++ .../model/test/question/QuestionChoices.java | 39 ++ .../model/test/question/QuestionGaps.java | 27 ++ .../model/test/question/QuestionPairs.java | 29 ++ .../model/test/question/QuestionPuzzle.java | 26 + .../test/question/QuestionRepository.java | 7 + .../model/test/result/TestResult.java | 27 ++ .../test/result/TestResultRepository.java | 13 + .../model/test/verifier/QuestionVerifier.java | 159 +++++++ .../verifier/QuestionVerifyDeserializer.java | 67 +++ .../model/userActivity/UserActivity.java | 12 + .../userActivity/UserActivityRepository.java | 17 + .../userActivity/UserActivityService.java | 50 ++ BackEnd/src/main/resources/opencsv-4.1.jar | Bin 0 -> 105568 bytes 42 files changed, 1591 insertions(+), 2 deletions(-) create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/controller/TestController.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/GroupRepository.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/TestRepository.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerChoicesSolveDTO.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerChoicesVerifyDTO.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerGapsSolveDTO.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerGapsVerifyDTO.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerPairsSolveDTO.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerPairsVerifyDTO.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerPuzzleSolveDTO.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerPuzzleVerifyDTO.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerVerifyDTO.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/GetResultDTO.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/QuestionVerifyDTO.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/Result.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/ResultPairs.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/ResultResponse.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/SaveTestResultDTO.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/TestCreateDTO.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/TestEditDTO.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/TestOwnerDTO.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/Answer.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerChoices.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerGaps.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerPairs.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerPuzzle.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerRepository.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/Question.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionChoices.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionGaps.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionPairs.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionPuzzle.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionRepository.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/result/TestResult.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/result/TestResultRepository.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/verifier/QuestionVerifier.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/test/verifier/QuestionVerifyDeserializer.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/userActivity/UserActivityRepository.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/userActivity/UserActivityService.java create mode 100644 BackEnd/src/main/resources/opencsv-4.1.jar diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/controller/TestController.java b/BackEnd/src/main/java/studycave/studycaverestservice/controller/TestController.java new file mode 100644 index 0000000..0edddf3 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/controller/TestController.java @@ -0,0 +1,449 @@ +package studycave.studycaverestservice.controller; + + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Optional; + +import org.modelmapper.ModelMapper; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.security.access.prepost.PreAuthorize; +import org.springframework.security.core.Authentication; +import org.springframework.security.core.context.SecurityContextHolder; +import org.springframework.web.bind.annotation.CrossOrigin; +import org.springframework.web.bind.annotation.DeleteMapping; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.PutMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.RestController; + +import io.swagger.annotations.Api; +import studycave.studycaverestservice.model.badge.Badge; +import studycave.studycaverestservice.model.badge.BadgeRepository; +import studycave.studycaverestservice.model.simpleTest.SimpleTest; +import studycave.studycaverestservice.model.simpleTest.SimpleTestRepository; +import studycave.studycaverestservice.model.simpleTest.dto.SimpleTestDTO; +import studycave.studycaverestservice.model.studyGroup.GroupRepository; +import studycave.studycaverestservice.model.test.Test; +import studycave.studycaverestservice.model.test.TestRepository; +import studycave.studycaverestservice.model.test.dto.*; +import studycave.studycaverestservice.model.test.question.*; +import studycave.studycaverestservice.model.test.result.TestResult; +import studycave.studycaverestservice.model.test.result.TestResultRepository; +import studycave.studycaverestservice.model.test.verifier.QuestionVerifier; +import studycave.studycaverestservice.model.user.User; +import studycave.studycaverestservice.model.user.UserRepository; +import studycave.studycaverestservice.model.userActivity.UserActivityService; +import studycave.studycaverestservice.model.userBadge.UserBadge; +import studycave.studycaverestservice.model.userBadge.UserBadgeRepository; + +@RestController +@CrossOrigin +@RequestMapping("/tests") +@Api +public class TestController { + + @Autowired + TestRepository testRepository; + @Autowired + QuestionRepository questionRepository; + @Autowired + AnswerRepository answerRepository; + @Autowired + SimpleTestRepository simpleTestRepository; + @Autowired + UserRepository userRepository; + @Autowired + BadgeRepository badgeRepository; + @Autowired + GroupRepository groupRepository; + @Autowired + UserBadgeRepository userBadgeRepository; + @Autowired + ModelMapper modelMapper; + @Autowired + QuestionVerifier questionVerifier; + @Autowired + TestResultRepository testResultRepository; + @Autowired + UserActivityService userActivityService; + + @GetMapping("/{id}") + public Optional getTest(@PathVariable(required = true) Long id) { + Optional test = testRepository.findById(id); + for (Question question : test.get().getQuestions()) { + if(question instanceof QuestionGaps) { + List answers = ((QuestionGaps)question).getAnswers(); + Collections.sort(answers, + (o1, o2) -> o1.getId().compareTo(o2.getId())); + } + } + test.get().setGroup(null); + test.get().setActivity(null); + return test; + } + + @GetMapping("/{id}/solve") + public TestOwnerDTO getTestToSolve(@PathVariable(required = true) Long id) { + + Optional test = testRepository.findById(id); + + for (Question question : test.get().getQuestions()) { + if (question.getType().equals("true-false") || question.getType().equals("single-choice") + || question.getType().equals("multiple-choice")) { + List answersDTOs = new ArrayList(); + for (Answer answer : ((QuestionChoices) question).getAnswers()) { + AnswerChoicesSolveDTO answerDTO = modelMapper.map(answer, AnswerChoicesSolveDTO.class); + answersDTOs.add(answerDTO); + } + ((QuestionChoices) question).setAnswers(answersDTOs); + } + if (question.getType().equals("puzzle")) { + List answersDTOs = new ArrayList(); + for (Answer answer : ((QuestionPuzzle) question).getAnswers()) { + AnswerPuzzleSolveDTO answerDTO = modelMapper.map(answer, AnswerPuzzleSolveDTO.class); + answerDTO.generatePuzzles(); + answersDTOs.add(answerDTO); + } + ((QuestionPuzzle) question).setAnswers(answersDTOs); + } + if (question.getType().equals("gaps")) { + { + List answersDTOs = new ArrayList(); + for (Answer answer : ((QuestionGaps) question).getAnswers()) { + AnswerGapsSolveDTO answerDTO = modelMapper.map(answer, AnswerGapsSolveDTO.class); + if (answerDTO.isGap()) + answerDTO.setContent(null); + + answersDTOs.add(answerDTO); + } + ((QuestionGaps) question).setAnswers(answersDTOs); + } + } + if (question.getType().equals("pairs")) { + List answersDTOs = new ArrayList(); + + List left = new ArrayList(); + List right = new ArrayList(); + + for (Answer answer : ((QuestionPairs) question).getAnswers()) { + left.add(((AnswerPairs) answer).getFirst()); + right.add(((AnswerPairs) answer).getSecond()); + } + Collections.shuffle(left); + Collections.shuffle(right); + answersDTOs.add(new AnswerPairsSolveDTO(left, right)); + ((QuestionPairs) question).setAnswers(answersDTOs); + } + } + User user = userRepository.findById(test.get().getIdOwner()).get(); + TestOwnerDTO testDTO = modelMapper.map(test.get(), TestOwnerDTO.class); + testDTO.setOwner(user.getUsername()); + + return testDTO; + } + + @PostMapping("/results") + public void saveResult(@RequestBody SaveTestResultDTO resultDTO) { + User user = userRepository.findByUsername(resultDTO.getOwner()).orElse(null); + Optional test = testRepository.findById(resultDTO.getIdTest()); + + List testResult = this.testResultRepository.findByIdOwnerAndIdTest(user.getId(), resultDTO.getIdTest()); + + if (testResult.size() > 0) { + return; + } + + + int maxScore = 0; + for (Question question : test.get().getQuestions()) { + maxScore += question.getPoints(); + + } + TestResult result = modelMapper.map(resultDTO, TestResult.class); + result.setIdOwner(user.getId()); + result.setMaxScore(maxScore); + result.setIdResult((long) 0); + testResultRepository.save(result); + if(userBadgeRepository.findByIdAndUser((long)9, user.getId()).isEmpty()) { + UserBadge badgeAchieved = new UserBadge(); + Badge badge = new Badge(); + badge = badgeRepository.findById((long)9).orElse(null); + badgeAchieved.setBadge(badge); + badgeAchieved.setUser(user); + userBadgeRepository.save(badgeAchieved); + } + userActivityService.saveActivity("solvedTest", resultDTO.getUserScore().intValue(), null, user, null, test.get().getGroup(), null, null, test.get()); + } + + @GetMapping("/results/max") + public GetResultDTO saveResult(@RequestParam Long id, @RequestParam String username) { + + User user = userRepository.findByUsername(username).get(); + List result = testResultRepository.findByIdOwnerAndIdTest(user.getId(), id); + + if (!result.isEmpty()) { + TestResult maxResult = result.get(0); + for (TestResult t : result) { + if (t.getUserScore() > maxResult.getUserScore()) { + maxResult = t; + } + } + return new GetResultDTO(maxResult.getUserScore(), maxResult.getMaxScore()); + } else { + Optional test = testRepository.findById(id); + int maxScore = 0; + for (Question question : test.get().getQuestions()) { + maxScore += question.getPoints(); + } + return new GetResultDTO(0, maxScore); + } + + } + + @PostMapping("/{id}/questions/verify") + public ResultResponse verifyQuestion(@PathVariable(required = true) Long id, + @RequestBody QuestionVerifyDTO question) { + return questionVerifier.verify(id, question); + + } + + @PreAuthorize("isAuthenticated()") + @DeleteMapping("/{id}") + public ResponseEntity deleteTest(@PathVariable(required = true) Long id) { + + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + String currentPrincipalName = authentication.getName(); + Long userId = userRepository.findByUsername(currentPrincipalName).get().getId(); + + Optional test = testRepository.findById(id); + if (test.isPresent()) { + if (userId.equals(test.get().getIdOwner())) { + testRepository.deleteById(id); + return new ResponseEntity(HttpStatus.OK); + } + } + return new ResponseEntity("Access Forbidden", HttpStatus.FORBIDDEN); + } + + @PostMapping + public void postTest(@RequestBody TestCreateDTO testDTO) { + User user = userRepository.findByUsername(testDTO.getOwner()).get(); + testDTO.setIdOwner(user.getId()); + Test test = modelMapper.map(testDTO, Test.class); + test.setId((long) 0); + for (Question question : test.getQuestions()) { + question.setTest(test); + if (question instanceof QuestionChoices) { + for (AnswerChoices answer : ((QuestionChoices) question).getAnswers()) + answer.setQuestion(question); + // ((QuestionChoices) question).setType(); + } + if (question instanceof QuestionPairs) { + for (AnswerPairs answer : ((QuestionPairs) question).getAnswers()) + answer.setQuestion(question); + // ((QuestionPairs) question).setType(); + } + if (question instanceof QuestionPuzzle) { + for (AnswerPuzzle answer : ((QuestionPuzzle) question).getAnswers()) + answer.setQuestion(question); + // ((QuestionPuzzle) question).setType(); + } + if (question instanceof QuestionGaps) { + for (AnswerGaps answer : ((QuestionGaps) question).getAnswers()) + answer.setQuestion(question); + // ((QuestionGaps) question).setType(); + } + } + test.setAddDate(); + test.setEditDate(); + test.setGrade(); + + // Badge for creating first test + if(userBadgeRepository.findByIdAndUser((long)4, user.getId()).isEmpty()) { + UserBadge badgeAchieved = new UserBadge(); + Badge badge = new Badge(); + badge = badgeRepository.findById((long)4).orElse(null); + badgeAchieved.setBadge(badge); + badgeAchieved.setUser(user); + userBadgeRepository.save(badgeAchieved); + } + + testRepository.save(test); + } + + @GetMapping + public ResponseEntity getTest(@RequestParam(value = "owner", required = false) String owner, + @RequestParam(value = "permission", required = false) String permission) { + + Optional user = userRepository.findByUsername(owner); + Long ownerId = user.isPresent() ? user.get().getId() : null; + + if (owner != null && !user.isPresent()) + return new ResponseEntity<>(new String("User not found"), HttpStatus.NOT_FOUND); + + ArrayList testDTOs = new ArrayList(); + + List tests = simpleTestRepository.findByOptionalPermissionAndOptionalOwner(permission, ownerId); + for (SimpleTest test : tests) { + String username = userRepository.findById((long) test.getIdOwner()).get().getUsername(); + SimpleTestDTO testDTO = modelMapper.map(test, SimpleTestDTO.class); + testDTO.setOwner(username); + if(test.getGroupId() != null) + testDTO.setGroup(groupRepository.findById((long)test.getGroupId()).orElse(null).getName()); + testDTOs.add(testDTO); + + } + return new ResponseEntity>(testDTOs, HttpStatus.OK); + } + + @PutMapping + public ResponseEntity editTest(@RequestBody TestEditDTO testDTO) { + + + //Authorization + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + String currentPrincipalName = authentication.getName(); + Long userId = userRepository.findByUsername(currentPrincipalName).get().getId(); + + + Optional originalTest = testRepository.findById(testDTO.getId()); + + if (userId.equals(originalTest.get().getIdOwner())) { + // pass + + } else + return new ResponseEntity("Access Forbidden", HttpStatus.FORBIDDEN); + + // + User user = userRepository.findByUsername(testDTO.getOwner()).get(); + testDTO.setIdOwner(user.getId()); + Test test = modelMapper.map(testDTO, Test.class); + for (Question question : test.getQuestions()) { + question.setTest(test); + if (question instanceof QuestionChoices) { + for (AnswerChoices answer : ((QuestionChoices) question).getAnswers()) + answer.setQuestion(question); + // ((QuestionChoices) question).setType(); + } + if (question instanceof QuestionPairs) { + for (AnswerPairs answer : ((QuestionPairs) question).getAnswers()) + answer.setQuestion(question); + // ((QuestionPairs) question).setType(); + } + if (question instanceof QuestionPuzzle) { + for (AnswerPuzzle answer : ((QuestionPuzzle) question).getAnswers()) + answer.setQuestion(question); + // ((QuestionPuzzle) question).setType(); + } + if (question instanceof QuestionGaps) { + for (AnswerGaps answer : ((QuestionGaps) question).getAnswers()) + answer.setQuestion(question); + // ((QuestionGaps) question).setType(); + } + } + + List deleteq = new ArrayList<>(); + List deletea = new ArrayList<>(); + Test oldtest = testRepository.findById(test.getId()).orElse(null); + + test.setAddDate(oldtest.getAddDate()); + test.setEditDate(); + test.setGrade(oldtest.getGrade()); + + Boolean isinq = false; + Boolean isina = false; + + for (Question oldquestion : oldtest.getQuestions()) { + isinq = false; + for (Question question : test.getQuestions()) { + if (oldquestion.getId() == question.getId()) + isinq = true; + + if (oldquestion instanceof QuestionChoices && question instanceof QuestionChoices) { + for (AnswerChoices oldanswer : ((QuestionChoices) oldquestion).getAnswers()) { + isina = false; + for (AnswerChoices answer : ((QuestionChoices) question).getAnswers()) + if (oldanswer.getId() == answer.getId()) + isina = true; + if (isina == false) { + deletea.add(oldanswer.getId()); + // System.out.println("usuwam answer: "+oldanswer.getId()); + } + } + } + if (oldquestion instanceof QuestionPairs && question instanceof QuestionPairs) { + for (AnswerPairs oldanswer : ((QuestionPairs) oldquestion).getAnswers()) { + isina = false; + for (AnswerPairs answer : ((QuestionPairs) question).getAnswers()) + if (oldanswer.getId() == answer.getId()) + isina = true; + if (isina == false) { + deletea.add(oldanswer.getId()); + // System.out.println("usuwam answer: "+oldanswer.getId()); + } + } + } + if (oldquestion instanceof QuestionPuzzle && question instanceof QuestionPuzzle) { + for (AnswerPuzzle oldanswer : ((QuestionPuzzle) oldquestion).getAnswers()) { + isina = false; + for (AnswerPuzzle answer : ((QuestionPuzzle) question).getAnswers()) + if (oldanswer.getId() == answer.getId()) + isina = true; + if (isina == false) { + deletea.add(oldanswer.getId()); + // System.out.println("usuwam answer: "+oldanswer.getId()); + } + } + } + List answers = new ArrayList<>(); + if (oldquestion instanceof QuestionGaps && question instanceof QuestionGaps) { + for (AnswerGaps answer : ((QuestionGaps) question).getAnswers()) { + answers.add(answer); + } + Collections.reverse(answers); + for (AnswerGaps answer : answers) { + answer.setId(null); + answer.setQuestion(question); + } + + for (AnswerGaps oldanswer : ((QuestionGaps) oldquestion).getAnswers()) { + if (answerRepository.findById(oldanswer.getId()) != null) { + deletea.add(oldanswer.getId()); + // deleteq.add(oldquestion.getId()); + // System.out.println("usuwam answer: "+oldanswer.getId()); + } + } + } + + // System.out.println(question.getId()+" "+ oldquestion.getId()); + } + if (isinq == false) { + deleteq.add(oldquestion.getId()); + // System.out.println("usuwam "+oldquestion.getId()); + } + } + + testRepository.save(test); + + for (Long a : deletea) + if (a != null) + if (answerRepository.findById(a) != null) + answerRepository.deleteById(a); + for (Long q : deleteq) + if (q != null) + if (questionRepository.findById(q) != null) + questionRepository.deleteById(q); + + return new ResponseEntity(HttpStatus.OK); + + } +} + diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/GroupRepository.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/GroupRepository.java new file mode 100644 index 0000000..6554ee4 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/GroupRepository.java @@ -0,0 +1,14 @@ +package studycave.studycaverestservice.model.studyGroup; + +import org.springframework.data.jpa.repository.JpaRepository; +import studycave.studycaverestservice.model.studyGroup.StudyGroup; + +import java.util.List; + +public interface GroupRepository extends JpaRepository { + + List findByName(String name); + + List findByGroupKey(String groupKey); + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/Test.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/Test.java index 61554bb..ff12c5b 100644 --- a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/Test.java +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/Test.java @@ -7,6 +7,7 @@ import lombok.Getter; import lombok.NoArgsConstructor; import lombok.Setter; import studycave.studycaverestservice.model.studyGroup.StudyGroup; +import studycave.studycaverestservice.model.test.question.Question; import studycave.studycaverestservice.model.userActivity.UserActivity; import javax.persistence.*; @@ -45,16 +46,32 @@ public class Test { private String permission; private int grade; -/* + @JsonProperty("body") @OneToMany(fetch = FetchType.LAZY,mappedBy="test",cascade = CascadeType.ALL) @JsonManagedReference List questions = new ArrayList<>(); -*/ + @ManyToOne @JoinColumn(name="group_id",referencedColumnName="id") private StudyGroup group; @OneToMany(fetch = FetchType.LAZY, mappedBy = "test", cascade = CascadeType.ALL) private List activity; + + public void setAddDate() { + java.util.Date utilDate = new java.util.Date(); + Date sqlDate = new Date(utilDate.getTime()); + this.addDate = sqlDate; + } + + public void setGrade() { + this.grade = 0; + } + + public void setEditDate() { + java.util.Date utilDate = new java.util.Date(); + Date sqlDate = new Date(utilDate.getTime()); + this.editDate = sqlDate; + } } diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/TestRepository.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/TestRepository.java new file mode 100644 index 0000000..4168537 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/TestRepository.java @@ -0,0 +1,19 @@ +package studycave.studycaverestservice.model.test; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; + +import java.util.List; + +public interface TestRepository extends JpaRepository { + + @Query("select t from Test t where (t.permission = 'GROUP' and t.group.id = :g and t.status = 'VERIFIED' )") + List findTestByGroup(@Param("g") Long g); + + + + @Query("select t from Test t where (t.permission = 'GROUP' and t.group.id = :g and t.status = 'UNVERIFIED' )") + List findWaitingTestByGroupKey(@Param("g") Long g); + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerChoicesSolveDTO.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerChoicesSolveDTO.java new file mode 100644 index 0000000..1b6186e --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerChoicesSolveDTO.java @@ -0,0 +1,19 @@ +package studycave.studycaverestservice.model.test.dto; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import studycave.studycaverestservice.model.test.question.AnswerChoices; + +public class AnswerChoicesSolveDTO extends AnswerChoices { + + @JsonIgnore + private Boolean good; + + public AnswerChoicesSolveDTO() { + super(); + } + + + + + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerChoicesVerifyDTO.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerChoicesVerifyDTO.java new file mode 100644 index 0000000..cd0c7dd --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerChoicesVerifyDTO.java @@ -0,0 +1,14 @@ +package studycave.studycaverestservice.model.test.dto; + +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class AnswerChoicesVerifyDTO extends AnswerVerifyDTO { + protected Long id; + String content; + @JsonProperty(value = "is_good") + Boolean isGood; +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerGapsSolveDTO.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerGapsSolveDTO.java new file mode 100644 index 0000000..bb7e6bc --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerGapsSolveDTO.java @@ -0,0 +1,16 @@ +package studycave.studycaverestservice.model.test.dto; + +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import studycave.studycaverestservice.model.test.question.AnswerGaps; + +public class AnswerGapsSolveDTO extends AnswerGaps { + + @JsonInclude(JsonInclude.Include.NON_NULL) + private String[] content = new String[25]; + + @JsonProperty("is_gap") + private boolean gap; + + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerGapsVerifyDTO.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerGapsVerifyDTO.java new file mode 100644 index 0000000..dc8e0c2 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerGapsVerifyDTO.java @@ -0,0 +1,11 @@ +package studycave.studycaverestservice.model.test.dto; + +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class AnswerGapsVerifyDTO extends AnswerVerifyDTO { + protected Long id; + protected String content; +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerPairsSolveDTO.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerPairsSolveDTO.java new file mode 100644 index 0000000..b514075 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerPairsSolveDTO.java @@ -0,0 +1,44 @@ +package studycave.studycaverestservice.model.test.dto; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import studycave.studycaverestservice.model.test.question.AnswerPairs; + +import java.util.ArrayList; +import java.util.List; + +public class AnswerPairsSolveDTO extends AnswerPairs { + + @JsonIgnore + private Long id; + @JsonIgnore + private String first; + @JsonIgnore + private String second; + + + private List left = new ArrayList(); + private List right = new ArrayList(); + + + + public AnswerPairsSolveDTO(List left, List right) { + super(); + this.left = left; + this.right = right; + } + public List getLeft() { + return left; + } + public void setLeft(List left) { + this.left = left; + } + public List getRight() { + return right; + } + public void setRight(List right) { + this.right = right; + } + + + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerPairsVerifyDTO.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerPairsVerifyDTO.java new file mode 100644 index 0000000..288a45c --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerPairsVerifyDTO.java @@ -0,0 +1,11 @@ +package studycave.studycaverestservice.model.test.dto; + +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public class AnswerPairsVerifyDTO extends AnswerVerifyDTO{ + protected String left; + protected String right; +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerPuzzleSolveDTO.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerPuzzleSolveDTO.java new file mode 100644 index 0000000..e4aff55 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerPuzzleSolveDTO.java @@ -0,0 +1,30 @@ +package studycave.studycaverestservice.model.test.dto; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import lombok.Getter; +import lombok.Setter; +import studycave.studycaverestservice.model.test.question.AnswerPuzzle; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +@Getter +@Setter +public class AnswerPuzzleSolveDTO extends AnswerPuzzle { + + @JsonIgnore + private String[] correct = new String[10]; + + private List puzzles = new ArrayList(); + + public void generatePuzzles() { + this.puzzles = new ArrayList(Arrays.asList(this.getCorrect())); + Collections.shuffle(puzzles); + } + + public AnswerPuzzleSolveDTO() { + super(); + } +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerPuzzleVerifyDTO.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerPuzzleVerifyDTO.java new file mode 100644 index 0000000..73f4d1e --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerPuzzleVerifyDTO.java @@ -0,0 +1,14 @@ +package studycave.studycaverestservice.model.test.dto; + + +import lombok.Getter; +import lombok.Setter; + +import java.util.List; + +@Setter +@Getter +public class AnswerPuzzleVerifyDTO extends AnswerVerifyDTO { + protected Long id; + protected List puzzles; +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerVerifyDTO.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerVerifyDTO.java new file mode 100644 index 0000000..9219052 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/AnswerVerifyDTO.java @@ -0,0 +1,13 @@ +package studycave.studycaverestservice.model.test.dto; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import lombok.Getter; +import lombok.Setter; + +@Getter +@Setter +public abstract class AnswerVerifyDTO { + + @JsonIgnore + protected String type; +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/GetResultDTO.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/GetResultDTO.java new file mode 100644 index 0000000..75ebfff --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/GetResultDTO.java @@ -0,0 +1,16 @@ +package studycave.studycaverestservice.model.test.dto; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class GetResultDTO { + private float userScore; + private int maxScore; + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/QuestionVerifyDTO.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/QuestionVerifyDTO.java new file mode 100644 index 0000000..b075b94 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/QuestionVerifyDTO.java @@ -0,0 +1,28 @@ +package studycave.studycaverestservice.model.test.dto; + +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import studycave.studycaverestservice.model.test.verifier.QuestionVerifyDeserializer; + +import java.util.List; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +@JsonDeserialize(using = QuestionVerifyDeserializer.class) +public class QuestionVerifyDTO { + + @ApiModelProperty(position = 1) + Long id; + @ApiModelProperty(position = 2) + String type; + + @ApiModelProperty(position = 3) + List answers; + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/Result.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/Result.java new file mode 100644 index 0000000..9e73a10 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/Result.java @@ -0,0 +1,19 @@ +package studycave.studycaverestservice.model.test.dto; + +import com.fasterxml.jackson.annotation.JsonInclude; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class Result { + + @JsonInclude(JsonInclude.Include.NON_NULL) + protected Long id; + protected Boolean correct; + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/ResultPairs.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/ResultPairs.java new file mode 100644 index 0000000..9c2b2f0 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/ResultPairs.java @@ -0,0 +1,23 @@ +package studycave.studycaverestservice.model.test.dto; + +import com.fasterxml.jackson.annotation.JsonIgnore; + +public class ResultPairs extends Result{ + + @JsonIgnore + protected Long id; + protected String left; + protected String right; + + public ResultPairs(Long id, Boolean correct) { + super(id, correct); + // TODO Auto-generated constructor stub + } + + public ResultPairs(String left, String right, Boolean correct) { + super(null, correct); + this.left=left; + this.right=right; + } + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/ResultResponse.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/ResultResponse.java new file mode 100644 index 0000000..c78d474 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/ResultResponse.java @@ -0,0 +1,19 @@ +package studycave.studycaverestservice.model.test.dto; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +import java.util.ArrayList; +import java.util.List; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class ResultResponse { + float points; + List results = new ArrayList(); + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/SaveTestResultDTO.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/SaveTestResultDTO.java new file mode 100644 index 0000000..4fee95f --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/SaveTestResultDTO.java @@ -0,0 +1,36 @@ +package studycave.studycaverestservice.model.test.dto; + +import com.fasterxml.jackson.annotation.JsonProperty; + +public class SaveTestResultDTO { + private String owner; + @JsonProperty(value="id") + private Long idTest; + private Float userScore; + + public SaveTestResultDTO() { + super(); + } + + public String getOwner() { + return owner; + } + public void setOwner(String owner) { + this.owner = owner; + } + public Long getIdTest() { + return idTest; + } + public void setIdTest(Long idTest) { + this.idTest = idTest; + } + public Float getUserScore() { + return userScore; + } + public void setUserScore(Float userScore) { + this.userScore = userScore; + } + + + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/TestCreateDTO.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/TestCreateDTO.java new file mode 100644 index 0000000..c0f495c --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/TestCreateDTO.java @@ -0,0 +1,38 @@ +package studycave.studycaverestservice.model.test.dto; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import studycave.studycaverestservice.model.test.question.Question; + +import java.sql.Date; +import java.util.List; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class TestCreateDTO { + + private String title; + private String owner; + @JsonIgnore + private long idOwner; + //@JsonIgnore + @JsonProperty("add_date") + private Date addDate; + //@JsonIgnore + @JsonProperty("edit_date") + private Date editDate; + @ApiModelProperty(value = "Default value for note", required = true,example = "public") + private String permission; + + @JsonIgnore + private Long grade; + @JsonProperty("body") + List questions; +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/TestEditDTO.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/TestEditDTO.java new file mode 100644 index 0000000..f0ccbe1 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/TestEditDTO.java @@ -0,0 +1,40 @@ +package studycave.studycaverestservice.model.test.dto; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonProperty; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import studycave.studycaverestservice.model.test.question.Question; + +import java.sql.Date; +import java.util.List; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class TestEditDTO { + + private Long id; + private String title; + private String owner; + @JsonIgnore + private long idOwner; + @JsonIgnore + @JsonProperty("add_date") + private Date addDate; + @JsonIgnore + @JsonProperty("edit_date") + private Date editDate; + @ApiModelProperty(value = "Default value for note", required = true,example = "public") + private String permission; + + @JsonIgnore + private Long grade; + @JsonProperty("body") + List questions; + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/TestOwnerDTO.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/TestOwnerDTO.java new file mode 100644 index 0000000..2ed27c2 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/dto/TestOwnerDTO.java @@ -0,0 +1,38 @@ +package studycave.studycaverestservice.model.test.dto; + +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import studycave.studycaverestservice.model.test.question.Question; + +import java.sql.Date; +import java.util.ArrayList; +import java.util.List; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class TestOwnerDTO { + + private Long id; + private String title; + @JsonIgnore + private Long idOwner; + @JsonProperty("owner") + private String owner; + @JsonProperty("add_date") + private Date addDate; + @JsonProperty("edit_date") + private Date editDate; + + private String permission; + private int grade; + + @JsonProperty("body") + List questions = new ArrayList<>(); + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/Answer.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/Answer.java new file mode 100644 index 0000000..26a70a9 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/Answer.java @@ -0,0 +1,32 @@ +package studycave.studycaverestservice.model.test.question; + +import com.fasterxml.jackson.annotation.JsonBackReference; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +import javax.persistence.*; + +@Entity +@Inheritance(strategy = InheritanceType.JOINED) +@Getter +@Setter +@AllArgsConstructor +public abstract class Answer { + @Id + @Column(name="id_ans") + @GeneratedValue(strategy=GenerationType.IDENTITY) + private Long id; + + @ApiModelProperty(hidden = true) + @ManyToOne + @JoinColumn(name="id_question",referencedColumnName="id") + @JsonBackReference + private Question question; + + public Answer() { + super(); + } +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerChoices.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerChoices.java new file mode 100644 index 0000000..b4f5a12 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerChoices.java @@ -0,0 +1,24 @@ +package studycave.studycaverestservice.model.test.question; + +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.Getter; +import lombok.Setter; + +import javax.persistence.Column; +import javax.persistence.Entity; + +@Entity +@Getter +@Setter +public class AnswerChoices extends Answer { + + private String content; + + @Column(name = "is_good") + @JsonProperty("is_good") + private Boolean good; + + public AnswerChoices() { + super(); + } +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerGaps.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerGaps.java new file mode 100644 index 0000000..14a1409 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerGaps.java @@ -0,0 +1,23 @@ +package studycave.studycaverestservice.model.test.question; + +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.Getter; +import lombok.Setter; + +import javax.persistence.Column; +import javax.persistence.Entity; + +@Entity +@Getter +@Setter +public class AnswerGaps extends Answer{ + private String[] content = new String[25]; + + @Column(name="is_gap") + @JsonProperty("is_gap") + private boolean gap; + + public AnswerGaps() { + super(); + } +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerPairs.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerPairs.java new file mode 100644 index 0000000..6d08022 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerPairs.java @@ -0,0 +1,19 @@ +package studycave.studycaverestservice.model.test.question; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +import javax.persistence.Entity; + +@Entity +@Getter +@Setter +@NoArgsConstructor +@AllArgsConstructor +public class AnswerPairs extends Answer { + private String first; + private String second; + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerPuzzle.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerPuzzle.java new file mode 100644 index 0000000..d59dcd1 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerPuzzle.java @@ -0,0 +1,17 @@ +package studycave.studycaverestservice.model.test.question; + +import lombok.Getter; +import lombok.Setter; + +import javax.persistence.Entity; + +@Entity +@Getter +@Setter +public class AnswerPuzzle extends Answer { + private String[] correct = new String[10]; + + public AnswerPuzzle() { + super(); + } +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerRepository.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerRepository.java new file mode 100644 index 0000000..af1a454 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/AnswerRepository.java @@ -0,0 +1,6 @@ +package studycave.studycaverestservice.model.test.question; + +import org.springframework.data.jpa.repository.JpaRepository; + +public interface AnswerRepository extends JpaRepository { +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/Question.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/Question.java new file mode 100644 index 0000000..17bdc26 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/Question.java @@ -0,0 +1,67 @@ +package studycave.studycaverestservice.model.test.question; + +import com.fasterxml.jackson.annotation.*; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import studycave.studycaverestservice.model.test.Test; + +import javax.persistence.*; +import java.util.ArrayList; +import java.util.List; + +@JsonTypeInfo(use=JsonTypeInfo.Id.NAME, include= JsonTypeInfo.As.PROPERTY, property = "type", visible = true ) +@JsonSubTypes({ + @JsonSubTypes.Type(value = QuestionChoices.class, name="single-choice"), + @JsonSubTypes.Type(value = QuestionChoices.class, name="multiple-choice"), + @JsonSubTypes.Type(value = QuestionChoices.class, name="true-false"), + @JsonSubTypes.Type(value = QuestionPairs.class, name="pairs"), + @JsonSubTypes.Type(value = QuestionPuzzle.class, name="puzzle"), + @JsonSubTypes.Type(value = QuestionGaps.class, name="gaps") +}) +@Entity +@Inheritance(strategy = InheritanceType.SINGLE_TABLE) +@NoArgsConstructor +@AllArgsConstructor +public abstract class Question { + + @Id + @GeneratedValue(strategy=GenerationType.IDENTITY) + @Getter + @Setter + private Long id; + + @Column(name="question") + @JsonProperty("question") + @Getter + @Setter + private String text; + + @Column(name="nr_question") + @JsonProperty("nr") + @Getter + @Setter + private int nrQuestion; + //@NotNull + @Getter + @Setter + protected String type; + @Getter + @Setter + private int points; + + @ApiModelProperty(hidden = true) + @ManyToOne + @JoinColumn(name="id_test",referencedColumnName="id") + @JsonBackReference + @Getter + @Setter + private Test test; + + @OneToMany(fetch = FetchType.LAZY,mappedBy="question",cascade = CascadeType.ALL) + @JsonManagedReference + List answers = new ArrayList<>(); + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionChoices.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionChoices.java new file mode 100644 index 0000000..2d2e29e --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionChoices.java @@ -0,0 +1,39 @@ +package studycave.studycaverestservice.model.test.question; + +import com.fasterxml.jackson.annotation.JsonManagedReference; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +import javax.persistence.CascadeType; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.OneToMany; +import java.util.ArrayList; +import java.util.List; + +@Entity +@AllArgsConstructor +public class QuestionChoices extends Question { + + @OneToMany(fetch = FetchType.LAZY,mappedBy="question",cascade = CascadeType.ALL) + @JsonManagedReference + List answers = new ArrayList<>(); + + public List getAnswers() { + return answers; + } + + public void setAnswers(List answers) { + this.answers = answers; + } + + public void setType() { + this.type = "choices"; + } + + public QuestionChoices(){ + super(); + } +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionGaps.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionGaps.java new file mode 100644 index 0000000..1be5bea --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionGaps.java @@ -0,0 +1,27 @@ +package studycave.studycaverestservice.model.test.question; + +import com.fasterxml.jackson.annotation.JsonManagedReference; +import lombok.Getter; +import lombok.Setter; + +import javax.persistence.CascadeType; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.OneToMany; +import java.util.ArrayList; +import java.util.List; + +@Entity +@Getter +@Setter + +public class QuestionGaps extends Question { + @OneToMany(fetch = FetchType.LAZY,mappedBy="question",cascade = CascadeType.ALL) + @JsonManagedReference + List answers = new ArrayList<>(); + + + public QuestionGaps(){ + super(); + } +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionPairs.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionPairs.java new file mode 100644 index 0000000..82ac9d7 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionPairs.java @@ -0,0 +1,29 @@ +package studycave.studycaverestservice.model.test.question; + +import com.fasterxml.jackson.annotation.JsonManagedReference; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.Setter; + +import javax.persistence.CascadeType; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.OneToMany; +import java.util.ArrayList; +import java.util.List; + +@Entity +@AllArgsConstructor +@Getter +@Setter +public class QuestionPairs extends Question{ + @OneToMany(fetch = FetchType.LAZY,mappedBy="question",cascade = CascadeType.ALL) + @JsonManagedReference + List answers = new ArrayList<>(); + + + + public QuestionPairs() { + super(); + } +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionPuzzle.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionPuzzle.java new file mode 100644 index 0000000..8176fe3 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionPuzzle.java @@ -0,0 +1,26 @@ +package studycave.studycaverestservice.model.test.question; + +import com.fasterxml.jackson.annotation.JsonManagedReference; +import lombok.Getter; +import lombok.Setter; + +import javax.persistence.CascadeType; +import javax.persistence.Entity; +import javax.persistence.FetchType; +import javax.persistence.OneToMany; +import java.util.ArrayList; +import java.util.List; + +@Entity +@Getter +@Setter +public class QuestionPuzzle extends Question { + @OneToMany(fetch = FetchType.LAZY,mappedBy="question",cascade = CascadeType.ALL) + @JsonManagedReference + List answers = new ArrayList<>(); + + + public QuestionPuzzle(){ + super(); + } +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionRepository.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionRepository.java new file mode 100644 index 0000000..b0e9036 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/question/QuestionRepository.java @@ -0,0 +1,7 @@ +package studycave.studycaverestservice.model.test.question; + +import org.springframework.data.jpa.repository.JpaRepository; + +public interface QuestionRepository extends JpaRepository { + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/result/TestResult.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/result/TestResult.java new file mode 100644 index 0000000..6247568 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/result/TestResult.java @@ -0,0 +1,27 @@ +package studycave.studycaverestservice.model.test.result; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +import javax.persistence.*; + +@Entity +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class TestResult { + @Id + @Column(name="id") + @GeneratedValue(strategy= GenerationType.IDENTITY) + private Long idResult; + @Column(name="id_owner") + private Long idOwner; + @Column(name="id_test") + private Long idTest; + private float userScore; + private int maxScore; + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/result/TestResultRepository.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/result/TestResultRepository.java new file mode 100644 index 0000000..9851d7b --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/result/TestResultRepository.java @@ -0,0 +1,13 @@ +package studycave.studycaverestservice.model.test.result; + +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.List; + +public interface TestResultRepository extends JpaRepository { + + List findByIdOwner(Long id); + + List findByIdOwnerAndIdTest(Long id, Long id2); + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/verifier/QuestionVerifier.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/verifier/QuestionVerifier.java new file mode 100644 index 0000000..f6cc803 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/verifier/QuestionVerifier.java @@ -0,0 +1,159 @@ +package studycave.studycaverestservice.model.test.verifier; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; +import studycave.studycaverestservice.model.test.Test; +import studycave.studycaverestservice.model.test.TestRepository; +import studycave.studycaverestservice.model.test.dto.*; +import studycave.studycaverestservice.model.test.question.*; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; + +@Component +public class QuestionVerifier { + + @Autowired + TestRepository testRepository; + + private ResultResponse choiceVerify(QuestionVerifyDTO question, Question questionCorrect) { + List results = new ArrayList(); + float points = questionCorrect.getPoints(); + for (AnswerVerifyDTO element : question.getAnswers()) { + AnswerChoicesVerifyDTO answer = (AnswerChoicesVerifyDTO) element; + Optional answerCorrect = ((QuestionChoices) questionCorrect).getAnswers().stream() + .filter(a -> a.getId().equals(answer.getId())).findAny(); + if (answerCorrect.get().getGood() == ((AnswerChoicesVerifyDTO) answer).getIsGood()) { + results.add(new Result(answer.getId(), true)); + } else { + results.add(new Result(answer.getId(), false)); + points = 0; + } + } + return new ResultResponse(points, results); + } + + private ResultResponse gapsVerify(QuestionVerifyDTO question, Question questionCorrect) { + List results = new ArrayList(); + float points = questionCorrect.getPoints(); + float wrongAnswers = 0; + for (AnswerVerifyDTO element : question.getAnswers()) { + AnswerGapsVerifyDTO answer = (AnswerGapsVerifyDTO) element; + Optional answerCorrect = ((QuestionGaps) questionCorrect).getAnswers().stream() + .filter(a -> a.getId().equals(answer.getId())).findAny(); + if (Arrays.asList(answerCorrect.get().getContent()).stream() + .anyMatch(((AnswerGapsVerifyDTO) answer).getContent()::equalsIgnoreCase)) { + results.add(new Result(answer.getId(), true)); + } else { + results.add(new Result(answer.getId(), false)); + wrongAnswers += 1; + } + } + + if (wrongAnswers == question.getAnswers().size()) { + points = 0; + } else { + points = points - (points/question.getAnswers().size() * wrongAnswers); + } + return new ResultResponse(points, results); + } + + private ResultResponse pairsVerify(QuestionVerifyDTO question, Question questionCorrect) { + List results = new ArrayList(); + float points = questionCorrect.getPoints(); + float wrongAnswers = 0; + for (AnswerVerifyDTO element : question.getAnswers()) { + AnswerPairsVerifyDTO answer = (AnswerPairsVerifyDTO) element; + Optional answerCorrect = ((QuestionPairs) questionCorrect).getAnswers().stream() + .filter(a -> a.getFirst().equals(answer.getLeft())) + .findAny(); + if (answerCorrect.isPresent()) { + if (answerCorrect.get().getSecond().equals(answer.getRight())) { + results.add(new ResultPairs(answer.getLeft(), answer.getRight(), true)); + } else { + results.add(new ResultPairs(answer.getLeft(), answer.getRight(), false)); + points = 0; + } + } else { + wrongAnswers += 1; + results.add(new ResultPairs(answer.getLeft(), answer.getRight(), false)); + } + } + if (wrongAnswers == question.getAnswers().size()) { + points = 0; + } else { + points = points - (points/question.getAnswers().size() * wrongAnswers); + } + return new ResultResponse(points, results); + } + + private ResultResponse puzzleVerify(QuestionVerifyDTO question, Question questionCorrect) { + List results = new ArrayList(); + + float points = questionCorrect.getPoints(); + for (AnswerVerifyDTO element : question.getAnswers()) { + AnswerPuzzleVerifyDTO answer = (AnswerPuzzleVerifyDTO) element; + Optional answerCorrect = ((QuestionPuzzle) questionCorrect).getAnswers().stream() + .filter(a -> a.getId().equals(answer.getId())).findAny(); + + List userPuzzles = answer.getPuzzles(); + String[] correctPuzzles = answerCorrect.get().getCorrect(); + + if (userPuzzles.size() == correctPuzzles.length) { + Result result = new Result(answer.getId(), true); + for (int i = 0; i < userPuzzles.size(); i++) { + if (userPuzzles.get(i).equalsIgnoreCase(correctPuzzles[i])) { + // pass + } else { + result.setCorrect(false); + points = 0; + } + } + results.add(result); + } else + points = 0; + + } + + return new ResultResponse(points, results); + } + + public ResultResponse verify(Long idTest, QuestionVerifyDTO question) { + Optional test = testRepository.findById(idTest); + String type = question.getType(); + if (test.isPresent()) { + + Optional questionCorrect = test.get().getQuestions().stream() + .filter(q -> q.getId().equals(question.getId())).findAny(); + + if (type.equals("single-choice") || type.equals("multiple-choice") || type.equals("true-false")) { + { + return choiceVerify(question, questionCorrect.get()); + } + + } + + if (type.equals("gaps")) { + { + return gapsVerify(question, questionCorrect.get()); + } + } + if (type.equals("pairs")) { + { + return pairsVerify(question, questionCorrect.get()); + } + } + if (type.equals("puzzle")) { + { + return puzzleVerify(question, questionCorrect.get()); + } + } + + } + return null; + + } + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/test/verifier/QuestionVerifyDeserializer.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/verifier/QuestionVerifyDeserializer.java new file mode 100644 index 0000000..c3e52bf --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/test/verifier/QuestionVerifyDeserializer.java @@ -0,0 +1,67 @@ +package studycave.studycaverestservice.model.test.verifier; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.core.ObjectCodec; +import com.fasterxml.jackson.databind.DeserializationContext; +import com.fasterxml.jackson.databind.JsonDeserializer; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ObjectNode; +import org.springframework.beans.factory.annotation.Autowired; +import studycave.studycaverestservice.model.test.dto.*; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +public class QuestionVerifyDeserializer extends JsonDeserializer { + + @Autowired + ObjectMapper objectMapper; + + @Override + public QuestionVerifyDTO deserialize(com.fasterxml.jackson.core.JsonParser jsonParser, + DeserializationContext context) throws IOException, JsonProcessingException { + + QuestionVerifyDTO question = new QuestionVerifyDTO(); + + ObjectCodec oc = jsonParser.getCodec(); + JsonNode node = oc.readTree(jsonParser); + question.setId(node.get("id").asLong()); + String type = node.get("type").textValue(); + question.setType(type); + + Iterator elements = node.get("answers").elements(); + List answers = new ArrayList(); + + while (elements.hasNext()) { + JsonNode next = elements.next(); + ((ObjectNode) next).put("type", type); + if (type.equals("single-choice") || type.equals("multiple-choice") || type.equals("true-false")) { + AnswerChoicesVerifyDTO answer = objectMapper.treeToValue(next, AnswerChoicesVerifyDTO.class); + answers.add(answer); + continue; + } + if (type.equals("gaps")) { + AnswerGapsVerifyDTO answer = objectMapper.treeToValue(next, AnswerGapsVerifyDTO.class); + answers.add(answer); + continue; + } + if (type.equals("puzzle")) { + AnswerPuzzleVerifyDTO answer = objectMapper.treeToValue(next, AnswerPuzzleVerifyDTO.class); + answers.add(answer); + continue; + } + if (type.equals("pairs")) { + AnswerPairsVerifyDTO answer = objectMapper.treeToValue(next, AnswerPairsVerifyDTO.class); + answers.add(answer); + continue; + } + } + question.setAnswers(answers); + return question; + } + +} + diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/userActivity/UserActivity.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/userActivity/UserActivity.java index a637ae8..3076c05 100644 --- a/BackEnd/src/main/java/studycave/studycaverestservice/model/userActivity/UserActivity.java +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/userActivity/UserActivity.java @@ -1,5 +1,9 @@ package studycave.studycaverestservice.model.userActivity; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; import studycave.studycaverestservice.model.flashcardset.Set; import studycave.studycaverestservice.model.material.Material; import studycave.studycaverestservice.model.studyGroup.StudyGroup; @@ -10,6 +14,10 @@ import javax.persistence.*; import java.sql.Timestamp; @Entity +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor public class UserActivity { @Id @@ -48,4 +56,8 @@ public class UserActivity { @ManyToOne @JoinColumn(name = "fromUser_id") private User fromUser; + + public void setDate() { + this.date = new java.sql.Timestamp(new java.util.Date().getTime()); + } } diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/userActivity/UserActivityRepository.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/userActivity/UserActivityRepository.java new file mode 100644 index 0000000..c1bb60b --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/userActivity/UserActivityRepository.java @@ -0,0 +1,17 @@ +package studycave.studycaverestservice.model.userActivity; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; + +import java.sql.Date; +import java.sql.Timestamp; +import java.util.List; + +public interface UserActivityRepository extends JpaRepository { + + @Query("SELECT u FROM UserActivity u WHERE (u.fromUser.id = ?1 OR u.toUser.id = ?1) " + + "AND (?2 is null OR u.group.id = ?2) AND (?3 is null OR u.date >= ?3) AND (?4 is null OR u.date <= ?4)") + List findAllByToUserOrFromUserAndGroupAndTime(Long userId, Long groupId, + Date start, Timestamp end); + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/userActivity/UserActivityService.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/userActivity/UserActivityService.java new file mode 100644 index 0000000..686869c --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/userActivity/UserActivityService.java @@ -0,0 +1,50 @@ +package studycave.studycaverestservice.model.userActivity; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.stereotype.Service; +import studycave.studycaverestservice.model.flashcardset.Set; +import studycave.studycaverestservice.model.material.Material; +import studycave.studycaverestservice.model.studyGroup.GroupRepository; +import studycave.studycaverestservice.model.studyGroup.StudyGroup; +import studycave.studycaverestservice.model.test.Test; +import studycave.studycaverestservice.model.user.User; +import studycave.studycaverestservice.model.user.UserRepository; + +@Service +public class UserActivityService { + + @Autowired + UserRepository userRepository; + @Autowired + GroupRepository groupRepository; + @Autowired + UserActivityRepository userActivityRepository; + + public ResponseEntity saveActivity( + String type, + int points, + String comment, + User toUser, + User fromUser, + StudyGroup group, + Material material, + Set set, + Test test + ) { + UserActivity activity = new UserActivity(); + activity.setType(type); + activity.setPoints(points); + activity.setComment(comment); + activity.setDate(); + activity.setToUser(toUser); + activity.setFromUser(fromUser); + activity.setGroup(group); + activity.setTest(test); + activity.setSet(set); + activity.setMaterial(material); + this.userActivityRepository.save(activity); + return new ResponseEntity<>(HttpStatus.OK); + } +} diff --git a/BackEnd/src/main/resources/opencsv-4.1.jar b/BackEnd/src/main/resources/opencsv-4.1.jar new file mode 100644 index 0000000000000000000000000000000000000000..488d16288018a9e420eeb453e6a1f620ed6cd323 GIT binary patch literal 105568 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

3ZX@JUMh}=;~Nck+|j9}pp$!? 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%0DJz%);a>Ya+Px_i3&qXWY13a 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 V1mw*xNdSM2fu$`KAK=9W_J5T_L3{uJ literal 0 HcmV?d00001