Merge branch 'adrian'

This commit is contained in:
yetju000 2019-11-23 12:01:58 +01:00
commit 3aafb0cbaf
20 changed files with 700 additions and 7 deletions

View File

@ -0,0 +1,141 @@
package studycave.studycaverestservice.controller;
import java.util.ArrayList;
import java.util.List;
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.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import studycave.studycaverestservice.model.badge.Badge;
import studycave.studycaverestservice.model.badge.BadgeRepository;
import studycave.studycaverestservice.model.studyGroupMember.StudyGroupMemberRepository;
import studycave.studycaverestservice.model.user.dto.UserDTO;
import studycave.studycaverestservice.model.user.dto.UserLoginDTO;
import studycave.studycaverestservice.model.user.dto.UserRegisterDTO;
import studycave.studycaverestservice.model.user.User;
import studycave.studycaverestservice.model.user.UserRepository;
import studycave.studycaverestservice.model.userBadge.UserBadge;
import studycave.studycaverestservice.model.userBadge.UserBadgeRepository;
import studycave.studycaverestservice.model.userBadge.dto.UserBadgeDTO;
@RestController
@CrossOrigin
@Api
public class UserController {
@Autowired
UserRepository userRepository;
@Autowired
StudyGroupMemberRepository memberRepository;
@Autowired
BadgeRepository badgeRepository;
@Autowired
UserBadgeRepository userBadgeRepository;
@Autowired
BCryptPasswordEncoder bCryptPasswordEncoder;
@Autowired
ModelMapper modelMapper;
@PostMapping("/user/register")
public String Register(@RequestBody UserRegisterDTO userDTO) {
if(userRepository.findByUsername(userDTO.getUsername()).orElse(null)!=null)
return "Login zajety";
if(userRepository.findByEmail(userDTO.getEmail()).orElse(null)!=null)
return "Email zajety";
userDTO.setPassword(bCryptPasswordEncoder.encode(userDTO.getPassword()));
User user = modelMapper.map(userDTO, User.class);
userRepository.save(user);
// Badge for registering
UserBadge badgeAchieved = new UserBadge();
Badge badge = new Badge();
badge = badgeRepository.findById((long)1).orElse(null);
badgeAchieved.setBadge(badge);
badgeAchieved.setUser(user);
userBadgeRepository.save(badgeAchieved);
return "Dodano uzytkownika";
}
@GetMapping("/user/{username}")
public ResponseEntity<?> getInfo(
@PathVariable(required = true)String username) {
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
String currentPrincipalName = authentication.getName();
User user = userRepository.findByUsername(username).get();
UserDTO userInfo = new UserDTO();
userInfo.setId(user.getId());
userInfo.setName(user.getName());
userInfo.setSurname(user.getSurname());
userInfo.setEmail(user.getEmail());
userInfo.setPassword(user.getPassword());
userInfo.setUsername(user.getUsername());
if (currentPrincipalName.equals(username)) return new ResponseEntity<UserDTO>(userInfo,HttpStatus.OK);
else return new ResponseEntity("Access Forbidden",HttpStatus.FORBIDDEN);
}
@PutMapping("/user/info/update")
public String updateUser(@RequestBody User user) {
User finduser = userRepository.findByUsername(user.getUsername()).orElse(null);
if(finduser!=null)
if(finduser.getId()!=user.getId())
return "Login zajety";
finduser = userRepository.findByEmail(user.getEmail()).orElse(null);
if(finduser!=null)
if(finduser.getId()!=user.getId())
return "Email zajety";
if(user.getPassword() == null)
user.setPassword(userRepository.findById(user.getId()).orElse(null).getPassword());
else
user.setPassword(bCryptPasswordEncoder.encode(user.getPassword()));
userRepository.save(user);
return "Edycja udana";
}
@ApiOperation("Login.")
@PostMapping("/login")
public void fakeLogin( //show in Swagger
@RequestBody UserLoginDTO user){
throw new IllegalStateException("This method shouldn't be called. It's implemented by Spring Security filters.");
}
@GetMapping("/user/badges")
public ResponseEntity<List<UserBadgeDTO>> getUserBadges() {
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
String currentPrincipalName = authentication.getName();
Long user_id = (userRepository.findByUsername(currentPrincipalName).orElse(null)).getId();
List<UserBadgeDTO> userBadges = new ArrayList<>();
List<Badge> badges = new ArrayList<>();
badges = badgeRepository.findAll();
for(Badge b : badges) {
UserBadgeDTO badge = new UserBadgeDTO();
badge.setBadgeName(b.getName());
badge.setIcon(b.getIconPath());
if(userBadgeRepository.findByIdAndUser(b.getId(), user_id).isEmpty())
badge.setUnlocked(false);
else
badge.setUnlocked(true);
userBadges.add(badge);
}
return new ResponseEntity<List<UserBadgeDTO>>(userBadges, HttpStatus.OK);
}
}

