Backup::getList() - Code Metrics - Inspection of "Core API changes" - gplcart/backup - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c9d315...7f8584 )

by Iurii

created 2017-08-29 20:55 UTC

Backup::getList() D

↳ Parent: Backup

Complexity

Conditions	12
Paths	256

Size

Total Lines	58
Code Lines	35

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	58
rs	4.7667
c	0
b	0
f	0
cc	12
eloc	35
nc	256
nop	1

How to fix Long Method Complexity

<?php

/**
 * @package Backup
 * @author Iurii Makukh <[email protected]>
 * @copyright Copyright (c) 2015, Iurii Makukh
 * @license https://www.gnu.org/licenses/gpl.html GNU/GPLv3
 */

namespace gplcart\modules\backup\models;

use gplcart\core\Model,
    gplcart\core\Handler;
use gplcart\core\models\User as UserModel,
    gplcart\core\models\Language as LanguageModel;

/**
 * Manages basic behaviors and data related to Backup model
 */
class Backup extends Model
{

    /**
     * Language model instance
     * @var \gplcart\core\models\Language $language
     */
    protected $language;

    /**
     * User model instance
     * @var \gplcart\core\models\User $user
     */
    protected $user;

    /**
     * @param UserModel $user
     * @param LanguageModel $language
     */
    public function __construct(UserModel $user, LanguageModel $language)
    {
        parent::__construct();

        $this->user = $user;
        $this->language = $language;
    }

    /**
     * Returns an array of backups or counts them
     * @param array $data
     * @return array|integer
     */
    public function getList(array $data = array())
    {
        $sql = 'SELECT b.*, u.name AS user_name';

        if (!empty($data['count'])) {
            $sql = 'SELECT COUNT(b.backup_id)';
        }

        $sql .= ' FROM backup b'
                . ' LEFT JOIN user u ON(b.user_id = u.user_id)'
                . ' WHERE b.backup_id > 0';

        $where = array();

        if (isset($data['user_id'])) {
            $sql .= ' AND b.user_id = ?';
            $where[] = $data['user_id'];
        }

        if (isset($data['id'])) {
            $sql .= ' AND b.id = ?';
            $where[] = $data['id'];
        }

        if (isset($data['version'])) {
            $sql .= ' AND b.version = ?';
            $where[] = $data['version'];
        }

        if (isset($data['name'])) {
            $sql .= ' AND b.name LIKE ?';
            $where[] = "%{$data['name']}%";
        }

        $allowed_order = array('asc', 'desc');
        $allowed_sort = array('name', 'user_id', 'version',
            'id', 'backup_id', 'type', 'created');

        if (isset($data['sort']) && in_array($data['sort'], $allowed_sort)//
                && isset($data['order']) && in_array($data['order'], $allowed_order)
        ) {
            $sql .= " ORDER BY b.{$data['sort']} {$data['order']}";
        } else {
            $sql .= ' ORDER BY b.created DESC';
        }

        if (!empty($data['limit'])) {
            $sql .= ' LIMIT ' . implode(',', array_map('intval', $data['limit']));
        }

        if (!empty($data['count'])) {
            return (int) $this->db->fetchColumn($sql, $where);
        }

        $results = $this->db->fetchAll($sql, $where, array('index' => 'backup_id'));
        $this->hook->attach('module.backup.list', $results, $this);
        return $results;
    }

    /**
     * Adds a backup to the database
     * @param array $data
     * @return boolean|integer
     */
    public function add(array $data)
    {
        $result = null;
        $this->hook->attach('module.backup.add.before', $data, $result, $this);

        if (isset($result)) {
            return $result;
        }

        if (empty($data['user_id'])) {
            $data['user_id'] = $this->user->getId();
        }

        $data['created'] = GC_TIME;
        $result = $this->db->insert('backup', $data);

        $this->hook->attach('module.backup.add.after', $data, $result, $this);
        return $result;
    }

    /**
     * Loads a backup from the database
     * @param integer $id
     * @return array
     */
    public function get($id)
    {
        $sql = 'SELECT * FROM backup WHERE backup_id=?';
        return $this->db->fetch($sql, array($id));
    }

    /**
     * Deletes a backup from disk and database
     * @param integer $id
     * @return boolean
     */
    public function delete($id)
    {
        $result = null;
        $this->hook->attach('module.backup.delete.before', $id, $this);

        if (isset($result)) {
            return $result;
        }

        $result = (bool) $this->db->delete('backup', array('backup_id' => $id));

        if ($result) {
            $this->deleteZip($id);
        }

        $this->hook->attach('module.backup.delete.after', $id, $result, $this);
        return (bool) $result;
    }

