LPTracker - Code Metrics - Inspection of "Add contact fields methods" - lptracker/php-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f9d0ca...755fa4 )

unknown

created 2017-06-19 15:23 UTC

LPTracker B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	465
Duplicated Lines	32.47 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes

Metric	Value
wmc	50
lcom	1
cbo	10
dl	151
loc	465
rs	8.6206
c	0
b	0
f	0

17 Methods

Rating	Name	Duplication	Size	Complexity
B	login()	0	23	4
A	logout()	0	4	1
A	getProjectList()	11	11	2
A	getProject()	10	10	1
A	getProjectCustoms()	19	19	3
A	getProjectFields()	19	19	3
B	createContact()	8	38	5
A	saveContact()	19	19	3
B	editContact()	8	27	4
A	updateContactField()	0	21	3
B	createLead()	0	24	5
A	saveLead()	18	18	3
A	editLead()	0	9	1
A	getLeadComments()	19	19	3
A	addCommentToLead()	20	20	2
A	saveLeadCustom()	0	18	3
B	editLeadCustom()	0	26	4

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like LPTracker often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use LPTracker, and based on these observations, apply Extract Interface, too.

<?php

namespace LPTracker;

use LPTracker\models\Comment;
use LPTracker\models\Contact;
use LPTracker\models\ContactField;
use LPTracker\models\Custom;
use LPTracker\models\Lead;
use LPTracker\models\Project;
use LPTracker\exceptions\LPTrackerSDKException;
use LPTracker\authentication\AccessToken;

/**
 * Class LPTracker
 * @package LPTracker
 */
class LPTracker extends LPTrackerBase
{

    /**
     * @param        $login
     * @param        $password
     * @param string $serviceName
     *
     * @return AccessToken
     * @throws LPTrackerSDKException
     */
    public function login($login, $password, $serviceName = '')
    {
        if (empty($login)) {
            throw new LPTrackerSDKException('Login is empty');
        }
        if (empty($password)) {
            throw new LPTrackerSDKException('Password is empty');
        }
        if (empty($serviceName)) {
            $serviceName = LPTrackerBase::DEFAULT_SERVICE_NAME;
        }

        $response = LPTrackerRequest::sendRequest('/login', [
            'login'    => $login,
            'password' => $password,
            'service'  => $serviceName,
            'version'  => LPTrackerBase::VERSION
        ], 'POST', null, $this->address);

        $accessToken = new AccessToken($response['token']);

        return $accessToken;
    }


    /**
     *
     */
    public function logout()
    {
        LPTrackerRequest::sendRequest('/logout', [], 'POST', $this->token, $this->address);
    }


    /**
     * @return Project[]
     */
    public function getProjectList()

    {
        $response = LPTrackerRequest::sendRequest('/projects', [], 'GET', $this->token, $this->address);

        $result = [];
        foreach ($response as $projectData) {
            $result[] = new Project($projectData);
        }

        return $result;
    }


    /**
     * @param $id
     *
     * @return Project
     */
    public function getProject($id)

    {
        $url = '/project/'.$id;

        $response = LPTrackerRequest::sendRequest($url, [], 'GET', $this->token, $this->address);

        $project = new Project($response);

        return $project;
    }


    /**
     * @param $project
     *
     * @return Custom[]
     */
    public function getProjectCustoms($project)

    {
        if ($project instanceof Project) {
            $project = $project->getId();
        } else {
            $project = intval($project);
        }

        $url = '/project/'.$project.'/customs';

        $response = LPTrackerRequest::sendRequest($url, [], 'GET', $this->token, $this->address);

        $result = [];
        foreach ($response as $customData) {
            $result[] = new Custom($customData);
        }

        return $result;
    }


    /**
     * @param $project
     *
     * @return ContactField[]
     */
    public function getProjectFields($project)

    {
        if ($project instanceof Project) {
            $project = $project->getId();
        } else {
            $project = intval($project);
        }

        $url = '/project/'.$project.'/fields';

        $response = LPTrackerRequest::sendRequest($url, [], 'GET', $this->token, $this->address);

        $result = [];
        foreach ($response as $customData) {
            $result[] = new ContactField($customData);
        }

        return $result;
    }


