svn commit: r1691890 [5/14] - in /chemistry/portcmis: ./ PortCMIS/ PortCMIS/Properties/ PortCMIS/binding/ PortCMIS/binding/atompub/ PortCMIS/binding/browser/ PortCMIS/binding/browser/json/ PortCMIS/client/ PortCMIS/const/ PortCMIS/data/ PortCMIS/enum/ ...

[fm...@apache.org]

Added: chemistry/portcmis/PortCMIS/binding/browser/BrowserBinding.cs
URL: http://svn.apache.org/viewvc/chemistry/portcmis/PortCMIS/binding/browser/BrowserBinding.cs?rev=1691890&view=auto
==============================================================================
--- chemistry/portcmis/PortCMIS/binding/browser/BrowserBinding.cs (added)
+++ chemistry/portcmis/PortCMIS/binding/browser/BrowserBinding.cs Mon Jul 20 08:48:57 2015
@@ -0,0 +1,2216 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements. See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership. The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License. You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* Kind, either express or implied. See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+using PortCMIS.binding;
+using PortCMIS.Binding.Browser.Json;
+using PortCMIS.Binding.Http;
+using PortCMIS.Binding.Impl;
+using PortCMIS.Binding.Services;
+using PortCMIS.Client;
+using PortCMIS.Data;
+using PortCMIS.Data.Extensions;
+using PortCMIS.Enums;
+using PortCMIS.Exceptions;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PortCMIS.Binding.Browser
+{
+    public class RepositoryInfoBrowserBinding : RepositoryInfo
+    {
+        public string RepositoryUrl { get; set; }
+        public string RootUrl { get; set; }
+    }
+
+    /// <summary>
+    /// Browser binding SPI.
+    /// </summary>
+    internal class CmisBrowserSpi : ICmisSpi
+    {
+        public const string RepositoryUrlCache = "org.apache.chemistry.portcmis.binding.browser.repositoryurls";
+
+        private BindingSession session;
+        private RepositoryService repositoryService;
+        private NavigationService navigationService;
+        private ObjectService objectService;
+        private VersioningService versioningService;
+        private DiscoveryService discoveryService;
+        private MultiFilingService multiFilingService;
+        private RelationshipService relationshipService;
+        private PolicyService policyService;
+        private AclService aclService;
+
+        public void Initialize(IBindingSession session)
+        {
+            this.session = session as BindingSession;
+            if (this.session == null)
+            {
+                throw new ArgumentException("Inavlid binding session!");
+            }
+
+            repositoryService = new RepositoryService(this.session);
+            navigationService = new NavigationService(this.session);
+            objectService = new ObjectService(this.session);
+            versioningService = new VersioningService(this.session);
+            discoveryService = new DiscoveryService(this.session);
+            multiFilingService = new MultiFilingService(this.session);
+            relationshipService = new RelationshipService(this.session);
+            policyService = new PolicyService(this.session);
+            aclService = new AclService(this.session);
+        }
+
+        public IRepositoryService GetRepositoryService()
+        {
+            return repositoryService;
+        }
+
+        public INavigationService GetNavigationService()
+        {
+            return navigationService;
+        }
+
+        public IObjectService GetObjectService()
+        {
+            return objectService;
+        }
+
+        public IVersioningService GetVersioningService()
+        {
+            return versioningService;
+        }
+
+        public IRelationshipService GetRelationshipService()
+        {
+            return relationshipService;
+        }
+
+        public IDiscoveryService GetDiscoveryService()
+        {
+            return discoveryService;
+        }
+
+        public IMultiFilingService GetMultiFilingService()
+        {
+            return multiFilingService;
+        }
+
+        public IAclService GetAclService()
+        {
+            return aclService;
+        }
+
+        public IPolicyService GetPolicyService()
+        {
+            return policyService;
+        }
+
+        public void ClearAllCaches()
+        {
+            session.RemoveValue(RepositoryUrlCache);
+        }
+
+        public void ClearRepositoryCache(string repositoryId)
+        {
+            RepositoryUrlCache repUrlCache = session.GetValue(RepositoryUrlCache) as RepositoryUrlCache;
+            if (repUrlCache != null)
+            {
+                repUrlCache.RemoveRepository(repositoryId);
+            }
+        }
+
+        public void Dispose()
+        {
+            // nothing to do
+        }
+    }
+
+    internal class ClientTypeCache : ITypeCache
+    {
+        private string RepositoryId { get; set; }
+        private AbstractBrowserBindingService Service { get; set; }
+
+        public ClientTypeCache(string repositoryId, AbstractBrowserBindingService service)
+        {
+            this.RepositoryId = repositoryId;
+            this.Service = service;
+        }
+
+        public ITypeDefinition GetTypeDefinition(string typeId)
+        {
+            TypeDefinitionCache cache = Service.Session.GetTypeDefinitionCache();
+
+            ITypeDefinition type = cache.Get(RepositoryId, typeId);
+            if (type == null)
+            {
+                type = Service.GetTypeDefinitionInternal(RepositoryId, typeId);
+                if (type != null)
+                {
+                    cache.Put(RepositoryId, type);
+                }
+            }
+
+            return type;
+        }
+
+        public ITypeDefinition ReloadTypeDefinition(string typeId)
+        {
+            TypeDefinitionCache cache = Service.Session.GetTypeDefinitionCache();
+
+            ITypeDefinition type = Service.GetTypeDefinitionInternal(RepositoryId, typeId);
+            if (type != null)
+            {
+                cache.Put(RepositoryId, type);
+            }
+
+            return type;
+        }
+
+        public ITypeDefinition GetTypeDefinitionForObject(string objectId)
+        {
+            return null;
+        }
+
+        public IPropertyDefinition GetPropertyDefinition(string propId)
+        {
+            return null;
+        }
+    }
+
+    internal class FormDataComposer
+    {
+        public string CmisAction { get; private set; }
+
+        public IContentStream Stream { get; set; }
+
+        public IProperties Properties { get; set; }
+        public bool Succinct { get; set; }
+        public DateTimeFormat DateTimeFormat { get; set; }
+
+        public IAcl AddAces { get; set; }
+        public IAcl RemoveAces { get; set; }
+
+        public IList<string> Policies { get; set; }
+        public string PolicyId { get; set; }
+
+        public IList<string> AddSecondaryTypeIds { get; set; }
+        public IList<string> RemoveSecondaryTypeIds { get; set; }
+
+        public IList<IBulkUpdateObjectIdAndChangeToken> ObjectIdsAndChangeTokens { get; set; }
+
+        private IDictionary<string, object> parameters;
+
+        public IDictionary<string, object> Parameters
+        {
+            get
+            {
+                if (parameters == null)
+                {
+                    parameters = new Dictionary<string, object>();
+                }
+                return parameters;
+            }
+            set { parameters = value; }
+        }
+
+        public FormDataComposer(string cmisAction)
+        {
+            CmisAction = cmisAction;
+        }
+
+        public HttpContent CreateHttpContent()
+        {
+            if (Stream == null)
+            {
+                return CreateFormUrlEncodedContent();
+            }
+            else
+            {
+                return CreateMultipartFormDataContent();
+            }
+        }
+
+        protected FormUrlEncodedContent CreateFormUrlEncodedContent()
+        {
+            return new FormUrlEncodedContent(CreateContent());
+        }
+
+        protected MultipartFormDataContent CreateMultipartFormDataContent()
+        {
+            MultipartFormDataContent content = new MultipartFormDataContent();
+
+            IList<KeyValuePair<string, string>> parameters = CreateContent();
+            foreach (KeyValuePair<string, string> p in parameters)
+            {
+                content.Add(new StringContent(p.Value, Encoding.UTF8), p.Key);
+            }
+
+            if (Stream.Stream != null)
+            {
+                StreamContent streamContent = new StreamContent(Stream.Stream);
+                streamContent.Headers.ContentType = new MediaTypeHeaderValue(Stream.MimeType ?? "applictaion/octet-stream");
+
+                content.Add(streamContent, "content", Stream.FileName ?? "content");
+            }
+
+            return content;
+        }
+
+        protected IList<KeyValuePair<string, string>> CreateContent()
+        {
+            IList<KeyValuePair<string, string>> result = new List<KeyValuePair<string, string>>();
+
+            // set cmisaction
+            result.Add(new KeyValuePair<string, string>(BindingConstants.ControlCmisAction, CmisAction));
+
+            // set parameters
+            if (parameters != null)
+            {
+                foreach (KeyValuePair<string, object> p in parameters)
+                {
+                    if (p.Value != null)
+                    {
+                        result.Add(new KeyValuePair<string, string>(p.Key, UrlBuilder.NormalizeParameter(p.Value)));
+                    }
+                }
+            }
+
+            // set succinct
+            if (Succinct)
+            {
+                result.Add(new KeyValuePair<string, string>(BindingConstants.ControlSuccinct, "true"));
+            }
+
+            // set properties
+            AddPropertiesParameters(Properties, result);
+
+            // set Aces
+            AddAcesParameters(AddAces, BindingConstants.ControlAddAcePrincipal, BindingConstants.ControlRemoveAcePermission, result);
+            AddAcesParameters(RemoveAces, BindingConstants.ControlRemoveAcePrincipal, BindingConstants.ControlRemoveAcePermission, result);
+
+            // set policies
+            AddPoliciesParameters(Policies, result);
+            AddPolicyIdParameter(PolicyId, result);
+
+            // set secondary type IDs
+            AddSecondaryTypeIdParameters(AddSecondaryTypeIds, BindingConstants.ControlAddSecondaryType, result);
+            AddSecondaryTypeIdParameters(RemoveSecondaryTypeIds, BindingConstants.ControlRemoveSecondaryType, result);
+
+            // set bulk update values
+            AddObjectIdsAndChangeTokens(ObjectIdsAndChangeTokens, result);
+
+            return result;
+        }
+
+        private void AddPropertiesParameters(IProperties properties, IList<KeyValuePair<string, string>> result)
+        {
+            if (properties == null || properties.PropertyList == null)
+            {
+                return;
+            }
+
+            int idx = 0;
+            foreach (PropertyData prop in properties.PropertyList)
+            {
+                if (prop == null)
+                {
+                    continue;
+                }
+
+                string idxStr = "[" + idx + "]";
+                result.Add(new KeyValuePair<string, string>(BindingConstants.ControlPropId + idxStr, prop.Id));
+
+                if (prop.Values != null && prop.Values.Count > 0)
+                {
+                    if (prop.Values.Count == 1)
+                    {
+                        result.Add(new KeyValuePair<string, string>(
+                            BindingConstants.ControlPropValue + idxStr, ConvertPropertyValue(prop.FirstValue, DateTimeFormat)));
+                    }
+                    else
+                    {
+                        int vidx = 0;
+                        foreach (object obj in prop.Values)
+                        {
+                            string vidxStr = "[" + vidx + "]";
+                            result.Add(new KeyValuePair<string, string>(
+                                BindingConstants.ControlPropValue + idxStr + vidxStr, ConvertPropertyValue(obj, DateTimeFormat)));
+                            vidx++;
+                        }
+                    }
+                }
+                idx++;
+            }
+        }
+
+        private void AddAcesParameters(IAcl acl, string principalControl, string permissionControl, IList<KeyValuePair<string, string>> result)
+        {
+            if (acl == null || acl.Aces == null)
+            {
+                return;
+            }
+
+            int idx = 0;
+            foreach (IAce ace in acl.Aces)
+            {
+                if (ace.PrincipalId != null && ace.Permissions != null && ace.Permissions.Count > 0)
+                {
+                    string idxStr = "[" + idx + "]";
+                    result.Add(new KeyValuePair<string, string>(principalControl + idxStr, ace.PrincipalId));
+
+                    int permIdx = 0;
+                    foreach (string perm in ace.Permissions)
+                    {
+                        if (perm != null)
+                        {
+                            string permIdxStr = "[" + permIdx + "]";
+                            result.Add(new KeyValuePair<string, string>(permissionControl + idxStr + permIdxStr, perm));
+                            permIdx++;
+                        }
+                    }
+                    idx++;
+                }
+            }
+        }
+
+        private void AddPoliciesParameters(IList<string> policies, IList<KeyValuePair<string, string>> result)
+        {
+            if (policies == null)
+            {
+                return;
+            }
+
+            int idx = 0;
+            foreach (string policy in policies)
+            {
+                if (policy != null)
+                {
+                    string idxStr = "[" + idx + "]";
+                    result.Add(new KeyValuePair<string, string>(BindingConstants.ControlPolicy + idxStr, policy));
+                    idx++;
+                }
+            }
+        }
+
+        private void AddPolicyIdParameter(string policyId, IList<KeyValuePair<string, string>> result)
+        {
+            if (policyId == null)
+            {
+                return;
+            }
+
+            result.Add(new KeyValuePair<string, string>(BindingConstants.ControlPolicyId, policyId));
+        }
+
+        private void AddSecondaryTypeIdParameters(IList<string> secondaryTypeIds, string secondaryTypeIdControl, IList<KeyValuePair<string, string>> result)
+        {
+            if (secondaryTypeIds == null || secondaryTypeIds.Count == 0)
+            {
+                return;
+            }
+
+            int idx = 0;
+            foreach (string typeId in secondaryTypeIds)
+            {
+                if (typeId == null || typeId.Length == 0)
+                {
+                    continue;
+                }
+
+                string idxStr = "[" + idx + "]";
+                result.Add(new KeyValuePair<string, string>(secondaryTypeIdControl + idxStr, typeId));
+
+                idx++;
+            }
+        }
+
+        public void AddObjectIdsAndChangeTokens(IList<IBulkUpdateObjectIdAndChangeToken> objectIdsAndChangeTokens, IList<KeyValuePair<string, string>> result)
+        {
+            if (objectIdsAndChangeTokens == null || objectIdsAndChangeTokens.Count == 0)
+            {
+                return;
+            }
+
+            int idx = 0;
+            foreach (IBulkUpdateObjectIdAndChangeToken oc in objectIdsAndChangeTokens)
+            {
+                if (oc == null || oc.Id == null || oc.Id.Length == 0)
+                {
+                    continue;
+                }
+
+                string idxStr = "[" + idx + "]";
+                result.Add(new KeyValuePair<string, string>(BindingConstants.ControlObjectId + idxStr, oc.Id));
+                result.Add(new KeyValuePair<string, string>(BindingConstants.ControlChangeToken + idxStr, oc.ChangeToken ?? ""));
+
+                idx++;
+            }
+        }
+
+        private string ConvertPropertyValue(object value, DateTimeFormat dateTimeFormat)
+        {
+            if (value == null)
+            {
+                return null;
+            }
+            else if (value is DateTime)
+            {
+                if (DateTimeFormat == DateTimeFormat.Extended)
+                {
+                    return DateTimeHelper.FormatISO8601((DateTime)value);
+                }
+                else
+                {
+                    return DateTimeHelper.ConvertDateTimeToMillis((DateTime)value).ToString();
+                }
+            }
+            else if (value is decimal)
+            {
+                return ((decimal)value).ToString("#", CultureInfo.InvariantCulture);
+            }
+            else if (value is BigInteger)
+            {
+                return ((BigInteger)value).ToString("#", CultureInfo.InvariantCulture);
+            }
+            else
+            {
+                return value.ToString();
+            }
+        }
+    }
+
+
+    /// <summary>
+    /// Common service data and operations.
+    /// </summary>
+    internal abstract class AbstractBrowserBindingService
+    {
+        private BindingSession session;
+
+        public BindingSession Session
+        {
+            get
+            {
+                return session;
+            }
+            protected set
+            {
+                session = value;
+
+                Succinct = true;
+                object succintObj = session.GetValue(SessionParameter.BrowserSuccinct);
+                if (succintObj is string)
+                {
+                    Succinct = Convert.ToBoolean((string)succintObj);
+                }
+
+                DateTimeFormat = DateTimeFormat.Simple;
+                object dateTimeFormatObj = session.GetValue(SessionParameter.BrowserDateTimeFormat);
+                if (dateTimeFormatObj is string)
+                {
+                    DateTimeFormat? dtf = ((string)dateTimeFormatObj).GetCmisEnum<DateTimeFormat>();
+                    DateTimeFormat = dtf ?? DateTimeFormat.Simple;
+                }
+            }
+        }
+        protected bool Succinct { get; private set; }
+        protected string SuccinctParameter { get { return Succinct ? "true" : null; } }
+
+        protected DateTimeFormat DateTimeFormat { get; private set; }
+        protected string DateTimeFormatParameter { get { return DateTimeFormat == DateTimeFormat.Simple ? null : DateTimeFormat.GetCmisValue(); } }
+
+        protected string GetServiceUrl()
+        {
+            return Session.GetValue(SessionParameter.BrowserUrl) as string;
+        }
+
+        protected UrlBuilder GetRepositoryUrl(string repositoryId, string selector)
+        {
+            UrlBuilder result = GetRepositoryUrlCache().GetRepositoryUrl(repositoryId, selector);
+
+            if (result == null)
+            {
+                GetRepositoriesInternal(repositoryId);
+                result = GetRepositoryUrlCache().GetRepositoryUrl(repositoryId, selector);
+            }
+
+            if (result == null)
+            {
+                throw new CmisObjectNotFoundException("Unknown repository!");
+            }
+
+            return result;
+        }
+
+        protected UrlBuilder GetRepositoryUrl(string repositoryId)
+        {
+            UrlBuilder result = GetRepositoryUrlCache().GetRepositoryUrl(repositoryId);
+
+            if (result == null)
+            {
+                GetRepositoriesInternal(repositoryId);
+                result = GetRepositoryUrlCache().GetRepositoryUrl(repositoryId);
+            }
+
+            if (result == null)
+            {
+                throw new CmisObjectNotFoundException("Unknown repository!");
+            }
+
+            return result;
+        }
+
+        protected UrlBuilder GetObjectUrl(string repositoryId, string objectId, string selector)
+        {
+            UrlBuilder result = GetRepositoryUrlCache().GetObjectUrl(repositoryId, objectId, selector);
+
+            if (result == null)
+            {
+                GetRepositoriesInternal(repositoryId);
+                result = GetRepositoryUrlCache().GetObjectUrl(repositoryId, objectId, selector);
+            }
+
+            if (result == null)
+            {
+                throw new CmisObjectNotFoundException("Unknown repository!");
+            }
+
+            return result;
+        }
+
+        protected UrlBuilder GetObjectUrl(string repositoryId, string objectId)
+        {
+            UrlBuilder result = GetRepositoryUrlCache().GetObjectUrl(repositoryId, objectId);
+
+            if (result == null)
+            {
+                GetRepositoriesInternal(repositoryId);
+                result = GetRepositoryUrlCache().GetObjectUrl(repositoryId, objectId);
+            }
+
+            if (result == null)
+            {
+                throw new CmisObjectNotFoundException("Unknown repository!");
+            }
+
+            return result;
+        }
+
+        protected UrlBuilder GetPathUrl(string repositoryId, string path, string selector)
+        {
+            UrlBuilder result = GetRepositoryUrlCache().GetPathUrl(repositoryId, path, selector);
+
+            if (result == null)
+            {
+                GetRepositoriesInternal(repositoryId);
+                result = GetRepositoryUrlCache().GetPathUrl(repositoryId, path, selector);
+            }
+
+            if (result == null)
+            {
+                throw new CmisObjectNotFoundException("Unknown repository!");
+            }
+
+            return result;
+        }
+
+
+        protected RepositoryUrlCache GetRepositoryUrlCache()
+        {
+            RepositoryUrlCache repositoryUrlCache = Session.GetValue(CmisBrowserSpi.RepositoryUrlCache) as RepositoryUrlCache;
+            if (repositoryUrlCache == null)
+            {
+                repositoryUrlCache = new RepositoryUrlCache();
+                Session.PutValue(CmisBrowserSpi.RepositoryUrlCache, repositoryUrlCache);
+            }
+
+            return repositoryUrlCache;
+        }
+
+        protected void SetChangeToken(ref string changeToken, IObjectData obj)
+        {
+            if (changeToken == null)
+            {
+                return;
+            }
+
+            changeToken = null;
+
+            if (obj == null || obj.Properties == null)
+            {
+                return;
+            }
+
+            IPropertyData ct = obj.Properties[PropertyIds.ChangeToken];
+            if (ct != null && ct.PropertyType == PropertyType.String)
+            {
+                changeToken = (string)ct.FirstValue;
+            }
+        }
+
+        // ---- exceptions ----
+
+        /// <summary>
+        /// Converts an error message or a HTTP status code into an Exception.
+        /// </summary>
+        protected CmisBaseException ConvertStatusCode(int code, string message, string errorContent, Exception e)
+        {
+            object obj = null;
+            try
+            {
+                if (errorContent != null)
+                {
+                    JsonParser parser = new JsonParser();
+                    obj = parser.Parse(new StringReader(errorContent));
+                }
+            }
+            catch (JsonParseException)
+            {
+                // error content is not valid JSON -> ignore
+            }
+
+            if (obj is JsonObject)
+            {
+                JsonObject json = (JsonObject)obj;
+                object jsonError = json[BrowserConstants.ErrorException];
+                if (jsonError is string)
+                {
+                    object jsonMessage = json[BrowserConstants.ErrorMessage];
+                    if (jsonMessage != null)
+                    {
+                        message = jsonMessage.ToString();
+                    }
+
+                    if (CmisConstraintException.ExceptionName.Equals((string)jsonError, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return new CmisConstraintException(message, errorContent, e);
+                    }
+                    else if (CmisContentAlreadyExistsException.ExceptionName.Equals((string)jsonError, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return new CmisContentAlreadyExistsException(message, errorContent, e);
+                    }
+                    else if (CmisFilterNotValidException.ExceptionName.Equals((string)jsonError, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return new CmisFilterNotValidException(message, errorContent, e);
+                    }
+                    else if (CmisInvalidArgumentException.ExceptionName.Equals((string)jsonError, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return new CmisInvalidArgumentException(message, errorContent, e);
+                    }
+                    else if (CmisNameConstraintViolationException.ExceptionName.Equals((string)jsonError, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return new CmisNameConstraintViolationException(message, errorContent, e);
+                    }
+                    else if (CmisNotSupportedException.ExceptionName.Equals((string)jsonError, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return new CmisNotSupportedException(message, errorContent, e);
+                    }
+                    else if (CmisObjectNotFoundException.ExceptionName.Equals((string)jsonError, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return new CmisObjectNotFoundException(message, errorContent, e);
+                    }
+                    else if (CmisPermissionDeniedException.ExceptionName.Equals((string)jsonError, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return new CmisPermissionDeniedException(message, errorContent, e);
+                    }
+                    else if (CmisStorageException.ExceptionName.Equals((string)jsonError, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return new CmisStorageException(message, errorContent, e);
+                    }
+                    else if (CmisStreamNotSupportedException.ExceptionName.Equals((string)jsonError, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return new CmisStreamNotSupportedException(message, errorContent, e);
+                    }
+                    else if (CmisUpdateConflictException.ExceptionName.Equals((string)jsonError, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return new CmisUpdateConflictException(message, errorContent, e);
+                    }
+                    else if (CmisVersioningException.ExceptionName.Equals((string)jsonError, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return new CmisVersioningException(message, errorContent, e);
+                    }
+                    else if (code == 503)
+                    {
+                        return new CmisServiceUnavailableException(message, errorContent, e);
+                    }
+                }
+            }
+
+            // fall back to status code
+            switch (code)
+            {
+                case 301:
+                case 302:
+                case 303:
+                case 307:
+                    return new CmisConnectionException("Redirects are not supported (HTTP status code " + code + "): " + message, errorContent, e);
+                case 400:
+                    return new CmisInvalidArgumentException(message, errorContent, e);
+                case 401:
+                    return new CmisUnauthorizedException(message, errorContent, e);
+                case 403:
+                    return new CmisPermissionDeniedException(message, errorContent, e);
+                case 404:
+                    return new CmisObjectNotFoundException(message, errorContent, e);
+                case 405:
+                    return new CmisNotSupportedException(message, errorContent, e);
+                case 407:
+                    return new CmisProxyAuthenticationException(message, errorContent, e);
+                case 409:
+                    return new CmisConstraintException(message, errorContent, e);
+                case 503:
+                    return new CmisServiceUnavailableException(message, errorContent, e);
+                default:
+                    return new CmisRuntimeException(message, errorContent, e);
+            }
+        }
+
+
+        // ---- helpers ----
+
+        /// <summary>
+        /// Parses an object from an input stream.
+        /// </summary>
+        protected JsonObject ParseObject(Stream stream, string charset)
+        {
+            object obj = Parse(stream, charset);
+
+            if (obj is JsonObject)
+            {
+                return (JsonObject)obj;
+            }
+
+            throw new CmisConnectionException("Unexpected object!");
+        }
+
+        /// <summary>
+        /// Parses an array from an input stream.
+        /// </summary>
+        protected JsonArray ParseArray(Stream stream, string charset)
+        {
+            object obj = Parse(stream, charset);
+
+            if (obj is JsonArray)
+            {
+                return (JsonArray)obj;
+            }
+
+            throw new CmisConnectionException("Unexpected object!");
+        }
+
+        /// <summary>
+        /// Parses an input stream.
+        /// </summary>
+        protected object Parse(Stream stream, string charset)
+        {
+            Encoding enc;
+            if (charset == null)
+            {
+                enc = Encoding.UTF8;
+            }
+            else
+            {
+                try
+                {
+                    enc = Encoding.GetEncoding(charset);
+                }
+                catch (Exception e)
+                {
+                    throw new CmisConnectionException("Unsupported charset: " + charset, e);
+                }
+            }
+
+            StreamReader reader = null;
+
+            object obj = null;
+            try
+            {
+                reader = new StreamReader(stream, enc);
+                JsonParser parser = new JsonParser();
+                obj = parser.Parse(reader);
+            }
+            catch (Exception e)
+            {
+                throw new CmisConnectionException("Parsing exception!", e);
+            }
+            finally
+            {
+                IOUtils.ConsumeAndClose(reader);
+                if (reader == null)
+                {
+                    stream.Dispose();
+                }
+            }
+
+            return obj;
+        }
+
+        /// <summary>
+        /// Performs a GET on an URL, checks the response code and returns the
+        /// result.
+        /// </summary>
+        protected IResponse Read(UrlBuilder url)
+        {
+            // make the call
+            IResponse resp = Session.GetHttpInvoker().InvokeGET(url, session);
+
+            // check response code
+            if (resp.StatusCode != 200)
+            {
+                throw ConvertStatusCode(resp.StatusCode, resp.Message, resp.ErrorContent, null);
+            }
+
+            return resp;
+        }
+
+
+        /// <summary>
+        /// Performs a POST on an URL, checks the response code and returns the
+        /// result.
+        /// </summary>
+        protected IResponse Post(UrlBuilder url, HttpContent content)
+        {
+            // make the call
+            IResponse resp = Session.GetHttpInvoker().InvokePOST(url, content, session);
+
+            // check response code
+            if (resp.StatusCode != 200 && resp.StatusCode != 201)
+            {
+                throw ConvertStatusCode(resp.StatusCode, resp.Message, resp.ErrorContent, null);
+            }
+
+            return resp;
+        }
+
+        /// <summary>
+        /// Performs a POST on an URL, checks the response code and returns the
+        /// result.
+        /// </summary>
+        protected void PostAndConsume(UrlBuilder url, HttpContent content)
+        {
+            IResponse resp = Post(url, content);
+            IOUtils.ConsumeAndClose(resp.Stream);
+        }
+
+        // -----
+
+        protected IList<IRepositoryInfo> GetRepositoriesInternal(string repositoryId)
+        {
+            UrlBuilder url = null;
+
+            if (repositoryId == null)
+            {
+                // no repository id provided -> get all
+                url = new UrlBuilder(GetServiceUrl());
+            }
+            else
+            {
+                // use URL of the specified repository
+                url = GetRepositoryUrlCache().GetRepositoryUrl(repositoryId, BindingConstants.SelectorRepositoryInfo);
+                if (url == null)
+                {
+                    // repository infos haven't been fetched yet -> get them all
+                    url = new UrlBuilder(GetServiceUrl());
+                }
+            }
+
+            // read and parse
+            IResponse resp = Read(url);
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            IList<IRepositoryInfo> repInfos = new List<IRepositoryInfo>();
+
+            foreach (KeyValuePair<string, object> jri in json)
+            {
+                if (jri.Value is JsonObject)
+                {
+                    IRepositoryInfo ri = JsonConverter.ConvertRepositoryInfo((JsonObject)jri.Value);
+                    string id = ri.Id;
+
+                    if (ri is RepositoryInfoBrowserBinding)
+                    {
+                        string repositoryUrl = ((RepositoryInfoBrowserBinding)ri).RepositoryUrl;
+                        string rootUrl = ((RepositoryInfoBrowserBinding)ri).RootUrl;
+
+                        if (id == null || repositoryUrl == null || rootUrl == null)
+                        {
+                            throw new CmisConnectionException("Found invalid Repository Info! (id: " + id + ")");
+                        }
+
+                        GetRepositoryUrlCache().AddRepository(id, repositoryUrl, rootUrl);
+                    }
+
+                    repInfos.Add(ri);
+                }
+                else
+                {
+                    throw new CmisConnectionException("Found invalid Repository Info!");
+                }
+            }
+
+            return repInfos;
+        }
+
+        /**
+        * Retrieves a type definition.
+         */
+        public ITypeDefinition GetTypeDefinitionInternal(string repositoryId, string typeId)
+        {
+            // build URL
+            UrlBuilder url = GetRepositoryUrl(repositoryId, BindingConstants.SelectorTypeDefinition);
+            url.AddParameter(BindingConstants.ParamTypeId, typeId);
+
+            // read and parse
+            IResponse resp = Read(url);
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            return JsonConverter.ConvertTypeDefinition(json);
+        }
+    }
+
+    internal class RepositoryService : AbstractBrowserBindingService, IRepositoryService
+    {
+        public RepositoryService(BindingSession session)
+        {
+            Session = session;
+        }
+
+        public IList<IRepositoryInfo> GetRepositoryInfos(IExtensionsData extension)
+        {
+            return GetRepositoriesInternal(null);
+        }
+
+        public IRepositoryInfo GetRepositoryInfo(string repositoryId, IExtensionsData extension)
+        {
+            IList<IRepositoryInfo> repositoryInfos = GetRepositoriesInternal(repositoryId);
+
+            if (repositoryInfos.Count == 0)
+            {
+                throw new CmisObjectNotFoundException("Repository '" + repositoryId + "'not found!");
+            }
+
+            if (repositoryInfos.Count == 1)
+            {
+                return repositoryInfos[0];
+            }
+
+            // find the repository
+            foreach (IRepositoryInfo info in repositoryInfos)
+            {
+                if (info.Id == null)
+                {
+                    continue;
+                }
+
+                if (info.Id == repositoryId)
+                {
+                    return info;
+                }
+            }
+
+            throw new CmisObjectNotFoundException("Repository '" + repositoryId + "'not found!");
+        }
+
+        public ITypeDefinitionList GetTypeChildren(string repositoryId, string typeId, bool? includePropertyDefinitions,
+            BigInteger? maxItems, BigInteger? skipCount, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetRepositoryUrl(repositoryId, BindingConstants.SelectorTypeChildren);
+            url.AddParameter(BindingConstants.ParamTypeId, typeId);
+            url.AddParameter(BindingConstants.ParamPropertyDefinitions, includePropertyDefinitions);
+            url.AddParameter(BindingConstants.ParamMaxItems, maxItems);
+            url.AddParameter(BindingConstants.ParamSkipCount, skipCount);
+            url.AddParameter(BindingConstants.ParamDateTimeFormat, DateTimeFormatParameter);
+
+            // read and parse
+            IResponse resp = Read(url);
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            return JsonConverter.ConvertTypeChildren(json);
+        }
+
+        public IList<ITypeDefinitionContainer> GetTypeDescendants(string repositoryId, string typeId, BigInteger? depth,
+            bool? includePropertyDefinitions, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetRepositoryUrl(repositoryId, BindingConstants.SelectorTypeDecendants);
+            url.AddParameter(BindingConstants.ParamTypeId, typeId);
+            url.AddParameter(BindingConstants.ParamDepth, depth);
+            url.AddParameter(BindingConstants.ParamPropertyDefinitions, includePropertyDefinitions);
+            url.AddParameter(BindingConstants.ParamDateTimeFormat, DateTimeFormatParameter);
+
+            // read and parse
+            IResponse resp = Read(url);
+            JsonArray json = ParseArray(resp.Stream, resp.Charset);
+
+            return JsonConverter.ConvertTypeDescendants(json);
+        }
+
+        public ITypeDefinition GetTypeDefinition(string repositoryId, string typeId, IExtensionsData extension)
+        {
+            return GetTypeDefinitionInternal(repositoryId, typeId);
+        }
+
+
+        public ITypeDefinition CreateType(string repositoryId, ITypeDefinition type, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetRepositoryUrl(repositoryId);
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionCreateType);
+            if (type != null)
+            {
+                StringWriter sw = new StringWriter();
+                JsonConverter.Convert(type, DateTimeFormat).WriteJsonString(sw);
+
+                composer.Parameters[BindingConstants.ControlType] = sw.ToString();
+            }
+
+            // send and parse
+            IResponse resp = Post(url, composer.CreateHttpContent());
+
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            return JsonConverter.ConvertTypeDefinition(json);
+        }
+
+        public ITypeDefinition UpdateType(string repositoryId, ITypeDefinition type, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetRepositoryUrl(repositoryId);
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionUpdateType);
+            if (type != null)
+            {
+                StringWriter sw = new StringWriter();
+                JsonConverter.Convert(type, DateTimeFormat).WriteJsonString(sw);
+
+                composer.Parameters[BindingConstants.ControlType] = sw.ToString();
+            }
+
+            // send and parse
+            IResponse resp = Post(url, composer.CreateHttpContent());
+
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            return JsonConverter.ConvertTypeDefinition(json);
+        }
+
+        public void DeleteType(string repositoryId, string typeId, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetRepositoryUrl(repositoryId);
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionDeleteType);
+            composer.Parameters[BindingConstants.ControlTypeId] = typeId;
+
+            // send
+            PostAndConsume(url, composer.CreateHttpContent());
+        }
+    }
+
+    internal class NavigationService : AbstractBrowserBindingService, INavigationService
+    {
+        public NavigationService(BindingSession session)
+        {
+            Session = session;
+        }
+
+        public IObjectInFolderList GetChildren(string repositoryId, string folderId, string filter, string orderBy,
+            bool? includeAllowableActions, IncludeRelationships? includeRelationships, string renditionFilter,
+            bool? includePathSegment, BigInteger? maxItems, BigInteger? skipCount, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, folderId, BindingConstants.SelectorChildren);
+            url.AddParameter(BindingConstants.Paramfilter, filter);
+            url.AddParameter(BindingConstants.ParamOrderBy, orderBy);
+            url.AddParameter(BindingConstants.ParamAllowableActions, includeAllowableActions);
+            url.AddParameter(BindingConstants.ParamRelationships, includeRelationships);
+            url.AddParameter(BindingConstants.ParamRenditionfilter, renditionFilter);
+            url.AddParameter(BindingConstants.ParamPathSegment, includePathSegment);
+            url.AddParameter(BindingConstants.ParamMaxItems, maxItems);
+            url.AddParameter(BindingConstants.ParamSkipCount, skipCount);
+            url.AddParameter(BindingConstants.ParamSuccinct, SuccinctParameter);
+            url.AddParameter(BindingConstants.ParamDateTimeFormat, DateTimeFormatParameter);
+
+            // read and parse
+            IResponse resp = Read(url);
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            return JsonConverter.ConvertObjectInFolderList(json, typeCache);
+        }
+
+        public IList<IObjectInFolderContainer> GetDescendants(string repositoryId, string folderId, BigInteger? depth, string filter,
+            bool? includeAllowableActions, IncludeRelationships? includeRelationships, string renditionFilter,
+            bool? includePathSegment, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, folderId, BindingConstants.SelectorDecendants);
+            url.AddParameter(BindingConstants.ParamDepth, depth);
+            url.AddParameter(BindingConstants.Paramfilter, filter);
+            url.AddParameter(BindingConstants.ParamAllowableActions, includeAllowableActions);
+            url.AddParameter(BindingConstants.ParamRelationships, includeRelationships);
+            url.AddParameter(BindingConstants.ParamRenditionfilter, renditionFilter);
+            url.AddParameter(BindingConstants.ParamPathSegment, includePathSegment);
+            url.AddParameter(BindingConstants.ParamSuccinct, SuccinctParameter);
+            url.AddParameter(BindingConstants.ParamDateTimeFormat, DateTimeFormatParameter);
+
+            // read and parse
+            IResponse resp = Read(url);
+            JsonArray json = ParseArray(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            return JsonConverter.ConvertDescendants(json, typeCache);
+        }
+
+        public IList<IObjectInFolderContainer> GetFolderTree(string repositoryId, string folderId, BigInteger? depth, string filter,
+            bool? includeAllowableActions, IncludeRelationships? includeRelationships, string renditionFilter,
+            bool? includePathSegment, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, folderId, BindingConstants.SelectorFolderTree);
+            url.AddParameter(BindingConstants.ParamDepth, depth);
+            url.AddParameter(BindingConstants.Paramfilter, filter);
+            url.AddParameter(BindingConstants.ParamAllowableActions, includeAllowableActions);
+            url.AddParameter(BindingConstants.ParamRelationships, includeRelationships);
+            url.AddParameter(BindingConstants.ParamRenditionfilter, renditionFilter);
+            url.AddParameter(BindingConstants.ParamPathSegment, includePathSegment);
+            url.AddParameter(BindingConstants.ParamSuccinct, SuccinctParameter);
+            url.AddParameter(BindingConstants.ParamDateTimeFormat, DateTimeFormatParameter);
+
+            // read and parse
+            IResponse resp = Read(url);
+            JsonArray json = ParseArray(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            return JsonConverter.ConvertDescendants(json, typeCache);
+        }
+
+        public IList<IObjectParentData> GetObjectParents(string repositoryId, string objectId, string filter,
+            bool? includeAllowableActions, IncludeRelationships? includeRelationships, string renditionFilter,
+            bool? includeRelativePathSegment, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId, BindingConstants.SelectorParents);
+            url.AddParameter(BindingConstants.Paramfilter, filter);
+            url.AddParameter(BindingConstants.ParamAllowableActions, includeAllowableActions);
+            url.AddParameter(BindingConstants.ParamRelationships, includeRelationships);
+            url.AddParameter(BindingConstants.ParamRenditionfilter, renditionFilter);
+            url.AddParameter(BindingConstants.ParamRelativePathSegment, includeRelativePathSegment);
+            url.AddParameter(BindingConstants.ParamSuccinct, SuccinctParameter);
+            url.AddParameter(BindingConstants.ParamDateTimeFormat, DateTimeFormatParameter);
+
+            // read and parse
+            IResponse resp = Read(url);
+            JsonArray json = ParseArray(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            return JsonConverter.ConvertObjectParents(json, typeCache);
+        }
+
+        public IObjectData GetFolderParent(string repositoryId, string folderId, string filter, ExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, folderId, BindingConstants.SelectorParent);
+            url.AddParameter(BindingConstants.Paramfilter, filter);
+            url.AddParameter(BindingConstants.ParamSuccinct, SuccinctParameter);
+            url.AddParameter(BindingConstants.ParamDateTimeFormat, DateTimeFormatParameter);
+
+            // read and parse
+            IResponse resp = Read(url);
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            return JsonConverter.ConvertObject(json, typeCache);
+        }
+
+        public IObjectList GetCheckedOutDocs(string repositoryId, string folderId, string filter, string orderBy,
+            bool? includeAllowableActions, IncludeRelationships? includeRelationships, string renditionFilter,
+            BigInteger? maxItems, BigInteger? skipCount, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = (folderId != null ? GetObjectUrl(repositoryId, folderId, BindingConstants.SelectorCheckedout)
+                    : GetRepositoryUrl(repositoryId, BindingConstants.SelectorCheckedout));
+            url.AddParameter(BindingConstants.Paramfilter, filter);
+            url.AddParameter(BindingConstants.ParamOrderBy, orderBy);
+            url.AddParameter(BindingConstants.ParamAllowableActions, includeAllowableActions);
+            url.AddParameter(BindingConstants.ParamRelationships, includeRelationships);
+            url.AddParameter(BindingConstants.ParamRenditionfilter, renditionFilter);
+            url.AddParameter(BindingConstants.ParamMaxItems, maxItems);
+            url.AddParameter(BindingConstants.ParamSkipCount, skipCount);
+            url.AddParameter(BindingConstants.ParamSuccinct, SuccinctParameter);
+            url.AddParameter(BindingConstants.ParamDateTimeFormat, DateTimeFormatParameter);
+
+            // read and parse
+            IResponse resp = Read(url);
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            return JsonConverter.ConvertObjectList(json, typeCache, false);
+        }
+    }
+
+    internal class ObjectService : AbstractBrowserBindingService, IObjectService
+    {
+        public ObjectService(BindingSession session)
+        {
+            Session = session;
+        }
+
+        public string CreateDocument(string repositoryId, IProperties properties, string folderId, IContentStream contentStream,
+            VersioningState? versioningState, IList<string> policies, IAcl addAces, IAcl removeAces, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = (folderId != null ? GetObjectUrl(repositoryId, folderId) : GetRepositoryUrl(repositoryId));
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionCreateDocument);
+            composer.Properties = properties;
+            composer.Succinct = Succinct;
+            composer.DateTimeFormat = DateTimeFormat;
+            composer.Parameters[BindingConstants.ParamVersioningState] = versioningState;
+            composer.Policies = policies;
+            composer.AddAces = addAces;
+            composer.RemoveAces = removeAces;
+            composer.Stream = contentStream;
+
+            // send and parse
+            IResponse resp = Post(url, composer.CreateHttpContent());
+
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            IObjectData newObj = JsonConverter.ConvertObject(json, typeCache);
+
+            return (newObj == null ? null : newObj.Id);
+        }
+
+        public string CreateDocumentFromSource(string repositoryId, string sourceId, IProperties properties, string folderId,
+            VersioningState? versioningState, IList<string> policies, IAcl addAces, IAcl removeAces, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = (folderId != null ? GetObjectUrl(repositoryId, folderId) : GetRepositoryUrl(repositoryId));
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionCreateDocumentFromSource);
+            composer.Parameters[BindingConstants.ParamSourceId] = sourceId;
+            composer.Properties = properties;
+            composer.Succinct = Succinct;
+            composer.DateTimeFormat = DateTimeFormat;
+            composer.Parameters[BindingConstants.ParamVersioningState] = versioningState;
+            composer.Policies = policies;
+            composer.AddAces = addAces;
+            composer.RemoveAces = removeAces;
+
+            // send and parse
+            IResponse resp = Post(url, composer.CreateHttpContent());
+
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            IObjectData newObj = JsonConverter.ConvertObject(json, typeCache);
+
+            return (newObj == null ? null : newObj.Id);
+        }
+
+        public string CreateFolder(string repositoryId, IProperties properties, string folderId, IList<string> policies,
+            IAcl addAces, IAcl removeAces, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, folderId);
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionCreateFolder);
+            composer.Properties = properties;
+            composer.Succinct = Succinct;
+            composer.DateTimeFormat = DateTimeFormat;
+            composer.Policies = policies;
+            composer.AddAces = addAces;
+            composer.RemoveAces = removeAces;
+
+            // send and parse
+            IResponse resp = Post(url, composer.CreateHttpContent());
+
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            IObjectData newObj = JsonConverter.ConvertObject(json, typeCache);
+
+            return (newObj == null ? null : newObj.Id);
+        }
+
+        public string CreateRelationship(string repositoryId, IProperties properties, IList<string> policies, IAcl addAces,
+            IAcl removeAces, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetRepositoryUrl(repositoryId);
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionCreateRelationship);
+            composer.Properties = properties;
+            composer.Succinct = Succinct;
+            composer.DateTimeFormat = DateTimeFormat;
+            composer.Policies = policies;
+            composer.AddAces = addAces;
+            composer.RemoveAces = removeAces;
+
+            // send and parse
+            IResponse resp = Post(url, composer.CreateHttpContent());
+
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            IObjectData newObj = JsonConverter.ConvertObject(json, typeCache);
+
+            return (newObj == null ? null : newObj.Id);
+        }
+
+        public string CreatePolicy(string repositoryId, IProperties properties, string folderId, IList<string> policies,
+            IAcl addAces, IAcl removeAces, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = (folderId != null ? GetObjectUrl(repositoryId, folderId) : GetRepositoryUrl(repositoryId));
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionCreatePolicy);
+            composer.Properties = properties;
+            composer.Succinct = Succinct;
+            composer.DateTimeFormat = DateTimeFormat;
+            composer.Policies = policies;
+            composer.AddAces = addAces;
+            composer.RemoveAces = removeAces;
+
+            // send and parse
+            IResponse resp = Post(url, composer.CreateHttpContent());
+
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            IObjectData newObj = JsonConverter.ConvertObject(json, typeCache);
+
+            return (newObj == null ? null : newObj.Id);
+        }
+
+        public string CreateItem(string repositoryId, IProperties properties, string folderId, IList<string> policies,
+            IAcl addAces, IAcl removeAces, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = (folderId != null ? GetObjectUrl(repositoryId, folderId) : GetRepositoryUrl(repositoryId));
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionCreateItem);
+            composer.Properties = properties;
+            composer.Succinct = Succinct;
+            composer.DateTimeFormat = DateTimeFormat;
+            composer.Policies = policies;
+            composer.AddAces = addAces;
+            composer.RemoveAces = removeAces;
+
+            // send and parse
+            IResponse resp = Post(url, composer.CreateHttpContent());
+
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            IObjectData newObj = JsonConverter.ConvertObject(json, typeCache);
+
+            return (newObj == null ? null : newObj.Id);
+        }
+
+        public IAllowableActions GetAllowableActions(string repositoryId, string objectId, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId, BindingConstants.SelectorAllowableActionS);
+
+            // read and parse
+            IResponse resp = Read(url);
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            return JsonConverter.ConvertAllowableActions(json);
+        }
+
+        public IProperties GetProperties(string repositoryId, string objectId, string filter, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId, BindingConstants.SelectorProperties);
+            url.AddParameter(BindingConstants.Paramfilter, filter);
+            url.AddParameter(BindingConstants.ParamSuccinct, SuccinctParameter);
+            url.AddParameter(BindingConstants.ParamDateTimeFormat, DateTimeFormatParameter);
+
+            // read and parse
+            IResponse resp = Read(url);
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            if (Succinct)
+            {
+                ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+                return JsonConverter.ConvertSuccinctProperties(json, null, typeCache);
+            }
+            else
+            {
+                return JsonConverter.ConvertProperties(json, null);
+            }
+        }
+
+        public IList<IRenditionData> GetRenditions(string repositoryId, string objectId, string renditionFilter,
+            BigInteger? maxItems, BigInteger? skipCount, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId, BindingConstants.SelectorRenditions);
+            url.AddParameter(BindingConstants.ParamRenditionfilter, renditionFilter);
+            url.AddParameter(BindingConstants.ParamMaxItems, maxItems);
+            url.AddParameter(BindingConstants.ParamSkipCount, skipCount);
+
+            // read and parse
+            IResponse resp = Read(url);
+            JsonArray json = ParseArray(resp.Stream, resp.Charset);
+
+            return JsonConverter.ConvertRenditions(json);
+        }
+
+        public IObjectData GetObject(string repositoryId, string objectId, string filter, bool? includeAllowableActions,
+            IncludeRelationships? includeRelationships, string renditionFilter, bool? includePolicyIds,
+            bool? includeAcl, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId, BindingConstants.SelectorObject);
+            url.AddParameter(BindingConstants.Paramfilter, filter);
+            url.AddParameter(BindingConstants.ParamAllowableActions, includeAllowableActions);
+            url.AddParameter(BindingConstants.ParamRelationships, includeRelationships);
+            url.AddParameter(BindingConstants.ParamRenditionfilter, renditionFilter);
+            url.AddParameter(BindingConstants.ParamPolicyIds, includePolicyIds);
+            url.AddParameter(BindingConstants.ParamAcl, includeAcl);
+            url.AddParameter(BindingConstants.ParamSuccinct, SuccinctParameter);
+            url.AddParameter(BindingConstants.ParamDateTimeFormat, DateTimeFormatParameter);
+
+            // read and parse
+            IResponse resp = Read(url);
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            return JsonConverter.ConvertObject(json, typeCache);
+        }
+
+        public IObjectData GetObjectByPath(string repositoryId, string path, string filter, bool? includeAllowableActions,
+            IncludeRelationships? includeRelationships, string renditionFilter, bool? includePolicyIds, bool? includeAcl,
+            IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetPathUrl(repositoryId, path, BindingConstants.SelectorObject);
+            url.AddParameter(BindingConstants.Paramfilter, filter);
+            url.AddParameter(BindingConstants.ParamAllowableActions, includeAllowableActions);
+            url.AddParameter(BindingConstants.ParamRelationships, includeRelationships);
+            url.AddParameter(BindingConstants.ParamRenditionfilter, renditionFilter);
+            url.AddParameter(BindingConstants.ParamPolicyIds, includePolicyIds);
+            url.AddParameter(BindingConstants.ParamAcl, includeAcl);
+            url.AddParameter(BindingConstants.ParamSuccinct, SuccinctParameter);
+            url.AddParameter(BindingConstants.ParamDateTimeFormat, DateTimeFormatParameter);
+
+            // read and parse
+            IResponse resp = Read(url);
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            return JsonConverter.ConvertObject(json, typeCache);
+        }
+
+        public IContentStream GetContentStream(string repositoryId, string objectId, string streamId, BigInteger? offset, BigInteger? length,
+            IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId, BindingConstants.SelectorContent);
+            url.AddParameter(BindingConstants.ParamStreamId, streamId);
+
+            // get the content
+            IResponse resp = Session.GetHttpInvoker().InvokeGET(url, Session, (long?)offset, (long?)length);
+
+            // check response code
+            if ((resp.StatusCode != 200) && (resp.StatusCode != 206))
+            {
+                throw ConvertStatusCode(resp.StatusCode, resp.Message, resp.ErrorContent, null);
+            }
+
+            // build result object
+            ContentStream result;
+            if (resp.StatusCode == 206)
+            {
+                result = new PartialContentStream();
+            }
+            else
+            {
+                result = new ContentStream();
+            }
+
+            result.FileName = resp.Filename;
+            result.Length = resp.ContentLength;
+            result.MimeType = resp.ContentType;
+            result.Stream = resp.Stream;
+
+            return result;
+        }
+
+        public void UpdateProperties(string repositoryId, ref string objectId, ref string changeToken, IProperties properties,
+            IExtensionsData extension)
+        {
+            // we need an object ID
+            if (objectId == null || objectId.Length == 0)
+            {
+                throw new CmisInvalidArgumentException("Object ID must be set!");
+            }
+
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId);
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionUpdateProperties);
+            composer.Properties = properties;
+            composer.Succinct = Succinct;
+            composer.DateTimeFormat = DateTimeFormat;
+            composer.Parameters[BindingConstants.ParamChangeToken] =
+                (changeToken == null || Session.GetValue(SessionParameter.OmitChangeTokens, false) ? null : changeToken);
+
+            // send and parse
+            IResponse resp = Post(url, composer.CreateHttpContent());
+
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            IObjectData newObj = JsonConverter.ConvertObject(json, typeCache);
+
+            objectId = (newObj == null ? null : newObj.Id);
+
+            SetChangeToken(ref changeToken, newObj);
+        }
+
+        public IList<IBulkUpdateObjectIdAndChangeToken> BulkUpdateProperties(string repositoryId,
+                IList<IBulkUpdateObjectIdAndChangeToken> objectIdAndChangeToken, IProperties properties,
+                IList<string> addSecondaryTypeIds, IList<string> removeSecondaryTypeIds, IExtensionsData extension)
+        {
+            // we need object ids
+            if (objectIdAndChangeToken == null || objectIdAndChangeToken.Count == 0)
+            {
+                throw new CmisInvalidArgumentException("Object IDs must be set!");
+            }
+
+            // build URL
+            UrlBuilder url = GetRepositoryUrl(repositoryId);
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionBulkUpdate);
+            composer.ObjectIdsAndChangeTokens = objectIdAndChangeToken;
+            composer.Properties = properties;
+            composer.Succinct = Succinct;
+            composer.DateTimeFormat = DateTimeFormat;
+            composer.AddSecondaryTypeIds = addSecondaryTypeIds;
+            composer.RemoveSecondaryTypeIds = removeSecondaryTypeIds;
+
+            // send and parse
+            IResponse resp = Post(url, composer.CreateHttpContent());
+
+            JsonArray json = ParseArray(resp.Stream, resp.Charset);
+
+            return JsonConverter.ConvertBulkUpdate(json);
+        }
+
+        public void MoveObject(string repositoryId, ref string objectId, string targetFolderId, string sourceFolderId,
+            IExtensionsData extension)
+        {
+            // we need an object id
+            if (objectId == null || objectId.Length == 0)
+            {
+                throw new CmisInvalidArgumentException("Object ID must be set!");
+            }
+
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId);
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionMove);
+            composer.Parameters[BindingConstants.ParamTargetFolderId] = targetFolderId;
+            composer.Parameters[BindingConstants.ParamSourceFolderId] = sourceFolderId;
+            composer.Succinct = Succinct;
+            composer.DateTimeFormat = DateTimeFormat;
+
+            // send and parse
+            IResponse resp = Post(url, composer.CreateHttpContent());
+
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            IObjectData newObj = JsonConverter.ConvertObject(json, typeCache);
+
+            objectId = (newObj == null ? null : newObj.Id);
+        }
+
+        public void DeleteObject(string repositoryId, string objectId, bool? allVersions, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId);
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionDelete);
+            composer.Parameters[BindingConstants.ParamAllVersions] = allVersions;
+
+            // send
+            PostAndConsume(url, composer.CreateHttpContent());
+        }
+
+        public IFailedToDeleteData DeleteTree(string repositoryId, string folderId, bool? allVersions, UnfileObject? unfileObjects,
+            bool? continueOnFailure, ExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, folderId);
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionDeleteTree);
+            composer.Parameters[BindingConstants.ParamAllVersions] = allVersions;
+            composer.Parameters[BindingConstants.ParamUnfileObjects] = unfileObjects;
+            composer.Parameters[BindingConstants.ParamContinueOnFailure] = continueOnFailure;
+
+            // send
+            IResponse resp = Post(url, composer.CreateHttpContent());
+
+            if (resp.StatusCode == 200 && resp.ContentLength > 0 && (!resp.Stream.CanSeek || resp.Stream.Length > 0))
+            {
+                try
+                {
+                    JsonObject json = ParseObject(resp.Stream, resp.Charset);
+                    return JsonConverter.ConvertFailedToDelete(json);
+                }
+                catch (IOException e)
+                {
+                    throw new CmisConnectionException("Cannot read response!", e);
+                }
+            }
+
+            return new FailedToDeleteData();
+        }
+
+        public void SetContentStream(string repositoryId, ref string objectId, bool? overwriteFlag, ref string changeToken,
+            IContentStream contentStream, IExtensionsData extension)
+        {
+            // we need an object id
+            if (objectId == null || objectId.Length == 0)
+            {
+                throw new CmisInvalidArgumentException("Object ID must be set!");
+            }
+
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId);
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionSetContent);
+            composer.Stream = contentStream;
+            composer.Parameters[BindingConstants.ParamOverwriteFlag] = overwriteFlag;
+            composer.Succinct = Succinct;
+            composer.Parameters[BindingConstants.ParamChangeToken] =
+                (changeToken == null || Session.GetValue(SessionParameter.OmitChangeTokens, false) ? null : changeToken);
+
+
+            // send and parse
+            IResponse resp = Post(url, composer.CreateHttpContent());
+
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            IObjectData newObj = JsonConverter.ConvertObject(json, typeCache);
+
+            objectId = (newObj == null ? null : newObj.Id);
+
+            SetChangeToken(ref changeToken, newObj);
+        }
+
+        public void AppendContentStream(string repositoryId, ref string objectId, bool? isLastChunk, ref string changeToken,
+            IContentStream contentStream, IExtensionsData extension)
+        {
+            // we need an object id
+            if (objectId == null || objectId.Length == 0)
+            {
+                throw new CmisInvalidArgumentException("Object ID must be set!");
+            }
+
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId);
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionAppendContent);
+            composer.Stream = contentStream;
+            composer.Parameters[BindingConstants.ControlIsLastChunk] = isLastChunk;
+            composer.Succinct = Succinct;
+            composer.Parameters[BindingConstants.ParamChangeToken] =
+                (changeToken == null || Session.GetValue(SessionParameter.OmitChangeTokens, false) ? null : changeToken);
+
+            // send and parse
+            IResponse resp = Post(url, composer.CreateHttpContent());
+
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            IObjectData newObj = JsonConverter.ConvertObject(json, typeCache);
+
+            objectId = (newObj == null ? null : newObj.Id);
+
+            SetChangeToken(ref changeToken, newObj);
+        }
+
+        public void DeleteContentStream(string repositoryId, ref string objectId, ref string changeToken, IExtensionsData extension)
+        {
+            // we need an object id
+            if (objectId == null || objectId.Length == 0)
+            {
+                throw new CmisInvalidArgumentException("Object ID must be set!");
+            }
+
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId);
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionDeleteContent);
+            composer.Succinct = Succinct;
+            composer.Parameters[BindingConstants.ParamChangeToken] =
+                (changeToken == null || Session.GetValue(SessionParameter.OmitChangeTokens, false) ? null : changeToken);
+
+            // send and parse
+            IResponse resp = Post(url, composer.CreateHttpContent());
+
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            IObjectData newObj = JsonConverter.ConvertObject(json, typeCache);
+
+            objectId = (newObj == null ? null : newObj.Id);
+
+            SetChangeToken(ref changeToken, newObj);
+        }
+    }
+
+    internal class VersioningService : AbstractBrowserBindingService, IVersioningService
+    {
+        public VersioningService(BindingSession session)
+        {
+            Session = session;
+        }
+
+        public void CheckOut(string repositoryId, ref string objectId, IExtensionsData extension, out bool? contentCopied)
+        {
+            // we need an object id
+            if (objectId == null || objectId.Length == 0)
+            {
+                throw new CmisInvalidArgumentException("Object ID must be set!");
+            }
+
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId);
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionCheckOut);
+            composer.Succinct = Succinct;
+
+            // send and parse
+            IResponse resp = Post(url, composer.CreateHttpContent());
+
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            IObjectData newObj = JsonConverter.ConvertObject(json, typeCache);
+
+            objectId = (newObj == null ? null : newObj.Id);
+
+            contentCopied = null;
+        }
+
+        public void CancelCheckOut(string repositoryId, string objectId, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId);
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionCancelCheckOut);
+
+            // send
+            PostAndConsume(url, composer.CreateHttpContent());
+        }
+
+        public void CheckIn(string repositoryId, ref string objectId, bool? major, IProperties properties,
+            IContentStream contentStream, string checkinComment, IList<string> policies, IAcl addAces, IAcl removeAces,
+            IExtensionsData extension)
+        {
+            // we need an object id
+            if (objectId == null || objectId.Length == 0)
+            {
+                throw new CmisInvalidArgumentException("Object ID must be set!");
+            }
+
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId);
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionCheckIn);
+            composer.Stream = contentStream;
+            composer.Parameters[BindingConstants.ParamMajor] = major;
+            composer.Properties = properties;
+            composer.Succinct = Succinct;
+            composer.DateTimeFormat = DateTimeFormat;
+            composer.Parameters[BindingConstants.ParamCheckinComment] = checkinComment;
+            composer.Policies = policies;
+            composer.AddAces = addAces;
+            composer.RemoveAces = removeAces;
+
+            // send and parse
+            IResponse resp = Post(url, composer.CreateHttpContent());
+
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            IObjectData newObj = JsonConverter.ConvertObject(json, typeCache);
+
+            objectId = (newObj == null ? null : newObj.Id);
+        }
+
+        public IObjectData GetObjectOfLatestVersion(string repositoryId, string objectId, string versionSeriesId, bool major,
+            string filter, bool? includeAllowableActions, IncludeRelationships? includeRelationships,
+            string renditionFilter, bool? includePolicyIds, bool? includeAcl, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId, BindingConstants.SelectorObject);
+            url.AddParameter(BindingConstants.Paramfilter, filter);
+            url.AddParameter(BindingConstants.ParamAllowableActions, includeAllowableActions);
+            url.AddParameter(BindingConstants.ParamRelationships, includeRelationships);
+            url.AddParameter(BindingConstants.ParamRenditionfilter, renditionFilter);
+            url.AddParameter(BindingConstants.ParamPolicyIds, includePolicyIds);
+            url.AddParameter(BindingConstants.ParamAcl, includeAcl);
+            url.AddParameter(BindingConstants.ParamReturnVersion, (!major ? ReturnVersion.Latest : ReturnVersion.LatestMajor));
+            url.AddParameter(BindingConstants.ParamSuccinct, SuccinctParameter);
+            url.AddParameter(BindingConstants.ParamDateTimeFormat, DateTimeFormatParameter);
+
+            // read and parse
+            IResponse resp = Read(url);
+
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            return JsonConverter.ConvertObject(json, typeCache);
+        }
+
+        public IProperties GetPropertiesOfLatestVersion(string repositoryId, string objectId, string versionSeriesId, bool major,
+            string filter, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId, BindingConstants.SelectorProperties);
+            url.AddParameter(BindingConstants.Paramfilter, filter);
+            url.AddParameter(BindingConstants.ParamReturnVersion, (!major ? ReturnVersion.Latest : ReturnVersion.LatestMajor));
+            url.AddParameter(BindingConstants.ParamSuccinct, SuccinctParameter);
+            url.AddParameter(BindingConstants.ParamDateTimeFormat, DateTimeFormatParameter);
+
+            // read and parse
+            IResponse resp = Read(url);
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            if (Succinct)
+            {
+                ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+                return JsonConverter.ConvertSuccinctProperties(json, null, typeCache);
+            }
+            else
+            {
+                return JsonConverter.ConvertProperties(json, null);
+            }
+        }
+
+        public IList<IObjectData> GetAllVersions(string repositoryId, string objectId, string versionSeriesId, string filter,
+            bool? includeAllowableActions, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId, BindingConstants.SelectorVersions);
+            url.AddParameter(BindingConstants.Paramfilter, filter);
+            url.AddParameter(BindingConstants.ParamAllowableActions, includeAllowableActions);
+            url.AddParameter(BindingConstants.ParamSuccinct, SuccinctParameter);
+            url.AddParameter(BindingConstants.ParamDateTimeFormat, DateTimeFormatParameter);
+
+            // read and parse
+            IResponse resp = Read(url);
+
+            JsonArray json = ParseArray(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            return JsonConverter.ConvertObjects(json, typeCache);
+        }
+    }
+
+    internal class DiscoveryService : AbstractBrowserBindingService, IDiscoveryService
+    {
+        public DiscoveryService(BindingSession session)
+        {
+            Session = session;
+        }
+
+        public IObjectList Query(string repositoryId, string statement, bool? searchAllVersions,
+            bool? includeAllowableActions, IncludeRelationships? includeRelationships, string renditionFilter,
+            BigInteger? maxItems, BigInteger? skipCount, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetRepositoryUrl(repositoryId);
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionQuery);
+            composer.Parameters[BindingConstants.ParamStatement] = statement;
+            composer.Parameters[BindingConstants.ParamSearchAllVersions] = searchAllVersions;
+            composer.Parameters[BindingConstants.ParamAllowableActions] = includeAllowableActions;
+            composer.Parameters[BindingConstants.ParamRelationships] = includeRelationships;
+            composer.Parameters[BindingConstants.ParamRenditionfilter] = renditionFilter;
+            composer.Parameters[BindingConstants.ParamMaxItems] = maxItems;
+            composer.Parameters[BindingConstants.ParamSkipCount] = skipCount;
+            composer.DateTimeFormat = DateTimeFormat;
+            // Important: No succinct flag here!!!
+
+            // send and parse
+            IResponse resp = Post(url, composer.CreateHttpContent());
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+            return JsonConverter.ConvertObjectList(json, typeCache, true);
+        }
+
+        public IObjectList GetContentChanges(string repositoryId, ref string changeLogToken, bool? includeProperties,
+           string filter, bool? includePolicyIds, bool? includeAcl, BigInteger? maxItems, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetRepositoryUrl(repositoryId, BindingConstants.SelectorContentChanges);
+            url.AddParameter(BindingConstants.ParamChangeLogToken, changeLogToken);
+            url.AddParameter(BindingConstants.ParamProperties, includeProperties);
+            url.AddParameter(BindingConstants.Paramfilter, filter);
+            url.AddParameter(BindingConstants.ParamPolicyIds, includePolicyIds);
+            url.AddParameter(BindingConstants.ParamAcl, includeAcl);
+            url.AddParameter(BindingConstants.ParamMaxItems, maxItems);
+            url.AddParameter(BindingConstants.ParamSuccinct, SuccinctParameter);
+            url.AddParameter(BindingConstants.ParamDateTimeFormat, DateTimeFormatParameter);
+
+            // read and parse
+            IResponse resp = Read(url);
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            if (changeLogToken != null && json != null)
+            {
+                object token = json[BrowserConstants.JsonObjectListChangeLogToken];
+                if (token is string)
+                {
+                    changeLogToken = (string)token;
+                }
+            }
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            return JsonConverter.ConvertObjectList(json, typeCache, false);
+        }
+    }
+
+    internal class RelationshipService : AbstractBrowserBindingService, IRelationshipService
+    {
+        public RelationshipService(BindingSession session)
+        {
+            Session = session;
+        }
+
+        public IObjectList GetObjectRelationships(string repositoryId, string objectId, bool? includeSubRelationshipTypes,
+            RelationshipDirection? relationshipDirection, string typeId, string filter, bool? includeAllowableActions,
+            BigInteger? maxItems, BigInteger? skipCount, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId, BindingConstants.SelectorRelationships);
+            url.AddParameter(BindingConstants.ParamSubRelationshipTypes, includeSubRelationshipTypes);
+            url.AddParameter(BindingConstants.ParamRelationshipDirection, relationshipDirection);
+            url.AddParameter(BindingConstants.ParamTypeId, typeId);
+            url.AddParameter(BindingConstants.Paramfilter, filter);
+            url.AddParameter(BindingConstants.ParamAllowableActions, includeAllowableActions);
+            url.AddParameter(BindingConstants.ParamMaxItems, maxItems);
+            url.AddParameter(BindingConstants.ParamSkipCount, skipCount);
+            url.AddParameter(BindingConstants.ParamSuccinct, SuccinctParameter);
+            url.AddParameter(BindingConstants.ParamDateTimeFormat, DateTimeFormatParameter);
+
+            // read and parse
+            IResponse resp = Read(url);
+            JsonObject json = ParseObject(resp.Stream, resp.Charset);
+
+            ITypeCache typeCache = new ClientTypeCache(repositoryId, this);
+
+            return JsonConverter.ConvertObjectList(json, typeCache, false);
+        }
+    }
+
+    internal class MultiFilingService : AbstractBrowserBindingService, IMultiFilingService
+    {
+        public MultiFilingService(BindingSession session)
+        {
+            Session = session;
+        }
+
+        public void AddObjectToFolder(string repositoryId, string objectId, string folderId, bool? allVersions, IExtensionsData extension)
+        {
+            // build URL
+            UrlBuilder url = GetObjectUrl(repositoryId, objectId);
+
+            // prepare form data
+            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionRemoveObjectToFolder);
+            composer.Parameters[BindingConstants.ParamFolderId] = folderId;
+            composer.Parameters[BindingConstants.ParamAllVersions] = allVersions;
+
+            // send
+            PostAndConsume(url, composer.CreateHttpContent());
+        }
+
+        public void RemoveObjectFromFolder(string repositoryId, string objectId, string folderId, IExtensionsData extension)
+        {
+            // build URL

[... 104 lines stripped ...]