Magento 2 Archives - WEB4PRO https://web4pro.net/blog-news/category/magento-2-blog/ Thu, 11 Jan 2024 16:20:43 +0000 en-US hourly 1 https://s3.eu-central-1.amazonaws.com/web4pro.net-new/wp-content/uploads/2023/04/07085114/favicon-32x32-1.png Magento 2 Archives - WEB4PRO https://web4pro.net/blog-news/category/magento-2-blog/ 32 32 Magento 2.2.6 Bug When Saving Placeholder Image https://web4pro.net/blog-news/magento-2-2-6-bug-saving-placeholder-image/ Thu, 06 Dec 2018 11:39:10 +0000 https://web4pro.net/?p=7518 If a product in Magento® 2 doesn’t have an image, a placeholder is displayed on the front end. The store administrator can set the image for the placeholder on the Product Image Placeholders page: Stores -> Configuration -> Catalog -> Product Image Placeholders Magento. However, a bug was detected in Magento 2.2.6 that doesn’t let administrators upload their own images for placeholders. Below, we’ll examine the reason for this bug and how to fix it.

Working with Placeholders

Placeholders are configuration parameters that are set in adminhtml/system.xml in the Magento_Catalog module. Their description looks like this:

...
<group id="placeholder" translate="label" sortOrder="300" showInDefault="1" showInWebsite="1" showInStore="1">
    <label>Product Image Placeholders</label>
    <clone_fields>1</clone_fields>
    <clone_model>Magento\Catalog\Model\Config\CatalogClone\Media\Image</clone_model>
    <field id="placeholder" type="image" sortOrder="1" showInDefault="1" showInWebsite="1" showInStore="1">
        <backend_model>Magento\Config\Model\Config\Backend\Image</backend_model>
        <upload_dir config="system/filesystem/media" scope_info="1">catalog/product/placeholder</upload_dir>
        <base_url type="media" scope_info="1">catalog/product/placeholder</base_url>
    </field>
</group>
....

This group of parameters is defined as such because a product could have any number of image attributes, including those implemented by different third-party modules.The cloning model Magento\Catalog\Model\Config\CatalogClone\Media\Image will look as follows:

class Image extends \Magento\Framework\App\Config\Value
{
    /**
     * Eav config
     *
     * @var \Magento\Eav\Model\Config
     */
    protected $_eavConfig;
    /**
     * Attribute collection factory
     *
     * @var \Magento\Catalog\Model\ResourceModel\Product\Attribute\CollectionFactory
     */
    protected $_attributeCollectionFactory;
    /**
     * @param \Magento\Framework\Model\Context $context
     * @param \Magento\Framework\Registry $registry
     * @param \Magento\Framework\App\Config\ScopeConfigInterface $config
     * @param \Magento\Framework\App\Cache\TypeListInterface $cacheTypeList
     * @param \Magento\Catalog\Model\ResourceModel\Product\Attribute\CollectionFactory $attributeCollectionFactory
     * @param \Magento\Eav\Model\Config $eavConfig
     * @param \Magento\Framework\Model\ResourceModel\AbstractResource $resource
     * @param \Magento\Framework\Data\Collection\AbstractDb $resourceCollection
     * @param array $data
     */
    public function __construct(
        \Magento\Framework\Model\Context $context,
        \Magento\Framework\Registry $registry,
        \Magento\Framework\App\Config\ScopeConfigInterface $config,
        \Magento\Framework\App\Cache\TypeListInterface $cacheTypeList,
        \Magento\Catalog\Model\ResourceModel\Product\Attribute\CollectionFactory $attributeCollectionFactory,
        \Magento\Eav\Model\Config $eavConfig,
        \Magento\Framework\Model\ResourceModel\AbstractResource $resource = null,
        \Magento\Framework\Data\Collection\AbstractDb $resourceCollection = null,
        array $data = []
    ) {
        $this->_attributeCollectionFactory = $attributeCollectionFactory;
        $this->_eavConfig = $eavConfig;
        parent::__construct($context, $registry, $config, $cacheTypeList, $resource, $resourceCollection, $data);
    }
    /**
     * Get fields prefixes
     *
     * @return array
     */
    public function getPrefixes()
    {
        // use cached eav config
        $entityTypeId = $this->_eavConfig->getEntityType(\Magento\Catalog\Model\Product::ENTITY)->getId();
        /* @var $collection \Magento\Catalog\Model\ResourceModel\Product\Attribute\Collection */
        $collection = $this->_attributeCollectionFactory->create();
        $collection->setEntityTypeFilter($entityTypeId);
        $collection->setFrontendInputTypeFilter('media_image');
        $prefixes = [];
        foreach ($collection as $attribute) {
            /* @var $attribute \Magento\Eav\Model\Entity\Attribute */
            $prefixes[] = [
                'field' => $attribute->getAttributeCode() . '_',
                'label' => $attribute->getFrontend()->getLabel(),
            ];
        }
        return $prefixes;
    }
}

When the administrator uploads an image in the field on the configuration page and the submit form, it will be processed on the server by the Magento\Config\Controller\Adminhtml\System\Config\Save controller and will look as follows:

