Google Git
Sign in
apache / chemistry-portcmis / f48c7f41c2c1c31011bb58202439fba8b6e1bdfb / . / PortCMIS / binding / browser / BrowserConverter.cs
blob: 5adaa0b4168f51b255ee0a22c2e1a2ce93691d6a [file] [log] [blame]
/*
* 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 System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using PortCMIS.Binding.Browser.Json;
using PortCMIS.Data;
using PortCMIS.Enums;
using PortCMIS.Exceptions;
using PortCMIS.Data.Extensions;
using System.Collections;
using System.Numerics;
using PortCMIS.Const;
namespace PortCMIS.Binding.Browser
{
internal class JsonConverter
{
public enum PropertyMode
{
Object,
Query,
Change
}
/// <summary>
/// Converts a repository info object.
/// </summary>
internal static JsonObject Convert(IRepositoryInfo repositoryInfo, string repositoryUrl,
string rootUrl, bool addExtendedDatetimeExtensionFeature)
{
if (repositoryInfo == null)
{
return null;
}
JsonObject result = new JsonObject();
result.Add(BrowserConstants.JsonRepInfoId, repositoryInfo.Id);
result.Add(BrowserConstants.JsonRepInfoName, repositoryInfo.Name);
result.Add(BrowserConstants.JsonRepInfoDescription, repositoryInfo.Description);
result.Add(BrowserConstants.JsonRepInfoVendor, repositoryInfo.VendorName);
result.Add(BrowserConstants.JsonRepInfoProduct, repositoryInfo.ProductName);
result.Add(BrowserConstants.JsonRepInfoProductVersion, repositoryInfo.ProductVersion);
result.Add(BrowserConstants.JsonRepInfoRootFolderId, repositoryInfo.RootFolderId);
result.Add(BrowserConstants.JsonRepInfoCapabilities, Convert(repositoryInfo.Capabilities));
SetIfNotNull(BrowserConstants.JsonRepInfoAclCapabilities, Convert(repositoryInfo.AclCapabilities), result);
result.Add(BrowserConstants.JsonRepInfoChangeLogToken, repositoryInfo.LatestChangeLogToken);
result.Add(BrowserConstants.JsonRepInfoCmisVersionSupported, repositoryInfo.CmisVersionSupported);
SetIfNotNull(BrowserConstants.JsonRepInfoThinClientUri, repositoryInfo.ThinClientUri, result);
SetIfNotNull(BrowserConstants.JsonRepInfoChangesIncomplete, repositoryInfo.ChangesIncomplete, result);
JsonArray changesOnType = new JsonArray();
if (repositoryInfo.ChangesOnType != null)
{
foreach (BaseTypeId? type in repositoryInfo.ChangesOnType)
{
if (type != null)
{
changesOnType.Add(GetJsonStringValue(type.GetCmisValue()));
}
}
}
result.Add(BrowserConstants.JsonRepInfoChangesOnType, changesOnType);
SetIfNotNull(BrowserConstants.JsonRepInfoPrincipalIdAnonymous, repositoryInfo.PrincipalIdAnonymous, result);
SetIfNotNull(BrowserConstants.JsonRepInfoPrincipalIdAnyone, repositoryInfo.PrincipalIdAnyone, result);
if (IsNotEmpty(repositoryInfo.ExtensionFeatures))
{
JsonArray extendedFeatures = new JsonArray();
foreach (ExtensionFeature feature in repositoryInfo.ExtensionFeatures)
{
extendedFeatures.Add(Convert(feature));
}
result.Add(BrowserConstants.JsonRepInfoExtendedFeatures, extendedFeatures);
}
if (addExtendedDatetimeExtensionFeature)
{
object extendedFeatures;
if (!result.TryGetValue(BrowserConstants.JsonRepInfoExtendedFeatures, out extendedFeatures))
{
extendedFeatures = new JsonArray();
result.Add(BrowserConstants.JsonRepInfoExtendedFeatures, extendedFeatures);
}
if (extendedFeatures is JsonArray)
{
((JsonArray)extendedFeatures).Add(Convert(ExtensionFeatures.ExtendedDatetimeFormat));
}
}
result.Add(BrowserConstants.JsonRepInfoRepositoryUrl, repositoryUrl);
result.Add(BrowserConstants.JsonRepInfoRootFolderUrl, rootUrl);
ConvertExtension(repositoryInfo, result);
return result;
}
private static JsonObject Convert(IExtensionFeature feature)
{
if (feature == null)
{
return null;
}
JsonObject jsonFeature = new JsonObject();
SetIfNotNull(BrowserConstants.JsonFeatureId, feature.Id, jsonFeature);
SetIfNotNull(BrowserConstants.JsonFeatureUrl, feature.Url, jsonFeature);
SetIfNotNull(BrowserConstants.JsonFeatureCommonName, feature.CommonName, jsonFeature);
SetIfNotNull(BrowserConstants.JsonFeatureVersionLabel, feature.VersionLabel, jsonFeature);
SetIfNotNull(BrowserConstants.JsonFeatureDescription, feature.Description, jsonFeature);
if (IsNotEmpty(feature.FeatureData))
{
JsonObject data = new JsonObject();
foreach (KeyValuePair<string, string> kv in feature.FeatureData)
{
data.Add(kv.Key, kv.Value);
}
jsonFeature.Add(BrowserConstants.JsonFeatureData, data);
}
ConvertExtension(feature, jsonFeature);
return jsonFeature;
}
/// <summary>
/// Converts a capabilities object.
/// </summary>
internal static JsonObject Convert(IRepositoryCapabilities capabilities)
{
if (capabilities == null)
{
return null;
}
JsonObject result = new JsonObject();
result.Add(BrowserConstants.JsonCapContentStreamUpdatability, GetJsonEnumValue(capabilities.ContentStreamUpdatesCapability));
result.Add(BrowserConstants.JsonCapChanges, GetJsonEnumValue(capabilities.ChangesCapability));
result.Add(BrowserConstants.JsonCapRenditions, GetJsonEnumValue(capabilities.RenditionsCapability));
result.Add(BrowserConstants.JsonCapGetDescendants, capabilities.IsGetDescendantsSupported);
result.Add(BrowserConstants.JsonCapGetFolderTree, capabilities.IsGetFolderTreeSupported);
result.Add(BrowserConstants.JsonCapMultifiling, capabilities.IsMultifilingSupported);
result.Add(BrowserConstants.JsonCapUnfiling, capabilities.IsUnfilingSupported);
result.Add(BrowserConstants.JsonCapVersionSpecificFiling, capabilities.IsVersionSpecificFilingSupported);
result.Add(BrowserConstants.JsonCapPwcSearchable, capabilities.IsPwcSearchableSupported);
result.Add(BrowserConstants.JsonCapPwcUpdatable, capabilities.IsPwcUpdatableSupported);
result.Add(BrowserConstants.JsonCapAllVersionsSerachable, capabilities.IsAllVersionsSearchableSupported);
result.Add(BrowserConstants.JsonCapOrderBy, GetJsonEnumValue(capabilities.OrderByCapability));
result.Add(BrowserConstants.JsonCapQuery, GetJsonEnumValue(capabilities.QueryCapability));
result.Add(BrowserConstants.JsonCapJoin, GetJsonEnumValue(capabilities.JoinCapability));
result.Add(BrowserConstants.JsonCapAcl, GetJsonEnumValue(capabilities.AclCapability));
if (capabilities.CreatablePropertyTypes != null)
{
ICreatablePropertyTypes creatablePropertyTypes = capabilities.CreatablePropertyTypes;
JsonObject creatablePropertyTypesJson = new JsonObject();
if (creatablePropertyTypes.CanCreate != null)
{
JsonArray canCreate = new JsonArray();
foreach (PropertyType propType in creatablePropertyTypes.CanCreate)
{
canCreate.Add(propType.GetCmisValue());
}
creatablePropertyTypesJson.Add(BrowserConstants.JsonCapCreatablePropertyTypesCanCreate, canCreate);
}
ConvertExtension(creatablePropertyTypes, creatablePropertyTypesJson);
result.Add(BrowserConstants.JsonCapCreatablePropertyTypes, creatablePropertyTypesJson);
}
if (capabilities.NewTypeSettableAttributes != null)
{
INewTypeSettableAttributes newTypeSettableAttributes = capabilities.NewTypeSettableAttributes;
JsonObject newTypeSettableAttributesJson = new JsonObject();
newTypeSettableAttributesJson.Add(BrowserConstants.JsonCapNewTypeSettableAttributesId,
newTypeSettableAttributes.CanSetId);
newTypeSettableAttributesJson.Add(BrowserConstants.JsonCapNewTypeSettableAttributesLocalName,
newTypeSettableAttributes.CanSetLocalName);
newTypeSettableAttributesJson.Add(BrowserConstants.JsonCapNewTypeSettableAttributesLocalNameSpace,
newTypeSettableAttributes.CanSetLocalNamespace);
newTypeSettableAttributesJson.Add(BrowserConstants.JsonCapNewTypeSettableAttributesDisplayName,
newTypeSettableAttributes.CanSetDisplayName);
newTypeSettableAttributesJson.Add(BrowserConstants.JsonCapNewTypeSettableAttributesQueryName,
newTypeSettableAttributes.CanSetQueryName);
newTypeSettableAttributesJson.Add(BrowserConstants.JsonCapNewTypeSettableAttributesDescription,
newTypeSettableAttributes.CanSetDescription);
newTypeSettableAttributesJson.Add(BrowserConstants.JsonCapNewTypeSettableAttributesCreatable,
newTypeSettableAttributes.CanSetCreatable);
newTypeSettableAttributesJson.Add(BrowserConstants.JsonCapNewTypeSettableAttributesFileable,
newTypeSettableAttributes.CanSetFileable);
newTypeSettableAttributesJson.Add(BrowserConstants.JsonCapNewTypeSettableAttributesQueryable,
newTypeSettableAttributes.CanSetQueryable);
newTypeSettableAttributesJson.Add(BrowserConstants.JsonCapNewTypeSettableAttributesFulltextIndexed,
newTypeSettableAttributes.CanSetFulltextIndexed);
newTypeSettableAttributesJson.Add(BrowserConstants.JsonCapNewTypeSettableAttributesIncludeInSupertypeQuery,
newTypeSettableAttributes.CanSetIncludedInSupertypeQuery);
newTypeSettableAttributesJson.Add(BrowserConstants.JsonCapNewTypeSettableAttributesControlablePolicy,
newTypeSettableAttributes.CanSetControllablePolicy);
newTypeSettableAttributesJson.Add(BrowserConstants.JsonCapNewTypeSettableAttributesControlableAcl,
newTypeSettableAttributes.CanSetControllableAcl);
ConvertExtension(newTypeSettableAttributes, newTypeSettableAttributesJson);
result.Add(BrowserConstants.JsonCapNewTypeSettableAttributes, newTypeSettableAttributesJson);
}
ConvertExtension(capabilities, result);
return result;
}
/// <summary>
/// Converts an Acl capabilities object.
/// </summary>
internal static JsonObject Convert(IAclCapabilities capabilities)
{
if (capabilities == null)
{
return null;
}
JsonObject result = new JsonObject();
result.Add(BrowserConstants.JsonAclCapSupportedPermissions, GetJsonEnumValue(capabilities.SupportedPermissions));
result.Add(BrowserConstants.JsonAclCapAclPropagation, GetJsonEnumValue(capabilities.AclPropagation));
// permissions
if (capabilities.Permissions != null)
{
JsonArray permissions = new JsonArray();
foreach (PermissionDefinition permDef in capabilities.Permissions)
{
JsonObject permission = new JsonObject();
permission.Add(BrowserConstants.JsonAclCapPermissionPermission, permDef.Id);
permission.Add(BrowserConstants.JsonAclCapPermissionDescription, permDef.Description);
permissions.Add(permission);
}
result.Add(BrowserConstants.JsonAclCapPermissions, permissions);
}
// permission mapping
if (capabilities.PermissionMapping != null)
{
JsonArray permissionMapping = new JsonArray();
foreach (PermissionMapping permMap in capabilities.PermissionMapping.Values)
{
JsonArray mappingPermissions = new JsonArray();
if (permMap.Permissions != null)
{
foreach (string p in permMap.Permissions)
{
mappingPermissions.Add(p);
}
}
JsonObject mapping = new JsonObject();
mapping.Add(BrowserConstants.JsonAclCapMappingKey, permMap.Key);
mapping.Add(BrowserConstants.JsonAclCapMappingPermission, mappingPermissions);
permissionMapping.Add(mapping);
}
result.Add(BrowserConstants.JsonAclCapPermissionMapping, permissionMapping);
}
ConvertExtension(capabilities, result);
return result;
}
internal static IRepositoryInfo ConvertRepositoryInfo(JsonObject json)
{
if (json == null)
{
return null;
}
RepositoryInfoBrowserBinding result = new RepositoryInfoBrowserBinding();
result.Id = GetString(json, BrowserConstants.JsonRepInfoId);
result.Name = GetString(json, BrowserConstants.JsonRepInfoName);
result.Description = GetString(json, BrowserConstants.JsonRepInfoDescription);
result.VendorName = GetString(json, BrowserConstants.JsonRepInfoVendor);
result.ProductName = GetString(json, BrowserConstants.JsonRepInfoProduct);
result.ProductVersion = GetString(json, BrowserConstants.JsonRepInfoProductVersion);
result.RootFolderId = GetString(json, BrowserConstants.JsonRepInfoRootFolderId);
result.RepositoryUrl = GetString(json, BrowserConstants.JsonRepInfoRepositoryUrl);
result.RootUrl = GetString(json, BrowserConstants.JsonRepInfoRootFolderUrl);
result.Capabilities = ConvertRepositoryCapabilities(GetJsonObject(json, BrowserConstants.JsonRepInfoCapabilities));
result.AclCapabilities = ConvertAclCapabilities(GetJsonObject(json, BrowserConstants.JsonRepInfoAclCapabilities));
result.LatestChangeLogToken = GetString(json, BrowserConstants.JsonRepInfoChangeLogToken);
result.CmisVersionSupported = GetString(json, BrowserConstants.JsonRepInfoCmisVersionSupported);
result.ThinClientUri = GetString(json, BrowserConstants.JsonRepInfoThinClientUri);
result.ChangesIncomplete = GetBoolean(json, BrowserConstants.JsonRepInfoChangesIncomplete);
JsonArray changesOnType = GetJsonArray(json, BrowserConstants.JsonRepInfoChangesOnType);
if (changesOnType != null)
{
IList<BaseTypeId?> types = new List<BaseTypeId?>();
foreach (object type in changesOnType)
{
if (type != null)
{
types.Add(type.ToString().GetCmisEnum<BaseTypeId>());
}
}
result.ChangesOnType = types;
}
result.PrincipalIdAnonymous = GetString(json, BrowserConstants.JsonRepInfoPrincipalIdAnonymous);
result.PrincipalIdAnyone = GetString(json, BrowserConstants.JsonRepInfoPrincipalIdAnyone);
JsonArray extendedFeatures = GetJsonArray(json, BrowserConstants.JsonRepInfoExtendedFeatures);
if (extendedFeatures != null)
{
IList<IExtensionFeature> features = new List<IExtensionFeature>();
foreach (object extendedFeature in extendedFeatures)
{
JsonObject jsonFeature = GetJsonObject(extendedFeature);
ExtensionFeature feature = new ExtensionFeature();
feature.Id = GetString(jsonFeature, BrowserConstants.JsonFeatureId);
feature.Url = GetString(jsonFeature, BrowserConstants.JsonFeatureUrl);
feature.CommonName = GetString(jsonFeature, BrowserConstants.JsonFeatureCommonName);
feature.VersionLabel = GetString(jsonFeature, BrowserConstants.JsonFeatureVersionLabel);
feature.Description = GetString(jsonFeature, BrowserConstants.JsonFeatureDescription);
JsonObject data = GetJsonObject(jsonFeature, BrowserConstants.JsonFeatureData);
if (data != null)
{
IDictionary<string, string> dataMap = new Dictionary<string, string>();
foreach (KeyValuePair<string, object> kv in data)
{
dataMap.Add(kv.Key, (kv.Value == null ? null : kv.Value.ToString()));
}
if (dataMap.Count > 0)
{
feature.FeatureData = dataMap;
}
}
ConvertExtension(jsonFeature, feature, BrowserConstants.FeatureKeys);
features.Add(feature);
}
if (features.Count > 0)
{
result.ExtensionFeatures = features;
}
}
// handle extensions
ConvertExtension(json, result, BrowserConstants.RepInfoKeys);
return result;
}
internal static IRepositoryCapabilities ConvertRepositoryCapabilities(JsonObject json)
{
if (json == null)
{
return null;
}
RepositoryCapabilities result = new RepositoryCapabilities();
result.ContentStreamUpdatesCapability = GetEnum<CapabilityContentStreamUpdates?>(json, BrowserConstants.JsonCapContentStreamUpdatability);
result.ChangesCapability = GetEnum<CapabilityChanges?>(json, BrowserConstants.JsonCapChanges);
result.RenditionsCapability = GetEnum<CapabilityRenditions?>(json, BrowserConstants.JsonCapRenditions);
result.IsGetDescendantsSupported = GetBoolean(json, BrowserConstants.JsonCapGetDescendants);
result.IsGetFolderTreeSupported = GetBoolean(json, BrowserConstants.JsonCapGetFolderTree);
result.IsMultifilingSupported = GetBoolean(json, BrowserConstants.JsonCapMultifiling);
result.IsUnfilingSupported = GetBoolean(json, BrowserConstants.JsonCapUnfiling);
result.IsVersionSpecificFilingSupported = GetBoolean(json, BrowserConstants.JsonCapVersionSpecificFiling);
result.IsPwcSearchableSupported = GetBoolean(json, BrowserConstants.JsonCapPwcSearchable);
result.IsPwcUpdatableSupported = GetBoolean(json, BrowserConstants.JsonCapPwcUpdatable);
result.IsAllVersionsSearchableSupported = GetBoolean(json, BrowserConstants.JsonCapAllVersionsSerachable);
result.OrderByCapability = GetEnum<CapabilityOrderBy?>(json, BrowserConstants.JsonCapOrderBy);
result.QueryCapability = GetEnum<CapabilityQuery?>(json, BrowserConstants.JsonCapQuery);
result.JoinCapability = GetEnum<CapabilityJoin?>(json, BrowserConstants.JsonCapJoin);
result.AclCapability = GetEnum<CapabilityAcl?>(json, BrowserConstants.JsonCapAcl);
JsonObject creatablePropertyTypesJson = GetJsonObject(json, BrowserConstants.JsonCapCreatablePropertyTypes);
if (creatablePropertyTypesJson != null)
{
CreatablePropertyTypes creatablePropertyTypes = new CreatablePropertyTypes();
JsonArray canCreateJson = GetJsonArray(creatablePropertyTypesJson, BrowserConstants.JsonCapCreatablePropertyTypesCanCreate);
if (canCreateJson != null)
{
ISet<PropertyType> canCreate = new HashSet<PropertyType>();
foreach (object o in canCreateJson)
{
try
{
if (o != null)
{
canCreate.Add(o.ToString().GetCmisEnum<PropertyType>());
}
}
catch (Exception)
{
// ignore
}
}
creatablePropertyTypes.CanCreate = canCreate;
}
ConvertExtension(creatablePropertyTypesJson, creatablePropertyTypes, BrowserConstants.CapCreatablePropertyTypesKeys);
result.CreatablePropertyTypes = creatablePropertyTypes;
}
JsonObject newTypeSettableAttributesJson = GetJsonObject(json, BrowserConstants.JsonCapNewTypeSettableAttributes);
if (newTypeSettableAttributesJson != null)
{
NewTypeSettableAttributes newTypeSettableAttributes = new NewTypeSettableAttributes();
newTypeSettableAttributes.CanSetId = GetBoolean(newTypeSettableAttributesJson,
BrowserConstants.JsonCapNewTypeSettableAttributesId);
newTypeSettableAttributes.CanSetLocalName = GetBoolean(newTypeSettableAttributesJson,
BrowserConstants.JsonCapNewTypeSettableAttributesLocalName);
newTypeSettableAttributes.CanSetLocalNamespace = GetBoolean(newTypeSettableAttributesJson,
BrowserConstants.JsonCapNewTypeSettableAttributesLocalNameSpace);
newTypeSettableAttributes.CanSetDisplayName = GetBoolean(newTypeSettableAttributesJson,
BrowserConstants.JsonCapNewTypeSettableAttributesDisplayName);
newTypeSettableAttributes.CanSetQueryName = GetBoolean(newTypeSettableAttributesJson,
BrowserConstants.JsonCapNewTypeSettableAttributesQueryName);
newTypeSettableAttributes.CanSetDescription = GetBoolean(newTypeSettableAttributesJson,
BrowserConstants.JsonCapNewTypeSettableAttributesDescription);
newTypeSettableAttributes.CanSetCreatable = GetBoolean(newTypeSettableAttributesJson,
BrowserConstants.JsonCapNewTypeSettableAttributesCreatable);
newTypeSettableAttributes.CanSetFileable = GetBoolean(newTypeSettableAttributesJson,
BrowserConstants.JsonCapNewTypeSettableAttributesFileable);
newTypeSettableAttributes.CanSetQueryable = GetBoolean(newTypeSettableAttributesJson,
BrowserConstants.JsonCapNewTypeSettableAttributesQueryable);
newTypeSettableAttributes.CanSetFulltextIndexed = GetBoolean(newTypeSettableAttributesJson,
BrowserConstants.JsonCapNewTypeSettableAttributesFulltextIndexed);
newTypeSettableAttributes.CanSetIncludedInSupertypeQuery = GetBoolean(newTypeSettableAttributesJson,
BrowserConstants.JsonCapNewTypeSettableAttributesIncludeInSupertypeQuery);
newTypeSettableAttributes.CanSetControllablePolicy = GetBoolean(newTypeSettableAttributesJson,
BrowserConstants.JsonCapNewTypeSettableAttributesControlablePolicy);
newTypeSettableAttributes.CanSetControllableAcl = GetBoolean(newTypeSettableAttributesJson,
BrowserConstants.JsonCapNewTypeSettableAttributesControlableAcl);
ConvertExtension(newTypeSettableAttributesJson, newTypeSettableAttributes, BrowserConstants.CapNewTypeSettableAttributesKeys);
result.NewTypeSettableAttributes = newTypeSettableAttributes;
}
// handle extensions
ConvertExtension(json, result, BrowserConstants.CapKeys);
return result;
}
internal static AclCapabilities ConvertAclCapabilities(JsonObject json)
{
if (json == null)
{
return null;
}
AclCapabilities result = new AclCapabilities();
result.SupportedPermissions = GetEnum<SupportedPermissions?>(json, BrowserConstants.JsonAclCapSupportedPermissions);
result.AclPropagation = GetEnum<AclPropagation?>(json, BrowserConstants.JsonAclCapAclPropagation);
JsonArray permissions = GetJsonArray(json, BrowserConstants.JsonAclCapPermissions);
if (permissions != null)
{
IList<IPermissionDefinition> permissionDefinitionList = new List<IPermissionDefinition>();
foreach (object permission in permissions)
{
JsonObject permissionMap = GetJsonObject(permission);
if (permissionMap != null)
{
PermissionDefinition permDef = new PermissionDefinition();
permDef.Id = GetString(permissionMap, BrowserConstants.JsonAclCapPermissionPermission);
permDef.Description = GetString(permissionMap, BrowserConstants.JsonAclCapPermissionDescription);
ConvertExtension(permissionMap, permDef, BrowserConstants.AclCapPermissionKeys);
permissionDefinitionList.Add(permDef);
}
}
result.Permissions = permissionDefinitionList;
}
JsonArray permissionMapping = GetJsonArray(json, BrowserConstants.JsonAclCapPermissionMapping);
if (permissionMapping != null)
{
IDictionary<string, IPermissionMapping> permMap = new Dictionary<string, IPermissionMapping>();
foreach (object permission in permissionMapping)
{
JsonObject permissionMap = GetJsonObject(permission);
if (permissionMap != null)
{
PermissionMapping mapping = new PermissionMapping();
string key = GetString(permissionMap, BrowserConstants.JsonAclCapMappingKey);
mapping.Key = key;
JsonArray perms = GetJsonArray(permissionMap, BrowserConstants.JsonAclCapMappingPermission);
if (perms != null)
{
IList<string> permList = new List<string>();
foreach (object perm in perms)
{
if (perm != null)
{
permList.Add(perm.ToString());
}
}
mapping.Permissions = permList;
}
ConvertExtension(permissionMap, mapping, BrowserConstants.AclCapMappingKeys);
permMap.Add(key, mapping);
}
}
result.PermissionMapping = permMap;
}
// handle extensions
ConvertExtension(json, result, BrowserConstants.AclCapKeys);
return result;
}
internal static ITypeDefinition ConvertTypeDefinition(JsonObject json)
{
if (json == null)
{
return null;
}
AbstractTypeDefinition result = null;
string id = GetString(json, BrowserConstants.JsonTypeId);
// find base type
BaseTypeId? baseType = GetEnum<BaseTypeId?>(json, BrowserConstants.JsonTypeBaseId);
if (baseType == null)
{
throw new CmisInvalidArgumentException("Invalid base type: " + id);
}
switch (baseType)
{
case BaseTypeId.CmisFolder:
result = new FolderTypeDefinition();
break;
case BaseTypeId.CmisDocument:
result = new DocumentTypeDefinition();
((DocumentTypeDefinition)result).ContentStreamAllowed = GetEnum<ContentStreamAllowed?>(json, BrowserConstants.JsonTypeContentstreamAllowed);
((DocumentTypeDefinition)result).IsVersionable = GetBoolean(json, BrowserConstants.JsonTypeVersionable);
break;
case BaseTypeId.CmisRelationship:
result = new RelationshipTypeDefinition();
JsonArray allowedSourceTypes = GetJsonArray(json, BrowserConstants.JsonTypeAllowedSourceTypes);
if (allowedSourceTypes != null)
{
IList<string> types = new List<string>();
foreach (object type in allowedSourceTypes)
{
if (type != null)
{
types.Add(type.ToString());
}
}
((RelationshipTypeDefinition)result).AllowedSourceTypeIds = types;
}
JsonArray allowedTargetTypes = GetJsonArray(json, BrowserConstants.JsonTypeAllowedTargetTypes);
if (allowedTargetTypes != null)
{
IList<string> types = new List<string>();
foreach (object type in allowedTargetTypes)
{
if (type != null)
{
types.Add(type.ToString());
}
}
((RelationshipTypeDefinition)result).AllowedTargetTypeIds = types;
}
break;
case BaseTypeId.CmisPolicy:
result = new PolicyTypeDefinition();
break;
case BaseTypeId.CmisItem:
result = new ItemTypeDefinition();
break;
case BaseTypeId.CmisSecondary:
result = new SecondaryTypeDefinition();
break;
default:
throw new CmisRuntimeException("Type '" + id + "' does not match a base type!");
}
result.BaseTypeId = (BaseTypeId)baseType;
result.Description = GetString(json, BrowserConstants.JsonTypeDescription);
result.DisplayName = GetString(json, BrowserConstants.JsonTypeDisplayname);
result.Id = id;
result.IsControllableAcl = GetBoolean(json, BrowserConstants.JsonTypeControlableAcl);
result.IsControllablePolicy = GetBoolean(json, BrowserConstants.JsonTypeControlablePolicy);
result.IsCreatable = GetBoolean(json, BrowserConstants.JsonTypeCreatable);
result.IsFileable = GetBoolean(json, BrowserConstants.JsonTypeFileable);
result.IsFulltextIndexed = GetBoolean(json, BrowserConstants.JsonTypeFulltextIndexed);
result.IsIncludedInSupertypeQuery = GetBoolean(json, BrowserConstants.JsonTypeIncludeInSuperTypeQuery);
result.IsQueryable = GetBoolean(json, BrowserConstants.JsonTypeQueryable);
result.LocalName = GetString(json, BrowserConstants.JsonTypeLocalName);
result.LocalNamespace = GetString(json, BrowserConstants.JsonTypeLocalNameSpace);
result.ParentTypeId = GetString(json, BrowserConstants.JsonTypeParentId);
result.QueryName = GetString(json, BrowserConstants.JsonTypeQueryName);
JsonObject typeMutabilityJson = GetJsonObject(json, BrowserConstants.JsonTypeTypeMutability);
if (typeMutabilityJson != null)
{
TypeMutability typeMutability = new TypeMutability();
typeMutability.CanCreate = GetBoolean(typeMutabilityJson, BrowserConstants.JsonTypeTypeMutablilityCreate);
typeMutability.CanUpdate = GetBoolean(typeMutabilityJson, BrowserConstants.JsonTypeTypeMutablilityUpdate);
typeMutability.CanDelete = GetBoolean(typeMutabilityJson, BrowserConstants.JsonTypeTypeMutablilityDelete);
ConvertExtension(typeMutabilityJson, typeMutability, BrowserConstants.JsonTypeTypeMutablilityKeys);
result.TypeMutability = typeMutability;
}
JsonObject propertyDefinitions = GetJsonObject(json, BrowserConstants.JsonTypePropertyDefinitions);
if (propertyDefinitions != null)
{
foreach (KeyValuePair<string, object> propDef in propertyDefinitions)
{
result.AddPropertyDefinition(ConvertPropertyDefinition(GetJsonObject(propDef.Value)));
}
}
// handle extensions
ConvertExtension(json, result, BrowserConstants.TypeKeys);
return result;
}
internal static IPropertyDefinition ConvertPropertyDefinition(JsonObject json)
{
if (json == null)
{
return null;
}
PropertyDefinition result = null;
string id = GetString(json, BrowserConstants.JsonPropertyId);
// find property type
PropertyType? propertyType = GetEnum<PropertyType?>(json, BrowserConstants.JsonPropertyTypePropertyType);
if (propertyType == null)
{
throw new CmisRuntimeException("Invalid property type '" + id + "'! Data type not set!");
}
// find cardinality
Cardinality? cardinality = GetEnum<Cardinality?>(json, BrowserConstants.JsonPropertyTypeCardinality);
if (cardinality == null)
{
throw new CmisRuntimeException("Invalid property type '" + id + "'! Cardinality not set!");
}
// set specific values
switch (propertyType)
{
case PropertyType.String:
result = new PropertyStringDefinition();
((PropertyStringDefinition)result).MaxLength = GetInteger(json, BrowserConstants.JsonPropertyTypeMaxLength);
((PropertyStringDefinition)result).Choices = ConvertChoicesString(GetJsonArray(json, BrowserConstants.JsonPropertyTypeChoice));
((PropertyStringDefinition)result).DefaultValue = CopyDefaultValue<string>(json);
break;
case PropertyType.Id:
result = new PropertyIdDefinition();
((PropertyIdDefinition)result).Choices = ConvertChoicesString(GetJsonArray(json, BrowserConstants.JsonPropertyTypeChoice));
((PropertyIdDefinition)result).DefaultValue = CopyDefaultValue<string>(json);
break;
case PropertyType.Boolean:
result = new PropertyBooleanDefinition();
((PropertyBooleanDefinition)result).Choices = ConvertChoicesBoolean(GetJsonArray(json, BrowserConstants.JsonPropertyTypeChoice));
((PropertyBooleanDefinition)result).DefaultValue = CopyDefaultValue<bool?>(json);
break;
case PropertyType.Integer:
result = new PropertyIntegerDefinition();
((PropertyIntegerDefinition)result).MinValue = GetInteger(json, BrowserConstants.JsonPropertyTypeMinValue);
((PropertyIntegerDefinition)result).MaxValue = GetInteger(json, BrowserConstants.JsonPropertyTypeMaxValue);
((PropertyIntegerDefinition)result).Choices = ConvertChoicesInteger(GetJsonArray(json, BrowserConstants.JsonPropertyTypeChoice));
((PropertyIntegerDefinition)result).DefaultValue = CopyDefaultValue<BigInteger?>(json);
break;
case PropertyType.DateTime:
result = new PropertyDateTimeDefinition();
((PropertyDateTimeDefinition)result).DateTimeResolution = GetEnum<DateTimeResolution?>(json, BrowserConstants.JsonPropertyTypeResolution);
((PropertyDateTimeDefinition)result).Choices = ConvertChoicesDateTime(GetJsonArray(json, BrowserConstants.JsonPropertyTypeChoice));
((PropertyDateTimeDefinition)result).DefaultValue = CopyDefaultValue<DateTime?>(json);
break;
case PropertyType.Decimal:
result = new PropertyDecimalDefinition();
((PropertyDecimalDefinition)result).MinValue = GetDecimal(json, BrowserConstants.JsonPropertyTypeMinValue);
((PropertyDecimalDefinition)result).MaxValue = GetDecimal(json, BrowserConstants.JsonPropertyTypeMaxValue);
((PropertyDecimalDefinition)result).Precision = GetEnum<DecimalPrecision?>(json, BrowserConstants.JsonPropertyTypePrecision);
((PropertyDecimalDefinition)result).Choices = ConvertChoicesDecimal(GetJsonArray(json, BrowserConstants.JsonPropertyTypeChoice));
((PropertyDecimalDefinition)result).DefaultValue = CopyDefaultValue<decimal?>(json);
break;
case PropertyType.Html:
result = new PropertyHtmlDefinition();
((PropertyHtmlDefinition)result).Choices = ConvertChoicesString(GetJsonArray(json, BrowserConstants.JsonPropertyTypeChoice));
((PropertyHtmlDefinition)result).DefaultValue = CopyDefaultValue<string>(json);
break;
case PropertyType.Uri:
result = new PropertyUriDefinition();
((PropertyUriDefinition)result).Choices = ConvertChoicesString(GetJsonArray(json, BrowserConstants.JsonPropertyTypeChoice));
((PropertyUriDefinition)result).DefaultValue = CopyDefaultValue<string>(json);
break;
default:
throw new CmisRuntimeException("Property type '" + id + "' does not match a data type!");
}
// generic
result.Id = id;
result.PropertyType = (PropertyType)propertyType;
result.Cardinality = (Cardinality)cardinality;
result.LocalName = GetString(json, BrowserConstants.JsonPropertyTypeLocalName);
result.LocalNamespace = GetString(json, BrowserConstants.JsonPropertyTypeLocalNameSpace);
result.QueryName = GetString(json, BrowserConstants.JsonPropertyTypeQueryName);
result.Description = GetString(json, BrowserConstants.JsonPropertyTypeDescription);
result.DisplayName = GetString(json, BrowserConstants.JsonPropertyTypeDisplayname);
result.IsInherited = GetBoolean(json, BrowserConstants.JsonPropertyTypeInhertited);
result.IsOpenChoice = GetBoolean(json, BrowserConstants.JsonPropertyTypeOpenChoice);
result.IsOrderable = GetBoolean(json, BrowserConstants.JsonPropertyTypeOrderable);
result.IsQueryable = GetBoolean(json, BrowserConstants.JsonPropertyTypeQueryable);
result.IsRequired = GetBoolean(json, BrowserConstants.JsonPropertyTypeRequired);
result.Updatability = GetEnum<Updatability?>(json, BrowserConstants.JsonPropertyTypeUpdatability);
// handle extensions
ConvertExtension(json, result, BrowserConstants.PropertyTypeKeys);
return result;
}
private static IList<T> CopyDefaultValue<T>(JsonObject json)
{
IList<T> result = null;
object defaultValue = null;
if (json.TryGetValue(BrowserConstants.JsonPropertyTypeDefaultValue, out defaultValue))
{
if (defaultValue is JsonArray)
{
result = new List<T>();
foreach (object value in (JsonArray)defaultValue)
{
if (value is T)
{
result.Add((T)value);
}
}
}
else if (defaultValue is T)
{
result = new List<T>() { (T)defaultValue };
}
}
return result;
}
/// <summary>
/// Converts choices.
/// </summary>
private static IList<IChoice<string>> ConvertChoicesString(JsonArray choices)
{
if (choices == null)
{
return null;
}
IList<IChoice<string>> result = new List<IChoice<string>>();
foreach (object obj in choices)
{
if (!(obj is JsonObject))
{
continue;
}
JsonObject choiceJson = (JsonObject)obj;
Choice<string> choice = new Choice<string>();
choice.DisplayName = GetString(choiceJson, BrowserConstants.JsonPropertyTypeChoiceDisplayname);
object choiceValue = choiceJson[BrowserConstants.JsonPropertyTypeChoiceValue];
List<string> values = new List<string>();
if (choiceValue is JsonArray)
{
foreach (object value in (JsonArray)choiceValue)
{
values.Add((string)GetCmisValue(value, PropertyType.String));
}
}
else
{
values.Add((string)GetCmisValue(choiceValue, PropertyType.String));
}
choice.Value = values;
choice.Choices = ConvertChoicesString(GetJsonArray(choiceJson, BrowserConstants.JsonPropertyTypeChoiceChoice));
result.Add(choice);
}
return result;
}
/// <summary>
/// Converts choices.
/// </summary>
private static IList<IChoice<bool?>> ConvertChoicesBoolean(JsonArray choices)
{
if (choices == null)
{
return null;
}
IList<IChoice<bool?>> result = new List<IChoice<bool?>>();
foreach (object obj in choices)
{
if (!(obj is JsonObject))
{
continue;
}
JsonObject choiceJson = (JsonObject)obj;
if (choiceJson != null)
{
Choice<bool?> choice = new Choice<bool?>();
choice.DisplayName = GetString(choiceJson, BrowserConstants.JsonPropertyTypeChoiceDisplayname);
object choiceValue = choiceJson[BrowserConstants.JsonPropertyTypeChoiceValue];
List<bool?> values = new List<bool?>();
if (choiceValue is JsonArray)
{
foreach (object value in (JsonArray)choiceValue)
{
values.Add((bool?)GetCmisValue(value, PropertyType.Boolean));
}
}
else
{
values.Add((bool?)GetCmisValue(choiceValue, PropertyType.Boolean));
}
choice.Value = values;
choice.Choices = ConvertChoicesBoolean(GetJsonArray(choiceJson, BrowserConstants.JsonPropertyTypeChoiceChoice));
result.Add(choice);
}
}
return result;
}
/// <summary>
/// Converts choices.
/// </summary>
private static IList<IChoice<BigInteger?>> ConvertChoicesInteger(JsonArray choices)
{
if (choices == null)
{
return null;
}
IList<IChoice<BigInteger?>> result = new List<IChoice<BigInteger?>>();
foreach (object obj in choices)
{
if (!(obj is JsonObject))
{
continue;
}
JsonObject choiceJson = (JsonObject)obj;
if (choiceJson != null)
{
Choice<BigInteger?> choice = new Choice<BigInteger?>();
choice.DisplayName = GetString(choiceJson, BrowserConstants.JsonPropertyTypeChoiceDisplayname);
object choiceValue = choiceJson[BrowserConstants.JsonPropertyTypeChoiceValue];
List<BigInteger?> values = new List<BigInteger?>();
if (choiceValue is JsonArray)
{
foreach (object value in (JsonArray)choiceValue)
{
values.Add((BigInteger?)GetCmisValue(value, PropertyType.Integer));
}
}
else
{
values.Add((BigInteger?)GetCmisValue(choiceValue, PropertyType.Integer));
}
choice.Value = values;
choice.Choices = ConvertChoicesInteger(GetJsonArray(choiceJson, BrowserConstants.JsonPropertyTypeChoiceChoice));
result.Add(choice);
}
}
return result;
}
/// <summary>
/// Converts choices.
/// </summary>
private static IList<IChoice<decimal?>> ConvertChoicesDecimal(JsonArray choices)
{
if (choices == null)
{
return null;
}
IList<IChoice<decimal?>> result = new List<IChoice<decimal?>>();
foreach (object obj in choices)
{
if (!(obj is JsonObject))
{
continue;
}
JsonObject choiceJson = (JsonObject)obj;
if (choiceJson != null)
{
Choice<decimal?> choice = new Choice<decimal?>();
choice.DisplayName = GetString(choiceJson, BrowserConstants.JsonPropertyTypeChoiceDisplayname);
object choiceValue = choiceJson[BrowserConstants.JsonPropertyTypeChoiceValue];
List<decimal?> values = new List<decimal?>();
if (choiceValue is JsonArray)
{
foreach (object value in (JsonArray)choiceValue)
{
values.Add((decimal?)GetCmisValue(value, PropertyType.Decimal));
}
}
else
{
values.Add((decimal)GetCmisValue(choiceValue, PropertyType.Decimal));
}
choice.Value = values;
choice.Choices = ConvertChoicesDecimal(GetJsonArray(choiceJson, BrowserConstants.JsonPropertyTypeChoiceChoice));
result.Add(choice);
}
}
return result;
}
/// <summary>
/// Converts choices.
/// </summary>
private static IList<IChoice<DateTime?>> ConvertChoicesDateTime(JsonArray choices)
{
if (choices == null)
{
return null;
}
IList<IChoice<DateTime?>> result = new List<IChoice<DateTime?>>();
foreach (object obj in choices)
{
if (!(obj is JsonObject))
{
continue;
}
JsonObject choiceJson = (JsonObject)obj;
if (choiceJson != null)
{
Choice<DateTime?> choice = new Choice<DateTime?>();
choice.DisplayName = GetString(choiceJson, BrowserConstants.JsonPropertyTypeChoiceDisplayname);
object choiceValue = choiceJson[BrowserConstants.JsonPropertyTypeChoiceValue];
List<DateTime?> values = new List<DateTime?>();
if (choiceValue is JsonArray)
{
foreach (object value in (JsonArray)choiceValue)
{
values.Add((DateTime?)GetCmisValue(value, PropertyType.DateTime));
}
}
else
{
values.Add((DateTime)GetCmisValue(choiceValue, PropertyType.DateTime));
}
choice.Value = values;
choice.Choices = ConvertChoicesDateTime(GetJsonArray(choiceJson, BrowserConstants.JsonPropertyTypeChoiceChoice));
result.Add(choice);
}
}
return result;
}
/// <summary>
/// Converts an object.
/// </summary>
internal static JsonObject Convert(IObjectData objectData, ITypeCache typeCache, PropertyMode propertyMode, bool succinct, DateTimeFormat dateTimeFormat)
{
if (objectData == null)
{
return null;
}
JsonObject result = new JsonObject();
// properties
if (objectData.Properties != null)
{
if (succinct)
{
JsonObject properties = Convert(objectData.Properties, objectData.Id, typeCache, propertyMode, true,
dateTimeFormat);
if (properties != null)
{
result.Add(BrowserConstants.JsonObjectSuccinctProperties, properties);
}
}
else
{
JsonObject properties = Convert(objectData.Properties, objectData.Id, typeCache, propertyMode, false,
dateTimeFormat);
if (properties != null)
{
result.Add(BrowserConstants.JsonObjectProperties, properties);
}
}
JsonObject propertiesExtension = new JsonObject();
ConvertExtension(objectData.Properties, propertiesExtension);
if (propertiesExtension.Count > 0)
{
result.Add(BrowserConstants.JsonObjectPropertiesExtension, propertiesExtension);
}
}
// allowable actions
if (objectData.AllowableActions != null)
{
result.Add(BrowserConstants.JsonObjectAllowableActions, Convert(objectData.AllowableActions));
}
// relationships
if (IsNotEmpty(objectData.Relationships))
{
JsonArray relationships = new JsonArray();
foreach (ObjectData relationship in objectData.Relationships)
{
relationships.Add(Convert(relationship, typeCache, propertyMode, succinct, dateTimeFormat));
}
result.Add(BrowserConstants.JsonObjectRelationships, relationships);
}
// change event info
if (objectData.ChangeEventInfo != null && propertyMode == PropertyMode.Change)
{
JsonObject changeEventInfo = new JsonObject();
IChangeEventInfo cei = objectData.ChangeEventInfo;
changeEventInfo.Add(BrowserConstants.JsonChangeEventType, GetJsonEnumValue(cei.ChangeType));
changeEventInfo.Add(BrowserConstants.JsonChangeEventTime, GetJsonValue(cei.ChangeTime, dateTimeFormat));
ConvertExtension(objectData.ChangeEventInfo, changeEventInfo);
result.Add(BrowserConstants.JsonObjectChangeEventInfo, changeEventInfo);
}
// Acl
if ((objectData.Acl != null) && (objectData.Acl.Aces != null) && propertyMode != PropertyMode.Query)
{
result.Add(BrowserConstants.JsonObjectAcl, Convert(objectData.Acl));
}
SetIfNotNull(BrowserConstants.JsonObjectExactAcl, objectData.IsExactAcl, result);
// policy ids
if ((objectData.PolicyIds != null) && (objectData.PolicyIds.PolicyIds != null) && propertyMode != PropertyMode.Query)
{
JsonObject policyIds = new JsonObject();
JsonArray ids = new JsonArray();
policyIds.Add(BrowserConstants.JsonObjectPolicyIdsIds, ids);
foreach (string pi in objectData.PolicyIds.PolicyIds)
{
ids.Add(pi);
}
ConvertExtension(objectData.PolicyIds, policyIds);
result.Add(BrowserConstants.JsonObjectPolicyIds, policyIds);
}
// renditions
if (IsNotEmpty(objectData.Renditions))
{
JsonArray renditions = new JsonArray();
foreach (RenditionData rendition in objectData.Renditions)
{
renditions.Add(Convert(rendition));
}
result.Add(BrowserConstants.JsonObjectRenditions, renditions);
}
ConvertExtension(objectData, result);
return result;
}
/// <summary>
/// Converts a bag of properties.
/// </summary>
internal static JsonObject Convert(IProperties properties, string objectId, ITypeCache typeCache, PropertyMode propertyMode, bool succinct, DateTimeFormat dateTimeFormat)
{
if (properties == null)
{
return null;
}
// get the type
ITypeDefinition type = null;
if (typeCache != null)
{
IPropertyData typeProp = properties[PropertyIds.ObjectTypeId];
if (typeProp != null && typeProp.PropertyType == PropertyType.Id)
{
object typeId = typeProp.FirstValue;
if (typeId != null)
{
type = typeCache.GetTypeDefinition(typeId.ToString());
}
}
}
JsonObject result = new JsonObject();
foreach (IPropertyData property in properties.PropertyList)
{
IPropertyDefinition propDef = null;
if (typeCache != null)
{
propDef = typeCache.GetPropertyDefinition(property.Id);
}
if (propDef == null && type != null)
{
propDef = type[property.Id];
}
if (propDef == null && typeCache != null && objectId != null && propertyMode != PropertyMode.Change)
{
typeCache.GetTypeDefinitionForObject(objectId);
propDef = typeCache.GetPropertyDefinition(property.Id);
}
string propId = (propertyMode == PropertyMode.Query ? property.QueryName : property.Id);
if (propId == null)
{
throw new CmisRuntimeException("No query name or alias for property '" + property.Id + "'!");
}
result.Add(propId, Convert(property, propDef, succinct, dateTimeFormat));
}
return result;
}
/// <summary>
/// Converts a property.
/// </summary>
internal static object Convert(IPropertyData property, IPropertyDefinition propDef, bool succinct, DateTimeFormat dateTimeFormat)
{
if (property == null)
{
return null;
}
if (succinct)
{
object result = null;
if (propDef != null)
{
if (IsNullOrEmpty(property.Values))
{
result = null;
}
else if (propDef.Cardinality == Cardinality.Single)
{
result = GetJsonValue(property.Values[0], dateTimeFormat);
}
else
{
JsonArray values = new JsonArray();
foreach (object value in property.Values)
{
values.Add(GetJsonValue(value, dateTimeFormat));
}
result = values;
}
}
else
{
if (IsNullOrEmpty(property.Values))
{
result = null;
}
else
{
JsonArray values = new JsonArray();
foreach (object value in property.Values)
{
values.Add(GetJsonValue(value, dateTimeFormat));
}
result = values;
}
}
return result;
}
else
{
JsonObject result = new JsonObject();
result.Add(BrowserConstants.JsonPropertyId, property.Id);
SetIfNotNull(BrowserConstants.JsonPropertyLocalName, property.LocalName, result);
SetIfNotNull(BrowserConstants.JsonPropertyDisplayname, property.DisplayName, result);
SetIfNotNull(BrowserConstants.JsonPropertyQueryName, property.QueryName, result);
if (propDef != null)
{
result.Add(BrowserConstants.JsonPropertyDatatype, propDef.PropertyType.GetCmisValue());
result.Add(BrowserConstants.JsonPropertyCardinality, GetJsonEnumValue(propDef.Cardinality));
if (IsNullOrEmpty(property.Values))
{
result.Add(BrowserConstants.JsonPropertyValue, null);
}
else if (propDef.Cardinality == Cardinality.Single)
{
result.Add(BrowserConstants.JsonPropertyValue, GetJsonValue(property.Values[0], dateTimeFormat));
}
else
{
JsonArray values = new JsonArray();
foreach (object value in property.Values)
{
values.Add(GetJsonValue(value, dateTimeFormat));
}
result.Add(BrowserConstants.JsonPropertyValue, values);
}
}
else
{
result.Add(BrowserConstants.JsonPropertyDatatype, property.PropertyType.GetCmisValue());
if (IsNullOrEmpty(property.Values))
{
result.Add(BrowserConstants.JsonPropertyValue, null);
}
else
{
JsonArray values = new JsonArray();
foreach (object value in property.Values)
{
values.Add(GetJsonValue(value, dateTimeFormat));
}
result.Add(BrowserConstants.JsonPropertyValue, values);
}
}
ConvertExtension(property, result);
return result;
}
}
/// <summary>
/// Converts allowable actions.
/// </summary>
internal static JsonObject Convert(IAllowableActions allowableActions)
{
if (allowableActions == null)
{
return null;
}
JsonObject result = new JsonObject();
ISet<PortCMIS.Enums.Action> actionSet = allowableActions.Actions;
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);
result.Add(action.GetCmisValue(), actionSet.Contains(action));
}
ConvertExtension(allowableActions, result);
return result;
}
/// <summary>
/// Converts an Acl.
/// </summary>
internal static JsonObject Convert(IAcl acl)
{
if (acl == null || acl.Aces == null)
{
return null;
}
JsonArray aceObjects = new JsonArray();
foreach (IAce ace in acl.Aces)
{
JsonArray permissions = new JsonArray();
if (ace.Permissions != null)
{
foreach (string p in ace.Permissions)
{
permissions.Add(p);
}
}
JsonObject aceObject = new JsonObject();
JsonObject principalObject = new JsonObject();
principalObject.Add(BrowserConstants.JsonAcePrincipalId, ace.PrincipalId);
ConvertExtension(ace.Principal, principalObject);
aceObject.Add(BrowserConstants.JsonAcePrincipal, principalObject);
aceObject.Add(BrowserConstants.JsonAcePermissions, permissions);
aceObject.Add(BrowserConstants.JsonAceIsDirect, ace.IsDirect);
ConvertExtension(ace, aceObject);
aceObjects.Add(aceObject);
}
JsonObject result = new JsonObject();
result.Add(BrowserConstants.JsonAclAces, aceObjects);
SetIfNotNull(BrowserConstants.JsonAclIsExact, acl.IsExact, result);
ConvertExtension(acl, result);
return result;
}
/// <summary>
/// Converts a rendition.
/// </summary>
internal static JsonObject Convert(IRenditionData rendition)
{
if (rendition == null)
{
return null;
}
JsonObject result = new JsonObject();
result.Add(BrowserConstants.JsonRenditionStreamId, rendition.StreamId);
result.Add(BrowserConstants.JsonRenditionMimeType, rendition.MimeType);
result.Add(BrowserConstants.JsonRenditionLength, rendition.Length);
result.Add(BrowserConstants.JsonRenditionKind, rendition.Kind);
SetIfNotNull(BrowserConstants.JsonRenditionTitle, rendition.Title, result);
SetIfNotNull(BrowserConstants.JsonRenditionHeight, rendition.Height, result);
SetIfNotNull(BrowserConstants.JsonRenditionWidth, rendition.Width, result);
SetIfNotNull(BrowserConstants.JsonRenditionDocumentId, rendition.RenditionDocumentId, result);
ConvertExtension(rendition, result);
return result;
}
/// <summary>
/// Converts a query object list.
/// </summary>
internal static JsonObject Convert(IObjectList list, ITypeCache typeCache, PropertyMode propertyMode,
bool succinct, DateTimeFormat dateTimeFormat)
{
if (list == null)
{
return null;
}
JsonObject result = new JsonObject();
JsonArray objects = new JsonArray();
if (list.Objects != null)
{
foreach (IObjectData objectData in list.Objects)
{
objects.Add(Convert(objectData, typeCache, propertyMode, succinct, dateTimeFormat));
}
}
if (propertyMode == PropertyMode.Query)
{
result.Add(BrowserConstants.JsonQueryResultListResults, objects);
SetIfNotNull(BrowserConstants.JsonQueryResultListHasMoreItems, list.HasMoreItems, result);
SetIfNotNull(BrowserConstants.JsonQueryResultListNumItems, list.NumItems, result);
}
else
{
result.Add(BrowserConstants.JsonObjectListObjects, objects);
SetIfNotNull(BrowserConstants.JsonObjectListHasMoreItems, list.HasMoreItems, result);
SetIfNotNull(BrowserConstants.JsonObjectListNumItems, list.NumItems, result);
}
ConvertExtension(list, result);
return result;
}
/// <summary>
/// Converts an object in a folder list.
/// </summary>
internal static JsonObject Convert(IObjectInFolderData objectInFolder, ITypeCache typeCache,
bool succinct, DateTimeFormat dateTimeFormat)
{
if ((objectInFolder == null) || (objectInFolder.Object == null))
{
return null;
}
JsonObject result = new JsonObject();
result.Add(BrowserConstants.JsonObjectInFolderObject, Convert(objectInFolder.Object, typeCache, PropertyMode.Object, succinct, dateTimeFormat));
SetIfNotNull(BrowserConstants.JsonObjectInFolderPathSegment, objectInFolder.PathSegment, result);
ConvertExtension(objectInFolder, result);
return result;
}
/// <summary>
/// Converts a folder list.
/// </summary>
internal static JsonObject Convert(IObjectInFolderList objectInFolderList, ITypeCache typeCache,
bool succinct, DateTimeFormat dateTimeFormat)
{
if (objectInFolderList == null)
{
return null;
}
JsonObject result = new JsonObject();
if (objectInFolderList.Objects != null)
{
JsonArray objects = new JsonArray();
foreach (ObjectInFolderData objectData in objectInFolderList.Objects)
{
objects.Add(Convert(objectData, typeCache, succinct, dateTimeFormat));
}
result.Add(BrowserConstants.JsonObjectInFolderListObjects, objects);
}
SetIfNotNull(BrowserConstants.JsonObjectInFolderListHasMoreItems, objectInFolderList.HasMoreItems, result);
SetIfNotNull(BrowserConstants.JsonObjectInFolderListNumItems, objectInFolderList.NumItems, result);
ConvertExtension(objectInFolderList, result);
return result;
}
/// <summary>
/// Converts a folder container.
/// </summary>
internal static JsonObject Convert(IObjectInFolderContainer container, ITypeCache typeCache, bool succinct, DateTimeFormat dateTimeFormat)
{
if (container == null)
{
return null;
}
JsonObject result = new JsonObject();
result.Add(BrowserConstants.JsonObjectInFolderContainerObject, Convert(container.Object, typeCache, succinct, dateTimeFormat));
if (IsNotEmpty(container.Children))
{
JsonArray children = new JsonArray();
foreach (ObjectInFolderContainer descendant in container.Children)
{
children.Add(Convert(descendant, typeCache, succinct, dateTimeFormat));
}
result.Add(BrowserConstants.JsonObjectInFolderContainerChildren, children);
}
ConvertExtension(container, result);
return result;
}
/// <summary>
/// Converts an object parent.
/// </summary>
internal static JsonObject Convert(IObjectParentData parent, ITypeCache typeCache, bool succinct, DateTimeFormat dateTimeFormat)
{
if ((parent == null) || (parent.Object == null))
{
return null;
}
JsonObject result = new JsonObject();
result.Add(BrowserConstants.JsonObjectParentsObject, Convert(parent.Object, typeCache, PropertyMode.Object, succinct, dateTimeFormat));
if (parent.RelativePathSegment != null)
{
result.Add(BrowserConstants.JsonObjectParentsRelativePathSegment, parent.RelativePathSegment);
}
ConvertExtension(parent, result);
return result;
}
/// <summary>
/// Converts a type definition.
/// </summary>
internal static JsonObject Convert(ITypeDefinition type, DateTimeFormat dateTimeFormat)
{
if (type == null)
{
return null;
}
JsonObject result = new JsonObject();
result.Add(BrowserConstants.JsonTypeId, type.Id);
result.Add(BrowserConstants.JsonTypeLocalName, type.LocalName);
result.Add(BrowserConstants.JsonTypeLocalNameSpace, type.LocalNamespace);
SetIfNotNull(BrowserConstants.JsonTypeDisplayname, type.DisplayName, result);
SetIfNotNull(BrowserConstants.JsonTypeQueryName, type.QueryName, result);
SetIfNotNull(BrowserConstants.JsonTypeDescription, type.Description, result);
result.Add(BrowserConstants.JsonTypeBaseId, type.BaseTypeId.GetCmisValue());
SetIfNotNull(BrowserConstants.JsonTypeParentId, type.ParentTypeId, result);
result.Add(BrowserConstants.JsonTypeCreatable, type.IsCreatable);
result.Add(BrowserConstants.JsonTypeFileable, type.IsFileable);
result.Add(BrowserConstants.JsonTypeQueryable, type.IsQueryable);
result.Add(BrowserConstants.JsonTypeFulltextIndexed, type.IsFulltextIndexed);
result.Add(BrowserConstants.JsonTypeIncludeInSuperTypeQuery, type.IsIncludedInSupertypeQuery);
result.Add(BrowserConstants.JsonTypeControlablePolicy, type.IsControllablePolicy);
result.Add(BrowserConstants.JsonTypeControlableAcl, type.IsControllableAcl);
if (type.TypeMutability != null)
{
ITypeMutability typeMutability = type.TypeMutability;
JsonObject typeMutabilityJson = new JsonObject();
typeMutabilityJson.Add(BrowserConstants.JsonTypeTypeMutablilityCreate, typeMutability.CanCreate);
typeMutabilityJson.Add(BrowserConstants.JsonTypeTypeMutablilityUpdate, typeMutability.CanUpdate);
typeMutabilityJson.Add(BrowserConstants.JsonTypeTypeMutablilityDelete, typeMutability.CanDelete);
ConvertExtension(typeMutability, typeMutabilityJson);
result.Add(BrowserConstants.JsonTypeTypeMutability, typeMutabilityJson);
}
if (type is DocumentTypeDefinition)
{
result.Add(BrowserConstants.JsonTypeVersionable, ((DocumentTypeDefinition)type).IsVersionable);
result.Add(BrowserConstants.JsonTypeContentstreamAllowed, GetJsonEnumValue(((DocumentTypeDefinition)type).ContentStreamAllowed));
}
if (type is RelationshipTypeDefinition)
{
result.Add(BrowserConstants.JsonTypeAllowedSourceTypes, GetJsonArrayFromList(((RelationshipTypeDefinition)type).AllowedSourceTypeIds));
result.Add(BrowserConstants.JsonTypeAllowedTargetTypes, GetJsonArrayFromList(((RelationshipTypeDefinition)type).AllowedTargetTypeIds));
}
if (IsNotEmpty(type.PropertyDefinitions))
{
JsonObject propertyDefs = new JsonObject();
foreach (IPropertyDefinition pd in type.PropertyDefinitions)
{
propertyDefs.Add(pd.Id, Convert(pd, dateTimeFormat));
}
result.Add(BrowserConstants.JsonTypePropertyDefinitions, propertyDefs);
}
ConvertExtension(type, result);
return result;
}
/// <summary>
/// Converts a property type definition.
/// </summary>
internal static JsonObject Convert(IPropertyDefinition propertyDefinition, DateTimeFormat dateTimeFormat)
{
if (propertyDefinition == null)
{
return null;
}
JsonObject result = new JsonObject();
// type specific
if (propertyDefinition is PropertyStringDefinition)
{
SetIfNotNull(BrowserConstants.JsonPropertyTypeMaxLength, ((PropertyStringDefinition)propertyDefinition).MaxLength, result);
AddCmisDefaultValue(((PropertyStringDefinition)propertyDefinition).DefaultValue, propertyDefinition.Cardinality, result, dateTimeFormat);
AddChoices(((PropertyStringDefinition)propertyDefinition).Choices, propertyDefinition.Cardinality, result, dateTimeFormat);
}
else if (propertyDefinition is PropertyIdDefinition)
{
AddCmisDefaultValue(((PropertyIdDefinition)propertyDefinition).DefaultValue, propertyDefinition.Cardinality, result, dateTimeFormat);
AddChoices(((PropertyIdDefinition)propertyDefinition).Choices, propertyDefinition.Cardinality, result, dateTimeFormat);
}
else if (propertyDefinition is PropertyIntegerDefinition)
{
SetIfNotNull(BrowserConstants.JsonPropertyTypeMinValue, ((PropertyIntegerDefinition)propertyDefinition).MinValue, result);
SetIfNotNull(BrowserConstants.JsonPropertyTypeMaxValue, ((PropertyIntegerDefinition)propertyDefinition).MaxValue, result);
AddCmisDefaultValue(((PropertyIntegerDefinition)propertyDefinition).DefaultValue, propertyDefinition.Cardinality, result, dateTimeFormat);
AddChoices(((PropertyIntegerDefinition)propertyDefinition).Choices, propertyDefinition.Cardinality, result, dateTimeFormat);
}
else if (propertyDefinition is PropertyDecimalDefinition)
{
SetIfNotNull(BrowserConstants.JsonPropertyTypeMinValue, ((PropertyDecimalDefinition)propertyDefinition).MinValue, result);
SetIfNotNull(BrowserConstants.JsonPropertyTypeMaxValue, ((PropertyDecimalDefinition)propertyDefinition).MaxValue, result);
DecimalPrecision? precision = ((PropertyDecimalDefinition)propertyDefinition).Precision;
if (precision != null)
{
result.Add(BrowserConstants.JsonPropertyTypePrecision, precision.GetCmisValue());
}
AddCmisDefaultValue(((PropertyDecimalDefinition)propertyDefinition).DefaultValue, propertyDefinition.Cardinality, result, dateTimeFormat);
AddChoices(((PropertyDecimalDefinition)propertyDefinition).Choices, propertyDefinition.Cardinality, result, dateTimeFormat);
}
else if (propertyDefinition is PropertyBooleanDefinition)
{
AddCmisDefaultValue(((PropertyBooleanDefinition)propertyDefinition).DefaultValue, propertyDefinition.Cardinality, result, dateTimeFormat);
AddChoices(((PropertyBooleanDefinition)propertyDefinition).Choices, propertyDefinition.Cardinality, result, dateTimeFormat);
}
else if (propertyDefinition is PropertyDateTimeDefinition)
{
DateTimeResolution? resolution = ((PropertyDateTimeDefinition)propertyDefinition).DateTimeResolution;
if (resolution != null)
{
result.Add(BrowserConstants.JsonPropertyTypeResolution, resolution.GetCmisValue());
}
AddCmisDefaultValue(((PropertyDateTimeDefinition)propertyDefinition).DefaultValue, propertyDefinition.Cardinality, result, dateTimeFormat);
AddChoices(((PropertyDateTimeDefinition)propertyDefinition).Choices, propertyDefinition.Cardinality, result, dateTimeFormat);
}
else if (propertyDefinition is PropertyHtmlDefinition)
{
AddCmisDefaultValue(((PropertyHtmlDefinition)propertyDefinition).DefaultValue, propertyDefinition.Cardinality, result, dateTimeFormat);
AddChoices(((PropertyHtmlDefinition)propertyDefinition).Choices, propertyDefinition.Cardinality, result, dateTimeFormat);
}
else if (propertyDefinition is PropertyUriDefinition)
{
AddCmisDefaultValue(((PropertyUriDefinition)propertyDefinition).DefaultValue, propertyDefinition.Cardinality, result, dateTimeFormat);
AddChoices(((PropertyUriDefinition)propertyDefinition).Choices, propertyDefinition.Cardinality, result, dateTimeFormat);
}
else
{
throw new CmisRuntimeException("Invalid property definition!");
}
// generic
result.Add(BrowserConstants.JsonPropertyTypeId, propertyDefinition.Id);
result.Add(BrowserConstants.JsonPropertyTypeLocalName, propertyDefinition.LocalName);
SetIfNotNull(BrowserConstants.JsonPropertyTypeLocalNameSpace, propertyDefinition.LocalNamespace, result);
SetIfNotNull(BrowserConstants.JsonPropertyTypeDisplayname, propertyDefinition.DisplayName, result);
SetIfNotNull(BrowserConstants.JsonPropertyTypeQueryName, propertyDefinition.QueryName, result);
SetIfNotNull(BrowserConstants.JsonPropertyTypeDescription, propertyDefinition.Description, result);
result.Add(BrowserConstants.JsonPropertyTypePropertyType, propertyDefinition.PropertyType.GetCmisValue());
result.Add(BrowserConstants.JsonPropertyTypeCardinality, GetJsonEnumValue(propertyDefinition.Cardinality));
result.Add(BrowserConstants.JsonPropertyTypeUpdatability, GetJsonEnumValue(propertyDefinition.Updatability));
SetIfNotNull(BrowserConstants.JsonPropertyTypeInhertited, propertyDefinition.IsInherited, result);
result.Add(BrowserConstants.JsonPropertyTypeRequired, propertyDefinition.IsRequired);
result.Add(BrowserConstants.JsonPropertyTypeQueryable, propertyDefinition.IsQueryable);
result.Add(BrowserConstants.JsonPropertyTypeOrderable, propertyDefinition.IsOrderable);
SetIfNotNull(BrowserConstants.JsonPropertyTypeOpenChoice, propertyDefinition.IsOpenChoice, result);
ConvertExtension(propertyDefinition, result);
return result;
}
private static void AddCmisDefaultValue<T>(IList<T> defaultValue, Cardinality? cardinality, JsonObject target, DateTimeFormat dateTimeFormat)
{
if (defaultValue == null)
{
return;
}
if (cardinality == Cardinality.Single)
{
if (defaultValue.Count > 0)
{
target.Add(BrowserConstants.JsonPropertyTypeDefaultValue, GetJsonValue(defaultValue[0], dateTimeFormat));
}
}
else
{
JsonArray values = new JsonArray();
foreach (object value in defaultValue)
{
values.Add(GetJsonValue(value, dateTimeFormat));
}
target.Add(BrowserConstants.JsonPropertyTypeDefaultValue, values);
}
}
private static void AddChoices<T>(IList<IChoice<T>> choices, Cardinality? cardinality, JsonObject target, DateTimeFormat dateTimeFormat)
{
if (choices == null)
{
return;
}
target.Add(BrowserConstants.JsonPropertyTypeChoice, ConvertChoices(choices, cardinality, dateTimeFormat));
}
/// <summary>
/// Converts choices.
/// </summary>
private static JsonArray ConvertChoices<T>(IList<IChoice<T>> choices, Cardinality? cardinality, DateTimeFormat dateTimeFormat)
{
if (choices == null)
{
return null;
}
JsonArray result = new JsonArray();
foreach (IChoice<object> choice in choices)
{
JsonObject jsonChoice = new JsonObject();
jsonChoice.Add(BrowserConstants.JsonPropertyTypeChoiceDisplayname, choice.DisplayName);
if (cardinality == Cardinality.Single)
{
if (choice.Value.Count > 0)
{
jsonChoice.Add(BrowserConstants.JsonPropertyTypeChoiceValue, GetJsonValue(choice.Value[0], dateTimeFormat));
}
}
else
{
JsonArray values = new JsonArray();
foreach (object value in choice.Value)
{
values.Add(GetJsonValue(value, dateTimeFormat));
}
jsonChoice.Add(BrowserConstants.JsonPropertyTypeChoiceValue, values);
}
if (IsNotEmpty(choice.Choices))
{
jsonChoice.Add(BrowserConstants.JsonPropertyTypeChoiceChoice, ConvertChoices(choice.Choices, cardinality, dateTimeFormat));
}
result.Add(jsonChoice);
}
return result;
}
/// <summary>
/// Converts a type definition list.
/// </summary>
internal static JsonObject Convert(ITypeDefinitionList list, DateTimeFormat dateTimeFormat)
{
if (list == null)
{
return null;
}
JsonObject result = new JsonObject();
if (list.List != null)
{
JsonArray objects = new JsonArray();
foreach (ITypeDefinition type in list.List)
{
objects.Add(Convert(type, dateTimeFormat));
}
result.Add(BrowserConstants.JsonTypeListTypes, objects);
}
SetIfNotNull(BrowserConstants.JsonTypeListHasMoreItems, list.HasMoreItems, result);
SetIfNotNull(BrowserConstants.JsonTypeListNumItems, list.NumItems, result);
ConvertExtension(list, result);
return result;
}
/// <summary>
/// Converts a type definition list.
/// </summary>
internal static ITypeDefinitionList ConvertTypeChildren(JsonObject json)
{
if (json == null)
{
return null;
}
TypeDefinitionList result = new TypeDefinitionList();
JsonArray typesList = GetJsonArray(json, BrowserConstants.JsonTypeListTypes);
IList<ITypeDefinition> types = new List<ITypeDefinition>();
if (typesList != null)
{
foreach (object type in typesList)
{
if (type is JsonObject)
{
types.Add(ConvertTypeDefinition((JsonObject)type));
}
}
}
result.List = types;
result.HasMoreItems = GetBoolean(json, BrowserConstants.JsonTypeListHasMoreItems);
result.NumItems = GetInteger(json, BrowserConstants.JsonTypeListNumItems);
ConvertExtension(json, result, BrowserConstants.TypeListKeys);
return result;
}
/// <summary>
/// Converts a type definition container.
/// </summary>
internal static JsonObject Convert(ITypeDefinitionContainer container, DateTimeFormat dateTimeFormat)
{
if (container == null)
{
return null;
}
JsonObject result = new JsonObject();
result.Add(BrowserConstants.JsonTypesContainerType, Convert(container.TypeDefinition, dateTimeFormat));
if (IsNotEmpty(container.Children))
{
JsonArray children = new JsonArray();
foreach (ITypeDefinitionContainer child in container.Children)
{
children.Add(Convert(child, dateTimeFormat));
}
result.Add(BrowserConstants.JsonTypesContainerChildren, children);
}
ConvertExtension(container, result);
return result;
}
/// <summary>
/// Converts a type definition list.
/// </summary>
internal static IList<ITypeDefinitionContainer> ConvertTypeDescendants(JsonArray json)
{
if (json == null)
{
return null;
}
if (json.Count == 0)
{
return new List<ITypeDefinitionContainer>();
}
IList<ITypeDefinitionContainer> result = new List<ITypeDefinitionContainer>();
foreach (object obj in json)
{
if (obj is JsonObject)
{
JsonObject jsonContainer = (JsonObject)obj;
TypeDefinitionContainer container = new TypeDefinitionContainer();
container.TypeDefinition = ConvertTypeDefinition(GetJsonObject(jsonContainer, BrowserConstants.JsonTypesContainerType));
JsonArray children = GetJsonArray(jsonContainer, BrowserConstants.JsonTypesContainerChildren);
if (children != null)
{
container.Children = ConvertTypeDescendants(children);
}
else
{
container.Children = new List<ITypeDefinitionContainer>();
}
ConvertExtension(jsonContainer, container, BrowserConstants.TypesContainerKeys);
result.Add(container);
}
}
return result;
}
/// <summary>
/// Converts an object.
/// </summary>
internal static IObjectData ConvertObject(JsonObject json, ITypeCache typeCache)
{
if (json == null)
{
return null;
}
ObjectData result = new ObjectData();
result.Acl = ConvertAcl(GetJsonObject(json, BrowserConstants.JsonObjectAcl));
result.AllowableActions = ConvertAllowableActions(GetJsonObject(json, BrowserConstants.JsonObjectAllowableActions));
JsonObject jsonChangeEventInfo = GetJsonObject(json, BrowserConstants.JsonObjectChangeEventInfo);
if (jsonChangeEventInfo != null)
{
ChangeEventInfo changeEventInfo = new ChangeEventInfo();
changeEventInfo.ChangeTime = GetDateTime(jsonChangeEventInfo, BrowserConstants.JsonChangeEventTime);
changeEventInfo.ChangeType = GetEnum<ChangeType?>(jsonChangeEventInfo, BrowserConstants.JsonChangeEventType);
ConvertExtension(json, result, BrowserConstants.ChangeEventKeys);
result.ChangeEventInfo = changeEventInfo;
}
result.IsExactAcl = GetBoolean(json, BrowserConstants.JsonObjectExactAcl);
result.PolicyIds = ConvertPolicyIds(GetJsonObject(json, BrowserConstants.JsonObjectPolicyIds));
JsonObject propMap = GetJsonObject(json, BrowserConstants.JsonObjectSuccinctProperties);
if (propMap != null)
{
result.Properties = ConvertSuccinctProperties(propMap, GetJsonObject(json, BrowserConstants.JsonObjectPropertiesExtension), typeCache);
}
propMap = GetJsonObject(json, BrowserConstants.JsonObjectProperties);
if (propMap != null)
{
result.Properties = ConvertProperties(propMap, GetJsonObject(json, BrowserConstants.JsonObjectPropertiesExtension));
}
JsonArray jsonRelationships = GetJsonArray(json, BrowserConstants.JsonObjectRelationships);
if (jsonRelationships != null)
{
result.Relationships = ConvertObjects(jsonRelationships, typeCache);
}
JsonArray jsonRenditions = GetJsonArray(json, BrowserConstants.JsonObjectRenditions);
if (jsonRenditions != null)
{
result.Renditions = ConvertRenditions(jsonRenditions);
}
ConvertExtension(json, result, BrowserConstants.ObjectKeys);
return result;
}
/// <summary>
/// Converts an object.
/// </summary>
internal static IList<IObjectData> ConvertObjects(List<object> json, ITypeCache typeCache)
{
if (json == null)
{
return null;
}
IList<IObjectData> result = new List<IObjectData>();
foreach (object obj in json)
{
IObjectData relationship = ConvertObject(GetJsonObject(obj), typeCache);
if (relationship != null)
{
result.Add(relationship);
}
}
return result;
}
/// <summary>
/// Converts an Acl.
/// </summary>
internal static IAcl ConvertAcl(JsonObject json)
{
if (json == null)
{
return null;
}
Acl result = new Acl();
List<IAce> aces = new List<IAce>();
JsonArray jsonAces = GetJsonArray(json, BrowserConstants.JsonAclAces);
if (jsonAces != null)
{
foreach (Object obj in jsonAces)
{
JsonObject entry = GetJsonObject(obj);
if (entry != null)
{
Ace ace = new Ace();
bool? isDirect = GetBoolean(entry, BrowserConstants.JsonAceIsDirect);
ace.IsDirect = (isDirect != null ? (bool)isDirect : true);
JsonArray jsonPermissions = GetJsonArray(entry, BrowserConstants.JsonAcePermissions);
if (jsonPermissions != null)
{
List<string> permissions = new List<string>();
foreach (object perm in jsonPermissions)
{
if (perm != null)
{
permissions.Add(perm.ToString());
}
}
ace.Permissions = permissions;
}
JsonObject jsonPrincipal = GetJsonObject(entry, BrowserConstants.JsonAcePrincipal);
if (jsonPrincipal != null)
{
Principal principal = new Principal();
principal.Id = GetString(jsonPrincipal, BrowserConstants.JsonAcePrincipalId);
ConvertExtension(jsonPrincipal, principal, BrowserConstants.PrincipalKeys);
ace.Principal = principal;
}
ConvertExtension(entry, ace, BrowserConstants.AceKeys);
aces.Add(ace);
}
}
}
result.Aces = aces;
result.IsExact = GetBoolean(json, BrowserConstants.JsonAclIsExact);
ConvertExtension(json, result, BrowserConstants.AclKeys);
return result;
}
/// <summary>
/// Converts allowable actions.
/// </summary>
internal static AllowableActions ConvertAllowableActions(JsonObject json)
{
if (json == null)
{
return null;
}
AllowableActions result = new AllowableActions();
ISet<PortCMIS.Enums.Action> allowableActions = new HashSet<PortCMIS.Enums.Action>();
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);
bool? cmisValue = GetBoolean(json, action.GetCmisValue());
if (cmisValue != null && cmisValue == true)
{
allowableActions.Add(action);
}
}
result.Actions = allowableActions;
ConvertExtension(json, result, BrowserConstants.AllowableActionsKeys);
return result;
}
/// <summary>
/// Converts a list of policy ids.
/// </summary>
internal static PolicyIdList ConvertPolicyIds(JsonObject json)
{
if (json == null)
{
return null;
}
PolicyIdList result = new PolicyIdList();
List<string> policyIds = new List<string>();
JsonArray ids = GetJsonArray(json, BrowserConstants.JsonObjectPolicyIdsIds);
if (ids != null)
{
foreach (object obj in ids)
{
if (obj is string)
{
policyIds.Add((string)obj);
}
}
}
ConvertExtension(json, result, BrowserConstants.PolicyIdsKeys);
result.PolicyIds = policyIds;
return result;
}
/// <summary>
/// Converts properties.
/// </summary>
internal static IProperties ConvertProperties(JsonObject json, JsonObject extJson)
{
if (json == null)
{
return null;
}
Properties result = new Properties();
foreach (KeyValuePair<string, object> jsonProperty in json)
{
JsonObject jsonPropertyMap = GetJsonObject(jsonProperty.Value);
if (jsonPropertyMap != null)
{
string id = GetString(jsonPropertyMap, BrowserConstants.JsonPropertyId);
string queryName = GetString(jsonPropertyMap, BrowserConstants.JsonPropertyQueryName);
if (id == null && queryName == null)
{
throw new CmisRuntimeException("Invalid property! Neither a property ID nor a query name is provided!");
}
PropertyType? propertyType;
try
{
string propertyTypeStr = GetString(jsonPropertyMap, BrowserConstants.JsonPropertyDatatype);
propertyType = propertyTypeStr.GetCmisEnum<PropertyType>();
}
catch (Exception e)
{
throw new CmisRuntimeException("Invalid property datatype: " + id, e);
}
if (propertyType == null)
{
throw new CmisRuntimeException("Invalid property datatype: " + id);
}
object value = jsonPropertyMap[BrowserConstants.JsonPropertyValue];
IList<object> values = null;
if (value is JsonArray)
{
values = (JsonArray)value;
}
else if (value != null)
{
values = new List<object>() { value };
}
PropertyData property = new PropertyData((PropertyType)propertyType);
switch (propertyType)
{
case PropertyType.String:
case PropertyType.Id:
case PropertyType.Html:
case PropertyType.Uri:
property.Values = CopyStringValues(values);
break;
case PropertyType.Boolean:
property.Values = CopyBooleanValues(values);
break;
case PropertyType.Integer:
property.Values = CopyIntegerValues(values);
break;
case PropertyType.Decimal:
property.Values = CopyDecimalValues(values);
break;
case PropertyType.DateTime:
property.Values = CopyDateTimeValues(values);
break;
default:
throw new CmisRuntimeException("Unknown property type!");
}
property.Id = id;
property.DisplayName = GetString(jsonPropertyMap, BrowserConstants.JsonPropertyDisplayname);
property.QueryName = queryName;
property.LocalName = GetString(jsonPropertyMap, BrowserConstants.JsonPropertyLocalName);
ConvertExtension(jsonPropertyMap, property, BrowserConstants.PropertyKeys);
result.AddProperty(property);
}
}
if (extJson != null)
{
ConvertExtension(extJson, result, new HashSet<string>());
}
return result;
}
/// <summary>
/// Converts properties.
/// </summary>
internal static IProperties ConvertSuccinctProperties(JsonObject json, JsonObject extJson, ITypeCache typeCache)
{
if (json == null)
{
return null;
}
ITypeDefinition typeDef = null;
// TODO: try....
object objectTypeId;
if (json.TryGetValue(PropertyIds.ObjectTypeId, out objectTypeId))
{
if (objectTypeId is string)
{
typeDef = typeCache.GetTypeDefinition((string)objectTypeId);
}
}
JsonArray secTypeIds = GetJsonArray(json, PropertyIds.SecondaryObjectTypeIds);
IList<ITypeDefinition> secTypeDefs = null;
if (IsNotEmpty(secTypeIds))
{
secTypeDefs = new List<ITypeDefinition>(secTypeIds.Count);
foreach (object secTypeId in secTypeIds)
{
if (secTypeId is String)
{
secTypeDefs.Add(typeCache.GetTypeDefinition((string)secTypeId));
}
}
}
Properties result = new Properties();
foreach (KeyValuePair<string, object> kv in json)
{
string id = kv.Key;
IPropertyDefinition propDef = null;
if (typeDef != null)
{
propDef = typeDef[id];
}
if (propDef == null && secTypeDefs != null)
{
foreach (ITypeDefinition secTypeDef in secTypeDefs)
{
if (secTypeDef != null && secTypeDef.PropertyDefinitions != null)
{
propDef = secTypeDef[id];
if (propDef != null)
{
break;
}
}
}
}
if (propDef == null)
{
propDef = typeCache.GetTypeDefinition(BaseTypeId.CmisDocument.GetCmisValue())[id];
}
if (propDef == null)
{
propDef = typeCache.GetTypeDefinition(BaseTypeId.CmisFolder.GetCmisValue())[id];
}
if (propDef == null && typeDef != null)
{
ITypeDefinition reloadedTypeDef = typeCache.ReloadTypeDefinition(typeDef.Id);
if (reloadedTypeDef != null)
{
propDef = reloadedTypeDef[id];
}
}
if (propDef == null && secTypeDefs != null)
{
foreach (ITypeDefinition secTypeDef in secTypeDefs)
{
ITypeDefinition reloadedTypeDef = typeCache.ReloadTypeDefinition(secTypeDef.Id);
if (reloadedTypeDef != null && reloadedTypeDef.PropertyDefinitions != null)
{
propDef = reloadedTypeDef[id];
if (propDef != null)
{
break;
}
}
}
}
IList<object> values = null;
if (kv.Value is JsonArray)
{
values = (JsonArray)kv.Value;
}
else if (kv.Value != null)
{
values = new List<object>() { kv.Value };
}
PropertyData property = null;
if (propDef != null)
{
property = new PropertyData(propDef.PropertyType);
switch (propDef.PropertyType)
{
case PropertyType.String:
case PropertyType.Id:
case PropertyType.Html:
case PropertyType.Uri:
property.Values = CopyStringValues(values);
break;
case PropertyType.Boolean:
property.Values = CopyBooleanValues(values);
break;
case PropertyType.Integer:
property.Values = CopyIntegerValues(values);
break;
case PropertyType.Decimal:
property.Values = CopyDecimalValues(values);
break;
case PropertyType.DateTime:
property.Values = CopyDateTimeValues(values);
break;
default:
throw new CmisRuntimeException("Unknown property type!");
}
property.Id = id;
property.DisplayName = propDef.DisplayName;
property.QueryName = propDef.QueryName;
property.LocalName = propDef.LocalName;
}
else
{
// this else block should only be reached in rare circumstances
// it may return incorrect types
if (values == null)
{
property = new PropertyData(PropertyType.String);
property.Values = null;
}
else
{
object firstValue = values[0];
if (firstValue is bool)
{
property = new PropertyData(PropertyType.Boolean);
property.Values = CopyBooleanValues(values);
}
else if (firstValue is BigInteger)
{
property = new PropertyData(PropertyType.Integer);
property.Values = CopyIntegerValues(values);
}
else if (firstValue is decimal)
{
property = new PropertyData(PropertyType.Decimal);
property.Values = CopyDecimalValues(values);
}
else
{
property = new PropertyData(PropertyType.String);
property.Values = CopyStringValues(values);
}
}
property.Id = id;
property.DisplayName = id;
property.QueryName = null;
property.LocalName = null;
}
result.AddProperty(property);
}
if (extJson != null)
{
ConvertExtension(extJson, result, new HashSet<string>());
}
return result;
}
private static IList<object> CopyStringValues(IList<object> source)
{
List<object> result = null;
if (source != null)
{
result = new List<object>(source.Count);
foreach (object obj in source)
{
if (obj is string)
{
result.Add((string)obj);
}
else
{
throw new CmisRuntimeException("Invalid property value: " + obj);
}
}
}
return result;
}
private static IList<object> CopyBooleanValues(IList<object> source)
{
List<object> result = null;
if (source != null)
{
result = new List<object>(source.Count);
foreach (object obj in source)
{
if (obj is bool)
{
result.Add((bool)obj);
}
else
{
throw new CmisRuntimeException("Invalid property value: " + obj);
}
}
}
return result;
}
private static IList<object> CopyIntegerValues(IList<object> source)
{
List<object> result = null;
if (source != null)
{
result = new List<object>(source.Count);
foreach (object obj in source)
{
if (obj is BigInteger)
{
result.Add((BigInteger)obj);
}
else
{
throw new CmisRuntimeException("Invalid property value: " + obj);
}
}
}
return result;
}
private static IList<object> CopyDecimalValues(IList<object> source)
{
List<object> result = null;
if (source != null)
{
result = new List<object>(source.Count);
foreach (object obj in source)
{
if (obj is decimal)
{
result.Add((decimal)obj);
}
else if (obj is BigInteger)
{
result.Add((decimal)((BigInteger)obj));
}
else
{
throw new CmisRuntimeException("Invalid property value: " + obj);
}
}
}
return result;
}
private static IList<object> CopyDateTimeValues(IList<object> source)
{
List<object> result = null;
if (source != null)
{
result = new List<object>(source.Count);
foreach (object obj in source)
{
if (obj is BigInteger)
{
result.Add(DateTimeHelper.ConvertMillisToDateTime((long)((BigInteger)obj)));
}
else if (obj is string)
{
DateTime dt;
try
{
dt = DateTimeHelper.ParseISO8601((string)obj);
}
catch (Exception e)
{
throw new CmisRuntimeException("Invalid property value: " + obj, e);
}
result.Add(dt);
}
else
{
throw new CmisRuntimeException("Invalid property value: " + obj);
}
}
}
return result;
}
/// <summary>
/// Converts a rendition.
/// </summary>
internal static IRenditionData ConvertRendition(JsonObject json)
{
if (json == null)
{
return null;
}
RenditionData result = new RenditionData();
result.Height = GetInteger(json, BrowserConstants.JsonRenditionHeight);
result.Kind = GetString(json, BrowserConstants.JsonRenditionKind);
result.Length = GetInteger(json, BrowserConstants.JsonRenditionLength);
result.MimeType = GetString(json, BrowserConstants.JsonRenditionMimeType);
result.RenditionDocumentId = GetString(json, BrowserConstants.JsonRenditionDocumentId);
result.StreamId = GetString(json, BrowserConstants.JsonRenditionStreamId);
result.Title = GetString(json, BrowserConstants.JsonRenditionTitle);
result.Width = GetInteger(json, BrowserConstants.JsonRenditionWidth);
ConvertExtension(json, result, BrowserConstants.RenditionKeys);
return result;
}
/// <summary>
/// Converts a list of renditions.
/// </summary>
internal static IList<IRenditionData> ConvertRenditions(List<object> json)
{
if (json == null)
{
return null;
}
IList<IRenditionData> result = new List<IRenditionData>();
foreach (object obj in json)
{
IRenditionData rendition = ConvertRendition(GetJsonObject(obj));
if (rendition != null)
{
result.Add(rendition);
}
}
return result;
}
/// <summary>
/// Converts a object list.
/// </summary>
internal static ObjectInFolderList ConvertObjectInFolderList(JsonObject json, ITypeCache typeCache)
{
if (json == null)
{
return null;
}
ObjectInFolderList result = new ObjectInFolderList();
JsonArray jsonChildren = GetJsonArray(json, BrowserConstants.JsonObjectInFolderListObjects);
IList<IObjectInFolderData> objects = new List<IObjectInFolderData>();
if (jsonChildren != null)
{
foreach (object obj in jsonChildren)
{
JsonObject JsonObject = GetJsonObject(obj);
if (JsonObject != null)
{
objects.Add(ConvertObjectInFolder(JsonObject, typeCache));
}
}
}
result.Objects = objects;
result.HasMoreItems = GetBoolean(json, BrowserConstants.JsonObjectInFolderListHasMoreItems);
result.NumItems = GetInteger(json, BrowserConstants.JsonObjectInFolderListNumItems);
ConvertExtension(json, result, BrowserConstants.ObjectInFolderListKeys);
return result;
}
/// <summary>
/// Converts an object in a folder.
/// </summary>
internal static ObjectInFolderData ConvertObjectInFolder(JsonObject json, ITypeCache typeCache)
{
if (json == null)
{
return null;
}
ObjectInFolderData result = new ObjectInFolderData();
result.Object = ConvertObject(GetJsonObject(json, BrowserConstants.JsonObjectInFolderObject), typeCache);
result.PathSegment = GetString(json, BrowserConstants.JsonObjectInFolderPathSegment);
ConvertExtension(json, result, BrowserConstants.ObjectInFolderKeys);
return result;
}
/// <summary>
/// Converts a descendants tree.
/// </summary>
internal static IList<IObjectInFolderContainer> ConvertDescendants(JsonArray json, ITypeCache typeCache)
{
if (json == null)
{
return null;
}
IList<IObjectInFolderContainer> result = new List<IObjectInFolderContainer>();
foreach (object obj in json)
{
JsonObject desc = GetJsonObject(obj);
if (desc != null)
{
result.Add(ConvertDescendant(desc, typeCache));
}
}
return result;
}
/// <summary>
/// Converts a descendant.
/// </summary>
internal static IObjectInFolderContainer ConvertDescendant(JsonObject json, ITypeCache typeCache)
{
if (json == null)
{
return null;
}
ObjectInFolderContainer result = new ObjectInFolderContainer();
result.Object = ConvertObjectInFolder(GetJsonObject(json, BrowserConstants.JsonObjectInFolderContainerObject), typeCache);
IList<IObjectInFolderContainer> containerList = new List<IObjectInFolderContainer>();
JsonArray jsonContainerList = GetJsonArray(json, BrowserConstants.JsonObjectInFolderContainerChildren);
if (jsonContainerList != null)
{
foreach (object obj in jsonContainerList)
{
JsonObject containerChild = GetJsonObject(obj);
if (containerChild != null)
{
containerList.Add(ConvertDescendant(containerChild, typeCache));
}
}
}
result.Children = containerList;
ConvertExtension(json, result, BrowserConstants.ObjectInFolderContainerKeys);
return result;
}
/// <summary>
/// Converts an object parents list.
/// </summary>
internal static IList<IObjectParentData> ConvertObjectParents(JsonArray json, ITypeCache typeCache)
{
if (json == null)
{
return null;
}
IList<IObjectParentData> result = new List<IObjectParentData>();
foreach (object obj in json)
{
JsonObject jsonParent = GetJsonObject(obj);
if (jsonParent != null)
{
ObjectParentData parent = new ObjectParentData();
parent.Object = ConvertObject(GetJsonObject(jsonParent, BrowserConstants.JsonObjectParentsObject), typeCache);
parent.RelativePathSegment = GetString(jsonParent, BrowserConstants.JsonObjectParentsRelativePathSegment);
ConvertExtension(jsonParent, parent, BrowserConstants.ObjectParentsKeys);
result.Add(parent);
}
}
return result;
}
/// <summary>
/// Converts a object list.
/// </summary>
internal static IObjectList ConvertObjectList(JsonObject json, ITypeCache typeCache, bool isQueryResult)
{
if (json == null)
{
return null;
}
ObjectList result = new ObjectList();
JsonArray jsonChildren = GetJsonArray(json, isQueryResult ? BrowserConstants.JsonQueryResultListResults : BrowserConstants.JsonObjectListObjects);
IList<IObjectData> objects = new List<IObjectData>();
if (jsonChildren != null)
{
foreach (object obj in jsonChildren)
{
JsonObject JsonObject = GetJsonObject(obj);
if (JsonObject != null)
{
objects.Add(ConvertObject(JsonObject, typeCache));
}
}
}
result.Objects = objects;
if (isQueryResult)
{
result.HasMoreItems = GetBoolean(json, BrowserConstants.JsonQueryResultListHasMoreItems);
result.NumItems = GetInteger(json, BrowserConstants.JsonQueryResultListNumItems);
ConvertExtension(json, result, BrowserConstants.QueryResultListKeys);
}
else
{
result.HasMoreItems = GetBoolean(json, BrowserConstants.JsonObjectListHasMoreItems);
result.NumItems = GetInteger(json, BrowserConstants.JsonObjectListNumItems);
ConvertExtension(json, result, BrowserConstants.ObjectListKeys);
}
return result;
}
// -----------------------------------------------------------------
/// <summary>
/// Converts FailedToDelete ids.
/// </summary>
internal static JsonObject Convert(IFailedToDeleteData ftd)
{
if (ftd == null)
{
return null;
}
JsonObject result = new JsonObject();
JsonArray ids = new JsonArray();
if (ftd.Ids != null)
{
foreach (string id in ftd.Ids)
{
ids.Add(id);
}
}
result.Add(BrowserConstants.JsonFailedToDeleteId, ids);
ConvertExtension(ftd, result);
return result;
}
/// <summary>
/// Converts FailedToDelete ids.
/// </summary>
internal static IFailedToDeleteData ConvertFailedToDelete(JsonObject json)
{
if (json == null)
{
return null;
}
FailedToDeleteData result = new FailedToDeleteData();
List<string> ids = new List<string>();
JsonArray jsonIds = GetJsonArray(json, BrowserConstants.JsonFailedToDeleteId);
if (jsonIds != null)
{
foreach (object obj in jsonIds)
{
if (obj != null)
{
ids.Add(obj.ToString());
}
}
}
result.Ids = ids;
ConvertExtension(json, result, BrowserConstants.FailedToDeleteKeys);
return result;
}
// -----------------------------------------------------------------
/// <summary>
/// Converts bulk update data.
/// </summary>
internal static JsonObject Convert(IBulkUpdateObjectIdAndChangeToken oc)
{
if (oc == null)
{
return null;
}
JsonObject result = new JsonObject();
SetIfNotNull(BrowserConstants.JsonBulkUpdateId, oc.Id, result);
SetIfNotNull(BrowserConstants.JsonBulkUpdateNewId, oc.NewId, result);
SetIfNotNull(BrowserConstants.JsonBulkUpdateChangeToken, oc.ChangeToken, result);
ConvertExtension(oc, result);
return result;
}
/// <summary>
/// Converts bulk update data lists.
/// </summary>
internal static IList<IBulkUpdateObjectIdAndChangeToken> ConvertBulkUpdate(JsonArray json)
{
if (json == null)
{
return null;
}
IList<IBulkUpdateObjectIdAndChangeToken> result = new List<IBulkUpdateObjectIdAndChangeToken>();
foreach (object ocJson in json)
{
IBulkUpdateObjectIdAndChangeToken oc = ConvertBulkUpdate(GetJsonObject(ocJson));
if (oc != null)
{
result.Add(oc);
}
}
return result;
}
/// <summary>
/// Converts bulk update data.
/// </summary>
internal static IBulkUpdateObjectIdAndChangeToken ConvertBulkUpdate(JsonObject json)
{
if (json == null)
{
return null;
}
string id = GetString(json, BrowserConstants.JsonBulkUpdateId);
string newId = GetString(json, BrowserConstants.JsonBulkUpdateNewId);
string changeToken = GetString(json, BrowserConstants.JsonBulkUpdateChangeToken);
BulkUpdateObjectIdAndChangeToken result = new BulkUpdateObjectIdAndChangeToken() { Id = id, NewId = newId, ChangeToken = changeToken };
ConvertExtension(json, result, BrowserConstants.BulkUpdateKeys);
return result;
}
// -----------------------------------------------------------------
internal static void ConvertExtension(IExtensionsData source, JsonObject target)
{
if (source == null || source.Extensions == null)
{
return;
}
foreach (ICmisExtensionElement ext in source.Extensions)
{
AddExtensionToTarget(ext, target);
}
}
private static JsonObject ConvertExtensionList(IList<ICmisExtensionElement> extensionList)
{
if (extensionList == null)
{
return null;
}
JsonObject result = new JsonObject();
foreach (ICmisExtensionElement ext in extensionList)
{
AddExtensionToTarget(ext, result);
}
return result;
}
private static void AddExtensionToTarget(ICmisExtensionElement ext, JsonObject target)
{
if (ext == null)
{
return;
}
object value = null;
if (IsNotEmpty(ext.Children))
{
value = ConvertExtensionList(ext.Children);
}
else
{
value = ext.Value;
}
if (!target.ContainsKey(ext.Name))
{
target.Add(ext.Name, value);
}
else
{
object extValue = target[ext.Name];
JsonArray array;
if (extValue is JsonArray)
{
array = (JsonArray)extValue;
}
else
{
array = new JsonArray();
array.Add(extValue);
}
array.Add(value);
target.Add(ext.Name, array);
}
}
internal static void ConvertExtension(JsonObject source, IExtensionsData target, ISet<string> cmisKeys)
{
if (source == null)
{
return;
}
IList<ICmisExtensionElement> extensions = null;
foreach (KeyValuePair<string, object> element in source)
{
if (cmisKeys.Contains(element.Key))
{
continue;
}
if (extensions == null)
{
extensions = new List<ICmisExtensionElement>();
}
if (element.Value is JsonObject)
{
extensions.Add(new CmisExtensionElement() { Name = element.Key, Children = ConvertExtension((JsonObject)element.Value) });
}
else if (element.Value is JsonArray)
{
IList<ICmisExtensionElement> exts = ConvertExtension(element.Key, (JsonArray)element.Value);
foreach (ICmisExtensionElement ext in exts)
{
extensions.Add(ext);
}
}
else
{
string value = (element.Value == null ? null : element.Value.ToString());
extensions.Add(new CmisExtensionElement() { Name = element.Key, Value = value });
}
}
target.Extensions = extensions;
}
internal static IList<ICmisExtensionElement> ConvertExtension(JsonObject map)
{
if (map == null)
{
return null;
}
IList<ICmisExtensionElement> extensions = new List<ICmisExtensionElement>();
foreach (KeyValuePair<string, object> element in map)
{
if (element.Value is JsonObject)
{
extensions.Add(new CmisExtensionElement() { Name = element.Key, Children = ConvertExtension((JsonObject)element.Value) });
}
else if (element.Value is JsonArray)
{
IList<ICmisExtensionElement> exts = ConvertExtension(element.Key, (JsonArray)element.Value);
foreach (ICmisExtensionElement ext in exts)
{
extensions.Add(ext);
}
}
else
{
string value = (element.Value == null ? null : element.Value.ToString());
extensions.Add(new CmisExtensionElement() { Name = element.Key, Value = value });
}
}
return extensions;
}
internal static IList<ICmisExtensionElement> ConvertExtension(string name, JsonArray list)
{
if (list == null)
{
return null;
}
IList<ICmisExtensionElement> extensions = new List<ICmisExtensionElement>();
foreach (object element in list)
{
if (element is JsonObject)
{
extensions.Add(new CmisExtensionElement() { Name = name, Children = ConvertExtension((JsonObject)element) });
}
else if (element is JsonArray)
{
IList<ICmisExtensionElement> exts = ConvertExtension(name, (JsonArray)element);
foreach (ICmisExtensionElement ext in exts)
{
extensions.Add(ext);
}
}
else
{
string value = (element == null ? null : element.ToString());
extensions.Add(new CmisExtensionElement() { Name = name, Value = value });
}
}
return extensions;
}
// -----------------------------------------------------------------
internal static string GetJsonStringValue(object obj)
{
if (obj == null)
{
return null;
}
return obj.ToString();
}
internal static object GetJsonValue(object value, DateTimeFormat dateTimeFormat)
{
if (value is DateTime)
{
if (dateTimeFormat == DateTimeFormat.Extended)
{
return DateTimeHelper.FormatISO8601((DateTime)value);
}
else
{
return new BigInteger(DateTimeHelper.ConvertDateTimeToMillis((DateTime)value));
}
}
return value;
}
internal static string GetJsonEnumValue<T>(T? cmisEnum) where T : struct
{
if (!cmisEnum.HasValue)
{
return null;
}
if (!Enum.IsDefined(typeof(T), cmisEnum.Value))
{
throw new ArgumentException("Invalid enum value!");
}
return ((Enum)Enum.ToObject(typeof(T), cmisEnum.Value)).GetCmisValue();
}
internal static object GetCmisValue(object value, PropertyType propertyType)
{
if (value == null)
{
return null;
}
switch (propertyType)
{
case PropertyType.String:
case PropertyType.Id:
case PropertyType.Html:
case PropertyType.Uri:
if (value is string)
{
return value;
}
throw new CmisRuntimeException("Invalid String value!");
case PropertyType.Boolean:
if (value is bool)
{
return value;
}
throw new CmisRuntimeException("Invalid Boolean value!");
case PropertyType.Integer:
if (value is BigInteger)
{
return value;
}
throw new CmisRuntimeException("Invalid Integer value!");
case PropertyType.Decimal:
if (value is decimal)
{
return value;
}
throw new CmisRuntimeException("Invalid Decimal value!");
case PropertyType.DateTime:
if (value is BigInteger)
{
return DateTimeHelper.ConvertMillisToDateTime((long)((BigInteger)value));
}
else if (value is string)
{
DateTime dt;
try
{
dt = DateTimeHelper.ParseISO8601((string)value);
}
catch (Exception e)
{
throw new CmisRuntimeException("Invalid DateTime value!", e);
}
return dt;
}
throw new CmisRuntimeException("Invalid DateTime value!");
default:
break;
}
throw new CmisRuntimeException("Unknown property type!");
}
internal static JsonArray GetJsonArrayFromList<T>(IList<T> list)
{
if (list == null)
{
return null;
}
JsonArray result = new JsonArray();
foreach (T value in list)
{
result.Add(value);
}
return result;
}
internal static void SetIfNotNull(string name, object obj, JsonObject json)
{
if (obj != null)
{
json.Add(name, obj);
}
}
internal static JsonObject GetJsonObject(object o)
{
if (o == null)
{
return null;
}
if (o is JsonObject)
{
return (JsonObject)o;
}
throw new CmisRuntimeException("Expected a JSON object but found a "
+ (o is JsonArray ? "JSON array" : o.GetType().ToString()) + ": " + o.ToString());
}
internal static object GetObject(JsonObject json, string key)
{
object value;
if (json.TryGetValue(key, out value))
{
return value;
}
return null;
}
internal static JsonObject GetJsonObject(JsonObject json, string key)
{
object value;
if (json.TryGetValue(key, out value))
{
if (value is JsonObject)
{
return (JsonObject)value;
}
else if (value == null)
{
return null;
}
throw new CmisRuntimeException("Expected a JSON object but found a "
+ (value is JsonArray ? "JSON array" : value.GetType().ToString()) + ": " + value.ToString());
}
return null;
}
internal static JsonArray GetJsonArray(JsonObject json, string key)
{
object value;
if (json.TryGetValue(key, out value))
{
if (value is JsonArray)
{
return (JsonArray)value;
}
else if (value == null)
{
return null;
}
throw new CmisRuntimeException("Expected a JSON array but found a "
+ (value is JsonObject ? "JSON object" : value.GetType().ToString()) + ": " + value.ToString());
}
return null;
}
internal static string GetString(JsonObject json, string key)
{
object value;
if (json.TryGetValue(key, out value))
{
return value as string;
}
return null;
}
internal static bool? GetBoolean(JsonObject json, string key)
{
object value;
if (json.TryGetValue(key, out value))
{
return value as bool?;
}
return null;
}
internal static BigInteger? GetInteger(JsonObject json, string key)
{
object value;
if (json.TryGetValue(key, out value))
{
return value as BigInteger?;
}
return null;
}
internal static decimal? GetDecimal(JsonObject json, string key)
{
object value;
if (json.TryGetValue(key, out value))
{
if (value is decimal)
{
return (decimal)value;
}
if (value is BigInteger)
{
return (decimal)((BigInteger)value);
}
}
return null;
}
internal static DateTime? GetDateTime(JsonObject json, string key)
{
object value;
if (json.TryGetValue(key, out value))
{
if (value is BigInteger)
{
return DateTimeHelper.ConvertMillisToDateTime((long)((BigInteger)value));
}
else if (value is string)
{
return DateTimeHelper.ParseISO8601((string)value);
}
}
return null;
}
internal static T GetEnum<T>(JsonObject json, string key)
{
object value;
if (json.TryGetValue(key, out value))
{
if (value is string)
{
return ((string)value).GetCmisEnum<T>();
}
}
return default(T);
}
internal static bool IsNotEmpty<T>(ICollection<T> col)
{
return col != null && col.Count > 0;
}
internal static bool IsNotEmpty(JsonObject json)
{
return json != null && json.Count > 0;
}
internal static bool IsNullOrEmpty<T>(ICollection<T> col)
{
return col == null || col.Count == 0;
}
}
}