Add the basis for transactions

pom.xml

@@ -28,6 +28,22 @@
             <artifactId>json-path</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.rest-assured</groupId>
+            <artifactId>rest-assured</artifactId>
+            <version>3.0.7</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <properties>

src/main/java/Application.java

@@ -1,9 +1,10 @@
 import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.context.annotation.ComponentScan;
 
 @SpringBootApplication
-@ComponentScan(basePackages = {"hello", "transactions"})
+@ComponentScan(basePackages = {"transactions", "sessions", "categories"})
 public class Application {
 
     public static void main(String[] args) {

src/main/java/WebConfiguration.java

@@ -0,0 +1,16 @@
+import org.apache.catalina.servlets.WebdavServlet;
+import org.springframework.boot.web.servlet.ServletRegistrationBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+import java.sql.SQLException;
+
+@Configuration
+@ComponentScan
+public class WebConfiguration {
+    @Bean(initMethod="start",destroyMethod="stop")
+    public org.h2.tools.Server h2WebConsonleServer () throws SQLException {
+        return org.h2.tools.Server.createWebServer("-web", "-webAllowOthers", "-webDaemon", "-webPort", "8082");
+    }
+}

src/main/java/categories/CategoryController.java

@@ -0,0 +1,39 @@
+package categories;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.*;
+import sessions.SessionController;
+
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/v0")
+public class CategoryController {
+
+    @PostMapping("/{sessionId}/categories")
+    @ResponseStatus(HttpStatus.CREATED)
+    public Category postCategory(@PathVariable Integer sessionId, @RequestBody Category category) {
+        int id = SessionController.counter.incrementAndGet();
+        category.setId(id);
+        SessionController.sessions.get(sessionId).getCategories().put(id, category);
+        return category;
+    }
+
+    @GetMapping("/{sessionId}/categories")
+    public Map getCategories(@PathVariable Integer sessionId) {
+        return SessionController.sessions.get(sessionId).getCategories();
+    }
+
+    @GetMapping("/{sessionId}/categories/{categoryId}")
+    public Category getCategory(@PathVariable Integer sessionId, @PathVariable Integer categoryId) {
+        return SessionController.sessions.get(sessionId).getCategories().get(categoryId);
+    }
+
+    @PutMapping("/{sessionId}/categories/{categoryId}")
+    public Category updateCategory(@PathVariable Integer sessionId, @PathVariable Integer categoryId,
+                                   @RequestBody Category category) {
+        category.setId(categoryId);
+        SessionController.sessions.get(sessionId).getCategories().put(categoryId, category);
+        return category;
+    }
+}

src/main/java/sessions/Session.java

@@ -0,0 +1,28 @@
+package sessions;
+
+import categories.Category;
+import transactions.Transaction;
+
+import java.util.LinkedHashMap;
+
+public class Session {
+    private final int sessionId;
+    private LinkedHashMap<Integer, Transaction> transactions = new LinkedHashMap<>();
+    private LinkedHashMap<Integer, Category> categories = new LinkedHashMap<>();
+
+    public Session(int sessionId) {
+        this.sessionId = sessionId;
+    }
+
+    public int getSessionId() {
+        return sessionId;
+    }
+
+    public LinkedHashMap<Integer, Transaction> getTransactions() {
+        return transactions;
+    }
+
+    public LinkedHashMap<Integer, Category> getCategories() {
+        return categories;
+    }
+}

src/main/java/sessions/SessionController.java

@@ -0,0 +1,32 @@
+package sessions;
+
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+@RestController
+@RequestMapping("/api/v0")
+public class SessionController {
+    public static final AtomicInteger counter = new AtomicInteger();
+    public static LinkedHashMap<Integer, Session> sessions =
+            new LinkedHashMap<>();
+
+    @RequestMapping("/sessions")
+    public Map newSession() {
+        int sessionId = counter.incrementAndGet();
+        Session newSession = new Session(sessionId);
+        sessions.put(sessionId, newSession);
+        Map response = new HashMap();
+        response.put("sessionID",sessionId);
+        return response;
+    }
+
+    @RequestMapping("/debug")
+    public Object debugInfo(){
+        return sessions;
+    }
+}

src/main/java/transactions/TransactionController.java

@@ -1,88 +1,80 @@
 package transactions;
 
 import categories.Category;
-import hello.Greeting;
 import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
-import org.springframework.web.servlet.view.RedirectView;
-import users.User;
+import sessions.Session;
+import sessions.SessionController;
 
-import javax.validation.constraints.Min;
 import java.util.*;
-import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
 @RestController
 @RequestMapping("/api/v0")
 public class TransactionController {
-    private final AtomicInteger counter = new AtomicInteger();
-    private LinkedHashMap<Integer, User> users =
-            new LinkedHashMap<Integer, User>();
 
-    @RequestMapping("/")
-    @ResponseStatus(HttpStatus.TEMPORARY_REDIRECT)
-    public RedirectView newUser(){
-        int userId = counter.incrementAndGet();
-        User newUser = new User(userId);
-        users.put(userId, newUser);
-        //TODO fix redirecting
-        //return newUser;
-        return new RedirectView("/api/v0/" + userId + "/transactions");
-    }
-
-    @RequestMapping("/debug")
-    public Object debugInfo(){
-        return users;
-    }
-
-    @PostMapping("/{userId}/transactions")
+    @PostMapping("/{sessionId}/transactions")
     @ResponseStatus(HttpStatus.CREATED)
-    public Transaction postTransaction(@PathVariable Integer userId, @RequestBody Transaction transaction) {
-        int id = counter.incrementAndGet();
+    public Transaction postTransaction(@PathVariable Integer sessionId, @RequestBody Transaction transaction) {
+        int id = SessionController.counter.incrementAndGet();
         transaction.setId(id);
-        users.get(userId).getTransactions().put(id,transaction);
+        SessionController.sessions.get(sessionId).getTransactions().put(id,transaction);
         return transaction;
     }
 
-    @GetMapping("/{userId}/transactions")
-    public Map getTransactions(@PathVariable Integer userId, @RequestParam(defaultValue = "0") Integer offset,
+    @GetMapping("/{sessionId}/transactions")
+    public Map getTransactions(@PathVariable Integer sessionId, @RequestParam(defaultValue = "0") Integer offset,
                                 @RequestParam(defaultValue = "20") Integer limit) {
-        LinkedHashMap<Integer, Transaction> transactionMap = users.get(userId).getTransactions();
+        LinkedHashMap<Integer, Transaction> transactionMap = SessionController.sessions.get(sessionId).getTransactions();
         SortedSet<Integer> transactionList = new TreeSet<Integer>(transactionMap.keySet());
         SortedSet<Integer> keys = transactionList.subSet(Math.min(offset+2, transactionList.size()-1),
                 Math.min(offset+limit+2, transactionList.size()+2));
         //Return 'submap' with the keys from the subset
         return keys.stream().collect(Collectors.toMap(Function.identity(), transactionMap::get));
     }
 
-    @GetMapping(value = "/{userId}/transactions", params = "category")
-    public Map getTransactionsCategory(@PathVariable Integer userId, @RequestParam Integer category) {
-        LinkedHashMap<Integer, Transaction> resultMap = new LinkedHashMap<Integer, Transaction>();
-        LinkedHashMap<Integer, Transaction> transactionMap = users.get(userId).getTransactions();
+    @GetMapping(value = "/{sessionId}/transactions", params = "category")
+    public Map getTransactionsCategory(@PathVariable Integer sessionId, @RequestParam Integer category) {
+        LinkedHashMap<Integer, Transaction> resultMap = new LinkedHashMap<>();
+        LinkedHashMap<Integer, Transaction> transactionMap = SessionController.sessions.get(sessionId).getTransactions();
         for (Transaction transaction : transactionMap.values()) {
-            if(transaction.getCategory().getId()==category) {
-                resultMap.put(transaction.getId(), transaction);
+            if (transaction.getCategory()!=null) {
+                if (transaction.getCategory().getId() == category) {
+                    resultMap.put(transaction.getId(), transaction);
+                }
             }
         }
         return resultMap;
     }
 
-    @GetMapping("/{userId}/transactions/{transactionId}")
-    public Transaction getTransaction(@PathVariable Integer userId, @PathVariable Integer transactionId){
-        return users.get(userId).getTransactions().get(transactionId);
+    @GetMapping("/{sessionId}/transactions/{transactionId}")
+    public Transaction getTransaction(@PathVariable Integer sessionId, @PathVariable Integer transactionId) {
+        return SessionController.sessions.get(sessionId).getTransactions().get(transactionId);
     }
 
-    @DeleteMapping("/{userId}/transactions/{transactionId}")
-    public void deleteTransaction(@PathVariable Integer userId, @PathVariable Integer transactionId) {
-        users.get(userId).getTransactions().remove(transactionId);
+    @DeleteMapping("/{sessionId}/transactions/{transactionId}")
+    public void deleteTransaction(@PathVariable Integer sessionId, @PathVariable Integer transactionId) {
+        SessionController.sessions.get(sessionId).getTransactions().remove(transactionId);
+    }
+    @PatchMapping(value = "/{sessionId}/transactions/{transactionId}", params = "categoryId")
+    public ResponseEntity<Transaction> assignCategory(@PathVariable Integer sessionId, @PathVariable Integer transactionId,
+                                                      @RequestParam Integer categoryId) {
+        Transaction transaction = SessionController.sessions.get(sessionId).getTransactions().get(transactionId);
+        if (SessionController.sessions.get(sessionId).getCategories().containsKey(categoryId)) {
+            Category category = SessionController.sessions.get(sessionId).getCategories().get(categoryId);
+            transaction.setCategory(category);
+            return new ResponseEntity<>(transaction, HttpStatus.OK);
+        }
+        return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
     }
 
-    @PatchMapping("/{userId}/transactions/{transactionId}")
-    public Transaction assignCategory(@PathVariable Integer userId, @PathVariable Integer transactionId,
-                                      @RequestBody Category category) {
-        Transaction transaction = users.get(userId).getTransactions().get(transactionId);
-        transaction.setCategory(category);
+    @PutMapping("/{sessionId}/transactions/{transactionId}")
+    public Transaction updateTransaction(@PathVariable Integer sessionId, @PathVariable Integer transactionId,
+                                         @RequestBody Transaction transaction) {
+        transaction.setId(transactionId);
+        SessionController.sessions.get(sessionId).getTransactions().put(transactionId, transaction);
         return transaction;
     }
-}
+}