class Save extends AbstractConfig
{
    /**
     * Backend Config Model Factory
     *
     * @var \Magento\Config\Model\Config\Factory
     */
    protected $_configFactory;
    /**
     * @var \Magento\Framework\Cache\FrontendInterface
     */
    protected $_cache;
    /**
     * @var \Magento\Framework\Stdlib\StringUtils
     */
    protected $string;
    /**
     * @param \Magento\Backend\App\Action\Context $context
     * @param \Magento\Config\Model\Config\Structure $configStructure
     * @param \Magento\Config\Controller\Adminhtml\System\ConfigSectionChecker $sectionChecker
     * @param \Magento\Config\Model\Config\Factory $configFactory
     * @param \Magento\Framework\Cache\FrontendInterface $cache
     * @param \Magento\Framework\Stdlib\StringUtils $string
     */
    public function __construct(
        \Magento\Backend\App\Action\Context $context,
        \Magento\Config\Model\Config\Structure $configStructure,
        \Magento\Config\Controller\Adminhtml\System\ConfigSectionChecker $sectionChecker,
        \Magento\Config\Model\Config\Factory $configFactory,
        \Magento\Framework\Cache\FrontendInterface $cache,
        \Magento\Framework\Stdlib\StringUtils $string
    ) {
        parent::__construct($context, $configStructure, $sectionChecker);
        $this->_configFactory = $configFactory;
        $this->_cache = $cache;
        $this->string = $string;
    }
    /**
     * Get groups for save
     *
     * @return array|null
     */
    protected function _getGroupsForSave()
    {
        $groups = $this->getRequest()->getPost('groups');
        $files = $this->getRequest()->getFiles('groups');
        if ($files && is_array($files)) {
            /**
             * Carefully merge $_FILES and $_POST information
             * None of ' =' or 'array_merge_recursive' can do this correct
             */
            foreach ($files as $groupName => $group) {
                $data = $this->_processNestedGroups($group);
                if (!empty($data)) {
                    if (!empty($groups[$groupName])) {
                        $groups[$groupName] = array_merge_recursive((array)$groups[$groupName], $data);
                    } else {
                        $groups[$groupName] = $data;
                    }
                }
            }
        }
        return $groups;
    }
    /**
     * Process nested groups
     *
     * @param mixed $group
     * @return array
     */
    protected function _processNestedGroups($group)
    {
        $data = [];
        if (isset($group['fields']) && is_array($group['fields'])) {
            foreach ($group['fields'] as $fieldName => $field) {
                if (!empty($field['value'])) {
                    $data['fields'][$fieldName] = ['value' => $field['value']];
                }
            }
        }
        if (isset($group['groups']) && is_array($group['groups'])) {
            foreach ($group['groups'] as $groupName => $groupData) {
                $nestedGroup = $this->_processNestedGroups($groupData);
                if (!empty($nestedGroup)) {
                    $data['groups'][$groupName] = $nestedGroup;
                }
            }
        }
        return $data;
    }
    /**
     * Custom save logic for section
     *
     * @return void
     */
    protected function _saveSection()
    {
        $method = '_save' . $this->string->upperCaseWords($this->getRequest()->getParam('section'), '_', '');
        if (method_exists($this, $method)) {
            $this->{$method}();
        }
    }
    /**
     * Advanced save procedure
     *
     * @return void
     */
    protected function _saveAdvanced()
    {
        $this->_cache->clean();
    }
    /**
     * Save configuration
     *
     * @return \Magento\Backend\Model\View\Result\Redirect
     */
    public function execute()
    {
        try {
            // custom save logic
            $this->_saveSection();
            $section = $this->getRequest()->getParam('section');
            $website = $this->getRequest()->getParam('website');
            $store = $this->getRequest()->getParam('store');
            $configData = [
                'section' => $section,
                'website' => $website,
                'store' => $store,
                'groups' => $this->_getGroupsForSave(),
            ];
            /** @var \Magento\Config\Model\Config $configModel  */
            $configModel = $this->_configFactory->create(['data' => $configData]);
            $configModel->save();
            $this->messageManager->addSuccess(__('You saved the configuration.'));
        } catch (\Magento\Framework\Exception\LocalizedException $e) {
            $messages = explode("\n", $e->getMessage());
            foreach ($messages as $message) {
                $this->messageManager->addError($message);
            }
        } catch (\Exception $e) {
            $this->messageManager->addException(
                $e,
                __('Something went wrong while saving this configuration:') . ' ' . $e->getMessage()
            );
        }
        $this->_saveState($this->getRequest()->getPost('config_state'));
        /** @var \Magento\Backend\Model\View\Result\Redirect $resultRedirect */
        $resultRedirect = $this->resultRedirectFactory->create();
        return $resultRedirect->setPath(
            'adminhtml/system_config/edit',
            [
                '_current' => ['section', 'website', 'store'],
                '_nosid' => true
            ]
        );
    }
}

As you can see, in the execute method the save is carried out in the save() method of the Magento\Config\Model\Config class. Let’s take a look at this class.

