@Override
public int compare(StoredObject f1, StoredObject f2) {
String segment1 = f1.getName();
String segment2 = f2.getName();
return segment1.compareTo(segment2);
}
@Override
public void rename(StoredObject so, String newName, String user) {
try {
lock();
if (so.getId().equals(fRootFolder.getId())) {
throw new CmisInvalidArgumentException("Root folder cannot be renamed.");
}
if (so instanceof Fileable) {
for (String folderId : ((Fileable) so).getParentIds()) {
Folder folder = (Folder) getObjectById(folderId);
if (hasChild(folder, newName)) {
throw new CmisNameConstraintViolationException(
"Cannot rename object to "
+ newName
+ ". This path already exists in parent "
+ getFolderPath(folder.getId())
+ ".");
}
}
}
so.setName(newName);
} finally {
unlock();
}
}
@Override
public List<StoredObject> getRelationships(
String objectId, List<String> typeIds, RelationshipDirection direction) {
List<StoredObject> res = new ArrayList<StoredObject>();
if (typeIds != null && typeIds.size() > 0) {
for (String typeId : typeIds) {
for (StoredObject so : fStoredObjectMap.values()) {
if (so instanceof Relationship && so.getTypeId().equals(typeId)) {
Relationship ro = (Relationship) so;
if (ro.getSourceObjectId().equals(objectId)
&& (RelationshipDirection.EITHER == direction
|| RelationshipDirection.SOURCE == direction)) {
res.add(so);
} else if (ro.getTargetObjectId().equals(objectId)
&& (RelationshipDirection.EITHER == direction
|| RelationshipDirection.TARGET == direction)) {
res.add(so);
}
}
}
}
} else {
res = getAllRelationships(objectId, direction);
}
return res;
}
@Override
public StoredObject createRelationship(
String name,
StoredObject sourceObject,
StoredObject targetObject,
Map<String, PropertyData<?>> propMap,
String user,
Acl addACEs,
Acl removeACEs) {
RelationshipImpl rel = new RelationshipImpl();
rel.createSystemBasePropertiesWhenCreated(propMap, user);
rel.setCustomProperties(propMap);
rel.setRepositoryId(fRepositoryId);
rel.setName(name);
if (null != sourceObject) {
rel.setSource(sourceObject.getId());
}
if (null != targetObject) {
rel.setTarget(targetObject.getId());
}
String id = storeObject(rel);
rel.setId(id);
applyAcl(rel, addACEs, removeACEs);
return rel;
}
@Override
public boolean isTypeInUse(String typeId) {
// iterate over all the objects and check for each if the type matches
for (String objectId : getIds()) {
StoredObject so = getObjectById(objectId);
if (so.getTypeId().equals(typeId)) {
return true;
}
}
return false;
}
private void checkAccess(String principalId, StoredObject so, Permission permission) {
if (!hasAccess(principalId, so, permission)) {
throw new CmisPermissionDeniedException(
"Object with id "
+ so.getId()
+ " and name "
+ so.getName()
+ " does not grant "
+ permission.toString()
+ " access to principal "
+ principalId);
}
}
public String storeObject(StoredObject so) {
String id = so.getId();
// check if update or create
if (null == id) {
id = getNextId().toString();
}
fStoredObjectMap.put(id, so);
return id;
}
@Override
public void addParent(StoredObject so, Folder parent) {
try {
lock();
if (hasChild(parent, so.getName())) {
throw new IllegalArgumentException(
"Cannot assign new parent folder, this name already exists in target folder.");
}
MultiFiling mfi;
if (so instanceof MultiFiling) {
mfi = (MultiFiling) so;
} else {
throw new IllegalArgumentException("Object " + so.getId() + "is not fileable");
}
addParentIntern(mfi, parent);
} finally {
unlock();
}
}
public Acl getAcl(
CallContext context,
String repositoryId,
String objectId,
Boolean onlyBasicPermissions,
ExtensionsData extension,
ObjectInfoHandler objectInfos) {
LOG.debug("start getAcl()");
Acl acl = null;
StoredObject so = validator.getAcl(context, repositoryId, objectId, extension);
if (so instanceof DocumentVersion) acl = ((DocumentVersion) so).getParentDocument().getAcl();
else acl = so.getAcl();
if (context.isObjectInfoRequired()) {
ObjectInfoImpl objectInfo = new ObjectInfoImpl();
fAtomLinkProvider.fillInformationForAtomLinks(repositoryId, so, objectInfo);
objectInfos.addObjectInfo(objectInfo);
}
return acl;
}
@Override
public void updateObject(
StoredObject so, Map<String, PropertyData<?>> newProperties, String user) {
// nothing to do
Map<String, PropertyData<?>> properties = so.getProperties();
for (String key : newProperties.keySet()) {
PropertyData<?> value = newProperties.get(key);
if (key.equals(PropertyIds.SECONDARY_OBJECT_TYPE_IDS)) {
properties.put(key, value); // preserve it even if it is empty!
} else if (null == value || value.getValues() == null || value.getFirstValue() == null) {
// delete property
properties.remove(key);
} else {
properties.put(key, value);
}
}
// update system properties and secondary object type ids
so.updateSystemBasePropertiesWhenModified(properties, user);
properties.remove(PropertyIds.SECONDARY_OBJECT_TYPE_IDS);
}
@Override
public ContentStream setContent(StoredObject so, ContentStream contentStream) {
if (so instanceof Content) {
ContentStreamDataImpl newContent;
Content content = (Content) so;
if (null == contentStream) {
newContent = null;
} else {
boolean useFakeContentStore =
so.getTypeId().equals(DefaultTypeSystemCreator.BIG_CONTENT_FAKE_TYPE);
newContent =
new ContentStreamDataImpl(
MAX_CONTENT_SIZE_KB == null ? 0 : MAX_CONTENT_SIZE_KB, useFakeContentStore);
String fileName = contentStream.getFileName();
if (null == fileName || fileName.length() <= 0) {
fileName = so.getName(); // use name of document as fallback
}
newContent.setFileName(fileName);
String mimeType = contentStream.getMimeType();
if (null == mimeType || mimeType.length() <= 0) {
mimeType = "application/octet-stream"; // use as fallback
}
newContent.setMimeType(mimeType);
newContent.setLastModified(new GregorianCalendar());
try {
newContent.setContent(contentStream.getStream());
} catch (IOException e) {
throw new CmisRuntimeException("Failed to get content from InputStream", e);
}
}
content.setContent(newContent);
return newContent;
} else {
throw new CmisInvalidArgumentException(
"Cannot set content, object does not implement interface Content.");
}
}
@Override
public void move(StoredObject so, Folder oldParent, Folder newParent, String user) {
try {
if (hasChild(newParent, so.getName())) {
throw new CmisInvalidArgumentException(
"Cannot move object "
+ so.getName()
+ " to folder "
+ getFolderPath(newParent.getId())
+ ". A child with this name already exists.");
}
lock();
if (so instanceof MultiFiling) {
MultiFiling fi = (MultiFiling) so;
addParentIntern(fi, newParent);
removeParentIntern(fi, oldParent);
} else if (so instanceof FolderImpl) {
((FolderImpl) so).setParentId(newParent.getId());
}
} finally {
unlock();
}
}
@Override
public List<String> getParentIds(StoredObject so, String user) {
List<String> visibleParents = new ArrayList<String>();
if (!(so instanceof Fileable)) {
throw new CmisInvalidArgumentException("Object is not fileable: " + so.getId());
}
Filing fileable = (Fileable) so;
List<String> parents = fileable.getParentIds();
for (String id : parents) {
StoredObject parent = getObjectById(id);
if (hasReadAccess(user, parent)) {
visibleParents.add(id);
}
}
return visibleParents;
}
@Override
public void removeParent(StoredObject so, Folder parent) {
try {
lock();
MultiFiling mfi;
if (so instanceof MultiFiling) {
mfi = (MultiFiling) so;
} else {
throw new IllegalArgumentException("Object " + so.getId() + "is not fileable");
}
removeParentIntern(mfi, parent);
} finally {
unlock();
}
}