    /**
     * @param       $project
     * @param array $details
     * @param array $contactData
     * @param array $fields
     *
     * @return Contact
     * @throws LPTrackerSDKException
     */
    public function createContact(
        $project,
        array $details,
        array $contactData = [],
        array $fields = []
    ) {
        if (empty($details)) {
            throw new LPTrackerSDKException('Contact details can not be empty');
        }

        if ($project instanceof Project) {
            $project = $project->getId();
        } else {
            $project = intval($project);
        }

        $contactData['project_id'] = $project;
        $contactData['details'] = $details;

        foreach ($fields as $fieldId => $fieldValue) {

            if ($fieldValue instanceof ContactField) {
                $fieldId = $fieldValue->getId();
                $fieldValue = $fieldValue->getValue();
            }

            $contactData['fields'][$fieldId] = $fieldValue;
        }

        $contact = new Contact($contactData);
        $contact->validate();

        $response = LPTrackerRequest::sendRequest('/contact', $contact->toArray(), 'POST', $this->token,
            $this->address);

        $resultContact = new Contact($response);

        return $resultContact;
    }


    /**
     * @param Contact $contact
     *
     * @return Contact
     * @throws LPTrackerSDKException
     */
    public function saveContact(Contact $contact)

    {
        if ( ! $contact->validate()) {
            throw new LPTrackerSDKException('Invalid contact');
        }

        if ($contact->getId() > 0) {
            $url = '/contact/'.$contact->getId();

            $response = LPTrackerRequest::sendRequest($url, $contact->toArray(), 'PUT', $this->token, $this->address);
        } else {
            $response = LPTrackerRequest::sendRequest('/contact', $contact->toArray(), 'POST', $this->token,
                $this->address);
        }

        $resultContact = new Contact($response);

        return $resultContact;
    }


    /**
     * @param       $contactId
     * @param array $details
     * @param array $contactData
     * @param array $fields
     *
     * @return Contact
     * @throws LPTrackerSDKException
     */
    public function editContact(
        $contactId,
        array $details,
        array $contactData = [],
        array $fields = []
    ) {
        if (empty($details)) {
            throw new LPTrackerSDKException('Contact details can not be empty');
        }

        $contactData['id'] = $contactId;
        $contactData['details'] = $details;

        foreach ($fields as $fieldId => $fieldValue) {

            if ($fieldValue instanceof ContactField) {
                $fieldId = $fieldValue->getId();
                $fieldValue = $fieldValue->getValue();
            }

            $contactData['fields'][$fieldId] = $fieldValue;
        }

        $contact = new Contact($contactData);
        $contact->validate();

        return $this->saveContact($contact);
    }


    /**
     * @param $contact
     * @param $field
     * @param $newValue
     *
     * @return ContactField
     */
    public function updateContactField($contact, $field, $newValue)
    {
        if ($contact instanceof Contact) {
            $contact = $contact->getId();
        }
        if ($field instanceof ContactField) {
            $field = $field->getId();
        }

        $url = '/contact/'.$contact.'/field/'.$field;

        $data = [
            'value' => $newValue
        ];

        $response = LPTrackerRequest::sendRequest($url, $data, 'PUT', $this->token, $this->address);

        $contactField = new ContactField($response);

        return $contactField;
    }


    /**
     * @param       $contact
     * @param array $leadData
     * @param array $options
     *
     * @return Lead
     * @throws LPTrackerSDKException
     */
    public function createLead($contact, array $leadData = [], array $options = [])
    {
        if ($contact instanceof Contact) {
            $leadData['contact_id'] = $contact->getId();
        } else {
            $leadData['contact_id'] = intval($contact);
        }

        $lead = new Lead($leadData);
        if ( ! $lead->validate()) {
            throw new LPTrackerSDKException('Invalid lead data');
        }

        $data = $lead->toArray();
        if (isset($options['callback'])) {
            $data['callback'] = $options['callback'] ? true : false;
        }

        $response = LPTrackerRequest::sendRequest('/lead', $data, 'POST', $this->token, $this->address);

        $resultLead = new Lead($response);

        return $resultLead;
    }