View File

@ -0,0 +1,30 @@
package studycave.studycaverestservice.model.badge;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import studycave.studycaverestservice.model.userBadge.UserBadge;
import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;
@Entity
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class Badge {
@Id
@Column(name="id")
@GeneratedValue(strategy= GenerationType.IDENTITY)
private Long id;
private String name;
private String iconPath;
@OneToMany(fetch = FetchType.LAZY, mappedBy = "badge", cascade = CascadeType.ALL)
List<UserBadge> users = new ArrayList<>();
}

View File

@ -0,0 +1,7 @@
package studycave.studycaverestservice.model.badge;
import org.springframework.data.jpa.repository.JpaRepository;
public interface BadgeRepository extends JpaRepository<Badge, Long> {
}

View File

@ -0,0 +1,41 @@
package studycave.studycaverestservice.model.flashcard;
import com.fasterxml.jackson.annotation.JsonBackReference;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import studycave.studycaverestservice.model.flashcardset.Set;
import javax.persistence.*;
@Entity
@Table(name = "flashcard")
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class Flashcard {
@Id
@GeneratedValue(strategy= GenerationType.IDENTITY)
private Long id;
@Column(name="left_side")
@JsonProperty("left_side")
private String leftSide;
@Column(name="right_side")
@JsonProperty("right_side")
private String rightSide;
@ManyToOne
@JoinColumn(name="id_set",referencedColumnName="id")
@ApiModelProperty(hidden = true)
@JsonBackReference
private Set flashcardSet;
public Flashcard(String firstName, String lastName) {
this.leftSide = firstName;
this.rightSide = lastName;
}
}

View File

@ -0,0 +1,70 @@
package studycave.studycaverestservice.model.flashcardset;
import com.fasterxml.jackson.annotation.JsonManagedReference;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import studycave.studycaverestservice.model.flashcard.Flashcard;
import studycave.studycaverestservice.model.studyGroup.StudyGroup;
import studycave.studycaverestservice.model.userActivity.UserActivity;
import javax.persistence.*;
import java.sql.Date;
import java.util.ArrayList;
import java.util.List;
@Entity
@Table(name = "flashcardset")
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class Set {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private String category;
@Column(name="id_owner")
@JsonProperty("owner")
private int idOwner;
@Column(name="add_date")
@JsonProperty("add_date")
private Date addDate;
@Column(name="edit_date")
@JsonProperty("edit_date")
private Date editDate;
private int grade;
@Column(name="permission")
private String permission;
@Column(name="status")
private String status;
@OneToMany(mappedBy="flashcardSet",cascade = CascadeType.ALL)
@JsonManagedReference
List<Flashcard> flashcards;
@ManyToOne
@JoinColumn(name="group_id",referencedColumnName="id")
private StudyGroup group;
@OneToMany(fetch = FetchType.LAZY, mappedBy = "set", cascade = CascadeType.ALL)
private List<UserActivity> activity = new ArrayList<>();
public Set(String name, String category, int idOwner) {
super();
this.name = name;
this.category = category;
this.idOwner = idOwner;
}
}

View File

@ -0,0 +1,53 @@
package studycave.studycaverestservice.model.material;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import studycave.studycaverestservice.model.studyGroup.StudyGroup;
import studycave.studycaverestservice.model.userActivity.UserActivity;
import javax.persistence.*;
import java.sql.Date;
import java.util.ArrayList;
import java.util.List;
@Entity
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class Material {
@Id
@GeneratedValue(strategy= GenerationType.IDENTITY)
private Long id;
private String title;
private String path;
private int owner;
private String permission;
@Column(name="add_date")
@JsonProperty("add_date")
private Date addDate;
@Column(name="edit_date")
@JsonProperty("edit_date")
private Date editDate;
private int grade;
@Column(name="status")
private String status;
@ManyToOne
@JoinColumn(name="group_id",referencedColumnName="id")
private StudyGroup group;
@OneToMany(fetch = FetchType.LAZY, mappedBy = "material", cascade = CascadeType.ALL)
private List<UserActivity> activity = new ArrayList<>();
}

