User.php

<?php
/**
* @license MIT
* boutique-en-ligne (maxaboom)
* Copyright (c) 2023 Abraham Ukachi, Axel Vair, Morgane Marechal, Catherine Tranchand. The Maxaboom Project Contributors.
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* @project boutique-en-ligne (maxaboom)
* @name User - Model
* @test test/user_model.php
* @file User.php
* @author: Morgane Marechal <morgane.marechal@laplateforme.io>
* @contributors: Abraham Ukachi <abraham.ukachi@laplateforme.io>, Axel Vair <axel.vair@laplateforme.io>, Catherine Tranchand <catherine.tranchand@laplateforme.io>
* @version: 0.0.1
* 
* Example usage:
*   
*   1+|> // Create a new user
*    -|>
*    -|> $user = User::create([
*    -|>   'firstname' => 'John',
*    -|>   'lastname' => 'Doe',
*    -|>   'mail' => 'john.doe@gmail.com',
*    -|>   'password' => '********',
*    -|>   'dob' => '1990-01-01',
*    -|>   'user_role' => 'customer'
*    -|> ]);
*    -|>
*   o=|> echo $user->id; // 69
*    -|>
*
*   2+|> // Find a user by id
*    -|>
*    -|> $user = User::find(69);
*    -|>
*   o=|> echo $user->firstname; // John
*    -|>
*
*
*   3+|> // Connect a user
*    -|>
*    -|> $user = User::connect([
*    -|>   'mail' => 'abraham.ukachi@laplateforme.io',
*    -|>   'password' => '********'
*    -|> ]);
*    -|>
*   o=|> if($user){
*    -|>   echo $user->firstname; // Abraham
*    -|> }
*    -|>
*/



// declare a namespace for this User class
namespace Maxaboom\Models;


// use these classes
use datetime;
use PDO;
use PDOException;


/**
 * Class User / User Model
 * A class that represents the `users` table in the database.
 */
class User extends Model {
  
  // Define some constants
  const SESSION_NAME = 'user';


  // Define some properties here ;)
  
  // protected properties

  /**
   * The table associated with this model
   *
   * @var string
   */
  protected string $table = 'users';


  /**
   * Indicates if the model should automatically connect to the database.
   *
   * @var bool
   */
  protected bool $autoConnect = true;


  /**
   * All the supported fields in the `users` table
   * @var array
   */
  protected array $fields = [
    'id',
    'firstname',
    'lastname',
    'mail',
    'password',
    'dob',
    'user_role',
    'created_at',
    'updated_at',
    'deleted_at'
  ];

  
  // public properties
  
  public ?int $id = null;
  public ?string $firstname = null;
  public ?string $lastname = null;
  public ?string $mail = null;
  public ?string $password = null;
  public ?string $dob = null;
  public ?string $user_role = null;
  public ?string $created_at = null;
  public ?string $updated_at = null;
  public ?string $deleted_at = null;



  /**
   * Indicates if the model should be timestamped.
   *
   * @var bool
   */
  public bool $timestamps = true;




  /**
   * OrderItem constructor.
   * NOTE: This constructor is called automatically when the class is instantiated
   */
  public function __construct() {
    // call the parent Model constructor
    parent::__construct();

    // check if the user is connected
    if($this->isConnected()){
      // get the user id from session as `userId`
      $userId = $this->getSession('id');

      // populate the user info with `userId`
      $this->populateUserInfo($userId);
    }

  }


  // PUBLIC STATIC SETTERS

  // PUBLIC STATIC GETTERS

  // PUBLIC STATIC METHODS


