@Override
public void updateProperties(
CallContext callContext,
String repositoryId,
Holder<String> objectId,
Properties properties,
Holder<String> changeToken) {
exceptionService.invalidArgumentRequiredHolderString("objectId", objectId);
Lock lock = threadLockService.getWriteLock(repositoryId, objectId.getValue());
try {
lock.lock();
// //////////////////
// Exception
// //////////////////
Content content =
checkExceptionBeforeUpdateProperties(
callContext, repositoryId, objectId, properties, changeToken);
// //////////////////
// Body of the method
// //////////////////
contentService.updateProperties(callContext, repositoryId, properties, content);
nemakiCachePool.get(repositoryId).removeCmisCache(objectId.getValue());
} finally {
lock.unlock();
}
}
@Override
public void deleteContentStream(
CallContext callContext,
String repositoryId,
Holder<String> objectId,
Holder<String> changeToken,
ExtensionsData extension) {
exceptionService.invalidArgumentRequiredHolderString("objectId", objectId);
Lock lock = threadLockService.getWriteLock(repositoryId, objectId.getValue());
try {
lock.lock();
// //////////////////
// Exception
// //////////////////
Document document = contentService.getDocument(repositoryId, objectId.getValue());
exceptionService.objectNotFound(DomainType.OBJECT, document, document.getId());
exceptionService.constraintContentStreamRequired(repositoryId, document);
// //////////////////
// Body of the method
// //////////////////
contentService.deleteContentStream(callContext, repositoryId, objectId);
nemakiCachePool.get(repositoryId).removeCmisCache(objectId.getValue());
} finally {
lock.unlock();
}
}
@Override
public AllowableActions getAllowableActions(
CallContext callContext, String repositoryId, String objectId) {
exceptionService.invalidArgumentRequired("objectId", objectId);
Lock lock = threadLockService.getReadLock(repositoryId, objectId);
try {
lock.lock();
// //////////////////
// General Exception
// //////////////////
Content content = contentService.getContent(repositoryId, objectId);
exceptionService.objectNotFound(DomainType.OBJECT, content, objectId);
// NOTE: The permission key doesn't exist according to CMIS
// specification.
// //////////////////
// Body of the method
// //////////////////
return compileService.compileAllowableActions(callContext, repositoryId, content);
} finally {
lock.unlock();
}
}
@Override
public List<RenditionData> getRenditions(
CallContext callContext,
String repositoryId,
String objectId,
String renditionFilter,
BigInteger maxItems,
BigInteger skipCount,
ExtensionsData extension) {
Lock lock = threadLockService.getReadLock(repositoryId, objectId);
try {
lock.lock();
List<Rendition> renditions = contentService.getRenditions(repositoryId, objectId);
List<RenditionData> results = new ArrayList<RenditionData>();
for (Rendition rnd : renditions) {
RenditionDataImpl data =
new RenditionDataImpl(
rnd.getId(),
rnd.getMimetype(),
BigInteger.valueOf(rnd.getLength()),
rnd.getKind(),
rnd.getTitle(),
BigInteger.valueOf(rnd.getWidth()),
BigInteger.valueOf(rnd.getHeight()),
rnd.getRenditionDocumentId());
results.add(data);
}
return results;
} finally {
lock.unlock();
}
}
@Override
public ContentStream getContentStream(
CallContext callContext,
String repositoryId,
String objectId,
String streamId,
BigInteger offset,
BigInteger length) {
exceptionService.invalidArgumentRequired("objectId", objectId);
Lock lock = threadLockService.getReadLock(repositoryId, objectId);
try {
lock.lock();
// //////////////////
// General Exception
// //////////////////
Content content = contentService.getContent(repositoryId, objectId);
exceptionService.objectNotFound(DomainType.OBJECT, content, objectId);
exceptionService.permissionDenied(
callContext, repositoryId, PermissionMapping.CAN_GET_PROPERTIES_OBJECT, content);
// //////////////////
// Body of the method
// //////////////////
if (streamId == null) {
return getContentStreamInternal(repositoryId, content, offset, length);
} else {
return getRenditionStream(repositoryId, content, streamId);
}
} finally {
lock.unlock();
}
}
@Override
public void setContentStream(
CallContext callContext,
String repositoryId,
Holder<String> objectId,
boolean overwriteFlag,
ContentStream contentStream,
Holder<String> changeToken) {
exceptionService.invalidArgumentRequiredHolderString("objectId", objectId);
Lock lock = threadLockService.getWriteLock(repositoryId, objectId.getValue());
try {
lock.lock();
// //////////////////
// General Exception
// //////////////////
exceptionService.invalidArgumentRequired("contentStream", contentStream);
Document doc = (Document) contentService.getContent(repositoryId, objectId.getValue());
exceptionService.objectNotFound(DomainType.OBJECT, doc, objectId.getValue());
exceptionService.permissionDenied(
callContext, repositoryId, PermissionMapping.CAN_SET_CONTENT_DOCUMENT, doc);
DocumentTypeDefinition td =
(DocumentTypeDefinition) typeManager.getTypeDefinition(repositoryId, doc.getObjectType());
exceptionService.constraintImmutable(repositoryId, doc, td);
// //////////////////
// Specific Exception
// //////////////////
exceptionService.contentAlreadyExists(doc, overwriteFlag);
exceptionService.streamNotSupported(td, contentStream);
exceptionService.updateConflict(doc, changeToken);
exceptionService.versioning(doc);
Folder parent = contentService.getParent(repositoryId, objectId.getValue());
exceptionService.objectNotFoundParentFolder(repositoryId, objectId.getValue(), parent);
// //////////////////
// Body of the method
// //////////////////
String oldId = objectId.getValue();
// TODO Externalize versioningState
if (doc.isPrivateWorkingCopy()) {
Document result = contentService.replacePwc(callContext, repositoryId, doc, contentStream);
objectId.setValue(result.getId());
} else {
Document result =
contentService.createDocumentWithNewStream(
callContext, repositoryId, doc, contentStream);
objectId.setValue(result.getId());
}
nemakiCachePool.get(repositoryId).removeCmisCache(oldId);
} finally {
lock.unlock();
}
}
@Override
public ObjectData getObject(
CallContext callContext,
String repositoryId,
String objectId,
String filter,
Boolean includeAllowableActions,
IncludeRelationships includeRelationships,
String renditionFilter,
Boolean includePolicyIds,
Boolean includeAcl,
ExtensionsData extension) {
exceptionService.invalidArgumentRequired("objectId", objectId);
Lock lock = threadLockService.getReadLock(repositoryId, objectId);
try {
lock.lock();
// //////////////////
// General Exception
// //////////////////
Content content = contentService.getContent(repositoryId, objectId);
// WORK AROUND: getObject(versionSeriesId) is interpreted as
// getDocumentOflatestVersion
if (content == null) {
VersionSeries versionSeries = contentService.getVersionSeries(repositoryId, objectId);
if (versionSeries != null) {
content = contentService.getDocumentOfLatestVersion(repositoryId, objectId);
}
}
exceptionService.objectNotFound(DomainType.OBJECT, content, objectId);
exceptionService.permissionDenied(
callContext, repositoryId, PermissionMapping.CAN_GET_PROPERTIES_OBJECT, content);
// //////////////////
// Body of the method
// //////////////////
ObjectData object =
compileService.compileObjectData(
callContext,
repositoryId,
content,
filter,
includeAllowableActions,
includeRelationships,
null,
includeAcl);
return object;
} finally {
lock.unlock();
}
}
@Override
public void appendContentStream(
CallContext callContext,
String repositoryId,
Holder<String> objectId,
Holder<String> changeToken,
ContentStream contentStream,
boolean isLastChunk,
ExtensionsData extension) {
exceptionService.invalidArgumentRequiredHolderString("objectId", objectId);
Lock lock = threadLockService.getWriteLock(repositoryId, objectId.getValue());
try {
lock.lock();
// //////////////////
// General Exception
// //////////////////
exceptionService.invalidArgumentRequired("contentStream", contentStream);
Document doc = (Document) contentService.getContent(repositoryId, objectId.getValue());
exceptionService.objectNotFound(DomainType.OBJECT, doc, objectId.getValue());
exceptionService.permissionDenied(
callContext, repositoryId, PermissionMapping.CAN_SET_CONTENT_DOCUMENT, doc);
DocumentTypeDefinition td =
(DocumentTypeDefinition) typeManager.getTypeDefinition(repositoryId, doc.getObjectType());
exceptionService.constraintImmutable(repositoryId, doc, td);
// //////////////////
// Specific Exception
// //////////////////
exceptionService.streamNotSupported(td, contentStream);
exceptionService.updateConflict(doc, changeToken);
exceptionService.versioning(doc);
// //////////////////
// Body of the method
// //////////////////
contentService.appendAttachment(
callContext, repositoryId, objectId, changeToken, contentStream, isLastChunk, extension);
nemakiCachePool.get(repositoryId).removeCmisCache(objectId.getValue());
} finally {
lock.unlock();
}
}
@Override
public ObjectData getObjectByPath(
CallContext callContext,
String repositoryId,
String path,
String filter,
Boolean includeAllowableActions,
IncludeRelationships includeRelationships,
String renditionFilter,
Boolean includePolicyIds,
Boolean includeAcl,
ExtensionsData extension) {
// //////////////////
// General Exception
// //////////////////
exceptionService.invalidArgumentRequired("objectId", path);
// FIXME path is not preserved in db.
Content content = contentService.getContentByPath(repositoryId, path);
// TODO create objectNotFoundByPath method
exceptionService.objectNotFoundByPath(DomainType.OBJECT, content, path);
Lock lock = threadLockService.getReadLock(repositoryId, content.getId());
try {
lock.lock();
exceptionService.permissionDenied(
callContext, repositoryId, PermissionMapping.CAN_GET_PROPERTIES_OBJECT, content);
// //////////////////
// Body of the method
// //////////////////
return compileService.compileObjectData(
callContext,
repositoryId,
content,
filter,
includeAllowableActions,
includeRelationships,
renditionFilter,
includeAcl);
} finally {
lock.unlock();
}
}
@Override
public void moveObject(
CallContext callContext,
String repositoryId,
Holder<String> objectId,
String sourceFolderId,
String targetFolderId) {
exceptionService.invalidArgumentRequiredHolderString("objectId", objectId);
Lock lock = threadLockService.getWriteLock(repositoryId, objectId.getValue());
try {
lock.lock();
// //////////////////
// General Exception
// //////////////////
exceptionService.invalidArgumentRequiredString("sourceFolderId", sourceFolderId);
exceptionService.invalidArgumentRequiredString("targetFolderId", targetFolderId);
Content content = contentService.getContent(repositoryId, objectId.getValue());
exceptionService.objectNotFound(DomainType.OBJECT, content, objectId.getValue());
Folder source = contentService.getFolder(repositoryId, sourceFolderId);
exceptionService.objectNotFound(DomainType.OBJECT, source, sourceFolderId);
Folder target = contentService.getFolder(repositoryId, targetFolderId);
exceptionService.objectNotFound(DomainType.OBJECT, target, targetFolderId);
exceptionService.permissionDenied(
callContext, repositoryId, PermissionMapping.CAN_MOVE_OBJECT, content);
exceptionService.permissionDenied(
callContext, repositoryId, PermissionMapping.CAN_MOVE_SOURCE, source);
exceptionService.permissionDenied(
callContext, repositoryId, PermissionMapping.CAN_MOVE_TARGET, target);
// //////////////////
// Body of the method
// //////////////////
contentService.move(callContext, repositoryId, content, target);
nemakiCachePool.get(repositoryId).removeCmisCache(content.getId());
} finally {
lock.unlock();
}
}