class Config extends \Magento\Framework\DataObject
{
    /**
     * Config data for sections
     *
     * @var array
     */
    protected $_configData;
    /**
     * Event dispatcher
     *
     * @var \Magento\Framework\Event\ManagerInterface
     */
    protected $_eventManager;
    /**
     * System configuration structure
     *
     * @var \Magento\Config\Model\Config\Structure
     */
    protected $_configStructure;
    /**
     * Application config
     *
     * @var \Magento\Framework\App\Config\ScopeConfigInterface
     */
    protected $_appConfig;
    /**
     * Global factory
     *
     * @var \Magento\Framework\App\Config\ScopeConfigInterface
     */
    protected $_objectFactory;
    /**
     * TransactionFactory
     *
     * @var \Magento\Framework\DB\TransactionFactory
     */
    protected $_transactionFactory;
    /**
     * Config data loader
     *
     * @var \Magento\Config\Model\Config\Loader
     */
    protected $_configLoader;
    /**
     * Config data factory
     *
     * @var \Magento\Framework\App\Config\ValueFactory
     */
    protected $_configValueFactory;
    /**
     * @var \Magento\Store\Model\StoreManagerInterface
     */
    protected $_storeManager;
    /**
     * @var Config\Reader\Source\Deployed\SettingChecker
     */
    private $settingChecker;
    /**
     * @param \Magento\Framework\App\Config\ReinitableConfigInterface $config
     * @param \Magento\Framework\Event\ManagerInterface $eventManager
     * @param \Magento\Config\Model\Config\Structure $configStructure
     * @param \Magento\Framework\DB\TransactionFactory $transactionFactory
     * @param \Magento\Config\Model\Config\Loader $configLoader
     * @param \Magento\Framework\App\Config\ValueFactory $configValueFactory
     * @param \Magento\Store\Model\StoreManagerInterface $storeManager
     * @param Config\Reader\Source\Deployed\SettingChecker|null $settingChecker
     * @param array $data
     */
    public function __construct(
        \Magento\Framework\App\Config\ReinitableConfigInterface $config,
        \Magento\Framework\Event\ManagerInterface $eventManager,
        \Magento\Config\Model\Config\Structure $configStructure,
        \Magento\Framework\DB\TransactionFactory $transactionFactory,
        \Magento\Config\Model\Config\Loader $configLoader,
        \Magento\Framework\App\Config\ValueFactory $configValueFactory,
        \Magento\Store\Model\StoreManagerInterface $storeManager,
        SettingChecker $settingChecker = null,
        array $data = []
    ) {
        parent::__construct($data);
        $this->_eventManager = $eventManager;
        $this->_configStructure = $configStructure;
        $this->_transactionFactory = $transactionFactory;
        $this->_appConfig = $config;
        $this->_configLoader = $configLoader;
        $this->_configValueFactory = $configValueFactory;
        $this->_storeManager = $storeManager;
        $this->settingChecker = $settingChecker ?: ObjectManager::getInstance()->get(SettingChecker::class);
    }
    /**
     * Save config section
     * Require set: section, website, store and groups
     *
     * @throws \Exception
     * @return $this
     */
    public function save()
    {
        $this->initScope();
        $sectionId = $this->getSection();
        $groups = $this->getGroups();
        if (empty($groups)) {
            return $this;
        }
        $oldConfig = $this->_getConfig(true);
        /** @var \Magento\Framework\DB\Transaction $deleteTransaction */
        $deleteTransaction = $this->_transactionFactory->create();
        /** @var \Magento\Framework\DB\Transaction $saveTransaction */
        $saveTransaction = $this->_transactionFactory->create();
        $changedPaths = [];
        // Extends for old config data
        $extraOldGroups = [];
        foreach ($groups as $groupId => $groupData) {
            $this->_processGroup(
                $groupId,
                $groupData,
                $groups,
                $sectionId,
                $extraOldGroups,
                $oldConfig,
                $saveTransaction,
                $deleteTransaction
            );
            $groupChangedPaths = $this->getChangedPaths($sectionId, $groupId, $groupData, $oldConfig, $extraOldGroups);
            $changedPaths = \array_merge($changedPaths, $groupChangedPaths);
        }
        try {
            $deleteTransaction->delete();
            $saveTransaction->save();
            // re-init configuration
            $this->_appConfig->reinit();
            // website and store codes can be used in event implementation, so set them as well
            $this->_eventManager->dispatch(
                "admin_system_config_changed_section_{$this->getSection()}",
                [
                    'website' => $this->getWebsite(),
                    'store' => $this->getStore(),
                    'changed_paths' => $changedPaths,
                ]
            );
        } catch (\Exception $e) {
            // re-init configuration
            $this->_appConfig->reinit();
            throw $e;
        }
        return $this;
    }
    /**
     * Map field name if they were cloned
     *
     * @param Group $group
     * @param string $fieldId
     * @return string
     */
    private function getOriginalFieldId(Group $group, string $fieldId): string
    {
        if ($group->shouldCloneFields()) {
            $cloneModel = $group->getCloneModel();
            /** @var \Magento\Config\Model\Config\Structure\Element\Field $field */
            foreach ($group->getChildren() as $field) {
                foreach ($cloneModel->getPrefixes() as $prefix) {
                    if ($prefix['field'] . $field->getId() === $fieldId) {
                        $fieldId = $field->getId();
                        break(2);
                    }
                }
            }
        }
        return $fieldId;
    }
    /**
     * Get field object
     *
     * @param string $sectionId
     * @param string $groupId
     * @param string $fieldId
     * @return Field
     */
    private function getField(string $sectionId, string $groupId, string $fieldId): Field
    {
        /** @var \Magento\Config\Model\Config\Structure\Element\Group $group */
        $group = $this->_configStructure->getElement($sectionId . '/' . $groupId);
        $fieldPath = $group->getPath() . '/' . $this->getOriginalFieldId($group, $fieldId);
        $field = $this->_configStructure->getElement($fieldPath);
        return $field;
    }
    /**
     * Get field path
     *
     * @param Field $field
     * @param array &$oldConfig Need for compatibility with _processGroup()
     * @param array &$extraOldGroups Need for compatibility with _processGroup()
     * @return string
     */
    private function getFieldPath(Field $field, array &$oldConfig, array &$extraOldGroups): string
    {
        $path = $field->getGroupPath() . '/' . $field->getId();
        /**
         * Look for custom defined field path
         */
        $configPath = $field->getConfigPath();
        if ($configPath && strrpos($configPath, '/') > 0) {
            // Extend old data with specified section group
            $configGroupPath = substr($configPath, 0, strrpos($configPath, '/'));
            if (!isset($extraOldGroups[$configGroupPath])) {
                $oldConfig = $this->extendConfig($configGroupPath, true, $oldConfig);
                $extraOldGroups[$configGroupPath] = true;
            }
            $path = $configPath;
        }
        return $path;
    }
    /**
     * Check is config value changed
     *
     * @param array $oldConfig
     * @param string $path
     * @param array $fieldData
     * @return bool
     */
    private function isValueChanged(array $oldConfig, string $path, array $fieldData): bool
    {
        if (isset($oldConfig[$path]['value'])) {
            $result = !isset($fieldData['value']) || $oldConfig[$path]['value'] !== $fieldData['value'];
        } else {
            $result = empty($fieldData['inherit']);
        }
        return $result;
    }
    /**
     * Get changed paths
     *
     * @param string $sectionId
     * @param string $groupId
     * @param array $groupData
     * @param array &$oldConfig
     * @param array &$extraOldGroups
     * @return array
     */
    private function getChangedPaths(
        string $sectionId,
        string $groupId,
        array $groupData,
        array &$oldConfig,
        array &$extraOldGroups
    ): array {
        $changedPaths = [];
        if (isset($groupData['fields'])) {
            foreach ($groupData['fields'] as $fieldId => $fieldData) {
                $field = $this->getField($sectionId, $groupId, $fieldId);
                $path = $this->getFieldPath($field, $oldConfig, $extraOldGroups);
                if ($this->isValueChanged($oldConfig, $path, $fieldData)) {
                    $changedPaths[] = $path;
                }
            }
        }
        if (isset($groupData['groups'])) {
            $subSectionId = $sectionId . '/' . $groupId;
            foreach ($groupData['groups'] as $subGroupId => $subGroupData) {
                $subGroupChangedPaths = $this->getChangedPaths(
                    $subSectionId,
                    $subGroupId,
                    $subGroupData,
                    $oldConfig,
                    $extraOldGroups
                );
                $changedPaths = \array_merge($changedPaths, $subGroupChangedPaths);
            }
        }
        return $changedPaths;
    }
    /**
     * Process group data
     *
     * @param string $groupId
     * @param array $groupData
     * @param array $groups
     * @param string $sectionPath
     * @param array &$extraOldGroups
     * @param array &$oldConfig
     * @param \Magento\Framework\DB\Transaction $saveTransaction
     * @param \Magento\Framework\DB\Transaction $deleteTransaction
     * @return void
     * @SuppressWarnings(PHPMD.CyclomaticComplexity)
     * @SuppressWarnings(PHPMD.NPathComplexity)
     */
    protected function _processGroup(
        $groupId,
        array $groupData,
        array $groups,
        $sectionPath,
        array &$extraOldGroups,
        array &$oldConfig,
        \Magento\Framework\DB\Transaction $saveTransaction,
        \Magento\Framework\DB\Transaction $deleteTransaction
    ) {
        $groupPath = $sectionPath . '/' . $groupId;
        if (isset($groupData['fields'])) {
            /** @var \Magento\Config\Model\Config\Structure\Element\Group $group */
            $group = $this->_configStructure->getElement($groupPath);
            // set value for group field entry by fieldname
            // use extra memory
            $fieldsetData = [];
            foreach ($groupData['fields'] as $fieldId => $fieldData) {
                $fieldsetData[$fieldId] = $fieldData['value'] ?? null;
            }
            foreach ($groupData['fields'] as $fieldId => $fieldData) {
                $isReadOnly = $this->settingChecker->isReadOnly(
                    $groupPath . '/' . $fieldId,
                    $this->getScope(),
                    $this->getScopeCode()
                );
                if ($isReadOnly) {
                    continue;
                }
                $field = $this->getField($sectionPath, $groupId, $fieldId);
                /** @var \Magento\Framework\App\Config\ValueInterface $backendModel */
                $backendModel = $field->hasBackendModel()
                    ? $field->getBackendModel()
                    : $this->_configValueFactory->create();
                if (!isset($fieldData['value'])) {
                    $fieldData['value'] = null;
                }
                $data = [
                    'field' => $fieldId,
                    'groups' => $groups,
                    'group_id' => $group->getId(),
                    'scope' => $this->getScope(),
                    'scope_id' => $this->getScopeId(),
                    'scope_code' => $this->getScopeCode(),
                    'field_config' => $field->getData(),
                    'fieldset_data' => $fieldsetData,
                ];
                $backendModel->addData($data);
                $this->_checkSingleStoreMode($field, $backendModel);
                $path = $this->getFieldPath($field, $extraOldGroups, $oldConfig);
                $backendModel->setPath($path)->setValue($fieldData['value']);
                $inherit = !empty($fieldData['inherit']);
                if (isset($oldConfig[$path])) {
                    $backendModel->setConfigId($oldConfig[$path]['config_id']);
                    /**
                     * Delete config data if inherit
                     */
                    if (!$inherit) {
                        $saveTransaction->addObject($backendModel);
                    } else {
                        $deleteTransaction->addObject($backendModel);
                    }
                } elseif (!$inherit) {
                    $backendModel->unsConfigId();
                    $saveTransaction->addObject($backendModel);
                }
            }
        }
        if (isset($groupData['groups'])) {
            foreach ($groupData['groups'] as $subGroupId => $subGroupData) {
                $this->_processGroup(
                    $subGroupId,
                    $subGroupData,
                    $groups,
                    $groupPath,
                    $extraOldGroups,
                    $oldConfig,
                    $saveTransaction,
                    $deleteTransaction
                );
            }
        }
    }
....
}

