/** * Connect to the mail server and delete all mails. */ public void deleteMails() throws MessagingException { Folder folder = getStore().getFolder(MAIL_INBOX); folder.open(Folder.READ_WRITE); // Get folder's list of messages. Message[] messages = folder.getMessages(); // Retrieve message headers for each message in folder. FetchProfile profile = new FetchProfile(); profile.add(FetchProfile.Item.ENVELOPE); folder.fetch(messages, profile); for (Message message : messages) { message.setFlag(Flags.Flag.DELETED, true); } folder.close(true); }
/** * Creates the EML message in the specified folder. * * @param folderFileInfo The folder to create message in. * @param message The original MimeMessage. * @return ID of the new message created * @throws FileNotFoundException * @throws FileExistsException * @throws MessagingException * @throws IOException */ private long createMimeMessageInFolder( FileInfo folderFileInfo, MimeMessage message, Flags flags) throws FileExistsException, FileNotFoundException, IOException, MessagingException { String name = AlfrescoImapConst.MESSAGE_PREFIX + GUID.generate(); FileFolderService fileFolderService = serviceRegistry.getFileFolderService(); FileInfo messageFile = fileFolderService.create(folderFileInfo.getNodeRef(), name, ContentModel.TYPE_CONTENT); final long newMessageUid = (Long) messageFile.getProperties().get(ContentModel.PROP_NODE_DBID); name = AlfrescoImapConst.MESSAGE_PREFIX + newMessageUid + AlfrescoImapConst.EML_EXTENSION; fileFolderService.rename(messageFile.getNodeRef(), name); Flags newFlags = new Flags(flags); newFlags.add(Flag.RECENT); imapService.setFlags(messageFile, newFlags, true); if (extractAttachmentsEnabled) { imapService.extractAttachments(messageFile.getNodeRef(), message); } // Force persistence of the message to the repository new IncomingImapMessage(messageFile, serviceRegistry, message); return newMessageUid; }
@Override public void onRestoreNode(final ChildAssociationRef childAssocRef) { doAsSystem(new RunAsWork<Void>() { @Override public Void doWork() throws Exception { NodeRef childNodeRef = childAssocRef.getChildRef(); if (serviceRegistry.getDictionaryService().isSubClass(nodeService.getType(childNodeRef), ContentModel.TYPE_CONTENT)) { setFlag(childNodeRef, Flags.Flag.DELETED, false); setFlag(childNodeRef, Flags.Flag.SEEN, false); } NodeRef folderRef = childAssocRef.getParentRef(); long newId = (Long) nodeService.getProperty(childNodeRef, ContentModel.PROP_NODE_DBID); if (nodeService.hasAspect(folderRef, ImapModel.ASPECT_IMAP_FOLDER)) { // Force generation of a new change token and updating the UIDVALIDITY getUidValidityTransactionListener(folderRef).recordNewUid(newId); } return null; } }); }
protected void deleteMailsFromUserMailbox(final Properties props, final String folderName, final int start, final int deleteCount, final String user, final String password) throws MessagingException { final Store store = Session.getInstance(props).getStore(); store.connect(user, password); checkStoreForTestConnection(store); final Folder f = store.getFolder(folderName); f.open(Folder.READ_WRITE); final int msgCount = f.getMessageCount(); final Message[] m = deleteCount == -1 ? f.getMessages() : f.getMessages(start, Math.min(msgCount, deleteCount + start - 1)); int d = 0; for (final Message message : m) { message.setFlag(Flag.DELETED, true); logger.info("Delete msgnum: {} with sid {}", message.getMessageNumber(), message.getSubject()); d++; } f.close(true); logger.info("Deleted " + d + " messages"); store.close(); }
public void changeMailStatus(int mailId, Flag flag, MailCredentials credentials) throws MessagingException { Properties properties = getServerProperties(credentials.getProtocol(), credentials.getHost(), "" + credentials.getPort()); Session session = Session.getDefaultInstance(properties); // connects to the message store Store store = session.getStore(credentials.getProtocol()); store.connect(credentials.getUsername(), credentials.getPassword()); // opens the inbox folder Folder folderInbox = store.getFolder("INBOX"); folderInbox.open(Folder.READ_WRITE); logger.debug("unread:" + folderInbox.getUnreadMessageCount() + ", new:" + folderInbox.getNewMessageCount()); // fetches new messages from server int msgnum[] = new int[] { mailId }; Message[] messages = folderInbox.getMessages(msgnum); if (messages.length == 1 && messages[0] != null) { messages[0].setFlag(flag, true); } folderInbox.close(false); store.close(); }
public void expungeMessage(FileInfo fileInfo) { Flags flags = getFlags(fileInfo); if (flags.contains(Flags.Flag.DELETED)) { // See MNT-12259 //fileFolderService.delete(fileInfo.getNodeRef()); hideAndDelete(fileInfo.getNodeRef()); messageCache.remove(fileInfo.getNodeRef()); } }
/** * Set flags to the specified imapFolder. * * @param messageInfo FileInfo of imap Folder. * @param flags flags to set. * @param value value to set. */ public void setFlags(FileInfo messageInfo, Flags flags, boolean value) { checkForFlaggableAspect(messageInfo.getNodeRef()); for (Flags.Flag flag : flags.getSystemFlags()) { setFlag(messageInfo, flag, value); } }
/** * Moves the node <code>sourceNodeRef</code> extracted from the message id. * A part of a complex move operation. * * @param folderInfo FileInfo * @param message MimeMessage * @param flags Flags * @param sourceNodeRef NodeRef * @return UUID of the moved node * @throws FileExistsException * @throws FileNotFoundException */ @SuppressWarnings("deprecation") private long copyOrMoveNode(FileInfo folderInfo, MimeMessage message, Flags flags, NodeRef sourceNodeRef, boolean move) throws FileExistsException, FileNotFoundException { FileFolderService fileFolderService = serviceRegistry.getFileFolderService(); FileFilterMode.setClient(FileFilterMode.Client.imap); FileInfo messageFile = null; if (move) { fileFolderService.setHidden(sourceNodeRef, false); messageFile = fileFolderService.move(sourceNodeRef, folderInfo.getNodeRef(), null); } else { NodeRef newNodeRef = serviceRegistry.getCopyService().copyAndRename(sourceNodeRef, folderInfo.getNodeRef(), ContentModel.ASSOC_CONTAINS, null, false); fileFolderService.setHidden(newNodeRef, false); messageFile = fileFolderService.getFileInfo(newNodeRef); } final long newMessageUid = (Long) messageFile.getProperties().get(ContentModel.PROP_NODE_DBID); imapService.persistMessageHeaders(messageFile.getNodeRef(), message); Flags newFlags = new Flags(flags); newFlags.add(Flag.RECENT); imapService.setFlags(messageFile, newFlags, true); imapService.setFlag(messageFile, Flag.DELETED, false); return newMessageUid; }
/** * Marks all messages in the folder as deleted using {@link javax.mail.Flags.Flag#DELETED} flag. */ @Override public void deleteAllMessagesInternal() throws FolderException { if (isReadOnly()) { throw new FolderException("Can't delete all - Permission denied"); } for (Map.Entry<Long, FileInfo> entry : searchMails().entrySet()) { imapService.setFlag(entry.getValue(), Flags.Flag.DELETED, true); // comment out to physically remove content. // fileFolderService.delete(fileInfo.getNodeRef()); } }
/** * Returns the list of messages that have no {@link javax.mail.Flags.Flag#DELETED} flag set for current user. * * @return the list of non-deleted messages. */ @Override protected List<SimpleStoredMessage> getNonDeletedMessagesInternal() { if (logger.isDebugEnabled()) { logger.debug("[getNonDeletedMessagesInternal] " + this); } List<SimpleStoredMessage> result = new ArrayList<SimpleStoredMessage>(); Collection<SimpleStoredMessage> values = getMessagesInternal(); for (SimpleStoredMessage message : values) { if (!getFlags(message).contains(Flags.Flag.DELETED)) { result.add(message); } } if (logger.isDebugEnabled() && folderInfo != null) { logger.debug(folderInfo.getName() + " - Non deleted messages count:" + result.size()); } return result; }
/** * Returns count of messages with {@link javax.mail.Flags.Flag#RECENT} flag. * If {@code reset} parameter is {@code true} - removes {@link javax.mail.Flags.Flag#RECENT} flag from * the message for current user. * * @param reset - if true the {@link javax.mail.Flags.Flag#RECENT} will be deleted for current user if exists. * @return returns count of recent messages. */ @Override public int getRecentCount(boolean reset) { int recent = getFolderStatus().recentCount; if (reset && recent > 0) { CommandCallback<Void> command = new CommandCallback<Void>() { public Void command() throws Throwable { for (FileInfo fileInfo : folderStatus.search.values()) { Flags flags = imapService.getFlags(fileInfo); if (flags.contains(Flags.Flag.RECENT)) { imapService.setFlag(fileInfo, Flags.Flag.RECENT, false); } } return null; } }; try { command.run(); } catch (AccessDeniedException ade) { if (logger.isDebugEnabled()) { logger.debug("Access denied to reset RECENT FLAG"); } } } return recent; }
@Test public void deleteMailById() throws MessagingException { MimeMessage[] mails = greenMail.getReceivedMessages(); String messageId = mails[0].getMessageID(); MailConnectors.deleteMails() .createRequest() .folder("INBOX") .messageIds(messageId) .execute(); mails = greenMail.getReceivedMessages(); assertThat(mails).hasSize(2); assertThat(mails[0].isSet(Flag.DELETED)).isTrue(); assertThat(mails[1].isSet(Flag.DELETED)).isFalse(); }
@Test public void folderFromConfiguration() throws MessagingException { MailConnectors.deleteMails() .createRequest() .messageNumbers(1) .execute(); MimeMessage[] mails = greenMail.getReceivedMessages(); assertThat(mails).hasSize(2); assertThat(mails[0].isSet(Flag.DELETED)).isTrue(); assertThat(mails[1].isSet(Flag.DELETED)).isFalse(); }
private boolean verifyMail(final String sender, final String subject) { LOG.info("Waiting for notification to be sent..."); try { Thread.sleep(10000); } catch (InterruptedException e) { } boolean found = false; try { Session session = Session.getDefaultInstance( System.getProperties()); Store store = session.getStore("pop3"); store.connect(pop3Host, mailAddress, mailPassword); Folder inbox = store.getFolder("INBOX"); assertNotNull(inbox); inbox.open(Folder.READ_WRITE); Message[] messages = inbox.getMessages(); for (int i = 0; i < messages.length; i++) { if (sender.equals(messages[i].getFrom()[0].toString()) && subject.equals(messages[i].getSubject())) { found = true; messages[i].setFlag(Flag.DELETED, true); } } inbox.close(true); store.close(); } catch (Throwable t) { LOG.error("Unexpected exception", t); fail("Unexpected exception while fetching e-mail"); } return found; }
private void markMessageRead(List<EwsMessage> messagesRead) throws MessagingException, Exception, ServiceResponseException { if (messagesRead == null || messagesRead.isEmpty()) return; for (EwsMessage aMessage : messagesRead) { EmailMessage aRawMessage = aMessage.getEmailMessage(); if (aMessage.getFlags().contains(Flag.SEEN)) { aRawMessage.setIsRead(Boolean.TRUE); } else { aRawMessage.setIsRead(Boolean.FALSE); } aRawMessage.update(CONFLICT_RESOLUTION_MODE); } }
private Message[] deleteMessages(List<EwsMessage> messagesToDelete) throws MessagingException { if (messagesToDelete == null || messagesToDelete.isEmpty()) return new Message[] {}; List<EwsMessage> lDeletedMessages = new ArrayList<EwsMessage>(); for (int i = messagesToDelete.size() - 1; i >= 0; i--) { EwsMessage aMessage = messagesToDelete.get(i); if (aMessage.getFlags().contains(Flag.DELETED)) { try { EmailMessage aRawMessage = aMessage.getEmailMessage(); aRawMessage.delete(DELETE_MODE); } catch (Exception e) { throw new MessagingException(e.getMessage(), e); } lDeletedMessages.add(aMessage); messagesToDelete.remove(i); } } Message[] retValue = lDeletedMessages.toArray(new Message[0]); if (retValue.length > 0) { notifyMessageRemovedListeners(true, retValue); } return retValue; }
@Override public void treatMessage(Message message) throws Exception { String sender = InternetAddress.toString(message.getFrom()); String subject = message.getSubject(); if (sender.contains("leboncoin.fr") && subject.contains("Activez votre annonce")) { Logger.traceINFO("Found confirmation mail - " + subject); String url = extractConfirmationUrl(message.getContent().toString()); Logger.traceINFO("Sending confirmation : " + url); HtmlPage confirmationPage = Client.get().getPage(url); String confirmationStr = confirmationPage.asXml(); if (confirmationStr.contains("Vous nous avez d�j� envoy� une confirmation")) { Logger.traceERROR("Mail already confirmed. This is a huge error."); } Logger.traceINFO("Confirmation sent for mail - " + subject); message.setFlag(Flag.SEEN, true); } }
public synchronized Message[] expunge() throws MessagingException { checkExists(); final List<Message> expunged = new ArrayList<Message>(); for (final Message msg : getByFlags(new Flags(Flag.DELETED), true)) { expunged.add(messages.remove(((MockMessage) msg).getMockid())); ((MockMessage) msg).setExpunged(true); for (final MailboxEventListener mailboxEventListener : mailboxEventListeners) { mailboxEventListener.messageExpunged(this, (MockMessage) msg, true); } } logger.debug(expunged.size() + " messages expunged (deleted) from" + getFullName()); return expunged.toArray(new Message[expunged.size()]); }
/** * Sets flags for this message. Flags not explicitly stored in metadata * will be kept in-memory. * @param flag The current state of flags for this message. */ @Override public synchronized void setFlags(Flags flag, boolean set) throws MessagingException { if (flag.contains(Flag.RECENT)) setRecent(set); if (flag.contains(Flag.SEEN)) setUnread(!set); if (flag.contains(Flag.ANSWERED)) setReplied(set); if (flag.contains(Flag.DELETED)) setDeleted(set); super.setFlags(flag, set); }
/** * Updates in-memory flags from stored metadata and returns them. */ @Override public Flags getFlags() throws MessagingException { super.setFlag(Flag.RECENT, isRecent()); super.setFlag(Flag.SEEN, !isUnread()); super.setFlag(Flag.ANSWERED, isReplied()); super.setFlag(Flag.DELETED, isDeleted()); return super.getFlags(); }
private void doDeleteMessages(final Folder folder, final Collection<Message> messages) { List<Message> messagesFiltered = FluentIterable.from(messages).filter(MessagePredicates.forRecipient(mailAccount.getAddress())) .toList(); if (messagesFiltered.isEmpty()) { return; } try { log.debug("Flagging {} message(s) for deletion", messagesFiltered.size()); for (Message message : messagesFiltered) { message.setFlag(Flag.DELETED, true); } folder.close(true); log.debug("Expunged {} message(s)", messagesFiltered.size()); } catch (MessagingException ex) { throw new MailException("Error deleting e-mail message", ex); } }
/** * Writes mailbox to mbox format */ public void writeMailBoxToFile(String outputDirectory) { try { PrintWriter out = new PrintWriter(new FileWriter( outputDirectory + File.separator + mailBoxID + ".mbox", false)); for (StoredSmtpMessage msg : mails.values()) { if (!msg.getFlags().contains(Flag.DELETED)) StreamUtilities.writeMessageToMBoxRDFormat(msg, out); } out.close(); } catch (Exception e) { e.printStackTrace(); } }
public List<Mail> getNewEmails(MailCredentials credentials) throws MessagingException, IOException { Properties properties = getServerProperties(credentials.getProtocol(), credentials.getHost(), "" + credentials.getPort()); Session session = Session.getDefaultInstance(properties); // connects to the message store Store store = session.getStore(credentials.getProtocol()); store.connect(credentials.getUsername(), credentials.getPassword()); logger.debug("url:" + store.getURLName()); // opens the inbox folder Folder folderInbox = store.getFolder("INBOX"); folderInbox.open(Folder.READ_ONLY); logger.debug("unread:" + folderInbox.getUnreadMessageCount() + ", new:" + folderInbox.getNewMessageCount()); // fetches new messages from server FlagTerm ft = new FlagTerm(new Flags(Flags.Flag.SEEN), false); Message messages[] = folderInbox.search(ft); List<Mail> mails = getMails(messages); // disconnect folderInbox.close(false); store.close(); return Lists.reverse(mails); }
private List<String> getFlags(Message msg) throws MessagingException { List<String> returnedFlags = new ArrayList<String>(); Flags flags = msg.getFlags(); if (flags.contains(Flag.ANSWERED)) { returnedFlags.add("answered"); } else if (flags.contains(Flag.DELETED)) { returnedFlags.add("deleted"); } else if (flags.contains(Flag.DRAFT)) { returnedFlags.add("draft"); } else if (flags.contains(Flag.RECENT)) { returnedFlags.add("new"); } else if (flags.contains(Flag.SEEN)) { returnedFlags.add("seen"); } return returnedFlags; }
@Override public void onCreateChildAssociation(final ChildAssociationRef childAssocRef, boolean isNewNode) { doAsSystem(new RunAsWork<Void>() { @Override public Void doWork() throws Exception { NodeRef childNodeRef = childAssocRef.getChildRef(); if (serviceRegistry.getDictionaryService().isSubClass(nodeService.getType(childNodeRef), ContentModel.TYPE_CONTENT)) { long newId = (Long) nodeService.getProperty(childNodeRef, ContentModel.PROP_NODE_DBID); // Keep a record of minimum and maximum node IDs in this folder in this transaction and add a listener that will // update the UIDVALIDITY and MAXUID properties appropriately. Also force generation of a new change token getUidValidityTransactionListener(childAssocRef.getParentRef()).recordNewUid(newId); // Flag new content as recent setFlag(childNodeRef, Flags.Flag.RECENT, true); } if (logger.isDebugEnabled()) { logger.debug("[onCreateChildAssociation] Association " + childAssocRef + " created. CHANGETOKEN will be changed."); } return null; } }); }
public String[] readPassAndKeyFromEmail(boolean delete, String userName) throws MessagingException { // Download message headers from server. int retries = 0; String userPass = null; String userKey = null; while (retries < 40 && userPass == null) { // Open main "INBOX" folder. Folder folder = getStore().getFolder(MAIL_INBOX); folder.open(Folder.READ_WRITE); // Get folder's list of messages. Message[] messages = folder.getMessages(); // Retrieve message headers for each message in folder. FetchProfile profile = new FetchProfile(); profile.add(FetchProfile.Item.ENVELOPE); folder.fetch(messages, profile); for (Message message : messages) { if (message.getSubject().equals(MAIL_SUBJECT_USER_ACCOUNT_CREATED_EN)) { String content = getMessageContent(message); String userNameFromEmail = readInformationFromGivenMail(MAIL_BODY_USERNAME_PATTERN_EN, content); if (userName.equals(userNameFromEmail)) { userKey = readInformationFromGivenMail(MAIL_BODY_USERKEY_PATTERN_EN, content); userPass = readInformationFromGivenMail(MAIL_BODY_PASSWORD_PATTERN_EN, content); if (delete) { message.setFlag(Flag.DELETED, true); } break; } } } folder.close(true); try { Thread.sleep(1000); } catch (InterruptedException e) { // ignored } retries++; } return new String[] {userKey, userPass}; }
/** * Create a new MessageData object given the message object. */ public MessageData(Message message) throws MessagingException { _message = message; // cache the size just because it involves a calculation _size = message.getSize() / 1024; // cache this since the folder has to be open to get this: _isRead = _message.isSet(Flag.SEEN); _isDeleted = _message.isSet(Flag.DELETED); }
@Override public Object invokeTarget() throws Exception { // poll only messages which are not deleted Message[] messages = target.search(new FlagTerm(new Flags(Flag.DELETED), false)); return Arrays.asList(messages); }
@Override public Object invokeTarget() throws Exception { for (Message message : target) { message.setFlag(Flag.DELETED, true); } return null; }
@Test @Deployment(resources = "processes/mail-delete.bpmn") public void deleteMailById() throws MessagingException { MimeMessage[] mails = greenMail.getReceivedMessages(); String messageId = mails[0].getMessageID(); engineRule.getRuntimeService().startProcessInstanceByKey("delete-mail", Variables.createVariables().putValue("messageId", messageId)); mails = greenMail.getReceivedMessages(); assertThat(mails).hasSize(2); assertThat(mails[0].isSet(Flag.DELETED)).isTrue(); assertThat(mails[1].isSet(Flag.DELETED)).isFalse(); }