From 52ff18a70fddf199f7f37a555f192362471f726f Mon Sep 17 00:00:00 2001 From: yetju000 Date: Sun, 24 Nov 2019 11:05:19 +0100 Subject: [PATCH] added group controller --- BackEnd/pom.xml | 7 + .../controller/GroupController.java | 189 +++++ .../StudyGroupComment/StudyGroupComment.java | 36 + .../StudyGroupCommentRepository.java | 13 + .../dto/SimpleStudyGroupCommentDto.java | 15 + .../dto/StudyGroupCommentDto.java | 17 + .../model/flashcardset/SetRepository.java | 27 + .../model/studyGroup/CreateGroupDto.java | 17 + .../model/studyGroup/GroupService.java | 692 ++++++++++++++++++ .../model/studyGroup/dto/AddMaterialDto.java | 16 + .../model/studyGroup/dto/AddSetDto.java | 16 + .../model/studyGroup/dto/AddTestDto.java | 16 + .../model/studyGroup/dto/ContentDto.java | 29 + .../model/studyGroup/dto/GroupDto.java | 20 + .../model/studyGroup/dto/GroupInfoDto.java | 23 + .../model/studyGroup/dto/GroupJoinDto.java | 15 + .../dto/SimpleStudyGroupMemberDTO.java | 17 + .../model/studyGroup/dto/VerifyDto.java | 29 + .../model/user/dto/LeaderboardDTO.java | 25 + .../model/user/dto/SimpleUserInfo.java | 15 + 20 files changed, 1234 insertions(+) create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/controller/GroupController.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/StudyGroupComment/StudyGroupComment.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/StudyGroupComment/StudyGroupCommentRepository.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/StudyGroupComment/dto/SimpleStudyGroupCommentDto.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/StudyGroupComment/dto/StudyGroupCommentDto.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/flashcardset/SetRepository.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/CreateGroupDto.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/GroupService.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/AddMaterialDto.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/AddSetDto.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/AddTestDto.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/ContentDto.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/GroupDto.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/GroupInfoDto.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/GroupJoinDto.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/SimpleStudyGroupMemberDTO.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/VerifyDto.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/user/dto/LeaderboardDTO.java create mode 100644 BackEnd/src/main/java/studycave/studycaverestservice/model/user/dto/SimpleUserInfo.java diff --git a/BackEnd/pom.xml b/BackEnd/pom.xml index 8edd65a..89ab3c0 100644 --- a/BackEnd/pom.xml +++ b/BackEnd/pom.xml @@ -23,6 +23,13 @@ org.springframework.boot spring-boot-starter + + + org.apache.commons + commons-text + 1.8 + + org.springframework.boot diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/controller/GroupController.java b/BackEnd/src/main/java/studycave/studycaverestservice/controller/GroupController.java new file mode 100644 index 0000000..5948f8c --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/controller/GroupController.java @@ -0,0 +1,189 @@ +package studycave.studycaverestservice.controller; + + +import java.util.List; +import java.util.Optional; +import javax.validation.Valid; +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.GetMapping; +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.RestController; +import io.swagger.annotations.Api; +import studycave.studycaverestservice.model.StudyGroupComment.dto.SimpleStudyGroupCommentDto; +import studycave.studycaverestservice.model.studyGroup.CreateGroupDto; +import studycave.studycaverestservice.model.studyGroup.GroupService; +import studycave.studycaverestservice.model.studyGroup.dto.*; +import studycave.studycaverestservice.model.studyGroupMember.StudyGroupMemberRepository; +import studycave.studycaverestservice.model.user.UserRepository; + +@RestController +@CrossOrigin +@RequestMapping("/groups") +@PreAuthorize("isAuthenticated()") +@Api +public class GroupController { + + @Autowired + GroupService groupService; + @Autowired + UserRepository userRepository; + @Autowired + StudyGroupMemberRepository memberRepository; + + // @PreAuthorize("isAuthenticated()") + @PreAuthorize("#groupDto.owner == authentication.name") + @PostMapping() + public ResponseEntity create(@RequestBody CreateGroupDto groupDto) { + return this.groupService.createGroup(groupDto); + } + + @GetMapping("{group_id}/info") + public GroupInfoDto getGroupInfo(@PathVariable(required = true) Long group_id) { + return this.groupService.getGroupInfo(group_id); + } + + @DeleteMapping("/{group_id}/member/{user_id}") + public ResponseEntity deleteUserFromGroup(@PathVariable(required = true) Long group_id, + @PathVariable(required = true) Long user_id) { + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + String currentPrincipalName = authentication.getName(); + Long id = userRepository.findByUsername(currentPrincipalName).get().getId(); + if (this.memberRepository.findUserInGroup(group_id, id).getIsGroupLeader() == true) + return this.groupService.deleteUserFromGroup(group_id, user_id); + else + return new ResponseEntity<>("Brak uprawnien do operacji", HttpStatus.BAD_REQUEST); + } + + @DeleteMapping("/{group_id}") + public ResponseEntity deleteGroup(@PathVariable(required = true) Long group_id) { + return this.groupService.deleteGroup(group_id); + } + + @GetMapping("/{group_id}/generate") + public ResponseEntity generateCode(@PathVariable(required = true) Long group_id) { + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + String currentPrincipalName = authentication.getName(); + Long id = userRepository.findByUsername(currentPrincipalName).get().getId(); + if (this.memberRepository.findUserInGroup(group_id, id).getIsGroupLeader() == true) + return this.groupService.generateCode(group_id); + else + return new ResponseEntity<>("Brak uprawnien do operacji", HttpStatus.BAD_REQUEST); + } + + @GetMapping() + public List getMyGroup() { + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + String currentPrincipalName = authentication.getName(); + Long id = userRepository.findByUsername(currentPrincipalName).get().getId(); + return this.groupService.getMyGroups(id); + } + + @PostMapping("/members") + public ResponseEntity addmember(@RequestBody GroupJoinDto groupDto) { + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + String currentPrincipalName = authentication.getName(); + Long userId = userRepository.findByUsername(currentPrincipalName).get().getId(); + return this.groupService.joinToGroup(userId, groupDto.getGroupCode()); + } + + @GetMapping("/{group_id}/content/{type}") + public ResponseEntity getContent(@PathVariable(required = true) Long group_id, @PathVariable(required = true) String type) { + return this.groupService.getContent(group_id,type); + } + + @DeleteMapping("/{group_id}/content/{type}/{content_id}") + public ResponseEntity deleteContent(@PathVariable(required = true) Long group_id, @PathVariable(required = true) String type, @PathVariable(required = true) Long content_id) { + return this.groupService.deleteContent(group_id, type, content_id); + } + + @PostMapping("/{groupId}/flashcard-sets") + public ResponseEntity addFlashardSet(@PathVariable(required = true) String groupId, + @RequestBody List setIds) { + return this.groupService.addFlashcardSets(groupId, setIds); + } + + @PostMapping("/{groupId}/materials") + public ResponseEntity addMaterial(@PathVariable(required = true) String groupId, + @RequestBody List materialIds) { + + return this.groupService.addMaterials(groupId, materialIds); + } + + @PostMapping("/{groupId}/tests") + public ResponseEntity addTests(@PathVariable(required = true) String groupId, + @RequestBody List testIds) { + return this.groupService.addTests(groupId, testIds); + } + + @PutMapping("/{groupId}/tests/{testId}/status") + public ResponseEntity verifyTest(@PathVariable(required = true) String groupId, + @PathVariable(required = true) String testId, @Valid @RequestBody VerifyDto dto) { + if (dto.getStatus() == VerifyDto.VerifyType.ACCEPTED) { + return this.groupService.acceptTest(groupId, testId, dto); + } + return this.groupService.rejectTest(groupId, testId, dto); + } + + @PutMapping("/{groupId}/materials/{materialId}/status") + public ResponseEntity verifyMaterial(@PathVariable(required = true) String groupId, + @PathVariable(required = true) String materialId, @Valid @RequestBody VerifyDto dto) { + if (dto.getStatus() == VerifyDto.VerifyType.ACCEPTED) { + return this.groupService.acceptMaterial(groupId, materialId, dto); + } + return this.groupService.rejectMaterial(groupId, materialId, dto); + } + + @PutMapping("/{groupId}/flashcard-sets/{setId}/status") + public ResponseEntity verifySet(@PathVariable(required = true) String groupId, + @PathVariable(required = true) String setId, @Valid @RequestBody VerifyDto dto) { + if (dto.getStatus() == VerifyDto.VerifyType.ACCEPTED) { + return this.groupService.acceptSet(groupId, setId, dto); + } + return this.groupService.rejectSet(groupId, setId, dto); + } + + @GetMapping("/{groupId}/content/{type}/unverified") + public ResponseEntity getUnverifiedContent(@PathVariable(required = true) Long groupId, + @PathVariable(required = true) String type) { + return this.groupService.getUnverifiedContent(groupId, type); + } + + @GetMapping("/{type}/{content_id}/comments") + public ResponseEntity getComments(@PathVariable(required = true) String type, + @PathVariable(required = true) Long content_id) { + return this.groupService.getComments(type, content_id); + } + + @PostMapping("/{type}/{content_id}/comments") + public ResponseEntity addComment(@PathVariable(required = true) String type, + @PathVariable(required = true) Long content_id, @RequestBody SimpleStudyGroupCommentDto comment) { + return this.groupService.addComment(type, content_id, comment); + } + + @DeleteMapping("/comments/{comment_id}") + public ResponseEntity deleteComment(@PathVariable(required = true) Long comment_id) { + return this.groupService.deleteComment(comment_id); + } + + @GetMapping("/{group_id}/leaderboard") + public ResponseEntity getGroupLeaderboard(@PathVariable(required = true) Long group_id) { + return this.groupService.getGroupLeaderboard(group_id); + } + + @GetMapping("/{group_id}/testleaderboard") + public ResponseEntity getGroupTestLeaderboard(@PathVariable(required = true) Long group_id) { + return this.groupService.getGroupTestLeaderboard(group_id); + } +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/StudyGroupComment/StudyGroupComment.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/StudyGroupComment/StudyGroupComment.java new file mode 100644 index 0000000..197e7f0 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/StudyGroupComment/StudyGroupComment.java @@ -0,0 +1,36 @@ +package studycave.studycaverestservice.model.StudyGroupComment; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; + +@Entity +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class StudyGroupComment { + @Id + @Column(name = "id") + @GeneratedValue(strategy=GenerationType.IDENTITY) + private Long id; + + @Column(name = "content_id") + private Long contentId; + + @Column(name = "user_id") + private Long userId; + + private String text; + + @Column(name = "content_type") + private String contentType; + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/StudyGroupComment/StudyGroupCommentRepository.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/StudyGroupComment/StudyGroupCommentRepository.java new file mode 100644 index 0000000..0c5e01c --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/StudyGroupComment/StudyGroupCommentRepository.java @@ -0,0 +1,13 @@ +package studycave.studycaverestservice.model.StudyGroupComment; + +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 StudyGroupCommentRepository extends JpaRepository { + + @Query("select c from StudyGroupComment c where ( c.contentId = :id and c.contentType = :t )") + List findCommentsByContent(@Param("t") String t, @Param("id") Long id); +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/StudyGroupComment/dto/SimpleStudyGroupCommentDto.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/StudyGroupComment/dto/SimpleStudyGroupCommentDto.java new file mode 100644 index 0000000..3beeefb --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/StudyGroupComment/dto/SimpleStudyGroupCommentDto.java @@ -0,0 +1,15 @@ +package studycave.studycaverestservice.model.StudyGroupComment.dto; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@Getter +@Setter +@AllArgsConstructor@NoArgsConstructor +public class SimpleStudyGroupCommentDto { + private String username; + private String text; + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/StudyGroupComment/dto/StudyGroupCommentDto.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/StudyGroupComment/dto/StudyGroupCommentDto.java new file mode 100644 index 0000000..5f2d4bc --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/StudyGroupComment/dto/StudyGroupCommentDto.java @@ -0,0 +1,17 @@ +package studycave.studycaverestservice.model.StudyGroupComment.dto; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class StudyGroupCommentDto { + private Long id; + private String text; + private String username; + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/flashcardset/SetRepository.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/flashcardset/SetRepository.java new file mode 100644 index 0000000..23b4d68 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/flashcardset/SetRepository.java @@ -0,0 +1,27 @@ +package studycave.studycaverestservice.model.flashcardset; + +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; +import java.util.Optional; + +public interface SetRepository extends JpaRepository { + Set save(Set set); + void deleteById(Long id); + Optional findById(Long id); + List findAll(); + + @Query("select count(s) from Set s join s.flashcards f where (f.leftSide = :x and f.rightSide = :y and s.id=:id) or (f.leftSide = :y and f.rightSide = :x and s.id=:id)") + int findResult(@Param("id") Long id, @Param("x") String x, @Param("y") String y); + + + @Query("select t from Set t where (t.permission = 'GROUP' and t.group.id = :g and t.status = 'VERIFIED' )") + List findSetByGroup(@Param("g") Long g); + + + @Query("select t from Set t where (t.permission = 'GROUP' and t.group.id = :g and t.status = 'UNVERIFIED' )") + List findWaitingSetByGroupKey(@Param("g") Long g); + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/CreateGroupDto.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/CreateGroupDto.java new file mode 100644 index 0000000..adb18b6 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/CreateGroupDto.java @@ -0,0 +1,17 @@ +package studycave.studycaverestservice.model.studyGroup; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class CreateGroupDto { + + private String owner; + private String name; + private String description; +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/GroupService.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/GroupService.java new file mode 100644 index 0000000..c790c5a --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/GroupService.java @@ -0,0 +1,692 @@ +package studycave.studycaverestservice.model.studyGroup; + + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +import javax.persistence.EntityManager; +import javax.persistence.PersistenceContext; + +import org.apache.commons.text.RandomStringGenerator; +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.core.Authentication; +import org.springframework.security.core.context.SecurityContextHolder; +import org.springframework.stereotype.Service; +import org.springframework.web.bind.annotation.RequestBody; +import studycave.studycaverestservice.model.StudyGroupComment.StudyGroupComment; +import studycave.studycaverestservice.model.StudyGroupComment.StudyGroupCommentRepository; +import studycave.studycaverestservice.model.StudyGroupComment.dto.SimpleStudyGroupCommentDto; +import studycave.studycaverestservice.model.StudyGroupComment.dto.StudyGroupCommentDto; +import studycave.studycaverestservice.model.badge.Badge; +import studycave.studycaverestservice.model.badge.BadgeRepository; +import studycave.studycaverestservice.model.flashcard.Flashcard; +import studycave.studycaverestservice.model.flashcardset.Set; +import studycave.studycaverestservice.model.flashcardset.SetRepository; +import studycave.studycaverestservice.model.material.Material; +import studycave.studycaverestservice.model.material.MaterialRepository; +import studycave.studycaverestservice.model.studyGroup.dto.*; +import studycave.studycaverestservice.model.studyGroupMember.StudyGroupMember; +import studycave.studycaverestservice.model.studyGroupMember.StudyGroupMemberRepository; +import studycave.studycaverestservice.model.test.Test; +import studycave.studycaverestservice.model.test.TestRepository; +import studycave.studycaverestservice.model.test.question.*; +import studycave.studycaverestservice.model.test.result.TestResultRepository; +import studycave.studycaverestservice.model.user.User; +import studycave.studycaverestservice.model.user.UserRepository; +import studycave.studycaverestservice.model.user.dto.LeaderboardDTO; +import studycave.studycaverestservice.model.user.dto.SimpleUserInfo; +import studycave.studycaverestservice.model.userActivity.UserActivity; +import studycave.studycaverestservice.model.userActivity.UserActivityService; +import studycave.studycaverestservice.model.userBadge.UserBadge; +import studycave.studycaverestservice.model.userBadge.UserBadgeRepository; + + +@Service +public class GroupService { + + @Autowired + ModelMapper modelMapper; + @Autowired + GroupRepository groupRepository; + @Autowired + UserRepository userRepository; + @Autowired + MaterialRepository materialRepository; + @Autowired + StudyGroupMemberRepository memberRepository; + @Autowired + BadgeRepository badgeRepository; + @Autowired + UserBadgeRepository userBadgeRepository; + @Autowired + SetRepository setRepository; + @Autowired + TestRepository testRepository; + @Autowired + TestResultRepository testResultRepository; + @Autowired + StudyGroupCommentRepository commentRepository; + @Autowired + UserActivityService userActivityService; + + @PersistenceContext + private EntityManager entityManager; + + public ResponseEntity createGroup(CreateGroupDto groupDto) { + StudyGroup group = modelMapper.map(groupDto, StudyGroup.class); + RandomStringGenerator generator = new RandomStringGenerator.Builder().withinRange('0', 'z') + .filteredBy(Character::isLetterOrDigit).build(); + + String groupKey = generator.generate(10); + + while (!this.groupRepository.findByGroupKey(groupKey).isEmpty()) { + groupKey = generator.generate(10); + } + ; + group.setGroupKey(groupKey); + Optional owner = this.userRepository.findByUsername(groupDto.getOwner()); + if (!owner.isPresent()) { + return new ResponseEntity<>("Invalid Owner", HttpStatus.BAD_REQUEST); + } + + List members = new ArrayList<>(); + StudyGroupMember member = new StudyGroupMember(); + member.setUser(owner.get()); + member.setIsGroupLeader(true); + member.setGroup(group); + members.add(member); + group.setMembers(members); + + group = this.groupRepository.save(group); + GroupDto createdGroupDto = modelMapper.map(group, GroupDto.class); + createdGroupDto.setKey(group.getGroupKey()); + createdGroupDto.setOwner(group.getMembers().get(0).getUser().getUsername()); + // Badge for creating first group + if(userBadgeRepository.findByIdAndUser((long)2, owner.orElse(null).getId()).isEmpty()) { + UserBadge badgeAchieved = new UserBadge(); + Badge badge = new Badge(); + badge = badgeRepository.findById((long)2).orElse(null); + badgeAchieved.setBadge(badge); + badgeAchieved.setUser(owner.orElse(null)); + userBadgeRepository.save(badgeAchieved); + } + + return new ResponseEntity(createdGroupDto, HttpStatus.OK); + } + + public GroupInfoDto getGroupInfo(Long id) { + StudyGroup group = new StudyGroup(); + group = this.groupRepository.findById(id).orElse(null); + GroupInfoDto groupInfo = new GroupInfoDto(); + groupInfo.setId(group.getId()); + groupInfo.setName(group.getName()); + groupInfo.setDescription(group.getDescription()); + groupInfo.setGroupKey(group.getGroupKey()); + List users = new ArrayList<>(); + for (StudyGroupMember m : group.getMembers()) { + if (m.getIsGroupLeader() != true) { + SimpleUserInfo u = new SimpleUserInfo(); + u.setId(m.getUser().getId()); + u.setUsername(m.getUser().getUsername()); + users.add(u); + } + else + groupInfo.setOwner(m.getUser().getUsername()); + } + groupInfo.setUsers(users); + return groupInfo; + } + + public ResponseEntity deleteUserFromGroup(Long gId, Long pId) { + StudyGroupMember user = new StudyGroupMember(); + user = this.memberRepository.findUserInGroup(gId, pId); + this.memberRepository.delete(user); + return new ResponseEntity(HttpStatus.OK); + + } + + public ResponseEntity deleteGroup(Long id) { + StudyGroup group = new StudyGroup(); + group = this.groupRepository.findById(id).orElse(null); + for (StudyGroupMember m : group.getMembers()) { + this.memberRepository.delete(m); + } + this.groupRepository.delete(group); + return new ResponseEntity(HttpStatus.OK); + } + + public ResponseEntity generateCode(Long id) { + StudyGroup group = new StudyGroup(); + group = this.groupRepository.findById(id).orElse(null); + RandomStringGenerator generator = new RandomStringGenerator.Builder().withinRange('0', 'z') + .filteredBy(Character::isLetterOrDigit).build(); + + String groupKey = generator.generate(10); + + while (!this.groupRepository.findByGroupKey(groupKey).isEmpty()) { + groupKey = generator.generate(10); + } + + group.setGroupKey(groupKey); + this.groupRepository.save(group); + return new ResponseEntity<>(groupKey, HttpStatus.OK); + } + + public List getMyGroups(Long id) { + // User user = new User(); + // user = this.userRepository.findByUsername(username).orElse(null); + List groups = new ArrayList<>(); + groups = this.memberRepository.findByMember(id); + List simplegroups = new ArrayList<>(); + for (StudyGroupMember g : groups) { + SimpleStudyGroupMemberDTO s = new SimpleStudyGroupMemberDTO(); + s.setName(g.getGroup().getName()); + s.setId(g.getGroup().getId()); + if (g.getIsGroupLeader() == true) + s.setRole("OWNER"); + else + s.setRole("MEMBER"); + simplegroups.add(s); + } + return simplegroups; + } + + public ResponseEntity joinToGroup(Long userId, String groupCode) { + List groups = this.groupRepository.findByGroupKey(groupCode); + + if (groups.isEmpty()) { + return new ResponseEntity<>("Nie znaleziono grupy", HttpStatus.NOT_FOUND); + } + + for (StudyGroup group : groups) { + if (group.getGroupKey().equals(groupCode)) { + for (StudyGroupMember member : group.getMembers()) { + if (member.getUser().getId() == userId) { + return new ResponseEntity<>("Użytkownik znajduje się już w grupie", HttpStatus.CONFLICT); + } + } + StudyGroupMember newMember = new StudyGroupMember(); + newMember.setIsGroupLeader(false); + newMember.setGroup(group); + newMember.setUser(this.userRepository.findById(userId).orElse(null)); + this.memberRepository.save(newMember); + GroupDto groupDto = modelMapper.map(group, GroupDto.class); + + // Badge for joining first group + if(userBadgeRepository.findByIdAndUser((long)3, userId).isEmpty()) { + UserBadge badgeAchieved = new UserBadge(); + Badge badge = new Badge(); + badge = badgeRepository.findById((long)3).orElse(null); + badgeAchieved.setBadge(badge); + badgeAchieved.setUser(userRepository.findById(userId).orElse(null)); + userBadgeRepository.save(badgeAchieved); + } + + return new ResponseEntity(groupDto, HttpStatus.OK); + } + } + + return new ResponseEntity<>("Niepoprawny kod", HttpStatus.BAD_REQUEST); + } + + public ResponseEntity addFlashcardSets(String groupId, @RequestBody List setIds) { + StudyGroup group = this.groupRepository.findById(Long.parseLong(groupId)).orElse(null); + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + User user = userRepository.findByUsername(authentication.getName()).get(); + + if (group == null) { + return new ResponseEntity<>("Nie znaleziono grupy", HttpStatus.NOT_FOUND); + } + for (AddSetDto s : setIds) { + Long setId = Long.parseLong(s.getSetId()); + this.setRepository.findById(setId).ifPresent(set -> { + List flashcards = set.getFlashcards(); + for (Flashcard flashcard : flashcards) { + entityManager.detach(flashcard); + flashcard.setId(null); + } + entityManager.detach(set); + set.setId(null); + set.setPermission("GROUP"); + set.setStatus("UNVERIFIED"); + set.setGroup(group); + this.setRepository.save(set); + this.userActivityService.saveActivity("addedResource", 0, null, user, null, group, null, set, null); + }); + } + return new ResponseEntity<>("Dodano", HttpStatus.OK); + } + + + public ResponseEntity addMaterials(String groupId, @RequestBody List materialIds) { + StudyGroup group = this.groupRepository.findById(Long.parseLong(groupId)).orElse(null); + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + User user = userRepository.findByUsername(authentication.getName()).get(); + + if (group == null) { + return new ResponseEntity<>("Nie znaleziono grupy", HttpStatus.NOT_FOUND); + } + for (AddMaterialDto m : materialIds) { + Long materialId = Long.parseLong(m.getMaterialId()); + this.materialRepository.findById(materialId).ifPresent(material -> { + entityManager.detach(material); + material.setId(null); + material.setPermission("GROUP"); + material.setStatus("UNVERIFIED"); + material.setGroup(group); + this.materialRepository.save(material); + this.userActivityService.saveActivity("addedResource", 0, null, user, null, group, material, null, null); + }); + } + return new ResponseEntity<>("Dodano", HttpStatus.OK); + } + + public ResponseEntity addTests(String groupId, @RequestBody List testIds) { + StudyGroup group = this.groupRepository.findById(Long.parseLong(groupId)).orElse(null); + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + User user = userRepository.findByUsername(authentication.getName()).get(); + + if (group == null) { + return new ResponseEntity<>("Nie znaleziono grupy", HttpStatus.NOT_FOUND); + } + for (AddTestDto t : testIds) { + Long testId = Long.parseLong(t.getTestId()); + this.testRepository.findById(testId).ifPresent(test -> { + List questions = test.getQuestions(); + for (Question question : questions) { + if (question instanceof QuestionChoices) { + for (AnswerChoices answer : ((QuestionChoices) question).getAnswers()) { + entityManager.detach(answer); + answer.setId(null); + } + } + if (question instanceof QuestionPairs) { + for (AnswerPairs answer : ((QuestionPairs) question).getAnswers()) { + entityManager.detach(answer); + answer.setId(null); + } + } + if (question instanceof QuestionPuzzle) { + for (AnswerPuzzle answer : ((QuestionPuzzle) question).getAnswers()) { + entityManager.detach(answer); + answer.setId(null); + } + } + if (question instanceof QuestionGaps) { + for (AnswerGaps answer : ((QuestionGaps) question).getAnswers()) { + entityManager.detach(answer); + answer.setId(null); + } + } + entityManager.detach(question); + question.setId(null); + } + entityManager.detach(test); + test.setId(null); + test.setPermission("GROUP"); + test.setStatus("UNVERIFIED"); + test.setGroup(group); + this.testRepository.save(test); + this.userActivityService.saveActivity("addedResource", 0, null, user, null, group, null, null, test); + }); + } + + return new ResponseEntity<>("Dodano", HttpStatus.OK); + } + + + public ResponseEntity getContent(Long group_id, String type) { + List contents = new ArrayList<>(); + + switch (type){ + case "tests": + List tests = new ArrayList<>(); + tests = this.testRepository.findTestByGroup(group_id); + for (Test t : tests) { + ContentDto contentTest = new ContentDto(); + contentTest.setId(t.getId()); + contentTest.setOwner((userRepository.findById(t.getIdOwner()).orElse(null)).getUsername()); + contentTest.setAddDate(); + contentTest.setGrade((long) 0); + contentTest.setTitle(t.getTitle()); + contents.add(contentTest); + } + + return new ResponseEntity>(contents, HttpStatus.OK); + case "materials": + List materials = new ArrayList<>(); + materials = this.materialRepository.findMaterialByGroup(group_id); + for (Material m : materials ) { + ContentDto contentMaterial = new ContentDto(); + contentMaterial.setId(m.getId()); + contentMaterial.setOwner((userRepository.findById((long)m.getOwner()).orElse(null)).getUsername()); + contentMaterial.setAddDate(); + contentMaterial.setGrade((long) 0); + contentMaterial.setTitle(m.getTitle()); + contents.add(contentMaterial); + } + + return new ResponseEntity>(contents, HttpStatus.OK); + case "flashcardsets": + List sets = new ArrayList<>(); + sets = this.setRepository.findSetByGroup(group_id); + for (Set s : sets) { + ContentDto contentSet = new ContentDto(); + contentSet.setId(s.getId()); + contentSet.setOwner((userRepository.findById((long)s.getIdOwner()).orElse(null)).getUsername()); + contentSet.setAddDate(); + contentSet.setGrade((long) 0); + contentSet.setTitle(s.getName()); + contents.add(contentSet); + } + + return new ResponseEntity>(contents, HttpStatus.OK); + default: + return new ResponseEntity<>("Błąd w zapytaniu", HttpStatus.BAD_REQUEST); + } + + } + + public ResponseEntity getUnverifiedContent(Long group_id, String type){ + List contents = new ArrayList<>(); + + switch (type){ + case "tests": + List tests = new ArrayList<>(); + tests = this.testRepository.findWaitingTestByGroupKey(group_id); + for (Test t : tests) { + ContentDto content = new ContentDto(); + content.setId(t.getId()); + content.setOwner((userRepository.findById(t.getIdOwner()).orElse(null)).getUsername()); + content.setAddDate(); + content.setGrade((long) 0); + content.setTitle(t.getTitle()); + contents.add(content); + } + return new ResponseEntity>(contents, HttpStatus.OK); + case "materials": + List materials = new ArrayList<>(); + materials = this.materialRepository.findWaitingMaterialByGroupKey(group_id); + for (Material m : materials ) { + ContentDto content = new ContentDto(); + content.setId(m.getId()); + content.setOwner((userRepository.findById((long)m.getOwner()).orElse(null)).getUsername()); + content.setAddDate(); + content.setGrade((long) 0); + content.setTitle(m.getTitle()); + contents.add(content); + } + return new ResponseEntity>(contents, HttpStatus.OK); + case "flashcards": + List sets = new ArrayList<>(); + sets = this.setRepository.findWaitingSetByGroupKey(group_id); + for (Set s : sets) { + ContentDto content = new ContentDto(); + content.setId(s.getId()); + content.setOwner((userRepository.findById((long)s.getIdOwner()).orElse(null)).getUsername()); + content.setAddDate(); + content.setGrade((long) 0); + content.setTitle(s.getName()); + contents.add(content); + } + return new ResponseEntity>(contents, HttpStatus.OK); + default: + return new ResponseEntity<>("Błąd w zapytaniu", HttpStatus.BAD_REQUEST); + } + } + + public ResponseEntity acceptTest(String groupId, String testId, VerifyDto dto) { + StudyGroup group = this.groupRepository.findById(Long.parseLong(groupId)).orElse(null); + if (group == null) { + return new ResponseEntity<>("Nie znaleziono grupy", HttpStatus.NOT_FOUND); + } + Test test = this.testRepository.getOne(Long.parseLong(testId)); + test.setPermission("GROUP"); + test.setStatus("VERIFIED"); + this.testRepository.save(test); + + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + User user = userRepository.findByUsername(authentication.getName()).get(); + User toUser = new User(); + toUser.setId(Long.valueOf(test.getIdOwner())); + this.userActivityService.saveActivity("acceptedResource", dto.getPoints(), dto.getComment(), toUser, user, group, null, null, test); + return new ResponseEntity<>("Dodano", HttpStatus.OK); + } + + public ResponseEntity acceptSet(String groupId, String setId, VerifyDto dto) { + StudyGroup group = this.groupRepository.findById(Long.parseLong(groupId)).orElse(null); + if (group == null) { + return new ResponseEntity<>("Nie znaleziono grupy", HttpStatus.NOT_FOUND); + } + Set set = this.setRepository.findById(Long.parseLong(setId)).orElse(null); + if (set == null) { + return new ResponseEntity<>("Nie znaleziono zestawu", HttpStatus.NOT_FOUND); + } + set.setPermission("GROUP"); + set.setStatus("VERIFIED"); + this.setRepository.save(set); + + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + User user = userRepository.findByUsername(authentication.getName()).get(); + User toUser = new User(); + toUser.setId(Long.valueOf(set.getIdOwner())); + this.userActivityService.saveActivity("acceptedResource", dto.getPoints(), dto.getComment(), toUser, user, group, null, set, null); + return new ResponseEntity<>("Dodano", HttpStatus.OK); + } + + public ResponseEntity acceptMaterial(String groupId, String materialId, VerifyDto dto) { + StudyGroup group = this.groupRepository.findById(Long.parseLong(groupId)).orElse(null); + if (group == null) { + return new ResponseEntity<>("Nie znaleziono grupy", HttpStatus.NOT_FOUND); + } + Material material = this.materialRepository.findById(Long.parseLong(materialId)).orElse(null); + if (material == null) { + return new ResponseEntity<>("Nie znaleziono materiału", HttpStatus.NOT_FOUND); + } + material.setPermission("GROUP"); + material.setStatus("VERIFIED"); + this.materialRepository.save(material); + + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + User user = userRepository.findByUsername(authentication.getName()).get(); + User toUser = new User(); + toUser.setId(Long.valueOf(material.getOwner())); + this.userActivityService.saveActivity("acceptedResource", dto.getPoints(), dto.getComment(), toUser, user, group, material, null, null); + return new ResponseEntity<>("Dodano", HttpStatus.OK); + } + + public ResponseEntity rejectTest(String groupId, String testId, VerifyDto dto) { + StudyGroup group = this.groupRepository.findById(Long.parseLong(groupId)).orElse(null); + if (group == null) { + return new ResponseEntity<>("Nie znaleziono grupy", HttpStatus.NOT_FOUND); + } + Test test = this.testRepository.getOne(Long.parseLong(testId)); + + test.setPermission("GROUP"); + test.setStatus("REJECTED"); + this.testRepository.save(test); + + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + User user = userRepository.findByUsername(authentication.getName()).get(); + User toUser = new User(); + toUser.setId(Long.valueOf(test.getIdOwner())); + this.userActivityService.saveActivity("rejectedResource", dto.getPoints(), dto.getComment(), toUser, user, group, null, null, test); + return new ResponseEntity<>("Usunięto", HttpStatus.OK); + } + + public ResponseEntity rejectSet(String groupId, String setId, VerifyDto dto) { + StudyGroup group = this.groupRepository.findById(Long.parseLong(groupId)).orElse(null); + if (group == null) { + return new ResponseEntity<>("Nie znaleziono grupy", HttpStatus.NOT_FOUND); + } + Set set = this.setRepository.findById(Long.parseLong(setId)).orElse(null); + if (set == null) { + return new ResponseEntity<>("Nie znaleziono zestawu", HttpStatus.NOT_FOUND); + } + + set.setPermission("GROUP"); + set.setStatus("REJECTED"); + this.setRepository.save(set); + + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + User user = userRepository.findByUsername(authentication.getName()).get(); + User toUser = new User(); + toUser.setId(Long.valueOf(set.getIdOwner())); + this.userActivityService.saveActivity("rejectedResource", dto.getPoints(), dto.getComment(), toUser, user, group, null, set, null); + return new ResponseEntity<>("Usunięto", HttpStatus.OK); + } + + public ResponseEntity rejectMaterial(String groupId, String materialId, VerifyDto dto) { + StudyGroup group = this.groupRepository.findById(Long.parseLong(groupId)).orElse(null); + if (group == null) { + return new ResponseEntity<>("Nie znaleziono grupy", HttpStatus.NOT_FOUND); + } + Material material = this.materialRepository.findById(Long.parseLong(materialId)).orElse(null); + if (material == null) { + return new ResponseEntity<>("Nie znaleziono materiału", HttpStatus.NOT_FOUND); + } + + material.setPermission("GROUP"); + material.setStatus("REJECTED"); + this.materialRepository.save(material); + + Authentication authentication = SecurityContextHolder.getContext().getAuthentication(); + User user = userRepository.findByUsername(authentication.getName()).get(); + User toUser = new User(); + toUser.setId(Long.valueOf(material.getOwner())); + this.userActivityService.saveActivity("rejectedResource", dto.getPoints(), dto.getComment(), toUser, user, group, material, null, null); + return new ResponseEntity<>("Usunięto", HttpStatus.OK); + } + + public ResponseEntity getComments(String type, Long content_id) { + List comments = new ArrayList<>(); + for(StudyGroupComment c : this.commentRepository.findCommentsByContent(type, content_id)) { + StudyGroupCommentDto comment = new StudyGroupCommentDto(); + comment.setId(c.getId()); + comment.setText(c.getText()); + comment.setUsername((this.userRepository.findById(c.getUserId()).orElse(null)).getUsername()); + System.out.println(comment); + comments.add(comment); + } + return new ResponseEntity>(comments, HttpStatus.OK); + } + + public ResponseEntity addComment(String type, Long content_id, SimpleStudyGroupCommentDto text) { + StudyGroupComment comment = new StudyGroupComment(); + comment.setContentType(type); + comment.setContentId(content_id); + comment.setText(text.getText()); + comment.setUserId((this.userRepository.findByUsername(text.getUsername()).orElse(null)).getId()); + this.commentRepository.save(comment); + if(userBadgeRepository.findByIdAndUser((long)7, (this.userRepository.findByUsername(text.getUsername()).orElse(null)).getId()).isEmpty()) { + UserBadge badgeAchieved = new UserBadge(); + Badge badge = new Badge(); + badge = badgeRepository.findById((long)7).orElse(null); + badgeAchieved.setBadge(badge); + badgeAchieved.setUser(this.userRepository.findByUsername(text.getUsername()).orElse(null)); + userBadgeRepository.save(badgeAchieved); + } + return new ResponseEntity<>("Dodano komentarz", HttpStatus.OK); + } + + public ResponseEntity deleteComment(Long comment_id) { + this.commentRepository.deleteById(comment_id); + return new ResponseEntity<>("Usunięto komentarz", HttpStatus.OK); + } + + public ResponseEntity deleteContent(Long group_id, String type, Long content_id){ + switch (type) { + case "tests": + Test test = this.testRepository.findById(content_id).orElse(null); + if (test == null) { + return new ResponseEntity<>("Nie znaleziono", HttpStatus.NOT_FOUND); + } + test.setStatus("DELETED"); + this.testRepository.save(test); + return new ResponseEntity<>("Usunięto", HttpStatus.OK); + case "materials": + Material material = this.materialRepository.findById(content_id).orElse(null); + if (material == null) { + return new ResponseEntity<>("Nie znaleziono", HttpStatus.NOT_FOUND); + } + material.setStatus("DELETED"); + this.materialRepository.save(material); + return new ResponseEntity<>("Usunięto", HttpStatus.OK); + case "sets": + Set set = this.setRepository.findById(content_id).orElse(null); + if (set == null) { + return new ResponseEntity<>("Nie znaleziono", HttpStatus.NOT_FOUND); + } + set.setStatus("DELETED"); + this.setRepository.save(set); + return new ResponseEntity<>("Usunięto", HttpStatus.OK); + default: + return new ResponseEntity<>("Błąd zapytania", HttpStatus.BAD_REQUEST); + } + } + + public ResponseEntity getGroupLeaderboard(Long group_id){ + StudyGroup group = this.groupRepository.findById(group_id).orElse(null); + if (group == null) { + return new ResponseEntity<>("Nie znaleziono grupy", HttpStatus.NOT_FOUND); + } + List leaderboard = new ArrayList<>(); + for(StudyGroupMember m : group.getMembers()) { + if(!m.getIsGroupLeader()) { + float score = 0; + LeaderboardDTO user = new LeaderboardDTO(); + for (UserActivity a : m.getUser().getActivityTo()) { + score += a.getPoints(); + } + user.setUsername(m.getUser().getUsername()); + if(userBadgeRepository.findByIdAndUser((long)8, m.getUser().getId()).isEmpty() && score > 100) { + UserBadge badgeAchieved = new UserBadge(); + Badge badge = new Badge(); + badge = badgeRepository.findById((long)8).orElse(null); + badgeAchieved.setBadge(badge); + badgeAchieved.setUser(m.getUser()); + userBadgeRepository.save(badgeAchieved); + } + if(userBadgeRepository.findByIdAndUser((long)12, m.getUser().getId()).isEmpty() && score > 250) { + UserBadge badgeAchieved = new UserBadge(); + Badge badge = new Badge(); + badge = badgeRepository.findById((long)12).orElse(null); + badgeAchieved.setBadge(badge); + badgeAchieved.setUser(m.getUser()); + userBadgeRepository.save(badgeAchieved); + } + user.setPoints(score); + leaderboard.add(user); + } + } + return new ResponseEntity>(leaderboard,HttpStatus.OK); + } + + public ResponseEntity getGroupTestLeaderboard(Long group_id){ + StudyGroup group = this.groupRepository.findById(group_id).orElse(null); + if (group == null) { + return new ResponseEntity<>("Nie znaleziono grupy", HttpStatus.NOT_FOUND); + } + List leaderboard = new ArrayList<>(); + for(StudyGroupMember m : group.getMembers()) { + if(!m.getIsGroupLeader()) { + float score = 0; + LeaderboardDTO user = new LeaderboardDTO(); + for (UserActivity a : m.getUser().getActivityTo()) { + if(a.getType() == "solvedTest") + score += a.getPoints(); + } + user.setUsername(m.getUser().getUsername()); + user.setPoints(score); + leaderboard.add(user); + } + // leaderboard.sort((o1, o2) -> Integer.toString(o1.getPoints()).compareTo(Integer.toString(o2.getPoints()))); + } + return new ResponseEntity>(leaderboard,HttpStatus.OK); + } + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/AddMaterialDto.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/AddMaterialDto.java new file mode 100644 index 0000000..f16d311 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/AddMaterialDto.java @@ -0,0 +1,16 @@ +package studycave.studycaverestservice.model.studyGroup.dto; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class AddMaterialDto { + + private String materialId; + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/AddSetDto.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/AddSetDto.java new file mode 100644 index 0000000..ea0b87e --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/AddSetDto.java @@ -0,0 +1,16 @@ +package studycave.studycaverestservice.model.studyGroup.dto; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class AddSetDto { + + private String setId; + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/AddTestDto.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/AddTestDto.java new file mode 100644 index 0000000..2e6f8bb --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/AddTestDto.java @@ -0,0 +1,16 @@ +package studycave.studycaverestservice.model.studyGroup.dto; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class AddTestDto { + + private String testId; + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/ContentDto.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/ContentDto.java new file mode 100644 index 0000000..a56d09d --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/ContentDto.java @@ -0,0 +1,29 @@ +package studycave.studycaverestservice.model.studyGroup.dto; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +import java.sql.Date; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class ContentDto { + + private Long id; + private String title; + private Date addDate; + private String owner; + private Long grade; + + public void setAddDate() { + + java.util.Date utilDate = new java.util.Date(); + Date sqlDate = new Date(utilDate.getTime()); + this.addDate = sqlDate; + } + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/GroupDto.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/GroupDto.java new file mode 100644 index 0000000..2f2e73b --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/GroupDto.java @@ -0,0 +1,20 @@ +package studycave.studycaverestservice.model.studyGroup.dto; + +import com.fasterxml.jackson.annotation.JsonInclude; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@JsonInclude(JsonInclude.Include.NON_NULL) +@AllArgsConstructor +@NoArgsConstructor +@Getter +@Setter +public class GroupDto { + private Long id; + private String owner; + private String name; + private String description; + private String key; +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/GroupInfoDto.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/GroupInfoDto.java new file mode 100644 index 0000000..eca977d --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/GroupInfoDto.java @@ -0,0 +1,23 @@ +package studycave.studycaverestservice.model.studyGroup.dto; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import studycave.studycaverestservice.model.user.dto.SimpleUserInfo; + +import java.util.ArrayList; +import java.util.List; + +@AllArgsConstructor +@NoArgsConstructor +@Getter +@Setter +public class GroupInfoDto { + private Long id; + private String owner; + private String name; + private String description; + private String groupKey; + List users = new ArrayList<>(); +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/GroupJoinDto.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/GroupJoinDto.java new file mode 100644 index 0000000..d1a5c30 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/GroupJoinDto.java @@ -0,0 +1,15 @@ +package studycave.studycaverestservice.model.studyGroup.dto; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class GroupJoinDto { + String groupCode; + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/SimpleStudyGroupMemberDTO.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/SimpleStudyGroupMemberDTO.java new file mode 100644 index 0000000..b5e3917 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/SimpleStudyGroupMemberDTO.java @@ -0,0 +1,17 @@ +package studycave.studycaverestservice.model.studyGroup.dto; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class SimpleStudyGroupMemberDTO { + private String name; + private Long id; + private String role; + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/VerifyDto.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/VerifyDto.java new file mode 100644 index 0000000..499d18b --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/studyGroup/dto/VerifyDto.java @@ -0,0 +1,29 @@ +package studycave.studycaverestservice.model.studyGroup.dto; + +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +import javax.validation.constraints.NotNull; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class VerifyDto { + + public enum VerifyType { + ACCEPTED, REJECTED; + } + + @ApiModelProperty + @NotNull + VerifyType status; + @ApiModelProperty + int points; + @ApiModelProperty + String comment; + +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/user/dto/LeaderboardDTO.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/user/dto/LeaderboardDTO.java new file mode 100644 index 0000000..319aefd --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/user/dto/LeaderboardDTO.java @@ -0,0 +1,25 @@ +package studycave.studycaverestservice.model.user.dto; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class LeaderboardDTO implements Comparable { + private String Username; + private float points; + + + @Override + public int compareTo(Object o) { + int result = this.getUsername().compareTo(((LeaderboardDTO) o).getUsername()); + if(result == 0) { + result = (this.getPoints() < ((LeaderboardDTO) o).getPoints() ? -1 : (this.getPoints() == ((LeaderboardDTO) o).getPoints() ? 0 : 1)); + } + return result; + } +} diff --git a/BackEnd/src/main/java/studycave/studycaverestservice/model/user/dto/SimpleUserInfo.java b/BackEnd/src/main/java/studycave/studycaverestservice/model/user/dto/SimpleUserInfo.java new file mode 100644 index 0000000..64c8cb8 --- /dev/null +++ b/BackEnd/src/main/java/studycave/studycaverestservice/model/user/dto/SimpleUserInfo.java @@ -0,0 +1,15 @@ +package studycave.studycaverestservice.model.user.dto; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@Getter +@Setter +@AllArgsConstructor +@NoArgsConstructor +public class SimpleUserInfo { + private String username; + private Long id; +}