  /**
   * Method used to connect the user
   *
   * @example usage
   *    self::connect([
   *      'mail' => 'abc@gmail.com',
   *      'password' => '***'
   *    ]);
   *
   * @param array $params : The parameters to use to connect the user
   *
   * @return false|self : Returns the current model instance if the user is connected, otherwise returns false
   */
  public static function connect(array $params): false|self {
    // initialize the `result` boolean variable
    $result = false;

    // get an instance of the current model
    $instance = self::getInstance();

    // Do nothing if the user is already connected
    if ($instance->isConnected()) {
      return $instance;
    }
    
    // However, if the user is not connected--
    // --verify the `$params` argument
    self::verifyParams($params, $instance);

    // if there's a mail and password in the `$params` argument
    if (isset($params['mail']) && isset($params['password'])) {
      // get the mail
      $mail = $params['mail'];
      // get the password
      $password = $params['password'];

      // find the user by mail
      $user = self::where('mail', $mail);


      // DEBUG [4dbsmaster]: tell me about it ;)
      // printf("user->password => %s & password => %s | exists ? %s", $user->password, $password, $user->exists());

      // If the user exists...
      if ($user->exists()) {
        // ...check if the password matches
        $passwordsMatch = password_verify($password, $user->password);

        // DEBUG [4dbsmaster]: tell me about it ;)
        // printf("passwordsMatch => %s", $passwordsMatch);

        // if the passwords match...
        if ($passwordsMatch) {
          // ...create a user session
          $instance->createSession([
            'id' => $user->id,
            'firstname' => $user->firstname,
            'lastname' => $user->lastname,
            'mail' => $user->mail
          ]);

          // update the `result` to the user instance
          $result = $user;
        }

      }
    }

    // return the `result`
    return $result;
  }
  

  // PUBLIC SETTERS
  
  // PUBLIC GETTERS
  
  // PUBLIC METHODS



  // PRIVATE STATIC SETTERS

  // PRIVATE STATIC GETTERS

  // PRIVATE STATIC METHODS


  // PRIVATE SETTERS
  
  // PRIVATE GETTERS
  
  // PRIVATE METHODS





  // +++++++ `Morgane Marechal` - CODE ++++++++
  
  
    //method for register user
    public function register($firstname, $lastname, $mail, $password)
    {
        $user_role = "customer";
        if (!$this->verifUser($mail)) {
            $created_at = $this->getCurrentDate();
            $sql = "INSERT INTO users (firstname, lastname, mail, password, created_at, user_role)
                    VALUES (:firstname, :lastname, :mail, :password, :created_at, :user_role)";
            $sql_exe = $this->db->prepare($sql);
            $sql_exe->execute([
                'firstname' => htmlspecialchars($firstname),
                'lastname' => htmlspecialchars($lastname),
                'mail' => htmlspecialchars($mail),
                'password' => password_hash($password, PASSWORD_DEFAULT),
                'created_at' => $created_at,
                'user_role' => htmlspecialchars($user_role),
            ]);

            if ($sql_exe) {
               return true;
            } else {
                return false;
            }
        } else {
            return false;
        }
    }

    /* Check if user in DB */
    public function verifUser($mail)
    {
            $sql = "SELECT * 
                    FROM users
                    WHERE mail = :mail";
            $sql_exe = $this->db->prepare($sql);
            $sql_exe->execute([
                'mail' => $mail,
            ]);
            $results = $sql_exe->fetch(PDO::FETCH_ASSOC);
            if ($results) {
                return true;
            } else {
                return false;
            }
    }

    /**
     * Function that verif if user id exist in bdd
     * @param $id
     * @return int
     */
    public function verifUserById($id): int{
        $sql = "SELECT * FROM users WHERE id = :id";
        $sql_exe = $this->db->prepare($sql);
        $sql_exe->execute([
            'id' => $id,
        ]);
        $results = $sql_exe->fetch(PDO::FETCH_ASSOC);
        if($results){
            return true;
        }else{
            return false;
        }
    }

    //call registerGuest() if no SESSION_ID when pay product   
    public function registerGuest($firstname, $lastname, $mail)
    {
        if (!$this->verifGuest()) {
            $created_at = $this->getCurrentDate();
            $sql = "INSERT INTO users (firstname, lastname, mail, user_role, created_at) VALUES (:firstname, :lastname, :mail, :user_role, :created_at)";
            $sql_exe = $this->db->prepare($sql);
            $sql_exe->execute([
                'firstname' => htmlspecialchars($firstname),
                'lastname' => htmlspecialchars($lastname),
                'mail' => htmlspecialchars($mail),
                'user_role' => 'guest',
                'created_at' => $created_at
            ]);

            if ($sql_exe) {
                //header("Refresh:2; url=connection.php");
                echo json_encode(['response' => 'ok', 'reussite' => 'Inscription réussie.']);
            } else {
                echo json_encode(['response' => 'not ok', 'echoue' => 'L\'inscription a échoué.']);
            }
        } else {
            echo json_encode(['response' => 'not ok', 'echoue' => 'Vous avez un compte utilisateur, vous devez vous connecter']);
        }
    }

