update database helper and transaction

src/main/java/database/DatabaseHelper.java

@@ -10,13 +10,25 @@ public class DatabaseHelper {
     private static final String DATABASE_PWD = "vHEQszGXcJ6;/)}z!V";
     private final static String DATABASE_URL = "jdbc:postgresql://37.187.101.44:5432/"+DATABASE_NAME;
 
+    private static JdbcConnectionSource jdbcConnectionSource;
 
     public ConnectionSource setupDatabaseConnection(){
         try{
-            return new JdbcConnectionSource(DATABASE_URL, DATABASE_USER, DATABASE_PWD);
+            jdbcConnectionSource = new JdbcConnectionSource(DATABASE_URL, DATABASE_USER, DATABASE_PWD);
+            return jdbcConnectionSource;
         }catch (Exception e){
             System.out.print("\n"+e.getMessage());
             return null;
         }
     }
+
+    public static void closeConnection(){
+        try{
+            jdbcConnectionSource.close();
+        } catch (Exception e){
+            e.printStackTrace();
+        }
+    }
+
+
 }

src/main/java/database/Wallet/WalletDao.java

@@ -6,10 +6,6 @@ import com.j256.ormlite.stmt.PreparedQuery;
 import com.j256.ormlite.stmt.QueryBuilder;
 import com.j256.ormlite.stmt.UpdateBuilder;
 import database.DatabaseHelper;
-import org.apache.log4j.BasicConfigurator;
-import org.apache.log4j.Logger;
-import restImplementation.WalletImplementation;
-
 import java.time.Instant;
 import java.util.List;
 