    /**
     * @param Lead $lead
     *
     * @return Lead
     * @throws LPTrackerSDKException
     */
    public function saveLead(Lead $lead)

    {
        if ( ! $lead->validate()) {
            throw new LPTrackerSDKException('Invalid lead');
        }

        if ($lead->getId() > 0) {
            $url = '/lead/'.$lead->getId();

            $response = LPTrackerRequest::sendRequest($url, $lead->toArray(), 'PUT', $this->token, $this->address);
        } else {
            $response = LPTrackerRequest::sendRequest('/lead', $lead->toArray(), 'POST', $this->token, $this->address);
        }

        $resultLead = new Lead($response);

        return $resultLead;
    }


    /**
     * @param       $leadId
     * @param array $leadData
     *
     * @return Lead
     */
    public function editLead($leadId, array $leadData = [])
    {
        $leadData['id'] = $leadId;

        $lead = new Lead($leadData);
        $lead->validate();

        return $this->saveLead($lead);
    }


    /**
     * @param $lead
     *
     * @return Comment[]
     */
    public function getLeadComments($lead)

    {
        if ($lead instanceof Lead) {
            $lead = $lead->getId();
        } else {
            $lead = intval($lead);
        }

        $url = '/lead/'.$lead.'/comments';

        $response = LPTrackerRequest::sendRequest($url, [], 'GET', $this->token, $this->address);

        $result = [];
        foreach ($response as $commentData) {
            $result[] = new Comment($commentData);
        }

        return $result;
    }


    /**
     * @param $lead
     * @param $text
     *
     * @return Comment
     */
    public function addCommentToLead($lead, $text)

    {
        if ($lead instanceof Lead) {
            $lead = $lead->getId();
        } else {
            $lead = intval($lead);
        }

        $url = '/lead/'.$lead.'/comment';

        $data = [
            'text' => $text
        ];

        $response = LPTrackerRequest::sendRequest($url, $data, 'POST', $this->token, $this->address);

        $comment = new Comment($response);

        return $comment;
    }


    /**
     * @param Custom $custom
     *
     * @return Custom
     * @throws LPTrackerSDKException
     */
    public function saveLeadCustom(Custom $custom)
    {
        if ( ! $custom->validate() || empty($custom->getLeadId())) {
            throw new LPTrackerSDKException('Invalid custom');
        }

        $url = '/lead/'.$custom->getLeadId().'/custom/'.$custom->getId();

        $data = [
            'value' => $custom->getValue()
        ];

        $response = LPTrackerRequest::sendRequest($url, $data, 'PUT', $this->token, $this->address);

        $resultCustom = new Custom($response);

        return $resultCustom;
    }


    /**
     * @param $lead
     * @param $custom
     * @param $newValue
     *
     * @return Custom
     */
    public function editLeadCustom($lead, $custom, $newValue)
    {
        if ($lead instanceof Lead) {
            $lead = $lead->getId();
        } else {
            $lead = intval($lead);
        }

        if ($custom instanceof Custom) {
            if (empty($newValue)) {
                $newValue = $custom->getValue();
            }
            $custom = $custom->getId();
        } else {
            $custom = intval($custom);
        }

        $customModel = new Custom([
            'id'      => $custom,
            'lead_id' => $lead,
            'value'   => $newValue
        ]);
        $customModel->validate();

        return $this->saveLeadCustom($customModel);
    }
}

