Ottenere l'URL dell'immagine completa del prodotto nel modello

Sto cercando di creare un blocco statico per mostrare prodotti dinamici. Questo è il codice che dovrebbe ottenere ogni categoria figlio e stampare l'immagine per ciascun prodotto in ciascuna categoria.

<?php
    $objectManager = \Magento\Framework\App\ObjectManager::getInstance();
    $category = $objectManager->get('Magento\Framework\Registry')->registry('current_category');
    ?><ol><?php
    foreach ($category->getChildrenCategories() as $child_category) {
        ?><li>
            <ul><?php
                foreach ($child_category->getProductCollection() as $product) {
                    ?><li><img src="<?php echo $product->getImage();?>"/><li><?php
                }
            ?></ul>
        </li><?php
    }
    ?></ol>

Funziona quasi, tranne che per gli img srcs sono solo "/a/b/ab001.jpg" come esempio e non il percorso completo, ad esempio "/ pub / media / catalogue / product / cache / 1 / small_image / 240x300 / abc123def456 / a / b / 001.jpg "quindi non è possibile trovare le immagini. Qual è il modo corretto di ottenere immagini dei prodotti?

Se il blocco si estende Magento\Catalog\Block\Product\AbstractProduct, puoi utilizzare:

$imageType = 'category_page_list'; // choose which image
$image = $block->getImage($product, $imageType);

Quindi ottenere l'URL dell'immagine con

$image->getImageUrl();

o se vuoi emetterlo come <img>elemento:

echo $image->toHtml();

Se il blocco non estende / non può estendere il blocco del prodotto astratto, puoi creare un getImage()metodo da solo:

public function getImage($product, $imageId)
{
    return $this->imageBuilder->setProduct($product)
        ->setImageId($imageId)
        ->create();
}

$this->imageBuilder deve essere iniettato come Magento\Catalog\Block\Product\ImageBuilder

Le variabili $imageTypeo $imageIddovrebbero essere uno dei tipi di immagine definiti nel tema, ad esempio category_page_list.

Vedi app/design/frontend/Magento/luma/etc/view.xmlper tutti i tipi di immagine nel tema Luma, per esempio.

In Magento 2 vengono utilizzati questi tipi di immagine anziché definire la larghezza e l'altezza direttamente nel modello.

Se è necessario ridimensionare l'immagine del prodotto e utilizzare il sistema di cache delle immagini Magento predefinito e non ci si trova nell'area di frontend, è possibile utilizzare questa soluzione alternativa.

Caso d'uso: può essere utile se hai bisogno di ridimensionare gli URL immagine sull'API personalizzata per un'applicazione esterna.

Codice funzione:

/**
 * @var \Magento\Catalog\Model\ProductFactory
 */
protected $productFactory;

/**
 * @var \Magento\Catalog\Helper\ImageFactory
 */
protected $helperFactory;

/**
 * @var \Magento\Store\Model\App\Emulation
 */
protected $appEmulation;

/**
 * Constructor.
 *
 * @param \Magento\Catalog\Model\ProductFactory $productFactory
 * @param \Magento\Store\Model\App\Emulation $appEmulation
 * @param \Magento\Catalog\Helper\ImageFactory $helperFactory
 * @param \Magento\Store\Model\StoreManagerInterface $storeManager
 */
public function __construct(
    \Magento\Catalog\Model\ProductFactory $productFactory,
    \Magento\Store\Model\App\Emulation $appEmulation,
    \Magento\Catalog\Helper\ImageFactory $helperFactory,
    \Magento\Store\Model\StoreManagerInterface $storeManager,
) {
    $this->productFactory                   = $productFactory;
    $this->imageBuilder                     = $imageBuilder;
    $this->helperFactory                    = $helperFactory;
    $this->appEmulation                     = $appEmulation;
    $this->storeManager                     = $storeManager;
}

