🥇Magento 2: Produkte aus externen Quellen importieren

Magento ist eine E-Commerce-Lösung, d.h. sie ist stärker auf den Verkauf von Produkten ausgerichtet als auf die damit verbundenen Lager-, Logistik- oder Finanzbuchhaltungsaufgaben. Für letztere sind andere Anwendungen (wie zum Beispiel ERP-Systeme) besser geeignet. Daher besteht in der Praxis häufig die Notwendigkeit, Magento mit diesen anderen Systemen (z.B. mit 1C) zu integrieren.

Im Großen und Ganzen kann die Integration auf die Datenreplikation reduziert werden:

Katalog (Produkte, Kategorien);
Bestandsdaten (Produktbestände und Preise);
Kunden;
Bestellungen;

Magento bietet zur Manipulation von Daten in der Datenbank eine separate Objektklasse an — das Repository. Aufgrund der speziellen Natur von Magento ist das Hinzufügen von Daten zur Datenbank über Repositories leicht zu codieren, geschieht aber, sagen wir mal, nicht schnell. In diesem Artikel betrachte ich die Hauptphasen des programmatischen Hinzufügens eines Produkts zu Magento 2 auf die "klassische" Weise — unter Verwendung von Repo-Klassen.

Kunden und Bestellungen werden normalerweise in die andere Richtung repliziert — von Magento in externe ERP-Systeme. Daher ist es damit einfacher, auf der Seite von Magento müssen einfach die entsprechenden Daten ausgewählt werden, und dann — "von unserer Seite sind die Kugeln geflogen«.

Prinzipien der Dateneinschreibung in die Datenbank

Momentan erfolgt das Erstellen von speicherbaren Objekten in der Datenbank programmatisch in Magento über Factory:

function __construct (MagentoCmsModelBlockFactory $blockFactory) {
    $this->blockFactory = $blockFactory;
}

/** @var MagentoCmsModelBlock $block * /
$block = $this->blockFactory->create();

und die Einspeisung in die Datenbank erfolgt über Repository:

function __construct (MagentoCmsApiBlockRepositoryInterface $blockRepo) {
    $this->blockRepo = $blockRepo;
}

$this->blockRepo->save($block);

Der Ansatz mit "Factory" und "Repository" kann für alle grundlegenden Modelle im Anwendungsbereich von Magento 2 verwendet werden.

Basisinformationen über das Produkt

Ich betrachte die Datenstruktur, die der Version Magento 2.3 entspricht. Die grundlegendsten Informationen über das Produkt befinden sich in der Tabelle catalog_product_entity (Produktenregister):

entity_id
attribute_set_id
type_id
sku
has_options
required_options
created_at
updated_at

Ich beschränke mich auf einen Produkttyp (type_id='simple'), einem Satz von Standardattributen (attribute_set_id=4) und ignoriere die Attribute has_options und required_options. Da die Attribute entity_id, created_at und updated_at automatisch generiert werden, benötigen wir im Grunde nur die Angabe von sku. Ich mache es so:

/** @var MagentoCatalogApiDataProductInterfaceFactory $factProd */
/** @var MagentoCatalogApiProductRepositoryInterface $repoProd */
/** @var MagentoCatalogApiDataProductInterface $prod */
$prod = $factProd->create();
$prod->setAttributeSetId(4);
$prod->setTypeId('simple');
$prod->setSku($sku);
$repoProd->save($prod);

und erhalte eine Ausnahme:

Der Wert des Attributs "Produktname" ist leer. Setzen Sie das Attribut und versuchen Sie es erneut.

Ich füge den Produktnamen in die Anfrage ein und erhalte die Meldung, dass das Attribut fehlt. Preis. Nach Hinzufügen des Preises wird das Produkt in die Datenbank aufgenommen:

$prod = $factProd->create();
$prod->setAttributeSetId(4);
$prod->setTypeId('simple');
$prod->setSku($sku);
$prod->setName($name);
$prod->setPrice($price);
$repoProd->save($prod);

