ClientLocal - Code Metrics - Inspection of "add activity endpoint helper" - directus/directus-sdk-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — d64 ( 6654da...3ef1d3 )

by Welling

created 2016-11-23 10:23 UTC

ClientLocal A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	281
Duplicated Lines	5.69 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

Importance

Changes

Metric	Value
dl	16
loc	281
ccs	0
cts	140
cp	0
rs	10
c	0
b	0
f	0
wmc	30
lcom	1
cbo	4

28 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getTables()	0	4	1
A	getTable()	0	4	1
A	getColumns()	0	4	1
A	getColumn()	0	4	1
A	getEntries()	0	6	1
A	getEntry()	0	7	1
A	getUsers()	0	5	1
A	getUser()	0	4	1
A	getGroups()	0	4	1
A	getGroup()	0	4	1
A	getGroupPrivileges()	0	8	1
A	getFiles()	0	4	1
A	getFile()	0	4	1
A	getSettings()	0	4	1
A	getSettingsByCollection()	0	8	1
A	getMessages()	0	7	1
A	createEntry()	8	8	1
A	updateEntry()	8	8	1
A	deleteEntry()	0	13	2
A	createUser()	0	4	1
A	updateUser()	0	4	1
A	deleteUser()	0	4	1
A	createFile()	0	4	1
A	updateFile()	0	4	1
A	deleteFile()	0	4	1
A	createActivity()	0	4	1
A	getTableGateway()	0	9	2

How to fix Duplicated Code

<?php

/**
 * Directus – <http://getdirectus.com>
 *
 * @link      The canonical repository – <https://github.com/directus/directus>
 * @copyright Copyright 2006-2016 RANGER Studio, LLC – <http://rangerstudio.com>
 * @license   GNU General Public License (v3) – <http://www.gnu.org/copyleft/gpl.html>
 */

namespace Directus\SDK;

use Directus\Database\Connection;
use Directus\Database\TableGateway\BaseTableGateway;
use Directus\Database\TableGateway\DirectusMessagesTableGateway;
use Directus\Database\TableGateway\RelationalTableGateway;
use Directus\Database\TableSchema;

/**
 * Client Local
 *
 * Client to Interact with the database directly using Directus Database Component
 *
 * @author Welling Guzmán <[email protected]>
 */
class ClientLocal extends AbstractClient
{
    /**
     * @var BaseTableGateway[]
     */
    protected $tableGateways = [];

    /**
     * @var Connection
     */
    protected $connection = null;

    /**
     * ClientLocal constructor.
     *
     * @param $connection
     */
    public function __construct($connection)
    {
        $this->connection = $connection;
    }

    /**
     * @inheritDoc
     */
    public function getTables(array $params = [])
    {
        return $this->createResponseFromData(TableSchema::getTablesSchema($params));

    }

    /**
     * @inheritDoc
     */
    public function getTable($tableName)
    {
        return $this->createResponseFromData(TableSchema::getSchemaArray($tableName));

    }

    /**
     * @inheritDoc
     */
    public function getColumns($tableName, array $params = [])
    {
        return $this->createResponseFromData(TableSchema::getColumnSchemaArray($tableName, $params));

    }

    /**
     * @inheritDoc
     */
    public function getColumn($tableName, $columnName)
    {
        return $this->createResponseFromData(TableSchema::getColumnSchemaArray($tableName, $columnName));

    }

    /**
     * @inheritDoc
     */
    public function getEntries($tableName, array $params = [])
    {
        $tableGateway = $this->getTableGateway($tableName);

        return $this->createResponseFromData($tableGateway->getEntries($params));

    }

    /**
     * @inheritDoc
     */
    public function getEntry($tableName, $id, array $params = [])
    {
        // @TODO: Dynamic ID
        return $this->getEntries($tableName, array_merge($params, [
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
            'id' => $id
        ]));
    }

    /**
     * @inheritDoc
     */
    public function getUsers(array $params = [])
    {
        // @TODO: store the directus tables somewhere (SchemaManager?)
        return $this->getEntries('directus_users', $params);
    }

