I den föregående artikeln Jag har beskrivit processen för produktimport i Magento 2 på det vanliga sättet – via modeller och repositarier. Den vanliga metoden har en ganska låg databehandlingshastighet. På min bärbara dator var det ungefär en produkt per sekund. I den här fortsättningen kommer jag att titta på ett alternativt sätt att importera produkter – genom direktinskrivning i databasen, helt utan standardmekanismerna i Magento 2 (modeller, fabriker, repositarier). Följden av steg som möjliggör produktimport kan anpassas till vilket programmeringsspråk som helst som kan arbeta med MySQL.

Ansvarsfriskrivning: I Magento finns det en färdig funktion för dataimport och du kommer förmodligen att ha tillräckligt med det. Men om du behöver mer full kontroll över importprocessen, utan begränsningar kopplade till förbereda en CSV-fil för vad som finns – välkommen ner.

Koden som skapades som resultat av att skriva de två artiklarna kan ses i Magento-modulen "flancer32/mage2_ext_demo_import". Här är några begränsningar som jag följde för att förenkla koden för demomodulen:

• Produkter skapas endast, inte uppdateras.
• En lagerplats
• Endast kategori namn importeras, utan deras struktur
• Datastrukturerna motsvarar version 2.3

JSON för import av enskild produkt:

{
  "sku": "MVA20D-UBV-3",
  "name": "Tätningspropp för försegling VA47-29 IEK",
  "desc": "Ger tillgång till enheter ...",
  "desc_short": "Tätningsproppen för försegling VA47-29 IEK är avsedd för ...",
  "price": 5.00,
  "qty": 25,
  "categories": ["Kategori 1", "Kategori 2"],
  "image_path": "mva20d_ubv_3.png"
}

Översikt över huvudsakliga steg vid import

• registrering av själva produkten
• koppling mellan produkten och webbplatsen
• grundläggande produktattribut (EAV)
• lagerdata (antal produkter i lager)
• media (bilder)
• kopplingar till katalogkategorier

Registrering av produkt

Grundläggande information om produkten finns i catalog_product_entity:

SKAPA TABELL `catalog_product_entity` (
  `entity_id` int(10) unsigned NOT NULL AUTO_INCREMENT KOMMENTAR 'Entity Id',
  `attribute_set_id` smallint(5) unsigned NOT NULL STANDARD '0' KOMMENTAR 'Attributuppsättning ID',
  `type_id` varchar(32) NOT NULL STANDARD 'simple' KOMMENTAR 'Typ ID',
  `sku` varchar(64) STANDARD NULL KOMMENTAR 'SKU',
  `has_options` smallint(6) NOT NULL STANDARD '0' KOMMENTAR 'Har alternativ',
  `required_options` smallint(5) unsigned NOT NULL STANDARD '0' KOMMENTAR 'Obligatoriska alternativ',
  `created_at` timestamp NOT NULL STANDARD CURRENT_TIMESTAMP KOMMENTAR 'Skapelsestid',
  `updated_at` timestamp NOT NULL STANDARD CURRENT_TIMESTAMP VID UPPDATERING CURRENT_TIMESTAMP KOMMENTAR 'Uppdateringstid',
  PRIMARY KEY (`entity_id`),
  KEY `CATALOG_PRODUCT_ENTITY_ATTRIBUTE_SET_ID` (`attribute_set_id`),
  KEY `CATALOG_PRODUCT_ENTITY_SKU` (`sku`)
)

Minimalt nödvändig information för att skapa en post i produktregistret:

• attributset_id
• sku

extra:

• typ_id — om vi inte anger det, kommer 'simple' att användas

För direktinspelning till databasen använder jag Magento:s DB-adapter:

