public getFolderParentResponse GetFolderParent(getFolderParentRequest request)
{
var textFolder = ModelHelper.GetTextFolder(request.repositoryId, request.folderId);
if (textFolder.Parent != null)
{
return(new getFolderParentResponse(ToCmisObject(((Kooboo.CMS.Content.Models.TextFolder)textFolder.Parent).AsActual())));
}
else
{
var cmisObject = new cmisObjectType();
cmisObject.properties = new cmisPropertiesType();
cmisObject.properties.Items = new cmisProperty[] {
new cmisPropertyId()
{
displayName = "Id",
localName = "Id",
propertyDefinitionId = CmisPropertyDefinitionId.ObjectId,
queryName = "Id",
value = new string[] { "/" }
}
};
return(new getFolderParentResponse(cmisObject));
}
}
public static cmisObjectType TocmisObjectType(TextContent textContent)
{
cmisObjectType cmisObject = new cmisObjectType();
cmisObject.properties = ToCmisPropertiesType(textContent);
return(cmisObject);
}
public static cmisObjectType TocmisObjectType(TextContent textContent, IEnumerable <Category> categories)
{
cmisObjectType cmisObject = new cmisObjectType();
cmisObject.properties = ToCmisPropertiesType(textContent, categories);
return(cmisObject);
}
public void getAndAssertChildren(ObjectsHierarchy hierarchy, string filter, int skipCount, int maxItems, RenditionData renditionData)
{
string[] foldersIds = hierarchy.FolderIds.ToArray();
string[] documentsIds = hierarchy.DocumentIds.ToArray();
string[] allCreatedObjectsIds = hierarchy.toIdsArray();
string rootFolderId = hierarchy.RootFolder.ObjectId;
cmisObjectInFolderListType children = getAndAssertChildren(rootFolderId, filter, null, maxItems, skipCount, renditionData != null ? renditionData.getFilter() : null);
cmisObjectType[] childrenObjects = new cmisObjectType[children.objects.Length];
for (int i = 0; i < children.objects.Length; ++i)
{
childrenObjects[i] = children.objects[i] != null ? children.objects[i].@object : null;
}
if (maxItems > 0)
{
int resultCount = (skipCount + maxItems) < allCreatedObjectsIds.Length ? maxItems : allCreatedObjectsIds.Length - skipCount;
Assert.IsTrue(resultCount == childrenObjects.Length, "Count of returned items doesn't equal to expected count");
}
else
{
assertObjectsByType(enumTypesOfFileableObjects.any, documentsIds, foldersIds, allCreatedObjectsIds, childrenObjects);
}
foreach (cmisObjectType cmisObject in childrenObjects)
{
assertObjectProperties(cmisObject.properties, filter);
if (renditionData != null)
{
assertRenditions(cmisObject, renditionData.getFilter(), renditionData.getExpectedKinds(), renditionData.getExpectedMimetypes());
}
}
logger.log("Children were successfully received");
logger.log("");
}
private string getAndAssertObjectId(cmisObjectInFolderContainerType objectInFolderContainer)
{
Assert.IsTrue(objectInFolderContainer != null && objectInFolderContainer.objectInFolder != null &&
objectInFolderContainer.objectInFolder.@object != null, "Object from response is null");
cmisObjectType cmisObject = objectInFolderContainer.objectInFolder.@object;
return((string)searchAndAssertPropertyByName(cmisObject.properties.Items, OBJECT_IDENTIFIER_PROPERTY, false));
}
private void assertEntry(cmisObjectType entry, string filter)
{
Assert.IsNotNull(entry, "One of the Change Event Entries is in 'not set' state solely");
Assert.IsNotNull(entry.properties, "Properties of one of the Change Event Entries are undefined");
if (null != filter)
{
assertPropertiesByFilter(entry.properties, filter);
}
Assert.IsNotNull(entry.changeEventInfo, "Change Event Info for one of the Change Event Entries is undefined");
}
public AtomEntryWriter(cmisObjectType cmisObject, string mediaType, string filename, Stream stream)
{
if (cmisObject == null || cmisObject.properties == null)
{
throw new CmisInvalidArgumentException("Object and properties must not be null!");
}
if (stream != null && mediaType == null)
{
throw new CmisInvalidArgumentException("Media type must be set if a stream is present!");
}
this.cmisObject = cmisObject;
this.mediaType = mediaType;
this.filename = filename;
this.stream = stream;
}
public AtomEntryWriter(cmisObjectType cmisObject, string mediaType, string filename, Stream stream)
{
if (cmisObject == null || cmisObject.properties == null)
{
throw new CmisInvalidArgumentException("Object and properties must not be null!");
}
if (stream != null && mediaType == null)
{
throw new CmisInvalidArgumentException("Media type must be set if a stream is present!");
}
this.cmisObject = cmisObject;
this.mediaType = mediaType;
this.filename = filename;
this.stream = stream;
}
private void assertVersions(cmisObjectType[] response, string filter, bool includeAllowableActions, bool pwcIncluded)
{
object lastVersionLabel = "";
object lastCreationDate = null;
for (int i = (pwcIncluded) ? (1) : (0); i < response.Length; i++)
{
cmisObjectType versionObject = response[i];
if (!isValueNotSet(filter) && !string.Empty.Equals(filter) && !ANY_PROPERTY_FILTER.Equals(filter))
{
assertPropertiesByFilter(versionObject.properties, filter);
}
else
{
object cmisObjectId = searchAndAssertPropertyByName(versionObject.properties.Items, OBJECT_IDENTIFIER_PROPERTY, false);
Assert.IsFalse(isValueNotSet(cmisObjectId), "Document Version Id property is undefined");
object versionLabel = searchAndAssertPropertyByName(versionObject.properties.Items, VERSION_LABEL_PROPERTY, false);
Assert.IsFalse(isValueNotSet(versionLabel), "Invalid Version Object");
Assert.AreNotEqual(lastVersionLabel, versionLabel, ("Invalid Version was found in Document Object Versions collection. Dublicated Version Object with Version Label='" + versionLabel + "'"));
lastVersionLabel = versionLabel;
object creationDate = searchAndAssertPropertyByName(versionObject.properties.Items, CREATION_DATE_PROPERTY, false);
if (!isValueNotSet(lastCreationDate))
{
Assert.IsFalse(isValueNotSet(creationDate), "Invalid CreationDate property value");
Assert.IsTrue((((System.DateTime)creationDate).CompareTo(lastCreationDate) <= 0), "Versions sorting by Creation Date Descending is invalid");
}
else
{
lastCreationDate = creationDate;
}
}
if (includeAllowableActions)
{
assertAllowableActions(versionObject.allowableActions);
}
}
if (pwcIncluded)
{
object property = searchAndAssertPropertyByName(response[0].properties.Items, VERSION_SERIES_CHECKEDOUT_PROPERTY, false);
Assert.IsTrue((!isValueNotSet(property) && (bool)property), "Document Object was Checked Out but PWC was not returned");
}
}
public void testPathSegments()
{
string folderId = createAndAssertFolder(getAndAssertRootFolder()).ObjectId;
string documentId = createAndAssertObject(folderId, enumVersioningState.none).ObjectId;
logger.log("[NavigationService->getChildren]");
cmisObjectInFolderListType childrenResponse = navigationServiceClient.getChildren(getAndAssertRepositoryId(), getAndAssertRootFolder(), "*", null, false,
enumIncludeRelationships.none, null, true, Convert.ToString(MAX_REQUESTED_COUNT), TEXTUAL_ZERO, null);
Assert.IsNotNull(childrenResponse.objects != null, "GetChildren response is NULL");
string folderPathSegment = null;
foreach (cmisObjectInFolderType objectInFolder in childrenResponse.objects)
{
Assert.IsNotNull(objectInFolder, "CmisObjectInFolder is NULL");
Assert.IsNotNull(objectInFolder.pathSegment, "pathSegment is NULL");
Assert.IsNotNull(objectInFolder.@object, "CmisObject is NULL");
Assert.IsNotNull([email protected], "Properties are NULL");
if (folderId.Equals((string)searchAndAssertPropertyByName([email protected], OBJECT_IDENTIFIER_PROPERTY, false)))
{
folderPathSegment = objectInFolder.pathSegment;
}
}
Assert.IsNotNull(folderPathSegment, "pathSegment is NULL");
logger.log("[NavigationService->getObjectParents]");
cmisObjectParentsType[] parentsResponse = navigationServiceClient.getObjectParents(getAndAssertRepositoryId(), documentId, "*",
false, enumIncludeRelationships.none, null, true, null);
Assert.IsNotNull(parentsResponse, "GetObjectParents response is NULL");
Assert.IsTrue(parentsResponse.Length > 0, "GetObjectParents response is empty");
string documentPathSegment = parentsResponse[0].relativePathSegment;
Assert.IsNotNull(documentPathSegment, "pathSegment is NULL");
string folderPath = "/" + folderPathSegment;
string documentPath = "/" + folderPathSegment + "/" + documentPathSegment;
logger.log("[ObjectService->getObjectByPath]");
cmisObjectType objectByPath = objectServiceClient.getObjectByPath(getAndAssertRepositoryId(), folderPath, OBJECT_IDENTIFIER_PROPERTY, false, enumIncludeRelationships.none, null, null, null, null);
Assert.IsNotNull(objectByPath, "GetObjectByPath response is NULL");
Assert.IsNotNull(objectByPath.properties, "Object properties are NULL");
string folderIdByPath = (string)searchAndAssertPropertyByName(objectByPath.properties.Items, OBJECT_IDENTIFIER_PROPERTY, false);
Assert.AreEqual(folderId, folderIdByPath, "Returned by path objectId is not equal to expected");
logger.log("[ObjectService->getObjectByPath]");
objectByPath = objectServiceClient.getObjectByPath(getAndAssertRepositoryId(), documentPath, OBJECT_IDENTIFIER_PROPERTY, false, enumIncludeRelationships.none, null, null, null, null);
Assert.IsNotNull(objectByPath, "GetObjectByPath response is NULL");
Assert.IsNotNull(objectByPath.properties, "Object properties are NULL");
string documentIdByPath = (string)searchAndAssertPropertyByName(objectByPath.properties.Items, OBJECT_IDENTIFIER_PROPERTY, false);
Assert.AreEqual(documentId, documentIdByPath, "Returned by path objectId is not equal to expected");
logger.log("[NavigationService->getDescedants]");
cmisObjectInFolderContainerType[] descendantsResponse = navigationServiceClient.getDescendants(getAndAssertRepositoryId(), folderId, "2", ANY_PROPERTY_FILTER, false, enumIncludeRelationships.none, null, true, null);
Assert.IsNotNull(descendantsResponse, "GetDescendants response is NULL");
foreach (cmisObjectInFolderContainerType objectInFolderContainer in descendantsResponse)
{
Assert.IsNotNull(objectInFolderContainer, "CmisObjectInFolderContainer is NULL");
Assert.IsNotNull(objectInFolderContainer.objectInFolder, "CmisObjectInFolder is NULL");
Assert.IsNotNull(objectInFolderContainer.objectInFolder.pathSegment, "pathSegment is NULL");
Assert.IsNotNull(objectInFolderContainer.objectInFolder.@object, "CmisObject is NULL");
if (documentId.Equals((string)searchAndAssertPropertyByName([email protected], OBJECT_IDENTIFIER_PROPERTY, false)))
{
Assert.AreEqual(documentPathSegment, objectInFolderContainer.objectInFolder.pathSegment, "Returned by path objectId is not equal to expected");
}
}
}
public AtomEntryWriter(cmisObjectType cmisObject)
: this(cmisObject, null, null, null)
{
}
public AtomEntryWriter(cmisObjectType cmisObject)
: this(cmisObject, null, null, null)
{
}
private void assertVersions(cmisObjectType[] response, string filter, bool includeAllowableActions, bool pwcIncluded)
{
object lastVersionLabel = "";
object lastCreationDate = null;
for (int i = (pwcIncluded) ? (1) : (0); i < response.Length; i++)
{
cmisObjectType versionObject = response[i];
if (!isValueNotSet(filter) && !string.Empty.Equals(filter) && !ANY_PROPERTY_FILTER.Equals(filter))
{
assertPropertiesByFilter(versionObject.properties, filter);
}
else
{
object cmisObjectId = searchAndAssertPropertyByName(versionObject.properties.Items, OBJECT_IDENTIFIER_PROPERTY, false);
Assert.IsFalse(isValueNotSet(cmisObjectId), "Document Version Id property is undefined");
object versionLabel = searchAndAssertPropertyByName(versionObject.properties.Items, VERSION_LABEL_PROPERTY, false);
Assert.IsFalse(isValueNotSet(versionLabel), "Invalid Version Object");
Assert.AreNotEqual(lastVersionLabel, versionLabel, ("Invalid Version was found in Document Object Versions collection. Dublicated Version Object with Version Label='" + versionLabel + "'"));
lastVersionLabel = versionLabel;
object creationDate = searchAndAssertPropertyByName(versionObject.properties.Items, CREATION_DATE_PROPERTY, false);
if (!isValueNotSet(lastCreationDate))
{
Assert.IsFalse(isValueNotSet(creationDate), "Invalid CreationDate property value");
Assert.IsTrue((((System.DateTime)creationDate).CompareTo(lastCreationDate) <= 0), "Versions sorting by Creation Date Descending is invalid");
}
else
{
lastCreationDate = creationDate;
}
}
if (includeAllowableActions)
{
assertAllowableActions(versionObject.allowableActions);
}
}
if (pwcIncluded)
{
object property = searchAndAssertPropertyByName(response[0].properties.Items, VERSION_SERIES_CHECKEDOUT_PROPERTY, false);
Assert.IsTrue((!isValueNotSet(property) && (bool)property), "Document Object was Checked Out but PWC was not returned");
}
}
protected static void assertProperties(FileableObject expectedProperties, cmisPropertiesType properties)
{
cmisObjectType cmisObject = new cmisObjectType();
cmisObject.properties = properties;
assertObject(expectedProperties, cmisObject, false, enumIncludeRelationships.none);
}
private void assertEntry(cmisObjectType entry, string filter)
{
Assert.IsNotNull(entry, "One of the Change Event Entries is in 'not set' state solely");
Assert.IsNotNull(entry.properties, "Properties of one of the Change Event Entries are undefined");
if (null != filter)
{
assertPropertiesByFilter(entry.properties, filter);
}
Assert.IsNotNull(entry.changeEventInfo, "Change Event Info for one of the Change Event Entries is undefined");
}
private static cmisObjectType ToCmisObject(Kooboo.CMS.Content.Models.TextFolder textFolder)
{
var hasSchema = !string.IsNullOrEmpty(textFolder.SchemaName);
var cmisObject = new cmisObjectType();
cmisObject.allowableActions = new cmisAllowableActionsType()
{
canAddObjectToFolder = hasSchema,
canApplyACL = false,
canApplyPolicy = false,
canCancelCheckOut = false,
canCheckIn = false,
canCheckOut = false,
canCreateDocument = hasSchema,
canCreateFolder = true,
canCreateRelationship = hasSchema,
canDeleteContentStream = true,
canDeleteObject = hasSchema,
canDeleteTree = false,
canGetACL = false,
canGetAllVersions = false,
canGetAppliedPolicies = false,
canGetChildren = true,
canGetContentStream = false,
canGetDescendants = false,
canGetFolderParent = true,
canGetFolderTree = true,
canGetObjectParents = false,
canGetObjectRelationships = false,
canGetProperties = false,
canGetRenditions = false,
canMoveObject = false,
canRemoveObjectFromFolder = false,
canRemovePolicy = false,
canSetContentStream = false,
canUpdateProperties = false
};
cmisObject.changeEventInfo = null;
cmisObject.exactACL = false;
cmisObject.policyIds = null;
cmisObject.rendition = null;
cmisObject.properties = new cmisPropertiesType();
var properties = new List <cmisProperty>();
properties.Add(new cmisPropertyId()
{
displayName = "Id",
localName = "Id",
propertyDefinitionId = CmisPropertyDefinitionId.ObjectId,
queryName = "Id",
value = new string[] { textFolder.FriendlyName }
});
properties.Add(new cmisPropertyString()
{
displayName = "Name",
localName = "Name",
propertyDefinitionId = CmisPropertyDefinitionId.Name,
queryName = "Name",
value = new string[] { textFolder.FriendlyName }
});
properties.Add(new cmisPropertyString()
{
displayName = "DisplayName",
localName = "DisplayName",
queryName = "DisplayName",
value = new string[] { textFolder.DisplayName }
});
properties.Add(new cmisPropertyDateTime()
{
displayName = "UtcCreationDate",
localName = "UtcCreationDate",
propertyDefinitionId = CmisPropertyDefinitionId.CreationDate,
queryName = "UtcCreationDate",
value = new DateTime[] { textFolder.UtcCreationDate }
});
properties.Add(new cmisPropertyString()
{
displayName = "UserId",
localName = "UserId",
propertyDefinitionId = CmisPropertyDefinitionId.CreatedBy,
queryName = "UserId",
value = new string[] { textFolder.UserId }
});
properties.Add(new cmisPropertyBoolean()
{
displayName = "EnablePaging",
localName = "EnablePaging",
queryName = "EnablePaging",
value = new bool[] { textFolder.EnablePaging == null ? true : textFolder.EnablePaging.Value }
});
properties.Add(new cmisPropertyBoolean()
{
displayName = "Sortable",
localName = "Sortable",
queryName = "Sortable",
value = new bool[] { textFolder.Sortable == null ? true : textFolder.Sortable.Value }
});
properties.Add(new cmisPropertyString()
{
displayName = "SchemaName",
localName = "SchemaName",
queryName = "SchemaName",
value = new string[] { textFolder.SchemaName }
});
properties.Add(new cmisPropertyBoolean()
{
displayName = "Hidden",
localName = "Hidden",
queryName = "Hidden",
value = new bool[] { textFolder.Hidden == null ? false : textFolder.Hidden.Value }
});
properties.Add(new cmisPropertyInteger()
{
displayName = "PageSize",
localName = "PageSize",
queryName = "PageSize",
value = new string[] { textFolder.PageSize.ToString() }
});
cmisObject.properties.Items = properties.ToArray();
return(cmisObject);
}
protected void assertRenditions(cmisObjectType cmisObject, string filter, string[] expectedKinds, string[] expectedMimetypes)
{
Assert.IsNotNull(cmisObject, "cmisObject is null");
if (filter == null || filter.Equals(RENDITION_FILTER_NONE))
{
Assert.IsTrue(cmisObject.rendition == null || cmisObject.rendition.Length == 0, "Rendition are not empty for empty filter");
}
else
{
if (cmisObject.rendition != null)
{
logger.log(cmisObject.rendition.Length + " renditions received for filter '" + filter + "'");
foreach (cmisRenditionType rendition in cmisObject.rendition)
{
assertRendition(rendition);
if (!filter.Equals(RENDITION_FILTER_WILDCARD))
{
assertContains(rendition, expectedKinds, expectedMimetypes);
}
}
}
}
}
public static void assertRelationships(string objectId, cmisObjectType[] relationships, System.Nullable<enumIncludeRelationships> direction)
{
if ((null == direction) || (enumIncludeRelationships.none == direction))
{
Assert.IsTrue(isValueNotSet(relationships), ("Relationships for " + direction + " direction were returned for Object with Id=" + objectId));
}
else
{
Assert.IsFalse(isValueNotSet(relationships), ("Relationships for " + direction + " direction for Object with Id=" + objectId + " were not returned"));
foreach (cmisObjectType relationship in relationships)
{
Assert.IsFalse(isValueNotSet(relationship), ("One of the Relationship Objects for Object with Id=" + objectId + " is in 'not set' state solely"));
Assert.IsFalse(isValueNotSet(relationship.properties), "Properties of one of the Relationship Objects are undefined");
Assert.IsFalse(isValueNotSet(relationship.properties.Items), "Properties of one of the Relationship Object are empty");
string sourceId = (string)searchAndAssertPropertyByName(relationship.properties.Items, RELATIONSHIP_SOURCE_OBJECT_ID, false);
string targetId = (string)searchAndAssertPropertyByName(relationship.properties.Items, RELATIONSHIP_TARGET_OBJECT_ID, false);
objectId = getVersionSeries(objectId);
sourceId = getVersionSeries(sourceId);
targetId = getVersionSeries(targetId);
switch (direction)
{
case enumIncludeRelationships.source:
{
Assert.AreEqual(objectId, sourceId, ("Relationship objects collection with specified Document object id = " + objectId + " as source object are invalid"));
break;
}
case enumIncludeRelationships.target:
{
Assert.AreEqual(objectId, targetId, ("Relationship objects collection with specified Document object id = " + objectId + " as target object are invalid"));
break;
}
case enumIncludeRelationships.both:
{
Assert.IsTrue((objectId.Equals(sourceId) || objectId.Equals(targetId)), ("Relationship Object for " + direction + " direction has not " + objectId + " as either Source nor Target Object Id Property"));
break;
}
}
}
}
}
protected static void assertObject(FileableObject expectedProperties, cmisObjectType actualObject, bool includeAllowableActions, enumIncludeRelationships relationshipsType)
{
Assert.IsFalse(isValueNotSet(actualObject), "Returned Object is undefined");
Assert.IsFalse(isValueNotSet(actualObject.properties), "Properties of returned Object are undefined");
Assert.IsFalse(isValueNotSet(actualObject.properties.Items), "Properties of returned Object are empty");
object propertyValue = searchAndAssertPropertyByName(actualObject.properties.Items, NAME_PROPERTY, false);
Assert.AreEqual(expectedProperties.ObjectName, propertyValue, ("Object Name Property value differs to Property value returned with Get Properties Response. Expected: " + expectedProperties.ObjectName + ", actual: " + propertyValue));
propertyValue = searchAndAssertPropertyByName(actualObject.properties.Items, TYPE_ID_PROPERTY, false);
Assert.AreEqual(expectedProperties.ObjectTypeId, propertyValue, ("Object Type Id Property value differs to Property value returned with Get Properties Response. Expected: " + expectedProperties.ObjectName + ", actual: " + propertyValue));
propertyValue = searchAndAssertPropertyByName(actualObject.properties.Items, OBJECT_IDENTIFIER_PROPERTY, false);
Assert.AreEqual(expectedProperties.ObjectId, propertyValue, ("Expected Object Id='" + expectedProperties.ObjectId + "' is not equal to actual Object Id='" + propertyValue + "'"));
//TODO: uncomment when problem will be found
//assertActualVersioningState(actualObject.properties, expectedProperties.InitialVersion);
if (includeAllowableActions)
{
Assert.IsNotNull(actualObject.allowableActions, "Allowable Actions was not returned in Get Object Properties response");
Assert.IsTrue(!isValueNotSet(actualObject.allowableActions.canGetProperties) && actualObject.allowableActions.canGetProperties, ("Properties of Object with id='" + expectedProperties.ObjectId + "' Reading is not allowed but Properties were returned"));
logger.log("Allowable actions were checked successfully");
}
else
{
Assert.IsTrue(isValueNotSet(actualObject.allowableActions), "Allowable Actions were not requested but were returned in response of Get Properties");
}
assertRelationships(expectedProperties.ObjectId, actualObject.relationship, relationshipsType);
logger.log("Relationships for " + relationshipsType + " direction were checked successfully");
}
public void assertObjectCollectionsConsitence(cmisObjectType[] actualObjects, string[] expectedIds)
{
Assert.IsTrue((expectedIds.Length == actualObjects.Length), "Size of Expected Object Collection is not equal to Actual Object Collection. Collections of Expected and Actual Objects are not consistent");
HashSet<string> expectedIdsSet = new HashSet<string>(expectedIds);
foreach (cmisObjectType actualObject in actualObjects)
{
Assert.IsFalse(isValueNotSet(actualObject), "One of the Parent Object is in 'not set' state solely");
Assert.IsFalse(isValueNotSet(actualObject.properties), "Properties of one of the Parent Object are undefined");
Assert.IsFalse(isValueNotSet(actualObject.properties.Items), "Properties of one of the Parent Object are empty");
string objectId = (string)searchAndAssertPropertyByName(actualObject.properties.Items, OBJECT_IDENTIFIER_PROPERTY, false);
Assert.IsTrue(expectedIdsSet.Contains(objectId), ("objectId='" + objectId + "' is not in expected Object Ids set. Collections of Expected and Actual Objects are not consistent"));
}
}
public cmisObjectType[] receiveParents()
{
if (IsFolder)
{
logger.log("[NavigationService->getFolderParent]");
logger.log("Receiving FolderParent, descendantObjectId=" + DescendantObjectId);
return new cmisObjectType[] { navigationServiceClient.getFolderParent(getAndAssertRepositoryId(), DescendantObjectId, ANY_PROPERTY_FILTER, null) };
}
else
{
logger.log("[NavigationService->getObjectParents]");
logger.log("Receiving ObjectParents, descendantObjectId=" + DescendantObjectId);
cmisObjectParentsType[] response = navigationServiceClient.getObjectParents(getAndAssertRepositoryId(), DescendantObjectId, ANY_PROPERTY_FILTER, false, enumIncludeRelationships.none, null, false, null);
cmisObjectType[] result = new cmisObjectType[response.Length];
if (response != null)
{
for (int i = 0; i < response.Length; ++i)
{
result[i] = response[i] != null ? response[i].@object : null;
}
}
return result;
}
}