    public function verifGuest()
    {
            $mail = htmlspecialchars($_POST['mail'] ?? '');
            $sql = "SELECT * 
                    FROM users
                    WHERE mail = :mail";
            $sql_exe = $this->db->prepare($sql);
            $sql_exe->execute([
                'mail' => $mail,
            ]);
            $results = $sql_exe->fetch(PDO::FETCH_ASSOC);
            if ($results) {
                if ($results["user_role"]==="customer"){
                    return true;
                }else{
                    return false;
                }               
            } else {
                return false;
            }
    }


        //method for admin for create user
    public function createUser($firstname, $lastname, $mail, $password, $checkpassword, $role)
    {
        if (!$this->verifUser($mail)) {
            $created_at = $this->getCurrentDate();
            $sql = "INSERT INTO users (firstname, lastname, mail, password, created_at, user_role)
                    VALUES (:firstname, :lastname, :mail, :password, :created_at, :user_role)";
            $sql_exe = $this->db->prepare($sql);
            $sql_exe->execute([
                'firstname' => htmlspecialchars($firstname),
                'lastname' => htmlspecialchars($lastname),
                'mail' => htmlspecialchars($mail),
                'password' => password_hash($password, PASSWORD_DEFAULT),
                'created_at' => $created_at,
                'user_role' => htmlspecialchars($role)
            ]);

            if ($sql_exe) {
               return true;
            } else {
                return false;
            }
        } else {
            return false;
        }
    }





    // method get current date
    public function getCurrentDate(){
        $mydate=getdate(date("U"));
        $myhour=date("H:i:s");
        $monthdate=$mydate['mon'];
        $dday=$mydate['mday'];
        $mon = str_pad($monthdate, 2, "0", STR_PAD_LEFT);
        $day = str_pad($dday, 2, "0", STR_PAD_LEFT);

        $date="$mydate[year]-$mon-$day $myhour";
        return $date;
    }

    //method get lastGuestId

    public function connection($mail, $password)
    {
        $sql = "SELECT * 
                FROM users
                WHERE mail = :mail ";
        $sql_exe = $this->db->prepare($sql);
        $sql_exe->execute([
            'mail' => $mail,
        ]);

        // fetch the result as `user`
        $user = $sql_exe->fetch(PDO::FETCH_ASSOC);

        if ($user) {
            $hashed_password = $user['password'];
            if (password_verify($password, $hashed_password)) {

              // create session
              $this->createSession([
                'id' => $user['id'],
                'firstname' => $user['firstname'],
                'lastname' => $user['lastname'],
                'mail' => $user['mail']
              ]);

                // $userId = $results['id'];
                // $_SESSION['id'] = $userId;
                $this->populateUserInfo($user['id']);
                return true;
            } else {
                return false;
            }
        } else {
            return false;
        }
    }


    public function disconnect() {
      $result = false;

      // Check the session
      
      // If there's a session..
      if ($this->checkSession()) {
        // .. destroy it
        $this->destroySession();
        // set the result to true
        $result = true;
      }

      return $result;
    }



  /**
   * Checks if the user is connected
   *
   * @return bool
   */
  public function isConnected(): bool {
    // initialize the `result` variable
    $result = false;
    
    // Check the session 
    
    // If there's a session..
    if($this->checkSession()){
      // get the user id from session as `userId`
      $userId = $this->getSession('id');
      // vertify the user id
      $result = $this->verifUserById($userId);

      // if the user id is not valid
      if(!$result){
        // destroy the session
        $this->destroySession();
      }

    }

    // return the result
    return $result;
  }


    public function populateUserInfo($id){
        $sql = "SELECT * FROM users WHERE id = $id";
        $sql_exe = $this->db->prepare($sql);
        $sql_exe->execute([]);
        $info = $sql_exe->fetch(PDO::FETCH_ASSOC);

        $this->id = $info['id'];
        $this->firstname = $info['firstname'];
        $this->lastname = $info['lastname'];
        $this->mail = $info['mail'];
        $this->user_role = $info['user_role'];
    }

