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

package database.user;

import com.j256.ormlite.dao.Dao;
import com.j256.ormlite.dao.DaoManager;
import com.j256.ormlite.stmt.DeleteBuilder;
import com.j256.ormlite.stmt.PreparedQuery;
import com.j256.ormlite.stmt.QueryBuilder;
import com.j256.ormlite.stmt.UpdateBuilder;
import database.DatabaseHelper;
import java.time.Instant;

//Class to communicate with database with ORMLite
public class UserDao {
    private DatabaseHelper dbh = new DatabaseHelper();
    private boolean sessionOpen = false;
    private Dao<User, String> userDao;
    private void createUserDaoConnection(){
        try {
            if(!sessionOpen){
                userDao = DaoManager.createDao(dbh.setupDatabaseConnection(),User.class);
                sessionOpen = true;
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public void addUser(User user)throws Exception {
        createUserDaoConnection();
        userDao.create(user);
        DatabaseHelper.closeConnection();
    }

    public boolean checkApprovedUser(String email) throws Exception {
        return getUserWithEmail(email).isApproved();
    }

    public boolean checkVerifiedUser(String email) throws Exception {
        return getUserWithEmail(email).isVerified();
    }

    public boolean updateUserPassword(String email, String password) throws Exception {
        createUserDaoConnection();
        UpdateBuilder<User, String> updateBuilder = userDao.updateBuilder();
        updateBuilder.updateColumnValue("password",password);
        long now = Instant.now().toEpochMilli();
        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;
        }
    }

    public void deleteUser(String email) throws Exception {
        createUserDaoConnection();
        DeleteBuilder<User, String> deleteBuilder = userDao.deleteBuilder();
        deleteBuilder.where().eq("email",email);
        deleteBuilder.delete();
        DatabaseHelper.closeConnection();
    }

    public boolean verifyUserExist(String email) throws Exception {
        createUserDaoConnection();
        QueryBuilder<User, String> queryBuilder = userDao.queryBuilder();
        queryBuilder.where().eq("email",email);
        PreparedQuery<User> preparedQuery = queryBuilder.prepare();
        User user = userDao.queryForFirst(preparedQuery);
        DatabaseHelper.closeConnection();
        if(user==null){
            return false;
        }else{
            return true;
        }
    }

    public boolean checkUserPassword(String email, String password) throws Exception {
        User user = getUserWithEmail(email);
        if(password.equals(user.getPassword())){
            return true;
        }else{
            return false;
        }
    }

    public User getUserWithEmail(String email) throws Exception {
        createUserDaoConnection();
        if(!verifyUserExist(email)){
            return null;
        }else{
            QueryBuilder<User, String> queryBuilder = userDao.queryBuilder();
            queryBuilder.where().eq("email",email);
            PreparedQuery<User> preparedQuery = queryBuilder.prepare();
            User u = userDao.queryForFirst(preparedQuery);
            DatabaseHelper.closeConnection();
            return u;
        }
    }

    public User getUserWithPhone(String phone) throws Exception {
        createUserDaoConnection();
        QueryBuilder<User, String> queryBuilder = userDao.queryBuilder();
        queryBuilder.where().eq("phone",phone);
        PreparedQuery<User> preparedQuery = queryBuilder.prepare();
        User u = userDao.queryForFirst(preparedQuery);
        DatabaseHelper.closeConnection();
        return u;
    }

    public User getUserWithMailAndPhone(String email, String phone) throws Exception {
        createUserDaoConnection();
        QueryBuilder<User, String> queryBuilder = userDao.queryBuilder();
        queryBuilder.where().eq("email",email).and().eq("phone",phone);
        PreparedQuery<User> preparedQuery = queryBuilder.prepare();
        User u = userDao.queryForFirst(preparedQuery);
        DatabaseHelper.closeConnection();
        return u;
    }

    public User getUserWithHash(String userHash) throws Exception {
        createUserDaoConnection();
        QueryBuilder<User,String> queryBuilder = userDao.queryBuilder();
        queryBuilder.where().eq("user_hash",userHash);
        PreparedQuery<User> preparedQuery = queryBuilder.prepare();
        User u = userDao.queryForFirst(preparedQuery);
        DatabaseHelper.closeConnection();
        return u;
    }

    public int getUserIdWithHashAndEmail(String userHash, String userEmail) throws Exception {
        createUserDaoConnection();
        QueryBuilder<User,String> queryBuilder = userDao.queryBuilder();
        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();
    }

    public void approveUser (String email) throws Exception {
        createUserDaoConnection();
        UpdateBuilder<User, String> updateBuilder = userDao.updateBuilder();
        updateBuilder.updateColumnValue("approved",true);
        long now = Instant.now().toEpochMilli();
        updateBuilder.updateColumnValue("modification_date",now);
        updateBuilder.where().eq("email",email);
        updateBuilder.update();
        DatabaseHelper.closeConnection();
    }

    public void verifyUser (String email) throws Exception{
        createUserDaoConnection();
        UpdateBuilder<User, String> updateBuilder = userDao.updateBuilder();
        updateBuilder.updateColumnValue("verified",true);
        long now = Instant.now().toEpochMilli();
        updateBuilder.updateColumnValue("modification_date",now);
        updateBuilder.where().eq("email",email);
        updateBuilder.update();
        DatabaseHelper.closeConnection();
    }
}