Mediapart\Selligent\Transport

Complexity

Total Complexity

28

Size/Duplication

Total Lines	271
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	1	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	3
A	setLogger()	0	4	1
A	setList()	0	12	2
A	getList()	0	4	1
A	setCampaign()	0	6	1
A	getCampaign()	0	4	1
A	getExistingUserId()	0	17	3
A	createUser()	0	21	3
B	subscribe()	0	37	6
A	TriggerCampaignForUserAndActionListItemWithResult()	0	8	1
A	TriggerCampaignForUserWithResult()	0	6	1
B	triggerCampaign()	0	33	4
A	getOptions()	0	10	1

<?php

/**
 * This file is part of the Mediapart Selligent Client API
 *
 * CC BY-NC-SA <https://github.com/mediapart/selligent>
 *
 * For the full license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Mediapart\Selligent;

use Psr\Log\LoggerInterface;
use Psr\Log\LoggerAwareInterface;

use Mediapart\Selligent\Response\GetUserByFilterResponse;

/**
 *
 */
class Transport implements LoggerAwareInterface
{
    /**
     * @var \SoapClient
     */
    protected $client;

    /**
     * @var int
     */
    protected $list;

    /**
     * @var string
     */
    protected $campaign;

    /**
     * @var LoggerInterface
     */
    protected $logger = null;

    /**
     * @param \SoapClient $client
     * @param string $list
     * @param string $campaign
     */
    public function __construct(\SoapClient $client, $list = null, $campaign = null)
    {
        $this->client = $client;

        if (!is_null($list)) {
            $this->setList($list);
        }
        if (!is_null($campaign)) {
            $this->setCampaign($campaign);
        }
    }

    /**
     * {@inheritDoc}
     */
    public function setLogger(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }

    /**
     *
     * @param string $list Name of the list 
     * @throws Exception if the list was not found in the remote server
     * @return self
     */
    public function setList($list)
    {
        $response = $this->client->GetListID(['name' => $list]);

        if (Response::SUCCESSFUL !== $response->getCode()) {
            throw new \Exception();
        } else {
            $this->list = $response->getId();

            return $this;
        }
    }

    /**
     * @return int
     */
    public function getList()
    {
        return $this->list;
    }

    /**
     *
     * @param string $campaign Gate Name
     * @return self
     */
    public function setCampaign($campaign)
    {
        $this->campaign = $campaign;

        return $this;
    }

    /**
     * @return string
     */
    public function getCampaign()
    {
        return $this->campaign;
    }

    /**
     * @param GetUserByFilterResponse $response
     * @param string $idKey
     *
     * @return integer
     */
    private function getExistingUserId(GetUserByFilterResponse $response, $idKey)
    {
        $properties = $response->getProperties();
        if (isset($properties[$idKey])) {
            $id = $properties[$idKey];
            if ($this->logger) {
                $this->logger->info('User already registered', [$idKey => $id]);
            }
            return $id;
        } else {
            throw new \UnexpectedValueException(sprintf(
                "key %s do not exists in %s",
                $idKey,
                implode(',', array_keys((array) $properties))
            ));
        }
    }

    /**
     * @param Properties $user
     * @return integer
     */
    private function createUser(Properties $user)
    {
        $response = $this->client->CreateUser([
            'List' => $this->list,
            'Changes' => $user,
        ]);
        $id = null;
        if (Response::SUCCESSFUL === $response->getCode()) {
            $id = $response->getUserId();
            if ($this->logger) {
                $this->logger->notice(
                    'New user registered',
                    [
                        'id' => $id, 
                        'properties' => $user
                    ]
                );
            }
        }
        return $id;
    }

    /**
     * Subscribe the given user, if not already in list, and returns his identifier
     *
     * @param Properties $user
     * @return int User id
     * @throws UnexpectedValueException if $idKey is not an existing Property
     * @throws Exception If something happens during the request
     */
    public function subscribe(Properties $user, $idKey = 'ID')
    {
        $response = $this->client->GetUserByFilter([
            'List' => $this->list,
            'Filter' => $user,
        ]);

        try {
            switch ($response->getCode()) {

                /* the user already exists */
                case Response::SUCCESSFUL:
                    $id = $this->getExistingUserId($response, $idKey);
                    break;

                /* the user do not exist, we create it */
                case Response::ERROR_NORESULT:
                    if($id = $this->createUser($user)) {
                        break;
                    }

                /* something wrong */
                default:
                    throw new \Exception(
                        $response->getError(),
                        $response->getCode()
                    );
            }
        } catch (\Exception $e) {
            if ($this->logger) {
                $this->logger->error($e->getMessage());
            }
            throw $e;
        }

        return $id;
    }

    /**
     * @param int $userId
     * @param Properties $inputData
     * @param array $actionProperties
     */
    public function TriggerCampaignForUserAndActionListItemWithResult($userId, Properties $inputData, array $actionProperties = [])
    {
        $options['Actioncode'] = $actionProperties['Actioncode'];

$options was never initialized. Although not strictly required by PHP, it is generally a good practice to add $options = array(); before regardless.

        $options['ActionListID'] = $actionProperties['ActionListID'];
        $options['ActionListItemData'] = $inputData;

        $this->triggerCampaign($userId,'TriggerCampaignForUserAndActionListItemWithResult', $options);
    }

    /**
     * @param int $userId
     * @param Properties $inputData
     */
    public function TriggerCampaignForUserWithResult($userId, Properties $inputData)
    {
        $options['InputData'] = $inputData;

$options was never initialized. Although not strictly required by PHP, it is generally a good practice to add $options = array(); before regardless.

        $this->triggerCampaign($userId,'TriggerCampaignForUserWithResult', $options);
    }

    /**
     * @param int $userId
     * @param string $method
     * @param array $options
     * @return mixed
     * @throws \Exception
     */
    private function triggerCampaign($userId, $method = 'TriggerCampaignForUserWithResult', array $options)
    {
        $options = array_merge($this->getOptions($userId), $options);

        $response = call_user_func([$this->client, $method], $options);

        $context = [
            'request' => [
                'method' => $method,
                'value' => $options,
           ],
            'response' => [
                'code' => $response->getCode(),
                'error' => $response->getError(),
                'result' => $response->getResult(),
            ],
        ];

        if (Response::SUCCESSFUL !== $response->getCode()) {
            if ($this->logger) {
                $this->logger->error('triggerCampaign has failed', $context);
            }
            throw new \Exception(
                $response->getError(),
                $response->getCode()
            );
        } else {
            if ($this->logger) {
                $this->logger->info('triggerCampaign with success', $context);
            }
            return $response->getResult();
        }
    }

    /**
     * @param int $userId
     * @return array
     */
    private function getOptions($userId)
    {
        $options = [
            'List' => $this->list,
            'UserID' => $userId,
            'GateName' => $this->campaign,
        ];

        return $options;
    }
}