927 lines
33 KiB
PHP
927 lines
33 KiB
PHP
<?php
|
||
// https://pacyga.pl/wp-content/uploads/woo-feed/custom/xml/komplet-produktow-3.xml
|
||
|
||
// Include PrestaShop configuration
|
||
include(dirname(__FILE__).'/config/config.inc.php');
|
||
include(dirname(__FILE__).'/init.php');
|
||
|
||
$context = Context::getContext();
|
||
|
||
// Sprawdzenie trybu działania na podstawie parametrów URL
|
||
$modeAdd = (Tools::getValue('add') === 'true');
|
||
$modeUpdate = (Tools::getValue('update') === 'true');
|
||
$modeSynch = (Tools::getValue('synch') === 'true');
|
||
|
||
if (!$modeAdd && !$modeUpdate && !$modeSynch) {
|
||
die('Brak akcji. Dodaj do adresu ?add=true lub ?update=true lub ?synch=true');
|
||
}
|
||
|
||
// Plik logu aktualizacji cen
|
||
$logFile = __DIR__ . '/update_price_log.csv';
|
||
|
||
// Wczytanie XML
|
||
$xmlUrl = 'https://pacyga.pl/wp-content/uploads/woo-feed/custom/xml/komplet-produktow-3.xml';
|
||
$xml = simplexml_load_file($xmlUrl) or die("Error: Cannot create object");
|
||
|
||
// === FUNKCJE POMOCNICZE ===
|
||
|
||
// Function to find attribute group by name
|
||
function findAttributeGroupByName($name) {
|
||
$id_lang = Context::getContext()->language->id;
|
||
$sql = 'SELECT `id_attribute_group`
|
||
FROM `'._DB_PREFIX_.'attribute_group_lang`
|
||
WHERE `name` = \''.pSQL($name).'\'
|
||
AND `id_lang` = '.(int)$id_lang;
|
||
$result = Db::getInstance()->getRow($sql);
|
||
return $result ? new AttributeGroup($result['id_attribute_group']) : false;
|
||
}
|
||
|
||
// Function to find attribute by name
|
||
function findAttributeByName($id_attribute_group, $name) {
|
||
$id_lang = Context::getContext()->language->id;
|
||
$sql = 'SELECT a.`id_attribute`
|
||
FROM `'._DB_PREFIX_.'attribute` a
|
||
JOIN `'._DB_PREFIX_.'attribute_lang` al
|
||
ON a.`id_attribute` = al.`id_attribute`
|
||
WHERE al.`name` = \''.pSQL($name).'\'
|
||
AND al.`id_lang` = '.(int)$id_lang.'
|
||
AND a.`id_attribute_group` = '.(int)$id_attribute_group;
|
||
$result = Db::getInstance()->getRow($sql);
|
||
return $result ? new Attribute($result['id_attribute']) : false;
|
||
}
|
||
|
||
// Function to create attribute if it doesn't exist
|
||
function createAttribute($name, $values) {
|
||
$attributeGroup = findAttributeGroupByName($name);
|
||
if (!$attributeGroup) {
|
||
$attributeGroup = new AttributeGroup();
|
||
$attributeGroup->name = createMultiLangField($name);
|
||
$attributeGroup->public_name = createMultiLangField($name);
|
||
$attributeGroup->group_type = 'select';
|
||
$attributeGroup->add();
|
||
}
|
||
|
||
foreach ($values as $value) {
|
||
$attribute = findAttributeByName($attributeGroup->id, $value);
|
||
if (!$attribute) {
|
||
$attribute = new Attribute();
|
||
$attribute->id_attribute_group = $attributeGroup->id;
|
||
$attribute->name = createMultiLangField($value);
|
||
$attribute->add();
|
||
}
|
||
}
|
||
|
||
return $attributeGroup->id;
|
||
}
|
||
|
||
// Helper function to create a multi-language field
|
||
function createMultiLangField($field) {
|
||
$languages = Language::getLanguages(false);
|
||
$res = [];
|
||
foreach ($languages as $lang) {
|
||
$res[(int)$lang['id_lang']] = $field;
|
||
}
|
||
return $res;
|
||
}
|
||
|
||
// Helper function to create a valid link_rewrite
|
||
function createLinkRewrite($field) {
|
||
$languages = Language::getLanguages(false);
|
||
$res = [];
|
||
$linkRewrite = Tools::link_rewrite($field); // PrestaShop's function to create valid link_rewrite
|
||
foreach ($languages as $lang) {
|
||
$res[(int)$lang['id_lang']] = $linkRewrite;
|
||
}
|
||
return $res;
|
||
}
|
||
|
||
// Function to get category ID from name (nieużywana, ale poprawiona)
|
||
function getCategoryId($categoryName) {
|
||
$result = Category::searchByName(1, $categoryName); // 1 for default language id
|
||
if (!empty($result) && isset($result[0]['id_category'])) {
|
||
return (int)$result[0]['id_category'];
|
||
} else {
|
||
// Create category if not exists
|
||
$category = new Category();
|
||
$category->name = createMultiLangField($categoryName);
|
||
$category->link_rewrite = createLinkRewrite($categoryName);
|
||
$category->id_parent = 2; // Default parent category
|
||
$category->add();
|
||
return (int)$category->id;
|
||
}
|
||
}
|
||
|
||
function getAllImageUrlsFromXmlProduct($productData, $max = 10)
|
||
{
|
||
$urls = [];
|
||
|
||
// główne <image>
|
||
if (!empty($productData->image)) {
|
||
$urls[] = trim((string)$productData->image);
|
||
}
|
||
|
||
// images_1..10 oraz Images_1..10 (różna wielkość liter w XML!)
|
||
for ($i = 1; $i <= $max; $i++) {
|
||
$k1 = 'images_' . $i;
|
||
$k2 = 'Images_' . $i;
|
||
|
||
$u1 = isset($productData->{$k1}) ? trim((string)$productData->{$k1}) : '';
|
||
$u2 = isset($productData->{$k2}) ? trim((string)$productData->{$k2}) : '';
|
||
|
||
if ($u1 !== '') $urls[] = $u1;
|
||
if ($u2 !== '') $urls[] = $u2;
|
||
}
|
||
|
||
// usuń duplikaty + puste
|
||
$urls = array_values(array_unique(array_filter($urls)));
|
||
|
||
return $urls;
|
||
}
|
||
|
||
|
||
// Function to download image from URL and associate it with a product
|
||
function addProductImage($productId, $imageUrl, $isCover = false)
|
||
{
|
||
$image = new Image();
|
||
$image->id_product = (int)$productId;
|
||
$image->position = Image::getHighestPosition($productId) + 1;
|
||
$image->cover = (bool)$isCover; // tylko pierwsze jako cover
|
||
$image->add();
|
||
|
||
$imagePath = $image->getPathForCreation();
|
||
|
||
// pobranie pliku
|
||
$url = str_replace(' ', '%20', trim($imageUrl));
|
||
|
||
// UWAGA: copy() czasem failuje na HTTPS; file_get_contents + file_put_contents bywa pewniejsze
|
||
$data = @file_get_contents($url);
|
||
if ($data === false) {
|
||
$image->delete();
|
||
return false;
|
||
}
|
||
|
||
if (@file_put_contents($imagePath . '.jpg', $data) === false) {
|
||
$image->delete();
|
||
return false;
|
||
}
|
||
|
||
$imageTypes = ImageType::getImagesTypes('products');
|
||
foreach ($imageTypes as $imageType) {
|
||
ImageManager::resize(
|
||
$imagePath . '.jpg',
|
||
$imagePath . '-' . stripslashes($imageType['name']) . '.jpg',
|
||
(int)$imageType['width'],
|
||
(int)$imageType['height']
|
||
);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
// Function to find product by reference
|
||
function findProductByReference($reference) {
|
||
$sql = 'SELECT `id_product`
|
||
FROM `'._DB_PREFIX_.'product`
|
||
WHERE `reference` = \''.pSQL($reference).'\'';
|
||
$result = Db::getInstance()->getRow($sql);
|
||
return $result ? new Product((int)$result['id_product']) : false;
|
||
}
|
||
|
||
// Function to find combination by product ID and attribute IDs
|
||
function findCombinationByAttributes($id_product, $attributeIds) {
|
||
if (empty($attributeIds)) {
|
||
return false;
|
||
}
|
||
|
||
sort($attributeIds);
|
||
$conditions = [];
|
||
foreach ($attributeIds as $id_attr) {
|
||
$conditions[] = 'pac.`id_attribute` = '.(int)$id_attr;
|
||
}
|
||
|
||
$sql = 'SELECT c.`id_product_attribute`
|
||
FROM `'._DB_PREFIX_.'product_attribute` c
|
||
JOIN `'._DB_PREFIX_.'product_attribute_combination` pac
|
||
ON c.`id_product_attribute` = pac.`id_product_attribute`
|
||
WHERE c.`id_product` = '.(int)$id_product.'
|
||
GROUP BY c.`id_product_attribute`
|
||
HAVING SUM('.implode(' OR ', $conditions).') = '.count($attributeIds);
|
||
|
||
$result = Db::getInstance()->getRow($sql);
|
||
return $result ? new Combination((int)$result['id_product_attribute']) : false;
|
||
}
|
||
|
||
// znajdowanie kombinacji po indeksie/SKU (reference)
|
||
function findCombinationByReference($id_product, $reference) {
|
||
$sql = 'SELECT `id_product_attribute`
|
||
FROM `'._DB_PREFIX_.'product_attribute`
|
||
WHERE `id_product` = '.(int)$id_product.'
|
||
AND `reference` = \''.pSQL($reference).'\'';
|
||
$id = Db::getInstance()->getValue($sql);
|
||
return $id ? new Combination((int)$id) : false;
|
||
}
|
||
|
||
function parsePrice($rawPrice) {
|
||
// Na wszelki wypadek rzutujemy na string i obcinamy spacje
|
||
$rawPrice = trim((string)$rawPrice);
|
||
|
||
if ($rawPrice === '') {
|
||
return 0.0;
|
||
}
|
||
|
||
// Zostawiamy tylko cyfry, przecinek, kropkę i minus
|
||
// Usuwamy walutę, spacje, itp.
|
||
$clean = preg_replace('/[^\d,.\-]/', '', $rawPrice);
|
||
|
||
$hasComma = strpos($clean, ',') !== false;
|
||
$hasDot = strpos($clean, '.') !== false;
|
||
|
||
// Przypadek typowo polski: "1234,56" lub "125,00"
|
||
if ($hasComma && !$hasDot) {
|
||
$clean = str_replace(',', '.', $clean);
|
||
}
|
||
// Przypadek mieszany: "1.234,56" -> usuń kropki (separatory tysięcy), przecinek zamień na kropkę
|
||
elseif ($hasComma && $hasDot) {
|
||
$clean = str_replace('.', '', $clean); // usuwamy separatory tysięcy
|
||
$clean = str_replace(',', '.', $clean); // przecinek na kropkę
|
||
}
|
||
// Jeśli jest tylko kropka ("1234.56") – nic nie zmieniamy
|
||
|
||
return (float)$clean;
|
||
}
|
||
|
||
// Bazowa cena dla grupy – najtańszy wariant (zwraca [brutto, netto])
|
||
function getBasePricesFromGroup($products) {
|
||
$minNet = null;
|
||
$minGross = null;
|
||
|
||
foreach ($products as $p) {
|
||
$gross = parsePrice((string)$p->price);
|
||
if ($gross <= 0) {
|
||
continue;
|
||
}
|
||
$net = Tools::ps_round($gross / 1.23, 6);
|
||
|
||
if ($minNet === null || $net < $minNet) {
|
||
$minNet = $net;
|
||
$minGross = $gross;
|
||
}
|
||
}
|
||
|
||
if ($minNet === null) {
|
||
return [0.0, 0.0];
|
||
}
|
||
|
||
return [$minGross, $minNet];
|
||
}
|
||
|
||
// Czyści log aktualizacji cen - zostawia tylko wpisy z ostatnich X dni
|
||
function cleanUpdateLog($logFile, $daysToKeep = 30) {
|
||
if (!file_exists($logFile)) {
|
||
return;
|
||
}
|
||
|
||
$cutoffDate = date('Y-m-d', strtotime('-'.(int)$daysToKeep.' days'));
|
||
|
||
$lines = file($logFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
|
||
if ($lines === false || empty($lines)) {
|
||
return;
|
||
}
|
||
|
||
$newLines = [];
|
||
foreach ($lines as $line) {
|
||
$parts = explode(';', $line);
|
||
if (count($parts) < 1) {
|
||
// linia uszkodzona – pomijamy
|
||
continue;
|
||
}
|
||
$logDate = trim($parts[0]);
|
||
|
||
// Jeśli data ma format YYYY-MM-DD i jest nowsza/równa cutoff – zostawiamy
|
||
if (preg_match('/^\d{4}-\d{2}-\d{2}$/', $logDate) && $logDate >= $cutoffDate) {
|
||
$newLines[] = $line;
|
||
}
|
||
// Jeśli format daty jest dziwny – na wszelki wypadek zachowajmy wpis
|
||
elseif (!preg_match('/^\d{4}-\d{2}-\d{2}$/', $logDate)) {
|
||
$newLines[] = $line;
|
||
}
|
||
}
|
||
|
||
// Nadpisujemy plik przefiltrowaną zawartością
|
||
if (!empty($newLines)) {
|
||
file_put_contents($logFile, implode(PHP_EOL, $newLines) . PHP_EOL);
|
||
} else {
|
||
// Jeśli wszystko stare/uszkodzone – czyścimy plik
|
||
file_put_contents($logFile, '');
|
||
}
|
||
}
|
||
|
||
// Zwraca id_tax_rules_group dla stawki VAT (np. 23) dla kraju domyślnego
|
||
function getTaxRulesGroupIdForRate($rate, $id_country = null) {
|
||
if ($id_country === null) {
|
||
$id_country = (int)Configuration::get('PS_COUNTRY_DEFAULT');
|
||
}
|
||
|
||
$sql = 'SELECT trg.`id_tax_rules_group`
|
||
FROM `'._DB_PREFIX_.'tax_rules_group` trg
|
||
INNER JOIN `'._DB_PREFIX_.'tax_rule` tr
|
||
ON (trg.`id_tax_rules_group` = tr.`id_tax_rules_group`)
|
||
INNER JOIN `'._DB_PREFIX_.'tax` t
|
||
ON (tr.`id_tax` = t.`id_tax`)
|
||
WHERE trg.`active` = 1
|
||
AND tr.`id_country` = '.(int)$id_country.'
|
||
AND t.`rate` = '.(float)$rate.'
|
||
ORDER BY trg.`id_tax_rules_group` ASC';
|
||
|
||
$id = Db::getInstance()->getValue($sql);
|
||
return $id ? (int)$id : 8;
|
||
}
|
||
|
||
// Zwraca główny produkt z grupy – pierwszy, którego SKU istnieje w PrestaShop
|
||
function findMainProductDataFromGroup($products) {
|
||
foreach ($products as $p) {
|
||
$ref = (string)$p->sku;
|
||
if ($ref !== '' && findProductByReference($ref)) {
|
||
return $p; // to główny produkt
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
|
||
// === GRUPOWANIE PRODUKTÓW PO SYMBOLU ===
|
||
$productsBySymbol = [];
|
||
foreach ($xml->product as $productData) {
|
||
$symbol = (string)$productData->item_group_id;
|
||
if (!isset($productsBySymbol[$symbol])) {
|
||
$productsBySymbol[$symbol] = [];
|
||
}
|
||
$productsBySymbol[$symbol][] = $productData;
|
||
}
|
||
|
||
// ID grupy VAT 23%
|
||
$idTaxRulesGroup23 = 8;
|
||
|
||
// =======================================
|
||
// =========== TRYB AKTUALIZACJI =========
|
||
// =======================================
|
||
if ($modeUpdate) {
|
||
cleanUpdateLog($logFile, 30);
|
||
$today = date('Y-m-d');
|
||
$updatedToday = [];
|
||
|
||
// Wczytanie logu aktualizacji
|
||
if (file_exists($logFile)) {
|
||
$lines = file($logFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
|
||
foreach ($lines as $line) {
|
||
$parts = explode(';', $line);
|
||
if (count($parts) >= 3) {
|
||
$logDate = trim($parts[0]);
|
||
$logType = trim($parts[1]); // np. 'product'
|
||
$logRef = trim($parts[2]);
|
||
if ($logDate === $today) {
|
||
$updatedToday[$logType.'_'.$logRef] = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
$updatedSomething = false;
|
||
|
||
|
||
foreach ($productsBySymbol as $symbol => $products) {
|
||
if (empty($products)) {
|
||
continue;
|
||
}
|
||
|
||
// Główny produkt – referencja z pierwszego elementu grupy
|
||
// $mainProductData = $products[0];
|
||
// $reference = (string)$mainProductData->sku;
|
||
// $key = 'product_'.$reference;
|
||
$mainProductData = findMainProductDataFromGroup($products);
|
||
if (!$mainProductData) {
|
||
continue; // w grupie nie ma produktu, który istnieje w Presta
|
||
}
|
||
$reference = (string)$mainProductData->sku;
|
||
$key = 'product_'.$reference;
|
||
|
||
// Jeśli już zaktualizowany dzisiaj – pomijamy
|
||
if (isset($updatedToday[$key])) {
|
||
continue;
|
||
}
|
||
|
||
$product = findProductByReference($reference);
|
||
if (!$product) {
|
||
// produkt nie istnieje w Presta - pomijamy w trybie update
|
||
continue;
|
||
}
|
||
|
||
// BAZA: najtańszy wariant w grupie (brutto i netto)
|
||
list($grossBase, $netPrice) = getBasePricesFromGroup($products);
|
||
if ($grossBase <= 0 || $netPrice <= 0) {
|
||
// brak sensownej ceny – pomiń
|
||
continue;
|
||
}
|
||
|
||
// Flagi / liczniki
|
||
$updatedProductPrice = false;
|
||
$updatedCombinationCount = 0;
|
||
|
||
// Aktualizacja ceny produktu (NETTO) – baza = najtańszy wariant
|
||
$product->price = $netPrice;
|
||
$updatedProductPrice = true;
|
||
|
||
// Produkt zawsze aktywny + delivery times
|
||
$product->active = 1;
|
||
$product->delivery_in_stock = createMultiLangField('2-7 dni roboczych');
|
||
$product->delivery_out_stock = createMultiLangField('4-10 tygodni');
|
||
|
||
// Upewnij się, że produkt ma ustawioną grupę VAT 23%
|
||
if (!empty($idTaxRulesGroup23) && (int)$product->id_tax_rules_group !== (int)$idTaxRulesGroup23) {
|
||
$product->id_tax_rules_group = (int)$idTaxRulesGroup23;
|
||
}
|
||
|
||
// Sprawdź kategorię domyślną – jeśli "Strona główna", zamień na "Meble" (ID 107)
|
||
$id_lang = (int)$context->language->id;
|
||
$defaultCategory = new Category($product->id_category_default, $id_lang);
|
||
|
||
if (Validate::isLoadedObject($defaultCategory) && $defaultCategory->name == 'Strona główna') {
|
||
$newCategoryId = 107; // Meble
|
||
|
||
// Ustaw nową kategorię domyślną
|
||
$product->id_category_default = (int)$newCategoryId;
|
||
|
||
// Podmień kategorie produktu (zachowując ewentualne inne)
|
||
$categories = $product->getCategories();
|
||
$categories = array_diff($categories, [(int)$defaultCategory->id]);
|
||
$categories[] = (int)$newCategoryId;
|
||
$categories = array_unique(array_map('intval', $categories));
|
||
|
||
$product->updateCategories($categories);
|
||
}
|
||
|
||
// Zapis produktu
|
||
if ($product->update()) {
|
||
|
||
// --- STANY MAGAZYNOWE PRODUKTU (ID_PRODUCT_ATTRIBUTE = 0) ---
|
||
$mainStatus = (string)$mainProductData->Status_magazynowy;
|
||
$mainQty = ($mainStatus === 'instock') ? 100 : 0;
|
||
StockAvailable::setQuantity($product->id, 0, $mainQty);
|
||
|
||
// --- AKTUALIZACJA CEN I STANÓW KOMBINACJI NA PODSTAWIE XML ---
|
||
foreach ($products as $productDataVariant) {
|
||
$variantRef = (string)$productDataVariant->sku;
|
||
|
||
// Szukamy kombinacji po indeksie/SKU
|
||
$combination = findCombinationByReference($product->id, $variantRef);
|
||
if (!$combination) {
|
||
continue;
|
||
}
|
||
|
||
// Cena brutto wariantu z XML
|
||
$variantGross = parsePrice((string)$productDataVariant->price);
|
||
if ($variantGross <= 0) {
|
||
continue;
|
||
}
|
||
|
||
// Netto wariantu
|
||
$variantNet = Tools::ps_round($variantGross / 1.23, 6);
|
||
|
||
// Impact względem ceny bazowej produktu (najtańszy wariant)
|
||
$impact = $variantNet - $netPrice;
|
||
// zabezpieczenie na wypadek minimalnych różnic/zaokrągleń
|
||
if ($impact < 0) {
|
||
$impact = 0;
|
||
}
|
||
$impact = Tools::ps_round($impact, 6);
|
||
|
||
$combination->price = $impact;
|
||
|
||
// Stan magazynowy kombinacji
|
||
$variantStatus = (string)$productDataVariant->Status_magazynowy;
|
||
$variantQty = ($variantStatus === 'instock') ? 100 : 0;
|
||
StockAvailable::setQuantity($product->id, $combination->id, $variantQty);
|
||
|
||
if ($combination->update()) {
|
||
$updatedCombinationCount++;
|
||
}
|
||
}
|
||
// --- KONIEC AKTUALIZACJI KOMBINACJI ---
|
||
|
||
// Zapis do logu – że ten produkt został dziś zaktualizowany
|
||
$logLine = $today.';product;'.$reference.';'.$product->id.PHP_EOL;
|
||
file_put_contents($logFile, $logLine, FILE_APPEND);
|
||
|
||
echo '<p><strong>Zaktualizowano produkt:</strong> '.htmlspecialchars((string)$mainProductData->title).' ('.$reference.')</p>';
|
||
echo '<p>Nowa bazowa cena brutto (najtańszy wariant) z XML: '.$grossBase.'</p>';
|
||
echo '<p>Nowa cena netto produktu (bazowa) w Presta: '.$netPrice.'</p>';
|
||
|
||
// INFO: czy zaktualizowano cenę produktu
|
||
if ($updatedProductPrice) {
|
||
echo '<p><strong>Cena produktu została zaktualizowana.</strong></p>';
|
||
} else {
|
||
echo '<p><strong>Cena produktu nie uległa zmianie.</strong></p>';
|
||
}
|
||
|
||
// INFO: ile kombinacji zaktualizowano
|
||
if ($updatedCombinationCount > 0) {
|
||
echo '<p><strong>Zaktualizowano ceny/ilości kombinacji:</strong> '.$updatedCombinationCount.' szt.</p>';
|
||
} else {
|
||
echo '<p><strong>Nie zaktualizowano żadnej kombinacji (brak dopasowanych SKU albo cen).</strong></p>';
|
||
}
|
||
|
||
$updatedSomething = true;
|
||
}
|
||
|
||
// Aktualizujemy tylko jeden produkt na jedno wywołanie
|
||
break;
|
||
}
|
||
|
||
if ($updatedSomething) {
|
||
// echo '<script>setTimeout(function(){ location.reload(); }, 50);</script>';
|
||
} else {
|
||
echo '<p>Brak produktów do aktualizacji na dzisiaj (wszystkie z XML zostały już zaktualizowane).</p>';
|
||
}
|
||
|
||
exit;
|
||
}
|
||
|
||
// =======================================
|
||
// =========== TRYB DODAWANIA ============
|
||
// =======================================
|
||
if ($modeAdd) {
|
||
$productAdded = false;
|
||
$combinationAdded = false;
|
||
|
||
// Tworzenie lub aktualizacja produktów z kombinacjami (dodawanie)
|
||
foreach ($productsBySymbol as $symbol => $products) {
|
||
if (empty($products)) {
|
||
continue;
|
||
}
|
||
|
||
// ===== Filter item_group_id =====
|
||
// $mainProductDataTemp = $products[0];
|
||
// if ((string)$mainProductDataTemp->item_group_id !== '68590') {
|
||
// continue;
|
||
// }
|
||
|
||
// Główny produkt – wybieramy deterministycznie
|
||
$mainProductData = findMainProductDataFromGroup($products);
|
||
if (!$mainProductData) {
|
||
// fallback: jeśli żaden nie istnieje, wybierz alfabetycznie najniższy SKU
|
||
usort($products, function($a, $b) {
|
||
return strcmp((string)$a->sku, (string)$b->sku);
|
||
});
|
||
$mainProductData = $products[0];
|
||
}
|
||
$mainProduct = findProductByReference((string)$mainProductData->sku);
|
||
|
||
// BAZA: najtańszy wariant w grupie (brutto i netto)
|
||
list($grossBase, $netPrice) = getBasePricesFromGroup($products);
|
||
|
||
if (!$mainProduct) {
|
||
// Create a new product if it doesn't exist
|
||
$mainProduct = new Product();
|
||
$mainProduct->name = createMultiLangField((string)$mainProductData->title);
|
||
|
||
$description = (string)$mainProductData->description;
|
||
$description = str_replace("\n", "<br>", $description);
|
||
$mainProduct->description = createMultiLangField($description);
|
||
|
||
// Cena BRUTTO z XML -> NETTO (23%) – bazą jest najtańszy wariant
|
||
$mainProduct->price = $netPrice > 0 ? $netPrice : 0;
|
||
|
||
// VAT 23% jeśli dostępny
|
||
$mainProduct->id_tax_rules_group = 8;
|
||
|
||
// Produkt aktywny + delivery times
|
||
$mainProduct->active = 1;
|
||
$mainProduct->delivery_in_stock = createMultiLangField('2-7 dni roboczych');
|
||
$mainProduct->delivery_out_stock = createMultiLangField('4-10 tygodni');
|
||
|
||
$mainProduct->reference = (string)$mainProductData->sku;
|
||
$mainProduct->id_category_default = 107; // np. Meble
|
||
$mainProduct->link_rewrite = createLinkRewrite((string)$mainProductData->title);
|
||
|
||
// Najpierw dodaj produkt
|
||
$mainProduct->add();
|
||
|
||
$mainProduct = new Product($mainProduct->id);
|
||
$mainProduct->id_tax_rules_group = 8;
|
||
$mainProduct->update();
|
||
|
||
// ===== Poprawne przypisanie kategorii =====
|
||
$id_lang = (int)$context->language->id;
|
||
$defaultCategory = new Category($mainProduct->id_category_default, $id_lang);
|
||
|
||
if (Validate::isLoadedObject($defaultCategory) && $defaultCategory->name == 'Strona główna') {
|
||
$newCategoryId = 107; // Meble
|
||
$mainProduct->id_category_default = (int)$newCategoryId;
|
||
|
||
// Podmieniamy kategorie produktu (zachowując inne)
|
||
$categories = $mainProduct->getCategories();
|
||
$categories = array_diff($categories, [(int)$defaultCategory->id]);
|
||
$categories[] = (int)$newCategoryId;
|
||
$categories = array_unique(array_map('intval', $categories));
|
||
$mainProduct->updateCategories($categories);
|
||
}
|
||
// ===== Koniec ustawienia kategorii =====
|
||
|
||
// Add images to the product
|
||
$imageUrls = getAllImageUrlsFromXmlProduct($mainProductData, 10);
|
||
|
||
$first = true;
|
||
foreach ($imageUrls as $url) {
|
||
addProductImage($mainProduct->id, $url, $first);
|
||
$first = false;
|
||
}
|
||
|
||
$productAdded = true;
|
||
}
|
||
|
||
// Ensure the product is saved before adding combinations
|
||
if (!$mainProduct->id) {
|
||
echo "Failed to create or update main product: " . (string)$mainProductData->title . "\n";
|
||
continue;
|
||
}
|
||
|
||
// Ensure the combination set is unique for the product
|
||
$addedCombinations = [];
|
||
|
||
// Add or update combinations for each product in the group
|
||
foreach ($products as $productData) {
|
||
$attributes = [
|
||
'Kolor' => (string)$productData->Kolor,
|
||
'Długość' => (string)$productData->Dlugosc,
|
||
'Szerokość' => (string)$productData->Szerokosc,
|
||
'Głębokość' => (string)$productData->Glebokosc,
|
||
'Wysokość' => (string)$productData->Wysokosc,
|
||
];
|
||
|
||
$attributeIds = [];
|
||
foreach ($attributes as $name => $value) {
|
||
if (!empty($value)) {
|
||
$attributeGroupId = createAttribute($name, [$value]);
|
||
$attribute = findAttributeByName($attributeGroupId, $value);
|
||
if ($attribute) {
|
||
$attributeIds[] = (int)$attribute->id;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Create a unique key for the attribute set
|
||
sort($attributeIds);
|
||
$key = implode('-', $attributeIds);
|
||
|
||
// Add or update combination if it is unique
|
||
if (!empty($attributeIds) && !isset($addedCombinations[$key])) {
|
||
$combination = findCombinationByAttributes($mainProduct->id, $attributeIds);
|
||
|
||
// Oblicz cenę wariantu
|
||
$variantGross = parsePrice((string)$productData->price);
|
||
$variantNet = $variantGross > 0 ? Tools::ps_round($variantGross / 1.23, 6) : 0;
|
||
|
||
// Impact względem ceny bazowej produktu
|
||
$impact = $variantNet - $netPrice;
|
||
if ($impact < 0) {
|
||
$impact = 0; // zabezpieczenie
|
||
}
|
||
$impact = Tools::ps_round($impact, 6);
|
||
|
||
if (!$combination) {
|
||
// Create new combination
|
||
$combination = new Combination();
|
||
$combination->id_product = (int)$mainProduct->id;
|
||
$combination->quantity = 100; // startowo, i tak zaraz nadpiszemy StockAvailable
|
||
$combination->reference = (string)$productData->sku;
|
||
$combination->price = $impact; // wpływ na cenę (tax excluded)
|
||
$combination->ecotax = 0;
|
||
$combination->wholesale_price = 0;
|
||
$combination->default_on = 0;
|
||
$combination->add();
|
||
$combination->setAttributes($attributeIds);
|
||
|
||
// Dodatkowy update aby upewnić się że cena jest prawidłowo zapisana
|
||
$combination->price = $impact;
|
||
$combination->update();
|
||
|
||
$combinationAdded = true;
|
||
} else {
|
||
// Update existing combination
|
||
$combination->quantity = 100; // startowo
|
||
$combination->price = $impact; // aktualizacja ceny
|
||
$combination->update();
|
||
}
|
||
|
||
// Mark this combination as added
|
||
$addedCombinations[$key] = true;
|
||
}
|
||
|
||
if ($combinationAdded) {
|
||
break; // Break if a new combination was added
|
||
}
|
||
}
|
||
|
||
// --- STANY MAGAZYNOWE PRODUKTU (ID_PRODUCT_ATTRIBUTE = 0) ---
|
||
$mainStatus = (string)$mainProductData->Status_magazynowy;
|
||
$mainQty = ($mainStatus === 'instock') ? 100 : 0;
|
||
StockAvailable::setQuantity($mainProduct->id, 0, $mainQty);
|
||
|
||
// --- STANY MAGAZYNOWE KOMBINACJI ---
|
||
foreach ($products as $productDataVariant) {
|
||
$variantRef = (string)$productDataVariant->sku;
|
||
$variantStatus = (string)$productDataVariant->Status_magazynowy;
|
||
$variantQty = ($variantStatus === 'instock') ? 100 : 0;
|
||
|
||
$combination = findCombinationByReference($mainProduct->id, $variantRef);
|
||
if ($combination) {
|
||
StockAvailable::setQuantity($mainProduct->id, $combination->id, $variantQty);
|
||
}
|
||
}
|
||
|
||
// Ensure the product has combinations enabled
|
||
$mainProduct->checkDefaultAttributes();
|
||
Product::updateDefaultAttribute($mainProduct->id);
|
||
|
||
// Upewnij się że produkt główny ma poprawne ustawienie VAT po dodaniu kombinacji
|
||
if ($productAdded || $combinationAdded) {
|
||
$mainProduct = new Product($mainProduct->id); // Przeładuj produkt
|
||
if (!empty($idTaxRulesGroup23) && (int)$mainProduct->id_tax_rules_group !== (int)$idTaxRulesGroup23) {
|
||
$mainProduct->id_tax_rules_group = (int)$idTaxRulesGroup23;
|
||
$mainProduct->update();
|
||
}
|
||
}
|
||
|
||
if ($productAdded || $combinationAdded) {
|
||
if ($productAdded) {
|
||
echo "<p>Dodałem produkt: " . htmlspecialchars((string)$mainProductData->title) . "</p>";
|
||
}
|
||
if ($combinationAdded) {
|
||
echo "<p>Dodałem kombinację: " . htmlspecialchars((string)$mainProductData->title) . "</p>";
|
||
}
|
||
break; // Break if a new product or combination was added
|
||
}
|
||
}
|
||
|
||
echo '<p>Dodawanie zakończone.</p>';
|
||
exit;
|
||
}
|
||
|
||
// =======================================
|
||
// ========= TRYB SYNCHRONIZACJI =========
|
||
// =======================================
|
||
if ($modeSynch) {
|
||
echo '<h2>Rozpoczynam synchronizację produktów...</h2>';
|
||
|
||
$db = Db::getInstance();
|
||
|
||
// 1. Wyczyszczenie tymczasowej tabeli
|
||
$db->execute('TRUNCATE TABLE `'._DB_PREFIX_.'drewmax_products_temp`');
|
||
|
||
// 1.1 Wczytywanie SKU z XML i dodawanie do tymczasowej tabeli
|
||
$skusInXml = [];
|
||
foreach ($xml->product as $productData) {
|
||
$sku = trim((string)$productData->sku);
|
||
if ($sku === '') continue;
|
||
|
||
$skusInXml[] = $sku;
|
||
|
||
$db->execute('
|
||
INSERT INTO `'._DB_PREFIX_.'drewmax_products_temp` (`sku`, `date_checked`)
|
||
VALUES (\''.pSQL($sku).'\', NOW())
|
||
');
|
||
}
|
||
|
||
// 2. Praca z historią
|
||
if (!empty($skusInXml)) {
|
||
// Utworzenie listy SKU dla SQL
|
||
$skusList = "'" . implode("','", array_map('pSQL', $skusInXml)) . "'";
|
||
|
||
// 2.1 Dodawanie nowych SKU do historii lub przywracanie aktywności
|
||
$sqlInsert = '
|
||
INSERT INTO `'._DB_PREFIX_.'drewmax_products_history` (`sku`, `active`)
|
||
SELECT t.sku, 1
|
||
FROM `'._DB_PREFIX_.'drewmax_products_temp` t
|
||
LEFT JOIN `'._DB_PREFIX_.'drewmax_products_history` h ON h.sku = t.sku
|
||
WHERE h.sku IS NULL
|
||
';
|
||
$db->execute($sqlInsert);
|
||
|
||
$sqlUpdateActive = '
|
||
UPDATE `'._DB_PREFIX_.'drewmax_products_history` h
|
||
JOIN `'._DB_PREFIX_.'drewmax_products_temp` t ON h.sku = t.sku
|
||
SET h.active = 1
|
||
WHERE h.active = 0
|
||
';
|
||
$db->execute($sqlUpdateActive);
|
||
}
|
||
|
||
// 2.2 Wykluczanie produktów, których nie ma w temp
|
||
$sqlDeactivate = '
|
||
UPDATE `'._DB_PREFIX_.'drewmax_products_history` h
|
||
LEFT JOIN `'._DB_PREFIX_.'drewmax_products_temp` t ON h.sku = t.sku
|
||
SET h.active = 0
|
||
WHERE t.sku IS NULL AND h.active = 1
|
||
';
|
||
$db->execute($sqlDeactivate);
|
||
|
||
// Wyłącz produkty w PrestaShop dla SKU, które mają active=0
|
||
$skusToDisable = $db->executeS('
|
||
SELECT sku FROM `'._DB_PREFIX_.'drewmax_products_history`
|
||
WHERE active = 0
|
||
');
|
||
|
||
// 3. Synchronizacja statusu produktów i kombinacji w PrestaShop
|
||
// Pobieramy tylko SKU z historii (źródło prawdy)
|
||
$allHistory = $db->executeS('
|
||
SELECT sku, active
|
||
FROM `'._DB_PREFIX_.'drewmax_products_history`
|
||
');
|
||
|
||
foreach ($allHistory as $row) {
|
||
$sku = trim($row['sku']);
|
||
$activeStatus = (int)$row['active'];
|
||
|
||
if ($sku === '') {
|
||
continue;
|
||
}
|
||
|
||
/**
|
||
* KROK 3.1
|
||
* Sprawdzenie czy SKU jest GŁÓWNYM PRODUKTEM
|
||
* (tylko ps_product.reference)
|
||
*/
|
||
$idProduct = (int)$db->getValue('
|
||
SELECT id_product
|
||
FROM `'._DB_PREFIX_.'product`
|
||
WHERE reference = \''.pSQL($sku).'\'
|
||
LIMIT 1
|
||
');
|
||
|
||
if ($idProduct > 0) {
|
||
// === GŁÓWNY PRODUKT ===
|
||
$product = new Product($idProduct);
|
||
|
||
if (!Validate::isLoadedObject($product)) {
|
||
continue;
|
||
}
|
||
|
||
if ($activeStatus === 0 && (int)$product->active === 1) {
|
||
// Wyłącz produkt
|
||
$product->active = 0;
|
||
$product->update();
|
||
echo "Wyłączono PRODUKT: {$sku}<br>";
|
||
}
|
||
|
||
if ($activeStatus === 1 && (int)$product->active === 0) {
|
||
// Włącz produkt
|
||
$product->active = 1;
|
||
$product->update();
|
||
echo "Włączono PRODUKT: {$sku}<br>";
|
||
}
|
||
|
||
// Główny produkt obsłużony → NIE sprawdzamy kombinacji
|
||
continue;
|
||
}
|
||
|
||
/**
|
||
* KROK 3.2
|
||
* Jeśli NIE jest produktem → sprawdzamy czy to KOMBINACJA
|
||
*/
|
||
$combinationRow = $db->getRow('
|
||
SELECT id_product_attribute, id_product
|
||
FROM `'._DB_PREFIX_.'product_attribute`
|
||
WHERE reference = \''.pSQL($sku).'\'
|
||
LIMIT 1
|
||
');
|
||
|
||
if ($combinationRow) {
|
||
// === KOMBINACJA ===
|
||
if ($activeStatus === 0) {
|
||
$idProductAttribute = (int)$combinationRow['id_product_attribute'];
|
||
|
||
$combination = new Combination($idProductAttribute);
|
||
if (Validate::isLoadedObject($combination)) {
|
||
$combination->delete();
|
||
echo "Usunięto KOMBINACJĘ: {$sku} (ID: {$idProductAttribute})<br>";
|
||
}
|
||
}
|
||
|
||
// Jeśli active = 1 → NIC NIE ROBIMY (kombinacji się nie aktywuje)
|
||
continue;
|
||
}
|
||
|
||
/**
|
||
* KROK 3.3
|
||
* SKU nie istnieje w PrestaShop → ignorujemy
|
||
*/
|
||
}
|
||
echo '<h3>Synchronizacja zakończona.</h3>';
|
||
}
|
||
|
||
// reload page after 250ms if product or combination was added (dla trybu add)
|
||
if ($productAdded || $combinationAdded) {
|
||
// echo "<script>setTimeout(function(){location.reload();}, 250);</script>";
|
||
}
|
||
|
||
?>
|