391 lines
13 KiB
PHP
391 lines
13 KiB
PHP
<?php
|
|
|
|
use KupShop\AdminBundle\Util\StockInProductOfSupplierService;
|
|
use KupShop\KupShopBundle\Util\Compat\ServiceContainer;
|
|
use KupShop\KupShopBundle\Util\Functional\Mapping;
|
|
use Query\Operator;
|
|
|
|
class StockInImport
|
|
{
|
|
use DatabaseCommunication;
|
|
|
|
public $type;
|
|
|
|
public $errors = [];
|
|
public $default_settings = [
|
|
'type' => 'xlsx',
|
|
'fields' => [0 => 'code', 1 => 'name', 2 => 'quantity', 3 => 'ean', 4 => 'price', 5 => 'supplier_code'],
|
|
'search_in_products' => true,
|
|
'isdoc_search_in_ean' => true,
|
|
'encoding' => 'UTF-8',
|
|
'skip' => '1',
|
|
'piece_price' => true,
|
|
'default' => true,
|
|
];
|
|
public $supplier_settings;
|
|
protected $separator = ';';
|
|
protected $skip = 0;
|
|
protected $encoding;
|
|
protected $fields = [];
|
|
protected $stock_in;
|
|
protected $check_file_name = false;
|
|
protected $only_visible = false;
|
|
protected $search_in_products = false;
|
|
protected $multiple = 1;
|
|
protected $cut_code;
|
|
protected $ignore_code = false;
|
|
|
|
protected $stockInIndex;
|
|
protected StockInProductOfSupplierService $stockInProductOfSupplierService;
|
|
|
|
public function __construct($stock_in, $stockInIndex = 'invoice')
|
|
{
|
|
$this->stock_in = $stock_in;
|
|
$this->supplier_settings = sqlQueryBuilder()->select('s.import_settings')
|
|
->from('suppliers', 's')
|
|
->where(Operator::equals(['id' => $stock_in['id_supplier']]))
|
|
->execute()
|
|
->fetchColumn();
|
|
$this->stockInIndex = $stockInIndex;
|
|
|
|
/* @var StockInProductOfSupplierService $supplierService */
|
|
$this->stockInProductOfSupplierService = ServiceContainer::getService(StockInProductOfSupplierService::class);
|
|
}
|
|
|
|
public function load_supplier_settings()
|
|
{
|
|
$settings = $this->supplier_settings != null ? json_decode($this->supplier_settings, true) : $this->default_settings;
|
|
if ($this->supplier_settings && json_last_error()) {
|
|
throw new Exception('Nelze nacist nastaveni importu: '.json_last_error_msg());
|
|
}
|
|
foreach ((array) $settings as $key => $value) {
|
|
$this->$key = $value;
|
|
}
|
|
}
|
|
|
|
public function import($file)
|
|
{
|
|
if ($this->check_file_name) {
|
|
$name = pathinfo($file['name'], PATHINFO_FILENAME);
|
|
|
|
if ($name != $this->stock_in['code']) {
|
|
return $this->add_error("Nesedí jméno souboru s číslem faktury: {$name} != {$this->stock_in['code']}");
|
|
}
|
|
}
|
|
|
|
if (empty($file['tmp_name'])) {
|
|
return $this->add_error('Nebyl nahrán žádný soubor!');
|
|
}
|
|
|
|
$method = "import_{$this->type}";
|
|
|
|
sqlStartTransaction();
|
|
|
|
$ret = $this->$method($file['tmp_name']);
|
|
|
|
sqlFinishTransaction();
|
|
|
|
return $ret;
|
|
}
|
|
|
|
public function import_isdoc($file)
|
|
{
|
|
$xml = simplexml_load_file($file);
|
|
|
|
$factorage = [
|
|
'date_issued' => (string) $xml->IssueDate,
|
|
'note' => (string) $xml->note,
|
|
'date_expiration' => (string) $xml->PaymentMeans->Payment->Details->PaymentDueDate,
|
|
'total_price' => (string) $xml->LegalMonetaryTotal->TaxExclusiveAmount,
|
|
];
|
|
if (!$this->ignore_code) {
|
|
$factorage['code'] = (string) $xml->ID;
|
|
}
|
|
|
|
$this->updateSQL(
|
|
'stock_in',
|
|
$factorage,
|
|
[
|
|
'id' => $this->stock_in['id'],
|
|
]
|
|
);
|
|
|
|
foreach ($xml->InvoiceLines->InvoiceLine as $invoiceLine) {
|
|
$item = [
|
|
'code' => (string) $invoiceLine->Item->SellersItemIdentification->ID,
|
|
'name' => (string) $invoiceLine->Item->Description,
|
|
'quantity' => (string) $invoiceLine->InvoicedQuantity,
|
|
'price' => (string) $invoiceLine->LineExtensionAmount,
|
|
'vat' => (string) $invoiceLine->ClassifiedTaxCategory->Percent,
|
|
];
|
|
|
|
if ($this->isdoc_search_in_ean ?? false) {
|
|
$ean = array_filter([
|
|
(int) $invoiceLine->Item->CatalogueItemIdentification->ID ?? '', // tady by mel byt EAN dle dokumentace
|
|
(int) $invoiceLine->Item->SellersItemIdentification->ID ?? '', // nekdo ma EAN tady
|
|
]);
|
|
if ($ean) {
|
|
$ean = (count($ean) == 1 ? reset($ean) : $ean);
|
|
$item['ean'] = $ean;
|
|
}
|
|
}
|
|
|
|
if ($item['quantity'] < 0) {
|
|
$item['price'] = (string) $invoiceLine->UnitPrice;
|
|
}
|
|
|
|
$this->add_item($item);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function import_isdocx($file)
|
|
{
|
|
$za = new ZipArchive();
|
|
$res = $za->open($file);
|
|
if ($res !== true) {
|
|
return false;
|
|
}
|
|
|
|
// finds the first .isdoc file and returns it or false
|
|
$findIsdoc = function ($zipArchive) {
|
|
// loop through all files in zip
|
|
for ($i = 0; $i < $zipArchive->numFiles; $i++) {
|
|
$stat = $zipArchive->statIndex($i);
|
|
|
|
// if extension is .isdoc return the filename
|
|
if (preg_match('/(.*\.isdoc)/', $stat['name']) === 1) {
|
|
return $stat['name'];
|
|
}
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
$fileName = 'zip://'.$file.'#'.$findIsdoc($za);
|
|
$za->close();
|
|
|
|
return $this->import_isdoc($fileName);
|
|
}
|
|
|
|
public function fopen_convert($fileName)
|
|
{
|
|
$fc = iconv($this->encoding, 'utf-8', file_get_contents($fileName));
|
|
$handle = fopen('php://memory', 'rw');
|
|
fwrite($handle, $fc);
|
|
fseek($handle, 0);
|
|
|
|
return $handle;
|
|
}
|
|
|
|
public function import_xlsx($file)
|
|
{
|
|
$xlsx = new AutomaticImportTransform($file);
|
|
$data = $xlsx->GetXml();
|
|
|
|
$i = 0;
|
|
foreach ($data->item as $row) {
|
|
if ($i < $this->skip) {
|
|
$i++;
|
|
continue;
|
|
}
|
|
|
|
$arr = json_decode(json_encode($row), true)['col'];
|
|
$arr = array_pad($arr, count($this->fields), null);
|
|
$item = array_combine($this->fields, array_slice($arr, 0, count($this->fields)));
|
|
|
|
// kontrola prázdného řádku
|
|
if (!empty($item) && !is_array($item['quantity'])) {
|
|
$this->add_item($item);
|
|
} else {
|
|
continue;
|
|
}
|
|
|
|
$i++;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function import_csv($file)
|
|
{
|
|
if ($this->encoding) {
|
|
$file = $this->fopen_convert($file);
|
|
} else {
|
|
$file = fopen($file, 'r');
|
|
}
|
|
|
|
if (!$file) {
|
|
exit('Nelze načíst soubor');
|
|
}
|
|
|
|
$count = count($this->fields);
|
|
|
|
while ($this->skip-- > 0) {
|
|
fgetcsv($file, null, $this->separator);
|
|
}
|
|
|
|
while ($row = fgetcsv($file, null, $this->separator)) {
|
|
$row = array_combine($this->fields, array_slice($row, 0, $count));
|
|
$this->add_item($row);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function add_item($item)
|
|
{
|
|
/*
|
|
* Funkce na uříznutí X počtu znaků z kodu. Stačí zadat v importu/exportu "cut" = 'začátek';'konec'
|
|
* */
|
|
if ($this->cut_code) {
|
|
$cut = explode(';', $this->cut_code);
|
|
$item['code'] = substr($item['code'], $cut[0], $cut[1] ?? (strlen($item['code']) - $cut[0]));
|
|
}
|
|
|
|
$mapping = [];
|
|
if (!empty($item['code'])) {
|
|
$mapping = ['code' => $item['code']];
|
|
}
|
|
if (!empty($item['ean'])) {
|
|
$mapping['ean'] = $item['ean'];
|
|
}
|
|
|
|
if (!empty($mapping)) {
|
|
$qb = sqlQueryBuilder()->select('pos.id_product', 'pos.id_variation', 'pos.import_multiplier', 'p.vat as id_vat')
|
|
->from('products_of_suppliers', 'pos')
|
|
->leftJoin('pos', 'products', 'p', 'pos.id_product=p.id')
|
|
->where(Operator::equals(['pos.id_supplier' => $this->stock_in['id_supplier']]));
|
|
if ($this->only_visible) {
|
|
$qb->andWhere(Operator::equals(['p.figure' => 'Y']));
|
|
}
|
|
|
|
$operators = array_map(function ($key, $value) {
|
|
if (is_array($value)) {
|
|
return Operator::inIntArray($value, "pos.{$key}");
|
|
}
|
|
|
|
return Operator::equals(["pos.{$key}" => $value]);
|
|
}, array_keys($mapping), $mapping);
|
|
$qb->andWhere(Operator::orX($operators));
|
|
|
|
$product = $qb->execute()->fetch();
|
|
|
|
if (!$product && $this->search_in_products) {
|
|
$qb = sqlQueryBuilder()->select('p.id AS id_product, pv.id AS id_variation')
|
|
->fromProducts()
|
|
->joinVariationsOnProducts();
|
|
|
|
$productsMapping = array_merge(
|
|
Mapping::mapKeys($mapping, function ($key, $value) {return ["p.{$key}", $value]; }),
|
|
Mapping::mapKeys($mapping, function ($key, $value) {return ["pv.{$key}", $value]; })
|
|
);
|
|
if (isset($productsMapping['pv.code']) && !findModule(Modules::PRODUCTS_VARIATIONS, Modules::SUB_CODE)) {
|
|
unset($productsMapping['pv.code']);
|
|
}
|
|
|
|
$operators = array_map(function ($key, $value) {
|
|
if (is_array($value)) {
|
|
return Operator::inStringArray($value, $key);
|
|
}
|
|
|
|
return Operator::equals([$key => $value]);
|
|
}, array_keys($productsMapping), $productsMapping);
|
|
$qb->andWhere(Operator::orX($operators));
|
|
|
|
if ($this->only_visible) {
|
|
$qb->andWhere(Operator::equals(['p.figure' => 'Y']));
|
|
}
|
|
$product = $qb->execute()->fetch();
|
|
|
|
if ($product) {
|
|
$product['import_multiplier'] = 1;
|
|
}
|
|
}
|
|
} else {
|
|
$product = null;
|
|
$mapping['code'] = translate('unknown');
|
|
$mapping['ean'] = translate('unknown');
|
|
}
|
|
|
|
if (!$product || $product['import_multiplier'] == 0) {
|
|
$product = ['id_product' => null, 'id_variation' => null, 'name' => "{$item['name']} (kód: {$mapping['code']}, ean: {$mapping['ean']})", 'import_multiplier' => 1, 'id_vat' => 0];
|
|
} else {
|
|
$product['name'] = null;
|
|
}
|
|
|
|
$product['id_stock_in'] = $this->stock_in['id'];
|
|
|
|
$product['quantity'] = round((float) $item['quantity'] * (float) $product['import_multiplier'] * (float) $this->multiple);
|
|
|
|
$product['vat'] = empty($item['vat']) ? getVat($product['id_vat']) : $item['vat'];
|
|
|
|
if (empty($item['price']) && !empty($item['price_with_vat'])) {
|
|
$price = toDecimal($this->preparePrice($item['price_with_vat']))->removeVat($product['vat']);
|
|
} else {
|
|
$price = toDecimal($this->preparePrice($item['price']));
|
|
}
|
|
|
|
// if isset price multiplier
|
|
if (isset($this->stock_in['multiplier'])) {
|
|
$price = $price->mul(toDecimal($this->stock_in['multiplier']));
|
|
}
|
|
|
|
unset($product['id_vat']);
|
|
|
|
if (isset($this->piece_price)) {
|
|
$product['price'] = $price;
|
|
} else {
|
|
$product['price'] = $product['quantity'] > 0 ? $price->div(toDecimal($product['quantity'])) : $price;
|
|
}
|
|
|
|
if ($this->insertSQL('stock_in_items', $product, ['import_multiplier']) <= 0) {
|
|
return $this->add_error('Cannot add '.print_r($product, true));
|
|
}
|
|
|
|
if ($product['id_product'] > 0 && !in_array($this->stockInIndex, ['future', 'preorder'])) {
|
|
$prod = new Product($product['id_product']);
|
|
$prod->storeIn($product['id_variation'], $product['quantity']);
|
|
}
|
|
|
|
$product['supplier_code'] = !empty($item['supplier_code']) ? trim($item['supplier_code']) : null;
|
|
$stockInData = getVal('data');
|
|
|
|
try {
|
|
$this->stockInProductOfSupplierService->updateOrInsertProductSupplier($product, $stockInData);
|
|
} catch (Exception|\Doctrine\DBAL\Driver\Exception) {
|
|
$this->add_error("Nepodařilo se uložit kód dodavatele '{$item['code']}' položky: {$item['name']}");
|
|
}
|
|
}
|
|
|
|
private function add_error($string)
|
|
{
|
|
$this->errors[] = $string;
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (!function_exists('json_last_error_msg')) {
|
|
function json_last_error_msg()
|
|
{
|
|
switch (json_last_error()) {
|
|
case JSON_ERROR_NONE:
|
|
return 'No errors';
|
|
case JSON_ERROR_DEPTH:
|
|
return 'Maximum stack depth exceeded';
|
|
case JSON_ERROR_STATE_MISMATCH:
|
|
return 'Underflow or the modes mismatch';
|
|
case JSON_ERROR_CTRL_CHAR:
|
|
return 'Unexpected control character found';
|
|
case JSON_ERROR_SYNTAX:
|
|
return 'Syntax error, malformed JSON';
|
|
case JSON_ERROR_UTF8:
|
|
return 'Malformed UTF-8 characters, possibly incorrectly encoded';
|
|
default:
|
|
return 'Unknown error';
|
|
}
|
|
}
|
|
}
|