module simplenews
1.0.0
Magento 2模塊開發或Magento 2 SimpleNews模塊逐步創建一個成熟的模塊。您可以按照我的代碼從划痕創建此模塊。或者，您可以直接下載壓縮焦油文件並安裝並播放它。
持久性層：描述資源模型，該模型負責使用CRUD請求在數據庫中提取和修改數據。此處還實現了Additional Business邏輯功能，例如，數據驗證和數據庫函數實現。
域層：負責業務邏輯，該業務邏輯不包含特定於資源的或數據庫特定信息。域層還可以包括服務合同。域層級別的數據模型取決於資源模型，該模型負責訪問數據庫。
服務層：介紹層和域層之間的中間層。它實現了使用PHP接口定義的服務合同。服務合同允許使用依賴項注入文件（di.xml）添加或更改業務邏輯資源模型。服務層還用於授予對API的訪問（REST /SOAP或其他模塊）。在模塊的 /API名稱空間中聲明服務界面。數據（實體）接口在 /API /數據中聲明。數據實體是傳遞到服務界面並返回的數據結構。
演示層：上層。它包含所有視圖元素（包括佈局，塊，模板，CSS，JS）和控制器。呈現層通常使用服務合同調用服務層。但是，根據實施，它可能與業務邏輯重疊。
API或API/數據：服務合同，定義服務界面和數據接口
適配器：課程遵循適配器模式並圍繞第三方庫中的類包裝，允許通過將第三方類界面轉換為本機代碼期望的接口，從而使用代碼中的第三方庫中的功能。 （Module-Search/Adapter/）
塊：我們的MVVM體系結構的ViewModels
收藏家：模塊 - deploy/collector/collector.php
命令：目錄用於存儲負責控制台程序執行的PHP文件。在我們的情況下，console/command/imagesResizecommand.php進程命令命令進行調整大小。
控制器：負責在與系統互動時處理用戶的流量
config：模塊deploy/config/bundleconfig.php
CRON：我們使用該目錄存儲文件，後來在CRON啟動上執行這些文件。
CustomerData：目錄包含負責處理各節信息的PHP文件。 Magento 2具有特殊的功能，可以對信息進行處理，更新和傳輸信息。
等等：配置XML文件模塊在此文件夾中定義自身及其零件（路由，模型，塊，觀察者和CRON作業），也可以由非核心模塊使用來覆蓋核心模塊的功能。
異常：（模塊 - sales/exception/）
文件：示例文件（Module-Inventory-Import-Export/Files/）
固定裝置：示例數據模塊（模塊 - same-sample-data/fixtures/orders.csv）
網關：（模塊付款/網關）
助手：將代碼保存在多個應用程序層中的類。例如，在CMS模塊中，助手類負責準備HTML以顯示瀏覽器。
I18N：持有國際化CSV文件，用於翻譯
索引器：indexHandler（模塊Inventory-indexer/indexer）
模型：用於模型和資源模型
觀察者：持有觀察者或正在“觀察”系統事件的模型。通常，當解僱此類事件時，觀察者會實例化模型來處理此類事件的必要業務邏輯。
軟件包：模塊數據/軟件包
定價：最終價格模型（Module-MSRP-GROUPED產品/定價）
流程：模塊數據/過程
插件：目錄包含插件文件允許我們在配置文件中所述的必要時修改某些模塊的函數：供應商/magento/module-catalog/etc/etc/di.xml
SEARCHADAPTER：模塊-Elasticsearch/SearchAdapter
ReportXML：供應商/Magento/Module-Analytics/ReportXML
設置：遷移類，負責架構和數據創建
服務：[考試]（Module-Media-Storage/service/imageresize.php，Module-deploy/或Module-catalog-url-url-ewrite/service/v1/v1/storeviewservice.php）
SRC：供應商/Magento/Magento2官能測試框架/SRC/Magento/
策略：模塊 - 部署/策略
資料來源：模塊數據/來源
測試：單位測試
UI：管理應用程序中使用的網格和表單等元素
查看 - 前端和管理應用程序的佈局（XML）文件和模板（PHTML）文件包含模板文件，CSS和JS文件，模塊媒體文件。這些文件位於子文件夾中，具體取決於使用區域：Adminhtml，Frontend或Base（網站管理和額葉部分的常見文件）。這些子目錄反過來，包括靜態視圖文件，設計模板，電子郵件模板和佈局文件：
ViewModel ：（模塊 - 銷售/ViewModel）
在此模塊中，我們將使用BDCrops用於供應商名稱，而SimpleNews則用於調製名稱。因此，我們需要製作此文件夾： app/code/BDC/SimpleNews
Magento 2尋找該模塊ETC目錄中每個模塊的配置信息。我們需要創建文件夾等並添加模塊：xml：
創建ETC/Module.xml和此文件的內容：
```
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Module/etc/module.xsd">
<module name="BDC_SimpleNews" setup_version="1.0.0" />
</config>
```
在此文件中，我們註冊了一個具有名稱BDC_SimpleNews的模塊，並且版本為1.0.0 。
所有Magento 2模塊必須通過Magento ComponentRogristrar類在Magento系統中註冊。該文件將放置在模塊根目錄中。在此步驟中，我們需要創建此文件：
創建registration.php並將以下代碼插入其中：
MagentoFrameworkComponentComponentRegistrar::register(
MagentoFrameworkComponentComponentRegistrar::MODULE,
'BDC_SimpleNews', __DIR__
);
供應商文件夾中的模塊將使用COMPOSER進行更新，並且App/Code中的所有模塊都不會通過Composer更新，這就是為什麼當您需要覆蓋任何模塊時，將其添加到App/Code中時
創建composer.json並將以下代碼插入其中：
```
{
"name": "bdc/module-simplenews",
"description": "BDCrops SimpleNews module for Magento 2 extensions.",
"type": "magento2-module",
"version": "1.0.3",
"license": [
"OSL-3.0",
"AFL-3.0"
],
"authors": [{
"name": "Abdul Matin",
"email": "[email protected]",
"company": "BDCrops Inc"
}
],
"homepage": "https://www.bdcrops.com",
"autoload": {
"files": [
"registration.php"
],
"psr-4": {
"BDC\SimpleNews\": ""
}
}
}
```
創建ETC/db_schema.xml＆插入以下代碼：
```
<?xml version="1.0"?>
<schema xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Setup/Declaration/Schema/etc/schema.xsd">
<table name="bdc_simplenews" resource="default" engine="innodb" comment="SimpleNews Table">
<column xsi:type="smallint" name="id" padding="6" unsigned="false" nullable="false" identity="true" comment="ID"/>
<column xsi:type="varchar" name="title" nullable="false" length="255" comment="Title"/>
<column xsi:type="varchar" name="summary" nullable="false" length="255" comment="Summary"/>
<column xsi:type="varchar" name="description" nullable="false" length="255" comment="Descrition"/>
<column xsi:type="timestamp" name="created_at" nullable="false" default="CURRENT_TIMESTAMP" on_update="false" comment="Created Datetime"/>
<column xsi:type="timestamp" name="updated_at" nullable="false" default="CURRENT_TIMESTAMP" on_update="true" comment="Updated Datetime"/>
<column xsi:type="smallint" name="status" padding="2" unsigned="false" nullable="false" comment="Status"/>
<constraint xsi:type="primary" referenceId="PRIMARY"> <column name="id"/> </constraint>
</table>
</schema>
```
tutarials模塊份量
您將無法在不創建模式白名單的情況下運行聲明模式。注意：建議為雙檢查目的生成一個新的白名單。為此，您需要a /etc/db_schema_whitelist.json文件，該文件將存儲所有添加的內容中的內容。要生成此文件，請運行：
php bin/magento setup:db-declaration:generate-whitelist [options]
php bin/magento setup:db-declaration:generate-whitelist --module-name=vendor_module
php bin/magento setup:db-declaration:generate-whitelist --module-name=BDC_SimpleNews
現在，將在/供應商/模塊/等文件夾中創建db_whitelist_schema.json文件。 
在上面的步驟上，您創建了一個空模塊。現在我們將在Magento環境中啟用它。在啟用模塊之前，我們必須檢查以確保Magento已在命令行中輸入以下內容識別我們的模塊：
php bin/magento module:status
如果您遵循以上步驟，則將在結果中看到這一點：
List of disabled modules:
BDC_SimpleNews
這意味著該模塊已通過系統識別，但仍被禁用。運行此命令啟用它：
php bin/magento module:enable BDC_SimpleNews
如果您看到此結果，則該模塊已成功啟用：
The following modules has been enabled:
- BDC_SimpleNews
這是您第一次啟用此模塊，因此Magento需要檢查和升級模塊數據庫。我們需要運行此評論：
php bin/magento setup:upgrade
現在，您可以在Stores -> Configuration -> Advanced -> Advanced模塊存在。
另外，您可以從phpmyadmin或您喜歡的工具中檢查數據庫表：
由於在舊方法中，我們在創建表時使用腳本在安裝架構或升級模式中編寫腳本，但是現在在新版本中，這將通過修補程序系統完成。數據補丁程序是包含數據修改說明的類。它是在A/<module_name> /setup/patch/data/data/< patch_name> .php文件中定義的，並實現了 magento magento setup stetup model patch patch datapatchinterface。模式補丁包含自定義架構修改說明。這些修改可能很複雜。它是在A/<Module_name>/setup/patch/schema/<patch_name> .php文件中定義的，並實現了 magento setup stetup stetup model patch patch schemapatchinterface。因此，要將數據添加到bdc_simplenews表中，請在文件夾BDC/SimplEnews/setup/patch/Data中創建Adddata.php文件，然後編寫以下代碼
創建設置/補丁/數據/adddata.php
```
<?php
namespace BDCSimpleNewsSetupPatchData;
use MagentoFrameworkSetupPatchDataPatchInterface;
use MagentoFrameworkSetupPatchPatchVersionInterface;
use MagentoFrameworkModuleSetupMigration;
use MagentoFrameworkSetupModuleDataSetupInterface;
class AddData implements DataPatchInterface, PatchVersionInterface {
private $news;
public function __construct( BDCSimpleNewsModelNews $news ) {
$this->news = $news;
}
public function apply(){
$newsData = [];
$newsData['title'] = "BDC News Head1";
$newsData['summary'] = "BDC News Summary";
$newsData['description'] = "BDCrops Inc description evulation of bangladesh";
//$newsData['status'] = 1;
$this->news->addData($newsData);
$this->news->getResource()->save($this->news);
}
public static function getDependencies() { return []; }
public static function getVersion() { return '2.0.0'; }
public function getAliases() { return []; }
}
```
我們需要創建這些文件以插入，更新，刪除和獲取數據庫中的數據。
創建模型文件：型號/news.php：
```
<?php
// These files to insert, update, delete and get data in the database.
namespace BDCSimpleNewsModel;
use MagentoFrameworkModelAbstractModel;
class News extends AbstractModel{
/**
* News constructor.
* @param MagentoFrameworkModelContext $context
* @param MagentoFrameworkRegistry $registry
* @param MagentoFrameworkModelResourceModelAbstractResource|null $resource
* @param MagentoFrameworkDataCollectionAbstractDb|null $resourceCollection
* @param array $data
*/
public function __construct(
MagentoFrameworkModelContext $context,
MagentoFrameworkRegistry $registry,
MagentoFrameworkModelResourceModelAbstractResource $resource = null,
MagentoFrameworkDataCollectionAbstractDb $resourceCollection = null,
array $data = [] ) {
parent::__construct($context, $registry, $resource, $resourceCollection, $data);
}
/**
* (non-PHPdoc)
* @see MagentoFrameworkModelAbstractModel::_construct()
*/
public function _construct(){
$this->_init('BDCSimpleNewsModelResourceNews');
}
/**
* Loading news data
*
* @param mixed $key
* @param string $field
* @return $this
*/
public function load($key, $field = null) {
if ($field === null) {
$this->_getResource()->load($this, $key, 'id');
return $this;
}
$this->_getResource()->load($this, $key, $field);
return $this;
}
}
```
Magento 2中的CRUD模型可以輕鬆地管理數據庫中的數據，您無需編寫許多代碼行即可創建CRUD。 CRUD代表創建，閱讀，更新和刪除。 Magento Orm是由Magento 2服務合同的一部分的存儲庫實現使用的。這是Magento 1的重要變化，因為模塊不再使用特定ORM依靠其他模塊，而不是僅使用實體存儲庫。該服務合同將在本文第二部分中的更多詳細信息中涵蓋。 MagentoOrm圍繞模型，資源模型和資源收集構建。 Magento Orm元素正在遵循：
ORM使您有可能在數據庫中創建，加載，更新和刪除數據。 Magento中的集合是一個實現IteratorAggregate和可計數PHP5 SPL界面的類。收集在Magento中廣泛用於存儲特定類型的一組對象。
模型就像一個黑匣子，它在資源模型的頂部提供了一層抽象。數據的提取，提取和操縱通過模型發生。根據經驗，我們創建的每個實體（即在數據庫中創建的每個表）都應具有自己的模型類。每個模型都擴展了Magento Framework Model AbstractModelClass，它繼承了 Magento Framework DataObjectClass，因此，我們可以在模型上分別稱為SetDataand GetData函數，以獲取或設置模型的數據。當我們調用_ init（）方法時，只有一個方法，_ struction（），然後將資源模型的名稱傳遞給其參數
創建資源模型/資源/news.php：
```
<?php
namespace BDCSimpleNewsModelResource;
use MagentoFrameworkModelResourceModelDbAbstractDb;
class News extends AbstractDb {
/**
* Define main table
*/
protected function _construct() { $this->_init('bdc_simplenews', 'id'); }
}
```
所有實際的數據庫操作均由資源模型執行。每個模型都必須具有資源模型，因為資源模型的所有方法都期望模型是其第一個參數。所有資源模型都必須擴展Magento Framework Model Resourcemodel db AbstractDbClass。在這裡，也有一種方法，<__構造>，我們稱為<_ Initmethod>，然後將兩個參數傳遞給它。數據庫中表的名稱以及該表中的主列的名稱。資源模型。在Magento 2中，模型類定義了最終用戶程序器將用於與模型數據交互的方法。資源模型類包含實際上從數據庫中獲取信息的方法。 Magento 2中的每個CRUD模型都有相應的資源模型類。
每個CRUD資源模型類都擴展了Magento Framework Model Resourcemodel db AbstractDB類。該基類包含從單個數據庫表獲取信息的基本邏輯。對於像我們這樣的基本模型，資源模型唯一要做的就是從_構造中調用_ init方法。資源模型的_ init方法接受兩個參數。第一個是數據庫表的名稱（BDC_SIMPLENEWS），第二個是模型（ID）的ID列。儘管它超出了本文的範圍，但Magento 2的主動記錄實現不包含通過主鍵鏈接表的方法。如何使用多個數據庫表取決於每個單獨的模塊開發人員，資源模型通常包含從相關表獲取信息所需的SQL生成方法。
創建集合模型/資源/新聞/Collection.php：
```
<?php
namespace BDCSimpleNewsModelResourceNews;
use MagentoFrameworkModelResourceModelDbCollectionAbstractCollection;
class Collection extends AbstractCollection {
/**
* Define model & resource model
*/
protected function _construct(){
$this->_init('BDCSimpleNewsModelNews', 'BDCSimpleNewsModelResourceNews');
}
}
```
當我們想從表中獲取多個行時，使用集合。意義收藏
借助模型和資源模型，您擁有將單個模型獲取並將單個模型保存到數據庫中所需的一切。但是，有時您需要獲取特定類型的多種型號。為了解決此問題，Magento 2中的每個CRUD模型都有相應的資源模型收集。收集收集單個模型。它被認為是一種資源模型，因為它構建了從數據庫表中獲取信息所需的SQL代碼。 Magento 2中的所有集合擴展了基礎 Magento Framework Model ResourceModel db collection AbstractCollection Collection Class類。像模型和資源模型一樣，收集資源模型必須調用_ init方法。收集資源模型的_ init方法接受兩個參數。第一個是該集合收集的模型。第二個是收集的模型的資源模型。我們創建一個新的Magento 2塊，注入 Magento Catalog Model Resourcemodel Product Product CollectionFactory類。這是從工廠收集的。 GetProductCollection返回新產品集合。此方法執行以下操作：
我們將找到如何創建前端路由，管理路線以及如何使用路由來重寫控制器。
<!--Use router 'standard' for frontend route-->
<router id="standard">
<!--Define a custom route with id and frontName-->
<route frontName="samplenews" id="samplenews">
<!--The module which this route match to-->
<module name="BDC_SampleNews"/>
</route>
</router>
請查看代碼，您會看到註冊路線非常簡單。您必須將標準路由器用於前端。該路線將有一個定義該模塊的孩子和2個屬性：
ID屬性是一個唯一的字符串，可以識別此路線。您將使用此字符串來聲明該模塊操作的佈局句柄。前名屬性也是一個唯一的字符串，將顯示在URL請求中。例如，如果您聲明這樣的路線：該模塊的URL應該是：
http://example.com/index.php/samplenews/controller/action和此操作的佈局句柄是：samplenews_controller_action.xml
{namespace}/{module}/Controller/{Controller}/{Action}.php
http://example.com/<router_name>/<controller_name>/<action_name>
路由器用於將URL分配給相應的控制器和操作。在此模塊中，我們需要為前端區域創建路線。因此，我們需要添加此文件：
創建etc/frontend/utaes.xml：
~~~
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../../../../../../lib/internal/Magento/Framework/
App/etc/routes.xsd">
<router id="standard">
<route id="news" frontName="news">
<module name="BDC_SimpleNews" />
</route>
</router>
</config>
~~~
定義路線後，通往我們模塊的URL路徑將是： http://example.com/news/
路由器：定義一個模塊的名稱，我們可以在URL中使用該名稱來查找模塊並執行控制器操作。
控制器：Magento 2中的控制器與MVC應用中的典型控制器不同。 Magento 2控制器僅負責一個特定的URL，僅包含一個執行方法。此方法負責返回結果對象和偶爾處理輸入POST數據。所有控制器繼承 Magento Framework App Action Action Class。在基本路由器中搜索所需的控制器，然後在前控制器中調用。
響應：Magento 2中的控制器可以根據目的和必要的結果返回幾種響應類型。
前端路線：請查看代碼，您會看到註冊路線非常簡單。您必須將標準路由器用於前端。該路線將有一個定義該模塊的孩子和2個屬性：
在這一部分中，我們將討論用於模型的工廠對象。如您在OOP中所知，將使用一種工廠方法來實例化對象。在Magento中，工廠對像也可以做同樣的事情。
工廠類名稱是模型類的名稱，並用“工廠”單詞附加。因此，就我們的例子而言，我們將舉辦新聞界面的課程。您不得創建此類。 Magento將為您創建它。每當Magento的Object Manager遇到以“工廠”一詞結尾的類名稱時，如果該類尚不存在，它將在VAR/Generation文件夾中自動生成工廠類。您將看到工廠課程：
use BDCSimpleNewsModelNewsFactory;
var/generation/<vendor_name>/<module_name>/Model/ClassFactory.php
var/generation/BDC/SimpleNew/Model/NewsFactory.php
為了實例化模型對象，我們將使用自動構造函數依賴項注入來注入出廠對象，然後使用出廠對象實例化模型對象。
Magento 2授權您註冊支持靜態註冊表方法的全局變量。 Magento 1以及Magento 2授權您註冊支持靜態註冊表方法的全局變量。為了實現這一目標，也許您曾經與Mage :: Register（）和Mage :: Registry（）在Magento 1中使用，但是現在在Magento 2平台中，運行註冊表有差異。您將需要應用 Magento Framework Registry，該註冊表接受已還原數據的設置和註冊表。但是，首先，您需要學習如何創建或使用自己的自定義註冊表，並向您展示如何檢索全球Magento 2註冊表對象，例如當前產品，類別，CMS頁面，CMS塊等，這很幸運，因為所有這些對像都會在此處引用。今天的主題將幫助您熟悉Magento 2註冊表對象。
/**
* @var MagentoFrameworkRegistry
*/
protected $_registry;
/**
* ...
* ...
* @param MagentoFrameworkRegistry $registry,
*/
public function __construct(
...,
...,
MagentoFrameworkRegistry $registry,
...) {
$this->_registry = $registry;
...
...
}
/**
* Setting custom variable in registry to be used
*
*/
public function setCustomVariable() {
$this->registry->register('custom_var', 'Added Value');
}
/**
* Retrieving custom variable from registry
* @return string
*/
public function getCustomVariable() {
return $this->registry->registry('custom_var');
}
創建控制器控制器/索引/index.php：
<?php
namespace BDCSimpleNewsControllerIndex;
use MagentoFrameworkAppActionAction;
use MagentoFrameworkAppActionContext;
use BDCSimpleNewsModelNewsFactory;
class Index extends Action {
/**
* @var BDCSimpleNewsModelNewsFactory
*/
protected $_modelNewsFactory;
/**
* @param Context $context
* @param NewsFactory $modelNewsFactory
*/
public function __construct(
Context $context,
NewsFactory $modelNewsFactory ) {
parent::__construct($context);
$this->_modelNewsFactory = $modelNewsFactory;
}
public function execute(){
/**
* When Magento get your model, it will generate a Factory class
* for your model at var/generaton folder and we can get your
* model by this way
*/
$newsModel = $this->_modelNewsFactory->create();
// Load the item with ID is 1
$item = $newsModel->load(1);
var_dump($item->getData());
// Get news collection
$newsCollection = $newsModel->getCollection();
// Load all data of collection
var_dump($newsCollection->getData());
}
}
```
</details>
定義控制器後，通往我們模塊的URL路徑將為： http://example.com/news/以下數據
$this->_forward('action', 'controller', 'Other_Module')
public function __construct(
$pageFactory MagentoFrameworkViewResultPageFactory
) {
$this->pageResultFactory = $pageFactory
}
public function execute()
{
return $this->pageResultFactory->create();
}
public function __construct(
MagentoFrameworkControllerResultRaw $rawResultFactory ,
) {
$this->rawResultFactory = $rawResultFactory;
}
public function execute()
{
$result = $this->rawResultFactory->create();
$result->setHeader('Content-Type', 'text/xml');
$result->setContents('<root><block></block></root>);
return $result;
}
public function __construct(
MagentoFrameworkControllerResultForwardFactory $resultForwardFactory
) {
$this->resultForwardFactory = $resultForwardFactory;
}
public function execute()
{
$result = $this->resultForwardFactory->create();
$result->forward('noroute');
return $result;
}
public function __construct(
MagentoFrameworkControllerResultRedirectFactory $resultRedirectFactory
) {
$this->resultRedirectFactory = $resultRedirectFactory;
}
public function execute()
{
$result = $this->resultRedirectFactory->create();
$result->setPath('*/*/index');
return $result;
}
如果您的Magento安裝具有網站，商店或視圖的層次結構，則可以設置配置設置的上下文或“範圍”以應用於安裝的特定部分。許多數據庫實體的上下文也可以分配一個特定範圍，以確定其在商店層次結構中的使用方式。要了解更多信息，請參見：產品範圍和價格範圍。
某些配置設置（例如郵政代碼）具有[全局]範圍，因為整個系統中都使用相同的值。 [網站]範圍適用於層次結構中低於該級別的任何商店，包括所有商店及其觀點。每個商店視圖的設置範圍範圍的任何項目都可以不同，該視圖通常用於支持多種語言。
除非商店以單存儲模式運行，否則每個配置設置的範圍都以字段標籤下方的小文本出現。如果您的安裝包含多個網站，商店或視圖，則應始終在進行任何更改之前選擇設置應用的位置。
Magento 2的一個重要但不好的文檔功能是如何按範圍編寫和獲取配置值。您會在全球範圍內找到大量的代碼樣本。有時您需要通過編程為不同商店進行不同的設置。因此，這是如何工作的。
Magento將所有AdminHTML設置保存在Magento數據庫中的Core_config表中。在那裡，您可以通過其路徑獲得值，該字符串指示通往和變量名稱的路徑。使用此路徑，您可以通過Magento 2核心方法獲得或設置值。為此，您需要使用：
以下示例代碼顯示瞭如何按範圍編寫存儲配置值：
class WriteConfig {
protected $_logger;
protected $_storeManager;
protected $_configWriter;
public function __construct(
PsrLogLoggerInterface $logger,
MagentoFrameworkAppConfigStorageWriterInterface $configWriter,
MagentoStoreModelStoreManagerInterface $storeManager ){
$this->_logger = $logger;
$this->_configWriter = $configWriter;
$this->_storeManager = $storeManager;
}
public function setConfig($value) {
//for all websites
$websites = $this->_storeManager->getWebsites();
$scope = "websites";
foreach($websites as $website) {
echo $website->getId().":n";
$this->_configWriter->save('my_section/something/configvaluename', $value, $scope, $website->getId());
}
return $this;
}
}
您只需要以給定值調用SetConfig（）方法。該方法將此值存儲到所有網站的定義路徑中。因此，它為每個定義的網站生成了一個新設置（core_config表中的行）。這是通過在保存方法上使用第三和第四參數來完成的。您使用此範圍的唯一路徑，值，範圍和ID。如果您不使用範圍，則將將值定為默認值（存儲ID 0）。您可以將值存儲到範圍“網站”或“存儲”。
現在是時候通過商店讀取數據了。您可以使用以下示例代碼執行此操作：
class ReadConfig
{
protected $_scopeConfig;
public function __construct(
MagentoFrameworkAppHelperContext $context,
MagentoFrameworkAppConfigScopeConfigInterface $scopeConfig
){
$this->_scopeConfig = $scopeConfig;
parent::__construct($context);
}
public function getConfig() {
return $this->_scopeConfig->getValue("my_section/something/configvaluename", "websites");
}
}
這很容易，您只需要使用getValue（）方法，然後添加第二個參數（在這裡我們使用網站範圍）。這將返回當前網站的存儲值。
在Magento 2：數據庫（core_config_data表）和XML文件中存儲配置值的主要位置。存儲在數據庫中的配置可以通過管理員面板更改，而XML文件中的數據具有技術性質，只能由開發人員更改。
在Magento 2中易於使用配置文件。配置文件包括：
Magento/Framework/Config為開發人員提供以下接口：
Magento 2為XML配置文件提供兩種類型的驗證：合併後合併和驗證之前的驗證。它可以是相同或不同的方案。要創建自定義配置文件，您需要創建以下元素：
product_types.xml magento_catalog的模塊，作為自定義配置文件的示例。每個模塊可以使用product_types.xml文件添加自己的產品類型，這些文件將經過驗證和合併。
System.xml是一個配置文件，用於在Magento 2系統配置中創建配置字段。如果您的模塊具有某些設置，則需要此設置。您可以轉到存儲 - >設置 - >配置以檢查其外觀。 Magento2系統配置頁面在邏輯上分為幾個部分：選項卡，部分，組，字段。
system.xml中的每個字段在創建之後都沒有任何值。當您打電話給它們時，您將收到“ null”結果。因此，對於模塊，我們需要設置字段的默認值，您將在不轉到配置，設置值並保存它的情況下調用該值。此默認值將保存在位於ETC文件夾中的config.xml中。讓我們為此簡單配置創建它：etc/config.xml
<default>
<section>
<group>
<field>{value}</field>
</group>
</section>
</default>
首先，讓我們保存值和沖洗緩存，然後您可以從數據庫中獲得保存的值。在system.xml中，我們添加了2個字段：enable和display_text。因此，路徑應該是：Samplenews/eneral/enable Samplenews/eneral/display_text簡單呼叫：ex
$this->scopeConfig->getValue('samplenews/general/enable', MagentoStoreModelScopeInterface::SCOPE_STORE);
$this->scopeConfig->getValue('samplenews/general/display_text', MagentoStoreModelScopeInterface::SCOPE_STORE);
創建FileEtc/adminhtml/System.xml目的：此文件將在商店>“設置”>“配置”部分中聲明您的配置），並將以下代碼插入：
```
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../Backend/etc/system_file.xsd">
<system>
<tab id="bdc" translate="label" sortOrder="1">
<label>BDC</label>
</tab>
<section id="simplenews" translate="label" sortOrder="1" showInDefault="1" showInWebsite="1" showInStore="1">
<label>Simple News</label>
<tab>bdc</tab>
<resource>BDC_SimpleNews::system_config</resource>
<group id="general" translate="label" type="text" sortOrder="1" showInDefault="1" showInWebsite="1" showInStore="1">
<label>General Settings</label>
<field id="enable_in_frontend" translate="label" type="select" sortOrder="1" showInDefault="1" showInWebsite="1" showInStore="1">
<label>Enable in frontend</label>
<source_model>MagentoConfigModelConfigSourceYesno</source_model>
</field>
<field id="head_title" translate="label comment" type="text" sortOrder="2" showInDefault="1" showInWebsite="1" showInStore="1">
<label>Head title</label>
<comment>Fill head title of news list page at here</comment>
<validate>required-entry</validate>
</field>
<field id="lastest_news_block_position" translate="label" type="select" sortOrder="3" showInDefault="1" showInWebsite="1" showInStore="1">
<label>Lastest news block position</label>
<source_model>BDCSimpleNewsModelSystemConfigLastestNewsPosition</source_model>
</field>
</group>
</section>
</system>
</config>
```
Magento 2中的系統配置值存儲在core_config_data數據庫表中，該表與Magento 1完全相同。但是XML配置文件不同。 System.xml是一個配置文件，用於在Magento 2系統配置中創建配置字段。系統配置文件在etc/adminhtml/system.xml
System.xml是一個配置文件，用於在Magento 2系統配置中創建配置字段。如果您的模塊具有某些設置，則需要此設置。您可以轉到存儲 - >設置 - >配置以檢查其外觀。
創建文件模型/系統/config/lastestnews/position.php：
```
<?php
namespace BDCSimpleNewsModelSystemConfigLastestNews;
use MagentoFrameworkOptionArrayInterface;
class Position implements ArrayInterface{
const LEFT = 1;
const RIGHT = 2;
const DISABLED = 0;
/**
* Get positions of lastest news block
*
* @return array
*/
public function toOptionArray(){
return [
self::LEFT => __('Left'),
self::RIGHT => __('Right'),
self::DISABLED => __('Disabled')
];
}
}
```
創建文件等/acl.xml（目的：此文件將為您的配置部分創建角色），並將以下代碼插入：
```
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../../../../../lib/internal/Magento/Framework/Acl/etc/acl.xsd">
<acl>
<resources>
<resource id="Magento_Backend::admin">
<resource id="Magento_Backend::stores">
<resource id="Magento_Backend::stores_settings">
<resource id="Magento_Config::config">
<resource id="BDC_SimpleNews::system_config" title="Simple News Section" />
</resource>
</resource>
</resource>
</resource>
</resources>
</acl>
</config>
```
創建文件等/config.xml，然後將以下代碼插入其中：
```
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../../Core/etc/config.xsd">
<default>
<simplenews>
<general>
<enable_in_frontend>1</enable_in_frontend>
<head_title>BDC - Simple News</head_title>
<lastest_news_position>1</lastest_news_position>
</general>
</simplenews>
</default>
</config>
```
Magento 2，助手可以在控制器，模型，視圖甚至其他幫助者中調用。幫助者可以被視為全球，並且始終可用。它們甚至可以作為單個對象的實例創建。此外，一旦您將它們注入班級，它們就可以在任何地方被稱為。助手主要是為了提供最常見功能的方法。例如，您可以使用助手在Magento的應用中構建日誌。 Magento 2助手類包括各種功能和方法，這些功能和方法通常在整個應用程序中使用。所有被聲明為助手的方法都可以在任何地方都調用，包括文件，型號，塊，控制器類或Magento 2中的另一個助手。
在Magento 2的早期版本中，可以使用輔助工廠，這使開發人員能夠實例化輔助方法。此外，您可以使用以下代碼使用ObjectManager實例化輔助工廠。
$object_manager = MagentoCoreModelObjectManager::getInstance();
$helper_factory = $object_manager->get('MagentoCoreModelFactoryHelper');
$helper = $helper_factory->get('MagentoCoreHelperData');
但是，此代碼仍然存在一些問題。幸運的是，已經提出了一個更好的概念，即Magento 2中的依賴注入。
使用此概念，環境將創建並為您提供一個對象而不是實例化。例如，如果類似於以下內容：
class Helper{
public function __contruct(Helper $xyz){
$this->xyz= $xyz;
}
}
在輔助類構造函數中，輔助類的對像是自動創建的，並分配了參考$ xyz。這是依賴注入。
通過這個概念，Magento 2提供了高價值鬆散的耦合模塊概念。如果您想將其註入特定類，只需在其構造函數中添加一個對象即可。但是，您需要記住，您不能兩次注入一個依賴。
創建文件：helper/data.php並將以下代碼插入其中：
<?php
namespace BDCSimpleNewsHelper;
use MagentoFrameworkAppHelperAbstractHelper;
use MagentoFrameworkAppConfigScopeConfigInterface;
use MagentoFrameworkAppHelperContext;
use MagentoStoreModelScopeInterface;
class Data extends AbstractHelper {
const XML_PATH_ENABLED = 'simplenews/general/enable_in_frontend';
const XML_PATH_HEAD_TITLE = 'simplenews/general/head_title';
const XML_PATH_LASTEST_NEWS = 'simplenews/general/lastest_news_block_position';
/**
* @var MagentoFrameworkAppConfigScopeConfigInterface
*/
protected $_scopeConfig;
/**
* @param Context $context
* @param ScopeConfigInterface $scopeConfig
*/
public function __construct(
Context $context,
ScopeConfigInterface $scopeConfig ) {
parent::__construct($context);
$this->_scopeConfig = $scopeConfig;
}
/**
* Check for module is enabled in frontend
*
* @return bool
*/
public function isEnabledInFrontend($store = null){
return $this->_scopeConfig->getValue(
self::XML_PATH_ENABLED,
ScopeInterface::SCOPE_STORE
);
}
/**
* Get head title for news list page
*
* @return string
*/
public function getHeadTitle() {
return $this->_scopeConfig->getValue(
self::XML_PATH_HEAD_TITLE,
ScopeInterface::SCOPE_STORE
);
}
/**
* Get lastest news block position (Left, Right, Disabled)
*
* @return int
*/
public function getLastestNewsBlockPosition() {
return $this->_scopeConfig->getValue(
self::XML_PATH_LASTEST_NEWS,
ScopeInterface::SCOPE_STORE
);
}
}
<add id="BDC_SimpleNews::news" title="Manage News" module="BDC_SimpleNews" sortOrder="10" action="bdc_simplenews/news" resource="BDC_SimpleNews::news" parent="BDC_SimpleNews::samplenews"/>
ID屬性是此註釋的標識符。這是一個唯一的字符串，應遵循格式：{vendor_modulename} :: {菜單_description}。
標題屬性是將在菜單欄上顯示的文本。
模塊屬性定義了此菜單所屬於的模塊。
sortroder屬性定義了菜單的位置。較低的值將顯示在菜單頂部。
父屬性是其他菜單節點的ID。它會告訴Magento，此菜單是另一個菜單的孩子。在此示例中，我們有父母=“ bdc_samplenews :: smplenews”，所以我們 - 知道此菜單“管理新聞”是“ Hello World”菜單的孩子，它將在Hello World菜單中顯示。
操作屬性將定義此菜單鏈接到的頁面的URL。正如我們上面討論的那樣，將遵循此格式{router_name} {controller_folder} {action_name}。 - 在此示例中，此菜單將鏈接到模塊採樣，控制器新聞和操作索引
資源屬性用於定義管理用戶必須擁有的ACL規則，以查看和訪問此菜單。我們將在其他主題中找到有關ACL的更多詳細信息。
創建文件：etc/adminhtml/menu.xml（目的：您的模塊的菜單項將在此處聲明），並將以下代碼插入：
```
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../../../Backend/etc/menu.xsd">
<menu>
<add id="BDC_SimpleNews::main_menu" title="Simple News"
module="BDC_SimpleNews" sortOrder="20"
resource="BDC_SimpleNews::simplenews" />
<add id="BDC_SimpleNews::add_news" title="Add News"
module="BDC_SimpleNews" sortOrder="1" parent="BDC_SimpleNews::main_menu"
action="simplenews/news/new" resource="BDC_SimpleNews::manage_news" />
<add id="BDC_SimpleNews::manage_news" title="Manage News"
module="BDC_SimpleNews" sortOrder="2" parent="BDC_SimpleNews::main_menu"
action="simplenews/news/index" resource="BDC_SimpleNews::manage_news" />
<add id="BDC_SimpleNews::configuration" title="Configurations"
module="BDC_SimpleNews" sortOrder="3" parent="BDC_SimpleNews::main_menu"
action="adminhtml/system_config/edit/section/simplenews"
resource="BDC_SimpleNews::configuration" />
</menu>
</config>
```
此路由將與前端路線相同，但您必須在AdminHTML文件夾中將其聲明為Router ID。文件：app/code/bdc/samplenews/etc/adminhtml/doutes.xml
管理頁面的URL與前端頁面相同，但是在Route_frontName之前將添加Admin_Area名稱，以識別這是管理路由器。例如，管理CMS頁面的URL：
http://example.com/index.php/admin/bdc_samplenews/controller/action管理員頁面的控制器操作將在文件夾控制器/adminhtml中添加。例如，上述URL：
{namespace}/{module}/Controller/Adminhtml/{Controller}/{Action}.php
<!--Use router 'admin' for admin route -->
<router id="admin">
<!--Define a custom route with id and frontName -->
<route id="bdc_samplenews" frontName="bdc_samplenews">
<!--The module which this route match to-->
<module name="BDC_SampleNews"/>
</route>
</router>
創建文件等/adminhtml/doutes.xml目的：將在此處聲明您的後端模塊的路由器，在此處插入以下代碼：
```
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../../../../../../lib/internal/Magento/
Framework/App/etc/routes.xsd">
<router id="admin">
<route id="simplenews" frontName="simplenews">
<module name="BDC_SimpleNews" />
</route>
</router>
</config>
```
http://example.com/index.php/admin/simplenews/controller/action {namespace}/{module}/Controller/Adminhtml/{Controller}/{Action}.php
就像在“管理”菜單和系統配置文章中一樣，您看到我們在創建它時一直具有資源屬性。現在，我們將將這些資源註冊到系統，以便Magento可以實現並讓我們為他們設定角色。要註冊資源，我們使用位於中的acl.xml文件
app/code/{namespace}/{module}/etc/acl.xml
作為模塊開發人員，ACL規則提出了一些有趣的挑戰。首先，作為模塊開發人員，您有幾個地方應在模塊中添加ACL規則檢查。一些例子
管理應用程序中的每個URL端點/控制器都必須實現一個_ ISAffored方法，該方法確定用戶是否可以訪問URL端點。
左手導航中的每個菜單項都有一個特定的ACL規則，該規則可以控制登錄用戶的菜單是否顯示。這通常是_ is的規則相同的規則）
系統中的每個配置字段 - >配置都有一個特定的ACL規則，該規則控制著菜單是否顯示
儘管需要字段，但對於模塊開發人員應如何設置和構建自己的規則，尚無艱難而快速的規則。此外，模塊開發人員可能需要特定於其模塊的其他規則。本文無法為您回答這些難題，但是我們將向您展示如何根據特定的ACL規則檢查當前用戶，查找現有規則的ID值以及如何創建自己的ACL規則樹。
Magento_backend :: Admin：我們的資源將作為Magento_backend的孩子放置。每個資源都有一個ID，標題和排序順序屬性：
ID：屬性是此資源的識別。當在管理菜單中定義資源，配置並限制對模塊控制器的訪問時，您可以使用它。這是一個唯一的字符串，應該採用此格式：vendor_modulename :: resource_name。
標題：在資源樹中顯示時屬性是此資源的標籤。
sortorder：屬性定義了該資源在樹中的位置。
打開此文件等/acl.xml，然後將源代碼修改為這樣：
```
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../../../lib/internal/Magento/
Framework/Acl/etc/acl.xsd">
<acl>
<resources>
<resource id="Magento_Backend::admin">
<resource id="BDC_SimpleNews::simplenews" title="Simple News" sortOrder="100">
<resource id="BDC_SimpleNews::add_news" title="Add News" sortOrder="1" />
<resource id="BDC_SimpleNews::manage_news" title="Manage News" sortOrder="2" />
<resource id="BDC_SimpleNews::configuration" title="Configurations" sortOrder="3" />
</resource>
<resource id="Magento_Backend::stores">
<resource id="Magento_Backend::stores_settings">
<resource id="Magento_Config::config">
<resource id="BDC_SimpleNews::system_config" title="Simple News Section" />
</resource>
</resource>
</resource>
</resource>
</resources>
</acl>
</config>
```
創建文件：view/adminhtml/layout/simpleenews_news_index.xml（目的：此文件用於聲明網格容器塊），並將以下代碼插入其中：
<?xml version="1.0"?>
<page xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../../../../../lib/internal/Magento/Framework/View/Layout/etc/page_configuration.xsd">
<update handle="formkey"/>
<update handle="simplenews_news_grid_block"/>
<body>
<referenceContainer name="content">
<block class="BDCSimpleNewsBlockAdminhtmlNews"
name="bdc_simplenews_news.grid.container" />
</referenceContainer>
</body>
</page>
創建文件：app/code/bdc/simpleNews/view/adminhtml/layout/simpleenews_news_grid_block.xml（目的：此文件用於聲明網格塊的內容）並將以下代碼插入：
```
<?xml version="1.0"?>
<page xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../../../../../lib/internal/Magento/Framework/View/Layout/etc/page_configuration.xsd">
<body>
<referenceBlock name="bdc_simplenews_news.grid.container">
<block class="MagentoBackendBlockWidgetGrid" name="bdc_simplenews_news.grid"
as="grid">
<arguments>
<argument name="id" xsi:type="string">newsGrid</argument>
<argument name="dataSource" xsi:type="object">BDCSimpleNewsModelResourceNewsCollection</argument>
<argument name="default_sort" xsi:type="string">id</argument>
<argument name="default_dir" xsi:type="string">desc</argument>
<argument name="save_parameters_in_session" xsi:type="boolean">true</argument>
<argument name="use_ajax" xsi:type="boolean">true</argument>
<argument name="grid_url" xsi:type="url" path="*/*/grid">
<param name="_current">1</param>
</argument>
</arguments>
<block class="MagentoBackendBlockWidgetGridMassaction"
name="bdc_simplenews_news.grid.massaction" as="grid.massaction">
<arguments>
<argument name="massaction_id_field" xsi:type="string">id</argument>
<argument name="form_field_name" xsi:type="string">news</argument>
<argument name="options" xsi:type="array">
<item name="delete" xsi:type="array">
<item name="label" xsi:type="string" translate="true">Delete</item>
<item name="url" xsi:type="string">*/*/massDelete</item>
<item name="confirm" xsi:type="string" translate="true">Are you sure you want to delete?</item>
</item>
</argument>
</arguments>
</block>
<block class="MagentoBackendBlockWidgetGridColumnSet"
name="bdc_simplenews_news.grid.columnSet" as="grid.columnSet">
<arguments>
<argument name="rowUrl" xsi:type="array">
<item name="path" xsi:type="string">*/*/edit</item>
<item name="extraParamsTemplate" xsi:type="array">
<item name="id" xsi:type="string">getId</item>
</item>
</argument>
</arguments>
<block class="MagentoBackendBlockWidgetGridColumn" as="id">
<arguments>
<argument name="header" xsi:type="string" translate="true">ID</argument>
<argument name="type" xsi:type="string">number</argument>
<argument name="id" xsi:type="string">id</argument>
<argument name="index" xsi:type="string">id</argument>
</arguments>
</block>
<block class="MagentoBackendBlockWidgetGridColumn" as="title">
<arguments>
<argument name="header" xsi:type="string" translate="true">Title</argument>
<argument name="index" xsi:type="string">title</argument>
</arguments>
</block>
<block class="MagentoBackendBlockWidgetGridColumn" as="summary">
<arguments>
<argument name="header" xsi:type="string" translate="true">Summary</argument>
<argument name="index" xsi:type="string">summary</argument>
</arguments>
</block>
<block class="MagentoBackendBlockWidgetGridColumn" as="status">
<arguments>
<argument name="header" xsi:type="string" translate="true">Status</argument>
<argument name="index" xsi:type="string">status</argument>
<argument name="type" xsi:type="string">options</argument>
<argument name="options" xsi:type="options" model="BDCSimpleNewsModelSystemConfigStatus"/>
</arguments>
</block>
<block class="MagentoBackendBlockWidgetGridColumn" as="action" acl="BDC_SimpleNews::manage_news">
<arguments>
<argument name="id" xsi:type="string">action</argument>
<argument name="header" xsi:type="string" translate="true">Action</argument>
<argument name="type" xsi:type="string">action</argument>
<argument name="getter" xsi:type="string">getId</argument>
<argument name="filter" xsi:type="boolean">false</argument>
<argument name="sortable" xsi:type="boolean">false</argument>
<argument name="index" xsi:type="string">stores</argument>
<argument name="is_system" xsi:type="boolean">true</argument>
<argument name="actions" xsi:type="array">
<item name="view_action" xsi:type="array">
<item name="caption" xsi:type="string" translate="true">Edit</item>
<item name="url" xsi:type="array">
<item name="base" xsi:type="string">*/*/edit</item>
</item>
<item name="field" xsi:type="string">id</item>
</item>
</argument>
<argument name="header_css_class" xsi:type="string">col-actions</argument>
<argument name="column_css_class" xsi:type="string">col-actions</argument>
</arguments>
</block>
</block>
</block>
</referenceBlock>
</body>
</page>
```
創建文件：app/code/bdc/simpleNews/view/adminhtml/layout/simpleenews_news_grid.xml（目的：目的：此文件用於在使用ajax重新加載網格時聲明網格的內容）並將以下代碼插入其中：
<?xml version="1.0"?>
<page xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../../../../../lib/internal/Magento/Framework/View/Layout/etc/layout_generic.xsd">
<update handle="formkey" />
<update handle="simplenews_news_grid_block" />
<container name="root">
<block class="MagentoBackendBlockWidgetGridContainer" name="bdc_simplenews_news.grid.container" template="Magento_Backend::widget/grid/container/empty.phtml"/>
</container>
</page>
創建文件：app/code/bdc/simpleenews/model/system/config/state.php（目的：此文件用於獲取新聞狀態選項），並將以下代碼插入：
```
<?php
namespace BDCSimpleNewsModelSystemConfig;
use MagentoFrameworkOptionArrayInterface;
class Status implements ArrayInterface {
const ENABLED = 1;
const DISABLED = 0;
/**
* @return array
*/
public function toOptionArray(){
$options = [
self::ENABLED => __('Enabled'),
self::DISABLED => __('Disabled')
];
return $options;
}
}
```
創建文件：app/code/bdc/simpleenews/block/adminhtml/news.php（目的：這是網格容器的塊文件），並將以下代碼插入其中：
```
<?php
namespace BDCSimpleNewsModelSystemConfig;
use MagentoFrameworkOptionArrayInterface;
class Status implements ArrayInterface {
const ENABLED = 1;
const DISABLED = 0;
/**
* @return array
*/
public function toOptionArray(){
$options = [
self::ENABLED => __('Enabled'),
self::DISABLED => __('Disabled')
];
return $options;
}
}
```
創建文件：app/code/bdc/simpleenews/model/system/config/status.php（目的：檢查），然後將以下代碼插入：
```
<?php
namespace BDCSimpleNewsModelSystemConfig;
use MagentoFrameworkOptionArrayInterface;
class Status implements ArrayInterface {
const ENABLED = 1;
const DISABLED = 0;
/**
* @return array
*/
public function toOptionArray(){
$options = [
self::ENABLED => __('Enabled'),
self::DISABLED => __('Disabled')
];
return $options;
}
}
```
創建文件：app/code/bdc/simpleenews/controller/adminhtml/news.php（目的：我將此文件用作根控制器，並且操作類將擴展此控制器），然後將以下代碼插入：
```
<?php
namespace BDCSimpleNewsBlockAdminhtml;
use MagentoBackendBlockWidgetGridContainer;
class News extends Container{
/**
* Constructor
*
* @return void
*/
protected function _construct(){
$this->_controller = 'adminhtml_news';
$this->_blockGroup = 'BDC_SimpleNews';
$this->_headerText = __('Manage News');
$this->_addButtonLabel = __('Add News');
parent::_construct();
}
}
```
創建文件：app/code/bdc/simpleenews/controller/adminhtml/news/index.php（目的：這是索引操作），並將以下代碼插入其中：
```
<?php
namespace BDCSimpleNewsControllerAdminhtmlNews;
use BDCSimpleNewsControllerAdminhtmlNews;
class Index extends News{
/**
* @return void
*/
public function execute(){
if ($this->getRequest()->getQuery('ajax')) {
$this->_forward('grid');
return;
}
/** @var MagentoBackendModelViewResultPage $resultPage */
$resultPage = $this->_resultPageFactory->create();
$resultPage->setActiveMenu('BDC_SimpleNews::main_menu');
$resultPage->getConfig()->getTitle()->prepend(__('Simple News'));
return $resultPage;
}
}
```
創建文件：app/code/bdc/simpleenews/controller/adminhtml/news/news/grid.php（目的：這是用於加載Ajax的網格操作），並將以下代碼插入其中：
```
<?php
namespace BDCSimpleNewsControllerAdminhtmlNews;
use BDCSimpleNewsControllerAdminhtmlNews;
class Grid extends News {
/**
* @return void
*/
public function execute() {
return $this->_resultPageFactory->create();
}
}
```
創建文件：app/code/bdc/simpleenews/view/adminhtml/layout/simpleenews_news_edit.xml（目的：此文件用於聲明在編輯頁面上使用的塊）並將以下代碼插入其中：
<?xml version="1.0"?>
<page xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
layout="admin-2columns-left" xsi:noNamespaceSchemaLocation="../../../../../../../lib/internal/Magento/Framework/View/Layout/etc/page_configuration.xsd">
<body>
<referenceContainer name="left">
<block class="BDCSimpleNewsBlockAdminhtmlNewsEditTabs" name="bdc_simplenews_news.edit.tabs"/>
</referenceContainer>
<referenceContainer name="content">
<block class="BDCSimpleNewsBlockAdminhtmlNewsEdit"
name="bdc_simplenews_news.edit"/>
</referenceContainer>
</body>
</page>
創建文件：app/code/bdc/simpleenews/view/adminhtml/layout/simpleenews_news_create.xml，然後將以下代碼插入：
```
<?xml version="1.0"?>
<layout xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../../../../../Magento/Core/etc/layout_single.xsd">
<update handle="simplenews_news_edit"/>
</layout>
```
創建文件：app/code/bdc/simpleenews/block/adminhtml/news/eding.php（目的：這是表單容器的塊文件），並將以下代碼插入：
```
<?php
namespace BDCSimpleNewsBlockAdminhtmlNews;
use MagentoBackendBlockWidgetFormContainer;
use MagentoBackendBlockWidgetContext;
use MagentoFrameworkRegistry;
class Edit extends Container
{
/**
* Core registry
*
* @var MagentoFrameworkRegistry
*/
protected $_coreRegistry = null;
/**
* @param Context $context
* @param Registry $registry
* @param array $data
*/
public function __construct(
Context $context,
Registry $registry,
array $data = []
) {
$this->_coreRegistry = $registry;
parent::__construct($context, $data);
}
/**
* Class constructor
*
* @return void
*/
protected function _construct()
{
$this->_objectId = 'id';
$this->_controller = 'adminhtml_news';
$this->_blockGroup = 'BDC_SimpleNews';
parent::_construct();
$this->buttonList->update('save', 'label', __('Save'));
$this->buttonList->add(
'saveandcontinue',
[
'label' => __('Save and Continue Edit'),
'class' => 'save',
'data_attribute' => [
'mage-init' => [
'button' => [
'event' => 'saveAndContinueEdit',
'target' => '#edit_form'
]
]
]
],
-100
);
$this->buttonList->update('delete', 'label', __('Delete'));
}
/**
* Retrieve text for header element depending on loaded news
*
* @return string
*/
public function getHeaderText()
{
$newsRegistry = $this->_coreRegistry->registry('simplenews_news');
if ($newsRegistry->getId()) {
$newsTitle = $this->escapeHtml($newsRegistry->getTitle());
return __("Edit News '%1'", $newsTitle);
} else {
return __('Add News');
}
}
/**
* Prepare layout
*
* @return MagentoFrameworkViewElementAbstractBlock
*/
protected function _prepareLayout()
{
$this->_formScripts[] = "
function toggleEditor() {
if (tinyMCE.getInstanceById('news_content') == null) {
tinyMCE.execCommand('mceAddControl', false, 'news_content');
} else {
tinyMCE.execCommand('mceRemoveControl', false, 'news_content');
}
};
";
return parent::_prepareLayout();
}
}
```
創建文件：app/code/bdc/simpleNews/block/adminhtml/news/news/edit/tabs.php（目的：此文件將在編輯頁面的左列上聲明選項卡），並將以下代碼插入：
```
<?php
namespace BDCSimpleNewsBlockAdminhtmlNews;
use MagentoBackendBlockWidgetFormContainer;
use MagentoBackendBlockWidgetContext;
use MagentoFrameworkRegistry;
class Edit extends Container
{
/**
* Core registry
*
* @var MagentoFrameworkRegistry
*/
protected $_coreRegistry = null;
/**
* @param Context $context
* @param Registry $registry
* @param array $data
*/
public function __construct(
Context $context,
Registry $registry,
array $data = []
) {
$this->_coreRegistry = $registry;
parent::__construct($context, $data);
}
/**
* Class constructor
*
* @return void
*/
protected function _construct()
{
$this->_objectId = 'id';
$this->_controller = 'adminhtml_news';
$this->_blockGroup = 'BDC_SimpleNews';
parent::_construct();
$this->buttonList->update('save', 'label', __('Save'));
$this->buttonList->add(
'saveandcontinue',
[
'label' => __('Save and Continue Edit'),
'class' => 'save',
'data_attribute' => [
'mage-init' => [
'button' => [
'event' => 'saveAndContinueEdit',
'target' => '#edit_form'
]
]
]
],
-100
);
$this->buttonList->update('delete', 'label', __('Delete'));
}
/**
* Retrieve text for header element depending on loaded news
*
* @return string
*/
public function getHeaderText()
{
$newsRegistry = $this->_coreRegistry->registry('simplenews_news');
if ($newsRegistry->getId()) {
$newsTitle = $this->escapeHtml($newsRegistry->getTitle());
return __("Edit News '%1'", $newsTitle);
} else {
return __('Add News');
}
}
/**
* Prepare layout
*
* @return MagentoFrameworkViewElementAbstractBlock
*/
protected function _prepareLayout()
{
$this->_formScripts[] = "
function toggleEditor() {
if (tinyMCE.getInstanceById('news_content') == null) {
tinyMCE.execCommand('mceAddControl', false, 'news_content');
} else {
tinyMCE.execCommand('mceRemoveControl', false, 'news_content');
}
};
";
return parent::_prepareLayout();
}
}
```
創建文件：app/code/bdc/simpleenews/block/adminhtml/news/news/eding/form.php（目的：此文件將聲明表單信息）並將以下代碼插入：
```
<?php
namespace BDCSimpleNewsBlockAdminhtmlNews;
use MagentoBackendBlockWidgetFormContainer;
use MagentoBackendBlockWidgetContext;
use MagentoFrameworkRegistry;
class Edit extends Container
{
/**
* Core registry
*
* @var MagentoFrameworkRegistry
*/
protected $_coreRegistry = null;
/**
* @param Context $context
* @param Registry $registry
* @param array $data
*/
public function __construct(
Context $context,
Registry $registry,
array $data = []
) {
$this->_coreRegistry = $registry;
parent::__construct($context, $data);
}
/**
* Class constructor
*
* @return void
*/
protected function _construct()
{
$this->_objectId = 'id';
$this->_controller = 'adminhtml_news';
$this->_blockGroup = 'BDC_SimpleNews';
parent::_construct();
$this->buttonList->update('save', 'label', __('Save'));
$this->buttonList->add(
'saveandcontinue',
[
'label' => __('Save and Continue Edit'),
'class' => 'save',
'data_attribute' => [
'mage-init' => [
'button' => [
'event' => 'saveAndContinueEdit',
'target' => '#edit_form'
]
]
]
],
-100
);
$this->buttonList->update('delete', 'label', __('Delete'));
}
/**
* Retrieve text for header element depending on loaded news
*
* @return string
*/
public function getHeaderText()
{
$newsRegistry = $this->_coreRegistry->registry('simplenews_news');
if ($newsRegistry->getId()) {
$newsTitle = $this->escapeHtml($newsRegistry->getTitle());
return __("Edit News '%1'", $newsTitle);
} else {
return __('Add News');
}
}
/**
* Prepare layout
*
* @return MagentoFrameworkViewElementAbstractBlock
*/
protected function _prepareLayout()
{
$this->_formScripts[] = "
function toggleEditor() {
if (tinyMCE.getInstanceById('news_content') == null) {
tinyMCE.execCommand('mceAddControl', false, 'news_content');
} else {
tinyMCE.execCommand('mceRemoveControl', false, 'news_content');
}
};
";
return parent::_prepareLayout();
}
}
```
創建文件：app/code/bdc/simpleenews/block/adminhtml/news/news/eding/tab/info.php（目的：此文件將以表單聲明字段），並將以下代碼插入：
```
<?php
namespace BDCSimpleNewsBlockAdminhtmlNews;
use MagentoBackendBlockWidgetFormContainer;
use MagentoBackendBlockWidgetContext;
use MagentoFrameworkRegistry;
class Edit extends Container
{
/**
* Core registry
*
* @var MagentoFrameworkRegistry
*/
protected $_coreRegistry = null;
/**
* @param Context $context
* @param Registry $registry
* @param array $data
*/
public function __construct(
Context $context,
Registry $registry,
array $data = []
) {
$this->_coreRegistry = $registry;
parent::__construct($context, $data);
}
/**
* Class constructor
*
* @return void
*/
protected function _construct()
{
$this->_objectId = 'id';
$this->_controller = 'adminhtml_news';
$this->_blockGroup = 'BDC_SimpleNews';
parent::_construct();
$this->buttonList->update('save', 'label', __('Save'));
$this->buttonList->add(
'saveandcontinue',
[
'label' => __('Save and Continue Edit'),
'class' => 'save',
'data_attribute' => [
'mage-init' => [
'button' => [
'event' => 'saveAndContinueEdit',
'target' => '#edit_form'
]
]
]
],
-100
);
$this->buttonList->update('delete', 'label', __('Delete'));
}
/**
* Retrieve text for header element depending on loaded news
*
* @return string
*/
public function getHeaderText()
{
$newsRegistry = $this->_coreRegistry->registry('simplenews_news');
if ($newsRegistry->getId()) {
$newsTitle = $this->escapeHtml($newsRegistry->getTitle());
return __("Edit News '%1'", $newsTitle);
} else {
return __('Add News');
}
}
/**
* Prepare layout
*
* @return MagentoFrameworkViewElementAbstractBlock
*/
protected function _prepareLayout()
{
$this->_formScripts[] = "
function toggleEditor() {
if (tinyMCE.getInstanceById('news_content') == null) {
tinyMCE.execCommand('mceAddControl', false, 'news_content');
} else {
tinyMCE.execCommand('mceRemoveControl', false, 'news_content');
}
};
";
return parent::_prepareLayout();
}
}
```
創建文件：app/code/bdc/simpleenews/controller/adminhtml/news/newAction.php（目的：這是新操作），並將以下代碼插入：
```
<?php
namespace BDCSimpleNewsControllerAdminhtmlNews;
use BDCSimpleNewsControllerAdminhtmlNews;
class NewAction extends News
{
/**
* Create new news action
*
* @return void
*/
public function execute()
{
$this->_forward('edit');
}
}
```
創建文件：app/code/bdc/simpleenews/controller/adminhtml/news/eding.php（目的：這是編輯新聞頁面的編輯操作），並將以下代碼插入：
```
<?php
namespace BDCSimpleNewsControllerAdminhtmlNews;
use BDCSimpleNewsControllerAdminhtmlNews;
class Edit extends News
{
/**
* @return void
*/
public function execute()
{
$newsId = $this->getRequest()->getParam('id');
/** @var BDCSimpleNewsModelNews $model */
$model = $this->_newsFactory->create();
if ($newsId) {
$model->load($newsId);
if (!$model->getId()) {
$this->messageManager->addError(__('This news no longer exists.'));
$this->_redirect('*/*/');
return;
}
}
// Restore previously entered form data from session
$data = $this->_session->getNewsData(true);
if (!empty($data)) {
$model->setData($data);
}
$this->_coreRegistry->register('simplenews_news', $model);
/** @var MagentoBackendModelViewResultPage $resultPage */
$resultPage = $this->_resultPageFactory->create();
$resultPage->setActiveMenu('BDC_SimpleNews::main_menu');
$resultPage->getConfig()->getTitle()->prepend(__('Simple News'));
return $resultPage;
}
}
```
創建文件：app/code/bdc/simpleenews/controller/adminhtml/news/save.php（目的：這是保存操作），並將以下代碼插入：
```
<?php
namespace BDCSimpleNewsControllerAdminhtmlNews;
use BDCSimpleNewsControllerAdminhtmlNews;
class Edit extends News
{
/**
* @return void
*/
public function execute()
{
$newsId = $this->getRequest()->getParam('id');
/** @var BDCSimpleNewsModelNews $model */
$model = $this->_newsFactory->create();
if ($newsId) {
$model->load($newsId);
if (!$model->getId()) {
$this->messageManager->addError(__('This news no longer exists.'));
$this->_redirect('*/*/');
return;
}
}
// Restore previously entered form data from session
$data = $this->_session->getNewsData(true);
if (!empty($data)) {
$model->setData($data);
}
$this->_coreRegistry->register('simplenews_news', $model);
/** @var MagentoBackendModelViewResultPage $resultPage */
$resultPage = $this->_resultPageFactory->create();
$resultPage->setActiveMenu('BDC_SimpleNews::main_menu');
$resultPage->getConfig()->getTitle()->prepend(__('Simple News'));
return $resultPage;
}
}
```
創建文件：app/code/bdc/simpleenews/controller/adminhtml/news/delete.php（目的：這是刪除操作），並將以下代碼插入其中：
```
<?php
namespace BDCSimpleNewsControllerAdminhtmlNews;
use BDCSimpleNewsControllerAdminhtmlNews;
class Delete extends News
{
/**
* @return void
*/
public function execute()
{
$newsId = (int) $this->getRequest()->getParam('id');
if ($newsId) {
/** @var $newsModel MageworldSimpleNewsModelNews */
$newsModel = $this->_newsFactory->create();
$newsModel->load($newsId);
// Check this news exists or not
if (!$newsModel->getId()) {
$this->messageManager->addError(__('This news no longer exists.'));
} else {
try {
// Delete news
$newsModel->delete();
$this->messageManager->addSuccess(__('The news has been deleted.'));
// Redirect to grid page
$this->_redirect('*/*/');
return;
} catch (Exception $e) {
$this->messageManager->addError($e->getMessage());
$this->_redirect('*/*/edit', ['id' => $newsModel->getId()]);
}
}
}
}
}
```
創建文件：app/code/bdc/simpleenews/controller/adminhtml/news/massdelete.php（目的：此文件用於刪除網格上的多項項目），並將以下代碼插入：
```
<?php
namespace BDCSimpleNewsControllerAdminhtmlNews;
use BDCSimpleNewsControllerAdminhtmlNews;
class MassDelete extends News {
/**
* @return void
*/
public function execute()
{
// Get IDs of the selected news
$newsIds = $this->getRequest()->getParam('news');
foreach ($newsIds as $newsId) {
try {
/** @var $newsModel MageworldSimpleNewsModelNews */
$newsModel = $this->_newsFactory->create();
$newsModel->load($newsId)->delete();
} catch (Exception $e) {
$this->messageManager->addError($e->getMessage());
}
}
if (count($newsIds)) {
$this->messageManager->addSuccess(
__('A total of %1 record(s) were deleted.', count($newsIds))
);
}
$this->_redirect('*/*/index');
}
}
```
<?xml version="1.0" encoding="UTF-8"?>
<page xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" layout="3columns"
xsi:noNamespaceSchemaLocation="../../../../../../../lib/internal/Magento/Framework/View/Layout/etc/page_configuration.xsd">
<head>
<css src="BDC_SimpleNews::css/style.css" />
</head>
<body>
<referenceContainer name="sidebar.main">
<block class="BDCSimpleNewsBlockLastestLeft" name="lestest.news.left"
before="-" />
</referenceContainer>
<referenceContainer name="sidebar.additional">
<block class="BDCSimpleNewsBlockLastestRight" name="lestest.news.right"
before="-" />
</referenceContainer>
</body>
</page>
<?xml version="1.0"?>
<page xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" layout="3columns" xsi:noNamespaceSchemaLocation="urn:magento:framework:View/Layout/etc/page_configuration.xsd">
<update handle="news_news" />
<body>
<referenceBlock name="content">
<block template="BDC_SimpleNews::list.phtml" class="BDCSimpleNewsBlockNewsList" name="bdc_simplenews_block_news_list"/>
</referenceBlock>
</body>
</page>
<?php
namespace BDCSimpleNewsBlock;
use MagentoFrameworkViewElementTemplate;
use BDCSimpleNewsModelNewsFactory;
class NewsList extends Template
{
/**
* @var BDCSimpleNewsModelNewsFactory
*/
protected $_newsFactory;
/**
* @param TemplateContext $context
* @param NewsFactory $newsFactory
* @param array $data
*/
public function __construct(
TemplateContext $context,
NewsFactory $newsFactory,
array $data = []
) {
$this->_newsFactory = $newsFactory;
parent::__construct($context, $data);
}
/**
* Set news collection
*/
protected function _construct()
{
parent::_construct();
$collection = $this->_newsFactory->create()->getCollection()
->setOrder('id', 'DESC');
$this->setCollection($collection);
}
/**
* @return $this
*/
protected function _prepareLayout()
{
parent::_prepareLayout();
/** @var MagentoThemeBlockHtmlPager */
$pager = $this->getLayout()->createBlock(
'MagentoThemeBlockHtmlPager','simplenews.news.list.pager'
);
$pager->setLimit(5)
->setShowAmounts(false)
->setCollection($this->getCollection());
$this->setChild('pager', $pager);
$this->getCollection()->load();
return $this;
}
/**
* @return string
*/
public function getPagerHtml()
{
return $this->getChildHtml('pager');
}
}
<div class="simplenews">
<?php
$newsCollection = $block->getCollection();
if ($newsCollection->getSize() > 0) :
?>
<div class="toolbar top">
<?php echo $block->getPagerHtml(); ?>
</div>
<ul>
<?php foreach ($newsCollection as $news) : ?>
<li>
<div class="simplenews-list">
<a class="news-title" href="<?php echo $this->getUrl('news/index/view',
['id' => $news->getId()]) ?>"><?php echo $news->getTitle() ?></a>
<div class="simplenews-list-content">
<?php echo $news->getSummary() ?>
</div>
</div>
</li>
<?php endforeach; ?>
</ul>
<div style="clear: both"></div>
<div class="toolbar-bottom">
<div class="toolbar bottom">
<?php echo $block->getPagerHtml(); ?>
</div>
</div>
<?php else : ?>
<p><?php echo __('Have no article!') ?></p>
<?php endif; ?>
</div>
<div class="simplenews">
<?php
$newsCollection = $block->getCollection();
if ($newsCollection->getSize() > 0) :
?>
<div class="toolbar top">
<?php echo $block->getPagerHtml(); ?>
</div>
<ul>
<?php foreach ($newsCollection as $news) : ?>
<li>
<div class="simplenews-list">
<a class="news-title" href="<?php echo $this->getUrl('news/index/view',
['id' => $news->getId()]) ?>"><?php echo $news->getTitle() ?></a>
<div class="simplenews-list-content">
<?php echo $news->getSummary() ?>
</div>
</div>
</li>
<?php endforeach; ?>
</ul>
<div style="clear: both"></div>
<div class="toolbar-bottom">
<div class="toolbar bottom">
<?php echo $block->getPagerHtml(); ?>
</div>
</div>
<?php else : ?>
<p><?php echo __('Have no article!') ?></p>
<?php endif; ?>
</div>
<?php
namespace BDCSimpleNewsControllerIndex;
use BDCSimpleNewsControllerNews;
class Index extends News
{
public function execute()
{
$pageFactory = $this->_pageFactory->create();
$pageFactory->getConfig()->getTitle()->set($this->_dataHelper->getHeadTitle());
//Add breadcrumb
$breadcrumbs = $pageFactory->getLayout()->getBlock('breadcrumbs');
$breadcrumbs->addCrumb('home', ['label'=>__('Home'), 'title'=>__('Home'), 'link'=>$this->_url->getUrl('')]);
$breadcrumbs->addCrumb('simplenews', ['label'=>__('Simple News'), 'title'=>__('Simple News')]);
return $pageFactory;
}
}
.simplenews > ul {
list-style: none;
padding: 0;
}
.simplenews > ul li {
padding: 10px 5px;
margin: 0;
background-color: #fff;
border-bottom: 1px #c4c1bc solid;
display: inline-block;
width: 100%;
}
.simplenews > ul li:last-child {
border-bottom: none;
}
.simplenews-list {
float: left;
position: relative;
margin-left: 10px;
width: 100%;
}
.simplenews-list a.news-title {
font-weight: bold;
}
.simplenews-list a.news-title:hover {
text-decoration: none;
}
.block-simplenews .block-title {
margin: 0px 0px 20px;
}
.block-simplenews-heading {
font-size: 18px;
font-weight: 300;
}
<?xml version="1.0" encoding="UTF-8"?>
<page xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" layout="3columns"
xsi:noNamespaceSchemaLocation="../../../../../../../lib/internal/Magento/Framework/View/Layout/etc/page_configuration.xsd">
<update handle="news_news" />
<body>
<referenceContainer name="content">
<block class="BDCSimpleNewsBlockView" name="bdc_simplenews_news_view"
template="BDC_SimpleNews::view.phtml" />
</referenceContainer>
</body>
</page>
<?php
namespace BDCSimpleNewsControllerIndex;
use BDCSimpleNewsControllerNews;
class View extends News
{
public function execute()
{
// Get news ID
$newsId = $this->getRequest()->getParam('id');
// Get news data
$news = $this->_newsFactory->create()->load($newsId);
// Save news data into the registry
$this->_objectManager->get('MagentoFrameworkRegistry')
->register('newsData', $news);
$pageFactory = $this->_pageFactory->create();
// Add title
$pageFactory->getConfig()->getTitle()->set($news->getTitle());
// Add breadcrumb
/** @var MagentoThemeBlockHtmlBreadcrumbs */
$breadcrumbs = $pageFactory->getLayout()->getBlock('breadcrumbs');
$breadcrumbs->addCrumb('home',
[
'label' => __('Home'),
'title' => __('Home'),
'link' => $this->_url->getUrl('')
]
);
$breadcrumbs->addCrumb('simplenews',
[
'label' => __('Simple News'),
'title' => __('Simple News'),
'link' => $this->_url->getUrl('news')
]
);
$breadcrumbs->addCrumb('news',
[
'label' => $news->getTitle(),
'title' => $news->getTitle()
]
);
return $pageFactory;
}
}
<?php
namespace BDCSimpleNewsControllerIndex;
use BDCSimpleNewsControllerNews;
class View extends News
{
public function execute()
{
// Get news ID
$newsId = $this->getRequest()->getParam('id');
// Get news data
$news = $this->_newsFactory->create()->load($newsId);
// Save news data into the registry
$this->_objectManager->get('MagentoFrameworkRegistry')
->register('newsData', $news);
$pageFactory = $this->_pageFactory->create();
// Add title
$pageFactory->getConfig()->getTitle()->set($news->getTitle());
// Add breadcrumb
/** @var MagentoThemeBlockHtmlBreadcrumbs */
$breadcrumbs = $pageFactory->getLayout()->getBlock('breadcrumbs');
$breadcrumbs->addCrumb('home',
[
'label' => __('Home'),
'title' => __('Home'),
'link' => $this->_url->getUrl('')
]
);
$breadcrumbs->addCrumb('simplenews',
[
'label' => __('Simple News'),
'title' => __('Simple News'),
'link' => $this->_url->getUrl('news')
]
);
$breadcrumbs->addCrumb('news',
[
'label' => $news->getTitle(),
'title' => $news->getTitle()
]
);
return $pageFactory;
}
}
<?php
$news = $block->getNewsInformation();
?>
<div class="mw-simplenews">
<?php echo $news->getDescription() ?>
</div>
<?xml version="1.0" encoding="UTF-8"?>
<page xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" layout="3columns"
xsi:noNamespaceSchemaLocation="../../../../../../../lib/internal/Magento/Framework/View/Layout/etc/page_configuration.xsd">
<head>
<css src="BDC_SimpleNews::css/style.css" />
</head>
<body>
<referenceContainer name="sidebar.main">
<block class="BDCSimpleNewsBlockLastestLeft" name="lestest.news.left"
before="-" />
</referenceContainer>
<referenceContainer name="sidebar.additional">
<block class="BDCSimpleNewsBlockLastestRight" name="lestest.news.right"
before="-" />
</referenceContainer>
</body>
</page>
<?php
namespace BDCSimpleNewsBlock;
use MagentoFrameworkViewElementTemplate;
use BDCSimpleNewsHelperData;
use BDCSimpleNewsModelNewsFactory;
use BDCSimpleNewsModelSystemConfigStatus;
class Lastest extends Template
{
/**
* @var BDCSimpleNewsHelperData
*/
protected $_dataHelper;
/**
* @var BDCSimpleNewsModelNewsFactory
*/
protected $_newsFactory;
/**
* @param TemplateContext $context
* @param Data $dataHelper
* @param NewsFactory $newsFactory
*/
public function __construct(
TemplateContext $context,
Data $dataHelper,
NewsFactory $newsFactory
) {
$this->_dataHelper = $dataHelper;
$this->_newsFactory = $newsFactory;
parent::__construct($context);
}
/**
* Get five latest news
*
* @return BDCSimpleNewsModelResourceNewsCollection
*/
public function getLatestNews()
{
// Get news collection
$collection = $this->_newsFactory->create()->getCollection();
$collection->addFieldToFilter(
'status',
['eq' => Status::ENABLED]
);
$collection->getSelect()
->order('id DESC')
->limit(5);
return $collection;
}
}
<?php
namespace BDCSimpleNewsBlockLastest;
use BDCSimpleNewsBlockLastest;
use BDCSimpleNewsModelSystemConfigLastestNewsPosition;
class Left extends Lastest
{
public function _construct()
{
$position = $this->_dataHelper->getLastestNewsBlockPosition();
// Check this position is applied or not
if ($position == Position::LEFT) {
$this->setTemplate('BDC_SimpleNews::lastest.phtml');
}
}
}
<?php
namespace BDCSimpleNewsBlockLastest;
use BDCSimpleNewsBlockLastest;
use BDCSimpleNewsModelSystemConfigLastestNewsPosition;
class Right extends Lastest
{
public function _construct()
{
$position = $this->_dataHelper->getLastestNewsBlockPosition();
// Check this position is applied or not
if ($position == Position::RIGHT) {
$this->setTemplate('BDC_SimpleNews::lastest.phtml');
}
}
}
<?php
$latestNews = $block->getLatestNews();
if ($latestNews->getSize() > 0) :
?>
<div class="block block-simplenews">
<div class="block-title">
<strong class="block-simplenews-heading"><?php echo __('Latest News') ?></strong>
</div>
<div class="block-content">
<?php foreach ($latestNews as $news) : ?>
<div>
<span>+ </span>
<a href="<?php echo $this->getUrl('news/index/view', ['id' => $news->getId()])
?>">
<span><?php echo $news->getTitle() ?></span>
</a>
</div>
<?php endforeach; ?>
</div>
</div>
<?php endif; ?>
將新命令添加到CLI是基於從XML級別傳遞到類Magento Framework Console Commandlist的參數。依賴注入在這裡派上用場。讓我們
編輯/創建ETC/di.xml：
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:ObjectManager/etc/config.xsd">
<type name="MagentoFrameworkConsoleCommandList">
<arguments>
<argument name="commands" xsi:type="array">
<item name="bdc_simplenews_create" xsi:type="object">BDCSimpleNewsConsoleCommandNewsCreate</item>
</argument>
</arguments>
</type>
</config>
我們將負責執行腳本的對象添加到類Magento Framework Console Commandlist。該類的構造函數只是一個數組，其中類對像以與上面示例相似的方式傳遞。
讓我們繼續進行下一步 - 為我們的新命令創建一個類，以及負責添加新用戶的助手：
創建控制台/命令/newsCreate.php：
<?php
namespace BDCSimpleNewsConsoleCommand;
use SymfonyComponentConsoleCommandCommand;
use SymfonyComponentConsoleInputInputOption;
use SymfonyComponentConsoleInputInputInterface;
use SymfonyComponentConsoleOutputOutputInterface;
use BDCSimpleNewsHelperNews;
class NewsCreate extends Command {
protected $newsHelper;
public function __construct(News $newsHelper)
{
$this->newsHelper = $newsHelper;
parent::__construct();
}
protected function configure()
{
$this->setName('bdcrops:news:create')
->setDescription('Create New News')
->setDefinition($this->getOptionsList());
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$output->writeln('<info>Creating new news...</info>');
$this->newsHelper->setData($input);
$this->newsHelper->execute();
$output->writeln('');
$output->writeln('<info>News created with the following data:</info>');
$output->writeln('<comment>News ID: ' . $this->newsHelper->getNewsId());
$output->writeln('<comment>Title: ' . $input->getOption(News::KEY_TITLE));
$output->writeln('<comment>Summary: ' . $input->getOption(News::KEY_SUMMARY));
$output->writeln('<comment>Description: ' . $input->getOption(News::KEY_DESC));
}
protected function getOptionsList(){
return [
new InputOption(News::KEY_TITLE, null, InputOption::VALUE_REQUIRED, '(Required) News Title'),
new InputOption(News::KEY_SUMMARY, null, InputOption::VALUE_REQUIRED, '(Required) News Summary'),
new InputOption(News::KEY_DESC, null, InputOption::VALUE_REQUIRED, '(Required) News Description'),
];
}
}
創建助手/news.php：
```
<?php
namespace BDCSimpleNewsHelper;
use MagentoFrameworkAppHelperContext;
use MagentoStoreModelStoreManagerInterface;
use MagentoFrameworkAppState;
use BDCSimpleNewsModelNewsFactory;
use SymfonyComponentConsoleInputInput;
use MagentoFrameworkAppHelperAbstractHelper;
class News extends AbstractHelper {
const KEY_TITLE = 'news-title';
const KEY_SUMMARY = 'news-summary';
const KEY_DESC = 'news-description';
protected $storeManager;
protected $state;
protected $newsFactory;
protected $data;
protected $newsId;
public function __construct(
Context $context,
StoreManagerInterface $storeManager,
State $state,
NewsFactory $newsFactory ) {
$this->storeManager = $storeManager;
$this->state = $state;
$this->newsFactory = $newsFactory;
parent::__construct($context);
}
public function setData(Input $input) {
$this->data = $input;
return $this;
}
public function execute() {
$this->state->setAreaCode('frontend');
$news = $this->newsFactory->create();
$news
->setTitle($this->data->getOption(self::KEY_TITLE))
->setSummary($this->data->getOption(self::KEY_SUMMARY))
->setDescription($this->data->getOption(self::KEY_DESC))
;
$news->save();
$this->newsId = $news->getId();
// if($this->data->getOption(self::KEY_SENDEMAIL)) {
// $news->sendNewAccountEmail();
// }
}
public function getNewsId() {
return (int)$this->newsId;
}
}
```
execute（）方法添加了一個新用戶。如果此階段的任何數據不正確（即密碼太短），則腳本將停止，並且控制台將顯示一個例外。
php bin/magento bdcrops:news:create --news-title="Matin Cli News" --news-summary="summary 1" --news-description="News Description 1"
在以下文件路徑中創建一個crontab.xml文件，並設置一個時間表以運行定義默認值的自定義cron代碼。
創建ETC/crontab.xml：
```
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Cron:etc/crontab.xsd">
<group id="bdc_crongroup">
<job name="bdcAddNews" instance="BDCSimpleNewsCronAddNews" method="execute">
<!-- <config_path>bdc/general/cron_expression</config_path> -->
<schedule>* * * * *</schedule>
</job>
</group>
</config>
```
在這裡定義模塊的crontab時，我們也需要定義組名稱。這裡group_name是cron組的名稱。該組名稱不必是唯一的，我們可以一次為一個組運行CRON。
這裡，
組ID：是一個Cron組名稱。作業名稱：是此Cron工作的獨特ID。實例：是要實例化的類（類Path）。方法：是要調用的工作實例中的一種方法。時間表：是Cron格式的時間表。
* * * * * command to be executed
| | | | |
| | | | +----- Day of week (0 - 7) (Sunday=0 or 7)
| | | +------- Month (1 - 12)
| | +--------- Day of month (1 - 31)
| +----------- Hour (0 - 23)
+------------- Minute (0 - 59)
該文件包含自定義CRON代碼，並且在Magento 2中運行時將執行該代碼。
創建cron/addnews.php：
```
<?php
namespace BDCSimpleNewsCron;
use BDCSimpleNewsModelNewsFactory;
//use BDCSimpleNewsModelConfig;
class AddNews {
private $newsFactory;
public function __construct(NewsFactory $newsFactory) {
$this->newsFactory = $newsFactory;
}
public function execute(){
$this->newsFactory->create()
->setTitle('Scheduled News')
->setSummary('Scheduled News setSummary ' . date('Ymd'))
->setDescription('Scheduled News setDescription ' . date('Ymd'))
->save();
}
}
```
完成上述步驟後，在您的Magento 2中運行以下SSH命令，安裝了根目錄以運行Magento 2 Cron Jobs
php bin/magento cache:flush
php bin/magento cron:run
要檢查Cron是否正常工作，請轉到DB
SELECT * FROM `cron_schedule`
SELECT * FROM `cron_schedule` where `job_code` LIKE "%bdc%"
聲明一個新組，並通過cron_groups.xml文件指定其配置選項（所有這些選項）
創建etc/cron_groups.xml：
```
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:BlogTreat_CustomCron:etc/cron_groups.xsd">
<group id="bdc_crongroup">
<schedule_generate_every>1</schedule_generate_every>
<schedule_ahead_for>4</schedule_ahead_for>
<schedule_lifetime>2</schedule_lifetime>
<history_cleanup_every>10</history_cleanup_every>
<history_success_lifetime>60</history_success_lifetime>
<history_failure_lifetime>600</history_failure_lifetime>
</group>
</config>
```
在哪裡：
您可以在管理面板中查看新的cron組：商店 - >配置 - >高級 - >系統 - > cron（計劃任務）
After completing the above steps run the below SSH command in your Magento 2 installed root directory to run the Magento 2 specific group of cron jobs only.
php bin/magento cron:run --group="bdc_crongroup"
To check whether the cron is working properly, go to Database & run below query.
SELECT * FROM `cron_schedule` where `job_code` LIKE "%bdc%"
SELECT * FROM `bdc_simplenews` ORDER BY `id` DESC
Cron job is a great feature which is used to do the specific task automatically in exact time and date without manual working. The cron job is the perfect choice to do the repeated action every date or every week.Magento 2 uses cron jobs for,
<schedule>* * * * * </schedule> ?Schedule is the time the cron will run. In this example, it run in each minute.
* * * * * *
| | | | | |
| | | | | +-- Year (range: 1900-3000)
| | | | +---- Day of the Week (range: 1-7, 1 standing for Monday)
| | | +------ Month of the Year (range: 1-12)
| | +-------- Day of the Month (range: 1-31)
| +---------- Hour (range: 0-23)
+------------ Minute (range: 0-59)
Magento 2 API framework allows developers to create new services for communicating with Magento 2 stores. It supports REST and SOAP web services and is based on CRUD operations (Create, Read, Update, Delete) and a Search Model.
At the moment, Magento 2 uses the following three authentication methods as is described in Magento 2 REST API documentation.
According to the Magento 2 API documentation, these authentication methods can only access the resources assigned to them. Magento 2 API framework first checks whether the call has appropriate authorization to perform the request. The API framework also supports field filtering of API responses to preserve cellular bandwidth. Developers use Magento 2 APIs for a wide range of tasks. For instance, you can create a shopping app and integrate it with your Magento 2 store. You can also build a web app which your employee could use to help customers make purchases. With the help of APIs, you can integrate your Magento 2 store with CRMs, ERPs or POS systems.
Using REST API in Magento 2 is a piece of cake. But for that, you need to understand the flow to call APIs in PHP. If you want to use token-based Magento 2 REST API, first you will need to authenticate and get the token from Magento 2. Then, you will have to pass it in the header of every request you perform. To get started with the REST API in Magento 2 using token-based authentication, you will need to create a web service User Role and register that role to a new Magento 2 Admin User. Keep in mind that creating a new role and user is necessary because it's not a good practice to use Magento Owner User in a web service.
When it comes to e-Commerce websites, APIs play the big role of reading and writing information from and to the server. Be it a customer's name or his already saved credit card details, every piece of information shown to the end user has to either read from or written to the web server. This is taken care by REST and SOAP APIs. REST and SOAP are models for web services, however, one that's most recommend for eCommerce websites. Though REST is fast, efficient and simple, SOAP is standardized, secure and apt for payments.
To create a web service role in Magento 2, follow these steps:
Now, create a new user for the newly created role through these steps:
As I mentioned earlier, I will authenticate REST API through Token authentication. This means that I will pass a username and password in the initial connection and receive the token . This token will be saved in a variable, which will be passed in the header for further calls.
You can fetch almost everything using Magento 2 REST API. The List of REST APIs for Magento EE and CE is a good guide on this topic.To demonstrate the API, I am going to get all the installed modules on a Magento 2 store. Here is the script:
```
<?php
//API URL for authentication
$apiURL="http://www.magento.lan/rest/V1/news/admin/token";
//parameters passing with URL
$data = array("username" => "apiaccess", "password" => "api@123");
$data_string = json_encode($data);
$ch = curl_init($apiURL);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_POSTFIELDS, $data_string);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, array("Content-Type: application/json","Content-Length: ".strlen($data_string)));
$token = curl_exec($ch);
//decoding generated token and saving it in a variable
$token= json_decode($token);
//******************************************//
//Using above token into header
$headers = array("Authorization: Bearer ".$token);
//API URL to get all Magento 2 modules
$requestUrl='http://www.magento.lan/rest/V1/news';
$ch = curl_init($requestUrl);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$result = curl_exec($ch);
//decoding result
$result= json_decode($result);
//printing result
print_r($result);
```
A Web API is an application programming interface for either a web server or a web browser. It is a web development concept, usually limited to a web application's client-side (including any web frameworks being used), and thus usually does not include web server or browser implementation details such as SAPIs or APIs unless publicly accessible by a remote web application.
Supports developers to use web services that communicate with the Magento system. For instance, a developer can create a customer account, product record through web service.關鍵功能包括：
APIs can be used to perform a wide array of tasks ex:
Register web service on Magento Admin following general steps to set up to enable web services.
routes are defined in etc/webapi.xml within a module, and although the structure of the definition xml is directed by the requirements of the REST API, the SOAP API uses the same definitions.
The following shows the route configuration for fetching a CMS block, as defined in BDC_SimpleNews::etc/webapi.xml:
<routes> <route url="/V1/news" method="GET">
<service class="BDCSimpleNewsApiNewsRepositoryInterface" method="getList"/>
<resources> <resource ref="anonymous"/> </resources>
</route>
</routes>
Create app/code/BDC/SimpleNews/etc/webapi.xml
```
<?xml version="1.0"?>
<routes>
<route url="/V1/news" method="GET">
<service class="BDCSimpleNewsApiNewsRepositoryInterface" method="getList"/>
<resources> <resource ref="anonymous"/> </resources>
</route>
</routes>
```
In the route tag the url attribute defines the route as /V1/cmsBlock/:blockId where the :blockId part represents an id parameter to be supplied. The method attribute defines the HTTP verb the route uses as 'GET' (other available verbs are PUT, POST and DELETE).
In the service tag the class attribute associates the service contract MagentoCmsApiBlockRepositoryInterface with the route, and the method attribute defines the method to call upon the object provided by the service contract.
Repositories give service requestors the ability to perform create, read, update, and delete (CRUD) operations on entities or a list of entities. A repository is an example of a service contract, and its implementation is part of the domain layer.
Repositories are service contracts which are interface classes & helps to hide business logic from controller,model & helper, defined repository file which is an interface class & model file in which define methods declared in repository class.To create module's repository, firstly have to define it in di.xml file at path: app/code/BDC/SimpleNews/etc/di.xml
<preference type="BDCSimpleNewsModelNews" for="BDCSimpleNewsApiDataNewsInterface"/>
<preference type="BDCSimpleNewsModelNewsRepository" for="BDCSimpleNewsApiNewsRepositoryInterface"/>
Final file look like as below:
```
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:ObjectManager/etc/config.xsd">
<type name="MagentoFrameworkConsoleCommandList">
<arguments>
<argument name="commands" xsi:type="array">
<item name="bdc_simplenews_create" xsi:type="object">BDCSimpleNewsConsoleCommandNewsCreate</item>
</argument>
</arguments>
</type>
<preference type="BDCSimpleNewsModelNews" for="BDCSimpleNewsApiDataNewsInterface"/>
<preference type="BDCSimpleNewsModelNewsRepository" for="BDCSimpleNewsApiNewsRepositoryInterface"/>
</config>
```
An interface defines the repository with all logical read and write operations for a specific entity. You can see an example of such a repository interface in the diagram. The interface gets implemented by one or more classes that provide data store specific implementations of each interface method Now, we need to create an interface and model, please note that you need to take care of the comments as well.
Repositories are service contracts which are interface classes & helps to hide your business logic from controller,model and helper.
A service contract must define data interfaces, which preserve data integrity, and service interfaces, which hide business logic from service requestors.
Data interfaces: define functions that return information about data entities, return search results, and set validation rules and return validation results. You must define the data interfaces for a service contract in the Api/Data subdirectory for a module.
Service interfaces: include management, repository, and metadata interfaces. You must define the service interfaces for a service contract in the Api subdirectory for a module.
Create Api/NewsRepositoryInterface.php
<?php
namespace BDCSimpleNewsApi;
interface NewsRepositoryInterface {
/**
* @return BDCSimpleNewsApiDataNewsInterface[]
*/
public function getList();
}
An interface allows unrelated classes to implement the same set of methods, regardless of their positions in the class inheritance hierarchy. An interface enables you to model multiple inheritance because a class can implement more than one interface whereas it can extend only one class.
Define data interfaces in the Api/Data subdirectory for a module.Ex. data interfaces for the Customer module are in the /app/code/Magento/Customer/Api/Data subdirectory.
Now, we need to create an interface and model, please note that you need to take care of the comments as well.
Create app/code/BDC/SimpleNews/Api/Data/NewsInterface.php & insert this following code into it:
```
<?php
namespace BDCSimpleNewsApiData;
interface NewsInterface {
/**
* @return string
*/
public function getTitle();
/**
* @return string|null
*/
public function getSummary();
/**
* @return string|null
*/
public function getDescription();
}
```
Get Collection in means showing the items in your store when run the command. With the code snippet in this topic, request the specific number of the news as you need. Let's start calling the news in Magento 2 now!
Create app/code/BDC/SimpleNews/Model/NewsRepository.php & insert this following code into it:
```
<?php
namespace BDCSimpleNewsModel;
use BDCSimpleNewsApiNewsRepositoryInterface;
use BDCSimpleNewsModelResourceNewsCollectionFactory;
class NewsRepository implements NewsRepositoryInterface {
private $collectionFactory;
public function __construct(CollectionFactory $collectionFactory){
$this->collectionFactory = $collectionFactory;
}
public function getList() {
return $this->collectionFactory->create()->getItems();
}
}
```
As mentioned above, the configuration is conveniently used by both the REST and SOAP APIs. However, the means of accessing resources differs quite a lot.The full REST resource URL is the easiest to determine as it just needs prefixing with 'http://www.yourdomain.com/rest/', so in the example above, assuming the news needed has an entity id of 1, the resource url would be 'http://www.yourdomain.com/rest/V1/news/1'.
Testing as guest: To test REST you can go to http://{domain_name}/rest/V1/{method}/{attribute}/{value}.
Example: http://magento2.loc/rest/V1/hello/name/Matin.
This is how response should look like for this example:
http://www.magento.lan/rest/V1/news
Here is small code that will test same API call but with SOAP(Not implements):
<?php
$proxy = new SoapClient('http://www.magento.lan/index.php/soap/default?wsdl&services=/V1/news');
$result = $proxy->bdcSimpleNewsV1();
var_dump($result);
Response for SOAP
object(stdClass)#2 (1) {
["result"]=>
string(10) "..."
}
If we don't set anonymous in resource of webapi.xml, we need to set existing Magento resource or create our own. We can do that by adding acl.xml to etc.
ACL – etc/acl.xml
<resource id="Magento_Backend::admin">
<resource id="BDC_SimpleNews::news" title="News API" translate="title" sortOrder="110" />
</resource>
In this case we need to add BDC_SimpleNews::news to webapi.xml resource instead anonymous.
Magento 2 Dependency injection is used to replace the Magento 1.x Mage class when you convert to work with Magento 2. The Dependency injection design pattern creates an external environment where you can inject dependencies into an object. Thanks to that, there is no longer to create the objects manually. Namely, as when object A calls object or value B, this means B is a dependency of A
If you are working with Magento 2 Dependency Injection, you should take look at Magento 2 Dependency Inversion Principle because this principle will restrict the direct working between the high level and low level classes. At that time, the interaction will implement via an interface of the low level classes as an abstract layer.
Specifically, the di.xml file takes responsibility for mapping an interface dependency to a preferred implementation class. It can be said that with Magento 2 Dependency Inversion Principle, the dependency of the coding will be reduced significantly due to the abstract layer.
Object manager - Dependency Injection Container Object Manager is called as Dependency Injection Container, Magento 2 service class which contains and handle the dependencies between the objects. During the class construction, the object manager injects the appropriate dependency as defined in the di.xml file.
Constructor signature dependencies In Magento 2, the class definition use constructor signature to get information (type and number of dependencies).
Compiling dependencies All information related to Magento 2 Dependency Injection are collected in a class and saved in files by a code complier tool. And then the ObjectManager will get this information to generate concrete objects in the application.
Magento 2 Dependency Injection includes two types: Constructor Injection and Method Injection. You can see the following code snippet to learn more about both of them.
Constructor injection As the above example, $menuItemFactory and $menu are the dependencies that will be added to an object's class through the constructor injection. Besides, remember that the constructor injection is required to declare all optional and required of an object.
Method injection About Method Injection, you will use it when an object makes clear a dependency in one of its methods. As if tracking in the referred instance, $command is the dependency passed into the class through the processCommand method.
Groups of Object In Magento 2, the object is divided into two groups: injectable and non-injectable (newable) objects.這些是什麼？
Injectable Objects About the injectable Objects, you can call as services or objects which will show the dependencies in their constructors and are created by the object manager via the configuration in the di.xml file. And you can use these injectable objects to request other injectable services in the constructors.
Non-injectable Objects Non-injectable (Newable) Objects are a bit similar to the injectable objects when they also expose the dependencies in their constructors, however, the newables are allowed to request other newables objects like Entities, Value Objects. In addition, you cannot demand the newable objects for keeping a reference to an injectable object.
This is the detialed information related to Magento 2 Dependency Injection design pattern. Wish you have a great time with it!
By default, there are three different ways to override core functionalities.
We write log after news item save .
Edit Helper/News.php look like:
```
<?php
namespace BDCSimpleNewsHelper;
use MagentoFrameworkAppHelperContext;
use MagentoStoreModelStoreManagerInterface;
use MagentoFrameworkAppState;
use BDCSimpleNewsModelNewsFactory;
use SymfonyComponentConsoleInputInput;
use PsrLogLoggerInterface;
class News extends MagentoFrameworkAppHelperAbstractHelper {
const KEY_TITLE = 'news-title';
const KEY_SUMMARY = 'news-summary';
const KEY_DESC = 'news-description';
protected $storeManager;
protected $state;
protected $newsFactory;
protected $data;
protected $newsId;
protected $logger;
public function __construct(
Context $context,
StoreManagerInterface $storeManager,
State $state,
NewsFactory $newsFactory,
LoggerInterface $logger ) {
$this->storeManager = $storeManager;
$this->state = $state;
$this->logger = $logger;
$this->newsFactory = $newsFactory;
parent::__construct($context);
}
public function setData(Input $input){
$this->data = $input;
return $this;
}
public function execute() {
$this->state->setAreaCode('frontend');
$news = $this->newsFactory->create();
$news->setTitle($this->data->getOption(self::KEY_TITLE))
->setSummary($this->data->getOption(self::KEY_SUMMARY))
->setDescription($this->data->getOption(self::KEY_DESC));
$news->save();
$this->logger->debug('DI: '.$news->getTitle());
}
public function getNewsId(){
return (int)$this->newsId;
}
}
```
Create Helper/BdcDebug.php Insert :
```
<?php
namespace BDCSimpleNewsHelper;
use MonologLogger;
use MagentoFrameworkLoggerHandlerBase;
class BdcDebug extends Base{
/**
* @var string
*/
protected $fileName = '/var/log/bdc_debug.log';
/**
* @var int
*/
protected $loggerType = Logger::DEBUG;
}
```
Although both of them are used for overriding the core modules, the way to use them is completely different.
With Preference, it must extend a core class. Preference can rewrite function. When you declare a Preference, your new class is expected to be a complete implementation of the class you want to override.
While a plugin allows you to execute your functions before, after or around (before & after) the core function is executed. It's NOT really rewritten function like Preference.
Since your plugin class doesn't replace the core class, in case there are many plugins hooked onto a target class, Magento 2 just executes them sequentially based on the sortOrder parameter in your file di.xml.
Class preferences basically do the same thing in Magento 2 that rewrites did in Magento 1. It states a preference for one class over another, which allows you to specify which class/type is selected by Magento's object manager. This means that you can override which method you want from the class, along with the methods that this class extends.
- Model class
- Block Class
- Controller Class
app/code/BDC/SimpleNews/etc/di.xml add below code :
<preference type="BDCSimpleNewsHelperBdcDebug" for="MagentoFrameworkLoggerHandlerDebug"/>
Argument types:object Node Formats: {typeName}
{typeName}
<type name="MagentoFrameworkLoggerMonolog">
<arguments>
<argument name="handlers" xsi:type="array">
<item name="debug" xsi:type="object">BDCSimpleNewsHelperBdcDebug</item>
</argument>
</arguments>
</type>
Within Magento 2, classes can depend on each other using constructor-based Dependency Injection. And instead of only allowing static dependencies (class A injects class B), Magento offers a configuration system that allows one dependency to be replaced with another (class B is swapped out for class C). One of these configurations is Virtual Types.
Virtual Types are defined in a file di.xml which might be located in numerous places - for instance, the etc/ folder of your own module. Virtual Types are in essence new PHP classes (but actually they are not, they are just links), that extend upon their original class while overriding the original class its constructor arguments by adding those in the di.xml file.
Within Magento 2, classes can depend on each other using constructor-based Dependency Injection. And instead of only allowing static dependencies (class A injects class B), Magento offers a configuration system that allows one dependency to be replaced with another (class B is swapped out for class C). One of these configurations is Virtual Types.
Virtual Types are defined in a file di.xml which might be located in numerous places - for instance, the etc/ folder of your own module. Virtual Types are in essence new PHP classes (but actually they are not, they are just links), that extend upon their original class while overriding the original class its constructor arguments by adding those in the di.xml file.
Once you realize that a Virtual Types is nothing more than a new PHP child object (as if there was an actual class generating it), it makes you wonder why you should do this through XML. Maybe it is easier to simply create a new PHP class in your module and modify things there? The end result is the same: There is a new object of a new type. (Note that this new class still needs to be used somewhere else to become useful. Typically this is done by using an XML Type to modify the constructor arguments of yet another class and inject this new virtual class in it.)
I personally favour new PHP classes over new Virtual Types. However, once the original class has a lengthy constructor, a new PHP class would require you to duplicate all parent dependencies in its own constructor and pass them on to its parent - and perhaps all of that trouble is only needed for replacing one of those dependencies. A Virtual Type is quicker: It requires some XML, yes, but it allows you to single out only that dependency that you actually need to be replaced. The more complex the original constructor, the better it is to use a Virtual Type. (That being said, the more complex the original constructor, the more this original constructor needs to be cleaned up - with references to SOLID.)
Now let's go to the main point of this blog: Virtual Types are identical to PHP classes created on the fly by the Object Manager. And just like all PHP classes, we have specific rules to stick to and namespacing is one of them. So why not use namespaces?
Let's take a dummy example without namespaces:
<virtualType name="bdcVirtualSomeClass" type="BDCExampleSomeClass">
</virtualType>
And now let's see a namespaced version:
<virtualType name="BDCExampleSomeClassVirtual" type="BDCExampleSomeClass">
</virtualType>
To me, the namespaced version looks a lot cleaner. Remember that defining this Virtual Type is only half of the story - if you don't intend to use it elsewhere, it just as well can be removed again. It only becomes useful once it is applied elsewhere, for instance using a Type:
<type name="MagentoFrameworkSomeExistingClass">
<arguments>
<argument name="someDep" xsi:type="object">BDCExampleSomeClassVirtual</argument>
</arguments>
</type>
Once others start debugging the class MagentoFrameworkSomeExistingClass, they might bump into the someDep argument and now, thanks to namespaces, the name of this Virtual Type identifies exactly who put that dependency there. This is why we have namespaces.
However, this might also become confusing if the Virtual Type actually looks too similar to a PHP class. I always tend to click through my PhpStorm environment with the generated/ folder excluded from my project. Once in a while, I bump into a class that is not there. And if Magento does not die at that moment, I assume it is something that is generated. Once the class has the word Factory or Proxy in it, this confirms my assumption. Wouldn't it make sense to also include the word Virtual in the namespaced name of a Virtual Type?
This leads to the following classes that would suggest that the PHP class actually is a VirtualType:
BDCExampleSomeClassVirtual
BDCExampleVirtualSomeClass
BDCExampleSomeClassVirtual
BDCExampleVirtualTypeSomeClass
BDCExampleSomeClassVirtualType
Obviously, there are many more variations. But just make sure to add the word Virtual in there.
<virtualType name="bdcLogger" type="MagentoFrameworkLoggerMonolog">
<arguments>
<argument name="handlers" xsi:type="array">
<item name="debug" xsi:type="object">BDCSimpleNewsHelperBdcDebug</item>
</argument>
</arguments>
</virtualType>
<type name="BDCSimpleNewsHelperNews">
<arguments> <argument name="logger" xsi:type="object">bdcLogger</argument> </arguments>
</type>
Finaly etc/di.xml look like ;
```
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:ObjectManager/etc/config.xsd">
<type name="MagentoFrameworkConsoleCommandList">
<arguments>
<argument name="commands" xsi:type="array">
<item name="bdc_simplenews_create" xsi:type="object">BDCSimpleNewsConsoleCommandNewsCreate</item>
</argument>
</arguments>
</type>
<preference type="BDCSimpleNewsModelNews" for="BDCSimpleNewsApiDataNewsInterface"/>
<preference type="BDCSimpleNewsModelNewsRepository" for="BDCSimpleNewsApiNewsRepositoryInterface"/>
<!-- <preference type="BDCSimpleNewsHelperBdcDebug" for="MagentoFrameworkLoggerHandlerDebug"/> -->
<!-- <type name="MagentoFrameworkLoggerMonolog">
<arguments>
<argument name="handlers" xsi:type="array">
<item name="debug" xsi:type="object">BDCSimpleNewsHelperBdcDebug</item>
</argument>
</arguments>
</type> -->
<virtualType name="bdcLogger" type="MagentoFrameworkLoggerMonolog">
<arguments>
<argument name="handlers" xsi:type="array">
<item name="debug" xsi:type="object">BDCSimpleNewsHelperBdcDebug</item>
</argument>
</arguments>
</virtualType>
<type name="BDCSimpleNewsHelperNews">
<arguments> <argument name="logger" xsi:type="object">bdcLogger</argument> </arguments>
</type>
</config>
```
跑步
php bin/magento cache:flush
php bin/magento bdcrops:news:create --news-title="News preference" --news-summary="summary preference 1" --news-description="News preference Description 1"
Now check var/log/bdc_debug.log all log are write there
devdocs
Events are dispatched by Magento modules on the trigger of a specific action. Not only that, Magento also allows you to also create your own custom event that can be dispatched in your code. When the action is triggered, it will pass data to the relevant observer configured for the dispatched event. Magento 2 events can be dispatched using MagentoFrameworkEventManager class and it can be obtained through the dependency injection by defining the dependency in your constructor.
Observers are used to catch the action which was triggered from events. In observers, you can set the required functionality or logic that is to be executed in response.
Magento 2 observers can be created by lacing your class file under the Module-Root/Observer directory. Your observer class should implement the following;
MagentoFrameworkEventObserverInterface and define its execution function.
Now let's start with the execution!
Let's assume that you want to change the background color of your store if the customer is not logged in.
Working with Magento 2 observers is one of many different ways of extending the core functionality of a Magento 2 powered eCommerce store. Thanks to Observers, you can run your custom codes in response to a specific Magento event or even with a custom event. You can choose other options such as extending and overriding the core modules, copying the core class to the local directory and put it in the same directory path it was in core directory and modify the core class directly. However, creating an observer is the number one choice
Observers are used for catching the action which was triggered before or after events. In observers, you can set the required functionality or logic that is to be executed in response.
Magento 2 observers can be created by lacing your class file under the Module-Root/Observer directory. Your observer class should implement the following: MagentoFrameworkEventObserverInterface and define its execution function.
Make sure you have registered the new module to test it before, we will practice on this module. I will use my module SampleEvent. And then, I will use an observer to customize the product name on the product view page.
Make your observer efficient: You should try to keep your observer small and efficient by avoiding complex computations if you can. Because having complex computations in your observer can slow down application processes.
Don't include business logic: Your observer should not contain logic other than what is needed for it to run. Business logic should be encapsulated in other classes that your observer uses.
Declare observer in the appropriate scope:
For the frontend events, declare observers in etc/frontend/events.xml, this event will be only used in the frontend. You can't use this event in the backend.
For the backend events, declare observers in etc/adminhtml/events.xml, this event will be only used in the backend. This event can't be used in the frontend.
Use the global etc/events.xml file only when an event can occur on both the frontend and the backend.
You can put events.xml in etc > webapi_rest > events.xml while handling Rest API request.
You can put events.xml in etc > webapi_soap > events.xml while handling Soap API request.
You can put events.xml in etc > crontab > events.xml while handling scheduled jobs only.
You can put events.xml in etc > setup > events.xml while Magento or extensions are being installed or upgraded.
controller_action_predispatch - executes before each controller dispatching.
controller_action_newsdispatch_{full_action_name} - executes after a controller with specific {full_action_name}.
controller_action_newsdispatch_{route_name} - executes after each controller with specific {route_name}.
controller_action_newsdispatch - executes after each controller dispatching.
Edit Helper/News.php:
<?php
namespace BDCSimpleNewsHelper;
use MagentoFrameworkAppHelperContext;
use MagentoStoreModelStoreManagerInterface;
use MagentoFrameworkAppState;
use BDCSimpleNewsModelNewsFactory;
use SymfonyComponentConsoleInputInput;
use PsrLogLoggerInterface;
use MagentoFrameworkEventManagerInterface;
class News extends MagentoFrameworkAppHelperAbstractHelper {
const KEY_TITLE = 'news-title';
const KEY_SUMMARY = 'news-summary';
const KEY_DESC = 'news-description';
protected $storeManager;
protected $state;
protected $newsFactory;
protected $data;
protected $newsId;
protected $logger;
protected $eventManager;
// $eventManager
public function __construct(
Context $context,
StoreManagerInterface $storeManager,
State $state,
NewsFactory $newsFactory,
LoggerInterface $logger,
ManagerInterface $eventManager) {
$this->storeManager = $storeManager;
$this->state = $state;
$this->logger = $logger;
$this->eventManager = $eventManager;
$this->newsFactory = $newsFactory;
parent::__construct($context);
}
public function setData(Input $input){
$this->data = $input;
return $this;
}
public function execute() {
$this->state->setAreaCode('frontend');
$news = $this->newsFactory->create();
$news->setTitle($this->data->getOption(self::KEY_TITLE))
->setSummary($this->data->getOption(self::KEY_SUMMARY))
->setDescription($this->data->getOption(self::KEY_DESC));
$news->save();
$this->logger->debug('DI: '.$news->getTitle());
// EventCode...
$this->eventManager->dispatch('bdc_simplenews_save_after', ['object' => $news]);
$this->newsId = $news->getId();
// if($this->data->getOption(self::KEY_SENDEMAIL)) {
// $news->sendNewAccountEmail();
// }
}
public function getNewsId(){
return (int)$this->newsId;
}
}
Usually, models extend the MagentoFrameworkModelAbstractModel class. It gives an ability to observe a predefined set of model events. And the model should have AbstractModel::_ eventPrefix attribute specified for observing events of a specific model. The attribute's value equals to "core_abstract" by default.
Also, in models we have AbstractModel::_ eventObject attribute that gives an ability to specify a name of the current model's instance for different model-specific events.
A list of the global models events:
model_load_before - executes before each model is loader. Here we can get an access to the following event's data.
$observer->getField() - gets currently processed model's field name.
$observer->getValue() - gets currently processed model's field value.
model_load_after - executes after each model loading.
model_save_after - executes after each model saving.
model_save_before - executes before each model saving.
clean_cache_by_tags - executes after model related cache tags are cleaned.
model_delete_before - executes before model is deleted.
model_delete_after - executes after model is deleted.
model_save_commit_after - executes after the models saving transaction is committed.
model_delete_commit_after - executes after the models saving transaction commit is deleted.
In this mentioned events, we can get an access to the following data:
$observer->getObject()
List model-specific events:
{event_prefix}_load_before – executes before model with {event_prefix} is loaded.
{event_prefix}_load_after – executes after model with {event_prefix} is loaded.
{event_prefix}_save_before – executes before model with {event_prefix} is saved.
{event_prefix}_save_after – executes after model with {event_prefix} is saved.
{event_prefix}_delete_before – executes before model with {event_prefix} is deleted.
{event_prefix}_delete_after – executes after model with {event_prefix} is deleted.
{event_prefix}_save_commit_after – executes after model's data with {event_prefix} is committed.
{event_prefix}_delete_commit_after – executes after model's data commit with {event_prefix} is deleted.
{event_prefix}_clear – executes when a model object is being prepared for correct deleting by the garbage collector.
Furthermore, we can get an access to the following event data from each of them:
$observer->getDataObject() – gets the current model reference.
$observer->get{event_object} – gets an event object for the current model.
If you want to find an event in code, you can do this.
Example: You need an event save_before or save after.
Create an event observer to hook in the event [model prefix]_ save_before. In here we will have observer variable, this variable could get the Model of model which we need to save data on it.
And then we can use setData('column_name',[new value]) to adjust the data of a column before saving to the database.
So why can we do that?
What is Model Prefix: in object Model, we have a property, this is protected $_ eventPrefix; (You can see in the model, if you don't have it, you can create it). It's is a string type. Getting the value and join it with _ save_before, we will have an event name.
EG: protected $ _ eventPrefix = 'abc'; => Event Observer = 'abc_save_before'.
You can declare another event:
[prefix]_ load_before
[prefix]_ save_after
[prefix]_ load_after
These events are default and always available with a model, If you want to use a custom event, you can use eventManager->dispatch('event_name',$data);
OR Model/News.php just add protected $_ eventPrefix = 'bdc_simplenews'; This event eventPrefix is used by abstract model to generate events automatically.Finaly script look like below:
```
<?php
// These files to insert, update, delete and get data in the database.
namespace BDCSimpleNewsModel;
use MagentoFrameworkModelAbstractModel;
class News extends AbstractModel{
protected $_eventPrefix = 'bdc_simplenews';
/**
* News constructor.
* @param MagentoFrameworkModelContext $context
* @param MagentoFrameworkRegistry $registry
* @param MagentoFrameworkModelResourceModelAbstractResource|null $resource
* @param MagentoFrameworkDataCollectionAbstractDb|null $resourceCollection
* @param array $data
*/
public function __construct(
MagentoFrameworkModelContext $context,
MagentoFrameworkRegistry $registry,
MagentoFrameworkModelResourceModelAbstractResource $resource = null,
MagentoFrameworkDataCollectionAbstractDb $resourceCollection = null,
array $data = []
) {
parent::__construct($context, $registry, $resource, $resourceCollection, $data);
}
/**
* (non-PHPdoc)
* @see MagentoFrameworkModelAbstractModel::_construct()
*/
public function _construct() {
$this->_init('BDCSimpleNewsModelResourceNews');
}
/**
* Loading news data
*
* @param mixed $key
* @param string $field
* @return $this
*/
public function load($key, $field = null) {
if ($field === null) {
$this->_getResource()->load($this, $key, 'id');
return $this;
}
$this->_getResource()->load($this, $key, $field);
return $this;
}
}
```
Create Observer/Logger.php
<?php
namespace BDCSimpleNewsObserver;
use MagentoFrameworkEventObserver;
use MagentoFrameworkEventObserverInterface;
use PsrLogLoggerInterface;
class Logger implements ObserverInterface {
private $logger;
public function __construct(LoggerInterface $logger){
$this->logger = $logger;
}
public function execute(Observer $observer){
$this->logger->debug("Observer:".
$observer->getEvent()->getObject()->getTitle()
);
}
}
create etc/events.xml
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:Event/etc/events.xsd">
<event name="bdc_simplenews_save_after">
<observer name="bdcLogger" instance="BDCSimpleNewsObserverLogger" />
</event>
</config>
- name – the observer registration name (it is important that the names do not coincide);
- instance – the class, which method will be executed when a specific even occurs;
- method – the method being executed.
add etc/di.xml
<type name="BDCSimpleNewsObserverLogger">
<arguments> <argument name="logger" xsi:type="object">bdcLogger</argument> </arguments>
</type>
Finally etc/di.xml look like:
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:ObjectManager/etc/config.xsd">
<type name="MagentoFrameworkConsoleCommandList">
<arguments>
<argument name="commands" xsi:type="array">
<item name="bdc_simplenews_create" xsi:type="object">BDCSimpleNewsConsoleCommandNewsCreate</item>
</argument>
</arguments>
</type>
<preference type="BDCSimpleNewsModelNews" for="BDCSimpleNewsApiDataNewsInterface"/>
<preference type="BDCSimpleNewsModelNewsRepository" for="BDCSimpleNewsApiNewsRepositoryInterface"/>
<!-- <preference type="BDCSimpleNewsHelperBdcDebug" for="MagentoFrameworkLoggerHandlerDebug"/> -->
<!-- <type name="MagentoFrameworkLoggerMonolog">
<arguments>
<argument name="handlers" xsi:type="array">
<item name="debug" xsi:type="object">BDCSimpleNewsHelperBdcDebug</item>
</argument>
</arguments>
</type> -->
<virtualType name="bdcLogger" type="MagentoFrameworkLoggerMonolog">
<arguments>
<argument name="handlers" xsi:type="array">
<item name="debug" xsi:type="object">BDCSimpleNewsHelperBdcDebug</item>
</argument>
</arguments>
</virtualType>
<type name="BDCSimpleNewsHelperNews">
<arguments> <argument name="logger" xsi:type="object">bdcLogger</argument> </arguments>
</type>
<type name="BDCSimpleNewsObserverLogger">
<arguments> <argument name="logger" xsi:type="object">bdcLogger</argument> </arguments>
</type>
</config>
跑步
php bin/magento cache:flush
php bin/magento bdcrops:news:create --news-title="News Observer" --news-summary="summary Observer 1" --news-description="News Observer Description 1"
Now check var/log/bdc_debug.log all log are write there
A plugin is a great way to expand or edit a public method's behavior by using code before, after or around method. First of all, please get an object that provides permission to all public methods of the observed method's class. Interception is a software design pattern that is used when we want to insert code dynamically without necessarily changing the original class behavior. The interception pattern in Magento 2 is implemented via plugins. Plugins are an amazing tool in Magento 2. They allow you to change the behavior of methods for classes without having to rewrite the classes as we did above. There are 3 different ways to use a plugin to change method behavior. You may have heard them on Sesame Street: - Before - After - Around
For a module developer as you, Magento 2 Interception plugin allows:
di.xml file in your module declares a plugin for a class object:
<config>
<type name="{ObservedType}">
<plugin name="{pluginName}" type="{PluginClassName}" sortOrder="1" disabled="false" />
</type>
</config>
更多詳細信息：
name – Using this attribute, you can provide a unique and recognizable name value that is specific to the plugin.
sortOrder – This attribute determines the order of execution when multiple plugins are observing the same method.
disabled – The default value of this attribute is set to false, but if it is set to true, it will disable the current plugin, and it will not get executed.
type – This attribute points to the class that we will be using to implement the before, after or around the listener.
Assuming we are writing a plugin for a specific method, let's choose a random method under Customer.php class, the getName() method. We define the before, after and around listeners for the getName() method by writing the naming conventions as follows.
Before + getName() => beforeGetName();
After + getName() => afterGetName();
Around + getName() => aroundGetName();
create Plugin/Logger.php
```
<?php
namespace BDCSimpleNewsPlugin;
use BDCSimpleNewsConsoleCommandNewsCreate;
use SymfonyComponentConsoleInputInputInterface;
use SymfonyComponentConsoleOutputOutputInterface;
class Logger{
/**
* @var OutputInterface
*/
private $output;
public function beforeRun(
NewsCreate $command,
InputInterface $input,
OutputInterface $output) {
$output->writeln('beforeExecute');
}
public function aroundRun(
NewsCreate $command,
Closure $proceed,
InputInterface $input,
OutputInterface $output) {
$output->writeln('aroundExecute before call');
$proceed->call($command, $input, $output);
$output->writeln('aroundExecute after call');
$this->output = $output;
}
//public function afterRun(NewsCreate $command){
//$this->output->writeln('afterExecute');
//}
}
```
add code app/code/BDC/SimpleNews/etc/di.xml
<type name="BDCSimpleNewsConsoleCommandNewsCreate">
<plugin name="bdcLoggerp" type="BDCSimpleNewsPluginLogger"/>
</type>
Finally etc/di.xml look like:
```
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:ObjectManager/etc/config.xsd">
<type name="MagentoFrameworkConsoleCommandList">
<arguments>
<argument name="commands" xsi:type="array">
<item name="bdc_simplenews_create" xsi:type="object">BDCSimpleNewsConsoleCommandNewsCreate</item>
</argument>
</arguments>
</type>
<preference type="BDCSimpleNewsModelNews" for="BDCSimpleNewsApiDataNewsInterface"/>
<preference type="BDCSimpleNewsModelNewsRepository" for="BDCSimpleNewsApiNewsRepositoryInterface"/>
<!-- <preference type="BDCSimpleNewsHelperBdcDebug" for="MagentoFrameworkLoggerHandlerDebug"/> -->
<!-- <type name="MagentoFrameworkLoggerMonolog">
<arguments>
<argument name="handlers" xsi:type="array">
<item name="debug" xsi:type="object">BDCSimpleNewsHelperBdcDebug</item>
</argument>
</arguments>
</type> -->
<virtualType name="bdcLogger" type="MagentoFrameworkLoggerMonolog">
<arguments>
<argument name="handlers" xsi:type="array">
<item name="debug" xsi:type="object">BDCSimpleNewsHelperBdcDebug</item>
</argument>
</arguments>
</virtualType>
<type name="BDCSimpleNewsHelperNews">
<arguments> <argument name="logger" xsi:type="object">bdcLogger</argument> </arguments>
</type>
<type name="BDCSimpleNewsObserverLogger">
<arguments> <argument name="logger" xsi:type="object">bdcLogger</argument> </arguments>
</type>
<type name="BDCSimpleNewsConsoleCommandNewsCreate">
<plugin name="bdcLoggerp" type="BDCSimpleNewsPluginLogger"/>
</type>
</config>
```
跑步
php bin/magento cache:flush
php bin/magento bdcrops:news:create --news-title="News Plugin" --news-summary="summary Plugin 1" --news-description="News Plugin Description 1"
Now check var/log/bdc_debug.log all log are write there
<block template="BDC_SimpleNews::list.phtml" class="BDCSimpleNewsBlockNewsList" name="bdc_simplenews_block_news_list"/>
Change as below:
<block template="BDC_SimpleNews::list.phtml" class="BDCSimpleNewsBlockNewsList" name="bdc_simplenews_block_news_list">
<arguments>
<argument name="label" xsi:type="string">Head Line: </argument>
</arguments>
</block>
<?php echo $block->getLabel(); ?>
RequireJS is a javascript module system. It implements the Asynchronous Module Definition (AMD) standard for javascript modules. In the terms of AMD, a javascript module provides a way to Run a javascript program that doesn't default to the global namespace Share javascript code and data between named modules and programs That's all RequireJS does. You may use a RequireJS module that implements some special bit of functionality, but its not RequireJS that provides that functionality. RequireJS is the pneumatic tube that ensures the functionality is delivered to you.
var config = {
"map": {
"*": { "<default_component>": "<custom_component>" }
}
};
var config = {
"shim": {
"3-rd-party-plugin": ["jquery"]
}
};
var config = {
"deps": [
"jquery"
]
};
Here, It loads the [jquery] as soon as the require define()'d is called.
var config = {
"baseUrl": "bdcrops/test"
};
require( ["sample/sample1", "https://code.jquery.com/jquery-3.1.1.min.js", "sample2.js"],
function(samplemodule) {
}
);
Here, samplemodule is reffered to bdcrops/test/sample/sample1.js, “https://code.jquery.com/jquery-3.1.1.min.js” is loaded from the url which is specified and sample2.js is loaded from the same directory.
var config = {
"baseUrl": "bdcrops/test",
"paths": {
"sample": "web/js"
},
};
require( ["sample/sample1"],
function(samplemodule) {
}
);
Now, samplemodule is reffered to the file at path “bdcrops/test/web/js/sample1.js”
var config = {
"map": {
'*': {
'sample': 'sample1.js'
}
}
config: {
"testData":{
"color":'red'
}
}
};
Now in your js file you can access this value by using :console.log(require.s.contexts._ .config.testData.color);It will gives you the “red” in output.
A Magento 2 RequireJS “mixin” allows you to programmatically listen for the initial instantiation of any RequireJS module and manipulate that module before returning it.
requireJS configuration create app/code/BDC/SimpleNews/view/frontend/requirejs-config.js
copy validation lib to mododule lib/web/mage/validation.js ==>app/code/BDC/SimpleNews/view/frontend/web/js/validation.js Change massages about 1684 line as
$.validator.messages = $.extend($.validator.messages, {
required: $.mage.__('This is a required field Custome.'),
var config = {
'map': {
'*': {
'mage/validation': 'BDC_SimpleNews/js/validation'
}
}
};
var config = {
'map': {
'*': {
'mage/validation': 'BDC_SimpleNews/js/validation'
}
},
config: {
mixins: {
'BDC_SimpleNews/js/validation': {
'BDC_SimpleNews/js/validation-mixin': true
}
}
}
};
define(function () {
'use strict';
var extension = {
isValid: function () {
return true;
}
};
return function (target) {
return target.extend(extension);
};
});
As you know, Magento 2 Grid is a kind of table which listing the items in your database table and provide you some features like: sort, filter, delete, update item, etc. The samplenews for this is the grid of products, grid of customer.Magento 2 provide two ways to create Admin Grid:
Declare resource in dependency injection file Now we will create di.xml file which will connect to the Model to get the data for our grid. File: app/code/BDC/SampleNews/etc/di.xml
Create layout file For the action bdc_simplenews/news/index, we will create a layout file name bdc_samplenews_news_index.xml
Create component layout file As declaration in layout file, we will create a component file bdc_samplenews_news_listing.xml
You have just find how to add a Magento 2 Grid by using Component. Now we will see how to do it by using normal layout/block file.
Create block for this grid File: app/code/BDC/SampleNews/Block/Adminhtml/News.php
Create layout file Now we will need a layout file to connect with Grid Block and render the grid. Let's create this file:app/code/BDC/SampleNews/view/adminhtml/layout/bdc_samplenews_news_index.xml
Create layout file Now we will need a layout file to connect with Grid Block and render the grid. Let's create this file: app/code/BDC/SampleNews/view/adminhtml/layout/bdc_samplenews_news_index.xml
-Argument: data_sources to use (which makes the links between your grid and the database) with the tag js_config. We also declare the spinner, that is the name of the tag "columns" that will be used in our grid. We then declare our buttons in the buttons tag with a name, a label, a class and a target url.
dataSource: dataProvider (the object that will fetch our data in database). With a "class" tag to define the name of the object to be used. This object will be defined later in the di.xml (dependency node file). We give a name to our dataSource via the "name" attribute and then we give it the field to use as the id for the grid in the database ("primaryFieldName") and for the request ("requestFieldName"). We then define in "config" the component to use (here "Magento_Ui/js/grid/provider") and the identifier in our bdd "indexField" which here has the value "pfay_contacts_id".
columns: It was defined above in the "spinner" section of the "argument" section, here it is named listing_columns. This area will allow us to define our columns with the identifier to be used to find oneself, the type of fields and filters to use for the grid, the type of sorting that will be used and a label.
The bookmarks allows you to save the state of the listing which you modified with the element "columns_control" previously created. Here is how to integrate the "bookmark" in the "container" :
<bookmark name="bookmarks">
<argument name="data" xsi:type="array">
<item name="config" xsi:type="array">
<item name="component" xsi:type="string">Magento_Ui/js/grid/controls/bookmarks/bookmarks</item>
<item name="displayArea" xsi:type="string">dataGridActions</item>
<item name="storageConfig" xsi:type="array">
<item name="saveUrl" xsi:type="url" path="*/*/save"/>
<item name="deleteUrl" xsi:type="url" path="*/*/delete"/>
<item name="namespace" xsi:type="string">contact_test_listing</item>
</item>
</item>
</argument>
</bookmark>
The pagination of the grid under magento2 is super well done and very easy to integrate, it is enough just to pay attention to the 2 paths "provider" and "selectProvider". Here is the code to insert:
<paging name="listing_paging">
<argument name="data" xsi:type="array">
<item name="config" xsi:type="array">
<item name="storageConfig" xsi:type="array">
<!-- we put here the path to the bookmarks element -->
<item name="provider" xsi:type="string">contacts_test_listing.contacts_test_listing.listing_top.bookmarks</item>
<item name="namespace" xsi:type="string">current.paging</item>
</item>
<!-- we put here the path to the element pfay_contact_ids of contacts_test_columns element -->
<item name="selectProvider" xsi:type="string">contacts_test_listing.contacts_test_listing.contacts_test_columns.pfay_contacts_id</item>
<item name="displayArea" xsi:type="string">bottom</item>
</item>
</argument>
</paging>
To be able to filter the table can sometimes be practical, for that a "filter" element can be added to the magento grid.這是這樣做的方法：
<filters name="listing_filters">
<argument name="data" xsi:type="array">
<item name="config" xsi:type="array">
<item name="storageConfig" xsi:type="array">
<item name="provider" xsi:type="string">contacts_test_listing.contacts_test_listing.listing_top.bookmarks</item>
<item name="namespace" xsi:type="string">curren.filters</item>
</item>
<item name="childDefaults" xsi:type="array">
<item name="provider" xsi:type="string">contacts_test_listing.contacts_test_listing.listing_top.listing_filters</item>
<item name="imports" xsi:type="array">
<item name="visible" xsi:type="string">contacts_test_listing.contacts_test_listing.listing_top.bookmarks:current.columns.${ $.index }.visible</item>
</item>
</item>
</item>
</argument>
</filters>
By default, it takes all the fields available on the grid, it knows how to filter with the "filter" item of your "columns" like these:
ici type text : text
ici type textRange : textRange
You want to be able to select several lines of your grid to delete them all at once or do another specific processing on all the lines selected at the same time? The Mass Actions are made for this. First of all it will be necessary to add the inputs on the edge of our grid to be able to select the lines, so in "columns" add this before the "column":
<selectionsColumn name="ids">
<argument name="data" xsi:type="array">
<item name="config" xsi:type="array">
<!-- define which field will be used as ID -->
<item name="indexField" xsi:type="string">pfay_contacts_id</item>
</item>
</argument>
</selectionsColumn>
You now see the checkboxes on the side that allow you to select multiple lines. Here is how to integrate the selectbox which allows to select the action to be performed once we have selected our lines:
<massaction name="listing_massaction">
<argument name="data" xsi:type="array">
<item name="config" xsi:type="array">
<!-- we put here the path to the element pfay_contact_ids of contacts_test_columns element -->
<item name="selectProvider" xsi:type="string">contacts_test_listing.contacts_test_listing.contacts_test_columns.ids</item>
<item name="displayArea" xsi:type="string">bottom</item>
<item name="indexField" xsi:type="string">pfay_contacts_id</item>
</item>
</argument>
<action name="delete">
<argument name="data" xsi:type="array">
<item name="config" xsi:type="array">
<item name="type" xsi:type="string">delete</item>
<item name="label" xsi:type="string" translate="true">Delete Selected</item>
<item name="url" xsi:type="url" path="*/*/massDelete"/>
<item name="confirm" xsi:type="array">
<item name="title" xsi:type="string" translate="true">Delete all selected contacts</item>
<item name="message" xsi:type="string" translate="true">Do you want to delete all the selected contacts?</item>
</item>
</item>
</argument>
</action>
</massaction>
Here it is the same, we have to be careful on what we enter as a path for the "selectProvider" and we add the actions following each other. In order to prepare the next tutorial, we will create the MassDelete controller. This is where we will be redirected when we select our action ( / /massDelete).
To create a search field on the magento admin, you must add an optional element in the container that will be called "filterSearch" like this: In
<!-- Filter Search -->
<filterSearch name="fulltext">
<argument name="data" xsi:type="array">
<item name="config" xsi:type="array">
<item name="provider" xsi:type="string">contacts_test_listing.contacts_test_listing_data_source</item>
<item name="chipsProvider" xsi:type="string">contacts_test_listing.contacts_test_listing.listing_top.listing_filters_chips</item>
<item name="storageConfig" xsi:type="array">
<item name="provider" xsi:type="string">contacts_test_listing.contacts_test_listing.listing_top.bookmarks</item>
<item name="namespace" xsi:type="string">current.search</item>
</item>
</item>
</argument>
</filterSearch>
For the searchbar to work you have to update your table to add the index.
1.grid collections
2.listing component configuration
Create Controller/Adminhtml/Index/Index.php
<?php
namespace BDCSimpleNewsControllerAdminhtmlIndex;
use MagentoFrameworkControllerResultFactory;
class Index extends MagentoBackendAppAction {
public function execute() {
return $this->resultFactory->create(ResultFactory::TYPE_PAGE);
}
}
Create Model/Resource/News/Grid/Collection.php
```
<?php
namespace BDCSimpleNewsModelResourceNewsGrid;
use MagentoFrameworkDataCollectionDbFetchStrategyInterface as FetchStrategy;
use MagentoFrameworkDataCollectionEntityFactoryInterface as EntityFactory;
use MagentoFrameworkEventManagerInterface as EventManager;
use PsrLogLoggerInterface as Logger;
use MagentoFrameworkViewElementUiComponentDataProviderSearchResult;
class Collection extends SearchResult {
public function __construct(
EntityFactory $entityFactory,
Logger $logger,
FetchStrategy $fetchStrategy,
EventManager $eventManager,
$mainTable = 'bdc_simplenews',
$resourceModel = 'BDCSimpleNewsModelResourceNews' ) {
parent::__construct(
$entityFactory,
$logger,
$fetchStrategy,
$eventManager,
$mainTable,
$resourceModel
);
}
}
```
Edit etc/di.xml
<type name="MagentoFrameworkViewElementUiComponentDataProviderCollectionFactory">
<arguments>
<argument name="collections" xsi:type="array">
<item name="bdc_news_grid_data_source" xsi:type="string">BDCSimpleNewsModelResourceNewsGridCollection</item>
</argument>
</arguments>
</type>
Create view/adminhtml/layout/simplenews_index_index.xml
<?xml version="1.0"?>
<page xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:View/Layout/etc/page_configuration.xsd">
<body>
<referenceContainer name="content">
<uiComponent name="bdc_news_grid"/>
</referenceContainer>
</body>
</page>
Create view/adminhtml/ui_component/bdc_news_grid.xml
```
<?xml version="1.0" encoding="UTF-8"?>
<listing xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Ui:etc/ui_configuration.xsd">
<argument name="data" xsi:type="array">
<item name="js_config" xsi:type="array">
<item name="provider" xsi:type="string">bdc_news_grid.bdc_news_grid_data_source</item>
<item name="deps" xsi:type="string">bdc_news_grid.bdc_news_grid_data_source</item>
</item>
<item name="spinner" xsi:type="string">bdc_news_columns</item>
<item name="buttons" xsi:type="array">
<item name="add" xsi:type="array">
<item name="name" xsi:type="string">add</item>
<item name="label" xsi:type="string" translate="true">Add News</item>
<item name="class" xsi:type="string">primary</item>
<item name="url" xsi:type="string">*/news/new</item>
</item>
</item>
</argument>
<dataSource name="bdc_news_grid_data_source">
<argument name="dataProvider" xsi:type="configurableObject">
<argument name="class" xsi:type="string">MagentoFrameworkViewElementUiComponentDataProviderDataProvider</argument>
<argument name="name" xsi:type="string">bdc_news_grid_data_source</argument>
<argument name="primaryFieldName" xsi:type="string">id</argument>
<argument name="requestFieldName" xsi:type="string">id</argument>
<argument name="data" xsi:type="array">
<item name="config" xsi:type="array">
<item name="update_url" xsi:type="url" path="mui/index/render"/>
<item name="component" xsi:type="string">Magento_Ui/js/grid/provider</item>
</item>
</argument>
</argument>
</dataSource>
<listingToolbar name="listing_top">
<bookmark name="bookmarks"/>
<columnsControls name="columns_controls"/>
<exportButton name="export_button"/>
<filterSearch name="fulltext"/>
<filters name="listing_filters"/>
<paging name="listing_paging"/>
<!-- <frontendLink name="frontend_link"/> -->
</listingToolbar>
<columns name="bdc_news_columns">
<argument name="data" xsi:type="array">
<item name="config" xsi:type="array">
<item name="childDefaults" xsi:type="array">
<item name="fieldAction" xsi:type="array">
<item name="provider" xsi:type="string">bdc_news_grid.bdc_news_grid.bdc_news_columns.actions</item>
<item name="target" xsi:type="string">applyAction</item>
<item name="params" xsi:type="array">
<item name="0" xsi:type="string">view</item>
<item name="1" xsi:type="string">${ $.$data.rowIndex }</item>
</item>
</item>
</item>
</item>
</argument>
<selectionsColumn name="ids">
<argument name="data" xsi:type="array">
<item name="config" xsi:type="array">
<item name="indexField" xsi:type="string">id</item>
</item>
</argument>
</selectionsColumn>
<column name="title">
<argument name="data" xsi:type="array">
<item name="config" xsi:type="array">
<item name="filter" xsi:type="string">text</item>
<item name="label" xsi:type="string" translate="true">Title</item>
</item>
</argument>
</column>
<column name="summary">
<argument name="data" xsi:type="array">
<item name="config" xsi:type="array">
<item name="filter" xsi:type="string">text</item>
<item name="label" xsi:type="string" translate="true">Summary</item>
</item>
</argument>
</column>
</columns>
</listing>
```
Clean Cache & Run
http://www.magento.lan/cadmin/simplenews/
New & save controllers
UI data provider form
Form ui component configuration
Create Ui/DataProvider.php
```
<?php
namespace BDCSimpleNewsUi;
use MagentoUiDataProviderAbstractDataProvider;
class DataProvider extends AbstractDataProvider{
protected $collection;
public function __construct(
$name,
$primaryFieldName,
$requestFieldName,
$collectionFactory,
array $meta = [],
array $data = [] ) {
parent::__construct($name, $primaryFieldName, $requestFieldName, $meta, $data);
$this->collection = $collectionFactory->create();
}
public function getData() {
$result = [];
foreach ($this->collection->getItems() as $item) {
$result[$item->getId()]['general'] = $item->getData();
}
return $result;
}
}
```
Create Controller/Adminhtml/Index/Index.php
```
<?php
namespace BDCSimpleNewsControllerAdminhtmlIndex;
use MagentoFrameworkControllerResultFactory;
class Index extends MagentoBackendAppAction {
public function execute() {
return $this->resultFactory->create(ResultFactory::TYPE_PAGE);
}
}
```
Create Controller/Adminhtml/Index/NewAction.php
```
<?php
namespace BDCSimpleNewsControllerAdminhtmlIndex;
use MagentoFrameworkControllerResultFactory;
class NewAction extends MagentoBackendAppAction{
public function execute() {
return $this->resultFactory->create(ResultFactory::TYPE_PAGE);
}
}
```
Create Controller/Adminhtml/Index/Save.php
```
<?php
namespace BDCSimpleNewsControllerAdminhtmlIndex;
use BDCSimpleNewsModelNewsFactory;
class Save extends MagentoBackendAppAction {
private $newsFactory;
public function __construct(
MagentoBackendAppActionContext $context,
NewsFactory $newsFactory
) {
$this->newsFactory = $newsFactory;
parent::__construct($context);
}
public function execute(){
$this->newsFactory->create()
->setData($this->getRequest()->getNewsValue()['general'])->save();
return $this->resultRedirectFactory->create()->setPath('simplenews/index/index');
}
}
```
create view/adminhtml/layout/simplenews_index_index.xml
```
<?xml version="1.0"?>
<page xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:View/Layout/etc/page_configuration.xsd">
<body>
<referenceContainer name="content">
<uiComponent name="bdc_news_grid"/>
</referenceContainer>
</body>
</page>
```
create view/adminhtml/ui_component/bdc_news_grid.xml
```
check admin panel as 
create view/adminhtml/layout/simplenews_index_new.xml
```
<?xml version="1.0"?>
<page layout="admin-2columns-left" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:View/Layout/etc/page_configuration.xsd">
<body>
<referenceContainer name="content">
<uiComponent name="bdc_news_form"/>
</referenceContainer>
</body>
</page>
```
create view/adminhtml/ui_component/bdc_news_form.xml
```
<?xml version="1.0" encoding="UTF-8"?>
<form xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Ui:etc/ui_configuration.xsd">
<argument name="data" xsi:type="array">
<item name="js_config" xsi:type="array">
<item name="provider" xsi:type="string">bdc_news_form.bdc_news_form_data_source</item>
<item name="deps" xsi:type="string">bdc_news_form.bdc_news_form_data_source</item>
</item>
<item name="label" xsi:type="string" translate="true">General</item>
<item name="layout" xsi:type="array">
<item name="type" xsi:type="string">tabs</item>
<item name="navContainerName" xsi:type="string">left</item>
</item>
<item name="buttons" xsi:type="array">
<item name="save" xsi:type="array">
<item name="name" xsi:type="string">save</item>
<item name="label" xsi:type="string" translate="true">Save</item>
<item name="class" xsi:type="string">primary</item>
<item name="url" xsi:type="string">*/*/save</item>
</item>
</item>
</argument>
<dataSource name="bdc_news_form_data_source">
<argument name="dataProvider" xsi:type="configurableObject">
<argument name="class" xsi:type="string">BDCSimpleNewsUiDataProvider</argument>
<argument name="name" xsi:type="string">bdc_news_form_data_source</argument>
<argument name="primaryFieldName" xsi:type="string">id</argument>
<argument name="requestFieldName" xsi:type="string">id</argument>
<argument name="collectionFactory" xsi:type="object">BDCSimpleNewsModelResourceNewsCollectionFactory</argument>
<argument name="data" xsi:type="array">
<item name="config" xsi:type="array">
<item name="submit_url" xsi:type="url" path="simplenews/index/save"/>
</item>
</argument>
</argument>
<argument name="data" xsi:type="array">
<item name="js_config" xsi:type="array">
<item name="component" xsi:type="string">Magento_Ui/js/form/provider</item>
</item>
</argument>
</dataSource>
<fieldset name="general">
<argument name="data" xsi:type="array">
<item name="config" xsi:type="array">
<item name="label" xsi:type="string" translate="true">General</item>
</item>
</argument>
<field name="title">
<argument name="data" xsi:type="array">
<item name="config" xsi:type="array">
<item name="label" xsi:type="string" translate="true">Title</item>
<item name="dataType" xsi:type="string">text</item>
<item name="formElement" xsi:type="string">input</item>
<item name="validation" xsi:type="array">
<item name="required-entry" xsi:type="boolean">true</item>
</item>
</item>
</argument>
</field>
<field name="summary">
<argument name="data" xsi:type="array">
<item name="config" xsi:type="array">
<item name="label" xsi:type="string" translate="true">Summary</item>
<item name="dataType" xsi:type="string">text</item>
<item name="formElement" xsi:type="string">input</item>
</item>
</argument>
</field>
</fieldset>
</form>
```
edit etc/adminhtml/menu.xml add below code
<add id="BDC_SimpleNews::manage_newsui" title="Manage News UI Grid"
module="BDC_SimpleNews" sortOrder="3" parent="BDC_SimpleNews::main_menu"
action="simplenews" resource="BDC_SimpleNews::manage_newsui" />
Copy To app/code/BDC/SimpleNews/view/adminhtml/layout/sales_order_index.xml <==vendor/magento/module-sales/view/adminhtml/layout/sales_order_grid.xml
Create view/adminhtml/ui_component/sales_order_grid.xml
```
<?xml version="1.0" encoding="UTF-8"?>
<listing xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Ui:etc/ui_configuration.xsd">
<columns name="sales_order_columns">
<column name="created_at">
<argument name="data" xsi:type="array">
<item name="config" xsi:type="array">
<item name="dateFormat" xsi:type="string">MMM dd, YYYY</item>
</item>
</argument>
</column>
<!-- <column name="base_tax_amount" class="MagentoSalesUiComponentListingColumnPrice">
<argument name="data" xsi:type="array">
<item name="config" xsi:type="array">
<item name="filter" xsi:type="string">textRange</item>
<item name="label" xsi:type="string" translate="true">Base Tax Amount</item>
</item>
</argument>
</column> -->
</columns>
</listing>
```
Edit etc/di.xml
<virtualType name="MagentoSalesModelResourceModelOrderGrid">
<arguments>
<argument name="columns" xsi:type="array">
<item name="base_tax_amount" xsi:type="string">sales_order.base_tax_amount</item>
</argument>
</arguments>
</virtualType>
Add new field 'base_tax_amount' on table sales_order_grid(add filed PhpMyAdmin)
Magento transforms data such as products, categories, and so on, to improve the performance of your storefront. As data changes, the transformed data must be updated—or reindexed. Magento has a very sophisticated architecture that stores lots of merchant data (including catalog data, prices, users, stores, and so on) in many database tables. To optimize storefront performance, Magento accumulates data into special tables using indexers.
For example, suppose you change the price of an item from $8.99 to $6.99. Magento must reindex the price change to display it on your storefront.
Without indexing, Magento would have to calculate the price of every product on the fly—taking into account shopping cart price rules, bundle pricing, discounts, tier pricing, and so on. Loading the price for a product would take a long time, possibly resulting in cart abandonment.
php bin/magento indexer:reindex
https://devdocs.magento.com/guides/v2.3/extension-dev-guide/declarative-schema/
https://onilab.com/blog/declarative-schema-magento-2-3-and-higherProducts
https://www.mage-world.com/blog/create-a-module-with-custom-database-table-in-magento-2.html
http://techjeffyu.com/blog/magento-2-a-full-magento-2-module
https://github.com/codingarrow/M2/tree/master/BDC/SimpleNews
