/**
  * Create an {@link ErrorPage} for status code 503
  * 
  * @see UnderConstruction_Extension::onBeforeInit()
  * @see DataObjectDecorator::requireDefaultRecords()
  * @return Void
  */
 function requireDefaultRecords()
 {
     // Ensure that an assets path exists before we do any error page creation
     if (!file_exists(ASSETS_PATH)) {
         mkdir(ASSETS_PATH);
     }
     $pageUnderConstructionErrorPage = DataObject::get_one('ErrorPage', "\"ErrorCode\" = '503'");
     $pageUnderConstructionErrorPageExists = $pageUnderConstructionErrorPage && $pageUnderConstructionErrorPage->exists() ? true : false;
     $pageUnderConstructionErrorPagePath = ErrorPage::get_filepath_for_errorcode(503);
     if (!($pageUnderConstructionErrorPageExists && file_exists($pageUnderConstructionErrorPagePath))) {
         if (!$pageUnderConstructionErrorPageExists) {
             $pageUnderConstructionErrorPage = new ErrorPage();
             $pageUnderConstructionErrorPage->ErrorCode = 503;
             $pageUnderConstructionErrorPage->Title = _t('UnderConstruction.TITLE', 'Under Construction');
             $pageUnderConstructionErrorPage->Content = _t('UnderConstruction.CONTENT', '<p>Sorry, this site is currently under construction.</p>');
             $pageUnderConstructionErrorPage->Status = 'New page';
             $pageUnderConstructionErrorPage->write();
             $pageUnderConstructionErrorPage->publish('Stage', 'Live');
         }
         // Ensure a static error page is created from latest error page content
         $response = Director::test(Director::makeRelative($pageUnderConstructionErrorPage->Link()));
         if ($fh = fopen($pageUnderConstructionErrorPagePath, 'w')) {
             $written = fwrite($fh, $response->getBody());
             fclose($fh);
         }
         if ($written) {
             DB::alteration_message('503 error page created', 'created');
         } else {
             DB::alteration_message(sprintf('503 error page could not be created at %s. Please check permissions', $pageUnderConstructionErrorPagePath), 'error');
         }
     }
 }

 static function die_fancy($except)
 {
     // Log the error?
     if ($except instanceof InternalException) {
         Log::error($except->getMessage());
     }
     // Utility: error pages
     $view = new ErrorPage($except);
     $view->write();
     exit;
 }

	/**
	 * Ensures that there is always a 404 page
	 * by checking if there's an instance of
	 * ErrorPage with a 404 error code. If there
	 * is not, one is created when the DB is built.
	 */
	function requireDefaultRecords() {
		parent::requireDefaultRecords();

		if(!DataObject::get_one('ErrorPage', "ErrorCode = '404'")) {
			$errorpage = new ErrorPage();
			$errorpage->ErrorCode = 404;
			$errorpage->Title = _t('ErrorPage.DEFAULTERRORPAGETITLE', 'Page not found');
			$errorpage->URLSegment = 'page-not-found';
			$errorpage->Content = _t('ErrorPage.DEFAULTERRORPAGECONTENT', '<p>Sorry, it seems you were trying to access a page that doesn\'t exist.</p><p>Please check the spelling of the URL you were trying to access and try again.</p>');
			$errorpage->Status = 'New page';
			$errorpage->write();
			
			Database::alteration_message('404 page created', 'created');
		}
	}

 public function testLinkShortcodeHandler()
 {
     $testFile = $this->objFromFixture('File', 'asdf');
     $parser = new ShortcodeParser();
     $parser->register('file_link', array('File', 'handle_shortcode'));
     $fileShortcode = sprintf('[file_link,id=%d]', $testFile->ID);
     $fileEnclosed = sprintf('[file_link,id=%d]Example Content[/file_link]', $testFile->ID);
     $fileShortcodeExpected = $testFile->Link();
     $fileEnclosedExpected = sprintf('<a href="%s" class="file" data-type="txt" data-size="977 KB">Example Content</a>', $testFile->Link());
     $this->assertEquals($fileShortcodeExpected, $parser->parse($fileShortcode), 'Test that simple linking works.');
     $this->assertEquals($fileEnclosedExpected, $parser->parse($fileEnclosed), 'Test enclosed content is linked.');
     $testFile->delete();
     $fileShortcode = '[file_link,id="-1"]';
     $fileEnclosed = '[file_link,id="-1"]Example Content[/file_link]';
     $this->assertEquals('', $parser->parse('[file_link]'), 'Test that invalid ID attributes are not parsed.');
     $this->assertEquals('', $parser->parse('[file_link,id="text"]'));
     $this->assertEquals('', $parser->parse('[file_link]Example Content[/file_link]'));
     if (class_exists('ErrorPage')) {
         $errorPage = ErrorPage::get()->filter('ErrorCode', 404)->First();
         $this->assertEquals($errorPage->Link(), $parser->parse($fileShortcode), 'Test link to 404 page if no suitable matches.');
         $this->assertEquals(sprintf('<a href="%s">Example Content</a>', $errorPage->Link()), $parser->parse($fileEnclosed));
     } else {
         $this->assertEquals('', $parser->parse($fileShortcode), 'Short code is removed if file record is not present.');
         $this->assertEquals('', $parser->parse($fileEnclosed));
     }
 }

 public function onBeforeHTTPError($statusCode, $request)
 {
     $response = ErrorPage::response_for($statusCode);
     if ($response) {
         throw new SS_HTTPResponse_Exception($response, $statusCode);
     }
 }

 public function output()
 {
     // TODO: Refactor into a content-type option
     if (\Director::is_ajax()) {
         return $this->friendlyErrorMessage;
     } else {
         // TODO: Refactor this into CMS
         if (class_exists('ErrorPage')) {
             $errorFilePath = \ErrorPage::get_filepath_for_errorcode($this->statusCode, class_exists('Translatable') ? \Translatable::get_current_locale() : null);
             if (file_exists($errorFilePath)) {
                 $content = file_get_contents($errorFilePath);
                 if (!headers_sent()) {
                     header('Content-Type: text/html');
                 }
                 // $BaseURL is left dynamic in error-###.html, so that multi-domain sites don't get broken
                 return str_replace('$BaseURL', \Director::absoluteBaseURL(), $content);
             }
         }
         $renderer = \Debug::create_debug_view();
         $output = $renderer->renderHeader();
         $output .= $renderer->renderInfo("Website Error", $this->friendlyErrorMessage, $this->friendlyErrorDetail);
         if (\Email::config()->admin_email) {
             $mailto = \Email::obfuscate(\Email::config()->admin_email);
             $output .= $renderer->renderParagraph('Contact an administrator: ' . $mailto . '');
         }
         $output .= $renderer->renderFooter();
         return $output;
     }
 }