    //methods for update info user

        // update lastname
        public function updateLastname($newlastname){
            $lastname=$_SESSION['lastname'];
            $sqlupdate = $this -> db -> prepare("UPDATE users SET lastname = '$newlastname' WHERE lastname = :lastname ");
            $sqlupdate->execute([
                'lastname' => $lastname,
            ]);
            $_SESSION['lastname'] = $newlastname;
            return "Vous avez changer votre nom et mis à jour votre profil.<br>";
        }

        // update firstname
        public function updateFirstname($newfirstname){
            $firstname=$_SESSION['firstname'];
            $sqlupdate = $this -> db -> prepare("UPDATE users SET firstname = '$newfirstname' WHERE firstname = :firstname ");
            $sqlupdate->execute([
                'firstname' => $firstname,
            ]);
            $_SESSION['firstname'] = $newfirstname;
            return "Vous avez changer votre prénom et mis à jour votre profil.<br>";
        } 

        public function updateMail(string $newmail, int $userId){
            //$mail=$_SESSION['mail'];
            $sqlupdate = $this->db->prepare("UPDATE users SET mail = :newmail WHERE id = :userId ");
            $result = $sqlupdate->execute([
              'newmail' => $newMail,
              'userId' => $userId
            ]);
            //$_SESSION['mail'] = $newmail;

            // update session
            $this->setSession('mail', $newmail);

            // return "Vous avez changer votre email et mis à jour votre profil.<br>";
            // return the `$result`
            return $result;

        }


    //display all users for admin
        public function displayUsers(){
            $displayUsers = $this->db->prepare("SELECT * FROM " . $this::TABLE_USERS);
            $displayUsers->execute([
            ]);
            $result = $displayUsers->fetchAll(PDO::FETCH_ASSOC);
            return $result;
        }

    //display one specific user by id

    public function getUserInfo(int $userId) {
        $userData = [];

        try {
            $query = "SELECT * FROM `users` WHERE id = '$userId'";
            $pdo_stmt = $this->db->query($query, PDO::FETCH_ASSOC);
            $result = $pdo_stmt->fetch();
            // update the product data
            $productData = $result;

        } catch (PDOException $e) {
            // TODO: handle the exception
        }
        return $result;
    }


    //update user
    public function updateUser($id, $firstname,$lastname, $mail, $user_role){
        $sql = "UPDATE users SET firstname = :firstname, lastname = :lastname, mail = :mail,
        user_role = :user_role WHERE id = :id";
        $sql_exe = $this->db->prepare($sql);
        $sql_exe->execute([
            'id' => $id,
            'firstname' => htmlspecialchars($firstname),
            'lastname' => htmlspecialchars($lastname),
            'mail' => htmlspecialchars($mail),
            'user_role' => htmlspecialchars($user_role),
        ]);         
        if ($sql_exe) {
            echo json_encode(['response' => 'ok', 'reussite' => 'Utilisateur modifié']);
        } else {
            echo json_encode(['response' => 'not ok', 'echoue' => 'Problème enregistrement']);
        }
    }

    //delete user

    public function deleteUser($idUser){
        $sql="DELETE FROM users WHERE id = :iduser";
        $sql_exe = $this->db->prepare($sql);
        $sql_exe->execute([
            'iduser' => $idUser
        ]);         
        if ($sql_exe) {
            return json_encode(['response' => 'ok', 'reussite' => 'Utilisateur supprimé']);
        } else {
            return json_encode(['response' => 'not ok', 'echoue' => 'Problème']);
        }
    }

    public function getInitials(){
        $firstnameInitials  = $this->firstname[0] ?? '';
        $lastnameInitials = $this->lastname[0] ?? '';
        return strtolower($firstnameInitials).strtolower($lastnameInitials);
    }


    /**
     * Method used to check if the current user is an admin
     *
     * @return bool - Returns TRUE if the user is an admin, FALSE otherwise
     */ 
    public function isAdmin(): bool {
      // do nothing if the user is not connected
      if (!$this->isConnected()) {
        return false;
      }

      // check if the user is an admin
      $isAdmin = $this->user_role === self::ROLE_ADMIN;

      // return `$isAdmin` value
      return $isAdmin;
    }

