src/App/Arguments.php

   1 <?php
   2 /**
   3  * @copyright Copyright (C) 2010-2023, 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\App;
  23
  24 /**
  25  * Determine all arguments of the current call, including
  26  * - The whole querystring (except the pagename/q parameter)
  27  * - The command
  28  * - The arguments (C-Style based)
  29  * - The count of arguments
  30  */
  31 class Arguments
  32 {
  33         const DEFAULT_MODULE = 'home';
  34
  35         /**
  36          * @var string The complete query string
  37          */
  38         private $queryString;
  39         /**
  40          * @var string The current Friendica command
  41          */
  42         private $command;
  43         /**
  44          * @var string The name of the current module
  45          */
  46         private $moduleName;
  47         /**
  48          * @var array The arguments of the current execution
  49          */
  50         private $argv;
  51         /**
  52          * @var int The count of arguments
  53          */
  54         private $argc;
  55         /**
  56          * @var string The used HTTP method
  57          */
  58         private $method;
  59
  60         public function __construct(string $queryString = '', string $command = '', string $moduleName = '', array $argv = [], int $argc = 0, string $method = Router::GET)
  61         {
  62                 $this->queryString = $queryString;
  63                 $this->command     = $command;
  64                 $this->moduleName  = $moduleName;
  65                 $this->argv        = $argv;
  66                 $this->argc        = $argc;
  67                 $this->method      = $method;
  68         }
  69
  70         /**
  71          * @return string The whole query string of this call with url-encoded query parameters
  72          */
  73         public function getQueryString()
  74         {
  75                 return $this->queryString;
  76         }
  77
  78         /**
  79          * @return string The whole command of this call
  80          */
  81         public function getCommand(): string
  82         {
  83                 return $this->command;
  84         }
  85
  86         /**
  87          * @return string The module name based on the arguments
  88          * @deprecated 2022.12 - With the new (sub-)routes, it's not trustworthy anymore, use the ModuleClass instead
  89          * @see Router::getModuleClass()
  90          */
  91         public function getModuleName(): string
  92         {
  93                 return $this->moduleName;
  94         }
  95
  96         /**
  97          * @return array All arguments of this call
  98          */
  99         public function getArgv(): array
 100         {
 101                 return $this->argv;
 102         }
 103
 104         /**
 105          * @return string The used HTTP method
 106          */
 107         public function getMethod(): string
 108         {
 109                 return $this->method;
 110         }
 111
 112         /**
 113          * @return int The count of arguments of this call
 114          */
 115         public function getArgc(): int
 116         {
 117                 return $this->argc;
 118         }
 119
 120         public function setArgv(array $argv)
 121         {
 122                 $this->argv = $argv;
 123                 $this->argc = count($argv);
 124         }
 125
 126         public function setArgc(int $argc)
 127         {
 128                 $this->argc = $argc;
 129         }
 130
 131         /**
 132          * Returns the value of a argv key
 133          * @todo there are a lot of $a->argv usages in combination with ?? which can be replaced with this method
 134          *
 135          * @param int   $position the position of the argument
 136          * @param mixed $default  the default value if not found
 137          *
 138          * @return mixed returns the value of the argument
 139          */
 140         public function get(int $position, $default = '')
 141         {
 142                 return $this->has($position) ? $this->argv[$position] : $default;
 143         }
 144
 145         /**
 146          * @param int $position
 147          *
 148          * @return bool if the argument position exists
 149          */
 150         public function has(int $position): bool
 151         {
 152                 return array_key_exists($position, $this->argv);
 153         }
 154
 155         /**
 156          * Determine the arguments of the current call
 157          *
 158          * @param array $server The $_SERVER variable
 159          * @param array $get    The $_GET variable
 160          *
 161          * @return Arguments The determined arguments
 162          */
 163         public function determine(array $server, array $get): Arguments
 164         {
 165                 // removing leading / - maybe a nginx problem
 166                 $server['QUERY_STRING'] = ltrim($server['QUERY_STRING'] ?? '', '/');
 167
 168                 $queryParameters = [];
 169                 parse_str($server['QUERY_STRING'], $queryParameters);
 170
 171                 if (!empty($get['pagename'])) {
 172                         $command = trim($get['pagename'], '/\\');
 173                 } elseif (!empty($queryParameters['pagename'])) {
 174                         $command = trim($queryParameters['pagename'], '/\\');
 175                 } elseif (!empty($get['q'])) {
 176                         // Legacy page name parameter, now conflicts with the search query parameter
 177                         $command = trim($get['q'], '/\\');
 178                 } else {
 179                         $command = '';
 180                 }
 181
 182                 // Remove generated and one-time use parameters
 183                 unset($queryParameters['pagename']);
 184                 unset($queryParameters['zrl']);
 185                 unset($queryParameters['owt']);
 186
 187                 /*
 188                  * Break the URL path into C style argc/argv style arguments for our
 189                  * modules. Given "http://example.com/module/arg1/arg2", $this->argc
 190                  * will be 3 (integer) and $this->argv will contain:
 191                  *   [0] => 'module'
 192                  *   [1] => 'arg1'
 193                  *   [2] => 'arg2'
 194                  */
 195                 if ($command) {
 196                         $argv = explode('/', $command);
 197                 } else {
 198                         $argv = [];
 199                 }
 200
 201                 $argc = count($argv);
 202
 203                 $queryString = $command . ($queryParameters ? '?' . http_build_query($queryParameters) : '');
 204
 205                 if ($argc > 0) {
 206                         $module = str_replace('.', '_', $argv[0]);
 207                         $module = str_replace('-', '_', $module);
 208                 } else {
 209                         $module = self::DEFAULT_MODULE;
 210                 }
 211
 212                 // Compatibility with the Firefox App
 213                 if (($module == "users") && ($command == "users/sign_in")) {
 214                         $module = "login";
 215                 }
 216
 217                 $httpMethod = in_array($server['REQUEST_METHOD'] ?? '', Router::ALLOWED_METHODS) ? $server['REQUEST_METHOD'] : Router::GET;
 218
 219                 return new Arguments($queryString, $command, $module, $argv, $argc, $httpMethod);
 220         }
 221 }