Example usage for org.springframework.mail MailSendException MailSendException

List of usage examples for org.springframework.mail MailSendException MailSendException

Introduction

In this page you can find the example usage for org.springframework.mail MailSendException MailSendException.

Prototype

public MailSendException(String msg, @Nullable Throwable cause) 

Source Link

Document

Constructor for MailSendException.

Usage

From source file:ch.wisv.areafiftylan.utils.mail.MailServiceImpl.java

@Override
public void sendMail(String recipientEmail, String recipientName, String subject, String messageString) {

    // Prepare message using a Spring helper
    final MimeMessage mimeMessage = this.mailSender.createMimeMessage();
    final MimeMessageHelper message;

    try {//from www.j  a  v  a 2  s  .  com
        message = new MimeMessageHelper(mimeMessage, true, "UTF-8");
        message.setSubject("[Area FiftyLAN] " + subject);
        message.setFrom(sender);
        message.setTo(recipientEmail);

        // Create the HTML body using Thymeleaf
        String htmlContent = prepareHtmlContent(recipientName, messageString);
        message.setText(htmlContent, true); // true = isHtml

        // Send mail
        this.mailSender.send(mimeMessage);
    } catch (MessagingException e) {
        throw new MailPreparationException("Unable to prepare email", e.getCause());
    } catch (MailException m) {
        throw new MailSendException("Unable to send email", m.getCause());
    }

}

From source file:org.smigo.config.DevelopmentConfiguration.java

@Bean
public JavaMailSenderImpl javaMailSender() {
    return new JavaMailSenderImpl() {
        @Override// www  .  j av  a2 s . c om
        public String getDefaultEncoding() {
            return "UTF-8";
        }

        @Override
        public void send(SimpleMailMessage simpleMessage) throws MailException {
            try {
                //Thread.sleep(2000);
                String text = simpleMessage.getText();
                String subject = simpleMessage.getSubject();
                FileUtils.writeStringToFile(MAIL_FILE, text, Charset.defaultCharset());
                FileUtils.writeStringToFile(MAIL_FILE_TXT, subject + System.lineSeparator() + text,
                        Charset.defaultCharset());
            } catch (Exception e) {
                throw new MailSendException("Error sending email to " + simpleMessage.getFrom(), e);
            }
        }

        @Override
        public void send(MimeMessage mimeMessage) throws MailException {
            try {
                final String s = IOUtils.toString(mimeMessage.getInputStream());
                FileUtils.writeStringToFile(MAIL_FILE, s, Charset.defaultCharset());
            } catch (IOException | MessagingException e) {
                throw new MailSendException("Error sending email: " + mimeMessage.toString(), e);
            }
        }

        @Override
        public void send(SimpleMailMessage[] simpleMessages) throws MailException {
            throw new MailPreparationException("Method not supported");
        }
    };
}

From source file:org.jasig.schedassist.impl.reminder.DefaultReminderServiceImplTest.java

/**
 * SA-21 verify service continues to process reminders after failed email.
 * /*from  w ww .j av  a2 s .  c om*/
 * @throws InputFormatException 
 * 
 */