As you can see, the save() method checks all groups of parameters sent to the server, and for each, it calls the _processGroup() method, while the final one calls the getField() method for each field.

The following happens in this method: the group of placeholders actually clones the same element for different EAV attributes that can implement the image. But at the same time, the getField method calls the getOriginalFieldId method, which returns the path catalog/placeholder/placeholder described in system.xml for any element.

This path will then be used to save the placeholder image in the core_config_data table. But this isn’t exactly what should be happening since the path to the placeholder configuration should be catalog/placeholder/image_placeholder for the default image, catalog/placeholder/small_image_placeholder for the listing image, etc.

Useful for you:

Solution Using Plugin

This problem needs to be solved, and the best way to do that is at the backend-model level. The back-end model in our case is implemented by the class Magento\Config\Model\Config\Backend\Image, which is inherited from Magento\Config\Model\Config\Backend\File. This is inherited from \Magento\Framework\App\Config\Value, which in turn is inherited from \Magento\Framework\Model\AbstractModel. But using the model’s event handler beforeSafe won’t work since the beforeSave method is redefined in the Magento\Config\Model\Config\Backend\File class without calling the parent method. So all that’s left is to implement the plugin as follows:

<type name="Magento\Config\Model\Config\Backend\Image">
    <plugin name="fix-placeholders" type="Web4pro\Defaultproduct\Model\Plugin" sortOrder="20"/>
</type>

Plugin’s class will be the following:

class Plugin
{
    public function beforeBeforeSave($subject){
        if(($f=$subject->getField())&&($subject->getPath()=='catalog/placeholder/placeholder')){
            $subject->setPath(str_replace('placeholder/placeholder','placeholder/'.$f,$subject->getPath()));
        }
        return array();
    }
}

With this fix, the path to each placeholder in the core_config_data table will be unique and placeholders will be saved successfully by the site administrator.

]]> Magento 1.x End of Life is June 2020 (Updated) https://web4pro.net/blog-news/magento-1-x-end-of-life-june-2020/ Mon, 18 Jun 2018 11:35:11 +0000 https://web4pro.net/?p=4120 Friends, now read carefully, especially those, who owns the online store based on Magento®. A little bird told us (Twitter, to be exact) that a new Age of Magento was nearby. Yes, Magento 2 has all the chances to become the next strong foundation for your super-powerful online store. So you should start considering it as a new eCommerce tool right now.

Magento Tweet. Support Update for Magento 1.x is June 2020
June 2020. Remember this time. It is when official Magento 1.x support will stop. And Magento 2 continues to conquer the market.

What does this mean for you?

  • You should keep up to date because it will be the complete renewal of the eCommerce market: the new version is a future of technology, as always.
  • The official updates stop. Therefore, the risk of vulnerabilities in the system grows many times in case you use not an updated Magento version. Your website security requires much attention.
  • Magento community works on new extensions for Magento 2. Gradually, the number of modern solutions compatible with the Magento 1.x website will be not enough for your needs, while the number of Magento 2 extensions will increase on a daily basis.
  • You can now check the exact support dates for Open Source and Community (Enterprise) editions and plan when it is better to upgrade your store.

The main ideas you may come up with are the following:

  • If you’re planning to get the eCommerce project developed, you should choose Magento 2 instead of Magento 1.x;
  • If you already have the Magento 1.x based eCommerce business, you can start migrating it to Magento 2.

The questions are: “Why?” and “What are the pros and difficulties you can meet?”

Let’s make it clear.

According to BuiltWith, almost 20% of Magento based websites use Magento 2.x (68,207 websites). That means a significant number of eCommerce business owners have already made their choice on the side of Magento 2.x. Is it the right decision? Let’s consider the pros and other details.

That means most of the eCommerce business owners have already made their choice on the side of Magento 2.x. Is it the right decision? Let’s consider the pros and other details.

Useful for you:

The Pros of Migration to Magento 2

Though Magento 2 is not fully-equipped with many useful features that were presented in Magento 1, it’s still much more flexible. There are some features you’ll discover when working with Magento 2:

Increased Flexibility of Magento 2

Magento 2 is super-flexible and extendable when it comes to customization. It includes a lot of features. It’s all because of Magento 2 improved architecture and modular code base that broadens the limits for fast and efficient project development.

Better Management of Magento 2

Now administration of the online store is also more flexible. You can:

  • include links to images and videos to your products;
  • work with the orders better, because you can see the various types of data related to the orders on the Dashboard, (such as lifetime sales, average orders, etc);
  • keep up with analytics (learn about best customers and sellers, view tax rates and quantities);
  • upload new products easily;
  • enjoy the user-friendly interface.

title=”The Benefits of Magento Commerce 2.2 for B2B Business” link=”https://web4pro.net/blog-news/the-benefits-of-magento-commerce-2-2-for-b2b-business/”

Useful for you:

Magento 2 API

The huge advantage is that Magento 2 comes with a Rest and SOAP-based API, unlike Magento 1.x. Magento API is a functionality that allows the web developers to integrate Magento with the other third-party services. While Magento 1.x came with a SOAP and XML-RPC based API, it was more difficult to perform integrations: it required the separate configuration of access rights for each user’s role. REST and SOAP had a different business logic. Now, in Magento 2, REST and SOAP business logic is equivalent, and the Magento 2 REST API allows the browsers based access to API calls.

Updating Magento 2 with Composer

It could be a useful feature when you are going to update Magento 2 version. The steps you should make are the following:

  • choose the version you need to upgrade via composer upgrade;
  • run the relevant command;
  • upgrade the database (don’t forget to backup).

Migration to Magento 2: Pitfalls

As you can see, Magento 2 is quite a powerful and even a cool tool. But also, we can’t miss a fly in the ointment. The technical and hosting requirements are very high for Magento 2. Here are some of the most important of them.

Magento 2 Technical Requirements

  • RAM 2GB
  • PHP 5.6
  • MySQL 5.6

Also, if talk about hosting, SSL security certificate is required for HTTPS. SSH access is required for hosting anyway, otherwise, it will be impossible to install new extensions, themes etc.

You can look through the full list of technical requirements here.

The next thing is the cost. It’s not cheap to move from Magento 1.x to Magento 2 if your online store is complicated enough. Additionally, Magento 2 doesn’t support Magento 1 themes. These facts are not very pleasant, right? But we have good news for you: migration to Magento 2 is an easy-going process with an experienced team of Magento developers.

How to Migrate from Magento 1 to Magento 2 and Why?

We, at WEB4PRO, have already completed a lot of Magento 2 based projects. Most of the project involved the task to migrate from Magento 1.x. Of course, this process could be challenging, but we have a lot of experience and effective solutions to perform it at the highest level.

Useful for you:

Also, there are several good ready-made modules for migration from Magento 1 to Magento 2. So, it’s possible for sure! Now you are aware of the things that will happen in a year, and you can be completely ready for these changes.

]]> Using Negative Values for the Product Quantity in Magento 2 https://web4pro.net/blog-news/using-negative-values-product-quantity-in-magento-2/ Wed, 13 Sep 2017 14:49:37 +0000 https://web4pro.net/?p=4292 When we deal with product quantity in Magento® 2, and it’s less than zero, we face the challenge. Sometimes we need to order the products in the online stores when they are not available at the moment. These products are in stock in Magento 2 but Merchants order them from the manufacturers and shippers after we place the order. In eCommerce, we call this back-order or drop-ship. In this case, the number of product quantity in the online store inventory can be less than 0. Yet, the products are available for the ordering.

Magento 2 includes this functionality. We can turn on the support for Qty field values which are less than 0 in Inventory Management Configuration. But there is one small catch. If the product quantity in Magento 2 is less than zero, the online shop administrator can’t edit and resave this product. The following error will appear in Qty field:

“Please enter a valid number in this field.”

You can find the description of this issue and the possible solution to it on GitHub. But you should know that it doesn’t work on the latest Magento versions (checked on Magento 2.1.7). We’ll cover the reason for this issues and the solution to it below.

The product editing form is implemented with UI-component. It is useful in case we need to do customization with different modules. For example, the form is claimed in the Catalog module. However, Cataloginventory module handles the quantity management.

