Merge branch 'main' of https://github.com/RIT-SWEN-261-02/team-project-2245-swen-261-02-2b-jellysolutions

3 files changed, 153 insertions, 76 deletions

diff --git a/ufund-api/src/main/java/com/ufund/api/ufundapi/controller/AuthController.java b/ufund-api/src/main/java/com/ufund/api/ufundapi/controller/AuthController.java
index b46d4ee..82b2c67 100644
--- a/ufund-api/src/main/java/com/ufund/api/ufundapi/controller/AuthController.java
+++ b/ufund-api/src/main/java/com/ufund/api/ufundapi/controller/AuthController.java
@@ -2,6 +2,8 @@ package com.ufund.api.ufundapi.controller;
 
 import java.io.IOException;
 import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
@@ -17,6 +19,7 @@ import com.ufund.api.ufundapi.service.AuthService;
 @RestController
 @RequestMapping("auth")
 public class AuthController {
+    private static final Logger LOG = Logger.getLogger(AuthController.class.getName());
     private final AuthService authService;
 
     public AuthController(AuthService authService) {
@@ -32,15 +35,18 @@ public class AuthController {
      */
     @PostMapping("")
     public ResponseEntity<String> login(@RequestBody Map<String, String> params) {
+        LOG.log(Level.INFO, "POST /auth body={0}", params);
         String username = params.get("username");
         String password = params.get("password");
         try {
             String key = authService.login(username, password);
             return new ResponseEntity<>(key, HttpStatus.OK);
-        } catch (IllegalAccessException e) {
-            return new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
+        } catch (IllegalAccessException ex) {
+            LOG.log(Level.WARNING, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.UNAUTHORIZED);
         } catch (IOException ex) {
-            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
+            LOG.log(Level.SEVERE, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }
 
@@ -52,11 +58,13 @@ public class AuthController {
      */
     @DeleteMapping("")
     public ResponseEntity<Object> logout(@RequestHeader("jelly-api-key") String key) {
+        LOG.log(Level.INFO, "DELETE /auth key={0}", key);
         try {
             authService.logout(key);
             return new ResponseEntity<>(HttpStatus.OK);
-        } catch (IOException e) {
-            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
+        } catch (IOException ex) {
+            LOG.log(Level.WARNING, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }
 }
diff --git a/ufund-api/src/main/java/com/ufund/api/ufundapi/controller/CupboardController.java b/ufund-api/src/main/java/com/ufund/api/ufundapi/controller/CupboardController.java
index 36ae341..12fb0a9 100644
--- a/ufund-api/src/main/java/com/ufund/api/ufundapi/controller/CupboardController.java
+++ b/ufund-api/src/main/java/com/ufund/api/ufundapi/controller/CupboardController.java
@@ -13,6 +13,7 @@ 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.RequestHeader;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
@@ -20,6 +21,7 @@ import org.springframework.web.bind.annotation.RestController;
 import com.ufund.api.ufundapi.DuplicateKeyException;
 import com.ufund.api.ufundapi.model.Need;
 import com.ufund.api.ufundapi.model.Need.GoalType;
+import com.ufund.api.ufundapi.service.AuthService;
 import com.ufund.api.ufundapi.service.CupboardService;
 
 @RestController
@@ -27,14 +29,16 @@ import com.ufund.api.ufundapi.service.CupboardService;
 public class CupboardController {
     private static final Logger LOG = Logger.getLogger(CupboardController.class.getName());
     private final CupboardService cupboardService;
+    private final AuthService authService;
 
     /**
      * Create a cupboard controller to receive REST signals
      *
      * @param cupboardService The Data Access Object
      */
-    public CupboardController(CupboardService cupboardService) {
+    public CupboardController(CupboardService cupboardService, AuthService authService) {
         this.cupboardService = cupboardService;
+        this.authService = authService;
     }
 
     /**
@@ -47,21 +51,33 @@ public class CupboardController {
      *         INTERNAL_SERVER_ERROR otherwise
      */
     @PostMapping("")
-    public ResponseEntity<Need> createNeed(@RequestBody Map<String, Object> params) {
-        System.out.println(params);
+    public ResponseEntity<Object> createNeed(@RequestBody Map<String, Object> params, @RequestHeader("jelly-api-key") String key) {
+        LOG.log(Level.INFO, "POST /cupboard body={0}", params);
+
         String name = (String) params.get("name");
-        double maxGoal = (double) params.get("maxGoal");
+        String image = (String) params.get("image");
+        String location = (String) params.get("location");
+        double maxGoal = ((Number) params.get("maxGoal")).doubleValue();
+        boolean urgent = (Boolean) params.get("urgent");
+        String description = (String) params.get("description");
         Need.GoalType goalType = GoalType.valueOf((String) params.get("type"));
 
         try {
-            Need need = cupboardService.createNeed(name, maxGoal, goalType);
+            authService.keyHasAccessToCupboard(key);
+            Need need = cupboardService.createNeed(name, image, location, maxGoal, goalType, urgent, description);
             return new ResponseEntity<>(need, HttpStatus.OK);
         } catch (DuplicateKeyException ex) {
-            return new ResponseEntity<>(HttpStatus.CONFLICT);
+            LOG.log(Level.WARNING, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.CONFLICT);
         } catch (IllegalArgumentException ex) {
-            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+            LOG.log(Level.WARNING, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.BAD_REQUEST);
+        } catch (IllegalAccessException ex) {
+            LOG.log(Level.WARNING, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.UNAUTHORIZED);
         } catch (IOException ex) {
-            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
+            LOG.log(Level.SEVERE, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }
 
@@ -74,39 +90,39 @@ public class CupboardController {
      *         ResponseEntity with HTTP status of INTERNAL_SERVER_ERROR otherwise
      */
     @GetMapping("")
-    public ResponseEntity<Need[]> getNeeds() {
-        LOG.info("GET /needs");
+    public ResponseEntity<Object> getNeeds() {
+        LOG.info("GET /cupboard");
 
         try {
             Need[] needs = cupboardService.getNeeds();
             return new ResponseEntity<>(needs, HttpStatus.OK);
-        } catch (IOException e) {
-            LOG.log(Level.SEVERE, e.getLocalizedMessage());
-            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
+        } catch (IOException ex) {
+            LOG.log(Level.SEVERE, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }
 
      /**
-     * Responds to the GET request for all {@linkplain Need need} whose name contains
-     * the text in name
-     * 
-     * @param name The name parameter which contains the text used to find the {@link Need need}
-     * 
-     * @return ResponseEntity with array of {@link Need need} objects (may be empty) and
-     * HTTP status of OK<br>
-     * ResponseEntity with HTTP status of INTERNAL_SERVER_ERROR otherwise
-     * <p>
-     */
+      * Responds to the GET request for all {@linkplain Need need} whose name contains
+      * the text in name
+      *
+      * @param name The name parameter which contains the text used to find the {@link Need need}
+      *
+      * @return ResponseEntity with array of {@link Need need} objects (may be empty) and
+      * HTTP status of OK<br>
+      * ResponseEntity with HTTP status of INTERNAL_SERVER_ERROR otherwise
+      * <p>
+      */
     @GetMapping("/")
-    public ResponseEntity<Need[]> searchNeeds(@RequestParam String name) {
-        LOG.info("GET /need/?name="+name);
+    public ResponseEntity<Object> searchNeeds(@RequestParam String name) {
+        LOG.info("GET /cupboard/?name="+name);
 
         try {
             Need[] needs = cupboardService.searchNeeds(name);
             return new ResponseEntity<>(needs, HttpStatus.OK);
-        } catch (IOException e) {
-            LOG.log(Level.SEVERE,e.getLocalizedMessage());
-            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
+        } catch (IOException ex) {
+            LOG.log(Level.SEVERE,ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }
 
@@ -119,8 +135,8 @@ public class CupboardController {
      *         ResponseEntity with HTTP status of NOT_FOUND if not found<br>
      */
     @GetMapping("/{id}")
-    public ResponseEntity<Need> getNeed(@PathVariable int id) {
-        LOG.log(Level.INFO, "GET /need/{0}", id);
+    public ResponseEntity<Object> getNeed(@PathVariable int id) {
+        LOG.log(Level.INFO, "GET /cupboard/{0}", id);
 
         try {
             Need need = cupboardService.getNeed(id);
@@ -129,9 +145,9 @@ public class CupboardController {
             } else {
                 return new ResponseEntity<>(HttpStatus.NOT_FOUND);
             }
-        } catch (IOException e) {
-            LOG.log(Level.SEVERE, e.getLocalizedMessage());
-            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
+        } catch (IOException ex) {
+            LOG.log(Level.SEVERE, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
         }
 
     }
@@ -143,9 +159,10 @@ public class CupboardController {
      * @return OK response and the need if it was successful, or INTERNAL_SERVER_ERROR if there was an issue
      */
     @PutMapping("/{id}")
-    public ResponseEntity<Need> updateNeed(@RequestBody Need need, @PathVariable int id) {
-        LOG.log(Level.INFO, "Updating need: " + need);
+    public ResponseEntity<Object> updateNeed(@RequestBody Need need, @PathVariable int id, @RequestHeader("jelly-api-key") String key) {
+        LOG.log(Level.INFO, "PUT /cupboard/{0} body={1}", of(id, need));
         try {
+            authService.keyHasAccessToCupboard(key);
             Need updatedNeed = cupboardService.updateNeed(need, id);
             if (updatedNeed != null) {
                 return new ResponseEntity<>(need, HttpStatus.OK);
@@ -153,11 +170,41 @@ public class CupboardController {
                 return new ResponseEntity<>(HttpStatus.NOT_FOUND);
             }
         } catch (IllegalArgumentException ex) {
-            ex.printStackTrace();
-            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+            LOG.log(Level.WARNING, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.BAD_REQUEST);
+        } catch (IllegalAccessException ex) {
+            LOG.log(Level.WARNING, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.UNAUTHORIZED);
+        } catch (IOException ex) {
+            LOG.log(Level.SEVERE, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    /**
+     * Checks out a need by checkoutAmount
+     *
+     * @param data JSON object with parameters needID and amount
+     * @param key  Key used to authenticate user
+     * @return OK if successful, other statuses if failure
+     */
+    @PutMapping("/checkout")
+    public ResponseEntity<Object> checkoutNeeds(@RequestBody Map<String, Integer> data, @RequestHeader("jelly-api-key") String key) {
+        int needID = data.get("needID");
+        int checkoutAmount = data.get("amount");
+        LOG.log(Level.INFO, "PUT /need/checkout body={0}", data);
+        try {
+            cupboardService.checkoutNeed(needID, checkoutAmount, key);
+            return new ResponseEntity<>(HttpStatus.OK);
+        } catch (IllegalArgumentException ex) {
+            LOG.log(Level.WARNING, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.BAD_REQUEST);
+        } catch (IllegalAccessException ex) {
+            LOG.log(Level.WARNING, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.UNAUTHORIZED);
         } catch (IOException ex) {
-            ex.printStackTrace();
-            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
+            LOG.log(Level.SEVERE, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }
 
@@ -168,17 +215,27 @@ public class CupboardController {
      * @return OK if the need was deleted, NOT_FOUND if the need was not found, or INTERNAL_SERVER_ERROR if an error occurred
     */
     @DeleteMapping("/{id}")
-    public ResponseEntity<Need> deleteNeed(@PathVariable int id) {
+    public ResponseEntity<Object> deleteNeed(@PathVariable int id, @RequestHeader("jelly-api-key") String key) {
+        LOG.log(Level.INFO, "DELETE /cupboard/{0}", id);
         try {
+            authService.keyHasAccessToCupboard(key);
             Need need = cupboardService.getNeed(id);
             if (cupboardService.deleteNeed(id)) {
                 return new ResponseEntity<>(need, HttpStatus.OK);
             } else {
                 return new ResponseEntity<>(HttpStatus.NOT_FOUND);
-            } 
-        } catch (IOException e) {
-            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
+            }
+        } catch (IllegalAccessException ex) {
+            LOG.log(Level.WARNING, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.UNAUTHORIZED);
+        } catch (IOException ex) {
+            LOG.log(Level.SEVERE, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }
 
+    private Object[] of(Object ...params) {
+        return params;
+    }
+
 }
diff --git a/ufund-api/src/main/java/com/ufund/api/ufundapi/controller/UserController.java b/ufund-api/src/main/java/com/ufund/api/ufundapi/controller/UserController.java
index dfaad3a..a34e891 100644
--- a/ufund-api/src/main/java/com/ufund/api/ufundapi/controller/UserController.java
+++ b/ufund-api/src/main/java/com/ufund/api/ufundapi/controller/UserController.java
@@ -1,7 +1,6 @@
 package com.ufund.api.ufundapi.controller;
 
 import java.io.IOException;
-import java.security.InvalidParameterException;
 import java.util.Map;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -42,7 +41,8 @@ public class UserController {
      *         otherwise
      */
     @PostMapping("")
-    public ResponseEntity<User> createUser(@RequestBody Map<String, String> params) {
+    public ResponseEntity<Object> createUser(@RequestBody Map<String, String> params) {
+        LOG.log(Level.INFO, "POST /users body={0}", params);
         String username = params.get("username");
         String password = params.get("password");
 
@@ -54,9 +54,11 @@ public class UserController {
                 return new ResponseEntity<>(HttpStatus.CONFLICT);
             }
         } catch (DuplicateKeyException ex) {
-            return new ResponseEntity<>(HttpStatus.CONFLICT);
+            LOG.log(Level.WARNING, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.CONFLICT);
         } catch (IOException ex) {
-            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
+            LOG.log(Level.SEVERE, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }
 
@@ -71,11 +73,11 @@ public class UserController {
      *         ResponseEntity with HTTP status of INTERNAL_SERVER_ERROR otherwise
      */
     @GetMapping("/{username}")
-    public ResponseEntity<User> getUser(@PathVariable String username, @RequestHeader("jelly-api-key") String key) {
-        LOG.log(Level.INFO, "GET /user/{0}", username);
+    public ResponseEntity<Object> getUser(@PathVariable String username, @RequestHeader("jelly-api-key") String key) {
+        LOG.log(Level.INFO, "GET /user/{0} key={1}", of(username, key));
 
         try {
-            authService.authenticate(username, key);
+            authService.keyHasAccessToUser(username, key);
             User user = userService.getUser(username);
             if (user != null) {
                 return new ResponseEntity<>(user.withoutPasswordHash(), HttpStatus.OK);
@@ -83,10 +85,11 @@ public class UserController {
                 return new ResponseEntity<>(HttpStatus.NOT_FOUND);
             }
         } catch (IllegalAccessException ex) {
-            return new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
-        } catch (IOException e) {
-            LOG.log(Level.SEVERE, e.getLocalizedMessage());
-            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
+            LOG.log(Level.WARNING, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.UNAUTHORIZED);
+        } catch (IOException ex) {
+            LOG.log(Level.SEVERE, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
         }
 
     }
@@ -101,24 +104,26 @@ public class UserController {
      *         INTERNAL_SERVER_ERROR if there was an issue
      */
     @PutMapping("/{username}")
-    public ResponseEntity<User> updateUser(@RequestBody User user, @PathVariable String username, @RequestHeader("jelly-api-key") String key) {
-        LOG.log(Level.INFO,"PUT: " + user + " " + username + " " + key.toString());
+    public ResponseEntity<Object> updateUser(@RequestBody User user, @PathVariable String username, @RequestHeader("jelly-api-key") String key) {
+        LOG.log(Level.INFO,"PUT /users/{0} body={1} key={2}", of(username, user, key));
         try {
-            //authService.authenticate(username, key);
+            authService.keyHasAccessToUser(username, key);
             user = userService.updateUser(user, username);
             if (user != null) {
                 return new ResponseEntity<>(user, HttpStatus.OK);
             } else {
                 return new ResponseEntity<>(HttpStatus.NOT_FOUND);
             }
-        } catch (InvalidParameterException ex) {
-            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
-        } catch (IOException e) {
-            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
-        } 
-        // catch (IllegalAccessException e) {
-        //     return new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
-        // }
+        } catch (IllegalArgumentException ex) {
+            LOG.log(Level.WARNING, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.BAD_REQUEST);
+        } catch (IllegalAccessException ex) {
+            LOG.log(Level.WARNING, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.UNAUTHORIZED);
+        } catch (IOException ex) {
+            LOG.log(Level.SEVERE, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
+        }
     }
 
     /**
@@ -130,20 +135,27 @@ public class UserController {
      *         INTERNAL_SERVER_ERROR if an error occurred
      */
     @DeleteMapping("/{username}")
-    public ResponseEntity<Boolean> deleteUser(@PathVariable String username, @RequestHeader("jelly-api-key") String key) {
+    public ResponseEntity<Object> deleteUser(@PathVariable String username, @RequestHeader("jelly-api-key") String key) {
+        LOG.log(Level.INFO, "DELETE /users/{0} id={1}", of(username, key));
 
         try {
-            authService.authenticate(username, key);
+            authService.keyHasAccessToUser(username, key);
             if (userService.deleteUser(username)) {
                 return new ResponseEntity<>(HttpStatus.OK);
             } else {
                 return new ResponseEntity<>(HttpStatus.NOT_FOUND);
             }
-        } catch (IOException e) {
-            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
-        } catch (IllegalAccessException e) {
-            return new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
+        } catch (IllegalAccessException ex) {
+            LOG.log(Level.WARNING, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.UNAUTHORIZED);
+        } catch (IOException ex) {
+            LOG.log(Level.SEVERE, ex.getLocalizedMessage());
+            return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }
 
+    private Object[] of(Object ...params) {
+        return params;
+    }
+
 }