Comment vérifier si le client est connecté ou non à magento 2?

Comment savoir si un client est connecté ou non à Magento 2.

Si le client est connecté, comment obtenir les données client de la session?

Après le code, vous pouvez vérifier la connexion du client ou pas n'importe où

$ objectManager = \ Magento \ Framework \ App \ ObjectManager :: getInstance ();
$ customerSession = $ objectManager-> get ('Magento \ Client \ Modèle \ Session');
if ($ customerSession-> isLoggedIn ()) {
   // action de connexion du client
}

Du contrôleur

$ this -> _ objectManager-> get ('Magento \ Client \ Modèle \ Session');
if ($ customerSession-> isLoggedIn ()) {
   // action de connexion du client
}

Rappel important: il ne faut jamais appeler directement le gestionnaire d'objets

Voici donc comment le faire de façon propre

Dans toutes les classes sauf les modèles

Vous devez d’abord injecter la classe suivante dans votre constructeur /Magento/Customer/Model/Session:

protected $_session;

public function __construct(
    ...
    \Magento\Customer\Model\Session $session,
    ...
) {
    ...
    $this->_session = $session;
    ...
}

Ensuite, dans votre classe, vous pouvez appeler le suivant:

if ($this->_session->isLoggedIn()) {
    // Customer is logged in 
} else {
    // Customer is not logged in
}

Dans un modèle

Cela nécessite un peu plus de travail dans un modèle car vous devrez configurer une préférence pour le bloc qui le rend propre à le faire:

<preference for="Block\That\Renders\The\Template"
            type="Vendor\Module\Block\Your\Custom\Block" />

Ensuite, dans votre contrôleur de bloc personnalisé, vous devez suivre la même injection de dépendance que pour toute classe (expliquée ci-dessus).

L' étape supplémentaire consiste à créer une méthode publique pouvant être utilisée dans votre modèle pour vérifier si un client est connecté ou non.

public function isCustomerLoggedIn()
{
    return $this->_session->isLoggedIn();
}

Ensuite, dans votre modèle, vous pouvez appeler:

if ($block->isCustomerLoggedIn()) {
    // Customer is logged in
} else {
    // Customer is not logged in
}

Alternative si la session client n'est pas encore initialisée

Il y a une autre façon de le faire qui implique d'utiliser Magento\Framework\App\Http\Contextau lieu deMagento/Customer/Model/Session

Ensuite, vous pouvez appeler $this->_context->getValue(\Magento\Customer\Model\Context::CONTEXT_AUTH)au lieu de $this->_session->isLoggedIn()vérifier si le client est connecté ou non.

Cependant, cette méthode pouvant donner des résultats différents , je vous suggère de lire cette excellente réponse pour plus d'informations: https://magento.stackexchange.com/a/92133/2380

C'est possible via Magento\Framework\App\Http\Contextou via Magento\Customer\Model\Session. Cependant, le résultat peut être différent:

