MemoryDAO::setMemoryForRelease() - Code Metrics - atari-legend/legacy - Measure and Improve Code Quality continuously with Scrutinizer

MemoryDAO::setMemoryForRelease() A
last analyzed 2024-03-07 17:20 UTC

↳ Parent: MemoryDAO

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	6
nc	1
nop	3
dl	0
loc	10
rs	10
c	0
b	0
f	0

<?php
namespace AL\Common\DAO;

require_once __DIR__."/../../lib/Db.php" ;
require_once __DIR__."/../Model/Game/Memory.php" ;
require_once __DIR__."/../Model/Game/Enhancement.php" ;

/**
 * DAO for memory
 */
class MemoryDAO {
    private $mysqli;

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

    /**
     * Get all memory amounts
     *
     * @return \AL\Common\Model\Game\Memory[] An array of memory amounts
     */
    public function getAllMemory() {
        $stmt = \AL\Db\execute_query(
            "MemoryDAO: getAllMemory",
            $this->mysqli,
            "SELECT id, name FROM memory ORDER BY name",
            null, null
        );

        \AL\Db\bind_result(
            "MemoryDAO: getAllMemory",
            $stmt,
            $id, $memory

        );

        $memory_all = [];
        while ($stmt->fetch()) {
            $memory_all[] = new \AL\Common\Model\Game\Memory(
                $id, $memory, null
            );
        }

        $stmt->close();

        return $memory_all;
    }

    /**
     * Get list of memory IDs for a game release
     *
     * @param integer release ID
filter:
    dependency_paths: ["lib/*"]
     */
    public function getMemoryForRelease($release_id) {
        $stmt = \AL\Db\execute_query(
            "MemoryDAO: getMemoryForRelease",
            $this->mysqli,
            "SELECT memory_id, memory.name, enhancement.id, enhancement.name
            FROM game_release_memory_enhanced LEFT JOIN
            memory ON (game_release_memory_enhanced.memory_id = memory.id)
            LEFT JOIN enhancement ON (game_release_memory_enhanced.enhancement_id = enhancement.id)
            WHERE release_id = ?",
            "i", $release_id
        );

        \AL\Db\bind_result(
            "MemoryDAO: getMemoryForRelease",
            $stmt,
            $memory_id, $memory, $enhancement_id, $enhancement

        );

        $memory_linked = [];
        while ($stmt->fetch()) {
            $memory_linked[] = new \AL\Common\Model\Game\Memory(
                $memory_id, $memory,
                ($enhancement_id != null)
                    ? new \AL\Common\Model\Game\Enhancement($enhancement_id, $enhancement)
                    : null
            );
        }

        $stmt->close();

        return $memory_linked;
    }

    /**
     * Set the list of memory enhancements for this release
     *
     * @param integer release ID
     * @param integer[] List of memory IDs
filter:
    dependency_paths: ["lib/*"]
     */
    public function setMemoryForRelease($release_id, $memory_id, $enhancement_id) {

        $stmt = \AL\Db\execute_query(
            "MemoryDAO: setMemoryForRelease",
            $this->mysqli,
            "INSERT INTO game_release_memory_enhanced (release_id, memory_id, enhancement_id) VALUES (?, ?, ?)",
            "iis", $release_id, $memory_id, $enhancement_id
        );

        $stmt->close();
    }

     /**
     * Update enhancement for memory
     *
     * @param integer Game Release ID
     * @param integer memory ID
     */
    public function updateMemoryForRelease($game_release_id, $memory_id, $enhancement_id) {
        $stmt = \AL\Db\execute_query(
            "MemoryDAO: UpdateMemoryForRelease",
            $this->mysqli,
            "UPDATE game_release_memory_enhanced
            SET
                `enhancement_id` = ?
            WHERE release_id = ? AND memory_id = ?",
            "sii", $enhancement_id, $game_release_id, $memory_id
        );

        $stmt->close();
    }


         /**
     * Delete Memory enhancement for release
     *
     * @param integer Game Release ID
     * @param integer memory ID
     */
    public function deleteMemoryForRelease($game_release_id, $memory_id) {
        $stmt = \AL\Db\execute_query(
            "MemoryDAO: DeleteMemoryForRelease",
            $this->mysqli,
            "DELETE FROM game_release_memory_enhanced
            WHERE release_id = ? AND memory_id = ?",
            "ii", $game_release_id, $memory_id
        );

        $stmt->close();
    }