    /**
     * @inheritDoc
     */
    public function getUser($id, array $params = [])
    {
        return $this->getEntry('directus_users', $id, $params);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * @inheritDoc
     */
    public function getGroups(array $params = [])
    {
        return $this->getEntries('directus_groups', $params);
    }

    /**
     * @inheritDoc
     */
    public function getGroup($id, array $params = [])
    {
        return $this->getEntry('directus_groups', $id, $params);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * @inheritDoc
     */
    public function getGroupPrivileges($groupID)
    {
        $this->getEntries('directus_privileges', [
            'filter' => [
                'group_id' => ['eq' => $groupID]
            ]
        ]);
    }

    /**
     * @inheritDoc
     */
    public function getFiles(array $params = [])
    {
        return $this->getEntries('directus_files', $params);
    }

    /**
     * @inheritDoc
     */
    public function getFile($id, array $params = [])
    {
        return $this->getEntry('directus_files', $id, $params);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * @inheritDoc
     */
    public function getSettings()
    {
        return $this->getEntries('directus_settings');
    }

    /**
     * @inheritDoc
     */
    public function getSettingsByCollection($collectionName)
    {
        return $this->getEntries('directus_settings', [
            'filter' => [
                'collection' => ['eq' => $collectionName]
            ]
        ]);
    }

    /**
     * @inheritDoc
     */
    public function getMessages($userId)
    {
        $messagesTableGateway = new DirectusMessagesTableGateway($this->connection, null);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $result = $messagesTableGateway->fetchMessagesInboxWithHeaders($userId);

        return $this->createResponseFromData($result);

    }

    /**
     * @inheritDoc
     */
    public function createEntry($tableName, array $data)

    {
        $tableGateway = $this->getTableGateway($tableName);
        $data = $this->parseData($tableName, $data);
        $newRecord = $tableGateway->manageRecordUpdate($tableName, $data);

        return $this->createResponseFromData($newRecord->toArray());

    }

    /**
     * @inheritDoc
     */
    public function updateEntry($tableName, $id, array $data)

    {
        $tableGateway = $this->getTableGateway($tableName);
        $data = $this->parseData($tableName, $data);
        $record = $tableGateway->manageRecordUpdate($tableName, array_merge($data, ['id' => $id]));

        return $this->createResponseFromData($record->toArray());
    }

    /**
     * @inheritDoc
     */
    public function deleteEntry($tableName, $ids)
    {
        // @TODO: Accept EntryCollection and Entry
        $tableGateway = $this->getTableGateway($tableName);

        if (!is_array($ids)) {
            $ids = [$ids];
        }

        return $tableGateway->delete(function($delete) use ($ids) {
            return $delete->where->in('id', $ids);
        });
    }

    /**
     * @inheritDoc
     */
    public function createUser(array $data)
    {
        return $this->createEntry('directus_users', $data);
    }

    /**
     * @inheritDoc
     */
    public function updateUser($id, array $data)
    {
        return $this->updateEntry('directus_users', $id, $data);
    }

    /**
     * @inheritDoc
     */
    public function deleteUser($ids)
    {
        return $this->deleteEntry('directus_users', $ids);
    }

    /**
     * @inheritDoc
     */
    public function createFile(array $data)
    {
        return $this->createEntry('directus_files', $data);
    }

    /**
     * @inheritDoc
     */
    public function updateFile($id, array $data)
    {
        return $this->updateEntry('directus_files', $id, $data);
    }

    /**
     * @inheritDoc
     */
    public function deleteFile($ids)
    {
        return $this->deleteEntry('directus_files', $ids);
    }

    /**
     * @inheritdoc
     */
    public function createActivity($data)
    {
        return $this->createEntry('directus_activity', $data);
    }

    /**
     * Get a table gateway for the given table name
     *
     * @param $tableName
     *
     * @return RelationalTableGateway
     */
    protected function getTableGateway($tableName)
    {
        if (!array_key_exists($tableName, $this->tableGateways)) {
            $acl = TableSchema::getAclInstance();
            $this->tableGateways[$tableName] = new RelationalTableGateway($tableName, $this->connection, $acl);
        }

        return $this->tableGateways[$tableName];
    }
}


1		<?php
2
3		/**
4		* Directus – <http://getdirectus.com>
5		*
6		* @link The canonical repository – <https://github.com/directus/directus>
7		* @copyright Copyright 2006-2016 RANGER Studio, LLC – <http://rangerstudio.com>
8		* @license GNU General Public License (v3) – <http://www.gnu.org/copyleft/gpl.html>
9		*/
10
11		namespace Directus\SDK;
12
13		use Directus\Database\Connection;
14		use Directus\Database\TableGateway\BaseTableGateway;
15		use Directus\Database\TableGateway\DirectusMessagesTableGateway;
16		use Directus\Database\TableGateway\RelationalTableGateway;
17		use Directus\Database\TableSchema;
18
19		/**
20		* Client Local
21		*
22		* Client to Interact with the database directly using Directus Database Component
23		*
24		* @author Welling Guzmán <[email protected]>
25		*/
26		class ClientLocal extends AbstractClient
27		{
28		/**
29		* @var BaseTableGateway[]
30		*/
31		protected $tableGateways = [];
32
33		/**
34		* @var Connection
35		*/
36		protected $connection = null;
37
38		/**
39		* ClientLocal constructor.
40		*
41		* @param $connection
42		*/
43		public function __construct($connection)
44		{
45		$this->connection = $connection;
46		}
47
48		/**
49		* @inheritDoc
50		*/
51		public function getTables(array $params = [])
52		{
53		return $this->createResponseFromData(TableSchema::getTablesSchema($params));
		0 ignored issues – show Bug Compatibility introduced 2016-11-02 21:37 UTC by Report Bug Copy Issue Report The expression `$this->createResponseFro...TablesSchema($params));` of type `Directus\SDK\Response\En...ctus\SDK\Response\Entry` adds the type `Directus\SDK\Response\Entry` to the return on line 53 which is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getTables` of type `Directus\SDK\Response\EntryCollection`. Loading history...
54		}
55
56		/**
57		* @inheritDoc
58		*/
59		public function getTable($tableName)
60		{
61		return $this->createResponseFromData(TableSchema::getSchemaArray($tableName));
		0 ignored issues – show Bug Compatibility introduced 2016-11-02 21:37 UTC by Report Bug Copy Issue Report The expression `$this->createResponseFro...hemaArray($tableName));` of type `Directus\SDK\Response\En...ctus\SDK\Response\Entry` adds the type `Directus\SDK\Response\EntryCollection` to the return on line 61 which is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getTable` of type `Directus\SDK\Response\Entry`. Loading history...
62		}
63
64		/**
65		* @inheritDoc
66		*/
67		public function getColumns($tableName, array $params = [])
68		{
69		return $this->createResponseFromData(TableSchema::getColumnSchemaArray($tableName, $params));
		0 ignored issues – show Bug Compatibility introduced 2016-11-02 22:04 UTC by Report Bug Copy Issue Report The expression `$this->createResponseFro...($tableName, $params));` of type `Directus\SDK\Response\En...ctus\SDK\Response\Entry` adds the type `Directus\SDK\Response\Entry` to the return on line 69 which is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getColumns` of type `Directus\SDK\Response\EntryCollection`. Loading history...
70		}
71
72		/**
73		* @inheritDoc
74		*/
75		public function getColumn($tableName, $columnName)
76		{
77		return $this->createResponseFromData(TableSchema::getColumnSchemaArray($tableName, $columnName));
		0 ignored issues – show Bug Compatibility introduced 2016-11-02 21:37 UTC by Report Bug Copy Issue Report The expression `$this->createResponseFro...bleName, $columnName));` of type `Directus\SDK\Response\En...ctus\SDK\Response\Entry` adds the type `Directus\SDK\Response\EntryCollection` to the return on line 77 which is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getColumn` of type `Directus\SDK\Response\Entry`. Loading history...
78		}
79
80		/**
81		* @inheritDoc
82		*/
83		public function getEntries($tableName, array $params = [])
84		{
85		$tableGateway = $this->getTableGateway($tableName);
86
87		return $this->createResponseFromData($tableGateway->getEntries($params));
		0 ignored issues – show Bug Compatibility introduced 2016-11-02 21:37 UTC by Report Bug Copy Issue Report The expression `$this->createResponseFro...->getEntries($params));` of type `Directus\SDK\Response\En...ctus\SDK\Response\Entry` adds the type `Directus\SDK\Response\Entry` to the return on line 87 which is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getEntries` of type `Directus\SDK\Response\EntryCollection`. Loading history...
88		}
89
90		/**
91		* @inheritDoc
92		*/
93		public function getEntry($tableName, $id, array $params = [])
94		{
95		// @TODO: Dynamic ID
96		return $this->getEntries($tableName, array_merge($params, [
		0 ignored issues – show Bug Best Practice introduced 2016-11-02 21:37 UTC by Report Bug Copy Issue Report The return type of `return $this->getEntries..., array('id' => $id)));` (`Directus\SDK\Response\EntryCollection`) is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getEntry` of type `Directus\SDK\Response\Entry`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
97		'id' => $id
98		]));
99		}
100
101		/**
102		* @inheritDoc
103		*/
104		public function getUsers(array $params = [])
105		{
106		// @TODO: store the directus tables somewhere (SchemaManager?)
107		return $this->getEntries('directus_users', $params);
108		}
109
110		/**
111		* @inheritDoc
112		*/
113		public function getUser($id, array $params = [])
114		{
115		return $this->getEntry('directus_users', $id, $params);
		0 ignored issues – show Bug Best Practice introduced 2016-11-02 21:37 UTC by Report Bug Copy Issue Report The return type of `return $this->getEntry('..._users', $id, $params);` (`Directus\SDK\Response\EntryCollection`) is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getUser` of type `Directus\SDK\Response\Entry`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
116		}
117
118		/**
119		* @inheritDoc
120		*/
121		public function getGroups(array $params = [])
122		{
123		return $this->getEntries('directus_groups', $params);
124		}
125
126		/**
127		* @inheritDoc
128		*/
129		public function getGroup($id, array $params = [])
130		{
131		return $this->getEntry('directus_groups', $id, $params);
		0 ignored issues – show Bug Best Practice introduced 2016-11-02 21:37 UTC by Report Bug Copy Issue Report The return type of `return $this->getEntry('...groups', $id, $params);` (`Directus\SDK\Response\EntryCollection`) is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getGroup` of type `Directus\SDK\Response\Entry`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
132		}
133
134		/**
135		* @inheritDoc
136		*/
137		public function getGroupPrivileges($groupID)
138		{
139		$this->getEntries('directus_privileges', [
140		'filter' => [
141		'group_id' => ['eq' => $groupID]
142		]
143		]);
144		}
145
146		/**
147		* @inheritDoc
148		*/
149		public function getFiles(array $params = [])
150		{
151		return $this->getEntries('directus_files', $params);
152		}
153
154		/**
155		* @inheritDoc
156		*/
157		public function getFile($id, array $params = [])
158		{
159		return $this->getEntry('directus_files', $id, $params);
		0 ignored issues – show Bug Best Practice introduced 2016-11-02 21:37 UTC by Report Bug Copy Issue Report The return type of `return $this->getEntry('..._files', $id, $params);` (`Directus\SDK\Response\EntryCollection`) is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getFile` of type `Directus\SDK\Response\Entry`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
160		}
161
162		/**
163		* @inheritDoc
164		*/
165		public function getSettings()
166		{
167		return $this->getEntries('directus_settings');
168		}
169
170		/**
171		* @inheritDoc
172		*/
173		public function getSettingsByCollection($collectionName)
174		{
175		return $this->getEntries('directus_settings', [
176		'filter' => [
177		'collection' => ['eq' => $collectionName]
178		]
179		]);
180		}
181
182		/**
183		* @inheritDoc
184		*/
185		public function getMessages($userId)
186		{
187		$messagesTableGateway = new DirectusMessagesTableGateway($this->connection, null);
		0 ignored issues – show Documentation introduced 2016-11-17 02:00 UTC by Report Bug Copy Issue Report `null` is of type `null`, but the function expects a `object<Directus\Permissions\Acl>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
188		$result = $messagesTableGateway->fetchMessagesInboxWithHeaders($userId);
189
190		return $this->createResponseFromData($result);
		0 ignored issues – show Bug Compatibility introduced 2016-11-01 06:08 UTC by Report Bug Copy Issue Report The expression `$this->createResponseFromData($result);` of type `Directus\SDK\Response\En...ctus\SDK\Response\Entry` adds the type `Directus\SDK\Response\Entry` to the return on line 190 which is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getMessages` of type `Directus\SDK\Response\EntryCollection`. Loading history...
191		}
192
193		/**
194		* @inheritDoc
195		*/
196	View Code Duplication	public function createEntry($tableName, array $data)
		0 ignored issues – show Duplication introduced 2016-11-21 02:02 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...
197		{
198		$tableGateway = $this->getTableGateway($tableName);
199		$data = $this->parseData($tableName, $data);
200		$newRecord = $tableGateway->manageRecordUpdate($tableName, $data);
201
202		return $this->createResponseFromData($newRecord->toArray());
		0 ignored issues – show Bug Compatibility introduced 2016-11-01 21:59 UTC by Report Bug Copy Issue Report The expression `$this->createResponseFro...$newRecord->toArray());` of type `Directus\SDK\Response\En...ctus\SDK\Response\Entry` adds the type `Directus\SDK\Response\EntryCollection` to the return on line 202 which is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::createEntry` of type `Directus\SDK\Response\Entry`. Loading history...
