encoding password with salt successfully

Author: Borovski Cergei

src/main/java/mate/academy/Main.java

@@ -2,17 +2,25 @@
 
 import java.time.LocalDate;
 import java.time.LocalDateTime;
+import javax.naming.AuthenticationException;
+import mate.academy.exception.RegistrationException;
+import mate.academy.lib.Injector;
 import mate.academy.model.CinemaHall;
 import mate.academy.model.Movie;
 import mate.academy.model.MovieSession;
+import mate.academy.model.User;
+import mate.academy.security.AuthenticationService;
 import mate.academy.service.CinemaHallService;
 import mate.academy.service.MovieService;
 import mate.academy.service.MovieSessionService;
 
 public class Main {
-    public static void main(String[] args) {
-        MovieService movieService = null;
+    public static final Injector injector = Injector.getInstance("mate.academy");
 
+    public static void main(String[] args) throws RegistrationException, AuthenticationException {
+
+        MovieService movieService = (MovieService) injector
+                .getInstance(MovieService.class);
         Movie fastAndFurious = new Movie("Fast and Furious");
         fastAndFurious.setDescription("An action film about street racing, heists, and spies.");
         movieService.add(fastAndFurious);
@@ -27,7 +35,8 @@ public static void main(String[] args) {
         secondCinemaHall.setCapacity(200);
         secondCinemaHall.setDescription("second hall with capacity 200");
 
-        CinemaHallService cinemaHallService = null;
+        CinemaHallService cinemaHallService = (CinemaHallService) injector
+                .getInstance(CinemaHallService.class);
         cinemaHallService.add(firstCinemaHall);
         cinemaHallService.add(secondCinemaHall);
 
@@ -44,12 +53,22 @@ public static void main(String[] args) {
         yesterdayMovieSession.setMovie(fastAndFurious);
         yesterdayMovieSession.setShowTime(LocalDateTime.now().minusDays(1L));
 
-        MovieSessionService movieSessionService = null;
+        MovieSessionService movieSessionService = (MovieSessionService) injector
+                .getInstance(MovieSessionService.class);
         movieSessionService.add(tomorrowMovieSession);
         movieSessionService.add(yesterdayMovieSession);
 
         System.out.println(movieSessionService.get(yesterdayMovieSession.getId()));
         System.out.println(movieSessionService.findAvailableSessions(
-                        fastAndFurious.getId(), LocalDate.now()));
+                fastAndFurious.getId(), LocalDate.now()));
+
+        AuthenticationService authenticationService = (AuthenticationService) injector
+                .getInstance(AuthenticationService.class);
+        User registerUser = authenticationService.register("liame@gmail.com", "drowssap");
+        User loginUser = authenticationService.login("liame@gmail.com", "drowssap");
+
+        System.out.println(registerUser);
+        System.out.println(loginUser);
+
     }
 }

src/main/java/mate/academy/dao/UserDao.java

@@ -0,0 +1,10 @@
+package mate.academy.dao;
+
+import java.util.Optional;
+import mate.academy.model.User;
+
+public interface UserDao {
+    User add(User user);
+
+    Optional<User> findByEmail(String email);
+}

src/main/java/mate/academy/dao/impl/UserDaoImpl.java

@@ -0,0 +1,49 @@
+package mate.academy.dao.impl;
+
+import java.util.Optional;
+import mate.academy.dao.UserDao;
+import mate.academy.exception.DataProcessingException;
+import mate.academy.lib.Dao;
+import mate.academy.model.User;
+import mate.academy.util.HibernateUtil;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.Transaction;
+
+@Dao
+public class UserDaoImpl implements UserDao {
+
+    @Override
+    public User add(User user) {
+        Session session = null;
+        Transaction transaction = null;
+        try {
+            session = HibernateUtil.getSessionFactory().openSession();
+            transaction = session.beginTransaction();
+            session.persist(user);
+            transaction.commit();
+        } catch (Exception e) {
+            if (transaction != null) {
+                transaction.rollback();
+            }
+            throw new DataProcessingException("Can`t add user to DB ", e);
+        } finally {
+            if (session != null) {
+                session.close();
+            }
+        }
+        return user;
+    }
+
+    @Override
+    public Optional<User> findByEmail(String email) {
+        SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
+        try (Session session = sessionFactory.openSession()) {
+            return session.createQuery("from User u where u.email = :email", User.class)
+                    .setParameter("email", email)
+                    .uniqueResultOptional();
+        } catch (Exception e) {
+            throw new DataProcessingException("Can`t find user by email = " + email, e);
+        }
+    }
+}

src/main/java/mate/academy/exception/AuthenticationException.java

@@ -0,0 +1,7 @@
+package mate.academy.exception;
+
+public class AuthenticationException extends Exception {
+    public AuthenticationException(String message) {
+        super(message);
+    }
+}

src/main/java/mate/academy/exception/RegistrationException.java

@@ -0,0 +1,7 @@
+package mate.academy.exception;
+
+public class RegistrationException extends Exception {
+    public RegistrationException(String message) {
+        super(message);
+    }
+}

src/main/java/mate/academy/model/User.java

@@ -0,0 +1,60 @@
+package mate.academy.model;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "users")
+public class User {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private long id;
+    @Column(unique = true)
+    private String email;
+    private String password;
+    private byte[] salt;
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public byte[] getSalt() {
+        return salt;
+    }
+
+    public void setSalt(byte[] salt) {
+        this.salt = salt;
+    }
+
+    @Override
+    public String toString() {
+        return "User{"
+                + "id=" + id
+                + ", email='" + email + '\''
+                + '}';
+    }
+}