function create($sku, $typeId, $attrSetId)
{
    \/** @var MagentoFrameworkAppResourceConnection $this->resource *\/ 
    \/** @var MagentoFrameworkDBAdapterPdoMysql $conn *\/ 
    $conn = $this->resource->getConnection();
    $table = $this->resource->getTableName('catalog_product_entity');
    $bind = [
        'sku' => $sku,
        'type_id' => $typeId,
        'attribute_set_id' => $attrSetId
    ];
    $conn->insert($table, $bind);
    $result = $conn->lastInsertId($table);
    return $result;
}

Efter registrering av produkten i catalog_product_entity blir den synlig i adminpanelen, i produktgridden (Katalog / Produkter).

Produktens koppling till webbplatsen

Produktens koppling till webbplatsen bestämmer i vilka butiker och på vilka fönster produkten kommer att vara tillgänglig på fronten.

function linkToWebsite($prodId, $websiteId)
{
    \/** @var MagentoFrameworkAppResourceConnection $this->resource *\/ 
    \/** @var MagentoFrameworkDBAdapterPdoMysql $conn *\/ 
    $conn = $this->resource->getConnection();
    $table = $this->resource->getTableName('catalog_product_website');
    $bind = [
        'product_id' => $prodId,
        'website_id' => $websiteId
    ];
    $conn->insert($table, $bind);
}

Grundläggande produktattribut

En nyligen registrerad produkt har ännu inget namn eller beskrivning. Detta görs via EAV-attribut. Här är en lista över grundläggande produktattribut som behövs för att produkten ska visas korrekt på fronten:

• name
• price
• description
• kort_beskrivning
• status
• skatteklass_id
• url_nyckel
• synlighet

Ett separat attribut läggs till produkten så här (detaljer om att hämta ID och typ av attribut via dess kod är utelämnade):

public function create($prodId, $attrCode, $attrValue)
{
    $attrId = \/** hämta attribut-ID med attributkod *\/ 
    $attrType = \/** hämta attributtyp [datetime|decimal|int|text|varchar] med attributkod *\/ 
    if ($attrId) {
        \/** @var MagentoFrameworkAppResourceConnection $this->resource *\/ 
        \/** @var MagentoFrameworkDBAdapterPdoMysql $conn *\/ 
        $conn = $this->resource->getConnection();
        $tblName = 'catalog_product_entity_' . $attrType;
        $table = $this->resource->getTableName($tblName);
        $bind = [
            'attribute_id' => $attrId,
            'entity_id' => $prodId,
            \/** sätt alla attribut till standardbutiksvisning med id=0 (admin) *\/ 
            'store_id' => 0,
            'value' => $attrValue
        ];
        $conn->insert($table, $bind);
    }
}

Genom attributkoden bestämmer vi dess id och datatyp (datetime, decimal, int, text, varchar), sedan skriver vi data till motsvarande tabell för den administrativa butiken (store_id = 0).

Efter att ha lagt till de ovan nämnda attributen till produkten ser vi en sådan bild i adminpanelen:

Lagerdata

Från och med version 2.3 i Magento finns två uppsättningar tabeller parallellt som lagrar lagerinformation (produkternas mängd):

• kataloglager_*: gammal struktur;
• lager_*: ny struktur (MSI — Multi Source Inventory);

Inventardata måste läggas till i båda strukturerna eftersom den nya strukturen ännu inte är helt oberoende av den gamla (det verkar mycket troligt att för default lagret i den nya strukturen används tabellen cataloginventory_stock_status som inventory_stock_1).

cataloginventory_

Vid utplacering av Magneto 2.3 har vi initialt 2 poster i store_website, vilket motsvarar två webbplatser — en administrativ och en huvudkundsida:

website_id|code |name        |sort_order|default_group_id|is_default|
----------|-----|------------|----------|----------------|----------|
         0|admin|Admin       |         0|               0|         0|
         1|base |Huvudwebbsite|         0|               1|         1|

I tabellen cataloginventory_stock har vi bara en post:

stock_id|website_id|stock_name|
--------|----------|----------|
       1|         0|Standard   |

Det vill säga, vi har i den gamla strukturen endast ett "lager" (stock) och det är kopplat till den administrativa webbplatsen. Tillägg via adminpanelen av nya utgångar/stocks i MSI (den nya strukturen) resulterar inte i nya poster i cataloginventory_stock.

Inventardata om produkter i den gamla strukturen skrivs initialt in i tabellerna:

• cataloginventory_stock_item
• cataloginventory_stock_status

cataloginventory_stock_item

function createOldItem($prodId, $qty)
{
    $isQtyDecimal = (((int)$qty) != $qty);
    $isInStock = ($qty > 0);
    
    /** @var MagentoFrameworkAppResourceConnection $this->resource */
    /** @var MagentoFrameworkDBAdapterPdoMysql $conn */
    $conn = $this->resource->getConnection();
    $table = $this->resource->getTableName('cataloginventory_stock_item');
    $bind = [
        'product_id' => $prodId,
        /* vi använder bara en stock i 'cataloginventory' strukturen som standard */
        'stock_id' => 1,
        'qty' => $qty,
        'is_qty_decimal' => $isQtyDecimal,
        'is_in_stock' => $isInStock,
        /* standardlagret är kopplat till admin webbplats (se `cataloginventory_stock`) */
        'website_id' => 0
    ];
    $conn->insert($table, $bind);
}