    /**
     * Get list of minimum memory IDs for a game release
     *
     * @param integer release ID
     */
    public function getMinimumMemoryForRelease($release_id) {
        $stmt = \AL\Db\execute_query(
            "MemoryDAO: getMinimumMemoryForRelease",
            $this->mysqli,
            "SELECT memory_id, name
            FROM game_release_memory_minimum LEFT JOIN
            memory ON (game_release_memory_minimum.memory_id = memory.id)
            WHERE release_id = ?",
            "i", $release_id
        );

        \AL\Db\bind_result(
            "MemoryDAO: getMinimumMemoryForRelease",
            $stmt,
            $memory_id, $memory

        );

        $memory_linked = [];
        while ($stmt->fetch()) {
            $memory_linked[] = new \AL\Common\Model\Game\Memory(
                $memory_id, $memory, null
            );
        }

        $stmt->close();

        return $memory_linked;
    }

    /**
     * Set the list of minimum memory for this release
     *
     * @param integer release ID
     * @param integer[] List of memory IDs
     */
    public function setMinimumMemoryForRelease($release_id, $memory_id) {

        $stmt = \AL\Db\execute_query(
            "MemoryDAO: setMinimumMemoryForRelease",
            $this->mysqli,
            "INSERT INTO game_release_memory_minimum (release_id, memory_id) VALUES (?, ?)",
            "ii", $release_id, $memory_id
        );

        $stmt->close();
    }

    /**
     * Delete minimum memory for release
     *
     * @param integer Game Release ID
     * @param integer memory ID
     */
    public function deleteMinimumMemoryForRelease($game_release_id, $memory_id) {
        $stmt = \AL\Db\execute_query(
            "MemoryDAO: deleteMinimumMemoryForRelease",
            $this->mysqli,
            "DELETE FROM game_release_memory_minimum
            WHERE release_id = ? and memory_id = ?",
            "ii", $game_release_id, $memory_id
        );

        $stmt->close();
    }

     /**
     * Get list of incompatible memory IDs for a game release
     *
     * @param integer release ID
     */
    public function getMemoryIncompatibleForRelease($release_id) {
        $stmt = \AL\Db\execute_query(
            "MemoryDAO: getMemoryIncompatibleForRelease",
            $this->mysqli,
            "SELECT memory_id, name
            FROM game_release_memory_incompatible LEFT JOIN
            memory ON (game_release_memory_incompatible.memory_id = memory.id)
            WHERE release_id = ?",
            "i", $release_id
        );

        \AL\Db\bind_result(
            "MemoryDAO: getMemoryIncompatibleForRelease",
            $stmt,
            $memory_id, $memory

        );

        $memory_linked = [];
        while ($stmt->fetch()) {
            $memory_linked[] = new \AL\Common\Model\Game\Memory(
                $memory_id, $memory, null
            );
        }

        $stmt->close();

        return $memory_linked;
    }

    /**
     * Set the list of incompatible memory for this release
     *
     * @param integer release ID
     * @param integer[] List of memory IDs
     */
    public function setMemoryIncompatibleForRelease($release_id, $memory_id) {

        $stmt = \AL\Db\execute_query(
            "MemoryDAO: setMemoryIncompatibleForRelease",
            $this->mysqli,
            "INSERT INTO game_release_memory_incompatible (release_id, memory_id) VALUES (?, ?)",
            "ii", $release_id, $memory_id
        );

        $stmt->close();
    }

         /**
     * Delete incompatible memory for release
     *
     * @param integer Game Release ID
     * @param integer memory ID
     */
    public function deleteMemoryIncompatibleForRelease($game_release_id, $memory_id) {
        $stmt = \AL\Db\execute_query(
            "MemoryDAO: deleteMemoryIncompatibleForRelease",
            $this->mysqli,
            "DELETE FROM game_release_memory_incompatible
            WHERE release_id = ? and memory_id = ?",
            "ii", $game_release_id, $memory_id
        );

        $stmt->close();
    }

     /**
     * add a memory amount to the database
     *
     * @param varchar memory
     */
    public function addMemory($memory) {
        $stmt = \AL\Db\execute_query(
            "MemoryDAO: addMemory",
            $this->mysqli,
            "INSERT INTO memory (`name`) VALUES (?)",
            "s", $memory
        );

        $stmt->close();
    }