View File

@ -0,0 +1,50 @@
package studycave.studycaverestservice.model.studyGroup;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import studycave.studycaverestservice.model.studyGroupMember.StudyGroupMember;
import studycave.studycaverestservice.model.test.Test;
import studycave.studycaverestservice.model.userActivity.UserActivity;
import studycave.studycaverestservice.model.material.Material;
import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;
@Entity
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class StudyGroup {
@Id
@Column(name = "id")
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private String description;
@Column(unique = true)
private String groupKey;
@OneToMany(mappedBy = "group", cascade = CascadeType.ALL)
List<StudyGroupMember> members = new ArrayList<>();
@OneToMany(mappedBy = "group", cascade = CascadeType.ALL)
List<StudyGroupMember> flashcardSets = new ArrayList<>();
@OneToMany(mappedBy = "group", cascade = CascadeType.ALL)
List<Material> materials = new ArrayList<>();
@OneToMany(mappedBy = "group", cascade = CascadeType.ALL)
List<Test> tests = new ArrayList<>();
@OneToMany(mappedBy = "group", cascade = CascadeType.ALL)
private List<UserActivity> activity = new ArrayList<>();
}

View File

@ -0,0 +1,34 @@
package studycave.studycaverestservice.model.studyGroupMember;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import studycave.studycaverestservice.model.studyGroup.StudyGroup;
import studycave.studycaverestservice.model.user.User;
import javax.persistence.*;
@Entity
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class StudyGroupMember {
@Id
@Column(name="id")
@GeneratedValue(strategy= GenerationType.IDENTITY)
private Long id;
@ManyToOne
@JoinColumn(name="group_id",referencedColumnName="id")
private StudyGroup group;
@ManyToOne
@JoinColumn(name="user_id",referencedColumnName="id")
private User user;
@Column(name="is_group_leader")
private Boolean isGroupLeader;
}

View File

@ -0,0 +1,18 @@
package studycave.studycaverestservice.model.studyGroupMember;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
public interface StudyGroupMemberRepository extends JpaRepository<StudyGroupMember, Long> {
@Query("select t from StudyGroupMember t where t.user.id = :i")
List<StudyGroupMember> findByMember(@Param("i") Long i);
@Query("select t from StudyGroupMember t where (t.group.id = :g and t.user.id = :u)")
StudyGroupMember findUserInGroup(@Param("g") Long g, @Param("u") Long u);
}

View File

@ -0,0 +1,60 @@
package studycave.studycaverestservice.model.test;
import com.fasterxml.jackson.annotation.JsonManagedReference;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import studycave.studycaverestservice.model.studyGroup.StudyGroup;
import studycave.studycaverestservice.model.userActivity.UserActivity;
import javax.persistence.*;
import java.sql.Date;
import java.util.ArrayList;
import java.util.List;
@Entity
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class Test {
@Id
@GeneratedValue(strategy= GenerationType.IDENTITY)
private Long id;
private String title;
@Column(name="id_owner")
@JsonProperty("owner")
private Long idOwner;
@Column(name="add_date")
@JsonProperty("add_date")
private Date addDate;
@Column(name="edit_date")
@JsonProperty("edit_date")
private Date editDate;
@Column(name="status")
private String status;
private String permission;
private int grade;
/*
@JsonProperty("body")
@OneToMany(fetch = FetchType.LAZY,mappedBy="test",cascade = CascadeType.ALL)
@JsonManagedReference
List<Question> questions = new ArrayList<>();
*/
@ManyToOne
@JoinColumn(name="group_id",referencedColumnName="id")
private StudyGroup group;
@OneToMany(fetch = FetchType.LAZY, mappedBy = "test", cascade = CascadeType.ALL)
private List<UserActivity> activity;
}

View File

@ -1,12 +1,16 @@
package studycave.studycaverestservice.model;
package studycave.studycaverestservice.model.user;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import studycave.studycaverestservice.model.studyGroupMember.StudyGroupMember;
import studycave.studycaverestservice.model.userActivity.UserActivity;
import studycave.studycaverestservice.model.userBadge.UserBadge;
import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;
@Entity
@Getter
@ -31,8 +35,8 @@ public class User {
@Column(unique=true)
private String email;
/*
@OneToMany(fetch = FetchType.LAZY,mappedBy="user",cascade = CascadeType.ALL)
@OneToMany(mappedBy="user",cascade = CascadeType.ALL)
List<StudyGroupMember> groupMembers = new ArrayList<>();
@OneToMany(mappedBy = "toUser", cascade = CascadeType.ALL)
@ -41,7 +45,7 @@ public class User {
@OneToMany(mappedBy = "fromUser", cascade = CascadeType.ALL)
private List<UserActivity> activityFrom;
@OneToMany(fetch = FetchType.LAZY, mappedBy = "user", cascade = CascadeType.ALL)
List<UserBadge> badges = new ArrayList<>();*/
@OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
List<UserBadge> badges = new ArrayList<>();
}