function __autoload($classe)
{
    $classe = $classe . '.php';
    if (file_exists('Controller' . DS . $classe)) {
        require_once 'Controller' . DS . $classe;
    } else {
        if (file_exists('Model' . DS . $classe)) {
            require_once 'Model' . DS . $classe;
        } else {
            if (file_exists('Model' . DS . 'Entity' . DS . $classe)) {
                require_once 'Model' . DS . 'Entity' . DS . $classe;
            } else {
                if (file_exists('Model' . DS . 'Interface' . DS . $classe)) {
                    require_once 'Model' . DS . 'Interface' . DS . $classe;
                } else {
                    if (file_exists('Library' . DS . $classe)) {
                        require_once 'Library' . DS . $classe;
                    } else {
                        if (file_exists('Exceptions' . DS . $classe)) {
                            require_once 'Exceptions' . DS . $classe;
                        } else {
                            ///se a pagina nao for encontrada ela renderiza errorPage
                            ErrorPage::page404NotFound($classe);
                        }
                    }
                }
            }
        }
    }
}

 public static function create_default_error_page($code = 404, $values = [], $type = 'ErrorPage')
 {
     if (class_exists('ErrorPage')) {
         return;
     }
     $pagePath = \ErrorPage::get_filepath_for_errorcode($code);
     if (!DataList::create('ErrorPage')->filter('ErrorCode', $code)->exists() || !file_exists($pagePath)) {
         $page = Object::create($type);
         foreach ($values as $f => $v) {
             $page->{$f} = $v;
         }
         $page->ErrorCode = $code;
         $page->write();
         $page->publish('Stage', 'Live');
         $response = static::test(static::makeRelative($page->Link()));
         $written = null;
         if ($fh = fopen($pagePath, 'w')) {
             $written = fwrite($fh, $response->getBody());
             fclose($fh);
         }
         if ($written) {
             DB::alteration_message($page->Title . ' Page created', 'created');
         } else {
             DB::alteration_message(sprintf($page->Title . ' Page could not be created at %s. Please check permissions', $pagePath), 'error');
         }
     }
 }

 public function getByLink($url)
 {
     if (!($page = Page::get_by_link($url))) {
         $page = ErrorPage::get()->filter('ErrorCode', 404)->first();
     }
     $data = array('timepstamp' => time(), 'page' => $page->forAPI());
     return $data;
 }

 /**
  * Ensures that there is always a 404 page.
  */
 function requireDefaultRecords()
 {
     parent::requireDefaultRecords();
     if (!DataObject::get_one("ErrorPage", "ErrorCode = '404'")) {
         $errorpage = new ErrorPage();
         $errorpage->ErrorCode = 404;
         $errorpage->Title = _t('ErrorPage.DEFAULTERRORPAGETITLE', 'Page not found');
         $errorpage->URLSegment = "page-not-found";
         $errorpage->ShowInMenus = false;
         $errorpage->Content = _t('ErrorPage.DEFAULTERRORPAGECONTENT', '<p>Sorry, it seems you were trying to access a page that doesn\'t exist.</p><p>Please check the spelling of the URL you were trying to access and try again.</p>');
         $errorpage->Status = "New page";
         $errorpage->write();
         // Don't publish, as the manifest may not be built yet
         // $errorpage->publish("Stage", "Live");
         Database::alteration_message("404 page created", "created");
     }
 }

 static function require_admin()
 {
     $user = Authentication::require_user();
     if (!$user->is_admin) {
         ErrorPage::die_fancy(new NotAuthorizedException());
     }
     return $user;
 }

 function tearDown()
 {
     parent::tearDown();
     ErrorPage::set_static_filepath($this->orig['ErrorPage_staticfilepath']);
     Director::set_environment_type($this->orig['Director_environmenttype']);
     Filesystem::removeFolder($this->tmpAssetsPath . '/ErrorPageTest');
     Filesystem::removeFolder($this->tmpAssetsPath);
 }

 public function tearDown()
 {
     parent::tearDown();
     ErrorPage::config()->static_filepath = $this->orig['ErrorPage_staticfilepath'];
     Filesystem::removeFolder($this->tmpAssetsPath . '/ErrorPageTest');
     Filesystem::removeFolder($this->tmpAssetsPath);
     Config::inst()->update('Director', 'environment_type', $this->origEnvType);
 }

 function testErrorPageLocations()
 {
     $subsite1 = $this->objFromFixture('Subsite', 'domaintest1');
     Subsite::changeSubsite($subsite1->ID);
     $path = ErrorPage::get_filepath_for_errorcode(500);
     $static_path = Config::inst()->get('ErrorPage', 'static_filepath');
     $expected_path = $static_path . '/error-500-' . $subsite1->domain() . '.html';
     $this->assertEquals($expected_path, $path);
 }

 public function httpError($code, $message = null)
 {
     if (!Permission::check("ADMIN")) {
         $response = ErrorPage::response_for($code);
     }
     if (empty($response)) {
         $response = $message;
     }
     throw new SS_HTTPResponse_Exception($response);
 }

 /**
  * Process IPN request from ClickBank. Only process POST request
  * 
  * @param	object	$_POST
  * @return	int		HTTP code 
  */
 public function ipn(SS_HTTPRequest $request)
 {
     if ($request->isPost()) {
         if (ClickBankManager::validate_ipn_request($request->postVars())) {
             ClickBankManager::process_ipn_request($request->postVars());
             return Director::get_status_code();
         }
     }
     return ErrorPage::response_for(404);
 }

 /**
  *	Retrieve the correct error page for the current multisite instance.
  *	@param integer
  *	@param SS_HTTPRequest
  *	@throws SS_HTTPResponse_Exception
  */
 public function onBeforeHTTPError($code, $request)
 {
     $errorPage = ErrorPage::get()->filter(array('ErrorCode' => $code, 'SiteID' => Multisites::inst()->getCurrentSiteId()))->first();
     if ($errorPage) {
         Requirements::clear();
         Requirements::clear_combined_files();
         $response = ModelAsController::controller_for($errorPage)->handleRequest($request, DataModel::inst());
         throw new SS_HTTPResponse_Exception($response, $code);
     }
 }

 public function requireDefaultRecords()
 {
     if (Config::inst()->get('UniversalErrorPage', 'ConvertOnDevBuild')) {
         $ErrorPages = ErrorPage::get()->filter('ClassName', 'ErrorPage');
         foreach ($ErrorPages as $ErrorPage) {
             $ErrorPage->ClassName = 'UniversalErrorPage';
             $ErrorPage->write();
             $ErrorPage->doPublish();
             DB::alteration_message("#{$ErrorPage->ID} {$ErrorPage->Title} changed to UniversalErrorPage.", "changed");
         }
     }
 }

 public function alternateFilepathForErrorcode($code, $locale)
 {
     $path = ErrorPage::get_static_filepath();
     $parts = array();
     if ($site = Multisites::inst()->getActiveSite()) {
         $parts[] = $site->Host;
     }
     $parts[] = $code;
     if ($locale && $this->owner->hasExtension('Translatable') && $locale != Translatable::default_locale()) {
         $parts[] = $locale;
     }
     return sprintf("%s/error-%s.html", $path, implode('-', $parts));
 }

 function onBeforeInit()
 {
     if (Config::inst()->get('IpAccess', 'enabled')) {
         $ipAccess = new IpAccess($this->owner->getRequest()->getIP(), Config::inst()->get('IpAccess', 'allowed_ips'));
         if (!$ipAccess->hasAccess()) {
             if (class_exists('ErrorPage', true)) {
                 $response = ErrorPage::response_for(403);
             }
             $response = $response ? $response : 'The requested page could not be found.';
             return $this->owner->httpError(403, $response);
         }
     }
 }