Der Produktname wird in der Tabelle der varchar-Attribute des Produkts gespeichert (catalog_product_entity_varchar), der Preis in der Tabelle catalog_product_entity_decimal. Vor dem Hinzufügen des Produkts ist es ratsam, ausdrücklich festzulegen, dass wir das Admin-Frontend zum Importieren von Daten verwenden:

/** @var MagentoStoreModelStoreManagerInterface $manStore */
$manStore->setCurrentStore(0);

Zusätzliche Attribute

Die Bearbeitung zusätzlicher Produktattribute in Magento ist eine Freude. Das EAV-Datenmodell für die wichtigsten Entitäten (siehe Tabelle eav_entity_type) ist eines der Schlüsselfeatures dieser Plattform. Fügen Sie einfach die entsprechenden Attribute zum Produktmodell hinzu:

$prodEntity->setData('description', $desc);
$prodEntity->setData('short_description', $desc_short);
// oder
$prodEntity->setDescription($desc);
$prodEntity->setShortDescription($desc_short);

und beim Speichern des Modells über das Repo-Objekt:

$repoProd->save($prod);

werden die zusätzlichen Attribute ebenfalls in den entsprechenden Datenbanktabellen gespeichert.

Inventardaten

Einfach gesagt, die Menge des Produkts auf Lager. In Magento 2.3 unterscheiden sich die Strukturen in der Datenbank, die das Format der Lagerdatenspeicherung beschreiben, deutlich von den vorherigen. Dennoch ist das Hinzufügen der Menge des Produkts auf Lager über das Produktmodell nicht viel komplizierter als das Hinzufügen anderer Attribute:

/** @var MagentoCatalogModelProduct $prodEntity */
/** @var MagentoCatalogApiProductRepositoryInterface $repoProd */
$inventory = [
    'is_in_stock' => true,
    'qty' => 1234
];
$prodEntity->setData('quantity_and_stock_status', $inventory);
$repoProd->save($prodEntity);

Medien

In der Regel unterscheidet sich die Medienpräsentation des Produkts für den Kunden im Online-Shop (E-Commerce) von der Medienpräsentation desselben Produkts für den Mitarbeiter im internen ERP-System. Im ersten Fall ist es wünschenswert, das „Produkt im besten Licht“ zu zeigen, im zweiten Fall reicht es aus, einen allgemeinen Überblick über das Produkt zu geben. Dennoch ist der Transfer auch nur eines Primärbildes des Produkts ein recht gängiger Fall beim Import von Daten.

Beim Hinzufügen eines Bildes über das Admin-Panel wird das Bild zunächst im temporären Verzeichnis (./pub/media/tmp/catalog/product) gespeichert und wird erst beim Speichern des Produkts in das Medienverzeichnis (./pub/media/catalog/product) verschoben. Auch beim Hinzufügen über das Admin-Panel werden dem Bild die Tags Image, small_image, thumbnail, swatch_image.

/** @var MagentoCatalogApiProductRepositoryInterface $repoProd */
/** @var MagentoCatalogModelProductGalleryCreateHandler $hndlGalleryCreate */
/* $imagePath = '/path/to/file.png';  $imagePathRelative = '/f/i/file.png' */
$imagePathRelative = $this->imagePlaceToTmpMedia($imagePath);
/* reload product with gallery data */
$product = $repoProd->get($sku);
/* add image to product's gallery */
$gallery['images'][] = [
    'file' => $imagePathRelative,
    'media_type' => 'image'
    'label' => ''
];
$product->setData('media_gallery', $gallery);
/* set usage areas */
$product->setData('image', $imagePathRelative);
$product->setData('small_image', $imagePathRelative);
$product->setData('thumbnail', $imagePathRelative);
$product->setData('swatch_image', $imagePathRelative);
/* create product's gallery */
$hndlGalleryCreate->execute($product);

