Merged user registration branch onto main

Author: Madhavan7

.gitignore

@@ -1,14 +1,14 @@
 # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
 # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
 
-# User-specific stuff
+# entities.user_entities.User-specific stuff
 .idea/**/workspace.xml
 .idea/**/tasks.xml
 .idea/**/usage.statistics.xml
 .idea/**/dictionaries
 .idea/**/shelf
 
-# AWS User-specific
+# AWS entities.user_entities.User-specific
 .idea/**/aws.xml
 
 # Generated files

build.gradle

@@ -7,6 +7,8 @@ repositories {
 }
 
 dependencies {
+    implementation 'javax.mail:javax.mail-api:1.6.2'
+    implementation 'com.sun.mail:javax.mail:1.6.2'
     implementation 'junit:junit:4.13.1'
     testImplementation('org.junit.jupiter:junit-jupiter:5.6.0')
 }

src/main/java/data_access/UserDatabase.java

@@ -0,0 +1,88 @@
+package data_access;
+
+import interface_adapters.IRetrieveList;
+import interface_adapters.user_registration_interface_adapters.UserExists;
+import entities.user_entities.User;
+import entities.user_entities.UserFactory;
+import use_cases.user_login_use_case.UserCreator;
+import interface_adapters.UserRetriever;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.List;
+public class UserDatabase implements UserExists, UserRetriever, UserCreator, IRetrieveList {
+    File accounts;
+    List<User> accountList;
+    public UserDatabase(){
+        this.accounts = new File("TestUserDatabase3.csv");
+        this.accountList = this.getList();
+    }
+    public UserDatabase(File accounts){
+        if(!accounts.exists()){
+            try {
+                accounts.createNewFile();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        this.accounts = accounts;
+        this.accountList = this.getList();
+    }
+    @Override
+    public boolean UserExists(String username, String email) {
+        for(User user: this.accountList){
+            if(user.getUsername().equals(username) || user.getEmail().equals(email)){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    // Creates a new user with a username and password, and an email address
+    // The order is username, password, email address, verification status, status
+    //
+    @Override
+    public void createUser(String username, String password, String email, String type){
+        User newUser = UserFactory.BirthUser(username, password, email, type);
+        this.accountList.add(newUser);
+        try(FileOutputStream fileOut = new FileOutputStream(accounts)){
+            try(ObjectOutputStream out = new ObjectOutputStream(fileOut)){
+                out.writeObject(this.accountList);
+                out.close();
+                fileOut.close();
+            }catch(Exception e){
+                System.out.println("Error");
+            }
+        }catch(Exception e){
+            System.out.println("Error");
+        }
+    }
+
+    @Override
+//  To be edited to get user from the array format rather than the serialized format.
+    public User getUser(String username) {
+        User ans = null;
+        for (int i = 0; i < (this.getList().size()); i++) {
+            if (this.getList().get(i).getUsername().equals(username)) {
+                ans = this.getList().get(i);
+            }
+        }
+        return ans;
+    }
+
+    //Returns an ArrayList with the users that is extracted from the file, so that other objects can use this list.
+    @Override
+    public List<User> getList() {
+        List<User> users = new ArrayList<>();
+        try(FileInputStream fileIn = new FileInputStream(accounts);
+            ObjectInputStream in = new ObjectInputStream(fileIn)) {
+
+            users = (ArrayList<User>) in.readObject();
+            return users;
+        }catch(EOFException e){
+            return users;
+            } catch (IOException | ClassNotFoundException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+}

src/main/java/entities/user_entities/BasicUser.java

@@ -0,0 +1,6 @@
+import entities.user_entities.User;
+public class BasicUser extends User{
+    public BasicUser(String Username, String Password, String Email){
+        super(Username, Password, Email);
+    }
+}

src/main/java/entities/user_entities/User.java

@@ -0,0 +1,37 @@
+import use_cases.user_attribute_modification_use_case.Changeable;
+
+import java.io.Serializable;
+public abstract class User implements Serializable, Changeable {
+    protected String username;
+    protected String password;
+    protected String email;
+    boolean verified = false;
+    boolean online = false;
+    public User(String username, String password, String email){
+        this.username = username;
+        this.password = password;
+        this.email = email;
+    }
+    public String getEmail(){
+        return this.email;
+    }
+    public String getUsername(){
+        return this.username;
+    }
+    private String getPassword(){
+        return this.password;
+    }
+
+    @Override
+//    from Changeable
+    public void changeFeature(String feature, String newFeature){
+        if (feature == "Username"){
+            this.username = newFeature;
+        } else if (feature == "Password"){
+            this.password = newFeature;
+        } else if (feature == "Email"){
+            this.email = newFeature;
+        }
+    }
+
+}

src/main/java/entities/user_entities/UserFactory.java

@@ -0,0 +1,8 @@
+package entities.user_entities;
+
+public class UserFactory {
+    //Following the factory design pattern, just in case in the future we decide to add various different types of Users
+    public static User BirthUser(String Username, String Password, String Email, String type){
+        return new BasicUser(Username, Password, Email);
+    }
+}

src/main/java/interface_adapters/IRetrieveList.java

@@ -0,0 +1,7 @@
+package interface_adapters;
+import entities.user_entities.User;
+import java.util.List;
+
+public interface IRetrieveList {
+    List<User> getList();
+}

src/main/java/interface_adapters/UserRetriever.java

@@ -0,0 +1,8 @@
+package interface_adapters;
+
+import entities.user_entities.User;
+import interface_adapters.user_registration_interface_adapters.UserExists;
+
+public interface UserRetriever extends UserExists {
+    User getUser(String username);
+}

src/main/java/interface_adapters/user_registration_interface_adapters/UserExists.java

@@ -0,0 +1,5 @@
+package interface_adapters.user_registration_interface_adapters;
+
+public interface UserExists {
+    boolean UserExists(String username, String password);
+}

src/main/java/interface_adapters/user_registration_interface_adapters/UserRegistrationController.java

@@ -0,0 +1,117 @@
+package interface_adapters.user_registration_interface_adapters;
+
+import use_cases.user_login_use_case.UserCreator;
+import interface_adapters.user_registration_interface_adapters.UserVerifier;
+import use_cases.user_login_use_case.verificationMethodFactory;
+
+import javax.swing.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.Random;
+public class UserRegistrationController implements UserVerifier, ActionListener, UserRegistrator {
+    private final String username;
+    private final String password;
+    private final String email;
+    private String preference;
+    private boolean userExists = false;
+    private UserCreator database;
+    Random random;
+    private final int code;
+    private JTextField verificationCodeText;
+    private JLabel success;
+
+    /*public UserRegistrationController(int code, String Username, String Password, String email, UserDatabase database){
+        this.code = code;
+        this.username = Username;
+        this.password = Password;
+        this.email = email;
+        this.database = database;
+    }*/
+
+    public UserRegistrationController(UserRegistrationGateway properties){
+        this.username = properties.getUsername();
+        this.password = properties.getPassword();
+        this.email = properties.getEmail();
+        this.userExists = properties.isUserExists();
+        this.code = properties.getCode();
+        this.database = properties.getDatabase();
+    }
+
+    //Asks for the verification code from the user, and matches it with this.code to potentially verify the user
+    public void verify(String email){
+        JFrame verificationFrame = new JFrame();
+        verificationFrame.setSize(400, 200);
+        verificationFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+        JPanel verificationPanel = new JPanel();
+        verificationFrame.add(verificationPanel);
+
+        verificationPanel.setLayout(null);
+        JLabel verificationLabel = new JLabel("Verification Code");
+        verificationLabel.setBounds(10,25, 200, 25);
+        verificationCodeText = new JTextField();
+        verificationCodeText.setBounds(125, 20, 165, 25);
+
+        verificationPanel.add(verificationLabel);
+        verificationPanel.add(verificationCodeText);
+
+        //Success/Failure Labels
+        success = new JLabel("");
+        success.setBounds(10, 50, 100, 25);
+        verificationPanel.add(success);
+
+        JButton verifyButton = new JButton("verify");
+        verifyButton.setBounds(125, 50, 100, 25);
+        verificationPanel.add(verifyButton);
+        verifyButton.addActionListener(this);
+        verificationFrame.setVisible(true);
+
+        verificationMethodFactory mailMan = new verificationMethodFactory(email, "Email", code);
+        mailMan.deliverCode();
+    }
+
+    public void registerUser() {
+        if(this.userExists){
+            System.out.println("An account with this username or email already exists");
+            accountExistsMessage();
+        }else{
+            this.verify(email);
+        }
+    }
+
+    public static void accountExistsMessage(){
+        JFrame accountExistsFrame = new JFrame();
+        accountExistsFrame.setSize(400, 100);
+        accountExistsFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+        JPanel accountExistsPanel = new JPanel();
+        accountExistsPanel.setLayout(null);
+        accountExistsFrame.add(accountExistsPanel);
+        JLabel errorMessage = new JLabel("An account with this username or email already exists");
+        errorMessage.setBounds(10,20, 350, 20);
+        accountExistsPanel.add(errorMessage);
+        accountExistsFrame.setVisible(true);
+    }
+
+    public static void verificationSuccessMessage(){
+        JFrame verificationSuccessFrame = new JFrame();
+        verificationSuccessFrame.setSize(400, 100);
+        verificationSuccessFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+        JPanel verificationSuccessPanel = new JPanel();
+        verificationSuccessPanel.setLayout(null);
+        verificationSuccessFrame.add(verificationSuccessPanel);
+        JLabel errorMessage = new JLabel("Could not verify please try again");
+        errorMessage.setBounds(10,20, 350, 20);
+        verificationSuccessPanel.add(errorMessage);
+        verificationSuccessFrame.setVisible(true);
+    }
+
+    @Override
+    public void actionPerformed(ActionEvent e) {
+        int verCode = Integer.parseInt(verificationCodeText.getText());
+        if(verCode == this.code){
+            database.createUser(this.username, this.password, this.email, "Basic");
+            System.out.println("Verification successful");
+        }else{
+            verificationSuccessMessage();
+        }
+    }
+}