/**
* @param ref The node representing the current document ref
* @return Model map for email templates
*/
@SuppressWarnings("unchecked")
private Map<String, Object> createEmailTemplateModel(NodeRef ref, Action ruleAction) {
Map<String, Object> model = new HashMap<String, Object>();
NodeRef person = personService.getPerson(authService.getCurrentUserName());
model.put("person", new TemplateNode(person, serviceRegistry, null));
model.put("document", new TemplateNode(ref, serviceRegistry, null));
NodeRef parent = serviceRegistry.getNodeService().getPrimaryParent(ref).getParentRef();
model.put("space", new TemplateNode(parent, serviceRegistry, null));
// current date/time is useful to have and isn't supplied by FreeMarker
// by default
model.put("date", new Date());
// add custom method objects
model.put("hasAspect", new HasAspectMethod());
model.put("message", new I18NMessageMethod());
model.put("dateCompare", new DateCompareMethod());
model.put("url", new URLHelper(repoRemoteUrl));
Map<String, Object> additionalParams =
(Map<String, Object>) ruleAction.getParameterValue(PARAM_ADDITIONAL_INFO);
if (additionalParams != null) {
model.putAll(additionalParams);
}
return model;
}
/**
* Sends an invitation email.
*
* @param properties A Map containing the properties needed to send the email.
*/
public void sendMail(Map<String, String> properties) {
checkProperties(properties);
ParameterCheck.mandatory("Properties", properties);
NodeRef inviter = personService.getPerson(properties.get(wfVarInviterUserName));
String inviteeName = properties.get(wfVarInviteeUserName);
NodeRef invitee = personService.getPerson(inviteeName);
Action mail = actionService.createAction(MailActionExecuter.NAME);
mail.setParameterValue(MailActionExecuter.PARAM_FROM, getEmail(inviter));
mail.setParameterValue(MailActionExecuter.PARAM_TO, getEmail(invitee));
mail.setParameterValue(MailActionExecuter.PARAM_SUBJECT, buildSubject(properties));
mail.setParameterValue(MailActionExecuter.PARAM_TEMPLATE, getEmailTemplateNodeRef());
mail.setParameterValue(
MailActionExecuter.PARAM_TEMPLATE_MODEL,
(Serializable) buildMailTextModel(properties, inviter, invitee));
mail.setParameterValue(MailActionExecuter.PARAM_IGNORE_SEND_FAILURE, true);
actionService.executeAction(mail, getWorkflowPackage(properties));
}
@Override
protected String applyInternal() throws Exception {
String guestId = AuthenticationUtil.getGuestUserName();
if (personService.personExists(guestId)) {
NodeRef personRef = personService.getPerson(guestId);
permissionService.setInheritParentPermissions(personRef, true);
}
return I18NUtil.getMessage(MSG_SUCCESS);
}
private NodeRef createPerson(String userName) {
// if user with given user name doesn't already exist then create user
if (this.authenticationService.authenticationExists(userName) == false) {
// create user
this.authenticationService.createAuthentication(userName, "password".toCharArray());
}
// if person node with given user name doesn't already exist then create
// person
if (this.personService.personExists(userName) == false) {
// create person properties
PropertyMap personProps = new PropertyMap();
personProps.put(ContentModel.PROP_USERNAME, userName);
// create person node for user
return personService.createPerson(personProps);
}
return personService.getPerson(userName);
}
/**
* Send an email message
*
* @throws AlfrescoRuntimeExeption
*/
@SuppressWarnings("unchecked")
@Override
protected void executeImpl(final Action ruleAction, final NodeRef actionedUponNodeRef) {
try {
MimeMessage message = javaMailSender.createMimeMessage();
// use the true flag to indicate you need a multipart message
MimeMessageHelper helper = new MimeMessageHelper(message, true);
// set recipient
String to = (String) ruleAction.getParameterValue(PARAM_TO);
if (to != null && to.length() != 0) {
helper.setTo(to);
} else {
// see if multiple recipients have been supplied - as a list of
// authorities
Serializable toManyMails = ruleAction.getParameterValue(PARAM_TO_MANY);
List<String> recipients = new ArrayList<String>();
if (toManyMails instanceof List) {
for (String mailAdress : (List<String>) toManyMails) {
if (validateAddress(mailAdress)) {
recipients.add(mailAdress);
}
}
} else if (toManyMails instanceof String) {
if (validateAddress((String) toManyMails)) {
recipients.add((String) toManyMails);
}
}
if (recipients != null && recipients.size() > 0) {
helper.setTo(recipients.toArray(new String[recipients.size()]));
} else {
// No recipients have been specified
logger.error("No recipient has been specified for the mail action");
}
}
// set subject line
helper.setSubject((String) ruleAction.getParameterValue(PARAM_SUBJECT));
// See if an email template has been specified
String text = null;
NodeRef templateRef = (NodeRef) ruleAction.getParameterValue(PARAM_TEMPLATE);
if (templateRef != null) {
// build the email template model
Map<String, Object> model = createEmailTemplateModel(actionedUponNodeRef, ruleAction);
// process the template against the model
text = templateService.processTemplate("freemarker", templateRef.toString(), model);
}
// set the text body of the message
if (text == null) {
text = (String) ruleAction.getParameterValue(PARAM_TEXT);
}
// adding the boolean true to send as HTML
helper.setText(text, true);
FileFolderService fileFolderService = serviceRegistry.getFileFolderService();
/* add inline images.
* "action.parameters.images is a ,-delimited string, containing a map of images and resources, from this example:
message.setText("my text <img src='cid:myLogo'>", true);
message.addInline("myLogo", new ClassPathResource("img/mylogo.gif"));
so the "images" param can look like this: headerLogo|images/headerLogoNodeRef,footerLogo|footerLogoNodeRef
*/
String imageList = (String) ruleAction.getParameterValue(PARAM_IMAGES);
System.out.println(imageList);
String[] imageMap = imageList.split(","); // comma no spaces
Map<String, String> images = new HashMap<String, String>();
for (String image : imageMap) {
System.out.println(image);
String map[] = image.split("\\|");
for (String key : map) {
System.out.println(key);
}
System.out.println(map.length);
images.put(map[0].trim(), map[1].trim());
System.out.println(images.size());
System.out.println("-" + map[0] + " " + map[1] + "-");
}
NodeRef imagesFolderNodeRef = (NodeRef) ruleAction.getParameterValue(PARAM_IMAGES_FOLDER);
if (null != imagesFolderNodeRef) {
ContentService contentService = serviceRegistry.getContentService();
System.out.println("mapping");
for (Map.Entry<String, String> entry : images.entrySet()) {
System.out.println(
entry.getKey()
+ " "
+ entry.getValue()
+ " "
+ ruleAction.getParameterValue(PARAM_IMAGES_FOLDER));
NodeRef imageFile = fileFolderService.searchSimple(imagesFolderNodeRef, entry.getValue());
if (null != imageFile) {
ContentReader reader = contentService.getReader(imageFile, ContentModel.PROP_CONTENT);
ByteArrayResource resource =
new ByteArrayResource(IOUtils.toByteArray(reader.getContentInputStream()));
helper.addInline(entry.getKey(), resource, reader.getMimetype());
} else {
logger.error("No image for " + entry.getKey());
}
}
} else {
logger.error("No images folder");
}
// set the from address
NodeRef person = personService.getPerson(authService.getCurrentUserName());
String fromActualUser = null;
if (person != null) {
fromActualUser = (String) nodeService.getProperty(person, ContentModel.PROP_EMAIL);
}
if (fromActualUser != null && fromActualUser.length() != 0) {
helper.setFrom(fromActualUser);
} else {
String from = (String) ruleAction.getParameterValue(PARAM_FROM);
if (from == null || from.length() == 0) {
helper.setFrom(fromAddress);
} else {
helper.setFrom(from);
}
}
NodeRef attachmentsFolder = (NodeRef) ruleAction.getParameterValue(PARAM_ATTCHMENTS_FOLDER);
if (attachmentsFolder != null) {
List<FileInfo> attachFiles = fileFolderService.listFiles(attachmentsFolder);
if (attachFiles != null && attachFiles.size() > 0) {
for (FileInfo attachFile : attachFiles) {
ContentReader contentReader = fileFolderService.getReader(attachFile.getNodeRef());
ByteArrayResource resource =
new ByteArrayResource(IOUtils.toByteArray(contentReader.getContentInputStream()));
helper.addAttachment(attachFile.getName(), resource, contentReader.getMimetype());
}
}
}
// Send the message unless we are in "testMode"
javaMailSender.send(message);
} catch (Exception e) {
String toUser = (String) ruleAction.getParameterValue(PARAM_TO);
if (toUser == null) {
Object obj = ruleAction.getParameterValue(PARAM_TO_MANY);
if (obj != null) {
toUser = obj.toString();
}
}
logger.error("Failed to send email to " + toUser, e);
throw new AlfrescoRuntimeException("Failed to send email to:" + toUser, e);
}
}
@Override
public void setUp() throws Exception {
ServiceRegistry serviceRegistry = (ServiceRegistry) ctx.getBean("ServiceRegistry");
authenticationService = serviceRegistry.getAuthenticationService();
imapService = serviceRegistry.getImapService();
importerService = serviceRegistry.getImporterService();
NodeService nodeService = serviceRegistry.getNodeService();
SearchService searchService = serviceRegistry.getSearchService();
NamespaceService namespaceService = serviceRegistry.getNamespaceService();
PersonService personService = serviceRegistry.getPersonService();
FileFolderService fileFolderService = serviceRegistry.getFileFolderService();
TransactionService transactionService = serviceRegistry.getTransactionService();
PermissionService permissionService = serviceRegistry.getPermissionService();
// start the transaction
UserTransaction txn = transactionService.getUserTransaction();
txn.begin();
authenticationService.authenticate(USER_NAME, USER_PASSWORD.toCharArray());
anotherUserName = "******";
NodeRef person = personService.getPerson(anotherUserName);
if (person != null) {
personService.deletePerson(anotherUserName);
PropertyMap testUser = new PropertyMap();
testUser.put(ContentModel.PROP_USERNAME, anotherUserName);
testUser.put(ContentModel.PROP_FIRSTNAME, anotherUserName);
testUser.put(ContentModel.PROP_LASTNAME, anotherUserName);
testUser.put(ContentModel.PROP_EMAIL, anotherUserName + "@alfresco.com");
testUser.put(ContentModel.PROP_JOBTITLE, "jobTitle");
personService.createPerson(testUser);
}
if (authenticationService.authenticationExists(anotherUserName)) {
authenticationService.deleteAuthentication(anotherUserName);
}
authenticationService.createAuthentication(anotherUserName, anotherUserName.toCharArray());
user =
new AlfrescoImapUser(anotherUserName + "@alfresco.com", anotherUserName, anotherUserName);
String storePath = "workspace://SpacesStore";
String companyHomePathInStore = "/app:company_home";
StoreRef storeRef = new StoreRef(storePath);
NodeRef storeRootNodeRef = nodeService.getRootNode(storeRef);
List<NodeRef> nodeRefs =
searchService.selectNodes(
storeRootNodeRef, companyHomePathInStore, null, namespaceService, false);
NodeRef companyHomeNodeRef = nodeRefs.get(0);
ChildApplicationContextFactory imap = (ChildApplicationContextFactory) ctx.getBean("imap");
ApplicationContext imapCtx = imap.getApplicationContext();
ImapServiceImpl imapServiceImpl = (ImapServiceImpl) imapCtx.getBean("imapService");
// Delete test folder
nodeRefs =
searchService.selectNodes(
storeRootNodeRef,
companyHomePathInStore
+ "/"
+ NamespaceService.CONTENT_MODEL_PREFIX
+ ":"
+ TEST_IMAP_ROOT_FOLDER_NAME,
null,
namespaceService,
false);
if (nodeRefs.size() == 1) {
NodeRef ch = nodeRefs.get(0);
nodeService.deleteNode(ch);
}
// Creating IMAP test folder for IMAP root
LinkedList<String> folders = new LinkedList<String>();
folders.add(TEST_IMAP_ROOT_FOLDER_NAME);
FileFolderServiceImpl.makeFolders(
fileFolderService, companyHomeNodeRef, folders, ContentModel.TYPE_FOLDER);
// Setting IMAP root
RepositoryFolderConfigBean imapHome = new RepositoryFolderConfigBean();
imapHome.setStore(storePath);
imapHome.setRootPath(companyHomePathInStore);
imapHome.setFolderPath(TEST_IMAP_ROOT_FOLDER_NAME);
imapServiceImpl.setImapHome(imapHome);
// Starting IMAP
imapServiceImpl.startupInTxn(true);
nodeRefs =
searchService.selectNodes(
storeRootNodeRef,
companyHomePathInStore
+ "/"
+ NamespaceService.CONTENT_MODEL_PREFIX
+ ":"
+ TEST_IMAP_ROOT_FOLDER_NAME,
null,
namespaceService,
false);
// Used to create User's folder
NodeRef userFolderRef = imapService.getUserImapHomeRef(anotherUserName);
permissionService.setPermission(
userFolderRef, anotherUserName, PermissionService.ALL_PERMISSIONS, true);
importTestData("imap/load_test_data.acp", userFolderRef);
reauthenticate(anotherUserName, anotherUserName);
AlfrescoImapFolder testDataFolder =
imapService.getOrCreateMailbox(user, TEST_DATA_FOLDER_NAME, true, false);
SimpleStoredMessage m = testDataFolder.getMessages().get(0);
m = testDataFolder.getMessage(m.getUid());
AlfrescoImapFolder folder = imapService.getOrCreateMailbox(user, TEST_FOLDER_NAME, false, true);
logger.info("Creating folders...");
long t = System.currentTimeMillis();
try {
for (int i = 0; i < MESSAGE_QUANTITY; i++) {
System.out.println("i = " + i);
folder.appendMessage(m.getMimeMessage(), new Flags(), new Date());
}
} catch (Exception e) {
logger.error(e, e);
}
t = System.currentTimeMillis() - t;
logger.info("Create time: " + t + " ms (" + t / 1000 + " s (" + t / 60000 + " min))");
txn.commit();
}
@Override
public PagingResults<PersonFavourite> getPagedFavourites(
String userName,
Set<Type> types,
List<Pair<FavouritesService.SortFields, Boolean>> sortProps,
PagingRequest pagingRequest) {
// Get the user node reference
final NodeRef personNodeRef = personService.getPerson(userName);
if (personNodeRef == null) {
throw new AlfrescoRuntimeException(
"Can not get preferences for " + userName + " because he/she does not exist.");
}
boolean includeFiles = types.contains(Type.FILE);
boolean includeFolders = types.contains(Type.FOLDER);
boolean includeSites = types.contains(Type.SITE);
String currentUserName = AuthenticationUtil.getFullyAuthenticatedUser();
if (authenticationContext.isSystemUserName(currentUserName) == true
|| permissionService.hasPermission(personNodeRef, PermissionService.WRITE)
== AccessStatus.ALLOWED
|| userName.equals(currentUserName) == true) {
// we may have more than one favourite that is considered the same w.r.t. the PersonFavourite
// comparator
final Map<PersonFavouriteKey, PersonFavourite> sortedFavouriteNodes =
new TreeMap<PersonFavouriteKey, PersonFavourite>(getComparator(sortProps));
PrefKeys sitePrefKeys = getPrefKeys(Type.SITE);
PrefKeys documentsPrefKeys = getPrefKeys(Type.FILE);
PrefKeys foldersPrefKeys = getPrefKeys(Type.FOLDER);
Map<String, Serializable> preferences = preferenceService.getPreferences(userName);
for (String key : preferences.keySet()) {
if (includeFiles && key.startsWith(documentsPrefKeys.sharePrefKey)) {
String nodes = (String) preferences.get(key);
if (nodes != null) {
sortedFavouriteNodes.putAll(extractFavouriteNodes(userName, Type.FILE, nodes));
}
} else if (includeFolders && key.startsWith(foldersPrefKeys.sharePrefKey)) {
String nodes = (String) preferences.get(key);
if (nodes != null) {
sortedFavouriteNodes.putAll(extractFavouriteNodes(userName, Type.FOLDER, nodes));
}
} else if (includeSites
&& key.startsWith(sitePrefKeys.getSharePrefKey())
&& !key.endsWith(".createdAt")) {
// key is either of the form org.alfresco.share.sites.favourites.<siteId>.favourited or
// org.alfresco.share.sites.favourites.<siteId>
extractFavouriteSite(userName, Type.SITE, sortedFavouriteNodes, preferences, key);
}
}
int totalSize = sortedFavouriteNodes.size();
final PageDetails pageDetails = PageDetails.getPageDetails(pagingRequest, totalSize);
final List<PersonFavourite> page = new ArrayList<PersonFavourite>(pageDetails.getPageSize());
Iterator<PersonFavourite> it = sortedFavouriteNodes.values().iterator();
for (int counter = 0; counter < pageDetails.getEnd() && it.hasNext(); counter++) {
PersonFavourite favouriteNode = it.next();
if (counter < pageDetails.getSkipCount()) {
continue;
}
if (counter > pageDetails.getEnd() - 1) {
break;
}
page.add(favouriteNode);
}
return new PagingResults<PersonFavourite>() {
@Override
public List<PersonFavourite> getPage() {
return page;
}
@Override
public boolean hasMoreItems() {
return pageDetails.hasMoreItems();
}
@Override
public Pair<Integer, Integer> getTotalResultCount() {
Integer total = Integer.valueOf(sortedFavouriteNodes.size());
return new Pair<Integer, Integer>(total, total);
}
@Override
public String getQueryExecutionId() {
return null;
}
};
} else {
// The current user does not have sufficient permissions to update the preferences for this
// user
throw new AccessDeniedException(
"The current user "
+ currentUserName
+ " does not have sufficient permissions to get the favourites of the user "
+ userName);
}
}
public List<TopItem> listTopItems(int count, String type, int date, SiteInfo site) {
ActivityScoreQuery activityScoreQuery = new ActivityScoreQuery();
TopQuery topQuery = activityScoreQuery;
// Site
topQuery.setSite(site.getShortName());
// Date
DateMidnight dm = new DateMidnight();
dm = dm.minusDays(date);
topQuery.setDate(dm.toDate());
// Criteria
Map<String, TopCriterion> activityCriterionMap = typeActivityCriteriaMap.get(type);
if (activityCriterionMap == null) {
throw new IllegalArgumentException("Unknown top type '" + type + "'");
}
List<TopCriterion> criteria = new ArrayList<TopCriterion>(activityCriterionMap.values());
topQuery.setCriteria(criteria);
List<UserScore> topResults = topActivityDAO.executeTopQuery(topQuery);
int topSize = Math.min(topResults.size(), count);
List<TopItem> topItems = new ArrayList<TopItem>(topSize);
if (topSize > 0) {
Map<String, TopItem> topItemsMap = new HashMap<String, TopItem>(topSize);
List<String> userIds = new ArrayList<String>(topSize);
int position = 1;
for (UserScore topUser : topResults) {
String userName = topUser.getUserId();
NodeRef node = personService.getPerson(userName);
int score = topUser.getScore();
TopItem topItem = new TopItem(position, score, node);
topItems.add(topItem);
topItemsMap.put(userName, topItem);
userIds.add(userName);
position++;
if (position > count) {
break;
}
}
activityScoreQuery.setUserIds(userIds);
List<UserActivityScore> activityScoreResults =
topActivityDAO.executeActivityScoreQuery(activityScoreQuery);
for (UserActivityScore userActivityScore : activityScoreResults) {
String activity = userActivityScore.getActivity();
TopCriterion criterion = activityCriterionMap.get(activity);
userActivityScore.setCriterion(criterion);
String userName = userActivityScore.getUserId();
TopItem topItem = topItemsMap.get(userName);
Score score = topItem.getScore();
score.getCriterionScores().add(userActivityScore);
}
}
if (logger.isDebugEnabled()) {
XStream xstream = new XStream();
logger.debug("listTopItems()=" + xstream.toXML(topItems));
}
return topItems;
}