Come verificare se il cliente ha effettuato l'accesso o meno in magento 2?

Come scoprire se il cliente ha effettuato l'accesso o meno in Magento 2.

Se il cliente ha effettuato l'accesso, come ottenere i dati del cliente dalla sessione?

Seguendo il codice è possibile controllare l'accesso del cliente o non ovunque

$ objectManager = \ Magento \ Framework \ App \ ObjectManager :: getInstance ();
$ customerSession = $ objectManager-> get ('Magento \ Customer \ Model \ Session');
if ($ customerSession-> isLoggedIn ()) {
   // azione di accesso del cliente
}

Dal controller

$ This -> _ objectManager-> get ( 'Magento \ clienti \ modello \ Session');
if ($ customerSession-> isLoggedIn ()) {
   // azione di accesso del cliente
}

Promemoria importante: non si dovrebbe mai chiamare direttamente l'Object Manager

Ecco quindi come farlo in modo pulito

In qualsiasi classe tranne i modelli

Devi prima iniettare la seguente classe nel tuo costruttore /Magento/Customer/Model/Session::

protected $_session;

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

Quindi nella tua classe puoi chiamare quanto segue:

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

In un modello

Richiede un po 'più di lavoro in un modello in quanto dovrai impostare una preferenza per il blocco che rende il modello per farlo in modo pulito:

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

Quindi nel tuo block control personalizzato devi seguire la stessa iniezione di dipendenza di qualsiasi classe (spiegata sopra).

Il passaggio aggiuntivo qui è quello di creare un metodo pubblico che può essere utilizzato nel modello per verificare se un cliente ha effettuato l'accesso o meno

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

Quindi nel tuo modello puoi chiamare:

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

Alternativa se la sessione del cliente non è ancora inizializzata

C'è un altro modo di farlo che implica l'uso Magento\Framework\App\Http\Contextinvece diMagento/Customer/Model/Session

Quindi puoi chiamare $this->_context->getValue(\Magento\Customer\Model\Context::CONTEXT_AUTH)invece di $this->_session->isLoggedIn()verificare se il cliente ha effettuato l'accesso o meno.

Tuttavia, questo metodo può darti risultati diversi , ti suggerisco di leggere questa ottima risposta per ulteriori informazioni: https://magento.stackexchange.com/a/92133/2380

È possibile via Magento\Framework\App\Http\Contexto via Magento\Customer\Model\Session. Tuttavia, il risultato può essere diverso:

• Il contesto HTTP viene inizializzato prima della sessione del cliente (ma non importa poiché entrambi sono inizializzati nei controller di azione)
• Quando il PageCachemodulo è attivo (probabilmente sempre in produzione), tenere presente che non appena inizia la generazione del layout, la sessione del cliente verrà cancellata da \Magento\PageCache\Model\Layout\DepersonalizePlugin::afterGenerateXmltutte le pagine memorizzabili nella cache. Significa che se ora controlli se il cliente è connesso tramite contesto HTTP, continuerà a dire "sì", ma i dati del cliente non saranno più disponibili nella sessione del cliente. Quindi è necessario un doppio controllo prima di provare ad accedere ai dati nella sessione del cliente. Ciò può facilmente avvenire in blocco, mentre è improbabile nel controller di azione poiché non è previsto che generi layout manualmente lì, verrà generato dopo che il controller di azione restituisce l'istanza diResultInterface

Per eliminare qualsiasi rischio di incoerenze descritte quando PageCache è attivo, prendere in considerazione l'utilizzo della sessione del cliente, se è già inizializzata (vero per i controller di azione). Altrimenti usa il contesto 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);

Nessuna di queste soluzioni ha funzionato per me. Sembra che alcune pagine abbiano effettuato l'accesso ma altre no. Sembra che questo sia il bug:

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

Ho finito per creare un aiuto che potrei chiamare nei miei modelli:

<?php
namespace MyVendor\MyModule\Helper;

use Magento\Framework\App\Helper\AbstractHelper;