@Test
public void testPersistedReminderWithInvalidEmailAddress() throws InputFormatException {
    java.util.Date now = new java.util.Date();
    java.util.Date later = DateUtils.addHours(now, 1);
    DefaultEventUtilsImpl eventUtils = new DefaultEventUtilsImpl(new NullAffiliationSourceImpl());
    AvailableBlock targetBlock = AvailableBlockBuilder.createBlock(now, later);

    PersistedReminderImpl persisted = new PersistedReminderImpl();
    persisted.setOwnerId(1L);
    persisted.setReminderId(1L);
    persisted.setRecipientId("recipientid");
    persisted.setSendTime(now);
    persisted.setBlockStartTime(now);
    persisted.setBlockEndTime(later);

    MockCalendarAccount recipient = new MockCalendarAccount();
    recipient.setDisplayName("Some Visitor");
    recipient.setEmailAddress("bogus@nowhere.com");

    MockCalendarAccount account = new MockCalendarAccount();
    account.setDisplayName("Some Person");
    account.setEmailAddress("somebodyelse@nowhere.com");
    MockScheduleOwner owner = new MockScheduleOwner(account, 1L);
    AvailableBlock block = AvailableBlockBuilder.createBlock(new Date(), DateUtils.addMinutes(new Date(), 30));
    VEvent event = eventUtils.constructAvailableAppointment(block, owner, new MockScheduleVisitor(recipient),
            "test event");

    ReminderDao reminderDao = mock(ReminderDao.class);
    OwnerDao ownerDao = mock(OwnerDao.class);
    ICalendarAccountDao calendarAccountDao = mock(ICalendarAccountDao.class);
    SchedulingAssistantService schedAssistService = mock(SchedulingAssistantService.class);
    MailSender mailSender = mock(MailSender.class);

    List<PersistedReminderImpl> pending = new ArrayList<PersistedReminderImpl>();
    pending.add(persisted);

    when(reminderDao.getPendingReminders()).thenReturn(pending);
    when(ownerDao.locateOwnerByAvailableId(1L)).thenReturn(owner);
    when(calendarAccountDao.getCalendarAccount("recipientid")).thenReturn(recipient);

    when(schedAssistService.getExistingAppointment(targetBlock, owner)).thenReturn(event);
    SMTPAddressFailedException smtpFailure = new SMTPAddressFailedException(new InternetAddress(), "DATA", 550,
            "illegal alias");

    MailSendException exception = new MailSendException("failed", smtpFailure);

    doThrow(exception).when(mailSender).send(isA(SimpleMailMessage.class));

    DefaultReminderServiceImpl reminderService = new DefaultReminderServiceImpl();
    reminderService.setCalendarAccountDao(calendarAccountDao);
    reminderService.setMailSender(mailSender);
    reminderService.setMessageSource(messageSource);
    reminderService.setOwnerDao(ownerDao);
    reminderService.setReminderDao(reminderDao);
    reminderService.setSchedulingAssistantService(schedAssistService);

    reminderService.setEventUtils(eventUtils);
    List<IReminder> pendingCheck = reminderService.getPendingReminders();
    Assert.assertEquals(1, pendingCheck.size());
    Assert.assertTrue(reminderService.shouldSend(pendingCheck.get(0)));
    reminderService.processPendingReminders();

    verify(reminderDao, times(1)).deleteEventReminder(isA(ReminderImpl.class));
}

From source file:cz.zcu.kiv.eegdatabase.data.service.SpringJavaMailService.java

private boolean sendEmail(String from, String to, String subject, String emailBody) throws MailException {// make
                                                                                                          // public
                                                                                                          // if
                                                                                                          // needed
    try {/*from ww w.ja va 2s. c  o  m*/
        log.debug("email body: " + emailBody);
        log.debug("Composing e-mail message");
        MimeMessage mimeMessage = createMimeMessage(from, to, subject, emailBody);
        log.debug("MailSender " + mailSender + " sending email");
        mailSender.send(mimeMessage);
        log.debug("E-mail was sent");
        return true;
    } catch (MailException e) {
        log.error(e.getMessage(), e);
        throw new MailSendException(e.getMessage(), e);
    }
}

From source file:org.springframework.mail.javamail.JavaMailSenderImpl.java

/**
 * Actually send the given array of MimeMessages via JavaMail.
 * @param mimeMessages MimeMessage objects to send
 * @param originalMessages corresponding original message objects
 * that the MimeMessages have been created from (with same array
 * length and indices as the "mimeMessages" array), if any
 * @throws org.springframework.mail.MailAuthenticationException
 * in case of authentication failure// w  w w.  ja  v  a2 s .c  o  m
 * @throws org.springframework.mail.MailSendException
 * in case of failure when sending a message
 */
protected void doSend(MimeMessage[] mimeMessages, Object[] originalMessages) throws MailException {
    Map failedMessages = new HashMap();
    try {
        Transport transport = getTransport(getSession());
        transport.connect(getHost(), getPort(), getUsername(), getPassword());
        try {
            for (int i = 0; i < mimeMessages.length; i++) {
                MimeMessage mimeMessage = mimeMessages[i];
                try {
                    if (mimeMessage.getSentDate() == null) {
                        mimeMessage.setSentDate(new Date());
                    }
                    mimeMessage.saveChanges();
                    transport.sendMessage(mimeMessage, mimeMessage.getAllRecipients());
                } catch (MessagingException ex) {
                    Object original = (originalMessages != null ? originalMessages[i] : mimeMessage);
                    failedMessages.put(original, ex);
                }
            }
        } finally {
            transport.close();
        }
    } catch (AuthenticationFailedException ex) {
        throw new MailAuthenticationException(ex);
    } catch (MessagingException ex) {
        throw new MailSendException("Mail server connection failed", ex);
    }
    if (!failedMessages.isEmpty()) {
        throw new MailSendException(failedMessages);
    }
}