Cataloginventory Module for Product Quantity in Magento 2

It’s possible to implement customization with classes-modifiers. They fit into Magento\Catalog\Ui\DataProvider\Product\Form\Modifier\Pool virtual type with di.xml.

If we take the Cataloginventory module, this modifier is claimed in the following way there:

<virtualType name="Magento\Catalog\Ui\DataProvider\Product\Form\Modifier\Pool">
        <arguments>
            <argument name="modifiers" xsi:type="array">
                <item name="advancedInventory" xsi:type="array">
                    <item name="class" xsi:type="string">Magento\CatalogInventory\Ui\DataProvider\Product\Form\Modifier\AdvancedInventory</item>
                    <item name="sortOrder" xsi:type="number">20</item>
                </item>
            </argument>
        </arguments>
    </virtualType>

The modifier class should implement \Magento\Ui\DataProvider\Modifier\ModifierInterface which must create two methods: modifyData($data) and modifyMeta($meta).

The component configuration is implemented in modifyMeta($meta) method, including its frontend part (javascript). In the solution from GitHub, the developer recommended turning off the digital validation with a custom modifier. We can implement it in the following way:

<virtualType name="Magento\Catalog\Ui\DataProvider\Product\Form\Modifier\Pool">
        <arguments>
            <argument name="modifiers" xsi:type="array">
                <item name="hf_quantity" xsi:type="array">
                    <item name="class" xsi:type="string">Web4pro\Defaultproduct\Ui\DataProvider\Product\Modifier\Quantity</item>
                    <item name="sortOrder" xsi:type="number">10000000</item>
                </item>
            </argument>
        </arguments>
    </virtualType>
class Quantity implements \Magento\Ui\DataProvider\Modifier\ModifierInterface {

    protected $arrayManager;

    public function __construct(\Magento\Framework\Stdlib\ArrayManager $arrayManager){
        $this->arrayManager =$arrayManager;
    }

public function modifyMeta(array $meta)
{
    if ($path = $this->arrayManager->findPath('quantity_and_stock_status_qty', $meta, null, 'children')) {
        $this->arrayManager->remove(
            $path . '/children/qty/arguments/data/config/validation/validate-digits',
            $meta
        );
    }

    if ($path = $this->arrayManager->findPath('advanced_inventory_modal', $meta)) {
        $meta = $this->arrayManager->merge(
            $path . '/children/stock_data/children/qty/arguments/data/config',
            $meta,
            ['validation' => ['validate-digits' => false]]
        );
    }

    return $meta;
}


    public function modifyData(array $data){
        return $data;
    }
}

In the latest Magento versions (Magento 2.1.7) this code will not work. The reason is the following. Magento has the implementation of support for integers and fractions. For example, the fractions work in case of product drop-shipping by weight.

The Solution for Product Quantity in Magento 2

Magento_CatalogInventory/js/components/qty-validator-changer component was implemented for the quantity validation. This is its code:

define([
    'Magento_Ui/js/form/element/abstract'
], function (Abstract) {
    'use strict';

    return Abstract.extend({
        defaults: {
            valueUpdate: 'input'
        },

        /**
         * Change validator
         */
        handleChanges: function (value) {
            var isDigits = value !== 1;

            this.validation['validate-number'] = !isDigits;
            this.validation['validate-digits'] = isDigits;
            this.validation['less-than-equals-to'] = isDigits ? 99999999 : 99999999.9999;
            this.validate();
        }
    });
});

handleChanges method checks the configuration value transmitted to the component. If the integers are used for the quantity, we should apply validate-digits validator. If we deal with fractions, we should apply validate-number. So, it’s not enough to turn off the validate-digits validator. We also should set the needed value of handleChanges function’s parameter. It allows us to avoid choosing this validator by the other function.

We describe this function’s parameter in Magento\CatalogInventory\Ui\DataProvider\Product\Form\Modifier\AdvancedInventory modifier the following way:

...
'imports' => [
                    'handleChanges' => '${$.provider}:data.product.stock_data.is_qty_decimal',
                ],
….

As we can see, we can get its values in both cases, whether we use integers or fractions for quantity. We set that in the configuration. So, let’s implement modifyMeta($meta) method in our modifier:

  public function modifyMeta(array $meta)
    {
        if ($path = $this->arrayManager->findPath('quantity_and_stock_status_qty', $meta, null, 'children')) {
            $this->arrayManager->remove(
                $path . '/children/qty/arguments/data/config/validation/validate-digits',
                $meta
            );
            $this->arrayManager->merge($path . '/children/qty/arguments/data/config/imports',$meta,
                                       array('handleChanges'=>"1"));
        }

        if ($path = $this->arrayManager->findPath('advanced_inventory_modal', $meta)) {
            $meta = $this->arrayManager->merge(
                $path . '/children/stock_data/children/qty/arguments/data/config',
                $meta,
                ['validation' => ['validate-digits' => false],'imports'=>['handleChanges'=>'1']]
            );
        }

        return $meta;
    }

Finally, we have the next results:

  • we turned off the validate-digits validator;
  • we set ‘handleChanges’ equal to 1.

It will cause the use of the right frontend validator. Furthermore, it won’t break the backend logic for the products which are on sales by item not by weight. We should repeat this twice because we can find the link under the Qty field. This link opens the advanced_inventory_modal pop-up.

As a result, the online store administrator will be able to save the products of which quantity is less than 0 without any problems.

This case is new to Magento 2. We make everything possible to make your journey with Magento 2 easier. If you have any questions regarding Magento 2 Extension Development, please, contact us. We’ll take care of your project.

]]> Extension Attributes for Total Model in Magento 2 https://web4pro.net/blog-news/extension-attributes-for-total-model-in-magento-2/ Thu, 10 Aug 2017 13:39:19 +0000 https://web4pro.net/?p=4246 We continue to set extension attributes in Magento® 2. Last time we were talking about the adding a custom attribute to the customer’s address. But what if we need to set these attributes for the total model? Today we’ll consider how we can do that step by step.

Total Model

Total model is a dynamic system used for collecting the shopping cart and the order total. It usually contains the elements which take part in calculating the total cost: final products total, discount, tax, shipping fee, and some other parameters.

