LivePersonInc\LiveEngageLaravel\LiveEngageLaravel

Complexity

Total Complexity

56

Size/Duplication

Total Lines	393
Duplicated Lines	0 %

Importance

Changes

0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__get()	0	3	1
A	__construct()	0	5	2
B	login()	0	25	1
A	skills()	0	5	1
A	get()	0	3	1
A	retry()	0	5	1
B	requestV2()	0	22	4
A	limit()	0	5	1
A	nonInteractive()	0	4	1
D	history()	0	46	10
A	domain()	0	9	2
B	retrieveMsgHistory()	0	24	3
A	key()	0	5	1
C	requestV1()	0	51	7
D	messagingHistory()	0	45	10
A	__set()	0	3	1
A	account()	0	5	1
A	visitor()	0	12	2
A	getAgentStatus()	0	20	2
A	active()	0	4	1
B	retrieveHistory()	0	24	3

<?php

namespace LivePersonInc\LiveEngageLaravel;

use Carbon\Carbon;
use GuzzleHttp\Client;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Subscriber\Oauth\Oauth1;
use LivePersonInc\LiveEngageLaravel\Models\Info;
use LivePersonInc\LiveEngageLaravel\Models\Payload;
use LivePersonInc\LiveEngageLaravel\Models\Visitor;
use LivePersonInc\LiveEngageLaravel\Models\Agent;
use LivePersonInc\LiveEngageLaravel\Models\Campaign;
use LivePersonInc\LiveEngageLaravel\Models\Engagement;
use LivePersonInc\LiveEngageLaravel\Models\Conversation;
use LivePersonInc\LiveEngageLaravel\Collections\EngagementHistory;
use LivePersonInc\LiveEngageLaravel\Collections\Humans;
use LivePersonInc\LiveEngageLaravel\Exceptions\LiveEngageException;
use LivePersonInc\LiveEngageLaravel\Collections\ConversationHistory;

class LiveEngageLaravel
{
    private $account = false;
    private $results = [];
    private $skills = [];
    private $next = false;
    private $prev = false;
    private $start;
    private $end;
    private $config = 'services.liveperson.default';
    private $version = '1.0';
    private $history_limit = 50;
    private $history = false;
    private $context = 'interactionHistoryRecords';
    private $interactive = true;
    private $ended = true;
    private $bearer = false;

    private $domain = false;

    private $retry_limit = 5;
    private $retry_counter = 0;

    public function __get($attribute)
    {
        return $this->$attribute;
    }

    public function __set($attribute, $value)
    {
        return $this->$attribute = $value;
    }

    public function __construct()
    {
        $this->account = config("{$this->config}.account");
        //$this->domain = config("{$this->config}.domain");
        $this->version = config("{$this->config}.version") ?: $this->version;
    }

    public function key($key = 'default')
    {
        $this->config = "services.liveperson.$key";

        return $this;
    }
    
    public function nonInteractive()
    {
	    $this->interactive = false;
	    return $this;
    }
    
    public function active()
    {
	    $this->ended = false;
	    return $this;
    }

    public function limit($limit)
    {
        $this->history_limit = $limit;

        return $this;
    }

    public function skills($skills)
    {
        $this->skills = $skills;

        return $this;
    }

    public function retry($limit)
    {
        $this->retry_limit = $limit;

        return $this;
    }

    public function get()
    {
        return $this->results;
    }

    public function account($accountid)
    {
        $this->account = $accountid;

        return $this;
    }

    public function domain($service)
    {
        $response = $this->requestV1("https://api.liveperson.net/api/account/{$this->account}/service/{$service}/baseURI.json?version={$this->version}", 'GET');
        if (is_a($response, 'Exception')) {

It seems like $response can also be of type mixed; however, parameter $object of is_a() does only seem to accept object|string, maybe add an additional type check?

            throw new \Exception('Unable to get LivePerson account domain', 101);
        } else {
            $this->domain = $response->baseURI;

            return $this;
        }
    }

    public function visitor($visitorID, $sessionID, $setData = false)
    {
        $this->domain('smt');

        if ($setData) {
            $url = "https://{$this->domain}/api/account/{$this->account}/monitoring/visitors/{$visitorID}/visits/current/events?v=1&sid={$sessionID}";

            return $this->requestV1($url, 'POST', $setData);
        } else {
            $url = "https://{$this->domain}/api/account/{$this->account}/monitoring/visitors/{$visitorID}/visits/current/state?v=1&sid={$sessionID}";

            return $this->requestV1($url, 'GET');
        }
    }

