I create an attribute name [show_on_category_page] with yes/no values if it’s set to yes then the product show on the category page but if its select no, then product not shown on category page.
After that in vendor module catalog file [listproduct.php] I set the condition to fetch that products only which have attribute [show_on_category_page == 1].Its show to that products only which have [show_on_category_page == 1] but its leave space empty from the product is hidden, plus its show total number of products count wrong too for example total products in category is 32 & I set [show_on_category_page == 0] to 2 products, so mean in frontend it should show the 30 products but its show 32.
Its the function in which I set my condition :
protected function _getProductCollection()
{
if ($this->_productCollection === null) {
$result = $this->initializeProductCollection();
$this->_productCollection = $result->addAttributeToFilter('show_on_category_page', ['eq' => 1]);
}
return $this->_productCollection;
}
Here is the full code of vendor file :
declare(strict_types=1);
namespace MagentoCatalogBlockProduct;
use MagentoCatalogApiCategoryRepositoryInterface;
use MagentoCatalogBlockProductProductListToolbar;
use MagentoCatalogModelCategory;
use MagentoCatalogModelConfig;
use MagentoCatalogModelLayer;
use MagentoCatalogModelLayerResolver;
use MagentoCatalogModelProduct;
use MagentoCatalogModelResourceModelProductCollection;
use MagentoCatalogPricingPriceFinalPrice;
use MagentoEavModelEntityCollectionAbstractCollection;
use MagentoFrameworkAppActionInterface;
use MagentoFrameworkAppConfigElement;
use MagentoFrameworkDataHelperPostHelper;
use MagentoFrameworkDataObjectIdentityInterface;
use MagentoFrameworkExceptionNoSuchEntityException;
use MagentoFrameworkPricingRender;
use MagentoFrameworkUrlHelperData;
use MagentoFrameworkAppObjectManager;
use MagentoCatalogHelperOutput as OutputHelper;
use MonologLogger;
use MonologHandlerStreamHandler;
/**
* Product list
* @api
* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
* @since 100.0.2
*/
class ListProduct extends AbstractProduct implements IdentityInterface
{
/**
* Default toolbar block name
*
* @var string
*/
protected $_defaultToolbarBlock = Toolbar::class;
/**
* Product Collection
*
* @var AbstractCollection
*/
protected $_productCollection;
/**
* Catalog layer
*
* @var Layer
*/
protected $_catalogLayer;
/**
* @var PostHelper
*/
protected $_postDataHelper;
/**
* @var Data
*/
protected $urlHelper;
/**
* @var CategoryRepositoryInterface
*/
protected $categoryRepository;
/**
* @param Context $context
* @param PostHelper $postDataHelper
* @param Resolver $layerResolver
* @param CategoryRepositoryInterface $categoryRepository
* @param Data $urlHelper
* @param array $data
* @param OutputHelper|null $outputHelper
*/
public function __construct(
Context $context,
PostHelper $postDataHelper,
Resolver $layerResolver,
CategoryRepositoryInterface $categoryRepository,
Data $urlHelper,
array $data = [],
?OutputHelper $outputHelper = null
) {
$this->_catalogLayer = $layerResolver->get();
$this->_postDataHelper = $postDataHelper;
$this->categoryRepository = $categoryRepository;
$this->urlHelper = $urlHelper;
$data['outputHelper'] = $outputHelper ?? ObjectManager::getInstance()->get(OutputHelper::class);
parent::__construct(
$context,
$data
);
}
/**
* Retrieve loaded product collection
*
* The goal of this method is to choose whether the existing collection should be returned
* or a new one should be initialized.
*
* It is not just a caching logic, but also is a real logical check
* because there are two ways how collection may be stored inside the block:
* - Product collection may be passed externally by 'setCollection' method
* - Product collection may be requested internally from the current Catalog Layer.
*
* And this method will return collection anyway,
* even when it did not pass externally and therefore isn't cached yet
*
* @return AbstractCollection
*/
protected function _getProductCollection()
{
if ($this->_productCollection === null) {
$result = $this->initializeProductCollection();
$this->_productCollection = $result->addAttributeToFilter('show_on_category_page', ['eq' => 1]);
}
return $this->_productCollection;
}
/**
* Get catalog layer model
*
* @return Layer
*/
public function getLayer()
{
return $this->_catalogLayer;
}
/**
* Retrieve loaded category collection
*
* @return AbstractCollection
*/
public function getLoadedProductCollection()
{
return $this->_getProductCollection();
}
/**
* Retrieve current view mode
*
* @return string
*/
public function getMode()
{
if ($this->getChildBlock('toolbar')) {
return $this->getChildBlock('toolbar')->getCurrentMode();
}
return $this->getDefaultListingMode();
}
/**
* Get listing mode for products if toolbar is removed from layout.
* Use the general configuration for product list mode from config path catalog/frontend/list_mode as default value
* or mode data from block declaration from layout.
*
* @return string
*/
private function getDefaultListingMode()
{
// default Toolbar when the toolbar layout is not used
$defaultToolbar = $this->getToolbarBlock();
$availableModes = $defaultToolbar->getModes();
// layout config mode
$mode = $this->getData('mode');
if (!$mode || !isset($availableModes[$mode])) {
// default config mode
$mode = $defaultToolbar->getCurrentMode();
}
return $mode;
}
/**
* Need use as _prepareLayout - but problem in declaring collection from another block.
* (was problem with search result)
*
* @return $this
*/
protected function _beforeToHtml()
{
$collection = $this->_getProductCollection();
$this->addToolbarBlock($collection);
if (!$collection->isLoaded()) {
$collection->load();
}
$categoryId = $this->getLayer()->getCurrentCategory()->getId();
if ($categoryId) {
foreach ($collection as $product) {
$product->setData('category_id', $categoryId);
}
}
return parent::_beforeToHtml();
}
/**
* Add toolbar block from product listing layout
*
* @param Collection $collection
*/
private function addToolbarBlock(Collection $collection)
{
$toolbarLayout = $this->getToolbarFromLayout();
if ($toolbarLayout) {
$this->configureToolbar($toolbarLayout, $collection);
}
}
/**
* Retrieve Toolbar block from layout or a default Toolbar
*
* @return Toolbar
*/
public function getToolbarBlock()
{
$block = $this->getToolbarFromLayout();
if (!$block) {
$block = $this->getLayout()->createBlock($this->_defaultToolbarBlock, uniqid(microtime()));
}
return $block;
}
/**
* Get toolbar block from layout
*
* @return bool|Toolbar
*/
private function getToolbarFromLayout()
{
$blockName = $this->getToolbarBlockName();
$toolbarLayout = false;
if ($blockName) {
$toolbarLayout = $this->getLayout()->getBlock($blockName);
}
return $toolbarLayout;
}
/**
* Retrieve additional blocks html
*
* @return string
*/
public function getAdditionalHtml()
{
return $this->getChildHtml('additional');
}
/**
* Retrieve list toolbar HTML
*
* @return string
*/
public function getToolbarHtml()
{
return $this->getChildHtml('toolbar');
}
/**
* Set collection.
*
* @param AbstractCollection $collection
* @return $this
*/
public function setCollection($collection)
{
$this->_productCollection = $collection;
return $this;
}
/**
* Add attribute.
*
* @param array|string|integer|Element $code
* @return $this
*/
public function addAttribute($code)
{
$this->_getProductCollection()->addAttributeToSelect($code);
return $this;
}
/**
* Get price block template.
*
* @return mixed
*/
public function getPriceBlockTemplate()
{
return $this->_getData('price_block_template');
}
/**
* Retrieve Catalog Config object
*
* @return Config
*/
protected function _getConfig()
{
return $this->_catalogConfig;
}
/**
* Prepare Sort By fields from Category Data
*
* @param Category $category
* @return $this
*/
public function prepareSortableFieldsByCategory($category)
{
if (!$this->getAvailableOrders()) {
$this->setAvailableOrders($category->getAvailableSortByOptions());
}
$availableOrders = $this->getAvailableOrders();
if (!$this->getSortBy()) {
$categorySortBy = $this->getDefaultSortBy() ?: $category->getDefaultSortBy();
if ($categorySortBy) {
if (!$availableOrders) {
$availableOrders = $this->_getConfig()->getAttributeUsedForSortByArray();
}
if (isset($availableOrders[$categorySortBy])) {
$this->setSortBy($categorySortBy);
}
}
}
return $this;
}
/**
* Return identifiers for produced content
*
* @return array
*/
public function getIdentities()
{
$identities = [];
$category = $this->getLayer()->getCurrentCategory();
if ($category) {
$identities[] = [Product::CACHE_PRODUCT_CATEGORY_TAG . '_' . $category->getId()];
}
//Check if category page shows only static block (No products)
if ($category->getData('display_mode') != Category::DM_PAGE) {
foreach ($this->_getProductCollection() as $item) {
$identities[] = $item->getIdentities();
}
}
$identities = array_merge([], ...$identities);
return $identities;
}
/**
* Get post parameters
*
* @param Product $product
* @return array
*/
public function getAddToCartPostParams(Product $product)
{
$url = $this->getAddToCartUrl($product, ['_escape' => false]);
return [
'action' => $url,
'data' => [
'product' => (int) $product->getEntityId(),
ActionInterface::PARAM_NAME_URL_ENCODED => $this->urlHelper->getEncodedUrl($url),
]
];
}
/**
* Get product price.
*
* @param Product $product
* @return string
*/
public function getProductPrice(Product $product)
{
$priceRender = $this->getPriceRender();
$price = '';
if ($priceRender) {
$price = $priceRender->render(
FinalPrice::PRICE_CODE,
$product,
[
'include_container' => true,
'display_minimal_price' => true,
'zone' => Render::ZONE_ITEM_LIST,
'list_category_page' => true
]
);
}
return $price;
}
/**
* Specifies that price rendering should be done for the list of products.
* (rendering happens in the scope of product list, but not single product)
*
* @return Render
*/
protected function getPriceRender()
{
return $this->getLayout()->getBlock('product.price.render.default')
->setData('is_product_list', true);
}
/**
* Configures product collection from a layer and returns its instance.
*
* Also in the scope of a product collection configuration, this method initiates configuration of Toolbar.
* The reason to do this is because we have a bunch of legacy code
* where Toolbar configures several options of a collection and therefore this block depends on the Toolbar.
*
* This dependency leads to a situation where Toolbar sometimes called to configure a product collection,
* and sometimes not.
*
* To unify this behavior and prevent potential bugs this dependency is explicitly called
* when product collection initialized.
*
* @return Collection
*/
private function initializeProductCollection()
{
$layer = $this->getLayer();
/* @var $layer Layer */
if ($this->getShowRootCategory()) {
$this->setCategoryId($this->_storeManager->getStore()->getRootCategoryId());
}
// if this is a product view page
if ($this->_coreRegistry->registry('product')) {
// get collection of categories this product is associated with
$categories = $this->_coreRegistry->registry('product')
->getCategoryCollection()->setPage(1, 1)
->load();
// if the product is associated with any category
if ($categories->count()) {
// show products from this category
$this->setCategoryId($categories->getIterator()->current()->getId());
}
}
$origCategory = null;
if ($this->getCategoryId()) {
try {
$category = $this->categoryRepository->get($this->getCategoryId());
} catch (NoSuchEntityException $e) {
$category = null;
}
if ($category) {
$origCategory = $layer->getCurrentCategory();
$layer->setCurrentCategory($category);
}
}
$collection = $layer->getProductCollection();
$this->prepareSortableFieldsByCategory($layer->getCurrentCategory());
if ($origCategory) {
$layer->setCurrentCategory($origCategory);
}
$this->_eventManager->dispatch(
'catalog_block_product_list_collection',
['collection' => $collection]
);
return $collection;
}
/**
* Configures the Toolbar block with options from this block and configured product collection.
*
* The purpose of this method is the one-way sharing of different sorting related data
* between this block, which is responsible for product list rendering,
* and the Toolbar block, whose responsibility is a rendering of these options.
*
* @param ProductListToolbar $toolbar
* @param Collection $collection
* @return void
*/
private function configureToolbar(Toolbar $toolbar, Collection $collection)
{
// use sortable parameters
$orders = $this->getAvailableOrders();
if ($orders) {
$toolbar->setAvailableOrders($orders);
}
$sort = $this->getSortBy();
if ($sort) {
$toolbar->setDefaultOrder($sort);
}
$dir = $this->getDefaultDirection();
if ($dir) {
$toolbar->setDefaultDirection($dir);
}
$modes = $this->getModes();
if ($modes) {
$toolbar->setModes($modes);
}
// set collection to toolbar and apply sort
$toolbar->setCollection($collection);
$this->setChild('toolbar', $toolbar);
}
}
Can anyone suggest me where I am wrong in this ?