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;
+}