Session et database - Apprendre-PHP.com

Bonsoir !

J'ai un problème au niveau de ma session et la base de donnée

prenons par exemple la class MYSQLUser si je souhaite récuperer les infos d'un user par son id je fais :

MYSQLUser
public static function findById($id)
  {
    $sql = 'SELECT * FROM '.self::T_USERS.'
         WHERE '.self::F_ID.'= ?';
 
    $pdo = self::getConnection();
    $statement = $pdo->prepare($sql);
 
    $statement->execute(array($id));
    $rs = $statement->fetch(PDO::FETCH_OBJ);
    if(empty($rs)) { return null; }
 
    $user = new User();
    $user->hydrateFromObject($rs);
 
    return $user;
  }

seulement voila j'ai aussi créer une class user !

et je pass en paramètre l'objet Session $session !

donc forcément quand je créer un nouvel user dans ma class MYSQLUser il me demande l'objet Session

et quand je lui met par curiosité il m'indique qu'une session exist déjà ! logique d'ailleurs !

donc voilà je suis un peu dans une impasse et je vois pas trop comment résoudre ce problème !

Si quelqu'un à une idée je suis prenneur ! 

Merci Vini

donc forcément quand je créer un nouvel user dans ma class MYSQLUser 
il me demande 'objet Session et quand je lui met par curiosité il m'indique 
qu'une session exist déjà ! logique d'ailleurs !

 Non, pourquoi logiqiue ? Pourquoi une session existe déjà si tu n'as pas encore créé l'utilisateur ?

Il faut peut être que tu distingues les sessions pour toi en temps qu'utilsateur, des sessions créées en temps que visiteur. 

merci pour ton aide !

en fait je créer dans mon controller de base un objet user et comme tu me la dit il faut peut etre que je distingue plusieur type d'utilisateur !

ca j'instancie ma class user comme ça $user = new User($session)

je le fais d'entré car j'ai mis en place un systeme de suivi du visiteur dans un but de statistic !

Cependant ton idée est bonne je n'avais pas vu les choses comme ça ! pourrais tu développé un peu stp ?

voici le model de ma class user qui herite de ma class Personqui contient les attribut communs à d'autre class pour l'avenir 

User
Class User extends Person
{
 
  private        $session      = null;
  protected      $culture      = null;
  protected      $tracker      = null;
  protected static   $availableCultures  = array();
 
 
  /**
   * Constructor
   * 
   * @access public
   * @param Session $session
   * @return void
   * 
   */
  public function __construct(Session $session)
  {
    $this->session = $session;
  }
 
 
  /**
   * Set the culture
   * 
   * @access public
   * @param $culture
   * @return mixed throw | $culture
   * 
   */
  public function setCulture($culture)
  {
    if(!$this->isValidCultures($culture))
    {
      throw new CultureException(sprintf('The given culture %s is not valid', $culture));
    }
    $this->setAttribute('user_culture', $culture);
  }
 
 
  /**
   * Return the culture
   * 
   * @access public
   * @return string $culture
   * 
   */
  public function getCulture()
  {
    return $this->getAttribute('user_culture');
  }
 
 
  /**
   * Set available Culture
   * 
   * @access public
   * @param $culture
   * @return array $culture
   * 
   */
  public function setAvailableCultures(Array $culture)
  {
    self::$availableCultures = $culture;
  }
 
 
  /**
   * Set Attribute
   * 
   * @access public
   * @param $name
   * @param $value
   * @return void
   * 
   */
  public function setAttribute($name,$value)
  {
    $this->session->setAttribute($name,$value);
  }
 
 
  /**
   * Returns the attribute from the session
   * 
   * @access public
   * @param $name
   * @return string $value
   * 
   */
  public function getAttribute($name)
  {
    return $this->session->getAttribute($name);
  }
 
 
  /**
   * Is valid Culture
   * 
   * @access public
   * @param array $culture
   * @return bool
   * 
   */
  protected function isValidCultures($culture)
  {
    return in_array($culture, self::$availableCultures);
  }
 
 
  public function setTracker(Tracker $tracker)
  {
    $this->tracker = $tracker;
  }
 
 
  /**
   * Add a new visit
   * 
   * @access public
   * @return Tracker::newVisitUser($this)
   * 
   */
  public function newVisitUser()
  {
    return Tracker::newVisitUser($this);
  }
 
 
  /**
   * Follow the visitor
   * 
   * @access public
   * @return Tracker::followUser($this);
   * 
   */
  public function followUser()
  {
    return Tracker::followUser($this);
  }
 
 
  /**
   * Save
   * 
   * 
   * @access public
   * @return MYSQL::Person(Person $Person)
   * 
   */
  public function save()
  {
    return MYSQLUser::save($this);
  }
 
 
  /**
   * Update
   * 
   * 
   * @access public
   * @return MYSQL::Person(Person $Person)
   * 
   */
  public function update()
  {
    return MYSQLUser::update($this);
  }
 
 
  /**
   * Delete
   * 
   * 
   * @access public
   * @return MYSQL::Person(Person $Person)
   * 
   */
  public function delete()
  {
    return MYSQLUser::delete($this);
  }
 
 
  /**
   * 
   * @return unknown_type
   */
  public function __toString()
  {
      return $str = '.....';
  }
 
  
 
}
?>

