src/Module/BaseApi.php

   1 <?php
   2 /**
   3  * @copyright Copyright (C) 2010-2021, the Friendica project
   4  *
   5  * @license GNU AGPL version 3 or any later version
   6  *
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as
   9  * published by the Free Software Foundation, either version 3 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  19  *
  20  */
  21
  22 namespace Friendica\Module;
  23
  24 use Friendica\BaseModule;
  25 use Friendica\Core\Logger;
  26 use Friendica\Core\System;
  27 use Friendica\DI;
  28 use Friendica\Network\HTTPException;
  29 use Friendica\Security\BasicAuth;
  30 use Friendica\Security\OAuth;
  31 use Friendica\Util\HTTPInputData;
  32
  33 require_once __DIR__ . '/../../include/api.php';
  34
  35 class BaseApi extends BaseModule
  36 {
  37         const SCOPE_READ   = 'read';
  38         const SCOPE_WRITE  = 'write';
  39         const SCOPE_FOLLOW = 'follow';
  40         const SCOPE_PUSH   = 'push';
  41
  42         /**
  43          * @var string json|xml|rss|atom
  44          */
  45         protected static $format = 'json';
  46
  47         public static function init(array $parameters = [])
  48         {
  49                 $arguments = DI::args();
  50
  51                 if (substr($arguments->getCommand(), -4) === '.xml') {
  52                         self::$format = 'xml';
  53                 }
  54                 if (substr($arguments->getCommand(), -4) === '.rss') {
  55                         self::$format = 'rss';
  56                 }
  57                 if (substr($arguments->getCommand(), -4) === '.atom') {
  58                         self::$format = 'atom';
  59                 }
  60         }
  61
  62         public static function delete(array $parameters = [])
  63         {
  64                 if (!api_user()) {
  65                         throw new HTTPException\UnauthorizedException(DI::l10n()->t('Permission denied.'));
  66                 }
  67
  68                 $a = DI::app();
  69
  70                 if (!empty($a->user['uid']) && $a->user['uid'] != api_user()) {
  71                         throw new HTTPException\ForbiddenException(DI::l10n()->t('Permission denied.'));
  72                 }
  73         }
  74
  75         public static function patch(array $parameters = [])
  76         {
  77                 if (!api_user()) {
  78                         throw new HTTPException\UnauthorizedException(DI::l10n()->t('Permission denied.'));
  79                 }
  80
  81                 $a = DI::app();
  82
  83                 if (!empty($a->user['uid']) && $a->user['uid'] != api_user()) {
  84                         throw new HTTPException\ForbiddenException(DI::l10n()->t('Permission denied.'));
  85                 }
  86         }
  87
  88         public static function post(array $parameters = [])
  89         {
  90                 if (!api_user()) {
  91                         throw new HTTPException\UnauthorizedException(DI::l10n()->t('Permission denied.'));
  92                 }
  93
  94                 $a = DI::app();
  95
  96                 if (!empty($a->user['uid']) && $a->user['uid'] != api_user()) {
  97                         throw new HTTPException\ForbiddenException(DI::l10n()->t('Permission denied.'));
  98                 }
  99         }
 100
 101         public static function put(array $parameters = [])
 102         {
 103                 if (!api_user()) {
 104                         throw new HTTPException\UnauthorizedException(DI::l10n()->t('Permission denied.'));
 105                 }
 106
 107                 $a = DI::app();
 108
 109                 if (!empty($a->user['uid']) && $a->user['uid'] != api_user()) {
 110                         throw new HTTPException\ForbiddenException(DI::l10n()->t('Permission denied.'));
 111                 }
 112         }
 113
 114         /**
 115          * Quit execution with the message that the endpoint isn't implemented
 116          *
 117          * @param string $method
 118          * @return void
 119          */
 120         public static function unsupported(string $method = 'all')
 121         {
 122                 $path = DI::args()->getQueryString();
 123                 Logger::info('Unimplemented API call', ['method' => $method, 'path' => $path, 'agent' => $_SERVER['HTTP_USER_AGENT'] ?? '', 'request' => HTTPInputData::process()]);
 124                 $error = DI::l10n()->t('API endpoint %s %s is not implemented', strtoupper($method), $path);
 125                 $error_description = DI::l10n()->t('The API endpoint is currently not implemented but might be in the future.');
 126                 $errorobj = new \Friendica\Object\Api\Mastodon\Error($error, $error_description);
 127                 System::jsonError(501, $errorobj->toArray());
 128         }
 129
 130         /**
 131          * Processes data from GET requests and sets defaults
 132          *
 133          * @return array request data
 134          */
 135         public static function getRequest(array $defaults)
 136         {
 137                 $httpinput = HTTPInputData::process();
 138                 $input = array_merge($httpinput['variables'], $httpinput['files'], $_REQUEST);
 139
 140                 $request = [];
 141
 142                 foreach ($defaults as $parameter => $defaultvalue) {
 143                         if (is_string($defaultvalue)) {
 144                                 $request[$parameter] = $input[$parameter] ?? $defaultvalue;
 145                         } elseif (is_int($defaultvalue)) {
 146                                 $request[$parameter] = (int)($input[$parameter] ?? $defaultvalue);
 147                         } elseif (is_float($defaultvalue)) {
 148                                 $request[$parameter] = (float)($input[$parameter] ?? $defaultvalue);
 149                         } elseif (is_array($defaultvalue)) {
 150                                 $request[$parameter] = $input[$parameter] ?? [];
 151                         } elseif (is_bool($defaultvalue)) {
 152                                 $request[$parameter] = in_array(strtolower($input[$parameter] ?? ''), ['true', '1']);
 153                         } else {
 154                                 Logger::notice('Unhandled default value type', ['parameter' => $parameter, 'type' => gettype($defaultvalue)]);
 155                         }
 156                 }
 157
 158                 foreach ($input ?? [] as $parameter => $value) {
 159                         if ($parameter == 'pagename') {
 160                                 continue;
 161                         }
 162                         if (!in_array($parameter, array_keys($defaults))) {
 163                                 Logger::notice('Unhandled request field', ['parameter' => $parameter, 'value' => $value, 'command' => DI::args()->getCommand()]);
 164                         }
 165                 }
 166
 167                 Logger::debug('Got request parameters', ['request' => $request, 'command' => DI::args()->getCommand()]);
 168                 return $request;
 169         }
 170
 171         /**
 172          * Get current application token
 173          *
 174          * @return array token
 175          */
 176         protected static function getCurrentApplication()
 177         {
 178                 $token = OAuth::getCurrentApplicationToken();
 179
 180                 if (empty($token)) {
 181                         $token = BasicAuth::getCurrentApplicationToken();
 182                 }
 183
 184                 return $token;
 185         }
 186
 187         /**
 188          * Get current user id, returns 0 if not logged in
 189          *
 190          * @return int User ID
 191          */
 192         public static function getCurrentUserID()
 193         {
 194                 $uid = OAuth::getCurrentUserID();
 195
 196                 if (empty($uid)) {
 197                         $uid = BasicAuth::getCurrentUserID(false);
 198                 }
 199
 200                 return (int)$uid;
 201         }
 202
 203         /**
 204          * Check if the provided scope does exist.
 205          * halts execution on missing scope or when not logged in.
 206          *
 207          * @param string $scope the requested scope (read, write, follow, push)
 208          */
 209         public static function checkAllowedScope(string $scope)
 210         {
 211                 $token = self::getCurrentApplication();
 212
 213                 if (empty($token)) {
 214                         Logger::notice('Empty application token');
 215                         DI::mstdnError()->Forbidden();
 216                 }
 217
 218                 if (!isset($token[$scope])) {
 219                         Logger::warning('The requested scope does not exist', ['scope' => $scope, 'application' => $token]);
 220                         DI::mstdnError()->Forbidden();
 221                 }
 222
 223                 if (empty($token[$scope])) {
 224                         Logger::warning('The requested scope is not allowed', ['scope' => $scope, 'application' => $token]);
 225                         DI::mstdnError()->Forbidden();
 226                 }
 227         }
 228
 229         /**
 230          * Get user info array.
 231          *
 232          * @param int|string $contact_id Contact ID or URL
 233          * @return array|bool
 234          * @throws HTTPException\BadRequestException
 235          * @throws HTTPException\InternalServerErrorException
 236          * @throws HTTPException\UnauthorizedException
 237          * @throws \ImagickException
 238          */
 239         protected static function getUser($contact_id = null)
 240         {
 241                 return api_get_user(DI::app(), $contact_id);
 242         }
 243
 244         /**
 245          * Formats the data according to the data type
 246          *
 247          * @param string $root_element
 248          * @param array $data An array with a single element containing the returned result
 249          * @return false|string
 250          */
 251         protected static function format(string $root_element, array $data)
 252         {
 253                 $return = api_format_data($root_element, self::$format, $data);
 254
 255                 switch (self::$format) {
 256                         case "xml":
 257                                 header("Content-Type: text/xml");
 258                                 break;
 259                         case "json":
 260                                 header("Content-Type: application/json");
 261                                 if (!empty($return)) {
 262                                         $json = json_encode(end($return));
 263                                         if (!empty($_GET['callback'])) {
 264                                                 $json = $_GET['callback'] . "(" . $json . ")";
 265                                         }
 266                                         $return = $json;
 267                                 }
 268                                 break;
 269                         case "rss":
 270                                 header("Content-Type: application/rss+xml");
 271                                 $return  = '<?xml version="1.0" encoding="UTF-8"?>' . "\n" . $return;
 272                                 break;
 273                         case "atom":
 274                                 header("Content-Type: application/atom+xml");
 275                                 $return = '<?xml version="1.0" encoding="UTF-8"?>' . "\n" . $return;
 276                                 break;
 277                 }
 278
 279                 return $return;
 280         }
 281
 282         /**
 283          * Creates the XML from a JSON style array
 284          *
 285          * @param $data
 286          * @param $root_element
 287          * @return string
 288          */
 289         protected static function createXml($data, $root_element)
 290         {
 291                 return api_create_xml($data, $root_element);
 292         }
 293 }