/application/controllers/api.php - Komentovat - FreenetIS - Redmine

freenetis-github/application/controllers/api.php @ 5ab61fb4

-ac9009
+<?php defined('SYSPATH') or die('No direct script access.');
 /*
  * This file is part of open source system FreenetIS
  * and it is release under GPLv3 licence.
+ *
  * More info about licence can be found:
  * http://www.gnu.org/licenses/gpl-3.0.html
+ *
  * More info about project can be found:
  * http://www.freenetis.org/
+ *
  */
 require_once APPPATH . '/vendors/phpax-rs/loader.php';
 require_once APPPATH . '/vendors/php-http-auth-server/loader.php';
 /**
  * FreenetIS REST API builded using PHPAX-RS framework.
  * All requested passed to this controller are handled by PHPAX-RS REST
  * end points classes that are stored in ./api_endpoints folder and their
  * names end with "_Api".
+ *
  * @author Ondřej Fibich <ondrej.fibich@gmail.com>
  * @package Controller
  * @since 1.2
  */
 class Api_Controller extends Controller
+{
     /**
      * Base API path (relative path to this constroller).
      */
     const API_BASE_PATH = '/api';
     /**
      * API end point class name suffix.
      */
     const API_ENDPOINT_SUFFIX = '_Api';
     /**
      * API directory relative to controllers dir that contains all endpoints.
      */
     const API_ENPOIND_DIR = 'api_endpoints';
     /**
      * @var \phpaxrs\PhpaxRs
      */
     private static $phpaxRs = NULL;
     /**
      * Initilize singleton instance of PHPAX-RS framework runtime and adds
      * available serializators and end points.
      */
     public function __construct()
+    {
         parent::__construct();
 		// access control
 		if (!module::e('api'))
+		{
 			self::error(PAGE);
+		}
         // init PHPAX-RS
         if (self::$phpaxRs === NULL)
+        {
             $base_path = rtrim(Settings::get('suffix'), '/') . '/'
                     . Config::get('lang') . self::API_BASE_PATH;
             self::$phpaxRs = new \phpaxrs\PhpaxRs($base_path);
             // add serializators
             self::$phpaxRs->add_serializator('application/json',
                     '\phpaxrs\serializator\JsonSerializator');
             // add end points
             $ds = DIRECTORY_SEPARATOR;
             self::add_end_points(__DIR__ . $ds . self::API_ENPOIND_DIR);
+        }
+    }
     /**
      * We do not need preprocessor.
+     *
      * @return boolean
      */
     protected function is_preprocesor_enabled()
+    {
         return FALSE;
+    }
     /**
      * Maps every request to PHPAX-RS.
+     *
      * @param string $method
      * @param array $args
      */
     public function _remap($method, $args)
+    {
 		$base_url = url::base() . url::current();
 		$part_request_url = '/';
 		if ($method === 'index') { // index method should be ignored in path
 			$method = NULL;
+		}
 		if (!empty($method))
+		{
 			$part_request_url .= $method . '/';
 			if (!empty($args))
+			{
 				$part_request_url .= implode('/', $args);
+			}
 			$part_request_url = '/' . ltrim($part_request_url, '/');
+		}
 		// authorization and authentification
 		if ($this->check_http_auth(request::method(), $part_request_url))
+		{
 			// serve request using PHPAX-RS
 			$response = self::$phpaxRs->serve($base_url);
 			// render response
 			self::$phpaxRs->render($response);
+		}
+    }
     /**
      * Register all end point classes from the given directory.
+     *
      * @param string $dir
      */
     private static function add_end_points($dir)
+    {
         if (!is_dir($dir))
+        {
             self::warning(PARAMETER, 'Invalid API end points directory');
+        }
         $files = scandir($dir);
         if (is_array($files))
+        {
             foreach ($files as $file)
+            {
                 if (is_file($dir . DIRECTORY_SEPARATOR . $file) &&
                     text::ends_with($file, EXT))
+                {
                     $class = substr($file, 0, strlen($file) - strlen(EXT));
                     $path = trim(strtolower(str_replace('_', '/', $class)), '/');
                     $class_full = $class . self::API_ENDPOINT_SUFFIX;
 						self::$phpaxRs->add_endpoint('/' . $path, $class_full);
+                }
+            }
+        }
+    }
 	/**
 	 * Check authorization and authentification using HTTP Digest Authentication
 	 * and API account. If auth failed than the whole script is terminated with
 	 * error response with proper HTTP response status code.
+	 *
 	 * @param string $http_method request HTTP method name
 	 * @param string $req_url_part request URL without API base URL
 	 * @return boolean auth success?
 	 */
 	private function check_http_auth($http_method, $req_url_part)
+	{
 		$sn = Settings::get('domain')
 				. str_replace('/', ' ', Settings::get('suffix')) . ' API';
         $aam = new ApiAccountManager();
         $auth_type = Settings::get('api_auth_type');
 		$handler = \phphttpauthserver\HttpAuth::factory($auth_type, $aam, $sn);
 		$auth_rsp = $handler->auth();
 		// authentification failed?
 		if (!$auth_rsp->isPassed())
+		{
 			self::trigger_auth_error(401, $auth_rsp->getErrors(),
 					$auth_rsp->getHeaders());
+		}
         // proceed with authorization
         $api_account = $aam->get_user_account($auth_rsp->getUsername());
         // API account not found
         if (!$api_account->id)
+        {
             self::trigger_auth_error(500, 'API account not found');
+        }
         // log access
         try
+        {
             $log_type = Api_account_log_Model::get_rq_type_of($http_method);
             $description = mb_strtoupper($http_method) . ' ' . $req_url_part;
             $api_account->create_request_log($log_type, $description)
                 ->save_throwable();
+        }
         catch (InvalidArgumentException $ex)
+        {
             self::trigger_auth_error(405); // HTTP method not accepted
+        }
         catch (Exception $ex)
+        {
             self::trigger_auth_error(500, 'API log failed, cause: ' . $ex);
+        }
         // API account not allowed?
         if (!$api_account->enabled)
+        {
             self::trigger_auth_error(403);
+        }
         // Reaonly access -> only GET HTTP method allowed for request
         if ($api_account->readonly && mb_strtoupper($http_method) !== 'GET')
+        {
             self::trigger_auth_error(403);
+        }
         // API account access restricted to allowed template paths?
         if (!empty($api_account->allowed_paths))
+        {
             $allowed_tpaths = explode(',', $api_account->allowed_paths);
             if (!empty($allowed_tpaths) &&
                 !url_tpath::match_one_of($allowed_tpaths, $req_url_part))
+            {
                 self::trigger_auth_error(403);
+            }
+        }
         // OK allowed
         return TRUE;
+	}
 	/**
 	 * Renders authorization or authentification error and exists.
+	 *
 	 * @staticvar array $status_codes allowed status codes
 	 * @param integer $status_code HTTP status code (one of allowed)
 	 * @param array|string $errors array of errors
 	 * @param array $headers HTTP headers as associative array
 	 * @throws ErrorException on invalid state or arguments
 	 */
 	private static function trigger_auth_error($status_code, $errors = array(),
 			$headers = array())
+	{
 		// status codes names
 		static $status_codes = array
+		(
 => 'Unauthorized',
 => 'Forbidden',
 => 'Method Not Allowed',
 => 'Internal Server Error'
 		);
 		// render status code
 		if (headers_sent())
+		{
 			throw ErrorException('E' . $status_code . ': headers already send');
+		}
 		if (!array_key_exists($status_code, $status_codes))
+		{
 			throw ErrorException('Invalid status code: ' . $status_code);
+		}
 		header('HTTP/1.1 ' . $status_code . ' ' . $status_codes[$status_code]);
 		// add headers
 		if (!empty($headers))
+		{
 			foreach ($headers as $key => $value)
+			{
 				header($key . ': ' . $value);
+			}
+		}
 		// output errors
 		if (!empty($errors))
+		{
 			if (is_string($errors))
+			{
 				$errors = array($errors);
+			}
 			echo implode("\n", $errors) . "\n";
+		}
 		exit();
+	}
+}
 /**
  * Account manager implementation using API account model.
+ *
  * @link Api_account_Model
  */
 class ApiAccountManager implements \phphttpauthserver\IAccountManager
