DEnumController::__construct() - Code Metrics - alphadevx/alpha - Measure and Improve Code Quality continuously with Scrutinizer

DEnumController::__construct() A
last analyzed 2021-05-08 15:41 UTC

↳ Parent: DEnumController

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	12
rs	9.8666
cc	1
nc	1
nop	0

<?php

namespace Alpha\Controller;

use Alpha\Util\Logging\Logger;
use Alpha\Util\Http\Response;
use Alpha\View\View;
use Alpha\Exception\IllegalArguementException;
use Alpha\Exception\SecurityException;
use Alpha\Exception\FailedSaveException;
use Alpha\Exception\AlphaException;
use Alpha\Exception\RecordNotFoundException;
use Alpha\Model\ActiveRecord;
use Alpha\Model\Type\DEnum;
use Alpha\Model\Type\DEnumItem;

/**
 * Controller used to edit DEnums and associated DEnumItems.
 *
 * @since 1.0
 *
 * @author John Collins <[email protected]>
 * @license http://www.opensource.org/licenses/bsd-license.php The BSD License
 * @copyright Copyright (c) 2018, John Collins (founder of Alpha Framework).
 * All rights reserved.
 *
 * <pre>
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the
 * following conditions are met:
 *
 * * Redistributions of source code must retain the above
 *   copyright notice, this list of conditions and the
 *   following disclaimer.
 * * Redistributions in binary form must reproduce the above
 *   copyright notice, this list of conditions and the
 *   following disclaimer in the documentation and/or other
 *   materials provided with the distribution.
 * * Neither the name of the Alpha Framework nor the names
 *   of its contributors may be used to endorse or promote
 *   products derived from this software without specific
 *   prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * </pre>
 */
class DEnumController extends ActiveRecordController implements ControllerInterface
{
    /**
     * Trace logger.
     *
     * @var \Alpha\Util\Logging\Logger
     *
     * @since 1.0
     */
    private static $logger = null;


    /**
     * DEnum to work on
     *
     * @var \Alpha\Model\Type\DEnum
     *
     * @since 3.0.0
     */
    protected $record;

    /**
     * constructor to set up the object.
     *
     * @since 1.0
     */
    public function __construct()
    {
        self::$logger = new Logger('DEnumController');
        self::$logger->debug('>>__construct()');

        // ensure that the super class constructor is called, indicating the rights group
        parent::__construct('Admin');

        $this->record = new DEnum();

        self::$logger->debug('<<__construct');
    }

    /**
     * Handle GET requests.
     *
     * @param \Alpha\Util\Http\Request $request
     *
     * @return \Alpha\Util\Http\Response
     *
     * @since 1.0
     */
    public function doGET($request)
    {
        self::$logger->debug('>>doGET($request=['.var_export($request, true).'])');

        $params = $request->getParams();

        $body = '';

        // load one DEnum
        if (isset($params['denumID'])) {
            $RecordOid = $params['denumID'];

            // set up the title and meta details
            $this->setTitle('Editing a DEnum');
            $this->setDescription('Page to edit a DEnum.');
            $this->setKeywords('edit,DEnum');

            $body .= View::displayPageHead($this);

            $message = $this->getStatusMessage();
            if (!empty($message)) {
                $body .= $message;
            }

            try {
                $this->record->load($RecordOid);

                ActiveRecord::disconnect();

                $view = View::getInstance($this->record);

                $body .= View::renderDeleteForm($request->getURI());

                $body .= $view->editView(array('URI' => $request->getURI()));
            } catch (RecordNotFoundException $e) {
                self::$logger->error('Unable to load the DEnum of id ['.$params['denumID'].'], error was ['.$e->getMessage().']');
            }
        } else { // load all DEnums
            // set up the title and meta details
            $this->setTitle('Listing all DEnums');
            $this->setDescription('Page to list all DEnums.');
            $this->setKeywords('list,all,DEnums');

            $body .= View::displayPageHead($this);

            // make sure that the DEnum tables exist
            if (!$this->record->checkTableExists()) {
                $body .= View::displayErrorMessage('Warning! The DEnum tables do not exist, attempting to create them now...');
                $body .= $this->createDEnumTables();
            }

            // get all of the records and invoke the list view on each one

            // set the start point for the list pagination
            if (isset($params['start']) ? $this->start = $params['start'] : $this->start = 1);

            $objects = $this->record->loadAll($this->start);

            ActiveRecord::disconnect();

            $this->recordCount = $this->record->getCount();

            $body .= View::renderDeleteForm($request->getURI());

            foreach ($objects as $object) {
                $temp = View::getInstance($object);
                $body .= $temp->listView(array('URI' => $request->getURI()));
            }
        }

        $body .= View::displayPageFoot($this);

        self::$logger->debug('<<doGET');

        return new Response(200, $body, array('Content-Type' => 'text/html'));
    }