@@ -32,6 +28,7 @@ public class WalletDao {
     public void addWallet(Wallet wallet)throws Exception {
         createWalletDaoConnection();
         walletDao.create(wallet);
+        DatabaseHelper.closeConnection();
     }
 
     public Wallet getWallet(String walletHash) throws Exception {
@@ -39,7 +36,9 @@ public class WalletDao {
         QueryBuilder<Wallet, String> queryBuilder = walletDao.queryBuilder();
         queryBuilder.where().eq("wallet_hash",walletHash).and().eq("is_active",true);
         PreparedQuery<Wallet> preparedQuery = queryBuilder.prepare();
-        return walletDao.queryForFirst(preparedQuery);
+        Wallet w = walletDao.queryForFirst(preparedQuery);
+        DatabaseHelper.closeConnection();
+        return w;
     }
 
     public void updateWalletBalance(String walletHash, double newBalance) throws Exception {
@@ -50,6 +49,7 @@ public class WalletDao {
         updateBuilder.updateColumnValue("modification_date",now);
         updateBuilder.where().eq("wallet_hash",walletHash);
         updateBuilder.update();
+        DatabaseHelper.closeConnection();
     }
 
     public List<Wallet> getUserWallet(String userHash) throws Exception {
@@ -57,7 +57,9 @@ public class WalletDao {
         QueryBuilder<Wallet, String> queryBuilder = walletDao.queryBuilder();
         queryBuilder.where().eq("user_hash",userHash).and().eq("is_active",true);
         PreparedQuery<Wallet> preparedQuery = queryBuilder.prepare();
-        return walletDao.query(preparedQuery);
+        List<Wallet> w = walletDao.query(preparedQuery);
+        DatabaseHelper.closeConnection();
+        return w;
     }
 
     public List<Wallet> getUserOldWallets(String userHash) throws Exception{
@@ -65,7 +67,9 @@ public class WalletDao {
         QueryBuilder<Wallet, String> queryBuilder = walletDao.queryBuilder();
         queryBuilder.where().eq("user_hash",userHash).and().eq("is_active",false);
         PreparedQuery<Wallet> preparedQuery = queryBuilder.prepare();
-        return walletDao.query(preparedQuery);
+        List<Wallet> w = walletDao.query(preparedQuery);
+        DatabaseHelper.closeConnection();
+        return w;
     }
 
     public void transferWallet(String walletHash, String newUserHash) throws Exception{
@@ -76,6 +80,7 @@ public class WalletDao {
         updateBuilder.updateColumnValue("modification_date",now);
         updateBuilder.where().eq("wallet_hash",walletHash).and().eq("is_active",true);
         updateBuilder.update();
+        DatabaseHelper.closeConnection();
     }
 
     public void deleteWallet(String walletHash, String userHash) throws Exception{
@@ -86,6 +91,7 @@ public class WalletDao {
         updateBuilder.updateColumnValue("modification_date",now);
         updateBuilder.where().eq("wallet_hash",walletHash).and().eq("user_hash",userHash);
         updateBuilder.update();
+        DatabaseHelper.closeConnection();
     }
 
 }

src/main/java/database/session/SessionDao.java

@@ -25,7 +25,9 @@ public class SessionDao {
     public int setStartSession(Session session) throws Exception {
         createSessionDaoConnection();
         sessionDao.create(session);
-        return session.getSession_id();
+        int Session_id = session.getSession_id();
+        DatabaseHelper.closeConnection();
+        return Session_id;
     }
 
     public void setEndSession(int session_id) throws Exception {
@@ -35,5 +37,6 @@ public class SessionDao {
         updateBuilder.updateColumnValue("end_session",now);
         updateBuilder.where().eq("session_id",session_id);
         updateBuilder.update();
+        DatabaseHelper.closeConnection();
     }
 }

src/main/java/database/transaction/TransactionDao.java

@@ -5,7 +5,7 @@ import com.j256.ormlite.dao.DaoManager;
 import com.j256.ormlite.stmt.PreparedQuery;
 import com.j256.ormlite.stmt.QueryBuilder;
 import database.DatabaseHelper;
-
+import java.math.BigInteger;
 import java.util.List;
 
 public class TransactionDao {
@@ -26,16 +26,23 @@ public class TransactionDao {
     public void addTransaction(Transaction transaction)throws Exception{
         createTransactionDaoConnection();
         transactionDao.create(transaction);
+        DatabaseHelper.closeConnection();
     }
 
-    public List<Transaction> getWalletTransactions(String wallet_hash)throws Exception{
+    public List<Transaction> getWalletTransactions(String wallet_hash, int size)throws Exception{
         createTransactionDaoConnection();
         QueryBuilder<Transaction, String> queryBuilder = transactionDao.queryBuilder();
         queryBuilder.where().eq("transaction_from",wallet_hash).or().eq("transaction_to",wallet_hash);
-        queryBuilder.limit(new Long(10));
+
+        if(size!=0){
+            queryBuilder.limit(new Long(size));
+        }
+
         queryBuilder.orderBy("transaction_date",false);
         PreparedQuery<Transaction> preparedQuery = queryBuilder.prepare();
-        return transactionDao.query(preparedQuery);
+        List<Transaction> t = transactionDao.query(preparedQuery);
+        DatabaseHelper.closeConnection();
+        return t;
     }
 
     public Transaction getTransaction(String wallet_hash, String transaction_hash)throws Exception{
@@ -43,25 +50,91 @@ public class TransactionDao {
         QueryBuilder<Transaction, String> queryBuilder = transactionDao.queryBuilder();
         queryBuilder.where().eq("transaction_to",wallet_hash).or().eq("transaction_from",wallet_hash).and().eq("transaction_hash",transaction_hash);
         PreparedQuery<Transaction> preparedQuery = queryBuilder.prepare();
-        return transactionDao.queryForFirst(preparedQuery);
+        Transaction t = transactionDao.queryForFirst(preparedQuery);
+        DatabaseHelper.closeConnection();
+        return t;
     }
 
-    public List<Transaction> getUserSentTransaction(String wallet_hash)throws Exception{
+    public List<Transaction> getSentTransactions(String wallet_hash, int number)throws Exception{
         createTransactionDaoConnection();
         QueryBuilder<Transaction, String> queryBuilder = transactionDao.queryBuilder();
         queryBuilder.where().eq("transaction_from",wallet_hash);
-        queryBuilder.orderBy("transaction_date",false);
+
-        PreparedQuery<Transaction> preparedQuery = queryBuilder.prepare();
+        if(number!=0){
-        return transactionDao.query(preparedQuery);
+            queryBuilder.limit(new Long(number));
         }
 
-    public List<Transaction> getUserReceivedTransaction(String wallet_hash)throws Exception{
+        queryBuilder.orderBy("transaction_date",false);
+        PreparedQuery<Transaction> preparedQuery = queryBuilder.prepare();
+        List<Transaction> t = transactionDao.query(preparedQuery);
+        DatabaseHelper.closeConnection();
+        return t;
+    }
+
+    public List<Transaction> getReceivedTransactions(String wallet_hash, int number)throws Exception{
         createTransactionDaoConnection();
         QueryBuilder<Transaction, String> queryBuilder = transactionDao.queryBuilder();
         queryBuilder.where().eq("transaction_to",wallet_hash);
-        queryBuilder.orderBy("transaction_date",false);
+
-        PreparedQuery<Transaction> preparedQuery = queryBuilder.prepare();
+        if(number!=0){
-        return transactionDao.query(preparedQuery);
+            queryBuilder.limit(new Long(number));
         }
 
+        queryBuilder.orderBy("transaction_date",false);
+        PreparedQuery<Transaction> preparedQuery = queryBuilder.prepare();
+        List<Transaction> t = transactionDao.query(preparedQuery);
+        DatabaseHelper.closeConnection();
+        return t;
+    }
+
+    public List<Transaction> getAllTransactionBetweenDate(String wallet_hash, String start, String end, int number) throws Exception{
+        createTransactionDaoConnection();
+        QueryBuilder<Transaction, String> queryBuilder = transactionDao.queryBuilder();
+        queryBuilder.where().eq("transaction_from",wallet_hash).or().eq("transaction_to",wallet_hash);
+        queryBuilder.where().between("transaction_date", new BigInteger(start), new BigInteger(end));
+
+        if(number!=0){
+            queryBuilder.limit(new Long(number));
+        }
+
+        queryBuilder.orderBy("transaction_date",false);
+        PreparedQuery<Transaction> preparedQuery = queryBuilder.prepare();
+        List<Transaction> t = transactionDao.query(preparedQuery);
+        DatabaseHelper.closeConnection();
+        return t;
+    }
+
+    public List<Transaction> getSentTransactionBetweenDate(String wallet_hash, String start, String end, int number) throws Exception{
+        createTransactionDaoConnection();
+        QueryBuilder<Transaction, String> queryBuilder = transactionDao.queryBuilder();
+        queryBuilder.where().eq("transaction_from",wallet_hash).and().between("transaction_date", new BigInteger(start), new BigInteger(end));
+
+        if(number!=0){
+            queryBuilder.limit(new Long(number));
+        }
+
+        queryBuilder.orderBy("transaction_date",false);
+        PreparedQuery<Transaction> preparedQuery = queryBuilder.prepare();
+        List<Transaction> t = transactionDao.query(preparedQuery);
+        DatabaseHelper.closeConnection();
+        return t;
+    }
+
+    public List<Transaction> getReceivedTransactionBetweenDate(String wallet_hash, String start, String end, int number) throws Exception{
+        createTransactionDaoConnection();
+        QueryBuilder<Transaction, String> queryBuilder = transactionDao.queryBuilder();
+        queryBuilder.where().eq("transaction_to",wallet_hash).and().between("transaction_date", new BigInteger(start), new BigInteger(end));
+
+        if(number!=0){
+            queryBuilder.limit(new Long(number));
+        }
+
+        queryBuilder.orderBy("transaction_date",false);
+        PreparedQuery<Transaction> preparedQuery = queryBuilder.prepare();
+        List<Transaction> t = transactionDao.query(preparedQuery);
+        DatabaseHelper.closeConnection();
+        return t;
+    }
+
+
 }

src/main/java/database/user/UserDao.java

@@ -28,6 +28,7 @@ public class UserDao {
     public void addUser(User user)throws Exception {
         createUserDaoConnection();
         userDao.create(user);
+        DatabaseHelper.closeConnection();
     }
 
     public boolean checkApprovedUser(String email) throws Exception {
@@ -36,6 +37,7 @@ public class UserDao {
         queryBuilder.where().eq("email",email);
         PreparedQuery<User> preparedQuery = queryBuilder.prepare();
         User user = userDao.queryForFirst(preparedQuery);
+        DatabaseHelper.closeConnection();
         return user.isApproved();
     }
 
@@ -45,6 +47,7 @@ public class UserDao {
         queryBuilder.where().eq("email",email);
         PreparedQuery<User> preparedQuery = queryBuilder.prepare();
         User user = userDao.queryForFirst(preparedQuery);
+        DatabaseHelper.closeConnection();
         return user.isVerified();
     }
 
@@ -56,10 +59,11 @@ public class UserDao {
         updateBuilder.updateColumnValue("modification_date",now);
         updateBuilder.where().eq("email",email);
         updateBuilder.update();
-
         if(checkUserPassword(email, password)){
+            DatabaseHelper.closeConnection();
             return true;
         }else{
+            DatabaseHelper.closeConnection();
             return false;
         }
     }
@@ -69,6 +73,7 @@ public class UserDao {
         DeleteBuilder<User, String> deleteBuilder = userDao.deleteBuilder();
         deleteBuilder.where().eq("email",email);
         deleteBuilder.delete();
+        DatabaseHelper.closeConnection();
     }
 
     public boolean verifyUserExist(String email) throws Exception {
@@ -77,7 +82,7 @@ public class UserDao {
         queryBuilder.where().eq("email",email);
         PreparedQuery<User> preparedQuery = queryBuilder.prepare();
         User user = userDao.queryForFirst(preparedQuery);
-
+        DatabaseHelper.closeConnection();
         if(user==null){
             return false;
         }else{
@@ -86,7 +91,6 @@ public class UserDao {
     }
 
     public boolean checkUserPassword(String email, String password) throws Exception {
-        createUserDaoConnection();
         User user = getUserWithEmail(email);
         if(password.equals(user.getPassword())){
             return true;
@@ -103,7 +107,9 @@ public class UserDao {
             QueryBuilder<User, String> queryBuilder = userDao.queryBuilder();
             queryBuilder.where().eq("email",email);
             PreparedQuery<User> preparedQuery = queryBuilder.prepare();
-            return userDao.queryForFirst(preparedQuery);
+            User u = userDao.queryForFirst(preparedQuery);
+            DatabaseHelper.closeConnection();
+            return u;
         }
     }
 
@@ -112,7 +118,9 @@ public class UserDao {
         QueryBuilder<User, String> queryBuilder = userDao.queryBuilder();
         queryBuilder.where().eq("phone",phone);
         PreparedQuery<User> preparedQuery = queryBuilder.prepare();
-        return userDao.queryForFirst(preparedQuery);
+        User u = userDao.queryForFirst(preparedQuery);
+        DatabaseHelper.closeConnection();
+        return u;
     }
 
     public User getUserWithMailAndPhone(String email, String phone) throws Exception {
@@ -120,7 +128,9 @@ public class UserDao {
         QueryBuilder<User, String> queryBuilder = userDao.queryBuilder();
         queryBuilder.where().eq("email",email).and().eq("phone",phone);
         PreparedQuery<User> preparedQuery = queryBuilder.prepare();
-        return userDao.queryForFirst(preparedQuery);
+        User u = userDao.queryForFirst(preparedQuery);
+        DatabaseHelper.closeConnection();
+        return u;
     }
 
     public User getUserWithHash(String userHash) throws Exception {
@@ -128,7 +138,9 @@ public class UserDao {
         QueryBuilder<User,String> queryBuilder = userDao.queryBuilder();
         queryBuilder.where().eq("user_hash",userHash);
         PreparedQuery<User> preparedQuery = queryBuilder.prepare();
-        return userDao.queryForFirst(preparedQuery);
+        User u = userDao.queryForFirst(preparedQuery);
+        DatabaseHelper.closeConnection();
+        return u;
     }
 
     public int getUserIdWithHashAndEmail(String userHash, String userEmail) throws Exception {
@@ -137,6 +149,7 @@ public class UserDao {
         queryBuilder.where().eq("user_hash",userHash).and().eq("email",userEmail);
         PreparedQuery<User> preparedQuery = queryBuilder.prepare();
         User userResponse = userDao.queryForFirst(preparedQuery);
+        DatabaseHelper.closeConnection();
         return userResponse.getUserId();
     }
 
@@ -148,6 +161,7 @@ public class UserDao {
         updateBuilder.updateColumnValue("modification_date",now);
         updateBuilder.where().eq("email",email);
         updateBuilder.update();
+        DatabaseHelper.closeConnection();
     }
 
     public void verifyUser (String email) throws Exception{
@@ -158,5 +172,6 @@ public class UserDao {
         updateBuilder.updateColumnValue("modification_date",now);
         updateBuilder.where().eq("email",email);
         updateBuilder.update();
+        DatabaseHelper.closeConnection();
     }
 }

src/main/java/restImplementation/TransactionImplementation.java

@@ -2,8 +2,6 @@ package restImplementation;
 
 import blockchain.query.QueryWrapper;
 import blockchain.query.TransactionWrapper;
-import database.Wallet.Wallet;
-import database.Wallet.WalletDao;
 import database.transaction.Transaction;
 import database.transaction.TransactionDao;
 import database.user.User;
@@ -18,7 +16,6 @@ import java.time.Instant;
 import java.util.*;
 
 public class TransactionImplementation {
-
     public HashMap sendTransaction(String sourceUserHash, String sourceUserPwd, String sourceWalletHash, String destinationWalletHash, double amount, String transactionUnit) throws Exception {
         TransactionWrapper transactionWrapper = new TransactionWrapper();
         QueryWrapper queryWrapper = new QueryWrapper();
@@ -81,73 +78,86 @@ public class TransactionImplementation {
         return returnResponse;
     }
 
-    //GET
+
+    //GET A TRANSACTION
     public Transaction getTransaction(String wallet_hash, String transaction_hash) throws Exception {
         TransactionDao transactionDao = new TransactionDao();
         return transactionDao.getTransaction(wallet_hash,transaction_hash);
     }
 
-    //SENT
-    public List<Transaction> getSentTransaction(String wallet_hash) throws Exception {
-        TransactionDao transactionDao = new TransactionDao();
-        return transactionDao.getUserSentTransaction(wallet_hash);
-    }
-    public List<List<Transaction>> getAllSentTransaction(String user_hash) throws Exception {
-        TransactionDao transactionDao = new TransactionDao();
-        WalletDao walletDao = new WalletDao();
-        List<List<Transaction>> transactionList = new ArrayList<>();
-        List<Wallet> userWallets = walletDao.getUserWallet(user_hash);
 
-        for(Wallet w : userWallets){
+    //GET LATEST
-            transactionList.add(transactionDao.getUserSentTransaction(w.getWallet_hash()));
+    public List<Transaction> getLatestTransactions(String wallet_hash) throws Exception {
+        TransactionDao transactionDao = new TransactionDao();
+        return transactionDao.getWalletTransactions(wallet_hash,10);
     }
-        return transactionList;
+
+    //GET ALL
+    public List<Transaction> getWalletTransactions(String wallet_hash, String size) throws Exception {
+        TransactionDao transactionDao = new TransactionDao();
+        return transactionDao.getWalletTransactions(wallet_hash,Integer.parseInt(size));
     }
 
+
+    //GET ALL BETWEEN DATE
+    public List<Transaction> getAllBetweenDate(String wallet_hash, String start, String end, String size) throws Exception{
+        TransactionDao transactionDao = new TransactionDao();
+        return transactionDao.getAllTransactionBetweenDate(wallet_hash,start,end,Integer.parseInt(size));
+    }
+
+
+    //SENT
+    public List<Transaction> getSentTransaction(String wallet_hash, String size) throws Exception {
+        TransactionDao transactionDao = new TransactionDao();
+        return transactionDao.getSentTransactions(wallet_hash, Integer.parseInt(size));
+    }
+
+
+    public List<Transaction> getSentBetweenDate(String wallet_hash, String start, String end, String size) throws Exception{
+        TransactionDao transactionDao = new TransactionDao();
+        return transactionDao.getSentTransactionBetweenDate(wallet_hash,start,end,Integer.parseInt(size));
+    }
+
+
     //RECEIVED
-    public List<Transaction> getReceivedTransaction(String wallet_hash) throws Exception {
+    public List<Transaction> getReceivedTransaction(String wallet_hash, String size) throws Exception {
         TransactionDao transactionDao = new TransactionDao();
-        return transactionDao.getUserReceivedTransaction(wallet_hash);
+        return transactionDao.getReceivedTransactions(wallet_hash, Integer.parseInt(size));
     }
-    public List<List<Transaction>> getAllReceivedTransaction(String user_hash) throws Exception {
+
+
+    public List<Transaction> getReceivedBetweenDate(String wallet_hash, String start, String end, String size) throws Exception{
+        TransactionDao transactionDao = new TransactionDao();
+        return transactionDao.getReceivedTransactionBetweenDate(wallet_hash,start,end,Integer.parseInt(size));
+    }
+
+
+    /*
+    public List<List<Transaction>> getAllSentTransaction(String user_hash, String number) throws Exception {
         TransactionDao transactionDao = new TransactionDao();
         WalletDao walletDao = new WalletDao();
         List<List<Transaction>> transactionList = new ArrayList<>();
         List<Wallet> userWallets = walletDao.getUserWallet(user_hash);
 
         for(Wallet w : userWallets){
-            transactionList.add(transactionDao.getUserReceivedTransaction(w.getWallet_hash()));
+            transactionList.add(transactionDao.getUserSentTransaction(w.getWallet_hash(),Integer.parseInt(number)));
         }
         return transactionList;
     }
 
-    public List<Transaction> getLatestTransactions(String user_hash) throws Exception {
+    public List<List<Transaction>> getAllReceivedTransaction(String user_hash, String number) throws Exception {
         TransactionDao transactionDao = new TransactionDao();
         WalletDao walletDao = new WalletDao();
-        List<Transaction> returnList = new ArrayList<>();
+        List<List<Transaction>> transactionList = new ArrayList<>();
         List<Wallet> userWallets = walletDao.getUserWallet(user_hash);
-        List<Transaction> allTransactions = new ArrayList<>();
 
         for(Wallet w : userWallets){
-            List<Transaction> list = transactionDao.getWalletTransactions(w.getWallet_hash());
+            transactionList.add(transactionDao.getUserReceivedTransaction(w.getWallet_hash(), Integer.parseInt(number)));
-            for(Transaction t : list){
-                allTransactions.add(t);
         }
-        }
+        return transactionList;
-        Collections.sort(allTransactions);
-
-        int iterator = 0;
-        int reverseListIndex = allTransactions.size()-1;
-        while (iterator<10){
-            returnList.add(allTransactions.get(reverseListIndex));
-            iterator++;
-            reverseListIndex--;
     }
 
-        return returnList;
+    public List<Transaction> getAllTransactions(String user_hash, String number) throws Exception {
-    }
-
-    public List<Transaction> getAllTransactions(String user_hash) throws Exception {
         TransactionDao transactionDao = new TransactionDao();
         WalletDao walletDao = new WalletDao();
         List<Wallet> userWallets = walletDao.getUserWallet(user_hash);
@@ -155,7 +165,7 @@ public class TransactionImplementation {
         List<Transaction> returnList = new ArrayList<>();
 
         for(Wallet w : userWallets){
-            List<Transaction> list = transactionDao.getWalletTransactions(w.getWallet_hash());
+            List<Transaction> list = transactionDao.getWalletTransactions(w.getWallet_hash(),Integer.parseInt(number));
             for(Transaction t : list){
                 allTransactions.add(t);
             }
@@ -167,6 +177,5 @@ public class TransactionImplementation {
 
         return returnList;
     }
-
+    */
-    //TODO SELECT BETWEEN
 }

src/main/java/restService/TransactionResource.java

@@ -34,6 +34,7 @@ public class TransactionResource {
         }
     }
 
+
     //GET A TRANSACTION
     @RequestMapping(value = "/get", method = RequestMethod.GET, params = {"wallet_hash","txID"},produces = "application/json")
     @ResponseStatus(HttpStatus.OK)
@@ -52,7 +53,114 @@ public class TransactionResource {
         }
     }
 
+
+    //GET LATEST
+    @RequestMapping(value = "/get/latest", method = RequestMethod.GET, params = {"wallet_hash"}, produces = "application/json")
+    @ResponseStatus(HttpStatus.OK)
+    public ResponseEntity getLatestTransaction(@RequestParam(value = "wallet_hash") String wallet_hash){
+        TransactionImplementation transactionImplementation = new TransactionImplementation();
+        try {
+            List<Transaction> listTransaction = transactionImplementation.getLatestTransactions(wallet_hash);
+            return ResponseEntity.status(HttpStatus.OK).body(listTransaction);
+        } catch (Exception e){
+            String r = "{\"response\":\""+e.getMessage()+"\"}";
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(r);
+        }
+    }
+
+    //GET ALL
+    @RequestMapping(value = "/getTransactions", method = RequestMethod.GET, params = {"wallet_hash","size"}, produces = "application/json")
+    @ResponseStatus(HttpStatus.OK)
+    public ResponseEntity getWalletTransactions(@RequestParam(value = "wallet_hash") String wallet_hash, @RequestParam(value = "size") String size){
+        TransactionImplementation transactionImplementation = new TransactionImplementation();
+        try {
+            List<Transaction> listTransaction = transactionImplementation.getWalletTransactions(wallet_hash,size);
+            return ResponseEntity.status(HttpStatus.OK).body(listTransaction);
+        } catch (Exception e){
+            String r = "{\"response\":\""+e.getMessage()+"\"}";
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(r);
+        }
+    }
+    //GET ALL WITH DATE
+    @RequestMapping(value = "/getTransactions", method = RequestMethod.GET, params = {"wallet_hash","start_date","end_date","size"}, produces = "application/json")
+    @ResponseStatus(HttpStatus.OK)
+    public ResponseEntity getWalletTransactionsWithDate(@RequestParam(value = "wallet_hash") String wallet_hash, @RequestParam(value = "start_date") String start_date,
+                                                        @RequestParam(value = "end_date") String end_date, @RequestParam(value = "size") String size){
+        TransactionImplementation transactionImplementation = new TransactionImplementation();
+        try {
+            List<Transaction> listTransaction = transactionImplementation.getAllBetweenDate(wallet_hash,start_date,end_date,size);
+            return ResponseEntity.status(HttpStatus.OK).body(listTransaction);
+        } catch (Exception e){
+            String r = "{\"response\":\""+e.getMessage()+"\"}";
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(r);
+        }
+    }
+
+
     //SENT
+    //GET SENT
+    @RequestMapping(value = "/get/sent", method = RequestMethod.GET, params = {"wallet_hash","size"}, produces = "application/json")
+    @ResponseStatus(HttpStatus.OK)
+    public ResponseEntity getSentTransaction(@RequestParam(value = "wallet_hash") String wallet_hash, @RequestParam(value = "size") String size){
+        TransactionImplementation transactionImplementation = new TransactionImplementation();
+        try {
+            List<Transaction> listTransaction = transactionImplementation.getSentTransaction(wallet_hash,size);
+            return ResponseEntity.status(HttpStatus.OK).body(listTransaction);
+        } catch (Exception e){
+            String r = "{\"response\":\""+e.getMessage()+"\"}";
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(r);
+        }
+    }
+    //GET SENT WITH DATE
+    @RequestMapping(value = "/get/sent", method = RequestMethod.GET, params = {"wallet_hash","start_date","end_date","size"}, produces = "application/json")
+    @ResponseStatus(HttpStatus.OK)
+    public ResponseEntity getSentTransactionWithDate(@RequestParam(value = "wallet_hash") String wallet_hash, @RequestParam(value = "start_date") String start_date,
+                                             @RequestParam(value = "end_date") String end_date, @RequestParam(value = "size") String size){
+        TransactionImplementation transactionImplementation = new TransactionImplementation();
+        try {
+            List<Transaction> listTransaction = transactionImplementation.getSentBetweenDate(wallet_hash,start_date,end_date,size);
+            return ResponseEntity.status(HttpStatus.OK).body(listTransaction);
+        } catch (Exception e){
+            String r = "{\"response\":\""+e.getMessage()+"\"}";
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(r);
+        }
+    }
+
+
+    //RECEIVED
+    //GET RECEIVED
+    @RequestMapping(value = "/get/received", method = RequestMethod.GET, params = {"wallet_hash","size"}, produces = "application/json")
+    @ResponseStatus(HttpStatus.OK)
+    public ResponseEntity getReceivedTransaction(@RequestParam(value = "wallet_hash") String wallet_hash, @RequestParam(value = "size") String size){
+        TransactionImplementation transactionImplementation = new TransactionImplementation();
+        try {
+            List<Transaction> listTransaction = transactionImplementation.getReceivedTransaction(wallet_hash,size);
+            return ResponseEntity.status(HttpStatus.OK).body(listTransaction);
+        } catch (Exception e){
+            String r = "{\"response\":\""+e.getMessage()+"\"}";
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(r);
+        }
+    }
+    //GET RECEIVED WITH DATE
+    @RequestMapping(value = "/get/received", method = RequestMethod.GET, params = {"wallet_hash","start_date","end_date","size"}, produces = "application/json")
+    @ResponseStatus(HttpStatus.OK)
+    public ResponseEntity getReceivedTransactionWithDate(@RequestParam(value = "wallet_hash") String wallet_hash, @RequestParam(value = "start_date") String start_date,
+                                                         @RequestParam(value = "end_date") String end_date, @RequestParam(value = "size") String size){
+        TransactionImplementation transactionImplementation = new TransactionImplementation();
+        try {
+            List<Transaction> listTransaction = transactionImplementation.getReceivedBetweenDate(wallet_hash,start_date,end_date,size);
+            return ResponseEntity.status(HttpStatus.OK).body(listTransaction);
+        } catch (Exception e){
+            String r = "{\"response\":\""+e.getMessage()+"\"}";
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(r);
+        }
+    }
+
+
+
+
+
+    /*
     //GET ALL SENT TRANSACTION
     @RequestMapping(value = "/get/allSent", method = RequestMethod.GET, params = {"user_hash"}, produces = "application/json")
     @ResponseStatus(HttpStatus.OK)
@@ -66,22 +174,7 @@ public class TransactionResource {
             return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(r);
         }
     }
-    //GET SENT FROM WALLET
-    @RequestMapping(value = "/get/sent", method = RequestMethod.GET, params = {"wallet_hash"}, produces = "application/json")
-    @ResponseStatus(HttpStatus.OK)
-    public ResponseEntity getSentTransaction(@RequestParam(value = "wallet_hash") String wallet_hash){
-        TransactionImplementation transactionImplementation = new TransactionImplementation();
-        try {
-            List<Transaction> listTransaction = transactionImplementation.getSentTransaction(wallet_hash);
-            return ResponseEntity.status(HttpStatus.OK).body(listTransaction);
-        } catch (Exception e){
-            String r = "{\"response\":\""+e.getMessage()+"\"}";
-            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(r);
-        }
-    }
 
-
-    //RECEIVED
     //GET ALL RECEIVED TRANSACTION
     @RequestMapping(value = "/get/allReceived", method = RequestMethod.GET, params = {"user_hash"}, produces = "application/json")
     @ResponseStatus(HttpStatus.OK)
@@ -95,32 +188,6 @@ public class TransactionResource {
             return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(r);
         }
     }
-    //GET RECEIVED FROM WALLET
-    @RequestMapping(value = "/get/received", method = RequestMethod.GET, params = {"wallet_hash"}, produces = "application/json")
-    @ResponseStatus(HttpStatus.OK)
-    public ResponseEntity getReceivedTransaction(@RequestParam(value = "wallet_hash") String wallet_hash){
-        TransactionImplementation transactionImplementation = new TransactionImplementation();
-        try {
-            List<Transaction> listTransaction = transactionImplementation.getReceivedTransaction(wallet_hash);
-            return ResponseEntity.status(HttpStatus.OK).body(listTransaction);
-        } catch (Exception e){
-            String r = "{\"response\":\""+e.getMessage()+"\"}";
-            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(r);
-        }
-    }
-
-    @RequestMapping(value = "/get/latest", method = RequestMethod.GET, params = {"user_hash"}, produces = "application/json")
-    @ResponseStatus(HttpStatus.OK)
-    public ResponseEntity getLatestTransaction(@RequestParam(value = "user_hash") String user_hash){
-        TransactionImplementation transactionImplementation = new TransactionImplementation();
-        try {
-            List<Transaction> listTransaction = transactionImplementation.getLatestTransactions(user_hash);
-            return ResponseEntity.status(HttpStatus.OK).body(listTransaction);
-        } catch (Exception e){
-            String r = "{\"response\":\""+e.getMessage()+"\"}";
-            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(r);
-        }
-    }
 
     @RequestMapping(value = "/getAll", method = RequestMethod.GET, params = {"user_hash"}, produces = "application/json")
     @ResponseStatus(HttpStatus.OK)
@@ -134,4 +201,5 @@ public class TransactionResource {
             return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(r);
         }
     }
+    */
 }

src/test/java/database/TransactionTest.java

@@ -0,0 +1,25 @@
+package database;
+
+import database.transaction.Transaction;
+import database.transaction.TransactionDao;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.util.List;
+
+@Ignore
+public class TransactionTest {
+    @Test
+    public void getTransactionBetween(){
+        TransactionDao transactionDao = new TransactionDao();
+        try{
+            List<Transaction> list = transactionDao.getAllTransactionBetweenDate("$2a$10$dmrOFohMnbeVzVHMGc5JnuQ7MMTObn3lHTrMSe/IonD3VTeM.muo.","1555180582250","1555186015913",2);
+            for(Transaction t : list){
+                System.out.println(t.toString());
+            }
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+
+    }
+}

src/test/java/database/UserLoginTest.java

@@ -0,0 +1,22 @@
+package database;
+
+import database.user.User;
+import database.user.UserDao;
+import org.junit.Ignore;
+import org.junit.Test;
+
+@Ignore
+public class UserLoginTest {
+    @Test
+    public void Login(){
+        try{
+            String email = "thomas.meunier@gmail.com";
+            UserDao userDao = new UserDao();
+            User u = userDao.getUserWithEmail(email);
+            System.out.println(u.toString());
+        } catch (Exception e){
+            e.printStackTrace();
+        }
+
+    }
+}

src/test/java/restImplementation/TransactionImplementationTest.java

@@ -16,6 +16,7 @@ public class TransactionImplementationTest {
 
 
 
+    /*
     @Test
     public void doMultipleTransaction(){
         TransactionImplementation transactionImplementation = new TransactionImplementation();
@@ -206,6 +207,7 @@ public class TransactionImplementationTest {
             logger.warn("Error: "+e.getMessage());
         }
     }
+    */
 
 
 }