Magento 2: Importera produkter från externa källor

Magento är en e-handelslösning, vilket innebär att den är mer inriktad på att sälja produkter än på relaterad lagring, logistik eller finansiell redovisning. För detta ändamål passar andra applikationer (t.ex. ERP-system) bättre. Därför uppstår det ganska ofta i praktisk användning av Magento behov av att integrera butiken med dessa andra system (t.ex. med 1C).

Generellt kan integrationen sammanfattas som replikering av data för:

• katalogen (produkter, kategorier);
• lagerdata (produkters lagernivåer och priser);
• kunder;
• beställningar;

Magento erbjuder en speciell klass av objekt för att manipulera data i databasen — förrådet. På grund av Magento-specifikationen är tillägg av data i databasen via repositories lätt att koda, men sker inte direkt. I denna publikation kommer jag att gå igenom de huvudsakliga stegen för programmatisk tillägg av produkten i Magento 2 på det "klassiska" sättet — med hjälp av repo-klasser.

Kunder och beställningar replikeras vanligtvis åt andra hållet — från Magento till externa ERP-system. Därför är det enklare, på Magento-sidan behöver man bara välja de lämpliga uppgifterna, och sedan — "från vår sida flög kulorna ut«.

Principer för att skriva data till databasen

För närvarande skapas objekt som lagras i databasen programmatiskt i Magento via Factory:

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

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

och att skriva till databasen — via Repository:

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

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

Tillvägagångssättet med användning av "Factory" och "Repository" kan användas för alla huvudsakliga modeller inom Magento 2:s ämnesområde.

Grundläggande produktinformation

Jag analyserar datakonstruktionen som motsvarar versionen Magento 2.3. Den mest grundläggande informationen om produkten finns i tabellen catalog_product_entity (produktenhet):

entity_id
attribute_set_id
type_id
sku
has_options
required_options
created_at
updated_at

Jag begränsar mig till en produktkategori (type_id='simple'), en uppsättning standardattribut (attribute_set_id=4) och ignorerar attributen has_options och required_optionsEftersom attributen entity_id, created_at och updated_at genereras automatiskt, är det i princip tillräckligt för oss att ange sku. Jag gör så här:

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

och får ett undantag:

Attributvärdet för "Produktnamn" är tomt. Ställ in attributet och försök igen.

Jag lägger till produktnamnet i begäran och får ett meddelande om att det saknas en attribut. Pris. Efter att ha lagt till priset sparas produkten i databasen:

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

Produktens namn sparas i tabellen för varchar-attribut (catalog_product_entity_varchar), priset sparas i tabellen catalog_product_entity_decimal. Innan produkten läggs till är det bra att tydligt ange att vi använder den administrativa vy:n för att importera data:

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

Ytterligare attribut

Att behandla ytterligare produktattribut med hjälp av Magento är ett nöje. EAV-datamodellen för huvudentiteter (se tabell eav_entity_type) är en av de nyckelfunktioner som denna plattform har. Vi lägger helt enkelt till de relevanta attributen till produktmodellen:

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

och vid sparande av modellen via repo-objektet:

$repoProd->save($prod);

kommer de ytterligare attributen även att sparas i motsvarande databastabeller.

Lagerdata

Enkelt uttryckt — mängden av produkten i lagret. I Magento 2.3 skiljer sig strukturerna i databasen som beskriver lagring av lagerdata signifikant från vad som fanns tidigare. Trots det är det inte mycket svårare att lägga till produktmängden i lagret via produktmodellen än att lägga till andra attribut: Media

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

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

fall vid datainport. När en bild läggs till via adminpanelen sparas bilden först i en tillfällig katalog (

./pub/media/tmp/catalog/product) och flyttas först till mediakatalogen (./pub/media/catalog/product) när produkten sparas. Också när man lägger till via adminpanelen tilldelas bilden taggarsmall_image bild, thumbnail, swatch_image, 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.

/** @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);

Почему-то медиа подвязывается только после предварительного сохранения продукта и получения его из репозитория заново. И нужно указывать атрибут label vid skapandet av en post i produktens mediegalleri (annars får vi ett undantag Odefinierad index: label i .../modul-katalog/Model/Product/Gallery/CreateHandler.php på rad 516).

Kategorier

Strukturen för butikens kategorier och backend-applikationen eller placeringen av produkterna kan ofta variera betydligt. Strategier för att överföra data om kategorier och produkter beror på många faktorer. I det här exemplet följer jag följande:

• kategorier i backend och butik motsvarar varandra efter namn;
• om en kategori importeras som inte finns i butiken skapas den under roten av kategorin (Standardkategori) och dess framtida positionering i butikens katalog planeras manuellt;
• kopplingen av produkten till kategorin sker endast vid dess skapande i butiken (vid första importen);

Huvudinformationen om kategorin finns i tabellen catalog_category_entity (katalogen över kategorier). Skapande av kategori i Magento:

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

Kopplingen av produkten till kategorin sker via kategori-ID och produktens SKU:

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

Sammanfattningsvis

Att skriva kod för att programatiskt lägga till en produkt i Magento 2 är ganska enkelt. Allt ovan har jag sammanställt i en demomodul "flancer32/mage2_ext_demo_import". Modulen har endast ett konsolkommando fl32:import:prod, som importerar produkter beskrivna i JSON-filen "./etc/data/products.json«:

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

Bilder för importen finns i katalogen ./etc/data/img.

Tiden för att importera 10 produkter på detta sätt är cirka 10 sekunder på min laptop. Om vi utvecklar denna tanke vidare, kan vi enkelt komma fram till att vi kan importera cirka 3600 produkter på en timme, och det kan ta omkring 30 timmar att importera 100K produkter. Att byta ut laptopen mot en server kan lindra situationen något. Kanske till och med i stora drag. Men inte i ordning. Möjligen är denna hastighet särskilt långsam på något sätt en av anledningarna till att projektet magento/async-import.

En radikal lösning för att öka importhastigheten kan vara direktinspelning i databasen, men i så fall förloras alla "fördelar" som rör Magento:s utvidgbarhet - allt "utökat" måste göras själv. Ändå är det värt det. Om möjligheten ges, kommer jag att överväga tillvägagångssättet med direktinspelning i databasen i nästa artikel.

Källa: habr.com