    /**
     * Deletes a backup ZIP archive
     * @param integer $backup_id
     * @return boolean
     */
    protected function deleteZip($backup_id)
    {
        $backup = $this->get($backup_id);

        if (isset($backup['path']) && file_exists(GC_FILE_DIR . "/{$backup['path']}")) {
            return unlink(GC_FILE_DIR . "/{$backup['path']}");
        }

        return false;
    }

    /**
     * Performs backup operation
     * @param string $handler_id
     * @param array $data
     * @return boolean|string
     */
    public function backup($handler_id, $data)
    {
        $handlers = $this->getHandlers();
        return Handler::call($handlers, $handler_id, 'backup', array($data, $this));
    }

    /**
     * Performs restore operation
     * @param string $handler_id
     * @param array $data
     * @return boolean|string
     */
    public function restore($handler_id, $data)
    {
        $handlers = $this->getHandlers();
        return Handler::call($handlers, $handler_id, 'restore', array($data, $this));
    }

    /**
     * Whether a backup already exists
     * @param string $id
     * @param null|string $version
     * @return bool
     */
    public function exists($id, $version = null)
    {
        $list = $this->getList(array('id' => $id, 'version' => $version));
        return !empty($list);
    }

    /**
     * Returns an array of backup handlers
     * @return array
     */
    public function getHandlers()
    {
        $handlers = &gplcart_static(__METHOD__);

        if (isset($handlers)) {
            return $handlers;
        }

        $handlers = $this->getDefaultHandlers();
        $this->hook->attach('module.backup.handlers', $handlers, $this);
        return $handlers;
    }

    /**
     * Returns a single handler
     * @param string $handler_id
     * @return array
     */
    public function getHandler($handler_id)
    {
        $handlers = $this->getHandlers();
        return empty($handlers[$handler_id]) ? array() : $handlers[$handler_id];
    }

    /**
     * Returns an array of default backup handlers
     * @return array
     */
    protected function getDefaultHandlers()
    {
        $handlers = array();

        $handlers['module'] = array(
            'name' => $this->language->text('Module'),
            'handlers' => array(
                'backup' => array('gplcart\\modules\\backup\\handlers\\Module', 'backup')
        ));

        return $handlers;
    }

}