1		<?php
2
3		namespace LPTracker;
4
5		use LPTracker\models\Comment;
6		use LPTracker\models\Contact;
7		use LPTracker\models\ContactField;
8		use LPTracker\models\Custom;
9		use LPTracker\models\Lead;
10		use LPTracker\models\Project;
11		use LPTracker\exceptions\LPTrackerSDKException;
12		use LPTracker\authentication\AccessToken;
13
14		/**
15		* Class LPTracker
16		* @package LPTracker
17		*/
18		class LPTracker extends LPTrackerBase
19		{
20
21		/**
22		* @param $login
23		* @param $password
24		* @param string $serviceName
25		*
26		* @return AccessToken
27		* @throws LPTrackerSDKException
28		*/
29		public function login($login, $password, $serviceName = '')
30		{
31		if (empty($login)) {
32		throw new LPTrackerSDKException('Login is empty');
33		}
34		if (empty($password)) {
35		throw new LPTrackerSDKException('Password is empty');
36		}
37		if (empty($serviceName)) {
38		$serviceName = LPTrackerBase::DEFAULT_SERVICE_NAME;
39		}
40
41		$response = LPTrackerRequest::sendRequest('/login', [
42		'login' => $login,
43		'password' => $password,
44		'service' => $serviceName,
45		'version' => LPTrackerBase::VERSION
46		], 'POST', null, $this->address);
47
48		$accessToken = new AccessToken($response['token']);
49
50		return $accessToken;
51		}
52
53
54		/**
55		*
56		*/
57		public function logout()
58		{
59		LPTrackerRequest::sendRequest('/logout', [], 'POST', $this->token, $this->address);
60		}
61
62
63		/**
64		* @return Project[]
65		*/
66	View Code Duplication	public function getProjectList()
		0 ignored issues – show Duplication introduced 2017-06-01 11:30 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
67		{
68		$response = LPTrackerRequest::sendRequest('/projects', [], 'GET', $this->token, $this->address);
69
70		$result = [];
71		foreach ($response as $projectData) {
72		$result[] = new Project($projectData);
73		}
74
75		return $result;
76		}
77
78
79		/**
80		* @param $id
81		*
82		* @return Project
83		*/
84	View Code Duplication	public function getProject($id)
		0 ignored issues – show Duplication introduced 2017-06-01 11:30 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
85		{
86		$url = '/project/'.$id;
87
88		$response = LPTrackerRequest::sendRequest($url, [], 'GET', $this->token, $this->address);
89
90		$project = new Project($response);
91
92		return $project;
93		}
94
95
96		/**
97		* @param $project
98		*
99		* @return Custom[]
100		*/
101	View Code Duplication	public function getProjectCustoms($project)
		0 ignored issues – show Duplication introduced 2017-06-01 11:30 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
102		{
103		if ($project instanceof Project) {
104		$project = $project->getId();
105		} else {
106		$project = intval($project);
107		}
108
109		$url = '/project/'.$project.'/customs';
110
111		$response = LPTrackerRequest::sendRequest($url, [], 'GET', $this->token, $this->address);
112
113		$result = [];
114		foreach ($response as $customData) {
115		$result[] = new Custom($customData);
116		}
117
118		return $result;
119		}
120
121
122		/**
123		* @param $project
124		*
125		* @return ContactField[]
126		*/
127	View Code Duplication	public function getProjectFields($project)
		0 ignored issues – show Duplication introduced 2017-06-19 15:25 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
128		{
129		if ($project instanceof Project) {
130		$project = $project->getId();
131		} else {
132		$project = intval($project);
133		}
134
135		$url = '/project/'.$project.'/fields';
136
137		$response = LPTrackerRequest::sendRequest($url, [], 'GET', $this->token, $this->address);
138
139		$result = [];
140		foreach ($response as $customData) {
141		$result[] = new ContactField($customData);
142		}
143
144		return $result;
145		}
146
147
148		/**
149		* @param $project
150		* @param array $details
151		* @param array $contactData
152		* @param array $fields
153		*
154		* @return Contact
155		* @throws LPTrackerSDKException
156		*/
157		public function createContact(
158		$project,
159		array $details,
160		array $contactData = [],
161		array $fields = []
162		) {
163		if (empty($details)) {
164		throw new LPTrackerSDKException('Contact details can not be empty');
165		}
166
167		if ($project instanceof Project) {
168		$project = $project->getId();
169		} else {
170		$project = intval($project);
171		}
172
173		$contactData['project_id'] = $project;
174		$contactData['details'] = $details;
175
176	View Code Duplication	foreach ($fields as $fieldId => $fieldValue) {
		0 ignored issues – show Duplication introduced 2017-06-19 15:25 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
177		if ($fieldValue instanceof ContactField) {
178		$fieldId = $fieldValue->getId();
179		$fieldValue = $fieldValue->getValue();
180		}
181
182		$contactData['fields'][$fieldId] = $fieldValue;
183		}
184
185		$contact = new Contact($contactData);
186		$contact->validate();
187
188		$response = LPTrackerRequest::sendRequest('/contact', $contact->toArray(), 'POST', $this->token,
189		$this->address);
190
191		$resultContact = new Contact($response);
192
193		return $resultContact;
194		}
195
196
197		/**
198		* @param Contact $contact
199		*
200		* @return Contact
201		* @throws LPTrackerSDKException
202		*/
203	View Code Duplication	public function saveContact(Contact $contact)
		0 ignored issues – show Duplication introduced 2017-06-01 11:30 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
204		{
205		if ( ! $contact->validate()) {
206		throw new LPTrackerSDKException('Invalid contact');
207		}
208
209		if ($contact->getId() > 0) {
210		$url = '/contact/'.$contact->getId();
211
212		$response = LPTrackerRequest::sendRequest($url, $contact->toArray(), 'PUT', $this->token, $this->address);
213		} else {
214		$response = LPTrackerRequest::sendRequest('/contact', $contact->toArray(), 'POST', $this->token,
215		$this->address);
216		}
217
218		$resultContact = new Contact($response);
219
220		return $resultContact;
221		}
222
223
224		/**
225		* @param $contactId
226		* @param array $details
227		* @param array $contactData
228		* @param array $fields
229		*
230		* @return Contact
231		* @throws LPTrackerSDKException
232		*/
233		public function editContact(
234		$contactId,
235		array $details,
236		array $contactData = [],
237		array $fields = []
238		) {
239		if (empty($details)) {
240		throw new LPTrackerSDKException('Contact details can not be empty');
241		}
242
243		$contactData['id'] = $contactId;
244		$contactData['details'] = $details;
245
246	View Code Duplication	foreach ($fields as $fieldId => $fieldValue) {
		0 ignored issues – show Duplication introduced 2017-06-19 15:25 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
247		if ($fieldValue instanceof ContactField) {
248		$fieldId = $fieldValue->getId();
249		$fieldValue = $fieldValue->getValue();
250		}
251
252		$contactData['fields'][$fieldId] = $fieldValue;
253		}
254
255		$contact = new Contact($contactData);
256		$contact->validate();
257
258		return $this->saveContact($contact);
259		}
260
261
262		/**
263		* @param $contact
264		* @param $field
265		* @param $newValue
266		*
267		* @return ContactField
268		*/
269		public function updateContactField($contact, $field, $newValue)
270		{
271		if ($contact instanceof Contact) {
272		$contact = $contact->getId();
273		}
274		if ($field instanceof ContactField) {
275		$field = $field->getId();
276		}
277
278		$url = '/contact/'.$contact.'/field/'.$field;
279
280		$data = [
281		'value' => $newValue
282		];
283
284		$response = LPTrackerRequest::sendRequest($url, $data, 'PUT', $this->token, $this->address);
285
286		$contactField = new ContactField($response);
287
288		return $contactField;
289		}
290
291
292		/**
293		* @param $contact
294		* @param array $leadData
295		* @param array $options
296		*
297		* @return Lead
298		* @throws LPTrackerSDKException
299		*/
300		public function createLead($contact, array $leadData = [], array $options = [])
301		{
302		if ($contact instanceof Contact) {
303		$leadData['contact_id'] = $contact->getId();
304		} else {
305		$leadData['contact_id'] = intval($contact);
306		}
307
308		$lead = new Lead($leadData);
309		if ( ! $lead->validate()) {
310		throw new LPTrackerSDKException('Invalid lead data');
311		}
312
313		$data = $lead->toArray();
314		if (isset($options['callback'])) {
315		$data['callback'] = $options['callback'] ? true : false;
316		}
317
318		$response = LPTrackerRequest::sendRequest('/lead', $data, 'POST', $this->token, $this->address);
319
320		$resultLead = new Lead($response);
321
322		return $resultLead;
323		}
324
325
326		/**
327		* @param Lead $lead
328		*
329		* @return Lead
330		* @throws LPTrackerSDKException
331		*/
332	View Code Duplication	public function saveLead(Lead $lead)
		0 ignored issues – show Duplication introduced 2017-06-01 11:30 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
333		{
334		if ( ! $lead->validate()) {
335		throw new LPTrackerSDKException('Invalid lead');
336		}
337
338		if ($lead->getId() > 0) {
339		$url = '/lead/'.$lead->getId();
340
341		$response = LPTrackerRequest::sendRequest($url, $lead->toArray(), 'PUT', $this->token, $this->address);
342		} else {
343		$response = LPTrackerRequest::sendRequest('/lead', $lead->toArray(), 'POST', $this->token, $this->address);
344		}
345
346		$resultLead = new Lead($response);
347
348		return $resultLead;
349		}
350
351
352		/**
353		* @param $leadId
354		* @param array $leadData
355		*
356		* @return Lead
357		*/
358		public function editLead($leadId, array $leadData = [])
359		{
360		$leadData['id'] = $leadId;
361
362		$lead = new Lead($leadData);
363		$lead->validate();
364
365		return $this->saveLead($lead);
366		}
367
368
369		/**
370		* @param $lead
371		*
372		* @return Comment[]
373		*/
374	View Code Duplication	public function getLeadComments($lead)
		0 ignored issues – show Duplication introduced 2017-06-01 11:30 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
375		{
376		if ($lead instanceof Lead) {
377		$lead = $lead->getId();
378		} else {
379		$lead = intval($lead);
380		}
381
382		$url = '/lead/'.$lead.'/comments';
383
384		$response = LPTrackerRequest::sendRequest($url, [], 'GET', $this->token, $this->address);
385
386		$result = [];
387		foreach ($response as $commentData) {
388		$result[] = new Comment($commentData);
389		}
390
391		return $result;
392		}
393
394
395		/**
396		* @param $lead
397		* @param $text
398		*
399		* @return Comment
400		*/
401	View Code Duplication	public function addCommentToLead($lead, $text)
		0 ignored issues – show Duplication introduced 2017-06-01 11:30 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
402		{
403		if ($lead instanceof Lead) {
404		$lead = $lead->getId();
405		} else {
406		$lead = intval($lead);
407		}
408
409		$url = '/lead/'.$lead.'/comment';
410
411		$data = [
412		'text' => $text
413		];
414
415		$response = LPTrackerRequest::sendRequest($url, $data, 'POST', $this->token, $this->address);
416
417		$comment = new Comment($response);
418
419		return $comment;
420		}
421
422
423		/**
424		* @param Custom $custom
425		*
426		* @return Custom
427		* @throws LPTrackerSDKException
428		*/
429		public function saveLeadCustom(Custom $custom)
430		{
431		if ( ! $custom->validate() \|\| empty($custom->getLeadId())) {
432		throw new LPTrackerSDKException('Invalid custom');
433		}
434
435		$url = '/lead/'.$custom->getLeadId().'/custom/'.$custom->getId();
436
437		$data = [
438		'value' => $custom->getValue()
439		];
440
441		$response = LPTrackerRequest::sendRequest($url, $data, 'PUT', $this->token, $this->address);
442
443		$resultCustom = new Custom($response);
444
445		return $resultCustom;
446		}
447
448
449		/**
450		* @param $lead
451		* @param $custom
452		* @param $newValue
453		*
454		* @return Custom
455		*/
456		public function editLeadCustom($lead, $custom, $newValue)
457		{
458		if ($lead instanceof Lead) {
459		$lead = $lead->getId();
460		} else {
461		$lead = intval($lead);
462		}
463
464		if ($custom instanceof Custom) {
465		if (empty($newValue)) {
466		$newValue = $custom->getValue();
467		}
468		$custom = $custom->getId();
469		} else {
470		$custom = intval($custom);
471		}
472
473		$customModel = new Custom([
474		'id' => $custom,
475		'lead_id' => $lead,
476		'value' => $newValue
477		]);
478		$customModel->validate();
479
480		return $this->saveLeadCustom($customModel);
481		}
482		}

lptracker / php-sdk

GitHub Access Token became invalid