| /* | |
| * 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.AtomPub; | |
| using PortCMIS.Client.Impl; | |
| using PortCMIS.Data; | |
| using PortCMIS.Data.Extensions; | |
| using PortCMIS.Enums; | |
| using PortCMIS.Exceptions; | |
| using PortCMIS.Utils; | |
| using System; | |
| using System.Collections.Generic; | |
| using System.Linq; | |
| using System.Numerics; | |
| using System.Text; | |
| using System.Threading.Tasks; | |
| using System.Xml; | |
| namespace PortCMIS.Binding.AtomPub | |
| { | |
| class XmlConverter | |
| { | |
| // --------------- | |
| // --- writers --- | |
| // --------------- | |
| public static void writeRepositoryInfo(XmlWriter writer, CmisVersion cmisVersion, string ns, IRepositoryInfo source) | |
| { | |
| if (source == null) | |
| { | |
| return; | |
| } | |
| writer.WriteStartElement(XmlConstants.TAG_REPOSITORY_INFO, ns); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_REPINFO_ID, source.Id); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_REPINFO_NAME, source.Name); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_REPINFO_DESCRIPTION, source.Description); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_REPINFO_VENDOR, source.VendorName); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_REPINFO_PRODUCT, source.ProductName); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_REPINFO_PRODUCT_VERSION, source.ProductVersion); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_REPINFO_ROOT_FOLDER_ID, source.RootFolderId); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_REPINFO_CHANGE_LOG_TOKEN, source.LatestChangeLogToken); | |
| writeRepositoryCapabilities(writer, cmisVersion, source.Capabilities); | |
| writeAclCapabilities(writer, cmisVersion, source.AclCapabilities); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_REPINFO_CMIS_VERSION_SUPPORTED, source.CmisVersionSupported); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_REPINFO_THIN_CLIENT_URI, source.ThinClientUri); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_REPINFO_CHANGES_INCOMPLETE, source.ChangesIncomplete); | |
| if (source.ChangesOnType != null) | |
| { | |
| foreach (BaseTypeId baseType in source.ChangesOnType) | |
| { | |
| if (cmisVersion == CmisVersion.Cmis_1_0 && baseType == BaseTypeId.CmisItem) | |
| { | |
| Logger.Warn("Receiver only understands CMIS 1.0 but the Changes On Type list in the Repository info contains the base type Item. " | |
| + "The Item base type has been removed from the list."); | |
| continue; | |
| } | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_REPINFO_CHANGES_ON_TYPE, baseType); | |
| } | |
| } | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_REPINFO_PRINCIPAL_ID_ANONYMOUS, source.PrincipalIdAnonymous); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_REPINFO_PRINCIPAL_ID_ANYONE, source.PrincipalIdAnyone); | |
| if (cmisVersion != CmisVersion.Cmis_1_0 && source.ExtensionFeatures != null) | |
| { | |
| foreach (ExtensionFeature feature in source.ExtensionFeatures) | |
| { | |
| writeExtendedFeatures(writer, cmisVersion, feature); | |
| } | |
| } | |
| writeExtensions(writer, source); | |
| writer.WriteEndElement(); | |
| } | |
| public static void writeRepositoryCapabilities(XmlWriter writer, CmisVersion cmisVersion, IRepositoryCapabilities source) | |
| { | |
| if (source == null) | |
| { | |
| return; | |
| } | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_REPINFO_CAPABILITIES, XmlConstants.NAMESPACE_CMIS); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_ACL, source.AclCapability); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_ALL_VERSIONS_SEARCHABLE, source.IsAllVersionsSearchableSupported); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_CHANGES, source.ChangesCapability); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_CONTENT_STREAM_UPDATABILITY, source.ContentStreamUpdatesCapability); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_GET_DESCENDANTS, source.IsGetDescendantsSupported); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_GET_FOLDER_TREE, source.IsGetFolderTreeSupported); | |
| if (cmisVersion != CmisVersion.Cmis_1_0) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_ORDER_BY, source.OrderByCapability); | |
| } | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_MULTIFILING, source.IsMultifilingSupported); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_PWC_SEARCHABLE, source.IsPwcSearchableSupported); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_PWC_UPDATABLE, source.IsPwcUpdatableSupported); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_QUERY, source.QueryCapability); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_RENDITIONS, source.RenditionsCapability); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_UNFILING, source.IsUnfilingSupported); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_VERSION_SPECIFIC_FILING, source.IsVersionSpecificFilingSupported); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_JOIN, source.JoinCapability); | |
| if (cmisVersion != CmisVersion.Cmis_1_0) | |
| { | |
| if (source.CreatablePropertyTypes != null) | |
| { | |
| ICreatablePropertyTypes creatablePropertyTypes = source.CreatablePropertyTypes; | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_CAP_CREATABLE_PROPERTY_TYPES, XmlConstants.NAMESPACE_CMIS); | |
| if (creatablePropertyTypes.CanCreate != null) | |
| { | |
| foreach (PropertyType pt in creatablePropertyTypes.CanCreate) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_CREATABLE_PROPERTY_TYPES_CANCREATE, | |
| pt); | |
| } | |
| } | |
| writeExtensions(writer, creatablePropertyTypes); | |
| writer.WriteEndElement(); | |
| } | |
| if (source.NewTypeSettableAttributes != null) | |
| { | |
| INewTypeSettableAttributes newTypeSettableAttributes = source.NewTypeSettableAttributes; | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES, XmlConstants.NAMESPACE_CMIS); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_ID, | |
| newTypeSettableAttributes.CanSetId); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_LOCALNAME, | |
| newTypeSettableAttributes.CanSetLocalName); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, | |
| XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_LOCALNAMESPACE, | |
| newTypeSettableAttributes.CanSetLocalNamespace); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_DISPLAYNAME, | |
| newTypeSettableAttributes.CanSetDisplayName); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_QUERYNAME, | |
| newTypeSettableAttributes.CanSetQueryName); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_DESCRIPTION, | |
| newTypeSettableAttributes.CanSetDescription); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_CREATEABLE, | |
| newTypeSettableAttributes.CanSetCreatable); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_FILEABLE, | |
| newTypeSettableAttributes.CanSetFileable); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_QUERYABLE, | |
| newTypeSettableAttributes.CanSetQueryable); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, | |
| XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_FULLTEXTINDEXED, | |
| newTypeSettableAttributes.CanSetFulltextIndexed); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, | |
| XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_INCLUDEDINSUPERTYTPEQUERY, | |
| newTypeSettableAttributes.CanSetIncludedInSupertypeQuery); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, | |
| XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_CONTROLABLEPOLICY, | |
| newTypeSettableAttributes.CanSetControllablePolicy); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, | |
| XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_CONTROLABLEACL, | |
| newTypeSettableAttributes.CanSetControllableAcl); | |
| writeExtensions(writer, newTypeSettableAttributes); | |
| writer.WriteEndElement(); | |
| } | |
| } | |
| writeExtensions(writer, source); | |
| writer.WriteEndElement(); | |
| } | |
| public static void writeAclCapabilities(XmlWriter writer, CmisVersion cmisVersion, IAclCapabilities source) | |
| { | |
| if (source == null) | |
| { | |
| return; | |
| } | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_REPINFO_ACL_CAPABILITIES, XmlConstants.NAMESPACE_CMIS); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_ACLCAP_SUPPORTED_PERMISSIONS, source.SupportedPermissions); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_ACLCAP_ACL_PROPAGATION, source.AclPropagation); | |
| if (source.Permissions != null) | |
| { | |
| foreach (IPermissionDefinition pd in source.Permissions) | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_ACLCAP_PERMISSIONS, XmlConstants.NAMESPACE_CMIS); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_ACLCAP_PERMISSION_PERMISSION, pd.Id); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_ACLCAP_PERMISSION_DESCRIPTION, pd.Description); | |
| writeExtensions(writer, pd); | |
| writer.WriteEndElement(); | |
| } | |
| } | |
| if (source.PermissionMapping != null) | |
| { | |
| foreach (IPermissionMapping pm in source.PermissionMapping.Values) | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_ACLCAP_PERMISSION_MAPPING, XmlConstants.NAMESPACE_CMIS); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_ACLCAP_MAPPING_KEY, pm.Key); | |
| if (pm.Permissions != null) | |
| { | |
| foreach (String perm in pm.Permissions) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_ACLCAP_MAPPING_PERMISSION, perm); | |
| } | |
| } | |
| writeExtensions(writer, pm); | |
| writer.WriteEndElement(); | |
| } | |
| } | |
| writeExtensions(writer, source); | |
| writer.WriteEndElement(); | |
| } | |
| public static void writeExtendedFeatures(XmlWriter writer, CmisVersion cmisVersion, ExtensionFeature source) | |
| { | |
| if (source == null) | |
| { | |
| return; | |
| } | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_REPINFO_EXTENDED_FEATURES, XmlConstants.NAMESPACE_CMIS); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_FEATURE_ID, source.Id); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_FEATURE_URL, source.Url); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_FEATURE_COMMON_NAME, source.CommonName); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_FEATURE_VERSION_LABEL, source.VersionLabel); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_FEATURE_DESCRIPTION, source.Description); | |
| if (source.FeatureData != null) | |
| { | |
| foreach (KeyValuePair<string, string> data in source.FeatureData) | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_FEATURE_DATA, XmlConstants.NAMESPACE_CMIS); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_FEATURE_DATA_KEY, data.Key); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_FEATURE_DATA_VALUE, data.Value); | |
| writer.WriteEndElement(); | |
| } | |
| } | |
| writeExtensions(writer, source); | |
| writer.WriteEndElement(); | |
| } | |
| // -------------------------- | |
| // --- definition writers --- | |
| // -------------------------- | |
| public static void writeTypeDefinition(XmlWriter writer, CmisVersion cmisVersion, string ns, ITypeDefinition source) | |
| { | |
| if (source == null) | |
| { | |
| return; | |
| } | |
| if (cmisVersion == CmisVersion.Cmis_1_0) | |
| { | |
| if (source.BaseTypeId == BaseTypeId.CmisItem) | |
| { | |
| Logger.Warn("Receiver only understands CMIS 1.0. It may not able to handle an Item type definition."); | |
| } | |
| else if (source.BaseTypeId == BaseTypeId.CmisSecondary) | |
| { | |
| Logger.Warn("Receiver only understands CMIS 1.0. It may not able to handle a Secondary type definition."); | |
| } | |
| } | |
| writer.WriteStartElement(XmlConstants.TAG_TYPE, ns); | |
| writer.WriteAttributeString("xmlns", XmlConstants.PREFIX_XSI, null, XmlConstants.NAMESPACE_XSI); | |
| string prefix = writer.LookupPrefix(ns); | |
| if (prefix != null) | |
| { | |
| writer.WriteAttributeString("xmlns", prefix, null, ns); | |
| } | |
| if (source.BaseTypeId == BaseTypeId.CmisDocument) | |
| { | |
| writer.WriteAttributeString(XmlConstants.PREFIX_XSI, "type", XmlConstants.NAMESPACE_XSI, XmlConstants.PREFIX_CMIS + ":" + XmlConstants.ATTR_DOCUMENT_TYPE); | |
| } | |
| else if (source.BaseTypeId == BaseTypeId.CmisFolder) | |
| { | |
| writer.WriteAttributeString(XmlConstants.PREFIX_XSI, "type", XmlConstants.NAMESPACE_XSI, XmlConstants.PREFIX_CMIS + ":" + XmlConstants.ATTR_FOLDER_TYPE); | |
| } | |
| else if (source.BaseTypeId == BaseTypeId.CmisRelationship) | |
| { | |
| writer.WriteAttributeString(XmlConstants.PREFIX_XSI, "type", XmlConstants.NAMESPACE_XSI, XmlConstants.PREFIX_CMIS + ":" + XmlConstants.ATTR_RELATIONSHIP_TYPE); | |
| } | |
| else if (source.BaseTypeId == BaseTypeId.CmisPolicy) | |
| { | |
| writer.WriteAttributeString(XmlConstants.PREFIX_XSI, "type", XmlConstants.NAMESPACE_XSI, XmlConstants.PREFIX_CMIS + ":" + XmlConstants.ATTR_POLICY_TYPE); | |
| } | |
| else if (source.BaseTypeId == BaseTypeId.CmisItem) | |
| { | |
| writer.WriteAttributeString(XmlConstants.PREFIX_XSI, "type", XmlConstants.NAMESPACE_XSI, XmlConstants.PREFIX_CMIS + ":" + XmlConstants.ATTR_ITEM_TYPE); | |
| } | |
| else if (source.BaseTypeId == BaseTypeId.CmisSecondary) | |
| { | |
| writer.WriteAttributeString(XmlConstants.PREFIX_XSI, "type", XmlConstants.NAMESPACE_XSI, XmlConstants.PREFIX_CMIS + ":" + XmlConstants.ATTR_SECONDARY_TYPE); | |
| } | |
| else | |
| { | |
| throw new CmisRuntimeException("Type definition has no base type id!"); | |
| } | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_ID, source.Id); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_LOCALNAME, source.LocalName); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_LOCALNAMESPACE, source.LocalNamespace); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_DISPLAYNAME, source.DisplayName); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_QUERYNAME, source.QueryName); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_DESCRIPTION, source.Description); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_BASE_ID, source.BaseTypeId); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_PARENT_ID, source.ParentTypeId); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_CREATABLE, source.IsCreatable); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_FILEABLE, source.IsFileable); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_QUERYABLE, source.IsQueryable); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_FULLTEXT_INDEXED, source.IsFulltextIndexed); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_INCLUDE_IN_SUPERTYPE_QUERY, source.IsIncludedInSupertypeQuery); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_CONTROLABLE_POLICY, source.IsControllablePolicy); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_CONTROLABLE_ACL, source.IsControllableAcl); | |
| if (cmisVersion != CmisVersion.Cmis_1_0 && source.TypeMutability != null) | |
| { | |
| ITypeMutability tm = source.TypeMutability; | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_TYPE_TYPE_MUTABILITY, XmlConstants.NAMESPACE_CMIS); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_TYPE_MUTABILITY_CREATE, tm.CanCreate); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_TYPE_MUTABILITY_UPDATE, tm.CanUpdate); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_TYPE_MUTABILITY_DELETE, tm.CanDelete); | |
| writeExtensions(writer, tm); | |
| writer.WriteEndElement(); | |
| } | |
| if (source.PropertyDefinitions != null) | |
| { | |
| foreach (IPropertyDefinition pd in source.PropertyDefinitions) | |
| { | |
| writePropertyDefinition(writer, cmisVersion, pd); | |
| } | |
| } | |
| if (source is DocumentTypeDefinition) | |
| { | |
| DocumentTypeDefinition docDef = (DocumentTypeDefinition)source; | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_VERSIONABLE, docDef.IsVersionable); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_CONTENTSTREAM_ALLOWED, docDef.ContentStreamAllowed); | |
| } | |
| if (source is RelationshipTypeDefinition) | |
| { | |
| RelationshipTypeDefinition relDef = (RelationshipTypeDefinition)source; | |
| if (relDef.AllowedSourceTypeIds != null) | |
| { | |
| foreach (String id in relDef.AllowedSourceTypeIds) | |
| { | |
| if (id != null) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_ALLOWED_SOURCE_TYPES, id); | |
| } | |
| } | |
| } | |
| if (relDef.AllowedTargetTypeIds != null) | |
| { | |
| foreach (String id in relDef.AllowedTargetTypeIds) | |
| { | |
| if (id != null) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_TYPE_ALLOWED_TARGET_TYPES, id); | |
| } | |
| } | |
| } | |
| } | |
| writeExtensions(writer, source); | |
| writer.WriteEndElement(); | |
| } | |
| public static void writePropertyDefinition(XmlWriter writer, CmisVersion cmisVersion, IPropertyDefinition source) | |
| { | |
| if (source == null) | |
| { | |
| return; | |
| } | |
| //if (source.PropertyType == null) | |
| //{ | |
| // throw new CmisRuntimeException("Property type for property definition '" + source.Id + "' is not set!"); | |
| //} | |
| switch (source.PropertyType) | |
| { | |
| case PropertyType.String: | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_TYPE_PROP_DEF_STRING, XmlConstants.NAMESPACE_CMIS); | |
| break; | |
| case PropertyType.Id: | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_TYPE_PROP_DEF_ID, XmlConstants.NAMESPACE_CMIS); | |
| break; | |
| case PropertyType.Integer: | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_TYPE_PROP_DEF_INTEGER, XmlConstants.NAMESPACE_CMIS); | |
| break; | |
| case PropertyType.Boolean: | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_TYPE_PROP_DEF_BOOLEAN, XmlConstants.NAMESPACE_CMIS); | |
| break; | |
| case PropertyType.DateTime: | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_TYPE_PROP_DEF_DATETIME, XmlConstants.NAMESPACE_CMIS); | |
| break; | |
| case PropertyType.Decimal: | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_TYPE_PROP_DEF_DECIMAL, XmlConstants.NAMESPACE_CMIS); | |
| break; | |
| case PropertyType.Html: | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_TYPE_PROP_DEF_HTML, XmlConstants.NAMESPACE_CMIS); | |
| break; | |
| case PropertyType.Uri: | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_TYPE_PROP_DEF_URI, XmlConstants.NAMESPACE_CMIS); | |
| break; | |
| default: | |
| throw new CmisRuntimeException("Property definition has no property type!"); | |
| } | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_ID, source.Id); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_LOCALNAME, source.LocalName); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_LOCALNAMESPACE, source.LocalNamespace); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_DISPLAYNAME, source.DisplayName); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_QUERYNAME, source.QueryName); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_DESCRIPTION, source.Description); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_PROPERTY_TYPE, source.PropertyType); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_CARDINALITY, source.Cardinality); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_UPDATABILITY, source.Updatability); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_INHERITED, source.IsInherited); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_REQUIRED, source.IsRequired); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_QUERYABLE, source.IsQueryable); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_ORDERABLE, source.IsOrderable); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_OPENCHOICE, source.IsOpenChoice); | |
| if (source is IPropertyStringDefinition) | |
| { | |
| IPropertyStringDefinition def = (IPropertyStringDefinition)source; | |
| if (def.DefaultValue != null) | |
| { | |
| PropertyData prop = new PropertyData(PropertyType.String); | |
| prop.AddValue(def.DefaultValue); | |
| writeProperty(writer, prop, true); | |
| } | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_MAX_LENGTH, def.MaxLength); | |
| if (def.Choices != null) | |
| { | |
| foreach (IChoice<string> c in def.Choices) | |
| { | |
| if (c != null) | |
| { | |
| writeChoice<string>(writer, source.PropertyType, c); | |
| } | |
| } | |
| } | |
| } | |
| else if (source is IPropertyIdDefinition) | |
| { | |
| IPropertyIdDefinition def = (IPropertyIdDefinition)source; | |
| if (def.DefaultValue != null) | |
| { | |
| PropertyData prop = new PropertyData(PropertyType.Id); | |
| prop.AddValue(def.DefaultValue); | |
| writeProperty(writer, prop, true); | |
| } | |
| if (def.Choices != null) | |
| { | |
| foreach (IChoice<string> c in def.Choices) | |
| { | |
| if (c != null) | |
| { | |
| writeChoice<string>(writer, source.PropertyType, c); | |
| } | |
| } | |
| } | |
| } | |
| else if (source is IPropertyIntegerDefinition) | |
| { | |
| IPropertyIntegerDefinition def = (IPropertyIntegerDefinition)source; | |
| if (def.DefaultValue != null) | |
| { | |
| PropertyData prop = new PropertyData(PropertyType.Integer); | |
| prop.AddValue(def.DefaultValue); | |
| writeProperty(writer, prop, true); | |
| } | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_MAX_VALUE, def.MaxValue); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_MIN_VALUE, def.MinValue); | |
| if (def.Choices != null) | |
| { | |
| foreach (IChoice<BigInteger> c in def.Choices) | |
| { | |
| if (c != null) | |
| { | |
| writeChoice<BigInteger>(writer, source.PropertyType, c); | |
| } | |
| } | |
| } | |
| } | |
| else if (source is IPropertyBooleanDefinition) | |
| { | |
| IPropertyBooleanDefinition def = (IPropertyBooleanDefinition)source; | |
| if (def.DefaultValue != null) | |
| { | |
| PropertyData prop = new PropertyData(PropertyType.Boolean); | |
| prop.AddValue(def.DefaultValue); | |
| writeProperty(writer, prop, true); | |
| } | |
| if (def.Choices != null) | |
| { | |
| foreach (IChoice<bool> c in def.Choices) | |
| { | |
| if (c != null) | |
| { | |
| writeChoice<bool>(writer, source.PropertyType, c); | |
| } | |
| } | |
| } | |
| } | |
| else if (source is PropertyDateTimeDefinition) | |
| { | |
| IPropertyDateTimeDefinition def = (IPropertyDateTimeDefinition)source; | |
| if (def.DefaultValue != null) | |
| { | |
| PropertyData prop = new PropertyData(PropertyType.DateTime); | |
| prop.AddValue(def.DefaultValue); | |
| writeProperty(writer, prop, true); | |
| } | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_RESOLUTION, def.DateTimeResolution); | |
| if (def.Choices != null) | |
| { | |
| foreach (IChoice<DateTime> c in def.Choices) | |
| { | |
| if (c != null) | |
| { | |
| writeChoice<DateTime>(writer, source.PropertyType, c); | |
| } | |
| } | |
| } | |
| } | |
| else if (source is IPropertyDecimalDefinition) | |
| { | |
| IPropertyDecimalDefinition def = (IPropertyDecimalDefinition)source; | |
| if (def.DefaultValue != null) | |
| { | |
| PropertyData prop = new PropertyData(PropertyType.Decimal); | |
| prop.AddValue(def.DefaultValue); | |
| writeProperty(writer, prop, true); | |
| } | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_MAX_VALUE, def.MaxValue); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_MIN_VALUE, def.MinValue); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_PRECISION, def.Precision); | |
| if (def.Choices != null) | |
| { | |
| foreach (IChoice<decimal?> c in def.Choices) | |
| { | |
| if (c != null) | |
| { | |
| writeChoice<decimal?>(writer, source.PropertyType, c); | |
| } | |
| } | |
| } | |
| } | |
| else if (source is IPropertyHtmlDefinition) | |
| { | |
| IPropertyHtmlDefinition def = (IPropertyHtmlDefinition)source; | |
| if (def.DefaultValue != null) | |
| { | |
| PropertyData prop = new PropertyData(PropertyType.Html); | |
| prop.AddValue(def.DefaultValue); | |
| writeProperty(writer, prop, true); | |
| } | |
| if (def.Choices != null) | |
| { | |
| foreach (IChoice<string> c in def.Choices) | |
| { | |
| if (c != null) | |
| { | |
| writeChoice<string>(writer, source.PropertyType, c); | |
| } | |
| } | |
| } | |
| } | |
| else if (source is IPropertyUriDefinition) | |
| { | |
| IPropertyUriDefinition def = (IPropertyUriDefinition)source; | |
| if (def.DefaultValue != null) | |
| { | |
| PropertyData prop = new PropertyData(PropertyType.Uri); | |
| prop.AddValue(def.DefaultValue); | |
| writeProperty(writer, prop, true); | |
| } | |
| if (def.Choices != null) | |
| { | |
| foreach (IChoice<string> c in def.Choices) | |
| { | |
| if (c != null) | |
| { | |
| writeChoice<string>(writer, source.PropertyType, c); | |
| } | |
| } | |
| } | |
| } | |
| writeExtensions(writer, source); | |
| writer.WriteEndElement(); | |
| } | |
| public static void writeChoice<T>(XmlWriter writer, PropertyType propType, IChoice<T> source) | |
| { | |
| if (source == null) | |
| { | |
| return; | |
| } | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_PROPERTY_TYPE_CHOICE, XmlConstants.NAMESPACE_CMIS); | |
| if (source.DisplayName != null) | |
| { | |
| writer.WriteAttributeString(XmlConstants.ATTR_PROPERTY_TYPE_CHOICE_DISPLAYNAME, source.DisplayName); | |
| } | |
| if (source.Value != null) | |
| { | |
| switch (propType) | |
| { | |
| case PropertyType.String: | |
| case PropertyType.Id: | |
| case PropertyType.Html: | |
| case PropertyType.Uri: | |
| foreach (string value in (IList<string>)source.Value) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_CHOICE_VALUE, value); | |
| } | |
| break; | |
| case PropertyType.Integer: | |
| foreach (BigInteger value in (IList<BigInteger>)source.Value) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_CHOICE_VALUE, value); | |
| } | |
| break; | |
| case PropertyType.Boolean: | |
| foreach (bool? value in (IList<bool?>)source.Value) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_CHOICE_VALUE, value); | |
| } | |
| break; | |
| case PropertyType.DateTime: | |
| foreach (DateTime value in (IList<DateTime>)source.Value) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_CHOICE_VALUE, value); | |
| } | |
| break; | |
| case PropertyType.Decimal: | |
| foreach (decimal? value in (IList<decimal?>)source.Value) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_TYPE_CHOICE_VALUE, value); | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| if (source.Choices != null) | |
| { | |
| foreach (Choice<T> c in source.Choices) | |
| { | |
| if (c != null) | |
| { | |
| writeChoice<T>(writer, propType, c); | |
| } | |
| } | |
| } | |
| writer.WriteEndElement(); | |
| } | |
| // ----------------------- | |
| // --- object writers --- | |
| // ----------------------- | |
| public static void writeObject(XmlWriter writer, CmisVersion cmisVersion, string ns, IObjectData source) | |
| { | |
| writeObject(writer, cmisVersion, false, XmlConstants.TAG_OBJECT, ns, source); | |
| } | |
| public static void writeObject(XmlWriter writer, CmisVersion cmisVersion, bool root, string name, string ns, IObjectData source) | |
| { | |
| if (source == null) | |
| { | |
| return; | |
| } | |
| if (cmisVersion == CmisVersion.Cmis_1_0) | |
| { | |
| if (source.BaseTypeId == BaseTypeId.CmisItem) | |
| { | |
| Logger.Warn("Receiver only understands CMIS 1.0. It may not be able to handle an Item object."); | |
| } | |
| } | |
| if (root) | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, name, XmlConstants.NAMESPACE_CMIS); | |
| writer.WriteAttributeString("xmlns", XmlConstants.PREFIX_CMIS, null, XmlConstants.NAMESPACE_CMIS); | |
| } | |
| else | |
| { | |
| writer.WriteStartElement(name, ns); | |
| } | |
| if (source.Properties != null) | |
| { | |
| IProperties properties = source.Properties; | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_OBJECT_PROPERTIES, XmlConstants.NAMESPACE_CMIS); | |
| if (properties.PropertyList != null) | |
| { | |
| foreach (PropertyData property in properties.PropertyList) | |
| { | |
| writeProperty(writer, property, false); | |
| } | |
| } | |
| writeExtensions(writer, properties); | |
| writer.WriteEndElement(); | |
| } | |
| if (source.AllowableActions != null) | |
| { | |
| writeAllowableActions(writer, cmisVersion, false, source.AllowableActions); | |
| } | |
| if (source.Relationships != null) | |
| { | |
| foreach (IObjectData rel in source.Relationships) | |
| { | |
| if (rel != null) | |
| { | |
| writeObject(writer, cmisVersion, false, XmlConstants.TAG_OBJECT_RELATIONSHIP, XmlConstants.NAMESPACE_CMIS, rel); | |
| } | |
| } | |
| } | |
| if (source.ChangeEventInfo != null) | |
| { | |
| IChangeEventInfo info = source.ChangeEventInfo; | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_OBJECT_CHANGE_EVENT_INFO, XmlConstants.NAMESPACE_CMIS); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CHANGE_EVENT_TYPE, info.ChangeType); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_CHANGE_EVENT_TIME, info.ChangeTime); | |
| writeExtensions(writer, info); | |
| writer.WriteEndElement(); | |
| } | |
| if (source.Acl != null) | |
| { | |
| writeAcl(writer, cmisVersion, false, source.Acl); | |
| } | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_OBJECT_EXACT_ACL, source.IsExactAcl); | |
| if (source.PolicyIds != null) | |
| { | |
| IPolicyIdList pids = source.PolicyIds; | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_OBJECT_POLICY_IDS, XmlConstants.NAMESPACE_CMIS); | |
| if (pids.PolicyIds != null) | |
| { | |
| foreach (string id in pids.PolicyIds) | |
| { | |
| if (id != null) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_POLICY_ID, id); | |
| } | |
| } | |
| } | |
| writeExtensions(writer, pids); | |
| writer.WriteEndElement(); | |
| } | |
| if (source.Renditions != null) | |
| { | |
| foreach (IRenditionData rend in source.Renditions) | |
| { | |
| if (rend != null) | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_OBJECT_RENDITION, XmlConstants.NAMESPACE_CMIS); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_RENDITION_STREAM_ID, rend.StreamId); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_RENDITION_MIMETYPE, rend.MimeType); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_RENDITION_LENGTH, rend.Length); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_RENDITION_KIND, rend.Kind); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_RENDITION_TITLE, rend.Title); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_RENDITION_HEIGHT, rend.Height); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_RENDITION_WIDTH, rend.Width); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_RENDITION_DOCUMENT_ID, rend.RenditionDocumentId); | |
| writeExtensions(writer, rend); | |
| writer.WriteEndElement(); | |
| } | |
| } | |
| } | |
| writeExtensions(writer, source); | |
| writer.WriteEndElement(); | |
| } | |
| public static void writeProperty(XmlWriter writer, IPropertyData source, bool isDefaultValue) | |
| { | |
| if (source == null) | |
| { | |
| return; | |
| } | |
| if (isDefaultValue) | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_PROPERTY_TYPE_DEAULT_VALUE, XmlConstants.NAMESPACE_CMIS); | |
| } | |
| else | |
| { | |
| if (source.PropertyType == PropertyType.String) | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_PROP_STRING, XmlConstants.NAMESPACE_CMIS); | |
| } | |
| else if (source.PropertyType == PropertyType.Id) | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_PROP_ID, XmlConstants.NAMESPACE_CMIS); | |
| } | |
| else if (source.PropertyType == PropertyType.Integer) | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_PROP_INTEGER, XmlConstants.NAMESPACE_CMIS); | |
| } | |
| else if (source.PropertyType == PropertyType.Boolean) | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_PROP_BOOLEAN, XmlConstants.NAMESPACE_CMIS); | |
| } | |
| else if (source.PropertyType == PropertyType.DateTime) | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_PROP_DATETIME, XmlConstants.NAMESPACE_CMIS); | |
| } | |
| else if (source.PropertyType == PropertyType.Decimal) | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_PROP_DECIMAL, XmlConstants.NAMESPACE_CMIS); | |
| } | |
| else if (source.PropertyType == PropertyType.Html) | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_PROP_HTML, XmlConstants.NAMESPACE_CMIS); | |
| } | |
| else if (source.PropertyType == PropertyType.Uri) | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_PROP_URI, XmlConstants.NAMESPACE_CMIS); | |
| } | |
| else | |
| { | |
| throw new CmisRuntimeException("Invalid property datatype!"); | |
| } | |
| } | |
| if (source.Id != null) | |
| { | |
| writer.WriteAttributeString(XmlConstants.ATTR_PROPERTY_ID, source.Id); | |
| } | |
| if (source.DisplayName != null) | |
| { | |
| writer.WriteAttributeString(XmlConstants.ATTR_PROPERTY_DISPLAYNAME, source.DisplayName); | |
| } | |
| if (source.LocalName != null) | |
| { | |
| writer.WriteAttributeString(XmlConstants.ATTR_PROPERTY_LOCALNAME, source.LocalName); | |
| } | |
| if (source.QueryName != null) | |
| { | |
| writer.WriteAttributeString(XmlConstants.ATTR_PROPERTY_QUERYNAME, source.QueryName); | |
| } | |
| if (source.Values != null) | |
| { | |
| switch (source.PropertyType) | |
| { | |
| case PropertyType.String: | |
| case PropertyType.Id: | |
| case PropertyType.Html: | |
| case PropertyType.Uri: | |
| foreach (string value in source.Values.Cast<string>()) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_VALUE, value); | |
| } | |
| break; | |
| case PropertyType.Integer: | |
| foreach (BigInteger value in source.Values.Cast<BigInteger>()) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_VALUE, value); | |
| } | |
| break; | |
| case PropertyType.Boolean: | |
| foreach (bool value in source.Values.Cast<bool>()) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_VALUE, value); | |
| } | |
| break; | |
| case PropertyType.DateTime: | |
| foreach (DateTime value in source.Values.Cast<DateTime>()) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_VALUE, value); | |
| } | |
| break; | |
| case PropertyType.Decimal: | |
| foreach (decimal value in source.Values.Cast<decimal>()) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_PROPERTY_VALUE, value); | |
| } | |
| break; | |
| } | |
| } | |
| writeExtensions(writer, source); | |
| writer.WriteEndElement(); | |
| } | |
| public static void writeAllowableActions(XmlWriter writer, CmisVersion cmisVersion, bool root, IAllowableActions source) | |
| { | |
| if (source == null) | |
| { | |
| return; | |
| } | |
| if (root) | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, "allowableActions", XmlConstants.NAMESPACE_CMIS); | |
| writer.WriteAttributeString("xmlns", XmlConstants.PREFIX_CMIS, null, XmlConstants.NAMESPACE_CMIS); | |
| } | |
| else | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_OBJECT_ALLOWABLE_ACTIONS, XmlConstants.NAMESPACE_CMIS); | |
| } | |
| if (source.Actions != null) | |
| { | |
| var values = Enum.GetValues(typeof(PortCMIS.Enums.Action)); | |
| foreach (var value in values) | |
| { | |
| PortCMIS.Enums.Action action = (PortCMIS.Enums.Action)Enum.ToObject(typeof(PortCMIS.Enums.Action), value); | |
| if (source.Actions.Contains(action)) | |
| { | |
| if (action == PortCMIS.Enums.Action.CanCreateItem && cmisVersion == CmisVersion.Cmis_1_0) | |
| { | |
| Logger.Warn("Receiver only understands CMIS 1.0 but the Allowable Actions contain the canCreateItem action. " | |
| + "The canCreateItem action has been removed from the Allowable Actions."); | |
| continue; | |
| } | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, action.GetCmisValue(), true); | |
| } | |
| } | |
| } | |
| writeExtensions(writer, source); | |
| writer.WriteEndElement(); | |
| } | |
| public static void writeAcl(XmlWriter writer, CmisVersion cmisVersion, bool root, IAcl source) | |
| { | |
| if (source == null) | |
| { | |
| return; | |
| } | |
| if (root) | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, "acl", XmlConstants.NAMESPACE_CMIS); | |
| writer.WriteAttributeString("xmlns", XmlConstants.PREFIX_CMIS, null, XmlConstants.NAMESPACE_CMIS); | |
| } | |
| else | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_OBJECT_ACL, XmlConstants.NAMESPACE_CMIS); | |
| } | |
| if (source.Aces != null) | |
| { | |
| foreach (IAce ace in source.Aces) | |
| { | |
| if (ace != null) | |
| { | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_ACL_PERMISSISONS, XmlConstants.NAMESPACE_CMIS); | |
| if (ace.Principal != null) | |
| { | |
| IPrincipal principal = ace.Principal; | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_ACE_PRINCIPAL, XmlConstants.NAMESPACE_CMIS); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_ACE_PRINCIPAL_ID, principal.Id); | |
| writeExtensions(writer, principal); | |
| writer.WriteEndElement(); | |
| } | |
| if (ace.Permissions != null) | |
| { | |
| foreach (String perm in ace.Permissions) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_ACE_PERMISSIONS, perm); | |
| } | |
| } | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_ACE_IS_DIRECT, ace.IsDirect); | |
| writeExtensions(writer, ace); | |
| writer.WriteEndElement(); | |
| } | |
| } | |
| } | |
| writeExtensions(writer, source); | |
| writer.WriteEndElement(); | |
| } | |
| // ------------- | |
| // --- query --- | |
| // ------------- | |
| public static void writeQuery(XmlWriter writer, CmisVersion cmisVersion, QueryType source) | |
| { | |
| if (source == null) | |
| { | |
| return; | |
| } | |
| writer.WriteStartElement(XmlConstants.TAG_QUERY, XmlConstants.NAMESPACE_CMIS); | |
| writer.WriteAttributeString("xmlns", XmlConstants.PREFIX_CMIS, null, XmlConstants.NAMESPACE_CMIS); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_QUERY_STATEMENT, source.Statement); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_QUERY_SEARCHALLVERSIONS, source.SearchAllVersions); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_QUERY_INCLUDEALLOWABLEACTIONS, source.IncludeAllowableActions); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_QUERY_INCLUDERELATIONSHIPS, source.IncludeRelationships); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_QUERY_RENDITIONFILTER, source.RenditionFilter); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_QUERY_MAXITEMS, source.MaxItems); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_QUERY_SKIPCOUNT, source.SkipCount); | |
| writeExtensions(writer, source); | |
| writer.WriteEndElement(); | |
| } | |
| // ------------------- | |
| // --- bulk update --- | |
| // ------------------- | |
| public static void writeBulkUpdate(XmlWriter writer, String ns, BulkUpdate bulkUpdate) | |
| { | |
| if (bulkUpdate == null || bulkUpdate.ObjectIdAndChangeToken == null) | |
| { | |
| return; | |
| } | |
| writer.WriteStartElement(XmlConstants.TAG_BULK_UPDATE, ns); | |
| foreach (IBulkUpdateObjectIdAndChangeToken idAndToken in bulkUpdate.ObjectIdAndChangeToken) | |
| { | |
| if (idAndToken == null) | |
| { | |
| continue; | |
| } | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_BULK_UPDATE_ID_AND_TOKEN, XmlConstants.NAMESPACE_CMIS); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_IDANDTOKEN_ID, idAndToken.Id); | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_IDANDTOKEN_CHANGETOKEN, idAndToken.ChangeToken); | |
| writeExtensions(writer, idAndToken); | |
| writer.WriteEndElement(); | |
| } | |
| if (bulkUpdate.Properties != null) | |
| { | |
| IProperties properties = bulkUpdate.Properties; | |
| writer.WriteStartElement(XmlConstants.PREFIX_CMIS, XmlConstants.TAG_BULK_UPDATE_PROPERTIES, XmlConstants.NAMESPACE_CMIS); | |
| if (properties.PropertyList != null) | |
| { | |
| foreach (PropertyData property in properties.PropertyList) | |
| { | |
| writeProperty(writer, property, false); | |
| } | |
| } | |
| writeExtensions(writer, properties); | |
| writer.WriteEndElement(); | |
| } | |
| if (bulkUpdate.AddSecondaryTypeIds != null) | |
| { | |
| foreach (string id in bulkUpdate.AddSecondaryTypeIds) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_BULK_UPDATE_ADD_SECONDARY_TYPES, id); | |
| } | |
| } | |
| if (bulkUpdate.RemoveSecondaryTypeIds != null) | |
| { | |
| foreach (string id in bulkUpdate.RemoveSecondaryTypeIds) | |
| { | |
| XmlUtils.Write(writer, XmlConstants.PREFIX_CMIS, XmlConstants.NAMESPACE_CMIS, XmlConstants.TAG_BULK_UPDATE_REMOVE_SECONDARY_TYPES, id); | |
| } | |
| } | |
| writer.WriteEndElement(); | |
| } | |
| // ------------------------- | |
| // --- extension writers --- | |
| // ------------------------- | |
| public static void writeExtensions(XmlWriter writer, IExtensionsData source) | |
| { | |
| if (source == null) | |
| { | |
| return; | |
| } | |
| IList<string> ns = new List<string>(); | |
| if (source.Extensions != null) | |
| { | |
| foreach (ICmisExtensionElement element in source.Extensions) | |
| { | |
| if (element == null) | |
| { | |
| continue; | |
| } | |
| writeExtensionElement(writer, element, ns); | |
| } | |
| } | |
| } | |
| private static void writeExtensionElement(XmlWriter writer, ICmisExtensionElement source, IList<string> ns) | |
| { | |
| if (source == null || source.Name == null) | |
| { | |
| return; | |
| } | |
| bool addedNamespace = false; | |
| if (source.Namespace != null) | |
| { | |
| string prefix = writer.LookupPrefix(source.Namespace); | |
| if (prefix == null) | |
| { | |
| int p = ns.IndexOf(source.Namespace); | |
| if (p == -1) | |
| { | |
| prefix = "e" + (ns.Count + 1); | |
| ns.Add(source.Namespace); | |
| addedNamespace = true; | |
| } | |
| else | |
| { | |
| prefix = "e" + (p + 1); | |
| } | |
| } | |
| writer.WriteStartElement(prefix, source.Name, source.Namespace); | |
| if (addedNamespace) | |
| { | |
| writer.WriteAttributeString("xmlns", prefix, null, source.Namespace); | |
| } | |
| } | |
| else | |
| { | |
| writer.WriteStartElement(source.Name); | |
| } | |
| if (source.Attributes != null) | |
| { | |
| foreach (KeyValuePair<string, string> attr in source.Attributes) | |
| { | |
| writer.WriteAttributeString(attr.Key, attr.Value); | |
| } | |
| } | |
| if (source.Value != null) | |
| { | |
| writer.WriteString(source.Value); | |
| } | |
| else | |
| { | |
| if (source.Children != null) | |
| { | |
| foreach (ICmisExtensionElement child in source.Children) | |
| { | |
| writeExtensionElement(writer, child, ns); | |
| } | |
| } | |
| } | |
| writer.WriteEndElement(); | |
| if (addedNamespace) | |
| { | |
| ns.RemoveAt(ns.Count - 1); | |
| } | |
| } | |
| // --------------- | |
| // --- parsers --- | |
| // --------------- | |
| public static RepositoryInfo convertRepositoryInfo(XmlReader parser) | |
| { | |
| return REPOSITORY_INFO_PARSER.Walk(parser); | |
| } | |
| public static ITypeDefinition convertTypeDefinition(XmlReader parser) | |
| { | |
| return TYPE_DEF_PARSER.Walk(parser); | |
| } | |
| public static IObjectData convertObject(XmlReader parser) | |
| { | |
| return OBJECT_PARSER.Walk(parser); | |
| } | |
| public static QueryType convertQuery(XmlReader parser) | |
| { | |
| return QUERY_PARSER.Walk(parser); | |
| } | |
| public static IAllowableActions convertAllowableActions(XmlReader parser) | |
| { | |
| return ALLOWABLE_ACTIONS_PARSER.Walk(parser); | |
| } | |
| public static IAcl convertAcl(XmlReader parser) | |
| { | |
| return ACL_PARSER.Walk(parser); | |
| } | |
| public static BulkUpdate convertBulkUpdate(XmlReader parser) | |
| { | |
| return BULK_UPDATE_PARSER.Walk(parser); | |
| } | |
| // ------------------------------ | |
| // --- repository info parser --- | |
| // ------------------------------ | |
| private static readonly RepositoryInfoParser REPOSITORY_INFO_PARSER = new RepositoryInfoParser(); | |
| private class RepositoryInfoParser : XmlWalker<RepositoryInfo> | |
| { | |
| protected override RepositoryInfo PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new RepositoryInfo(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, RepositoryInfo target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_REPINFO_ID)) | |
| { | |
| target.Id = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_REPINFO_NAME)) | |
| { | |
| target.Name = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_REPINFO_DESCRIPTION)) | |
| { | |
| target.Description = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_REPINFO_VENDOR)) | |
| { | |
| target.VendorName = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_REPINFO_PRODUCT)) | |
| { | |
| target.ProductName = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_REPINFO_PRODUCT_VERSION)) | |
| { | |
| target.ProductVersion = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_REPINFO_ROOT_FOLDER_ID)) | |
| { | |
| target.RootFolderId = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_REPINFO_CHANGE_LOG_TOKEN)) | |
| { | |
| target.LatestChangeLogToken = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_REPINFO_CAPABILITIES)) | |
| { | |
| target.Capabilities = CAPABILITIES_PARSER.Walk(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_REPINFO_ACL_CAPABILITIES)) | |
| { | |
| target.AclCapabilities = ACL_CAPABILITIES_PARSER.Walk(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_REPINFO_CMIS_VERSION_SUPPORTED)) | |
| { | |
| target.CmisVersionSupported = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_REPINFO_THIN_CLIENT_URI)) | |
| { | |
| target.ThinClientUri = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_REPINFO_CHANGES_INCOMPLETE)) | |
| { | |
| target.ChangesIncomplete = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_REPINFO_CHANGES_ON_TYPE)) | |
| { | |
| target.ChangesOnType = AddToList(target.ChangesOnType, ReadEnum<BaseTypeId>(parser)); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_REPINFO_PRINCIPAL_ID_ANONYMOUS)) | |
| { | |
| target.PrincipalIdAnonymous = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_REPINFO_PRINCIPAL_ID_ANYONE)) | |
| { | |
| target.PrincipalIdAnyone = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_REPINFO_EXTENDED_FEATURES)) | |
| { | |
| target.ExtensionFeatures = AddToList(target.ExtensionFeatures, EXTENDED_FEATURES_PARSER.Walk(parser)); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly CapabilitiesParser CAPABILITIES_PARSER = new CapabilitiesParser(); | |
| private class CapabilitiesParser : XmlWalker<RepositoryCapabilities> | |
| { | |
| protected override RepositoryCapabilities PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new RepositoryCapabilities(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, RepositoryCapabilities target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_CAP_ACL)) | |
| { | |
| target.AclCapability = ReadEnum<CapabilityAcl>(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_ALL_VERSIONS_SEARCHABLE)) | |
| { | |
| target.IsAllVersionsSearchableSupported = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_CHANGES)) | |
| { | |
| target.ChangesCapability = ReadEnum<CapabilityChanges>(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_CONTENT_STREAM_UPDATABILITY)) | |
| { | |
| target.ContentStreamUpdatesCapability = ReadEnum<CapabilityContentStreamUpdates>(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_GET_DESCENDANTS)) | |
| { | |
| target.IsGetDescendantsSupported = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_GET_FOLDER_TREE)) | |
| { | |
| target.IsGetFolderTreeSupported = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_ORDER_BY)) | |
| { | |
| target.OrderByCapability = ReadEnum<CapabilityOrderBy>(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_MULTIFILING)) | |
| { | |
| target.IsMultifilingSupported = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_PWC_SEARCHABLE)) | |
| { | |
| target.IsPwcSearchableSupported = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_PWC_UPDATABLE)) | |
| { | |
| target.IsPwcUpdatableSupported = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_QUERY)) | |
| { | |
| target.QueryCapability = ReadEnum<CapabilityQuery>(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_RENDITIONS)) | |
| { | |
| target.RenditionsCapability = ReadEnum<CapabilityRenditions>(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_UNFILING)) | |
| { | |
| target.IsUnfilingSupported = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_VERSION_SPECIFIC_FILING)) | |
| { | |
| target.IsVersionSpecificFilingSupported = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_JOIN)) | |
| { | |
| target.JoinCapability = ReadEnum<CapabilityJoin>(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_CREATABLE_PROPERTY_TYPES)) | |
| { | |
| target.CreatablePropertyTypes = CREATABLE_PROPERTY_TYPES_PARSER.Walk(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES)) | |
| { | |
| target.NewTypeSettableAttributes = NEW_TYPES_SETTABLE_ATTRIBUTES_PARSER.Walk(parser); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly CreatablePropertyTypesParser CREATABLE_PROPERTY_TYPES_PARSER = new CreatablePropertyTypesParser(); | |
| private class CreatablePropertyTypesParser : XmlWalker<CreatablePropertyTypes> | |
| { | |
| protected override CreatablePropertyTypes PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new CreatablePropertyTypes(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, CreatablePropertyTypes target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_CAP_CREATABLE_PROPERTY_TYPES_CANCREATE)) | |
| { | |
| if (target.CanCreate == null) | |
| { | |
| target.CanCreate = new HashSet<PropertyType>(); | |
| } | |
| target.CanCreate.Add(ReadEnum<PropertyType>(parser)); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly NewTypesSettableAttributesParser NEW_TYPES_SETTABLE_ATTRIBUTES_PARSER = new NewTypesSettableAttributesParser(); | |
| private class NewTypesSettableAttributesParser : XmlWalker<NewTypeSettableAttributes> | |
| { | |
| protected override NewTypeSettableAttributes PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new NewTypeSettableAttributes(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, NewTypeSettableAttributes target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_ID)) | |
| { | |
| target.CanSetId = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_LOCALNAME)) | |
| { | |
| target.CanSetLocalName = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_LOCALNAMESPACE)) | |
| { | |
| target.CanSetLocalNamespace = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_DISPLAYNAME)) | |
| { | |
| target.CanSetDisplayName = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_QUERYNAME)) | |
| { | |
| target.CanSetQueryName = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_DESCRIPTION)) | |
| { | |
| target.CanSetDescription = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_CREATEABLE)) | |
| { | |
| target.CanSetCreatable = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_FILEABLE)) | |
| { | |
| target.CanSetFileable = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_QUERYABLE)) | |
| { | |
| target.CanSetQueryable = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_FULLTEXTINDEXED)) | |
| { | |
| target.CanSetFulltextIndexed = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_INCLUDEDINSUPERTYTPEQUERY)) | |
| { | |
| target.CanSetIncludedInSupertypeQuery = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_CONTROLABLEPOLICY)) | |
| { | |
| target.CanSetControllablePolicy = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CAP_NEW_TYPE_SETTABLE_ATTRIBUTES_CONTROLABLEACL)) | |
| { | |
| target.CanSetControllableAcl = ReadBoolean(parser); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly AclCapabilitiesParser ACL_CAPABILITIES_PARSER = new AclCapabilitiesParser(); | |
| private class AclCapabilitiesParser : XmlWalker<AclCapabilities> | |
| { | |
| protected override AclCapabilities PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new AclCapabilities(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, AclCapabilities target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_ACLCAP_SUPPORTED_PERMISSIONS)) | |
| { | |
| target.SupportedPermissions = ReadEnum<SupportedPermissions>(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_ACLCAP_ACL_PROPAGATION)) | |
| { | |
| target.AclPropagation = ReadEnum<AclPropagation>(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_ACLCAP_PERMISSIONS)) | |
| { | |
| target.Permissions = AddToList(target.Permissions, PERMISSION_DEFINITION_PARSER.Walk(parser)); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_ACLCAP_PERMISSION_MAPPING)) | |
| { | |
| PermissionMapping pm = PERMISSION_MAPPING_PARSER.Walk(parser); | |
| IDictionary<string, IPermissionMapping> mapping = target.PermissionMapping; | |
| if (mapping == null) | |
| { | |
| target.PermissionMapping = new Dictionary<string, IPermissionMapping>(); | |
| mapping = target.PermissionMapping; | |
| } | |
| mapping.Add(pm.Key, pm); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly PermissionDefinitionParser PERMISSION_DEFINITION_PARSER = new PermissionDefinitionParser(); | |
| private class PermissionDefinitionParser : XmlWalker<PermissionDefinition> | |
| { | |
| protected override PermissionDefinition PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new PermissionDefinition(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, PermissionDefinition target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_ACLCAP_PERMISSION_PERMISSION)) | |
| { | |
| target.Id = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_ACLCAP_PERMISSION_DESCRIPTION)) | |
| { | |
| target.Description = ReadText(parser); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly PermissionMappingParser PERMISSION_MAPPING_PARSER = new PermissionMappingParser(); | |
| private class PermissionMappingParser : XmlWalker<PermissionMapping> | |
| { | |
| protected override PermissionMapping PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new PermissionMapping(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, PermissionMapping target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_ACLCAP_MAPPING_KEY)) | |
| { | |
| target.Key = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_ACLCAP_MAPPING_PERMISSION)) | |
| { | |
| target.Permissions = AddToList(target.Permissions, ReadText(parser)); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly ExtensionFeatureParser EXTENDED_FEATURES_PARSER = new ExtensionFeatureParser(); | |
| private class ExtensionFeatureParser : XmlWalker<ExtensionFeature> | |
| { | |
| protected override ExtensionFeature PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new ExtensionFeature(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, ExtensionFeature target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_FEATURE_ID)) | |
| { | |
| target.Id = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_FEATURE_URL)) | |
| { | |
| target.Url = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_FEATURE_COMMON_NAME)) | |
| { | |
| target.CommonName = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_FEATURE_VERSION_LABEL)) | |
| { | |
| target.VersionLabel = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_FEATURE_DESCRIPTION)) | |
| { | |
| target.Description = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_FEATURE_DATA)) | |
| { | |
| String[] data = FEATURE_DATA_PARSER.Walk(parser); | |
| IDictionary<string, string> featureData = target.FeatureData; | |
| featureData.Add(data[0], data[1]); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly FetaureDataParser FEATURE_DATA_PARSER = new FetaureDataParser(); | |
| private class FetaureDataParser : XmlWalker<string[]> | |
| { | |
| protected override string[] PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new string[2]; | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, string[] target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_FEATURE_DATA_KEY)) | |
| { | |
| target[0] = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_FEATURE_DATA_VALUE)) | |
| { | |
| target[1] = ReadText(parser); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| // -------------------------- | |
| // --- definition parsers --- | |
| // -------------------------- | |
| private static readonly TypeDefParser TYPE_DEF_PARSER = new TypeDefParser(); | |
| private class TypeDefParser : XmlWalker<AbstractTypeDefinition> | |
| { | |
| protected override AbstractTypeDefinition PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| AbstractTypeDefinition result = null; | |
| string typeAttr = parser.GetAttribute("type", XmlConstants.NAMESPACE_XSI); | |
| if (typeAttr != null) | |
| { | |
| if (typeAttr.EndsWith(XmlConstants.ATTR_DOCUMENT_TYPE)) | |
| { | |
| result = new DocumentTypeDefinition(); | |
| } | |
| else if (typeAttr.EndsWith(XmlConstants.ATTR_FOLDER_TYPE)) | |
| { | |
| result = new FolderTypeDefinition(); | |
| } | |
| else if (typeAttr.EndsWith(XmlConstants.ATTR_RELATIONSHIP_TYPE)) | |
| { | |
| result = new RelationshipTypeDefinition(); | |
| ((RelationshipTypeDefinition)result).AllowedSourceTypeIds = new List<string>(); | |
| ((RelationshipTypeDefinition)result).AllowedTargetTypeIds = new List<string>(); | |
| } | |
| else if (typeAttr.EndsWith(XmlConstants.ATTR_POLICY_TYPE)) | |
| { | |
| result = new PolicyTypeDefinition(); | |
| } | |
| else if (typeAttr.EndsWith(XmlConstants.ATTR_ITEM_TYPE)) | |
| { | |
| result = new ItemTypeDefinition(); | |
| } | |
| else if (typeAttr.EndsWith(XmlConstants.ATTR_SECONDARY_TYPE)) | |
| { | |
| result = new SecondaryTypeDefinition(); | |
| } | |
| } | |
| if (result == null) | |
| { | |
| throw new CmisInvalidArgumentException("Cannot read type definition!"); | |
| } | |
| return result; | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, AbstractTypeDefinition target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_ID)) | |
| { | |
| target.Id = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_LOCALNAME)) | |
| { | |
| target.LocalName = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_LOCALNAMESPACE)) | |
| { | |
| target.LocalNamespace = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_DISPLAYNAME)) | |
| { | |
| target.DisplayName = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_QUERYNAME)) | |
| { | |
| target.QueryName = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_DESCRIPTION)) | |
| { | |
| target.Description = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_BASE_ID)) | |
| { | |
| BaseTypeId? baseType = ReadEnum<BaseTypeId?>(parser); | |
| if (baseType == null) | |
| { | |
| throw new CmisInvalidArgumentException("Invalid base type!"); | |
| } | |
| target.BaseTypeId = baseType.Value; | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_PARENT_ID)) | |
| { | |
| target.ParentTypeId = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_CREATABLE)) | |
| { | |
| target.IsCreatable = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_FILEABLE)) | |
| { | |
| target.IsFileable = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_QUERYABLE)) | |
| { | |
| target.IsQueryable = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_FULLTEXT_INDEXED)) | |
| { | |
| target.IsFulltextIndexed = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_INCLUDE_IN_SUPERTYPE_QUERY)) | |
| { | |
| target.IsIncludedInSupertypeQuery = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_CONTROLABLE_POLICY)) | |
| { | |
| target.IsControllablePolicy = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_CONTROLABLE_ACL)) | |
| { | |
| target.IsControllableAcl = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_TYPE_MUTABILITY)) | |
| { | |
| target.TypeMutability = TYPE_MUTABILITY_PARSER.Walk(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_PROP_DEF_STRING) || IsTag(localname, XmlConstants.TAG_TYPE_PROP_DEF_ID) | |
| || IsTag(localname, XmlConstants.TAG_TYPE_PROP_DEF_BOOLEAN) || IsTag(localname, XmlConstants.TAG_TYPE_PROP_DEF_INTEGER) | |
| || IsTag(localname, XmlConstants.TAG_TYPE_PROP_DEF_DATETIME) || IsTag(localname, XmlConstants.TAG_TYPE_PROP_DEF_DECIMAL) | |
| || IsTag(localname, XmlConstants.TAG_TYPE_PROP_DEF_HTML) || IsTag(localname, XmlConstants.TAG_TYPE_PROP_DEF_URI)) | |
| { | |
| target.AddPropertyDefinition(PROPERTY_TYPE_PARSER.Walk(parser)); | |
| return true; | |
| } | |
| if (target is DocumentTypeDefinition) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_VERSIONABLE)) | |
| { | |
| ((DocumentTypeDefinition)target).IsVersionable = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_CONTENTSTREAM_ALLOWED)) | |
| { | |
| ((DocumentTypeDefinition)target).ContentStreamAllowed = ReadEnum<ContentStreamAllowed>(parser); | |
| return true; | |
| } | |
| } | |
| if (target is RelationshipTypeDefinition) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_ALLOWED_SOURCE_TYPES)) | |
| { | |
| RelationshipTypeDefinition relTarget = (RelationshipTypeDefinition)target; | |
| relTarget.AllowedSourceTypeIds = AddToList(relTarget.AllowedSourceTypeIds, ReadText(parser)); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_ALLOWED_TARGET_TYPES)) | |
| { | |
| RelationshipTypeDefinition relTarget = (RelationshipTypeDefinition)target; | |
| relTarget.AllowedTargetTypeIds = AddToList(relTarget.AllowedTargetTypeIds, ReadText(parser)); | |
| return true; | |
| } | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly TypeMutabilityParser TYPE_MUTABILITY_PARSER = new TypeMutabilityParser(); | |
| private class TypeMutabilityParser : XmlWalker<TypeMutability> | |
| { | |
| protected override TypeMutability PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new TypeMutability(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, TypeMutability target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_TYPE_MUTABILITY_CREATE)) | |
| { | |
| target.CanCreate = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_TYPE_MUTABILITY_UPDATE)) | |
| { | |
| target.CanUpdate = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_TYPE_MUTABILITY_DELETE)) | |
| { | |
| target.CanDelete = ReadBoolean(parser); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly PropertyTypeParser PROPERTY_TYPE_PARSER = new PropertyTypeParser(); | |
| private class PropertyTypeParser : XmlWalker<PropertyDefinition> | |
| { | |
| protected override PropertyDefinition PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| PropertyDefinition result = null; | |
| if (IsTag(localname, XmlConstants.TAG_TYPE_PROP_DEF_STRING)) | |
| { | |
| result = new PropertyStringDefinition(); | |
| } | |
| else if (IsTag(localname, XmlConstants.TAG_TYPE_PROP_DEF_ID)) | |
| { | |
| result = new PropertyIdDefinition(); | |
| } | |
| else if (IsTag(localname, XmlConstants.TAG_TYPE_PROP_DEF_BOOLEAN)) | |
| { | |
| result = new PropertyBooleanDefinition(); | |
| } | |
| else if (IsTag(localname, XmlConstants.TAG_TYPE_PROP_DEF_INTEGER)) | |
| { | |
| result = new PropertyIntegerDefinition(); | |
| } | |
| else if (IsTag(localname, XmlConstants.TAG_TYPE_PROP_DEF_DATETIME)) | |
| { | |
| result = new PropertyDateTimeDefinition(); | |
| } | |
| else if (IsTag(localname, XmlConstants.TAG_TYPE_PROP_DEF_DECIMAL)) | |
| { | |
| result = new PropertyDecimalDefinition(); | |
| } | |
| else if (IsTag(localname, XmlConstants.TAG_TYPE_PROP_DEF_HTML)) | |
| { | |
| result = new PropertyHtmlDefinition(); | |
| } | |
| else if (IsTag(localname, XmlConstants.TAG_TYPE_PROP_DEF_URI)) | |
| { | |
| result = new PropertyUriDefinition(); | |
| } | |
| if (result == null) | |
| { | |
| throw new CmisInvalidArgumentException("Cannot read property type definition!"); | |
| } | |
| return result; | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, PropertyDefinition target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_ID)) | |
| { | |
| target.Id = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_LOCALNAME)) | |
| { | |
| target.LocalName = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_LOCALNAMESPACE)) | |
| { | |
| target.LocalNamespace = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_DISPLAYNAME)) | |
| { | |
| target.DisplayName = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_QUERYNAME)) | |
| { | |
| target.QueryName = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_DESCRIPTION)) | |
| { | |
| target.Description = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_PROPERTY_TYPE)) | |
| { | |
| PropertyType? propType = ReadEnum<PropertyType?>(parser); | |
| if (propType == null) | |
| { | |
| throw new CmisInvalidArgumentException("Invalid property data type!"); | |
| } | |
| target.PropertyType = propType.Value; | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_CARDINALITY)) | |
| { | |
| Cardinality? cardinality = ReadEnum<Cardinality?>(parser); | |
| if (cardinality == null) | |
| { | |
| throw new CmisInvalidArgumentException("Invalid cardinality!"); | |
| } | |
| target.Cardinality = cardinality.Value; | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_UPDATABILITY)) | |
| { | |
| Updatability? updatability = ReadEnum<Updatability?>(parser); | |
| if (updatability == null) | |
| { | |
| throw new CmisInvalidArgumentException("Invalid updatability!"); | |
| } | |
| target.Updatability = updatability.Value; | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_INHERITED)) | |
| { | |
| target.IsInherited = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_REQUIRED)) | |
| { | |
| target.IsRequired = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_QUERYABLE)) | |
| { | |
| target.IsQueryable = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_ORDERABLE)) | |
| { | |
| target.IsOrderable = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_OPENCHOICE)) | |
| { | |
| target.IsOpenChoice = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (target is PropertyStringDefinition) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_DEAULT_VALUE)) | |
| { | |
| PropertyData prop = PROPERTY_STRING_PARSER.Walk(parser); | |
| if (prop.Values != null) | |
| { | |
| ((PropertyStringDefinition)target).DefaultValue = prop.Values.Cast<string>().ToList(); | |
| } | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_CHOICE)) | |
| { | |
| CHOICE_STRING_PARSER.addToChoiceList(parser, (PropertyStringDefinition)target); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_MAX_LENGTH)) | |
| { | |
| ((PropertyStringDefinition)target).MaxLength = ReadInteger(parser); | |
| return true; | |
| } | |
| } | |
| else if (target is PropertyIdDefinition) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_DEAULT_VALUE)) | |
| { | |
| PropertyData prop = PROPERTY_ID_PARSER.Walk(parser); | |
| if (prop.Values != null) | |
| { | |
| ((PropertyIdDefinition)target).DefaultValue = prop.Values.Cast<string>().ToList(); | |
| } | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_CHOICE)) | |
| { | |
| CHOICE_STRING_PARSER.addToChoiceList(parser, (PropertyIdDefinition)target); | |
| return true; | |
| } | |
| } | |
| else if (target is PropertyBooleanDefinition) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_DEAULT_VALUE)) | |
| { | |
| PropertyData prop = PROPERTY_BOOLEAN_PARSER.Walk(parser); | |
| if (prop.Values != null) | |
| { | |
| ((PropertyBooleanDefinition)target).DefaultValue = prop.Values.Cast<bool?>().ToList(); | |
| } | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_CHOICE)) | |
| { | |
| CHOICE_BOOLEAN_PARSER.addToChoiceList(parser, (PropertyBooleanDefinition)target); | |
| return true; | |
| } | |
| } | |
| else if (target is PropertyIntegerDefinition) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_DEAULT_VALUE)) | |
| { | |
| PropertyData prop = PROPERTY_INTEGER_PARSER.Walk(parser); | |
| if (prop.Values != null) | |
| { | |
| ((PropertyIntegerDefinition)target).DefaultValue = prop.Values.Cast<BigInteger?>().ToList(); | |
| } | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_CHOICE)) | |
| { | |
| CHOICE_INTEGER_PARSER.addToChoiceList(parser, (PropertyIntegerDefinition)target); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_MAX_VALUE)) | |
| { | |
| ((PropertyIntegerDefinition)target).MaxValue = ReadInteger(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_MIN_VALUE)) | |
| { | |
| ((PropertyIntegerDefinition)target).MinValue = ReadInteger(parser); | |
| return true; | |
| } | |
| } | |
| else if (target is PropertyDateTimeDefinition) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_DEAULT_VALUE)) | |
| { | |
| PropertyData prop = PROPERTY_DATETIME_PARSER.Walk(parser); | |
| if (prop.Values != null) | |
| { | |
| ((PropertyDateTimeDefinition)target).DefaultValue = prop.Values.Cast<DateTime?>().ToList(); | |
| } | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_CHOICE)) | |
| { | |
| CHOICE_DATETIME_PARSER.addToChoiceList(parser, (PropertyDateTimeDefinition)target); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_RESOLUTION)) | |
| { | |
| ((PropertyDateTimeDefinition)target).DateTimeResolution = ReadEnum<DateTimeResolution>(parser); | |
| return true; | |
| } | |
| } | |
| else if (target is PropertyDecimalDefinition) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_DEAULT_VALUE)) | |
| { | |
| PropertyData prop = PROPERTY_DECIMAL_PARSER.Walk(parser); | |
| if (prop.Values != null) | |
| { | |
| ((PropertyDecimalDefinition)target).DefaultValue = prop.Values.Cast<decimal?>().ToList(); | |
| } | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_CHOICE)) | |
| { | |
| CHOICE_DECIMAL_PARSER.addToChoiceList(parser, (PropertyDecimalDefinition)target); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_MAX_VALUE)) | |
| { | |
| ((PropertyDecimalDefinition)target).MaxValue = ReadDecimal(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_MIN_VALUE)) | |
| { | |
| ((PropertyDecimalDefinition)target).MinValue = ReadDecimal(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_PRECISION)) | |
| { | |
| ((PropertyDecimalDefinition)target).Precision = ReadEnum<DecimalPrecision>(parser); | |
| return true; | |
| } | |
| } | |
| else if (target is PropertyHtmlDefinition) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_DEAULT_VALUE)) | |
| { | |
| PropertyData prop = PROPERTY_HTML_PARSER.Walk(parser); | |
| if (prop.Values != null) | |
| { | |
| ((PropertyHtmlDefinition)target).DefaultValue = prop.Values.Cast<string>().ToList(); | |
| } | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_CHOICE)) | |
| { | |
| CHOICE_STRING_PARSER.addToChoiceList(parser, (PropertyHtmlDefinition)target); | |
| return true; | |
| } | |
| } | |
| else if (target is IPropertyUriDefinition) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_DEAULT_VALUE)) | |
| { | |
| PropertyData prop = PROPERTY_URI_PARSER.Walk(parser); | |
| if (prop.Values != null) | |
| { | |
| ((PropertyUriDefinition)target).DefaultValue = prop.Values.Cast<string>().ToList(); | |
| } | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_CHOICE)) | |
| { | |
| CHOICE_STRING_PARSER.addToChoiceList(parser, (PropertyUriDefinition)target); | |
| return true; | |
| } | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly ChoiceStringParser CHOICE_STRING_PARSER = new ChoiceStringParser(); | |
| private class ChoiceStringParser : ChoiceXmlWalker<string> | |
| { | |
| protected override Choice<string> createTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new Choice<string>(); | |
| } | |
| protected override void addValue(XmlReader parser, Choice<string> target) | |
| { | |
| target.Value = AddToList(target.Value, ReadText(parser)); | |
| } | |
| protected override void addChoice(XmlReader parser, Choice<string> target) | |
| { | |
| target.Choices = AddToList(target.Choices, CHOICE_STRING_PARSER.Walk(parser)); | |
| } | |
| public void addToChoiceList(XmlReader parser, PropertyDefinition propDef) | |
| { | |
| if (propDef is PropertyStringDefinition) | |
| { | |
| PropertyStringDefinition pd = (PropertyStringDefinition)propDef; | |
| pd.Choices = AddToList(pd.Choices, CHOICE_STRING_PARSER.Walk(parser)); | |
| } | |
| else if (propDef is PropertyIdDefinition) | |
| { | |
| PropertyIdDefinition pd = (PropertyIdDefinition)propDef; | |
| pd.Choices = AddToList(pd.Choices, CHOICE_STRING_PARSER.Walk(parser)); | |
| } | |
| else if (propDef is PropertyUriDefinition) | |
| { | |
| PropertyUriDefinition pd = (PropertyUriDefinition)propDef; | |
| pd.Choices = AddToList(pd.Choices, CHOICE_STRING_PARSER.Walk(parser)); | |
| } | |
| else if (propDef is PropertyHtmlDefinition) | |
| { | |
| PropertyHtmlDefinition pd = (PropertyHtmlDefinition)propDef; | |
| pd.Choices = AddToList(pd.Choices, CHOICE_STRING_PARSER.Walk(parser)); | |
| } | |
| } | |
| }; | |
| private static readonly ChoiceBooleanParser CHOICE_BOOLEAN_PARSER = new ChoiceBooleanParser(); | |
| private class ChoiceBooleanParser : ChoiceXmlWalker<bool?> | |
| { | |
| protected override Choice<bool?> createTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new Choice<bool?>(); | |
| } | |
| protected override void addValue(XmlReader parser, Choice<bool?> target) | |
| { | |
| target.Value = AddToList(target.Value, ReadBoolean(parser)); | |
| } | |
| protected override void addChoice(XmlReader parser, Choice<bool?> target) | |
| { | |
| target.Choices = AddToList(target.Choices, CHOICE_BOOLEAN_PARSER.Walk(parser)); | |
| } | |
| public void addToChoiceList(XmlReader parser, PropertyBooleanDefinition propDef) | |
| { | |
| propDef.Choices = AddToList(propDef.Choices, CHOICE_BOOLEAN_PARSER.Walk(parser)); | |
| } | |
| }; | |
| private static readonly ChoiceIntegerParser CHOICE_INTEGER_PARSER = new ChoiceIntegerParser(); | |
| private class ChoiceIntegerParser : ChoiceXmlWalker<BigInteger?> | |
| { | |
| protected override Choice<BigInteger?> createTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new Choice<BigInteger?>(); | |
| } | |
| protected override void addValue(XmlReader parser, Choice<BigInteger?> target) | |
| { | |
| target.Value = AddToList(target.Value, ReadInteger(parser)); | |
| } | |
| protected override void addChoice(XmlReader parser, Choice<BigInteger?> target) | |
| { | |
| target.Choices = AddToList(target.Choices, CHOICE_INTEGER_PARSER.Walk(parser)); | |
| } | |
| public void addToChoiceList(XmlReader parser, PropertyIntegerDefinition propDef) | |
| { | |
| propDef.Choices = AddToList(propDef.Choices, CHOICE_INTEGER_PARSER.Walk(parser)); | |
| } | |
| }; | |
| private static readonly ChoiceDateTimeParser CHOICE_DATETIME_PARSER = new ChoiceDateTimeParser(); | |
| private class ChoiceDateTimeParser : ChoiceXmlWalker<DateTime?> | |
| { | |
| protected override Choice<DateTime?> createTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new Choice<DateTime?>(); | |
| } | |
| protected override void addValue(XmlReader parser, Choice<DateTime?> target) | |
| { | |
| target.Value = AddToList(target.Value, ReadDateTime(parser)); | |
| } | |
| protected override void addChoice(XmlReader parser, Choice<DateTime?> target) | |
| { | |
| target.Choices = AddToList(target.Choices, CHOICE_DATETIME_PARSER.Walk(parser)); | |
| } | |
| public void addToChoiceList(XmlReader parser, PropertyDateTimeDefinition propDef) | |
| { | |
| propDef.Choices = AddToList(propDef.Choices, CHOICE_DATETIME_PARSER.Walk(parser)); | |
| } | |
| }; | |
| private static readonly ChoiceDecimalParser CHOICE_DECIMAL_PARSER = new ChoiceDecimalParser(); | |
| private class ChoiceDecimalParser : ChoiceXmlWalker<decimal?> | |
| { | |
| protected override Choice<decimal?> createTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new Choice<decimal?>(); | |
| } | |
| protected override void addValue(XmlReader parser, Choice<decimal?> target) | |
| { | |
| target.Value = AddToList(target.Value, ReadDecimal(parser)); | |
| } | |
| protected override void addChoice(XmlReader parser, Choice<decimal?> target) | |
| { | |
| target.Choices = AddToList(target.Choices, CHOICE_DECIMAL_PARSER.Walk(parser)); | |
| } | |
| public void addToChoiceList(XmlReader parser, PropertyDecimalDefinition propDef) | |
| { | |
| propDef.Choices = AddToList(propDef.Choices, CHOICE_DECIMAL_PARSER.Walk(parser)); | |
| } | |
| }; | |
| private abstract class ChoiceXmlWalker<T> : XmlWalker<Choice<T>> | |
| { | |
| protected abstract Choice<T> createTarget(XmlReader parser, string localname, string ns); | |
| protected override Choice<T> PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| Choice<T> result = createTarget(parser, localname, ns); | |
| if (parser.HasAttributes) | |
| { | |
| result.DisplayName = parser.GetAttribute(XmlConstants.ATTR_PROPERTY_TYPE_CHOICE_DISPLAYNAME); | |
| } | |
| return result; | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, Choice<T> target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_CHOICE_VALUE)) | |
| { | |
| try | |
| { | |
| addValue(parser, target); | |
| } | |
| catch (CmisInvalidArgumentException e) | |
| { | |
| // a few repositories send invalid values here | |
| if (Logger.IsWarnEnabled) | |
| { | |
| Logger.Warn("Found invalid choice value for choice entry \"" + target.DisplayName + "\"!", e); | |
| } | |
| } | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_TYPE_CHOICE_CHOICE)) | |
| { | |
| addChoice(parser, target); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| protected abstract void addValue(XmlReader parser, Choice<T> target); | |
| protected abstract void addChoice(XmlReader parser, Choice<T> target); | |
| } | |
| // --------------------------------- | |
| // --- objects and lists parsers --- | |
| // --------------------------------- | |
| private static readonly ObjectParser OBJECT_PARSER = new ObjectParser(); | |
| private class ObjectParser : XmlWalker<ObjectData> | |
| { | |
| protected override ObjectData PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new ObjectData(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, ObjectData target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_OBJECT_PROPERTIES)) | |
| { | |
| target.Properties = PROPERTIES_PARSER.Walk(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_OBJECT_ALLOWABLE_ACTIONS)) | |
| { | |
| target.AllowableActions = ALLOWABLE_ACTIONS_PARSER.Walk(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_OBJECT_RELATIONSHIP)) | |
| { | |
| target.Relationships = AddToList(target.Relationships, OBJECT_PARSER.Walk(parser)); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_OBJECT_CHANGE_EVENT_INFO)) | |
| { | |
| target.ChangeEventInfo = CHANGE_EVENT_PARSER.Walk(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_OBJECT_ACL)) | |
| { | |
| target.Acl = ACL_PARSER.Walk(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_OBJECT_EXACT_ACL)) | |
| { | |
| target.IsExactAcl = ReadBoolean(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_OBJECT_POLICY_IDS)) | |
| { | |
| target.PolicyIds = POLICY_IDS_PARSER.Walk(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_OBJECT_RENDITION)) | |
| { | |
| target.Renditions = AddToList(target.Renditions, RENDITION_PARSER.Walk(parser)); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly PropertiesParser PROPERTIES_PARSER = new PropertiesParser(); | |
| private class PropertiesParser : XmlWalker<Properties> | |
| { | |
| protected override Properties PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new Properties(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, Properties target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_PROP_STRING)) | |
| { | |
| target.AddProperty(PROPERTY_STRING_PARSER.Walk(parser)); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROP_ID)) | |
| { | |
| target.AddProperty(PROPERTY_ID_PARSER.Walk(parser)); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROP_BOOLEAN)) | |
| { | |
| target.AddProperty(PROPERTY_BOOLEAN_PARSER.Walk(parser)); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROP_INTEGER)) | |
| { | |
| target.AddProperty(PROPERTY_INTEGER_PARSER.Walk(parser)); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROP_DATETIME)) | |
| { | |
| target.AddProperty(PROPERTY_DATETIME_PARSER.Walk(parser)); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROP_DECIMAL)) | |
| { | |
| target.AddProperty(PROPERTY_DECIMAL_PARSER.Walk(parser)); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROP_HTML)) | |
| { | |
| target.AddProperty(PROPERTY_HTML_PARSER.Walk(parser)); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_PROP_URI)) | |
| { | |
| target.AddProperty(PROPERTY_URI_PARSER.Walk(parser)); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly AllowableActionsParser ALLOWABLE_ACTIONS_PARSER = new AllowableActionsParser(); | |
| private class AllowableActionsParser : XmlWalker<AllowableActions> | |
| { | |
| protected override AllowableActions PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new AllowableActions(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, AllowableActions target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| PortCMIS.Enums.Action? action = localname.GetCmisEnum<PortCMIS.Enums.Action?>(); | |
| if (action != null) | |
| { | |
| ISet<PortCMIS.Enums.Action> actions = target.Actions; | |
| if (actions == null) | |
| { | |
| target.Actions = new HashSet<PortCMIS.Enums.Action>(); | |
| actions = target.Actions; | |
| } | |
| if (ReadBoolean(parser) == true) | |
| { | |
| actions.Add(action.Value); | |
| } | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly ChangeEventParser CHANGE_EVENT_PARSER = new ChangeEventParser(); | |
| private class ChangeEventParser : XmlWalker<ChangeEventInfo> | |
| { | |
| protected override ChangeEventInfo PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new ChangeEventInfo(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, ChangeEventInfo target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_CHANGE_EVENT_TYPE)) | |
| { | |
| target.ChangeType = ReadEnum<ChangeType>(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_CHANGE_EVENT_TIME)) | |
| { | |
| target.ChangeTime = ReadDateTime(parser); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly AclParser ACL_PARSER = new AclParser(); | |
| private class AclParser : XmlWalker<Acl> | |
| { | |
| protected override Acl PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new Acl(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, Acl target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_ACL_PERMISSISONS)) | |
| { | |
| target.Aces = AddToList(target.Aces, ACE_PARSER.Walk(parser)); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly AceParser ACE_PARSER = new AceParser(); | |
| private class AceParser : XmlWalker<Ace> | |
| { | |
| protected override Ace PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new Ace(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, Ace target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_ACE_PRINCIPAL)) | |
| { | |
| target.Principal = PRINCIPAL_PARSER.Walk(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_ACE_PERMISSIONS)) | |
| { | |
| target.Permissions = AddToList(target.Permissions, ReadText(parser)); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_ACE_IS_DIRECT)) | |
| { | |
| bool? isDirect = ReadBoolean(parser); | |
| target.IsDirect = (isDirect != null ? (bool)isDirect : true); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly PrincipalParser PRINCIPAL_PARSER = new PrincipalParser(); | |
| private class PrincipalParser : XmlWalker<Principal> | |
| { | |
| protected override Principal PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new Principal(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, Principal target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_ACE_PRINCIPAL_ID)) | |
| { | |
| target.Id = ReadText(parser); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly PolicyIdsParser POLICY_IDS_PARSER = new PolicyIdsParser(); | |
| private class PolicyIdsParser : XmlWalker<PolicyIdList> | |
| { | |
| protected override PolicyIdList PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new PolicyIdList(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, PolicyIdList target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_POLICY_ID)) | |
| { | |
| target.PolicyIds = AddToList(target.PolicyIds, ReadText(parser)); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly RenditionParser RENDITION_PARSER = new RenditionParser(); | |
| private class RenditionParser : XmlWalker<RenditionData> | |
| { | |
| protected override RenditionData PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new RenditionData(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, RenditionData target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_RENDITION_STREAM_ID)) | |
| { | |
| target.StreamId = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_RENDITION_MIMETYPE)) | |
| { | |
| target.MimeType = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_RENDITION_LENGTH)) | |
| { | |
| target.Length = ReadInteger(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_RENDITION_KIND)) | |
| { | |
| target.Kind = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_RENDITION_TITLE)) | |
| { | |
| target.Title = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_RENDITION_HEIGHT)) | |
| { | |
| target.Height = ReadInteger(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_RENDITION_WIDTH)) | |
| { | |
| target.Width = ReadInteger(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_RENDITION_DOCUMENT_ID)) | |
| { | |
| target.RenditionDocumentId = ReadText(parser); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| // ------------------------ | |
| // --- property parsers --- | |
| // ------------------------ | |
| private static readonly PropertyXmlWalker PROPERTY_STRING_PARSER = new PropertyStringParser(); | |
| private class PropertyStringParser : PropertyStringXmlWalker | |
| { | |
| protected override PropertyData createTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new PropertyData(PropertyType.String); | |
| } | |
| }; | |
| private static readonly PropertyXmlWalker PROPERTY_ID_PARSER = new PropertyIdParser(); | |
| private class PropertyIdParser : PropertyStringXmlWalker | |
| { | |
| protected override PropertyData createTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new PropertyData(PropertyType.Id); | |
| } | |
| }; | |
| private static readonly PropertyXmlWalker PROPERTY_HTML_PARSER = new PropertyHtmlParser(); | |
| private class PropertyHtmlParser : PropertyStringXmlWalker | |
| { | |
| protected override PropertyData createTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new PropertyData(PropertyType.Html); | |
| } | |
| }; | |
| private static readonly PropertyXmlWalker PROPERTY_URI_PARSER = new PropertyUriParser(); | |
| private class PropertyUriParser : PropertyStringXmlWalker | |
| { | |
| protected override PropertyData createTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new PropertyData(PropertyType.Uri); | |
| } | |
| }; | |
| private static readonly PropertyXmlWalker PROPERTY_BOOLEAN_PARSER = new PropertyBooleanParser(); | |
| private class PropertyBooleanParser : PropertyXmlWalker | |
| { | |
| protected override PropertyData createTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new PropertyData(PropertyType.Boolean); | |
| } | |
| protected override void addValue(XmlReader parser, PropertyData target) | |
| { | |
| target.Values = AddToList(target.Values, ReadBoolean(parser)); | |
| } | |
| }; | |
| private static readonly PropertyXmlWalker PROPERTY_INTEGER_PARSER = new PropertyIntegerParser(); | |
| private class PropertyIntegerParser : PropertyXmlWalker | |
| { | |
| protected override PropertyData createTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new PropertyData(PropertyType.Integer); | |
| } | |
| protected override void addValue(XmlReader parser, PropertyData target) | |
| { | |
| target.Values = AddToList(target.Values, ReadInteger(parser)); | |
| } | |
| }; | |
| private static readonly PropertyXmlWalker PROPERTY_DECIMAL_PARSER = new PropertyDecimalParser(); | |
| private class PropertyDecimalParser : PropertyXmlWalker | |
| { | |
| protected override PropertyData createTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new PropertyData(PropertyType.Decimal); | |
| } | |
| protected override void addValue(XmlReader parser, PropertyData target) | |
| { | |
| target.Values = AddToList(target.Values, ReadDecimal(parser)); | |
| } | |
| }; | |
| private static readonly PropertyXmlWalker PROPERTY_DATETIME_PARSER = new PropertyDateTimeParser(); | |
| private class PropertyDateTimeParser : PropertyXmlWalker | |
| { | |
| protected override PropertyData createTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new PropertyData(PropertyType.DateTime); | |
| } | |
| protected override void addValue(XmlReader parser, PropertyData target) | |
| { | |
| target.Values = AddToList(target.Values, ReadDateTime(parser)); | |
| } | |
| }; | |
| private abstract class PropertyXmlWalker : XmlWalker<PropertyData> | |
| { | |
| protected abstract PropertyData createTarget(XmlReader parser, string localname, string ns); | |
| protected override PropertyData PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| PropertyData result = createTarget(parser, localname, ns); | |
| if (parser.HasAttributes) | |
| { | |
| result.Id = parser.GetAttribute(XmlConstants.ATTR_PROPERTY_ID); | |
| result.LocalName = parser.GetAttribute(XmlConstants.ATTR_PROPERTY_LOCALNAME); | |
| result.DisplayName = parser.GetAttribute(XmlConstants.ATTR_PROPERTY_DISPLAYNAME); | |
| result.QueryName = parser.GetAttribute(XmlConstants.ATTR_PROPERTY_QUERYNAME); | |
| } | |
| return result; | |
| } | |
| protected abstract void addValue(XmlReader parser, PropertyData target); | |
| protected override bool Read(XmlReader parser, string localname, string ns, PropertyData target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_PROPERTY_VALUE)) | |
| { | |
| try | |
| { | |
| addValue(parser, target); | |
| } | |
| catch (CmisInvalidArgumentException e) | |
| { | |
| // a few repositories send invalid values here | |
| // for example, in some cases SharePoint sends an empty | |
| // "value" tag instead of omitting the "value" tag to | |
| // indicate a "not set" value | |
| // -> being tolerant is better than breaking an | |
| // application because of this | |
| if (Logger.IsWarnEnabled) | |
| { | |
| Logger.Warn("Found invalid property value for property " + target.Id + "!", e); | |
| } | |
| } | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| } | |
| private abstract class PropertyStringXmlWalker : PropertyXmlWalker | |
| { | |
| protected override void addValue(XmlReader parser, PropertyData target) | |
| { | |
| target.Values = AddToList(target.Values, ReadText(parser)); | |
| } | |
| } | |
| // -------------------- | |
| // --- query parser --- | |
| // -------------------- | |
| private static readonly QueryParser QUERY_PARSER = new QueryParser(); | |
| private class QueryParser : XmlWalker<QueryType> | |
| { | |
| protected override QueryType PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new QueryType(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, QueryType target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_QUERY_STATEMENT)) | |
| { | |
| target.Statement = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_QUERY_SEARCHALLVERSIONS)) | |
| { | |
| target.SearchAllVersions = ReadBoolean(parser) ?? false; | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_QUERY_INCLUDEALLOWABLEACTIONS)) | |
| { | |
| target.IncludeAllowableActions = ReadBoolean(parser) ?? false; | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_QUERY_INCLUDERELATIONSHIPS)) | |
| { | |
| target.IncludeRelationships = ReadEnum<IncludeRelationships>(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_QUERY_RENDITIONFILTER)) | |
| { | |
| target.RenditionFilter = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_QUERY_MAXITEMS)) | |
| { | |
| target.MaxItems = ReadInteger(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_QUERY_SKIPCOUNT)) | |
| { | |
| target.SkipCount = ReadInteger(parser); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| // -------------------------- | |
| // --- bulk update parser --- | |
| // -------------------------- | |
| private static readonly BulkUpdateParser BULK_UPDATE_PARSER = new BulkUpdateParser(); | |
| private class BulkUpdateParser : XmlWalker<BulkUpdate> | |
| { | |
| protected override BulkUpdate PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new BulkUpdate(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, BulkUpdate target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_BULK_UPDATE_ID_AND_TOKEN)) | |
| { | |
| target.ObjectIdAndChangeToken = AddToList(target.ObjectIdAndChangeToken, ID_AND_TOKEN_PARSER.Walk(parser)); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_BULK_UPDATE_PROPERTIES)) | |
| { | |
| target.Properties = PROPERTIES_PARSER.Walk(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_BULK_UPDATE_ADD_SECONDARY_TYPES)) | |
| { | |
| target.AddSecondaryTypeIds = AddToList(target.AddSecondaryTypeIds, ReadText(parser)); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_BULK_UPDATE_REMOVE_SECONDARY_TYPES)) | |
| { | |
| target.RemoveSecondaryTypeIds = AddToList(target.RemoveSecondaryTypeIds, ReadText(parser)); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| private static readonly IdAndTokenParser ID_AND_TOKEN_PARSER = new IdAndTokenParser(); | |
| private class IdAndTokenParser : XmlWalker<BulkUpdateObjectIdAndChangeToken> | |
| { | |
| protected override BulkUpdateObjectIdAndChangeToken PrepareTarget(XmlReader parser, string localname, string ns) | |
| { | |
| return new BulkUpdateObjectIdAndChangeToken(); | |
| } | |
| protected override bool Read(XmlReader parser, string localname, string ns, BulkUpdateObjectIdAndChangeToken target) | |
| { | |
| if (IsCmisNamespace(ns)) | |
| { | |
| if (IsTag(localname, XmlConstants.TAG_IDANDTOKEN_ID)) | |
| { | |
| target.Id = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_IDANDTOKEN_NEWID)) | |
| { | |
| target.NewId = ReadText(parser); | |
| return true; | |
| } | |
| if (IsTag(localname, XmlConstants.TAG_IDANDTOKEN_CHANGETOKEN)) | |
| { | |
| target.ChangeToken = ReadText(parser); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }; | |
| } | |
| } |