    /**
     * delete a $memory amount
     *
     * @param int $memory_id
     */
    public function deleteMemory($memory_id) {
        $stmt = \AL\Db\execute_query(
            "MemoryDAO: deleteMemory",
            $this->mysqli,
            "DELETE FROM memory WHERE id = ?",
            "i", $memory_id
        );

        $stmt->close();
    }

        /**
     * update a memory amount
     *
     * @param int memory_id
filter:
    dependency_paths: ["lib/*"]
     * @param varchar memory_memory
filter:
    dependency_paths: ["lib/*"]
     */
    public function updateMemory($memory_id, $memory) {
        $stmt = \AL\Db\execute_query(
            "MemoryDAO: updateMemory",
            $this->mysqli,
            "UPDATE memory SET name = ? WHERE id = ?",
            "si", $memory, $memory_id
        );

        $stmt->close();
    }
}


1			<?php
2			namespace AL\Common\DAO;
3
4			require_once __DIR__."/../../lib/Db.php" ;
5			require_once __DIR__."/../Model/Game/Memory.php" ;
6			require_once __DIR__."/../Model/Game/Enhancement.php" ;
7
8			/**
9			* DAO for memory
10			*/
11			class MemoryDAO {
12			private $mysqli;
13
14			public function __construct($mysqli) {
15			$this->mysqli = $mysqli;
16			}
17
18			/**
19			* Get all memory amounts
20			*
21			* @return \AL\Common\Model\Game\Memory[] An array of memory amounts
22			*/
23			public function getAllMemory() {
24			$stmt = \AL\Db\execute_query(
25			"MemoryDAO: getAllMemory",
26			$this->mysqli,
27			"SELECT id, name FROM memory ORDER BY name",
28			null, null
29			);
30
31			\AL\Db\bind_result(
32			"MemoryDAO: getAllMemory",
33			$stmt,
34			$id, $memory
			0 ignored issues – show Comprehensibility Best Practice introduced 2020-12-06 16:57 UTC by Report Bug Copy Issue Report The variable `$memory` does not exist. Did you maybe mean `$memory_all`? Loading history...
35			);
36
37			$memory_all = [];
38			while ($stmt->fetch()) {
39			$memory_all[] = new \AL\Common\Model\Game\Memory(
40			$id, $memory, null
41			);
42			}
43
44			$stmt->close();
45
46			return $memory_all;
47			}
48
49			/**
50			* Get list of memory IDs for a game release
51			*
52			* @param integer release ID
			0 ignored issues – show Bug introduced 2020-12-06 16:57 UTC by Report Bug Copy Issue Report The type `AL\Common\DAO\release` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
53			*/
54			public function getMemoryForRelease($release_id) {
55			$stmt = \AL\Db\execute_query(
56			"MemoryDAO: getMemoryForRelease",
57			$this->mysqli,
58			"SELECT memory_id, memory.name, enhancement.id, enhancement.name
59			FROM game_release_memory_enhanced LEFT JOIN
60			memory ON (game_release_memory_enhanced.memory_id = memory.id)
61			LEFT JOIN enhancement ON (game_release_memory_enhanced.enhancement_id = enhancement.id)
62			WHERE release_id = ?",
63			"i", $release_id
64			);
65
66			\AL\Db\bind_result(
67			"MemoryDAO: getMemoryForRelease",
68			$stmt,
69			$memory_id, $memory, $enhancement_id, $enhancement
			0 ignored issues – show Comprehensibility Best Practice introduced 2020-12-06 16:57 UTC by Report Bug Copy Issue Report The variable `$enhancement_id` seems to be never defined. Loading history... Comprehensibility Best Practice introduced 2020-12-06 16:57 UTC by Report Bug Copy Issue Report The variable `$enhancement` seems to be never defined. Loading history... Comprehensibility Best Practice introduced 2020-12-06 16:57 UTC by Report Bug Copy Issue Report The variable `$memory` does not exist. Did you maybe mean `$memory_linked`? Loading history...
70			);
71
72			$memory_linked = [];
73			while ($stmt->fetch()) {
74			$memory_linked[] = new \AL\Common\Model\Game\Memory(
75			$memory_id, $memory,
76			($enhancement_id != null)
77			? new \AL\Common\Model\Game\Enhancement($enhancement_id, $enhancement)
78			: null
79			);
80			}
81
82			$stmt->close();
83
84			return $memory_linked;
85			}
86
87			/**
88			* Set the list of memory enhancements for this release
89			*
90			* @param integer release ID
91			* @param integer[] List of memory IDs
			0 ignored issues – show Bug introduced 2020-12-06 16:57 UTC by Report Bug Copy Issue Report The type `AL\Common\DAO\List` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
92			*/
93			public function setMemoryForRelease($release_id, $memory_id, $enhancement_id) {
94
95			$stmt = \AL\Db\execute_query(
96			"MemoryDAO: setMemoryForRelease",
97			$this->mysqli,
98			"INSERT INTO game_release_memory_enhanced (release_id, memory_id, enhancement_id) VALUES (?, ?, ?)",
99			"iis", $release_id, $memory_id, $enhancement_id
100			);
101
102			$stmt->close();
103			}
104
105			/**
106			* Update enhancement for memory
107			*
108			* @param integer Game Release ID
109			* @param integer memory ID
110			*/
111			public function updateMemoryForRelease($game_release_id, $memory_id, $enhancement_id) {
112			$stmt = \AL\Db\execute_query(
113			"MemoryDAO: UpdateMemoryForRelease",
114			$this->mysqli,
115			"UPDATE game_release_memory_enhanced
116			SET
117			`enhancement_id` = ?
118			WHERE release_id = ? AND memory_id = ?",
119			"sii", $enhancement_id, $game_release_id, $memory_id
120			);
121
122			$stmt->close();
123			}
124
125
126			/**
127			* Delete Memory enhancement for release
128			*
129			* @param integer Game Release ID
130			* @param integer memory ID
131			*/
132			public function deleteMemoryForRelease($game_release_id, $memory_id) {
133			$stmt = \AL\Db\execute_query(
134			"MemoryDAO: DeleteMemoryForRelease",
135			$this->mysqli,
136			"DELETE FROM game_release_memory_enhanced
137			WHERE release_id = ? AND memory_id = ?",
138			"ii", $game_release_id, $memory_id
139			);
140
141			$stmt->close();
142			}
143
144			/**
145			* Get list of minimum memory IDs for a game release
146			*
147			* @param integer release ID
148			*/
149			public function getMinimumMemoryForRelease($release_id) {
150			$stmt = \AL\Db\execute_query(
151			"MemoryDAO: getMinimumMemoryForRelease",
152			$this->mysqli,
153			"SELECT memory_id, name
154			FROM game_release_memory_minimum LEFT JOIN
155			memory ON (game_release_memory_minimum.memory_id = memory.id)
156			WHERE release_id = ?",
157			"i", $release_id
158			);
159
160			\AL\Db\bind_result(
161			"MemoryDAO: getMinimumMemoryForRelease",
162			$stmt,
163			$memory_id, $memory
			0 ignored issues – show Comprehensibility Best Practice introduced 2020-12-06 16:57 UTC by Report Bug Copy Issue Report The variable `$memory` does not exist. Did you maybe mean `$memory_linked`? Loading history...
164			);
165
166			$memory_linked = [];
167			while ($stmt->fetch()) {
168			$memory_linked[] = new \AL\Common\Model\Game\Memory(
169			$memory_id, $memory, null
170			);
171			}
172
173			$stmt->close();
174
175			return $memory_linked;
176			}
177
178			/**
179			* Set the list of minimum memory for this release
180			*
181			* @param integer release ID
182			* @param integer[] List of memory IDs
183			*/
184			public function setMinimumMemoryForRelease($release_id, $memory_id) {
185
186			$stmt = \AL\Db\execute_query(
187			"MemoryDAO: setMinimumMemoryForRelease",
188			$this->mysqli,
189			"INSERT INTO game_release_memory_minimum (release_id, memory_id) VALUES (?, ?)",
190			"ii", $release_id, $memory_id
191			);
192
193			$stmt->close();
194			}
195
196			/**
197			* Delete minimum memory for release
198			*
199			* @param integer Game Release ID
200			* @param integer memory ID
201			*/
202			public function deleteMinimumMemoryForRelease($game_release_id, $memory_id) {
203			$stmt = \AL\Db\execute_query(
204			"MemoryDAO: deleteMinimumMemoryForRelease",
205			$this->mysqli,
206			"DELETE FROM game_release_memory_minimum
207			WHERE release_id = ? and memory_id = ?",
208			"ii", $game_release_id, $memory_id
209			);
210
211			$stmt->close();
212			}
213
214			/**
215			* Get list of incompatible memory IDs for a game release
216			*
217			* @param integer release ID
218			*/
219			public function getMemoryIncompatibleForRelease($release_id) {
220			$stmt = \AL\Db\execute_query(
221			"MemoryDAO: getMemoryIncompatibleForRelease",
222			$this->mysqli,
223			"SELECT memory_id, name
224			FROM game_release_memory_incompatible LEFT JOIN
225			memory ON (game_release_memory_incompatible.memory_id = memory.id)
226			WHERE release_id = ?",
227			"i", $release_id
228			);
229
230			\AL\Db\bind_result(
231			"MemoryDAO: getMemoryIncompatibleForRelease",
232			$stmt,
233			$memory_id, $memory
			0 ignored issues – show Comprehensibility Best Practice introduced 2020-12-06 16:57 UTC by Report Bug Copy Issue Report The variable `$memory` does not exist. Did you maybe mean `$memory_linked`? Loading history...
234			);
235
236			$memory_linked = [];
237			while ($stmt->fetch()) {
238			$memory_linked[] = new \AL\Common\Model\Game\Memory(
239			$memory_id, $memory, null
240			);
241			}
242
243			$stmt->close();
244
245			return $memory_linked;
246			}
247
248			/**
249			* Set the list of incompatible memory for this release
250			*
251			* @param integer release ID
252			* @param integer[] List of memory IDs
253			*/
254			public function setMemoryIncompatibleForRelease($release_id, $memory_id) {
255
256			$stmt = \AL\Db\execute_query(
257			"MemoryDAO: setMemoryIncompatibleForRelease",
258			$this->mysqli,
259			"INSERT INTO game_release_memory_incompatible (release_id, memory_id) VALUES (?, ?)",
260			"ii", $release_id, $memory_id
261			);
262
263			$stmt->close();
264			}
265
266			/**
267			* Delete incompatible memory for release
268			*
269			* @param integer Game Release ID
270			* @param integer memory ID
271			*/
272			public function deleteMemoryIncompatibleForRelease($game_release_id, $memory_id) {
273			$stmt = \AL\Db\execute_query(
274			"MemoryDAO: deleteMemoryIncompatibleForRelease",
275			$this->mysqli,
276			"DELETE FROM game_release_memory_incompatible
277			WHERE release_id = ? and memory_id = ?",
278			"ii", $game_release_id, $memory_id
279			);
280
281			$stmt->close();
282			}
283
284			/**
285			* add a memory amount to the database
286			*
287			* @param varchar memory
288			*/
289			public function addMemory($memory) {
290			$stmt = \AL\Db\execute_query(
291			"MemoryDAO: addMemory",
292			$this->mysqli,
293			"INSERT INTO memory (`name`) VALUES (?)",
294			"s", $memory
295			);
296
297			$stmt->close();
298			}
299
300			/**
301			* delete a $memory amount
302			*
303			* @param int $memory_id
304			*/
305			public function deleteMemory($memory_id) {
306			$stmt = \AL\Db\execute_query(
307			"MemoryDAO: deleteMemory",
308			$this->mysqli,
309			"DELETE FROM memory WHERE id = ?",
310			"i", $memory_id
311			);
312
313			$stmt->close();
314			}
315
316			/**
317			* update a memory amount
318			*
319			* @param int memory_id
			0 ignored issues – show Bug introduced 2020-12-06 16:57 UTC by Report Bug Copy Issue Report The type `AL\Common\DAO\memory_id` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
320			* @param varchar memory_memory
			0 ignored issues – show Bug introduced 2020-12-06 16:57 UTC by Report Bug Copy Issue Report The type `AL\Common\DAO\memory_memory` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
321			*/
322			public function updateMemory($memory_id, $memory) {
323			$stmt = \AL\Db\execute_query(
324			"MemoryDAO: updateMemory",
325			$this->mysqli,
326			"UPDATE memory SET name = ? WHERE id = ?",
327			"si", $memory, $memory_id
328			);
329
330			$stmt->close();
331			}
332			}
333

atari-legend / legacy

MemoryDAO::setMemoryForRelease() A last analyzed 2024-03-07 17:20 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

MemoryDAO::setMemoryForRelease() A
last analyzed 2024-03-07 17:20 UTC