ClientLocal::updateEntry() - Code Metrics - Inspection of "add update entry method" - directus/directus-sdk-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — d64 ( e3735b...c39f80 )

by Welling

created 2016-11-01 22:31 UTC

ClientLocal::updateEntry() A

↳ Parent: ClientLocal

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	3
dl	0
loc	7
ccs	0
cts	0
cp	0
crap	2
rs	9.4285
c	0
b	0
f	0

<?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;
use Directus\SDK\Response\EntryCollection;
use Directus\SDK\Response\Entry;
use Zend\Db\Sql\Select;

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

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

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

    /**
     * Gets the list of tables name in the database
     *
     * @param array $params
     *
     * @return array
     */
    public function getTables(array $params = [])
    {
        return TableSchema::getTablesSchema($params);
    }

    /**
     * Gets all the columns in the database
     *
     * @param array $params
     *
     * @return array
     */
    public function getColumns(array $params = [])
    {
        return TableSchema::getColumnsSchema($params);
    }

    /**
     * Gets table columns
     *
     * @param $tableName
     * @param array $params
     *
     * @return \Directus\Database\Object\Column[]
     */
    public function getTableColumns($tableName, array $params = [])
    {
        $tables = TableSchema::getTableColumnsSchema($tableName, $params);


        return $tables;
    }

    /**
     * Gets all the entries in the given table name
     *
     * @param string $tableName
     * @param array $params
     *
     * @return Entry|EntryCollection
     */
    public function getEntries($tableName, array $params = [])
    {
        $tableGateway = $this->getTableGateway($tableName);

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

    /**
     * Gets an entry in the given table name with the given id
     *
     * @param string $tableName
     * @param mixed $id
     * @param array $params
     *
     * @return array|mixed
     */
    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
        ]));
    }

    /**
     * Gets the list of users
     *
     * @param array $params
     *
     * @return array|mixed
     */
    public function getUsers(array $params = [])
    {
        // @TODO: store the directus tables somewhere (SchemaManager?)
        return $this->getEntries('directus_users', $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());
}
    }

    /**
     * Gets an user by the given id
     *
     * @param $id
     * @param array $params
     *
     * @return array|mixed
     */
    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 fetchTables()
    {
        // TODO: Implement fetchTables() method.
    }

    /**
     * @inheritDoc
     */
    public function fetchTableInfo($tableName)
    {
        // TODO: Implement fetchTableInfo() method.
    }

    /**
     * @inheritDoc
     */
    public function fetchColumns($tableName)

    {
        // TODO: Implement fetchColumns() method.
    }

    /**
     * @inheritDoc
     */
    public function fetchColumnInfo($tableName, $columnName)
    {
        // TODO: Implement fetchColumnInfo() method.
    }

    /**
     * @inheritDoc
     */
    public function fetchItems($tableName = null, $conditions = [])
    {
        if ($tableName == null) {
            $tableName = $this->getTable();

        }

        $select = new Select($tableName);

        // Conditional to honor the active column, (does not check if column exists)
        if (isset($conditions['active'])) {
            $select->where->equalTo('active', $conditions['active']);
        }

        // Order by "id desc" by default or by a parameter value
        if (isset($conditions['sort'])) {
            $select->order($conditions['sort']);
        }

        return $this->selectWith($select);

    }

    /**
     * @inheritDoc
     */
    public function fetchItem($tableName, $itemID)

    {
        // TODO: Implement fetchItem() method.
    }

    /**
     * @inheritDoc
     */
    public function fetchGroups()
    {
        // TODO: Implement fetchGroups() method.
    }

    /**
     * @inheritDoc
     */
    public function fetchGroupInfo($groupID)
    {
        // TODO: Implement fetchGroupInfo() method.
    }

    /**
     * @inheritDoc
     */
    public function fetchGroupPrivileges($groupID)
    {
        // TODO: Implement fetchGroupPrivileges() method.
    }

    /**
     * @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);
    }

    /**
     * @inheritDoc
     */
    public function fetchSettings()
    {
        // TODO: Implement fetchSettings() method.
    }

    /**
     * @inheritDoc
     */
    public function fetchSettingCollection($collectionName)
    {
        // TODO: Implement fetchSettingCollection() method.
    }

    /**
     * @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);
        $newRecord = $tableGateway->manageRecordUpdate($tableName, $data);

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

    }

    /**
     * @inheritDoc
     */
    public function updateEntry($tableName, $id, array $data)
    {
        $tableGateway = $this->getTableGateway($tableName);
        $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);
        });
    }

    /**
     * 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];
    }

    // @TODO: move to a builder class
    protected function createResponseFromData($data)
    {
        if (isset($data['rows'])) {
            $response = new EntryCollection($data);
        } else {
            $response = new Entry($data);
        }

        return $response;
    }
}


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			use Directus\SDK\Response\EntryCollection;
19			use Directus\SDK\Response\Entry;
20			use Zend\Db\Sql\Select;
21
22			/**
23			* Client Local
24			*
25			* Client to Interact with the database directly using Directus Database Component
26			*
27			* @author Welling Guzmán <[email protected]>
28			*/
29			class ClientLocal implements RequestsInterface
30			{
31			/**
32			* @var BaseTableGateway[]
33			*/
34			protected $tableGateways = [];
35
36			/**
37			* @var Connection
38			*/
39			protected $connection = null;
40
41			/**
42			* ClientLocal constructor.
43			*
44			* @param $connection
45			*/
46			public function __construct($connection)
47			{
48			$this->connection = $connection;
49			}
50
51			/**
52			* Gets the list of tables name in the database
53			*
54			* @param array $params
55			*
56			* @return array
57			*/
58			public function getTables(array $params = [])
59			{
60			return TableSchema::getTablesSchema($params);
61			}
62
63			/**
64			* Gets all the columns in the database
65			*
66			* @param array $params
67			*
68			* @return array
69			*/
70			public function getColumns(array $params = [])
71			{
72			return TableSchema::getColumnsSchema($params);
73			}
74
75			/**
76			* Gets table columns
77			*
78			* @param $tableName
79			* @param array $params
80			*
81			* @return \Directus\Database\Object\Column[]
82			*/
83			public function getTableColumns($tableName, array $params = [])
84			{
85			$tables = TableSchema::getTableColumnsSchema($tableName, $params);
			0 ignored issues – show Bug introduced 2016-10-19 21:21 UTC by Report Bug Copy Issue Report The method `getTableColumnsSchema()` does not exist on `Directus\Database\TableSchema`. Did you maybe mean `getTable()`? This check marks calls to methods that do not seem to exist on an object. This is most likely the result of a method being renamed without all references to it being renamed likewise. Loading history...
86
87			return $tables;
88			}
89
90			/**
91			* Gets all the entries in the given table name
92			*
93			* @param string $tableName
94			* @param array $params
95			*
96			* @return Entry\|EntryCollection
97			*/
98			public function getEntries($tableName, array $params = [])
99			{
100			$tableGateway = $this->getTableGateway($tableName);
101
102			return $this->createResponseFromData($tableGateway->getEntries($params));
103			}
104
105			/**
106			* Gets an entry in the given table name with the given id
107			*
108			* @param string $tableName
109			* @param mixed $id
110			* @param array $params
111			*
112			* @return array\|mixed
113			*/
114			public function getEntry($tableName, $id, array $params = [])
115			{
116			// @TODO: Dynamic ID
117			return $this->getEntries($tableName, array_merge($params, [
			0 ignored issues – show Bug Best Practice introduced 2016-10-22 01:08 UTC by Report Bug Copy Issue Report The return type of `return $this->getEntries..., array('id' => $id)));` (`Directus\SDK\Response\En...esponse\EntryCollection`) is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getEntry` of type `array`. 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...
118			'id' => $id
119			]));
120			}
121
122			/**
123			* Gets the list of users
124			*
125			* @param array $params
126			*
127			* @return array\|mixed
128			*/
129			public function getUsers(array $params = [])
130			{
131			// @TODO: store the directus tables somewhere (SchemaManager?)
132			return $this->getEntries('directus_users', $params);
			0 ignored issues – show Bug Best Practice introduced 2016-10-31 20:05 UTC by Report Bug Copy Issue Report The return type of `return $this->getEntries...ectus_users', $params);` (`Directus\SDK\Response\En...esponse\EntryCollection`) is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getUsers` of type `array`. 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...
133			}
134
135			/**
136			* Gets an user by the given id
137			*
138			* @param $id
139			* @param array $params
140			*
141			* @return array\|mixed
142			*/
143			public function getUser($id, array $params = [])
144			{
145			return $this->getEntry('directus_users', $id, $params);
			0 ignored issues – show Bug Best Practice introduced 2016-10-22 01:08 UTC by Report Bug Copy Issue Report The return type of `return $this->getEntry('..._users', $id, $params);` (`Directus\SDK\Response\En...esponse\EntryCollection`) is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getUser` of type `array`. 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...
146			}
147
148			/**
149			* @inheritDoc
150			*/
151			public function fetchTables()
152			{
153			// TODO: Implement fetchTables() method.
154			}
155
156			/**
157			* @inheritDoc
158			*/
159			public function fetchTableInfo($tableName)
160			{
161			// TODO: Implement fetchTableInfo() method.
162			}
163
164			/**
165			* @inheritDoc
166			*/
167			public function fetchColumns($tableName)
			0 ignored issues – show Unused Code introduced 2016-10-19 21:21 UTC by Report Bug Copy Issue Report The parameter `$tableName` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
168			{
169			// TODO: Implement fetchColumns() method.
170			}
171
172			/**
173			* @inheritDoc
174			*/
175			public function fetchColumnInfo($tableName, $columnName)
176			{
177			// TODO: Implement fetchColumnInfo() method.
178			}
179
180			/**
181			* @inheritDoc
182			*/
183			public function fetchItems($tableName = null, $conditions = [])
184			{
185			if ($tableName == null) {
186			$tableName = $this->getTable();
			0 ignored issues – show Bug introduced 2016-10-19 21:21 UTC by Report Bug Copy Issue Report The method `getTable()` does not exist on `Directus\SDK\ClientLocal`. Did you maybe mean `getTables()`? This check marks calls to methods that do not seem to exist on an object. This is most likely the result of a method being renamed without all references to it being renamed likewise. Loading history...
187			}
188
189			$select = new Select($tableName);
190
191			// Conditional to honor the active column, (does not check if column exists)
192			if (isset($conditions['active'])) {
193			$select->where->equalTo('active', $conditions['active']);
194			}
195
196			// Order by "id desc" by default or by a parameter value
197			if (isset($conditions['sort'])) {
198			$select->order($conditions['sort']);
199			}
200
201			return $this->selectWith($select);
			0 ignored issues – show Bug introduced 2016-10-17 02:28 UTC by Report Bug Copy Issue Report The method `selectWith()` does not seem to exist on `object<Directus\SDK\ClientLocal>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
202			}
203
204			/**
205			* @inheritDoc
206			*/
207			public function fetchItem($tableName, $itemID)
			0 ignored issues – show Unused Code introduced 2016-10-17 02:28 UTC by Report Bug Copy Issue Report The parameter `$tableName` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2016-10-17 02:28 UTC by Report Bug Copy Issue Report The parameter `$itemID` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
208			{
209			// TODO: Implement fetchItem() method.
210			}
211
212			/**
213			* @inheritDoc
214			*/
215			public function fetchGroups()
216			{
217			// TODO: Implement fetchGroups() method.
218			}
219
220			/**
221			* @inheritDoc
222			*/
223			public function fetchGroupInfo($groupID)
224			{
225			// TODO: Implement fetchGroupInfo() method.
226			}
227
228			/**
229			* @inheritDoc
230			*/
231			public function fetchGroupPrivileges($groupID)
232			{
233			// TODO: Implement fetchGroupPrivileges() method.
234			}
235
236			/**
237			* @inheritDoc
238			*/
239			public function getFiles(array $params = [])
240			{
241			return $this->getEntries('directus_files', $params);
242			}
243
244			/**
245			* @inheritDoc
246			*/
247			public function getFile($id, array $params = [])
248			{
249			return $this->getEntry('directus_files', $id, $params);
250			}
251
252			/**
253			* @inheritDoc
254			*/
255			public function fetchSettings()
256			{
257			// TODO: Implement fetchSettings() method.
258			}
259
260			/**
261			* @inheritDoc
262			*/
263			public function fetchSettingCollection($collectionName)
264			{
265			// TODO: Implement fetchSettingCollection() method.
266			}
267
268			/**
269			* @inheritDoc
270			*/
271			public function getMessages($userId)
272			{
273			$messagesTableGateway = new DirectusMessagesTableGateway($this->connection, null);
			0 ignored issues – show Documentation introduced 2016-11-01 06:08 UTC by Report Bug Copy Issue Report `null` is of type `null`, but the function expects a `object<Directus\Acl\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...
274			$result = $messagesTableGateway->fetchMessagesInboxWithHeaders($userId);
275
276			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 276 which is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::getMessages` of type `Directus\SDK\Response\EntryCollection`. Loading history...
277			}
278
279			/**
280			* @inheritDoc
281			*/
282			public function createEntry($tableName, array $data)
283			{
284			$tableGateway = $this->getTableGateway($tableName);
285			$newRecord = $tableGateway->manageRecordUpdate($tableName, $data);
286
287			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 287 which is incompatible with the return type declared by the interface `Directus\SDK\RequestsInterface::createEntry` of type `Directus\SDK\Response\Entry`. Loading history...
288			}
289
290			/**
291			* @inheritDoc
292			*/
293			public function updateEntry($tableName, $id, array $data)
294			{
295			$tableGateway = $this->getTableGateway($tableName);
296			$record = $tableGateway->manageRecordUpdate($tableName, array_merge($data, ['id' => $id]));
297
298			return $this->createResponseFromData($record->toArray());
299			}
300
301			/**
302			* @inheritDoc
303			*/
304			public function deleteEntry($tableName, $ids)
305			{
306			// @TODO: Accept EntryCollection and Entry
307			$tableGateway = $this->getTableGateway($tableName);
308
309			if (!is_array($ids)) {
310			$ids = [$ids];
311			}
312
313			return $tableGateway->delete(function($delete) use ($ids) {
314			return $delete->where->in('id', $ids);
315			});
316			}
317
318			/**
319			* Get a table gateway for the given table name
320			*
321			* @param $tableName
322			*
323			* @return RelationalTableGateway
324			*/
325			protected function getTableGateway($tableName)
326			{
327			if (!array_key_exists($tableName, $this->tableGateways)) {
328			$acl = TableSchema::getAclInstance();
329			$this->tableGateways[$tableName] = new RelationalTableGateway($tableName, $this->connection, $acl);
330			}
331
332			return $this->tableGateways[$tableName];
333			}
334
335			// @TODO: move to a builder class
336			protected function createResponseFromData($data)
337			{
338			if (isset($data['rows'])) {
339			$response = new EntryCollection($data);
340			} else {
341			$response = new Entry($data);
342			}
343
344			return $response;
345			}
346			}
347

directus / directus-sdk-php

Push — d64 ( e3735b...c39f80 )

ClientLocal::updateEntry() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like