/**
 * Created by Carl Owens (carl@partfire.co.uk)
 * 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;
    }
}

Quindi potrei usare l'helper nei miei modelli in questo modo:

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

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

Per ottenere l'accesso dell'utente al modello, puoi semplicemente chiamare l'helper in una sola linea:

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

<?php if( $_loggedin ) : ?>

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

<?php endif; ?>

Nessuna delle soluzioni qui ha funzionato per me in modo affidabile in Magento v2.1 con Full Page Cache e Varnish abilitati in modalità Produzione. Alla fine ho trovato una soluzione che ha funzionato il 100% delle volte con tutta la cache abilitata dopo averne avuto l'idea vendor/magento/module-theme/view/frontend/templates/html/header.phtml. Ecco la mia soluzione, che mostra un collegamento "Accedi" quando l'utente è disconnesso e un collegamento "Esci" quando l'utente ha effettuato l'accesso:

<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>

AGGIORNAMENTO: Dalla v2.1.5 questa soluzione non è più affidabile. Vedere il numero 9156 per una soluzione.

Ci sono molte risposte là fuori che vanno qualcosa del genere ...

OTTIENI IL MANAGER DELL'OGGETTO CARICARE IL MODELLO DI CLASSE DO STUFF

Questa è la metodologia SBAGLIATA da usare in Magento2.0. Nel 2.0, le fabbriche di oggetti generate automaticamente sono la strada da percorrere. Puoi iniettarli nel tuo costruttore in quasi tutte le classi e usarli. Esempio:

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
            }

Ciao risposta qui:

$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
}

Fonte .

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

Sostituito get con create ora funziona bene:

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

Questa è anche una delle soluzioni "Verifica se il cliente è connesso o meno in Magento2"

Prova sotto il codice:

 $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()); 
 }

Prova sotto il codice:

<?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();
    }
}

Per usare il codice sopra nel file phtml puoi chiamare la funzione isLoggedIn () come:

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

Spero che questo aiuto, grazie.

Ho la soluzione migliore. Si basa sull'autenticazione del cliente . Alcune sessioni del cliente non funzionavano, ma ogni volta che la mia soluzione funzionava. Diamo un'occhiata.

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

Grazie.

Soluzione attualmente in uso (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;
    }
}

Se desideri controllare il cliente che ha effettuato l'accesso o meno, utilizza questo codice nei file 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()) {

}

Un'altra risposta:

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

Cosa ne pensi?

Il recupero dello stato registrato dal modello Session non funzionerà nel caso in cui si desideri utilizzarlo dopo aver abilitato la cache FPC predefinita di Magento, in tal caso, è necessario utilizzare SessionFactory.

La sessione non viene avviata se la memorizzazione nella cache FPC è abilitata, dettagli: https://github.com/magento/magento2/issues/3294#issuecomment-328464943

Per risolvere questo problema devi usare SessionFactory, ad esempio:

/**
* @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();
}

Ho provato molti modi trovati su Google, ma nessuna soluzione funziona. Quindi ho verificato la funzionalità di base e ho creato un file php per verificare che un cliente abbia effettuato l'accesso o meno senza utilizzare l'Object Manager.

            / **
         * Sessione cliente
         * Modulo creato da codici tecnologici Web
         * Sviluppato da Vinay Sikarwar
         * @var \ Magento \ Framework \ App \ Http \ Context
         * /
        $ session protetta;

        / **
         * Costruttore di registrazione.
         * @param Context $ context
         * @param array $ data
         * /
        funzione pubblica __construct (
            Context $ context,
                    \ Magento \ Framework \ Session \ Generic $ session,
            array $ data
        )
        {
                    $ this -> _ session = $ session;
                    costrutto parent :: __ ($ context, $ data);
        }

            / **
         * Verifica dello stato di accesso del cliente
         *
         * @api
         * @return bool
         * /
        funzione pubblica isCustomerLoggedIn ()
        {
            return (bool) $ this-> getCustomerId ()
                && $ this-> checkCustomerId ($ this-> getId ())
                &&! $ this-> getIsCustomerEmulated ();
        }
    }

Per maggiori informazioni, consulta qui http://blog.webtechnologycodes.com/customer-loggedin-check-magento2