Symfony Profiler

<?php
namespace Virgin\SystemIntegration\Services\VirginUser;
use phpDocumentor\Reflection\Types\This;
use Shopware\Core\Checkout\Customer\CustomerEntity;
use Shopware\Core\Checkout\Customer\SalesChannel\AbstractLoginRoute;
use Shopware\Core\Checkout\Customer\SalesChannel\AccountService;
use Shopware\Core\Framework\Context;
use Shopware\Core\Framework\DataAbstractionLayer\EntityRepository;
use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
use Shopware\Core\Framework\Validation\DataBag\RequestDataBag;
use Shopware\Core\System\SalesChannel\ContextTokenResponse;
use Shopware\Core\System\SalesChannel\SalesChannelContext;
use Symfony\Component\HttpFoundation\Cookie;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Session\Session;
use Symfony\Contracts\Translation\TranslatorInterface;
use Virgin\GDPRPlugin\Service\PrivacyService;
use Virgin\LeadManager\Utils\Services\LeadGenerationService;
use Virgin\ProductModelExtension\Custom\Club\ClubEntity;
use Virgin\SystemIntegration\Exception\VirginApiException;
use Virgin\SystemIntegration\Services\RestApiClient;
use Shopware\Core\Framework\Validation\DataValidator;
use Shopware\Core\Framework\Validation\DataValidationDefinition;
use Symfony\Component\Validator\Constraints\Email;
use Shopware\Core\System\SystemConfig\SystemConfigService;
use Virgin\SystemIntegration\Services\Selling\Subscription;
use Symfony\Component\Security\Core\Exception\BadCredentialsException;
use Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException;
use Shopware\Core\Checkout\Customer\Exception\InactiveCustomerException;
use Virgin\VirginCustomElement\Service\LandingPageService;
class VirginUser
{
const CONTACT_LEADPURO = 100;
// COSTANTI PER LA GESTIONE DEL TIPO DI UTILIZZATORE //
const PERSONTYPE_LEAD = 0;
const PERSONTYPE_SOCIO = 1;
const PERSONTYPE_EXSOCIO = 2;
const PERSONTYPE_INSOLUTO = 3;
const PERSONTYPE_BLACKLIST = 4;
const PERSONTYPE_DROPECCEZ = 5;
const PERSONTYPE_NN = 6;
const PERSONTYPE_LEADLAYER = 7;
const PERSONDESC_LEAD = 'Lead';
const PERSONDESC_SOCIO = 'Socio';
const PERSONDESC_EXSOCIO = 'ExSocio';
const PERSONDESC_INSOLUTO = 'Insoluto';
const PERSONDESC_BLACKLIST = 'BlackList';
const PERSONDESC_DROPECCEZ = 'Drop Eccezione'; //drop eccezione è una cancellazione anticipata rispetto alla naturale data di scadenza del'abbonamento es. motivi di salute
const PERSONDESC_LEADLAYER = 'Lead Layer';
const PERSONDESC_NN = 'Non Disponibile';
// COSTANTI PER GESTIONE TIPO DI APPUNTAMENTO //
const APP_INFO = 1;
const APP_TRY = 2;
// -------------------------------------//
const ERROR_PSW_VAIGLOBAL_WRONG = 'VAPI API Error Forbidden';
const ERROR_EXERP_DUPLICATE = 'Esiste già un cliente registrato su Exerp con questa email.';
const HOME_TRAINING_CLUB_CODE = 233;
private $personDesc;
private $personType;
/** @var GlobalUser */
private $globalUser;
/** @var ExerpUser */
private $exerp_User;
/** @var PartnerUser */
private $partner_User;
/** @var LeadLayerUser $leadLayer_User */
private $leadLayer_User;
private $errorCode;
private $errorDesc;
/** @var EntityRepository */
private $customerRepository;
private $partnerGroup;
/** @var LeadGenerationService */
private $leadService;
/** @var RestApiClient */
private $restApiClient;
private $clubRepository;
/** @var SystemConfigService
*/
private SystemConfigService $systemConfigService;
/** @var DataValidator
*/
private $dataValidator;
/** @var PrivacyService */
private $privacyService;
private $isInLeadLayer;
private $customerGroupRepository;
/** @var AccountService */
private $accountService;
/** @var TranslatorInterface */
private $translator;
/**
* @var AbstractLoginRoute
*/
private $loginRoute;
/**
* @var ClubEntity
*/
private $clubEntity;
/**
* @var CustomerEntity|null
*/
private $customerEntity;
/**
* @var Session
*/
private $session;
public function __construct(
$customerRepository,
$leadService,
$restApiClient,
$clubRepository,
$systemConfigService,
$dataValidator,
$privacyService,
$customerGroupRepository,
$accountService,
$translator,
AbstractLoginRoute $loginRoute,
Session $session
)
{
$this->customerRepository = $customerRepository;
$this->leadService = $leadService;
$this->restApiClient = $restApiClient;
$this->clubRepository = $clubRepository;
$this->systemConfigService = $systemConfigService;
$this->dataValidator = $dataValidator;
$this->privacyService = $privacyService;
$this->customerGroupRepository = $customerGroupRepository;
$this->accountService = $accountService;
$this->translator = $translator;
$this->loginRoute = $loginRoute;
$this->session = $session;
}
public function checkPersonFull($email, $password, $codFisc)
{
$response = $this->restApiClient->checkPerson($email, $password, $codFisc);
if ($response!=""){
$this->mapResponseToObject($response);
$this->DetectPersonType();
$this->GetSubscription();
}
return json_decode($response, true);
}
public function checkPerson($email, $codFisc = null)
{
$response = $this->restApiClient->checkPerson($email, null, $codFisc);
// var_dump($response);
if ($response!=""){
$this->mapResponseToObject($response);
$this->DetectPersonType();
$this->GetSubscription();
}
return $response;
}
public function checkPersonByExerpInfo($exerpId, $campaignCode)
{
$response = $this->restApiClient->checkPersonByExerpInfo($exerpId, $campaignCode);
if ($response!=""){
$this->mapResponseToObject($response);
$this->DetectPersonType();
$this->GetSubscription();
}
return $response;
}
public function mapResponseToObject($response): VirginUser
{
$this->personType = self::PERSONTYPE_NN;
$response = json_decode($response);
$this->personDesc = $response->personDesc;
$this->errorCode = $response->errorCode;
$this->errorDesc = $response->errorDesc;
$this->exerp_User = null;
$this->globalUser = null;
$this->leadLayer_User = null;
$this->isInLeadLayer = false;
$this->partner_User = null;
if (isset($response->exerp_User)) {
$this->exerp_User = new ExerpUser();
$this->exerp_User->setErrorCode($response->exerp_User->errorCode);
$this->exerp_User->setErrorDesc($response->exerp_User->errorDesc);
$this->exerp_User->setId($response->exerp_User->id);
$this->exerp_User->setCenterId($response->exerp_User->centerId);
$this->exerp_User->setExternalId($response->exerp_User->externalId);
$this->exerp_User->setEmail($response->email);
$this->exerp_User->setCustomerGroup($response->customerGroup);
}
if (isset($response->exerp_Person)) {
if(is_array($response->exerp_Person)){
$key = array_search('ACTIVE',array_column($response->exerp_Person,'status'));
if($key === false) {
$this->personType = self::PERSONTYPE_EXSOCIO;
} else {
$this->personType = self::PERSONTYPE_SOCIO;
}
if($key>0){
$response->exerp_Person=$response->exerp_Person[$key];
}else{
$response->exerp_Person= reset($response->exerp_Person);
}
}
$user = $response->exerp_Person;
$this->exerp_User = new ExerpUser();
$this->exerp_User->setCenterId($user->personId->center);
$this->exerp_User->setId($user->personId->id);
$this->exerp_User->setExternalId($user->personId->externalId);
$this->exerp_User->setPersonStatus($user->status);
$this->exerp_User->setGender($user->gender);
$this->exerp_User->setLastName($user->lastName);
$this->exerp_User->setFirstName($user->firstName);
$this->exerp_User->setCodFisc($user->codFisc);
$this->exerp_User->setPersonType($user->personType);
$this->exerp_User->setEmail($response->email);
$this->exerp_User->setCustomerGroup($response->customerGroup);
//var_dump($this->exerp_User );
}
if (isset($response->global_User)) {
$this->globalUser = new GlobalUser(
$response->global_User->userId,
$response->global_User->firstName,
$response->global_User->lastName,
$response->global_User->email,
$response->global_User->gender,
$response->global_User->dateOfBirth,
$response->global_User->externalId,
$response->global_User->claims,
$response->global_User->error,
$response->global_User->token,
$response->global_User->refreshToken
);
if ($this->getGlobalUser()->getToken() !=null && $this->session->get('tokenGlobal') != $this->getGlobalUser()->getToken()){
$this->session->set('refreshTokenGlobal', $this->getGlobalUser()->getRefreshToken());
$this->session->set('tokenGlobal', $this->getGlobalUser()->getToken());
$this->session->set('tokenGlobalTimestamp', new \DateTime());
}
}
if (isset($response->leadLayer_User)) {
$this->isInLeadLayer = true;
$this->leadLayer_User = new LeadLayerUser();
$this->leadLayer_User->setNome($response->leadLayer_User->nome);
$this->leadLayer_User->setCognome($response->leadLayer_User->cognome);
$this->leadLayer_User->setCanale($response->leadLayer_User->canale);
$this->leadLayer_User->setGuidLead($response->leadLayer_User->guid_lead);
$this->leadLayer_User->setGiornoPredefinito($response->leadLayer_User->giorno_predefinito);
$this->leadLayer_User->setOrarioPredefinito($response->leadLayer_User->orario_predefinito);
$this->leadLayer_User->setClubDescrizione($response->leadLayer_User->club_Descrizione);
$this->leadLayer_User->setGuidClub($response->leadLayer_User->guid_Club);
$this->leadLayer_User->setTelefono($response->leadLayer_User->telefono);
$this->leadLayer_User->setEmail($response->leadLayer_User->email);
$this->leadLayer_User->setCanale($response->leadLayer_User->canale);
$this->leadLayer_User->setPrivacy($response->leadLayer_User->privacy);
}
if (isset($response->partnerUser)) {
$this->partner_User = new PartnerUser();
$this->partner_User->setEmail($response->partnerUser->email ?? null);
$this->partner_User->setUserName($response->partnerUser->userName ?? null);
$this->partner_User->setSurnameName($response->partnerUser->surnameName ?? null);
$this->partner_User->setBirthdate($response->partnerUser->birthdate ?? null);
$this->partner_User->setBirthPlace($response->partnerUser->birthPlace ?? null);
$this->partner_User->setFiscalCode($response->partnerUser->fiscalCode ?? null);
$this->partner_User->setCustomerGroup($response->partnerUser->customerGroup ?? null);
$this->partner_User->setItalian($response->partnerUser->italian ?? null);
$this->partner_User->setNation($response->partnerUser->nation ?? null);
$this->partner_User->setPhoneNumber($response->partnerUser->phoneNumber ?? null);
$this->partner_User->setResidentAddress($response->partnerUser->residentAddress ?? null);
$this->partner_User->setResidentCity($response->partnerUser->residentCity ?? null);
$this->partner_User->setClubId($response->partnerUser->clubId ?? null);
$this->setPartnerGroup($response->partnerUser->customerGroup ?? null);
}
return $this;
}
private function DetectPersonType()
{
$personType = $this->personType;
$inExerp = isset($this->exerp_User) ? true : false;
$inLeadLayer = isset($this->leadLayer_User) ? true : false;
if ($inExerp) {
// Socio da verificarne il tipo
$externalId = $this->exerp_User->getExternalId();
$personDetails = $this->restApiClient->getPersonDetail($externalId);
if (isset($personDetails)) {
$personDetailsArray = json_decode($personDetails,true);
$personDetails = json_decode($personDetails);
$this->exerp_User->setPersonType($personDetails->person->personType);
$this->exerp_User->setPersonStatus($personDetails->person->status);
$this->exerp_User->setCodFisc($personDetails->person->codFisc);
$this->exerp_User->setSuspended($personDetails->personTypeAndStatus->suspended);
$this->exerp_User->setBlackListed($personDetails->personTypeAndStatus->blacklisted);
$this->exerp_User->setSubscriptions($personDetails->subscriptions);
$this->exerp_User->setFirstName($personDetails->person->firstName);
$this->exerp_User->setLastName($personDetails->person->lastName);
$this->exerp_User->setCenterId($personDetails->person->personId->center);
if($personDetailsArray['person']['status'] == 'TEMPORARYINACTIVE'
|| $personDetailsArray['person']['status'] == 'INACTIVE') {
$key = array_search('ACTIVE',array_column($personDetailsArray['subscriptions'],'state'));
if($key===false){
// Sub Appena acquistata ma non attiva quindi sono TEMPORARYINACTIVE ma sub non ancora attiva
$key = array_search('CREATED',array_column($personDetailsArray['subscriptions'],'state'));
}
if($key===false){
// Sub in stato freeze
$key = array_search('FROZEN',array_column($personDetailsArray['subscriptions'],'state'));
}
if($key===false){
// se non è attivo cerco per sub appena creato
$personType = self::PERSONTYPE_EXSOCIO;
}else{
$personType = self::PERSONTYPE_SOCIO;
}
} else {
if($personDetailsArray['person']['status'] =='ACTIVE'){
$key = array_search('ACTIVE',array_column($personDetailsArray['subscriptions'],'state'));
if($key===false){
$key = array_search('CREATED',array_column($personDetailsArray['subscriptions'],'state'));
}
if($key===false){
$key = array_search('FROZEN',array_column($personDetailsArray['subscriptions'],'state'));
}
if($key===false){
$key = array_search('CREATED',array_column($personDetailsArray['subscriptions'],'state'));
}
//var_dump($key);
if($key === false) {
$personType = self::PERSONTYPE_EXSOCIO;
} else {
$personType = self::PERSONTYPE_SOCIO;
}
}else{
$personType = self::PERSONTYPE_EXSOCIO;
}
}
};
$balance = $this->restApiClient->getBalance($externalId);
if (isset($balance)) {
$this->exerp_User->setBalance($balance["totalPayableDebt"]);
}
if ($this->exerp_User->getBalance() > 0) {
$personType = self::PERSONTYPE_INSOLUTO;
}
if ($this->exerp_User->getBlackListed()) {
$personType = self::PERSONTYPE_BLACKLIST;
}
//var_dump($this->exerp_User->getPersonStatus());
if($this->exerp_User->getPersonStatus() =='LEAD'){
$personType = self::PERSONTYPE_LEAD;
}
}else{
$personType = self::PERSONTYPE_LEAD;
if ($inLeadLayer) {
$personType = self::PERSONTYPE_LEADLAYER;
}
}
$this->personType = $personType;
$this->PersonTypeDesc();
// var_dump($this->personType );
}
private function PersonTypeDesc()
{
switch ($this->personType) {
case self::PERSONTYPE_LEAD:
$this->personDesc = self::PERSONDESC_LEAD;
break;
case self::PERSONTYPE_EXSOCIO:
$this->personDesc = self::PERSONDESC_EXSOCIO;
break;
case self::PERSONTYPE_INSOLUTO:
$this->personDesc = self::PERSONDESC_INSOLUTO;
break;
case self::PERSONTYPE_BLACKLIST:
$this->personDesc = self::PERSONDESC_BLACKLIST;
break;
case self::PERSONTYPE_SOCIO:
$this->personDesc = self::PERSONDESC_SOCIO;
break;
case self::PERSONTYPE_DROPECCEZ:
$this->personDesc = self::PERSONDESC_DROPECCEZ;
break;
case self::PERSONTYPE_LEADLAYER:
$this->personDesc = self::PERSONDESC_LEADLAYER;
break;
case self::PERSONDESC_NN:
$this->personDesc = self::PERSONDESC_NN;
}
}
public function GetSubscription()
{
if (isset($this->exerp_User)) {
$exerpId=null;
$exrpCenterId=null;
if($this->exerp_User->getId() != '' || $this->exerp_User->getId() != null){
$exerpId = $this ->exerp_User->getId();
$exrpCenterId=$this ->exerp_User->getCenterId();
}
if ($exerpId!=null) {
$response = $this->restApiClient->getPersonSubscriptions($exerpId ,$exrpCenterId);
if (isset($response)) {
$subJson = json_decode($response,true);
if($subJson['item'] != null) {
$item = array_search('ACTIVE',array_column($subJson['item'],'state'));
if($item !== false){
$sub = new Subscription();
$sub->setName($subJson['item'][$item]['product']['name']);
$sub->setPeriodLength($subJson['item'][$item]['product']['periodLength']);
$sub->setPeriodUnit($subJson['item'][$item]['product']['periodUnit']);
$sub->setType($subJson['item'][$item]['product']['type']);
$sub->setStartDate($subJson['item'][$item]['startDate']);
$sub->setEndDate($subJson['item'][$item]['endDate']);
$sub->setSubscriptionId($subJson['item'][$item]['subscriptionId']['center']. 'ss' .$subJson['item'][$item]['subscriptionId']['id']);
$sub->setState($subJson['item'][$item]['state']);
$sub->setSubState($subJson['item'][$item]['subState']);
$this->exerp_User->setSubscriptions($sub);
}
}
}
}
}
}
/**
* @param RequestDataBag $data
* @return string|null
*/
public function CheckFormParamsToStorefront(RequestDataBag $data): ?string
{
$firstname = $data->get('name');
$lastname = $data->get('lastname');
$phone = $data->get('phone');
$phonePrefix = $data->get('intlPrefix');
$email = $data->get('email');
$privacy = $data->get('privacy');
$club = $data->get('club');
$zipcode = $data->get('zipcode');
$validation = new DataValidationDefinition('customer.email');
$validation->add('email', new Email());
if (empty($firstname) || empty($lastname) || empty($phone) || empty($email) || empty($club)) {
return 'lead-manager.form.message.errorMessage';
}
$response = $this->leadService->getCaptchaResponse($_POST['g-recaptcha-response'], $this->systemConfigService->get('LeadManager.config.secretKey'));
if (!$response->success) {
return 'lead-manager.form.message.invalidCaptcha';
}
if (!preg_match($this->systemConfigService->get('LeadManager.config.textRegex'), $firstname) || !preg_match($this->systemConfigService->get('LeadManager.config.textRegex'), $lastname) || !preg_match($this->systemConfigService->get('LeadManager.config.numberRegex'), $phone)) {
return 'lead-manager.form.message.errorRegexFields';
}
try {
$this->dataValidator->validate(['email' => $email], $validation);
} catch (\Exception $e) {
return $e->getMessage();
}
return null;
}
/**
* @param array $formParams
* @param SalesChannelContext $context
* @return string|null
*/
public function handlePerson(array $formParams, SalesChannelContext $context): ?string
{
$privacy = $formParams['privacy'] ?? false;
if (!empty($_SESSION['utm_params'])) {
$this->restApiClient->insertUtmParams($_SESSION['utm_params'], $formParams['email'], $formParams['firstName'], $formParams['lastName']);
unset($_SESSION['utm_params']);
}
if ($this->getPersonType()!=self::PERSONTYPE_LEAD && $this->getPersonType()!=self::PERSONTYPE_LEADLAYER){
return 'lead-manager.form.message.userRegistered';
}
if ($this->getErrorDesc()){
return 'lead-manager.account.genericErrorLogin';
}
try {
$this->saveCurrentLead(
null,
$formParams['email'],
$formParams['firstName'],
$formParams['lastName'],
$formParams['phone'],
$formParams['club'],
$privacy,
null,
$context
);
} catch (VirginApiException $e) {
} catch (\Exception $e) {
return 'lead-manager.form.message.errorRegistration';
}
return null;
}
/**
* @param array $formParams
* @param string|null $guid
* @return void
* @throws VirginApiException
* @throws \Exception
*/
private function upsertLeadToLayer(array $formParams, string $guid=null): void
{
if ($guid){
$lead = $this->restApiClient->getLead(['guid' => $guid]);
} else {
$lead = $this->restApiClient->getLead(['email' => $formParams['email']]);
}
if ($lead != []) {
$this->restApiClient->updateLeadAndAppointment($formParams);
} else {
$this->restApiClient->insertLeadAndAppointment($formParams);
}
}
/**
* @param array $customerData
* @param SalesChannelContext $context
* @return false|void
*/
public function updateLead(array $customerData, SalesChannelContext $context)
{
if (empty($customerData)) {
return false;
}
try {
$currentLead = $this->getCurrentLead();
if (
$currentLead['firstName'] != $customerData['name'] ||
$currentLead['lastName'] != $customerData['surname'] ||
$currentLead['phoneNumber'] != $customerData['phone'] ||
$currentLead['email'] != $customerData['email'] ||
$currentLead['clubId'] != $customerData['clubId']
) {
$this->saveCurrentLead(
$currentLead['guid_lead'],
$customerData['email'],
$customerData['name'],
$customerData['surname'],
$customerData['phone'],
$currentLead['clubId'],
$currentLead['privacy'],
$currentLead['timestamp'],
$context
);
}
} catch (\Exception $e) {
return false;
}
}
public function getCustomerGroupIdByVirginUserTypeCode($userTypeCode)
{
$customerGroupEntity = $this->customerGroupRepository->search(
(new Criteria())->addFilter(new EqualsFilter('customFields.virgin_user_type_code', $userTypeCode))
, Context::createDefaultContext())->first();
return $customerGroupEntity->getId();
}
public function getCustomerGroupIdByName($customerGroupName)
{
$customerGroupEntity = $this->customerGroupRepository->search(
(new Criteria())->addFilter(new EqualsFilter('name', $customerGroupName))
, Context::createDefaultContext())->first();
return $customerGroupEntity->getId();
}
public function writeCookies($formParams)
{
$params = [
'name' => $formParams['firstName'],
'lastname' => $formParams['lastName'],
'phone' => $formParams['phone'],
'email' => $formParams['email'],
'userType' => '', // handle CRM user type
];
$this->leadService->createCookie($params);
}
/**
* @param $data
* @param SalesChannelContext $context
* @return array
*/
public function LoginManager($data, SalesChannelContext $context): array
{
$email = $data->get('username');
$password = $data->get('password');
$checkPersonResponse = $this->checkPersonFull($email , $password,null);
if (!$checkPersonResponse || $this->errorCode == 500) {
return [
'login' => false,
'errorMessage' => $this->translator->trans('lead-manager.form.message.checkpersonFail')
];
}
$this->setCustomerEntity($this->getCustomerByEmail($email, $context));
$this->setClub($context);
if ($checkPersonResponse['personDesc'] == "LEAD" || $checkPersonResponse['personDesc'] == "LEADLAYER") {
return [
'login' => false,
'errorMessage' => $this->translator->trans('lead-manager.form.message.accountLoginOldLead'),
'personType' => $this->getPersonType()
];
}
if ($this->errorDesc == self::ERROR_PSW_VAIGLOBAL_WRONG) {
return [
'login' => false,
'errorMessage' => $this->translator->trans('lead-manager.form.message.accountLogin'),
'personType' => $this->getPersonType()
];
}
if (!empty($this->errorDesc)) {
return [
'login' => false,
'errorMessage' => $this->translator->trans('lead-manager.account.genericErrorLogin'),
'personType' => $this->getPersonType()
];
}
if ($this->getGlobalUser() == null || $this->getExerpUser() == null){
return [
'login' => false,
'errorMessage' => $this->translator->trans('lead-manager.form.message.checkpersonFail')
];
}
//user is not on shopware, implicit registration
if (!$this->getCustomerEntity()) {
$this->setCustomerEntity($this->registerFromGlobal($context, $email, $password));
if (!$this->getCustomerEntity()){
return [
'login' => false,
'errorMessage' => $this->translator->trans('lead-manager.form.message.checkpersonFail'),
];
}
}
$customerUpdateArray = $this->getUpdateShopwareFields($password);
$customFields = [
'lead_implicit_registration' => false,
'privacy_consent' => null,
'home_training' => $this->getIsHomeTraining(),
];
if ($this->getPartnerUser()) {
$customFields = array_merge($customFields, $this->getPartnerUser()->getObjectVars());
}
$customerUpdateArray['id'] = $this->getCustomerEntity()->getId();
$customerUpdateArray['customFields'] = $customFields;
if (!empty($_SESSION['utm_params'])) {
$this->restApiClient->insertUtmParams($_SESSION['utm_params'], $email, $this->getCustomerEntity()->getFirstName(), $this->getCustomerEntity()->getLastName(), 'LOGIN');
unset($_SESSION['utm_params']);
}
if ($this->leadLayer_User){
$customerUpdateArray['customFields']['virgin_guid'] = $this->leadLayer_User->getGuidLead();
} else {
error_log("LoginManager - no leadLayer_user for ".$email);
}
try {
if ($this->getPersonType() != VirginUser::PERSONTYPE_BLACKLIST) {
$this->customerRepository->update([$customerUpdateArray], $context->getContext());
$this->loginRoute->login($data, $context);
if ($this->getCustomerEntity()->getCustomFields() &&
isset($this->getCustomerEntity()->getCustomFields()['unsolved_under_evaluation']) &&
$this->getCustomerEntity()->getCustomFields()['unsolved_under_evaluation']
) {
$this->customerRepository->update([
[
'id' => $this->getCustomerEntity()->getId(),
'customFields' => [
'unsolved_under_evaluation' => false,
],
],
], $context->getContext());
}
}
$this->session->set('personType', $this->getPersonType());
$response = [
'login' => true,
'personType' => $this->getPersonType(),
'customerEntity' => $this->getCustomerEntity()
];
} catch (BadCredentialsException|UnauthorizedHttpException|InactiveCustomerException $e) {
//login ko
switch ($e) {
case $e instanceof UnauthorizedHttpException:
case $e instanceof BadCredentialsException:
default:
$errorMessage = $this->translator->trans('lead-manager.form.message.accountLogin');
}
$response = [
'login' => false,
'errorMessage' => $errorMessage,
'personType' => $this->getPersonType(),
'customerEntity' => $this->getCustomerEntity()
];
}
return $response;
}
/**
* @param string $email
* @param SalesChannelContext $salesChannelContext
* @return CustomerEntity | null
*/
private function getCustomerByEmail(string $email, SalesChannelContext $salesChannelContext): ?CustomerEntity
{
$criteria = new Criteria();
$criteria->addFilter(new EqualsFilter('customer.email', $email));
/** @var CustomerEntity $customerEntity */
return $this->customerRepository->search($criteria, $salesChannelContext->getContext())->first();
}
/**
* @param string $urlLogin
* @param string $urlCourses
* @return string
* @throws VirginApiException
*/
public function getURL_TO_PersonalAreaCMS(string $urlLogin, string $urlCourses ): string
{
$token = $this->getGlobalToken();
if (!$token){
return "#";
}
return $urlLogin.'?token='.$token.'&landingurl='.$urlCourses;
}
/**
* @return mixed|null
* @throws VirginApiException
*/
public function getGlobalToken()
{
if ($this->session->get('tokenGlobalTimestamp') &&
(new \DateTime())->diff($this->session->get('tokenGlobalTimestamp'))->m < 120
){
return $this->session->get('tokenGlobal');
}
$tokenData = $this->restApiClient->GlobalRefreshToken($this->session->get('refreshTokenGlobal'));
if (!$tokenData){
return null;
}
$this->session->set('refreshTokenGlobal', $tokenData['token']);
$this->session->set('tokenGlobal', $tokenData['oneTimeToken']);
$this->session->set('tokenGlobalTimestamp', new \DateTime());
return $tokenData['oneTimeToken'];
}
/**
* @return mixed
*/
public function getPersonDesc()
{
return $this->personDesc;
}
/**
* @param mixed $personDesc
*/
public function setPersonDesc($personDesc): void
{
$this->personDesc = $personDesc;
}
/**
* @return mixed
*/
public function getPersonType()
{
return $this->personType;
}
/**
* @param GlobalUser $globalUser
*/
public function setGlobalUser(GlobalUser $globalUser): void
{
$this->globalUser = $globalUser;
}
/**
* @return GlobalUser | null
*/
public function getGlobalUser(): ?GlobalUser
{
return $this->globalUser ?? null;
}
/**
* @return ExerpUser | null
*/
public function getExerpUser(): ?ExerpUser
{
return $this->exerp_User ?? null;
}
/**
* @param ExerpUser $exerp_User
*/
public function setExerpUser(ExerpUser $exerp_User): void
{
$this->exerp_User = $exerp_User;
}
/**
* @return mixed
*/
public function getErrorCode()
{
return $this->errorCode;
}
/**
* @param mixed $errorCode
*/
public function setErrorCode($errorCode): void
{
$this->errorCode = $errorCode;
}
/**
* @return mixed
*/
public function getErrorDesc()
{
return $this->errorDesc;
}
/**
* @param mixed $errorDesc
*/
public function setErrorDesc($errorDesc): void
{
$this->errorDesc = $errorDesc;
}
/**
* @return LeadLayerUser
*/
public function getLeadLayerUser(): ?LeadLayerUser
{
return $this->leadLayer_User;
}
/**
* @param LeadLayerUser $leadLayer_User
*/
public function setLeadLayerUser(LeadLayerUser $leadLayer_User): void
{
$this->leadLayer_User = $leadLayer_User;
}
/**
* @return mixed
*/
public function getIsInLeadLayer()
{
return $this->isInLeadLayer;
}
/**
* @param mixed $isInLeadLayer
*/
public function setIsInLeadLayer($isInLeadLayer): void
{
$this->isInLeadLayer = $isInLeadLayer;
}
/**
* @return mixed
*/
public function getPartnerGroup()
{
return $this->partnerGroup;
}
/**
* @param mixed $partnerGroup
*/
public function setPartnerGroup($partnerGroup): void
{
$customerGroups = explode(",", $partnerGroup);
if(count($customerGroups) > 1) {
$this->partnerGroup = $customerGroups[1];
} else {
$this->partnerGroup = $customerGroups[0];
}
}
/**
* @return PartnerUser
*/
public function getPartnerUser():? PartnerUser
{
return $this->partner_User;
}
/**
* @param PartnerUser $partner_User
*/
public function setPartnerUser(PartnerUser $partner_User)
{
$this->partner_User = $partner_User;
}
/**
* @return mixed
*/
public function getCustomerGroupId()
{
if($this->getExerpUser() != null && !empty($this->getExerpUser()->getCustomerGroup())) {
$customerGroupId = $this->getCustomerGroupIdByName($this->getExerpUser()->getCustomerGroup());
} else {
if(!empty($this->getPartnerGroup())) {
$customerGroupId = $this->getCustomerGroupIdByName($this->getPartnerGroup());
if(empty($customerGroupId)) {
$customerGroupId = $this->getCustomerGroupIdByVirginUserTypeCode($this->getPersonType());
}
} else {
$customerGroupId = $this->getCustomerGroupIdByVirginUserTypeCode($this->getPersonType());
}
}
return $customerGroupId;
}
private function registerFromGlobal(SalesChannelContext $context, $email, $password): CustomerEntity
{
$shopwareUserBasicData = [
'firstName' => $this->getGlobalUser()->getFirstName(),
'lastName' => $this->getGlobalUser()->getLastName(),
'salutationId' => $this->leadService->getDefaultSalutation($context),
'email' => $email,
'password' => $password,
];
//registrazione implicita
return $this->leadService->prepareRegistrationData($context, $shopwareUserBasicData, false);
}
/**
* @param string|null $password
* @return array|null
*/
private function getUpdateShopwareFields(string $password=null): ?array
{
if (!$this->getCustomerEntity()){
return null;
}
//clubentity
$updateArray = [
'active' => true,
'group' => [
'id' => $this->getCustomerGroupId()
],
'extensions' => ['preferredClubId' => $this->getClubEntity() ? $this->getClubEntity()->getId() : null],
];
if ($this->getCustomerEntity()->getFirstName() != $this->getGlobalUser()->getFirstName()) {
$updateArray['firstName'] = $this->getGlobalUser()->getFirstName();
}
if ($this->getCustomerEntity()->getLastName() != $this->getGlobalUser()->getLastName()) {
$updateArray['lastName'] = $this->getGlobalUser()->getLastName();
}
if ($password && !password_verify($password, $this->customerEntity->getPassword())){
$updateArray['password'] = $password;
}
return $updateArray;
}
/**
* @param SalesChannelContext $context
* @return void
*/
private function setClub(SalesChannelContext $context)
{
if ($this->getExerpUser()) {
$criteria = new Criteria();
$criteria->addFilter(new EqualsFilter('club.centerId', $this->getExerpUser()->getCenterId()));
/** @var ClubEntity $clubEntity */
$this->clubEntity = $this->clubRepository->search($criteria, $context->getContext())->first();
}
}
/**
* @return ClubEntity|null
*/
public function getClubEntity(): ? ClubEntity
{
return $this->clubEntity;
}
/**
* @return bool
*/
private function getIsHomeTraining(): bool
{
return $this->getExerpUser()->getCenterId() == $this::HOME_TRAINING_CLUB_CODE;
}
private function isImplicit()
{
return $this->customerEntity->getCustomFields()['lead_implicit_registration'] ?? false;
}
/**
* @return CustomerEntity|null
*/
public function getCustomerEntity(): ?CustomerEntity
{
return $this->customerEntity;
}
/**
* @param CustomerEntity|null $customerEntity
* @return void
*/
private function setCustomerEntity(?CustomerEntity $customerEntity)
{
$this->customerEntity = $customerEntity;
}
/**
* @throws \Exception
*/
public function getCurrentLead(){
if (
$this->session->get('leadUser') &&
(new \DateTime())->diff(
(new \DateTime())->setTimestamp($this->session->get('leadUser')['timestamp'])
)->days > 30
) {
$this->session->set('leadUser', null);
throw new \Exception('Expired Lead');
}
if (isset($_COOKIE['leadUser'])){
$this->session->set('leadUser', json_decode($_COOKIE['leadUser'], true));
}
return $this->session->get('leadUser');
}
/**
* @param string|null $guid
* @param string $email
* @param string $firstName
* @param string $lastName
* @param string $phoneNumber
* @param string $clubId
* @param bool $privacy
* @param string|null $timestamp
* @param SalesChannelContext $context
* @throws VirginApiException
*/
public function saveCurrentLead(
?string $guid,
string $email,
string $firstName,
string $lastName,
string $phoneNumber,
string $clubId,
bool $privacy,
?string $timestamp,
SalesChannelContext $context,
bool $skipUpsertLeadToLayer= false
): void
{
$update = true;
if (!$guid){
$dateTime = new \DateTime();
$guid = $dateTime->getTimestamp() . $email;
$timestamp = $dateTime->getTimestamp();
$update = false;
}
$user = [
'guid_lead' => $guid,
'firstName' => $firstName,
'lastName' => $lastName,
'email' => $email,
'phoneNumber' => $phoneNumber,
'clubId' => $clubId,
'privacy' => $privacy,
'timestamp' => $timestamp,
];
$this->session->set('leadUser', $user);
//todo
$privacyText = "";
if ($privacyText) {
$user['privacyJson'] = $privacyText;
}
if ($clubId == 'digital'){
return;
} else {
$criteria = new Criteria();
$criteria->addFilter(new EqualsFilter('club.id', $clubId));
/** @var ClubEntity $clubEntity */
$clubEntity = $this->clubRepository->search($criteria, $context->getContext())->first();
$user['guid_club'] = $clubEntity->getGuidVirgin();
$user['clubName'] = $clubEntity->getName();
}
if (!$skipUpsertLeadToLayer) {
$this->upsertLeadToLayer($user, $update ? $guid : null);
}
}
/**
* @param string|null $email
* @return bool
*/
public function canBuy(string $email = null): bool
{
if ($email){
$this->checkPerson($email);
}
return match ($this->getPersonType()) {
$this::PERSONTYPE_LEAD,
$this::PERSONTYPE_LEADLAYER,
$this::PERSONTYPE_DROPECCEZ,
$this::PERSONTYPE_EXSOCIO => true,
default => false,
};
}
}

custom/plugins/SystemIntegration/src/Services/VirginUser/VirginUser.php line 1163