1			<?php
2
3			/**
4			* @package Backup
5			* @author Iurii Makukh <[email protected]>
6			* @copyright Copyright (c) 2015, Iurii Makukh
7			* @license https://www.gnu.org/licenses/gpl.html GNU/GPLv3
8			*/
9
10			namespace gplcart\modules\backup\models;
11
12			use gplcart\core\Model,
13			gplcart\core\Handler;
14			use gplcart\core\models\User as UserModel,
15			gplcart\core\models\Language as LanguageModel;
16
17			/**
18			* Manages basic behaviors and data related to Backup model
19			*/
20			class Backup extends Model
21			{
22
23			/**
24			* Language model instance
25			* @var \gplcart\core\models\Language $language
26			*/
27			protected $language;
28
29			/**
30			* User model instance
31			* @var \gplcart\core\models\User $user
32			*/
33			protected $user;
34
35			/**
36			* @param UserModel $user
37			* @param LanguageModel $language
38			*/
39			public function __construct(UserModel $user, LanguageModel $language)
40			{
41			parent::__construct();
42
43			$this->user = $user;
44			$this->language = $language;
45			}
46
47			/**
48			* Returns an array of backups or counts them
49			* @param array $data
50			* @return array\|integer
51			*/
52			public function getList(array $data = array())
53			{
54			$sql = 'SELECT b.*, u.name AS user_name';
55
56			if (!empty($data['count'])) {
57			$sql = 'SELECT COUNT(b.backup_id)';
58			}
59
60			$sql .= ' FROM backup b'
61			. ' LEFT JOIN user u ON(b.user_id = u.user_id)'
62			. ' WHERE b.backup_id > 0';
63
64			$where = array();
65
66			if (isset($data['user_id'])) {
67			$sql .= ' AND b.user_id = ?';
68			$where[] = $data['user_id'];
69			}
70
71			if (isset($data['id'])) {
72			$sql .= ' AND b.id = ?';
73			$where[] = $data['id'];
74			}
75
76			if (isset($data['version'])) {
77			$sql .= ' AND b.version = ?';
78			$where[] = $data['version'];
79			}
80
81			if (isset($data['name'])) {
82			$sql .= ' AND b.name LIKE ?';
83			$where[] = "%{$data['name']}%";
84			}
85
86			$allowed_order = array('asc', 'desc');
87			$allowed_sort = array('name', 'user_id', 'version',
88			'id', 'backup_id', 'type', 'created');
89
90			if (isset($data['sort']) && in_array($data['sort'], $allowed_sort)//
91			&& isset($data['order']) && in_array($data['order'], $allowed_order)
92			) {
93			$sql .= " ORDER BY b.{$data['sort']} {$data['order']}";
94			} else {
95			$sql .= ' ORDER BY b.created DESC';
96			}
97
98			if (!empty($data['limit'])) {
99			$sql .= ' LIMIT ' . implode(',', array_map('intval', $data['limit']));
100			}
101
102			if (!empty($data['count'])) {
103			return (int) $this->db->fetchColumn($sql, $where);
104			}
105
106			$results = $this->db->fetchAll($sql, $where, array('index' => 'backup_id'));
107			$this->hook->attach('module.backup.list', $results, $this);
108			return $results;
109			}
110
111			/**
112			* Adds a backup to the database
113			* @param array $data
114			* @return boolean\|integer
115			*/
116			public function add(array $data)
117			{
118			$result = null;
119			$this->hook->attach('module.backup.add.before', $data, $result, $this);
120
121			if (isset($result)) {
122			return $result;
123			}
124
125			if (empty($data['user_id'])) {
126			$data['user_id'] = $this->user->getId();
127			}
128
129			$data['created'] = GC_TIME;
130			$result = $this->db->insert('backup', $data);
131
132			$this->hook->attach('module.backup.add.after', $data, $result, $this);
133			return $result;
134			}
135
136			/**
137			* Loads a backup from the database
138			* @param integer $id
139			* @return array
140			*/
141			public function get($id)
142			{
143			$sql = 'SELECT * FROM backup WHERE backup_id=?';
144			return $this->db->fetch($sql, array($id));
145			}
146
147			/**
148			* Deletes a backup from disk and database
149			* @param integer $id
150			* @return boolean
151			*/
152			public function delete($id)
153			{
154			$result = null;
155			$this->hook->attach('module.backup.delete.before', $id, $this);
156
157			if (isset($result)) {
158			return $result;
159			}
160
161			$result = (bool) $this->db->delete('backup', array('backup_id' => $id));
162
163			if ($result) {
164			$this->deleteZip($id);
165			}
166
167			$this->hook->attach('module.backup.delete.after', $id, $result, $this);
168			return (bool) $result;
169			}
170
171			/**
172			* Deletes a backup ZIP archive
173			* @param integer $backup_id
174			* @return boolean
175			*/
176			protected function deleteZip($backup_id)
177			{
178			$backup = $this->get($backup_id);
179
180			if (isset($backup['path']) && file_exists(GC_FILE_DIR . "/{$backup['path']}")) {
181			return unlink(GC_FILE_DIR . "/{$backup['path']}");
182			}
183
184			return false;
185			}
186
187			/**
188			* Performs backup operation
189			* @param string $handler_id
190			* @param array $data
191			* @return boolean\|string
192			*/
193			public function backup($handler_id, $data)
194			{
195			$handlers = $this->getHandlers();
196			return Handler::call($handlers, $handler_id, 'backup', array($data, $this));
197			}
198
199			/**
200			* Performs restore operation
201			* @param string $handler_id
202			* @param array $data
203			* @return boolean\|string
204			*/
205			public function restore($handler_id, $data)
206			{
207			$handlers = $this->getHandlers();
208			return Handler::call($handlers, $handler_id, 'restore', array($data, $this));
209			}
210
211			/**
212			* Whether a backup already exists
213			* @param string $id
214			* @param null\|string $version
215			* @return bool
216			*/
217			public function exists($id, $version = null)
218			{
219			$list = $this->getList(array('id' => $id, 'version' => $version));
220			return !empty($list);
221			}
222
223			/**
224			* Returns an array of backup handlers
225			* @return array
226			*/
227			public function getHandlers()
228			{
229			$handlers = &gplcart_static(__METHOD__);
230
231			if (isset($handlers)) {
232			return $handlers;
233			}
234
235			$handlers = $this->getDefaultHandlers();
236			$this->hook->attach('module.backup.handlers', $handlers, $this);
237			return $handlers;
238			}
239
240			/**
241			* Returns a single handler
242			* @param string $handler_id
243			* @return array
244			*/
245			public function getHandler($handler_id)
246			{
247			$handlers = $this->getHandlers();
248			return empty($handlers[$handler_id]) ? array() : $handlers[$handler_id];
249			}
250
251			/**
252			* Returns an array of default backup handlers
253			* @return array
254			*/
255			protected function getDefaultHandlers()
256			{
257			$handlers = array();
258
259			$handlers['module'] = array(
260			'name' => $this->language->text('Module'),
261			'handlers' => array(
262			'backup' => array('gplcart\\modules\\backup\\handlers\\Module', 'backup')
263			));
264
265			return $handlers;
266			}
267
268			}
269

gplcart / backup

Push — master ( c9d315...7f8584 )

Backup::getList() D

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like