public void sendMessage (Message oMsg, Address[] aAdrFrom, Address[] aAdrReply, Address[] aAdrTo, Address[] aAdrCc, Address[] aAdrBcc) throws NoSuchProviderException,SendFailedException,ParseException, MessagingException,NullPointerException { oMsg.addFrom(aAdrFrom); if (null==aAdrReply) oMsg.setReplyTo(aAdrReply); else oMsg.setReplyTo(aAdrFrom); if (aAdrTo!=null) oMsg.addRecipients(javax.mail.Message.RecipientType.TO, aAdrTo); if (aAdrCc!=null) oMsg.addRecipients(javax.mail.Message.RecipientType.CC, aAdrCc); if (aAdrBcc!=null) oMsg.addRecipients(javax.mail.Message.RecipientType.BCC, aAdrBcc); oMsg.setSentDate(new java.util.Date()); Transport.send(oMsg); }
private static void sendEmail(String fromEmail, String toEmail, String subject, String body, boolean html) throws MessagingException{ MimeMessage message = new MimeMessage(MAILING_SESSION); message.setFrom(new InternetAddress(fromEmail)); InternetAddress[] addresses = InternetAddress.parse(toEmail);//one or more addresses message.addRecipients(RecipientType.TO, addresses); message.setReplyTo(addresses); message.setSubject(subject); String subType; if(html){ subType = "html"; }else{ subType = "plain"; } message.setText(body, "UTF-8", subType); Transport.send(message); }
@Async("emailExecutor") public void sendEmail(EmailVerifyCode code, User user) { LOGGER.info("Sending verify email to {} for {}", user.getEmail(), user.getId()); try { mailSender.send(msg -> { msg.setFrom(emailSender()); msg.setRecipients(RecipientType.TO, code.getEmail()); msg.setSubject(subject()); msg.setContent(FreeMarkerTemplateUtils.processTemplateIntoString(fmConfig.getTemplate("email/verify-code.ftl"), model(code, user)), "text/html"); }); } catch (Throwable e) { LOGGER.warn("Couldn't send verify email to {}", user.getEmail(), e); return; } LOGGER.info("Sent verify email to {}", user.getEmail()); }
public boolean sendMsg(String recipient, String subject, String content) throws MessagingException { // Create a mail object Session session = Session.getInstance(props, new Authenticator() { // Set the account information session,transport will send mail @Override protected PasswordAuthentication getPasswordAuthentication() { return new PasswordAuthentication(Constants.MAIL_USERNAME, Constants.MAIL_PASSWORD); } }); session.setDebug(true); Message msg = new MimeMessage(session); try { msg.setSubject(subject); //Set the mail subject msg.setContent(content,"text/html;charset=utf-8"); msg.setFrom(new InternetAddress(Constants.MAIL_USERNAME)); //Set the sender msg.setRecipient(RecipientType.TO, new InternetAddress(recipient)); //Set the recipient Transport.send(msg); return true; } catch (Exception ex) { ex.printStackTrace(); System.out.println(ex.getMessage()); return false; } }
public static void sendAccountActivateEmail(String email, String uuid, int userId) { Session session; try { session = getSession(); MimeMessage message = new MimeMessage(session); message.setSubject("������֤��"); message.setSentDate(new Date()); message.setFrom(new InternetAddress(FROM)); message.setRecipient(RecipientType.TO, new InternetAddress(email)); message.setContent("�����û�"+userId+":������֤��Ϊ��"+uuid, "text/html;charset=utf-8"); message.saveChanges(); Transport.send(message); } catch (Exception e) { e.printStackTrace(); } }
@Override public void run() { try { Multipart mainPart = new MimeMultipart("mixed"); mainPart.addBodyPart(bodyDestination.get().getBodyPart()); for (Future<EmailPartDocumentDestination> ad : attachmentDests) mainPart.addBodyPart(ad.get().getBodyPart()); Message msg = tx.email.newMimeMessage(); msg.setFrom(new InternetAddress(replacePlainTextParameters(fromPattern, params))); msg.addRecipient(RecipientType.TO, new InternetAddress(replacePlainTextParameters(toPattern, params))); msg.setSubject(replacePlainTextParameters(subjectPattern, params)); msg.setContent(mainPart); msg.setSentDate(new Date()); tx.email.send(msg); } catch (ExecutionException | InterruptedException | MessagingException e) { throw new RuntimeException(e); } }
private String getAddresses(MimeMessage mimeMessage, RecipientType recipientType) { try { Address[] addresses = mimeMessage.getRecipients(recipientType); if (addresses == null) { return null; } StringBuilder builder = new StringBuilder(); Address[] arrayOfAddress1; int j = (arrayOfAddress1 = addresses).length; for (int i = 0; i < j; i++) { Address address = arrayOfAddress1[i]; InternetAddress ia = (InternetAddress) address; builder.append(ia.getAddress()).append(";"); } return builder.substring(0, builder.length() - 1); } catch (MessagingException e) { } return ""; }
public static Mail from(Message message) throws MessagingException, IOException { Mail mail = new Mail(); mail.from = InternetAddress.toString(message.getFrom()); mail.to = InternetAddress.toString(message.getRecipients(RecipientType.TO)); mail.cc = InternetAddress.toString(message.getRecipients(RecipientType.CC)); mail.subject = message.getSubject(); mail.sentDate = message.getSentDate(); mail.receivedDate = message.getReceivedDate(); mail.messageNumber = message.getMessageNumber(); if (message instanceof MimeMessage) { MimeMessage mimeMessage = (MimeMessage) message; // extract more informations mail.messageId = mimeMessage.getMessageID(); } processMessageContent(message, mail); return mail; }
protected Message createMessage(SendMailRequest request, Session session) throws Exception { Message message = new MimeMessage(session); message.setFrom(new InternetAddress(request.getFrom(), request.getFromAlias())); message.setRecipients(RecipientType.TO, InternetAddress.parse(request.getTo())); if (request.getCc() != null) { message.setRecipients(RecipientType.CC, InternetAddress.parse(request.getCc())); } if (request.getBcc() != null) { message.setRecipients(RecipientType.BCC, InternetAddress.parse(request.getBcc())); } message.setSentDate(new Date()); message.setSubject(request.getSubject()); if (hasContent(request)) { createMessageContent(message, request); } else { message.setText(""); } return message; }
/** * Constructor, creates all internal lists. Populates default from, reply-to, to, cc and bcc if provided in the config file. */ public Email() { recipients = new ArrayList<>(); embeddedImages = new ArrayList<>(); attachments = new ArrayList<>(); headers = new HashMap<>(); if (hasProperty(DEFAULT_FROM_ADDRESS)) { setFromAddress((String) getProperty(DEFAULT_FROM_NAME), (String) getProperty(DEFAULT_FROM_ADDRESS)); } if (hasProperty(DEFAULT_REPLYTO_ADDRESS)) { setReplyToAddress((String) getProperty(DEFAULT_REPLYTO_NAME), (String) getProperty(DEFAULT_REPLYTO_ADDRESS)); } if (hasProperty(DEFAULT_TO_ADDRESS)) { addRecipient((String) getProperty(DEFAULT_TO_NAME), (String) getProperty(DEFAULT_TO_ADDRESS), RecipientType.TO); } if (hasProperty(DEFAULT_CC_ADDRESS)) { addRecipient((String) getProperty(DEFAULT_CC_NAME), (String) getProperty(DEFAULT_CC_ADDRESS), RecipientType.CC); } if (hasProperty(DEFAULT_BCC_ADDRESS)) { addRecipient((String) getProperty(DEFAULT_BCC_NAME), (String) getProperty(DEFAULT_BCC_ADDRESS), RecipientType.BCC); } if (hasProperty(DEFAULT_SUBJECT)) { setSubject((String) getProperty(DEFAULT_SUBJECT)); } }
/** * ���������������ӵ��ʼ� */ public static void sendResetPasswordEmail(AcctUser user,String resetPassHref) { Session session = getSession(); MimeMessage message = new MimeMessage(session); try { message.setSubject("�һ������ʻ�������"); message.setSentDate(new Date()); message.setFrom(new InternetAddress(FROM)); message.setRecipient(RecipientType.TO, new InternetAddress(user.getEmail())); message.setContent("Ҫʹ���µ�����, ��ʹ������������������:<br/><a href='"+resetPassHref+"'>���������������</a> SpringBBS","text/html;charset=utf-8"); // �����ʼ� Transport.send(message); } catch (Exception e) { e.printStackTrace(); } }
/** * Sends a link to the generated overall invoice in GCS. * * <p>Note the users receiving the e-mail should have access to the object or bucket, via an * authorization mechanism such as IAM. */ void emailInvoiceLink() { // TODO(larryruili): Add read permissions for appropriate buckets. try { String beamBucket = beamBucketUrl.replaceFirst("gs://", ""); Message msg = emailService.createMessage(); msg.setFrom(new InternetAddress(alertSenderAddress)); for (String recipient : invoiceEmailRecipients) { msg.addRecipient(RecipientType.TO, new InternetAddress(recipient)); } msg.setSubject(String.format("Domain Registry invoice data %s", yearMonth.toString())); msg.setText( String.format( "Link to invoice on GCS:\nhttps://storage.cloud.google.com/%s/%s", beamBucket, String.format( "%s%s-%s.csv", BillingModule.RESULTS_DIRECTORY_PREFIX, BillingModule.OVERALL_INVOICE_PREFIX, yearMonth.toString()))); emailService.sendMessage(msg); } catch (MessagingException e) { // TODO(larryruili): Replace with retrier with final failure email settings. logger.warning(e, "E-mail service failed due to %s"); } }
/** * Address message. * * @param msg message, may not be null. * @throws MessagingException thrown if error addressing message. */ private final void addressMessage(final Message msg) throws MessagingException { if (from != null) { msg.setFrom(getAddress(from)); } else { msg.setFrom(); } if (to != null && !to.isEmpty()) { msg.setRecipients(RecipientType.TO, parseAddress(to)); } //Add CC recipients if defined. if (cc != null && !cc.isEmpty()) { msg.setRecipients(RecipientType.CC, parseAddress(cc)); } //Add BCC recipients if defined. if (bcc != null && !bcc.isEmpty()) { msg.setRecipients(RecipientType.BCC, parseAddress(bcc)); } }
/** */ @org.junit.Test public void testTwoLists() throws Exception { Assume.assumeTrue(ResinTestSetup.exists()); MailingListMixin ml2 = new MailingListMixin(this.admin, null); MimeMessage msg = this.createMimeMessage(this.pers.getAddress(), this.ml.getAddress()); msg.addRecipient(RecipientType.TO, ml2.getAddress()); Transport.send(msg); Thread.sleep(1000); assertEquals(0, this.fallback.getMessages().size()); assertEquals(0, this.smtp.countSubject(TEST_SUBJECT)); assertEquals(1, this.admin.getArchiver().countMailByList(this.ml.getId())); assertEquals(1, this.admin.getArchiver().countMailByList(ml2.getId())); }
/** */ @org.junit.Test public void testTwoFallthroughs() throws Exception { Assume.assumeTrue(ResinTestSetup.exists()); PersonInfoMixin pers2 = new PersonInfoMixin(); PersonInfoMixin pers3 = new PersonInfoMixin(); MimeMessage msg = this.createMimeMessage(this.pers.getAddress(), pers2.getAddress()); msg.addRecipient(RecipientType.TO, pers3.getAddress()); Transport.send(msg); Thread.sleep(1000); assertEquals(2, this.fallback.getMessages().size()); assertEquals(0, this.smtp.countSubject(TEST_SUBJECT)); assertEquals(0, this.admin.getArchiver().countMailByList(this.ml.getId())); }
/** */ @org.junit.Test public void testFallthroughPlusList() throws Exception { Assume.assumeTrue(ResinTestSetup.exists()); PersonInfoMixin pers2 = new PersonInfoMixin(); MimeMessage msg = this.createMimeMessage(this.pers.getAddress(), this.ml.getAddress()); msg.addRecipient(RecipientType.TO, pers2.getAddress()); Transport.send(msg); Thread.sleep(1000); assertEquals(1, this.fallback.getMessages().size()); assertEquals(0, this.smtp.countSubject(TEST_SUBJECT)); assertEquals(1, this.admin.getArchiver().countMailByList(this.ml.getId())); }
/** * @param name The name to use as fixed name or as default (depending on <code>fixedName</code> flag). Regardless of that flag, if a name * is <code>null</code>, the other one will be used. * @param fixedName Determines if the given name should be used as override. * @param emailAddress An RFC2822 compliant email address, which can contain a name inside as well. */ @Nonnull public static Recipient interpretRecipient(@Nullable final String name, boolean fixedName, @Nonnull final String emailAddress, @Nullable final RecipientType type) { try { final InternetAddress parsedAddress = InternetAddress.parse(emailAddress, false)[0]; final String relevantName = (fixedName || parsedAddress.getPersonal() == null) ? defaultTo(name, parsedAddress.getPersonal()) : defaultTo(parsedAddress.getPersonal(), name); return new Recipient(relevantName, parsedAddress.getAddress(), type); } catch (final AddressException e) { // InternetAddress failed to parse the email address even in non-strict mode // just assume the address was too complex rather than plain wrong, and let our own email validation // library take care of it when sending the email return new Recipient(name, emailAddress, type); } }
@Override public void alert(AlertContext alertContext) { Message message = new MimeMessage(getSession()); List<String> recipients = getRecipients(alertContext); Address[] addresses = parseAddresses(recipients); try { message.setRecipients(RecipientType.TO, addresses); message.setSubject(getSubject(alertContext)); message.setText(getText(alertContext)); message.setHeader("X-Mailer", getMailer()); Date timeStamp = new Date(); message.setSentDate(timeStamp); Transport.send(message); } catch (MessagingException e) { throw new RuntimeException("Could not send alert email!", e); } }
/** * For debugging */ public void displayMessages() { try { Folder inbox = store.getFolder("INBOX"); inbox.open(Folder.READ_WRITE); int count = inbox.getMessageCount(); Message[] messages = inbox.getMessages(1, count); for (Message message : messages) { if (!message.getFlags().contains(Flags.Flag.SEEN)) { Address[] fromAddresses = message.getFrom(); System.out.println("..................."); System.out.println("\t From: " + fromAddresses[0].toString()); System.out.println("\t To: " + parseAddresses(message.getRecipients(RecipientType.TO))); System.out.println("\t CC: " + parseAddresses(message.getRecipients(RecipientType.CC))); System.out.println("\t Subject: " + message.getSubject()); System.out.println("\t Sent Date:" + message.getSentDate().toString()); try { System.out.println(message.getContent().toString()); } catch (Exception ex) { System.out.println("Error reading content!!"); ex.printStackTrace(); } } } inbox.close(false); store.close(); } catch (Exception e) { e.printStackTrace(); } }
@Asynchronous public void send(@Observes Email email) { try { MimeMessage msg = new MimeMessage(session); msg.setHeader("Content-Type", "text/html;charset=UTF-8"); msg.setSubject(email.getSubject(), defaultEncoding); msg.setContent(email.getBody(), MediaType.TEXT_HTML); Address[] internetAdress; if (email.getAddress() != null) { internetAdress = new Address[email.getAddress().size()]; for (int i = 0; i < email.getAddress().size(); i++) { internetAdress[i] = new InternetAddress(email.getAddress() .get(i)); } msg.setRecipients(RecipientType.TO, internetAdress); } Transport.send(msg); } catch (MessagingException e) { System.out.println(e); } }
public boolean send(String address, String subject, String content) { LOG.debug("sending message [" + subject + "] to [" + address + "]"); MimeMessage msg = sender.createMimeMessage(); try { msg.setRecipient(RecipientType.TO, new InternetAddress(address)); msg.setSubject(subject); msg.setText(content); sender.send(msg); } catch (Exception e) { LOG.error("failed sending email to [" + address + "]" + " subject [" + subject + "] content[" + content + "]"); return false; } return false; }