1534 lines
58 KiB
Plaintext
1534 lines
58 KiB
Plaintext
<?php
|
|
|
|
/**
|
|
* Plik wymiany danych z systemem Baselinker
|
|
* @author Sewer Skrzypiński <info@baselinker.com>
|
|
* @version 4
|
|
* @package baselinker
|
|
*/
|
|
|
|
/** -----------------------------------------------------------------------------------------------------------
|
|
* Ustawienia wpisywane przez sprzedawcę
|
|
* - Należy uzupełnić dane wprowadzając je między apostrofy
|
|
*/
|
|
$options['baselinker_pass'] = 'rcszksgwexd171b6x4mz5m77n2psqpo3'; //hasło do komunikacji (dostępne w panelu Baselinkera w zakładce 'sklep internetowy')
|
|
|
|
$options['db_host'] = 'localhost'; //adres hosta bazy danych (najczęściej localhost)
|
|
$options['db_user'] = 'rsduvqkeer_grzanie'; //użytkownik bazy danych
|
|
$options['db_pass'] = '[QD-*l7%0M-Hicik'; //hasło bazy danych
|
|
$options['db_name'] = 'rsduvqkeer_grzanieplus-pl'; //nazwa bazy danych
|
|
$options['db_prefix'] = ''; //prefiks tabel bazy danych - domyślnie pozostaw pusty aby wykryć automatycznie
|
|
|
|
$options['images_folder'] = 'http://grzanieplus.pl/'; //adres folderu zawierającego zdjęcia produktów i producentów (rozpoczęty 'http://', zakończony /)
|
|
|
|
$options['special_price'] = 1; //czy używać ceny promocyjnej jeśli produkt jest w promocji? (0 - nie, 1 - tak)
|
|
$options['charset'] = 'UTF-8'; //zestaw znaków bazy danych (standardowo UTF-8)
|
|
|
|
$options['sote_shophash'] = 'f9862393534ee289a67584de0b0768a0'; // klucz rozkodowywania danych zamówienia (zawarty w pliku core/data/config/__stRegister.yml)
|
|
|
|
error_reporting(E_ERROR | E_WARNING);
|
|
date_default_timezone_set('Europe/Warsaw');
|
|
|
|
/** -----------------------------------------------------------------------------------------------------------
|
|
* Funkcje zarządzające komunikacją (przedrostek Conn_) oraz funkcje ułatwiające zapytania SQL (przedrostek DB_)
|
|
* - Jednakowe niezależnie od platformy
|
|
* - Nie należy edytować poniższego kodu
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
* Definicja funkcji json_encode oraz json_decode dla PHP4 (istnieją domyślnie w PHP5.2), iconv() dla tablic, oraz array_walk_recursive()
|
|
* Nie należy edytować. Credits goes to Steve http://usphp.com/manual/en/function.json-encode.php#82904
|
|
*/
|
|
if (!function_exists('json_encode'))
|
|
{
|
|
function json_encode($a=false,$is_key=false)
|
|
{if (is_null($a)) return 'null';if ($a === false) return 'false';if ($a === true) return 'true';
|
|
if (is_scalar($a)){if(is_int($a)&&$is_key){return '"'.$a.'"';} if (is_float($a)){return floatval(str_replace(",", ".", strval($a)));}if (is_string($a)){
|
|
static $jsonReplaces = array(array("\\", "/", "\n", "\t", "\r", "\b", "\f", '"'), array('\\\\', '\\/', '\\n', '\\t', '\\r', '\\b', '\\f', '\"'));
|
|
return '"' . str_replace($jsonReplaces[0], $jsonReplaces[1], $a) . '"';} else return $a;} $isList = true;
|
|
for ($i = 0, reset($a); $i < count($a); $i++, next($a)){if (key($a) !== $i){$isList = false;break;}}
|
|
$result = array(); if ($isList){foreach ($a as $v) $result[] = json_encode($v); return '[' . join(',', $result) . ']';}
|
|
else {foreach ($a as $k => $v) $result[] = json_encode($k,true).':'.json_encode($v); return '{' . join(',', $result) . '}';}}
|
|
}
|
|
if (!function_exists('json_decode'))
|
|
{
|
|
function json_decode($json, $assoc = true)
|
|
{$comment = false; $out = '$x='; for ($i=0; $i<strlen($json); $i++) { if (!$comment) {if (($json[$i] == '{') || ($json[$i] == '['))
|
|
$out .= ' array('; else if (($json[$i] == '}') || ($json[$i] == ']')) $out .= ')'; else if ($json[$i] == ':') $out .= '=>';
|
|
else $out .= $json[$i]; } else $out .= $json[$i]; if ($json[$i] == '"' && $json[($i-1)]!="\\") $comment = !$comment;} eval($out . ';'); return $x;}
|
|
}
|
|
if (!function_exists('array_walk_recursive'))
|
|
{
|
|
function array_walk_recursive(&$input, $funcname, $userdata = "")
|
|
{if (!is_callable($funcname)){return false;}if (!is_array($input)){return false;}foreach ($input AS $key => $value){
|
|
if (is_array($input[$key])){array_walk_recursive($input[$key], $funcname, $userdata);}else{$saved_value = $value;
|
|
if (!empty($userdata)){$funcname($value, $key, $userdata);}else{$funcname($value, $key);}if ($value != $saved_value)
|
|
{$input[$key] = $value;}}}return true;}
|
|
}
|
|
|
|
function array_iconv(&$val, $key, $userdata)
|
|
{$val = iconv($userdata[0], $userdata[1], $val);}
|
|
function recursive_iconv($in_charset, $out_charset, $arr)
|
|
{if (!is_array($arr)){return iconv($in_charset, $out_charset, $arr);}$ret = $arr;
|
|
array_walk_recursive($ret, "array_iconv", array($in_charset, $out_charset));return $ret;}
|
|
|
|
|
|
/**
|
|
* Funkcje wykonujące zapytania SQL
|
|
*/
|
|
function DB_Query($sql)
|
|
{
|
|
global $dbh;
|
|
|
|
if (func_num_args() > 1){$i = 0; foreach(func_get_args() as $val){if ($i==0){$i++; continue;}$sql = str_replace("{".($i-1)."}", substr($dbh->quote($val), 1, -1), $sql); $i++;}}
|
|
|
|
if (!($sth = $dbh->prepare($sql)))
|
|
{
|
|
$err = $dbh->errorInfo();
|
|
Conn_error('db_query', 'SQL error: ' . $err[2]);
|
|
}
|
|
|
|
if (!($sth->execute()))
|
|
{
|
|
$err = $sth->errorInfo();
|
|
Conn_error('db_query', 'SQL error: ' . $err[2]);
|
|
}
|
|
|
|
return $sth;
|
|
}
|
|
|
|
function DB_Result($sth, $num = 0) { if (DB_NumRows($sth) > $num){return $sth->fetchColumn($num);} return false; }
|
|
|
|
function DB_Identity() { global $dbh; return $dbh->lastInsertId(); }
|
|
|
|
function DB_NumRows($sth) { return $sth->rowCount(); }
|
|
|
|
function DB_Fetch($sth) { return $sth->fetch(PDO::FETCH_ASSOC); }
|
|
|
|
|
|
/**
|
|
* Funkcja obsługująca żądania i wysyłająca odpowiedź.
|
|
* Zalecane jest pozostawienie funkcji w tej postaci niezależnie od platformy
|
|
* @global array $options : tablica z ustawieniami ogólnymi
|
|
*/
|
|
function Conn_Init()
|
|
{
|
|
global $options;
|
|
|
|
//sprawdzanie poprawności hasła wymiany danych
|
|
if(!isset($_POST['bl_pass']))
|
|
{Conn_Error("no_password","Odwołanie do pliku bez podania hasła. Jest to poprawny komunikat jeśli plik integracyjny został otworzony w przeglądarce internetowej.");}
|
|
elseif($options['baselinker_pass'] == "" || $options['baselinker_pass'] !== $_POST['bl_pass'])
|
|
{Conn_Error("incorrect_password");}
|
|
|
|
//zmiana kodowania danych wejściowych
|
|
if($options['charset'] != "UTF-8")
|
|
{
|
|
foreach($_POST as $key => $val)
|
|
{$_POST[$key] = iconv('UTF-8', $options['charset'].'//IGNORE', $val);}
|
|
}
|
|
|
|
//łączenie z bazą danych sklepu
|
|
Shop_ConnectDatabase($_POST);
|
|
|
|
//rozbijanie tablic z danymi
|
|
if(isset($_POST['orders_ids'])){$_POST['orders_ids'] = explode(',', $_POST['orders_ids']);}
|
|
if(isset($_POST['products_id'])){$_POST['products_id'] = explode(',', $_POST['products_id']);}
|
|
if(isset($_POST['fields'])){$_POST['fields'] = explode(',', $_POST['fields']);}
|
|
if(isset($_POST['products'])){$_POST['products'] = json_decode(stripslashes($_POST['products']), true);}
|
|
|
|
//sprawdzanie czy podana metoda jest zaimplementowana
|
|
if(function_exists("Shop_".$_POST['action']))
|
|
{
|
|
$method = "Shop_".$_POST['action'];
|
|
Conn_SendResponse($method($_POST));
|
|
}
|
|
else
|
|
{Conn_Error("unsupported_action", "No action: ".$_POST['action']);}
|
|
}
|
|
|
|
|
|
/**
|
|
* Funkcja generująca odpowiedź do systemu w formacie JSON
|
|
* @global array $options tablica z ustawieniami ogólnymi
|
|
*/
|
|
function Conn_SendResponse($response)
|
|
{
|
|
global $options;
|
|
|
|
//zmiana kodowania danych wyjściowych
|
|
if($options['charset'] != "UTF-8" && count($response) > 0)
|
|
{
|
|
foreach($response as $key => $val)
|
|
{$response[$key] = recursive_iconv($options['charset'], 'UTF-8//IGNORE', $val);}
|
|
}
|
|
|
|
print json_encode($response);
|
|
exit();
|
|
}
|
|
|
|
|
|
/**
|
|
* Funkcja wypisująca kominukat błędu w formacie JSON i kończąca skrypt
|
|
* Zalecane jest pozostawienie funkcji w tej postaci niezależnie od platformy
|
|
* @param string $error_code kod błędu (standardowe wartości: db_connect, db_query, no_action)
|
|
* @param string $error_text opis błędu
|
|
*/
|
|
function Conn_Error($error_code, $error_text = '')
|
|
{
|
|
print json_encode(array('error' => true, 'error_code' => $error_code, 'error_text' => $error_text));
|
|
exit();
|
|
}
|
|
|
|
|
|
/**
|
|
* Ewentualne wczytanie dodatkowych funkcji z pliku baselinker_pm.php (BaseLinker Product Managment)
|
|
* Zawarte w dodatkowym pliku funkcje rozszerzają możliwości integracji ze sklepem o funkcje pozwalające dodawać i zmieniać kategorie, produkty oraz warianty.
|
|
* Obsługa tych funkcji jest wymagana przez niektóre moduły BaseLinkera (np. moduły integrujące system z programami typu ERP)
|
|
* Plik baselinker_pm.php jest dostępny dla wybranych platform sklepów. Skontaktuj się z administratorem w cely uzyskania pliku.
|
|
*/
|
|
if(file_exists("baselinker_pm.php"))
|
|
{include("baselinker_pm.php");}
|
|
|
|
|
|
//inicjacja komunikacji
|
|
Conn_Init();
|
|
|
|
|
|
|
|
|
|
/** -----------------------------------------------------------------------------------------------------------
|
|
* Funkcje obsługiwania żądań (przedrostek Shop_)
|
|
* - Zależne od platformy sklepu
|
|
* - Do edycji dla deweloperów
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
* Funkcja zwracająca wersję pliku wymiany danych
|
|
* Przy tworzeniu pliku należy skonsultować numer wersji i nazwę platformy
|
|
* z administracją systemu Baselinker
|
|
* @param array $request tablica z żadaniem od systemu, w przypadku tej funkcji nie używana
|
|
* @return array $response tablica z danymi platformy z polami:
|
|
* platform => nazwa platformy
|
|
* version => numer wersji pliku
|
|
*/
|
|
function Shop_FileVersion($request)
|
|
{
|
|
$response['platform'] = "SoteShop";
|
|
$response['version'] = "4.1.8"; //wersja pliku integracyjnego, nie wersja sklepu!
|
|
$response['standard'] = 4; //standard struktury pliku integracyjnego - obecny standard to 4.
|
|
|
|
return $response;
|
|
}
|
|
|
|
|
|
/**
|
|
* Funkcja zwracająca listę zaimplementowanych metod pliku
|
|
* Zalecane jest pozostawienie funkcji w tej postaci niezależnie od platformy
|
|
*/
|
|
function Shop_SupportedMethods()
|
|
{
|
|
$result = array();
|
|
$methods = get_defined_functions();
|
|
|
|
foreach($methods['user'] as $m)
|
|
{
|
|
if (stripos($m, 'shop_') === 0)
|
|
{$result[] = substr($m,5);}
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Funkcja nawiązująca komunikację z bazą danych sklepu
|
|
* @global array $options : tablica z ustawieniami ogólnymi z początku pliku
|
|
* @param array $request tablica z żadaniem od systemu, w przypadku tej funkcji nie używana
|
|
* @return boolean wartość logiczna określajaca sukces połączenia z bazą danych
|
|
*/
|
|
function Shop_ConnectDatabase($request)
|
|
{
|
|
global $options; //globalna tablica z ustawieniami
|
|
global $dbh; // handler bazy danych
|
|
|
|
$dbp = $options['db_prefix']; //Data Base Prefix - prefix tabel bazy
|
|
|
|
// wydzielenie portu z nazwy hosta
|
|
if (preg_match('/^\s*([\w\-\.]+):(\d+)\s*$/', $options['db_host'], $m))
|
|
{
|
|
$options['db_host'] = $m[1];
|
|
$options['db_port'] = $m[2];
|
|
}
|
|
|
|
// wygenerowanie DSN
|
|
$dsn = "mysql:dbname=${options['db_name']};host=${options['db_host']}";
|
|
|
|
if ($options['db_port'])
|
|
{
|
|
$dsn .= ";port=${options['db_port']}";
|
|
}
|
|
|
|
// nawiązanie połączenia z bazą danych sklepu
|
|
try {
|
|
$dbh = new PDO($dsn, $options['db_user'], $options['db_pass']);
|
|
} catch (Exception $ex) {
|
|
Conn_Error('db_connection', $ex->getMessage());
|
|
}
|
|
|
|
if($options['charset'] == "UTF-8")
|
|
{DB_Query("SET NAMES utf8");}
|
|
|
|
DB_Query("SET SESSION sql_mode = 'NO_ENGINE_SUBSTITUTION'");
|
|
|
|
// automatyczne wyszukiwanie prefiksu bazy danych
|
|
if ($dbp == '')
|
|
{
|
|
// wyszukiwanie tabeli z unikalną nazwą
|
|
$unique_table = 'st_product_has_attribute_field';
|
|
$search_table = DB_Query("SHOW TABLES LIKE '%${unique_table}'");
|
|
|
|
if (DB_NumRows($search_table) == 1)
|
|
{
|
|
$options['db_prefix'] = str_replace($unique_table, '', DB_Result($search_table));
|
|
$dbp = $options['db_prefix'];
|
|
}
|
|
else // nie wykryto jednoznacznie prefiksu
|
|
{
|
|
Conn_Error("database_prefix");
|
|
}
|
|
}
|
|
|
|
if (!$options['lang'])
|
|
{
|
|
$options['lang'] = DB_Result(DB_Query("SELECT language FROM `${dbp}st_language` WHERE active ORDER BY is_default DESC LIMIT 1"));
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Funkcja zwraca listę kategorii sklepowych
|
|
* Zwracana tabela powinna być posortowana alfabetycznie
|
|
* W nazwie kategorii podrzędnej powinna być zawrta nazwa nadkategorii - np "Komputery/Karty graficzne" zamiast "Karty graficzne"
|
|
* @global array $options : tablica z ustawieniami ogólnymi z początku pliku
|
|
* @param array $request tablica z żadaniem od systemu, w przypadku tej funkcji nie używana
|
|
* @return array $response tablica z listą kategori sklepowch w formacie:
|
|
* id kategorii => nazwa kategorii
|
|
*/
|
|
function Shop_ProductsCategories($request)
|
|
{
|
|
global $options; // globalna tablica z ustawieniami
|
|
$dbp = $options['db_prefix']; // Data Base Prefix - prefix tabel bazy
|
|
|
|
|
|
// pobieranie kategorii z bazy i zapisywanie do tabeli
|
|
$sql = "SELECT * FROM `${dbp}st_category` c
|
|
WHERE is_active = 1 AND is_hidden = 0";
|
|
$res = DB_Query($sql);
|
|
|
|
while ($category = DB_Fetch($res))
|
|
{
|
|
$categories[$category['id']] = $category['opt_name'];
|
|
$parents[$category['id']] = $category['parent_id'];
|
|
}
|
|
|
|
// budowanie drzewa kategorii na podstawie tablicy
|
|
$category_tree = array();
|
|
|
|
foreach ($categories as $id => $name)
|
|
{
|
|
$cat_name = "";
|
|
$this_id = $id;
|
|
|
|
while ($parents[$this_id] != 0)
|
|
{
|
|
$cat_name = $categories[$parents[$this_id]] .'/' . $cat_name;
|
|
$this_id = $parents[$this_id];
|
|
}
|
|
$category_tree[$id] = $cat_name.$name;
|
|
}
|
|
|
|
// sortowanie alfabetycznie wg nazw
|
|
asort($category_tree);
|
|
|
|
return $category_tree;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Funkcja zwraca listę produktów z bazy sklepu
|
|
* Zwracane liczby (np ceny) powinny mieć format typu: 123456798.12 (kropka oddziela część całkowitą, 2 miejsca po przecinku)
|
|
* @global array $options : tablica z ustawieniami ogólnymi z początku pliku
|
|
* @param array $request tablica z żadaniem od systemu zawierająca pola:
|
|
* category_id => id kategori (wartość 'all' jeśli wszystkie przedmioty)
|
|
* filter_limit => limit zwróconych kategorii w formacie SQLowym ("ilość pomijanych, ilość pobieranych")
|
|
* filter_sort => wartość po której ma być sortowana lista produktów. Możliwe wartości:
|
|
* "id [ASC|DESC]", "name [ASC|DESC]", "quantity [ASC|DESC]", "price [ASC|DESC]"
|
|
* filter_id => ograniczenie wyników do konkretnego id produktu
|
|
* filter_ean => ograniczenie wyników do konkretnego ean
|
|
* filter_sku => ograniczenie wyników do konkretnego sku (numeru magazynowego)
|
|
* filter_name => filtr nazw przedmiotów (fragment szukanej nazwy lub puste pole)
|
|
* filter_price_from => dolne ograniczenie ceny (nie wyświetlane produkty z niższą ceną)
|
|
* filter_price_to => górne ograniczenie ceny
|
|
* filter_quantity_from => dolne ograniczenie ilości produktów
|
|
* filter_quantity_to => górne ograniczenie ilości produktów
|
|
* filter_available => wyświetlanie tylko produktów oznaczonych jako dostępne (wartość 1) lub niedostępne (0) lub wszystkich (pusta wartość)
|
|
* @return array $response tablica z listą produktów w formacie:
|
|
* id produktu =>
|
|
'name' => nazwa produktu
|
|
'quantity' => dostępna ilość
|
|
'price' => cena w PLN
|
|
*/
|
|
function Shop_ProductsList($request)
|
|
{
|
|
global $options; //globalna tablica z ustawieniami
|
|
$dbp = $options['db_prefix']; //Data Base Prefix - prefix tabel bazy
|
|
|
|
// wyrażenie SQL zwracające cenę, nazwę, stan mag.
|
|
$price_spec = 'p.opt_price_brutto';
|
|
$name_spec = 'p.opt_name';
|
|
$qty_spec = 'p.stock';
|
|
|
|
// zmiana nazw kolumn na nazwy pól
|
|
$request['filter_sort'] = str_replace(array('id', 'name', 'quantity', 'price'), array('p.id', $name_spec, $qty_spec, $price_spec), $request['filter_sort']);
|
|
|
|
//pobieranie produktow z bazy danych
|
|
$sql = "SELECT p.id, $name_spec name, code, $price_spec price, $qty_spec stock
|
|
FROM `${dbp}st_product` p
|
|
WHERE 1";
|
|
|
|
|
|
if ($request['category_id'] != 'all' && $request['category_id'] != '') // wybór kategorii
|
|
{
|
|
$sql = preg_replace('/(\s+WHERE\s+)/', "\nJOIN `${dbp}st_product_has_category` phc ON phc.product_id = p.id$1", $sql);
|
|
$sql .= " AND phc.category_id = '${request['category_id']}'";
|
|
}
|
|
|
|
if ($request['filter_id'] != '') { $sql .= " AND p.id = '${request['filter_id']}'"; } //filtrowanie id
|
|
if ($request['filter_name'] != '') { $sql .= " AND $name_spec LIKE '%${request['filter_name']}%'"; } //filtrowanie nazwy
|
|
if ($request['filter_sku'] != '') { $sql .= " AND p.code LIKE '%${request['filter_sku']}%'"; } //filtrowanie SKU
|
|
if ($request['filter_quantity_from'] != '') { $sql .= " AND $qty_spec >= '${request['filter_quantity_from']}'"; } //filtrowanie ilości
|
|
if ($request['filter_quantity_to'] != '') { $sql .= " AND $qty_spec <= '${request['filter_quantity_to']}'"; } //filtrowanie ilości
|
|
if ($request['filter_available'] != '') { $sql .= " AND p.active = '${request['filter_available']}'"; } //produkty dostępne/niedostępne
|
|
if ($request['filter_price_from'] != '') { $sql .= " AND $price_spec >= '${request['filter_price_from']}'"; }
|
|
if ($request['filter_price_to'] != '') { $sql .= " AND $price_spec <= '${request['filter_price_to']}'"; }
|
|
|
|
if ($request['filter_sort'] != '') { $sql .= " ORDER BY ${request['filter_sort']}"; }
|
|
if ($request['filter_limit'] != '') { $sql .= " LIMIT ${request['filter_limit']}"; }
|
|
|
|
$response = array();
|
|
$result = DB_Query($sql);
|
|
|
|
while ($prod = DB_Fetch($result))
|
|
{
|
|
$response[$prod['id']] = array('name' => $prod['name'], 'quantity' => (int)$prod['stock'], 'price' => $prod['price'], 'sku' => $prod['code']);
|
|
}
|
|
|
|
return $response;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* Funkcja zwraca szczegółowe dane wybranych produktów
|
|
* Zwracane liczby (np ceny) powinny mieć format typu: 123456798.12 (kropka oddziela część całkowitą, 2 miejsca po przecinku)
|
|
* @global array $options : tablica z ustawieniami ogólnymi z początku pliku
|
|
* @param array $request tablica z żadaniem od systemu zawierająca pola:
|
|
* products_id => tablica z numerami id produktów
|
|
* fields => tablica z nazwami pól do zwrócenia (jeśli pusta zwracany jest cały wynik)
|
|
* @return array $response tablica z listą produktów w formacie:
|
|
* id produktu =>
|
|
'name' => nazwa produktu, 'ean' => Kod EAN, 'sku' => numer katalogowy, 'model' => nazwa modelu lub inny identyfikator np ISBN,
|
|
'description' => opis produktu (może zawierać tagi HTML), 'description_extra1' => drugi opis produktu (np opis krótki) 'weight' => waga produktu w kg,
|
|
'quantity' => dostępna ilość, 'man_name' => nazwa producenta, 'man_image' => pełny adres obrazka loga producenta,
|
|
'category_id' => numer ID głównej kategorii, 'category_name' => nazwa kategori do której należy przedmiot, 'tax' => wielkość podatku w formie liczby (np 23)
|
|
'price' => cena brutto w PLN,
|
|
'images' => tablica z pełnymi adresami dodatkowych obrazków (pierwsze zdjęcie główne, reszta w odpowiedniej kolejności),
|
|
'features' => tablica z opisem cech produktu. Poszczególny element tablicy zawiera nazwę i wartość cechy, np array('Rozdzielczość','Full HD')
|
|
'variants' => tablica z wariantami produktu do wyboru (np kolor, rozmiar). Format pola opisany jest w kodzie poniżej
|
|
*/
|
|
function Shop_ProductsData($request)
|
|
{
|
|
global $options; // globalna tablica z ustawieniami
|
|
$dbp = $options['db_prefix']; //Data Base Prefix - prefix tabel bazy
|
|
|
|
$category_tree = Shop_ProductsCategories($request);
|
|
$response = array();
|
|
$prodcat = array();
|
|
|
|
// mapowanie produktów do kategorii
|
|
$sql = "SELECT product_id, category_id
|
|
FROM `${dbp}st_product_has_category`
|
|
WHERE product_id IN ({0})
|
|
ORDER BY is_default";
|
|
$res = DB_Query($sql, implode(', ', $request['products_id']));
|
|
|
|
while ($map = DB_Fetch($res))
|
|
{
|
|
$prodcat[$map['product_id']] = $map['category_id'];
|
|
}
|
|
|
|
// pobieranie danych produktów z bazy danych
|
|
$sql = "SELECT p.id, p.code sku, p.code model, m.opt_name man_name,
|
|
m.image man_image, p.stock quantity,
|
|
p.opt_vat tax, p.weight, p.opt_price_brutto price, pi.name, pi.description,
|
|
pi.short_description description_extra1
|
|
FROM `${dbp}st_product` p
|
|
LEFT JOIN `${dbp}st_product_i18n` pi ON pi.id = p.id AND pi.culture = '{1}'
|
|
LEFT JOIN `${dbp}st_producer` m ON m.id = p.producer_id
|
|
WHERE
|
|
p.id IN ({0})";
|
|
$res = DB_Query($sql, implode(', ', $request['products_id']), $options['lang']);
|
|
|
|
while ($p = DB_Fetch($res))
|
|
{
|
|
$product_id = $p['id'];
|
|
|
|
// zdjęcie producenta
|
|
if ($p['man_image'])
|
|
{
|
|
$p['man_image'] = $options['images_folder'] . $p['man_image'];
|
|
}
|
|
|
|
// uzupełnienie powiązania z kategorią
|
|
if ($prodcat[$product_id])
|
|
{
|
|
$p['category_id'] = $prodcat[$product_id];
|
|
$p['category_name'] = $category_tree[$prodcat[$product_id]];
|
|
}
|
|
|
|
// warianty
|
|
$sql = "SELECT pov.id pov_id, if(isnull(povi.value), pov.opt_value, povi.value) name,
|
|
pov.price, pov.stock, depth, product_options_field_id field_id,
|
|
pov.use_product sku
|
|
FROM `${dbp}st_product_options_value` pov
|
|
LEFT JOIN `${dbp}st_product_options_value_i18n` povi ON povi.id = pov.id AND culture = '${options['lang']}'
|
|
WHERE pov.product_id = {0} AND NOT isnull(pov.opt_value)
|
|
ORDER by pov.depth, pov.lft";
|
|
$res2 = DB_Query($sql, $product_id);
|
|
|
|
$multiopt2 = array(array('name' => '', 'price' => $p['price']));
|
|
$depth = 0;
|
|
$field_id = 0;
|
|
|
|
while ($opt = DB_Fetch($res2))
|
|
{
|
|
if ($opt['depth'] != $depth)
|
|
{
|
|
$depth_col = 0;
|
|
$multiopt = $multiopt2;
|
|
$multiopt2 = array();
|
|
$depth = $opt['depth'];
|
|
}
|
|
elseif ($opt['field_id'] != $field_id)
|
|
{
|
|
$depth_col++;
|
|
}
|
|
|
|
$v = array(
|
|
'id' => $opt['pov_id'],
|
|
'name' => $multiopt[$depth_col]['name'] . ' ' . $opt['name'],
|
|
'quantity' => (int)$opt['stock'],
|
|
'price' => $opt['price'],
|
|
'sku' => $opt['sku'],
|
|
);
|
|
|
|
if (!$opt['price'])
|
|
{
|
|
$v['price'] = $multiopt[$depth_col]['price']; //cena z poprzedniego poziomu
|
|
}
|
|
// opcja zmienia cenę o N %
|
|
elseif (preg_match('/[\+-](\d+)%/', $v['price'], $m))
|
|
{
|
|
$v['price'] = number_format($multiopt[$depth_col]['price']*(100+$m[1])/100, 2, '.', '');
|
|
}
|
|
// opcja zmienia cenę o określoną kwotę
|
|
elseif (preg_match('/[\+-](\d+)/', $v['price'], $m))
|
|
{
|
|
$v['price'] = number_format($multiopt[$depth_col]['price']+$m[1], 2, '.', '');
|
|
}
|
|
|
|
$multiopt2[] = $v;
|
|
$field_id = $opt['field_id'];
|
|
}
|
|
|
|
$p['variants'] = array();
|
|
|
|
foreach ($multiopt2 as $v)
|
|
{
|
|
if (!$v['id']) { continue; }
|
|
|
|
$p['variants'][$v['id']] = array(
|
|
'full_name' => $p['name'] . ' ' . $v['name'],
|
|
'name' => $v['name'],
|
|
'price' => $v['price'],
|
|
'quantity' => $v['quantity'],
|
|
'sku' => $v['sku'],
|
|
);
|
|
}
|
|
|
|
// pobieranie obrazków
|
|
$p['images'] = array();
|
|
|
|
$sql = "SELECT relative_path, filename
|
|
FROM `${dbp}st_product_has_sf_asset` sphsa
|
|
JOIN `${dbp}sf_asset` sa ON sphsa.sf_asset_id = sa.id
|
|
JOIN `${dbp}sf_asset_folder` saf ON sa.folder_id = saf.id
|
|
WHERE sphsa.product_id = '{0}'
|
|
ORDER BY `is_default` DESC";
|
|
$res2 = DB_Query($sql, $product_id);
|
|
$images = array();
|
|
|
|
while ($img = DB_Fetch($res2))
|
|
{
|
|
$p['images'][] = "${options['images_folder']}${img['relative_path']}/${img['filename']}";
|
|
}
|
|
|
|
//pobieranie cech produktu (np. długość, kolor, rozmiar itp.)
|
|
$p['features'] = array();
|
|
|
|
$sql = "SELECT a.opt_name AS name, av.opt_value AS value
|
|
FROM `${dbp}app_product_attribute_variant_has_product` vhp
|
|
INNER JOIN `${dbp}app_product_attribute_variant` av ON av.id = vhp.variant_id
|
|
INNER JOIN `${dbp}app_product_attribute_has_variant` ahv ON ahv.variant_id = vhp.variant_id
|
|
INNER JOIN `${dbp}app_product_attribute` a ON a.id = ahv.attribute_id
|
|
WHERE vhp.product_id = '{0}' AND a.is_visible_on_pp";
|
|
$res2 = DB_Query($sql, $product_id);
|
|
|
|
while ($f = DB_Fetch($res2))
|
|
{
|
|
$p['features'][$f['name']] = isset($features[$f['name']]) ? ($features[$f['name']] . ", ${f['value']}") : $f['value'];
|
|
}
|
|
|
|
foreach (array_keys($p['features']) as $f)
|
|
{
|
|
$p['features'][] = array($f, $p['features'][$f]); unset($p['features'][$f]);
|
|
}
|
|
|
|
//pobieranie wartości tagu [special] z zewnętrznego skryptu
|
|
//poniższy warunek może pozostać identyczny niezależnie od platformy sklepu
|
|
if (file_exists("baselinker_extra.php"))
|
|
{
|
|
//pobranie dodatkowych informacji z zewnętrznego pliku pliku.
|
|
//Plik tworzony jest indywidualnie dla każdego sprzedawcy jeśli zgłosi potrzebę pobierania dodatkowych danych ze sklepu.
|
|
//Pozwala to uniknąć ingerowania w standardowy plik baselinker.php
|
|
include("baselinker_extra.php");
|
|
}
|
|
|
|
|
|
//wyrzucanie niepotrzebnych wartości jeśli określono pola do pobrania
|
|
//poniższy kod może pozostać identyczny niezależnie od platformy sklepu
|
|
if (!(count($request['fields']) == 1 && $request['fields'][0] == "") && !count($request['fields']) == 0)
|
|
{
|
|
$temp_p = array();
|
|
foreach($request['fields'] as $field)
|
|
{$temp_p[$field] = $p[$field];}
|
|
$p = $temp_p;
|
|
}
|
|
|
|
$response[$product_id] = $p;
|
|
}
|
|
|
|
return $response;
|
|
}
|
|
|
|
|
|
/**
|
|
* Funkcja zwraca stan magazynowy wszystkich produktów i ich wariantów
|
|
* @global array $options : tablica z ustawieniami ogólnymi z początku pliku
|
|
* @param array $request tablica z żadaniem od systemu, w przypadku tej funkcji nie używana
|
|
* @return array $response tablica ze stanem magazynowym wszystkich produktów, w formacie:
|
|
* id produktu => ID produktu jest kluczem tablicy, wartością jest tablica składająca się ze stanów wariantów
|
|
* id wariantu => kluczem tablicy jest ID wariantu (0 w przypadku produktu głównego)
|
|
* stan => wartościa jest stan magazynowy
|
|
* Przykład: array('432' => array('0' => 4, '543' => 2, '567' => 3)) - produkt ID 432, stan głównego produktu to 4, posiada dwa warianty (ID 543 i 563) o stanach 2 i 3.
|
|
*/
|
|
function Shop_ProductsQuantity($request)
|
|
{
|
|
global $options; //globalna tablica z ustawieniami
|
|
$dbp = $options['db_prefix']; //Data Base Prefix - prefix tabel bazy
|
|
|
|
$response = array();
|
|
|
|
$sql = "SELECT p.id product_id, p.stock qty,
|
|
pov.id pov_id, pov.stock, pov.depth
|
|
FROM `${dbp}st_product` p
|
|
LEFT JOIN `${dbp}st_product_options_value` pov ON pov.product_id = p.id AND NOT isnull(pov.product_options_value_id)
|
|
ORDER by p.id, pov.depth DESC";
|
|
$res = DB_Query($sql, $product_id);
|
|
//TODO join with product_options_value_id = null to get true main product count
|
|
//or check for null in the loop! Also fix PL with join to pov
|
|
//Actually here just use the last level without all this fuancy logic!
|
|
|
|
$prod_id = 0;
|
|
$depth = 0;
|
|
|
|
while ($opt = DB_Fetch($res))
|
|
{
|
|
if ($prod_id == $opt['product_id'] and $depth > $opt['depth'])
|
|
{
|
|
continue;
|
|
}
|
|
|
|
$response[$opt['product_id']][0] = (int)$opt['qty'];
|
|
|
|
if ($opt['pov_id'])
|
|
{
|
|
$response[$opt['product_id']][$opt['pov_id']] = (int)$opt['stock'];
|
|
}
|
|
|
|
$prod_id = $opt['product_id'];
|
|
$depth = $opt['depth'];
|
|
}
|
|
|
|
return $response;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Funkcja ustawia stan magazynowy wybranych produktów i ich wariantów
|
|
* @global array $options : tablica z ustawieniami ogólnymi z początku pliku
|
|
* @param array $request tablica z żadaniem od systemu:
|
|
* products => tablica zawierająca informacje o zmianach stanu produktu. Każdy element tablicy jest również tablicą składającą się z pól:
|
|
* product_id => ID produktu
|
|
* variant_id => ID wariantu (0 jeśli produkt główny)
|
|
* operation => rodzaj zmiany, dopuszczalne wartości to: 'set' (ustawia konkretny stan), 'change' (dodaje do stanu magazynowego, ujemna liczba w polu quantity zmniejszy stan o daną ilość sztuk, dodatnia zwiększy)
|
|
* quantity => zmiana stanu magazynowego (ilośc do ustawienia/zmniejszenia/zwiększenia zależnie od pola operation)
|
|
* @return array $response tablica zawierajaca pole z ilością zmienionych produktów:
|
|
* counter => ilość zmienionych produktów
|
|
*/
|
|
function Shop_ProductsQuantityUpdate($request)
|
|
{ global $options; // globalna tablica z ustawieniami
|
|
$dbp = $options['db_prefix']; // Data Base Prefix - prefix tabel bazy
|
|
|
|
foreach ($request['products'] as $prod)
|
|
{
|
|
$prod['quantity'] = (int)$prod['quantity'];
|
|
|
|
if ($prod['variant_id'])
|
|
{
|
|
$sql = "SELECT stock, lft, rgt FROM `${dbp}st_product_options_value`
|
|
WHERE product_id = '{0}' AND id = '{1}'";
|
|
$res = DB_Query($sql, $prod['product_id'], $prod['variant_id']);
|
|
|
|
if (!DB_NumRows($res))
|
|
{
|
|
continue; // nie znaleziono wariantu
|
|
}
|
|
|
|
$node = DB_Fetch($res);
|
|
}
|
|
|
|
if ($prod['operation'] == 'change') // zmiana względem aktualnego stanu
|
|
{
|
|
$mod = "if(stock >= -${prod['quantity']}, stock+${prod['quantity']}, 0)";
|
|
}
|
|
elseif ($prod['variant_id']) // podana liczba sztuk wariantu
|
|
{
|
|
// dla wszystkich powiązanych rekordów (gałęzie pov + produkt gł)
|
|
// używamy wartości względnej
|
|
$prod['quantity'] = $prod['quantity'] - (int)$node['stock'];
|
|
$mod = "if(stock >= -${prod['quantity']}, stock+${prod['quantity']}, 0)";
|
|
}
|
|
else // ustawienie konkretnej ilości sztuk dla produktu głównego
|
|
{
|
|
$mod = $prod['quantity'];
|
|
}
|
|
|
|
// aktualizacja stanu produktu głównego w tabeli st_product
|
|
DB_Query("UPDATE `${dbp}st_product` SET stock = $mod WHERE id = '{0}'", $prod['product_id']);
|
|
|
|
// aktualizacja stanu produktu głównego w tabeli st_product_options_value
|
|
DB_Query("UPDATE `${dbp}st_product_options_value` SET stock = $mod
|
|
WHERE product_id = '{0}' AND depth = 0", $prod['product_id']);
|
|
|
|
if ($prod['variant_id'])
|
|
{
|
|
$upd = "UPDATE `${dbp}st_product_options_value` SET stock = $mod
|
|
WHERE product_id = {0} AND id = {1}";
|
|
|
|
// aktualizacja stanów wszystkich atrybutów wariantu
|
|
$sql = "SELECT id FROM `${dbp}st_product_options_value`
|
|
WHERE product_id = {0} AND depth > 0 AND lft <= {1} AND rgt >= {2}";
|
|
$res = DB_Query($sql, $prod['product_id'], $node['lft'], $node['rgt']);
|
|
|
|
while ($opt = DB_Fetch($res))
|
|
{
|
|
DB_Query($upd, $prod['product_id'], $opt['id']);
|
|
}
|
|
}
|
|
}
|
|
|
|
return array('counter' => count($request['products']));
|
|
}
|
|
|
|
|
|
/**
|
|
* Funkcja tworzy zamówienie w sklepie na podstawie nadesłanych danych
|
|
* Jeśli funkcja otrzyuje na wejściu ID zamówienia, aktualizuje dane zamówienie zamiast tworzyć nowe
|
|
* @global array $options : tablica z ustawieniami ogólnymi z początku pliku
|
|
* @param array $request tablica z żadaniem od systemu, zawiera informacje o zamówieniu w formacie:
|
|
* previous_order_id => ID zamówienia (jeśli pierwszy raz dodawane do sklepu, wartość jest pusta. Jeśli było już wcześniej dodane, wartość zawiera poprzedni numer zamówienia)
|
|
* delivery_fullname, delivery_company, delivery_address, delivery_city, delivery_postcode, delivery_country => dane dotyczące adresu wysyłki
|
|
* invoice_fullname, invoice_company, invoice_address, invoice_city, invoice_postcode, invoice_country, invoice_nip => dane dotyczące adresu płatnika faktury
|
|
* phone => nr telefonu, email => adres email,
|
|
* delivery_method => nazwa sposóbu wysyłki, delivery_method_id => numer ID sposobu wysyłki, delivery_price => cena wysyłki
|
|
* user_comments => komentarz kupującego, currency => waluta zamówienia, status_id => status nowego zamówienia
|
|
* change_products_quantity => flaga (bool) informująca, czy po stworzeniu zamówienia zmniejszony ma zostać stan zakupionych produktów
|
|
* products => tablica z zakupionymi produktami w formacie:
|
|
* [] =>
|
|
* id => ID produktu
|
|
* variant_id => ID wariantu
|
|
* name => nazwa produktu (używana jeśli nie można pobrać jej z bazy na podstawie id)
|
|
* price => cena brutto w PLN
|
|
* currency => waluta
|
|
* quantity => zakupiona ilość
|
|
* attributes => tablica z atrybutami produktu w formacie:
|
|
* [] =>
|
|
* name => nazwa atrybutu (np. "kolor")
|
|
* value => wartość atybutu (np. "czerwony")
|
|
* price => różnica ceny dla tego produktu (np. "-10.00")
|
|
* zmiana ceny jest już uwzględniona w cenie produktu
|
|
* @return array $response tablica zawierająca numer nowego zamówienia:
|
|
* 'order_id' => numer utworzonego zamówienia
|
|
*/
|
|
function Shop_OrderAdd($request)
|
|
{
|
|
global $options; // globalna tablica z ustawieniami
|
|
$dbp = $options['db_prefix']; // Data Base Prefix - prefix tabel bazy
|
|
|
|
// zdefiniowanie waluty
|
|
$request['currency'] = $request['currency'] ? $request['currency'] : 'PLN';
|
|
$sql = "SELECT * FROM `${dbp}st_currency` WHERE shortcut = '${request['currency']}' LIMIT 1";
|
|
$res = DB_Query($sql);
|
|
$currency = DB_Fetch($res);
|
|
|
|
// jeśli zamówienie jest ponownie dodawane do bazy sklepu, wcześniejsze dane są usuwane
|
|
// przy ponownym dodawaniu zamówienia (aktualizowaniu), $request['previous_order_id'] zawiera poprzedni numer danego zamówienia w sklepie
|
|
if ($request['previous_order_id'] != "")
|
|
{
|
|
$sql = "SELECT o.* FROM `${dbp}st_order` o WHERE o.id = '${request['previous_order_id']}' ";
|
|
$old = DB_Fetch(DB_Query($sql));
|
|
|
|
DB_Query("DELETE FROM `${dbp}st_order_delivery` WHERE `id` = '{0}'", $old['order_delivery_id']);
|
|
DB_Query("DELETE FROM `${dbp}st_order_user_data_billing` WHERE `id` = '{0}'", $old['order_user_data_billing_id']);
|
|
DB_Query("DELETE FROM `${dbp}st_order_user_data_delivery` WHERE `id` = '{0}'", $old['order_user_data_delivery_id']);
|
|
DB_Query("DELETE FROM `${dbp}st_order_currency` WHERE `id` = '{0}'", $old['order_currency_id']);
|
|
DB_Query("DELETE FROM `${dbp}st_order_product` WHERE `order_id` = '{0}'", $old['id']);
|
|
DB_Query("DELETE FROM `${dbp}st_order` WHERE `id` = '{0}'", $old['id']);
|
|
}
|
|
|
|
// dodawanie waluty zamówienia
|
|
$sql = "INSERT INTO `${dbp}st_order_currency` (created_at, updated_at,
|
|
exchange, shortcut, front_symbol, back_symbol, name)
|
|
VALUES (now(), now(), '{0}', '{1}', '{2}', '{3}', '{4}')";
|
|
$res = DB_Query($sql, $currency['exchange'], $request['currency'], $currency['front_symbol'],
|
|
$currency['back_symbol'], $currency['opt_name']);
|
|
$currency_id = DB_Identity();
|
|
|
|
// pobieranie id kraju
|
|
$sql = "SELECT id FROM `${dbp}st_countries`
|
|
WHERE iso_a2 = '{0}' OR opt_name = '{1}' LIMIT 1";
|
|
$invoice_country_id = DB_Result(DB_Query($sql, $request['invoice_country_code'], $request['invoice_country']));
|
|
|
|
$sql = "SELECT id FROM `${dbp}st_countries`
|
|
WHERE iso_a2 = '{0}' OR opt_name = '{1}' LIMIT 1";
|
|
$delivery_country_id = DB_Result(DB_Query($sql, $request['delivery_country_code'], $request['delivery_country']));
|
|
|
|
// język
|
|
$culture = strtolower($request['invoice_country_code']);
|
|
|
|
if ($culture == 'pl')
|
|
{
|
|
$culture .= '_PL';
|
|
}
|
|
elseif ($culture == 'uk' or $culture == 'us' or $culture == 'au' or $culture == 'ca' or $culture == 'ie' or $culture == 'gb')
|
|
{
|
|
$culture = 'en_US';
|
|
}
|
|
|
|
|
|
// sprawdzanie czy użytkownik już istnieje w bazie danych
|
|
$sql = "SELECT id FROM `${dbp}sf_guard_user` WHERE username = '{0}'";
|
|
$res = DB_Query($sql, $request['email']);
|
|
|
|
if (DB_NumRows($res) > 0)
|
|
{
|
|
$user_id = DB_Result($res);
|
|
}
|
|
else
|
|
{
|
|
// dodawanie użytkownika do tabeli sf_guard_user
|
|
$sql = "INSERT INTO `${dbp}sf_guard_user`
|
|
(username, algorithm, salt, password, created_at,
|
|
last_login, is_active, is_super_admin, is_confirm, is_admin_confirm,
|
|
hash_code, language, external_account, wholesale, points,
|
|
points_available, points_release) VALUES
|
|
('{0}', 'sha1', 'allegro_user', 'allegro_user', '{1}',
|
|
'{1}', 1, 0, 0, 0,
|
|
'{2}', '{3}', NULL, NULL, 0,
|
|
1, 0);";
|
|
DB_Query($sql, $request['email'], date('Y-m-d H:i:s'), md5(microtime(true)*rand(10,10000000)), $culture);
|
|
$user_id = DB_Identity();
|
|
|
|
$sql = "INSERT INTO `sf_guard_user_group` (`user_id`, `group_id`) VALUES ('{0}', 2);";
|
|
DB_Query($sql, $user_id);
|
|
}
|
|
|
|
$invoice_street = explode(' ',$request['invoice_address']);
|
|
$invoice_house = array_pop($invoice_street);
|
|
$invoice_street = implode(' ',$invoice_street);
|
|
|
|
$request['invoice_country'] = $request['invoice_country'] ? $request['invoice_country'] : 'Polska';
|
|
$request['delivery_country'] = $request['delivery_country'] ? $request['delivery_country'] : 'Polska';
|
|
|
|
// dodawanie adresu płatnika do tabeli st_order_user_data_billing
|
|
$sql = "INSERT INTO `${dbp}st_order_user_data_billing` (
|
|
created_at, updated_at, country , full_name, company,
|
|
address ,code , town , street, house,
|
|
phone, vat_number, countries_id) VALUES (
|
|
'{0}', '{0}', '{1}', '{2}', '{3}',
|
|
'{4}', '{5}', '{6}', '{7}', '{8}',
|
|
'{9}' , '{10}', '{11}')";
|
|
DB_Query($sql, date('Y-m-d H:i:s'), $request['invoice_country'], $request['invoice_fullname'], $request['invoice_company'],
|
|
$request['invoice_address'], $request['invoice_postcode'], $request['invoice_city'], $invoice_street, $invoice_house,
|
|
$request['phone'] , $request['invoice_nip'], $invoice_country_id);
|
|
$invoice_address_id = DB_Identity();
|
|
|
|
$delivery_street = explode(' ', $request['delivery_address']);
|
|
$delivery_house = array_pop($delivery_street);
|
|
$delivery_street = implode(' ', $delivery_street);
|
|
|
|
// dodawanie adresu dostawy do tabeli st_order_user_data_delivery
|
|
$sql = "INSERT INTO `${dbp}st_order_user_data_delivery` (
|
|
created_at, updated_at, country, full_name, company,
|
|
address, code, town, street, house,
|
|
phone, countries_id) VALUES (
|
|
'{0}', '{0}', '{1}', '{2}', '{3}',
|
|
'{4}', '{5}', '{6}', '{7}', '{8}',
|
|
'{9}', '{10}')";
|
|
DB_Query($sql, date('Y-m-d H:i:s'), $request['delivery_country'], $request['delivery_fullname'], $request['delivery_company'],
|
|
$request['delivery_address'], $request['delivery_postcode'], $request['delivery_city'], $delivery_street, $delivery_house,
|
|
$request['phone'], $delivery_country_id);
|
|
$delivery_address_id = DB_Identity();
|
|
|
|
// VAT kosztów wysyłki
|
|
$sql = "SELECT d.tax_id, t.vat
|
|
FROM `${dbp}st_delivery` d JOIN `st_tax` t ON d.tax_id = t.id
|
|
ORDER BY (d.id = '{0}') DESC, d.is_default DESC, d.is_system_default DESC LIMIT 1";
|
|
$res = DB_Query($sql, $request['delivery_method_id']);
|
|
|
|
if (!($delivery_tax = DB_Fetch($res)))
|
|
{
|
|
$delivery_tax = array('tax_id' => 0, 'vat' => 23);
|
|
}
|
|
|
|
// dodawanie informacji o dostawie do tabeli st_order_delivery
|
|
$delivery_netto = number_format($request['delivery_price']/(100+$delivery_tax['vat'])*100, 2, '.', '');
|
|
$sql = "INSERT INTO `${dbp}st_order_delivery`
|
|
(created_at, updated_at, name, cost, opt_tax,
|
|
cost_brutto, delivery_id, tax_id)
|
|
VALUES ('{0}', '{0}', '{1}', '{2}', '{3}',
|
|
'{4}', '{5}', '{6}')";
|
|
DB_Query($sql, date('Y-m-d H:i:s'), $request['delivery_method'], $delivery_netto, $delivery_tax['vat'], $request['delivery_price'],
|
|
$request['delivery_method_id'], $delivery_tax['tax_id']);
|
|
$delivery_id = DB_Identity();
|
|
|
|
// karta klienta - adresy dostawy i płatności
|
|
$sql = "INSERT INTO `${dbp}st_user_data`
|
|
(crypt, created_at, updated_at, is_billing, is_default,
|
|
sf_guard_user_id, countries_id, street, house, code,
|
|
town, phone, full_name, address)
|
|
VALUES
|
|
(0, '{0}', '{0}', {10}, 0,
|
|
{1}, '{2}', '{3}', '{4}', '{5}',
|
|
'{6}', '{7}', '{8}', '{9}')";
|
|
DB_Query($sql, date('Y-m-d H:i:s'),
|
|
$user_id, $invoice_country_id, $invoice_street, $invoice_house, $request['invoice_postcode'],
|
|
$request['invoice_city'], $request['phone'], $request['invoice_fullname'], $request['invoice_address'], 1);
|
|
DB_Query($sql, date('Y-m-d H:i:s'),
|
|
$user_id, $delivery_country_id, $delivery_street, $delivery_house, $request['delivery_postcode'],
|
|
$request['delivery_city'], $request['phone'], $request['delivery_fullname'], $request['delivery_address'], 0);
|
|
|
|
// klucz bezpieczeństwa klienta
|
|
$secure_key = md5(microtime(true)*rand(10,10000000));
|
|
$secure_key2 = md5(microtime(true)*rand(10,10000000));
|
|
|
|
// wyliczanie całkowitego kosztu zamówienia
|
|
$total_sum = 0;
|
|
|
|
foreach ($request['products'] as $prod)
|
|
{
|
|
$total_sum += $prod['price'] * $prod['quantity'];
|
|
}
|
|
|
|
$total_sum += $request['delivery_price'];
|
|
|
|
// pobieranie numeru ostatniego zamowienia
|
|
if ($request['previous_order_id'] != '')
|
|
{
|
|
$last_nr = $request['previous_order_id'];
|
|
}
|
|
else
|
|
{
|
|
$sql = "SELECT number FROM `${dbp}st_order` ORDER BY ABS(number) DESC LIMIT 1";
|
|
$res = DB_Query($sql);
|
|
$last_nr = (int)DB_Result($res)+1;
|
|
}
|
|
|
|
// dodanie zamowienia do tabeli orders
|
|
$sql = "INSERT INTO `${dbp}st_order` (
|
|
created_at, updated_at, id, order_delivery_id, order_user_data_delivery_id,
|
|
order_user_data_billing_id, order_currency_id, order_status_id, sf_guard_user_id, hash_code,
|
|
number, description, client_culture, is_confirmed, opt_client_name,
|
|
opt_client_email, opt_client_company, opt_total_amount)
|
|
VALUES ('{0}', '{0}', '{1}' , '{2}', '{3}',
|
|
'{4}', '{5}', '{6}', '{7}', '{8}',
|
|
'{9}', '{10}', '{11}', '1', '{12}',
|
|
'{13}', '{14}', '{15}')";
|
|
DB_Query($sql, date('Y-m-d H:i:s'), $request['previous_order_id'], $delivery_id, $delivery_address_id,
|
|
$invoice_address_id, $currency_id, $request['status_id'], $user_id, $secure_key,
|
|
$last_nr, $request['user_comments'], $culture, $request['invoice_fullname'],
|
|
$request['email'], $request['invoice_company'], $total_sum);
|
|
// pobieranie numeru nowego zamówienia
|
|
$this_order_id = $request['previous_order_id'] ? $request['previous_order_id'] : DB_Identity();
|
|
|
|
// typ płatności
|
|
$sql = "SELECT id FROM `${dbp}st_payment_type`
|
|
WHERE active ORDER BY (module_name = 'stStandardPayment') DESC,
|
|
(opt_name {0} like '%pobran%') DESC LIMIT 1";
|
|
$res = DB_Query($sql, $request['payment_method_cod'] ? '' : 'not');
|
|
$payment_type_id = DB_Result($res);
|
|
|
|
// dodawanie płatności
|
|
$sql = "INSERT INTO `${dbp}st_payment`
|
|
(created_at, updated_at, sf_guard_user_id, payment_type_id, amount,
|
|
status, cancel, hash, version) VALUES
|
|
('{0}', '{0}', '{1}', '{2}', '{3}',
|
|
0, 0, '{4}', 2)";
|
|
DB_Query($sql, date('Y-m-d H:i:s'), $user_id, $payment_type_id, $total_sum, $secure_key2);
|
|
$this_payment_id = DB_Identity();
|
|
|
|
$sql = "INSERT INTO `${dbp}st_order_has_payment`
|
|
(created_at, updated_at, order_id, payment_id) VALUES
|
|
('{0}', '{0}', '{1}', '{2}')";
|
|
DB_Query($sql, date('Y-m-d H:i:s'), $this_order_id, $this_payment_id);
|
|
|
|
// obsługa produktów w zamówieniu
|
|
foreach ($request['products'] as $prod)
|
|
{
|
|
$sql = "SELECT * FROM `${dbp}st_product` p WHERE p.id = '{0}'";
|
|
$res = DB_Query($sql, $prod['id']);
|
|
$prod_data = DB_Fetch($res);
|
|
$price_netto = $prod['price'] / (1+$prod_data['opt_vat']/100);
|
|
$price_modifiers = array();
|
|
|
|
// obsługa wariantu
|
|
if ($prod['variant_id'])
|
|
{
|
|
$sql = "SELECT pov.depth, pov.lft, pov.rgt, pov.opt_value, pov.use_product,
|
|
pov.color, pof.opt_name
|
|
FROM `${dbp}st_product_options_value` pov
|
|
LEFT JOIN `${dbp}st_product_options_field` pof ON pof.id = pov.product_options_field_id
|
|
WHERE pov.product_id = '{0}' AND pov.id = '{1}'";
|
|
$res = DB_Query($sql, $prod['id'], $prod['variant_id']);
|
|
|
|
if (DB_NumRows($res))
|
|
{
|
|
$leaf = DB_Fetch($res);
|
|
|
|
$price_modifiers[] = array(
|
|
'value' => (float)0,
|
|
'type' => 'percent',
|
|
'level' => (int)$leaf['depth'],
|
|
'prefix' => '+',
|
|
'custom' => array(
|
|
'id' => (int)$prod['variant_id'],
|
|
'color' => $leaf['color'],
|
|
'field' => $leaf['opt_name'],
|
|
'type' => 'product_options',
|
|
),
|
|
'label' => $leaf['opt_value']
|
|
);
|
|
|
|
$prod_data['code'] = $leaf['use_product'];
|
|
|
|
// pozostałe opcje wyboru dla tego wariantu
|
|
$sql = "SELECT id, depth, opt_value
|
|
FROM `${dbp}st_product_options_value`
|
|
WHERE product_id = {0} AND depth > 0 AND lft < {1} and rgt > {2}
|
|
ORDER BY depth desc";
|
|
$res = DB_Query($sql, $prod['id'], $leaf['lft'], $leaf['rgt']);
|
|
|
|
while ($opt = DB_Fetch($res))
|
|
{
|
|
array_unshift($price_modifiers, array(
|
|
'value' => (float)0,
|
|
'type' => 'percent',
|
|
'level' => $opt['depth'],
|
|
'prefix' => '+',
|
|
'custom' => array(
|
|
'id' => (int)$opt['id'],
|
|
'type' => 'product_options',
|
|
),
|
|
'label' => $opt['opt_name'],
|
|
));
|
|
}
|
|
}
|
|
|
|
// nazwa produktu pobrana ze sklepu
|
|
if ($prod_data['name'] and $prod['name'])
|
|
{
|
|
$prod['name'] = $prod_data['name'];
|
|
}
|
|
}
|
|
|
|
|
|
// dodawanie produktu do zamowienia
|
|
$sql = "INSERT INTO `${dbp}st_order_product` (
|
|
created_at, updated_at, order_id, product_id, quantity,
|
|
code, name, image, price, price_brutto,
|
|
vat, price_modifiers, version, tax_id, discount)
|
|
VALUES (
|
|
'{0}', '{0}', '{1}', '{2}', '{3}',
|
|
'{4}', '{5}', '{6}', '{7}', '{8}',
|
|
'{9}', '{10}', '{11}', '{12}', '{13}')";
|
|
DB_Query($sql, date('Y-m-d H:i:s'), $this_order_id, $prod['id'], $prod['quantity'],
|
|
$prod_data['code'], $prod['name'], $prod_data['opt_image'], $price_netto, $prod['price'],
|
|
$prod_data['opt_vat'], serialize($price_modifiers), 3, $prod_data['tax_id'],
|
|
serialize(array()));
|
|
|
|
|
|
// zmniejszanie stanu magazynowego produktu (jeśli ustawiona flaga change_products_quantity)
|
|
if ($request['previous_order_id'] == '' and $request['change_products_quantity'])
|
|
{
|
|
Shop_ProductsQuantityUpdate(array('products' => array(array('product_id' => $prod['id'], 'variant_id' => $prod['variant_id'], 'operation' => 'change', 'quantity' => -1*$prod['quantity']))));
|
|
}
|
|
}
|
|
|
|
|
|
return array('order_id' => $this_order_id);
|
|
}
|
|
|
|
/**
|
|
* Funkcja pobiera zamówienia złożone w sklepie internetowym
|
|
* Zwracane liczby (np ceny) powinny mieć format typu: 123456798.12 (kropka oddziela część całkowitą, 2 miejsca po przecinku)
|
|
* @global array $options : tablica z ustawieniami ogólnymi z początku pliku
|
|
* @param array $request tablica z żadaniem od systemu, zawiera informacje o zamówieniu w formacie:
|
|
* time_from => czas od którego mają zastać pobrane zamówienia - format UNIX TIME
|
|
* id_from => ID od którego mają zastać pobrane zamówienia
|
|
* only_paid => flaga określająca czy pobierane mają być tylko zamówienia opłacone (0/1)
|
|
* @return array $response tablica zawierająca dane zamówień:
|
|
* id zamówienia => array:
|
|
* delivery_fullname, delivery_company, delivery_address, delivery_city, delivery_postcode, delivery_country => dane dotyczące adresu wysyłki
|
|
* invoice_fullname, invoice_company, invoice_address, invoice_city, invoice_postcode, invoice_country, invoice_nip => dane dotyczące adresu płatnika faktury
|
|
* phone => nr telefonu, email => adres email,
|
|
* date_add => data złożenia zamówienia,
|
|
* payment_method => nazwa metody płatności,
|
|
* user_comments => komentarz klienta do zamówienia,
|
|
* status_id => numer ID statusu zamówienia,
|
|
* delivery_method_id => numer ID metody wysyłki, delivery_method => nazwa metody wysyłki,
|
|
* delivery_price => cena wysyłki
|
|
* products => array:
|
|
* [] =>
|
|
* id => id produktu, variant_id => id wariantu produktu (0 jeśli produkt główny),
|
|
name => nazwa produktu
|
|
* quantity => zakupiona ilość, price => cena sztuki brutto (uwzględniająca atrybuty)
|
|
* weight => waga produktu w kg, tax => wysokość podatku jako liczba z zakresu 0-100
|
|
* attributes => array: - tablica z wybieralnymi atrybutami produktów (jeśli istnieją)
|
|
* [] =>
|
|
* name => nazwa atrybutu (np 'kolor'),
|
|
* value => wartość atrubutu (np 'czerwony'),
|
|
* price => różnica w cenie w stosunku do ceny standardowe
|
|
*/
|
|
function Shop_OrdersGet($request)
|
|
{
|
|
global $options; // globalna tablica z ustawieniami
|
|
$dbp = $options['db_prefix']; // Data Base Prefix - prefix tabel bazy
|
|
|
|
$response = array();
|
|
|
|
//dodatkowe dane dostawy w oddzielnej tabeli?
|
|
$sheepla_orders = DB_NumRows(DB_Query("SHOW TABLES LIKE '${dbp}sheepla_orders'"));
|
|
|
|
//formatowanie daty od której mają być pobrane zamówienia
|
|
$time_from = date("Y-m-d H:i:s", $request['time_from']);
|
|
$id_from = (int)$request['id_from'];
|
|
|
|
//zapytanie pobierające zamówienia od określonego czasu
|
|
$sql = "SELECT o.*, UNIX_TIMESTAMP(o.created_at) time_purchased, od.crypt od_crypt, ob.crypt ob_crypt,
|
|
od.full_name delivery_name, od.address delivery_street_address, od.address_more delivery_street_address2,
|
|
od.town delivery_city, od.code delivery_postcode, od.company delivery_company, od.phone delivery_phone,
|
|
ob.full_name customers_name, ob.address customers_street_address, ob.address_more customers_street_address2,
|
|
ob.town customers_city, ob.code customers_postcode, ob.company customers_company, ob.phone customers_phone,
|
|
ob.vat_number customers_nip, del.cost_brutto + if(del.payment_cost_brutto, del.payment_cost_brutto, 0) delivery_cost,
|
|
del.name delivery_method, oc.shortcut currency,
|
|
od.country delivery_country, ob.country customers_country, cod.name delivery_country_pl, cob.name customers_country_pl,
|
|
oc.exchange, obc.iso_a2 invoice_country_code, obd.iso_a2 delivery_country_code, del.delivery_id
|
|
FROM `${dbp}st_order` o
|
|
LEFT JOIN `${dbp}st_order_user_data_billing` ob ON ob.id = o.order_user_data_billing_id
|
|
LEFT JOIN `${dbp}st_order_user_data_delivery` od ON od.id = o.order_user_data_delivery_id
|
|
LEFT JOIN `${dbp}st_order_delivery` del ON del.id = o.order_delivery_id
|
|
LEFT JOIN `${dbp}st_order_currency` oc ON oc.id = o.order_currency_id
|
|
LEFT JOIN `${dbp}st_countries_i18n` cod ON cod.id = od.countries_id AND cod.culture LIKE 'pl%'
|
|
LEFT JOIN `${dbp}st_countries_i18n` cob ON cob.id = ob.countries_id AND cob.culture LIKE 'pl%'
|
|
LEFT JOIN `${dbp}st_countries` obc ON obc.id = od.countries_id
|
|
LEFT JOIN `${dbp}st_countries` obd ON obd.id = ob.countries_id
|
|
WHERE o.created_at >= '{0}' AND o.id >= {1}";
|
|
$res = DB_Query($sql, $time_from, $id_from);
|
|
|
|
while ($order = DB_Fetch($res))
|
|
{
|
|
$o = array('currency' => $order['currency']);
|
|
$o['delivery_fullname'] = $order['delivery_name'];
|
|
$o['delivery_company'] = $order['delivery_company'];
|
|
$o['delivery_address'] = Sote_Decrypt($order['delivery_street_address'], $order['od_crypt'])." ".Sote_Decrypt($order['delivery_street_address2'], $order['od_crypt']);
|
|
$o['delivery_city'] = Sote_Decrypt($order['delivery_city'], $order['od_crypt']);
|
|
$o['delivery_postcode'] = Sote_Decrypt($order['delivery_postcode'], $order['od_crypt']);
|
|
$o['delivery_country'] = $order['delivery_country_pl'] ? $order['delivery_country_pl'] : $order['delivery_country'];
|
|
$o['delivery_country_code'] = $order['delivery_country_code'];
|
|
|
|
$o['invoice_fullname'] = $order['customers_name'];
|
|
$o['invoice_company'] = $order['customers_company'];
|
|
$o['invoice_nip'] = $order['customers_nip'];
|
|
$o['invoice_address'] = Sote_Decrypt($order['customers_street_address'], $order['ob_crypt'])." ".Sote_Decrypt($order['customers_street_address2'], $order['ob_crypt']);
|
|
$o['invoice_city'] = Sote_Decrypt($order['customers_city'], $order['ob_crypt']);
|
|
$o['invoice_postcode'] = Sote_Decrypt($order['customers_postcode'], $order['ob_crypt']);
|
|
$o['invoice_country'] = $order['customers_country_pl'] ? $order['customers_country_pl'] : $order['customers_country'];
|
|
$o['invoice_country_code'] = $order['invoice_country_code'];
|
|
|
|
$o['phone'] = ($order['customers_telephone']!="")?Sote_Decrypt($order['customers_phone'], $order['ob_crypt']):Sote_Decrypt($order['delivery_phone'], $order['ob_crypt']);
|
|
$o['email'] = $order['opt_client_email'];
|
|
$o['date_add'] = $order['time_purchased'];
|
|
$o['payment_method'] = "";
|
|
$o['user_comments'] = $order['description'];
|
|
$o['delivery_method'] = $order['delivery_method'];
|
|
$o['delivery_method_id'] = $order['delivery_id'];
|
|
$o['status_id'] = $order['order_status_id'];
|
|
|
|
// dostawa do paczkomatu
|
|
if (preg_match('/^Paczkomat - (\w+)\s*$/', $o['delivery_company'], $m))
|
|
{
|
|
$o['delivery_point_name'] = $m[1];
|
|
|
|
foreach (array('address', 'city', 'country', 'postcode') as $fld)
|
|
{
|
|
$o["delivery_point_$fld"] = $o["delivery_$fld"];
|
|
}
|
|
}
|
|
elseif ($sheepla_orders)
|
|
{
|
|
$sql = "SELECT adddata FROM `${dbp}sheepla_orders` WHERE order_id = {0}";
|
|
|
|
if ($so_data = DB_Result(DB_Query($sql, $order['id'])))
|
|
{
|
|
if ($so_data = @unserialize($so_data))
|
|
{
|
|
if ($so_data['sheepla-widget-plinpost-paczkomat'])
|
|
{
|
|
$o['delivery_point_name'] = $so_data['sheepla-widget-plinpost-paczkomat'];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// jeśli zamówienie jest w walucie innej niż PLN, trzeba przeliczyć koszt wysyłki
|
|
if ($order['currency'] != 'PLN' and $order['exchange'])
|
|
{
|
|
$order['delivery_cost'] /= $order['exchange'];
|
|
}
|
|
|
|
$o['delivery_price'] = number_format($order['delivery_cost'], 2, ".", "");
|
|
|
|
// czy klient chce fakturę
|
|
if ($o['invoice_nip'])
|
|
{
|
|
$o['want_invoice'] = 1;
|
|
}
|
|
|
|
// sposób platności
|
|
$sql = "SELECT pt.opt_name, p.payed_at
|
|
FROM `${dbp}st_order_has_payment` op
|
|
JOIN `${dbp}st_payment` p ON p.id = op.payment_id
|
|
JOIN `${dbp}st_payment_type` pt ON pt.id = p.payment_type_id
|
|
WHERE op.order_id = '{0}' LIMIT 1";
|
|
$result = DB_Query($sql, $order['id']);
|
|
|
|
if ($payment = DB_Fetch($result))
|
|
{
|
|
$o['payment_method'] = $payment['opt_name'];
|
|
$o['paid'] = $payment['payed_at'] ? 1 : 0;
|
|
|
|
if (preg_match('/pobran|przy odb/i', $o['payment_method']))
|
|
{
|
|
$o['payment_method_cod'] = 1;
|
|
}
|
|
}
|
|
|
|
//produkty zamówienia
|
|
$o['products'] = array();
|
|
$total_products = 0;
|
|
$sql = "SELECT op.*, p.weight, p.code
|
|
FROM `${dbp}st_order_product` op
|
|
LEFT JOIN `${dbp}st_product` p ON p.id = op.product_id
|
|
WHERE op.order_id = '{0}' ";
|
|
$result = DB_Query($sql, $order['id']);
|
|
|
|
while ($product = DB_Fetch($result))
|
|
{
|
|
$op = array(
|
|
'id' => $product['product_id'],
|
|
'name' => $product['name'],
|
|
'quantity' => $product['quantity'],
|
|
'price' => $product['price_brutto'],
|
|
'tax' => $product['vat'],
|
|
'weight' => $product['weight'],
|
|
'sku' => $product['code'],
|
|
);
|
|
|
|
if ($product['price_modifiers'] != '')
|
|
{
|
|
$opts = unserialize($product['price_modifiers']);
|
|
$depth = 0;
|
|
|
|
foreach ($opts as $opt)
|
|
{
|
|
// modyfikacja ceny
|
|
if (!empty($opt['value']))
|
|
{
|
|
if ($opt['prefix'] == '-')
|
|
{
|
|
$opt['value'] = -$opt['value'];
|
|
}
|
|
|
|
if ($opt['type'] == 'percent')
|
|
{
|
|
$op['price'] = $opt['price'] + $opt['value']*$opt['price']/100;
|
|
}
|
|
else
|
|
{
|
|
if (is_array($opt['value']))
|
|
{
|
|
if ($opt['value']['brutto'])
|
|
{
|
|
$op['price'] = $opt['value']['brutto'];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$op['price'] += $opt['value'];
|
|
}
|
|
}
|
|
}
|
|
|
|
// id odstatniego poziomu zagłębienia identyfikuje wariant
|
|
if ($opt['level'] > $depth and !empty($opt['custom']) and $opt['custom']['type'] == 'product_options')
|
|
{
|
|
$op['variant_id'] = $opt['custom']['id'];
|
|
$depth = $opt['level'];
|
|
}
|
|
|
|
$op['name'] .= ' ' . $opt['label'];
|
|
}
|
|
|
|
$op['price'] = number_format($op['price'],2,".","");
|
|
}
|
|
|
|
if($product['discount'] != "")
|
|
{
|
|
$discounts = unserialize($product['discount']);
|
|
foreach($discounts as $d)
|
|
{
|
|
if($d['type'] == "%")
|
|
{$op['price'] *= 1-($d['value']/100);}
|
|
else
|
|
{$op['price'] -= $d['value'];}
|
|
|
|
$op['price'] = number_format($op['price'],2,".","");
|
|
}
|
|
}
|
|
|
|
$total_products += $op['price']*$op['quantity'];
|
|
$o['products'][] = $op;
|
|
}
|
|
|
|
// rabat od całości zamówienia
|
|
if ($order['discount_id'] and $order['order_discount'])
|
|
{
|
|
if ($discount = @unserialize($order['order_discount']))
|
|
{
|
|
if ($discount['value'])
|
|
{
|
|
$op = array('name' => 'Rabat', 'quantity' => 1, 'id' => '', 'tax' => 0);
|
|
|
|
// ustalenie nazwy rabatu
|
|
$sql = "SELECT name FROM `${dbp}st_discount` WHERE id = '{0}'";
|
|
|
|
if ($dname = DB_Result(DB_Query($sql, $order['discount_id'])))
|
|
{
|
|
$op['name'] = preg_match('/rabat/i', $dname) ? $dname : "Rabat $dname";
|
|
}
|
|
|
|
if ($discount['type'] == '%') // rabat procentowy
|
|
{
|
|
$op['price'] = number_format(-$discount['value']*$total_products/100, 2, '.', '');
|
|
}
|
|
else // rabat kwotowy
|
|
{
|
|
$op['price'] = -$discount['value'];
|
|
}
|
|
|
|
$o['products'][] = $op;
|
|
}
|
|
}
|
|
}
|
|
|
|
$response[$order['id']] = $o;
|
|
}
|
|
|
|
|
|
return $response;
|
|
}
|
|
|
|
/**
|
|
* Funkcja aktualizuje zamówienia wcześniej dodane do bazy
|
|
* W przypadku zapisywania numeru nadawaczego, parametr orders_ids będzie przyjmował zawsze tablicę z jedną pozycją
|
|
* @global array $options : tablica z ustawieniami ogólnymi z początku pliku
|
|
* @param array $request tablica z żadaniem od systemu, zawiera informacje o aktualizacji zamówienia w formacie:
|
|
* orders_ids => ID zamówień
|
|
* update_type => typ zmiany - 'status', `delivery_number`, lub 'paid' (aktualizacja statusu zamówienia, dodanie numeru nadawczego i dodanie/usunięcie wpłaty)
|
|
* update_value => aktualizowana wartość - ID statusu, numer nadawczy lub informacja o opłaceniu zamówienia (bool true/false)
|
|
* @return array $response tablica zawierająca potwierdzenie zmiany:
|
|
* 'counter' => ilość zamówień w których dokonano zmiany (nawet jeśli zamówienie pozostało takie jak wcześniej)
|
|
*/
|
|
function Shop_OrderUpdate($request)
|
|
{
|
|
global $options; // globalna tablica z ustawieniami
|
|
$dbp = $options['db_prefix']; // Data Base Prefix - prefix tabel bazy
|
|
|
|
$counter = 0;
|
|
|
|
// dla wszystkich nadesłanych numerów zamówień
|
|
foreach($request['orders_ids'] as $order_id)
|
|
{
|
|
// zmiana statusu
|
|
if ($request['update_type'] == 'status')
|
|
{
|
|
DB_Query("UPDATE `${dbp}st_order` SET order_status_id = '{0}', updated_at = '{1}' WHERE id = '{2}'",
|
|
$request['update_value'], date('Y-m-d H:i:s'), $order_id);
|
|
}
|
|
|
|
// zapisanie numeru nadawczego
|
|
elseif ($request['update_type'] == 'delivery_number')
|
|
{
|
|
DB_Query("UPDATE `${dbp}st_order_delivery` SET number = '{0}'
|
|
WHERE id = (SELECT order_delivery_id FROM `${dbp}st_order` WHERE id = '{1}')
|
|
LIMIT 1", $request['update_value'], $order_id);
|
|
}
|
|
|
|
// zmiana statusu wpłaty
|
|
elseif ($request['update_type'] == 'paid')
|
|
{
|
|
DB_Query("UPDATE `${dbp}st_payment` SET updated_at = '{0}', status = '{2}',
|
|
payed_at = " . ($request['update_value'] ? '"{0}"' : 'NULL') .
|
|
" WHERE id = (SELECT payment_id FROM `${dbp}st_order_has_payment`
|
|
WHERE order_id = '{1}' ORDER BY created_at DESC LIMIT 1) LIMIT 1",
|
|
date('Y-m-d H:i:s'), $order_id, $request['update_value'] ? 1 : 0);
|
|
DB_Query("UPDATE `${dbp}st_order` SET opt_is_payed = '{0}' WHERE id = '{1}'",
|
|
$request['update_value'] ? 1 : 0, $order_id);
|
|
}
|
|
|
|
$counter++;
|
|
}
|
|
|
|
return array('counter' => $counter);
|
|
}
|
|
|
|
|
|
/**
|
|
* Funkcja zwraca listę dostępnych statusów zamówień
|
|
* @global array $options : tablica z ustawieniami ogólnymi z początku pliku
|
|
* @param array $request tablica z żadaniem od systemu, w przypadku tej funkcji nie używana
|
|
* @return array $response tablica zawierająca dostępne statusy zamówień:
|
|
* 'status_id' => nazwa statusu
|
|
*/
|
|
function Shop_StatusesList($request)
|
|
{
|
|
global $options; // globalna tablica z ustawieniami
|
|
$dbp = $options['db_prefix']; // Data Base Prefix - prefix tabel bazy
|
|
|
|
$response = array();
|
|
$sql = "SELECT id, opt_name FROM `${dbp}st_order_status`
|
|
ORDER BY is_default DESC";
|
|
$res = DB_Query($sql);
|
|
|
|
while ($status = DB_Fetch($res))
|
|
{
|
|
$response[$status['id']] = $status['opt_name'];
|
|
}
|
|
|
|
return $response;
|
|
}
|
|
|
|
|
|
/**
|
|
* Funkcja zwraca listę dostępnych sposobów wysyłki
|
|
* @global array $options : tablica z ustawieniami ogólnymi z początku pliku
|
|
* @param array $request tablica z żadaniem od systemu, w przypadku tej funkcji nie używana
|
|
* @return array $response tablica zawierająca dostępne sposoby_wysyłki:
|
|
* 'delivery_id' => nazwa wysyłki
|
|
*/
|
|
function Shop_DeliveryMethodsList($request)
|
|
{
|
|
global $options; //globalna tablica z ustawieniami
|
|
$dbp = $options['db_prefix']; //Data Base Prefix - prefix tabel bazy
|
|
|
|
$response = array();
|
|
|
|
$sql = "SELECT id, opt_name
|
|
FROM `${dbp}st_delivery`
|
|
WHERE active ORDER BY is_default DESC";
|
|
$res = DB_Query($sql);
|
|
|
|
while ($method = DB_Fetch($res))
|
|
{
|
|
$response[$method['id']] = $method['opt_name'];
|
|
}
|
|
|
|
return $response;
|
|
}
|
|
|
|
function Sote_Decrypt($text, $decrypt = true)
|
|
{
|
|
global $options;
|
|
|
|
if($decrypt != "1"){return $text;}
|
|
|
|
$key = $options['sote_shophash'];
|
|
$string = $text;
|
|
$string = base64_decode($string);
|
|
$td = mcrypt_module_open('des', '','cfb', '');
|
|
$key = substr($key, 0, mcrypt_enc_get_key_size($td));
|
|
$iv_size = mcrypt_enc_get_iv_size($td);
|
|
$iv = substr($string,0,$iv_size);
|
|
$string = substr($string,$iv_size);
|
|
if (mcrypt_generic_init($td, $key, $iv) != -1) {
|
|
$c_t = @mdecrypt_generic($td, $string);
|
|
mcrypt_generic_deinit($td);
|
|
mcrypt_module_close($td);
|
|
return $c_t;
|
|
}
|
|
}
|
|
?>
|