installed dokuwiki, added to navbar, updated news

1 files changed, 357 insertions, 0 deletions

diff --git a/wiki/inc/remote.php b/wiki/inc/remote.php
new file mode 100644
index 0000000..2d2e327
--- /dev/null
+++ b/wiki/inc/remote.php
@@ -0,0 +1,357 @@
+<?php
+
+if (!defined('DOKU_INC')) die();
+
+class RemoteException extends Exception {}
+class RemoteAccessDeniedException extends RemoteException {}
+
+/**
+ * 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
+ *
+ * @throws RemoteException
+ */
+class RemoteAPI {
+
+    /**
+     * @var RemoteAPICore
+     */
+    private $coreMethods = null;
+
+    /**
+     * @var array remote methods provided by dokuwiki plugins - will be filled lazy via
+     * {@see 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
+     */
+    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.
+     */
+    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();
+            trigger_event('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);
+        return call_user_func_array(array($plugin, $name), $args);
+    }
+
+    /**
+     * 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);
+        return call_user_func_array(array($this->coreMethods, $this->getMethodName($coreMethods, $method)), $args);
+    }
+
+    /**
+     * Check if access should be checked
+     *
+     * @param array $methodMeta data about the method
+     */
+    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 RemoteAccessDeniedException If remote access disabled
+     */
+    public function hasAccess() {
+        global $conf;
+        global $USERINFO;
+        /** @var Input $INPUT */
+        global $INPUT;
+
+        if (!$conf['remote']) {
+            throw new RemoteAccessDeniedException('server error. RPC server not enabled.',-32604); //should not be here,just throw
+        }
+        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 RemoteException On denied access.
+     */
+    public function forceAccess() {
+        if (!$this->hasAccess()) {
+            throw new RemoteAccessDeniedException('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 DokuWiki_Remote_Plugin $plugin */
+                $plugin = plugin_load('remote', $pluginName);
+                if (!is_subclass_of($plugin, 'DokuWiki_Remote_Plugin')) {
+                    throw new RemoteException("Plugin $pluginName does not implement DokuWiki_Remote_Plugin");
+                }
+
+                $methods = $plugin->_getMethods();
+                foreach ($methods as $method => $meta) {
+                    $this->pluginMethods["plugin.$pluginName.$method"] = $meta;
+                }
+            }
+        }
+        return $this->pluginMethods;
+    }
+
+    /**
+     * Collects all the core methods
+     *
+     * @param RemoteAPICore $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 RemoteAPICore($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;
+    }
+}