/**
* {@inheritdoc}
*/
public function getRssData()
{
try {
$category = $this->categoryRepository->get($this->getRequest()->getParam('cid'));
} catch (NoSuchEntityException $e) {
return ['title' => 'Category Not Found', 'description' => 'Category Not Found', 'link' => $this->getUrl(''), 'charset' => 'UTF-8'];
}
$category->setIsAnchor(true);
$newUrl = $category->getUrl();
$title = $category->getName();
$data = ['title' => $title, 'description' => $title, 'link' => $newUrl, 'charset' => 'UTF-8'];
/** @var $product \Magento\Catalog\Model\Product */
foreach ($this->rssModel->getProductCollection($category, $this->getStoreId()) as $product) {
$product->setAllowedInRss(true);
$product->setAllowedPriceInRss(true);
$this->_eventManager->dispatch('rss_catalog_category_xml_callback', ['product' => $product]);
if (!$product->getAllowedInRss()) {
continue;
}
$description = '
<table><tr>
<td><a href="%s"><img src="%s" border="0" align="left" height="75" width="75"></a></td>
<td style="text-decoration:none;">%s %s</td>
</tr></table>
';
$description = sprintf($description, $product->getProductUrl(), $this->imageHelper->init($product, 'rss_thumbnail')->getUrl(), $product->getDescription(), $product->getAllowedPriceInRss() ? $this->renderPriceHtml($product) : '');
$data['entries'][] = ['title' => $product->getName(), 'link' => $product->getProductUrl(), 'description' => $description];
}
return $data;
}
/**
* Send Email Post Action
*
* @return \Magento\Framework\Controller\ResultInterface
* @SuppressWarnings(PHPMD.CyclomaticComplexity)
*/
public function execute()
{
/** @var \Magento\Framework\Controller\Result\Redirect $resultRedirect */
$resultRedirect = $this->resultFactory->create(ResultFactory::TYPE_REDIRECT);
if (!$this->_formKeyValidator->validate($this->getRequest())) {
$resultRedirect->setPath('sendfriend/product/send', ['_current' => true]);
return $resultRedirect;
}
$product = $this->_initProduct();
$data = $this->getRequest()->getPostValue();
if (!$product || !$data) {
/** @var \Magento\Framework\Controller\Result\Forward $resultForward */
$resultForward = $this->resultFactory->create(ResultFactory::TYPE_FORWARD);
$resultForward->forward('noroute');
return $resultForward;
}
$categoryId = $this->getRequest()->getParam('cat_id', null);
if ($categoryId) {
try {
$category = $this->categoryRepository->get($categoryId);
} catch (NoSuchEntityException $noEntityException) {
$category = null;
}
if ($category) {
$product->setCategory($category);
$this->_coreRegistry->register('current_category', $category);
}
}
$this->sendFriend->setSender($this->getRequest()->getPost('sender'));
$this->sendFriend->setRecipients($this->getRequest()->getPost('recipients'));
$this->sendFriend->setProduct($product);
try {
$validate = $this->sendFriend->validate();
if ($validate === true) {
$this->sendFriend->send();
$this->messageManager->addSuccess(__('The link to a friend was sent.'));
$url = $product->getProductUrl();
$resultRedirect->setUrl($this->_redirect->success($url));
return $resultRedirect;
} else {
if (is_array($validate)) {
foreach ($validate as $errorMessage) {
$this->messageManager->addError($errorMessage);
}
} else {
$this->messageManager->addError(__('We found some problems with the data.'));
}
}
} catch (\Magento\Framework\Exception\LocalizedException $e) {
$this->messageManager->addError($e->getMessage());
} catch (\Exception $e) {
$this->messageManager->addException($e, __('Some emails were not sent.'));
}
// save form data
$this->catalogSession->setSendfriendFormData($data);
$url = $this->_url->getUrl('sendfriend/product/send', ['_current' => true]);
$resultRedirect->setUrl($this->_redirect->error($url));
return $resultRedirect;
}
/**
* Create new Magento category with given $name.
*
* @param string $name
* @return int ID of the created category
*/
public function createMageCategory($name)
{
/** @var $category CategoryInterface */
$category = $this->_manObj->create(CategoryInterface::class);
$category->setName($name);
$category->setIsActive(false);
$saved = $this->_mageRepoCategory->save($category);
$result = $saved->getId();
return $result;
}
public function testDelete()
{
$categoryId = 5;
$parentId = 7;
$this->request->expects($this->any())->method('getParam')->with('id')->willReturn($categoryId);
$category = $this->getMock('Magento\\Catalog\\Model\\Category', ['getParentId', 'getPath'], [], '', false);
$category->expects($this->once())->method('getParentId')->willReturn($parentId);
$category->expects($this->once())->method('getPath')->willReturn('category-path');
$this->categoryRepository->expects($this->once())->method('get')->with($categoryId)->willReturn($category);
$this->authStorage->expects($this->once())->method('setDeletedPath')->with('category-path');
$this->resultRedirect->expects($this->once())->method('setPath')->with('catalog/*/', ['_current' => true, 'id' => $parentId]);
$this->unit->execute();
}
/**
* Generate list based on categories
*
* @param int $storeId
* @param Product $product
* @param ObjectRegistry $productCategories
* @return UrlRewrite[]
*/
public function generate($storeId, Product $product, ObjectRegistry $productCategories)
{
$urls = [];
foreach ($productCategories->getList() as $category) {
$anchorCategoryIds = $category->getAnchorsAbove();
if ($anchorCategoryIds) {
foreach ($anchorCategoryIds as $anchorCategoryId) {
$anchorCategory = $this->categoryRepository->get($anchorCategoryId);
$urls[] = $this->urlRewriteFactory->create()->setEntityType(ProductUrlRewriteGenerator::ENTITY_TYPE)->setEntityId($product->getId())->setRequestPath($this->urlPathGenerator->getUrlPathWithSuffix($product, $storeId, $anchorCategory))->setTargetPath($this->urlPathGenerator->getCanonicalUrlPath($product, $anchorCategory))->setStoreId($storeId)->setMetadata(['category_id' => $anchorCategory->getId()]);
}
}
}
return $urls;
}
/**
* @SuppressWarnings(PHPMD.ExcessiveMethodLength)
*/
public function testExecuteWithException()
{
$productId = 11;
$categoryId = 5;
$sender = 'sender';
$recipients = 'recipients';
$formData = ['sender' => $sender, 'recipients' => $recipients];
$redirectUrl = 'redirect_url';
/** @var \Magento\Framework\Controller\Result\Redirect|\PHPUnit_Framework_MockObject_MockObject $redirectMock */
$redirectMock = $this->getMockBuilder('Magento\\Framework\\Controller\\Result\\Redirect')->disableOriginalConstructor()->getMock();
$this->resultFactoryMock->expects($this->once())->method('create')->with(\Magento\Framework\Controller\ResultFactory::TYPE_REDIRECT, [])->willReturn($redirectMock);
$this->validatorMock->expects($this->once())->method('validate')->with($this->requestMock)->willReturn(true);
$this->requestMock->expects($this->exactly(2))->method('getParam')->willReturnMap([['id', null, $productId], ['cat_id', null, $categoryId]]);
/** @var \Magento\Catalog\Api\Data\ProductInterface|\PHPUnit_Framework_MockObject_MockObject $productMock */
$productMock = $this->getMockBuilder('Magento\\Catalog\\Api\\Data\\ProductInterface')->setMethods(['isVisibleInCatalog', 'setCategory', 'getProductUrl'])->getMockForAbstractClass();
$this->productRepositoryMock->expects($this->once())->method('getById')->with($productId, false, null, false)->willReturn($productMock);
$productMock->expects($this->once())->method('isVisibleInCatalog')->willReturn(true);
$this->categoryRepositoryMock->expects($this->once())->method('get')->with($categoryId, null)->willThrowException(new \Magento\Framework\Exception\NoSuchEntityException(__('No Category Exception.')));
$productMock->expects($this->never())->method('setCategory');
$this->registryMock->expects($this->once())->method('register')->willReturnMap([['product', $productMock, false, null]]);
$this->requestMock->expects($this->once())->method('getPostValue')->willReturn($formData);
$this->requestMock->expects($this->exactly(2))->method('getPost')->willReturnMap([['sender', $sender], ['recipients', $recipients]]);
$this->sendFriendMock->expects($this->once())->method('setSender')->with($sender)->willReturnSelf();
$this->sendFriendMock->expects($this->once())->method('setRecipients')->with($recipients)->willReturnSelf();
$this->sendFriendMock->expects($this->once())->method('setProduct')->with($productMock)->willReturnSelf();
$exception = new \Exception(__('Exception.'));
$this->sendFriendMock->expects($this->once())->method('validate')->willThrowException($exception);
$this->sendFriendMock->expects($this->never())->method('send');
$this->messageManagerMock->expects($this->once())->method('addException')->with($exception, __('Some emails were not sent.'))->willReturnSelf();
$this->catalogSessionMock->expects($this->once())->method('setSendfriendFormData')->with($formData);
$this->urlBuilderMock->expects($this->once())->method('getUrl')->with('sendfriend/product/send', ['_current' => true])->willReturn($redirectUrl);
$this->redirectMock->expects($this->once())->method('error')->with($redirectUrl)->willReturnArgument(0);
$redirectMock->expects($this->once())->method('setUrl')->with($redirectUrl)->willReturnSelf();
$this->assertEquals($redirectMock, $this->model->execute());
}
/**
* Get categories tree as recursive array
*
* @param int $parentId
* @param bool $asJson
* @param int $recursionLevel
* @return array
*/
public function getTreeArray($parentId = null, $asJson = false, $recursionLevel = 3)
{
$productId = $this->_request->getParam('product');
if ($productId) {
$product = $this->_productFactory->create()->setId($productId);
$this->_allowedCategoryIds = $product->getCategoryIds();
unset($product);
}
$result = [];
if ($parentId) {
try {
$category = $this->categoryRepository->get($parentId);
} catch (NoSuchEntityException $e) {
$category = null;
}
if ($category) {
$tree = $this->_getNodesArray($this->getNode($category, $recursionLevel));
if (!empty($tree) && !empty($tree['children'])) {
$result = $tree['children'];
}
}
} else {
$result = $this->_getNodesArray($this->getRoot(null, $recursionLevel));
}
if ($asJson) {
return $this->_jsonEncoder->encode($result);
}
$this->_allowedCategoryIds = [];
return $result;
}
public function testGetRssData()
{
$category = $this->getMockBuilder('\\Magento\\Catalog\\Model\\Category')->setMethods(['__sleep', '__wakeup', 'load', 'getId', 'getUrl', 'getName'])->disableOriginalConstructor()->getMock();
$category->expects($this->once())->method('getName')->will($this->returnValue('Category Name'));
$category->expects($this->once())->method('getUrl')->will($this->returnValue('http://magento.com/category-name.html'));
$this->categoryRepository->expects($this->once())->method('get')->will($this->returnValue($category));
$product = $this->getMockBuilder('\\Magento\\catalog\\Model\\Product')->setMethods(['__sleep', '__wakeup', 'getName', 'getAllowedInRss', 'getProductUrl', 'getDescription', 'getAllowedPriceInRss'])->disableOriginalConstructor()->getMock();
$product->expects($this->once())->method('getName')->will($this->returnValue('Product Name'));
$product->expects($this->once())->method('getAllowedInRss')->will($this->returnValue(true));
$product->expects($this->exactly(2))->method('getProductUrl')->will($this->returnValue('http://magento.com/product.html'));
$product->expects($this->once())->method('getDescription')->will($this->returnValue('Product Description'));
$product->expects($this->once())->method('getAllowedPriceInRss')->will($this->returnValue(true));
$this->rssModel->expects($this->once())->method('getProductCollection')->will($this->returnValue([$product]));
$this->imageHelper->expects($this->once())->method('init')->with($product, 'thumbnail')->will($this->returnSelf());
$this->imageHelper->expects($this->once())->method('resize')->with(75, 75)->will($this->returnValue('image_link'));
$data = $this->block->getRssData();
$this->assertEquals($this->rssFeed['link'], $data['link']);
$this->assertEquals($this->rssFeed['title'], $data['title']);
$this->assertEquals($this->rssFeed['description'], $data['description']);
$this->assertEquals($this->rssFeed['entries'][0]['title'], $data['entries'][0]['title']);
$this->assertEquals($this->rssFeed['entries'][0]['link'], $data['entries'][0]['link']);
$this->assertContains('<a href="http://magento.com/product.html">', $data['entries'][0]['description']);
$this->assertContains('<img src="image_link" border="0" align="left" height="75" width="75">', $data['entries'][0]['description']);
$this->assertContains('<td style="text-decoration:none;">Product Description </td>', $data['entries'][0]['description']);
}
/**
* Initialize and check product
*
* @return \Magento\Catalog\Model\Product|bool
*/
protected function initProduct()
{
$this->_eventManager->dispatch('review_controller_product_init_before', ['controller_action' => $this]);
$categoryId = (int)$this->getRequest()->getParam('category', false);
$productId = (int)$this->getRequest()->getParam('id');
$product = $this->loadProduct($productId);
if (!$product) {
return false;
}
if ($categoryId) {
$category = $this->categoryRepository->get($categoryId);
$this->coreRegistry->register('current_category', $category);
}
try {
$this->_eventManager->dispatch('review_controller_product_init', ['product' => $product]);
$this->_eventManager->dispatch(
'review_controller_product_init_after',
['product' => $product, 'controller_action' => $this]
);
} catch (\Magento\Framework\Exception\LocalizedException $e) {
$this->logger->critical($e);
return false;
}
return $product;
}
/**
* 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->categoryRepository->get(array_shift($productCategories));
$breadcrumbs = [];
foreach ($category->getParentCategories() as $cat) {
$breadcrumbs[] = $cat->getName();
}
$value = implode(' > ', $breadcrumbs);
}
$this->_setAttribute($entry, 'product_type', self::ATTRIBUTE_TYPE_TEXT, $value);
return $entry;
}
/**
* @dataProvider getUrlPathWithParentDataProvider
* @param string $urlKey
* @param bool $isCategoryNew
* @param bool $level
* @param int $parentCategoryParentId
* @param string $parentUrlPath
* @param string $result
*/
public function testGetUrlPathWithParent(
$urlKey,
$isCategoryNew,
$level,
$parentCategoryParentId,
$parentUrlPath,
$result
) {
$urlPath = null;
$parentLevel = CategoryUrlPathGenerator::MINIMAL_CATEGORY_LEVEL_FOR_PROCESSING - 1;
$this->category->expects($this->any())->method('getParentId')
->will($this->returnValue('parent_id'));
$this->category->expects($this->any())->method('getLevel')
->will($this->returnValue($level));
$this->category->expects($this->any())->method('getUrlPath')->will($this->returnValue($urlPath));
$this->category->expects($this->any())->method('getUrlKey')->will($this->returnValue($urlKey));
$this->category->expects($this->any())->method('isObjectNew')->will($this->returnValue($isCategoryNew));
$methods = ['__wakeup', 'getUrlPath', 'getParentId', 'getLevel', 'dataHasChangedFor', 'load'];
$parentCategory = $this->getMock('Magento\Catalog\Model\Category', $methods, [], '', false);
$parentCategory->expects($this->any())->method('getParentId')
->will($this->returnValue($parentCategoryParentId));
$parentCategory->expects($this->any())->method('getLevel')->will($this->returnValue($parentLevel));
$parentCategory->expects($this->any())->method('getUrlPath')->will($this->returnValue($parentUrlPath));
$parentCategory->expects($this->any())->method('dataHasChangedFor')
->will($this->returnValueMap([['url_key', false], ['path_ids', false]]));
$this->categoryRepository->expects($this->any())->method('get')->with('parent_id')
->will($this->returnValue($parentCategory));
$this->assertEquals($result, $this->categoryUrlPathGenerator->getUrlPath($this->category));
}
/**
* {@inheritdoc}
*/
public function getAssignedProducts($categoryId)
{
$category = $this->categoryRepository->get($categoryId);
$productsPosition = $category->getProductsPosition();
/** @var \Magento\Framework\Data\Collection\Db $products */
$products = $category->getProductCollection();
/** @var \Magento\Catalog\Api\Data\CategoryProductLinkInterface[] $links */
$links = [];
/** @var \Magento\Catalog\Model\Product $product */
foreach ($products->getItems() as $productId => $product) {
/** @var \Magento\Catalog\Api\Data\CategoryProductLinkInterface $link */
$link = $this->productLinkFactory->create();
$link->setSku($product->getSku())->setPosition($productsPosition[$productId])->setCategoryId($category->getId());
$links[] = $link;
}
return $links;
}
/**
* {@inheritdoc}
*/
public function getAssignedProducts($categoryId)
{
$category = $this->categoryRepository->get($categoryId);
/** @var \Magento\Catalog\Model\ResourceModel\Product\Collection $products */
$products = $category->getProductCollection();
$products->addFieldToSelect('position');
/** @var \Magento\Catalog\Api\Data\CategoryProductLinkInterface[] $links */
$links = [];
/** @var \Magento\Catalog\Model\Product $product */
foreach ($products->getItems() as $product) {
/** @var \Magento\Catalog\Api\Data\CategoryProductLinkInterface $link */
$link = $this->productLinkFactory->create();
$link->setSku($product->getSku())->setPosition($product->getData('cat_index_position'))->setCategoryId($category->getId());
$links[] = $link;
}
return $links;
}
/**
* Test method
*/
public function testGenerationForGlobalScope()
{
$this->category->expects($this->any())->method('getStoreId')->will($this->returnValue(null));
$this->category->expects($this->any())->method('getStoreIds')->will($this->returnValue([1]));
$this->storeViewService->expects($this->once())->method('doesEntityHaveOverriddenUrlKeyForStore')->will($this->returnValue(false));
$canonical = new \Magento\UrlRewrite\Service\V1\Data\UrlRewrite();
$canonical->setTargetPath('category-1')->setStoreId(1);
$this->canonicalUrlRewriteGenerator->expects($this->any())->method('generate')->will($this->returnValue([$canonical]));
$children = new \Magento\UrlRewrite\Service\V1\Data\UrlRewrite();
$children->setTargetPath('category-2')->setStoreId(2);
$this->childrenUrlRewriteGenerator->expects($this->any())->method('generate')->will($this->returnValue([$children]));
$current = new \Magento\UrlRewrite\Service\V1\Data\UrlRewrite();
$current->setTargetPath('category-3')->setStoreId(3);
$this->currentUrlRewritesRegenerator->expects($this->any())->method('generate')->will($this->returnValue([$current]));
$categoryForSpecificStore = $this->getMock('Magento\\Catalog\\Model\\Category', ['getUrlKey', 'getUrlPath'], [], '', false);
$this->categoryRepository->expects($this->once())->method('get')->willReturn($categoryForSpecificStore);
$this->assertEquals([$canonical, $children, $current], $this->categoryUrlRewriteGenerator->generate($this->category));
}
/**
* @param string $blockId
* @param string $categoryId
* @return void
*/
protected function setCategoryLandingPage($blockId, $categoryId)
{
$categoryCms = ['landing_page' => $blockId, 'display_mode' => 'PRODUCTS_AND_PAGE'];
if (!empty($categoryId)) {
$category = $this->categoryRepository->get($categoryId);
$category->setData($categoryCms);
$this->categoryRepository->save($categoryId);
}
}
public function testGetCurrentCategoryIfCurrentCategoryIsNotSet()
{
$rootCategoryId = 333;
$this->currentCategory->getData('current_category', null);
$this->registry->expects($this->once())->method('registry')->with($this->equalTo('current_category'))->willReturn(null);
$this->categoryRepository->expects($this->once())->method('get')->with($rootCategoryId)->willReturn($this->category);
$this->store->expects($this->any())->method('getRootCategoryId')->will($this->returnValue($rootCategoryId));
$this->assertEquals($this->currentCategory, $this->model->getCurrentCategory());
$this->assertEquals($this->currentCategory, $this->model->getData('current_category'));
}
/**
* Build category URL path
*
* @param \Magento\Catalog\Api\Data\CategoryInterface|\Magento\Framework\Model\AbstractModel $category
* @return string
*/
public function getUrlPath($category)
{
if ($category->getParentId() == Category::TREE_ROOT_ID) {
return '';
}
$path = $category->getUrlPath();
if ($path !== null && !$category->dataHasChangedFor('url_key') && !$category->dataHasChangedFor('parent_id')) {
return $path;
}
$path = $category->getUrlKey();
if ($path === false) {
return $category->getUrlPath();
}
if ($this->isNeedToGenerateUrlPathForParent($category)) {
$parentPath = $this->getUrlPath($this->categoryRepository->get($category->getParentId()));
$path = $parentPath === '' ? $path : $parentPath . '/' . $path;
}
return $path;
}
/**
* @expectedException \Magento\Framework\Exception\LocalizedException
* @expectedExceptionMessage Could not move category
*/
public function testMoveWithCouldNotMoveException()
{
$categoryId = 2;
$parentId = 1;
$afterId = null;
$categoryMock = $this->getMock('\\Magento\\Catalog\\Model\\Category', [], [], 'categoryMock', false);
$parentCategoryMock = $this->getMock('\\Magento\\Catalog\\Model\\Category', [], [], 'parentCategoryMock', false);
$this->categoryRepositoryMock->expects($this->exactly(2))->method('get')->will($this->returnValueMap([[$categoryId, null, $categoryMock], [$parentId, null, $parentCategoryMock]]));
$categoryMock->expects($this->once())->method('move')->with($parentId, $afterId)->willThrowException(new \Magento\Framework\Exception\LocalizedException(__('message')));
$this->model->move($categoryId, $parentId, $afterId);
}
/**
* Inits product to be used for product controller actions and layouts
* $params can have following data:
* 'category_id' - id of category to check and append to product as current.
* If empty (except FALSE) - will be guessed (e.g. from last visited) to load as current.
*
* @param int $productId
* @param \Magento\Framework\App\Action\Action $controller
* @param \Magento\Framework\DataObject $params
*
* @return false|ModelProduct
* @SuppressWarnings(PHPMD.CyclomaticComplexity)
* @SuppressWarnings(PHPMD.NPathComplexity)
*/
public function initProduct($productId, $controller, $params = null)
{
// Prepare data for routine
if (!$params) {
$params = new \Magento\Framework\DataObject();
}
// Init and load product
$this->_eventManager->dispatch('catalog_controller_product_init_before', ['controller_action' => $controller, 'params' => $params]);
if (!$productId) {
return false;
}
try {
$product = $this->productRepository->getById($productId, false, $this->_storeManager->getStore()->getId());
} catch (NoSuchEntityException $e) {
return false;
}
if (!$this->canShow($product)) {
return false;
}
if (!in_array($this->_storeManager->getStore()->getWebsiteId(), $product->getWebsiteIds())) {
return false;
}
// Load product current category
$categoryId = $params->getCategoryId();
if (!$categoryId && $categoryId !== false) {
$lastId = $this->_catalogSession->getLastVisitedCategoryId();
if ($product->canBeShowInCategory($lastId)) {
$categoryId = $lastId;
}
} elseif (!$product->canBeShowInCategory($categoryId)) {
$categoryId = null;
}
if ($categoryId) {
try {
$category = $this->categoryRepository->get($categoryId);
} catch (NoSuchEntityException $e) {
$category = null;
}
if ($category) {
$product->setCategory($category);
$this->_coreRegistry->register('current_category', $category);
}
}
// Register current data and dispatch final events
$this->_coreRegistry->register('current_product', $product);
$this->_coreRegistry->register('product', $product);
try {
$this->_eventManager->dispatch('catalog_controller_product_init_after', ['product' => $product, 'controller_action' => $controller]);
} catch (\Magento\Framework\Exception\LocalizedException $e) {
$this->_logger->critical($e);
return false;
}
return $product;
}
public function testApplyCustomLayoutUpdate()
{
$categoryId = 123;
$pageLayout = 'page_layout';
$this->objectManager->expects($this->any())->method('get')->will($this->returnValueMap([['Magento\\Catalog\\Helper\\Category', $this->categoryHelper], ['Magento\\Theme\\Helper\\Layout', $this->layoutHelper]]));
$this->request->expects($this->any())->method('getParam')->will($this->returnValueMap([[Action::PARAM_NAME_URL_ENCODED], ['id', false, $categoryId]]));
$this->categoryRepository->expects($this->any())->method('get')->with($categoryId)->will($this->returnValue($this->category));
$this->categoryHelper->expects($this->any())->method('canShow')->will($this->returnValue(true));
$settings = $this->getMock('Magento\\Framework\\Object', ['getPageLayout'], [], '', false);
$settings->expects($this->atLeastOnce())->method('getPageLayout')->will($this->returnValue($pageLayout));
$this->catalogDesign->expects($this->any())->method('getDesignSettings')->will($this->returnValue($settings));
$this->action->execute();
}
/**
* Refresh entities index
*
* @param int[] $entityIds
* @param bool $useTempTable
* @return Rows
*/
public function reindex(array $entityIds = [], $useTempTable = false)
{
$stores = $this->storeManager->getStores();
/* @var $store \Magento\Store\Model\Store */
foreach ($stores as $store) {
$tableName = $this->getTableNameByStore($store, $useTempTable);
if (!$this->getWriteAdapter()->isTableExists($tableName)) {
continue;
}
/** @TODO Do something with chunks */
$categoriesIdsChunks = array_chunk($entityIds, 500);
foreach ($categoriesIdsChunks as $categoriesIdsChunk) {
$categoriesIdsChunk = $this->filterIdsByStore($categoriesIdsChunk, $store);
$attributesData = $this->getAttributeValues($categoriesIdsChunk, $store->getId());
$data = [];
foreach ($categoriesIdsChunk as $categoryId) {
if (!isset($attributesData[$categoryId])) {
continue;
}
try {
$category = $this->categoryRepository->get($categoryId);
} catch (NoSuchEntityException $e) {
continue;
}
$data[] = $this->prepareValuesToInsert(array_merge($category->getData(), $attributesData[$categoryId], ['store_id' => $store->getId()]));
}
foreach ($data as $row) {
$updateFields = [];
foreach (array_keys($row) as $key) {
$updateFields[$key] = $key;
}
$this->getWriteAdapter()->insertOnDuplicate($tableName, $row, $updateFields);
}
}
$this->deleteNonStoreCategories($store, $useTempTable);
}
return $this;
}
/**
* Delete category action
*
* @return \Magento\Backend\Model\View\Result\Redirect
*/
public function execute()
{
/** @var \Magento\Backend\Model\View\Result\Redirect $resultRedirect */
$resultRedirect = $this->resultRedirectFactory->create();
$categoryId = (int) $this->getRequest()->getParam('id');
$parentId = null;
if ($categoryId) {
try {
$category = $this->categoryRepository->get($categoryId);
$parentId = $category->getParentId();
$this->_eventManager->dispatch('catalog_controller_category_delete', ['category' => $category]);
$this->_auth->getAuthStorage()->setDeletedPath($category->getPath());
$this->categoryRepository->delete($category);
$this->messageManager->addSuccess(__('You deleted the category.'));
} catch (\Magento\Framework\Exception\LocalizedException $e) {
$this->messageManager->addError($e->getMessage());
return $resultRedirect->setPath('catalog/*/edit', ['_current' => true]);
} catch (\Exception $e) {
$this->messageManager->addError(__('Something went wrong while trying to delete the category.'));
return $resultRedirect->setPath('catalog/*/edit', ['_current' => true]);
}
}
return $resultRedirect->setPath('catalog/*/', ['_current' => true, 'id' => $parentId]);
}
public function testMovePrimaryWorkflow()
{
$indexer = $this->getMock('stdClass', ['isScheduled']);
$indexer->expects($this->once())->method('isScheduled')->will($this->returnValue(true));
$this->indexerRegistry->expects($this->once())->method('get')->with('catalog_category_product')->will($this->returnValue($indexer));
$parentCategory = $this->getMock('Magento\\Catalog\\Model\\Category', ['getId', 'setStoreId', 'load'], [], '', false);
$parentCategory->expects($this->any())->method('getId')->will($this->returnValue(5));
$parentCategory->expects($this->any())->method('setStoreId')->will($this->returnSelf());
$parentCategory->expects($this->any())->method('load')->will($this->returnSelf());
$this->categoryRepository->expects($this->any())->method('get')->will($this->returnValue($parentCategory));
$store = $this->getMock('Magento\\Store\\Model\\Store', [], [], '', false);
$this->storeManager->expects($this->any())->method('getStore')->will($this->returnValue($store));
$this->category->setId(3);
$this->category->move(5, 7);
}
/**
* Change current category object
*
* @param mixed $category
* @return \Magento\Catalog\Model\Layer
* @throws \Magento\Framework\Exception\LocalizedException
*/
public function setCurrentCategory($category)
{
if (is_numeric($category)) {
try {
$category = $this->categoryRepository->get($category);
} catch (NoSuchEntityException $e) {
throw new \Magento\Framework\Exception\LocalizedException(__('Please correct the category.'), $e);
}
} elseif ($category instanceof \Magento\Catalog\Model\Category) {
if (!$category->getId()) {
throw new \Magento\Framework\Exception\LocalizedException(__('Please correct the category.'));
}
} else {
throw new \Magento\Framework\Exception\LocalizedException(__('Must be category model instance or its id.'));
}
if ($category->getId() != $this->getCurrentCategory()->getId()) {
$this->setData('current_category', $category);
}
return $this;
}
/**
* Check if a category can be shown
*
* @param ModelCategory|int $category
* @return bool
*/
public function canShow($category)
{
if (is_int($category)) {
try {
$category = $this->categoryRepository->get($category);
} catch (NoSuchEntityException $e) {
return false;
}
} else {
if (!$category->getId()) {
return false;
}
}
if (!$category->getIsActive()) {
return false;
}
if (!$category->isInRootCategoryList()) {
return false;
}
return true;
}
/**
* Retrieve loaded category collection
*
* @return AbstractCollection
*/
protected function _getProductCollection()
{
if ($this->_productCollection === null) {
$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()) {
try {
$category = $this->categoryRepository->get($this->getCategoryId());
} catch (NoSuchEntityException $e) {
$category = null;
}
if ($category) {
$origCategory = $layer->getCurrentCategory();
$layer->setCurrentCategory($category);
}
}
$this->_productCollection = $layer->getProductCollection();
$this->prepareSortableFieldsByCategory($layer->getCurrentCategory());
if ($origCategory) {
$layer->setCurrentCategory($origCategory);
}
}
return $this->_productCollection;
}
/**
* Initialize requested category object
*
* @return \Magento\Catalog\Model\Category
*/
protected function _initCategory()
{
$categoryId = (int) $this->getRequest()->getParam('id', false);
if (!$categoryId) {
return false;
}
try {
$category = $this->categoryRepository->get($categoryId, $this->_storeManager->getStore()->getId());
} catch (NoSuchEntityException $e) {
return false;
}
if (!$this->_objectManager->get('Magento\\Catalog\\Helper\\Category')->canShow($category)) {
return false;
}
$this->_catalogSession->setLastVisitedCategoryId($category->getId());
$this->_coreRegistry->register('current_category', $category);
try {
$this->_eventManager->dispatch('catalog_controller_category_init_after', ['category' => $category, 'controller_action' => $this]);
} catch (\Magento\Framework\Exception\LocalizedException $e) {
$this->_objectManager->get('Psr\\Log\\LoggerInterface')->critical($e);
return false;
}
return $category;
}
/**
* Get parent category object
*
* @return \Magento\Catalog\Model\Category
*/
public function getParentCategory()
{
if (!$this->hasData('parent_category')) {
$this->setData('parent_category', $this->categoryRepository->get($this->getParentId()));
}
return $this->_getData('parent_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->categoryRepository->expects($this->any())->method('get')->will($this->returnValue($this->category));
$this->assertInstanceOf('\\Magento\\Catalog\\Model\\Category', $this->model->getCategory());
}
/**
* Retrieve Visitor/Customer Last Viewed URL
*
* @return string
*/
public function getLastViewedUrl()
{
$productId = $this->_catalogSession->getLastViewedProductId();
if ($productId) {
try {
$product = $this->productRepository->getById($productId);
} catch (NoSuchEntityException $e) {
return '';
}
/* @var $product \Magento\Catalog\Model\Product */
if ($this->_catalogProduct->canShow($product, 'catalog')) {
return $product->getProductUrl();
}
}
$categoryId = $this->_catalogSession->getLastViewedCategoryId();
if ($categoryId) {
try {
$category = $this->categoryRepository->get($categoryId);
} catch (NoSuchEntityException $e) {
return '';
}
/* @var $category \Magento\Catalog\Model\Category */
if (!$this->_catalogCategory->canShow($category)) {
return '';
}
return $category->getCategoryUrl();
}
return '';
}