    /**
     * Handle POST requests.
     *
     * @param \Alpha\Util\Http\Request $request
     *
     * @return \Alpha\Util\Http\Response
     *
     * @throws \Alpha\Exception\SecurityException
     *
     * @since 1.0
     */
    public function doPOST($request)
    {
        self::$logger->debug('>>doPOST($request=['.var_export($request, true).'])');

        $params = $request->getParams();

        try {
            // check the hidden security fields before accepting the form POST data
            if (!$this->checkSecurityFields()) {
                self::$logger->debug('<<doPOST');
                throw new SecurityException('This page cannot accept post data from remote servers!');
            }

            // ensure that a ID is provided
            if (isset($params['denumID'])) {
                $RecordOid = $params['denumID'];
            } else {
                throw new IllegalArguementException('Could not load the DEnum object as an denumID was not supplied!');
            }

            if (isset($params['saveBut'])) {
                try {
                    $this->record->load($RecordOid);
                    // update the object from post data
                    $this->record->populateFromArray($params);

                    ActiveRecord::begin();

                    $this->record->save();

                    self::$logger->action('DEnum '.$this->record->getID().' saved');

                    // now save the DEnumItems
                    $tmp = new DEnumItem();
                    $denumItems = $tmp->loadItems($this->record->getID());

                    foreach ($denumItems as $item) {
                        $item->set('value', $params['value_'.$item->getID()]);
                        $item->save();

                        self::$logger->action('DEnumItem '.$item->getID().' saved');
                    }

                    // handle new DEnumItem if posted
                    if (isset($params['new_value']) && trim($params['new_value']) != '') {
                        $newItem = new DEnumItem();
                        $newItem->set('value', $params['new_value']);
                        $newItem->set('DEnumID', $this->record->getID());
                        $newItem->save();

                        self::$logger->action('DEnumItem '.$newItem->getID().' created');
                    }

                    ActiveRecord::commit();

                    $this->setStatusMessage(View::displayUpdateMessage(get_class($this->record).' '.$this->record->getID().' saved successfully.'));

                    return $this->doGET($request);
                } catch (FailedSaveException $e) {
                    self::$logger->error('Unable to save the DEnum of id ['.$params['oid'].'], error was ['.$e->getMessage().']');
                    ActiveRecord::rollback();
                }

                ActiveRecord::disconnect();
            }
        } catch (SecurityException $e) {
            $this->setStatusMessage(View::displayErrorMessage($e->getMessage()));
            self::$logger->warn($e->getMessage());
        } catch (IllegalArguementException $e) {
            $this->setStatusMessage(View::displayErrorMessage($e->getMessage()));
            self::$logger->error($e->getMessage());
        } catch (RecordNotFoundException $e) {
            self::$logger->warn($e->getMessage());
            $this->setStatusMessage(View::displayErrorMessage('Failed to load the requested item from the database!'));
        }

        $body = View::displayPageHead($this);

        $message = $this->getStatusMessage();
        if (!empty($message)) {
            $body .= $message;
        }

        $body .= View::displayPageFoot($this);
        self::$logger->debug('<<doPOST');

        return new Response(200, $body, array('Content-Type' => 'text/html'));
    }