    final public function retrieveHistory(Carbon $start, Carbon $end, $url = false)
    {
        $this->domain('engHistDomain');

        $url = $url ?: "https://{$this->domain}/interaction_history/api/account/{$this->account}/interactions/search?limit={$this->history_limit}&offset=0";

        $start_str = $start->toW3cString();
        $end_str = $end->toW3cString();

        $data = [
            'interactive' => $this->interactive,
            'ended' => $this->ended,
            'start' => [
                'from' => strtotime($start_str).'000',
                'to' => strtotime($end_str).'000',
            ],
        ];
        if (count($this->skills)) {
            $data['skillIds'] = $this->skills;
        }

        $data = new Payload($data);

        return $this->requestV1($url, 'POST', $data);
    }

    final public function retrieveMsgHistory(Carbon $start, Carbon $end, $url = false)
    {
        $this->domain('msgHist');

        $url = $url ?: "https://{$this->domain}/messaging_history/api/account/{$this->account}/conversations/search?limit={$this->history_limit}&offset=0";

        $start_str = $start->toW3cString();
        $end_str = $end->toW3cString();

        $data = [
            'interactive' => $this->interactive,
            'ended' => $this->ended,
            'start' => [
                'from' => strtotime($start_str).'000',
                'to' => strtotime($end_str).'000',
            ],
        ];
        if (count($this->skills)) {
            $data['skillIds'] = $this->skills;
        }

        $data = new Payload($data);

        return $this->requestV1($url, 'POST', $data);
    }
    
    public function getAgentStatus(array $skills)
    {
	
	    $this->domain('msgHist');
        
        $url = "https://{$this->domain}/messaging_history/api/account/{$this->account}/agent-view/status";
        
        $data['skillIds'] = $skills;

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

        
        $response = $this->requestV1($url, 'POST', $data);
        $agents = [];
        
        foreach ($response->agentStatusRecords as $agent) {

The property agentStatusRecords does not seem to exist on GuzzleHttp\Exception\ConnectException.

The property agentStatusRecords does not seem to exist on GuzzleHttp\Exception\ClientException.

	        $agents[] = new Agent((array) $agent);
        }
        
        $collection = new Humans($agents);
        $collection->metaData = $response->_metadata;

The property metaData does not seem to exist on LivePersonInc\LiveEngageLaravel\Collections\Humans.

The property _metadata does not seem to exist on GuzzleHttp\Exception\ClientException.

The property _metadata does not seem to exist on GuzzleHttp\Exception\ConnectException.

        
        return $collection;
        
    }

    public function messagingHistory(Carbon $start = null, Carbon $end = null)
    {
        $this->retry_counter = 0;

        $start = $start ?: (new Carbon())->today();
        $end = $end ?: (new Carbon())->today()->addHours(23)->addMinutes(59);

        $this->start = $start;
        $this->end = $end;

		if (is_object($results_object)) {

The variable $results_object does not exist. Did you maybe mean $results?

	        $results_object = $this->retrieveMsgHistory($start, $end);
	        $results = $results_object->conversationHistoryRecords;

The property conversationHistoryRecords does not seem to exist on GuzzleHttp\Exception\ConnectException.

The property conversationHistoryRecords does not seem to exist on GuzzleHttp\Exception\ClientException.

	        if (property_exists($results_object->_metadata, 'next')) {

The property _metadata does not seem to exist on GuzzleHttp\Exception\ConnectException.

The property _metadata does not seem to exist on GuzzleHttp\Exception\ClientException.

	            $this->next = $results_object->_metadata->next->href;
	        }
	        if (property_exists($results_object->_metadata, 'prev')) {
	            $this->prev = $results_object->_metadata->prev->href;
	        }
	
	        $history = [];
	        foreach ($results as $item) {
	            if (property_exists($item, 'info')) {
	                $item->info = new Info((array) $item->info);
	            }
	
	            if (property_exists($item, 'visitorInfo')) {
	                $item->visitorInfo = new Visitor((array) $item->visitorInfo);
	            }
	
	            if (property_exists($item, 'campaign')) {
	                $item->campaign = new Campaign((array) $item->campaign);
	            }
	
	            $history[] = new Conversation((array) $item);
	        }
	
	        $collection = new ConversationHistory($history, $this);
	        $collection->metaData = $results_object->_metadata;

The property metaData does not seem to exist on LivePersonInc\LiveEngageLaravel\Collections\ConversationHistory.

	        
	        return $collection;
	        
	    } else {
		    return false;
	    }
    }

