Api::getCustomCallPlugins() - Code Metrics - Inspection of "catch ArgumentCountError and return XML error mess..." - splitbrain/dokuwiki - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — remote-argumentcount ( e1215f )

by Henry

created 2020-03-03 03:52 UTC

Api::getCustomCallPlugins() A

↳ Parent: Api

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
nc	2
nop	0
dl	0
loc	9
rs	9.9666
c	0
b	0
f	0

<?php

namespace dokuwiki\Remote;

use dokuwiki\Extension\Event;
use dokuwiki\Extension\RemotePlugin;

/**
 * This class provides information about remote access to the wiki.
 *
 * == Types of methods ==
 * There are two types of remote methods. The first is the core methods.
 * These are always available and provided by dokuwiki.
 * The other is plugin methods. These are provided by remote plugins.
 *
 * == Information structure ==
 * The information about methods will be given in an array with the following structure:
 * array(
 *     'method.remoteName' => array(
 *          'args' => array(
 *              'type eg. string|int|...|date|file',
 *          )
 *          'name' => 'method name in class',
 *          'return' => 'type',
 *          'public' => 1/0 - method bypass default group check (used by login)
 *          ['doc' = 'method documentation'],
 *     )
 * )
 *
 * plugin names are formed the following:
 *   core methods begin by a 'dokuwiki' or 'wiki' followed by a . and the method name itself.
 *   i.e.: dokuwiki.version or wiki.getPage
 *
 * plugin methods are formed like 'plugin.<plugin name>.<method name>'.
 * i.e.: plugin.clock.getTime or plugin.clock_gmt.getTime
 */
class Api
{

    /**
     * @var ApiCore
     */
    private $coreMethods = null;

    /**
     * @var array remote methods provided by dokuwiki plugins - will be filled lazy via
     * {@see dokuwiki\Remote\RemoteAPI#getPluginMethods}
     */
    private $pluginMethods = null;

    /**
     * @var array contains custom calls to the api. Plugins can use the XML_CALL_REGISTER event.
     * The data inside is 'custom.call.something' => array('plugin name', 'remote method name')
     *
     * The remote method name is the same as in the remote name returned by _getMethods().
     */
    private $pluginCustomCalls = null;

    private $dateTransformation;
    private $fileTransformation;

    /**
     * constructor
     */
    public function __construct()
    {
        $this->dateTransformation = array($this, 'dummyTransformation');
        $this->fileTransformation = array($this, 'dummyTransformation');
    }

    /**
     * Get all available methods with remote access.
     *
     * @return array with information to all available methods
     * @throws RemoteException
     */
    public function getMethods()
    {
        return array_merge($this->getCoreMethods(), $this->getPluginMethods());
    }

    /**
     * Call a method via remote api.
     *
     * @param string $method name of the method to call.
     * @param array $args arguments to pass to the given method
     * @return mixed result of method call, must be a primitive type.
     * @throws RemoteException
     */
    public function call($method, $args = array())
    {
        if ($args === null) {
            $args = array();
        }
        list($type, $pluginName, /* $call */) = explode('.', $method, 3);
        if ($type === 'plugin') {
            return $this->callPlugin($pluginName, $method, $args);
        }
        if ($this->coreMethodExist($method)) {
            return $this->callCoreMethod($method, $args);
        }
        return $this->callCustomCallPlugin($method, $args);
    }

    /**
     * Check existance of core methods
     *
     * @param string $name name of the method
     * @return bool if method exists
     */
    private function coreMethodExist($name)
    {
        $coreMethods = $this->getCoreMethods();
        return array_key_exists($name, $coreMethods);
    }

    /**
     * Try to call custom methods provided by plugins
     *
     * @param string $method name of method
     * @param array $args
     * @return mixed
     * @throws RemoteException if method not exists
     */
    private function callCustomCallPlugin($method, $args)
    {
        $customCalls = $this->getCustomCallPlugins();
        if (!array_key_exists($method, $customCalls)) {
            throw new RemoteException('Method does not exist', -32603);
        }
        $customCall = $customCalls[$method];
        return $this->callPlugin($customCall[0], $customCall[1], $args);
    }

    /**
     * Returns plugin calls that are registered via RPC_CALL_ADD action
     *
     * @return array with pairs of custom plugin calls
     * @triggers RPC_CALL_ADD
     */
    private function getCustomCallPlugins()
    {
        if ($this->pluginCustomCalls === null) {
            $data = array();
            Event::createAndTrigger('RPC_CALL_ADD', $data);
            $this->pluginCustomCalls = $data;

        }
        return $this->pluginCustomCalls;
    }

    /**
     * Call a plugin method
     *
     * @param string $pluginName
     * @param string $method method name
     * @param array $args
     * @return mixed return of custom method
     * @throws RemoteException
     */
    private function callPlugin($pluginName, $method, $args)
    {
        $plugin = plugin_load('remote', $pluginName);
        $methods = $this->getPluginMethods();
        if (!$plugin) {
            throw new RemoteException('Method does not exist', -32603);
        }
        $this->checkAccess($methods[$method]);
        $name = $this->getMethodName($methods, $method);
        try {
            return call_user_func_array(array($plugin, $name), $args);
        } catch (\ArgumentCountError $th) {

            throw new RemoteException('Method does not exist - wrong parameter count.', -32603);
        }
    }

    /**
     * Call a core method
     *
     * @param string $method name of method
     * @param array $args
     * @return mixed
     * @throws RemoteException if method not exist
     */
    private function callCoreMethod($method, $args)
    {
        $coreMethods = $this->getCoreMethods();
        $this->checkAccess($coreMethods[$method]);
        if (!isset($coreMethods[$method])) {
            throw new RemoteException('Method does not exist', -32603);
        }
        $this->checkArgumentLength($coreMethods[$method], $args);
        try {
            return call_user_func_array(array($this->coreMethods, $this->getMethodName($coreMethods, $method)), $args);
        } catch (\ArgumentCountError $th) {

            throw new RemoteException('Method does not exist - wrong parameter count.', -32603);
        }
    }

    /**
     * Check if access should be checked
     *
     * @param array $methodMeta data about the method
     * @throws AccessDeniedException
     */
    private function checkAccess($methodMeta)
    {
        if (!isset($methodMeta['public'])) {
            $this->forceAccess();
        } else {
            if ($methodMeta['public'] == '0') {
                $this->forceAccess();
            }
        }
    }

    /**
     * Check the number of parameters
     *
     * @param array $methodMeta data about the method
     * @param array $args
     * @throws RemoteException if wrong parameter count
     */
    private function checkArgumentLength($methodMeta, $args)
    {
        if (count($methodMeta['args']) < count($args)) {
            throw new RemoteException('Method does not exist - wrong parameter count.', -32603);
        }
    }

    /**
     * Determine the name of the real method
     *
     * @param array $methodMeta list of data of the methods
     * @param string $method name of method
     * @return string
     */
    private function getMethodName($methodMeta, $method)
    {
        if (isset($methodMeta[$method]['name'])) {
            return $methodMeta[$method]['name'];
        }
        $method = explode('.', $method);
        return $method[count($method) - 1];
    }

    /**
     * Perform access check for current user
     *
     * @return bool true if the current user has access to remote api.
     * @throws AccessDeniedException If remote access disabled
     */
    public function hasAccess()
    {
        global $conf;
        global $USERINFO;
        /** @var \dokuwiki\Input\Input $INPUT */
        global $INPUT;

        if (!$conf['remote']) {
            throw new AccessDeniedException('server error. RPC server not enabled.', -32604);
        }
        if (trim($conf['remoteuser']) == '!!not set!!') {
            return false;
        }
        if (!$conf['useacl']) {
            return true;
        }
        if (trim($conf['remoteuser']) == '') {
            return true;
        }

        return auth_isMember($conf['remoteuser'], $INPUT->server->str('REMOTE_USER'), (array) $USERINFO['grps']);
    }

    /**
     * Requests access
     *
     * @return void
     * @throws AccessDeniedException On denied access.
     */
    public function forceAccess()
    {
        if (!$this->hasAccess()) {
            throw new AccessDeniedException('server error. not authorized to call method', -32604);
        }
    }

    /**
     * Collects all the methods of the enabled Remote Plugins
     *
     * @return array all plugin methods.
     * @throws RemoteException if not implemented
     */
    public function getPluginMethods()
    {
        if ($this->pluginMethods === null) {
            $this->pluginMethods = array();
            $plugins = plugin_list('remote');

            foreach ($plugins as $pluginName) {
                /** @var RemotePlugin $plugin */
                $plugin = plugin_load('remote', $pluginName);
                if (!is_subclass_of($plugin, 'dokuwiki\Extension\RemotePlugin')) {
                    throw new RemoteException(
                        "Plugin $pluginName does not implement dokuwiki\Plugin\DokuWiki_Remote_Plugin"
                    );
                }

                try {
                    $methods = $plugin->_getMethods();
                } catch (\ReflectionException $e) {
                    throw new RemoteException('Automatic aggregation of available remote methods failed', 0, $e);
                }

                foreach ($methods as $method => $meta) {
                    $this->pluginMethods["plugin.$pluginName.$method"] = $meta;
                }
            }
        }
        return $this->pluginMethods;
    }

    /**
     * Collects all the core methods
     *
     * @param ApiCore $apiCore this parameter is used for testing. Here you can pass a non-default RemoteAPICore
     *                         instance. (for mocking)
     * @return array all core methods.
     */
    public function getCoreMethods($apiCore = null)
    {
        if ($this->coreMethods === null) {
            if ($apiCore === null) {
                $this->coreMethods = new ApiCore($this);
            } else {
                $this->coreMethods = $apiCore;
            }
        }
        return $this->coreMethods->__getRemoteInfo();
    }

    /**
     * Transform file to xml
     *
     * @param mixed $data
     * @return mixed
     */
    public function toFile($data)
    {
        return call_user_func($this->fileTransformation, $data);
    }

    /**
     * Transform date to xml
     *
     * @param mixed $data
     * @return mixed
     */
    public function toDate($data)
    {
        return call_user_func($this->dateTransformation, $data);
    }

    /**
     * A simple transformation
     *
     * @param mixed $data
     * @return mixed
     */
    public function dummyTransformation($data)
    {
        return $data;
    }

    /**
     * Set the transformer function
     *
     * @param callback $dateTransformation
     */
    public function setDateTransformation($dateTransformation)
    {
        $this->dateTransformation = $dateTransformation;
    }

    /**
     * Set the transformer function
     *
     * @param callback $fileTransformation
     */
    public function setFileTransformation($fileTransformation)
    {
        $this->fileTransformation = $fileTransformation;
    }
}


1			<?php
2
3			namespace dokuwiki\Remote;
4
5			use dokuwiki\Extension\Event;
6			use dokuwiki\Extension\RemotePlugin;
7
8			/**
9			* This class provides information about remote access to the wiki.
10			*
11			* == Types of methods ==
12			* There are two types of remote methods. The first is the core methods.
13			* These are always available and provided by dokuwiki.
14			* The other is plugin methods. These are provided by remote plugins.
15			*
16			* == Information structure ==
17			* The information about methods will be given in an array with the following structure:
18			* array(
19			* 'method.remoteName' => array(
20			* 'args' => array(
21			* 'type eg. string\|int\|...\|date\|file',
22			* )
23			* 'name' => 'method name in class',
24			* 'return' => 'type',
25			* 'public' => 1/0 - method bypass default group check (used by login)
26			* ['doc' = 'method documentation'],
27			* )
28			* )
29			*
30			* plugin names are formed the following:
31			* core methods begin by a 'dokuwiki' or 'wiki' followed by a . and the method name itself.
32			* i.e.: dokuwiki.version or wiki.getPage
33			*
34			* plugin methods are formed like 'plugin.<plugin name>.<method name>'.
35			* i.e.: plugin.clock.getTime or plugin.clock_gmt.getTime
36			*/
37			class Api
38			{
39
40			/**
41			* @var ApiCore
42			*/
43			private $coreMethods = null;
44
45			/**
46			* @var array remote methods provided by dokuwiki plugins - will be filled lazy via
47			* {@see dokuwiki\Remote\RemoteAPI#getPluginMethods}
48			*/
49			private $pluginMethods = null;
50
51			/**
52			* @var array contains custom calls to the api. Plugins can use the XML_CALL_REGISTER event.
53			* The data inside is 'custom.call.something' => array('plugin name', 'remote method name')
54			*
55			* The remote method name is the same as in the remote name returned by _getMethods().
56			*/
57			private $pluginCustomCalls = null;
58
59			private $dateTransformation;
60			private $fileTransformation;
61
62			/**
63			* constructor
64			*/
65			public function __construct()
66			{
67			$this->dateTransformation = array($this, 'dummyTransformation');
68			$this->fileTransformation = array($this, 'dummyTransformation');
69			}
70
71			/**
72			* Get all available methods with remote access.
73			*
74			* @return array with information to all available methods
75			* @throws RemoteException
76			*/
77			public function getMethods()
78			{
79			return array_merge($this->getCoreMethods(), $this->getPluginMethods());
80			}
81
82			/**
83			* Call a method via remote api.
84			*
85			* @param string $method name of the method to call.
86			* @param array $args arguments to pass to the given method
87			* @return mixed result of method call, must be a primitive type.
88			* @throws RemoteException
89			*/
90			public function call($method, $args = array())
91			{
92			if ($args === null) {
93			$args = array();
94			}
95			list($type, $pluginName, /* $call */) = explode('.', $method, 3);
96			if ($type === 'plugin') {
97			return $this->callPlugin($pluginName, $method, $args);
98			}
99			if ($this->coreMethodExist($method)) {
100			return $this->callCoreMethod($method, $args);
101			}
102			return $this->callCustomCallPlugin($method, $args);
103			}
104
105			/**
106			* Check existance of core methods
107			*
108			* @param string $name name of the method
109			* @return bool if method exists
110			*/
111			private function coreMethodExist($name)
112			{
113			$coreMethods = $this->getCoreMethods();
114			return array_key_exists($name, $coreMethods);
115			}
116
117			/**
118			* Try to call custom methods provided by plugins
119			*
120			* @param string $method name of method
121			* @param array $args
122			* @return mixed
123			* @throws RemoteException if method not exists
124			*/
125			private function callCustomCallPlugin($method, $args)
126			{
127			$customCalls = $this->getCustomCallPlugins();
128			if (!array_key_exists($method, $customCalls)) {
129			throw new RemoteException('Method does not exist', -32603);
130			}
131			$customCall = $customCalls[$method];
132			return $this->callPlugin($customCall[0], $customCall[1], $args);
133			}
134
135			/**
136			* Returns plugin calls that are registered via RPC_CALL_ADD action
137			*
138			* @return array with pairs of custom plugin calls
139			* @triggers RPC_CALL_ADD
140			*/
141			private function getCustomCallPlugins()
142			{
143			if ($this->pluginCustomCalls === null) {
144			$data = array();
145			Event::createAndTrigger('RPC_CALL_ADD', $data);
146			$this->pluginCustomCalls = $data;
			0 ignored issues – show Documentation Bug introduced 2015-11-25 07:06 UTC by Report Bug Copy Issue Report It seems like `$data` of type `*` is incompatible with the declared type `array` of property `$pluginCustomCalls`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
147			}
148			return $this->pluginCustomCalls;
149			}
150
151			/**
152			* Call a plugin method
153			*
154			* @param string $pluginName
155			* @param string $method method name
156			* @param array $args
157			* @return mixed return of custom method
158			* @throws RemoteException
159			*/
160			private function callPlugin($pluginName, $method, $args)
161			{
162			$plugin = plugin_load('remote', $pluginName);
163			$methods = $this->getPluginMethods();
164			if (!$plugin) {
165			throw new RemoteException('Method does not exist', -32603);
166			}
167			$this->checkAccess($methods[$method]);
168			$name = $this->getMethodName($methods, $method);
169			try {
170			return call_user_func_array(array($plugin, $name), $args);
171			} catch (\ArgumentCountError $th) {
			0 ignored issues – show Bug introduced 2020-03-03 03:55 UTC by Report Bug Copy Issue Report The class `ArgumentCountError` does not exist. Did you forget a USE statement, or did you not list all dependencies? Scrutinizer analyzes your `composer.json`/`composer.lock` file if available to determine the classes, and functions that are defined by your dependencies. It seems like the listed class was neither found in your dependencies, nor was it found in the analyzed files in your repository. If you are using some other form of dependency management, you might want to disable this analysis. Loading history...
172			throw new RemoteException('Method does not exist - wrong parameter count.', -32603);
173			}
174			}
175
176			/**
177			* Call a core method
178			*
179			* @param string $method name of method
180			* @param array $args
181			* @return mixed
182			* @throws RemoteException if method not exist
183			*/
184			private function callCoreMethod($method, $args)
185			{
186			$coreMethods = $this->getCoreMethods();
187			$this->checkAccess($coreMethods[$method]);
188			if (!isset($coreMethods[$method])) {
189			throw new RemoteException('Method does not exist', -32603);
190			}
191			$this->checkArgumentLength($coreMethods[$method], $args);
192			try {
193			return call_user_func_array(array($this->coreMethods, $this->getMethodName($coreMethods, $method)), $args);
194			} catch (\ArgumentCountError $th) {
			0 ignored issues – show Bug introduced 2020-03-03 03:55 UTC by Report Bug Copy Issue Report The class `ArgumentCountError` does not exist. Did you forget a USE statement, or did you not list all dependencies? Scrutinizer analyzes your `composer.json`/`composer.lock` file if available to determine the classes, and functions that are defined by your dependencies. It seems like the listed class was neither found in your dependencies, nor was it found in the analyzed files in your repository. If you are using some other form of dependency management, you might want to disable this analysis. Loading history...
195			throw new RemoteException('Method does not exist - wrong parameter count.', -32603);
196			}
197			}
198
199			/**
200			* Check if access should be checked
201			*
202			* @param array $methodMeta data about the method
203			* @throws AccessDeniedException
204			*/
205			private function checkAccess($methodMeta)
206			{
207			if (!isset($methodMeta['public'])) {
208			$this->forceAccess();
209			} else {
210			if ($methodMeta['public'] == '0') {
211			$this->forceAccess();
212			}
213			}
214			}
215
216			/**
217			* Check the number of parameters
218			*
219			* @param array $methodMeta data about the method
220			* @param array $args
221			* @throws RemoteException if wrong parameter count
222			*/
223			private function checkArgumentLength($methodMeta, $args)
224			{
225			if (count($methodMeta['args']) < count($args)) {
226			throw new RemoteException('Method does not exist - wrong parameter count.', -32603);
227			}
228			}
229
230			/**
231			* Determine the name of the real method
232			*
233			* @param array $methodMeta list of data of the methods
234			* @param string $method name of method
235			* @return string
236			*/
237			private function getMethodName($methodMeta, $method)
238			{
239			if (isset($methodMeta[$method]['name'])) {
240			return $methodMeta[$method]['name'];
241			}
242			$method = explode('.', $method);
243			return $method[count($method) - 1];
244			}
245
246			/**
247			* Perform access check for current user
248			*
249			* @return bool true if the current user has access to remote api.
250			* @throws AccessDeniedException If remote access disabled
251			*/
252			public function hasAccess()
253			{
254			global $conf;
255			global $USERINFO;
256			/** @var \dokuwiki\Input\Input $INPUT */
257			global $INPUT;
258
259			if (!$conf['remote']) {
260			throw new AccessDeniedException('server error. RPC server not enabled.', -32604);
261			}
262			if (trim($conf['remoteuser']) == '!!not set!!') {
263			return false;
264			}
265			if (!$conf['useacl']) {
266			return true;
267			}
268			if (trim($conf['remoteuser']) == '') {
269			return true;
270			}
271
272			return auth_isMember($conf['remoteuser'], $INPUT->server->str('REMOTE_USER'), (array) $USERINFO['grps']);
273			}
274
275			/**
276			* Requests access
277			*
278			* @return void
279			* @throws AccessDeniedException On denied access.
280			*/
281			public function forceAccess()
282			{
283			if (!$this->hasAccess()) {
284			throw new AccessDeniedException('server error. not authorized to call method', -32604);
285			}
286			}
287
288			/**
289			* Collects all the methods of the enabled Remote Plugins
290			*
291			* @return array all plugin methods.
292			* @throws RemoteException if not implemented
293			*/
294			public function getPluginMethods()
295			{
296			if ($this->pluginMethods === null) {
297			$this->pluginMethods = array();
298			$plugins = plugin_list('remote');
299
300			foreach ($plugins as $pluginName) {
301			/** @var RemotePlugin $plugin */
302			$plugin = plugin_load('remote', $pluginName);
303			if (!is_subclass_of($plugin, 'dokuwiki\Extension\RemotePlugin')) {
304			throw new RemoteException(
305			"Plugin $pluginName does not implement dokuwiki\Plugin\DokuWiki_Remote_Plugin"
306			);
307			}
308
309			try {
310			$methods = $plugin->_getMethods();
311			} catch (\ReflectionException $e) {
312			throw new RemoteException('Automatic aggregation of available remote methods failed', 0, $e);
313			}
314
315			foreach ($methods as $method => $meta) {
316			$this->pluginMethods["plugin.$pluginName.$method"] = $meta;
317			}
318			}
319			}
320			return $this->pluginMethods;
321			}
322
323			/**
324			* Collects all the core methods
325			*
326			* @param ApiCore $apiCore this parameter is used for testing. Here you can pass a non-default RemoteAPICore
327			* instance. (for mocking)
328			* @return array all core methods.
329			*/
330			public function getCoreMethods($apiCore = null)
331			{
332			if ($this->coreMethods === null) {
333			if ($apiCore === null) {
334			$this->coreMethods = new ApiCore($this);
335			} else {
336			$this->coreMethods = $apiCore;
337			}
338			}
339			return $this->coreMethods->__getRemoteInfo();
340			}
341
342			/**
343			* Transform file to xml
344			*
345			* @param mixed $data
346			* @return mixed
347			*/
348			public function toFile($data)
349			{
350			return call_user_func($this->fileTransformation, $data);
351			}
352
353			/**
354			* Transform date to xml
355			*
356			* @param mixed $data
357			* @return mixed
358			*/
359			public function toDate($data)
360			{
361			return call_user_func($this->dateTransformation, $data);
362			}
363
364			/**
365			* A simple transformation
366			*
367			* @param mixed $data
368			* @return mixed
369			*/
370			public function dummyTransformation($data)
371			{
372			return $data;
373			}
374
375			/**
376			* Set the transformer function
377			*
378			* @param callback $dateTransformation
379			*/
380			public function setDateTransformation($dateTransformation)
381			{
382			$this->dateTransformation = $dateTransformation;
383			}
384
385			/**
386			* Set the transformer function
387			*
388			* @param callback $fileTransformation
389			*/
390			public function setFileTransformation($fileTransformation)
391			{
392			$this->fileTransformation = $fileTransformation;
393			}
394			}
395

splitbrain / dokuwiki

Push — remote-argumentcount ( e1215f )

Api::getCustomCallPlugins() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like