    /**
     * Method to create the DEnum tables if they don't exist.
     *
     * @since 1.0
     *
     * @return string
     */
    private function createDEnumTables()
    {
        $tmpDEnum = new DEnum();

        $body = '<p>Attempting to build table '.DEnum::TABLE_NAME.' for class DEnum : </p>';

        try {
            $tmpDEnum->makeTable();
            $body .= View::displayUpdateMessage('Successfully re-created the database table '.DEnum::TABLE_NAME);
            self::$logger->action('Re-created the table '.DEnum::TABLE_NAME);
        } catch (AlphaException $e) {
            $body .= View::displayErrorMessage('Failed re-created the database table '.DEnum::TABLE_NAME.', check the log');
            self::$logger->error($e->getMessage());
        }

        $tmpDEnumItem = new DEnumItem();

        $body .= '<p>Attempting to build table '.DEnumItem::TABLE_NAME.' for class DEnumItem : </p>';

        try {
            $tmpDEnumItem->makeTable();
            $body .= View::displayUpdateMessage('Successfully re-created the database table '.DEnumItem::TABLE_NAME);
            self::$logger->action('Re-created the table '.DEnumItem::TABLE_NAME);
        } catch (AlphaException $e) {
            $body .= View::displayErrorMessage('Failed re-created the database table '.DEnumItem::TABLE_NAME.', check the log');
            self::$logger->error($e->getMessage());
        }

        return $body;
    }
}


