diff --git a/webservice/classes/rest/Abstract.php b/webservice/classes/rest/Abstract.php
new file mode 100644
index 0000000..7658a6d
--- /dev/null
+++ b/webservice/classes/rest/Abstract.php
@@ -0,0 +1,221 @@
+<?php
+
+
+/** Rest_Interface */
+require_once 'classes/rest/Interface.php';
+
+/**
+ * Rest_Definition
+ */
+require_once 'classes/rest/Definition.php';
+
+/**
+ * Rest_Method_Definition
+ */
+require_once 'classes/rest/method/Definition.php';
+
+/**
+ * Rest_Method_Callback
+ */
+require_once 'classes/rest/method/Callback.php';
+
+/**
+ * Rest_Method_Prototype
+ */
+require_once 'classes/rest/method/Prototype.php';
+
+/**
+ * Rest_Method_Parameter
+ */
+require_once 'classes/rest/method/Parameter.php';
+
+/**
+ * Rest_Abstract
+ *
+ *
+ */
+abstract class Rest_Abstract implements Rest_Interface
+{
+    /**
+     * @deprecated
+     * @var array List of PHP magic methods (lowercased)
+     */
+    protected static $magic_methods = array(
+        '__call',
+        '__clone',
+        '__construct',
+        '__destruct',
+        '__get',
+        '__isset',
+        '__set',
+        '__set_state',
+        '__sleep',
+        '__tostring',
+        '__unset',
+        '__wakeup',
+    );
+
+    /**
+     * @var bool Flag; whether or not overwriting existing methods is allowed
+     */
+    protected $_overwriteExistingMethods = false;
+
+    /**
+     * @var Rest_Definition
+     */
+    protected $_table;
+
+    /**
+     * Constructor
+     *
+     * Setup server description
+     *
+     * @return void
+     */
+    public function __construct()
+    {
+        $this->_table = new Rest_Definition();
+        $this->_table->setOverwriteExistingMethods($this->_overwriteExistingMethods);
+    }
+
+    /**
+     * Returns a list of registered methods
+     *
+     * Returns an array of method definitions.
+     *
+     * @return Rest_Definition
+     */
+    public function getFunctions()
+    {
+        return $this->_table;
+    }
+
+    /**
+     * Lowercase a string
+     *
+     * Lowercase's a string by reference
+     *
+     * @deprecated
+     * @param  string $string value
+     * @param  string $key
+     * @return string Lower cased string
+     */
+    public static function lowerCase(&$value, &$key)
+    {
+        trigger_error(__CLASS__ . '::' . __METHOD__ . '() is deprecated and will be removed in a future version', E_USER_NOTICE);
+        return $value = strtolower($value);
+    }
+
+    /**
+     * Build callback for method signature
+     *
+     * @param  Rest_Reflection_Function_Abstract $reflection
+     * @return Rest_Method_Callback
+     */
+    protected function _buildCallback(Rest_Reflection_Function_Abstract $reflection)
+    {
+        $callback = new Rest_Method_Callback();
+        if ($reflection instanceof Rest_Reflection_Method) {
+            $callback->setType($reflection->isStatic() ? 'static' : 'instance')
+                     ->setClass($reflection->getDeclaringClass()->getName())
+                     ->setMethod($reflection->getName());
+        } elseif ($reflection instanceof Rest_Reflection_Function) {
+            $callback->setType('function')
+                     ->setFunction($reflection->getName());
+        }
+        return $callback;
+    }
+
+    /**
+     * Build a method signature
+     *
+     * @param  Rest_Reflection_Function_Abstract $reflection
+     * @param  null|string|object $class
+     * @return Rest_Method_Definition
+     * @throws Rest_Exception on duplicate entry
+     */
+    protected function _buildSignature(Rest_Reflection_Function_Abstract $reflection, $class = null)
+    {
+        $ns         = $reflection->getNamespace();
+        $name       = $reflection->getName();
+        $method     = empty($ns) ? $name : $ns . '.' . $name;
+
+        if (!$this->_overwriteExistingMethods && $this->_table->hasMethod($method)) {
+            require_once 'Exception.php';
+            throw new Rest_Exception('Duplicate method registered: ' . $method);
+        }
+
+        $definition = new Rest_Method_Definition();
+        $definition->setName($method)
+                   ->setCallback($this->_buildCallback($reflection))
+                   ->setMethodHelp($reflection->getDescription())
+                   ->setInvokeArguments($reflection->getInvokeArguments());
+
+        foreach ($reflection->getPrototypes() as $proto) {
+            $prototype = new Rest_Method_Prototype();
+            $prototype->setReturnType($this->_fixType($proto->getReturnType()));
+            foreach ($proto->getParameters() as $parameter) {
+                $param = new Rest_Method_Parameter(array(
+                    'type'     => $this->_fixType($parameter->getType()),
+                    'name'     => $parameter->getName(),
+                    'optional' => $parameter->isOptional(),
+                ));
+                if ($parameter->isDefaultValueAvailable()) {
+                    $param->setDefaultValue($parameter->getDefaultValue());
+                }
+                $prototype->addParameter($param);
+            }
+            $definition->addPrototype($prototype);
+        }
+        if (is_object($class)) {
+            $definition->setObject($class);
+        }
+        $this->_table->addMethod($definition);
+        return $definition;
+    }
+
+    /**
+     * Dispatch method
+     *
+     * @param  Rest_Method_Definition $invocable
+     * @param  array $params
+     * @return mixed
+     */
+    protected function _dispatch(Rest_Method_Definition $invocable, array $params)
+    {
+        $callback = $invocable->getCallback();
+        $type     = $callback->getType();
+
+        if ('function' == $type) {
+            $function = $callback->getFunction();
+            return call_user_func_array($function, $params);
+        }
+
+        $class  = $callback->getClass();
+        $method = $callback->getMethod();
+
+        if ('static' == $type) {
+            return call_user_func_array(array($class, $method), $params);
+        }
+
+        $object = $invocable->getObject();
+        if (!is_object($object)) {
+            $invokeArgs = $invocable->getInvokeArguments();
+            if (!empty($invokeArgs)) {
+                $reflection = new ReflectionClass($class);
+                $object     = $reflection->newInstanceArgs($invokeArgs);
+            } else {
+                $object = new $class;
+            }
+        }
+        return call_user_func_array(array($object, $method), $params);
+    }
+
+    /**
+     * Map PHP type to protocol type
+     *
+     * @param  string $type
+     * @return string
+     */
+    abstract protected function _fixType($type);
+}
diff --git a/webservice/classes/rest/Definition.php b/webservice/classes/rest/Definition.php
new file mode 100644
index 0000000..c271de3
--- /dev/null
+++ b/webservice/classes/rest/Definition.php
@@ -0,0 +1,243 @@
+<?php
+
+/**
+ * Server methods metadata
+ *
+ */
+class Rest_Definition implements Countable, Iterator
+{
+    /**
+     * @var array Array of Rest_Method_Definition objects
+     */
+    protected $_methods = array();
+
+    /**
+     * @var bool Whether or not overwriting existing methods is allowed
+     */
+    protected $_overwriteExistingMethods = false;
+
+    /**
+     * Constructor
+     *
+     * @param  null|array $methods
+     * @return void
+     */
+    public function __construct($methods = null)
+    {
+        if (is_array($methods)) {
+            $this->setMethods($methods);
+        }
+    }
+
+    /**
+     * Set flag indicating whether or not overwriting existing methods is allowed
+     *
+     * @param mixed $flag
+     * @return void
+     */
+    public function setOverwriteExistingMethods($flag)
+    {
+        $this->_overwriteExistingMethods = (bool) $flag;
+        return $this;
+    }
+
+    /**
+     * Add method to definition
+     *
+     * @param  array|Rest_Method_Definition $method
+     * @param  null|string $name
+     * @return Rest_Definition
+     * @throws Rest_Exception if duplicate or invalid method provided
+     */
+    public function addMethod($method, $name = null)
+    {
+        if (is_array($method)) {
+            require_once 'classes/rest/method/Definition.php';
+            $method = new Rest_Method_Definition($method);
+        } elseif (!$method instanceof Rest_Method_Definition) {
+            require_once 'Exception.php';
+            throw new Rest_Exception('Invalid method provided');
+        }
+
+        if (is_numeric($name)) {
+            $name = null;
+        }
+        if (null !== $name) {
+            $method->setName($name);
+        } else {
+            $name = $method->getName();
+        }
+        if (null === $name) {
+            require_once 'Exception.php';
+            throw new Rest_Exception('No method name provided');
+        }
+
+        if (!$this->_overwriteExistingMethods && array_key_exists($name, $this->_methods)) {
+            require_once 'Exception.php';
+            throw new Rest_Exception(sprintf('Method by name of "%s" already exists', $name));
+        }
+        $this->_methods[$name] = $method;
+        return $this;
+    }
+
+    /**
+     * Add multiple methods
+     *
+     * @param  array $methods Array of Rest_Method_Definition objects or arrays
+     * @return Rest_Definition
+     */
+    public function addMethods(array $methods)
+    {
+        foreach ($methods as $key => $method) {
+            $this->addMethod($method, $key);
+        }
+        return $this;
+    }
+
+    /**
+     * Set all methods at once (overwrite)
+     *
+     * @param  array $methods Array of Rest_Method_Definition objects or arrays
+     * @return Rest_Definition
+     */
+    public function setMethods(array $methods)
+    {
+        $this->clearMethods();
+        $this->addMethods($methods);
+        return $this;
+    }
+
+    /**
+     * Does the definition have the given method?
+     *
+     * @param  string $method
+     * @return bool
+     */
+    public function hasMethod($method)
+    {
+        return array_key_exists($method, $this->_methods);
+    }
+
+    /**
+     * Get a given method definition
+     *
+     * @param  string $method
+     * @return null|Rest_Method_Definition
+     */
+    public function getMethod($method)
+    {
+        if ($this->hasMethod($method)) {
+            return $this->_methods[$method];
+        }
+        return false;
+    }
+
+    /**
+     * Get all method definitions
+     *
+     * @return array Array of Rest_Method_Definition objects
+     */
+    public function getMethods()
+    {
+        return $this->_methods;
+    }
+
+    /**
+     * Remove a method definition
+     *
+     * @param  string $method
+     * @return Rest_Definition
+     */
+    public function removeMethod($method)
+    {
+        if ($this->hasMethod($method)) {
+            unset($this->_methods[$method]);
+        }
+        return $this;
+    }
+
+    /**
+     * Clear all method definitions
+     *
+     * @return Rest_Definition
+     */
+    public function clearMethods()
+    {
+        $this->_methods = array();
+        return $this;
+    }
+
+    /**
+     * Cast definition to an array
+     *
+     * @return array
+     */
+    public function toArray()
+    {
+        $methods = array();
+        foreach ($this->getMethods() as $key => $method) {
+            $methods[$key] = $method->toArray();
+        }
+        return $methods;
+    }
+
+    /**
+     * Countable: count of methods
+     *
+     * @return int
+     */
+    public function count()
+    {
+        return count($this->_methods);
+    }
+
+    /**
+     * Iterator: current item
+     *
+     * @return mixed
+     */
+    public function current()
+    {
+        return current($this->_methods);
+    }
+
+    /**
+     * Iterator: current item key
+     *
+     * @return int|string
+     */
+    public function key()
+    {
+        return key($this->_methods);
+    }
+
+    /**
+     * Iterator: advance to next method
+     *
+     * @return void
+     */
+    public function next()
+    {
+        return next($this->_methods);
+    }
+
+    /**
+     * Iterator: return to first method
+     *
+     * @return void
+     */
+    public function rewind()
+    {
+        return reset($this->_methods);
+    }
+
+    /**
+     * Iterator: is the current index valid?
+     *
+     * @return bool
+     */
+    public function valid()
+    {
+        return (bool) $this->current();
+    }
+}
diff --git a/webservice/classes/rest/Exception.php b/webservice/classes/rest/Exception.php
new file mode 100644
index 0000000..d497f47
--- /dev/null
+++ b/webservice/classes/rest/Exception.php
@@ -0,0 +1,14 @@
+<?php
+
+/**
+ *Reflection exceptions
+ *
+ * @package Server
+ * @subpackage Reflection
+ * @version
+ *
+ **/
+class Rest_Exception extends Exception
+{
+
+}
diff --git a/webservice/classes/rest/Interface.php b/webservice/classes/rest/Interface.php
new file mode 100644
index 0000000..d9758cc
--- /dev/null
+++ b/webservice/classes/rest/Interface.php
@@ -0,0 +1,96 @@
+<?php
+
+/**
+ * Rest_Interface
+ * These are all public functions that implemented in the
+ * Rest Interface
+ *
+ */
+interface Rest_Interface
+{
+    /**
+     * Attach a function as a server method
+     *
+     * Namespacing is primarily for xmlrpc, but may be used with other
+     * implementations to prevent naming collisions.
+     *
+     * @param string $function
+     * @param string $namespace
+     * @param null|array Optional array of arguments to pass to callbacks at
+     * dispatch.
+     * @return void
+     */
+    public function addFunction($function, $namespace = '');
+
+    /**
+     * Attach a class to a server
+     *
+     * The individual implementations should probably allow passing a variable
+     * number of arguments in, so that developers may define custom runtime
+     * arguments to pass to server methods.
+     *
+     * Namespacing is primarily for xmlrpc, but could be used for other
+     * implementations as well.
+     *
+     * @param mixed $class Class name or object instance to examine and attach
+     * to the server.
+     * @param string $namespace Optional namespace with which to prepend method
+     * names in the dispatch table.
+     * methods in the class will be valid callbacks.
+     * @param null|array Optional array of arguments to pass to callbacks at
+     * dispatch.
+     * @return void
+     */
+    public function setClass($class, $namespace = '', $argv = null);
+
+    /**
+     * Generate a server fault
+     *
+     * @param mixed $fault
+     * @param int $code
+     * @return mixed
+     */
+    public function fault($fault = null, $code = 404);
+
+    /**
+     * Handle a request
+     *
+     * Requests may be passed in, or the server may automagically determine the
+     * request based on defaults. Dispatches server request to appropriate
+     * method and returns a response
+     *
+     * @param mixed $request
+     * @return mixed
+     */
+    public function handle($request = false);
+
+    /**
+     * Return a server definition array
+     *
+     * Returns a server definition array as created using
+     * {@link * Rest_Reflection}. Can be used for server introspection,
+     * documentation, or persistence.
+     *
+     * @access public
+     * @return array
+     */
+    public function getFunctions();
+
+    /**
+     * Load server definition
+     *
+     * Used for persistence; loads a construct as returned by {@link getFunctions()}.
+     *
+     * @param array $array
+     * @return void
+     */
+    public function loadFunctions($definition);
+
+    /**
+     * Set server persistence
+     * 
+     * @param int $mode
+     * @return void
+     */
+    public function setPersistence($mode);
+}
diff --git a/webservice/classes/rest/Reflection.php b/webservice/classes/rest/Reflection.php
new file mode 100644
index 0000000..133a322
--- /dev/null
+++ b/webservice/classes/rest/Reflection.php
@@ -0,0 +1,86 @@
+<?php
+
+/**
+ * Rest_Reflection_Function
+ */
+require_once 'classes/rest/reflection/Function.php';
+
+/**
+ * Rest_Reflection_Class
+ */
+require_once 'classes/rest/reflection/Class.php';
+
+/**
+ * Reflection for determining method signatures to use with server classes
+ *
+ */
+class Rest_Reflection
+{
+    /**
+     * Perform class reflection to create dispatch signatures
+     *
+     * Creates a {@link Rest_Reflection_Class} object for the class or
+     * object provided.
+     *
+     * If extra arguments should be passed to dispatchable methods, these may
+     * be provided as an array to $argv.
+     *
+     * @param string|object $class Class name or object
+     * @param null|array $argv Optional arguments to be used during the method call
+     * @param string $namespace Optional namespace with which to prefix the
+     * method name (used for the signature key). Primarily to avoid collisions,
+     * also for XmlRpc namespacing
+     * @return Rest_Reflection_Class
+     * @throws Rest_Exception
+     *
+     *
+     */
+
+    public static function reflectClass($class, $argv = false, $namespace = '')
+    {
+            $reflection = new ReflectionClass($class);
+
+            //require_once 'Exception.php';
+            //throw new Rest_Exception('Invalid class or object passed to attachClass()');
+
+        if ($argv && !is_array($argv)) {
+            require_once 'Exception.php';
+            throw new Rest_Exception('Invalid argv argument passed to reflectClass');
+        }
+
+        return new Rest_Reflection_Class($reflection, $namespace, $argv);
+    }
+
+    /**
+     * Perform function reflection to create dispatch signatures
+     *
+     * Creates dispatch prototypes for a function. It returns a
+     * {@link Rest_Reflection_Function} object.
+     *
+     * If extra arguments should be passed to the dispatchable function, these
+     * may be provided as an array to $argv.
+     *
+     * @param string $function Function name
+     * @param null|array $argv Optional arguments to be used during the method call
+     * @param string $namespace Optional namespace with which to prefix the
+     * function name (used for the signature key). Primarily to avoid
+     * collisions, also for XmlRpc namespacing
+     * @return Rest_Reflection_Function
+     * @throws Rest_Exception
+     */
+    public static function reflectFunction($function, $argv = false, $namespace = '')
+    {
+        if (!is_string($function) || !function_exists($function)) {
+            require_once 'Exception.php';
+            throw new Rest_Exception('Invalid function "' . $function . '" passed to reflectFunction');
+        }
+
+
+        if ($argv && !is_array($argv)) {
+            require_once 'Exception.php';
+            throw new Rest_Exception('Invalid argv argument passed to reflectClass');
+        }
+
+        return new Rest_Reflection_Function(new ReflectionFunction($function), $namespace, $argv);
+    }
+}
diff --git a/webservice/classes/rest/Server.php b/webservice/classes/rest/Server.php
new file mode 100644
index 0000000..fb41e25
--- /dev/null
+++ b/webservice/classes/rest/Server.php
@@ -0,0 +1,624 @@
+<?php
+
+/**
+* Invokes  Rest Service  API for KnowledgeTree.
+*
+*
+* KnowledgeTree Community Edition
+* Document Management Made Simple
+* Copyright (C) 2008,2009 KnowledgeTree Inc.
+* Portions copyright The Jam Warehouse Software (Pty) Limited
+*
+* This program is free software; you can redistribute it and/or modify it under
+* the terms of the GNU General Public License version 3 as published by the
+* Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+* FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+* details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+* You can contact KnowledgeTree Inc., PO Box 7775 #87847, San Francisco,
+* California 94120-7775, or email info@knowledgetree.com.
+*
+* The interactive user interfaces in modified source and object code versions
+* of this program must display Appropriate Legal Notices, as required under
+* Section 5 of the GNU General Public License version 3.
+*
+* In accordance with Section 7(b) of the GNU General Public License version 3,
+* these Appropriate Legal Notices must retain the display of the "Powered by
+* KnowledgeTree" logo and retain the original copyright notice. If the display of the
+* logo is not reasonably feasible for technical reasons, the Appropriate Legal Notices
+* must display the words "Powered by KnowledgeTree" and retain the original
+* copyright notice.
+*
+* @copyright 2008-2009, KnowledgeTree Inc.
+* @license GNU General Public License version 3
+* @author KnowledgeTree Team
+* @package Webservice
+* @version Version 0.1
+*/
+
+/**
+ * Rest_Interface
+ */
+require_once 'classes/rest/Interface.php';
+
+/**
+ * Rest_Reflection
+ */
+require_once 'classes/rest/Reflection.php';
+
+/**
+ * Rest_Abstract
+ */
+require_once 'classes/rest/Abstract.php';
+
+/**
+ * Rest_Exception
+ *
+ */
+require_once 'classes/rest/Exception.php';
+
+class Rest_Server implements Rest_Interface
+{
+    /**
+     * Class Constructor Args
+     * @var array
+     */
+    protected $_args = array();
+
+    /**
+     * @var string Encoding
+     */
+    protected $_encoding = 'UTF-8';
+
+    /**
+     * @var array An array of Rest_Reflect_Method
+     */
+    protected $_functions = array();
+
+    /**
+     * @var array Array of headers to send
+     */
+    protected $_headers = array();
+
+    /**
+     * @var array PHP's Magic Methods, these are ignored
+     */
+    protected static $magicMethods = array(
+        '__construct',
+        '__destruct',
+        '__get',
+        '__set',
+        '__call',
+        '__sleep',
+        '__wakeup',
+        '__isset',
+        '__unset',
+        '__tostring',
+        '__clone',
+        '__set_state',
+    );
+
+    /**
+     * @var string Current Method
+     */
+    protected $_method;
+
+    /**
+     * @var Rest_Reflection
+     */
+    protected $_reflection = null;
+
+    /**
+     * Whether or not {@link handle()} should send output or return the response.
+     * @var boolean Defaults to false
+     */
+    protected $_returnResponse = false;
+
+    /**
+     * Constructor
+     */
+    public function __construct()
+    {
+		set_exception_handler(array($this, "fault"));
+        $this->_reflection = new Rest_Reflection();
+    }
+
+    /**
+     * Set XML encoding
+     *
+     * @param  string $encoding
+     * @return Rest_Server
+     */
+    public function setEncoding($encoding)
+    {
+        $this->_encoding = (string) $encoding;
+        return $this;
+    }
+
+    /**
+     * Get XML encoding
+     *
+     * @return string
+     */
+    public function getEncoding()
+    {
+        return $this->_encoding;
+    }
+
+    /**
+     * Lowercase a string
+     *
+     * Lowercase's a string by reference
+     *
+     * @param string $value
+     * @param string $key
+     * @return string Lower cased string
+     */
+    public static function lowerCase(&$value, &$key)
+    {
+        return $value = strtolower($value);
+    }
+
+    /**
+     * Whether or not to return a response
+     *
+     * If called without arguments, returns the value of the flag. If called
+     * with an argument, sets the flag.
+     *
+     * When 'return response' is true, {@link handle()} will not send output,
+     * but will instead return the response from the dispatched function/method.
+     *
+     * @param boolean $flag
+     * @return boolean|Rest_Server Returns Rest_Server when used to set the flag; returns boolean flag value otherwise.
+     */
+    public function returnResponse($flag = null)
+    {
+        if (null == $flag) {
+            return $this->_returnResponse;
+        }
+
+        $this->_returnResponse = ($flag) ? true : false;
+        return $this;
+    }
+
+    /**
+     * Implement Rest_Interface::handle()
+     *
+     * @param  array $request
+     * @throws Rest_Server_Exception
+     * @return string|void
+     */
+    public function handle($request = false)
+    {
+        $this->_headers = array('Content-Type: text/xml');
+        if (!$request) {
+            $request = $_REQUEST;
+        }
+        if (isset($request['method'])) {
+            $this->_method = $request['method'];
+            if (isset($this->_functions[$this->_method])) {
+                if ($this->_functions[$this->_method] instanceof Rest_Reflection_Function || $this->_functions[$this->_method] instanceof Rest_Reflection_Method && $this->_functions[$this->_method]->isPublic()) {
+                    $request_keys = array_keys($request);
+                    array_walk($request_keys, array(__CLASS__, "lowerCase"));
+                    $request = array_combine($request_keys, $request);
+
+                    $func_args = $this->_functions[$this->_method]->getParameters();
+
+                    $calling_args = array();
+                    foreach ($func_args as $arg) {
+                        if (isset($request[strtolower($arg->getName())])) {
+                            $calling_args[] = $request[strtolower($arg->getName())];
+                        } elseif ($arg->isOptional()) {
+                            $calling_args[] = $arg->getDefaultValue();
+                        }
+                    }
+
+                    foreach ($request as $key => $value) {
+                        if (substr($key, 0, 3) == 'arg') {
+                            $key = str_replace('arg', '', $key);
+                            $calling_args[$key] = $value;
+                        }
+                    }
+
+                    // Sort arguments by key -- @see ZF-2279
+                    ksort($calling_args);
+
+                    $result = false;
+                    if (count($calling_args) < count($func_args)) {
+                        $result = $this->fault(new Rest_Exception('Invalid Method Call to ' . $this->_method . '. Requires ' . count($func_args) . ', ' . count($calling_args) . ' given.'), 400);
+                    }
+
+                    if (!$result && $this->_functions[$this->_method] instanceof Rest_Reflection_Method) {
+                        // Get class
+                        $class = $this->_functions[$this->_method]->getDeclaringClass()->getName();
+
+                        if ($this->_functions[$this->_method]->isStatic()) {
+                            // for some reason, invokeArgs() does not work the same as
+                            // invoke(), and expects the first argument to be an object.
+                            // So, using a callback if the method is static.
+                            $result = $this->_callStaticMethod($class, $calling_args);
+                        } else {
+                            // Object method
+                            $result = $this->_callObjectMethod($class, $calling_args);
+                        }
+                    } elseif (!$result) {
+                        try {
+                            $result = call_user_func_array($this->_functions[$this->_method]->getName(), $calling_args); //$this->_functions[$this->_method]->invokeArgs($calling_args);
+                        } catch (Exception $e) {
+                            $result = $this->fault($e);
+                        }
+                    }
+                } else {
+
+                    $result = $this->fault(
+                        new Rest_Exception("Unknown Method '$this->_method'."),
+                        404
+                    );
+                }
+            } else {
+                    $result = $this->fault(
+                    new Rest_Exception("Unknown Method '$this->_method'."),
+                    404
+                );
+            }
+        } else {
+                $result = $this->fault(
+                new Rest_Exception("No Method Specified."),
+                404
+            );
+        }
+
+        if ($result instanceof SimpleXMLElement) {
+            $response = $result->asXML();
+        } elseif ($result instanceof DOMDocument) {
+            $response = $result->saveXML();
+        } elseif ($result instanceof DOMNode) {
+            $response = $result->ownerDocument->saveXML($result);
+        } elseif (is_array($result) || is_object($result)) {
+            $response = $this->_handleStruct($result);
+        } else {
+            $response = $this->_handleScalar($result);
+        }
+
+        if (!$this->returnResponse()) {
+            if (!headers_sent()) {
+                foreach ($this->_headers as $header) {
+                    header($header);
+                }
+            }
+
+            echo $response;
+            return;
+        }
+
+        return $response;
+     }
+
+    /**
+     * Implement Rest_Interface::setClass()
+     *
+     * @param string $classname Class name
+     * @param string $namespace Class namespace (unused)
+     * @param array $argv An array of Constructor Arguments
+     */
+    public function setClass($classname, $namespace = '', $argv = array())
+    {
+        $this->_args = $argv;
+        foreach ($this->_reflection->reflectClass($classname, $argv)->getMethods() as $method) {
+            $this->_functions[$method->getName()] = $method;
+        }
+    }
+
+    /**
+     * Handle an array or object result
+     *
+     * @param array|object $struct Result Value
+     * @return string XML Response
+     */
+    protected function _handleStruct($struct)
+    {
+        $function = $this->_functions[$this->_method];
+        if ($function instanceof Rest_Reflection_Method) {
+            $class = $function->getDeclaringClass()->getName();
+        } else {
+            $class = false;
+        }
+
+        $method = $function->getName();
+
+        $dom    = new DOMDocument('1.0', $this->getEncoding());
+        if ($class) {
+            $root   = $dom->createElement($class);
+            $method = $dom->createElement($method);
+            $root->appendChild($method);
+        } else {
+            $root   = $dom->createElement($method);
+            $method = $root;
+        }
+        $root->setAttribute('generator', 'Knowledgetree');
+        $root->setAttribute('version', '1.0');
+        $dom->appendChild($root);
+
+        $this->_structValue($struct, $dom, $method);
+
+        $struct = (array) $struct;
+        if (!isset($struct['status'])) {
+            $status = $dom->createElement('status', 'success');
+            $method->appendChild($status);
+        }
+
+        return $dom->saveXML();
+    }
+
+    /**
+     * Recursively iterate through a struct
+     *
+     * Recursively iterates through an associative array or object's properties
+     * to build XML response.
+     *
+     * @param mixed $struct
+     * @param DOMDocument $dom
+     * @param DOMElement $parent
+     * @return void
+     */
+    protected function _structValue($struct, DOMDocument $dom, DOMElement $parent)
+    {
+        $struct = (array) $struct;
+
+        foreach ($struct as $key => $value) {
+            if ($value === false) {
+                $value = 0;
+            } elseif ($value === true) {
+                $value = 1;
+            }
+
+            if (ctype_digit((string) $key)) {
+                $key = 'key_' . $key;
+            }
+
+            if (is_array($value) || is_object($value)) {
+                $element = $dom->createElement($key);
+                $this->_structValue($value, $dom, $element);
+            } else {
+                $element = $dom->createElement($key);
+                $element->appendChild($dom->createTextNode($value));
+            }
+
+            $parent->appendChild($element);
+        }
+    }
+
+    /**
+     * Handle a single value
+     *
+     * @param string|int|boolean $value Result value
+     * @return string XML Response
+     */
+    protected function _handleScalar($value)
+    {
+        $function = $this->_functions[$this->_method];
+        if ($function instanceof Rest_Reflection_Method) {
+            $class = $function->getDeclaringClass()->getName();
+        } else {
+            $class = false;
+        }
+
+        $method = $function->getName();
+
+        $dom = new DOMDocument('1.0', $this->getEncoding());
+        if ($class) {
+            $xml = $dom->createElement($class);
+            $methodNode = $dom->createElement($method);
+            $xml->appendChild($methodNode);
+        } else {
+            $xml = $dom->createElement($method);
+            $methodNode = $xml;
+        }
+        $xml->setAttribute('generator', 'KnowledgeTree');
+        $xml->setAttribute('version', '1.0');
+        $dom->appendChild($xml);
+
+        if ($value === false) {
+            $value = 0;
+        } elseif ($value === true) {
+            $value = 1;
+        }
+
+        if (isset($value)) {
+            $element = $dom->createElement('response');
+            $element->appendChild($dom->createTextNode($value));
+            $methodNode->appendChild($element);
+        } else {
+            $methodNode->appendChild($dom->createElement('response'));
+        }
+
+        $methodNode->appendChild($dom->createElement('status', 'success'));
+
+        return $dom->saveXML();
+    }
+
+    /**
+     * Implement Rest_Interface::fault()
+     *
+     * Creates XML error response, returning DOMDocument with response.
+     *
+     * @param string|Exception $fault Message
+     * @param int $code Error Code
+     * @return DOMDocument
+     */
+    public function fault($exception = null, $code = null)
+    {
+        if (isset($this->_functions[$this->_method])) {
+            $function = $this->_functions[$this->_method];
+        } elseif (isset($this->_method)) {
+            $function = $this->_method;
+        } else {
+            $function = 'rest';
+        }
+
+        if ($function instanceof Rest_Reflection_Method) {
+            $class = $function->getDeclaringClass()->getName();
+        } else {
+            $class = false;
+        }
+
+        if ($function instanceof Rest_Reflection_Function_Abstract) {
+            $method = $function->getName();
+        } else {
+            $method = $function;
+        }
+
+        $dom = new DOMDocument('1.0', $this->getEncoding());
+        if ($class) {
+            $xml       = $dom->createElement($class);
+            $xmlMethod = $dom->createElement($method);
+            $xml->appendChild($xmlMethod);
+        } else {
+            $xml       = $dom->createElement($method);
+            $xmlMethod = $xml;
+        }
+        $xml->setAttribute('generator', 'KnowledgeTree');
+        $xml->setAttribute('version', '1.0');
+        $dom->appendChild($xml);
+
+        $xmlResponse = $dom->createElement('response');
+        $xmlMethod->appendChild($xmlResponse);
+
+        if ($exception instanceof Exception) {
+            $element = $dom->createElement('message');
+            $element->appendChild($dom->createTextNode($exception->getMessage()));
+            $xmlResponse->appendChild($element);
+            $code = $exception->getCode();
+        } elseif (($exception !== null) || 'rest' == $function) {
+            $xmlResponse->appendChild($dom->createElement('message', 'An unknown error occured. Please try again.'));
+        } else {
+            $xmlResponse->appendChild($dom->createElement('message', 'Call to ' . $method . ' failed.'));
+        }
+
+        $xmlMethod->appendChild($xmlResponse);
+        $xmlMethod->appendChild($dom->createElement('status', 'failed'));
+
+        // Headers to send
+        if ($code === null || (404 != $code)) {
+            $this->_headers[] = 'HTTP/1.0 400 Bad Request';
+        } else {
+            $this->_headers[] = 'HTTP/1.0 404 File Not Found';
+        }
+
+        return $dom;
+    }
+
+    /**
+     * Retrieve any HTTP extra headers set by the server
+     *
+     * @return array
+     */
+    public function getHeaders()
+    {
+        return $this->_headers;
+    }
+
+    /**
+     * Implement Rest_Interface::addFunction()
+     *
+     * @param string $function Function Name
+     * @param string $namespace Function namespace (unused)
+     */
+    public function addFunction($function, $namespace = '')
+    {
+        if (!is_array($function)) {
+            $function = (array) $function;
+        }
+
+        foreach ($function as $func) {
+            if (is_callable($func) && !in_array($func, self::$magicMethods)) {
+                $this->_functions[$func] = $this->_reflection->reflectFunction($func);
+            } else {
+                throw new Rest_Exception("Invalid Method Added to Service.");
+            }
+        }
+    }
+
+    /**
+     * Implement Rest_Interface::getFunctions()
+     *
+     * @return array An array of Rest_Reflection_Method's
+     */
+    public function getFunctions()
+    {
+        return $this->_functions;
+    }
+
+    /**
+     * Implement Rest_Interface::loadFunctions()
+     *
+     * @todo Implement
+     * @param array $functions
+     */
+    public function loadFunctions($functions)
+    {
+    }
+
+    /**
+     * Implement Rest_Interface::setPersistence()
+     *
+     * @todo Implement
+     * @param int $mode
+     */
+    public function setPersistence($mode)
+    {
+    }
+
+    /**
+     * Call a static class method and return the result
+     *
+     * @param  string $class
+     * @param  array $args
+     * @return mixed
+     */
+    protected function _callStaticMethod($class, array $args)
+    {
+        try {
+            $result = call_user_func_array(array($class, $this->_functions[$this->_method]->getName()), $args);
+        } catch (Exception $e) {
+            $result = $this->fault($e);
+        }
+        return $result;
+    }
+
+    /**
+     * Call an instance method of an object
+     *
+     * @param  string $class
+     * @param  array $args
+     * @return mixed
+     * @throws Rest_Exception For invalid class name
+     */
+    protected function _callObjectMethod($class, array $args)
+    {
+        try {
+            if ($this->_functions[$this->_method]->getDeclaringClass()->getConstructor()) {
+                $object = $this->_functions[$this->_method]->getDeclaringClass()->newInstanceArgs($this->_args);
+            } else {
+                $object = $this->_functions[$this->_method]->getDeclaringClass()->newInstance();
+            }
+        } catch (Exception $e) {
+            echo $e->getMessage();
+            throw new Rest_Exception('Error instantiating class ' . $class . ' to invoke method ' . $this->_functions[$this->_method]->getName(), 500);
+        }
+
+        try {
+            $result = $this->_functions[$this->_method]->invokeArgs($object, $args);
+        } catch (Exception $e) {
+            $result = $this->fault($e);
+        }
+
+        return $result;
+    }
+}
diff --git a/webservice/classes/rest/method/Callback.php b/webservice/classes/rest/method/Callback.php
new file mode 100644
index 0000000..e3b808a
--- /dev/null
+++ b/webservice/classes/rest/method/Callback.php
@@ -0,0 +1,179 @@
+<?php
+/**
+ * Method callback metadata
+ *
+ */
+class Rest_Method_Callback
+{
+    /**
+     * @var string Class name for class method callback
+     */
+    protected $_class;
+
+    /**
+     * @var string Function name for function callback
+     */
+    protected $_function;
+
+    /**
+     * @var string Method name for class method callback
+     */
+    protected $_method;
+
+    /**
+     * @var string Callback type
+     */
+    protected $_type;
+
+    /**
+     * @var array Valid callback types
+     */
+    protected $_types = array('function', 'static', 'instance');
+
+    /**
+     * Constructor
+     *
+     * @param  null|array $options
+     * @return void
+     */
+    public function __construct($options = null)
+    {
+        if ((null !== $options) && is_array($options))  {
+            $this->setOptions($options);
+        }
+    }
+
+    /**
+     * Set object state from array of options
+     *
+     * @param  array $options
+     * @return Rest_Method_Callback
+     */
+    public function setOptions(array $options)
+    {
+        foreach ($options as $key => $value) {
+            $method = 'set' . ucfirst($key);
+            if (method_exists($this, $method)) {
+                $this->$method($value);
+            }
+        }
+        return $this;
+    }
+
+    /**
+     * Set callback class
+     *
+     * @param  string $class
+     * @return Rest_Method_Callback
+     */
+    public function setClass($class)
+    {
+        if (is_object($class)) {
+            $class = get_class($class);
+        }
+        $this->_class = $class;
+        return $this;
+    }
+
+    /**
+     * Get callback class
+     *
+     * @return string|null
+     */
+    public function getClass()
+    {
+        return $this->_class;
+    }
+
+    /**
+     * Set callback function
+     *
+     * @param  string $function
+     * @return Rest_Method_Callback
+     */
+    public function setFunction($function)
+    {
+        $this->_function = (string) $function;
+        $this->setType('function');
+        return $this;
+    }
+
+    /**
+     * Get callback function
+     *
+     * @return null|string
+     */
+    public function getFunction()
+    {
+        return $this->_function;
+    }
+
+    /**
+     * Set callback class method
+     *
+     * @param  string $method
+     * @return Rest_Method_Callback
+     */
+    public function setMethod($method)
+    {
+        $this->_method = $method;
+        return $this;
+    }
+
+    /**
+     * Get callback class  method
+     *
+     * @return null|string
+     */
+    public function getMethod()
+    {
+        return $this->_method;
+    }
+
+    /**
+     * Set callback type
+     *
+     * @param  string $type
+     * @return Rest_Method_Callback
+     * @throws Exception
+     */
+    public function setType($type)
+    {
+        if (!in_array($type, $this->_types)) {
+            require_once 'classes/rest/Exception.php';
+            throw new Rest_Exception('Invalid method callback type  passed to ' . __CLASS__ . '::' . __METHOD__);
+        }
+        $this->_type = $type;
+        return $this;
+    }
+
+    /**
+     * Get callback type
+     *
+     * @return string
+     */
+    public function getType()
+    {
+        return $this->_type;
+    }
+
+    /**
+     * Cast callback to array
+     *
+     * @return array
+     */
+    public function toArray()
+    {
+        $type = $this->getType();
+        $array = array(
+            'type' => $type,
+        );
+        if ('function' == $type) {
+            $array['function'] = $this->getFunction();
+        } else {
+            $array['class']  = $this->getClass();
+            $array['method'] = $this->getMethod();
+        }
+        return $array;
+    }
+}
diff --git a/webservice/classes/rest/method/Definition.php b/webservice/classes/rest/method/Definition.php
new file mode 100644
index 0000000..17720e5
--- /dev/null
+++ b/webservice/classes/rest/method/Definition.php
@@ -0,0 +1,267 @@
+<?php
+
+/**
+ * Method definition metadata
+ *
+ */
+class Rest_Method_Definition
+{
+    /**
+     * @var Rest_Method_Callback
+     */
+    protected $_callback;
+
+    /**
+     * @var array
+     */
+    protected $_invokeArguments = array();
+
+    /**
+     * @var string
+     */
+    protected $_methodHelp = '';
+
+    /**
+     * @var string
+     */
+    protected $_name;
+
+    /**
+     * @var null|object
+     */
+    protected $_object;
+
+    /**
+     * @var array Array of Rest_Method_Prototype objects
+     */
+    protected $_prototypes = array();
+
+    /**
+     * Constructor
+     *
+     * @param  null|array $options
+     * @return void
+     */
+    public function __construct($options = null)
+    {
+        if ((null !== $options) && is_array($options)) {
+            $this->setOptions($options);
+        }
+    }
+
+    /**
+     * Set object state from options
+     *
+     * @param  array $options
+     * @return Rest_Method_Definition
+     */
+    public function setOptions(array $options)
+    {
+        foreach ($options as $key => $value) {
+            $method = 'set' . ucfirst($key);
+            if (method_exists($this, $method)) {
+                $this->$method($value);
+            }
+        }
+        return $this;
+    }
+
+    /**
+     * Set method name
+     *
+     * @param  string $name
+     * @return Rest_Method_Definition
+     */
+    public function setName($name)
+    {
+        $this->_name = (string) $name;
+        return $this;
+    }
+
+    /**
+     * Get method name
+     *
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->_name;
+    }
+
+    /**
+     * Set method callback
+     *
+     * @param  array|Rest_Method_Callback $callback
+     * @return Rest_Method_Definition
+     */
+    public function setCallback($callback)
+    {
+        if (is_array($callback)) {
+            $callback = new Rest_Method_Callback($callback);
+        } elseif (!$callback instanceof Rest_Method_Callback) {
+            require_once 'classes/rest/Exception.php';
+            throw new Rest_Exception('Invalid method callback provided');
+        }
+        $this->_callback = $callback;
+        return $this;
+    }
+
+    /**
+     * Get method callback
+     *
+     * @return Rest_Method_Callback
+     */
+    public function getCallback()
+    {
+        return $this->_callback;
+    }
+
+    /**
+     * Add prototype to method definition
+     *
+     * @param  array|Rest_Method_Prototype $prototype
+     * @return Rest_Method_Definition
+     */
+    public function addPrototype($prototype)
+    {
+        if (is_array($prototype)) {
+            require_once 'Prototype.php';
+            $prototype = new Rest_Method_Prototype($prototype);
+        } elseif (!$prototype instanceof Rest_Method_Prototype) {
+            require_once 'classes/rest/Exception.php';
+            throw new Rest_Exception('Invalid method prototype provided');
+        }
+        $this->_prototypes[] = $prototype;
+        return $this;
+    }
+
+    /**
+     * Add multiple prototypes at once
+     *
+     * @param  array $prototypes Array of Rest_Method_Prototype objects or arrays
+     * @return Rest_Method_Definition
+     */
+    public function addPrototypes(array $prototypes)
+    {
+        foreach ($prototypes as $prototype) {
+            $this->addPrototype($prototype);
+        }
+        return $this;
+    }
+
+    /**
+     * Set all prototypes at once (overwrites)
+     *
+     * @param  array $prototypes Array of Rest_Method_Prototype objects or arrays
+     * @return Rest_Method_Definition
+     */
+    public function setPrototypes(array $prototypes)
+    {
+        $this->_prototypes = array();
+        $this->addPrototypes($prototypes);
+        return $this;
+    }
+
+    /**
+     * Get all prototypes
+     *
+     * @return array $prototypes Array of Rest_Method_Prototype objects or arrays
+     */
+    public function getPrototypes()
+    {
+        return $this->_prototypes;
+    }
+
+    /**
+     * Set method help
+     *
+     * @param  string $methodHelp
+     * @return Rest_Method_Definition
+     */
+    public function setMethodHelp($methodHelp)
+    {
+        $this->_methodHelp = (string) $methodHelp;
+        return $this;
+    }
+
+    /**
+     * Get method help
+     *
+     * @return string
+     */
+    public function getMethodHelp()
+    {
+        return $this->_methodHelp;
+    }
+
+    /**
+     * Set object to use with method calls
+     *
+     * @param  object $object
+     * @return Rest_Method_Definition
+     */
+    public function setObject($object)
+    {
+        if (!is_object($object) && (null !== $object)) {
+            require_once 'classes/rest/Exception.php';
+            throw new Rest_Exception('Invalid object passed to ' . __CLASS__ . '::' . __METHOD__);
+        }
+        $this->_object = $object;
+        return $this;
+    }
+
+    /**
+     * Get object to use with method calls
+     *
+     * @return null|object
+     */
+    public function getObject()
+    {
+        return $this->_object;
+    }
+
+    /**
+     * Set invoke arguments
+     *
+     * @param  array $invokeArguments
+     * @return Rest_Method_Definition
+     */
+    public function setInvokeArguments(array $invokeArguments)
+    {
+        $this->_invokeArguments = $invokeArguments;
+        return $this;
+    }
+
+    /**
+     * Retrieve invoke arguments
+     *
+     * @return array
+     */
+    public function getInvokeArguments()
+    {
+        return $this->_invokeArguments;
+    }
+
+    /**
+     * Serialize to array
+     *
+     * @return array
+     */
+    public function toArray()
+    {
+        $prototypes = $this->getPrototypes();
+        $signatures = array();
+        foreach ($prototypes as $prototype) {
+            $signatures[] = $prototype->toArray();
+        }
+
+        return array(
+            'name'            => $this->getName(),
+            'callback'        => $this->getCallback()->toArray(),
+            'prototypes'      => $signatures,
+            'methodHelp'      => $this->getMethodHelp(),
+            'invokeArguments' => $this->getInvokeArguments(),
+            'object'          => $this->getObject(),
+        );
+    }
+}
diff --git a/webservice/classes/rest/method/Parameter.php b/webservice/classes/rest/method/Parameter.php
new file mode 100644
index 0000000..6abaf20
--- /dev/null
+++ b/webservice/classes/rest/method/Parameter.php
@@ -0,0 +1,191 @@
+<?php
+
+
+/**
+ * Method parameter metadata
+ *
+ *
+ */
+class Rest_Method_Parameter
+{
+    /**
+     * @var mixed Default parameter value
+     */
+    protected $_defaultValue;
+
+    /**
+     * @var string Parameter description
+     */
+    protected $_description = '';
+
+    /**
+     * @var string Parameter variable name
+     */
+    protected $_name;
+
+    /**
+     * @var bool Is parameter optional?
+     */
+    protected $_optional = false;
+
+    /**
+     * @var string Parameter type
+     */
+    protected $_type = 'mixed';
+
+    /**
+     * Constructor
+     *
+     * @param  null|array $options
+     * @return void
+     */
+    public function __construct($options = null)
+    {
+        if (is_array($options)) {
+            $this->setOptions($options);
+        }
+    }
+
+    /**
+     * Set object state from array of options
+     *
+     * @param  array $options
+     * @return Rest_Method_Parameter
+     */
+    public function setOptions(array $options)
+    {
+        foreach ($options as $key => $value) {
+            $method = 'set' . ucfirst($key);
+            if (method_exists($this, $method)) {
+                $this->$method($value);
+            }
+        }
+        return $this;
+    }
+
+    /**
+     * Set default value
+     *
+     * @param  mixed $defaultValue
+     * @return Rest_Method_Parameter
+     */
+    public function setDefaultValue($defaultValue)
+    {
+        $this->_defaultValue = $defaultValue;
+        return $this;
+    }
+
+    /**
+     * Retrieve default value
+     *
+     * @return mixed
+     */
+    public function getDefaultValue()
+    {
+        return $this->_defaultValue;
+    }
+
+    /**
+     * Set description
+     *
+     * @param  string $description
+     * @return Rest_Method_Parameter
+     */
+    public function setDescription($description)
+    {
+        $this->_description = (string) $description;
+        return $this;
+    }
+
+    /**
+     * Retrieve description
+     *
+     * @return string
+     */
+    public function getDescription()
+    {
+        return $this->_description;
+    }
+
+    /**
+     * Set name
+     *
+     * @param  string $name
+     * @return Rest_Method_Parameter
+     */
+    public function setName($name)
+    {
+        $this->_name = (string) $name;
+        return $this;
+    }
+
+    /**
+     * Retrieve name
+     *
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->_name;
+    }
+
+    /**
+     * Set optional flag
+     *
+     * @param  bool $flag
+     * @return Rest_Method_Parameter
+     */
+    public function setOptional($flag)
+    {
+        $this->_optional = (bool) $flag;
+        return $this;
+    }
+
+    /**
+     * Is the parameter optional?
+     *
+     * @return bool
+     */
+    public function isOptional()
+    {
+        return $this->_optional;
+    }
+
+    /**
+     * Set parameter type
+     *
+     * @param  string $type
+     * @return Rest_Method_Parameter
+     */
+    public function setType($type)
+    {
+        $this->_type = (string) $type;
+        return $this;
+    }
+
+    /**
+     * Retrieve parameter type
+     *
+     * @return string
+     */
+    public function getType()
+    {
+        return $this->_type;
+    }
+
+    /**
+     * Cast to array
+     *
+     * @return array
+     */
+    public function toArray()
+    {
+        return array(
+            'type'         => $this->getType(),
+            'name'         => $this->getName(),
+            'optional'     => $this->isOptional(),
+            'defaultValue' => $this->getDefaultValue(),
+            'description'  => $this->getDescription(),
+        );
+    }
+}
diff --git a/webservice/classes/rest/method/Prototype.php b/webservice/classes/rest/method/Prototype.php
new file mode 100644
index 0000000..ca67d8e
--- /dev/null
+++ b/webservice/classes/rest/method/Prototype.php
@@ -0,0 +1,184 @@
+<?php
+
+
+/**
+ * Method prototype metadata
+ *
+ *
+ */
+class Rest_Method_Prototype
+{
+    /**
+     * @var string Return type
+     */
+    protected $_returnType = 'void';
+
+    /**
+     * @var array Map parameter names to parameter index
+     */
+    protected $_parameterNameMap = array();
+
+    /**
+     * @var array Method parameters
+     */
+    protected $_parameters = array();
+
+    /**
+     * Constructor
+     *
+     * @param  null|array $options
+     * @return void
+     */
+    public function __construct($options = null)
+    {
+        if ((null !== $options) && is_array($options)) {
+            $this->setOptions($options);
+        }
+    }
+
+    /**
+     * Set return value
+     *
+     * @param  string $returnType
+     * @return Rest_Method_Prototype
+     */
+    public function setReturnType($returnType)
+    {
+        $this->_returnType = $returnType;
+        return $this;
+    }
+
+    /**
+     * Retrieve return type
+     *
+     * @return string
+     */
+    public function getReturnType()
+    {
+        return $this->_returnType;
+    }
+
+    /**
+     * Add a parameter
+     *
+     * @param  string $parameter
+     * @return Rest_Method_Prototype
+     */
+    public function addParameter($parameter)
+    {
+        if ($parameter instanceof Rest_Method_Parameter) {
+            $this->_parameters[] = $parameter;
+            if (null !== ($name = $parameter->getName())) {
+                $this->_parameterNameMap[$name] = count($this->_parameters) - 1;
+            }
+        } else {
+            $parameter = new Rest_Method_Parameter(array(
+                'type' => (string) $parameter,
+            ));
+            $this->_parameters[] = $parameter;
+        }
+        return $this;
+    }
+
+    /**
+     * Add parameters
+     *
+     * @param  array $parameter
+     * @return Rest_Method_Prototype
+     */
+    public function addParameters(array $parameters)
+    {
+        foreach ($parameters as $parameter) {
+            $this->addParameter($parameter);
+        }
+        return $this;
+    }
+
+    /**
+     * Set parameters
+     *
+     * @param  array $parameters
+     * @return Rest_Method_Prototype
+     */
+    public function setParameters(array $parameters)
+    {
+        $this->_parameters       = array();
+        $this->_parameterNameMap = array();
+        $this->addParameters($parameters);
+        return $this;
+    }
+
+    /**
+     * Retrieve parameters as list of types
+     *
+     * @return array
+     */
+    public function getParameters()
+    {
+        $types = array();
+        foreach ($this->_parameters as $parameter) {
+            $types[] = $parameter->getType();
+        }
+        return $types;
+    }
+
+    /**
+     * Get parameter objects
+     *
+     * @return array
+     */
+    public function getParameterObjects()
+    {
+        return $this->_parameters;
+    }
+
+    /**
+     * Retrieve a single parameter by name or index
+     *
+     * @param  string|int $index
+     * @return null Rest_Server_Method_Parameter
+     */
+    public function getParameter($index)
+    {
+        if (!is_string($index) && !is_numeric($index)) {
+            return null;
+        }
+        if (array_key_exists($index, $this->_parameterNameMap)) {
+            $index = $this->_parameterNameMap[$index];
+        }
+        if (array_key_exists($index, $this->_parameters)) {
+            return $this->_parameters[$index];
+        }
+        return null;
+    }
+
+    /**
+     * Set object state from array
+     *
+     * @param  array $options
+     * @return Rest_Method_Prototype
+     */
+    public function setOptions(array $options)
+    {
+        foreach ($options as $key => $value) {
+            $method = 'set' . ucfirst($key);
+            if (method_exists($this, $method)) {
+                $this->$method($value);
+            }
+        }
+        return $this;
+    }
+
+    /**
+     * Serialize to array
+     *
+     * @return array
+     */
+    public function toArray()
+    {
+        return array(
+            'returnType' => $this->getReturnType(),
+            'parameters' => $this->getParameters(),
+        );
+    }
+}
diff --git a/webservice/classes/rest/model/RestService.class.php b/webservice/classes/rest/model/RestService.class.php
new file mode 100755
index 0000000..50b2ac1
--- /dev/null
+++ b/webservice/classes/rest/model/RestService.class.php
@@ -0,0 +1,162 @@
+<?php
+/**
+* Implements a cleaner wrapper restservice and webservice API for KnowledgeTree.
+*
+* KnowledgeTree Community Edition
+* Document Management Made Simple
+* Copyright (C) 2008,2009 KnowledgeTree Inc.
+* Portions copyright The Jam Warehouse Software (Pty) Limited
+*
+* This program is free software; you can redistribute it and/or modify it under
+* the terms of the GNU General Public License version 3 as published by the
+* Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+* FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+* details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+* You can contact KnowledgeTree Inc., PO Box 7775 #87847, San Francisco,
+* California 94120-7775, or email info@knowledgetree.com.
+*
+* The interactive user interfaces in modified source and object code versions
+* of this program must display Appropriate Legal Notices, as required under
+* Section 5 of the GNU General Public License version 3.
+*
+* In accordance with Section 7(b) of the GNU General Public License version 3,
+* these Appropriate Legal Notices must retain the display of the "Powered by
+* KnowledgeTree" logo and retain the original copyright notice. If the display of the
+* logo is not reasonably feasible for technical reasons, the Appropriate Legal Notices
+* must display the words "Powered by KnowledgeTree" and retain the original
+* copyright notice.
+*
+* @copyright 2008-2009, KnowledgeTree Inc.
+* @license GNU General Public License version 3
+* @author KnowledgeTree Team
+* @package Webservice
+* @version Version 0.1
+*/
+
+
+/**
+ * Class Service - will act as a switch between
+ * SOAP requests and REST requests
+ *@author KnowledgeTree Team
+ *@package Webservice
+ *@version Version 0.9
+ */
+class RestService
+{
+    /**
+     * Class construct
+     *
+     * @param object_type $object
+     * @return jason encoded string
+     */
+    public function __construct($object)
+    {
+        try {
+
+            $result = $this->runAsService($object);
+            echo jason_encode(array('status_code' => 0,'result' => $result));
+
+        } catch (Exception $e) {
+            echo json_encode(array('status_code' => 1,'result' => $e->getMessage()));
+        }
+    }
+
+    /**
+     * Constructor for invoking a reflection object
+     * Initiates the object as a service
+     * @param class $object
+     * @access private
+     * @return class instance
+     */
+
+    public function getJason()
+    {
+         $result = $this->runAsService($object);
+         return $result;
+
+    }
+
+    private function runAsService($object)
+    {
+
+        if (!isset($_GET['class'])) {
+
+          throw new Exception('Method name not specified.');
+        }
+
+        $reflObject = new ReflectionObject($object);
+
+        if (!$reflObject->hasMethod($_GET['class'])) {
+
+          throw new Exception('There is no method with this name.');
+
+        }
+
+        $reflMethod = $reflObject->getMethod($_GET['method']);
+
+        if ( !$reflMethod->isPublic() || $reflMethod->isStatic() || $reflMethod->isInternal() ) {
+
+            throw new Exception('Invalid method name specified.');
+
+        }
+
+        $reflParameters = $reflMethod->getParameters();
+
+        $args = array();
+
+
+        foreach ($reflParameters as $param) {
+
+         $paramName = $param->getName();
+
+          if (!isset($_GET[$paramName])) {
+
+            if ($param->isDefaultValueAvailable()) {
+
+              $paramValue = $param->getDefaultValue();
+
+            } else {
+
+              throw new Exception('Required parameter "'.$paramName.'" is not specified.');
+
+            }
+
+          } else {
+
+            $paramValue = $_GET[$paramName];
+
+          }
+
+
+          if ($param->getClass()) {
+
+            throw new Exception('The method contains unsupported parameter type: class object.');
+
+          }
+
+
+          if ($param->isArray() && !is_array($paramValue)) {
+
+            throw new Exception('Array expected for parameter "'.$paramName.'", but scalar found.');
+
+          }
+
+
+          $args[$param->getPosition()] = $paramValue;
+
+        }
+
+        return $reflMethod->invokeArgs($object, $args);
+
+      }
+
+}
+
+?>
\ No newline at end of file
diff --git a/webservice/classes/rest/model/address.class.php b/webservice/classes/rest/model/address.class.php
new file mode 100755
index 0000000..116069d
--- /dev/null
+++ b/webservice/classes/rest/model/address.class.php
@@ -0,0 +1,24 @@
+<?php
+
+/**
+  * Stores an address
+  *
+  * An address consists of a street, number, zipcode and city.
+  * This class is for example purposes only, just to
+  * show how to create a webservice
+  *
+  */
+class address{
+	/** @var string */
+	public $street;
+	
+	/** @var string */
+	public $nr;
+	
+	/** @var string */
+	public $zipcode;	
+	
+	/** @var string */
+	public $city;	
+}
+?>
\ No newline at end of file
diff --git a/webservice/classes/rest/model/contact.class.php b/webservice/classes/rest/model/contact.class.php
new file mode 100755
index 0000000..74e0ae8
--- /dev/null
+++ b/webservice/classes/rest/model/contact.class.php
@@ -0,0 +1,34 @@
+<?php
+
+
+/**
+  * The contact details for a person
+  *
+  * Stores the person's name, address and e-mail
+  * This class is for example purposes only, just to
+  * show how to create a webservice
+  *
+  */
+class contact{
+	/** @var int */
+	public $id;
+	
+	/** @var string */
+	public $name;
+
+	/** @var address */
+	public $address;
+
+	/** @var string */
+	public $email;
+	
+	/**
+	  * saves a contact
+	  *
+	  * @return void
+	  */
+	public function save() {
+		//save contact 2 db
+	}
+}
+?>
\ No newline at end of file
diff --git a/webservice/classes/rest/model/contactManager.class.php b/webservice/classes/rest/model/contactManager.class.php
new file mode 100755
index 0000000..53b8003
--- /dev/null
+++ b/webservice/classes/rest/model/contactManager.class.php
@@ -0,0 +1,61 @@
+<?php
+
+/**
+  * Keeps track of the people in our contact list.
+  *
+  * Starts with a standard contact list and can add
+  * new people to our list or change existing contacts.
+  * This class is for example purposes only, just to
+  * show how to create a webservice
+  */
+
+require('classes/rest/model/contact.class.php');
+require('classes/rest/model/address.class.php');
+class contactManager{
+
+	/**
+	 * Gets the current contact list.
+	 * @return contact[]
+	 */
+	public function	getContacts() {
+		$contact = new contact();
+		$contact->address = new Address();
+		$contact->address->city ="sesamcity";
+		$contact->address->street ="sesamstreet";
+		$contact->email = "me@you.com";
+		$contact->id = 1;
+		$contact->name ="me";
+
+		$ret[] = $contact;
+		return $ret;
+	}
+
+	/**
+	  * Gets the contact with the given id.
+	  * @param int The id
+	  * @return contact
+	  */
+	public function	getContact($id) {
+		//get contact from db
+		//might wanna throw an exception when it does not exists
+		throw new Exception("Contact '$id' not found");
+	}
+	/**
+	  * Generates an new, empty contact template
+	  * @return contact
+	  */
+	public function newContact() {
+		return new contact();
+	}
+
+	/**
+	  * Saves a given contact
+	  * @param contact
+	  * @return void
+	  */
+	public function saveContact(contact $contact) {
+		$contact->save();
+	}
+
+}
+?>
\ No newline at end of file
diff --git a/webservice/classes/rest/reflection/Class.php b/webservice/classes/rest/reflection/Class.php
new file mode 100644
index 0000000..fe7dec6
--- /dev/null
+++ b/webservice/classes/rest/reflection/Class.php
@@ -0,0 +1,171 @@
+<?php
+
+/**
+ * Rest_Reflection_Method
+ */
+require_once 'classes/rest/reflection/Method.php';
+
+/**
+ * Class/Object reflection
+ *
+ */
+class Rest_Reflection_Class
+{
+    /**
+     * Optional configuration parameters; accessible via {@link __get} and
+     * {@link __set()}
+     * @var array
+     */
+    protected $_config = array();
+
+    /**
+     * Array of {@link Rest_Reflection_Method}s
+     * @var array
+     */
+    protected $_methods = array();
+
+    /**
+     * Namespace
+     * @var string
+     */
+    protected $_namespace = null;
+
+    /**
+     * ReflectionClass object
+     * @var ReflectionClass
+     */
+    protected $_reflection;
+
+    /**
+     * Constructor
+     *
+     * Create array of dispatchable methods, each a
+     * {@link Rest_Reflection_Method}. Sets reflection object property.
+     *
+     * @param ReflectionClass $reflection
+     * @param string $namespace
+     * @param mixed $argv
+     * @return void
+     */
+    public function __construct(ReflectionClass $reflection, $namespace = null, $argv = false)
+    {
+        $this->_reflection = $reflection;
+        $this->setNamespace($namespace);
+
+        foreach ($reflection->getMethods() as $method) {
+            // Don't aggregate magic methods
+            if ('__' == substr($method->getName(), 0, 2)) {
+                continue;
+            }
+
+            if ($method->isPublic()) {
+                // Get signatures and description
+                $this->_methods[] = new Rest_Reflection_Method($this, $method, $this->getNamespace(), $argv);
+            }
+        }
+    }
+
+    /**
+     * Proxy reflection calls
+     *
+     * @param string $method
+     * @param array $args
+     * @return mixed
+     */
+    public function __call($method, $args)
+    {
+        if (method_exists($this->_reflection, $method)) {
+            return call_user_func_array(array($this->_reflection, $method), $args);
+        }
+
+        require_once 'classes/rest/Exception.php';
+        throw new Rest_Exception('Invalid reflection method');
+    }
+
+    /**
+     * Retrieve configuration parameters
+     *
+     * Values are retrieved by key from {@link $_config}. Returns null if no
+     * value found.
+     *
+     * @param string $key
+     * @return mixed
+     */
+    public function __get($key)
+    {
+        if (isset($this->_config[$key])) {
+            return $this->_config[$key];
+        }
+
+        return null;
+    }
+
+    /**
+     * Set configuration parameters
+     *
+     * Values are stored by $key in {@link $_config}.
+     *
+     * @param string $key
+     * @param mixed $value
+     * @return void
+     */
+    public function __set($key, $value)
+    {
+        $this->_config[$key] = $value;
+    }
+
+    /**
+     * Return array of dispatchable {@link Rest_Reflection_Method}s.
+     *
+     * @access public
+     * @return array
+     */
+    public function getMethods()
+    {
+        return $this->_methods;
+    }
+
+    /**
+     * Get namespace for this class
+     *
+     * @return string
+     */
+    public function getNamespace()
+    {
+        return $this->_namespace;
+    }
+
+    /**
+     * Set namespace for this class
+     *
+     * @param string $namespace
+     * @return void
+     */
+    public function setNamespace($namespace)
+    {
+        if (empty($namespace)) {
+            $this->_namespace = '';
+            return;
+        }
+
+        if (!is_string($namespace) || !preg_match('/[a-z0-9_\.]+/i', $namespace)) {
+            require_once 'classes/rest/Exception.php';
+            throw new Rest_Exception('Invalid namespace');
+        }
+
+        $this->_namespace = $namespace;
+    }
+
+    /**
+     * Wakeup from serialization
+     *
+     * Reflection needs explicit instantiation to work correctly. Re-instantiate
+     * reflection object on wakeup.
+     *
+     * @return void
+     */
+    public function __wakeup()
+    {
+        $this->_reflection = new ReflectionClass($this->getName());
+    }
+}
diff --git a/webservice/classes/rest/reflection/Function.php b/webservice/classes/rest/reflection/Function.php
new file mode 100644
index 0000000..e818ef8
--- /dev/null
+++ b/webservice/classes/rest/reflection/Function.php
@@ -0,0 +1,15 @@
+<?php
+
+/**
+ * Rest_Reflection_Function_Abstract
+ */
+require_once 'classes/rest/reflection/function/Abstract.php';
+
+/**
+ * Function Reflection
+ *
+ *
+ */
+class Rest_Reflection_Function extends Rest_Reflection_Function_Abstract
+{
+}
diff --git a/webservice/classes/rest/reflection/Method.php b/webservice/classes/rest/reflection/Method.php
new file mode 100644
index 0000000..34502d5
--- /dev/null
+++ b/webservice/classes/rest/reflection/Method.php
@@ -0,0 +1,86 @@
+<?php
+
+/**
+ * Rest_Reflection_Function_Abstract
+ */
+require_once 'classes/rest/reflection/function/Abstract.php';
+
+/**
+ * Method Reflection
+ *
+ *
+ */
+class Rest_Reflection_Method extends Rest_Reflection_Function_Abstract
+{
+    /**
+     * Parent class name
+     * @var string
+     */
+    protected $_class;
+
+    /**
+     * Parent class reflection
+     * @var Rest_Reflection_Class
+     */
+    protected $_classReflection;
+
+    /**
+     * Constructor
+     *
+     * @param Rest_Reflection_Class $class
+     * @param ReflectionMethod $r
+     * @param string $namespace
+     * @param array $argv
+     * @return void
+     */
+    public function __construct(Rest_Reflection_Class $class, ReflectionMethod $r, $namespace = null, $argv = array())
+    {
+        $this->_classReflection = $class;
+        $this->_reflection      = $r;
+
+        $classNamespace = $class->getNamespace();
+
+        // Determine namespace
+        if (!empty($namespace)) {
+            $this->setNamespace($namespace);
+        } elseif (!empty($classNamespace)) {
+            $this->setNamespace($classNamespace);
+        }
+
+        // Determine arguments
+        if (is_array($argv)) {
+            $this->_argv = $argv;
+        }
+
+        // If method call, need to store some info on the class
+        $this->_class = $class->getName();
+
+        // Perform some introspection
+        $this->_reflect();
+    }
+
+    /**
+     * Return the reflection for the class that defines this method
+     *
+     * @return Rest_Reflection_Class
+     */
+    public function getDeclaringClass()
+    {
+        return $this->_classReflection;
+    }
+
+    /**
+     * Wakeup from serialization
+     *
+     * Reflection needs explicit instantiation to work correctly. Re-instantiate
+     * reflection object on wakeup.
+     *
+     * @return void
+     */
+    public function __wakeup()
+    {
+        $this->_classReflection = new Rest_Reflection_Class(new ReflectionClass($this->_class), $this->getNamespace(), $this->getInvokeArguments());
+        $this->_reflection = new ReflectionMethod($this->_classReflection->getName(), $this->getName());
+    }
+
+}
diff --git a/webservice/classes/rest/reflection/Node.php b/webservice/classes/rest/reflection/Node.php
new file mode 100644
index 0000000..4cb7236
--- /dev/null
+++ b/webservice/classes/rest/reflection/Node.php
@@ -0,0 +1,178 @@
+<?php
+
+/**
+ * Node Tree class for Rest reflection operations
+ *
+ *
+ */
+class Rest_Reflection_Node
+{
+    /**
+     * Node value
+     * @var mixed
+     */
+    protected $_value = null;
+
+    /**
+     * Array of child nodes (if any)
+     * @var array
+     */
+    protected $_children = array();
+
+    /**
+     * Parent node (if any)
+     * @var Rest_Reflection_Node
+     */
+    protected $_parent = null;
+
+    /**
+     * Constructor
+     *
+     * @param mixed $value
+     * @param Rest_Reflection_Node $parent Optional
+     * @return Rest_Reflection_Node
+     */
+    public function __construct($value, Rest_Reflection_Node $parent = null)
+    {
+        $this->_value = $value;
+        if (null !== $parent) {
+            $this->setParent($parent, true);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Set parent node
+     *
+     * @param Rest_Reflection_Node $node
+     * @param boolean $new Whether or not the child node is newly created
+     * and should always be attached
+     * @return void
+     */
+    public function setParent(Rest_Reflection_Node $node, $new = false)
+    {
+        $this->_parent = $node;
+
+        if ($new) {
+            $node->attachChild($this);
+            return;
+        }
+    }
+
+    /**
+     * Create and attach a new child node
+     *
+     * @param mixed $value
+     * @access public
+     * @return Rest_Reflection_Node New child node
+     */
+    public function createChild($value)
+    {
+        $child = new self($value, $this);
+
+        return $child;
+    }
+
+    /**
+     * Attach a child node
+     *
+     * @param Rest_Reflection_Node $node
+     * @return void
+     */
+    public function attachChild(Rest_Reflection_Node $node)
+    {
+        $this->_children[] = $node;
+
+        if ($node->getParent() !== $this) {
+            $node->setParent($this);
+        }
+    }
+
+    /**
+     * Return an array of all child nodes
+     *
+     * @return array
+     */
+    public function getChildren()
+    {
+        return $this->_children;
+    }
+
+    /**
+     * Does this node have children?
+     *
+     * @return boolean
+     */
+    public function hasChildren()
+    {
+        return count($this->_children) > 0;
+    }
+
+    /**
+     * Return the parent node
+     *
+     * @return null|Rest_Reflection_Node
+     */
+    public function getParent()
+    {
+        return $this->_parent;
+    }
+
+    /**
+     * Return the node's current value
+     *
+     * @return mixed
+     */
+    public function getValue()
+    {
+        return $this->_value;
+    }
+
+    /**
+     * Set the node value
+     *
+     * @param mixed $value
+     * @return void
+     */
+    public function setValue($value)
+    {
+        $this->_value = $value;
+    }
+
+    /**
+     * Retrieve the bottommost nodes of this node's tree
+     *
+     * Retrieves the bottommost nodes of the tree by recursively calling
+     * getEndPoints() on all children. If a child is null, it returns the parent
+     * as an end point.
+     *
+     * @return array
+     */
+    public function getEndPoints()
+    {
+        $endPoints = array();
+        if (!$this->hasChildren()) {
+            return $endPoints;
+        }
+
+        foreach ($this->_children as $child) {
+            $value = $child->getValue();
+
+            if (null === $value) {
+                $endPoints[] = $this;
+            } elseif ((null !== $value)
+                && $child->hasChildren())
+            {
+                $childEndPoints = $child->getEndPoints();
+                if (!empty($childEndPoints)) {
+                    $endPoints = array_merge($endPoints, $childEndPoints);
+                }
+            } elseif ((null !== $value) && !$child->hasChildren()) {
+                $endPoints[] = $child;
+            }
+        }
+
+        return $endPoints;
+    }
+}
diff --git a/webservice/classes/rest/reflection/Parameter.php b/webservice/classes/rest/reflection/Parameter.php
new file mode 100644
index 0000000..3d8dc01
--- /dev/null
+++ b/webservice/classes/rest/reflection/Parameter.php
@@ -0,0 +1,138 @@
+<?php
+
+/**
+ * Parameter Reflection
+ *
+ * Decorates a ReflectionParameter to allow setting the parameter type
+ *
+ *
+ */
+class Rest_Reflection_Parameter
+{
+    /**
+     * @var ReflectionParameter
+     */
+    protected $_reflection;
+
+    /**
+     * Parameter position
+     * @var int
+     */
+    protected $_position;
+
+    /**
+     * Parameter type
+     * @var string
+     */
+    protected $_type;
+
+    /**
+     * Parameter description
+     * @var string
+     */
+    protected $_description;
+
+    /**
+     * Constructor
+     *
+     * @param ReflectionParameter $r
+     * @param string $type Parameter type
+     * @param string $description Parameter description
+     */
+    public function __construct(ReflectionParameter $r, $type = 'mixed', $description = '')
+    {
+        $this->_reflection = $r;
+        $this->setType($type);
+        $this->setDescription($description);
+    }
+
+    /**
+     * Proxy reflection calls
+     *
+     * @param string $method
+     * @param array $args
+     * @return mixed
+     */
+    public function __call($method, $args)
+    {
+        if (method_exists($this->_reflection, $method)) {
+            return call_user_func_array(array($this->_reflection, $method), $args);
+        }
+
+        require_once 'classes/rest/Exception.php';
+        throw new Rest_Exception('Invalid reflection method');
+    }
+
+    /**
+     * Retrieve parameter type
+     *
+     * @return string
+     */
+    public function getType()
+    {
+        return $this->_type;
+    }
+
+    /**
+     * Set parameter type
+     *
+     * @param string|null $type
+     * @return void
+     */
+    public function setType($type)
+    {
+        if (!is_string($type) && (null !== $type)) {
+            require_once 'classes/rest/Exception.php';
+            throw new Rest_Exception('Invalid parameter type');
+        }
+
+        $this->_type = $type;
+    }
+
+    /**
+     * Retrieve parameter description
+     *
+     * @return string
+     */
+    public function getDescription()
+    {
+        return $this->_description;
+    }
+
+    /**
+     * Set parameter description
+     *
+     * @param string|null $description
+     * @return void
+     */
+    public function setDescription($description)
+    {
+        if (!is_string($description) && (null !== $description)) {
+            require_once 'classes/rest/Exception.php';
+            throw new Rest_Exception('Invalid parameter description');
+        }
+
+        $this->_description = $description;
+    }
+
+    /**
+     * Set parameter position
+     *
+     * @param int $index
+     * @return void
+     */
+    public function setPosition($index)
+    {
+        $this->_position = (int) $index;
+    }
+
+    /**
+     * Return parameter position
+     *
+     * @return int
+     */
+    public function getPosition()
+    {
+        return $this->_position;
+    }
+}
diff --git a/webservice/classes/rest/reflection/Prototype.php b/webservice/classes/rest/reflection/Prototype.php
new file mode 100644
index 0000000..1b654b5
--- /dev/null
+++ b/webservice/classes/rest/reflection/Prototype.php
@@ -0,0 +1,79 @@
+<?php
+
+/**
+ * Rest_Reflection_ReturnValue
+ */
+require_once 'classes/rest/reflection/ReturnValue.php';
+
+/**
+ * Rest_Reflection_Parameter
+ */
+require_once 'classes/rest/reflection/Parameter.php';
+
+/**
+ * Method/Function prototypes
+ *
+ * Contains accessors for the return value and all method arguments.
+ *
+ */
+class Rest_Reflection_Prototype
+{
+    /**
+     * Constructor
+     *
+     * @param Reflection_ReturnValue $return
+     * @param array $params
+     * @return void
+     */
+    public function __construct(Rest_Reflection_ReturnValue $return, $params = null)
+    {
+        $this->_return = $return;
+
+        if (!is_array($params) && (null !== $params)) {
+            require_once 'rest/Exception.php';
+            throw new Rest_Exception('Invalid parameters');
+        }
+
+        if (is_array($params)) {
+            foreach ($params as $param) {
+                if (!$param instanceof Rest_Reflection_Parameter) {
+                    require_once 'rest/Exception.php';
+                    throw new Rest_Exception('One or more params are invalid');
+                }
+            }
+        }
+
+        $this->_params = $params;
+    }
+
+    /**
+     * Retrieve return type
+     *
+     * @return string
+     */
+    public function getReturnType()
+    {
+        return $this->_return->getType();
+    }
+
+    /**
+     * Retrieve the return value object
+     *
+     * @access public
+     * @return Reflection_ReturnValue
+     */
+    public function getReturnValue()
+    {
+        return $this->_return;
+    }
+
+    /**
+     * Retrieve method parameters
+     *
+     * @return array Array of {@link Reflection_Parameter}s
+     */
+    public function getParameters()
+    {
+        return $this->_params;
+    }
+}
diff --git a/webservice/classes/rest/reflection/ReturnValue.php b/webservice/classes/rest/reflection/ReturnValue.php
new file mode 100644
index 0000000..f6a0411
--- /dev/null
+++ b/webservice/classes/rest/reflection/ReturnValue.php
@@ -0,0 +1,87 @@
+<?php
+
+/**
+ * Return value reflection
+ *
+ * Stores the return value type and description
+ *
+ *
+ */
+class Rest_Reflection_ReturnValue
+{
+    /**
+     * Return value type
+     * @var string
+     */
+    protected $_type;
+
+    /**
+     * Return value description
+     * @var string
+     */
+    protected $_description;
+
+    /**
+     * Constructor
+     *
+     * @param string $type Return value type
+     * @param string $description Return value type
+     */
+    public function __construct($type = 'mixed', $description = '')
+    {
+        $this->setType($type);
+        $this->setDescription($description);
+    }
+
+    /**
+     * Retrieve parameter type
+     *
+     * @return string
+     */
+    public function getType()
+    {
+        return $this->_type;
+    }
+
+    /**
+     * Set parameter type
+     *
+     * @param string|null $type
+     * @return void
+     */
+    public function setType($type)
+    {
+        if (!is_string($type) && (null !== $type)) {
+            require_once 'classes/rest/Exception.php';
+            throw new Rest_Exception('Invalid parameter type');
+        }
+
+        $this->_type = $type;
+    }
+
+    /**
+     * Retrieve parameter description
+     *
+     * @return string
+     */
+    public function getDescription()
+    {
+        return $this->_description;
+    }
+
+    /**
+     * Set parameter description
+     *
+     * @param string|null $description
+     * @return void
+     */
+    public function setDescription($description)
+    {
+        if (!is_string($description) && (null !== $description)) {
+            require_once 'classes/rest/Exception.php';
+            throw new Rest_Exception('Invalid parameter description');
+        }
+
+        $this->_description = $description;
+    }
+}
diff --git a/webservice/classes/rest/reflection/function/Abstract.php b/webservice/classes/rest/reflection/function/Abstract.php
new file mode 100644
index 0000000..fb65965
--- /dev/null
+++ b/webservice/classes/rest/reflection/function/Abstract.php
@@ -0,0 +1,479 @@
+<?php
+
+
+/**
+ * Rest_Reflection_Node
+ */
+require_once 'classes/rest/reflection/Node.php';
+
+/**
+ * Rest_Reflection_Parameter
+ */
+require_once 'classes/rest/reflection/Parameter.php';
+
+/**
+ * Rest_Reflection_Prototype
+ */
+require_once 'classes/rest/reflection/Prototype.php';
+
+/**
+ * Function/Method Reflection
+ *
+ * Decorates a ReflectionFunction. Allows setting and retrieving an alternate
+ * 'service' name (i.e., the name to be used when calling via a service),
+ * setting and retrieving the description (originally set using the docblock
+ * contents), retrieving the callback and callback type, retrieving additional
+ * method invocation arguments, and retrieving the
+ * method
+ *
+ */
+abstract class Rest_Reflection_Function_Abstract
+{
+    /**
+     * @var ReflectionFunction
+     */
+    protected $_reflection;
+
+    /**
+     * Additional arguments to pass to method on invocation
+     * @var array
+     */
+    protected $_argv = array();
+
+    /**
+     * Used to store extra configuration for the method (typically done by the
+     * server class, e.g., to indicate whether or not to instantiate a class).
+     * Associative array; access is as properties via {@link __get()} and
+     * {@link __set()}
+     * @var array
+     */
+    protected $_config = array();
+
+    /**
+     * Declaring class (needed for when serialization occurs)
+     * @var string
+     */
+    protected $_class;
+
+    /**
+     * Function/method description
+     * @var string
+     */
+    protected $_description = '';
+
+    /**
+     * Namespace with which to prefix function/method name
+     * @var string
+     */
+    protected $_namespace;
+
+    /**
+     * Prototypes
+     * @var array
+     */
+    protected $_prototypes = array();
+
+    private $_return;
+    private $_returnDesc;
+    private $_paramDesc;
+    private $_sigParams;
+    private $_sigParamsDepth;
+
+    /**
+     * Constructor
+     *
+     * @param ReflectionFunction $r
+     */
+    public function __construct(Reflector $r, $namespace = null, $argv = array())
+    {
+        // In PHP 5.1.x, ReflectionMethod extends ReflectionFunction. In 5.2.x,
+        // both extend ReflectionFunctionAbstract. So, we can't do normal type
+        // hinting in the prototype, but instead need to do some explicit
+        // testing here.
+        if ((!$r instanceof ReflectionFunction)
+            && (!$r instanceof ReflectionMethod)) {
+            require_once 'classes/rest/Exception.php';
+            throw new Rest_Exception('Invalid reflection class');
+        }
+        $this->_reflection = $r;
+
+        // Determine namespace
+        if (null !== $namespace){
+            $this->setNamespace($namespace);
+        }
+
+        // Determine arguments
+        if (is_array($argv)) {
+            $this->_argv = $argv;
+        }
+
+        // If method call, need to store some info on the class
+        if ($r instanceof ReflectionMethod) {
+            $this->_class = $r->getDeclaringClass()->getName();
+        }
+
+        // Perform some introspection
+        $this->_reflect();
+    }
+
+    /**
+     * Create signature node tree
+     *
+     * Recursive method to build the signature node tree. Increments through
+     * each array in {@link $_sigParams}, adding every value of the next level
+     * to the current value (unless the current value is null).
+     *
+     * @param Rest_Reflection_Node $parent
+     * @param int $level
+     * @return void
+     */
+    protected function _addTree(Rest_Reflection_Node $parent, $level = 0)
+    {
+        if ($level >= $this->_sigParamsDepth) {
+            return;
+        }
+
+        foreach ($this->_sigParams[$level] as $value) {
+            $node = new Rest_Reflection_Node($value, $parent);
+            if ((null !== $value) && ($this->_sigParamsDepth > $level + 1)) {
+                $this->_addTree($node, $level + 1);
+            }
+        }
+    }
+
+    /**
+     * Build the signature tree
+     *
+     * Builds a signature tree starting at the return values and descending
+     * through each method argument. Returns an array of
+     * {@link Rest_Reflection_Node}s.
+     *
+     * @return array
+     */
+    protected function _buildTree()
+    {
+        $returnTree = array();
+        foreach ((array) $this->_return as $value) {
+            $node = new Rest_Reflection_Node($value);
+            $this->_addTree($node);
+            $returnTree[] = $node;
+        }
+
+        return $returnTree;
+    }
+
+    /**
+     * Build method signatures
+     *
+     * Builds method signatures using the array of return types and the array of
+     * parameters types
+     *
+     * @param array $return Array of return types
+     * @param string $returnDesc Return value description
+     * @param array $params Array of arguments (each an array of types)
+     * @param array $paramDesc Array of parameter descriptions
+     * @return array
+     */
+    protected function _buildSignatures($return, $returnDesc, $paramTypes, $paramDesc)
+    {
+        $this->_return         = $return;
+        $this->_returnDesc     = $returnDesc;
+        $this->_paramDesc      = $paramDesc;
+        $this->_sigParams      = $paramTypes;
+        $this->_sigParamsDepth = count($paramTypes);
+        $signatureTrees        = $this->_buildTree();
+        $signatures            = array();
+
+        $endPoints = array();
+        foreach ($signatureTrees as $root) {
+            $tmp = $root->getEndPoints();
+            if (empty($tmp)) {
+                $endPoints = array_merge($endPoints, array($root));
+            } else {
+                $endPoints = array_merge($endPoints, $tmp);
+            }
+        }
+
+        foreach ($endPoints as $node) {
+            if (!$node instanceof Rest_Reflection_Node) {
+                continue;
+            }
+
+            $signature = array();
+            do {
+                array_unshift($signature, $node->getValue());
+                $node = $node->getParent();
+            } while ($node instanceof Rest_Reflection_Node);
+
+            $signatures[] = $signature;
+        }
+
+        // Build prototypes
+        $params = $this->_reflection->getParameters();
+        foreach ($signatures as $signature) {
+            $return = new Rest_Reflection_ReturnValue(array_shift($signature), $this->_returnDesc);
+            $tmp    = array();
+            foreach ($signature as $key => $type) {
+                $param = new Rest_Reflection_Parameter($params[$key], $type, $this->_paramDesc[$key]);
+                $param->setPosition($key);
+                $tmp[] = $param;
+            }
+
+            $this->_prototypes[] = new Rest_Reflection_Prototype($return, $tmp);
+        }
+    }
+
+    /**
+     * Use code reflection to create method signatures
+     *
+     * Determines the method help/description text from the function DocBlock
+     * comment. Determines method signatures using a combination of
+     * ReflectionFunction and parsing of DocBlock @param and @return values.
+     *
+     * @param ReflectionFunction $function
+     * @return array
+     */
+    protected function _reflect()
+    {
+        $function           = $this->_reflection;
+        $helpText           = '';
+        $signatures         = array();
+        $returnDesc         = '';
+        $paramCount         = $function->getNumberOfParameters();
+        $paramCountRequired = $function->getNumberOfRequiredParameters();
+        $parameters         = $function->getParameters();
+        $docBlock           = $function->getDocComment();
+
+        if (!empty($docBlock)) {
+            // Get help text
+            if (preg_match(':/\*\*\s*\r?\n\s*\*\s(.*?)\r?\n\s*\*(\s@|/):s', $docBlock, $matches))
+            {
+                $helpText = $matches[1];
+                $helpText = preg_replace('/(^\s*\*\s)/m', '', $helpText);
+                $helpText = preg_replace('/\r?\n\s*\*\s*(\r?\n)*/s', "\n", $helpText);
+                $helpText = trim($helpText);
+            }
+
+            // Get return type(s) and description
+            $return     = 'void';
+            if (preg_match('/@return\s+(\S+)/', $docBlock, $matches)) {
+                $return = explode('|', $matches[1]);
+                if (preg_match('/@return\s+\S+\s+(.*?)(@|\*\/)/s', $docBlock, $matches))
+                {
+                    $value = $matches[1];
+                    $value = preg_replace('/\s?\*\s/m', '', $value);
+                    $value = preg_replace('/\s{2,}/', ' ', $value);
+                    $returnDesc = trim($value);
+                }
+            }
+
+            // Get param types and description
+            if (preg_match_all('/@param\s+([^\s]+)/m', $docBlock, $matches)) {
+                $paramTypesTmp = $matches[1];
+                if (preg_match_all('/@param\s+\S+\s+(\$^\S+)\s+(.*?)(@|\*\/)/s', $docBlock, $matches))
+                {
+                    $paramDesc = $matches[2];
+                    foreach ($paramDesc as $key => $value) {
+                        $value = preg_replace('/\s?\*\s/m', '', $value);
+                        $value = preg_replace('/\s{2,}/', ' ', $value);
+                        $paramDesc[$key] = trim($value);
+                    }
+                }
+            }
+        } else {
+            $helpText = $function->getName();
+            $return   = 'void';
+        }
+
+        // Set method description
+        $this->setDescription($helpText);
+
+        // Get all param types as arrays
+        if (!isset($paramTypesTmp) && (0 < $paramCount)) {
+            $paramTypesTmp = array_fill(0, $paramCount, 'mixed');
+        } elseif (!isset($paramTypesTmp)) {
+            $paramTypesTmp = array();
+        } elseif (count($paramTypesTmp) < $paramCount) {
+            $start = $paramCount - count($paramTypesTmp);
+            for ($i = $start; $i < $paramCount; ++$i) {
+                $paramTypesTmp[$i] = 'mixed';
+            }
+        }
+
+        // Get all param descriptions as arrays
+        if (!isset($paramDesc) && (0 < $paramCount)) {
+            $paramDesc = array_fill(0, $paramCount, '');
+        } elseif (!isset($paramDesc)) {
+            $paramDesc = array();
+        } elseif (count($paramDesc) < $paramCount) {
+            $start = $paramCount - count($paramDesc);
+            for ($i = $start; $i < $paramCount; ++$i) {
+                $paramDesc[$i] = '';
+            }
+        }
+
+        if (count($paramTypesTmp) != $paramCount) {
+            require_once 'classes/rest/Exception.php';
+            throw new Rest_Exception(
+               'Variable number of arguments is not supported for services (except optional parameters). '
+             . 'Number of function arguments must currespond to actual number of arguments described in a docblock.');
+        }
+
+        $paramTypes = array();
+        foreach ($paramTypesTmp as $i => $param) {
+            $tmp = explode('|', $param);
+            if ($parameters[$i]->isOptional()) {
+                array_unshift($tmp, null);
+            }
+            $paramTypes[] = $tmp;
+        }
+
+        $this->_buildSignatures($return, $returnDesc, $paramTypes, $paramDesc);
+    }
+
+
+    /**
+     * Proxy reflection calls
+     *
+     * @param string $method
+     * @param array $args
+     * @return mixed
+     */
+    public function __call($method, $args)
+    {
+        if (method_exists($this->_reflection, $method)) {
+            return call_user_func_array(array($this->_reflection, $method), $args);
+        }
+
+        require_once 'classes/rest/Exception.php';
+        throw new Rest_Exception('Invalid reflection method ("' .$method. '")');
+    }
+
+    /**
+     * Retrieve configuration parameters
+     *
+     * Values are retrieved by key from {@link $_config}. Returns null if no
+     * value found.
+     *
+     * @param string $key
+     * @return mixed
+     */
+    public function __get($key)
+    {
+        if (isset($this->_config[$key])) {
+            return $this->_config[$key];
+        }
+
+        return null;
+    }
+
+    /**
+     * Set configuration parameters
+     *
+     * Values are stored by $key in {@link $_config}.
+     *
+     * @param string $key
+     * @param mixed $value
+     * @return void
+     */
+    public function __set($key, $value)
+    {
+        $this->_config[$key] = $value;
+    }
+
+    /**
+     * Set method's namespace
+     *
+     * @param string $namespace
+     * @return void
+     */
+    public function setNamespace($namespace)
+    {
+        if (empty($namespace)) {
+            $this->_namespace = '';
+            return;
+        }
+
+        if (!is_string($namespace) || !preg_match('/[a-z0-9_\.]+/i', $namespace)) {
+            require_once 'classes/rest/Exception.php';
+            throw new Rest_Exception('Invalid namespace');
+        }
+
+        $this->_namespace = $namespace;
+    }
+
+    /**
+     * Return method's namespace
+     *
+     * @return string
+     */
+    public function getNamespace()
+    {
+        return $this->_namespace;
+    }
+
+    /**
+     * Set the description
+     *
+     * @param string $string
+     * @return void
+     */
+    public function setDescription($string)
+    {
+        if (!is_string($string)) {
+            require_once 'classes/rest/Exception.php';
+            throw new Rest_Exception('Invalid description');
+        }
+
+        $this->_description = $string;
+    }
+
+    /**
+     * Retrieve the description
+     *
+     * @return void
+     */
+    public function getDescription()
+    {
+        return $this->_description;
+    }
+
+    /**
+     * Retrieve all prototypes as array of
+     * {@link Rest_Reflection_Prototype Rest_Reflection_Prototypes}
+     *
+     * @return array
+     */
+    public function getPrototypes()
+    {
+        return $this->_prototypes;
+    }
+
+    /**
+     * Retrieve additional invocation arguments
+     *
+     * @return array
+     */
+    public function getInvokeArguments()
+    {
+        return $this->_argv;
+    }
+
+    /**
+     * Wakeup from serialization
+     *
+     * Reflection needs explicit instantiation to work correctly. Re-instantiate
+     * reflection object on wakeup.
+     *
+     * @return void
+     */
+    public function __wakeup()
+    {
+        if ($this->_reflection instanceof ReflectionMethod) {
+            $class = new ReflectionClass($this->_class);
+            $this->_reflection = new ReflectionMethod($class->newInstance(), $this->getName());
+        } else {
+            $this->_reflection = new ReflectionFunction($this->getName());
+        }
+    }
+}
diff --git a/webservice/classes/soap/IPPhpDoc.class.php b/webservice/classes/soap/IPPhpDoc.class.php
new file mode 100755
index 0000000..35e49b4
--- /dev/null
+++ b/webservice/classes/soap/IPPhpDoc.class.php
@@ -0,0 +1,110 @@
+<?PHP
+
+/**
+ * The base phpdoc class searches for available classes
+ *
+ *@author KnowledgeTree Team
+ *@package Webservice
+ *@version Version 0.9
+ */
+class IPPhpDoc{
+	/** @var IPReflectionClass[] Array with available classes */
+	public $classes = array();
+
+	/** @var IPReflectionClass The current class */
+	public $class = "";
+
+	/**
+	* Constructor, initiates the getClasses() method
+	*
+	* @return void
+	*/
+	function __construct() {
+		$this->getClasses();
+	}
+
+	/** Sets the current class
+	 * @param string The class name
+	 * @return void
+	 */
+	public function setClass($class) {
+		$this->class = new IPReflectionClass($class);
+	}
+	/**
+	 * Get all classes
+	 *
+	 * @return IPReflectionClass[]
+	 */
+	function getClasses() {
+		$ar = get_declared_classes();
+		foreach($ar as $class){
+			$c = new reflectionClass($class);
+			if($c->isUserDefined()){//add only when class is user-defined
+				$this->classes[$class] = new IPReflectionClass($class);
+			}
+		}
+		ksort($this->classes);
+		return $this->classes;
+	}
+	/**
+	 * Generates the documentation page with all classes, methods etc.
+	 * @TODO FIXME: use the new template class
+	 * @param string Template file (optional)
+	 * @return string
+	 */
+	public function getDocumentation($template="classes/soap/templates/docclass.xsl")	{
+		if(!is_file($template))
+			throw new WSException("Could not find the template file: '$template'");
+		$xtpl = new IPXSLTemplate($template);
+		$documentation = Array();
+		$documentation['menu'] = Array();
+		//loop menu items
+		$documentation['menu'] = $this->getClasses();
+
+		if($this->class){
+			if($this->class->isUserDefined()) {
+				$this->class->properties = $this->class->getProperties(false, false);
+				$this->class->methods = $this->class->getMethods(false, false);
+				foreach((array)$this->class->methods as $method) {
+					$method->params = $method->getParameters();
+				}
+			} else {
+				$documentation['fault'] = "Native class";
+			}
+			$documentation['class'] = $this->class;
+		}
+		echo $xtpl->execute($documentation);
+	}
+
+
+	/**
+	 *
+	 * @param $comment String The doccomment
+	 * @param $annotationName String the annotation name
+	 * @param $annotationClass String the annotation class
+	 * @return void
+	 */
+	public static function getAnnotation($comment, $annotationName, $annotationClass = null){
+		if(!$annotationClass){
+			$annotationClass = $annotationName;
+		}
+		$start = 0;
+		if($start = stripos($comment, "@".$annotationName)){
+			$obi = new $annotationClass();
+			$start = strpos($comment, "(", $start);
+			$end = strpos($comment, ")", $start);
+			$propString = substr($comment, $start, ($end-$start) + 1);
+			$eval = "return Array$propString;";
+			$arr = @eval($eval);
+			if($arr === false) throw new Exception("Error parsing annotation: $propString");
+
+			foreach ((Array)$arr as $name => $value){
+				$obi->$name= $value;
+			}
+			return $obi;
+		}
+		throw new Exception("Cannot find annotation @$annotationName ($start, $end): {$this->comment} ");
+	}
+
+}
+?>
\ No newline at end of file
diff --git a/webservice/classes/soap/IPReflectionClass.class.php b/webservice/classes/soap/IPReflectionClass.class.php
new file mode 100755
index 0000000..21e30b9
--- /dev/null
+++ b/webservice/classes/soap/IPReflectionClass.class.php
@@ -0,0 +1,114 @@
+<?php
+/**
+ * An extended reflection/documentation class for classes
+ *
+ * This class extends the reflectionClass class by also parsing the
+ * comment for javadoc compatible @tags and by providing help
+ * functions to generate a WSDL file. THe class might also
+ * be used to generate a phpdoc on the fly
+ *
+ *@author KnowledgeTree Team
+ *@package Webservice
+ *@version Version 0.9
+ *@extends reflectionClass
+ */
+class IPReflectionClass extends reflectionClass {
+	/** @var string class name */
+	public $classname = null;
+
+	/** @var string */
+	public $fullDescription = "";
+
+	/** @var string */
+	public $smallDescription = "";
+
+	/** @var IPReflectionMethod[] */
+	public $methods = Array();
+
+	/** @var IPReflectionProperty[] */
+	public $properties = Array();
+
+	/** @var string */
+	public $extends;
+
+	/** @var string */
+	private $comment = null;
+
+
+	/**
+	 * Constructor
+	 *
+	 * sets the class name and calls the constructor of the reflectionClass
+	 *
+	 * @param string The class name
+	 * @return void
+	 */
+	public function __construct($classname){
+		$this->classname = $classname;
+		parent::__construct($classname);
+
+		$this->parseComment();
+	}
+
+	/**
+	 *Provides all methods exposed by this class as an array
+	 *
+	 * @param boolean If the method should also return protected functions
+	 * @param boolean If the method should also return private functions
+	 * @return IPReflectionMethod[]
+	 */
+	public function getMethods($alsoProtected = true, $alsoPrivate = true){
+		$ar = parent::getMethods();
+		foreach($ar as $method){
+			$m = new IPReflectionMethod($this->classname, $method->name);
+			if((!$m->isPrivate() || $alsoPrivate) && (!$m->isProtected() || $alsoProtected) && ($m->getDeclaringClass()->name == $this->classname))
+				$this->methods[$method->name] = $m;
+		}
+		ksort($this->methods);
+		return $this->methods;
+	}
+
+	/**
+	 * Exposes an array with public properties of the class
+	 *
+	 * @param boolean If the method should also return protected properties
+	 * @param boolean If the method should also return private properties
+	 * @return IPReflectionProperty[]
+	 */
+	public function getProperties($alsoProtected=true,$alsoPrivate=true) {
+		$ar = parent::getProperties();
+		$this->properties = Array();
+		foreach($ar as $property){
+			if((!$property->isPrivate() || $alsoPrivate) && (!$property->isProtected() || $alsoProtected)){
+				try{
+					$p = new IPReflectionProperty($this->classname, $property->getName());
+					$this->properties[$property->name]=$p;
+				}catch(ReflectionException $exception){
+					echo "Fault on property: ".$property->name."<br>\n";
+				}
+			}
+		}
+		ksort($this->properties);
+		return $this->properties;
+	}
+
+	/**
+	 * 	Exposes annotations of the class
+	 * @param $annotationName String the annotation name
+	 * @param $annotationClass String the annotation class
+	 * @return void
+	 */
+	public function getAnnotation($annotationName, $annotationClass = null){
+		return IPPhpDoc::getAnnotation($this->comment, $annotationName, $annotationClass);
+	}
+
+	/**
+	 * Gets all the usefull information from the comments
+	 * @return void
+	 */
+	private function parseComment() {
+		$this->comment = $this->getDocComment();
+		new IPReflectionCommentParser($this->comment, $this);
+	}
+}
+?>
\ No newline at end of file
diff --git a/webservice/classes/soap/IPReflectionCommentParser.class.php b/webservice/classes/soap/IPReflectionCommentParser.class.php
new file mode 100755
index 0000000..9d8340f
--- /dev/null
+++ b/webservice/classes/soap/IPReflectionCommentParser.class.php
@@ -0,0 +1,170 @@
+<?php
+/**
+ * Class for parsing the comment blocks for classes, functions
+ * methods and properties.
+ *
+ * The class parses the commentblock and extracts certain
+ * documentation tags and the (full/small) description
+ *
+ *@author KnowledgeTree Team
+ *@package Webservice
+ *@version Version 0.9
+ */
+
+class IPReflectionCommentParser{
+	/**
+	 * @var string Contains the full commen text
+	 */
+	public $comment;
+
+	/**
+	 * @var object refence to the IPReflection(Class|Method|Property)
+	 */
+	public $obj;
+
+	/** @var boolean */
+	public $smallDescriptionDone;
+
+	/** @var boolean */
+	public $fullDescriptionDone;
+
+	/**
+	 * Constructor, initiateds the parse function
+	 *
+	 * @param string Commentaar block
+	 * @param string Defines if its the comment for a class, public of function
+	 */
+	function __construct($comment, $obj) {
+		$this->comment	= $comment;
+		$this->obj		= $obj;
+		$this->parse();
+	}
+	/**
+	 * parses the comment, line for line
+	 *
+	 * Will take the type of comment (class, property or function) as an
+	 * argument and split it up in lines.
+	 * @param string Defines if its the comment for a class, public of function
+	 * @return void
+	 */
+	function parse() {
+		//reset object
+		$descriptionDone = false;
+		$this->fullDescriptionDone = false;
+
+		//split lines
+		$lines = split("\n", $this->comment);
+
+		//check lines for description or tags
+		foreach ($lines as $line) {
+			$pos = strpos($line,"* @");
+			if (trim($line) == "/**" || trim($line) == "*/") { //skip the start and end line
+			}elseif (!($pos === false)) { //comment
+				$this->parseTagLine(substr($line,$pos+3));
+				$descriptionDone=true;
+			}elseif(!$descriptionDone){
+				$this->parseDescription($line);
+			}
+		}
+		//if full description is empty, put small description in full description
+		if (trim(str_replace(Array("\n","\r"), Array("", ""), $this->obj->fullDescription)) == "")
+			$this->obj->fullDescription = $this->obj->smallDescription;
+	}
+
+	/**
+	 * Parses the description to the small and full description properties
+	 *
+	 * @param string The description line
+	 * @return void
+	 */
+
+	function parseDescription($descriptionLine) {
+		if(strpos($descriptionLine,"*") <= 2) $descriptionLine = substr($descriptionLine, (strpos($descriptionLine,"*") + 1));
+
+	 	//geen lege comment regel indien al in grote omschrijving
+	 	if(trim(str_replace(Array("\n","\r"), Array("", ""), $descriptionLine)) == ""){
+	 		if($this->obj->fullDescription == "")
+	 			$descriptionLine = "";
+			$this->smallDescriptionDone = true;
+		}
+
+		if(!$this->smallDescriptionDone)//add to small description
+			$this->obj->smallDescription.=$descriptionLine;
+		else{//add to full description
+			$this->obj->fullDescription.=$descriptionLine;
+		}
+	 }
+
+	/**
+	 * Parses a tag line and extracts the tagname and values
+	 *
+	 * @param string The tagline
+	 * @return void
+	 */
+	function parseTagLine($tagLine) {
+		$tagArr = explode(" ", $tagLine);
+		$tag = $tagArr[0];
+
+		switch(strtolower($tag)){
+			case 'abstract':
+				$this->obj->abstract = true; break;
+			case 'access':
+				$this->obj->isPrivate = (strtolower(trim($tagArr[1]))=="private")?true:false;
+				break;
+			case 'author':
+				unset($tagArr[0]);
+				$this->obj->author = implode(" ",$tagArr);
+				break;
+			case 'copyright':
+				unset($tagArr[0]);
+				$this->obj->copyright = implode(" ",$tagArr);
+				break;
+			case 'deprecated':
+			case 'deprec':
+				$this->obj->deprecated = true;
+				break;
+			case 'extends': break;
+			case 'global':
+				$this->obj->globals[] = $tagArr[1];
+				break;
+			case 'param':
+				$o = new stdClass();
+				$o->type = trim($tagArr[1]);
+				$o->comment = implode(" ",$tagArr);
+				$this->obj->params[] = $o;
+				break;
+			case 'return':
+				$this->obj->return = trim($tagArr[1]); break;
+			case 'link':break;
+			case 'see':break;
+			case 'since':
+				$this->obj->since = trim($tagArr[1]); break;
+			case 'static':
+				$this->obj->static = true; break;
+			case 'throws':
+				unset($tagArr[0]);
+				$this->obj->throws = implode(" ",$tagArr);
+				break;
+			case 'todo':
+				unset($tagArr[0]);
+				$this->obj->todo[] = implode(" ",$tagArr);
+				break;
+			case 'var':
+				$this->obj->type = trim($tagArr[1]);
+				unset($tagArr[0],$tagArr[1]);
+				$comment=implode(" ",$tagArr);
+				//check if its an optional property
+				$this->obj->optional = strpos($comment,"[OPTIONAL]") !== FALSE;
+				$this->obj->autoincrement = strpos($comment,"[AUTOINCREMENT]") !== FALSE;
+				$this->obj->description = str_replace("[OPTIONAL]", "", $comment);
+				break;
+			case 'version':
+				$this->obj->version = $tagArr[1];
+				break;
+			default:
+			  //echo "\nno valid tag: '".strtolower($tag)."' at tagline: '$tagLine' <br>";
+				//do nothing
+		}
+	}
+}
+?>
\ No newline at end of file
diff --git a/webservice/classes/soap/IPReflectionMethod.class.php b/webservice/classes/soap/IPReflectionMethod.class.php
new file mode 100755
index 0000000..9f11b05
--- /dev/null
+++ b/webservice/classes/soap/IPReflectionMethod.class.php
@@ -0,0 +1,100 @@
+<?php
+/**
+ * An extended reflection/documentation class for class methods
+ *
+ * This class extends the reflectioMethod class by also parsing the
+ * comment for javadoc compatible @tags and by providing help
+ * functions to generate a WSDL file. The class might also
+ * be used to generate a phpdoc on the fly
+ *
+ *@author KnowledgeTree Team
+ *@package Webservice
+ *@version Version 0.9
+ *@extends reflectionMethod
+ */
+
+class IPReflectionMethod extends reflectionMethod{
+	/** @var string class name */
+	public $classname;
+
+	/** @var string The return type for this method	 */
+	public $return = "";
+
+	/** @var IPReflectionParameter[] Associative array with reflectionParameter objects */
+	public $parameters = array();
+
+	/** @var string */
+	public $fullDescription = "";
+
+	/** @var string */
+	public $smallDescription = "";
+
+	/** @var string */
+	public $throws="";
+
+	/**
+	 * Constructor which calls the parent constructor and makes sure the comment
+	 * of the method is parsed
+	 *
+	 * @param string The class name
+	 * @param string The method name
+	 */
+	public function __construct($class,$method){
+		$this->classname = $class;
+		parent::__construct($class,$method);
+		$this->parseComment();
+	}
+
+	/**
+	 * Returns the full function name, including arguments
+	 * @return string
+	 */
+	public function getFullName(){
+		$args = $this->getParameters();
+		$argstr = "";
+
+		foreach((array)$args as $arg){
+			if($argstr!="")$argstr.=", ";
+			$argstr.= $arg->type ." $".$arg->name;
+		}
+		return $this->return." ".$this->name."(".$argstr.")";
+	}
+
+	/**
+	 * Returns an array with parameter objects, containing type info etc.
+	 *
+	 * @return ReflectionParameter[] Associative array with parameter objects
+	 */
+	public function getParameters(){
+		$this->parameters = Array();
+		$ar = parent::getParameters();
+		$i = 0;
+
+		foreach((array)$ar as $parameter){
+			$parameter->type = $this->params[$i++]->type;
+			$this->parameters[$parameter->name] = $parameter;
+		}
+
+		return $this->parameters;
+	}
+
+	/**
+	 *
+	 * @param $annotationName String the annotation name
+	 * @param $annotationClass String the annotation class
+	 * @return void
+	 */
+	public function getAnnotation($annotationName, $annotationClass = null){
+		return IPPhpDoc::getAnnotation($this->comment, $annotationName, $annotationClass);
+	}
+
+	/**
+	 * Parses the comment and adds found properties to this class
+	 * @return void
+	 */
+	private function parseComment(){
+		$this->comment = $this->getDocComment();
+		new IPReflectionCommentParser($this->comment, $this);
+	}
+}
+?>
\ No newline at end of file
diff --git a/webservice/classes/soap/IPReflectionProperty.class.php b/webservice/classes/soap/IPReflectionProperty.class.php
new file mode 100755
index 0000000..4feaa29
--- /dev/null
+++ b/webservice/classes/soap/IPReflectionProperty.class.php
@@ -0,0 +1,75 @@
+<?php
+/**
+ * An extended reflection/documentation class for class properties
+ *
+ * This class extends the reflectionProperty class by also parsing the
+ * comment for javadoc compatible @tags and by providing help
+ * functions to generate a WSDL file. The class might also
+ * be used to generate a phpdoc on the fly
+ *
+ *@author KnowledgeTree Team
+ *@package Webservice
+ *@version Version 0.9
+ *@extends reflectionProperty
+ */
+class IPReflectionProperty extends reflectionProperty {
+	/** @var string Classname to whom this property belongs */
+	public $classname;
+
+	/** @var string Type description of the property */
+	public $type = "";
+
+	/** @var boolean Determens if the property is a private property */
+	public $isPrivate = false;
+
+	/** @var string */
+	public $description;
+
+	/** @var boolean */
+	public $optional = false;
+
+	/** @var boolean */
+	public $autoincrement = false;
+
+	/** @var string */
+	public $fullDescription = "";
+
+	/** @var string */
+	public $smallDescription = "";
+
+	/** @var string */
+	public $name = null;
+
+	/** @var string */
+	private $comment = null;
+
+	/**
+	 * constructor. will initiate the commentParser
+	 *
+	 * @param string Class name
+	 * @param string Property name
+	 * @return void
+	 */
+	public function __construct($class, $property){
+		$this->classname = $class;
+		parent::__construct($class, $property);
+		$this->parseComment();
+	}
+
+	/**
+	 *
+	 * @param $annotationName String the annotation name
+	 * @param $annotationClass String the annotation class
+	 * @return void
+	 */
+	public function getAnnotation($annotationName, $annotationClass = null){
+		return IPPhpDoc::getAnnotation($this->comment, $annotationName, $annotationClass);
+	}
+
+	private function parseComment(){
+		// No getDocComment available for properties in php 5.0.3 :(
+		$this->comment = $this->getDocComment();
+		new IPReflectionCommentParser($this->comment, $this);
+	}
+}
+?>
\ No newline at end of file
diff --git a/webservice/classes/soap/IPXMLSchema.class.php b/webservice/classes/soap/IPXMLSchema.class.php
new file mode 100755
index 0000000..4b1653f
--- /dev/null
+++ b/webservice/classes/soap/IPXMLSchema.class.php
@@ -0,0 +1,179 @@
+<?php
+
+/**
+ * This class helps you creating a valid XMLSchema file
+ *@author KnowledgeTree Team
+ *@package Webservice
+ *@version Version 0.9
+ */
+class IPXMLSchema {
+	/** @var domelement reference to the parent domelement */
+	private $parentElement;
+
+	/** @var domelement[] Array with references to all known types in this schema */
+	private $types = Array();
+
+	/** @var boolean True=place array's inline */
+	private $array_inline = false;
+
+	public function __construct(domelement $parentElement){
+		$this->parentElement = $parentElement;
+	}
+
+	/**
+	 * Ads a complexType tag with xmlschema content to the types tag
+	 * @param string The variable type (Array or class name)
+	 * @param string The variable name
+	 * @param domNode Used when adding an inline complexType
+	 * @return domNode The complexType node
+	 */
+
+	public function addComplexType($type, $name = false, $parent = false) {
+		if(!$parent){//outline element
+			//check if the complexType doesn't already exists
+			if(isset($this->types[$name])) return $this->types[$name];
+
+			//create the complexType tag beneath the xsd:schema tag
+			$complexTypeTag=$this->addElement("xsd:complexType", $this->parentElement);
+			if($name){//might be an anonymous element
+				$complexTypeTag->setAttribute("name",$name);
+				$this->types[$name]=$complexTypeTag;
+			}
+		}else{//inline element
+			$complexTypeTag = $this->addElement("xsd:complexType", $parent);
+		}
+
+		//check if its an array
+		if(strtolower(substr($type,0,6)) == 'array(' || substr($type,-2) == '[]'){
+			$this->addArray($type,$complexTypeTag);
+		}else{//it should be an object
+			$tag=$this->addElement("xsd:all", $complexTypeTag);
+			//check if it has the name 'object()' (kind of a stdClass)
+			if(strtolower(substr($type,0,6)) == 'object'){//stdClass
+				$content = substr($type, 7, (strlen($type)-1));
+				$properties = split(",", $content);//split the content into properties
+				foreach((array)$properties as $property){
+					if($pos = strpos($property, "=>")){//array with keys (order is important, so use 'sequence' tag)
+						$keyType = substr($property,6,($pos-6));
+						$valueType = substr($property,($pos+2), (strlen($property)-7));
+						$el->$this->addTypeElement($valueType, $keyType, $tag);
+					}else{
+						throw new WSDLException("Error creating WSDL: expected \"=>\". When using the object() as type, use it as object(paramname=>paramtype,paramname2=>paramtype2)");
+					}
+				}
+			}else{ //should be a known class
+
+				if(!class_exists($name)) throw new WSDLException("Error creating WSDL: no class found with the name '$name' / $type : $parent, so how should we know the structure for this datatype?");
+				$v = new IPReflectionClass($name);
+				//TODO: check if the class extends another class?
+				$properties = $v->getProperties(false, false);//not protected and private properties
+
+				foreach((array) $properties as $property){
+					if(!$property->isPrivate){
+						$el = $this->addTypeElement($property->type, $property->name, $tag, $property->optional);
+					}
+				}
+			}
+		}
+		return $complexTypeTag;
+	}
+
+	/**
+	 * Adds an element tag beneath the parent and takes care
+	 * of the type (XMLSchema type or complexType)
+	 * @param string The datatype
+	 * @param string Name of the element
+	 * @param domNode The parent domNode
+	 * @param boolean If the property is optional
+	 * @return domNode
+	 */
+	public function addTypeElement($type, $name, $parent, $optional = false) {
+		$el = $this->addElement("xsd:element", $parent);
+		$el->setAttribute("name", $name);
+
+		if($optional){//if it's an optional property, set minOccur to 0
+			$el->setAttribute("minOccurs", "0");
+			$el->setAttribute("maxOccurs", "1");
+		}
+
+		//check if XML Schema datatype
+		if($t = $this->checkSchemaType(strtolower($type)))
+				$el->setAttribute("type", "xsd:".$t);
+		else{//no XML Schema datatype
+			//if valueType==Array, then create anonymouse inline complexType (within element tag without type attribute)
+			if(substr($type,-2) == '[]'){
+				if($this->array_inline){
+					$this->addComplexType($type, false, $el);
+				}else{
+					$name = substr($type, 0, -2)."Array";
+					$el->setAttribute("type", "tns:".$name);
+					$this->addComplexType($type, $name, false);
+				}
+			}else{//else, new complextype, outline (element with 'ref' attrib)
+				$el->setAttribute("type", "tns:".$type);
+				$this->addComplexType($type, $type);
+			}
+		}
+		return $el;
+	}
+
+	/**
+	 * Creates an xmlSchema element for the given array
+	 */
+	public function addArray($type, $parent) {
+		$cc = $this->addElement("xsd:complexContent", $parent);
+		$rs = $this->addElement("xsd:restriction", $cc);
+		$rs->setAttribute("base", "SOAP-ENC:Array");
+
+		$type = (substr($type,-2) == '[]') ? substr($type, 0, (strlen($type)-2)) : substr($type, 6, (strlen($type)-7));
+		$el = $this->addElement("xsd:attribute", $rs);
+		$el->setAttribute("ref", "SOAP-ENC:arrayType");
+
+		//check if XML Schema datatype
+		if($t = $this->checkSchemaType(strtolower($type)))
+				$el->setAttribute("wsdl:arrayType", "xsd:".$t."[]");
+		else{//no XML Schema datatype
+			//if valueType==Array, then create anonymouse inline complexType (within element tag without type attribute)
+			if(substr($type,-2) == '[]'){
+				$this->addComplexType($type, false, $el);
+			}else{//else, new complextype, outline (element with 'ref' attrib)
+				$el->setAttribute("wsdl:arrayType", "tns:".$type."[]");
+				$this->addComplexType($type, $type);
+			}
+		}
+		return $el;
+	}
+
+	/**
+	 * Checks if the given type is a valid XML Schema type or can be casted to a schema type
+	 * @param string The datatype
+	 * @return string
+	 */
+	public static function checkSchemaType($type) {
+		//XML Schema types
+		$types = Array("string" => "string",
+			  "int" => "int",
+			  "integer" => "int",
+			  "boolean" => "boolean",
+			  "float" => "float");
+		if(isset($types[$type])) return $types[$type];
+		else return false;
+	}
+
+	/**
+	 * Adds an child element to the parent
+	 * @param string
+	 * @param domNode
+	 * @return domNode
+	 */
+	private function addElement($name, $parent = false, $ns = false) {
+		if($ns)
+			$el = $parent->ownerDocument->createElementNS($ns, $name);
+		else
+			$el = $parent->ownerDocument->createElement($name);
+		if($parent)
+			$parent->appendChild($el);
+		return $el;
+	}
+}
+?>
\ No newline at end of file
diff --git a/webservice/classes/soap/IPXSLTemplate.class.php b/webservice/classes/soap/IPXSLTemplate.class.php
new file mode 100755
index 0000000..9f21055
--- /dev/null
+++ b/webservice/classes/soap/IPXSLTemplate.class.php
@@ -0,0 +1,85 @@
+<?php
+class tagRegistration {
+	public $namespace;
+	public $tagName;
+	public $function;
+	public function __construct($namespace, $tagName, $function) {
+		$this->namespace 	= $namespace;
+		$this->tagName 		= $tagName;
+		$this->function 	= $function;
+	}
+
+	public function process($node) {
+		$x = $node;
+		eval($this->function);
+	}
+}
+
+
+class IPXSLTemplate {
+	const NAMESPACE 	= "http://schema.knowledgetree.com/xmltemplate/";
+	public $dom 		= null;
+	public $xsltproc 	= null;
+	public $customTags 	= Array();
+
+    public function __construct($file) {
+    	$this->dom = new DOMDocument();
+    	$this->dom->load($file);
+   		$this->xsltproc = new XSLTProcessor();
+   		$this->xsltproc->registerPHPFunctions();
+    }
+
+    public function execute($model) {
+		//process custom tags
+		foreach($this->customTags as $reg) {
+			$nodelist = $this->dom->getElementsByTagNameNS($reg->namespace, $reg->tagName);
+			for($i = $nodelist->length; $i > 0; $i--){
+				$reg->process($nodelist->item($i-1));
+			}
+		}
+
+   		$this->xsltproc->importStyleSheet($this->dom);
+
+		$modelDom = new DomDocument();
+		$modelDom->appendChild($modelDom->createElement("model")); 	//root node
+		IPXSLTemplate::makeXML($model, $modelDom->documentElement);
+		//echo $modelDom->saveXML();
+ 		return $this->xsltproc->transformToXml($modelDom);
+    }
+
+    /** Add a new custom tag registration */
+    public function registerTag($namespace, $tagName, $function) {
+    	$this->customTags[] = new tagRegistration($namespace, $tagName, $function);
+    }
+
+    /** Makes a XML node from an object/ array / text */
+    static function makeXML($model, $parent, $addToParent = false) {
+		if(is_array($model)){
+			foreach($model as $name => $value){
+				if(!is_numeric($name)) {
+					$node = $parent->ownerDocument->createElement($name);
+	    			$parent->appendChild($node);
+					IPXSLTemplate::makeXml($value, $node, true);
+				} else {
+					$node = $parent;
+					IPXSLTemplate::makeXml($value, $node);
+				}
+			}
+		} elseif (is_object($model)) {
+			if($addToParent)
+				$node = $parent;
+			else{
+				$node = $parent->ownerDocument->createElement(get_class($model));
+				$parent->appendChild($node);
+			}
+			foreach($model as $propertyName => $propertyValue){
+				$property = $parent->ownerDocument->createElement($propertyName);
+	    		$node->appendChild($property);
+   				IPXSLTemplate::makeXml($propertyValue, $property);
+			}
+		} else {
+			$parent->appendChild($parent->ownerDocument->createTextNode($model));
+		}
+    }
+}
+?>
\ No newline at end of file
diff --git a/webservice/classes/soap/WSDLException.class.php b/webservice/classes/soap/WSDLException.class.php
new file mode 100755
index 0000000..df20680
--- /dev/null
+++ b/webservice/classes/soap/WSDLException.class.php
@@ -0,0 +1,26 @@
+<?php
+/**
+ * Exception class which can be thrown by
+ * the WSDLStruct class.
+ *
+ *@author KnowledgeTree Team
+ *@package Webservice
+ *@version Version 0.9
+ */
+class WSDLException extends Exception {
+ 	/**
+ 	 * @param string The error message
+ 	 * @return void
+ 	 */
+	function __construct($msg) {
+		$this->msg = $msg;
+	}
+ 	/**
+ 	 * @return void
+ 	 */
+ 	function Display() {
+		print "Error creating WSDL document:".$this->msg;
+		//var_dump(debug_backtrace());
+	}
+}
+?>
\ No newline at end of file
diff --git a/webservice/classes/soap/WSDLStruct.class.php b/webservice/classes/soap/WSDLStruct.class.php
new file mode 100755
index 0000000..4b2c2b4
--- /dev/null
+++ b/webservice/classes/soap/WSDLStruct.class.php
@@ -0,0 +1,338 @@
+<?php
+/**
+ * Class that can generate a WSDL document from PHP code
+ *
+ * This class generates a WSDL document for the given
+ * methods when the the methods and parameters are documented
+ * enough. When there is not enough documentation available (ie
+ * unclear what the type of a variable or return type is) a
+ * WSDLException is thrown.
+ *
+ *
+ *@author KnowledgeTree Team
+ *@package Webservice
+ *@version Version 0.9
+ */
+class WSDLStruct {
+	/** @var boolean  */
+	public $_debug = false;
+
+	/** @var int binding type: SOAP_RPC | SOAP_DOCUMENT */
+	public $binding_style;
+
+	/** @var int use: SOAP_LITERAL | SOAP_ENCODED */
+	public $use;
+	/************************** Private properties ***************************/
+
+	/** @var SOAPService[] */
+	private $services = Array();
+
+	/** @var domElement[] */
+	private $serviceTags = Array();
+
+	/** @var domElement[] */
+	private $operationTags = Array();
+
+		/** @var domElement[] references to the portType tags. servicename as key */
+	private $portTypeTags = Array();
+
+	/** @var domElement[] references to the binding tags. servicename as key */
+	private $bindingTags = Array();
+
+	/** @var domElement[] references to the binding operation tags. servicename as first key, operationname as second */
+	private $bindingOperationTags = Array();
+
+	/** @var domDocument */
+	private $doc;
+
+	/** @var domelement */
+	private $definitions;
+
+	/** @var domelement Refference tot the types tag*/
+	private $typesTag;
+
+	/** @var domelement Refference to the xsd:schema tag*/
+	private $xsdSchema;
+
+	/** @var IPXMLSchema */
+	private $xmlSchema;
+
+	//namespaces used
+	const NS_WSDL = "http://schemas.xmlsoap.org/wsdl/";
+	const NS_SOAP = "http://schemas.xmlsoap.org/wsdl/soap/";
+	const NS_ENC  = "http://schemas.xmlsoap.org/soap/encoding/";
+	const NS_XSD  = "http://www.w3.org/2001/XMLSchema";
+
+	const CREATE_EMPTY_INPUTS = true;
+
+	/*
+	 * @param string Target namespace
+	 * @param string URL for the webservice
+	 * @return void
+	 */
+	public function __construct($tns, $url, $type = SOAP_RPC, $use = SOAP_ENCODED){
+		if($type != SOAP_RPC 	 && $type != SOAP_DOCUMENT) throw new Exception("Webservice type parameter should be either SOAP_RPC or SOAP_DOCUMENT");
+		if($use  != SOAP_ENCODED && $use  != SOAP_LITERAL) throw new Exception("Webservice use parameter should be either SOAP_ENCODED or SOAP_LITERAL");
+
+		$this->use = $use;
+		$this->binding_style=$type;
+		$this->tns = $tns;
+		$this->url = $url;
+		$this->doc = new domDocument();
+		$this->definitions = $this->addElement("wsdl:definitions",$this->doc);
+
+		$this->typesTag = $this->addElement("wsdl:types", $this->definitions);
+		$this->xsdSchema = $this->addElement("xsd:schema", $this->typesTag);
+		$this->xsdSchema->setAttribute("targetNamespace", $this->tns);
+		$this->xmlSchema = new IPXMLSchema($this->xsdSchema);
+
+	}
+
+	/**
+	 * Adds the class to the services for this WSDL
+	 *
+	 * @param IPReflectionClass The service
+	 * @return void
+	 */
+	public function setService(IPReflectionClass $class){
+		$this->services[$class->classname] = $class;
+		$this->services[$class->classname]->getMethods(false, false);
+	}
+	/**
+	 * @return string The WSDL document for this structure
+	 */
+	public function generateDocument(){
+		$this->addToDebug("Generating document");
+
+		//add all definitions
+		$definitions=$this->definitions;
+		$definitions->setAttribute("xmlns", 			self::NS_WSDL);
+		$definitions->setAttribute("xmlns:soap", 		self::NS_SOAP);
+		$definitions->setAttribute("xmlns:SOAP-ENC", 	self::NS_ENC);
+		$definitions->setAttribute("xmlns:wsdl", 		self::NS_WSDL);
+		$definitions->setAttribute("xmlns:xsd", 		self::NS_XSD);
+		$definitions->setAttribute("xmlns:tns", 		$this->tns);
+		$definitions->setAttribute("targetNamespace", 	$this->tns);
+
+		//add all the services
+		foreach((array)$this->services as $serviceName => $service){
+			//add the portType
+			$portType = $this->addPortType($serviceName);
+
+			//add binding
+			$binding = $this->addBinding($serviceName);
+
+			//loop the operations
+			foreach((array)$service->methods as $operation){
+				$operationName = $operation->name;
+				$operationTag = $this->addOperation($operationName, $serviceName);
+
+				//input
+				//only when to operation needs arguments
+				$parameters = $operation->getParameters();
+				if(count($parameters)>0 || self::CREATE_EMPTY_INPUTS){
+					$messageName = $operationName."Request";
+					$input=$this->addElement("wsdl:input", $operationTag);
+					$input->setAttribute("message", "tns:".$messageName);
+					$para=Array();
+					foreach((array)$parameters as $parameterName => $parameter){
+						$para[$parameterName] = $parameter->type;
+					}
+					$this->addMessage($messageName, $para);
+					$this->addInput($this->bindingOperationTags[$serviceName][$operationName]);
+				}
+
+
+				//output
+				//only when the operation returns something
+				if(!$operation->return || trim($operation->return) == "") throw new WSDLException('No return type for '.$operationName);
+				if(strtolower(trim($operation->return))!='void'){
+					$messageName = $operationName."Response";
+					$output = $this->addElement("wsdl:output", $operationTag);
+					$output->setAttribute("message", "tns:".$messageName);
+					$this->addOutput($this->bindingOperationTags[$serviceName][$operationName]);
+					$this->addMessage($messageName,Array($operation->name."Return" => $operation->return));
+				}
+			}
+			// SH. now add the portType and binding
+			$this->definitions->AppendChild($portType);
+			$this->definitions->AppendChild($binding);
+
+			//add the service
+			$this->addService($serviceName);
+
+		}
+		return $this->doc->saveXML();
+	}
+
+	/**
+	 * Adds a new operation to the given service
+	 * @param string operation name
+	 * @param string service name
+	 * @return domElement
+	 */
+	private function addOperation($operationName, $serviceName){
+		$this->addToDebug("Adding Operation: '$operationName : $serviceName'");
+		$operationTag = $this->addElement("wsdl:operation",$this->portTypeTags[$serviceName]);
+		$operationTag->setAttribute("name",$operationName);
+
+		//create operation tag for binding
+		$bindingOperationTag = $this->addElement("wsdl:operation",$this->bindingTags[$serviceName]);
+		$bindingOperationTag->setAttribute("name",$operationName);
+
+		//soap operation tag
+		$soapOperationTag = $this->addElement("soap:operation",$bindingOperationTag);
+		$soapOperationTag->setAttribute("soapAction",$this->url."&method=".$operationName);
+		$soapOperationTag->setAttribute("style",($this->binding_style == SOAP_RPC)? "rpc" : "document");
+
+		//save references
+		$this->operationTags[$serviceName][$operationName] = $operationTag;
+		$this->bindingOperationTags[$serviceName][$operationName] = $bindingOperationTag;
+
+		//and return
+		return $operationTag;
+	}
+
+	/**
+	 * adds a new service tag to the WSDL file
+	 * @param string the service name
+	 * @return domElement
+	 */
+	private function addService($serviceName){
+		$this->addToDebug("Adding service: '$serviceName'");
+		//create service
+		$serviceTag=$this->addElement("wsdl:service",$this->definitions);
+		$serviceTag->setAttribute("name",$serviceName);
+
+			//port tag
+			$portTag=$this->addElement("wsdl:port", $serviceTag);
+			$portTag->setAttribute("name", $serviceName."Port");
+			$portTag->setAttribute("binding", "tns:".$serviceName."Binding");
+
+				//address tag
+				$addressTag = $this->addElement("soap:address", $portTag);
+				$addressTag->setAttribute("location", $this->url);
+
+		//keep a reference
+		$this->serviceTags[$serviceName] = $serviceTag;
+		//and return
+		return $serviceTag;
+	}
+
+	/**
+	 * Adds a new portType to the WSDL structure
+	 * @param string the service name for which we create a portType
+	 * @return domElement
+	 */
+	private function addPortType($serviceName){
+		$this->addToDebug("Adding portType: '$serviceName'");
+		// SH don't add to main doc just yet
+		// $portTypeTag=$this->addElement("wsdl:portType", $this->definitions);
+		$portTypeTag = $this->addElement("wsdl:portType");
+		$portTypeTag->setAttribute("name", $serviceName."PortType");
+
+		//keep a reference
+		$this->portTypeTags[$serviceName]=$portTypeTag;
+		//and return
+		return $portTypeTag;
+	}
+
+	/**
+	 * Adds a new binding to the WSDL structure
+	 * @param string serviceName to bind
+	 * @return domElement
+	 */
+	private function addBinding($serviceName){
+		$this->addToDebug("Adding binding: '$serviceName'");
+		// SH. don't add to main doc just yet
+		// $bindingTag=$this->addElement("binding");
+		$bindingTag=$this->addElement("binding",$this->definitions);
+		$bindingTag->setAttribute("name", $serviceName."Binding");
+		$bindingTag->setAttribute("type", "tns:".$serviceName."PortType");
+
+			//soap binding tag
+			$soapBindingTag = $this->addElement("soap:binding", $bindingTag);
+			$soapBindingTag->setAttribute("style", ($this->binding_style == SOAP_RPC)? "rpc" : "document");
+			$soapBindingTag->setAttribute("transport", "http://schemas.xmlsoap.org/soap/http");
+
+		//keep a reference
+		$this->bindingTags[$serviceName] = $bindingTag;
+		//and return
+		return $bindingTag;
+	}
+
+	/**
+	 * Adds a message tag to the WSDL document
+	 * @param string Message name
+	 * @param Array[string=>string] Array with variables & types
+	 */
+	private function addMessage($name, $parts){
+		$this->addToDebug("Adding message: '$name'");
+		$msg = $this->addElement("message", $this->definitions);
+		$msg->setAttribute("name", $name);
+		foreach((array)$parts as $partName => $partType){
+			$this->addToDebug("Adding Message part: '$partName => $partType'");
+			$part=$this->addElement("part", $msg);
+			$part->setAttribute("name", $partName);
+
+			//check if it is a valid XML Schema datatype
+			if($t = IPXMLSchema::checkSchemaType(strtolower($partType)))
+				$part->setAttribute("type", "xsd:".$t);
+			else{
+				//If it is an array, change the type name
+				$partName = (substr($partType,-2) == "[]")?substr($partType,0,strpos($partType,"["))."Array":$partType;
+
+				$part->setAttribute("type", "tns:".$partName);
+				$this->xmlSchema->addComplexType($partType, $partName);
+			}
+		}
+	}
+
+	/**
+	 * Adds an input element to the given parent (an operation tag)
+	 * @param domNode The Parent domNode
+	 * @param boolean Kind of tag. true=input tag, false=output tag
+	 * @return domNode The input/output node
+	 */
+	private function addInput($parent, $input=true){
+		$name = $input ? "wsdl:input" : "wsdl:output";
+		$tag=$this->addElement($name, $parent);
+		$soapOperation=$this->addElement("soap:body", $tag);
+		$soapOperation->setAttribute("use", ($this->use == SOAP_ENCODED)? "encoded" : "literal");
+		$soapOperation->setAttribute("namespace", $this->tns);
+		if($this->use == SOAP_ENCODED)
+			$soapOperation->setAttribute("encodingStyle", self::NS_ENC);
+	}
+
+	/**
+	 * Adds an output element to the given parent (an operation tag)
+	 * @param domNode The Parent domNode
+	 * @return domNode The output node
+	 */
+	private function addOutput($parent){
+		return $this->addInput($parent,false);
+	}
+
+	/*************************  Supporting functions ****************************/
+
+	private function addToDebug($msg){
+		if($this->_debug) echo '-'.$msg." <br>\n";
+	}
+
+	/**
+	 * Adds an child element to the parent
+	 * @param string The name element
+	 * @param domNode
+	 * @return domNode
+	 */
+	private function addElement($name, $parent=false, $ns=false){
+		if($ns)
+			$el=$this->doc->createElementNS($ns,$name);
+		else
+			$el=$this->doc->createElement($name);
+		if($parent)
+			$parent->appendChild($el);
+		return $el;
+	}
+}
+?>
\ No newline at end of file
diff --git a/webservice/classes/soap/WSException.class.php b/webservice/classes/soap/WSException.class.php
new file mode 100755
index 0000000..93c4de4
--- /dev/null
+++ b/webservice/classes/soap/WSException.class.php
@@ -0,0 +1,24 @@
+<?php
+/**
+ * Exception class which can be thrown by
+ * the WSHelper class.
+ *@author KnowledgeTree Team
+ *@package Webservice
+ *@version Version 0.9
+ */
+class WSException extends Exception {
+ 	/**
+ 	 * @param string The error message
+ 	 * @return void
+ 	 */
+	public function __construct($msg) {
+		$this->msg = $msg;
+	}
+ 	/**
+ 	 * @return void
+ 	 */
+ 	public function Display() {
+		echo $this->msg;
+	}
+}
+?>
\ No newline at end of file
diff --git a/webservice/classes/soap/WSHelper.class.php b/webservice/classes/soap/WSHelper.class.php
new file mode 100755
index 0000000..a7e82cb
--- /dev/null
+++ b/webservice/classes/soap/WSHelper.class.php
@@ -0,0 +1,183 @@
+<?php
+/**
+ * Class that generates a WSDL file and creates documentation
+ * for the webservices.
+ *
+ *@author KnowledgeTree Team
+ *@package Webservice
+ *@version Version 0.9
+ */
+class WSHelper {
+	private $uri;
+	private $class = null; //IPReflectionClass object
+	private $name; //class name
+	private $persistence = SOAP_PERSISTENCE_SESSION;
+	private $wsdlfile; //wsdl file name
+	private $server; //soap server object
+
+	public $actor;
+	public $structureMap = array();
+	public $classNameArr = array();
+	public $wsdlFolder; //WSDL cache folder
+	public $useWSDLCache = true;
+
+	public $type = SOAP_RPC;
+	public $use = SOAP_LITERAL;
+
+	/**
+	 * Constructor
+	 * @param string The Uri name
+	 * @return void
+	 */
+	public function __construct($uri, $class=null){
+		$this->uri = $uri;
+		$this->setWSDLCacheFolder($_SERVER['DOCUMENT_ROOT'].dirname($_SERVER['PHP_SELF'])."/wsdl/");
+		if($class) $this->setClass($class);
+	}
+
+	/**
+	 * Adds the given class name to the list of classes
+	 * to be included in the documentation/WSDL/Request handlers
+	 * @param string
+	 * @return void
+	 */
+	public function setClass($name){
+		$this->name = $name;
+		$this->wsdlfile = $this->wsdlFolder.$this->name.".wsdl";
+	}
+
+	public function setWSDLCacheFolder($folder) {
+		$this->wsdlFolder = $folder;
+		//reset wsdlfile
+		$this->wsdlfile = $this->wsdlFolder.$this->name.".wsdl";
+	}
+	/**
+	 * Sets the persistence level for the soap class
+	 */
+	public function setPersistence($persistence) {
+		$this->persistence = $persistence;
+	}
+
+	/**
+	 * Handles everything. Makes sure the webservice is handled,
+	 * documentations is generated, or the wsdl is generated,
+	 * according to the page request
+	 * @return void
+	 */
+	public function handle(){
+		if(substr($_SERVER['QUERY_STRING'], -4) == 'wsdl'){
+		   	$this->showWSDL();
+		}elseif(isset($GLOBALS['HTTP_RAW_POST_DATA']) && strlen($GLOBALS['HTTP_RAW_POST_DATA'])>0){
+			$this->handleRequest();
+		}else{
+			$this->createDocumentation();
+		}
+	}
+	/**
+	 * Checks if the current WSDL is up-to-date, regenerates if necessary and outputs the WSDL
+	 * @return void
+	 */
+	public function showWSDL(){
+		//check if it's a legal webservice class
+		if(!in_array($this->name, $this->classNameArr))
+			throw new Exception("No valid webservice class.");
+
+		//@TODO: nog een mooie oplossing voor het cachen zoeken
+		header("Content-type: text/xml");
+		if($this->useWSDLCache && file_exists($this->wsdlfile)){
+			readfile($this->wsdlfile);
+		}else{
+			//make sure to refresh PHP WSDL cache system
+			ini_set("soap.wsdl_cache_enabled",0);
+			echo $this->createWSDL();
+		}
+	}
+
+	private function createWSDL(){
+		$this->class = new IPReflectionClass($this->name);
+		$wsdl = new WSDLStruct($this->uri, "http://".$_SERVER['HTTP_HOST'].$_SERVER['SCRIPT_NAME']."?class=".$this->name, $this->type, $this->use);
+		$wsdl->setService($this->class);
+
+		try {
+			$gendoc = $wsdl->generateDocument();
+		} catch (WSDLException $exception) {
+   			$exception->Display();
+   			exit();
+		}
+
+		$fh = fopen($this->wsdlfile, "w+");
+		fwrite($fh, $gendoc);
+		fclose($fh);
+
+		return $gendoc;
+	}
+
+	/**
+	 * Lets the native PHP5 soap implementation handle the request
+	 * after registrating the class
+	 * @return void
+	 */
+	private function handleRequest(){
+		//check if it's a legal webservice class
+		if(!in_array($this->name, $this->classNameArr))
+			throw new Exception("No valid webservice class.");
+
+		//check cache
+		//if(!file_exists($this->wsdlfile))
+			$this->createWSDL();
+
+		$options = Array('actor' => $this->actor, 'classmap' => $this->structureMap);
+
+		header("Content-type: text/xml");
+		$this->server = new SoapServer($this->wsdlfile, $options);
+		$this->server->setClass($this->name);
+		$this->server->setPersistence($this->persistence);
+
+		use_soap_error_handler(true);
+		$this->server->handle();
+	}
+
+	/**
+	 * @param string code
+	 * @param string string
+	 * @param string actor
+	 * @param mixed details
+	 * @param string name
+	 * @return void
+	 */
+	public function fault($code, $string, $actor, $details, $name='') {
+		return $this->server->fault($code, $string, $actor, $details, $name);
+	}
+
+	/**
+	 * Generates the documentations for the webservice usage.
+	 * @TODO: "int", "boolean", "double", "float", "string", "void"
+	 * @param string Template filename
+	 * @return void
+	 */
+	public function createDocumentation($template="classes/soap/templates/docclass.xsl")	{
+		if(!is_file($template))
+			throw new WSException("Could not find the template file: '$template'");
+		$this->class = new IPReflectionClass($this->name);
+		$xtpl = new IPXSLTemplate($template);
+		$documentation = Array();
+		$documentation['menu'] = Array();
+		//loop menu items
+		sort($this->classNameArr);
+		foreach($this->classNameArr as $className) {
+			$documentation['menu'][] = new IPReflectionClass($className);
+		}
+
+		if($this->class){
+			$this->class->properties = $this->class->getProperties(false, false);
+			$this->class->methods = $this->class->getMethods(false, false);
+			foreach((array)$this->class->methods as $method) {
+				$method->params = $method->getParameters();
+			}
+
+			$documentation['class'] = $this->class;
+		}
+		echo $xtpl->execute($documentation);
+	}
+}
+?>
\ No newline at end of file
diff --git a/webservice/classes/soap/common.php b/webservice/classes/soap/common.php
new file mode 100755
index 0000000..84324cc
--- /dev/null
+++ b/webservice/classes/soap/common.php
@@ -0,0 +1,87 @@
+<?php
+/**
+* Implements a cleaner wrapper for webservices  API for KnowledgeTree.
+*
+* KnowledgeTree Community Edition
+* Document Management Made Simple
+* Copyright (C) 2008,2009 KnowledgeTree Inc.
+* Portions copyright The Jam Warehouse Software (Pty) Limited
+*
+* This program is free software; you can redistribute it and/or modify it under
+* the terms of the GNU General Public License version 3 as published by the
+* Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+* FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+* details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+* You can contact KnowledgeTree Inc., PO Box 7775 #87847, San Francisco,
+* California 94120-7775, or email info@knowledgetree.com.
+*
+* The interactive user interfaces in modified source and object code versions
+* of this program must display Appropriate Legal Notices, as required under
+* Section 5 of the GNU General Public License version 3.
+*
+* In accordance with Section 7(b) of the GNU General Public License version 3,
+* these Appropriate Legal Notices must retain the display of the "Powered by
+* KnowledgeTree" logo and retain the original copyright notice. If the display of the
+* logo is not reasonably feasible for technical reasons, the Appropriate Legal Notices
+* must display the words "Powered by KnowledgeTree" and retain the original
+* copyright notice.
+*
+* @copyright 2008-2009, KnowledgeTree Inc.
+* @license GNU General Public License version 3
+* @author KnowledgeTree Team
+* @package Webservice
+* @version Version 0.1
+*/
+
+
+error_reporting(E_ALL);
+ob_start("ob_gzhandler");
+
+require_once ("config.php");
+
+if(!extension_loaded("soap"))
+	die("Soap extension not loaded!");
+
+session_start();
+
+/** autoload function for PHP5 
+* Loads all the classes in the model
+*
+*/
+function __autoload($classname) {
+    try{
+        if(file_exists("classes/soap/model/$classname.class.php"))
+		include("classes/soap/model/$classname.class.php");
+	elseif(file_exists("classes/soap/$classname.class.php"))
+		include("classes/soap/$classname.class.php");
+	elseif(file_exists("classes/soap/$classname.class.php"))
+		include("classes/soap/$classname.class.php");
+    } catch (Exception $e) {
+        echo $e->getMessage();
+    }
+
+}
+
+/** Write out  debug file */
+function debug($txt,$file="debug.txt"){
+	$fp = fopen($file, "a");
+	fwrite($fp, str_replace("\n","\r\n","\r\n".$txt));
+	fclose($fp);
+}
+
+/** Write out object in the debug log */
+function debugObject($txt,$obj){
+	ob_start();
+	print_r($obj);
+	$data = ob_get_contents();
+	ob_end_clean();
+	debug($txt."\n".$data);
+}
+?>
diff --git a/webservice/classes/soap/config.php b/webservice/classes/soap/config.php
new file mode 100755
index 0000000..6344a5a
--- /dev/null
+++ b/webservice/classes/soap/config.php
@@ -0,0 +1,23 @@
+<?php
+
+/* All the allowed webservice classes */
+$WSClasses = array(
+	"contactManager",
+	"RestService"
+
+
+);
+
+/* The classmap associative array. When you want to allow objects as a parameter for
+ * your webservice method. ie. saveObject($object). By default $object will now be
+ * a stdClass, but when you add a classname defined in the type description in the @param
+ * documentation tag and add your class to the classmap below, the object will be of the
+ * given type. Requires PHP 5.0.3+
+ */
+$WSStructures = array(
+	"contact" => "contact",
+	"address" => "address",
+
+);
+
+?>
\ No newline at end of file
diff --git a/webservice/classes/soap/model/RestService.class.php b/webservice/classes/soap/model/RestService.class.php
new file mode 100755
index 0000000..2f507bf
--- /dev/null
+++ b/webservice/classes/soap/model/RestService.class.php
@@ -0,0 +1,155 @@
+<?php
+/**
+* Implements a cleaner wrapper restservice and webservice API for KnowledgeTree.
+*
+* KnowledgeTree Community Edition
+* Document Management Made Simple
+* Copyright (C) 2008,2009 KnowledgeTree Inc.
+* Portions copyright The Jam Warehouse Software (Pty) Limited
+*
+* This program is free software; you can redistribute it and/or modify it under
+* the terms of the GNU General Public License version 3 as published by the
+* Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+* FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+* details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+* You can contact KnowledgeTree Inc., PO Box 7775 #87847, San Francisco,
+* California 94120-7775, or email info@knowledgetree.com.
+*
+* The interactive user interfaces in modified source and object code versions
+* of this program must display Appropriate Legal Notices, as required under
+* Section 5 of the GNU General Public License version 3.
+*
+* In accordance with Section 7(b) of the GNU General Public License version 3,
+* these Appropriate Legal Notices must retain the display of the "Powered by
+* KnowledgeTree" logo and retain the original copyright notice. If the display of the
+* logo is not reasonably feasible for technical reasons, the Appropriate Legal Notices
+* must display the words "Powered by KnowledgeTree" and retain the original
+* copyright notice.
+*
+* @copyright 2008-2009, KnowledgeTree Inc.
+* @license GNU General Public License version 3
+* @author KnowledgeTree Team
+* @package Webservice
+* @version Version 0.1
+*/
+
+
+/**
+ * Class Service - will act as a switch between
+ * SOAP requests and REST requests
+ *@author KnowledgeTree Team
+ *@package Webservice
+ *@version Version 0.9
+ */
+class RestService
+{
+    /**
+     * Class construct
+     *
+     * @param object_type $object
+     * @return jason encoded string
+     */
+    public function __construct($object)
+    {
+        try {
+
+            $result = $this->runAsService($object);
+            echo jason_encode(array('status_code' => 0,'result' => $result));
+
+        } catch (Exception $e) {
+            echo json_encode(array('status_code' => 1,'result' => $e->getMessage()));
+        }
+    }
+
+    /**
+     * Constructor for invoking a reflection object
+     * Initiates the object as a service
+     * @param class $object
+     * @access private
+     * @return class instance
+     */
+
+    private function runAsService($object)
+    {
+
+        if (!isset($_GET['class'])) {
+
+          throw new Exception('Method name not specified.');
+        }
+
+        $reflObject = new ReflectionObject($object);
+
+        if (!$reflObject->hasMethod($_GET['class'])) {
+
+          throw new Exception('There is no method with this name.');
+
+        }
+
+        $reflMethod = $reflObject->getMethod($_GET['class']);
+
+        if ( !$reflMethod->isPublic() || $reflMethod->isStatic() || $reflMethod->isInternal() ) {
+
+            throw new Exception('Invalid method name specified.');
+
+        }
+
+        $reflParameters = $reflMethod->getParameters();
+
+        $args = array();
+
+
+        foreach ($reflParameters as $param) {
+
+         $paramName = $param->getName();
+
+          if (!isset($_GET[$paramName])) {
+
+            if ($param->isDefaultValueAvailable()) {
+
+              $paramValue = $param->getDefaultValue();
+
+            } else {
+
+              throw new Exception('Required parameter "'.$paramName.'" is not specified.');
+
+            }
+
+          } else {
+
+            $paramValue = $_GET[$paramName];
+
+          }
+
+
+          if ($param->getClass()) {
+
+            throw new Exception('The method contains unsupported parameter type: class object.');
+
+          }
+
+
+          if ($param->isArray() && !is_array($paramValue)) {
+
+            throw new Exception('Array expected for parameter "'.$paramName.'", but scalar found.');
+
+          }
+
+
+          $args[$param->getPosition()] = $paramValue;
+
+        }
+
+        return $reflMethod->invokeArgs($object, $args);
+
+      }
+
+}
+
+?>
\ No newline at end of file
diff --git a/webservice/classes/soap/model/address.class.php b/webservice/classes/soap/model/address.class.php
new file mode 100755
index 0000000..116069d
--- /dev/null
+++ b/webservice/classes/soap/model/address.class.php
@@ -0,0 +1,24 @@
+<?php
+
+/**
+  * Stores an address
+  *
+  * An address consists of a street, number, zipcode and city.
+  * This class is for example purposes only, just to
+  * show how to create a webservice
+  *
+  */
+class address{
+	/** @var string */
+	public $street;
+	
+	/** @var string */
+	public $nr;
+	
+	/** @var string */
+	public $zipcode;	
+	
+	/** @var string */
+	public $city;	
+}
+?>
\ No newline at end of file
diff --git a/webservice/classes/soap/model/contact.class.php b/webservice/classes/soap/model/contact.class.php
new file mode 100755
index 0000000..74e0ae8
--- /dev/null
+++ b/webservice/classes/soap/model/contact.class.php
@@ -0,0 +1,34 @@
+<?php
+
+
+/**
+  * The contact details for a person
+  *
+  * Stores the person's name, address and e-mail
+  * This class is for example purposes only, just to
+  * show how to create a webservice
+  *
+  */
+class contact{
+	/** @var int */
+	public $id;
+	
+	/** @var string */
+	public $name;
+
+	/** @var address */
+	public $address;
+
+	/** @var string */
+	public $email;
+	
+	/**
+	  * saves a contact
+	  *
+	  * @return void
+	  */
+	public function save() {
+		//save contact 2 db
+	}
+}
+?>
\ No newline at end of file
diff --git a/webservice/classes/soap/model/contactManager.class.php b/webservice/classes/soap/model/contactManager.class.php
new file mode 100755
index 0000000..a192add
--- /dev/null
+++ b/webservice/classes/soap/model/contactManager.class.php
@@ -0,0 +1,58 @@
+<?php
+
+/**
+  * Keeps track of the people in our contact list.
+  *
+  * Starts with a standard contact list and can add
+  * new people to our list or change existing contacts.
+  * This class is for example purposes only, just to
+  * show how to create a webservice
+  */
+class contactManager{
+
+	/**
+	 * Gets the current contact list.
+	 * @return contact[]
+	 */
+	public function	getContacts() {
+		$contact = new contact();
+		$contact->address = new Address();
+		$contact->address->city ="sesamcity";
+		$contact->address->street ="sesamstreet";
+		$contact->email = "me@you.com";
+		$contact->id = 1;
+		$contact->name ="me";
+
+		$ret[] = $contact;
+		return $ret;
+	}
+
+	/**
+	  * Gets the contact with the given id.
+	  * @param int The id
+	  * @return contact
+	  */
+	public function	getContact($id) {
+		//get contact from db
+		//might wanna throw an exception when it does not exists
+		throw new Exception("Contact '$id' not found");
+	}
+	/**
+	  * Generates an new, empty contact template
+	  * @return contact
+	  */
+	public function newContact() {
+		return new contact();
+	}
+
+	/**
+	  * Saves a given contact
+	  * @param contact
+	  * @return void
+	  */
+	public function saveContact(contact $contact) {
+		$contact->save();
+	}
+
+}
+?>
\ No newline at end of file
diff --git a/webservice/classes/soap/templates/css/doc.css b/webservice/classes/soap/templates/css/doc.css
new file mode 100755
index 0000000..1c92f1f
--- /dev/null
+++ b/webservice/classes/soap/templates/css/doc.css
@@ -0,0 +1,88 @@
+body {
+	margin:0;
+	padding:0;
+	text-align: center;
+	background: #ffffff url("../images/doc/back.gif") repeat-y center;
+}
+body, table, th, td, p, div {
+	font-family: Arial, Helvetica;
+	font-size: 12pt;
+	line-height:1.4;
+}
+#main {
+	margin-right: auto;
+	margin-left: auto;
+	text-align: left;
+	width: 980px;
+}
+#mainpadded {
+	padding: 0px 40px 80px 40px;
+}
+#mainheader {
+	background: #ffffff url("../images/doc/backtop.jpg") no-repeat;
+	height: 180px;
+}
+#mainheaderpadded {
+	padding: 130px 40px 0px 40px;
+	text-align: right;
+}
+td {
+	vertical-align: top;
+}
+td#menu {
+	width: 300px;
+}
+td#content {
+}
+div.method {
+	padding-left: 10px;
+	margin-bottom: 20px;
+	border-left: 2px solid #C0C0C0;
+}
+div.methodwarning {
+	padding-left: 10px;
+	margin-bottom: 20px;
+	border-left: 4px solid #FF0000;
+}
+div.property {
+	padding-left: 10px;
+	margin-bottom: 20px;
+	border-left: 2px solid #C0C0C0;
+}
+div.propertywarning {
+	padding-left: 10px;
+	margin-bottom: 20px;
+	border-left: 4px solid #FF0000;
+}
+div.warning {
+	font-weight: bold;
+	color: #FF0000;
+	float: left;
+}
+a {
+	color: #FFA619;
+	text-decoration: none;
+	font-weight: bold;
+}
+a:hover {
+	text-decoration: underline;
+}
+p {
+	margin-top: 5px;
+	margin-bottom: 10px;
+}
+h1 {
+	margin-top: 0px;
+	margin-bottom: 10px;
+	padding: 0px;
+	font-family: Verdana, Helvetica;
+	font-size: 20pt;
+	color: #000000;
+}
+h2 {
+	margin-top: 0px;
+	margin-bottom: 10px;
+	font-family: Verdana, Helvetica;
+	font-size: 16pt;
+	color: #000000;
+}
\ No newline at end of file
diff --git a/webservice/classes/soap/templates/docclass.xsl b/webservice/classes/soap/templates/docclass.xsl
new file mode 100755
index 0000000..380bdc4
--- /dev/null
+++ b/webservice/classes/soap/templates/docclass.xsl
@@ -0,0 +1,116 @@
+<xsl:stylesheet
+	version="1.0"
+	xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+	xmlns:php="http://php.net/xsl"
+	xmlns:ipub="http://www.ipublisher.nl/4.0"
+	xmlns:exsl="http://exslt.org/common"
+	xmlns:str="http://exslt.org/strings"
+	xmlns:date="http://exslt.org/dates-and-times"
+	extension-element-prefixes="str exsl date"
+	>
+<xsl:include href="str.replace.function.xsl"/>
+<xsl:output method="html" encoding="utf-8" indent="yes" doctype-public="-//W3C//DTD XHTML 1.0 Transitional//EN" doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" media-type="text/html"/>
+
+<xsl:template match="/model">
+	<html>
+	<head>
+		<title>Webservices</title>
+		<link rel="stylesheet" href="classes/soap/templates/css/doc.css" type="text/css" ></link>
+	</head>
+	<body>
+	<div id="main">
+	<div id="mainheader">
+	<div id="mainheaderpadded">
+		<xsl:if test="class != ''">
+			<h1><xsl:value-of select="class/name" />  <a href="?class={class/name}&amp;wsdl">&#160;[WSDL]</a></h1>
+		</xsl:if>
+	</div>
+	</div>
+	<div id="mainpadded">
+	<table cellpadding="0" cellspacing="0">
+	<tr>
+	<td id="menu">
+		<h2>Classes</h2>
+		<xsl:for-each select="/model/menu/*">
+			<a href="?class={name}"><xsl:value-of select="name"/></a><br />
+		</xsl:for-each>
+	</td>
+	<td id="content">
+			<xsl:if test="fault != ''">
+				<xsl:value-of select="fault" />
+			</xsl:if>
+		<xsl:if test="class != '' and not(fault)">
+
+			<h2>Full description</h2>
+			<p><xsl:value-of select="class/fullDescription" /></p>
+
+			<h2>Properties</h2>
+			<xsl:for-each select="class/properties/*">
+				<a name="property_{name}"></a>
+				<div class="property{warning}">
+				<b><xsl:value-of select="name" /></b><br />
+				<xsl:choose>
+					<xsl:when test="type != ''">
+						<xsl:choose>
+							<xsl:when test="contains('int,boolean,double,float,string,void', type)">
+								<i>type <xsl:value-of select="type" /></i><br />
+							</xsl:when>
+							<xsl:otherwise>
+								<i>type <a href="?class={str:replace(type,'[]','')}"><xsl:value-of select="type" /></a></i><br />
+							</xsl:otherwise>
+						</xsl:choose>
+					</xsl:when>
+					<xsl:otherwise>
+						<div class='warning'><img src='classes/soap/templates/images/doc/warning.gif'/> missing type info</div><br />
+					</xsl:otherwise>
+				</xsl:choose>
+				<xsl:value-of select="fullDescription" />
+				</div>
+			</xsl:for-each>
+
+			<h2>Methods</h2>
+			<xsl:for-each select="class/methods/*">
+				<a name="method_{name}"></a>
+				<div class="method{warning}">
+				<b><xsl:value-of select="name" /></b>(
+				<xsl:for-each select="params/*">
+					<xsl:value-of select="name"/>
+					<xsl:if test="position() != last()">,</xsl:if>
+				</xsl:for-each>
+				)
+				<br />
+				<xsl:choose>
+					<xsl:when test="return != ''">
+						<xsl:choose>
+							<xsl:when test="contains('int,boolean,double,float,string,void', return)">
+								<i>returns <xsl:value-of select="return" /></i><br />
+							</xsl:when>
+							<xsl:otherwise>
+								<i>returns <a href="?class={str:replace(return,'[]','')}"><xsl:value-of select="return" /></a></i><br />
+							</xsl:otherwise>
+						</xsl:choose>
+					</xsl:when>
+					<xsl:otherwise>
+						<div class='warning'><img src='images/doc/warning.gif'/> missing return value</div><br />
+					</xsl:otherwise>
+				</xsl:choose>
+				<xsl:choose>
+					<xsl:when test="throws != ''">
+						<i>throws  <xsl:value-of select="throws" /></i><br />
+					</xsl:when>
+				</xsl:choose>
+				<xsl:value-of select="fullDescription" /><br />
+				</div>
+			</xsl:for-each>
+		</xsl:if>
+	</td>
+	</tr>
+	</table>
+
+	</div>
+	<div id="mainfooter"><img src="images/doc/backbottom.jpg" /></div>
+	</div>
+	</body>
+	</html>
+</xsl:template>
+</xsl:stylesheet>
\ No newline at end of file
diff --git a/webservice/classes/soap/templates/images/doc/back.gif b/webservice/classes/soap/templates/images/doc/back.gif
new file mode 100755
index 0000000..202a0f4
--- /dev/null
+++ b/webservice/classes/soap/templates/images/doc/back.gif
diff --git a/webservice/classes/soap/templates/images/doc/backbottom.jpg b/webservice/classes/soap/templates/images/doc/backbottom.jpg
new file mode 100755
index 0000000..cc6cb62
--- /dev/null
+++ b/webservice/classes/soap/templates/images/doc/backbottom.jpg
diff --git a/webservice/classes/soap/templates/images/doc/backtop.jpg b/webservice/classes/soap/templates/images/doc/backtop.jpg
new file mode 100755
index 0000000..5fe6b1f
--- /dev/null
+++ b/webservice/classes/soap/templates/images/doc/backtop.jpg
diff --git a/webservice/classes/soap/templates/images/doc/warning.gif b/webservice/classes/soap/templates/images/doc/warning.gif
new file mode 100755
index 0000000..efbfa44
--- /dev/null
+++ b/webservice/classes/soap/templates/images/doc/warning.gif
diff --git a/webservice/classes/soap/templates/str.replace.function.xsl b/webservice/classes/soap/templates/str.replace.function.xsl
new file mode 100755
index 0000000..5d74e86
--- /dev/null
+++ b/webservice/classes/soap/templates/str.replace.function.xsl
@@ -0,0 +1,105 @@
+<?xml version="1.0"?>
+<xsl:stylesheet version="1.0"
+                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+                xmlns:str="http://exslt.org/strings"
+                xmlns:func="http://exslt.org/functions"
+                xmlns:exsl="http://exslt.org/common"
+                extension-element-prefixes="str exsl func">
+
+<func:function name="str:replace">
+	<xsl:param name="string" select="''" />
+   <xsl:param name="search" select="/.." />
+   <xsl:param name="replace" select="/.." />
+   <xsl:choose>
+      <xsl:when test="not($string)">
+        <func:result select="/.." />
+      </xsl:when>
+      <xsl:when test="function-available('exsl:node-set')">
+         <!-- this converts the search and replace arguments to node sets
+              if they are one of the other XPath types -->
+         <xsl:variable name="search-nodes-rtf">
+           <xsl:copy-of select="$search" />
+         </xsl:variable>
+         <xsl:variable name="replace-nodes-rtf">
+           <xsl:copy-of select="$replace" />
+         </xsl:variable>
+         <xsl:variable name="replacements-rtf">
+            <xsl:for-each select="exsl:node-set($search-nodes-rtf)/node()">
+               <xsl:variable name="pos" select="position()" />
+               <replace search="{.}">
+                  <xsl:copy-of select="exsl:node-set($replace-nodes-rtf)/node()[$pos]" />
+               </replace>
+            </xsl:for-each>
+         </xsl:variable>
+         <xsl:variable name="sorted-replacements-rtf">
+            <xsl:for-each select="exsl:node-set($replacements-rtf)/replace">
+               <xsl:sort select="string-length(@search)" data-type="number" order="descending" />
+               <xsl:copy-of select="." />
+            </xsl:for-each>
+         </xsl:variable>
+         <xsl:variable name="result">
+           <xsl:choose>
+              <xsl:when test="not($search)">
+                <xsl:value-of select="$string" />
+              </xsl:when>
+             <xsl:otherwise>
+               <xsl:call-template name="str:_replace">
+                  <xsl:with-param name="string" select="$string" />
+                  <xsl:with-param name="replacements" select="exsl:node-set($sorted-replacements-rtf)/replace" />
+               </xsl:call-template>
+             </xsl:otherwise>
+           </xsl:choose>
+         </xsl:variable>
+         <func:result select="exsl:node-set($result)/node()" />
+      </xsl:when>
+      <xsl:otherwise>
+         <xsl:message terminate="yes">
+            ERROR: function implementation of str:replace() relies on exsl:node-set().
+         </xsl:message>
+      </xsl:otherwise>
+   </xsl:choose>
+</func:function>
+
+<xsl:template name="str:_replace">
+  <xsl:param name="string" select="''" />
+  <xsl:param name="replacements" select="/.." />
+  <xsl:choose>
+    <xsl:when test="not($string)" />
+    <xsl:when test="not($replacements)">
+      <xsl:value-of select="$string" />
+    </xsl:when>
+    <xsl:otherwise>
+      <xsl:variable name="replacement" select="$replacements[1]" />
+      <xsl:variable name="search" select="$replacement/@search" />
+      <xsl:choose>
+        <xsl:when test="not(string($search))">
+          <xsl:value-of select="substring($string, 1, 1)" />
+          <xsl:copy-of select="$replacement/node()" />
+          <xsl:call-template name="str:_replace">
+            <xsl:with-param name="string" select="substring($string, 2)" />
+            <xsl:with-param name="replacements" select="$replacements" />
+          </xsl:call-template>
+        </xsl:when>
+        <xsl:when test="contains($string, $search)">
+          <xsl:call-template name="str:_replace">
+            <xsl:with-param name="string" select="substring-before($string, $search)" />
+            <xsl:with-param name="replacements" select="$replacements[position() > 1]" />
+          </xsl:call-template>      
+          <xsl:copy-of select="$replacement/node()" />
+          <xsl:call-template name="str:_replace">
+            <xsl:with-param name="string" select="substring-after($string, $search)" />
+            <xsl:with-param name="replacements" select="$replacements" />
+          </xsl:call-template>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:call-template name="str:_replace">
+            <xsl:with-param name="string" select="$string" />
+            <xsl:with-param name="replacements" select="$replacements[position() > 1]" />
+          </xsl:call-template>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+</xsl:stylesheet>
\ No newline at end of file
diff --git a/webservice/documentation.php b/webservice/documentation.php
new file mode 100755
index 0000000..422f6de
--- /dev/null
+++ b/webservice/documentation.php
@@ -0,0 +1,57 @@
+<?php
+
+/**
+* Generates documentation for WSDL generation for KnowledgeTree webservices.
+*
+* KnowledgeTree Community Edition
+* Document Management Made Simple
+* Copyright (C) 2008,2009 KnowledgeTree Inc.
+* Portions copyright The Jam Warehouse Software (Pty) Limited
+*
+* This program is free software; you can redistribute it and/or modify it under
+* the terms of the GNU General Public License version 3 as published by the
+* Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+* FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+* details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+* You can contact KnowledgeTree Inc., PO Box 7775 #87847, San Francisco,
+* California 94120-7775, or email info@knowledgetree.com.
+*
+* The interactive user interfaces in modified source and object code versions
+* of this program must display Appropriate Legal Notices, as required under
+* Section 5 of the GNU General Public License version 3.
+*
+* In accordance with Section 7(b) of the GNU General Public License version 3,
+* these Appropriate Legal Notices must retain the display of the "Powered by
+* KnowledgeTree" logo and retain the original copyright notice. If the display of the
+* logo is not reasonably feasible for technical reasons, the Appropriate Legal Notices
+* must display the words "Powered by KnowledgeTree" and retain the original
+* copyright notice.
+*
+* @copyright 2008-2009, KnowledgeTree Inc.
+* @license GNU General Public License version 3
+* @author KnowledgeTree Team
+* @package Webservice
+* @version Version 0.1
+*/
+//need to manually include for the function 'get_declared_classes()'
+include_once("classes/soap/IPPhpDoc.class.php");
+include_once("classes/soap/IPReflectionClass.class.php");
+include_once("classes/soap/IPReflectionCommentParser.class.php");
+include_once("classes/soap/IPReflectionMethod.class.php");
+include_once("classes/soap/IPReflectionProperty.class.php");
+include_once("classes/soap/IPXMLSchema.class.php");
+include_once("classes/soap/WSDLStruct.class.php");
+include_once("classes/soap/WSHelper.class.php");
+include_once("classes/soap/IPXSLTemplate.class.php");
+
+$phpdoc=new IPPhpdoc();
+if(isset($_GET['class'])) $phpdoc->setClass($_GET['class']);
+echo $phpdoc->getDocumentation();
+?>
\ No newline at end of file
diff --git a/webservice/restservice.php b/webservice/restservice.php
new file mode 100755
index 0000000..37d1f01
--- /dev/null
+++ b/webservice/restservice.php
@@ -0,0 +1,70 @@
+<?php
+/**
+* Implements a cleaner wrapper restservice  API for KnowledgeTree.
+*
+* KnowledgeTree Community Edition
+* Document Management Made Simple
+* Copyright (C) 2008,2009 KnowledgeTree Inc.
+* Portions copyright The Jam Warehouse Software (Pty) Limited
+*
+* This program is free software; you can redistribute it and/or modify it under
+* the terms of the GNU General Public License version 3 as published by the
+* Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+* FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+* details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+* You can contact KnowledgeTree Inc., PO Box 7775 #87847, San Francisco,
+* California 94120-7775, or email info@knowledgetree.com.
+*
+* The interactive user interfaces in modified source and object code versions
+* of this program must display Appropriate Legal Notices, as required under
+* Section 5 of the GNU General Public License version 3.
+*
+* In accordance with Section 7(b) of the GNU General Public License version 3,
+* these Appropriate Legal Notices must retain the display of the "Powered by
+* KnowledgeTree" logo and retain the original copyright notice. If the display of the
+* logo is not reasonably feasible for technical reasons, the Appropriate Legal Notices
+* must display the words "Powered by KnowledgeTree" and retain the original
+* copyright notice.
+*
+* @copyright 2008-2009, KnowledgeTree Inc.
+* @license GNU General Public License version 3
+* @author KnowledgeTree Team
+* @package Webservice
+* @version Version 0.1
+*/
+
+ob_start("ob_gzhandler");
+session_start();
+
+if(file_exists("classes/rest/Server.php"))
+      include("classes/rest/Server.php");	  
+if (file_exists("classes/rest/model/contactManager.class.php"))
+        include("classes/rest/model/contactManager.class.php");
+if (file_exists("classes/rest/model/RestService.class.php"))
+        include("classes/rest/model/RestService.class.php");
+
+
+try {
+        $server = new Rest_Server();
+      
+       	$server->setClass("contactManager");
+
+       	//$server->addFunction('getContacts');
+
+		$server->handle();
+        //var_dump($server);
+
+
+	}catch(Exception $e) {
+		//possible db transaction rollback
+		$server->fault("SERVER", $e->getMessage(),"", $e->__toString());
+	}
+exit;
+?>
\ No newline at end of file
diff --git a/webservice/tests/RESTClient.php b/webservice/tests/RESTClient.php
new file mode 100644
index 0000000..d8e8610
--- /dev/null
+++ b/webservice/tests/RESTClient.php
@@ -0,0 +1,76 @@
+<?php
+
+require_once "HTTP/Request.php";
+
+class RESTClient {
+
+    private $root_url = "";
+    private $curr_url = "";
+    private $user_name = "";
+    private $password = "";
+    private $response = "";
+    private $responseBody = "";
+    private $req = null;
+
+    public function __construct($root_url = "", $user_name = "", $password = "") {
+        $this->root_url = $this->curr_url = $root_url;
+        $this->user_name = $user_name;
+        $this->password = $password;
+        if ($root_url != "") {
+            $this->createRequest("GET");
+            $this->sendRequest();
+        }
+        return true;
+    }
+
+    public function createRequest($url, $method, $arr = null) {
+        $this->curr_url = $url;
+        $this->req =& new HTTP_Request($url);
+        if ($this->user_name != "" && $this->password != "") {
+           $this->req->setBasicAuth($this->user_name, $this->password);
+        }
+
+        switch($method) {
+            case "GET":
+                $this->req->setMethod(HTTP_REQUEST_METHOD_GET);
+                break;
+            case "POST":
+                $this->req->setMethod(HTTP_REQUEST_METHOD_POST);
+                $this->addPostData($arr);
+                break;
+            case "PUT":
+                $this->req->setMethod(HTTP_REQUEST_METHOD_PUT);
+                // to-do
+                break;
+            case "DELETE":
+                $this->req->setMethod(HTTP_REQUEST_METHOD_DELETE);
+                // to-do
+                break;
+        }
+    }
+
+    private function addPostData($arr) {
+        if ($arr != null) {
+            foreach ($arr as $key => $value) {
+                $this->req->addPostData($key, $value);
+            }
+        }
+    }
+
+    public function sendRequest() {
+        $this->response = $this->req->sendRequest();
+
+        if (PEAR::isError($this->response)) {
+            echo $this->response->getMessage();
+            die();
+        } else {
+            $this->responseBody = $this->req->getResponseBody();
+        }
+    }
+
+    public function getResponse() {
+        return $this->responseBody;
+    }
+
+}
+?>
\ No newline at end of file
diff --git a/webservice/tests/Rest.php b/webservice/tests/Rest.php
new file mode 100644
index 0000000..3293edd
--- /dev/null
+++ b/webservice/tests/Rest.php
@@ -0,0 +1,19 @@
+<?php
+
+include_once("RESTClient.php");
+
+$rest = new RESTclient();
+
+$inputs = array();
+$inputs["appid"] = "YahooDemo";
+$inputs["street"] = "701 First Street";
+$inputs["city"] = "Sunnyvale";
+$inputs["state"] = "CA";
+
+$url = "http://www.knowledgetree.pr/webservice/service.php?class=RestService";
+$rest->createRequest("$url","GET",'');
+$rest->sendRequest();
+$output = $rest->getResponse();
+echo $output;
+
+?>
\ No newline at end of file
diff --git a/webservice/tests/annotations.php b/webservice/tests/annotations.php
new file mode 100755
index 0000000..e10ef44
--- /dev/null
+++ b/webservice/tests/annotations.php
@@ -0,0 +1,44 @@
+<?
+chdir("..");
+include "common.php";
+
+class DefaultController {
+	const TYPE_PLAIN = 1;
+	const TYPE_HTML = 2;
+	public $type;
+	public $length;
+}
+/**
+ * @ann1('me'=>'you');
+ */
+class something{
+	/**
+	 * @var string
+	 * @Controller(type => DefaultController::TYPE_PLAIN, length => 100)
+	 */
+	public $propertyA;
+	
+	/**
+	 * @var string
+	 * @Controller(type => DefaultController::TYPE_HTML, length => 100)
+	 */
+	public function methodB () {
+		return "aap";
+	}
+}
+
+/* Annotation example */
+$rel = new IPReflectionClass("something");
+$properties = $rel->getProperties();
+$methods = $rel->getMethods();
+
+var_dump($rel->getAnnotation("ann1", "stdClass"));
+
+$property = $properties["propertyA"];
+$ann = $property->getAnnotation("Controller", "DefaultController");
+var_dump($ann);
+
+$method = $methods["methodB"];
+$ann = $method->getAnnotation("Controller", "DefaultController");
+var_dump($ann);
+?>
\ No newline at end of file
diff --git a/webservice/tests/webservice.php b/webservice/tests/webservice.php
new file mode 100755
index 0000000..e0cefbe
--- /dev/null
+++ b/webservice/tests/webservice.php
@@ -0,0 +1,17 @@
+<?php
+$wsdl = "http://".$_SERVER['HTTP_HOST']."/webservice/service.php?class=contactManager&wsdl";
+echo "<strong>WSDL file:</strong> ".$wsdl."<br>\n";
+
+$options = Array('actor' =>'http://www.knowledgetree.pr',
+				 'trace' => true);
+$client = new SoapClient($wsdl,$options);
+
+echo "<hr> <strong>Result from getContacts call:</strong><br>";
+
+$res = $client->getContacts();
+print_r($res);
+echo "<hr><strong>Raw Soap response:</strong><br>";
+echo htmlentities($client->__getLastResponse());
+echo "<hr><strong>SoapFault asking for an unknown contact:</strong><br>";
+$client->newContact();
+?>
\ No newline at end of file
diff --git a/webservice/webservice.php b/webservice/webservice.php
new file mode 100755
index 0000000..dcf0195
--- /dev/null
+++ b/webservice/webservice.php
@@ -0,0 +1,66 @@
+<?php
+/**
+* Invokes webservices  API for KnowledgeTree.
+*
+* KnowledgeTree Community Edition
+* Document Management Made Simple
+* Copyright (C) 2008,2009 KnowledgeTree Inc.
+* Portions copyright The Jam Warehouse Software (Pty) Limited
+*
+* This program is free software; you can redistribute it and/or modify it under
+* the terms of the GNU General Public License version 3 as published by the
+* Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+* FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+* details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+* You can contact KnowledgeTree Inc., PO Box 7775 #87847, San Francisco,
+* California 94120-7775, or email info@knowledgetree.com.
+*
+* The interactive user interfaces in modified source and object code versions
+* of this program must display Appropriate Legal Notices, as required under
+* Section 5 of the GNU General Public License version 3.
+*
+* In accordance with Section 7(b) of the GNU General Public License version 3,
+* these Appropriate Legal Notices must retain the display of the "Powered by
+* KnowledgeTree" logo and retain the original copyright notice. If the display of the
+* logo is not reasonably feasible for technical reasons, the Appropriate Legal Notices
+* must display the words "Powered by KnowledgeTree" and retain the original
+* copyright notice.
+*
+* @copyright 2008-2009, KnowledgeTree Inc.
+* @license GNU General Public License version 3
+* @author KnowledgeTree Team
+* @package Webservice
+* @version Version 0.1
+*/
+
+require_once "classes/soap/common.php";
+
+if($_GET['class'] && (in_array($_GET['class'], $WSClasses) || in_array($_GET['class'], $WSStructures))) {
+    $WSHelper = new WSHelper("http://www.knowledgetree.com", $_GET['class']);
+	$WSHelper->actor = "http://www.knowledgetree.com";
+	$WSHelper->use = SOAP_ENCODED;
+	$WSHelper->classNameArr = $WSClasses;
+	$WSHelper->structureMap = $WSStructures;
+	$WSHelper->setPersistence(SOAP_PERSISTENCE_REQUEST);
+	$WSHelper->setWSDLCacheFolder('wsdl/'); //trailing slash mandatory. Default is 'wsdl/'
+
+	try {
+
+		$WSHelper->handle();
+		//possible db transaction commit
+	}catch(Exception $e) {
+		//possible db transaction rollback
+		$WSHelper->fault("SERVER", $e->getMessage(),"", $e->__toString());
+	}
+} else {
+	die("No valid class selected");
+}
+
+?>
\ No newline at end of file
diff --git a/webservice/wsdl/contactManager.wsdl b/webservice/wsdl/contactManager.wsdl
new file mode 100644
index 0000000..d7ba892
--- /dev/null
+++ b/webservice/wsdl/contactManager.wsdl
@@ -0,0 +1,2 @@
+<?xml version="1.0"?>
+<wsdl:definitions xmlns="http://schemas.xmlsoap.org/wsdl/" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:tns="http://www.knowledgetree.com" targetNamespace="http://www.knowledgetree.com"><wsdl:types><xsd:schema targetNamespace="http://www.knowledgetree.com"><xsd:complexType name="contact"><xsd:all><xsd:element name="address" type="tns:address"/><xsd:element name="email" type="xsd:string"/><xsd:element name="id" type="xsd:int"/><xsd:element name="name" type="xsd:string"/></xsd:all></xsd:complexType><xsd:complexType name="address"><xsd:all><xsd:element name="city" type="xsd:string"/><xsd:element name="nr" type="xsd:string"/><xsd:element name="street" type="xsd:string"/><xsd:element name="zipcode" type="xsd:string"/></xsd:all></xsd:complexType><xsd:complexType name="contactArray"><xsd:complexContent><xsd:restriction base="SOAP-ENC:Array"><xsd:attribute ref="SOAP-ENC:arrayType" wsdl:arrayType="tns:contact[]"/></xsd:restriction></xsd:complexContent></xsd:complexType></xsd:schema></wsdl:types><message name="getContactRequest"><part name="id" type="xsd:int"/></message><message name="getContactResponse"><part name="getContactReturn" type="tns:contact"/></message><message name="getContactsRequest"/><message name="getContactsResponse"><part name="getContactsReturn" type="tns:contactArray"/></message><message name="newContactRequest"/><message name="newContactResponse"><part name="newContactReturn" type="tns:contact"/></message><message name="saveContactRequest"><part name="contact" type="tns:contact"/></message><wsdl:portType name="contactManagerPortType"><wsdl:operation name="getContact"><wsdl:input message="tns:getContactRequest"/><wsdl:output message="tns:getContactResponse"/></wsdl:operation><wsdl:operation name="getContacts"><wsdl:input message="tns:getContactsRequest"/><wsdl:output message="tns:getContactsResponse"/></wsdl:operation><wsdl:operation name="newContact"><wsdl:input message="tns:newContactRequest"/><wsdl:output message="tns:newContactResponse"/></wsdl:operation><wsdl:operation name="saveContact"><wsdl:input message="tns:saveContactRequest"/></wsdl:operation></wsdl:portType><binding name="contactManagerBinding" type="tns:contactManagerPortType"><soap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http"/><wsdl:operation name="getContact"><soap:operation soapAction="http://www.knowledgetree.pr/webservice/webservice.php?class=contactManager&amp;method=getContact" style="rpc"/><wsdl:input><soap:body use="encoded" namespace="http://www.knowledgetree.com" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/></wsdl:input><wsdl:output><soap:body use="encoded" namespace="http://www.knowledgetree.com" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/></wsdl:output></wsdl:operation><wsdl:operation name="getContacts"><soap:operation soapAction="http://www.knowledgetree.pr/webservice/webservice.php?class=contactManager&amp;method=getContacts" style="rpc"/><wsdl:input><soap:body use="encoded" namespace="http://www.knowledgetree.com" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/></wsdl:input><wsdl:output><soap:body use="encoded" namespace="http://www.knowledgetree.com" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/></wsdl:output></wsdl:operation><wsdl:operation name="newContact"><soap:operation soapAction="http://www.knowledgetree.pr/webservice/webservice.php?class=contactManager&amp;method=newContact" style="rpc"/><wsdl:input><soap:body use="encoded" namespace="http://www.knowledgetree.com" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/></wsdl:input><wsdl:output><soap:body use="encoded" namespace="http://www.knowledgetree.com" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/></wsdl:output></wsdl:operation><wsdl:operation name="saveContact"><soap:operation soapAction="http://www.knowledgetree.pr/webservice/webservice.php?class=contactManager&amp;method=saveContact" style="rpc"/><wsdl:input><soap:body use="encoded" namespace="http://www.knowledgetree.com" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"/></wsdl:input></wsdl:operation></binding><wsdl:service name="contactManager"><wsdl:port name="contactManagerPort" binding="tns:contactManagerBinding"><soap:address location="http://www.knowledgetree.pr/webservice/webservice.php?class=contactManager"/></wsdl:port></wsdl:service></wsdl:definitions>