src/main/java/mate/academy/security/AuthenticationService.java

@@ -0,0 +1,11 @@
+package mate.academy.security;
+
+import javax.naming.AuthenticationException;
+import mate.academy.exception.RegistrationException;
+import mate.academy.model.User;
+
+public interface AuthenticationService {
+    User login(String email, String password) throws AuthenticationException;
+
+    User register(String email, String password) throws RegistrationException;
+}

src/main/java/mate/academy/security/impl/AuthenticationServiceImpl.java

@@ -0,0 +1,44 @@
+package mate.academy.security.impl;
+
+import java.util.Optional;
+import javax.naming.AuthenticationException;
+import mate.academy.exception.RegistrationException;
+import mate.academy.lib.Inject;
+import mate.academy.lib.Service;
+import mate.academy.model.User;
+import mate.academy.security.AuthenticationService;
+import mate.academy.service.UserService;
+import mate.academy.util.HashUtil;
+
+@Service
+public class AuthenticationServiceImpl implements AuthenticationService {
+    @Inject
+    private UserService userService;
+
+    @Override
+    public User login(String email, String password) throws AuthenticationException {
+        final Optional<User> userFromDbOptional = userService.findByEmail(email);
+        if (userFromDbOptional.isEmpty()) {
+            throw new AuthenticationException("The user with email = "
+                    + email + "does not exist in the database");
+        }
+        final User user = userFromDbOptional.get();
+        String hashedPassword = HashUtil.hashPassword(password, user.getSalt());
+        if (user.getPassword().equals(hashedPassword)) {
+            return user;
+        }
+        throw new AuthenticationException("Password " + password + "is not correct");
+    }
+
+    @Override
+    public User register(String email, String password) throws RegistrationException {
+        final Optional<User> userFromDbOptional = userService.findByEmail(email);
+        if (userFromDbOptional.isEmpty()) {
+            User user = new User();
+            user.setEmail(email);
+            user.setPassword(password);
+            return userService.add(user);
+        }
+        throw new RegistrationException("Can`t register user");
+    }
+}

src/main/java/mate/academy/service/UserService.java

@@ -0,0 +1,10 @@
+package mate.academy.service;
+
+import java.util.Optional;
+import mate.academy.model.User;
+
+public interface UserService {
+    User add(User user);
+
+    Optional<User> findByEmail(String email);
+}

src/main/java/mate/academy/service/impl/UserServiceImpl.java

@@ -0,0 +1,27 @@
+package mate.academy.service.impl;
+
+import java.util.Optional;
+import mate.academy.dao.UserDao;
+import mate.academy.lib.Inject;
+import mate.academy.lib.Service;
+import mate.academy.model.User;
+import mate.academy.service.UserService;
+import mate.academy.util.HashUtil;
+
+@Service
+public class UserServiceImpl implements UserService {
+    @Inject
+    private UserDao userDao;
+
+    @Override
+    public User add(User user) {
+        user.setSalt(HashUtil.getSalt());
+        user.setPassword(HashUtil.hashPassword(user.getPassword(), user.getSalt()));
+        return userDao.add(user);
+    }
+
+    @Override
+    public Optional<User> findByEmail(String email) {
+        return userDao.findByEmail(email);
+    }
+}