@Override
public void setUp() throws Exception {
super.setUp();
this.fileFolderService = (FileFolderService) ctx.getBean("FileFolderService");
this.repositoryHelper = (Repository) ctx.getBean("repositoryHelper");
this.nodeService = (NodeService) ctx.getBean("NodeService");
this.transactionService = (TransactionService) ctx.getBean("transactionService");
server.setServletAuthenticatorFactory(new LocalTestRunAsAuthenticatorFactory());
NodeRef companyHomeNodeRef = repositoryHelper.getCompanyHome();
String guid = GUID.generate();
AuthenticationUtil.setFullyAuthenticatedUser(AuthenticationUtil.getSystemUserName());
folderWithoutAspect =
fileFolderService
.create(companyHomeNodeRef, "folder_" + guid, ContentModel.TYPE_FOLDER)
.getNodeRef();
assertNotNull("Doesn't create folder", folderWithoutAspect);
folderWithAspect =
fileFolderService
.create(companyHomeNodeRef, "folder_aspect_" + guid, ContentModel.TYPE_FOLDER)
.getNodeRef();
assertNotNull("Doesn't create folder", folderWithoutAspect);
// add 'dublincore' aspect
Map<QName, Serializable> aspectProps = new HashMap<QName, Serializable>(1);
aspectProps.put(ContentModel.PROP_SUBJECT, "Test subject");
nodeService.addAspect(folderWithAspect, ContentModel.ASPECT_DUBLINCORE, aspectProps);
}
public void testCheckOutCheckInWithTranslatableAspect() {
// Create a node to be used as the translation
NodeRef translationNodeRef =
nodeService
.createNode(
rootNodeRef,
ContentModel.ASSOC_CHILDREN,
QName.createQName("translation"),
ContentModel.TYPE_CONTENT)
.getChildRef();
nodeService.addAspect(
this.nodeRef,
QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, "translatable"),
null);
nodeService.createAssociation(
this.nodeRef,
translationNodeRef,
QName.createQName(NamespaceService.CONTENT_MODEL_1_0_URI, "translations"));
// Check it out
NodeRef workingCopy =
cociService.checkout(
this.nodeRef,
this.rootNodeRef,
ContentModel.ASSOC_CHILDREN,
QName.createQName("workingCopy"));
// Check it back in again
Map<String, Serializable> versionProperties = new HashMap<String, Serializable>();
versionProperties.put(Version.PROP_DESCRIPTION, "This is a test version");
cociService.checkin(workingCopy, versionProperties);
}
@Override
public Boolean doWork() throws Exception {
if (tracer.isDebugEnabled()) tracer.debug("DocumentAcquiring action.doWork, execution init");
try {
// calculating DOCUMENT_ACQUIRING properties values
Map<QName, Serializable> properties = new HashMap<QName, Serializable>();
properties.put(
SinekartaModel.PROP_QNAME_TIMESTAMP_PROCESS_START, new Date(System.currentTimeMillis()));
properties.put(
SinekartaModel.PROP_QNAME_REFERENCE_ID,
(String) this.nodeService.getProperty(actionedUponNodeRef, ContentModel.PROP_NODE_UUID));
// have we received info about the document type?
if (documentType != null) {
// if yes the document is moving from another space
properties.put(SinekartaModel.PROP_QNAME_DOCUMENT_MOVED, true);
properties.put(SinekartaModel.PROP_QNAME_DOCUMENT_DATE, documentDate);
properties.put(SinekartaModel.PROP_QNAME_DOCUMENT_TYPE, "" + documentType.getId());
properties.put(SinekartaModel.PROP_QNAME_LANGUAGE, documentLanguage);
}
// adding DOCUMENT_ACQUIRING aspect to document
nodeService.addAspect(
actionedUponNodeRef, SinekartaModel.ASPECT_QNAME_DOCUMENT_ACQUIRING, properties);
if (documentType != null) {
if (tracer.isDebugEnabled())
tracer.debug("DocumentAcquiring doWork : let's go to reorganize the archive");
// invoking archive organization action
Action documentOrganize =
actionService.createAction(DocumentOrganize.ACTION_NAME_DOCUMENT_ORGANIZE);
try {
actionService.executeAction(documentOrganize, actionedUponNodeRef, false, false);
} catch (Throwable t) {
tracer.error("Unable to reorganize archive", t);
throw new DocumentAcquiringException("Unable to reorganize archive", t);
}
}
} catch (Throwable e) {
tracer.error("DocumentAcquiring action.doWork, unable to acquire document", e);
koReason = "DocumentAcquiring action.doWork, unable to acquire document : " + e.getMessage();
return false;
}
if (tracer.isDebugEnabled()) tracer.debug("DocumentAcquiring action.doWork, finished ok");
return true;
}
public void onCopyComplete(
QName classRef,
NodeRef sourceNodeRef,
NodeRef targetNodeRef,
boolean copyToNewNode,
Map<NodeRef, NodeRef> copyMap) {
Set<NodeRef> workingCopyNodeRefs = TransactionalResourceHelper.getSet(KEY_WORKING_COPIES);
if (!workingCopyNodeRefs.contains(sourceNodeRef)) {
// This is not one of the nodes that needs to have discussions copied over
return;
}
// First check that the source node has forums
NodeRef sourceForumNodeRef = getForum(sourceNodeRef);
if (sourceForumNodeRef == null) {
// Missing! Clean the source node up!
nodeService.removeAspect(sourceNodeRef, ForumModel.ASPECT_DISCUSSABLE);
return;
}
// The aspect may or may not exist on the target node
if (!nodeService.hasAspect(targetNodeRef, ForumModel.ASPECT_DISCUSSABLE)) {
// Add the aspect
nodeService.addAspect(targetNodeRef, ForumModel.ASPECT_DISCUSSABLE, null);
}
// Get the forum node
NodeRef targetForumNodeRef = getForum(targetNodeRef);
// Merge the forum topics
List<ChildAssociationRef> topicAssocRefs =
nodeService.getChildAssocs(
sourceForumNodeRef, Collections.singleton(ForumModel.TYPE_TOPIC));
int copied = 0;
for (ChildAssociationRef topicAssocRef : topicAssocRefs) {
NodeRef topicNodeRef = topicAssocRef.getChildRef();
try {
// work out the name for the copied topic
String topicName;
String topicNodeName =
nodeService.getProperty(topicNodeRef, ContentModel.PROP_NAME).toString();
Serializable labelProp =
nodeService.getProperty(targetNodeRef, ContentModel.PROP_VERSION_LABEL);
if (labelProp == null) {
SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy-HH-mm-ss");
topicName = topicNodeName + " - " + dateFormat.format(new Date());
} else {
topicName = topicNodeName + " (" + labelProp.toString() + ")";
}
if (fileFolderService.searchSimple(targetForumNodeRef, topicName) != null) {
// A topic with that name already exists
continue;
}
fileFolderService.copy(topicNodeRef, targetForumNodeRef, topicName);
copied++;
} catch (FileExistsException e) {
// We checked for this, so this is a concurrency condition
throw new ConcurrencyFailureException("Target topic exists: " + e.getMessage(), e);
} catch (FileNotFoundException e) {
// The node was there, but now it's gone
throw new ConcurrencyFailureException("Forum was deleted: " + e.getMessage(), e);
}
}
}
public void testMultipleCheckoutsCheckInsWithPropChange() {
// Note: this test assumes cm:autoVersionProps=true by default (refer to cm:versionableAspect in
// contentModel.xml)
// Create a new node
ChildAssociationRef childAssocRef =
nodeService.createNode(
rootNodeRef,
ContentModel.ASSOC_CHILDREN,
QName.createQName("test"),
ContentModel.TYPE_CONTENT,
null);
final NodeRef testNodeRef = childAssocRef.getChildRef();
// Add the version aspect to the created node
nodeService.addAspect(testNodeRef, ContentModel.ASPECT_VERSIONABLE, null);
setComplete();
endTransaction();
// Checkout
final NodeRef workingCopy1 =
transactionService
.getRetryingTransactionHelper()
.doInTransaction(
new RetryingTransactionCallback<NodeRef>() {
public NodeRef execute() throws Exception {
return cociService.checkout(testNodeRef);
}
});
// Change property and checkin
transactionService
.getRetryingTransactionHelper()
.doInTransaction(
new RetryingTransactionCallback<Object>() {
public Object execute() throws Exception {
nodeService.setProperty(workingCopy1, ContentModel.PROP_AUTHOR, "author1");
Map<String, Serializable> versionProperties = new HashMap<String, Serializable>();
versionProperties.put(Version.PROP_DESCRIPTION, "This is a test version 1");
cociService.checkin(workingCopy1, versionProperties);
return null;
}
});
// Checkout
final NodeRef workingCopy2 =
transactionService
.getRetryingTransactionHelper()
.doInTransaction(
new RetryingTransactionCallback<NodeRef>() {
public NodeRef execute() throws Exception {
return cociService.checkout(testNodeRef);
}
});
// Change property and checkin
transactionService
.getRetryingTransactionHelper()
.doInTransaction(
new RetryingTransactionCallback<Object>() {
public Object execute() throws Exception {
nodeService.setProperty(workingCopy2, ContentModel.PROP_AUTHOR, "author2");
Map<String, Serializable> versionProperties = new HashMap<String, Serializable>();
versionProperties.put(Version.PROP_DESCRIPTION, "This is a test version 2");
cociService.checkin(workingCopy2, versionProperties);
return null;
}
});
// Checkout
final NodeRef workingCopy3 =
transactionService
.getRetryingTransactionHelper()
.doInTransaction(
new RetryingTransactionCallback<NodeRef>() {
public NodeRef execute() throws Exception {
return cociService.checkout(testNodeRef);
}
});
// Change property and checkin
transactionService
.getRetryingTransactionHelper()
.doInTransaction(
new RetryingTransactionCallback<Object>() {
public Object execute() throws Exception {
nodeService.setProperty(workingCopy3, ContentModel.PROP_AUTHOR, "author3");
Map<String, Serializable> versionProperties = new HashMap<String, Serializable>();
versionProperties.put(Version.PROP_DESCRIPTION, "This is a test version 3");
cociService.checkin(workingCopy3, versionProperties);
return null;
}
});
}
/** On setup in transaction implementation */
@Override
protected void onSetUpInTransaction() throws Exception {
// Set the services
this.nodeService = (NodeService) this.applicationContext.getBean("nodeService");
this.cociService =
(CheckOutCheckInService) this.applicationContext.getBean("checkOutCheckInService");
this.contentService = (ContentService) this.applicationContext.getBean("contentService");
this.versionService = (VersionService) this.applicationContext.getBean("versionService");
this.authenticationService =
(MutableAuthenticationService) this.applicationContext.getBean("authenticationService");
this.lockService = (LockService) this.applicationContext.getBean("lockService");
this.transactionService =
(TransactionService) this.applicationContext.getBean("transactionComponent");
this.permissionService =
(PermissionService) this.applicationContext.getBean("permissionService");
this.copyService = (CopyService) this.applicationContext.getBean("copyService");
// Authenticate as system to create initial test data set
AuthenticationComponent authenticationComponent =
(AuthenticationComponent) this.applicationContext.getBean("authenticationComponent");
authenticationComponent.setSystemUserAsCurrentUser();
// Create the store and get the root node reference
this.storeRef =
nodeService.createStore(StoreRef.PROTOCOL_WORKSPACE, "Test_" + System.currentTimeMillis());
this.rootNodeRef = nodeService.getRootNode(storeRef);
// Create the node used for tests
ChildAssociationRef childAssocRef =
nodeService.createNode(
rootNodeRef,
ContentModel.ASSOC_CHILDREN,
QName.createQName("test"),
ContentModel.TYPE_CONTENT);
this.nodeRef = childAssocRef.getChildRef();
nodeService.addAspect(this.nodeRef, ContentModel.ASPECT_TITLED, null);
nodeService.setProperty(this.nodeRef, ContentModel.PROP_NAME, TEST_VALUE_NAME);
nodeService.setProperty(this.nodeRef, PROP2_QNAME, TEST_VALUE_2);
// Add the initial content to the node
ContentWriter contentWriter =
this.contentService.getWriter(this.nodeRef, ContentModel.PROP_CONTENT, true);
contentWriter.setMimetype("text/plain");
contentWriter.setEncoding("UTF-8");
contentWriter.putContent(CONTENT_1);
// Add the lock and version aspects to the created node
nodeService.addAspect(this.nodeRef, ContentModel.ASPECT_VERSIONABLE, null);
nodeService.addAspect(this.nodeRef, ContentModel.ASPECT_LOCKABLE, null);
// Create and authenticate the user
this.userName = "******" + GUID.generate();
TestWithUserUtils.createUser(
this.userName, PWD, this.rootNodeRef, this.nodeService, this.authenticationService);
TestWithUserUtils.authenticateUser(
this.userName, PWD, this.rootNodeRef, this.authenticationService);
this.userNodeRef = TestWithUserUtils.getCurrentUser(this.authenticationService);
permissionService.setPermission(
this.rootNodeRef, this.userName, PermissionService.ALL_PERMISSIONS, true);
permissionService.setPermission(
this.nodeRef, this.userName, PermissionService.ALL_PERMISSIONS, true);
folderNodeRef =
nodeService
.createNode(
rootNodeRef,
ContentModel.ASSOC_CHILDREN,
QName.createQName("test"),
ContentModel.TYPE_FOLDER,
Collections.<QName, Serializable>singletonMap(ContentModel.PROP_NAME, "folder"))
.getChildRef();
fileNodeRef =
nodeService
.createNode(
folderNodeRef,
ContentModel.ASSOC_CONTAINS,
QName.createQName("test"),
ContentModel.TYPE_CONTENT,
Collections.<QName, Serializable>singletonMap(ContentModel.PROP_NAME, "file"))
.getChildRef();
contentWriter = this.contentService.getWriter(fileNodeRef, ContentModel.PROP_CONTENT, true);
contentWriter.setMimetype("text/plain");
contentWriter.setEncoding("UTF-8");
contentWriter.putContent(CONTENT_1);
}
private AlfrescoRuntimeException signFile(
final NodeRef nodeRefToSign,
final DigitalSigningDTO signingDTO,
final File alfTempDir,
final String alias,
final KeyStore ks,
final PrivateKey key,
final Certificate[] chain) {
final String fileNameToSign = fileFolderService.getFileInfo(nodeRefToSign).getName();
File fileConverted = null;
File tempDir = null;
try {
ContentReader fileToSignContentReader = getReader(nodeRefToSign);
if (fileToSignContentReader != null) {
String newName = null;
// Check if document is PDF or transform it
if (!MimetypeMap.MIMETYPE_PDF.equals(fileToSignContentReader.getMimetype())) {
// Transform document in PDF document
final ContentTransformer tranformer =
contentTransformerRegistry.getTransformer(
fileToSignContentReader.getMimetype(),
fileToSignContentReader.getSize(),
MimetypeMap.MIMETYPE_PDF,
new TransformationOptions());
if (tranformer != null) {
tempDir = new File(alfTempDir.getPath() + File.separatorChar + nodeRefToSign.getId());
if (tempDir != null) {
tempDir.mkdir();
fileConverted =
new File(tempDir, fileNameToSign + "_" + System.currentTimeMillis() + ".pdf");
if (fileConverted != null) {
final ContentWriter newDoc = new FileContentWriter(fileConverted);
if (newDoc != null) {
newDoc.setMimetype(MimetypeMap.MIMETYPE_PDF);
tranformer.transform(fileToSignContentReader, newDoc);
fileToSignContentReader = new FileContentReader(fileConverted);
final String originalName =
(String) nodeService.getProperty(nodeRefToSign, ContentModel.PROP_NAME);
newName = originalName.substring(0, originalName.lastIndexOf(".")) + ".pdf";
}
}
}
} else {
log.error(
"["
+ fileNameToSign
+ "] No suitable converter found to convert the document in PDF.");
return new AlfrescoRuntimeException(
"["
+ fileNameToSign
+ "] No suitable converter found to convert the document in PDF.");
}
}
// Convert PDF in PDF/A format
final File pdfAFile = convertPdfToPdfA(fileToSignContentReader.getContentInputStream());
final PdfReader reader = new PdfReader(new FileInputStream(pdfAFile));
if (nodeRefToSign != null) {
tempDir = new File(alfTempDir.getPath() + File.separatorChar + nodeRefToSign.getId());
if (tempDir != null) {
tempDir.mkdir();
final File file = new File(tempDir, fileNameToSign);
if (file != null) {
final FileOutputStream fout = new FileOutputStream(file);
final PdfStamper stp = PdfStamper.createSignature(reader, fout, '\0');
if (stp != null) {
final PdfSignatureAppearance sap = stp.getSignatureAppearance();
if (sap != null) {
sap.setCrypto(key, chain, null, PdfSignatureAppearance.WINCER_SIGNED);
sap.setReason(signingDTO.getSignReason());
sap.setLocation(signingDTO.getSignLocation());
sap.setContact(signingDTO.getSignContact());
sap.setCertificationLevel(PdfSignatureAppearance.CERTIFIED_NO_CHANGES_ALLOWED);
sap.setImageScale(1);
// digital signature
if (signingDTO.getSigningField() != null
&& !signingDTO.getSigningField().trim().equalsIgnoreCase("")) {
Image img = null;
if (signingDTO.getImage() != null) {
final ContentReader imageContentReader = getReader(signingDTO.getImage());
final AcroFields af = reader.getAcroFields();
if (af != null) {
final List<FieldPosition> positions =
af.getFieldPositions(signingDTO.getSigningField());
if (positions != null
&& positions.size() > 0
&& positions.get(0) != null
&& positions.get(0).position != null) {
final BufferedImage newImg =
scaleImage(
ImageIO.read(imageContentReader.getContentInputStream()),
BufferedImage.TYPE_INT_RGB,
Float.valueOf(positions.get(0).position.getWidth()).intValue(),
Float.valueOf(positions.get(0).position.getHeight()).intValue());
img = Image.getInstance(newImg, null);
} else {
log.error(
"["
+ fileNameToSign
+ "] The field '"
+ signingDTO.getSigningField()
+ "' doesn't exist in the document.");
return new AlfrescoRuntimeException(
"["
+ fileNameToSign
+ "] The field '"
+ signingDTO.getSigningField()
+ "' doesn't exist in the document.");
}
}
if (img == null) {
img =
Image.getInstance(
ImageIO.read(imageContentReader.getContentInputStream()), null);
}
sap.setImage(img);
}
sap.setVisibleSignature(signingDTO.getSigningField());
} else {
int pageToSign = 1;
if (DigitalSigningDTO.PAGE_LAST.equalsIgnoreCase(
signingDTO.getPages().trim())) {
pageToSign = reader.getNumberOfPages();
} else if (DigitalSigningDTO.PAGE_SPECIFIC.equalsIgnoreCase(
signingDTO.getPages().trim())) {
if (signingDTO.getPageNumber() > 0
&& signingDTO.getPageNumber() <= reader.getNumberOfPages()) {
pageToSign = signingDTO.getPageNumber();
} else {
throw new AlfrescoRuntimeException("Page number is out of bound.");
}
}
if (signingDTO.getImage() != null) {
final ContentReader imageContentReader = getReader(signingDTO.getImage());
// Resize image
final BufferedImage newImg =
scaleImage(
ImageIO.read(imageContentReader.getContentInputStream()),
BufferedImage.TYPE_INT_RGB,
signingDTO.getSignWidth(),
signingDTO.getSignHeight());
final Image img = Image.getInstance(newImg, null);
sap.setImage(img);
}
if (signingDTO.getPosition() != null
&& !DigitalSigningDTO.POSITION_CUSTOM.equalsIgnoreCase(
signingDTO.getPosition().trim())) {
final Rectangle pageRect = reader.getPageSizeWithRotation(1);
sap.setVisibleSignature(
positionSignature(
signingDTO.getPosition(),
pageRect,
signingDTO.getSignWidth(),
signingDTO.getSignHeight(),
signingDTO.getxMargin(),
signingDTO.getyMargin()),
pageToSign,
null);
} else {
sap.setVisibleSignature(
new Rectangle(
signingDTO.getLocationX(),
signingDTO.getLocationY(),
signingDTO.getLocationX() + signingDTO.getSignWidth(),
signingDTO.getLocationY() - signingDTO.getSignHeight()),
pageToSign,
null);
}
}
stp.close();
NodeRef destinationNode = null;
NodeRef originalDoc = null;
boolean addAsNewVersion = false;
if (signingDTO.getDestinationFolder() == null) {
destinationNode = nodeRefToSign;
nodeService.addAspect(destinationNode, ContentModel.ASPECT_VERSIONABLE, null);
addAsNewVersion = true;
} else {
originalDoc = nodeRefToSign;
destinationNode =
createDestinationNode(
file.getName(), signingDTO.getDestinationFolder(), nodeRefToSign);
}
if (destinationNode != null) {
final ContentWriter writer =
contentService.getWriter(destinationNode, ContentModel.PROP_CONTENT, true);
if (writer != null) {
writer.setEncoding(fileToSignContentReader.getEncoding());
writer.setMimetype("application/pdf");
writer.putContent(file);
file.delete();
if (fileConverted != null) {
fileConverted.delete();
}
nodeService.addAspect(
destinationNode,
SigningModel.ASPECT_SIGNED,
new HashMap<QName, Serializable>());
nodeService.setProperty(
destinationNode, SigningModel.PROP_REASON, signingDTO.getSignReason());
nodeService.setProperty(
destinationNode,
SigningModel.PROP_LOCATION,
signingDTO.getSignLocation());
nodeService.setProperty(
destinationNode, SigningModel.PROP_SIGNATUREDATE, new java.util.Date());
nodeService.setProperty(
destinationNode,
SigningModel.PROP_SIGNEDBY,
AuthenticationUtil.getRunAsUser());
if (newName != null) {
nodeService.setProperty(destinationNode, ContentModel.PROP_NAME, newName);
}
final X509Certificate c = (X509Certificate) ks.getCertificate(alias);
nodeService.setProperty(
destinationNode, SigningModel.PROP_VALIDITY, c.getNotAfter());
nodeService.setProperty(
destinationNode, SigningModel.PROP_ORIGINAL_DOC, originalDoc);
if (!addAsNewVersion) {
if (!nodeService.hasAspect(originalDoc, SigningModel.ASPECT_ORIGINAL_DOC)) {
nodeService.addAspect(
originalDoc,
SigningModel.ASPECT_ORIGINAL_DOC,
new HashMap<QName, Serializable>());
}
nodeService.createAssociation(
originalDoc, destinationNode, SigningModel.PROP_RELATED_DOC);
}
}
} else {
log.error("[" + fileNameToSign + "] Destination node is not a valid NodeRef.");
return new AlfrescoRuntimeException(
"[" + fileNameToSign + "] Destination node is not a valid NodeRef.");
}
} else {
log.error("[" + fileNameToSign + "] Unable to get PDF appearance signature.");
return new AlfrescoRuntimeException(
"[" + fileNameToSign + "] Unable to get PDF appearance signature.");
}
} else {
log.error("[" + fileNameToSign + "] Unable to create PDF signature.");
return new AlfrescoRuntimeException(
"[" + fileNameToSign + "] Unable to create PDF signature.");
}
}
}
} else {
log.error("[" + fileNameToSign + "] Unable to get document to sign content.");
return new AlfrescoRuntimeException(
"[" + fileNameToSign + "] Unable to get document to sign content.");
}
if (pdfAFile != null) {
pdfAFile.delete();
}
return null;
} else {
log.error("[" + fileNameToSign + "] The document has no content.");
return new AlfrescoRuntimeException(
"[" + fileNameToSign + "] The document has no content.");
}
} catch (KeyStoreException e) {
log.error("[" + fileNameToSign + "] " + e);
return new AlfrescoRuntimeException("[" + fileNameToSign + "] " + e.getMessage(), e);
} catch (ContentIOException e) {
log.error("[" + fileNameToSign + "] " + e);
return new AlfrescoRuntimeException("[" + fileNameToSign + "] " + e.getMessage(), e);
} catch (IOException e) {
log.error("[" + fileNameToSign + "] " + e);
return new AlfrescoRuntimeException("[" + fileNameToSign + "] " + e.getMessage(), e);
} catch (DocumentException e) {
log.error("[" + fileNameToSign + "] " + e);
return new AlfrescoRuntimeException("[" + fileNameToSign + "] " + e.getMessage(), e);
} finally {
if (tempDir != null) {
try {
tempDir.delete();
} catch (Exception ex) {
log.error("[" + fileNameToSign + "] " + ex);
return new AlfrescoRuntimeException("[" + fileNameToSign + "] " + ex.getMessage(), ex);
}
}
}
}