203		}
204
205		/**
206		* @inheritDoc
207		*/
208	View Code Duplication	public function updateEntry($tableName, $id, array $data)
		0 ignored issues – show Duplication introduced 2016-11-21 02:02 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...
209		{
210		$tableGateway = $this->getTableGateway($tableName);
211		$data = $this->parseData($tableName, $data);
212		$record = $tableGateway->manageRecordUpdate($tableName, array_merge($data, ['id' => $id]));
213
214		return $this->createResponseFromData($record->toArray());
215		}
216
217		/**
218		* @inheritDoc
219		*/
220		public function deleteEntry($tableName, $ids)
221		{
222		// @TODO: Accept EntryCollection and Entry
223		$tableGateway = $this->getTableGateway($tableName);
224
225		if (!is_array($ids)) {
226		$ids = [$ids];
227		}
228
229		return $tableGateway->delete(function($delete) use ($ids) {
230		return $delete->where->in('id', $ids);
231		});
232		}
233
234		/**
235		* @inheritDoc
236		*/
237		public function createUser(array $data)
238		{
239		return $this->createEntry('directus_users', $data);
240		}
241
242		/**
243		* @inheritDoc
244		*/
245		public function updateUser($id, array $data)
246		{
247		return $this->updateEntry('directus_users', $id, $data);
248		}
249
250		/**
251		* @inheritDoc
252		*/
253		public function deleteUser($ids)
254		{
255		return $this->deleteEntry('directus_users', $ids);
256		}
257
258		/**
259		* @inheritDoc
260		*/
261		public function createFile(array $data)
262		{
263		return $this->createEntry('directus_files', $data);
264		}
265
266		/**
267		* @inheritDoc
268		*/
269		public function updateFile($id, array $data)
270		{
271		return $this->updateEntry('directus_files', $id, $data);
272		}
273
274		/**
275		* @inheritDoc
276		*/
277		public function deleteFile($ids)
278		{
279		return $this->deleteEntry('directus_files', $ids);
280		}
281
282		/**
283		* @inheritdoc
284		*/
285		public function createActivity($data)
286		{
287		return $this->createEntry('directus_activity', $data);
288		}
289
290		/**
291		* Get a table gateway for the given table name
292		*
293		* @param $tableName
294		*
295		* @return RelationalTableGateway
296		*/
297		protected function getTableGateway($tableName)
298		{
299		if (!array_key_exists($tableName, $this->tableGateways)) {
300		$acl = TableSchema::getAclInstance();
301		$this->tableGateways[$tableName] = new RelationalTableGateway($tableName, $this->connection, $acl);
302		}
303
304		return $this->tableGateways[$tableName];
305		}
306		}
307

directus / directus-sdk-php

Push — d64 ( 6654da...3ef1d3 )

ClientLocal A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

28 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like