1: <?php
  2: /**
  3:  * Exceptions file.  Contains the various exceptions CakePHP will throw until they are
  4:  * moved into their permanent location.
  5:  *
  6:  * PHP 5
  7:  *
  8:  * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
  9:  * Copyright 2005-2012, Cake Software Foundation, Inc. (http://cakefoundation.org)
 10:  *
 11:  * Licensed under The MIT License
 12:  * Redistributions of files must retain the above copyright notice.
 13:  *
 14:  * @copyright     Copyright 2005-2012, Cake Software Foundation, Inc. (http://cakefoundation.org)
 15:  * @link          http://book.cakephp.org/2.0/en/development/testing.html
 16:  * @package       Cake.Error
 17:  * @since         CakePHP(tm) v 2.0
 18:  * @license       MIT License (http://www.opensource.org/licenses/mit-license.php)
 19:  */
 20: 
 21: /**
 22:  * Parent class for all of the HTTP related exceptions in CakePHP.
 23:  * All HTTP status/error related exceptions should extend this class so
 24:  * catch blocks can be specifically typed.
 25:  *
 26:  * @package       Cake.Error
 27:  */
 28: if (!class_exists('HttpException')) {
 29:     class HttpException extends RuntimeException {
 30:     }
 31: }
 32: 
 33: /**
 34:  * Represents an HTTP 400 error.
 35:  *
 36:  * @package       Cake.Error
 37:  */
 38: class BadRequestException extends HttpException {
 39: 
 40: /**
 41:  * Constructor
 42:  *
 43:  * @param string $message If no message is given 'Bad Request' will be the message
 44:  * @param string $code Status code, defaults to 400
 45:  */
 46:     public function __construct($message = null, $code = 400) {
 47:         if (empty($message)) {
 48:             $message = 'Bad Request';
 49:         }
 50:         parent::__construct($message, $code);
 51:     }
 52: 
 53: }
 54: 
 55: /**
 56:  * Represents an HTTP 401 error.
 57:  *
 58:  * @package       Cake.Error
 59:  */
 60: class UnauthorizedException extends HttpException {
 61: 
 62: /**
 63:  * Constructor
 64:  *
 65:  * @param string $message If no message is given 'Unauthorized' will be the message
 66:  * @param string $code Status code, defaults to 401
 67:  */
 68:     public function __construct($message = null, $code = 401) {
 69:         if (empty($message)) {
 70:             $message = 'Unauthorized';
 71:         }
 72:         parent::__construct($message, $code);
 73:     }
 74: 
 75: }
 76: 
 77: /**
 78:  * Represents an HTTP 403 error.
 79:  *
 80:  * @package       Cake.Error
 81:  */
 82: class ForbiddenException extends HttpException {
 83: 
 84: /**
 85:  * Constructor
 86:  *
 87:  * @param string $message If no message is given 'Forbidden' will be the message
 88:  * @param string $code Status code, defaults to 403
 89:  */
 90:     public function __construct($message = null, $code = 403) {
 91:         if (empty($message)) {
 92:             $message = 'Forbidden';
 93:         }
 94:         parent::__construct($message, $code);
 95:     }
 96: 
 97: }
 98: 
 99: /**
100:  * Represents an HTTP 404 error.
101:  *
102:  * @package       Cake.Error
103:  */
104: class NotFoundException extends HttpException {
105: 
106: /**
107:  * Constructor
108:  *
109:  * @param string $message If no message is given 'Not Found' will be the message
110:  * @param string $code Status code, defaults to 404
111:  */
112:     public function __construct($message = null, $code = 404) {
113:         if (empty($message)) {
114:             $message = 'Not Found';
115:         }
116:         parent::__construct($message, $code);
117:     }
118: 
119: }
120: 
121: /**
122:  * Represents an HTTP 405 error.
123:  *
124:  * @package       Cake.Error
125:  */
126: class MethodNotAllowedException extends HttpException {
127: 
128: /**
129:  * Constructor
130:  *
131:  * @param string $message If no message is given 'Method Not Allowed' will be the message
132:  * @param string $code Status code, defaults to 405
133:  */
134:     public function __construct($message = null, $code = 405) {
135:         if (empty($message)) {
136:             $message = 'Method Not Allowed';
137:         }
138:         parent::__construct($message, $code);
139:     }
140: 
141: }
142: 
143: /**
144:  * Represents an HTTP 500 error.
145:  *
146:  * @package       Cake.Error
147:  */
148: class InternalErrorException extends HttpException {
149: 
150: /**
151:  * Constructor
152:  *
153:  * @param string $message If no message is given 'Internal Server Error' will be the message
154:  * @param string $code Status code, defaults to 500
155:  */
156:     public function __construct($message = null, $code = 500) {
157:         if (empty($message)) {
158:             $message = 'Internal Server Error';
159:         }
160:         parent::__construct($message, $code);
161:     }
162: 
163: }
164: 
165: /**
166:  * CakeException is used a base class for CakePHP's internal exceptions.
167:  * In general framework errors are interpreted as 500 code errors.
168:  *
169:  * @package       Cake.Error
170:  */
171: class CakeException extends RuntimeException {
172: 
173: /**
174:  * Array of attributes that are passed in from the constructor, and
175:  * made available in the view when a development error is displayed.
176:  *
177:  * @var array
178:  */
179:     protected $_attributes = array();
180: 
181: /**
182:  * Template string that has attributes sprintf()'ed into it.
183:  *
184:  * @var string
185:  */
186:     protected $_messageTemplate = '';
187: 
188: /**
189:  * Constructor.
190:  *
191:  * Allows you to create exceptions that are treated as framework errors and disabled
192:  * when debug = 0.
193:  *
194:  * @param string|array $message Either the string of the error message, or an array of attributes
195:  *   that are made available in the view, and sprintf()'d into CakeException::$_messageTemplate
196:  * @param string $code The code of the error, is also the HTTP status code for the error.
197:  */
198:     public function __construct($message, $code = 500) {
199:         if (is_array($message)) {
200:             $this->_attributes = $message;
201:             $message = __d('cake_dev', $this->_messageTemplate, $message);
202:         }
203:         parent::__construct($message, $code);
204:     }
205: 
206: /**
207:  * Get the passed in attributes
208:  *
209:  * @return array
210:  */
211:     public function getAttributes() {
212:         return $this->_attributes;
213:     }
214: 
215: }
216: 
217: /**
218:  * Missing Controller exception - used when a controller
219:  * cannot be found.
220:  *
221:  * @package       Cake.Error
222:  */
223: class MissingControllerException extends CakeException {
224: 
225:     protected $_messageTemplate = 'Controller class %s could not be found.';
226: 
227: //@codingStandardsIgnoreStart
228:     public function __construct($message, $code = 404) {
229:         parent::__construct($message, $code);
230:     }
231: //@codingStandardsIgnoreEnd
232: 
233: }
234: 
235: /**
236:  * Missing Action exception - used when a controller action
237:  * cannot be found.
238:  *
239:  * @package       Cake.Error
240:  */
241: class MissingActionException extends CakeException {
242: 
243:     protected $_messageTemplate = 'Action %s::%s() could not be found.';
244: 
245: //@codingStandardsIgnoreStart
246:     public function __construct($message, $code = 404) {
247:         parent::__construct($message, $code);
248:     }
249: //@codingStandardsIgnoreEnd
250: 
251: }
252: 
253: /**
254:  * Private Action exception - used when a controller action
255:  * starts with a  `_`.
256:  *
257:  * @package       Cake.Error
258:  */
259: class PrivateActionException extends CakeException {
260: 
261:     protected $_messageTemplate = 'Private Action %s::%s() is not directly accessible.';
262: 
263: //@codingStandardsIgnoreStart
264:     public function __construct($message, $code = 404, Exception $previous = null) {
265:         parent::__construct($message, $code, $previous);
266:     }
267: //@codingStandardsIgnoreEnd
268: 
269: }
270: 
271: /**
272:  * Used when a component cannot be found.
273:  *
274:  * @package       Cake.Error
275:  */
276: class MissingComponentException extends CakeException {
277: 
278:     protected $_messageTemplate = 'Component class %s could not be found.';
279: 
280: }
281: 
282: /**
283:  * Used when a behavior cannot be found.
284:  *
285:  * @package       Cake.Error
286:  */
287: class MissingBehaviorException extends CakeException {
288: 
289:     protected $_messageTemplate = 'Behavior class %s could not be found.';
290: 
291: }
292: 
293: /**
294:  * Used when a view file cannot be found.
295:  *
296:  * @package       Cake.Error
297:  */
298: class MissingViewException extends CakeException {
299: 
300:     protected $_messageTemplate = 'View file "%s" is missing.';
301: 
302: }
303: 
304: /**
305:  * Used when a layout file cannot be found.
306:  *
307:  * @package       Cake.Error
308:  */
309: class MissingLayoutException extends CakeException {
310: 
311:     protected $_messageTemplate = 'Layout file "%s" is missing.';
312: 
313: }
314: 
315: /**
316:  * Used when a helper cannot be found.
317:  *
318:  * @package       Cake.Error
319:  */
320: class MissingHelperException extends CakeException {
321: 
322:     protected $_messageTemplate = 'Helper class %s could not be found.';
323: 
324: }
325: 
326: /**
327:  * Runtime Exceptions for ConnectionManager
328:  *
329:  * @package       Cake.Error
330:  */
331: class MissingDatabaseException extends CakeException {
332: 
333:     protected $_messageTemplate = 'Database connection "%s" could not be found.';
334: 
335: }
336: 
337: /**
338:  * Used when no connections can be found.
339:  *
340:  * @package       Cake.Error
341:  */
342: class MissingConnectionException extends CakeException {
343: 
344:     protected $_messageTemplate = 'Database connection "%s" is missing, or could not be created.';
345: 
346:     public function __construct($message, $code = 500) {
347:         if (is_array($message)) {
348:             $message += array('enabled' => true);
349:         }
350:         parent::__construct($message, $code);
351:     }
352: 
353: }
354: 
355: /**
356:  * Used when a Task cannot be found.
357:  *
358:  * @package       Cake.Error
359:  */
360: class MissingTaskException extends CakeException {
361: 
362:     protected $_messageTemplate = 'Task class %s could not be found.';
363: 
364: }
365: 
366: /**
367:  * Used when a shell method cannot be found.
368:  *
369:  * @package       Cake.Error
370:  */
371: class MissingShellMethodException extends CakeException {
372: 
373:     protected $_messageTemplate = "Unknown command %1\$s %2\$s.\nFor usage try `cake %1\$s --help`";
374: 
375: }
376: 
377: /**
378:  * Used when a shell cannot be found.
379:  *
380:  * @package       Cake.Error
381:  */
382: class MissingShellException extends CakeException {
383: 
384:     protected $_messageTemplate = 'Shell class %s could not be found.';
385: 
386: }
387: 
388: /**
389:  * Exception class to be thrown when a datasource configuration is not found
390:  *
391:  * @package       Cake.Error
392:  */
393: class MissingDatasourceConfigException extends CakeException {
394: 
395:     protected $_messageTemplate = 'The datasource configuration "%s" was not found in database.php';
396: 
397: }
398: 
399: /**
400:  * Used when a datasource cannot be found.
401:  *
402:  * @package       Cake.Error
403:  */
404: class MissingDatasourceException extends CakeException {
405: 
406:     protected $_messageTemplate = 'Datasource class %s could not be found.';
407: 
408: }
409: 
410: /**
411:  * Exception class to be thrown when a database table is not found in the datasource
412:  *
413:  * @package       Cake.Error
414:  */
415: class MissingTableException extends CakeException {
416: 
417:     protected $_messageTemplate = 'Table %s for model %s was not found in datasource %s.';
418: 
419: }
420: 
421: /**
422:  * Exception raised when a Model could not be found.
423:  *
424:  * @package       Cake.Error
425:  */
426: class MissingModelException extends CakeException {
427: 
428:     protected $_messageTemplate = 'Model %s could not be found.';
429: 
430: }
431: 
432: /**
433:  * Exception raised when a test loader could not be found
434:  *
435:  * @package       Cake.Error
436:  */
437: class MissingTestLoaderException extends CakeException {
438: 
439:     protected $_messageTemplate = 'Test loader %s could not be found.';
440: 
441: }
442: 
443: /**
444:  * Exception raised when a plugin could not be found
445:  *
446:  * @package       Cake.Error
447:  */
448: class MissingPluginException extends CakeException {
449: 
450:     protected $_messageTemplate = 'Plugin %s could not be found.';
451: 
452: }
453: 
454: /**
455:  * Exception raised when a Dispatcher filter could not be found
456:  *
457:  * @package       Cake.Error
458:  */
459: class MissingDispatcherFilterException extends CakeException {
460: 
461:     protected $_messageTemplate = 'Dispatcher filter %s could not be found.';
462: 
463: }
464: 
465: /**
466:  * Exception class for AclComponent and Interface implementations.
467:  *
468:  * @package       Cake.Error
469:  */
470: class AclException extends CakeException {
471: }
472: 
473: /**
474:  * Exception class for Cache.  This exception will be thrown from Cache when it
475:  * encounters an error.
476:  *
477:  * @package       Cake.Error
478:  */
479: class CacheException extends CakeException {
480: }
481: 
482: /**
483:  * Exception class for Router.  This exception will be thrown from Router when it
484:  * encounters an error.
485:  *
486:  * @package       Cake.Error
487:  */
488: class RouterException extends CakeException {
489: }
490: 
491: /**
492:  * Exception class for CakeLog.  This exception will be thrown from CakeLog when it
493:  * encounters an error.
494:  *
495:  * @package       Cake.Error
496:  */
497: class CakeLogException extends CakeException {
498: }
499: 
500: /**
501:  * Exception class for CakeSession.  This exception will be thrown from CakeSession when it
502:  * encounters an error.
503:  *
504:  * @package       Cake.Error
505:  */
506: class CakeSessionException extends CakeException {
507: }
508: 
509: /**
510:  * Exception class for Configure.  This exception will be thrown from Configure when it
511:  * encounters an error.
512:  *
513:  * @package       Cake.Error
514:  */
515: class ConfigureException extends CakeException {
516: }
517: 
518: /**
519:  * Exception class for Socket. This exception will be thrown from CakeSocket, CakeEmail, HttpSocket
520:  * SmtpTransport, MailTransport and HttpResponse when it encounters an error.
521:  *
522:  * @package       Cake.Error
523:  */
524: class SocketException extends CakeException {
525: }
526: 
527: /**
528:  * Exception class for Xml.  This exception will be thrown from Xml when it
529:  * encounters an error.
530:  *
531:  * @package       Cake.Error
532:  */
533: class XmlException extends CakeException {
534: }
535: 
536: /**
537:  * Exception class for Console libraries.  This exception will be thrown from Console library
538:  * classes when they encounter an error.
539:  *
540:  * @package       Cake.Error
541:  */
542: class ConsoleException extends CakeException {
543: }
544: 
545: /**
546:  * Represents a fatal error
547:  *
548:  * @package       Cake.Error
549:  */
550: class FatalErrorException extends CakeException {
551: 
552: /**
553:  * Constructor
554:  *
555:  * @param string $message
556:  * @param integer $code
557:  * @param string $file
558:  * @param integer $line
559:  */
560:     public function __construct($message, $code = 500, $file = null, $line = null) {
561:         parent::__construct($message, $code);
562:         if ($file) {
563:             $this->file = $file;
564:         }
565:         if ($line) {
566:             $this->line = $line;
567:         }
568:     }
569: 
570: }
571: 
572: /**
573:  * Not Implemented Exception - used when an API method is not implemented
574:  *
575:  * @package       Cake.Error
576:  */
577: class NotImplementedException extends CakeException {
578: 
579:     protected $_messageTemplate = '%s is not implemented.';
580: 
581: //@codingStandardsIgnoreStart
582:     public function __construct($message, $code = 501) {
583:         parent::__construct($message, $code);
584:     }
585: //@codingStandardsIgnoreEnd
586: 
587: }
588: