Change project to quizAPI

*Add localhost documentation
*Add testing page
*Add ResponseBody

pom.xml

@@ -25,6 +25,16 @@
             <version>30.1-jre</version>
         </dependency>
 
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
+
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-thymeleaf</artifactId>
+        </dependency>
 
         <dependency>
             <groupId>org.springframework.boot</groupId>

src/main/java/me/widua/databaseauthorization/api/QuestionApi.java

@@ -2,84 +2,92 @@
 
 import me.widua.databaseauthorization.manager.QuestionManager;
 import me.widua.databaseauthorization.model.QuestionModel;
+import me.widua.databaseauthorization.model.ResponseBody;
 import org.springframework.context.support.DefaultMessageSourceResolvable;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.validation.Errors;
 import org.springframework.web.bind.annotation.*;
 
 import javax.validation.Valid;
 import java.util.List;
+import java.util.Locale;
 import java.util.stream.Collectors;
 
 @RestController
 @RequestMapping("/api/")
+@CrossOrigin
 public class QuestionApi {
 
     private final QuestionManager manager;
 
 
     public QuestionApi(QuestionManager manager){ this.manager = manager; }
 
-    @GetMapping("/{questionCollection}")
+    @GetMapping("/getCollection")
     @PreAuthorize("hasAuthority('question:read')")
-    public ResponseEntity<List<QuestionModel>> getQuestionsByCollection(@PathVariable String questionCollection){
+    public ResponseEntity<List<QuestionModel>> getQuestionsByCollection(@RequestBody String questionCollection){
         return ResponseEntity.ok(manager.findAllQuestionsByCollection(questionCollection));
     }
 
     @PostMapping("/add")
     @PreAuthorize("hasAuthority('question:write')")
-    public ResponseEntity<String> addQuestion(@Valid @RequestBody QuestionModel question, Errors errors){
+    public ResponseEntity<ResponseBody> addQuestion(@Valid @RequestBody QuestionModel question, Errors errors){
         if (errors.hasErrors()){
             List<String> errorMessages = errors.getAllErrors().stream()
                     .map(DefaultMessageSourceResolvable::getDefaultMessage)
                     .collect(Collectors.toList());
-            return ResponseEntity.ok(errorMessages.toString());
+            return ResponseEntity.ok(new ResponseBody(HttpStatus.BAD_REQUEST, errorMessages.toString()));
         } else {
+            if (manager.doesSameQuestionExist(question) ){
+                return ResponseEntity.badRequest().body(new ResponseBody(HttpStatus.BAD_REQUEST, "This question exist in that collection!")) ;
+            }
+            question.setCollectionName(question.getCollectionName().toLowerCase(Locale.ROOT));
             manager.addQuestion(question);
-            return ResponseEntity.ok("Question successfully add");
+            return ResponseEntity.ok(new ResponseBody(HttpStatus.OK, "Question successfully add" ));
         }
 
     }
 
     @DeleteMapping("/{questionID}/delete")
     @PreAuthorize("hasAuthority('question:write')")
-    public ResponseEntity<String> deleteQuestion(@PathVariable String questionID){
+    public ResponseEntity<ResponseBody> deleteQuestion(@PathVariable String questionID){
         if (manager.isQuestionExist(questionID)){
             manager.deleteQuestion(questionID);
-            return ResponseEntity.ok("Question successfully deleted");
+            return ResponseEntity.ok(new ResponseBody(HttpStatus.OK , "Question successfully deleted" ));
         } else {
-            return ResponseEntity.ok("Question does not exist");
+            return ResponseEntity.badRequest().body(new ResponseBody(HttpStatus.NOT_FOUND , "Question does not exist" ));
         }
     }
 
     @PutMapping("/{questionID}/change")
     @PreAuthorize("hasAuthority('question:write')")
-    public ResponseEntity<String> changeQuestion(@PathVariable String questionID, @Valid @RequestBody QuestionModel question, Errors errors){
+    public ResponseEntity<ResponseBody> changeQuestion(@PathVariable String questionID, @Valid @RequestBody QuestionModel question, Errors errors){
         if (errors.hasErrors()){
             List<String> errorMessages = errors.getAllErrors().stream()
                     .map(DefaultMessageSourceResolvable::getDefaultMessage)
                     .collect(Collectors.toList());
-            return ResponseEntity.ok(errorMessages.toString());
+            return ResponseEntity.badRequest().body(new ResponseBody(HttpStatus.BAD_REQUEST, errorMessages.toString() ));
         }
         if (manager.isQuestionExist(questionID)){
         manager.changeQuestion(questionID,question);
-            return ResponseEntity.ok("Question successfully changed!");
+            return ResponseEntity.ok(new ResponseBody(HttpStatus.OK , "Question successfully changed!" ));
         } else {
-            return ResponseEntity.ok("Question does not exist!");
+            return ResponseEntity.badRequest().body(new ResponseBody(HttpStatus.NOT_FOUND, "Question does not exist!"));
         }
     }
 
 
-    @GetMapping("/{questionCollection}/randomQuestion")
+    @GetMapping("/randomQuestion")
     @PreAuthorize("hasAuthority('question:read')")
-    public ResponseEntity<QuestionModel> getRandomQuestion(@PathVariable String questionCollection){
+    public ResponseEntity<ResponseBody> getRandomQuestion(){
 
-        QuestionModel question = manager.getRandomQuestion(questionCollection);
+        QuestionModel question = manager.getRandomQuestion();
         if (question!=null){
-            return ResponseEntity.ok(question);
+            return ResponseEntity.ok(new ResponseBody(HttpStatus.OK , "Question found" , question));
         } else {
-            return ResponseEntity.noContent().build();
+            return ResponseEntity.badRequest().body(new ResponseBody( HttpStatus.NOT_FOUND , "Question not found!" )) ;
         }
     }
 

src/main/java/me/widua/databaseauthorization/api/UserApi.java

@@ -1,10 +1,12 @@
 package me.widua.databaseauthorization.api;
 
 import me.widua.databaseauthorization.manager.UserManager;
+import me.widua.databaseauthorization.model.ResponseBody;
 import me.widua.databaseauthorization.model.UserModel;
 import me.widua.databaseauthorization.model.UserRegisterModel;
 import me.widua.databaseauthorization.roles.Roles;
 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.userdetails.UsernameNotFoundException;
@@ -14,10 +16,12 @@
 
 import javax.validation.Valid;
 
+import static me.widua.databaseauthorization.roles.Roles.ADMINISTRATOR;
 import static me.widua.databaseauthorization.roles.Roles.USER;
 
 @RestController
 @RequestMapping("/user/")
+@CrossOrigin
 public class UserApi {
 
     private final UserManager userManager ;
@@ -31,11 +35,11 @@ public UserApi(UserManager userManager, PasswordEncoder passwordEncoder){
 
     @PostMapping("/register")
     @PreAuthorize("permitAll()")
-    public ResponseEntity<String> registerUser(@RequestBody @Valid UserRegisterModel userRegisterModel, Errors errors){
+    public ResponseEntity<ResponseBody> registerUser(@RequestBody @Valid UserRegisterModel userRegisterModel, Errors errors){
 
 
         if (errors.hasErrors()){
-            return ResponseEntity.badRequest().body(errors.toString());
+            return ResponseEntity.badRequest().body(new ResponseBody(HttpStatus.BAD_REQUEST, errors.toString()));
         } else {
 
             if (userRegisterModel.getPassword().equals(userRegisterModel.getRetypedPassword())){
@@ -49,15 +53,20 @@ public ResponseEntity<String> registerUser(@RequestBody @Valid UserRegisterModel
                             true,
                             true);
 
-                    userManager.registerUser(userModel);
-                    ResponseEntity<String> response = ResponseEntity.ok("User register correctly!");
-                    return response ;
+                    if (userManager.doesAnyAccountExist()){
+                        userManager.registerUser(userModel);
+                    } else {
+                        userModel.setAuthorities(ADMINISTRATOR.getGrangedAuthorities());
+                        userManager.registerUser(userModel);
+                    }
+
+
+                    return ResponseEntity.status(HttpStatus.OK).body(new ResponseBody(HttpStatus.OK, "User Registred correctly!"));
                 } else {
-                    return ResponseEntity.ok("Username exist!");
+                    return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(new ResponseBody(HttpStatus.BAD_REQUEST , "Username exist in database!"));
                 }
             } else {
-                ResponseEntity<String> response = ResponseEntity.badRequest().body("Not the same password");
-                return response;
+                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(new ResponseBody(HttpStatus.BAD_REQUEST , "Passwords not same!"));
             }
 
 
@@ -67,41 +76,41 @@ public ResponseEntity<String> registerUser(@RequestBody @Valid UserRegisterModel
 
     @PutMapping("/{username}/promote")
     @PreAuthorize("hasAuthority('user:write')")
-    public ResponseEntity<String> promoteUser(@PathVariable(name = "username") String username, @RequestParam String roleName){
+    public ResponseEntity<ResponseBody> promoteUser(@PathVariable(name = "username") String username, @RequestParam String roleName){
         UserModel user = userManager.findUserByUsername(username)
                 .orElseThrow(() ->  new UsernameNotFoundException(String.format("User %s does not exist", username)));
 
         if( userManager.findRoleByName(roleName) == null ){
-            return ResponseEntity.badRequest().body(String.format("Role %s does not exist!",roleName));
+            return ResponseEntity.badRequest().body(new ResponseBody(HttpStatus.BAD_REQUEST , String.format("Role %s does not exist!",roleName )));
         } else {
             Roles role = userManager.findRoleByName(roleName);
             userManager.promoteUser(user, role );
-            return ResponseEntity.ok(String.format("%s successfully promoted!", username));
+            return ResponseEntity.ok( new ResponseBody(HttpStatus.OK , String.format("%s successfully promoted!", username) ));
         }
 
     }
 
     @DeleteMapping("/{username}/delete")
     @PreAuthorize("hasAuthority('user:write')")
-    public ResponseEntity<String> deleteUser(@PathVariable(name = "username") String username ){
+    public ResponseEntity<ResponseBody> deleteUser(@PathVariable(name = "username") String username ){
         if (!userManager.findUserByUsername(username).isPresent()){
-            return ResponseEntity.ok().body(String.format("User %s does not exist", username));
+            return ResponseEntity.ok().body(new ResponseBody( HttpStatus.OK , String.format("User %s does not exist", username)  ));
         } else {
             userManager.deleteUser(username);
-            return ResponseEntity.ok(String.format("User %s successfully deleted!", username));
+            return ResponseEntity.ok(new ResponseBody(HttpStatus.OK , String.format("User %s successfully deleted!", username)));
         }
     }
 
     @PutMapping("/{username}/passwordChg")
     @PreAuthorize("hasAuthority('user:write')")
-    public ResponseEntity<String> passwordChange( @PathVariable(name = "username") String username, @RequestBody String password ){
+    public ResponseEntity<ResponseBody> passwordChange( @PathVariable(name = "username") String username, @RequestBody String password ){
 
         if (userManager.findUserByUsername(username).isPresent()){
             UserModel user = userManager.findUserByUsername(username).get();
             userManager.changePassword(user,password);
-            return ResponseEntity.ok("Password successfully changed!");
+            return ResponseEntity.ok(new ResponseBody(HttpStatus.OK , "Password changed correctly"));
         } else {
-            return ResponseEntity.badRequest().body(String.format("User %s does not exist", username));
+            return ResponseEntity.badRequest().body(new ResponseBody(HttpStatus.BAD_REQUEST , String.format("User %s does not exist", username) ));
         }
 
     }

src/main/java/me/widua/databaseauthorization/configuration/SecurityConfiguration.java

@@ -11,6 +11,7 @@
 import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
 import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
 import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.web.header.writers.StaticHeadersWriter;
 
 @Configuration
 @EnableWebSecurity
@@ -30,6 +31,7 @@ public SecurityConfiguration(PasswordEncoder passwordEncoder, UserDetailsService
     protected void configure(HttpSecurity http) throws Exception {
         http
                 .csrf().disable()
+                .cors().disable()
                 .authorizeRequests().antMatchers("/**").permitAll()
                 .and()
                 .httpBasic();

src/main/java/me/widua/databaseauthorization/controler/WebsiteControler.java

@@ -0,0 +1,32 @@
+package me.widua.databaseauthorization.controler;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.CrossOrigin;
+import org.springframework.web.bind.annotation.GetMapping;
+
+@Controller
+@CrossOrigin
+// Jest to kontroler który zarządza stroną informacyjną o projekcie.
+public class WebsiteControler {
+
+
+    @GetMapping("/")
+    public String getHomePage(){
+        return "home";
+    }
+
+    @GetMapping("/documentation")
+    public String getDocumentation(){
+        return "documentation";
+    }
+
+    @GetMapping("/about")
+    public String getAbout(){
+        return "about";
+    }
+
+    @GetMapping("/test")
+    public String getTest(){
+        return "test";
+    }
+}

src/main/java/me/widua/databaseauthorization/manager/QuestionManager.java

@@ -41,8 +41,8 @@ public void changeQuestion(String id, QuestionModel question){
         repository.save(question);
     }
 
-    public QuestionModel getRandomQuestion(String questionCollection){
-        List<QuestionModel> questions = findAllQuestionsByCollection(questionCollection);
+    public QuestionModel getRandomQuestion(){
+        List<QuestionModel> questions = repository.findAll();
         if (!questions.isEmpty()){
             Random random = new Random();
             int questionNumber = random.nextInt(questions.size());
@@ -60,4 +60,15 @@ public boolean isQuestionExist(String id){
             return false;
         }
     }
+
+    public boolean doesSameQuestionExist(QuestionModel questionModel){
+        List<QuestionModel> questions = repository.getAllByQuestionContentAndCollectionName(questionModel.getQuestionContent(), questionModel.getCollectionName()) ;
+        if (questions.isEmpty()) {
+            return false;
+        } else {
+            return true ;
+        }
+
+    }
+
 }

src/main/java/me/widua/databaseauthorization/manager/UserManager.java

@@ -59,5 +59,13 @@ public Roles findRoleByName(String roleName){
         }
     }
 
+    public boolean doesAnyAccountExist(){
+        if (repository.findAll().isEmpty()){
+            return false;
+        } else {
+            return true;
+        }
+    }
+
 
 }

src/main/java/me/widua/databaseauthorization/model/ResponseBody.java

@@ -0,0 +1,44 @@
+package me.widua.databaseauthorization.model;
+
+import org.springframework.http.HttpStatus;
+
+public class ResponseBody {
+    private HttpStatus stauts ;
+    private String message ;
+    private Object optional ;
+
+    public ResponseBody(HttpStatus stauts, String message, Object optional) {
+        this.stauts = stauts;
+        this.message = message;
+        this.optional = optional;
+    }
+
+    public ResponseBody(HttpStatus stauts, String message) {
+        this.stauts = stauts;
+        this.message = message;
+    }
+
+    public HttpStatus getStauts() {
+        return stauts;
+    }
+
+    public void setStauts(HttpStatus stauts) {
+        this.stauts = stauts;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public Object getOptional() {
+        return optional;
+    }
+
+    public void setOptional(Object optional) {
+        this.optional = optional;
+    }
+}

src/main/java/me/widua/databaseauthorization/model/UserRegisterModel.java

@@ -1,10 +1,13 @@
 package me.widua.databaseauthorization.model;
 
 import javax.validation.constraints.Email;
+import javax.validation.constraints.NotEmpty;
 
 public class UserRegisterModel {
 
+    @NotEmpty(message = "Musi istnieć nazwa użytkownika")
     private String username;
+    @NotEmpty(message = "Hasło musi zostać podane")
     private String password;
     private String retypedPassword;