Salut,

 Je ne sais pas comment tu gères les sessions avec ta classe mais tu peux par exemple avoir une session utilisateur et une session suivie :

dans ton controller quand tu créés un user pour le suivie, tu lui passes ta session : $_session['suivie']

et lorsque tu récupères des données utilisateurs tu utilises une autre session : $_session['user']

De cette façon tu auras un user1 qui permet le suivie de celui-ci durant sa visite et un user2 qui te permettra te récupérer des informations.

Voila, je sais pas si c'est la meilleur méthode mais sa devrait faire l'affaire. Te reste plus qu'a voir ta classe session pour voir si elle gère les tableaux a plusieurs dimensions.

Bonsoir !

encore une fois j'avais pas pensé à ça ! tant mieux je dormirais moin bete ce soir !

ma classe Session est simple en voici l'extrait: 

Session
<?php
 
class Session
{
 
  public function __construct()
  {
    session_start();
  }
 
 
  public function setAttribute($name,$value)
  {
    $_SESSION[$name] = $value;
  }
 
 
  public function getAttribute($name)
  {
    return isset($_SESSION[$name]) ? $_SESSION[$name] : null;
  }
 
 
  public function setLifeTime($lifetime = 30)
  {
    //ini_set('session.gc_maxlifetime', $lifetime * 60);
  }
 
 
  public function clearSession()
  {
    session_destroy();
    $_SESSION = array();
    unset($_SESSION);
  }
}
?>

et en fait j'ai inclus l'appele de session dans mon controller de base de mon MVC 

c'est à dire comme je savais que j'allais copier ce code à chaque page pour suivre le visiteur je me suis suis plustot que de le dupliquer je le met une base dans la super class controller !

exemple: 

Abstract baseController
Abstract class baseController
{
 
  const USER_DEFAULT_CULTURE = 'FR';
 
  protected $registry;
  protected $user;
 
 
 
  public function __construct($registry)
  {
    $this->registry = $registry;
    $this->culture();
    $this->trackUser();
  }
 
 
  public function user()
  {
    $this->registry->user = new User(new Session());
    $this->registry->user->setTracker(new Tracker);
    return $this->user = $this->registry->user;
  }
 
 
  public function getUser()
  {
    return $this->registry->user;
  }
 
 
 
  protected function culture()
  {
    $lang = $this->registry->router->getCulture();
    User::setAvailableCultures(array('DE','BE','EN','ES','FR','IT','PT'));
 
    $user = $this->user();
 
    if(is_null($user->getCulture()))
    {
      $user->setCulture($this->registry->config['language']); 
    }
 
    if(!empty($lang))
    {
      try
      {
        $user->setCulture($lang);
      }
      catch(Exception $e)
      {
        throw $e;
      }
    }
 
    require( LANG_APPLICATION . $user->getCulture() .'.php');
  }
 
 
  public function trackUser()
  {
    $user = $this->user;
 
 
 
    if($user->getAttribute('follow'))
    {
      $user->followUser();
      echo $user->getAttribute('num_visitor');
    }
    else
    {
      $user->newVisitUser();
    }
  }
 
  abstract public function index();
 
}
?>