    public function history(Carbon $start = null, Carbon $end = null)
    {
        $this->retry_counter = 0;

        $start = $start ?: (new Carbon())->today();
        $end = $end ?: (new Carbon())->today()->addHours(23)->addMinutes(59);

        $this->start = $start;
        $this->end = $end;

        $results_object = $this->retrieveHistory($start, $end);
        
        if (is_object($results_object)) {
        
	        $results = $results_object->interactionHistoryRecords;

The property interactionHistoryRecords does not seem to exist on GuzzleHttp\Exception\ClientException.

The property interactionHistoryRecords does not seem to exist on GuzzleHttp\Exception\ConnectException.

	        if (property_exists($results_object->_metadata, 'next')) {

The property _metadata does not seem to exist on GuzzleHttp\Exception\ClientException.

The property _metadata does not seem to exist on GuzzleHttp\Exception\ConnectException.

	            $this->next = $results_object->_metadata->next->href;
	        }
	        if (property_exists($results_object->_metadata, 'prev')) {
	            $this->prev = $results_object->_metadata->prev->href;
	        }
	
	        $history = [];
	        foreach ($results as $item) {
	            if (property_exists($item, 'info')) {
	                $item->info = new Info((array) $item->info);
	            }
	
	            if (property_exists($item, 'visitorInfo')) {
	                $item->visitorInfo = new Visitor((array) $item->visitorInfo);
	            }
	
	            if (property_exists($item, 'campaign')) {
	                $item->campaign = new Campaign((array) $item->campaign);
	            }
	
	            $history[] = new Engagement((array) $item);
	        }
	        
	        $collection = new EngagementHistory($history, $this);
	        $collection->metaData = $results_object->_metadata;

The property metaData does not seem to exist on LivePersonInc\LiveEngageLaravel\Collections\EngagementHistory.

	        
	        return $collection;
	        
        } else {
	        return false;
        }
    }
    
    public function login()
    {
	    $this->domain('agentVep');
	    
	    $consumer_key = config("{$this->config}.key");
        $consumer_secret = config("{$this->config}.secret");
        $token = config("{$this->config}.token");
        $secret = config("{$this->config}.token_secret");
        $username = config("{$this->config}.user_name");
        
        $auth = [
	        'username'          => $username,
            'appKey'            => $consumer_key,
            'secret'            => $consumer_secret,
            'accessToken'		=> $token,
            'accessTokenSecret' => $secret,
        ];
        
        $url = "https://{$this->domain}/api/account/{$this->account}/login?v=1.3";
        
        $response = $this->requestV1($url, 'POST', $auth);
        
        $this->bearer = $response->bearer;

The property bearer does not seem to exist on GuzzleHttp\Exception\ConnectException.

The property bearer does not seem to exist on GuzzleHttp\Exception\ClientException.

        
        return $this;
    }
    
    private function requestV2($url, $method, $payload = false)

The method requestV2() is not used, and could be removed.

    {
	    if (!$this->bearer) $this->login();
	    
	    $client = new Client();
	    $args = [
		    'headers' => [
			    'Authorization' => $this->bearer
		    ]
	    ];
	    
	    if ($payload !== false) {
            $args['body'] = json_encode($payload);
        }
	    
	    try {
		    $res = $client->request($method, $url, $args);
	    } catch (\Exception $e) {
		    throw $e;
	    } 
	    
	    return json_decode($res->getBody());
    }

    private function requestV1($url, $method, $payload = false)
    {
        $consumer_key = config("{$this->config}.key");
        $consumer_secret = config("{$this->config}.secret");
        $token = config("{$this->config}.token");
        $secret = config("{$this->config}.token_secret");

        $stack = HandlerStack::create();
        $auth = new Oauth1([
            'consumer_key'    => $consumer_key,
            'consumer_secret' => $consumer_secret,
            'token'           => $token,
            'token_secret'    => $secret,
            'signature_method'=> Oauth1::SIGNATURE_METHOD_HMAC,
        ]);
        $stack->push($auth);

        $client = new Client([
            'handler' => $stack,
        ]);

        $args = [
            'auth' => 'oauth',
            'headers' => [
                'content-type' => 'application/json',
            ],
        ];

        if ($payload !== false) {
            $args['body'] = json_encode($payload);
        }

        try {
            $res = $client->request($method, $url, $args);

            $response = json_decode($res->getBody());
        } catch (\GuzzleHttp\Exception\ConnectException $connection) {
            return $connection;
        } catch (\GuzzleHttp\Exception\ClientException $clientException) {
	        return $clientException;
        } catch (\Exception $e) {
            if ($this->retry_counter < $this->retry_limit || $this->retry_limit == -1) {
                usleep(1500);
                $this->retry_counter++;
                $response = $this->requestV1($url, $payload);
            } else {
                throw $e; //new LiveEngageException("Retry limit has been exceeded ($this->retry_limit)", 100);
            }
        }

        return $response;
    }
}