View File

@ -0,0 +1,10 @@
package studycave.studycaverestservice.model.user;
import java.util.Optional;
import org.springframework.data.jpa.repository.JpaRepository;
public interface UserRepository extends JpaRepository<User, Long> {
Optional<User> findByUsername(String username);
Optional<User> findByEmail(String email);
}

View File

@ -0,0 +1,26 @@
package studycave.studycaverestservice.model.user.dto;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class UserDTO {
private Long id;
private String name;
private String surname;
private String username;
private String password;
private String email;
}

View File

@ -0,0 +1,17 @@
package studycave.studycaverestservice.model.user.dto;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class UserLoginDTO {
private String username;
private String password;
}

View File

@ -0,0 +1,20 @@
package studycave.studycaverestservice.model.user.dto;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class UserRegisterDTO {
private String username;
private String password;
private String email;
private String name;
private String surname;
}

View File

@ -0,0 +1,51 @@
package studycave.studycaverestservice.model.userActivity;
import studycave.studycaverestservice.model.flashcardset.Set;
import studycave.studycaverestservice.model.material.Material;
import studycave.studycaverestservice.model.studyGroup.StudyGroup;
import studycave.studycaverestservice.model.test.Test;
import studycave.studycaverestservice.model.user.User;
import javax.persistence.*;
import java.sql.Timestamp;
@Entity
public class UserActivity {
@Id
@Column(name="id")
@GeneratedValue(strategy= GenerationType.IDENTITY)
private Long id;
private String type;
private int points;
private String comment;
private Timestamp date;
@ManyToOne
@JoinColumn(name="group_id",referencedColumnName="id")
private StudyGroup group;
@ManyToOne
@JoinColumn(name = "material_id")
private Material material;
@ManyToOne
@JoinColumn(name = "set_id")
private Set set;
@ManyToOne
@JoinColumn(name = "test_id")
private Test test;
@ManyToOne
@JoinColumn(name = "toUser_id")
private User toUser;
@ManyToOne
@JoinColumn(name = "fromUser_id")
private User fromUser;
}

View File

@ -0,0 +1,30 @@
package studycave.studycaverestservice.model.userBadge;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import studycave.studycaverestservice.model.badge.Badge;
import studycave.studycaverestservice.model.user.User;
import javax.persistence.*;
@Entity
@Setter
@Getter
@AllArgsConstructor
@NoArgsConstructor
public class UserBadge {
@Id
@Column(name="id")
@GeneratedValue(strategy= GenerationType.IDENTITY)
private Long id;
@ManyToOne
@JoinColumn(name="badge_id",referencedColumnName="id")
private Badge badge;
@ManyToOne
@JoinColumn(name="user_id",referencedColumnName="id")
private User user;
}

View File

@ -0,0 +1,13 @@
package studycave.studycaverestservice.model.userBadge;
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 UserBadgeRepository extends JpaRepository<UserBadge, Long> {
@Query("select ub from UserBadge ub where (ub.badge.id = :b and ub.user.id = :u )")
List<UserBadge> findByIdAndUser(@Param("b") Long b, @Param("u") Long u);
}

View File

@ -0,0 +1,18 @@
package studycave.studycaverestservice.model.userBadge.dto;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
public class UserBadgeDTO {
private String icon;
private String badgeName;
private Boolean unlocked;
}

View File

@ -41,8 +41,8 @@ public class JWTAuthenticationFilter extends UsernamePasswordAuthenticationFilte
public Authentication attemptAuthentication(HttpServletRequest req,
HttpServletResponse res) throws AuthenticationException {
try {
studycave.studycaverestservice.model.User creds = new ObjectMapper()
.readValue(req.getInputStream(), studycave.studycaverestservice.model.User.class);
studycave.studycaverestservice.model.user.User creds = new ObjectMapper()
.readValue(req.getInputStream(), studycave.studycaverestservice.model.user.User.class);
return authenticationManager.authenticate(
new UsernamePasswordAuthenticationToken(