PortCMIS/binding/browser/BrowserBinding.cs

/*
* 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.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.Net.Http;
using System.Net.Http.Headers;
using System.Numerics;
using System.Text;

namespace PortCMIS.Binding.Browser
{
    /// <summary>
    /// Extended Repository Info for the Browser Binding.
    /// </summary>
    public class RepositoryInfoBrowserBinding : RepositoryInfo
    {
        /// <value>
        /// The base repository URL for non-object related calls.
        /// </value>
        public string RepositoryUrl { get; set; }

        /// <value>
        /// The base root URL for object related calls.
        /// </value>
        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;

        /// <inheritdoc/>
        public void Initialize(IBindingSession session)
        {
            this.session = session as BindingSession;
            if (this.session == null)
            {
                throw new ArgumentException("Invalid 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);
        }

        /// <inheritdoc/>
        public IRepositoryService GetRepositoryService()
        {
            return repositoryService;
        }

        /// <inheritdoc/>
        public INavigationService GetNavigationService()
        {
            return navigationService;
        }

        /// <inheritdoc/>
        public IObjectService GetObjectService()
        {
            return objectService;
        }

        /// <inheritdoc/>
        public IVersioningService GetVersioningService()
        {
            return versioningService;
        }

        /// <inheritdoc/>
        public IRelationshipService GetRelationshipService()
        {
            return relationshipService;
        }

        /// <inheritdoc/>
        public IDiscoveryService GetDiscoveryService()
        {
            return discoveryService;
        }

        /// <inheritdoc/>
        public IMultiFilingService GetMultiFilingService()
        {
            return multiFilingService;
        }

        /// <inheritdoc/>
        public IAclService GetAclService()
        {
            return aclService;
        }

        /// <inheritdoc/>
        public IPolicyService GetPolicyService()
        {
            return policyService;
        }

        /// <inheritdoc/>
        public void ClearAllCaches()
        {
            session.RemoveValue(RepositoryUrlCache);
        }

        /// <inheritdoc/>
        public void ClearRepositoryCache(string repositoryId)
        {
            RepositoryUrlCache repUrlCache = session.GetValue(RepositoryUrlCache) as RepositoryUrlCache;
            if (repUrlCache != null)
            {
                repUrlCache.RemoveRepository(repositoryId);
            }
        }

        /// <inheritdoc/>
        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();

            try
            {
                IList<KeyValuePair<string, string>> mpfParameters = CreateContent();
                foreach (KeyValuePair<string, string> p in mpfParameters)
                {
                    content.Add(new StringContent(p.Value, Encoding.UTF8), p.Key);
                }

                if (Stream.Stream != null)
                {
                    StreamContent streamContent = new StreamContent(Stream.Stream);
                    streamContent.Headers.ContentType = MediaTypeHeaderValue.Parse(Stream.MimeType ?? "application/octet-stream");

                    content.Add(streamContent, "content", Stream.FileName ?? "content");
                }

                return content;
            } catch
            {
                content.Dispose();
                throw;
            }
        }

        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.ControlAddAcePermission, 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 (string.IsNullOrEmpty(typeId))
                {
                    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 string)
            {
                return (string)value;
            }
            else if (value is DateTime)
            {
                if (DateTimeFormat == DateTimeFormat.Extended)
                {
                    return DateTimeHelper.FormatISO8601((DateTime)value);
                }
                else
                {
                    return DateTimeHelper.ConvertDateTimeToMillis((DateTime)value).ToString(CultureInfo.InvariantCulture);
                }
            }
            else if (value is decimal)
            {
                return ((decimal)value).ToString("g", CultureInfo.InvariantCulture);
            }
            else if (value is BigInteger)
            {
                return ((BigInteger)value).ToString("0", CultureInfo.InvariantCulture);
            }
            else if (value is Boolean)
            {
                return (Boolean)value ? "true" : "false";
            }
            else if (value is Double)
            {
                if (Double.IsInfinity((Double)value) || Double.IsNaN((Double)value))
                {
                    return "null";
                }
                else
                {
                    return ((Double)value).ToString("g", CultureInfo.InvariantCulture);
                }
            }
            else if (value is Single)
            {
                if (Single.IsInfinity((Single)value) || Single.IsNaN((Single)value))
                {
                    return "null";
                }
                else
                {
                    return ((Single)value).ToString("g", CultureInfo.InvariantCulture);
                }
            }
            else
            {
                try
                {
                    return Convert.ToInt64(value, CultureInfo.InvariantCulture).ToString("0", CultureInfo.InvariantCulture);
                }
                catch
                {
                    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, CultureInfo.InvariantCulture);
                }

                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();
                    StringReader sr = new StringReader(errorContent);
                    try
                    {
                        obj = parser.Parse(sr);
                    }
                    finally
                    {
                        sr.Dispose();
                    }
                }
            }
            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;
        }

        /// <summary>
        /// Retrieves a type definition.
        /// </summary>
        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(CultureInfo.InvariantCulture);
                try
                {
                    JsonConverter.Convert(type, DateTimeFormat).WriteJsonString(sw);
                    composer.Parameters[BindingConstants.ControlType] = sw.ToString();
                }
                finally
                {
                    sw.Dispose();
                }
            }

            // 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(CultureInfo.InvariantCulture);
                try
                {
                    JsonConverter.Convert(type, DateTimeFormat).WriteJsonString(sw);
                    composer.Parameters[BindingConstants.ControlType] = sw.ToString();
                }
                finally
                {
                    sw.Dispose();
                }
            }

            // 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, IExtensionsData 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?.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?.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?.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?.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?.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?.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 (string.IsNullOrEmpty(objectId))
            {
                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?.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 (string.IsNullOrEmpty(objectId))
            {
                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?.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, IExtensionsData 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 (string.IsNullOrEmpty(objectId))
            {
                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?.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 (string.IsNullOrEmpty(objectId))
            {
                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?.Id;

            SetChangeToken(ref changeToken, newObj);
        }

        public void DeleteContentStream(string repositoryId, ref string objectId, ref string changeToken, IExtensionsData extension)
        {
            // we need an object id
            if (string.IsNullOrEmpty(objectId))
            {
                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?.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 (string.IsNullOrEmpty(objectId))
            {
                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?.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 (string.IsNullOrEmpty(objectId))
            {
                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?.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 == true ? ReturnVersion.LatestMajor : ReturnVersion.Latest));
            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 == true ? ReturnVersion.LatestMajor : ReturnVersion.Latest));
            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
            UrlBuilder url = GetObjectUrl(repositoryId, objectId);

            // prepare form data
            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionRemoveObjectFromFolder);
            composer.Parameters[BindingConstants.ParamFolderId] = folderId;

            // send
            PostAndConsume(url, composer.CreateHttpContent());
        }
    }

    internal class PolicyService : AbstractBrowserBindingService, IPolicyService
    {
        public PolicyService(BindingSession session)
        {
            Session = session;
        }

        public void ApplyPolicy(string repositoryId, string policyId, string objectId, IExtensionsData extension)
        {
            // build URL
            UrlBuilder url = GetObjectUrl(repositoryId, objectId);

            // prepare form data
            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionApplyPolicy);
            composer.PolicyId = policyId;

            // send
            PostAndConsume(url, composer.CreateHttpContent());
        }

        public void RemovePolicy(string repositoryId, string policyId, string objectId, IExtensionsData extension)
        {
            // build URL
            UrlBuilder url = GetObjectUrl(repositoryId, objectId);

            // prepare form data
            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionRemovePolicy);
            composer.PolicyId = policyId;

            // send
            PostAndConsume(url, composer.CreateHttpContent());
        }

        public IList<IObjectData> GetAppliedPolicies(string repositoryId, string objectId, string filter, IExtensionsData extension)
        {
            // build URL
            UrlBuilder url = GetObjectUrl(repositoryId, objectId, BindingConstants.SelectorPolicies);
            url.AddParameter(BindingConstants.ParamFilter, filter);
            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 AclService : AbstractBrowserBindingService, IAclService
    {
        public AclService(BindingSession session)
        {
            Session = session;
        }

        public IAcl GetAcl(string repositoryId, string objectId, bool? onlyBasicPermissions, IExtensionsData extension)
        {
            // build URL
            UrlBuilder url = GetObjectUrl(repositoryId, objectId, BindingConstants.SelectorAcl);
            url.AddParameter(BindingConstants.ParamOnlyBasicPermissions, onlyBasicPermissions);

            // read and parse
            IResponse resp = Read(url);
            JsonObject json = ParseObject(resp.Stream, resp.Charset);

            return JsonConverter.ConvertAcl(json);
        }

        public IAcl ApplyAcl(string repositoryId, string objectId, IAcl addAces, IAcl removeAces, AclPropagation? aclPropagation,
            IExtensionsData extension)
        {
            // build URL
            UrlBuilder url = GetObjectUrl(repositoryId, objectId);

            // prepare form data
            FormDataComposer composer = new FormDataComposer(BindingConstants.CmisActionApplyAcl);
            composer.AddAces = addAces;
            composer.RemoveAces = removeAces;
            composer.Parameters[BindingConstants.ParamAclPropagation] = aclPropagation;

            // send and parse
            IResponse resp = Post(url, composer.CreateHttpContent());
            JsonObject json = ParseObject(resp.Stream, resp.Charset);

            return JsonConverter.ConvertAcl(json);
        }
    }
}