private Content checkExceptionBeforeUpdateProperties(
CallContext callContext,
String repositoryId,
Holder<String> objectId,
Properties properties,
Holder<String> changeToken) {
// //////////////////
// General Exception
// //////////////////
exceptionService.invalidArgumentRequiredCollection("properties", properties.getPropertyList());
Content content = contentService.getContent(repositoryId, objectId.getValue());
exceptionService.objectNotFound(DomainType.OBJECT, content, objectId.getValue());
if (content.isDocument()) {
Document d = (Document) content;
exceptionService.versioning(d);
exceptionService.constraintUpdateWhenCheckedOut(repositoryId, callContext.getUsername(), d);
TypeDefinition typeDef = typeManager.getTypeDefinition(repositoryId, d);
exceptionService.constraintImmutable(repositoryId, d, typeDef);
}
exceptionService.permissionDenied(
callContext, repositoryId, PermissionMapping.CAN_UPDATE_PROPERTIES_OBJECT, content);
exceptionService.updateConflict(content, changeToken);
TypeDefinition tdf = typeManager.getTypeDefinition(repositoryId, content);
exceptionService.constraintPropertyValue(repositoryId, tdf, properties, objectId.getValue());
return content;
}
@Override
public String createDocumentFromSource(
CallContext callContext,
String repositoryId,
String sourceId,
Properties properties,
String folderId,
VersioningState versioningState,
List<String> policies,
Acl addAces,
Acl removeAces) {
Document original = contentService.getDocument(repositoryId, sourceId);
DocumentTypeDefinition td =
(DocumentTypeDefinition)
typeManager.getTypeDefinition(repositoryId, original.getObjectType());
// //////////////////
// General Exception
// //////////////////
exceptionService.invalidArgumentRequired("properties", properties);
exceptionService.invalidArgumentRequiredParentFolderId(repositoryId, folderId);
Folder parentFolder = contentService.getFolder(repositoryId, folderId);
exceptionService.objectNotFoundParentFolder(repositoryId, folderId, parentFolder);
exceptionService.permissionDenied(
callContext, repositoryId, PermissionMapping.CAN_CREATE_FOLDER_FOLDER, parentFolder);
// //////////////////
// Specific Exception
// //////////////////
exceptionService.constraintBaseTypeId(repositoryId, properties, BaseTypeId.CMIS_DOCUMENT);
exceptionService.constraintAllowedChildObjectTypeId(parentFolder, properties);
exceptionService.constraintPropertyValue(
repositoryId, td, properties, DataUtil.getIdProperty(properties, PropertyIds.OBJECT_ID));
exceptionService.constraintControllableVersionable(td, versioningState, null);
versioningState =
(td.isVersionable() && versioningState == null) ? VersioningState.MAJOR : versioningState;
exceptionService.constraintCotrollablePolicies(td, policies, properties);
exceptionService.constraintCotrollableAcl(td, addAces, removeAces, properties);
exceptionService.constraintPermissionDefined(repositoryId, addAces, null);
exceptionService.constraintPermissionDefined(repositoryId, removeAces, null);
exceptionService.nameConstraintViolation(properties, parentFolder);
// //////////////////
// Body of the method
// //////////////////
Document document =
contentService.createDocumentFromSource(
callContext,
repositoryId,
properties,
parentFolder,
original,
versioningState,
policies,
addAces,
removeAces);
return document.getId();
}
@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 void constraintVersionable(String repositoryId, String typeId) {
DocumentTypeDefinition type =
(DocumentTypeDefinition) typeManager.getTypeDefinition(repositoryId, typeId);
if (!type.isVersionable()) {
String msg = "Object type: " + type.getId() + " is not versionbale";
throw new CmisConstraintException(msg, HTTP_STATUS_CODE_409);
}
}
@Override
public void constraintBaseTypeId(
String repositoryId, Properties properties, BaseTypeId baseTypeId) {
String objectTypeId = DataUtil.getObjectTypeId(properties);
TypeDefinition td = typeManager.getTypeDefinition(repositoryId, objectTypeId);
if (!td.getBaseTypeId().equals(baseTypeId))
constraint(null, "cmis:objectTypeId is not an object type whose base tyep is " + baseTypeId);
}
@Override
public void invalidArgumentDoesNotExistType(String repositoryId, String typeId) {
String msg = "";
TypeDefinition type = typeManager.getTypeDefinition(repositoryId, typeId);
if (type == null) {
msg = "Specified type does not exist";
msg = msg + " [objectTypeId = " + typeId + "]";
invalidArgument(msg);
}
}
@Override
public void constraintOnlyLeafTypeDefinition(String repositoryId, String objectTypeId) {
TypeDefinitionContainer tdc = typeManager.getTypeById(repositoryId, objectTypeId);
if (!CollectionUtils.isEmpty(tdc.getChildren())) {
String msg =
"Cannot delete a type definition which has sub types"
+ " [objectTypeId = "
+ objectTypeId
+ "]";
throw new CmisConstraintException(msg, HTTP_STATUS_CODE_409);
}
}
@Override
public void constraintContentStreamRequired(String repositoryId, Document document) {
String objectTypeId = document.getObjectType();
DocumentTypeDefinition td =
(DocumentTypeDefinition) typeManager.getTypeDefinition(repositoryId, objectTypeId);
if (td.getContentStreamAllowed() == ContentStreamAllowed.REQUIRED) {
if (document.getAttachmentNodeId() == null
|| contentService.getAttachment(repositoryId, document.getAttachmentNodeId()) == null) {
constraint(document.getId(), "This document type does not allow no content stream");
}
}
}
@Override
public void constraintContentStreamDownload(String repositoryId, Document document) {
DocumentTypeDefinition documentTypeDefinition =
(DocumentTypeDefinition) typeManager.getTypeDefinition(repositoryId, document);
ContentStreamAllowed csa = documentTypeDefinition.getContentStreamAllowed();
if (ContentStreamAllowed.NOTALLOWED == csa
|| ContentStreamAllowed.ALLOWED == csa
&& StringUtils.isBlank(document.getAttachmentNodeId())) {
constraint(
document.getId(),
"This document has no ContentStream. getContentStream is not supported.");
}
}
@Override
public void invalidArgumentDeletableType(String repositoryId, String typeId) {
TypeDefinition type = typeManager.getTypeDefinition(repositoryId, typeId);
String msg = "";
TypeMutability typeMutability = type.getTypeMutability();
boolean canUpdate = (typeMutability.canDelete() == null) ? true : typeMutability.canDelete();
if (!canUpdate) {
msg = "Specified type is not deletable";
msg = msg + " [objectTypeId = " + type.getId() + "]";
invalidArgument(msg);
}
}
@Override
public String createRelationship(
CallContext callContext,
String repositoryId,
Properties properties,
List<String> policies,
Acl addAces,
Acl removeAces,
ExtensionsData extension) {
String objectTypeId = DataUtil.getIdProperty(properties, PropertyIds.OBJECT_TYPE_ID);
RelationshipTypeDefinition td =
(RelationshipTypeDefinition) typeManager.getTypeDefinition(repositoryId, objectTypeId);
// //////////////////
// Exception
// //////////////////
exceptionService.invalidArgumentRequiredCollection("properties", properties.getPropertyList());
String sourceId = DataUtil.getIdProperty(properties, PropertyIds.SOURCE_ID);
if (sourceId != null) {
Content source = contentService.getContent(repositoryId, sourceId);
if (source == null) exceptionService.constraintAllowedSourceTypes(td, source);
exceptionService.permissionDenied(
callContext, repositoryId, PermissionMapping.CAN_CREATE_RELATIONSHIP_SOURCE, source);
}
String targetId = DataUtil.getIdProperty(properties, PropertyIds.TARGET_ID);
if (targetId != null) {
Content target = contentService.getContent(repositoryId, targetId);
if (target == null) exceptionService.constraintAllowedTargetTypes(td, target);
exceptionService.permissionDenied(
callContext, repositoryId, PermissionMapping.CAN_CREATE_RELATIONSHIP_TARGET, target);
}
exceptionService.constraintBaseTypeId(repositoryId, properties, BaseTypeId.CMIS_RELATIONSHIP);
exceptionService.constraintPropertyValue(
repositoryId, td, properties, DataUtil.getIdProperty(properties, PropertyIds.OBJECT_ID));
exceptionService.constraintCotrollablePolicies(td, policies, properties);
exceptionService.constraintCotrollableAcl(td, addAces, removeAces, properties);
exceptionService.constraintPermissionDefined(repositoryId, addAces, null);
exceptionService.constraintPermissionDefined(repositoryId, removeAces, null);
exceptionService.nameConstraintViolation(properties, null);
// //////////////////
// Body of the method
// //////////////////
Relationship relationship =
contentService.createRelationship(
callContext, repositoryId, properties, policies, addAces, removeAces, extension);
nemakiCachePool.get(repositoryId).removeCmisCache(relationship.getSourceId());
nemakiCachePool.get(repositoryId).removeCmisCache(relationship.getTargetId());
return relationship.getId();
}
@Override
public <T> void constraintPropertyValue(
String repositoryId, TypeDefinition typeDefinition, Properties properties, String objectId) {
Map<String, PropertyDefinition<?>> propertyDefinitions =
typeDefinition.getPropertyDefinitions();
// Adding secondary types and its properties MAY be done in the same
// operation
List<String> secIds =
DataUtil.getIdListProperty(properties, PropertyIds.SECONDARY_OBJECT_TYPE_IDS);
if (CollectionUtils.isNotEmpty(secIds)) {
for (String secId : secIds) {
TypeDefinition sec = typeManager.getTypeById(repositoryId, secId).getTypeDefinition();
for (Entry<String, PropertyDefinition<?>> entry : sec.getPropertyDefinitions().entrySet()) {
if (!propertyDefinitions.containsKey(entry.getKey())) {
propertyDefinitions.put(entry.getKey(), entry.getValue());
}
}
}
}
for (PropertyData<?> _pd : properties.getPropertyList()) {
PropertyData<T> pd = (PropertyData<T>) _pd;
PropertyDefinition<T> propertyDefinition =
(PropertyDefinition<T>) propertyDefinitions.get(pd.getId());
// If an input property is not defined one, output error.
if (propertyDefinition == null) constraint(objectId, "An undefined property is provided!");
// Check "required" flag
if (propertyDefinition.isRequired() && !DataUtil.valueExist(pd.getValues()))
constraint(objectId, "An required property is not provided!");
// Check choices
constraintChoices(propertyDefinition, pd, objectId);
// Check min/max length
switch (propertyDefinition.getPropertyType()) {
case STRING:
constraintStringPropertyValue(propertyDefinition, pd, objectId);
break;
case DECIMAL:
constraintDecimalPropertyValue(propertyDefinition, pd, objectId);
case INTEGER:
constraintIntegerPropertyValue(propertyDefinition, pd, objectId);
break;
default:
break;
}
}
}
@Override
public void invalidArgumentCreatableType(String repositoryId, TypeDefinition type) {
String msg = "";
String parentId = type.getParentTypeId();
if (typeManager.getTypeById(repositoryId, parentId) == null) {
msg = "Specified parent type does not exist";
} else {
TypeDefinition parent = typeManager.getTypeById(repositoryId, parentId).getTypeDefinition();
if (parent.getTypeMutability() == null) {
msg = "Specified parent type does not have TypeMutability";
} else {
boolean canCreate = (parent.getTypeMutability() == null) ? false : true;
if (!canCreate) {
msg = "Specified parent type has TypeMutability.canCreate = false";
}
}
}
if (!StringUtils.isEmpty(msg)) {
msg = msg + " [objectTypeId = " + type.getId() + "]";
invalidArgument(msg);
}
}
@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 String createItem(
CallContext callContext,
String repositoryId,
Properties properties,
String folderId,
List<String> policies,
Acl addAces,
Acl removeAces,
ExtensionsData extension) {
// //////////////////
// General Exception
// //////////////////
TypeDefinition td =
typeManager.getTypeDefinition(repositoryId, DataUtil.getObjectTypeId(properties));
Folder parentFolder = contentService.getFolder(repositoryId, folderId);
exceptionService.objectNotFoundParentFolder(repositoryId, folderId, parentFolder);
exceptionService.invalidArgumentRequiredCollection("properties", properties.getPropertyList());
// //////////////////
// Specific Exception
// //////////////////
exceptionService.constraintBaseTypeId(repositoryId, properties, BaseTypeId.CMIS_ITEM);
exceptionService.constraintPropertyValue(
repositoryId, td, properties, DataUtil.getIdProperty(properties, PropertyIds.OBJECT_ID));
exceptionService.constraintCotrollablePolicies(td, policies, properties);
exceptionService.constraintCotrollableAcl(td, addAces, removeAces, properties);
// //////////////////
// Body of the method
// //////////////////
Item item =
contentService.createItem(
callContext,
repositoryId,
properties,
folderId,
policies,
addAces,
removeAces,
extension);
return item.getId();
}
@Override
public String createFolder(
CallContext callContext,
String repositoryId,
Properties properties,
String folderId,
List<String> policies,
Acl addAces,
Acl removeAces,
ExtensionsData extension) {
FolderTypeDefinition td =
(FolderTypeDefinition)
typeManager.getTypeDefinition(repositoryId, DataUtil.getObjectTypeId(properties));
Folder parentFolder = contentService.getFolder(repositoryId, folderId);
// //////////////////
// General Exception
// //////////////////
exceptionService.objectNotFoundParentFolder(repositoryId, folderId, parentFolder);
exceptionService.permissionDenied(
callContext, repositoryId, PermissionMapping.CAN_CREATE_FOLDER_FOLDER, parentFolder);
// //////////////////
// Specific Exception
// //////////////////
exceptionService.constraintBaseTypeId(repositoryId, properties, BaseTypeId.CMIS_FOLDER);
exceptionService.constraintAllowedChildObjectTypeId(parentFolder, properties);
exceptionService.constraintPropertyValue(
repositoryId, td, properties, DataUtil.getIdProperty(properties, PropertyIds.OBJECT_ID));
exceptionService.constraintCotrollablePolicies(td, policies, properties);
exceptionService.constraintCotrollableAcl(td, addAces, removeAces, properties);
exceptionService.constraintPermissionDefined(repositoryId, addAces, null);
exceptionService.constraintPermissionDefined(repositoryId, removeAces, null);
exceptionService.nameConstraintViolation(properties, parentFolder);
// //////////////////
// Body of the method
// //////////////////
Folder folder =
contentService.createFolder(callContext, repositoryId, properties, parentFolder);
return folder.getId();
}
private <T> PropertyDefinition<T> constraintUpdatePropertyDefinitionHelper(
PropertyDefinition<T> update, PropertyDefinition<?> old) {
String msg = "";
// objField.setName(field.getName());
// objField.setValue(field.getValue());
// return objField;
if (!old.isInherited().equals(update.isInherited())) {
msg += "'inherited' cannot be modified";
}
if (typeManager.getSystemPropertyIds().contains(update.getId())) {
msg += "CMIS-defined property definition cannot be modified";
}
if (Boolean.FALSE.equals(old.isRequired()) && Boolean.TRUE.equals(update.isRequired())) {
msg += "'required' cannot be modified from Optional to Required";
constraint(msg);
}
if (Boolean.TRUE.equals(old.isOpenChoice()) && Boolean.FALSE.equals(update.isOpenChoice())) {
msg += "'openChoice' cannot be modified from true to false";
constraint(msg);
}
if (Boolean.FALSE.equals(update.isOpenChoice())) {
constraintChoicesRestriction(update, old);
}
constraintRestrictedValidation(update, old);
if (!old.getPropertyType().equals(update.getPropertyType())) {
msg += "'property type' cannot be modified";
constraint(msg);
}
if (!old.getCardinality().equals(update.getCardinality())) {
msg += "'cardinality' cannot be modified";
constraint(msg);
}
return update;
}
@Override
public String createPolicy(
CallContext callContext,
String repositoryId,
Properties properties,
String folderId,
List<String> policies,
Acl addAces,
Acl removeAces,
ExtensionsData extension) {
// //////////////////
// General Exception
// //////////////////
exceptionService.invalidArgumentRequiredCollection("properties", properties.getPropertyList());
// NOTE: folderId is ignored because policy is not filable in Nemaki
TypeDefinition td =
typeManager.getTypeDefinition(
repositoryId, DataUtil.getIdProperty(properties, PropertyIds.OBJECT_TYPE_ID));
exceptionService.constraintPropertyValue(
repositoryId, td, properties, DataUtil.getIdProperty(properties, PropertyIds.OBJECT_ID));
// //////////////////
// Specific Exception
// //////////////////
exceptionService.constraintBaseTypeId(repositoryId, properties, BaseTypeId.CMIS_POLICY);
// exceptionService.constraintAllowedChildObjectTypeId(parent,
// properties);
exceptionService.constraintCotrollablePolicies(td, policies, properties);
exceptionService.constraintCotrollableAcl(td, addAces, removeAces, properties);
// exceptionService.nameConstraintViolation(properties, parent);
// //////////////////
// Body of the method
// //////////////////
Policy policy =
contentService.createPolicy(
callContext, repositoryId, properties, policies, addAces, removeAces, extension);
return policy.getId();
}
@Override
public void constraintImmutable(
String repositoryId, Document document, TypeDefinition typeDefinition) {
Boolean defaultVal =
(Boolean)
typeManager.getSingleDefaultValue(
PropertyIds.IS_IMMUTABLE, typeDefinition.getId(), repositoryId);
boolean flag = false;
if (document.isImmutable() == null) {
if (defaultVal != null && defaultVal) {
flag = true;
}
} else {
if (document.isImmutable()) {
flag = true;
}
}
if (flag) {
constraint(document.getId(), "Immutable document cannot be updated/deleted");
}
}
@Override
public void invalidArgumentSecondaryTypeIds(String repositoryId, Properties properties) {
if (properties == null) return;
Map<String, PropertyData<?>> map = properties.getProperties();
if (MapUtils.isEmpty(map)) return;
List<String> results = new ArrayList<String>();
PropertyData<?> ids = map.get(PropertyIds.SECONDARY_OBJECT_TYPE_IDS);
if (ids == null || CollectionUtils.isEmpty(ids.getValues())) return;
for (Object _id : ids.getValues()) {
String id = (String) _id;
TypeDefinitionContainer tdc = typeManager.getTypeById(repositoryId, id);
if (tdc == null) {
results.add(id);
}
}
if (CollectionUtils.isNotEmpty(results)) {
String msg =
"Invalid cmis:SecondaryObjectTypeIds are provided:" + StringUtils.join(results, ",");
invalidArgument(msg);
}
}
@Override
public void constraintDuplicatePropertyDefinition(
String repositoryId, TypeDefinition typeDefinition) {
Map<String, PropertyDefinition<?>> props = typeDefinition.getPropertyDefinitions();
if (MapUtils.isNotEmpty(props)) {
Set<String> keys = props.keySet();
TypeDefinition parent =
typeManager.getTypeDefinition(repositoryId, typeDefinition.getParentTypeId());
Map<String, PropertyDefinition<?>> parentProps = parent.getPropertyDefinitions();
if (MapUtils.isNotEmpty(parentProps)) {
Set<String> parentKeys = parentProps.keySet();
for (String key : keys) {
if (parentKeys.contains(key)) {
String msg =
"Duplicate property definition with parent type definition"
+ " [property id = "
+ key
+ "]";
throw new CmisConstraintException(msg, HTTP_STATUS_CODE_409);
}
}
}
}
}
@Override
public ObjectData create(
CallContext callContext,
String repositoryId,
Properties properties,
String folderId,
ContentStream contentStream,
VersioningState versioningState,
List<String> policies,
ExtensionsData extension) {
String typeId = DataUtil.getObjectTypeId(properties);
TypeDefinition type = typeManager.getTypeDefinition(repositoryId, typeId);
if (type == null) {
throw new CmisObjectNotFoundException("Type '" + typeId + "' is unknown!");
}
String objectId = null;
// TODO ACE can be set !
if (type.getBaseTypeId() == BaseTypeId.CMIS_DOCUMENT) {
objectId =
createDocument(
callContext,
repositoryId,
properties,
folderId,
contentStream,
versioningState,
null,
null,
null);
} else if (type.getBaseTypeId() == BaseTypeId.CMIS_FOLDER) {
objectId =
createFolder(
callContext, repositoryId, properties, folderId, policies, null, null, extension);
} else if (type.getBaseTypeId() == BaseTypeId.CMIS_RELATIONSHIP) {
objectId =
createRelationship(
callContext, repositoryId, properties, policies, null, null, extension);
} else if (type.getBaseTypeId() == BaseTypeId.CMIS_POLICY) {
objectId =
createPolicy(
callContext, repositoryId, properties, folderId, policies, null, null, extension);
} else if (type.getBaseTypeId() == BaseTypeId.CMIS_ITEM) {
objectId =
createItem(
callContext, repositoryId, properties, folderId, policies, null, null, extension);
} else {
throw new CmisObjectNotFoundException("Cannot create object of type '" + typeId + "'!");
}
ObjectData object =
compileService.compileObjectData(
callContext,
repositoryId,
contentService.getContent(repositoryId, objectId),
null,
false,
IncludeRelationships.NONE,
null,
false);
return object;
}