721 lines
27 KiB
PHP
721 lines
27 KiB
PHP
<?php
|
|
|
|
// fix cache redirects
|
|
if (!headers_sent()) {
|
|
header('Cache-Control: no-store, no-cache, must-revalidate');
|
|
}
|
|
|
|
if (!defined('_PS_VERSION_')) {
|
|
exit;
|
|
}
|
|
|
|
require_once (dirname(__FILE__) . '/x13allegro.ion.php');
|
|
|
|
define('X13_ALLEGRO_VERSION', '7.4.0');
|
|
define('X13_ALLEGRO_DEBUG', false);
|
|
|
|
class x13allegro extends x13allegro\XAllegroModuleCore
|
|
{
|
|
public $installed;
|
|
|
|
/** @var XAllegroUpdate|null */
|
|
public $update = null;
|
|
|
|
/** @var XAllegroConfiguration */
|
|
public $config;
|
|
|
|
/** @var x13allegro\Component\Session\SessionMessages|null */
|
|
public $sessionMessages = null;
|
|
|
|
/** @var bool */
|
|
public $bootstrap;
|
|
|
|
public function __construct()
|
|
{
|
|
$this->name = 'x13allegro';
|
|
$this->tab = 'market_place';
|
|
$this->version = X13_ALLEGRO_VERSION;
|
|
$this->author = 'X13.pl';
|
|
$this->need_instance = 0;
|
|
$this->bootstrap = true;
|
|
$this->ps_versions_compliancy = ['min' => '1.6.0.0', 'max' => '8.1.99'];
|
|
|
|
parent::__construct();
|
|
|
|
$this->config = new XAllegroConfiguration($this);
|
|
|
|
if (strpos($_SERVER['SCRIPT_NAME'], 'sync.php') === false
|
|
&& ($this->context->controller instanceof AdminController
|
|
|| $this->context->controller instanceof ModuleAdminController)
|
|
) {
|
|
// hack for Symfony sessions
|
|
$this->context->link->getAdminLink('AdminProducts');
|
|
$this->sessionMessages = new \x13allegro\Component\Session\SessionMessages();
|
|
}
|
|
|
|
if ($this->id && !$this->isHookRegistered('displayBackOfficeHeader')) {
|
|
$this->registerHook('displayBackOfficeHeader');
|
|
}
|
|
|
|
// check if configuration is valid
|
|
if ($this->id) {
|
|
$this->config->checkAndInstallDependencies();
|
|
}
|
|
|
|
$this->displayName = $this->l('Integracja PrestaShop z Allegro');
|
|
$this->description = $this->l('Zaawansowany moduł integrujący sklep PrestaShop z Allegro. Szybkie wystawianie ofert, pełna kontrola ilości oraz cen. Opcja importu zamówień z Allegro.');
|
|
$this->confirmUninstall = $this->l('Spowoduje usunięcie wszystkich powiązań ofert, kategorii, szablonów, oraz ustawień modułu!');
|
|
}
|
|
|
|
public function getContent()
|
|
{
|
|
Tools::redirectAdmin($this->context->link->getAdminLink('AdminXAllegroConfiguration'));
|
|
}
|
|
|
|
public function hookDisplayHeader()
|
|
{
|
|
if (XAllegroConfiguration::get('FRONT_DISPLAY_LINK')
|
|
&& version_compare(_PS_VERSION_, '1.7.0.0', '<')
|
|
&& Tools::getValue('controller') == 'product'
|
|
) {
|
|
$this->context->controller->addJS($this->_path . 'views/js/x13allegro-front.js');
|
|
}
|
|
}
|
|
|
|
public function hookDisplayLeftColumnProduct($params)
|
|
{
|
|
if (XAllegroConfiguration::get('FRONT_DISPLAY_LINK_HOOK') != 'displayLeftColumnProduct') {
|
|
return null;
|
|
}
|
|
|
|
return $this->generateProductAllegroAuctionLink($params);
|
|
}
|
|
|
|
public function hookDisplayRightColumnProduct($params)
|
|
{
|
|
if (XAllegroConfiguration::get('FRONT_DISPLAY_LINK_HOOK') != 'displayRightColumnProduct') {
|
|
return null;
|
|
}
|
|
|
|
return $this->generateProductAllegroAuctionLink($params);
|
|
}
|
|
|
|
public function hookDisplayProductButtons($params)
|
|
{
|
|
if (version_compare(_PS_VERSION_, '1.7.0.0', '<')
|
|
&& XAllegroConfiguration::get('FRONT_DISPLAY_LINK_HOOK') != 'displayProductButtons'
|
|
) {
|
|
return null;
|
|
}
|
|
|
|
return $this->generateProductAllegroAuctionLink($params);
|
|
}
|
|
|
|
public function hookDisplayProductAdditionalInfo($params)
|
|
{
|
|
if (version_compare(_PS_VERSION_, '1.7.0.0', '<')
|
|
&& XAllegroConfiguration::get('FRONT_DISPLAY_LINK_HOOK') != 'displayProductAdditionalInfo'
|
|
) {
|
|
return null;
|
|
}
|
|
|
|
return $this->generateProductAllegroAuctionLink($params);
|
|
}
|
|
|
|
public function hookDisplayProductAllegroAuctionLink($params)
|
|
{
|
|
if (XAllegroConfiguration::get('FRONT_DISPLAY_LINK_HOOK') != 'displayProductAllegroAuctionLink') {
|
|
return null;
|
|
}
|
|
|
|
return $this->generateProductAllegroAuctionLink($params);
|
|
}
|
|
|
|
private function generateProductAllegroAuctionLink($params)
|
|
{
|
|
if (!XAllegroConfiguration::get('FRONT_DISPLAY_LINK')) {
|
|
return null;
|
|
}
|
|
|
|
if (version_compare(_PS_VERSION_, '1.7.0.0', '>=')) {
|
|
if ($auction = XAllegroAuction::getAuctionByProduct($params['product']['id_product'], $params['product']['id_product_attribute'])) {
|
|
$this->context->smarty->assign([
|
|
'href' => 'https://allegro.pl/show_item.php?item=' . $auction['id_auction']
|
|
]);
|
|
}
|
|
}
|
|
|
|
$this->context->smarty->assign([
|
|
'allegro_img' => $this->context->shop->getBaseURL(Configuration::get('PS_SSL_ENABLED')) . 'modules/x13allegro/img/AdminXAllegroMain.png'
|
|
]);
|
|
|
|
return $this->display(__FILE__, 'product-allegro-auction-link.tpl');
|
|
}
|
|
|
|
public function hookDisplayAdminOrderTabShip($params)
|
|
{
|
|
if (!XAllegroOrder::exists($params['order']->id)) {
|
|
return null;
|
|
}
|
|
|
|
return $this->display(__FILE__, 'views/templates/hook/admin-order-tab-ship.tpl');
|
|
}
|
|
|
|
public function hookDisplayAdminOrderContentShip($params)
|
|
{
|
|
$allegroOrder = XAllegroOrder::getByOrderId($params['order']->id);
|
|
|
|
if (!$allegroOrder) {
|
|
return null;
|
|
}
|
|
|
|
$package_info = XAllegroCarrier::getPackageInfo($params['order']->id);
|
|
$order_shipping = $params['order']->getShipping();
|
|
|
|
foreach ($package_info as &$package) {
|
|
$package['same_number'] = (strcasecmp($package['order_tracking_number'], $package['send_tracking_number']) == 0);
|
|
}
|
|
|
|
foreach ($order_shipping as &$shipping) {
|
|
$shipping['carrier_name'] = (method_exists(Cart::class, 'replaceZeroByShopName') ? Cart::replaceZeroByShopName($shipping['carrier_name'], null) : $shipping['carrier_name']);
|
|
$shipping['package_info'] = (isset($package_info[$shipping['id_order_carrier']]) ? $package_info[$shipping['id_order_carrier']] : []);
|
|
}
|
|
|
|
try {
|
|
$api = new \x13allegro\Api\XAllegroApi(new XAllegroAccount($allegroOrder->id_xallegro_account));
|
|
$carrierOperators = (new \x13allegro\Api\DataProvider\CarrierOperatorsProvider($api))->getCarriers();
|
|
}
|
|
catch (Exception $ex) {
|
|
$carrierOperators = [];
|
|
}
|
|
|
|
$this->context->smarty->assign([
|
|
'order' => $params['order'],
|
|
'order_shipping' => $order_shipping,
|
|
'order_shipping_token' => Tools::getAdminTokenLite('AdminXAllegroOrderShipping'),
|
|
'carrier_list' => $carrierOperators
|
|
]);
|
|
|
|
return $this->display(__FILE__, 'views/templates/hook/admin-order-content-ship.tpl');
|
|
}
|
|
|
|
public function hookDisplayAdminOrderLeft($params)
|
|
{
|
|
/** @var XAllegroOrder $allegroOrder */
|
|
$allegroOrder = XAllegroOrder::getByOrderId($params['id_order']);
|
|
|
|
if (!$allegroOrder) {
|
|
return null;
|
|
}
|
|
|
|
$order = new Order($params['id_order']);
|
|
$allegroAccount = new XAllegroAccount($allegroOrder->id_xallegro_account);
|
|
|
|
try {
|
|
$api = new \x13allegro\Api\XAllegroApi($allegroAccount);
|
|
$invoices = $api->order()->checkoutForms($allegroOrder->checkout_form)->invoices()->getInvoices()->invoices;
|
|
}
|
|
catch (Exception $ex) {
|
|
$invoices = [];
|
|
}
|
|
|
|
$countries = [];
|
|
foreach (Country::getCountries($this->context->language->id) as $country) {
|
|
$countries[$country['iso_code']] = $country['name'];
|
|
}
|
|
|
|
$this->context->smarty->assign([
|
|
'languageId' => $this->context->language->id,
|
|
'countries' => $countries,
|
|
'orderStateId' => $order->current_state,
|
|
'orderHasInvoice' => Configuration::get('PS_INVOICE') && $order->hasInvoice(),
|
|
'allegroAccount' => $allegroAccount,
|
|
'allegroOrder' => $allegroOrder,
|
|
'allegroInvoices' => $invoices,
|
|
'unsupportedEvents' => \x13allegro\Repository\FulfillmentStatusRepository::getUnsupportedEvents(),
|
|
'fulfilmentStatuses' => \x13allegro\Repository\FulfillmentStatusRepository::toChoseList(),
|
|
'marketplaceProvider' => new \x13allegro\Api\DataProvider\MarketplacesProvider($allegroOrder->marketplace),
|
|
'ALLEGRO_STATUS_FILLED_IN' => XAllegroConfiguration::get('ALLEGRO_STATUS_FILLED_IN'),
|
|
'orderMainToken' => Tools::getAdminTokenLite('AdminXAllegroOrderMain')
|
|
]);
|
|
|
|
return $this->display(__FILE__, 'views/templates/hook/admin-order-left.tpl');
|
|
}
|
|
|
|
public function hookDisplayAdminOrder($params)
|
|
{
|
|
if (version_compare(_PS_VERSION_, '1.6.1.0', '<')) {
|
|
return $this->hookDisplayAdminOrderLeft($params);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public function hookDisplayAdminOrderMain($params)
|
|
{
|
|
if (!isset($params['order'])) {
|
|
$params['order'] = new Order($params['id_order']);
|
|
}
|
|
|
|
return $this->hookDisplayAdminOrderContentShip($params) . $this->hookDisplayAdminOrderLeft($params);
|
|
}
|
|
|
|
public function hookActionOrderStatusUpdate($params)
|
|
{
|
|
if (XAllegroConfiguration::get('ORDER_ADD_PAYMENT_WHEN_COD')) {
|
|
return;
|
|
}
|
|
|
|
/** @var XAllegroOrder $allegroOrder */
|
|
$allegroOrder = XAllegroOrder::getByOrderId($params['id_order']);
|
|
|
|
if (!$allegroOrder || $allegroOrder->checkout_form_content->payment->type != \x13allegro\Api\Model\Order\Enum\PaymentType::CASH_ON_DELIVERY) {
|
|
return;
|
|
}
|
|
|
|
$order = new Order((int)$params['id_order']);
|
|
|
|
if (isset($params['oldOrderStatus']) && $params['oldOrderStatus']->id) {
|
|
/** @var OrderState $orderStateCurrent */
|
|
$orderStateCurrent = $params['oldOrderStatus'];
|
|
} else {
|
|
$orderStateCurrent = new OrderState($order->current_state, $order->id_lang);
|
|
}
|
|
|
|
/** @var OrderState $orderStateNew */
|
|
$orderStateNew = $params['newOrderStatus'];
|
|
|
|
if (!$orderStateCurrent->paid
|
|
&& $orderStateNew->paid
|
|
&& empty(OrderPayment::getByOrderReference($order->reference))
|
|
) {
|
|
$orderPaymentFactory = new \x13allegro\SyncManager\Order\Data\Factory\OrderPaymentFactory(
|
|
$order,
|
|
$allegroOrder->checkout_form_content->payment,
|
|
$allegroOrder->checkout_form_content->summary,
|
|
true
|
|
);
|
|
|
|
if ($orderPaymentFactory->build()) {
|
|
\x13allegro\Component\Logger\Log::instance()
|
|
->env(\x13allegro\Component\Logger\LogEnv::HOOK())
|
|
->order($order->id)
|
|
->info(\x13allegro\Component\Logger\LogType::ORDER_PAYMENT_CREATE(), [
|
|
'payment.id' => $allegroOrder->checkout_form_content->payment->id,
|
|
'payment.type' => $allegroOrder->checkout_form_content->payment->type,
|
|
'payment.provider' => $allegroOrder->checkout_form_content->payment->provide,
|
|
'isCOD' => true
|
|
]);
|
|
}
|
|
}
|
|
}
|
|
|
|
public function hookActionOrderHistoryAddAfter($params)
|
|
{
|
|
if (false !== ($fulfilmentStatus = \x13allegro\Repository\FulfillmentStatusRepository::getStatusByOrderState($params['order_history']->id_order_state))) {
|
|
\x13allegro\Component\Logger\Log::instance()->env(\x13allegro\Component\Logger\LogEnv::HOOK());
|
|
|
|
if (false === ($result = XAllegroSyncFulfillmentStatus::sendFulfillmentStatus($params['order_history']->id_order, $fulfilmentStatus))) {
|
|
return;
|
|
}
|
|
|
|
if (strpos($_SERVER['SCRIPT_NAME'], 'sync.php') !== false) {
|
|
return;
|
|
}
|
|
|
|
if ($this->sessionMessages === null) {
|
|
return;
|
|
}
|
|
|
|
$bulkAction = '';
|
|
if (Tools::getValue('change_orders_status') || Tools::getIsset('submitUpdateOrderStatus')) {
|
|
$bulkAction = '[' . $this->l('Zamówienie ID') . ': ' . $result['orderId'] . '] ';
|
|
}
|
|
|
|
if ($result['status']) {
|
|
if ($result['revisionReload']) {
|
|
$this->sessionMessages->warnings($bulkAction . $this->l('Zaktualizowano dane odnośnie zamówienia Allegro, możesz teraz zmienić jego status.'));
|
|
} else {
|
|
$this->sessionMessages->confirmations($bulkAction . $this->l('Pomyślnie zaktualizowano status Allegro.'));
|
|
}
|
|
} else {
|
|
$this->sessionMessages->errors($bulkAction . $result['message']);
|
|
}
|
|
}
|
|
}
|
|
|
|
public function hookActionSetInvoice($params)
|
|
{
|
|
if (!XAllegroOrder::exists($params['Order']->id)
|
|
|| !Configuration::get('PS_INVOICE')
|
|
|| !XAllegroConfiguration::get('IMPORT_ORDERS')
|
|
|| !XAllegroConfiguration::get('ORDER_INVOICE_AUTO_PS_INVOICE')
|
|
) {
|
|
return;
|
|
}
|
|
|
|
\x13allegro\Component\Logger\Log::instance()->env(\x13allegro\Component\Logger\LogEnv::HOOK());
|
|
|
|
try {
|
|
$prestaShopInvoice = XAllegroSyncInvoice::getPrestaShopInvoice($params['Order'], Context::getContext());
|
|
|
|
XAllegroSyncInvoice::uploadOrderInvoice(
|
|
$params['Order']->id,
|
|
$prestaShopInvoice['invoiceFile'],
|
|
$prestaShopInvoice['invoiceFileName'],
|
|
$prestaShopInvoice['invoiceNumber']
|
|
);
|
|
}
|
|
catch (Exception $ex) {}
|
|
}
|
|
|
|
public function hookActionAdminControllerSetMedia()
|
|
{
|
|
if ($this->context->controller->controller_name == 'AdminProducts'
|
|
&& (version_compare(_PS_VERSION_, '9.0.0', '>=')
|
|
|| (version_compare(_PS_VERSION_, '8.0.0', '>=')
|
|
&& \x13allegro\Adapter\FeatureFlagAdapter::isEnabled('product_page_v2')))
|
|
) {
|
|
$this->context->controller->addJS(_PS_JS_DIR_ . 'admin/tinymce.inc.js');
|
|
$this->context->controller->addJS(_PS_JS_DIR_ . 'admin/tinymce_loader.js');
|
|
}
|
|
|
|
if ($this->context->controller->controller_name == 'AdminProducts'
|
|
|| $this->context->controller->controller_name == 'AdminOrders'
|
|
) {
|
|
$this->context->controller->addCSS(
|
|
$this->getPathUri() . 'views/css/x13allegro.css' .
|
|
(version_compare(_PS_VERSION_, '1.6.1.11', '>') ? '?v=' . X13_ALLEGRO_VERSION : '')
|
|
);
|
|
|
|
if (version_compare(_PS_VERSION_, '1.7.8.0', '>=')) {
|
|
$this->context->controller->addCSS(
|
|
$this->getPathUri() . 'views/css/x13allegro-modern.css' .
|
|
(version_compare(_PS_VERSION_, '1.6.1.11', '>') ? '?v=' . X13_ALLEGRO_VERSION : '')
|
|
);
|
|
}
|
|
|
|
$this->context->controller->addJqueryUI('ui.sortable');
|
|
$this->context->controller->addJS(
|
|
$this->getPathUri() . 'views/js/x13allegro.js' .
|
|
(version_compare(_PS_VERSION_, '1.6.1.11', '>') ? '?v=' . X13_ALLEGRO_VERSION : '')
|
|
);
|
|
}
|
|
}
|
|
|
|
public function hookDisplayAdminProductsExtra($params)
|
|
{
|
|
$product = new Product(version_compare(_PS_VERSION_, '1.7.0.0', '>=')
|
|
? (isset($params['id_product']) ? (int)$params['id_product'] : null)
|
|
: (int)Tools::getValue('id_product'));
|
|
|
|
if (!Validate::isLoadedObject($product)) {
|
|
return false;
|
|
}
|
|
|
|
$xProduct = new XAllegroProduct(null, $product->id);
|
|
$helper = new XAllegroHelperProductExtra($xProduct);
|
|
|
|
$this->context->smarty->assign([
|
|
'allegroAccounts' => XAllegroAccount::getAll(),
|
|
'productId' => $product->id,
|
|
'productsExtraController' => $this->context->link->getAdminLink('AdminXAllegroProductsExtra', false),
|
|
'productsExtraToken' => Tools::getAdminTokenLite('AdminXAllegroProductsExtra'),
|
|
'productCustomForm' => $helper->generateProductCustomForm(),
|
|
'tagManagerForm' => $helper->generateTagManagerForm(),
|
|
'imagesAdditionalForm' => $helper->generateImagesAdditionalForm(),
|
|
'imagesAdditionalMaxCount' => XAllegroProduct::IMAGES_ADDITIONAL_MAX,
|
|
'descriptionsAdditionalForm' => $helper->generateDescriptionsAdditionalForm(),
|
|
'descriptionsAdditionalMaxCount' => XAllegroProduct::DESCRIPTIONS_ADDITIONAL_MAX,
|
|
'displayX13AllegroAdminProductsExtra' => Hook::exec('displayX13AllegroAdminProductsExtra', [
|
|
'id_product' => $product->id
|
|
])
|
|
]);
|
|
|
|
return $this->display(__FILE__, 'views/templates/hook/admin-products-extra.tpl');
|
|
}
|
|
|
|
public function hookActionProductSave($params)
|
|
{
|
|
if (!isset($params['id_product'])
|
|
|| !Tools::getValue('x13allegro_product_extra')
|
|
|| version_compare(_PS_VERSION_, '1.7.0.0', '>=')
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
$helper = new XAllegroHelperProductExtra(new XAllegroProduct(null, $params['id_product']));
|
|
$helper->setAccountId((int)Tools::getValue('xallegro_product_custom_account'));
|
|
|
|
return $helper->processProductExtra($this->context->controller->errors);
|
|
}
|
|
|
|
public function hookActionObjectProductDeleteAfter($params)
|
|
{
|
|
if (Validate::isLoadedObject($params['object'])) {
|
|
$hookParams = [
|
|
'method' => 'productDeleted',
|
|
'id_shop' => $this->context->shop->id,
|
|
'id_product' => $params['object']->id
|
|
];
|
|
|
|
(new \x13allegro\SyncManager\Offer\Updater\PublicationStatusEnd())->updateFromHook($hookParams);
|
|
\x13allegro\Repository\ObjectAssociationRepository::deleteAssociationWithProduct($params['object']->id);
|
|
|
|
\x13allegro\Component\Logger\Log::instance()
|
|
->env(\x13allegro\Component\Logger\LogEnv::HOOK())
|
|
->product($this->context->shop->id, $params['object']->id)
|
|
->info(\x13allegro\Component\Logger\LogType::ASSOCIATION_DELETE(), ['hook' => 'actionObjectProductDeleteAfter']);
|
|
}
|
|
}
|
|
|
|
public function hookActionObjectCombinationDeleteAfter($params)
|
|
{
|
|
if (Validate::isLoadedObject($params['object'])) {
|
|
$hookParams = [
|
|
'method' => 'combinationDeleted',
|
|
'id_shop' => $this->context->shop->id,
|
|
'id_product' => $params['object']->id_product,
|
|
'id_product_attribute' => $params['object']->id
|
|
];
|
|
|
|
(new \x13allegro\SyncManager\Offer\Updater\PublicationStatusEnd())->updateFromHook($hookParams);
|
|
\x13allegro\Repository\ObjectAssociationRepository::deleteAssociationWithProductAttribute($params['object']->id);
|
|
|
|
\x13allegro\Component\Logger\Log::instance()
|
|
->env(\x13allegro\Component\Logger\LogEnv::HOOK())
|
|
->product($this->context->shop->id, $params['object']->id_product, $params['object']->id)
|
|
->info(\x13allegro\Component\Logger\LogType::ASSOCIATION_DELETE(), ['hook' => 'actionObjectCombinationDeleteAfter']);
|
|
}
|
|
}
|
|
|
|
public function hookActionObjectProductUpdateAfter($params)
|
|
{
|
|
if (Validate::isLoadedObject($params['object'])) {
|
|
if (!$params['object']->active) {
|
|
(new \x13allegro\SyncManager\Offer\Updater\PublicationStatusEnd())->updateFromHook([
|
|
'method' => 'productNotActive',
|
|
'id_shop' => $this->context->shop->id,
|
|
'id_product' => $params['object']->id
|
|
]);
|
|
} else {
|
|
(new \x13allegro\SyncManager\Offer\Updater\PublicationStatusActive())->updateFromHook([
|
|
'method' => 'productActive',
|
|
'id_product' => $params['object']->id
|
|
]);
|
|
}
|
|
}
|
|
}
|
|
|
|
public function hookActionObjectManufacturerDeleteAfter($params)
|
|
{
|
|
Db::getInstance()->delete('xallegro_manufacturer', 'id_manufacturer = ' . (int)$params['object']->id);
|
|
}
|
|
|
|
public function hookActionObjectGroupDeleteAfter($params)
|
|
{
|
|
$customerGroupsSelected = json_decode(XAllegroConfiguration::get('REGISTER_CUSTOMER_GROUP'), true);
|
|
$customerGroupDefault = (int)XAllegroConfiguration::get('REGISTER_CUSTOMER_GROUP_DEFAULT');
|
|
$priceGroupDefault = (int)XAllegroConfiguration::get('AUCTION_PRICE_CUSTOMER_GROUP');
|
|
$psCustomerGroupDefault = (int)Configuration::get('PS_CUSTOMER_GROUP');
|
|
$psUndefinedGroupDefault = (int)Configuration::get('PS_UNIDENTIFIED_GROUP');
|
|
|
|
if (array_key_exists($params['object']->id, $customerGroupsSelected)) {
|
|
unset($customerGroupsSelected[$params['object']->id]);
|
|
}
|
|
|
|
if (empty($customerGroupsSelected)) {
|
|
$customerGroupsSelected[$psCustomerGroupDefault] = true;
|
|
}
|
|
|
|
if ($params['object']->id === $customerGroupDefault) {
|
|
XAllegroConfiguration::updateValue('REGISTER_CUSTOMER_GROUP_DEFAULT', $psCustomerGroupDefault);
|
|
|
|
if (!array_key_exists($psCustomerGroupDefault, $customerGroupsSelected)) {
|
|
$customerGroupsSelected[$psCustomerGroupDefault] = true;
|
|
}
|
|
}
|
|
|
|
XAllegroConfiguration::updateValue('REGISTER_CUSTOMER_GROUP', json_encode($customerGroupsSelected));
|
|
|
|
if ($params['object']->id === $priceGroupDefault) {
|
|
XAllegroConfiguration::updateValue('AUCTION_PRICE_CUSTOMER_GROUP', $psUndefinedGroupDefault);
|
|
}
|
|
}
|
|
|
|
public function hookActionUpdateQuantity($params)
|
|
{
|
|
if (strpos($_SERVER['SCRIPT_NAME'], 'sync.php') === false) {
|
|
(new \x13allegro\SyncManager\Offer\Updater\QuantityUpdater())->updateFromHook($params);
|
|
(new \x13allegro\SyncManager\Offer\Updater\PublicationStatusActive())->updateFromHook([
|
|
'method' => 'quantityUpdate',
|
|
'id_product' => $params['id_product'],
|
|
'id_product_attribute' => $params['id_product_attribute']
|
|
]);
|
|
}
|
|
}
|
|
|
|
public function hookActionAdminPerformanceControllerAfter()
|
|
{
|
|
if (version_compare(_PS_VERSION_, '1.7.1.0', '<')) {
|
|
$this->hookActionClearSf2Cache();
|
|
}
|
|
}
|
|
|
|
public function hookActionClearSf2Cache()
|
|
{
|
|
XAllegroAutoLoader::getInstance()
|
|
->generateClassIndex()
|
|
->autoload();
|
|
|
|
(new \x13allegro\Component\Cache\Json())->clearAll();
|
|
}
|
|
|
|
public function hookActionDispatcher()
|
|
{
|
|
if (version_compare(_PS_VERSION_, '1.7.1.0', '<')
|
|
&& Tools::getValue('controller') == 'AdminOrders'
|
|
&& Tools::isSubmit('submitShippingNumber')
|
|
&& false !== ($orderId = Tools::getValue('id_order'))
|
|
&& XAllegroOrder::exists($orderId)
|
|
&& !XAllegroConfiguration::get('ORDER_SEND_CUSTOMER_MAIL')
|
|
&& Configuration::get('PS_MAIL_METHOD') != 3
|
|
) {
|
|
Configuration::set('PS_MAIL_METHOD', 3);
|
|
}
|
|
|
|
if (strpos($_SERVER['SCRIPT_NAME'], 'sync.php') !== false) {
|
|
Configuration::set('PS_SMARTY_CLEAR_CACHE', 'never');
|
|
}
|
|
}
|
|
|
|
public function hookActionX13AllegroOrderInvoiceList(array $params)
|
|
{
|
|
if (!isset($params['id_order'])) {
|
|
throw new InvalidArgumentException('Nie podano ID zamówienia PrestaShop.');
|
|
}
|
|
|
|
$allegroOrder = XAllegroOrder::getByOrderId($params['id_order']);
|
|
if (!$allegroOrder) {
|
|
return false;
|
|
}
|
|
|
|
\x13allegro\Component\Logger\Log::instance()->env(\x13allegro\Component\Logger\LogEnv::HOOK());
|
|
|
|
try {
|
|
$api = new \x13allegro\Api\XAllegroApi(new XAllegroAccount($allegroOrder->id_xallegro_account));
|
|
return $api->order()->checkoutForms($allegroOrder->checkout_form)->invoices()->getInvoices()->invoices;
|
|
}
|
|
catch (\x13allegro\Exception\ModuleException $ex) {
|
|
throw new RuntimeException((string)$ex);
|
|
}
|
|
}
|
|
|
|
public function hookActionX13AllegroOrderInvoiceUpload(array $params)
|
|
{
|
|
if (!isset($params['id_order'])) {
|
|
throw new InvalidArgumentException('Nie podano ID zamówienia PrestaShop.');
|
|
}
|
|
if (!isset($params['invoice_file'])) {
|
|
throw new InvalidArgumentException('Nie podano pliku faktury do wysłania.');
|
|
}
|
|
if (!isset($params['invoice_filename'])) {
|
|
throw new InvalidArgumentException('Nie podano nazwy pliku faktury do wysłania.');
|
|
}
|
|
|
|
\x13allegro\Component\Logger\Log::instance()->env(\x13allegro\Component\Logger\LogEnv::HOOK());
|
|
|
|
try {
|
|
return XAllegroSyncInvoice::uploadOrderInvoice(
|
|
$params['id_order'],
|
|
$params['invoice_file'],
|
|
$params['invoice_filename'],
|
|
isset($params['invoice_number']) ? $params['invoice_number'] : ''
|
|
);
|
|
}
|
|
catch (\x13allegro\Exception\ModuleException $ex) {
|
|
throw new RuntimeException((string)$ex);
|
|
}
|
|
}
|
|
|
|
public function install()
|
|
{
|
|
if (!parent::install() || !$this->config->installDependencies()) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public function uninstall()
|
|
{
|
|
if (!parent::uninstall() || !$this->config->uninstallDependencies() ) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function runUpgradeModule()
|
|
{
|
|
$result = parent::runUpgradeModule();
|
|
|
|
XAllegroAutoLoader::getInstance()->autoload();
|
|
\x13allegro\Component\Logger\Log::instance()->info(\x13allegro\Component\Logger\LogType::MODULE_UPGRADE_RUN(), $result);
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* @param string $module_name
|
|
* @return bool
|
|
*/
|
|
public static function getUpgradeStatus($module_name)
|
|
{
|
|
$result = parent::getUpgradeStatus($module_name);
|
|
|
|
XAllegroAutoLoader::getInstance()->autoload();
|
|
\x13allegro\Component\Logger\Log::instance()->info(\x13allegro\Component\Logger\LogType::MODULE_UPGRADE_STATUS(), $result);
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function reinstallTabs()
|
|
{
|
|
return $this->config->reinstallTabs();
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function reinstallMetas()
|
|
{
|
|
return $this->config->reinstallMetas();
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function installDemoTemplates()
|
|
{
|
|
return $this->config->installDemoTemplates();
|
|
}
|
|
|
|
/**
|
|
* @param string $message
|
|
* @param string $className
|
|
* @param bool $prefix
|
|
* @return string
|
|
*/
|
|
public function renderAdminMessage($message, $className = 'warning', $prefix = true)
|
|
{
|
|
return str_replace($this->displayName, '<span class="badge badge-' . $className . '"><b>' . $this->displayName . '</b></span>', ($prefix ? $this->displayName . ' ' : '') . $message);
|
|
}
|
|
}
|