/**
 * Retrieve product image
 *
 * @param \Magento\Catalog\Model\Product $product
 * @param string $imageId
 * @param array $attributes
 * @return \Magento\Catalog\Block\Product\Image
 */
public function getImage($product, $imageId, $attributes = [])
{
    $image = $this->helperFactory->create()->init($product, $imageId)
        ->constrainOnly(true)
        ->keepAspectRatio(true)
        ->keepTransparency(true)
        ->keepFrame(false)
        ->resize(200, 300);

    return $image;
}

public function customFunction()
{
    // some stuff here

    $storeId = $this->storeManager->getStore()->getId();

    $this->appEmulation->startEnvironmentEmulation($storeId, \Magento\Framework\App\Area::AREA_FRONTEND, true);

    $product = $this->productFactory->create()->loadByAttribute('sku', 'productSKU');
    $imageUrl = $this->getImage($product, 'product_base_image')->getUrl();

    echo $imageUrl;

    $this->appEmulation->stopEnvironmentEmulation();

    // some stuff here
}

L'esempio di output:

http://{domain}/media/catalog/product/cache/1/image/200x300/e9c3970ab036de70892d86c6d221abfe/s/r/{imageName}.jpg

Commenti :

Il terzo parametro della funzione startEnvironmentEmulation viene utilizzato per forzare l'uso dell'area frontend se si è già nello stesso storeId. (utile per l'area API)

Questa soluzione alternativa ti evita di avere questo tipo di errori:

http://XXXX.com/pub/static/webapi_rest/_view/en_US/Magento_Catalog/images/product/placeholder/.jpg

Uncaught Magento\Framework\View\Asset\File\NotFoundException: Unable to resolve the source file for 'adminhtml/_view/en_US/Magento_Catalog/images/product/placeh‌​older/.jpg'

Provalo

$store = $objectManager->get('Magento\Store\Model\StoreManagerInterface')->getStore();
$imageUrl = $store->getBaseUrl(\Magento\Framework\UrlInterface::URL_TYPE_MEDIA) . 'catalog/product' . $product->getImage();

Prova questo codice ..

$ProductImageUrl = $block->getUrl('pub/media/catalog').'product'.$_product->getImage();

Forse Magento\Catalog\Helper\Product::getImageUrl()potrebbe aiutare. Non capisco perché gli sviluppatori Magento non lo abbiano implementato in Magento\Catalog\Helper\Imageclasse poiché il getUrlmetodo nell'helper delle immagini non restituisce ciò che ci si potrebbe aspettare ...

Per favore prova questo codice:

$prdId = 35;
$objectManager = \Magento\Framework\App\ObjectManager::getInstance();
$hotPrd = $objectManager->get('Magento\Catalog\Model\Product')->load($prdId);
$store = $objectManager->get('Magento\Store\Model\StoreManagerInterface')->getStore();
echo $store->getBaseUrl(\Magento\Framework\UrlInterface::URL_TYPE_MEDIA) . 'catalog/product' . $hotPrd->getThumbnail();

È possibile utilizzare ObjectManager o Block.

Objectmanager:

$objectManager = \Magento\Framework\App\ObjectManager::getInstance();
$store = $objectManager->get('Magento\Store\Model\StoreManagerInterface')->getStore();
$imageUrl = $store->getBaseUrl(\Magento\Framework\UrlInterface::URL_TYPE_MEDIA) . 'catalog/product' . $product->getImage();

Blocco:

protected $_storeManagerInterface;

public function __construct(
  ...
  \Magento\Store\Model\StoreManagerInterface $storeManagerInterface,
  ...
)
{
  ...
  $this->_storeManagerInterface = $storeManagerInterface;
  ...
}

...

public function getStoreInterface($imgUrl){
   $store = $this->_storeManagerInterface->getStore();
   $storeMedia = $store->getBaseUrl(\Magento\Framework\UrlInterface::URL_TYPE_MEDIA) . 'catalog/product' . $imgUrl;
   return $storeMedia;
}
...

Chiama la funzione:

<img src="<?php echo $block->getStoreInterface($imgUrl) ?>"/>

Prova questo codice

<img class="test-image" alt="image" src="<?php echo $block->getUrl('pub/media/catalog/product', ['_secure' => $block->getRequest()->isSecure()]).$product->getImage();?>" />

Spero che questo ti possa aiutare

Nel tuo modulo:

public function getProducts()
{
    //... create collection code goes here...

    $result = [ ];

    foreach ( $collection as $product ) {
        $result[] = [
            'id'        => $product->getId(),
            '_sku'      => $product->getSku(),
            'permalink' => $product->getProductUrl($product),
            'title'     => $product->getName(),
            'raw_price' => $product->getPrice(),
            'image_url' => $this->getUrl().'pub/media/catalog/product'.$product->getImage()
        ];
    }

    return $result;
}

Quindi nel tuo blocco otterrai questo risultato:

print_r($block->getProducts());

Bene, non è perfetto, ma funziona per me.

Dai un'occhiata al risultato:

Nella tua classe iniettare dipendenza StoreManagerInterface come:

use \Magento\Framework\View\Element\Template\Context;
use \Magento\Store\Model\StoreManagerInterface;

public function __construct(Context $context, StoreManagerInterfac $storeManager)
    {
        parent::__construct($context);
        $this->_storeManager = $storeManager;

    }

dopo nel tuo metodo, ad esempio per ottenere thumbail

public function getProductThumbnail(){

        return $this->_storeManager->getStore()->getBaseUrl(\Magento\Framework\UrlInterface::URL_TYPE_MEDIA) . 'catalog/product' . $product->getImage();
    }

Puoi provare questo sotto il codice.

$objectManager = \Magento\Framework\App\ObjectManager::getInstance();
$category = $objectManager->get('Magento\Framework\Registry')->registry('current_category');
$childcategories = $category->getChildrenCategories();

foreach($childcategories as $child)
    {
echo '<li class="sub-cat">';
        $cat = $objectManager->create('Magento\Catalog\Model\Category')->load($child->getId()); 
        ?>
        <a href="<?php echo $cat->getUrl(); ?>">
        <div class="sub-title">
            <h3><?php echo $cat->getName();?></h3>
        </div> 
    <?php
        if ($_imgUrl = $cat->getImageUrl())
        {
            $_imgHtml = '<div class="category-image"><img src="' . $_imgUrl . '" alt="' . $block->escapeHtml($cat->getName()) . '" title="' . $block->escapeHtml($cat->getName()) . '" class="image" /></div>';
            $_imgHtml = $_helper->categoryAttribute($cat, $_imgHtml, 'image');
            /* @escapeNotVerified */ echo $_imgHtml;
        }  

    ?>      
    <?php echo '</a></li>'; }
    echo '</ul>';
}

Questo è un altro metodo di lavoro:

/** @var \Magento\Framework\UrlInterface $urlManager */
$url = $urlManager->getDirectUrl('pub/media/catalog/product' . $product->getImage());

O rispettando l'URL sicuro / insicuro in base alla richiesta corrente:

/** @var \Magento\Framework\UrlInterface $urlManager */
/** @var \Magento\Framework\App\RequestInterface $request */
$url = $urlManager->getDirectUrl(
    'pub/media/catalog/product' . $product->getImage(),
    ['_secure' => $request->isSecure()]
);

Lascio l'istanza dell'oggetto alla tua immaginazione.

Possiamo ottenere l'URL dell'immagine di base nel file phtml

$_objectManager = \Magento\Framework\App\ObjectManager::getInstance();
$imageHelper  = $_objectManager->get('\Magento\Catalog\Helper\Image');
<?php $image_url = $imageHelper->init($product, 'product_base_image')->setImageFile($product->getFile())->resize($imagewidth, $imageheight)->getUrl(); ?>