1			<?php
2
3			namespace Alpha\Controller;
4
5			use Alpha\Util\Logging\Logger;
6			use Alpha\Util\Http\Response;
7			use Alpha\View\View;
8			use Alpha\Exception\IllegalArguementException;
9			use Alpha\Exception\SecurityException;
10			use Alpha\Exception\FailedSaveException;
11			use Alpha\Exception\AlphaException;
12			use Alpha\Exception\RecordNotFoundException;
13			use Alpha\Model\ActiveRecord;
14			use Alpha\Model\Type\DEnum;
15			use Alpha\Model\Type\DEnumItem;
16
17			/**
18			* Controller used to edit DEnums and associated DEnumItems.
19			*
20			* @since 1.0
21			*
22			* @author John Collins <[email protected]>
23			* @license http://www.opensource.org/licenses/bsd-license.php The BSD License
24			* @copyright Copyright (c) 2018, John Collins (founder of Alpha Framework).
25			* All rights reserved.
26			*
27			* <pre>
28			* Redistribution and use in source and binary forms, with or
29			* without modification, are permitted provided that the
30			* following conditions are met:
31			*
32			* * Redistributions of source code must retain the above
33			* copyright notice, this list of conditions and the
34			* following disclaimer.
35			* * Redistributions in binary form must reproduce the above
36			* copyright notice, this list of conditions and the
37			* following disclaimer in the documentation and/or other
38			* materials provided with the distribution.
39			* * Neither the name of the Alpha Framework nor the names
40			* of its contributors may be used to endorse or promote
41			* products derived from this software without specific
42			* prior written permission.
43			*
44			* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
45			* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
46			* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
47			* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
48			* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
49			* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
50			* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
51			* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
52			* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
53			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
54			* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
55			* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
56			* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
57			* </pre>
58			*/
59			class DEnumController extends ActiveRecordController implements ControllerInterface
60			{
61			/**
62			* Trace logger.
63			*
64			* @var \Alpha\Util\Logging\Logger
65			*
66			* @since 1.0
67			*/
68			private static $logger = null;
			0 ignored issues – show Comprehensibility introduced 2015-12-23 21:44 UTC by Report Bug Copy Issue Report Consider using a different property name as you override a private property of the parent class. Loading history...
69
70			/**
71			* DEnum to work on
72			*
73			* @var \Alpha\Model\Type\DEnum
74			*
75			* @since 3.0.0
76			*/
77			protected $record;
78
79			/**
80			* constructor to set up the object.
81			*
82			* @since 1.0
83			*/
84			public function __construct()
85			{
86			self::$logger = new Logger('DEnumController');
87			self::$logger->debug('>>__construct()');
88
89			// ensure that the super class constructor is called, indicating the rights group
90			parent::__construct('Admin');
91
92			$this->record = new DEnum();
93
94			self::$logger->debug('<<__construct');
95			}
96
97			/**
98			* Handle GET requests.
99			*
100			* @param \Alpha\Util\Http\Request $request
101			*
102			* @return \Alpha\Util\Http\Response
103			*
104			* @since 1.0
105			*/
106			public function doGET($request)
107			{
108			self::$logger->debug('>>doGET($request=['.var_export($request, true).'])');
109
110			$params = $request->getParams();
111
112			$body = '';
113
114			// load one DEnum
115			if (isset($params['denumID'])) {
116			$RecordOid = $params['denumID'];
117
118			// set up the title and meta details
119			$this->setTitle('Editing a DEnum');
120			$this->setDescription('Page to edit a DEnum.');
121			$this->setKeywords('edit,DEnum');
122
123			$body .= View::displayPageHead($this);
124
125			$message = $this->getStatusMessage();
126			if (!empty($message)) {
127			$body .= $message;
128			}
129
130			try {
131			$this->record->load($RecordOid);
132
133			ActiveRecord::disconnect();
134
135			$view = View::getInstance($this->record);
136
137			$body .= View::renderDeleteForm($request->getURI());
138
139			$body .= $view->editView(array('URI' => $request->getURI()));
140			} catch (RecordNotFoundException $e) {
141			self::$logger->error('Unable to load the DEnum of id ['.$params['denumID'].'], error was ['.$e->getMessage().']');
142			}
143			} else { // load all DEnums
144			// set up the title and meta details
145			$this->setTitle('Listing all DEnums');
146			$this->setDescription('Page to list all DEnums.');
147			$this->setKeywords('list,all,DEnums');
148
149			$body .= View::displayPageHead($this);
150
151			// make sure that the DEnum tables exist
152			if (!$this->record->checkTableExists()) {
153			$body .= View::displayErrorMessage('Warning! The DEnum tables do not exist, attempting to create them now...');
154			$body .= $this->createDEnumTables();
155			}
156
157			// get all of the records and invoke the list view on each one
158
159			// set the start point for the list pagination
160			if (isset($params['start']) ? $this->start = $params['start'] : $this->start = 1);
161
162			$objects = $this->record->loadAll($this->start);
163
164			ActiveRecord::disconnect();
165
166			$this->recordCount = $this->record->getCount();
167
168			$body .= View::renderDeleteForm($request->getURI());
169
170			foreach ($objects as $object) {
171			$temp = View::getInstance($object);
172			$body .= $temp->listView(array('URI' => $request->getURI()));
173			}
174			}
175
176			$body .= View::displayPageFoot($this);
177
178			self::$logger->debug('<<doGET');
179
180			return new Response(200, $body, array('Content-Type' => 'text/html'));
181			}
182
183			/**
184			* Handle POST requests.
185			*
186			* @param \Alpha\Util\Http\Request $request
187			*
188			* @return \Alpha\Util\Http\Response
189			*
190			* @throws \Alpha\Exception\SecurityException
191			*
192			* @since 1.0
193			*/
194			public function doPOST($request)
195			{
196			self::$logger->debug('>>doPOST($request=['.var_export($request, true).'])');
197
198			$params = $request->getParams();
199
200			try {
201			// check the hidden security fields before accepting the form POST data
202			if (!$this->checkSecurityFields()) {
203			self::$logger->debug('<<doPOST');
204			throw new SecurityException('This page cannot accept post data from remote servers!');
205			}
206
207			// ensure that a ID is provided
208			if (isset($params['denumID'])) {
209			$RecordOid = $params['denumID'];
210			} else {
211			throw new IllegalArguementException('Could not load the DEnum object as an denumID was not supplied!');
212			}
213
214			if (isset($params['saveBut'])) {
215			try {
216			$this->record->load($RecordOid);
217			// update the object from post data
218			$this->record->populateFromArray($params);
219
220			ActiveRecord::begin();
221
222			$this->record->save();
223
224			self::$logger->action('DEnum '.$this->record->getID().' saved');
225
226			// now save the DEnumItems
227			$tmp = new DEnumItem();
228			$denumItems = $tmp->loadItems($this->record->getID());
229
230			foreach ($denumItems as $item) {
231			$item->set('value', $params['value_'.$item->getID()]);
232			$item->save();
233
234			self::$logger->action('DEnumItem '.$item->getID().' saved');
235			}
236
237			// handle new DEnumItem if posted
238			if (isset($params['new_value']) && trim($params['new_value']) != '') {
239			$newItem = new DEnumItem();
240			$newItem->set('value', $params['new_value']);
241			$newItem->set('DEnumID', $this->record->getID());
242			$newItem->save();
243
244			self::$logger->action('DEnumItem '.$newItem->getID().' created');
245			}
246
247			ActiveRecord::commit();
248
249			$this->setStatusMessage(View::displayUpdateMessage(get_class($this->record).' '.$this->record->getID().' saved successfully.'));
250
251			return $this->doGET($request);
252			} catch (FailedSaveException $e) {
253			self::$logger->error('Unable to save the DEnum of id ['.$params['oid'].'], error was ['.$e->getMessage().']');
254			ActiveRecord::rollback();
255			}
256
257			ActiveRecord::disconnect();
258			}
259			} catch (SecurityException $e) {
260			$this->setStatusMessage(View::displayErrorMessage($e->getMessage()));
261			self::$logger->warn($e->getMessage());
262			} catch (IllegalArguementException $e) {
263			$this->setStatusMessage(View::displayErrorMessage($e->getMessage()));
264			self::$logger->error($e->getMessage());
265			} catch (RecordNotFoundException $e) {
266			self::$logger->warn($e->getMessage());
267			$this->setStatusMessage(View::displayErrorMessage('Failed to load the requested item from the database!'));
268			}
269
270			$body = View::displayPageHead($this);
271
272			$message = $this->getStatusMessage();
273			if (!empty($message)) {
274			$body .= $message;
275			}
276
277			$body .= View::displayPageFoot($this);
278			self::$logger->debug('<<doPOST');
279
280			return new Response(200, $body, array('Content-Type' => 'text/html'));
281			}
282
283			/**
284			* Method to create the DEnum tables if they don't exist.
285			*
286			* @since 1.0
287			*
288			* @return string
289			*/
290			private function createDEnumTables()
291			{
292			$tmpDEnum = new DEnum();
293
294			$body = '<p>Attempting to build table '.DEnum::TABLE_NAME.' for class DEnum : </p>';
295
296			try {
297			$tmpDEnum->makeTable();
298			$body .= View::displayUpdateMessage('Successfully re-created the database table '.DEnum::TABLE_NAME);
299			self::$logger->action('Re-created the table '.DEnum::TABLE_NAME);
300			} catch (AlphaException $e) {
301			$body .= View::displayErrorMessage('Failed re-created the database table '.DEnum::TABLE_NAME.', check the log');
302			self::$logger->error($e->getMessage());
303			}
304
305			$tmpDEnumItem = new DEnumItem();
306
307			$body .= '<p>Attempting to build table '.DEnumItem::TABLE_NAME.' for class DEnumItem : </p>';
308
309			try {
310			$tmpDEnumItem->makeTable();
311			$body .= View::displayUpdateMessage('Successfully re-created the database table '.DEnumItem::TABLE_NAME);
312			self::$logger->action('Re-created the table '.DEnumItem::TABLE_NAME);
313			} catch (AlphaException $e) {
314			$body .= View::displayErrorMessage('Failed re-created the database table '.DEnumItem::TABLE_NAME.', check the log');
315			self::$logger->error($e->getMessage());
316			}
317
318			return $body;
319			}
320			}
321

alphadevx / alpha

DEnumController::__construct() A last analyzed 2021-05-08 15:41 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

DEnumController::__construct() A
last analyzed 2021-05-08 15:41 UTC