• Le contexte HTTP est initialisé avant la session client (mais cela n'a pas d'importance, car les deux sont initialisés dans des contrôleurs d'action)
• Lorsque le PageCachemodule est \Magento\PageCache\Model\Layout\DepersonalizePlugin::afterGenerateXmlactivé (probablement toujours en production), gardez à l'esprit que dès que la génération de la présentation a commencé, la session du client est effacée de toutes les pages pouvant être mises en cache. Cela signifie que si vous vérifiez maintenant si le client est connecté via HTTP, il indiquera toujours «oui», mais les données du client ne seront plus disponibles dans la session client. Un double contrôle est donc nécessaire avant d'essayer d'accéder aux données dans une session client. Cela peut facilement se produire en bloc, bien qu’il soit improbable dans le contrôleur d’action puisque vous n’êtes pas censé y générer manuellement la présentation, elle sera générée après que le contrôleur d’action ait renvoyé une instance deResultInterface

Pour éliminer tout risque d'incohérence décrite lorsque PageCache est activé, envisagez d'utiliser une session client si celle-ci est déjà initialisée (true pour les contrôleurs d'action). Sinon, utilisez le contexte HTTP.

/** @var \Magento\Framework\App\ObjectManager $om */
$om = \Magento\Framework\App\ObjectManager::getInstance();
/** @var \Magento\Framework\App\Http\Context $context */
$context = $om->get('Magento\Framework\App\Http\Context');
/** @var bool $isLoggedIn */
$isLoggedIn = $context->getValue(\Magento\Customer\Model\Context::CONTEXT_AUTH);

Aucune de ces solutions n'a fonctionné pour moi. Certaines pages semblent être connectées mais d'autres pas. Il semble que ce soit le bug:

https://github.com/magento/magento2/issues/3294

J'ai fini par créer un assistant que je pouvais appeler dans mes modèles:

<?php
namespace MyVendor\MyModule\Helper;

use Magento\Framework\App\Helper\AbstractHelper;

/**
 * Created by Carl Owens ([email protected])
 * Company: PartFire Ltd (www.partfire.co.uk)
 **/
class Data extends AbstractHelper
{
    /**
     * @var \Magento\Framework\App\Http\Context
     */
    private $httpContext;

    public function __construct(
        \Magento\Framework\App\Helper\Context $context,
        \Magento\Framework\App\Http\Context $httpContext
    ) {
        parent::__construct($context);
        $this->httpContext = $httpContext;
    }

    public function isLoggedIn()
    {
        $isLoggedIn = $this->httpContext->getValue(\Magento\Customer\Model\Context::CONTEXT_AUTH);
        return $isLoggedIn;
    }
}

Ensuite, je pourrais utiliser l’assistant dans mes modèles comme suit:

<?php
$helper = $this->helper('MyVendor\MyModule\Helper\Data');

if ($helper->isLoggedIn()) {
    //show something
}

Pour que l'utilisateur soit connecté au modèle, vous pouvez simplement appeler helper sur une seule ligne:

<?php $_loggedin = $this->helper('Magento\Checkout\Helper\Cart')->getCart()->getCustomerSession()->isLoggedIn(); ?>

<?php if( $_loggedin ) : ?>

     <div><!-- add your code --></div>

<?php endif; ?>

Aucune des solutions présentées ici ne fonctionnait de manière fiable dans Magento v2.1 avec la protection contre le cache Page complet et Varnish activées en mode Production. J'ai finalement trouvé une solution qui fonctionnait 100% du temps avec toute la mise en cache activée après avoir eu l'idée vendor/magento/module-theme/view/frontend/templates/html/header.phtml. Voici ma solution, qui affiche un lien "Sign In" lorsque l'utilisateur est déconnecté et un lien "Déconnexion" lorsque l'utilisateur est connecté:

<li data-bind="scope: 'customer'">
  <!-- ko if: customer().firstname  -->
  <a href="<?php echo $this->getUrl('customer/account/logout'); ?>" style="display:none;" data-bind="style: {display:'inline'}"><?php echo __('Sign Out') ?></a>
  <!-- /ko -->
  <!-- ko ifnot: customer().firstname  -->
  <a href="<?php echo $this->getUrl('customer/account/login'); ?>" style="display:none;" data-bind="style: {display:'inline'}"><?php echo __('Sign In') ?></a>
  <!-- /ko -->
  <script type="text/x-magento-init">
  {
    "*": {
      "Magento_Ui/js/core/app": {
        "components": {
          "customer": {
            "component": "Magento_Customer/js/view/customer"
          }
        }
      }
    }
  }
  </script>
</li>

MISE À JOUR: Depuis la version 2.1.5, cette solution n'est plus fiable. Voir le numéro 9156 pour une solution.

Il y a beaucoup de réponses là-bas qui vont quelque chose comme ça ...

OBTENIR UN GESTIONNAIRE D'OBJETS MODÈLE DE CLASSEMENT

C'est la méthodologie WRONG à utiliser dans Magento 2.0. En 2.0, les fabriques d'objets générées automatiquement sont la solution. Vous pouvez les injecter dans votre constructeur dans presque toutes les classes et les utiliser. Exemple:

public function __construct(
            Context $context,
            CollectionFactory $cmspageCollectionFactory,
            array $data = [],
            CustomerFactory $customerFactory,
            SessionFactory $sessionFactory)
        {
            parent::__construct($context, $data);
            $this->_cmspageCollectionFactory = $cmspageCollectionFactory;
            $this->customerFactory = $customerFactory;
            $this->sessionFactory = $sessionFactory;
        }

        /**
         * @return \Stti\Healthday\Model\ResourceModel\Cmspage\Collection
         */
        public function getCmspages()
        {
            // First check to see if someone is currently logged in.
            $customerSession = $this->sessionFactory->create();
            if ($customerSession->isLoggedIn()) {
                // customer is logged in;
                //$customer = $this->customerFactory->create()->get
            }

Bonjour a la réponse ici:

$objectManager = \Magento\Framework\App\ObjectManager::getInstance();
$customerSession = $objectManager->create('Magento\Customer\Model\Session');

if ($customerSession->isLoggedIn()) {
    $customerSession->getCustomerId();  // get Customer Id
    $customerSession->getCustomerGroupId();
    $customerSession->getCustomer();
    $customerSession->getCustomerData();

    echo $customerSessionget->getCustomer()->getName();  // get  Full Name
    echo $customerSessionget->getCustomer()->getEmail(); // get Email
}

Source .

$customerSession = $objectManager->get('Magento\Customer\Model\Session');

Remplacer get par create fonctionne maintenant très bien:

$customerSession = $objectManager->create('Magento\Customer\Model\Session');

C’est aussi l’une des solutions "Vérifier si le client est connecté ou non à Magento2"

Essayez ci-dessous le code:

 $om = \Magento\Framework\App\ObjectManager::getInstance();
 $context = $om->get('Magento\Framework\App\Http\Context');
 $isLoggedIn = $context->getValue(\Magento\Customer\Model\Context::CONTEXT_AUTH);
 if($isLoggedIn){
      echo "Yes Customer loggedin";
      echo "<pre>";print_r($context->getData()); 
 }

Essayez ci-dessous le code:

<?php
namespace YourCompany\ModuleName\Helper;

class Data extends \Magento\Framework\App\Helper\AbstractHelper
{
    public function __construct(
        \Magento\Framework\App\Helper\Context $context,
        \Magento\Customer\Model\Session $customerSession
    ) {
        $this->customerSession = $customerSession;
        parent::__construct($context);
    }

public function isLoggedIn() // You can use this fucntion in any phtml file
    {
        return $this->customerSession->isLoggedIn();
    }
}

Pour utiliser le code ci-dessus dans un fichier phtml, vous pouvez appeler la fonction isLoggedIn () en tant que:

<?php $helper = $this->helper('YourCompany\ModuleName\Helper\Data'); ?>
<?php if($helper->isLoggedIn()) : ?>
    logged in
<?php else : ?>
    not logged in
<?php endif; ?> 

J'espère que cette aide merci.

J'ai la meilleure solution. Il est basé sur l' authentification du client . Une partie de la session cliente ne fonctionnait pas, mais chaque fois que ma solution fonctionnerait. Nous allons jeter un coup d'oeil.

<?php
$objectManager = \Magento\Framework\App\ObjectManager::getInstance();
$customerSession = $objectManager->get('Magento\Customer\Block\Account\AuthorizationLink');
if ($customerSession->isLoggedIn() == true) {
//your code.
} ?>

Merci.

Solution actuellement utilisée (IMHO)

<?php

namespace My\Module\Helper\Data;

/**
 * @var \Magento\Framework\ObjectManagerInterface
 */
protected $objectManager;

/**
 * @var \Magento\Customer\Model\SessionFactory
 */
protected $customerSession;

/**
 * Class Data
 */
class Data extends \Magento\Framework\App\Helper\AbstractHelper
{
    /**
     * @param \Magento\Framework\ObjectManagerInterface $objectManager
     */
    public function __construct(
         \Magento\Framework\ObjectManagerInterface $objectManager
    )
    {
        $this->objectManager   = $objectManager;
        $this->customerSession = $this->objectManager->create('Magento\Customer\Model\SessionFactory')->create();
    }

    /**
     * @return \Magento\Customer\Model\SessionFactory
     */
    public function getCustomerSession()
    {
       return $this->customerSession;     
    }

    /**
     * @return bool
     */
    public function isCustomerLoggedIn()
    {
        return ($this->getCustomerSession()->isLoggedIn()) ? true : false;
    }
}

Si vous voulez vérifier le client connecté ou non, utilisez ce code dans les fichiers phtml,

$om = \Magento\Framework\App\ObjectManager::getInstance();
$appContext = $om->get('Magento\Framework\App\Http\Context');
$isLoggedIn = $appContext->getValue(\Magento\Customer\Model\Context::CONTEXT_AUTH);
if($isLoggedIn) {
    /** LOGGED IN CUSTOMER, this should work in template   **/
}

$objectManager = \Magento\Framework\App\ObjectManager::getInstance();
$customerSession = $objectManager->get('Magento\Customer\Model\Session');

if($customerSession->isLoggedIn()) {

}

Une autre réponse:

<?php $_loggedin = $block->getLayout()->createBlock('Magento\Customer\Block\Account\AuthorizationLink')->isLoggedIn() ?>
 <?php if( $_loggedin ) : ?>
   // your code
 <?php endif; ?>

Qu'est-ce que tu penses?

L'extraction du statut enregistré à partir du modèle de session ne fonctionnera pas si vous souhaitez l'utiliser après avoir activé le cache FPC par défaut de Magento. Dans ce cas, vous devez utiliser SessionFactory à la place.

La session n'est pas lancée si la mise en cache FPC est activée, détails: https://github.com/magento/magento2/issues/3294#issuecomment-328464943.

Pour résoudre ce problème, vous devez utiliser SessionFactory, par exemple:

/**
* @var \Magento\Customer\Model\Session
*/
protected $_customerSessionFactory;

public function __construct(
    ....
    \Magento\Customer\Model\SessionFactory $customerSessionFactory
    ....
) 
{
    ....
    $this->_customerSessionFactory = $customerSessionFactory;
    ....
}

public function getCustomerId(){
  $customer = $this->_customerSessionFactory->create();
  echo $customer->getCustomer()->getId();
}

J'ai essayé de nombreuses manières trouvées sur Google mais aucune des solutions ne fonctionne. J'ai donc vérifié la fonctionnalité principale et créé un fichier php pour vérifier si un client est connecté ou non sans utiliser le gestionnaire d'objets.

            / **
         * Session client
         * Module créé par Web Technology Codes
         * Développé par Vinay Sikarwar
         * @var \ Magento \ Framework \ App \ Http \ Contexte
         * /
        session protégée;

        / **
         * Constructeur d'enregistrement.
         * @param Context $ context
         * @param array $ data
         * /
        fonction publique __construct (
            Context $ context,
                    \ Magento \ Framework \ Session \ Generic $ session,
            tableau $ data
        )
        {
                    $ this -> _ session = $ session;
                    parent :: __ construct ($ context, $ data);
        }

            / **
         * Vérification de l'état de connexion du client
         *
         * @api
         * @return bool
         * /
        fonction publique isCustomerLoggedIn ()
        {
            return (bool) $ this-> getCustomerId ()
                && $ this-> checkCustomerId ($ this-> getId ())
                &&! $ this-> getIsCustomerEmulated ();
        }
    }

Pour plus d'informations, voir ici http://blog.webtechnologycodes.com/customer-loggedin-check-magento2