@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 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 void versioning(Document doc) { if (!doc.isLatestVersion() && !doc.isPrivateWorkingCopy()) { String msg = "The operation is not allowed on a non-current version of a document"; throw new CmisVersioningException(buildMsgWithId(msg, doc.getId()), HTTP_STATUS_CODE_409); } }
@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 constraintAlreadyCheckedOut(String repositoryId, Document document) { VersionSeries vs = contentService.getVersionSeries(repositoryId, document); if (vs.isVersionSeriesCheckedOut()) { if (!(document.isPrivateWorkingCopy())) { constraint(document.getId(), "The version series is already checked out"); } } }
@Override public void constraintUpdateWhenCheckedOut( String repositoryId, String currentUserId, Document document) { VersionSeries vs = contentService.getVersionSeries(repositoryId, document); if (vs.isVersionSeriesCheckedOut()) { if (document.isPrivateWorkingCopy()) { // Can update by only the use who has checked it out String whoCheckedOut = vs.getVersionSeriesCheckedOutBy(); if (!currentUserId.equals(whoCheckedOut)) { constraint( document.getId(), "This private working copy can be modified only by the user who has checked it out. "); } } else { // All versions except for PWC are locked. constraint(document.getId(), "All versions except for PWC are locked when checked out."); } } }
@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 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"); } }