/**
* Get or create new instance of category
*
* @return \Magento\Catalog\Model\Product
*/
private function _getCategory()
{
if (!$this->hasData('category')) {
$this->setCategory($this->_categoryFactory->create());
}
return $this->getCategory();
}
/**
* Get parent category options
*
* @return array
*/
protected function _getParentCategoryOptions()
{
$items = $this->_categoryFactory->create()->getCollection()->addAttributeToSelect('name')->addAttributeToSort('entity_id', 'ASC')->setPageSize(3)->load()->getItems();
$result = array();
if (count($items) === 2) {
$item = array_pop($items);
$result = array($item->getEntityId() => $item->getName());
}
return $result;
}
/**
* @param int $id
* @return CategoryModel
* @throws \Magento\Framework\Exception\NoSuchEntityException
*/
private function getCategory($id)
{
/** @var CategoryModel $category */
$category = $this->categoryFactory->create();
$category->load($id);
if (!$category->getId()) {
throw NoSuchEntityException::singleField(Category::ID, $id);
}
return $category;
}
/**
* @param int $categoryId
* @return Category
* @throws \Magento\Framework\Exception\NoSuchEntityException
*/
public function load($categoryId)
{
/** @var Category $category */
$category = $this->categoryFactory->create();
$category->load($categoryId);
if (!$category->getId()) {
throw new NoSuchEntityException('There is no category with provided ID');
}
return $category;
}
/**
* @SuppressWarnings(PHPMD.UnusedLocalVariable)
*/
protected function setUp()
{
/** @var \Magento\Framework\Registry $var */
$this->coreRegistry = $var = $this->getMockBuilder('\\Magento\\Framework\\Registry')->disableOriginalConstructor()->setMethods(['register'])->getMock();
$this->category = $this->getMockBuilder('Magento\\Catalog\\Model\\Category')->disableOriginalConstructor()->setMethods(['getId', 'setStoreId', 'load', 'getPathIds'])->getMock();
$this->categoryFactory = $this->getMockBuilder('Magento\\Catalog\\Model\\CategoryFactory')->disableOriginalConstructor()->setMethods(['create'])->getMock();
$this->categoryFactory->expects($this->any())->method('create')->will($this->returnValue($this->category));
$this->store = $this->getMockBuilder('\\Magento\\Store\\Model\\Store')->disableOriginalConstructor()->setMethods(['getId'])->getMock();
$this->layer = $this->getMockBuilder('Magento\\Catalog\\Model\\Layer')->disableOriginalConstructor()->setMethods(['getCurrentStore', 'getCurrentCategory'])->getMock();
$this->layer->expects($this->any())->method('getCurrentStore')->will($this->returnValue($this->store));
$objectManagerHelper = new ObjectManagerHelper($this);
$this->target = $objectManagerHelper->getObject('Magento\\Catalog\\Model\\Layer\\Filter\\DataProvider\\Category', ['coreRegistry' => $this->coreRegistry, 'categoryFactory' => $this->categoryFactory, 'layer' => $this->layer]);
}
/**
* {@inheritdoc}
*/
public function tree($rootCategoryId = null, $depth = null)
{
$category = null;
if (!is_null($rootCategoryId)) {
/** @var \Magento\Catalog\Model\Category $category */
$category = $this->categoryFactory->create()->load($rootCategoryId);
if (!$category->getId()) {
throw new \Magento\Framework\Exception\NoSuchEntityException('Root Category does not exist');
}
}
$result = $this->categoryTree->getTree($this->categoryTree->getRootNode($category), $depth);
return $result;
}
/**
* Creates a category.
*
* @param string $name
* @param int $parentId
*
* @return int
*/
protected function createCategory($name, $parentId)
{
/** @var \Magento\Catalog\Model\Category $category */
$category = $this->categoryFactory->create();
$parentCategory = $this->categoryFactory->create()->load($parentId);
$category->setPath($parentCategory->getPath());
$category->setParentId($parentId);
$category->setName($name);
$category->setIsActive(true);
$category->setIncludeInMenu(true);
$category->setAttributeSetId($category->getDefaultAttributeSetId());
$category->save();
return $category->getId();
}
/**
* Get all categories
*
* @param bool $sorted
* @param bool $asCollection
* @param bool $toLoad
*
* @return array|\Magento\Catalog\Model\ResourceModel\Category\Collection|\Magento\Framework\Data\Tree\Node\Collection
*/
public function getCategories($sorted = false, $asCollection = false, $toLoad = true)
{
$cacheKey = sprintf('%d-%d-%d-%d', $this->getSelectedRootCategory(), $sorted, $asCollection, $toLoad);
if (isset($this->_storeCategories[$cacheKey])) {
return $this->_storeCategories[$cacheKey];
}
/**
* Check if parent node of the store still exists
*/
$category = $this->_categoryFactory->create();
$storeCategories = $category->getCategories($this->getSelectedRootCategory(), $recursionLevel = 1, $sorted, $asCollection, $toLoad);
$this->_storeCategories[$cacheKey] = $storeCategories;
return $storeCategories;
}
/**
* @return \Magento\Catalog\Model\Category
*/
protected function getTreeRootCategory()
{
if (!$this->treeRootCategory) {
$this->treeRootCategory = $this->categoryFactory->create()->load(Category::TREE_ROOT_ID);
}
return $this->treeRootCategory;
}
protected function setUp()
{
$helper = new ObjectManager($this);
$this->category = $this->getMockBuilder('Magento\\Catalog\\Model\\Category')->setMethods(['load', 'getId', '__wakeup'])->disableOriginalConstructor()->getMock();
$this->categoryFactory = $this->getMockBuilder('Magento\\Catalog\\Model\\CategoryFactory')->setMethods(['create'])->disableOriginalConstructor()->getMock();
$this->categoryFactory->expects($this->any())->method('create')->will($this->returnValue($this->category));
$this->registry = $this->getMockBuilder('Magento\\Framework\\Registry')->setMethods(['registry'])->disableOriginalConstructor()->getMock();
$this->store = $this->getMockBuilder('Magento\\Store\\Model\\Store')->setMethods(['getRootCategoryId', 'getFilters', '__wakeup'])->disableOriginalConstructor()->getMockForAbstractClass();
$this->storeManager = $this->getMockBuilder('Magento\\Framework\\StoreManagerInterface')->setMethods(['getStore'])->disableOriginalConstructor()->getMockForAbstractClass();
$this->storeManager->expects($this->any())->method('getStore')->will($this->returnValue($this->store));
$this->stateKeyGenerator = $this->getMockBuilder('Magento\\Catalog\\Model\\Layer\\Category\\StateKey')->setMethods(['toString'])->disableOriginalConstructor()->getMock();
$this->collectionFilter = $this->getMockBuilder('Magento\\Catalog\\Model\\Layer\\Category\\CollectionFilter')->setMethods(['filter'])->disableOriginalConstructor()->getMock();
$this->collectionProvider = $this->getMockBuilder('Magento\\Catalog\\Model\\Layer\\ItemCollectionProviderInterface')->disableOriginalConstructor()->getMockForAbstractClass();
$this->filter = $this->getMockBuilder('Magento\\Catalog\\Model\\Layer\\Filter\\Item')->setMethods(['getFilter', 'getValueString'])->disableOriginalConstructor()->getMock();
$this->abstractFilter = $this->getMockBuilder('Magento\\Catalog\\Model\\Layer\\Filter\\AbstractFilter')->setMethods(['getRequestVar'])->disableOriginalConstructor()->getMock();
$this->context = $this->getMockBuilder('Magento\\Catalog\\Model\\Layer\\ContextInterface')->setMethods(['getStateKey', 'getCollectionFilter'])->disableOriginalConstructor()->getMockForAbstractClass();
$this->context->expects($this->any())->method('getStateKey')->will($this->returnValue($this->stateKeyGenerator));
$this->context->expects($this->any())->method('getCollectionFilter')->will($this->returnValue($this->collectionFilter));
$this->context->expects($this->any())->method('getCollectionProvider')->will($this->returnValue($this->collectionProvider));
$this->state = $this->getMockBuilder('Magento\\Catalog\\Model\\Layer\\State')->disableOriginalConstructor()->getMock();
$this->stateFactory = $this->getMockBuilder('Magento\\Catalog\\Model\\Layer\\StateFactory')->setMethods(['create'])->disableOriginalConstructor()->getMock();
$this->stateFactory->expects($this->any())->method('create')->will($this->returnValue($this->state));
$this->collection = $this->getMockBuilder('Magento\\Catalog\\Model\\Resource\\Product\\Collection')->disableOriginalConstructor()->getMock();
$this->model = $helper->getObject('Magento\\Catalog\\Model\\Layer', ['registry' => $this->registry, 'categoryFactory' => $this->categoryFactory, 'storeManager' => $this->storeManager, 'context' => $this->context, 'layerStateFactory' => $this->stateFactory]);
}
/**
* Retrieve loaded category collection
*
* @return AbstractCollection
*/
protected function _getProductCollection()
{
if (is_null($this->_productCollection)) {
$layer = $this->getLayer();
/* @var $layer \Magento\Catalog\Model\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(current($categories->getIterator()));
}
}
$origCategory = null;
if ($this->getCategoryId()) {
/** @var \Magento\Catalog\Model\Category $category */
$category = $this->_categoryFactory->create()->load($this->getCategoryId());
if ($category->getId()) {
$origCategory = $layer->getCurrentCategory();
$layer->setCurrentCategory($category);
}
}
$this->_productCollection = $layer->getProductCollection();
$this->prepareSortableFieldsByCategory($layer->getCurrentCategory());
if ($origCategory) {
$layer->setCurrentCategory($origCategory);
}
}
return $this->_productCollection;
}
/**
* Retrieve category url
*
* @param ModelCategory $category
* @return string
*/
public function getCategoryUrl($category)
{
if ($category instanceof ModelCategory) {
return $category->getUrl();
}
return $this->_categoryFactory->create()->setData($category->getData())->getUrl();
}
/**
* Set current attribute to entry (for specified product)
*
* @param \Magento\Catalog\Model\Product $product
* @param \Magento\Framework\Gdata\Gshopping\Entry $entry
* @return \Magento\Framework\Gdata\Gshopping\Entry
*/
public function convertAttribute($product, $entry)
{
$productCategories = $product->getCategoryIds();
// TODO: set Default value for product_type attribute if product isn't assigned for any category
$value = 'Shop';
if (!empty($productCategories)) {
$category = $this->_categoryFactory->create()->load(array_shift($productCategories));
$breadcrumbs = array();
foreach ($category->getParentCategories() as $cat) {
$breadcrumbs[] = $cat->getName();
}
$value = implode(' > ', $breadcrumbs);
}
$this->_setAttribute($entry, 'product_type', self::ATTRIBUTE_TYPE_TEXT, $value);
return $entry;
}
/**
* Load current category using the request params.
*
* @return CategoryInterface
*/
private function loadCategory()
{
$category = $this->categoryFactory->create();
$storeId = $this->getRequest()->getParam('store');
$categoryId = $this->getRequest()->getParam('entity_id');
$category->setStoreId($storeId)->load($categoryId);
return $category;
}
public function testGetCategory()
{
$this->category->expects($this->any())->method('getId')->will($this->returnValue(10));
$this->registry->expects($this->any())->method('registry')->will($this->returnValue($this->category));
$this->categoryFactory->expects($this->any())->method('create')->will($this->returnValue($this->category));
$this->category->expects($this->once())->method('load')->will($this->returnValue($this->category));
$this->assertInstanceOf('\\Magento\\Catalog\\Model\\Category', $this->model->getCategory());
}
/**
* Load category
*
* @param int $id
* @throws \Magento\Framework\Exception\NoSuchEntityException
* @return \Magento\Catalog\Model\Category
*/
protected function loadCategory($id)
{
$model = $this->categoryFactory->create();
$model->load($id);
if (!$model->getId()) {
throw NoSuchEntityException::singleField(CategoryDataObject::ID, $id);
}
return $model;
}
/**
* Return array of options as value-label pairs
*
* @return array Format: array(array('value' => '<value>', 'label' => '<label>'), ...)
*/
public function toOptionArray()
{
$cacheKey = sprintf('%d-%d-%d-%d', 1, false, false, true);
if (isset($this->_storeCategories[$cacheKey])) {
return $this->_storeCategories[$cacheKey];
}
/**
* Check if parent node of the store still exists
*/
$category = $this->_categoryFactory->create();
$storeCategories = $category->getCategories(1, $recursionLevel = 1, false, false, true);
$this->_storeCategories[$cacheKey] = $storeCategories;
$resultArray = [];
foreach ($storeCategories as $category) {
$resultArray[$category->getId()] = $category->getName();
}
return $resultArray;
}
/**
* Get categories collection
*
* @return \Magento\Catalog\Model\ResourceModel\Category\Collection
*/
public function getCategoryCollection()
{
$collection = $this->_getData('category_collection');
if ($collection === null) {
$collection = $this->_categoryFactory->create()->getCollection()->addAttributeToSelect(['name', 'is_active'])->setLoadProductCount(true);
$this->setData('category_collection', $collection);
}
return $collection;
}
/**
* Get last purchased category.
*
* @return string
*/
public function getLastCategoryPur()
{
$categoryId = $this->customer->getLastCategoryId();
//customer last category id
if ($categoryId) {
return $this->categoryFactory->create()->setStoreId($this->customer->getStoreId())->load($categoryId)->getName();
}
return '';
}
/**
* Load the root category used for a virtual category.
*
* @param CategoryInterface $category Virtual category.
*
* @return CategoryInterface
*/
private function getVirtualRootCategory(CategoryInterface $category)
{
$storeId = $this->getStoreId();
$rootCategory = $this->categoryFactory->create()->setStoreId($storeId);
if ($category->getVirtualCategoryRoot() !== null && !empty($category->getVirtualCategoryRoot())) {
$rootCategoryId = $category->getVirtualCategoryRoot();
$rootCategory->load($rootCategoryId);
}
return $rootCategory;
}
public function testAddErrorMessageWhenProductWithoutStores()
{
$form = $this->getMock('Magento\\Framework\\Data\\Form', [], [], '', false);
$form->expects($this->any())->method('getElement')->will($this->returnValue($this->getMockForAbstractClass('\\Magento\\Framework\\Data\\Form\\Element\\AbstractElement', [], '', false)));
$this->formFactory->expects($this->once())->method('create')->will($this->returnValue($form));
$fieldset = $this->getMock('Magento\\Framework\\Data\\Form\\Element\\Fieldset', [], [], '', false);
$form->expects($this->once())->method('addFieldset')->will($this->returnValue($fieldset));
$storeElement = $this->getMock('Magento\\Framework\\Data\\Form\\Element\\AbstractElement', ['setAfterElementHtml', 'setValues'], [], '', false);
$fieldset->expects($this->at(2))->method('addField')->with('store_id', 'select', ['label' => 'Store', 'title' => 'Store', 'name' => 'store_id', 'required' => true, 'value' => 0])->willReturn($storeElement);
$product = $this->getMock('Magento\\Catalog\\Model\\Product', [], [], '', false);
$product->expects($this->any())->method('getId')->willReturn('product_id');
$product->expects($this->once())->method('getStoreIds')->willReturn([]);
$this->productFactory->expects($this->once())->method('create')->willReturn($product);
$this->categoryFactory->expects($this->once())->method('create')->willReturn($this->getMock('Magento\\Catalog\\Model\\Category', [], [], '', false));
$storeElement->expects($this->once())->method('setAfterElementHtml');
$storeElement->expects($this->once())->method('setValues')->with([]);
$this->layout->expects($this->once())->method('createBlock')->willReturn($this->getMock('Magento\\Framework\\Data\\Form\\Element\\Renderer\\RendererInterface'));
$this->form->toHtml();
}
/**
* Get selected category object
*
* @return \Magento\Catalog\Model\Category
*/
public function getCategory()
{
if (!is_null($this->_categoryId)) {
/** @var \Magento\Catalog\Model\Category $category */
$category = $this->_categoryFactory->create()->load($this->_categoryId);
if ($category->getId()) {
return $category;
}
}
return $this->getLayer()->getCurrentCategory();
}
/**
* @return \Magento\Framework\Model\Resource\Db\Collection\AbstractCollection
*/
public function getCategoryCollection()
{
$storeId = $this->getRequest()->getParam('store', $this->_getDefaultStoreId());
$collection = $this->getData('category_collection');
if (is_null($collection)) {
$collection = $this->_categoryFactory->create()->getCollection();
$collection->addAttributeToSelect('name')->addAttributeToSelect('is_active')->setProductStoreId($storeId)->setLoadProductCount($this->_withProductCount)->setStoreId($storeId);
$this->setData('category_collection', $collection);
}
return $collection;
}
/**
* @param int $rootCategoryId
* @param int $storeId
* @return array
*/
protected function generateCategoryUrls($rootCategoryId, $storeId)
{
$urls = [];
$categories = $this->categoryFactory->create()->getCategories($rootCategoryId, 1, false, true);
foreach ($categories as $category) {
/** @var \Magento\Catalog\Model\Category $category */
$category->setStoreId($storeId);
$urls = array_merge($urls, $this->categoryUrlRewriteGenerator->generate($category));
}
return $urls;
}
/**
* @param \Magento\Framework\View\Element\Template\Context $context
* @param \Magento\Catalog\Model\CategoryFactory $categoryFactory
* @param \Magento\Catalog\Model\ResourceModel\Product\CollectionFactory $productCollectionFactory
* @param \Magento\Catalog\Model\Layer\Resolver $layerResolver
* @param \Magento\Framework\App\Http\Context $httpContext
* @param \Magento\Catalog\Helper\Category $catalogCategory
* @param \Magento\Framework\Registry $registry
* @param \Magento\Catalog\Model\Indexer\Category\Flat\State $flatState
* @param array $data
*/
public function __construct(\Magento\Framework\View\Element\Template\Context $context, \Magento\Catalog\Model\CategoryFactory $categoryFactory, \Magento\Catalog\Model\ResourceModel\Product\CollectionFactory $productCollectionFactory, \Magento\Catalog\Model\Layer\Resolver $layerResolver, \Magento\Framework\App\Http\Context $httpContext, \Magento\Catalog\Helper\Category $catalogCategory, \Magento\Framework\Registry $registry, \Magento\Catalog\Model\Indexer\Category\Flat\State $flatState, array $data = [])
{
$this->_productCollectionFactory = $productCollectionFactory;
$this->_catalogLayer = $layerResolver->get();
$this->httpContext = $httpContext;
$this->_catalogCategory = $catalogCategory;
$this->_registry = $registry;
$this->flatState = $flatState;
$this->_categoryInstance = $categoryFactory->create();
parent::__construct($context, $data);
}
/**
* @param array $row
* @return void
*/
protected function createCategory($row)
{
$category = $this->getCategoryByPath($row['path'] . '/' . $row['name']);
if (!$category) {
$parentCategory = $this->getCategoryByPath($row['path']);
$data = ['parent_id' => $parentCategory->getId(), 'name' => $row['name'], 'is_active' => $row['active'], 'is_anchor' => $row['is_anchor'], 'include_in_menu' => $row['include_in_menu'], 'url_key' => $row['url_key']];
$category = $this->categoryFactory->create();
$category->setData($data)->setPath($parentCategory->getData('path'))->setAttributeSetId($category->getDefaultAttributeSetId());
$this->setAdditionalData($row, $category);
$category->save();
}
}
/**
* Get product collection.
*
* @return array
*/
public function getLoadedProductCollection()
{
$productsToDisplay = [];
$mode = $this->getRequest()->getActionName();
$limit = $this->recommnededHelper->getDisplayLimitByMode($mode);
$from = $this->recommnededHelper->getTimeFromConfig($mode);
$to = $this->_localeDate->date()->format(\Zend_Date::ISO_8601);
$reportProductCollection = $this->reportProductCollection->create()->addViewsCount($from, $to)->setPageSize($limit);
//filter collection by category by category_id
if ($catId = $this->getRequest()->getParam('category_id')) {
$category = $this->categoryFactory->create()->load($catId);
if ($category->getId()) {
$reportProductCollection->getSelect()->joinLeft(['ccpi' => $this->coreResource->getTableName('catalog_category_product_index')], 'e.entity_id = ccpi.product_id', ['category_id'])->where('ccpi.category_id =?', $catId);
} else {
$this->helper->log('Most viewed. Category id ' . $catId . ' is invalid. It does not exist.');
}
}
//filter collection by category by category_name
if ($catName = $this->getRequest()->getParam('category_name')) {
$category = $this->categoryFactory->create()->loadByAttribute('name', $catName);
if ($category) {
$reportProductCollection->getSelect()->joinLeft(['ccpi' => $this->coreResource->getTableName('catalog_category_product_index')], 'e.entity_id = ccpi.product_id', ['category_id'])->where('ccpi.category_id =?', $category->getId());
} else {
$this->helper->log('Most viewed. Category name ' . $catName . ' is invalid. It does not exist.');
}
}
//product ids from the report product collection
$productIds = $reportProductCollection->getColumnValues('entity_id');
$productCollectionFactory = $this->productCollectionFactory->create();
$productCollectionFactory->addIdFilter($productIds)->addAttributeToSelect(['product_url', 'name', 'store_id', 'small_image', 'price']);
//product collection
foreach ($productCollectionFactory as $_product) {
//add only saleable products
if ($_product->isSalable()) {
$productsToDisplay[] = $_product;
}
}
return $productsToDisplay;
}
/**
* @param CategoryDataObject $category
* @param \Magento\Catalog\Model\Category $categoryModel
* @return \Magento\Catalog\Model\Category
* @throws \RuntimeException
*/
public function toModel(CategoryDataObject $category, \Magento\Catalog\Model\Category $categoryModel = null)
{
$categoryModel = $categoryModel ?: $this->categoryFactory->create();
$data = EavDataObjectConverter::toFlatArray($category);
/** @see /app/code/Magento/Catalog/Controller/Adminhtml/Category.php method "_filterCategoryPostData" */
if (isset($data['image']) && is_array($data['image'])) {
$data['image_additional_data'] = $data['image'];
unset($data['image']);
}
// this fields should not be changed
$data[CategoryDataObject::ID] = $categoryModel->getId();
$data[CategoryDataObject::PARENT_ID] = $categoryModel->getParentId();
$data[CategoryDataObject::PATH] = $categoryModel->getPath();
/** fill required fields */
$data['is_active'] = $category->isActive();
$data['include_in_menu'] = isset($data['include_in_menu']) ? (bool) $data['include_in_menu'] : false;
$categoryModel->addData($data);
if (!is_numeric($categoryModel->getAttributeSetId())) {
$categoryModel->setAttributeSetId($categoryModel->getDefaultAttributeSetId());
}
return $categoryModel;
}
/**
* Returns a random product category
*
* @return \Magento\Framework\DataObject
* @throws \Exception
* @throws \Magento\Framework\Exception\LocalizedException
*/
protected function getProductCategory()
{
if (NULL == $this->availableCategories) {
/** @var \Magento\Catalog\Model\ResourceModel\Category\Collection $categoriesCollection */
$categoriesCollection = $this->categoryFactory->create()->getCollection();
$categoriesCollection->addAttributeToFilter('entity_id', ['gt' => '0'])->addIsActiveFilter();
$this->availableCategories = $categoriesCollection->getItems();
}
if (count($this->availableCategories) > 0) {
return $this->availableCategories[array_rand($this->availableCategories)];
} else {
throw new \Exception("There are no categories available in the store");
}
}
/**
* List of parent categories
*
* @param int $categoryId
* @return \Magento\Catalog\Model\Category[]
*/
public function getFullPath($categoryId)
{
$store = $this->storeManager->getStore();
$rootId = $store->getRootCategoryId();
$result = [];
$id = $categoryId;
do {
$parent = $this->categoryFactory->create()->load($id)->getParentCategory();
$id = $parent->getId();
if (!$parent->getId()) {
break;
}
if (!$parent->getIsActive() && $parent->getId() != $rootId) {
break;
//return false;
}
if ($parent->getId() != $rootId) {
$result[] = $parent;
}
} while ($parent->getId() != $rootId);
$result = array_reverse($result);
return $result;
}