1760 lines
74 KiB
PHP
1760 lines
74 KiB
PHP
<?php
|
|
|
|
require_once (dirname(__FILE__) . '/../../x13allegro.php');
|
|
|
|
use x13allegro\Api\XAllegroApi;
|
|
use x13allegro\Api\Model\DateTime;
|
|
use x13allegro\Api\Model\Image;
|
|
use x13allegro\Api\Model\Marketplace\Enum\Marketplace;
|
|
use x13allegro\Api\Model\Offers\AdditionalMarketplaces\Marketplace as AdditionalMarketplace;
|
|
use x13allegro\Api\Model\Offers\Enum\SellingModeType;
|
|
use x13allegro\Api\Model\Offers\ProductSet\Product as AllegroProduct;
|
|
use x13allegro\Api\Model\Offers\OfferProduct;
|
|
use x13allegro\Api\Model\Offers\Promotion;
|
|
use x13allegro\Api\Model\PromotionPackages\Enum\PackageType;
|
|
use x13allegro\Api\Model\PromotionPackages\Enum\PackageModificationType;
|
|
use x13allegro\Api\Model\PromotionPackages\PromotionPackages;
|
|
use x13allegro\Api\DataFactory\CategoriesParametersFactory;
|
|
use x13allegro\Api\DataProvider\AdditionalServicesProvider;
|
|
use x13allegro\Api\DataProvider\AfterSaleServicesProvider;
|
|
use x13allegro\Api\DataProvider\CategoriesProvider;
|
|
use x13allegro\Api\DataProvider\CategoriesParametersProvider;
|
|
use x13allegro\Api\DataProvider\DeliveryMethodsProvider;
|
|
use x13allegro\Api\DataProvider\LoyaltyProvider;
|
|
use x13allegro\Api\DataProvider\MarketplacesProvider;
|
|
use x13allegro\Api\DataProvider\OfferFeesProvider;
|
|
use x13allegro\Api\DataProvider\ProductSearchProvider;
|
|
use x13allegro\Api\DataProvider\ResponsiblePersonsProvider;
|
|
use x13allegro\Api\DataProvider\SizeTablesProvider;
|
|
use x13allegro\Api\DataProvider\TaxesProvider;
|
|
use x13allegro\Component\Logger\LogType;
|
|
use x13allegro\Form\CategoryParameters\ParametersForm;
|
|
use x13allegro\Json\JsonMapBuilder;
|
|
use x13allegro\SyncManager\Offer\Enum\ProcessOperation;
|
|
use x13allegro\SyncManager\Offer\OfferProcessManager;
|
|
|
|
final class AdminXAllegroMainController extends XAllegroController
|
|
{
|
|
protected $allegroAutoLogin = true;
|
|
protected $allegroAccountSwitch = true;
|
|
|
|
private $allegroPromotionPackages;
|
|
private $allegroTemplates;
|
|
private $deliveryOptionsList;
|
|
private $shippingRatesList;
|
|
|
|
/** @var XAllegroPas */
|
|
private $allegroPasDefault;
|
|
|
|
/** @var CategoriesProvider */
|
|
private $categoriesProvider;
|
|
|
|
/** @var CategoriesParametersProvider */
|
|
private $categoriesParametersProvider;
|
|
|
|
/** @var TaxesProvider */
|
|
private $taxesProvider;
|
|
|
|
public function __construct()
|
|
{
|
|
parent::__construct();
|
|
|
|
$this->tabAccess = Profile::getProfileAccess($this->context->employee->id_profile, Tab::getIdFromClassName('AdminXAllegroPerform'));
|
|
|
|
$this->tpl_folder = 'x_allegro_main/';
|
|
}
|
|
|
|
public function init()
|
|
{
|
|
parent::init();
|
|
|
|
if (!$this->allegroApi) {
|
|
if ($this->ajax) {
|
|
die(json_encode(array('apiError' => true, 'messages' => $this->errors)));
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
$this->categoriesProvider = new CategoriesProvider($this->allegroApi);
|
|
$this->categoriesParametersProvider = new CategoriesParametersProvider($this->allegroApi);
|
|
$this->taxesProvider = new TaxesProvider($this->allegroApi);
|
|
|
|
if (!$this->ajax) {
|
|
$accountName = $this->allegroApi->getAccount()->username;
|
|
if ($this->allegroApi->getAccount()->sandbox) {
|
|
$accountName .= ' (sandbox)';
|
|
}
|
|
$this->toolbar_title = sprintf($this->l('Allegro - wystaw oferty na koncie: %s'), $accountName);
|
|
|
|
$this->allegroTemplates = XAllegroTemplate::getList();
|
|
$this->deliveryOptionsList = XAllegroPas::getList();
|
|
$this->allegroPasDefault = XAllegroPas::getDefault(true);
|
|
|
|
try {
|
|
$this->allegroPromotionPackages = $this->allegroApi->sale()->promotionPackages()->getPromotionPackages();
|
|
|
|
$result = $this->allegroApi->sale()->shippingRates()->getAll()->shippingRates;
|
|
|
|
foreach ($result as $shippingRate) {
|
|
$shippingRateMarketplaces = [];
|
|
foreach ($shippingRate->marketplaces as $marketplace) {
|
|
$shippingRateMarketplaces[] = $marketplace->id;
|
|
}
|
|
|
|
$this->shippingRatesList[$shippingRate->id] = array(
|
|
'id' => $shippingRate->id,
|
|
'name' => $shippingRate->name,
|
|
'marketplaces' => $shippingRateMarketplaces
|
|
);
|
|
}
|
|
}
|
|
catch (Exception $ex) {
|
|
$this->errors[] = (string)$ex;
|
|
}
|
|
}
|
|
}
|
|
|
|
public function setMedia($isNewTheme = false)
|
|
{
|
|
parent::setMedia($isNewTheme);
|
|
|
|
$this->addJqueryUI(array(
|
|
'ui.datepicker',
|
|
'ui.slider',
|
|
'ui.sortable'
|
|
));
|
|
$this->addjQueryPlugin('date');
|
|
|
|
$this->addJS($this->module->getPathUri() . 'views/js/tinymce/tinymce.min.js');
|
|
$this->addJS($this->module->getPathUri() . 'views/js/tinymce/jquery.tinymce.min.js');
|
|
|
|
$this->addCSS($this->module->getPathUri() . 'views/css/allegro-description.css');
|
|
}
|
|
|
|
/**
|
|
* @see AdminController::checkAccess()
|
|
* @param bool $disable
|
|
* @return bool
|
|
*/
|
|
public function viewAccess($disable = false)
|
|
{
|
|
$errors = array();
|
|
|
|
if (!parent::viewAccess($disable)) {
|
|
return false;
|
|
}
|
|
|
|
if ($this->tabAccess['edit'] !== '1') {
|
|
$errors[] = $this->l('Nie masz uprawnień do wystawiania nowych ofert.');
|
|
}
|
|
if (empty($this->allegroTemplates)) {
|
|
$errors[] = $this->l('Brak utworzonych/aktywnych szablonów -').' <a href="'.$this->context->link->getAdminLink('AdminXAllegroTemplates').'">'.$this->l('dodaj/aktywuj szablon').'</a>.';
|
|
}
|
|
if (empty($this->deliveryOptionsList)) {
|
|
$errors[] = $this->l('Brak utworzonych profili dostawy -').' <a href="'.$this->context->link->getAdminLink('AdminXAllegroPas').'&addxallegro_delivery">'.$this->l('dodaj profil dostawy').'</a>.';
|
|
}
|
|
if (empty($this->shippingRatesList)) {
|
|
$errors[] = $this->l('Brak utworzonych cenników dostawy, lub wystąpił problem z API Allegro -').' <a href="'.$this->context->link->getAdminLink('AdminXAllegroPas').'&addxallegro_delivery_rate">'.$this->l('dodaj cennik dostawy').'</a>.';
|
|
}
|
|
|
|
if (!empty($errors)) {
|
|
$this->errors = array_merge($this->errors, $errors);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function initPageHeaderToolbar()
|
|
{
|
|
$this->page_header_toolbar_btn['allegro_sold'] = array(
|
|
'href' => self::$currentIndex . '&token=' . $this->token . '&show=sold',
|
|
'desc' => $this->l('Wystaw oferty'),
|
|
'icon' => 'process-icon-gavel icon-gavel',
|
|
'class' => 'xallegro-perform'
|
|
);
|
|
|
|
parent::initPageHeaderToolbar();
|
|
}
|
|
|
|
public function initToolbar()
|
|
{
|
|
$this->toolbar_btn['allegro_sold'] = array(
|
|
'href' => self::$currentIndex . '&token=' . $this->token . '&show=sold',
|
|
'desc' => $this->l('Wystaw oferty'),
|
|
'class' => 'xallegro-perform fa fa-gavel'
|
|
);
|
|
|
|
parent::initToolbar();
|
|
|
|
unset($this->toolbar_btn['new']);
|
|
}
|
|
|
|
public function initContent()
|
|
{
|
|
parent::initContent();
|
|
|
|
$products = XAllegroProduct::getProducts(
|
|
array_map('intval', explode(',', Tools::getValue('id_product'))),
|
|
$this->context->shop->id,
|
|
$this->allegroApi->getAccount(),
|
|
$this->context
|
|
);
|
|
|
|
Hook::exec('filterX13AllegroAuctionProducts', array('products' => &$products));
|
|
|
|
/** @todo Refactoring */
|
|
$image_type = array('name' => null);
|
|
foreach (array_reverse(ImageType::getImagesTypes(null, true)) as $imgType) {
|
|
if ($imgType['products']) {
|
|
$image_type = $imgType;
|
|
break;
|
|
}
|
|
}
|
|
|
|
$accountConfiguration = new XAllegroConfigurationAccount($this->allegroApi->getAccount()->id);
|
|
$deliveryFields = $this->_getPasFields();
|
|
$marketplaces = [];
|
|
|
|
foreach (Marketplace::values() as $marketplace) {
|
|
$marketplacesProvider = new MarketplacesProvider($marketplace->getValue());
|
|
$marketplaceCountry = $marketplacesProvider->getMarketplaceCountry();
|
|
$marketplaceCurrency = $marketplacesProvider->getMarketplaceCurrency();
|
|
|
|
$marketplaces[$marketplace->getValue()] = [
|
|
'id' => $marketplace->getValue(),
|
|
'name' => $marketplace->getValueTranslated(),
|
|
'countryName' => $marketplaceCountry->name,
|
|
'countryCode' => $marketplaceCountry->iso_code,
|
|
'currencySign' => $marketplaceCurrency->sign,
|
|
'currencyPrecision' => $marketplaceCurrency->precision,
|
|
'currencyConversionRate' => $marketplaceCurrency->conversion_rate
|
|
];
|
|
}
|
|
|
|
$shippingRateMarketplaces = [];
|
|
$shippingRateDefaultId = $accountConfiguration->get('SHIPPING_RATE_DEFAULT_ID');
|
|
$shippingRateId = ($shippingRateDefaultId ?: current($this->shippingRatesList)['id']);
|
|
|
|
foreach ($this->shippingRatesList as $shippingRate) {
|
|
$shippingRateMarketplaces[$shippingRate['id']] = $shippingRate['marketplaces'];
|
|
}
|
|
|
|
$this->context->smarty->assign(array(
|
|
'account' => $this->allegroApi->getAccount(),
|
|
'products' => $products,
|
|
'durations' => XAllegroAuction::getPublicationDurationOptions(),
|
|
'durations_auction' => XAllegroAuction::getPublicationDurationOptions('AUCTION'),
|
|
'templates' => $this->allegroTemplates,
|
|
'shippingRateMarketplaces' => $shippingRateMarketplaces,
|
|
'shippingRateSelectedId' => $shippingRateId,
|
|
'shipping_rates' => $this->shippingRatesList,
|
|
'shipments' => $this->provideDeliveryMethods($this->shippingRatesList[$shippingRateId]['id']),
|
|
'afterSales' => (new AfterSaleServicesProvider($this->allegroApi))->getAllServices(),
|
|
'additionalServices' => (new AdditionalServicesProvider($this->allegroApi))->getAdditionalServices(),
|
|
'sizeTables' => (new SizeTablesProvider($this->allegroApi))->getSizeTables(),
|
|
'wholesalePriceList' => (new LoyaltyProvider($this->allegroApi))->getWholesalePriceList(),
|
|
'promotionPackages' => $this->allegroPromotionPackages,
|
|
'categories' => $this->categoriesProvider->getCategoriesList(),
|
|
'category_path' => array(null),
|
|
'select_images' => XAllegroConfiguration::get('SELECT_IMAGES'),
|
|
'select_images_max' => XAllegroApi::PHOTO_COMPANY_MAX,
|
|
'account_sandbox' => (int)$this->allegroApi->getAccount()->sandbox,
|
|
'image_legacy' => $this->checkLegacyImages(),
|
|
'images_preview_type' => $image_type,
|
|
'product_select_mode' => XAllegroConfiguration::get('SELECT_ALL'),
|
|
'productization_mode' => XAllegroConfiguration::get('PRODUCTIZATION_MODE'),
|
|
'message_to_seller' => !(int)$accountConfiguration->get('AUCTION_DISABLE_ORDER_MESSAGE', true),
|
|
'b2b_only' => (int)$accountConfiguration->get('AUCTION_B2B_ONLY', true),
|
|
'responsiblePersons' => (new ResponsiblePersonsProvider($this->allegroApi))->getResponsiblePersons(),
|
|
'responsiblePersonSelectedId' => $accountConfiguration->get('RESPONSIBLE_PERSON_DEFAULT_ID'),
|
|
'titleMaxSize' => XAllegroApi::TITLE_MAX_SIZE,
|
|
'marketplaces' => $marketplaces,
|
|
|
|
'toolbar_scroll' => true,
|
|
'toolbar_title' => $this->toolbar_title,
|
|
'toolbar_btn' => $this->page_header_toolbar_btn,
|
|
'new_assoc_info' => (int)XAllegroConfiguration::get('NEW_ASSOC_INFO'),
|
|
|
|
// bulk default options
|
|
'bulk_send_tax' => (int)XAllegroConfiguration::get('PRICE_TAX'),
|
|
|
|
// forms
|
|
'pas_fields' => $this->renderCustomForm($deliveryFields, $this->_getFieldsValuesFrom($deliveryFields), 0),
|
|
|
|
// tinymce
|
|
'ad' => __PS_BASE_URI__ . basename(_PS_ADMIN_DIR_),
|
|
'path_css' => _THEME_CSS_DIR_,
|
|
'iso' => (file_exists(_PS_ROOT_DIR_ . '/js/tiny_mce/langs/' . $this->context->language->iso_code . '.js') ? $this->context->language->iso_code : 'en'),
|
|
|
|
// productization
|
|
'productization_name' => XAllegroConfiguration::get('PRODUCTIZATION_NAME'),
|
|
'productization_description' => XAllegroConfiguration::get('PRODUCTIZATION_DESCRIPTION'),
|
|
'productization_show_reference' => XAllegroConfiguration::get('PRODUCTIZATION_SHOW_REFERENCE'),
|
|
'productization_show_gtin' => XAllegroConfiguration::get('PRODUCTIZATION_SHOW_GTIN'),
|
|
'productization_show_mpn' => XAllegroConfiguration::get('PRODUCTIZATION_SHOW_MPN'),
|
|
|
|
'fees_enabled' => $accountConfiguration->get('AUCTION_CALCULATE_FEES', true),
|
|
));
|
|
|
|
// fix HelperForm tinymce autoload
|
|
$removeJS = [
|
|
_PS_JS_DIR_ . 'tiny_mce/tiny_mce.js',
|
|
_PS_JS_DIR_ . 'admin/tinymce.inc.js'
|
|
];
|
|
|
|
if (defined('_TB_VERSION_')) {
|
|
foreach ($removeJS as $js) {
|
|
$jsCheck = preg_grep("#$js#", $this->js_files);
|
|
if (!empty($jsCheck)) {
|
|
unset($this->js_files[key($jsCheck)]);
|
|
}
|
|
}
|
|
} else {
|
|
$this->context->controller->removeJS($removeJS);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param string $shippingRateId
|
|
* @param bool $group
|
|
* @return array
|
|
*/
|
|
private function provideDeliveryMethods($shippingRateId, $group = true)
|
|
{
|
|
$deliveryMethods = array();
|
|
|
|
try {
|
|
$dataProvider = new DeliveryMethodsProvider(
|
|
$this->allegroApi->sale()->deliveryMethods()->getAll()->deliveryMethods
|
|
);
|
|
|
|
$deliveryMethods = $dataProvider->getDeliveryMethodsWithShippingRates(
|
|
$this->allegroApi->sale()->shippingRates()->getDetails($shippingRateId)
|
|
);
|
|
|
|
if ($group) {
|
|
$deliveryMethods = $dataProvider->groupDeliveryMethods($deliveryMethods);
|
|
}
|
|
}
|
|
catch (Exception $ex) {
|
|
$this->errors[] = $ex;
|
|
}
|
|
|
|
return $deliveryMethods;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
private function checkLegacyImages()
|
|
{
|
|
$image_legacy = false;
|
|
$dir = _PS_PROD_IMG_DIR_;
|
|
|
|
if (is_dir($dir)) {
|
|
if ($dh = opendir($dir)) {
|
|
while (($file = readdir($dh)) !== false && $image_legacy == false) {
|
|
if (!is_dir($dir.DIRECTORY_SEPARATOR.$file) && $file[0] != '.' && is_numeric($file[0])) {
|
|
$image_legacy = true;
|
|
}
|
|
}
|
|
closedir($dh);
|
|
}
|
|
}
|
|
|
|
return $image_legacy;
|
|
}
|
|
|
|
private function _getFieldsValuesFrom(array $fields)
|
|
{
|
|
$fieldsValues = array();
|
|
|
|
foreach ($fields[0]['form']['input'] as $input)
|
|
{
|
|
$fieldValue = Tools::getValue($input['name'], null);
|
|
|
|
if ($fieldValue === null && isset($input['default_value'])) {
|
|
$fieldValue = $input['default_value'];
|
|
}
|
|
|
|
$fieldsValues[$input['name']] = $fieldValue;
|
|
}
|
|
|
|
return $fieldsValues;
|
|
}
|
|
|
|
private function _getPasFields()
|
|
{
|
|
$profiles = array();
|
|
foreach ($this->deliveryOptionsList as $pas) {
|
|
$profiles[] = array(
|
|
'id_xallegro_pas' => $pas['id'],
|
|
'name' => $pas['name']
|
|
);
|
|
}
|
|
|
|
$deliveryOptionsFields[0]['form'] = array(
|
|
'legend' => array(
|
|
'title' => $this->l('Płatność i dostawa')
|
|
),
|
|
'input' => array(
|
|
array(
|
|
'type' => 'select',
|
|
'label' => $this->l('Profil'),
|
|
'name' => 'pas',
|
|
'class' => 'fixed-width-xxl',
|
|
'options' => array(
|
|
'query' => array_merge(
|
|
array(
|
|
array(
|
|
'id_xallegro_pas' => '0',
|
|
'name' => $this->l('-- Wybierz --')
|
|
)
|
|
), $profiles),
|
|
'id' => 'id_xallegro_pas',
|
|
'name' => 'name'
|
|
),
|
|
'default_value' => $this->allegroPasDefault->id
|
|
),
|
|
array(
|
|
'type' => 'select',
|
|
'label' => $this->l('Czas wysyłki'),
|
|
'name' => 'handling_time',
|
|
'required' => true,
|
|
'class' => 'fixed-width-xxl',
|
|
'options' => array(
|
|
'query' => XAllegroPas::getHandlingTimeOptions(),
|
|
'id' => 'id',
|
|
'name' => 'name'
|
|
),
|
|
'default_value' => $this->allegroPasDefault->handling_time
|
|
),
|
|
array(
|
|
'type' => 'textarea',
|
|
'label' => $this->l('Dodatkowe informacje o dostawie'),
|
|
'name' => 'additional_info',
|
|
'class' => 'fixed-width-xxl',
|
|
'rows' => 5,
|
|
'cols' => 35,
|
|
'default_value' => $this->allegroPasDefault->additional_info
|
|
),
|
|
array(
|
|
'type' => 'select',
|
|
'label' => $this->l('Kraj'),
|
|
'name' => 'country_code',
|
|
'class' => 'fixed-width-xxl',
|
|
'required' => true,
|
|
'options' => array(
|
|
'query' => XAllegroPas::getCountryCodeOptions(),
|
|
'id' => 'id',
|
|
'name' => 'name'
|
|
),
|
|
'default_value' => $this->allegroPasDefault->country_code
|
|
),
|
|
array(
|
|
'type' => 'select',
|
|
'label' => $this->l('Województwo'),
|
|
'name' => 'province',
|
|
'class' => 'fixed-width-xxl',
|
|
'options' => array(
|
|
'query' => XAllegroPas::getProvinceOptions(),
|
|
'id' => 'id',
|
|
'name' => 'name'
|
|
),
|
|
'default_value' => $this->allegroPasDefault->province
|
|
),
|
|
array(
|
|
'type' => 'text',
|
|
'label' => $this->l('Kod pocztowy'),
|
|
'name' => 'post_code',
|
|
'class' => 'fixed-width-xxl',
|
|
'size' => 12,
|
|
'default_value' => $this->allegroPasDefault->post_code
|
|
),
|
|
array(
|
|
'type' => 'text',
|
|
'label' => $this->l('Miasto'),
|
|
'name' => 'city',
|
|
'class' => 'fixed-width-xxl',
|
|
'size' => 35,
|
|
'required' => true,
|
|
'default_value' => $this->allegroPasDefault->city
|
|
),
|
|
array(
|
|
'type' => 'select',
|
|
'label' => $this->l('Opcje faktury'),
|
|
'name' => 'invoice',
|
|
'class' => 'fixed-width-xxl',
|
|
'required' => true,
|
|
'options' => array(
|
|
'query' => XAllegroPas::getInvoiceOptions(),
|
|
'id' => 'id',
|
|
'name' => 'name'
|
|
),
|
|
'default_value' => $this->allegroPasDefault->invoice
|
|
),
|
|
)
|
|
);
|
|
|
|
return $deliveryOptionsFields;
|
|
}
|
|
|
|
/**
|
|
* @param array $item
|
|
* @param array|null $errors
|
|
* @return void
|
|
*/
|
|
private function validateAuction(array $item, array &$errors = null)
|
|
{
|
|
static $ps_order_out_of_stock = null;
|
|
if ($ps_order_out_of_stock === null) {
|
|
$ps_order_out_of_stock = Configuration::get('PS_ORDER_OUT_OF_STOCK');
|
|
}
|
|
|
|
if (!$item['category_id']) {
|
|
$errors[] = $this->l('Nie wybrano kategorii.');
|
|
}
|
|
else if (!$item['category_is_leaf']) {
|
|
$errors[] = $this->l('Wybrana kategoria nie jest kategorią najniższego rzędu.');
|
|
}
|
|
|
|
if ($item['selling_mode'] == SellingModeType::AUCTION && $item['quantity'] > 1) {
|
|
$errors[] = $this->l('Ilość przedmiotów w ofercie z ceną wywoławczą nie może być większa niż 1.');
|
|
}
|
|
|
|
if (!isset($item['quantity']) || !$item['quantity']) {
|
|
$errors[] = $this->l('Nie podano ilości.');
|
|
}
|
|
else if ((int)$item['quantity'] < 1) {
|
|
$errors[] = $this->l('Podana ilość musi być większa od zera.');
|
|
}
|
|
else if (XAllegroConfiguration::get('QUANITY_CHECK')) {
|
|
$productOOS = StockAvailable::outOfStock($item['id_product'], $this->context->shop->id);
|
|
$oos = $productOOS == 2 ? (int)$ps_order_out_of_stock : $productOOS;
|
|
|
|
if (!$oos && (int)$item['quantity'] > StockAvailable::getQuantityAvailableByProduct($item['id_product'], $item['id_product_attribute'], $this->context->shop->id)) {
|
|
$errors[] = $this->l('Podana ilość jest większą niż dostępna.');
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
private function _getAuctionsFromPost()
|
|
{
|
|
$auctionsData = [
|
|
//'tags' => Tools::getValue('xallegro_tag', array()),
|
|
'starting_at' => (Tools::getValue('start') ? Tools::getValue('start_time') : null),
|
|
'warranty' => Tools::getValue('warranty', null),
|
|
'implied_warranty' => Tools::getValue('implied_warranty', null),
|
|
'return_policy' => Tools::getValue('return_policy', null),
|
|
'responsible_person' => Tools::getValue('responsible_person', null),
|
|
'message_to_seller' => Tools::getValue('message_to_seller'),
|
|
'offer_b2b_only' => (bool)Tools::getValue('offer_b2b_only'),
|
|
'additional_services' => Tools::getValue('additional_services', null),
|
|
'pas' => [
|
|
'country_code' => Tools::getValue('country_code'),
|
|
'province' => Tools::getValue('province', null),
|
|
'post_code' => Tools::getValue('post_code', null),
|
|
'city' => Tools::getValue('city'),
|
|
'invoice' => Tools::getValue('invoice'),
|
|
'handling_time' => Tools::getValue('handling_time'),
|
|
'additional_info' => Tools::getValue('additional_info', null),
|
|
'shipping_rate' => Tools::getValue('shipping_rate')
|
|
]
|
|
];
|
|
|
|
// ajax data limit is set by hand to 1
|
|
// but current index is dynamic
|
|
$itemPOST = Tools::getValue('item');
|
|
$currentIndex = key($itemPOST);
|
|
$item = current($itemPOST);
|
|
|
|
$images = [];
|
|
if ($item['image_main']) {
|
|
$images[] = $item['image_main'];
|
|
}
|
|
|
|
if (isset($item['images']) && !empty($item['images'])) {
|
|
foreach ($item['images'] as $image) {
|
|
if ($image != $item['image_main']) {
|
|
$images[] = $image;
|
|
}
|
|
}
|
|
}
|
|
|
|
$auctionsData['item'] = [
|
|
'enabled' => (isset($item['enabled']) ? $item['enabled'] : false),
|
|
'x_id' => $currentIndex,
|
|
'category_id' => (int)(!empty($item['category_id']) ? $item['category_id'] : false),
|
|
'category_is_leaf' => (int)(!empty($item['category_is_leaf']) ? $item['category_is_leaf'] : false),
|
|
'productization_mode' => (isset($item['productization_mode']) ? $item['productization_mode'] : false), // when its null then auction is disabled to issue
|
|
'allegro_product_id' => !empty($item['allegro_product_id']) ? $item['allegro_product_id'] : null,
|
|
'allegro_product_images' => !empty($item['allegro_product_images']) ? json_decode($item['allegro_product_images'], true) : null,
|
|
'allegro_product_description' => !empty($item['allegro_product_description']) ? json_decode($item['allegro_product_description']) : null,
|
|
'id_product' => (int)$item['id_product'],
|
|
'id_product_attribute' => (int)$item['id_product_attribute'],
|
|
'id_auction' => (float)$item['id_auction'],
|
|
'id_template' => (isset($item['template']) ? (int)$item['template'] : null),
|
|
'images' => $images,
|
|
'title' => $item['title'],
|
|
'description' => $item['description'],
|
|
'ean' => $item['ean13'],
|
|
'upc' => $item['upc'],
|
|
'reference' => $item['reference'],
|
|
'selling_mode' => $item['selling_mode'],
|
|
'duration' => (!$item['duration'] ? null : $item['duration']),
|
|
'auto_renew' => (isset($item['auto_renew']) ? $item['auto_renew'] : null),
|
|
'price_buy_now' => $item['price_buy_now'],
|
|
'price_starting' => (isset($item['price_asking']) ? $item['price_asking'] : 0),
|
|
'price_minimal' => (isset($item['price_minimal']) ? $item['price_minimal'] : 0),
|
|
'price_calculate_fees' => $item['price_calculate_fees'],
|
|
'tax_rate' => (isset($item['tax_rate']) ? $item['tax_rate'] : null),
|
|
'send_tax' => (isset($item['send_tax']) ? $item['send_tax'] : 0),
|
|
'quantity' => (isset($item['quantity']) ? $item['quantity'] : 1),
|
|
'unit' => $item['quantity_type'],
|
|
'category_parameters' => (isset($item['category_fields']) ? $item['category_fields'] : []),
|
|
'category_ambiguous_parameters' => (isset($item['category_ambiguous_fields']) ? $item['category_ambiguous_fields'] : []),
|
|
//'tags_individual' => (isset($item['product_tags']) ? true : false),
|
|
//'tags' => (isset($item['product_tags']) && isset($item['tags']) ? $item['tags'] : []),
|
|
'marketplaces' => (isset($item['marketplace']) ? $item['marketplace'] : []),
|
|
'promotionPackages' => [
|
|
PackageType::BASE => (isset($item['basePackages']) && $item['basePackages'] ? $item['basePackages'] : false),
|
|
PackageType::EXTRA => (isset($item['extraPackages']) ? $item['extraPackages'] : [])
|
|
],
|
|
'preorder' => (isset($item['preorder'])),
|
|
'preorder_date' => (isset($item['preorder_date']) ? $item['preorder_date'] : false),
|
|
'size_table' => (isset($item['size_table']) ? $item['size_table'] : false),
|
|
'wholesale_price' => (isset($item['wholesale_price']) ? $item['wholesale_price'] : false)
|
|
];
|
|
|
|
return $auctionsData;
|
|
}
|
|
|
|
public function ajaxProcessGetAllegroAccount()
|
|
{
|
|
// return empty response
|
|
die(json_encode([]));
|
|
}
|
|
|
|
public function ajaxProcessSaveDesc()
|
|
{
|
|
$collection = new Collection('XAllegroProduct');
|
|
$collection->where('id_product', '=', Tools::getValue('id_product'));
|
|
$collection->where('id_product_attribute', '=', Tools::getValue('id_product_attribute'));
|
|
|
|
if (Validate::isLoadedObject($collection->getFirst()))
|
|
{
|
|
$collection->getFirst()->description = Tools::getValue('description');
|
|
$collection->getFirst()->save();
|
|
}
|
|
else {
|
|
$product = new XAllegroProduct();
|
|
$product->id_product = Tools::getValue('id_product');
|
|
$product->id_product_attribute = Tools::getValue('id_product_attribute');
|
|
$product->save();
|
|
}
|
|
|
|
die(true);
|
|
}
|
|
|
|
public function ajaxProcessUpdateImagesPositions()
|
|
{
|
|
XAllegroProduct::updateImagesPositions(
|
|
Tools::getValue('id_product'),
|
|
Tools::getValue('id_product_attribute'),
|
|
Tools::getValue('images')
|
|
);
|
|
|
|
die(true);
|
|
}
|
|
|
|
public function ajaxProcessPreview()
|
|
{
|
|
$item = array();
|
|
foreach (Tools::getValue('data') as $data)
|
|
{
|
|
$name = explode(']', $data['name']);
|
|
if (!isset($name[1])) {
|
|
continue;
|
|
}
|
|
|
|
$name = trim($name[1], '[');
|
|
|
|
if ($name == 'images' || $name == 'additional') {
|
|
$item[$name][] = $data['value'];
|
|
} else {
|
|
$item[$name] = $data['value'];
|
|
}
|
|
}
|
|
|
|
$templateOverride = false;
|
|
$templateModifierExec = Hook::exec(
|
|
'actionX13AllegroTemplatePreviewModifier',
|
|
[
|
|
'item' => $item,
|
|
'template' => &$templateOverride
|
|
],
|
|
null,
|
|
true
|
|
);
|
|
if ($templateModifierExec && $templateOverride !== false) {
|
|
die(json_encode(array(
|
|
'preview' => $templateOverride['preview']
|
|
)));
|
|
}
|
|
|
|
if (!isset($item['description'])) {
|
|
$item['description'] = '';
|
|
}
|
|
|
|
$images = array_values(array_unique(array_merge(
|
|
(isset($item['image_main']) && $item['image_main'] ? array($item['image_main']) : array()),
|
|
(isset($item['images']) && is_array($item['images']) ? $item['images'] : array())
|
|
)));
|
|
|
|
$template = new XAllegroTemplate($item['template']);
|
|
$product = new Product($item['id_product'], false, $this->allegroApi->getAccount()->id_language, $this->context->shop->id);
|
|
$xProduct = new XAllegroProduct(null, $product->id);
|
|
|
|
$template->setProduct($product, $xProduct);
|
|
|
|
if ($item['id_product_attribute']) {
|
|
$combination = $product->getAttributeCombinationsById($item['id_product_attribute'], $this->allegroApi->getAccount()->id_language);
|
|
$template->setProductAttribute($combination);
|
|
}
|
|
|
|
$template->prepareVariables($item, $product, $images);
|
|
$template->render();
|
|
|
|
die(json_encode(array(
|
|
'preview' => $template->getHTML()
|
|
)));
|
|
}
|
|
|
|
public function ajaxProcessSearchInProductization()
|
|
{
|
|
$searchOptions = json_decode(XAllegroConfiguration::get('PRODUCTIZATION_SEARCH'), true);
|
|
$searchPhrase = Tools::getValue('searchPhrase');
|
|
$searchProduct = [];
|
|
|
|
$productName = Tools::getValue('productName');
|
|
$productReference = Tools::getValue('productReference');
|
|
$productEAN13 = Tools::getValue('productEAN13');
|
|
$productISBN = Tools::getValue('productISBN');
|
|
$productUPC = Tools::getValue('productUPC');
|
|
$productMPN = Tools::getValue('productMPN');
|
|
|
|
$productsFromAllegroSearch = [];
|
|
$productsFoundOption =
|
|
$productsFoundMode =
|
|
$productChosen = null;
|
|
|
|
// manual search
|
|
if (!empty($searchPhrase)) {
|
|
$searchPhrase = trim($searchPhrase);
|
|
// temporary disabled
|
|
// manual search always as everywhere
|
|
//$searchProduct['manual']['mode'][ProductSearchProvider::SEARCH_GTIN][] = $searchPhrase;
|
|
//$searchProduct['manual']['mode'][ProductSearchProvider::SEARCH_MPN][] = $searchPhrase;
|
|
$searchProduct['manual']['mode'][ProductSearchProvider::SEARCH_EVERYWHERE][] = $searchPhrase;
|
|
}
|
|
// search on init
|
|
// manual search with empty "searchPhrase"
|
|
else {
|
|
if (isset($searchOptions['GTIN']['search']) && $searchOptions['GTIN']['search']) {
|
|
if (!empty($productEAN13) && strlen($productEAN13) >= 8) {
|
|
$searchProduct['GTIN']['mode'][ProductSearchProvider::SEARCH_GTIN][] = $productEAN13;
|
|
$searchProduct['GTIN']['mode'][ProductSearchProvider::SEARCH_GTIN][] = str_pad($productEAN13, 13, '0', STR_PAD_LEFT);
|
|
}
|
|
if (!empty($productISBN)) {
|
|
$searchProduct['GTIN']['mode'][ProductSearchProvider::SEARCH_GTIN][] = $productISBN;
|
|
}
|
|
if (!empty($productUPC)) {
|
|
$searchProduct['GTIN']['mode'][ProductSearchProvider::SEARCH_GTIN][] = $productUPC;
|
|
}
|
|
|
|
if (isset($searchProduct['GTIN'])) {
|
|
$searchProduct['GTIN']['select'] = $searchOptions['GTIN']['select'];
|
|
}
|
|
}
|
|
|
|
if (isset($searchOptions['MPN']['search']) && $searchOptions['MPN']['search'] && !empty($productMPN)) {
|
|
$searchProduct['MPN']['mode'][ProductSearchProvider::SEARCH_MPN][] = $productMPN;
|
|
$searchProduct['MPN']['select'] = $searchOptions['MPN']['select'];
|
|
}
|
|
|
|
if (isset($searchOptions['reference']['search']) && $searchOptions['reference']['search'] && !empty($productReference)) {
|
|
// Product reference could be everything, and be everywhere
|
|
// it depends on how client use this feature
|
|
$searchProduct['reference']['mode'][ProductSearchProvider::SEARCH_GTIN][] = $productReference;
|
|
$searchProduct['reference']['mode'][ProductSearchProvider::SEARCH_MPN][] = $productReference;
|
|
$searchProduct['reference']['mode'][ProductSearchProvider::SEARCH_EVERYWHERE][] = $productReference;
|
|
$searchProduct['reference']['select'] = $searchOptions['reference']['select'];
|
|
}
|
|
|
|
if (isset($searchOptions['product_name']['search']) && $searchOptions['product_name']['search']) {
|
|
$searchProduct['product_name']['mode'][ProductSearchProvider::SEARCH_EVERYWHERE][] = $productName;
|
|
$searchProduct['product_name']['select'] = $searchOptions['product_name']['select'];
|
|
}
|
|
}
|
|
|
|
try {
|
|
foreach ($searchProduct as $searchOption => $searchModeList) {
|
|
foreach ($searchModeList['mode'] as $searchMode => $phraseList) {
|
|
foreach ($phraseList as $phrase) {
|
|
$productsFromAllegroSearch = (new ProductSearchProvider($this->allegroApi))->search($phrase, $searchMode);
|
|
|
|
if (!empty($productsFromAllegroSearch)) {
|
|
if ($searchOption != 'manual' && isset($searchOptions[$searchOption])) {
|
|
$productsFoundOption = $searchOptions[$searchOption]['select'];
|
|
$productsFoundMode = $searchOption;
|
|
}
|
|
|
|
break 3;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (empty($productsFromAllegroSearch)) {
|
|
exit(json_encode([
|
|
'result' => false,
|
|
'message' => '<div class="alert medium-alert alert-danger" role="alert"><p class="alert-text">'.$this->l('Nie znaleziono powiązania z Katalogiem Allegro').'</p></div>',
|
|
]));
|
|
}
|
|
|
|
$productsCategories = [];
|
|
foreach ($productsFromAllegroSearch as $product) {
|
|
$productsCategories[$product->id] = $this->formatCategoryPath($this->categoriesProvider->getCategoriesPathLite($product->category->id));
|
|
}
|
|
|
|
$productSearchModalContent = $this->context->smarty->createTemplate($this->module->getLocalPath() . 'views/templates/admin/' . $this->tpl_folder . 'product-selection-modal-content.tpl');
|
|
$productSearchModalContent->assign([
|
|
'products_from_allegro' => $productsFromAllegroSearch,
|
|
'products_categories' => $productsCategories,
|
|
'products_url' => 'https://allegro.pl' . ($this->allegroApi->getAccount()->sandbox ? '.allegrosandbox.pl' : '')
|
|
]);
|
|
|
|
$countProductsFromAllegroSearch = count($productsFromAllegroSearch);
|
|
if ($searchPhrase === false // not manual search
|
|
&& (($productsFoundOption == 'always_first' && $countProductsFromAllegroSearch >= 1)
|
|
|| ($productsFoundOption == 'only_single' && $countProductsFromAllegroSearch == 1))
|
|
) {
|
|
$productFromAllegro = $productsFromAllegroSearch[0];
|
|
|
|
$parametersForm = (new ParametersForm())
|
|
->setController($this)
|
|
->setLanguage($this->allegroApi->getAccount()->id_language)
|
|
->setCategory((new XAllegroCategory(XAllegroCategory::getIdByAllegroCategory($productFromAllegro->category->id))))
|
|
->setParameters($this->categoriesParametersProvider->getParameters($productFromAllegro->category->id))
|
|
->mapProductizationToHelperForm(
|
|
$productFromAllegro->parameters,
|
|
Tools::getValue('productId'),
|
|
Tools::getValue('productAttributeId'),
|
|
$productEAN13
|
|
);
|
|
|
|
$productChosen = [
|
|
'categoryId' => $productFromAllegro->category->id,
|
|
'categoryIsLeaf' => 1, // this is always to be true
|
|
'categoryPath' => $this->formatCategoryPath($this->categoriesProvider->getCategoriesPathLite($productFromAllegro->category->id)),
|
|
'taxes' => $this->taxesProvider->getTaxesForCategory($productFromAllegro->category->id),
|
|
'allegroProductId' => $productFromAllegro->id,
|
|
'allegroProductUrl' => XAllegroApi::generateProductUrl($productFromAllegro->id, $this->allegroApi->getAccount()->sandbox),
|
|
'allegroProductName' => $productFromAllegro->name,
|
|
'allegroProductImages' => json_encode($productFromAllegro->images),
|
|
'allegroProductDescription' => (isset($productFromAllegro->description) ? json_encode($productFromAllegro->description) : ''),
|
|
'allegroProductCategoryDefault' => $productFromAllegro->category->id,
|
|
'allegroProductCategorySimilar' => (!empty($productFromAllegro->category->similar) ? json_encode($productFromAllegro->category->similar) : false),
|
|
'allegroProductCategorySimilarCount' => (!empty($productFromAllegro->category->similar) ? count($productFromAllegro->category->similar) +1 : 0), // +1 add default category
|
|
'parameters' => str_replace('class="category-field', 'class="category-field ', $parametersForm->buildForm()),
|
|
'parametersDepending' => $parametersForm->getDependsOnValueIds(),
|
|
'parametersRequiredIf' => $parametersForm->getRequiredIfValuesIds()
|
|
];
|
|
}
|
|
|
|
exit(json_encode([
|
|
'result' => true,
|
|
'nbProducts' => count($productsFromAllegroSearch),
|
|
'productSelectionModal' => $productSearchModalContent->fetch(),
|
|
'productsFoundOption' => $productsFoundOption,
|
|
'productsFoundMode' => $productsFoundMode,
|
|
'productChosen' => $productChosen
|
|
]));
|
|
}
|
|
catch (Exception $e) {
|
|
exit(json_encode([
|
|
'result' => false,
|
|
'message' => '<div class="alert medium-alert alert-danger" role="alert"><p class="alert-text">' . $e . '</div>',
|
|
]));
|
|
}
|
|
}
|
|
|
|
public function ajaxProcessSelectFromProductization()
|
|
{
|
|
$categoryCurrentId = Tools::getValue('categoryCurrent');
|
|
$allegroProductId = Tools::getValue('allegroProductId');
|
|
$productEAN13 = Tools::getValue('productEAN13');
|
|
$productId = (int)Tools::getValue('productId');
|
|
$productAttributeId = (int)Tools::getValue('productAttributeId');
|
|
|
|
try {
|
|
$productDetails = $this->allegroApi
|
|
->sale()
|
|
->products()
|
|
->getProduct($allegroProductId);
|
|
|
|
$categoryId = ($categoryCurrentId ?: $productDetails->category->id);
|
|
|
|
$parametersForm = (new ParametersForm())
|
|
->setController($this)
|
|
->setLanguage($this->allegroApi->getAccount()->id_language)
|
|
->setCategory((new XAllegroCategory(XAllegroCategory::getIdByAllegroCategory($categoryId))))
|
|
->setParameters($this->categoriesParametersProvider->getParameters($categoryId))
|
|
->mapProductizationToHelperForm(
|
|
$productDetails->parameters,
|
|
$productId,
|
|
$productAttributeId,
|
|
$productEAN13
|
|
);
|
|
|
|
exit(json_encode([
|
|
'result' => true,
|
|
'parameters' => str_replace('class="category-field', 'class="category-field ', $parametersForm->buildForm()),
|
|
'parametersDepending' => $parametersForm->getDependsOnValueIds(),
|
|
'parametersRequiredIf' => $parametersForm->getRequiredIfValuesIds(),
|
|
'categoryId' => $categoryId,
|
|
'categoryPath' => $this->formatCategoryPath($this->categoriesProvider->getCategoriesPathLite($categoryId)),
|
|
'taxes' => $this->taxesProvider->getTaxesForCategory($categoryId),
|
|
'allegroProductUrl' => XAllegroApi::generateProductUrl($productDetails->id, $this->allegroApi->getAccount()->sandbox),
|
|
'allegroProductName' => $productDetails->name,
|
|
'allegroProductId' => $productDetails->id,
|
|
'allegroProductImages' => json_encode($productDetails->images),
|
|
'allegroProductDescription' => (isset($productDetails->description) ? json_encode($productDetails->description) : ''),
|
|
'allegroProductCategoryDefault' => $productDetails->category->id,
|
|
'allegroProductCategorySimilar' => (!empty($productDetails->category->similar) ? json_encode($productDetails->category->similar) : false),
|
|
'allegroProductCategorySimilarCount' => (!empty($productDetails->category->similar) ? count($productDetails->category->similar) +1 : 0), // +1 add default category
|
|
]));
|
|
}
|
|
catch (Exception $e) {
|
|
exit(json_encode([
|
|
'result' => false,
|
|
'message' => (string)$e,
|
|
]));
|
|
}
|
|
}
|
|
|
|
public function ajaxProcessGetCategories()
|
|
{
|
|
$categories =
|
|
$categoriesPath =
|
|
$parameters =
|
|
$parametersDepending =
|
|
$parametersRequiredIf =
|
|
$taxes = [];
|
|
$isLeaf =
|
|
$categoriesFieldsProduct = false;
|
|
|
|
$productIds = Tools::getValue('productsIds', []);
|
|
$categoryId = Tools::getValue('id_allegro_category');
|
|
$category = $this->categoriesProvider->getCategoryDetails($categoryId);
|
|
|
|
if (Tools::getValue('full_path')) {
|
|
foreach ($this->categoriesProvider->getCategoriesPath($categoryId) as $id => $list) {
|
|
$categoriesPath[] = [
|
|
'id' => $id,
|
|
'list' => $list
|
|
];
|
|
}
|
|
} else {
|
|
$categories = $this->categoriesProvider->getCategoriesList($categoryId);
|
|
}
|
|
|
|
if ($category && $category->leaf) {
|
|
$isLeaf = true;
|
|
}
|
|
|
|
if ($isLeaf && !empty($productIds)) {
|
|
try {
|
|
$parameters = $this->categoriesParametersProvider->getParameters($categoryId);
|
|
$taxes = $this->taxesProvider->getTaxesForCategory($categoryId);
|
|
}
|
|
catch (Exception $ex) {}
|
|
|
|
if (!empty($parameters)) {
|
|
list($x_id, $productId, $productAttributeId, $productCategoryId) = explode('_', $productIds[0]);
|
|
|
|
$defaultCategoryMapId = XAllegroCategory::getIdByAllegroCategory($categoryId);
|
|
$categoryMapId = XAllegroCategory::getPreciseMappingCategory($categoryId, $productCategoryId);
|
|
|
|
$parametersFormProduct = new ParametersForm();
|
|
$categoriesFieldsProduct = $parametersFormProduct
|
|
->setController($this)
|
|
->setLanguage($this->allegroApi->getAccount()->id_language)
|
|
->setCategory(new XAllegroCategory($categoryMapId ?: $defaultCategoryMapId))
|
|
->setParameters($parameters)
|
|
->setProductFieldsValues($productId, $productAttributeId)
|
|
->buildForm();
|
|
|
|
$parametersDepending = $parametersFormProduct->getDependsOnValueIds();
|
|
$parametersRequiredIf = $parametersFormProduct->getRequiredIfValuesIds();
|
|
}
|
|
}
|
|
|
|
die(json_encode(array(
|
|
'last_node' => (int)$isLeaf,
|
|
'fields_product' => $categoriesFieldsProduct,
|
|
'fields_product_depending' => $parametersDepending,
|
|
'fields_product_required_if' => $parametersRequiredIf,
|
|
'categories' => $categories,
|
|
'categories_array' => $categoriesPath,
|
|
'category_path' => $this->formatCategoryPath($this->categoriesProvider->getCategoriesPathLite($categoryId)),
|
|
'taxes' => $taxes
|
|
)));
|
|
}
|
|
|
|
public function ajaxProcessGetCategoriesSimilar()
|
|
{
|
|
$categoryDefaultId = Tools::getValue('categoryDefault');
|
|
$categoryList[$categoryDefaultId] = $this->formatCategoryPath($this->categoriesProvider->getCategoriesPathLite($categoryDefaultId));
|
|
|
|
foreach (json_decode(Tools::getValue('categorySimilar')) as $categorySimilar) {
|
|
$categoryList[$categorySimilar->id] = $this->formatCategoryPath($this->categoriesProvider->getCategoriesPathLite($categorySimilar->id));
|
|
}
|
|
|
|
$categorySimilarModalContent = $this->context->smarty->createTemplate($this->module->getLocalPath() . 'views/templates/admin/' . $this->tpl_folder . 'product-category-similar-modal-content.tpl');
|
|
$categorySimilarModalContent->assign([
|
|
'index' => Tools::getValue('index'),
|
|
'categoryList' => $categoryList,
|
|
'categoryCurrent' => Tools::getValue('categoryCurrent')
|
|
]);
|
|
|
|
die(json_encode([
|
|
'success' => true,
|
|
'html' => $categorySimilarModalContent->fetch()
|
|
]));
|
|
}
|
|
|
|
public function ajaxProcessGetCategoriesParameters()
|
|
{
|
|
$categoryList = json_decode(Tools::getValue('categoryList', '[]'), true);
|
|
$categoryPaths =
|
|
$categoryParameters = [];
|
|
|
|
try {
|
|
foreach (array_keys($categoryList) as $categoryId) {
|
|
$categoryPaths[$categoryId] = $this->categoriesProvider->getCategoriesPathLite($categoryId);
|
|
|
|
$categoryParameters[$categoryId] = (new ParametersForm())
|
|
->setController($this)
|
|
->setParameters($this->categoriesParametersProvider->getParameters($categoryId))
|
|
->setFieldsValues()
|
|
->buildForm();
|
|
}
|
|
}
|
|
catch (Exception $ex) {
|
|
die(json_encode([
|
|
'success' => false,
|
|
'message' => (string)$ex
|
|
]));
|
|
}
|
|
|
|
$tpl = $this->context->smarty->createTemplate($this->module->getLocalPath() . 'views/templates/admin/' . $this->tpl_folder . 'bulk-category-parameters-modal-content.tpl');
|
|
$tpl->assign([
|
|
'categoryList' => $categoryList,
|
|
'categoryPaths' => $categoryPaths,
|
|
'categoryParameters' => $categoryParameters
|
|
]);
|
|
|
|
die(json_encode([
|
|
'success' => true,
|
|
'modalContent' => $tpl->fetch()
|
|
]));
|
|
}
|
|
|
|
public function ajaxProcessGetTags()
|
|
{
|
|
$tags_product =
|
|
$tags_category =
|
|
$tags = false;
|
|
|
|
$xCategory = new XAllegroCategory(XAllegroCategory::getIdByAllegroCategory(Tools::getValue('id_allegro_category')));
|
|
$ids = Tools::getValue('productsIds');
|
|
$tags = (new XAllegroHelperTagManager())
|
|
->setEditable(false)
|
|
->renderTagsTable($this->allegroApi);
|
|
|
|
if ($tags && $ids) {
|
|
foreach ($ids as $id)
|
|
{
|
|
list($x_id, $id_product) = explode('_', $id);
|
|
|
|
$tagManger = new XAllegroHelperTagManager();
|
|
$tag_map = $tagManger->getTagMap(
|
|
$xCategory,
|
|
new XAllegroProduct(null, $id_product),
|
|
$this->allegroApi->getAccount()->id
|
|
);
|
|
|
|
if (!empty($tag_map)) {
|
|
$tags_product[$x_id] = $tagManger
|
|
->setEditable(false)
|
|
->renderTagsTable($this->allegroApi, $tag_map);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!Tools::getValue('onlyProducts')) {
|
|
$tags_category = (new XAllegroHelperTagManager())
|
|
->setMapType(XAllegroTagManager::MAP_AUCTION)
|
|
->setContainer('tags')
|
|
->renderAuctionManager($this->allegroApi, $xCategory->tags);
|
|
}
|
|
|
|
die(json_encode(array(
|
|
'tags' => $tags,
|
|
'tags_product' => $tags_product,
|
|
'tags_category' => $tags_category,
|
|
'tag_manager_auction_limit' => XAllegroApi::TAG_AUCTION_LIMIT
|
|
)));
|
|
}
|
|
|
|
public function ajaxProcessGetPas()
|
|
{
|
|
$pas = new XAllegroPas(Tools::getValue('id'));
|
|
|
|
die(json_encode(array(
|
|
'id' => $pas->id,
|
|
'name' => $pas->name,
|
|
'city' => $pas->city,
|
|
'country_code' => $pas->country_code,
|
|
'post_code' => $pas->post_code,
|
|
'province' => $pas->province,
|
|
'invoice' => $pas->invoice,
|
|
'handling_time' => $pas->handling_time,
|
|
'additional_info' => $pas->additional_info
|
|
)));
|
|
}
|
|
|
|
public function ajaxProcessChangeShippingRate()
|
|
{
|
|
$deliveryMethods = $this->provideDeliveryMethods(Tools::getValue('shipping_rate'), false);
|
|
|
|
if (!empty($this->errors)) {
|
|
die(json_encode(array(
|
|
'result' => false,
|
|
'message' => $this->errors
|
|
)));
|
|
}
|
|
|
|
die(json_encode(array(
|
|
'result' => true,
|
|
'deliveryMethods' => $deliveryMethods
|
|
)));
|
|
}
|
|
|
|
public function ajaxProcessPerformAuctions()
|
|
{
|
|
$auctionsData = $this->_getAuctionsFromPost();
|
|
$item = &$auctionsData['item'];
|
|
|
|
// exit;
|
|
if (!$item['enabled']) {
|
|
die(json_encode([]));
|
|
}
|
|
|
|
$offerId = 0;
|
|
$calculatedFees = 0;
|
|
$description = null;
|
|
$imagesUploaded = [];
|
|
$errors = [];
|
|
|
|
$this->validateAuction($item, $errors);
|
|
|
|
// exit;
|
|
if (!empty($errors)) {
|
|
$this->returnOfferErrorResponse($errors, $item['x_id'], $offerId, $item['title']);
|
|
}
|
|
|
|
if ($item['id_template']) {
|
|
$templateOverride = false;
|
|
$templateModifierExec = Hook::exec(
|
|
'actionX13AllegroTemplateModifier',
|
|
[
|
|
'item' => $item,
|
|
'template' => &$templateOverride
|
|
],
|
|
null,
|
|
true
|
|
);
|
|
|
|
if ($templateModifierExec && $templateOverride !== false) {
|
|
$imagesUploaded = $this->uploadOfferImages($templateOverride['usedImages'], $errors);
|
|
foreach($imagesUploaded as $image) {
|
|
$templateOverride['content'] = preg_replace('/' . $image['field'] . '/', $image['url'], $templateOverride['content']);
|
|
}
|
|
|
|
$description = json_decode($templateOverride['content']);
|
|
} else {
|
|
$template = $this->prepareOfferTemplate($item);
|
|
$imagesUploaded = $this->uploadOfferImages($template->getUsedImages(), $errors);
|
|
$description = $template->encodeTemplate($imagesUploaded);
|
|
}
|
|
}
|
|
|
|
// exit;
|
|
if (!empty($errors)) {
|
|
$this->returnOfferErrorResponse($errors, $item['x_id'], $offerId, $item['title']);
|
|
}
|
|
|
|
// TODO: bring back tags
|
|
$tags = [];
|
|
/*if ($item['tags_individual'] && !empty($item['tags'])) {
|
|
$tags = array_keys($item['tags']);
|
|
}
|
|
if (isset($auctionsData['tags'][$this->allegroApi->getAccount()->id]) && ! empty($auctionsData['tags'][$this->allegroApi->getAccount()->id])) {
|
|
$tags = array_merge($tags, array_keys($auctionsData['tags'][$this->allegroApi->getAccount()->id]));
|
|
}
|
|
$tags = array_slice($tags, 0, XAllegroApi::TAG_AUCTION_LIMIT);*/
|
|
|
|
// @todo move this logic outside of this controller
|
|
try {
|
|
$parametersProvider = new CategoriesParametersFactory($this->categoriesParametersProvider->getParameters($item['category_id']));
|
|
$offerParameters = $parametersProvider->prepareParametersForAuction($item['category_parameters'], $item['category_ambiguous_parameters']);
|
|
$productizationDescriptionImages = [];
|
|
$productizationImages = [];
|
|
$psImages = [];
|
|
|
|
foreach ($imagesUploaded as $psImage) {
|
|
$psImages[] = $psImage['url'];
|
|
}
|
|
|
|
if ($item['productization_mode'] == XAllegroAuction::PRODUCTIZATION_ASSIGN) {
|
|
// If we don't want to use productization description, we need to remove images coming from it to avoid possible duplicates
|
|
$imagesFromCatalogToIgnore = [];
|
|
if ('prestashop' == XAllegroConfiguration::get('PRODUCTIZATION_DESCRIPTION')) {
|
|
if (!empty($item['allegro_product_description'])) {
|
|
foreach ($item['allegro_product_description'] as $sections) {
|
|
foreach ($sections as $section) {
|
|
if (empty($section->items)) {
|
|
continue;
|
|
}
|
|
|
|
foreach ($section->items as $sectionItem) {
|
|
if ('IMAGE' == $sectionItem->type && !empty($sectionItem->url)) {
|
|
$imagesFromCatalogToIgnore[] = $sectionItem->url;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If we want all data from the Allegro Catalog, and we have them, we need to reset images from the PrestaShop
|
|
if ('allegro' == XAllegroConfiguration::get('PRODUCTIZATION_DESCRIPTION')
|
|
&& !empty($item['allegro_product_description'])
|
|
&& 'allegro' == XAllegroConfiguration::get('PRODUCTIZATION_IMAGES')
|
|
&& !empty($item['allegro_product_images'])
|
|
) {
|
|
$psImages = [];
|
|
}
|
|
|
|
if ('allegro' == XAllegroConfiguration::get('PRODUCTIZATION_DESCRIPTION') && !empty($item['allegro_product_description'])) {
|
|
$description = $item['allegro_product_description'];
|
|
|
|
// TODO: refacto, duplication with ignored images
|
|
$descriptionImages = [];
|
|
foreach ($description as $sections) {
|
|
foreach ($sections as $section) {
|
|
if (empty($section->items)) {
|
|
continue;
|
|
}
|
|
|
|
foreach ($section->items as $sectionItem) {
|
|
if ($sectionItem->type == 'IMAGE' && !empty($sectionItem->url)) {
|
|
$descriptionImages[] = $sectionItem->url;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach ($descriptionImages as $url) {
|
|
$productizationDescriptionImages[] = $url;
|
|
}
|
|
}
|
|
|
|
if ('allegro' == XAllegroConfiguration::get('PRODUCTIZATION_IMAGES') && !empty($item['allegro_product_images'])
|
|
&& empty($productizationDescriptionImages)
|
|
) {
|
|
if (count($item['allegro_product_images']) == 1) {
|
|
$imagesFromCatalogToIgnore = [];
|
|
}
|
|
foreach ($item['allegro_product_images'] as $catalogImage) {
|
|
if (in_array($catalogImage['url'], $imagesFromCatalogToIgnore)) {
|
|
continue;
|
|
}
|
|
$productizationImages[] = $catalogImage['url'];
|
|
}
|
|
}
|
|
|
|
if ('merge' == XAllegroConfiguration::get('PRODUCTIZATION_IMAGES')
|
|
&& !empty($item['allegro_product_images'])
|
|
&& empty($productizationDescriptionImages)
|
|
) {
|
|
if (1 == count($item['allegro_product_images'])) {
|
|
$imagesFromCatalogToIgnore = [];
|
|
}
|
|
|
|
foreach ($item['allegro_product_images'] as $catalogImage) {
|
|
if (in_array($catalogImage['url'], $imagesFromCatalogToIgnore)) {
|
|
continue;
|
|
}
|
|
$productizationImages[] = $catalogImage['url'];
|
|
}
|
|
}
|
|
|
|
// If description is coming from PrestaShop, we need to make sure that we have a place for them
|
|
if ('prestashop' == XAllegroConfiguration::get('PRODUCTIZATION_DESCRIPTION')
|
|
|| 'allegro' == XAllegroConfiguration::get('PRODUCTIZATION_DESCRIPTION') && empty($item['allegro_product_description'])
|
|
) {
|
|
$productizationImages = array_slice($productizationImages, 0, XAllegroApi::PHOTO_COMPANY_MAX - count($psImages));
|
|
}
|
|
}
|
|
|
|
/** @var OfferProduct $offer */
|
|
$offer = (new JsonMapBuilder('OfferProduct'))->map(new OfferProduct());
|
|
$offer = $this->prepareOfferBaseData($offer, $auctionsData, $description);
|
|
|
|
// Due to the fact that Allegro can return us a lot of images, we need to make sure that we have a place for them
|
|
$imagesFromCatalog = array_merge($productizationDescriptionImages, $productizationImages);
|
|
$psImages = array_slice($psImages, 0, XAllegroApi::PHOTO_COMPANY_MAX - count($imagesFromCatalog));
|
|
$images = array_slice(array_merge($psImages, $imagesFromCatalog), 0, XAllegroApi::PHOTO_COMPANY_MAX);
|
|
|
|
// we need to split the parameters between those for the product, and those for the auction itself
|
|
$parametersDescribingProduct = $parametersProvider->getProductParametersIDs();
|
|
$parametersForProduct = [];
|
|
|
|
foreach ($offerParameters as $key => $parameter) {
|
|
if (in_array($parameter->id, $parametersDescribingProduct)) {
|
|
$parametersForProduct[] = $parameter;
|
|
unset($offerParameters[$key]);
|
|
}
|
|
}
|
|
|
|
$offer->parameters = array_values($offerParameters);
|
|
|
|
/** @var AllegroProduct $allegroProduct */
|
|
$allegroProduct = (new JsonMapBuilder('Product'))->map(new AllegroProduct());
|
|
$allegroProduct->id = $item['allegro_product_id'];
|
|
$allegroProduct->name = $item['title'];
|
|
$allegroProduct->category->id = $item['category_id'];
|
|
$allegroProduct->parameters = $parametersForProduct;
|
|
|
|
foreach ($images as $image) {
|
|
$allegroProduct->image($image);
|
|
}
|
|
|
|
$offer->setProduct($allegroProduct);
|
|
|
|
foreach ($images as $image) {
|
|
$offer->image($image);
|
|
}
|
|
|
|
// This property is valid only for the first product in the product set
|
|
// @todo make it in model
|
|
if (!empty($auctionsData['responsible_person'])) {
|
|
$responsiblePerson = new StdClass();
|
|
$responsiblePerson->id = $auctionsData['responsible_person'];
|
|
|
|
$offer->productSet[0]->responsiblePerson = $responsiblePerson;
|
|
}
|
|
|
|
$offer->publication->status = 'ACTIVE';
|
|
|
|
if ($auctionsData['starting_at']) {
|
|
$offer->publication->startingAt = new DateTime($auctionsData['starting_at']);
|
|
}
|
|
|
|
if ($item['price_calculate_fees'] && (float)$item['price_buy_now'] != 0) {
|
|
$promotion = new Promotion();
|
|
|
|
foreach ($item['promotionPackages'] as $packageOptions) {
|
|
// extraPackages [checkbox]
|
|
if (is_array($packageOptions) && !empty($packageOptions)) {
|
|
foreach ($packageOptions as $packageId) {
|
|
$promotion->{$packageId} = true;
|
|
}
|
|
}
|
|
// basePackages [radio]
|
|
else if ($packageOptions) {
|
|
$promotion->{$packageOptions} = true;
|
|
}
|
|
}
|
|
|
|
$calculatedFees = (new OfferFeesProvider($this->allegroApi))->getOfferFees($offer, $promotion);
|
|
$offer->sellingMode->price->amount += $calculatedFees;
|
|
}
|
|
|
|
$offerProcessManager = new OfferProcessManager();
|
|
$resource = $this->allegroApi->sale()->productOffers();
|
|
|
|
/** @var OfferProduct $result */
|
|
$result = $resource->create($offer);
|
|
$offerId = $result->id;
|
|
|
|
//if (!empty($result->validation->errors)) {
|
|
// foreach ($result->validation->errors as $error) {
|
|
// $errors[] = ($error->userMessage ?: $error->message);
|
|
// }
|
|
//}
|
|
|
|
// exit;
|
|
//if (!empty($errors)) {
|
|
// $this->returnOfferErrorResponse($errors, $item['x_id'], $offerId, $item['title']);
|
|
//}
|
|
|
|
$auctionObj = new XAllegroAuction();
|
|
$auctionObj->id_xallegro_account = $this->allegroApi->getAccount()->id;
|
|
$auctionObj->id_shop = $this->context->shop->id;
|
|
$auctionObj->id_shop_group = $this->context->shop->id_shop_group;
|
|
$auctionObj->id_auction = $offerId;
|
|
$auctionObj->id_product = $item['id_product'];
|
|
$auctionObj->id_product_attribute = $item['id_product_attribute'];
|
|
$auctionObj->selling_mode = $item['selling_mode'];
|
|
$auctionObj->quantity = $item['quantity'];
|
|
$auctionObj->price_buy_now = $item['price_buy_now'] + $calculatedFees;
|
|
$auctionObj->fees = $calculatedFees;
|
|
$auctionObj->start_time = ($auctionsData['starting_at'] ? date('Y-m-d H:i:s', strtotime($auctionsData['starting_at'])) : '0000-00-00 00:00:00');
|
|
$auctionObj->start = 1;
|
|
$auctionObj->closed = 1;
|
|
$auctionObj->auto_renew = (!is_numeric($item['auto_renew']) ? null : (int)$item['auto_renew']);
|
|
$auctionObj->save();
|
|
|
|
foreach ($item['marketplaces'] as $marketplaceId => $marketplaceItem) {
|
|
if ($marketplaceId === $this->allegroApi->getAccount()->base_marketplace) {
|
|
continue;
|
|
}
|
|
|
|
$auctionObj->addAuctionMarketplace($marketplaceId, $marketplaceItem['price_buy_now']);
|
|
}
|
|
|
|
$operationId = (isset($resource->getHeaders()->location) ? basename($resource->getHeaders()->location) : null);
|
|
|
|
if ($operationId && $resource->getCode() === 202) {
|
|
$offerProcessManager->createProcess(
|
|
$this->allegroApi->getAccount()->id,
|
|
$offerId,
|
|
$operationId,
|
|
[ProcessOperation::STATUS_ACTIVE_CREATE]
|
|
);
|
|
}
|
|
|
|
$this->log
|
|
->account($this->allegroApi->getAccount()->id)
|
|
->product($this->context->shop->id, $item['id_product'], $item['id_product_attribute'])
|
|
->offer($offerId)
|
|
->logDatabase()
|
|
->info(LogType::OFFER_CREATE(), ($operationId ? ['operationId' => $operationId] : null));
|
|
|
|
$this->assignOfferPromotionPackages($offerId, $item);
|
|
}
|
|
catch (Exception $ex) {
|
|
// exit;
|
|
$this->returnOfferErrorResponse([(string)$ex], $item['x_id'], $offerId, $item['title']);
|
|
}
|
|
|
|
// exit;
|
|
$this->returnOfferSuccessResponse($item['x_id'], $offerId, $item['title']);
|
|
}
|
|
|
|
/**
|
|
* @param array $item
|
|
* @return XAllegroTemplate
|
|
*/
|
|
private function prepareOfferTemplate(array $item)
|
|
{
|
|
$product = new Product($item['id_product'], true, $this->allegroApi->getAccount()->id_language, $this->context->shop->id);
|
|
$xProduct = new XAllegroProduct(null, $product->id);
|
|
$xTemplate = new XAllegroTemplate($item['id_template']);
|
|
|
|
$xTemplate->setProduct($product, $xProduct);
|
|
|
|
if ($item['id_product_attribute']) {
|
|
$combination = $product->getAttributeCombinationsById($item['id_product_attribute'], $this->allegroApi->getAccount()->id_language);
|
|
$xTemplate->setProductAttribute($combination);
|
|
}
|
|
|
|
$templateVariables = [
|
|
'id_product' => $item['id_product'],
|
|
'id_product_attribute' => $item['id_product_attribute'],
|
|
'price_buy_now' => $item['price_buy_now'],
|
|
'title' => $item['title'],
|
|
'description' => $item['description']
|
|
];
|
|
|
|
$xTemplate->prepareVariables($templateVariables, $product, $item['images'])->render();
|
|
|
|
return $xTemplate;
|
|
}
|
|
|
|
/**
|
|
* @param array $images
|
|
* @param array|null $errors
|
|
* @return array
|
|
*/
|
|
private function uploadOfferImages(array $images, array &$errors = null)
|
|
{
|
|
$validImagesCount = 0;
|
|
|
|
for ($uploadErrors = 0; $uploadErrors < 3; $uploadErrors++) {
|
|
if ($validImagesCount < count($images)) {
|
|
foreach ($images as &$image) {
|
|
if (isset($image['valid_upload']) && $image['valid_upload']) {
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
/** @var Image $imageObject */
|
|
$imageObject = (new JsonMapBuilder('Image'))->map(new Image());
|
|
$imageObject->url = $image['url'];
|
|
|
|
$originalUrl = $image['url'];
|
|
|
|
if (XAllegroConfiguration::get('IMAGES_UPLOAD_TYPE') == 'BINARY') {
|
|
$imageUrl = $this->allegroApi->sale()->images()->uploadBinary($imageObject);
|
|
} else {
|
|
$imageUrl = $this->allegroApi->sale()->images()->upload($imageObject);
|
|
}
|
|
|
|
$image['url'] = $imageUrl->location;
|
|
$image['valid_upload'] = 1;
|
|
$validImagesCount++;
|
|
|
|
if (isset($errors[$originalUrl])) {
|
|
unset($errors[$originalUrl]);
|
|
}
|
|
}
|
|
catch (Exception $ex) {
|
|
$image['valid_upload'] = 0;
|
|
$errors[$originalUrl] = $ex . ' - ' . $originalUrl;
|
|
}
|
|
}
|
|
unset($image);
|
|
|
|
if (!empty($errors)) {
|
|
$uploadErrors++;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $images;
|
|
}
|
|
|
|
/**
|
|
* @param OfferProduct $offer
|
|
* @param array $auctionsData
|
|
* @param stdClass $description
|
|
* @return OfferProduct
|
|
*/
|
|
private function prepareOfferBaseData($offer, array $auctionsData, $description)
|
|
{
|
|
$item = &$auctionsData['item'];
|
|
|
|
$offer->name = $item['title'];
|
|
$offer->description = $description;
|
|
$offer->category->id = $item['category_id'];
|
|
$offer->publication->duration = $item['duration'];
|
|
$offer->sellingMode->format = $item['selling_mode'];
|
|
$offer->sellingMode->price->amount = $item['price_buy_now'];
|
|
$offer->sellingMode->price->currency = $this->allegroApi->getCurrency()->iso_code;
|
|
$offer->sellingMode->startingPrice->amount = $item['price_starting'];
|
|
$offer->sellingMode->startingPrice->currency = $this->allegroApi->getCurrency()->iso_code;
|
|
$offer->sellingMode->minimalPrice->amount = $item['price_minimal'];
|
|
$offer->sellingMode->minimalPrice->currency = $this->allegroApi->getCurrency()->iso_code;
|
|
$offer->stock->available = $item['quantity'];
|
|
$offer->stock->unit = $item['unit'];
|
|
$offer->delivery->handlingTime = $auctionsData['pas']['handling_time'];
|
|
$offer->delivery->additionalInfo = $auctionsData['pas']['additional_info'];
|
|
$offer->delivery->shippingRates->id = $auctionsData['pas']['shipping_rate'];
|
|
$offer->delivery->shipmentDate = ($item['preorder'] ? new DateTime($item['preorder_date']) : null);
|
|
$offer->location->countryCode = $auctionsData['pas']['country_code'];
|
|
$offer->location->province = $auctionsData['pas']['province'];
|
|
$offer->location->postCode = $auctionsData['pas']['post_code'];
|
|
$offer->location->city = $auctionsData['pas']['city'];
|
|
$offer->payments->invoice = $auctionsData['pas']['invoice'];
|
|
$offer->afterSalesServices->warranty->id = $auctionsData['warranty'];
|
|
$offer->afterSalesServices->impliedWarranty->id = $auctionsData['implied_warranty'];
|
|
$offer->afterSalesServices->returnPolicy->id = $auctionsData['return_policy'];
|
|
$offer->additionalServices->id = $auctionsData['additional_services'];
|
|
$offer->messageToSellerSettings->mode = $auctionsData['message_to_seller'];
|
|
$offer->b2b->buyableOnlyByBusiness = $auctionsData['offer_b2b_only'];
|
|
|
|
foreach ($item['marketplaces'] as $marketplaceId => $marketplaceItem) {
|
|
if ($marketplaceId === $this->allegroApi->getAccount()->base_marketplace) {
|
|
continue;
|
|
}
|
|
|
|
$marketplacesProvider = new MarketplacesProvider($marketplaceId);
|
|
|
|
/** @var AdditionalMarketplace $additionalMarketplace */
|
|
$additionalMarketplace = (new JsonMapBuilder('AdditionalMarketplace'))->map(new AdditionalMarketplace());
|
|
$additionalMarketplace->sellingMode->price->amount = $marketplaceItem['price_buy_now'];
|
|
$additionalMarketplace->sellingMode->price->currency = $marketplacesProvider->getMarketplaceCurrency()->iso_code;
|
|
|
|
$offer->additionalMarketplaces->{$marketplaceId} = $additionalMarketplace;
|
|
|
|
if ($item['send_tax'] && $marketplaceItem['tax'] !== '') {
|
|
$offer->taxSettings->addTaxRate($marketplaceItem['tax'], $marketplacesProvider->getMarketplaceCountry()->iso_code);
|
|
}
|
|
}
|
|
|
|
if ($item['send_tax']) {
|
|
if (isset($item['marketplaces'][$this->allegroApi->getAccount()->base_marketplace]['tax'])
|
|
&& $item['marketplaces'][$this->allegroApi->getAccount()->base_marketplace]['tax'] != ''
|
|
) {
|
|
$offer->taxSettings->addTaxRate($item['marketplaces'][$this->allegroApi->getAccount()->base_marketplace]['tax'], $this->context->country->iso_code);
|
|
}
|
|
} else {
|
|
$offer->taxSettings = null;
|
|
}
|
|
|
|
if ($item['size_table']) {
|
|
$offer->sizeTable->id = $item['size_table'];
|
|
} else {
|
|
$offer->sizeTable = null;
|
|
}
|
|
|
|
if ($item['wholesale_price']) {
|
|
$offer->discounts->wholesalePriceList->id = $item['wholesale_price'];
|
|
} else {
|
|
$offer->discounts = null;
|
|
}
|
|
|
|
$externalId = null;
|
|
switch (XAllegroConfiguration::get('AUCTION_EXTERNAL')) {
|
|
case XAllegroAuction::EXTERNAL_ID:
|
|
$externalId = trim($item['id_product'] . ($item['id_product_attribute'] ? '_' . $item['id_product_attribute'] : ''));
|
|
break;
|
|
|
|
case XAllegroAuction::EXTERNAL_REFERENCE:
|
|
$externalId = trim($item['reference']);
|
|
break;
|
|
|
|
case XAllegroAuction::EXTERNAL_EAN:
|
|
$externalId = trim($item['ean']);
|
|
break;
|
|
|
|
case XAllegroAuction::EXTERNAL_UPC:
|
|
$externalId = trim($item['upc']);
|
|
break;
|
|
|
|
case XAllegroAuction::EXTERNAL_ISBN:
|
|
$externalId = trim($item['isbn']);
|
|
break;
|
|
|
|
case XAllegroAuction::EXTERNAL_MPN:
|
|
$externalId = trim($item['mpn']);
|
|
break;
|
|
}
|
|
|
|
if (!empty($externalId)) {
|
|
$offer->external->id = $externalId;
|
|
} else {
|
|
$offer->external = null;
|
|
}
|
|
|
|
return $offer;
|
|
}
|
|
|
|
/**
|
|
* @param $offerId
|
|
* @param array $auctionsData
|
|
* @return void
|
|
*/
|
|
private function assignOfferPromotionPackages($offerId, array $auctionsData)
|
|
{
|
|
$promotionPackages = new PromotionPackages();
|
|
|
|
foreach ($auctionsData['promotionPackages'] as $packageType => $packageOptions) {
|
|
// extraPackages [checkbox]
|
|
if (is_array($packageOptions) && !empty($packageOptions)) {
|
|
foreach ($packageOptions as $packageId) {
|
|
$promotionPackages->addModification(PackageModificationType::CHANGE, $packageType, $packageId);
|
|
}
|
|
}
|
|
// basePackages [radio]
|
|
else if ($packageOptions) {
|
|
$promotionPackages->addModification(PackageModificationType::CHANGE, $packageType, $packageOptions);
|
|
}
|
|
}
|
|
|
|
if (!empty($promotionPackages->modifications)) {
|
|
$this->allegroApi->sale()->promotionPackages()->modifyOfferPromotionPackages($offerId, $promotionPackages);
|
|
|
|
// @todo add Log
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param array $errors
|
|
* @param int $currentIndex
|
|
* @param float $offerId
|
|
* @param string $offerTitle
|
|
* @return void
|
|
*/
|
|
private function returnOfferErrorResponse(array $errors, $currentIndex, $offerId, $offerTitle)
|
|
{
|
|
$error_content = 'Wystapiły nastepujące błędy:<ul>';
|
|
foreach ($errors as $error) {
|
|
foreach (explode(';', $error) as $errorLine) {
|
|
$error_content .= '<li>' . $errorLine . '</li>';
|
|
}
|
|
}
|
|
$error_content .= '</ul>';
|
|
|
|
$response[] = [
|
|
'success' => false,
|
|
'x_id' => $currentIndex,
|
|
'id_auction' => $offerId,
|
|
'message' => '<strong>' . $offerTitle . ': </strong>' . $error_content
|
|
];
|
|
|
|
die(json_encode($response));
|
|
}
|
|
|
|
/**
|
|
* @param $currentIndex
|
|
* @param $offerId
|
|
* @param $offerTitle
|
|
* @return void
|
|
*/
|
|
private function returnOfferSuccessResponse($currentIndex, $offerId, $offerTitle)
|
|
{
|
|
$url = XAllegroApi::generateOfferUrl($offerId, $this->allegroApi->getAccount()->sandbox);
|
|
|
|
$response[] = [
|
|
'success' => true,
|
|
'x_id' => $currentIndex,
|
|
'id_auction' => $offerId,
|
|
'message' => '<strong>' . $offerTitle . ': </strong> <a href="' . $url . '" target="_blank" rel="nofollow">' . $url . '</a>'
|
|
];
|
|
|
|
die(json_encode($response));
|
|
}
|
|
|
|
/**
|
|
* @param array $categoryPath
|
|
* @return string
|
|
*/
|
|
private function formatCategoryPath(array $categoryPath)
|
|
{
|
|
return implode('/', array_map(function($value) {
|
|
return "<span>$value</span>";
|
|
}, $categoryPath));
|
|
}
|
|
}
|