cataloginventory_stock_status

function createOldStatus($prodId, $qty)
{
    $isInStock = ($qty > 0);
    
    /** @var MagentoFrameworkAppResourceConnection $this->resource */
    /** @var MagentoFrameworkDBAdapterPdoMysql $conn */
    $conn = $this->resource->getConnection();
    $table = $this->resource->getTableName('cataloginventory_stock_status');
    $bind = [
        'product_id' => $prodId,
        /* vi använder bara en stock i 'cataloginventory' strukturen som standard */
        'stock_id' => 1, 
        'qty' => $qty,
        'stock_status' => MagentoCatalogInventoryApiDataStockStatusInterface::STATUS_IN_STOCK,
        /* standardlagret är kopplat till admin webbplats (se `cataloginventory_stock`) */
        'website_id' => 0 
    ];
    $conn->insert($table, $bind);
}

inventory_

Den nya strukturen för lagring av inventardata innehåller initialt 1 "ClickHouse-Ninja/Proton» (inventory_source):

source_code|name          |enabled|description   |latitude|longitude|country_id|...|
-----------|--------------|-------|--------------|--------|---------|----------|...|
default    |Standard Källa|      1|Standard Källa|0.000000| 0.000000|SE        |...|

och en "lager» (inventory_stock):

stock_id|name         |
--------|-------------|
       1|Standard Lager|

«Källa» är ett fysiskt lager för produkter (posten innehåller fysiska koordinater och en postadress). «Lager» är en logisk sammanslagning av flera «källor» (inventory_source_stock_link)

link_id|stock_id|source_code|priority|
-------|--------|-----------|--------|
      1|       1|default    |       1|

på vilken nivå som bindningen till försäljningskanalen sker (inventory_stock_sales_channel)

type   |code|stock_id|
-------|----|--------|
website|base|       1|

Utifrån datans struktur förutses det olika typer av försäljningskanaler, men som standard används endast kopplingen «stock«-«website» (länken till webbplatsen går genom webbplatsens kod — base).

En «lager» kan bindas till flera «källor«, och en «ClickHouse-Ninja/Proton» — till flera «lager» (förhållandet «många till många»). Undantag utgör de default-källor «ClickHouse-Ninja/Proton" och "lager«. De ombindas inte till andra enheter (en begränsning på kodnivå — ett fel uppstår: «Kan inte spara länk kopplad till standardkälla eller standardlager «). Mer information om MSI-strukturen i Magento 2 kan läsas i artikeln «Lagarsystem med användning av CQRS och Event Sourcing. DesignJag kommer att använda standardkonfigurationen och lägga till all lagerinformation i källan«.