Aus irgendeinem Grund hängt das Medium nur nach dem vorherigen Speichern des Produkts und dem erneuten Abrufen aus dem Repository. Und der Attribut muss angegeben werden label beim Hinzufügen eines Eintrags zur Mediengalerie des Produkts (sonst erhalten wir eine Ausnahme Undefined index: label in .../module-catalog/Model/Product/Gallery/CreateHandler.php in Zeile 516).

Kategorien

Oft kann die Struktur der Kategorien des Shops und der Backend-Anwendungen oder deren Produktplatzierung erheblich variieren. Die Strategien zur Übertragung von Daten über Kategorien und Produkte darin hängen von vielen Faktoren ab. In diesem Beispiel halte ich mich an Folgendes:

Die Kategorien des Backends und des Shops werden anhand des Namens zugeordnet;
wenn eine Kategorie importiert wird, die im Shop nicht vorhanden ist, wird sie unter der Wurzelkategorie (Default Category) erstellt, und ihre weitere Positionierung im Katalog des Shops erfolgt manuell;
Die Zuordnung des Produkts zu einer Kategorie erfolgt nur bei seiner Erstellung im Shop (erstem Import);

Die Hauptinformationen zur Kategorie befinden sich in der Tabelle catalog_category_entity (Katalog der Kategorien). Kategorie in Magento erstellen:

/** @var MagentoCatalogApiDataCategoryInterfaceFactory $factCat */
/** @var MagentoCatalogApiCategoryRepositoryInterface $repoCat */
$cat = $factCat->create();
$cat->setName($name);
$cat->setIsActive(true);
$repoCat->save($cat);

Die Zuordnung des Produkts zur Kategorie erfolgt über die ID der Kategorie und die SKU des Produkts:

/** @var MagentoCatalogModelCategoryProductLinkFactory $factCatProdLink */
/** @var MagentoCatalogApiCategoryLinkRepositoryInterface $repoCatLink */
$link = $factCatProdLink->create();
$link->setCategoryId($catMageId);
$link->setSku($prodSku);
$repoCatLink->save($link);

Insgesamt

Es ist nicht sehr schwierig, Code zum programmgesteuerten Hinzufügen eines Produkts zu Magento 2 zu schreiben. Alles, was ich bisher gesagt habe, habe ich in ein Demomodul "flancer32/mage2_ext_demo_import" zusammengefasst. Im Modul gibt es nur einen Konsolenbefehl fl32:import:prod, der Produkte importiert, die in der JSON-Datei "./etc/data/products.json«:

[
  {
    "sku": "...",
    "name": "...",
    "desc": "...",
    "desc_short": "...",
    "price": ...,
    "qty": ...,
    "categories": ["..."],
    "image_path": "..."
  }
]

Die Bilder für den Import befinden sich im Katalog ./etc/data/img.

Die Importzeit für 10 Produkte auf diese Weise beträgt ungefähr 10 Sekunden auf meinem Laptop. Wenn man diesen Gedanken weiterführt, ist es nicht schwer zu erkennen, dass man pro Stunde etwa 3600 Produkte importieren kann, und der Import von 100.000 Produkten könnte etwa 30 Stunden dauern. Der Austausch des Laptops gegen einen Server kann die Situation etwas entschärfen. Vielleicht sogar um ein Vielfaches. Aber nicht in Größenordnungen. Möglicherweise ist diese langsame Geschwindigkeit teilweise einer der Gründe für das Entstehen des Projekts magento/async-import.

Eine grundlegende Lösung zur Erhöhung der Importgeschwindigkeit könnte die direkte Speicherung in die Datenbank sein, jedoch gehen in diesem Fall alle «Vorteile» der Erweiterbarkeit von Magento verloren – alles, was «erweitert» werden muss, müsste man selbst umsetzen. Dennoch lohnt es sich. Wenn es gelingt, werde ich in dem nächsten Artikel den Ansatz mit der direkten Datenbankspeicherung in Betracht ziehen.

Quelle: habr.com