    /**
     * Returns the date of birth of the user
     *
     * @param bool $useDateFormat - If set to TRUE, the current `dateFormat` will be used when the user has no date of birth
     * @param string $dateFormat - The date format to use when the user has no date of birth
     * 
     * @return string 
     */
    public function getDateOfBirth(bool $useDateFormat = false, string $dateFormat = 'DD/MM/YYYY'): string {
      return $this->dob ?? ($useDateFormat ? $dateFormat : '');
    }


    /**
     * Returns the first name of the user
     *
     * @return string
     */
    public function getFirstName(): string {
      return $this->firstname ?? '';
    }


    /**
     * Returns the last name of the user
     *
     * @return string
     */
    public function getLastName(): string {
      return $this->lastname ?? '';
    }

    /**
     * Returns the user's full name
     *
     * @param bool $reversed - if TRUE, the name will be reversed (i.e. "Lastname Firstname")
     *
     * @return string - the user's full name
     */
    public function getFullname(bool $reversed = false): string {
      return ($this->isConnected()) ? $this->firstname . ' ' . $this->lastname : '';
    }

    /**
     * Returns the email of the user
     *
     * @return string
     */
    public function getEmail(): string {
      return $this->mail ?? '';
    }

    public function usersCount(){
        $displayUsers = $this->db->prepare("SELECT COUNT(*) FROM users");
        $displayUsers->execute([
        ]);
        $result = $displayUsers->fetchAll(PDO::FETCH_ASSOC);
        return $result;
    }



  // PRIVATE SETTERS

  /**
   * Sets the user's session data
   *
   * @param string $key - The key of the session variable to set (eg. `id`)
   * @param mixed $value - The value of the session variable to set (eg. `3`)
   *
   * @return void
   */
  private function setSession(string $key, mixed $value): void {
    // If the session does not exist, create it
    if ($this->checkSession() === false) { $this->createSession(); }

    // Set the given `$key` session variable to the given `$value`
    $_SESSION[self::SESSION_NAME][$key] = $value;
  }


  // PRIVATE GETTERS
  
  /**
   * Returns the user's session data if the `$key` parameter is NULL, 
   * or the value of the session variable corresponding to the `$key` parameter if not
   *
   * @param string|null $key - The key of the session variable to return
   *
   * @return mixed 
   */
  private function getSession(?string $key = null): mixed {
    return is_null($key) ? ($_SESSION[self::SESSION_NAME] ?? []) : ($_SESSION[self::SESSION_NAME][$key] ?? null);
  }


  // PRIVATE METHODS

  /**
   * Creates a session for the current user
   * NOTE: This method creates a `user` session variable
   *
   * @param array $user - The user data to store in the session (eg. `['id' => 1, 'firstname' => 'John']`)
   *
   * @return void
   */
  private function createSession(array $user): void {
    // If there is no `user` session variable
    if (!isset($_SESSION[self::SESSION_NAME])) {
      // Create the `user` session variable
      $_SESSION[self::SESSION_NAME] = [];
    }

    // Set the `user` session variable to the `$user` value
    $_SESSION[self::SESSION_NAME] = $user;
  }

  /**
   * Checks if the current user has a session
   * NOTE: This method checks if the `user` session variable exists,
   *       or if the `user` session variable has a specific `key`
   *
   * @param string|null $key - The key of the session variable to check
   *
   * @return bool - Returns TRUE if the session or specified `key` exists, FALSE otherwise, 
   */
  private function checkSession(?string $key = null): bool {
    return is_null($key) ? isset($_SESSION[self::SESSION_NAME]) : isset($_SESSION[self::SESSION_NAME][$key]);
  }


  /**
   * Destroys the session of the current user
   * NOTE: This method only destroys the `user` session variable
   *
   * @return void
   */
  private function destroySession(): void {
    // Destroy the session
    // session_destroy();

    // Unset the `user` session variable
    unset($_SESSION[self::SESSION_NAME]);
  }


  // +++++++ End of `Morgane Marechal` - CODE ++++++++

}