How It Works

Imagine the online store. You buy some products there and add them to the shopping cart. When you view the shopping cart page, you can see something like this:

Subtotal – X.XX$ final cost of products (the product’s cost multiplied by the number of products)

Tax  – X.XX$ (optionally)

Shipping  – X.XX$ (optionally)

Discount (optionally)

Total – X.XX $ (the final cost of the order)

Let’s take a look at VENROY online store (it’s Magento based) to see how it can work for you:

Magento based online store

The whole system shown in this example is the Total model. Let’s move on.

What We Need to Do

First of all, we need to add the row before subtotal in the total model. The row will show the customer’s profit. The profit is a marketing element that shows how much money the customer saves using the offer. This profit should not be included in the final cost of the shopping cart and the order totals. It is calculated on the base of subtotal.

So, we can separate our task into two main problems:

  • Add the row before Subtotal and don’t include its results to the total cost.
  • Make the extension and Magento 2 work right together.

These both conditions must work correctly with each other.

In the end, we should get the result of this kind:

You save: (Our additional row)

Subtotal – final cost of products (the product cost * the number of products)

Tax (optionally)

Shipping (optionally)

Discount (optionally)

Total – the final cost of the order

Let’s go on to code!

Preconditions

There is a Magento 2 based online store. It is oriented on the retail and wholesale customers. Due to this fact, most of the products have the tier prices, as well as the retail prices. The types of store products are the simple products and configurable products. As we said before, we need to output the additional row before Subtotal on the shopping cart and the order pages. This row must show the total profit for the wholesale customer. While calculating the profit, we don’t include the extra-charge for product options. This row mustn’t influence the order final cost, as well as it mustn’t be copied to the order.

Solution

Setting Magento 2 Extension Attributes

Last time, we added the custom attribute to the customer address. Let’s follow the same way. We’ll add the style_discount field with decimal(10,4) type to the address extension attributes table from the last example. Also, we’ll need to add the attribute to the extenson_attributes.xml file of our module. We should add it twice for two different interfaces.

...
<extension_attributes for="MagentoQuoteApiDataAddressInterface">
        <attribute code="type" type="int">
            <join reference_table="web4pro_quote_address" join_on_field="address_id" reference_field="address_id">
                <field column="type">type</field>
            </join>
        </attribute>
        <attribute code="style_discount" type="float">
            <join reference_table="web4pro_quote_address" join_on_field="address_id" reference_field="address_id">
                <field column="style_discount">style_discount</field>
            </join>
        </attribute>
    </extension_attributes>
    <extension_attributes for="MagentoQuoteApiDataTotalsInterface">
        <attribute code="style_discount" type="float"/>
    </extension_attributes>
…

In the first case, we should specify the table which will store this attribute. In the second case, there is no necessity to do this, because the entity implemented with MagentoQuoteApiDataTotalsInterface is always formed from the address data along the way. Saving of this attribute will be performed in sales_quote_address_save_after event processor, which we described in the previous example.

Furthermore, we need to describe the total model. Let’s create an etc/sales.xml file in the module for these purposes. It looks like the following:

<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Sales:etc/sales.xsd">
    <section name="quote">
        <group name="totals">
            <item name="style_discount" instance="Web4proAjaxcartModelQuoteAddressStyle" sort_order="110"/>
        </group>
    </section>
</config>

We choose the sort_order parameter keeping in mind that calculations were performed after Subtotal had been calculated. In this case, the Product entity has already been initialized for all shopping cart elements.

Implementing Total Model in Magento 2

The total model must implement two methods: collect() method used for the calculation and fetch() method used for the output on request. You can implement the total by following this example:

namespace Web4proAjaxcartModelQuoteAddress;
use MagentoQuoteModelQuoteAddressItem as AddressItem;

class Style extends MagentoQuoteModelQuoteAddressTotalAbstractTotal {

    protected $_objectManager;

    public function __construct(MagentoFrameworkObjectManagerInterface $objectManagerInterface){
        $this->_objectManager = $objectManagerInterface;
    }

    public function collect(
        MagentoQuoteModelQuote $quote,
        MagentoQuoteApiDataShippingAssignmentInterface $shippingAssignment,
        MagentoQuoteModelQuoteAddressTotal $total
    ) {
        parent::collect($quote,$shippingAssignment,$total);
        $items = $shippingAssignment->getItems();
        $address = $shippingAssignment->getShipping()->getAddress();
        $amount = 0;
        foreach($items as $item){
            if ($item->getParentItem()) {
                continue;
            }
            if ($item instanceof AddressItem) {
                $quoteItem = $item->getAddress()->getQuote()->getItemById($item
->getQuoteItemId());
            } else {
                $quoteItem = $item;
            }
            $product = $quoteItem->getData('product');
            $childProduct = $product;
            if($product->getTypeId()=='configurable'){
                $childProduct = $product->getCustomOption('simple_product')->getProduct();
            }
            $qty = $quoteItem->getQty();
            $amount =(float)($qty*($childProduct->getPriceModel()->getFinalPrice($qty,$childProduct)-$childProduct->getPriceModel()->getBasePrice($childProduct,1)));
        }
        $total->addTotalAmount($this->getCode(),$amount);
        $extensionAttr = $address->getExtensionAttributes();
        if(!$extensionAttr){
            $extensionAttr = $this->_objectManager
->create('MagentoQuoteApiDataAddressExtension');
        }
        $extensionAttr->setData($this->getCode(),$total->getTotalAmount($this->getCode()));
        $address->setExtensionAttributes($extensionAttr);
        return $this;
    }
    public function fetch(MagentoQuoteModelQuote $quote, MagentoQuoteModelQuoteAddressTotal $total)
    {
        $result = null;
        $amount = $total->getTotalAmount($this->getCode());

        if ($amount != 0) {
            $result = [
                'code' => $this->getCode(),
                'title' => __('Style Discount'),
                'value' => $amount
            ];
        }
        return $result;
    }
}

Copying Data to Total Model in Magento 2