, som används i försäljningskanalen kopplad till webbplatsen med koden default(motsvarar kunddelen av butiken — se. base function createNewItem($sku, $qty) { \/** @var MagentoFrameworkAppResourceConnection $this->resource *\/ \/** @var MagentoFrameworkDBAdapterPdoMysql $conn *\/ $conn = $this->resource->getConnection(); $table = $this->resource->getTableName('inventory_source_item'); $bind = [ 'source_code' => 'default', 'sku' => $sku, 'quantity' => $qty, 'status' => MagentoInventoryApiApiDataSourceItemInterface::STATUS_IN_STOCK ]; $conn->insert($table, $bind); } store_website):

Efter att ha lagt till lagerdata till produkten i adminpanelen får man en sådan bild:

Vid «manuell» tilläggning av bilder till produkten via adminpanelen skrivs den motsvarande informationen i följande tabeller:

Som regel skiljer sig mediastöd för produkten för kunden i butiken (e-handel) från mediastödet för samma produkt för anställda i det interna redovisningssystemet (ERP). I det första fallet är det önskvärt att visa "produkten frontal", i det andra fallet räcker det med att ge en allmän översikt över produkten. Trots detta är överföringen av åtminstone den primära bilden av produkten ganska vanlig

catalog_product_entity_media_gallery

• : medieregister (bilder och videofiler);catalog_product_entity_media_gallery_value
• : koppling av media till produkter och butiker (lokalisering);catalog_product_entity_media_gallery_value_to_entity
• : koppling av media endast till produkter (troligen, standard mediainnehåll för produkten);: här lagras roller där bilden används;
• catalog_product_entity_varcharoch själva bilderna lagras i katalogen

.\/pub\/media\/catalog\/product\/x\/y\/ — de första och andra bokstäverna av filnamnet på bilden. Till exempel, filen, där x och y ska sparas som image.png должен быть сохранён как ./pub/media/catalog/product/i/m/image.png, så att plattformen kan använda den som ett bildalternativ vid beskrivning av produkter i katalogen.

: medieregister (bilder och videofiler);

Registrerar den som är placerad i .\/pub\/media\/catalog\/product\/ mediafil (själva processen för att placera filen i denna artikel beaktas inte):

function createMediaGallery($imgPathPrefixed)
{
    $attrId = \/* hämta attribut-ID genom attributkod 'media_gallery' *\/\n    \/** @var MagentoFrameworkAppResourceConnection $this->resource *\/\n    \/** @var MagentoFrameworkDBAdapterPdoMysql $conn *\/\n    $conn = $this->resource->getConnection();\n    $table = $this->resource->getTableName('catalog_product_entity_media_gallery');\n    $bind = [\n        'attribute_id' => $attrId,\n        'value' => $imgPathPrefixed,\n        \/* 'image' eller 'video' *\/\n        'media_type' => 'image',\n        'disabled' => false\n    ];\n    $conn->insert($table, $bind);\n    $result = $conn->lastInsertId($table);\n    return $result;\n}

Vid registreringen får den nya mediafilen ett identifieringsnummer.

: koppling av media till produkter och butiker (lokalisering);

Kopplar den registrerade mediafilen med den motsvarande produkten för standardbutiken:

function createGalleryValue($mediaId, $prodId)
{
    \/** @var MagentoFrameworkAppResourceConnection $this->resource *\/\n    \/** @var MagentoFrameworkDBAdapterPdoMysql $conn *\/\n    $conn = $this->resource->getConnection();\n    $table = $this->resource->getTableName('catalog_product_entity_media_gallery_value');\n    $bind = [\n        'value_id' => $mediaId,\n        \/* använd adminbutiksvy som standard *\/\n        'store_id' => 0,\n        'entity_id' => $prodId,\n        'label' => null,\n        \/* vi har bara en bild *\/\n        'position' => 1,\n        'disabled' => false\n    ];\n    $conn->insert($table, $bind);\n}

: koppling av media endast till produkter (troligen, standard mediainnehåll för produkten);

Kopplar den registrerade mediafilen med den motsvarande produkten utan bindning till någon butik. Det är oklart var dessa data används och varför man inte kan referera till data från den föregående tabellen, men den här tabellen finns och data skrivs in i den när en bild läggs till produkten. Så här är det.

function createGalleryValueToEntity($mediaId, $prodId)
{
    \/** @var MagentoFrameworkAppResourceConnection $this->resource *\/\n    \/** @var MagentoFrameworkDBAdapterPdoMysql $conn *\/\n    $conn = $this->resource->getConnection();\n    $table = $this->resource->getTableName('catalog_product_entity_media_gallery_value_to_entity');\n    $bind = [\n        'value_id' => $mediaId,\n        'entity_id' => $prodId\n    ];\n    $conn->insert($table, $bind);\n}

catalog_product_entity_varchar

Mediafilen kan användas med olika roller (koden för motsvarande attribut anges inom parentes):

• Bas (bild)
• Liten bild (thumbnail)
• Thumbnail (swatch_image)
• Swatch-bild (Av någon anledning kopplas media endast efter att produkten har sparats prelimärt och hämtats från repot på nytt. Och man måste ange attributet)

Rollbindningarna för mediafilen sker just i catalog_product_entity_varchar. Koden för bindningen är liknande koden i avsnittet «Grundläggande produktattribut«.

Efter att ha lagt till en bild till produkten i adminpanelen ser det ut så här:

Kategorier

De huvudsakliga tabellerna som innehåller kategoridata:

• catalog_category_entity: register över kategorier;
• catalog_category_product: koppling mellan produkter och kategorier;
• catalog_category_entity_*: värden för EAV-attribut;

Inledningsvis, i en tom Magento-applikation i kategoriens register finns det 2 kategorier (jag har förkortat kolumntitlarna: crt — created_at, uppdatering — updated_at):

entity_id|attribute_set_id|parent_id|crt|upd|path|position|level|children_count|
---------|----------------|---------|---|---|----|--------|-----|--------------|
        1|               3|        0|...|...|1   |       0|    0|             1|
        2|               3|        1|...|...|1\/2 |       1|    1|             0|

Kategori med id=1 är roten till hela Magento-katalogen och är inte tillgänglig varken i adminpanel eller på fronten. Kategori med id=2 (Standardkategori) är rotkategorin för huvudbutiken på huvudwebbplatsen (Main Website Store), som skapas vid distributionen av applikationen (se. Admin / Stores / All Stores). Observera att den rotkategorin för butiken också är otillgänglig på fronten, endast dess underkategorier är tillgängliga.

Eftersom temat för denna artikel ändå är import av produktdata, kommer jag inte att använda direkt skrivning till databasen vid skapandet av kategorier, utan jag kommer att använda klasserna som tillhandahålls av Magento (modeller och repository). Direkt skrivning till databasen används endast för att koppla den importerade produkten med kategorin (kopplingen av kategorin görs baserat på dess namn, id för kategorin hämtas vid kopplingen):

function create($prodId, $catId)
{
    \/** @var MagentoFrameworkAppResourceConnection $this->resource *\/ 
    \/** @var MagentoFrameworkDBAdapterPdoMysql $conn *\/ 
    $conn = $this->resource->getConnection();
    $table = $this->resource->getTableName('catalog_category_product');
    $bind = [
        'category_id' => $catId,
        'product_id' => $prodId,
    ];
    $conn->insert($table, $bind);
}

Efter att ha lagt till kopplingen av produkten med kategorierna "Kategori 1" och "Kategori 2" ser produktens detaljer i adminpanelen ungefär ut så här:

Ytterligare åtgärder

Efter att importen av data har slutförts måste följande ytterligare åtgärder vidtas:

• indexering av data: anrop i terminalen .\/bin\/magento indexer:reindex;
• återgenerering av URL:er för produkter\/kategorier: kan använda tillägget "elgentos\/regenerate-catalog-urls«

Produkter i adminpanelen efter att ytterligare åtgärder har utförts:

och på fronten:

Sammanfattning

Det samma setet av produkter (10 stycken), som i den föregående artikeln, importeras åtminstone en ordning snabbare (1 sekund mot 10). För en mer exakt bedömning av hastigheten behövs fler produkter — flera hundra, helst tusentals. Ändå, även med en sådan liten storlek på indatadatan kan man dra slutsatsen att användningen av verktygen som tillhandahålls av Magento (modeller och repository) påtagligt (jag understryker — påtagligt!) snabbar utvecklingen av den nödvändiga funktionaliteten, men samtidigt (jag betonar — påtagligt!) sänker hastigheten för datainmatning i databasen.

Resultatet var att vatten var blött och det är ingen nyhet. Ändå har jag nu koden för att experimentera vidare och kanske göra mer intressanta slutsatser.

Källa: habr.com