mirror of
https://github.com/retailcrm/prestashop-module.git
synced 2025-03-01 19:03:14 +03:00
1387 lines
43 KiB
PHP
1387 lines
43 KiB
PHP
<?php
|
|
/**
|
|
* MIT License
|
|
*
|
|
* Copyright (c) 2021 DIGITAL RETAIL TECHNOLOGIES SL
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*
|
|
* DISCLAIMER
|
|
*
|
|
* Do not edit or add to this file if you wish to upgrade PrestaShop to newer
|
|
* versions in the future. If you wish to customize PrestaShop for your
|
|
* needs please refer to http://www.prestashop.com for more information.
|
|
*
|
|
* @author DIGITAL RETAIL TECHNOLOGIES SL <mail@simlachat.com>
|
|
* @copyright 2021 DIGITAL RETAIL TECHNOLOGIES SL
|
|
* @license https://opensource.org/licenses/MIT The MIT License
|
|
*
|
|
* Don't forget to prefix your containers with your own identifier
|
|
* to avoid any conflicts with others containers.
|
|
*/
|
|
|
|
class RetailcrmOrderBuilder
|
|
{
|
|
/**
|
|
* @var \RetailcrmApiClientV5
|
|
*/
|
|
protected $api;
|
|
|
|
/**
|
|
* @var int
|
|
*/
|
|
protected $default_lang;
|
|
|
|
/**
|
|
* @var Order|OrderCore|null
|
|
*/
|
|
protected $cmsOrder;
|
|
|
|
/**
|
|
* @var Cart|CartCore|null
|
|
*/
|
|
protected $cmsCart;
|
|
|
|
/**
|
|
* @var Customer|CustomerCore|null
|
|
*/
|
|
protected $cmsCustomer;
|
|
|
|
/**
|
|
* @var Address|\AddressCore
|
|
*/
|
|
protected $invoiceAddress;
|
|
|
|
/**
|
|
* @var Address|\AddressCore
|
|
*/
|
|
protected $deliveryAddress;
|
|
|
|
/**
|
|
* @var array|null
|
|
*/
|
|
protected $createdCustomer;
|
|
|
|
/**
|
|
* @var array|null
|
|
*/
|
|
protected $corporateCompanyExtractCache;
|
|
|
|
/**
|
|
* @var string
|
|
*/
|
|
protected $apiSite;
|
|
|
|
/**
|
|
* @return RetailcrmOrderBuilder
|
|
*/
|
|
public function defaultLangFromConfiguration()
|
|
{
|
|
$this->default_lang = (int) Configuration::get('PS_LANG_DEFAULT');
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param mixed $default_lang
|
|
*
|
|
* @return RetailcrmOrderBuilder
|
|
*/
|
|
public function setDefaultLang($default_lang)
|
|
{
|
|
$this->default_lang = $default_lang;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param mixed $api
|
|
*
|
|
* @return RetailcrmOrderBuilder
|
|
*/
|
|
public function setApi($api)
|
|
{
|
|
$this->api = $api;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param Order|OrderCore $cmsOrder
|
|
*
|
|
* @return RetailcrmOrderBuilder
|
|
*/
|
|
public function setCmsOrder($cmsOrder)
|
|
{
|
|
$this->cmsOrder = $cmsOrder;
|
|
|
|
if ($cmsOrder instanceof Order) {
|
|
if (null === $this->cmsCustomer) {
|
|
$this->cmsCustomer = $cmsOrder->getCustomer();
|
|
}
|
|
|
|
if (null === $this->invoiceAddress) {
|
|
$this->invoiceAddress = new Address($cmsOrder->id_address_invoice);
|
|
}
|
|
|
|
if (null === $this->deliveryAddress) {
|
|
$this->deliveryAddress = new Address($cmsOrder->id_address_delivery);
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param Cart|CartCore $cmsCart
|
|
*
|
|
* @return RetailcrmOrderBuilder
|
|
*/
|
|
public function setCmsCart($cmsCart)
|
|
{
|
|
$this->cmsCart = $cmsCart;
|
|
|
|
if ($cmsCart instanceof Cart) {
|
|
if (null === $this->cmsCustomer && !empty($cmsCart->id_customer)) {
|
|
$this->cmsCustomer = new Customer($cmsCart->id_customer);
|
|
}
|
|
|
|
if (null === $this->invoiceAddress && !empty($cmsCart->id_address_invoice)) {
|
|
$this->invoiceAddress = new Address($cmsCart->id_address_invoice);
|
|
}
|
|
|
|
if (null === $this->deliveryAddress && !empty($cmsCart->id_address_delivery)) {
|
|
$this->deliveryAddress = new Address($cmsCart->id_address_delivery);
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param mixed $cmsCustomer
|
|
*
|
|
* @return RetailcrmOrderBuilder
|
|
*/
|
|
public function setCmsCustomer($cmsCustomer)
|
|
{
|
|
$this->cmsCustomer = $cmsCustomer;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* getApiSite
|
|
*
|
|
* @return string|null
|
|
*/
|
|
protected function getApiSite()
|
|
{
|
|
if (empty($this->apiSite)) {
|
|
$response = $this->api->credentials();
|
|
|
|
if ($response->isSuccessful()
|
|
&& $response->offsetExists('sitesAvailable')
|
|
&& is_array($response['sitesAvailable'])
|
|
&& !empty($response['sitesAvailable'])
|
|
&& !empty($response['sitesAvailable'][0])
|
|
) {
|
|
$this->apiSite = $response['sitesAvailable'][0];
|
|
} else {
|
|
$this->apiSite = null;
|
|
}
|
|
}
|
|
|
|
return $this->apiSite;
|
|
}
|
|
|
|
/**
|
|
* Clear object
|
|
*
|
|
* @return mixed
|
|
*/
|
|
public function reset()
|
|
{
|
|
$this->cmsOrder = null;
|
|
$this->cmsCart = null;
|
|
$this->cmsCustomer = null;
|
|
$this->invoiceAddress = null;
|
|
$this->deliveryAddress = null;
|
|
$this->createdCustomer = null;
|
|
$this->corporateCompanyExtractCache = null;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Returns order with prepared customer data. Customer is created if it's not exist, shouldn't be called to just
|
|
* build order.
|
|
*
|
|
* @param bool $dataFromCart
|
|
*
|
|
* @return array
|
|
*/
|
|
public function buildOrderWithPreparedCustomer($dataFromCart = false)
|
|
{
|
|
if (RetailcrmTools::isCorporateEnabled() && RetailcrmTools::isOrderCorporate($this->cmsOrder)) {
|
|
return $this->buildCorporateOrder($dataFromCart);
|
|
}
|
|
|
|
return $this->buildRegularOrder($dataFromCart);
|
|
}
|
|
|
|
/**
|
|
* Creates customer if it's not present
|
|
*
|
|
* @return array|bool
|
|
*/
|
|
public function createCustomerIfNotExist()
|
|
{
|
|
$this->validateCmsCustomer();
|
|
|
|
$customer = $this->findRegularCustomer();
|
|
|
|
if (empty($customer)) {
|
|
$crmCustomer = static::buildCrmCustomer($this->cmsCustomer, $this->buildRegularAddress());
|
|
$createResponse = $this->api->customersCreate($crmCustomer);
|
|
|
|
if (!$createResponse || !$createResponse->isSuccessful()) {
|
|
$this->createdCustomer = [];
|
|
|
|
return false;
|
|
}
|
|
|
|
$this->createdCustomer = $this->findRegularCustomer();
|
|
$customer = $this->createdCustomer;
|
|
} else {
|
|
$crmCustomer = RetailcrmTools::mergeCustomerAddress($customer, $this->buildRegularAddress());
|
|
|
|
if (
|
|
!RetailcrmTools::isEqualCustomerAddress($customer, $crmCustomer)
|
|
|| !isset($crmCustomer['externalId'])
|
|
|| $crmCustomer['externalId'] !== $this->cmsCustomer->id
|
|
) {
|
|
if (isset($crmCustomer['tags'])) {
|
|
unset($crmCustomer['tags']);
|
|
}
|
|
|
|
$by = 'externalId';
|
|
|
|
if (!isset($crmCustomer['externalId']) || $crmCustomer['externalId'] !== $this->cmsCustomer->id) {
|
|
$crmCustomer['externalId'] = $this->cmsCustomer->id;
|
|
$by = 'id';
|
|
}
|
|
|
|
$response = $this->api->customersEdit($crmCustomer, $by);
|
|
|
|
if ($response instanceof RetailcrmApiResponse && $response->isSuccessful()) {
|
|
$customer = $crmCustomer;
|
|
}
|
|
}
|
|
}
|
|
|
|
return isset($customer['id']) ? $customer : false;
|
|
}
|
|
|
|
private function buildRegularOrder($dataFromCart = false)
|
|
{
|
|
$customer = $this->createCustomerIfNotExist();
|
|
$order = static::buildCrmOrder(
|
|
$this->cmsOrder,
|
|
$this->cmsCustomer,
|
|
$this->cmsCart,
|
|
false,
|
|
$dataFromCart,
|
|
'',
|
|
'',
|
|
isset($customer['id']) ? $customer['id'] : ''
|
|
);
|
|
|
|
return RetailcrmTools::clearArray($order);
|
|
}
|
|
|
|
/**
|
|
* Build regular customer address
|
|
*
|
|
* @return array
|
|
*/
|
|
private function buildRegularAddress()
|
|
{
|
|
$addressBuilder = new RetailcrmAddressBuilder();
|
|
|
|
return $addressBuilder
|
|
->setAddress($this->invoiceAddress)
|
|
->build()
|
|
->getDataArray()
|
|
;
|
|
}
|
|
|
|
/**
|
|
* Builds address array for corporate customer, returns empty array in case of failure.
|
|
*
|
|
* @param bool $isMain
|
|
*
|
|
* @return array
|
|
*/
|
|
private function buildCorporateAddress($isMain = true)
|
|
{
|
|
if (empty($this->invoiceAddress) || empty($this->invoiceAddress->id)) {
|
|
return [];
|
|
}
|
|
|
|
$addressBuilder = new RetailcrmAddressBuilder();
|
|
|
|
return $addressBuilder
|
|
->setMode(RetailcrmAddressBuilder::MODE_CORPORATE_CUSTOMER)
|
|
->setAddress($this->invoiceAddress)
|
|
->setIsMain($isMain)
|
|
->setWithExternalId(true)
|
|
->build()
|
|
->getDataArray()
|
|
;
|
|
}
|
|
|
|
/**
|
|
* Builds company for corporate customer
|
|
*
|
|
* @param int $addressId
|
|
*
|
|
* @return array
|
|
*/
|
|
private function buildCorporateCompany($addressId = 0)
|
|
{
|
|
$companyName = '';
|
|
$vat = '';
|
|
|
|
if (!empty($this->invoiceAddress)) {
|
|
if (empty($this->invoiceAddress->company)) {
|
|
$companyName = 'Main Company';
|
|
} else {
|
|
$companyName = $this->invoiceAddress->company;
|
|
}
|
|
|
|
if (!empty($this->invoiceAddress->vat_number)) {
|
|
$vat = $this->invoiceAddress->vat_number;
|
|
}
|
|
}
|
|
|
|
$company = [
|
|
'isMain' => true,
|
|
'name' => $companyName,
|
|
];
|
|
|
|
if (!empty($addressId)) {
|
|
$company['address'] = [
|
|
'id' => $addressId,
|
|
];
|
|
}
|
|
|
|
if (!empty($vat)) {
|
|
$company['contragent']['INN'] = $vat;
|
|
}
|
|
|
|
return RetailcrmTools::clearArray($company);
|
|
}
|
|
|
|
/**
|
|
* Creates new corporate customer from data, returns false in case of error
|
|
*
|
|
* @return array|bool
|
|
*/
|
|
private function createCorporateIfNotExist()
|
|
{
|
|
$crmAddressId = 0;
|
|
$companyWasFound = true;
|
|
$corporateWasFound = true;
|
|
$this->validateCmsCustomerInDb();
|
|
|
|
$customer = $this->createCustomerIfNotExist();
|
|
|
|
if (!$customer) {
|
|
RetailcrmLogger::writeCaller(__METHOD__, 'Cannot proceed because customer is empty!');
|
|
|
|
return false;
|
|
}
|
|
|
|
$crmCorporate = $this->findCorporateCustomerByContactAndCompany(
|
|
$customer['id'],
|
|
$this->invoiceAddress->company
|
|
);
|
|
|
|
if (empty($crmCorporate)) {
|
|
$crmCorporate = $this->findCorporateCustomerByCompany($this->invoiceAddress->company);
|
|
}
|
|
|
|
if (empty($crmCorporate)) {
|
|
$crmCorporate = $this->findCorporateCustomerByContact($customer['id']);
|
|
|
|
if (!empty($crmCorporate)) {
|
|
$companyWasFound = false;
|
|
}
|
|
}
|
|
|
|
if (empty($crmCorporate)) {
|
|
$crmCorporate = $this->createCorporateCustomer($customer['externalId']);
|
|
$corporateWasFound = false;
|
|
} elseif (isset($crmCorporate['id'])) {
|
|
$result = $this->appendAdditionalAddressToCorporate($crmCorporate['id']);
|
|
$crmAddressId = isset($result['id']) ? $result['id'] : 0;
|
|
}
|
|
|
|
if ($corporateWasFound) {
|
|
if (!$companyWasFound) {
|
|
$company = $this->buildCorporateCompany($crmAddressId);
|
|
$this->api->customersCorporateCompaniesCreate(
|
|
$crmCorporate['id'],
|
|
$company,
|
|
'id',
|
|
$this->getApiSite()
|
|
);
|
|
}
|
|
|
|
$contactList = $this->api->customersCorporateContacts(
|
|
$crmCorporate['id'],
|
|
['contactIds' => [$customer['id']]],
|
|
null,
|
|
null,
|
|
'id',
|
|
$this->getApiSite()
|
|
);
|
|
|
|
if (!$contactList->offsetExists('contacts')) {
|
|
return $crmCorporate;
|
|
}
|
|
|
|
if (0 == count($contactList['contacts'])) {
|
|
$contactData = [
|
|
'isMain' => false,
|
|
'customer' => [
|
|
'id' => $customer['id'],
|
|
'site' => $this->getApiSite(),
|
|
],
|
|
];
|
|
|
|
$crmCorporateCompany = $this->extractCorporateCompanyCached(
|
|
$crmCorporate['id'],
|
|
$this->invoiceAddress->company
|
|
);
|
|
|
|
if (!empty($crmCorporateCompany) && isset($crmCorporateCompany['id'])) {
|
|
$contactData['companies'] = [[
|
|
'company' => ['id' => $crmCorporateCompany['id']],
|
|
]];
|
|
}
|
|
|
|
$this->api->customersCorporateContactsCreate(
|
|
$crmCorporate['id'],
|
|
$contactData,
|
|
'id',
|
|
$this->getApiSite()
|
|
);
|
|
}
|
|
}
|
|
|
|
return $crmCorporate;
|
|
}
|
|
|
|
/**
|
|
* createCorporateCustomer
|
|
*
|
|
* @param string $contactPersonExternalId
|
|
*
|
|
* @return bool|array|\RetailcrmApiResponse
|
|
*/
|
|
private function createCorporateCustomer($contactPersonExternalId)
|
|
{
|
|
$customerCorporate = static::buildCrmCustomerCorporate(
|
|
$this->cmsCustomer,
|
|
$this->invoiceAddress->company,
|
|
$contactPersonExternalId,
|
|
false,
|
|
false,
|
|
$this->getApiSite()
|
|
);
|
|
$crmCorporate = $this->api->customersCorporateCreate($customerCorporate, $this->getApiSite());
|
|
|
|
if (!$crmCorporate || !$crmCorporate->isSuccessful()) {
|
|
return false;
|
|
}
|
|
|
|
$address = $this->buildCorporateAddress();
|
|
$createResponse = $this->api->customersCorporateAddressesCreate(
|
|
$crmCorporate['id'],
|
|
$address,
|
|
'id',
|
|
$this->getApiSite()
|
|
);
|
|
|
|
if ($createResponse && $createResponse->isSuccessful()) {
|
|
$company = $this->buildCorporateCompany($createResponse['id']);
|
|
$this->api->customersCorporateCompaniesCreate(
|
|
$crmCorporate['id'],
|
|
$company,
|
|
'id',
|
|
$this->getApiSite()
|
|
);
|
|
}
|
|
|
|
$crmCorporate = $this->api->customersCorporateGet($crmCorporate['id'], 'id', $this->getApiSite());
|
|
|
|
if ($crmCorporate
|
|
&& $crmCorporate->isSuccessful()
|
|
&& $crmCorporate->offsetExists('customerCorporate')
|
|
) {
|
|
return $crmCorporate['customerCorporate'];
|
|
}
|
|
|
|
return $crmCorporate;
|
|
}
|
|
|
|
/**
|
|
* Append new address to corporate customer if new address is not present in corporate customer.
|
|
*
|
|
* @param string|int $corporateId
|
|
*
|
|
* @return bool|array|\RetailcrmApiResponse
|
|
*/
|
|
private function appendAdditionalAddressToCorporate($corporateId)
|
|
{
|
|
$request = new RetailcrmApiPaginatedRequest();
|
|
$address = $this->buildCorporateAddress(false);
|
|
$addresses = $request
|
|
->setApi($this->api)
|
|
->setMethod('customersCorporateAddresses')
|
|
->setParams([
|
|
$corporateId,
|
|
[],
|
|
'{{page}}',
|
|
'{{limit}}',
|
|
'id',
|
|
$this->getApiSite(),
|
|
])
|
|
->setDataKey('addresses')
|
|
->execute()
|
|
->getData()
|
|
;
|
|
|
|
foreach ($addresses as $addressInCrm) {
|
|
if (!empty($addressInCrm['externalId']) && $addressInCrm['externalId'] == $this->invoiceAddress->id) {
|
|
return $this->api->customersCorporateAddressesEdit(
|
|
$corporateId,
|
|
$addressInCrm['externalId'],
|
|
$address,
|
|
'id',
|
|
'externalId',
|
|
$this->getApiSite()
|
|
);
|
|
}
|
|
|
|
if (RetailCrmTools::clearAddress($address['text']) === RetailCrmTools::clearAddress($addressInCrm['text'])) {
|
|
return $this->api->customersCorporateAddressesEdit(
|
|
$corporateId,
|
|
$addressInCrm['id'],
|
|
$address,
|
|
'id',
|
|
'id',
|
|
$this->getApiSite()
|
|
);
|
|
}
|
|
}
|
|
|
|
$this->api->customersCorporateAddressesCreate(
|
|
$corporateId,
|
|
$address,
|
|
'id',
|
|
$this->getApiSite()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Find self::cmsCustomer in retailCRM by id or by email
|
|
*
|
|
* @return array|mixed
|
|
*/
|
|
private function findRegularCustomer()
|
|
{
|
|
$this->validateCmsCustomer();
|
|
|
|
if (!empty($this->cmsCustomer->id) && !$this->cmsCustomer->is_guest) {
|
|
$customer = $this->api->customersGet($this->cmsCustomer->id);
|
|
|
|
if ($customer && $customer->isSuccessful() && $customer->offsetExists('customer')) {
|
|
return $customer['customer'];
|
|
}
|
|
}
|
|
|
|
if (!empty($this->cmsCustomer->email)) {
|
|
$customers = $this->api->customersList(['email' => $this->cmsCustomer->email]);
|
|
|
|
if ($customers
|
|
&& $customers->isSuccessful()
|
|
&& $customers->offsetExists('customers')
|
|
&& !empty($customers['customers'])
|
|
) {
|
|
$customer = reset($customers['customers']);
|
|
|
|
if ($customer['email'] === $this->cmsCustomer->email) {
|
|
return RetailcrmTools::filter(
|
|
'RetailcrmFilterFindCustomerByEmail',
|
|
$customer,
|
|
[
|
|
'cmsCustomer' => $this->cmsCustomer,
|
|
]
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* Finds all corporate customers with specified contact id and filters them by provided main company name
|
|
*
|
|
* @param $contactId
|
|
* @param $companyName
|
|
*
|
|
* @return array
|
|
*/
|
|
private function findCorporateCustomerByContactAndCompany($contactId, $companyName)
|
|
{
|
|
$crmCorporate = $this->api->customersCorporateList([
|
|
'contactIds' => [$contactId],
|
|
'companyName' => $companyName,
|
|
]);
|
|
|
|
if ($crmCorporate instanceof RetailcrmApiResponse
|
|
&& $crmCorporate->isSuccessful()
|
|
&& $crmCorporate->offsetExists('customersCorporate')
|
|
&& 0 < count($crmCorporate['customersCorporate'])
|
|
) {
|
|
$crmCorporate = $crmCorporate['customersCorporate'];
|
|
|
|
return reset($crmCorporate);
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* Find corporate customer by company name
|
|
*
|
|
* @param $companyName
|
|
*
|
|
* @return array
|
|
*/
|
|
private function findCorporateCustomerByCompany($companyName)
|
|
{
|
|
$crmCorporate = $this->api->customersCorporateList([
|
|
'companyName' => $companyName,
|
|
]);
|
|
|
|
if ($crmCorporate instanceof RetailcrmApiResponse
|
|
&& $crmCorporate->isSuccessful()
|
|
&& $crmCorporate->offsetExists('customersCorporate')
|
|
&& 0 < count($crmCorporate['customersCorporate'])
|
|
) {
|
|
$crmCorporate = $crmCorporate['customersCorporate'];
|
|
|
|
return reset($crmCorporate);
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* Find corporate customer by contact id
|
|
*
|
|
* @param $contactId
|
|
*
|
|
* @return array
|
|
*/
|
|
private function findCorporateCustomerByContact($contactId)
|
|
{
|
|
$crmCorporate = $this->api->customersCorporateList([
|
|
'contactIds' => [$contactId],
|
|
]);
|
|
|
|
if ($crmCorporate instanceof RetailcrmApiResponse
|
|
&& $crmCorporate->isSuccessful()
|
|
&& $crmCorporate->offsetExists('customersCorporate')
|
|
&& 0 < count($crmCorporate['customersCorporate'])
|
|
) {
|
|
$crmCorporate = $crmCorporate['customersCorporate'];
|
|
|
|
return reset($crmCorporate);
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* Get corporate companies, extract company data by provided identifiers
|
|
*
|
|
* @param int|string $corporateCrmId
|
|
* @param string $companyName
|
|
* @param string $by
|
|
*
|
|
* @return array
|
|
*/
|
|
private function extractCorporateCompany($corporateCrmId, $companyName, $by = 'id')
|
|
{
|
|
$companiesResponse = $this->api->customersCorporateCompanies(
|
|
$corporateCrmId,
|
|
[],
|
|
null,
|
|
null,
|
|
$by
|
|
);
|
|
|
|
if ($companiesResponse instanceof RetailcrmApiResponse
|
|
&& $companiesResponse->isSuccessful()
|
|
&& $companiesResponse->offsetExists('companies')
|
|
&& 0 < count($companiesResponse['companies'])
|
|
) {
|
|
$company = array_reduce(
|
|
$companiesResponse['companies'],
|
|
function ($carry, $item) use ($companyName) {
|
|
if (is_array($item) && isset($item['name']) && $item['name'] == $companyName) {
|
|
$carry = $item;
|
|
}
|
|
|
|
return $carry;
|
|
}
|
|
);
|
|
|
|
if (is_array($company)) {
|
|
return $company;
|
|
}
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* extractCorporateCompany with cache
|
|
*
|
|
* @param int|string $corporateCrmId
|
|
* @param string $companyName
|
|
* @param string $by
|
|
*
|
|
* @return array
|
|
*/
|
|
private function extractCorporateCompanyCached($corporateCrmId, $companyName, $by = 'id')
|
|
{
|
|
$cachedItemId = sprintf('%s:%s', (string) $corporateCrmId, $companyName);
|
|
|
|
if (!is_array($this->corporateCompanyExtractCache)) {
|
|
$this->corporateCompanyExtractCache = [];
|
|
}
|
|
|
|
if (!isset($this->corporateCompanyExtractCache[$cachedItemId])) {
|
|
$this->corporateCompanyExtractCache[$cachedItemId] = $this->extractCorporateCompany(
|
|
$corporateCrmId,
|
|
$companyName,
|
|
$by
|
|
);
|
|
}
|
|
|
|
return $this->corporateCompanyExtractCache[$cachedItemId];
|
|
}
|
|
|
|
/**
|
|
* Throws exception if cmsCustomer is not set
|
|
*
|
|
* @throws \InvalidArgumentException
|
|
*/
|
|
private function validateCmsCustomer()
|
|
{
|
|
if (null === $this->cmsCustomer) {
|
|
throw new \InvalidArgumentException('RetailcrmOrderBuilder::cmsCustomer must be set');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Throws exception if cmsCustomer is not set or it's not present in DB yet
|
|
*
|
|
* @throws \InvalidArgumentException
|
|
*/
|
|
private function validateCmsCustomerInDb()
|
|
{
|
|
$this->validateCmsCustomer();
|
|
|
|
if (empty($this->cmsCustomer->id)) {
|
|
throw new \InvalidArgumentException('RetailcrmOrderBuilder::cmsCustomer must be stored in DB');
|
|
}
|
|
}
|
|
|
|
private function buildCorporateOrder($dataFromCart = false)
|
|
{
|
|
$customer = $this->createCorporateIfNotExist();
|
|
$contactPersonId = '';
|
|
$contactPersonExternalId = '';
|
|
|
|
if (empty($customer)) {
|
|
return [];
|
|
}
|
|
|
|
if (empty($this->cmsCustomer->id)) {
|
|
$contacts = $this->api->customersList(['email' => $this->cmsCustomer->email]);
|
|
|
|
if ($contacts
|
|
&& $contacts->isSuccessful()
|
|
&& $contacts->offsetExists('customers')
|
|
&& !empty($contacts['customers'])
|
|
) {
|
|
$contacts = $contacts['customers'];
|
|
$contactPerson = reset($contacts);
|
|
|
|
if (isset($contactPerson['id'])) {
|
|
$contactPersonId = $contactPerson['id'];
|
|
}
|
|
}
|
|
} else {
|
|
$contacts = $this->api->customersCorporateContacts(
|
|
$customer['id'],
|
|
['contactExternalIds' => [$this->cmsCustomer->id]],
|
|
null,
|
|
null,
|
|
'id',
|
|
$this->getApiSite()
|
|
);
|
|
|
|
if ($contacts
|
|
&& $contacts->isSuccessful()
|
|
&& $contacts->offsetExists('contacts')
|
|
&& 1 == count($contacts['contacts'])
|
|
) {
|
|
$contactPersonExternalId = $this->cmsCustomer->id;
|
|
}
|
|
}
|
|
|
|
return static::buildCrmOrder(
|
|
$this->cmsOrder,
|
|
$this->cmsCustomer,
|
|
$this->cmsCart,
|
|
false,
|
|
$dataFromCart,
|
|
$contactPersonId,
|
|
$contactPersonExternalId,
|
|
$customer['id'],
|
|
$this->getApiSite()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Build array with order data for retailCRM from PrestaShop order data
|
|
*
|
|
* @param Order|\OrderCore $order PrestaShop Order
|
|
* @param Customer|\CustomerCore|null $customer PrestaShop Customer
|
|
* @param Cart|\CartCore|null $orderCart Cart for provided order. Optional
|
|
* @param bool $preferCustomerAddress Use customer address even if delivery address is
|
|
* provided
|
|
* @param bool $dataFromCart Prefer data from cart
|
|
* @param string $contactPersonId Contact person id to append
|
|
* @param string $contactPersonExternalId contact person externalId to append
|
|
* @param string $customerId Customer id
|
|
* @param string $site Site code (for customer only)
|
|
*
|
|
* @return array retailCRM order data
|
|
*
|
|
* @todo Refactor into OrderBuilder (current order builder should be divided into several independent builders).
|
|
*/
|
|
public static function buildCrmOrder(
|
|
$order,
|
|
$customer = null,
|
|
$orderCart = null,
|
|
$preferCustomerAddress = false,
|
|
$dataFromCart = false,
|
|
$contactPersonId = '',
|
|
$contactPersonExternalId = '',
|
|
$customerId = '',
|
|
$site = ''
|
|
) {
|
|
$delivery = json_decode(Configuration::get(RetailCRM::DELIVERY), true);
|
|
$payment = json_decode(Configuration::get(RetailCRM::PAYMENT), true);
|
|
$status = json_decode(Configuration::get(RetailCRM::STATUS), true);
|
|
$sendOrderNumber = (bool) Configuration::get(RetailCRM::ENABLE_ORDER_NUMBER_SENDING);
|
|
$orderNumber = $sendOrderNumber ? $order->reference : null;
|
|
|
|
if (false === Module::getInstanceByName('advancedcheckout')) {
|
|
$paymentType = $order->module;
|
|
} else {
|
|
$paymentType = $order->payment;
|
|
}
|
|
|
|
$order_status = array_key_exists($order->current_state, $status)
|
|
? $status[$order->current_state]
|
|
: null;
|
|
|
|
$cart = $orderCart;
|
|
|
|
if (null === $cart) {
|
|
$cart = new Cart($order->getCartIdStatic($order->id));
|
|
}
|
|
|
|
if (null === $customer) {
|
|
$customer = new Customer($order->id_customer);
|
|
}
|
|
|
|
$crmOrder = array_filter([
|
|
'externalId' => $order->id,
|
|
'number' => $orderNumber,
|
|
'createdAt' => RetailcrmTools::verifyDate($order->date_add, 'Y-m-d H:i:s')
|
|
? $order->date_add : date('Y-m-d H:i:s'),
|
|
'status' => $order_status,
|
|
'firstName' => $customer->firstname,
|
|
'lastName' => $customer->lastname,
|
|
'email' => $customer->email,
|
|
]);
|
|
|
|
$addressCollection = $cart->getAddressCollection();
|
|
$addressDelivery = new Address($order->id_address_delivery);
|
|
$addressInvoice = new Address($order->id_address_invoice);
|
|
|
|
if (null === $addressDelivery->id || true === $preferCustomerAddress) {
|
|
$addressDelivery = array_filter(
|
|
$addressCollection,
|
|
function ($v) use ($customer) {
|
|
return $v->id_customer == $customer->id;
|
|
}
|
|
);
|
|
|
|
if (is_array($addressDelivery) && 1 == count($addressDelivery)) {
|
|
$addressDelivery = reset($addressDelivery);
|
|
}
|
|
}
|
|
|
|
$addressBuilder = new RetailcrmAddressBuilder();
|
|
$addressBuilder
|
|
->setMode(RetailcrmAddressBuilder::MODE_ORDER_DELIVERY)
|
|
->setAddress($addressDelivery)
|
|
->build()
|
|
;
|
|
$crmOrder = array_merge($crmOrder, $addressBuilder->getDataArray());
|
|
|
|
$isCorporateEnabled = RetailcrmTools::isCorporateEnabled();
|
|
|
|
if ($isCorporateEnabled && RetailcrmTools::isOrderCorporate($order)) {
|
|
$crmOrder['contragent']['contragentType'] = 'legal-entity';
|
|
$crmOrder['contragent']['legalName'] = $addressInvoice->company ?? '';
|
|
$crmOrder['contragent']['INN'] = $addressInvoice->vat_number ?? '';
|
|
} else {
|
|
$crmOrder['contragent']['contragentType'] = 'individual';
|
|
|
|
if (
|
|
RetailcrmTools::isCampanyAndVatNumberSendEnabled()
|
|
&& Configuration::get(RetailCRM::COMPANY_AND_VAT_NUMBER_CREATED)
|
|
) {
|
|
$crmOrder['customFields']['ps_company'] = $addressInvoice->company ?? '';
|
|
$crmOrder['customFields']['ps_vat_number'] = $addressInvoice->vat_number ?? '';
|
|
}
|
|
}
|
|
|
|
if (!empty($payment[$paymentType])) {
|
|
$order_payment = [
|
|
'externalId' => $order->id . '#' . $order->reference,
|
|
'type' => $payment[$paymentType],
|
|
];
|
|
|
|
if (0 < round($order->total_paid_real, 2)) {
|
|
$order_payment['amount'] = round($order->total_paid_real, 2);
|
|
$order_payment['status'] = 'paid';
|
|
}
|
|
$crmOrder['payments'][] = $order_payment;
|
|
} else {
|
|
$crmOrder['payments'] = [];
|
|
}
|
|
|
|
$idCarrier = $dataFromCart ? $cart->id_carrier : $order->id_carrier;
|
|
|
|
if (empty($idCarrier)) {
|
|
$idCarrier = $order->id_carrier;
|
|
$totalShipping = $order->total_shipping;
|
|
$totalShippingWithoutTax = $order->total_shipping_tax_excl;
|
|
} else {
|
|
$totalShipping = $dataFromCart ? $cart->getCarrierCost($idCarrier) : $order->total_shipping;
|
|
|
|
if (!empty($totalShipping) && 0 != $totalShipping) {
|
|
$totalShippingWithoutTax = $dataFromCart
|
|
? $totalShipping - $cart->getCarrierCost($idCarrier, false)
|
|
: $order->total_shipping_tax_excl;
|
|
} else {
|
|
$totalShippingWithoutTax = $order->total_shipping_tax_excl;
|
|
}
|
|
}
|
|
|
|
// TODO Shouldn't cause any errors while creating order even if correspondent carrier is not set.
|
|
if (array_key_exists($idCarrier, $delivery) && !empty($delivery[$idCarrier])) {
|
|
$crmOrder['delivery']['code'] = $delivery[$idCarrier];
|
|
}
|
|
|
|
if (isset($totalShipping) && $order->total_discounts > $order->total_products_wt) {
|
|
$totalShipping -= $order->total_discounts - $order->total_products_wt;
|
|
$crmOrder['discountManualAmount'] = round($order->total_products_wt, 2);
|
|
} else {
|
|
$crmOrder['discountManualAmount'] = round($order->total_discounts, 2);
|
|
}
|
|
|
|
if (isset($totalShipping) && 0 < round($totalShipping, 2)) {
|
|
$crmOrder['delivery']['cost'] = round($totalShipping, 2);
|
|
} else {
|
|
$crmOrder['delivery']['cost'] = 0.00;
|
|
}
|
|
|
|
if (isset($totalShippingWithoutTax) && 0 < round($totalShippingWithoutTax, 2)) {
|
|
$crmOrder['delivery']['netCost'] = round($totalShippingWithoutTax, 2);
|
|
} else {
|
|
$crmOrder['delivery']['netCost'] = 0.00;
|
|
}
|
|
|
|
$comment = $order->getFirstMessage();
|
|
|
|
if (false !== $comment) {
|
|
$crmOrder['customerComment'] = $comment;
|
|
}
|
|
|
|
if ($dataFromCart) {
|
|
$productStore = $cart;
|
|
$converter = function ($product) {
|
|
$map = [
|
|
'product_attribute_id' => 'id_product_attribute',
|
|
'product_quantity' => 'cart_quantity',
|
|
'product_id' => 'id_product',
|
|
'id_order_detail' => 'id_product',
|
|
'product_name' => 'name',
|
|
'product_price' => 'price',
|
|
'purchase_supplier_price' => 'price',
|
|
'product_price_wt' => 'price_wt',
|
|
];
|
|
|
|
foreach ($map as $target => $value) {
|
|
if (isset($product[$value])) {
|
|
$product[$target] = $product[$value];
|
|
}
|
|
}
|
|
|
|
return $product;
|
|
};
|
|
} else {
|
|
$productStore = $order;
|
|
$converter = function ($product) {
|
|
return $product;
|
|
};
|
|
}
|
|
|
|
foreach ($productStore->getProducts() as $productData) {
|
|
$product = $converter($productData);
|
|
|
|
if (isset($product['product_attribute_id']) && 0 < $product['product_attribute_id']) {
|
|
$productId = $product['product_id'] . '#' . $product['product_attribute_id'];
|
|
} else {
|
|
$productId = $product['product_id'];
|
|
}
|
|
|
|
if (isset($product['attributes']) && $product['attributes']) {
|
|
$arProp = [];
|
|
$count = 0;
|
|
$arAttr = explode(',', $product['attributes']);
|
|
|
|
foreach ($arAttr as $valAttr) {
|
|
$arItem = explode(':', $valAttr);
|
|
|
|
if ($arItem[0] && $arItem[1]) {
|
|
// Product property code should start with a letter, digit or underscore
|
|
// and only contain letters, digits, underscores, hyphens and colons
|
|
$propertyCode = preg_replace('/(^[^\w]+)|([^\w\-:])/', '', $arItem[0]);
|
|
if (empty($propertyCode)) {
|
|
$propertyCode = 'prop_' . $count;
|
|
}
|
|
|
|
$arProp[$count]['code'] = $propertyCode;
|
|
$arProp[$count]['name'] = trim($arItem[0]);
|
|
$arProp[$count]['value'] = trim($arItem[1]);
|
|
}
|
|
|
|
++$count;
|
|
}
|
|
}
|
|
|
|
$item = [
|
|
'externalIds' => [
|
|
[
|
|
'code' => 'prestashop',
|
|
'value' => $productId . '_' . $product['id_order_detail'],
|
|
],
|
|
],
|
|
'offer' => ['externalId' => $productId],
|
|
'productName' => $product['product_name'],
|
|
'quantity' => $product['product_quantity'],
|
|
'initialPrice' => round($product['product_price'], 2),
|
|
'purchasePrice' => round($product['purchase_supplier_price'], 2),
|
|
];
|
|
|
|
if (true == Configuration::get('PS_TAX') && isset($product['product_price_wt'])) {
|
|
$item['initialPrice'] = round($product['product_price_wt'], 2);
|
|
}
|
|
|
|
if (isset($arProp)) {
|
|
$item['properties'] = $arProp;
|
|
}
|
|
|
|
$crmOrder['items'][] = $item;
|
|
}
|
|
|
|
if ($order->gift && 0 < $order->total_wrapping) {
|
|
self::setOrderGiftItem($order, $crmOrder);
|
|
}
|
|
|
|
if ($order->id_customer) {
|
|
if (!empty($customerId)) {
|
|
$crmOrder['customer']['id'] = $customerId;
|
|
}
|
|
|
|
if (!empty($contactPersonExternalId)) {
|
|
$crmOrder['contact']['externalId'] = $contactPersonExternalId;
|
|
$crmOrder['contact']['site'] = $site;
|
|
} elseif (!empty($contactPersonId)) {
|
|
$crmOrder['contact']['id'] = $contactPersonId;
|
|
$crmOrder['contact']['site'] = $site;
|
|
}
|
|
|
|
if (!empty($site)) {
|
|
$crmOrder['customer']['site'] = $site;
|
|
}
|
|
}
|
|
|
|
return RetailcrmTools::filter(
|
|
'RetailcrmFilterProcessOrder',
|
|
RetailcrmTools::clearArray($crmOrder),
|
|
[
|
|
'order' => $order,
|
|
'customer' => $customer,
|
|
'cart' => $cart,
|
|
]
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Builds retailCRM customer data from PrestaShop customer data
|
|
*
|
|
* @param Customer $object
|
|
* @param array $address
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function buildCrmCustomer(Customer $object, $address = [])
|
|
{
|
|
$customer = array_filter(array_merge(
|
|
[
|
|
'externalId' => !empty($object->id) ? $object->id : null,
|
|
'firstName' => $object->firstname,
|
|
'lastName' => $object->lastname,
|
|
'email' => $object->email,
|
|
'subscribed' => $object->newsletter,
|
|
'createdAt' => RetailcrmTools::verifyDate($object->date_add, 'Y-m-d H:i:s')
|
|
? $object->date_add : date('Y-m-d H:i:s'),
|
|
'birthday' => RetailcrmTools::verifyDate($object->birthday, 'Y-m-d')
|
|
? $object->birthday : '',
|
|
'sex' => '1' == $object->id_gender ? 'male' : ('2' == $object->id_gender ? 'female' : ''),
|
|
'isContact' => isset($address['company']),
|
|
],
|
|
$address
|
|
), function ($value) {
|
|
return !('' === $value || null === $value || (is_array($value) ? 0 == count($value) : false));
|
|
});
|
|
|
|
return RetailcrmTools::filter(
|
|
'RetailcrmFilterProcessCustomer',
|
|
$customer,
|
|
[
|
|
'customer' => $object,
|
|
'address' => $address,
|
|
]
|
|
);
|
|
}
|
|
|
|
public static function buildCrmCustomerCorporate(
|
|
Customer $object,
|
|
$nickName = '',
|
|
$contactExternalId = '',
|
|
$appendAddress = false,
|
|
$appendCompany = false,
|
|
$site = ''
|
|
) {
|
|
$customerAddresses = [];
|
|
$addresses = $object->getAddresses((int) Configuration::get('PS_LANG_DEFAULT'));
|
|
$customer = [
|
|
'addresses' => [],
|
|
'companies' => [],
|
|
];
|
|
$company = [
|
|
'isMain' => true,
|
|
'externalId' => null,
|
|
'active' => true,
|
|
'name' => '',
|
|
];
|
|
|
|
// TODO: $company['contragent']['INN'] may not work, should check that later...
|
|
foreach ($addresses as $address) {
|
|
$addressBuilder = new RetailcrmAddressBuilder();
|
|
|
|
if ($address instanceof Address && !empty($address->company)) {
|
|
$customerAddresses[] = $addressBuilder
|
|
->setMode(RetailcrmAddressBuilder::MODE_CORPORATE_CUSTOMER)
|
|
->setAddress($address)
|
|
->setWithExternalId(true)
|
|
->build()
|
|
->getDataArray()
|
|
;
|
|
$customer['nickName'] = empty($nickName) ? $address->company : $nickName;
|
|
$company['name'] = $address->company;
|
|
$company['contragent']['INN'] = $address->vat_number;
|
|
$company['externalId'] = 'company_' . $address->id;
|
|
}
|
|
|
|
if (is_array($address) && !empty($address['company'])) {
|
|
$customerAddresses[] = $addressBuilder
|
|
->setMode(RetailcrmAddressBuilder::MODE_CORPORATE_CUSTOMER)
|
|
->setAddressId($address['id_address'])
|
|
->setWithExternalId(true)
|
|
->build()
|
|
->getDataArray()
|
|
;
|
|
$customer['nickName'] = empty($nickName) ? $address->company : $nickName;
|
|
$company['name'] = $address['company'];
|
|
$company['contragent']['INN'] = $address['vat_number'];
|
|
$company['externalId'] = 'company_' . $address['id_address'];
|
|
}
|
|
}
|
|
|
|
if ($appendCompany && null !== $company['externalId']) {
|
|
$customer['companies'][] = $company;
|
|
}
|
|
|
|
if (!empty($contactExternalId) && !empty($site)) {
|
|
$customer['customerContacts'] = [[
|
|
'isMain' => true,
|
|
'customer' => [
|
|
'externalId' => $contactExternalId,
|
|
'site' => $site,
|
|
],
|
|
]];
|
|
|
|
if (!empty($customer['companies'])
|
|
&& isset($customer['companies'][0], $customer['companies'][0]['externalId'])
|
|
) {
|
|
$customer['customerContacts'][0]['companies'] = [[
|
|
'company' => ['externalId' => $customer['companies'][0]['externalId']],
|
|
]];
|
|
}
|
|
}
|
|
|
|
if ($appendAddress) {
|
|
$customer['addresses'] = $customerAddresses;
|
|
}
|
|
|
|
return RetailcrmTools::filter(
|
|
'RetailcrmFilterProcessCustomerCorporate',
|
|
RetailcrmTools::clearArray($customer),
|
|
[
|
|
'customer' => $object,
|
|
]
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns true if provided item array contains placeholder item added for equal price with payment.
|
|
*
|
|
* @param array $item
|
|
*
|
|
* @return bool
|
|
*/
|
|
public static function isGiftItem($item)
|
|
{
|
|
if (isset($item['offer'], $item['offer']['externalId'])
|
|
&& RetailcrmReferences::GIFT_WRAPPING_ITEM_EXTERNAL_ID == $item['offer']['externalId']
|
|
) {
|
|
return true;
|
|
}
|
|
|
|
if (isset($item['externalIds'])) {
|
|
foreach ($item['externalIds'] as $externalId) {
|
|
if ('prestashop' == $externalId['code']
|
|
&& RetailcrmReferences::GIFT_WRAPPING_ITEM_EXTERNAL_ID == $externalId['value']
|
|
) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns gift item
|
|
*
|
|
* @param float $giftItemPrice
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function getGiftItem($giftItemPrice)
|
|
{
|
|
return [
|
|
'externalIds' => [[
|
|
'code' => 'prestashop',
|
|
'value' => RetailcrmReferences::GIFT_WRAPPING_ITEM_EXTERNAL_ID,
|
|
]],
|
|
'offer' => ['externalId' => RetailcrmReferences::GIFT_WRAPPING_ITEM_EXTERNAL_ID],
|
|
'productName' => 'Gift Wrapping Cost',
|
|
'quantity' => 1,
|
|
'initialPrice' => $giftItemPrice,
|
|
'purchasePrice' => $giftItemPrice,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Sets gift item to order (should be called if order is marked as gift)
|
|
*
|
|
* @param Order|\OrderCore $orderCms
|
|
* @param array $orderCrm
|
|
*/
|
|
private static function setOrderGiftItem($orderCms, &$orderCrm)
|
|
{
|
|
$isFound = false;
|
|
$giftItemPrice = round($orderCms->total_wrapping, 2);
|
|
|
|
foreach ($orderCrm['items'] as $key => $item) {
|
|
if (self::isGiftItem($item)) {
|
|
$orderCrm['items'][$key] = self::getGiftItem($giftItemPrice);
|
|
$isFound = true;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!$isFound) {
|
|
$orderCrm['items'][] = self::getGiftItem($giftItemPrice);
|
|
}
|
|
}
|
|
}
|