+{
 	/**
 	 * API account model used for obtaining account informations.
+	 *
 	 * @var Api_account_Model
 	 */
 	private $api_account_model;
 	public function __construct()
+	{
 		$this->api_account_model = new Api_account_Model();
+	}
 	/*
 	 * @override
 	 */
 	public function getUserPassword($username)
+	{
-ab61fb4
+        try
-ac9009
+            Ondřej Fibich
 			$ua = $this->api_account_model->find_by_username($username);
-ab61fb4
+            Michal Kliment
 			if ($ua === NULL)
+			{
 				return FALSE;
+			}
 			return $ua->token;
-ac9009
+            Ondřej Fibich
-ab61fb4
+		catch (Exception $ex)
-ac9009
+            Ondřej Fibich
 			Log::add_exception($ex);
 			return FALSE;
+		}
+	}
 	/**
 	 * Gets API account that has given username or returns NULL if not found
 	 * or some error occures.
+	 *
 	 * @param string $username
 	 * @return Api_account_Model|null
 	 */
 	public function get_user_account($username)
+	{
 		try
+		{
 			return $this->api_account_model->find_by_username($username);
+		}
 		catch (Exception $ex)
+		{
 			Log::add_exception($ex);
 			return NULL;
+		}
+	}
+}

Projekt

Obecné

Profil

FreenetIS