We need to provide copying the data from the address to the total model. It’s possible with the plugin from the previous example to MagentoFrameworkApiDataObjectHelper class. But note that we should work separately with address attributes and total model attributes. We copy the first ones to the order address and the second ones – to the total model. When trying to copy some data to the receiver which can’t receive the attribute, the exception will be thrown out. The method looks like this one:

public function beforePopulateWithArray($helper,$dataObject, array $data, $interfaceName){
        switch($interfaceName){
            case 'MagentoSalesApiDataOrderAddressInterface':
                if($data['extension_attributes'] instanceof MagentoQuoteApiDataAddressExtensionInterface){
                    $data['extension_attributes'] = $data['extension_attributes']->__toArray();
                    if(isset($data['extension_attributes']['style_discount'])){
                        unset($data['extension_attributes']['style_discount']);
                    }
                }
            break;
            case 'MagentoCustomerApiDataAddressInterface':
                if(isset($data['extension_attributes'])&&($data['extension_attributes'] instanceof MagentoQuoteApiDataAddressExtensionInterface)){
                    $data['extension_attributes'] = $data['extension_attributes']->__toArray();
                    if(isset($data['extension_attributes']['type'])){
                        $data['type'] = $data['extension_attributes']['type'];
                    }
                }
                break;
            case 'MagentoQuoteApiDataTotalsInterface':
                if($data['extension_attributes'] instanceof MagentoFrameworkApiAbstractSimpleObject){
                    $data['extension_attributes'] = $data['extension_attributes']->__toArray();
                    if(isset($data['extension_attributes']['type'])){
                        unset($data['extension_attributes']['type']);
                    }
                }
                break;
        }
        return array($dataObject,$data,$interfaceName);
    }

Outputting Total on Shopping Cart Page

Now we are going to output a new Total on the shopping cart page. It requires us to describe and implement Magento 2 knockout-component. It’s described in Layout file the next way:

<referenceBlock name="checkout.cart.totals">
            <arguments>
                <argument name="jsLayout" xsi:type="array">
                    <item name="components" xsi:type="array">
                        <item name="block-totals" xsi:type="array">
                            <item name="children" xsi:type="array">
                                <item name="style_discount" xsi:type="array">
                                    <item name="component"  xsi:type="string">Web4pro_Ajaxcart/js/style</item>
                                    <item name="sortOrder" xsi:type="string">1</item>
                                    <item name="config" xsi:type="array">
                                        <item name="template" xsi:type="string">Web4pro_Ajaxcart/checkout/cart/totals/style</item>
                                        <item name="title" xsi:type="string" translate="true"><![CDATA[Style Quantity Discount]]></item>
                                    </item>
                                </item>
                            </item>
                        </item>
                    </item>
                </argument>
            </arguments>
        </referenceBlock>

We choose sort_order taking into consideration that the row is outputted before Subtotal. As you can see, the component consists of a template and a javascript file. The template is loaded asynchronously, and it’s filled with the content with JavaScript. This is how the template supposed to look like:

<tr class="totals">
    <th class="mark" scope="row" data-bind="text: title"></th>
    <td data-bind="attr: {'data-th': title}" class="amount">
        <span class="price" data-bind="text: getValue()"></span>
    </td>
</tr>

JavaScript code:

define(
    [
        'Magento_Checkout/js/view/summary/abstract-total',
        'Magento_Checkout/js/model/quote'
    ],
    function (Component, quote) {
        "use strict";
        return Component.extend({

            isDisplayed: function() {
                return this.getPureValue()!=0;
            },
            getPureValue: function() {
                var totals = quote.getTotals()();
                if (totals) {
                    if(typeof totals.style_discount=='undefined'){
                        quote.setTotals(window.checkoutConfig.totalsData);
                        totals = quote.getTotals()();
                    }
                    return totals.style_discount;
                }
                return quote.style_discount;
            },
            getValue: function() {
                    return this.getFormattedPrice(this.getPureValue());
            }
         });
    }
);

Pay attention to the if condition (type of totals.style_discount==’undefined’). It’s necessary because Magento 2 extension attributes (we checked  2.1.2 version) are written to Total JavaScript object if only the asynchronous loading takes place (_SetTotals() method). It is not being written when the page is loaded from window.checkoutConfig.totalsData.

We can output this component to the order page by following the same routine.

Pitfalls

One of the moments we should keep in mind is that Total content is being added while calculating the Grand Total. It’s not good for our task. The reason lies in the implementation features of Grand Total calculation in MagentoQuoteModelQuoteAddressTotalGrand class. Take a look:

public function collect(
        MagentoQuoteModelQuote $quote,
        MagentoQuoteApiDataShippingAssignmentInterface $shippingAssignment,
        MagentoQuoteModelQuoteAddressTotal $total
    ) {
        $totals = array_sum($total->getAllTotalAmounts());
        $baseTotals = array_sum($total->getAllBaseTotalAmounts());

        $total->setGrandTotal($totals);
        $total->setBaseGrandTotal($baseTotals);
        return $this;
    }

We can fix this out using a plugin which excludes our total from the sum.

<type name="MagentoQuoteModelQuoteAddressTotal">
        <plugin name="web4pro-remove-external-totals" type="Web4proAjaxcartModelPlugin" sortOrder="20"/>
    </type>

public function afterGetAllTotalAmounts($total,$result){
        if(isset($result['style_discount'])){
            unset($result['style_discount']);
        }
        return $result;
    }

Conclusion

Finally, we have coped with our task. Let’s summarise what we needed to do:

  • add the style_discount field with decimal(10,4) type to the address extension attributes table;
  • add the attribute to the extenson_attributes.xml file of our module (twice for two different interfaces);
  • create the etc/sales.xml file in the module to describe the total model;
  • implement the total model;
  • provide copying the data from the address to the total model with the plugin (work separately with address attributes and total model attributes);
  • fix the adding of Total content while calculating the Grand Total with a special plugin;
  • output a new Total on the shopping cart and the order pages.

This is how it works. We hope that our article answers your question about set extension attributes for the total model. However, if you have some issues regarding extensions at your store and you need assistance, we can provide you with Magento 2 Extension Development.

Wish you good luck with Total Models in Magento 2!

]]>