/**
  * This method builds {@link Multipart} based on {@link ContentModel}
  *
  * @param fileInfo - Source file information {@link FileInfo}
  * @throws MessagingException
  */
 private Multipart buildContentModelMultipart() throws MessagingException {
   MimeMultipart rootMultipart = new AlfrescoMimeMultipart("alternative", this.messageFileInfo);
   // Cite MOB-395: "email agent will be used to select an appropriate template" - we are not able
   // to
   // detect an email agent so we use a default template for all messages.
   // See AlfrescoImapConst to see the possible templates to use.
   if (isMessageInSitesLibrary) {
     String bodyTxt = getEmailBodyText(EmailBodyFormat.SHARE_TEXT_PLAIN);
     rootMultipart.addBodyPart(
         getTextBodyPart(
             bodyTxt,
             EmailBodyFormat.SHARE_TEXT_PLAIN.getSubtype(),
             EmailBodyFormat.SHARE_TEXT_PLAIN.getMimeType()));
     String bodyHtml = getEmailBodyText(EmailBodyFormat.SHARE_TEXT_HTML);
     rootMultipart.addBodyPart(
         getTextBodyPart(
             bodyHtml,
             EmailBodyFormat.SHARE_TEXT_HTML.getSubtype(),
             EmailBodyFormat.SHARE_TEXT_HTML.getMimeType()));
   } else {
     String bodyTxt = getEmailBodyText(EmailBodyFormat.ALFRESCO_TEXT_PLAIN);
     rootMultipart.addBodyPart(
         getTextBodyPart(
             bodyTxt,
             EmailBodyFormat.ALFRESCO_TEXT_PLAIN.getSubtype(),
             EmailBodyFormat.ALFRESCO_TEXT_PLAIN.getMimeType()));
     String bodyHtml = getEmailBodyText(EmailBodyFormat.ALFRESCO_TEXT_HTML);
     rootMultipart.addBodyPart(
         getTextBodyPart(
             bodyHtml,
             EmailBodyFormat.ALFRESCO_TEXT_HTML.getSubtype(),
             EmailBodyFormat.ALFRESCO_TEXT_HTML.getMimeType()));
   }
   return rootMultipart;
 }
  @Test
  public void html() throws Exception {
    String subject = "html";
    buildSMTPAppender(subject, SYNCHRONOUS);
    smtpAppender.setAsynchronousSending(false);
    smtpAppender.setLayout(buildHTMLLayout());
    smtpAppender.start();
    logger.addAppender(smtpAppender);
    logger.debug("html");
    logger.error("en error", new Exception("an exception"));

    MimeMultipart mp = verifyAndExtractMimeMultipart(subject);

    // verifyAndExtractMimeMultipart strict adherence to xhtml1-strict.dtd
    SAXReader reader = new SAXReader();
    reader.setValidation(true);
    reader.setEntityResolver(new XHTMLEntityResolver());
    byte[] messageBytes = getAsByteArray(mp.getBodyPart(0).getInputStream());
    ByteArrayInputStream bais = new ByteArrayInputStream(messageBytes);
    try {
      reader.read(bais);
    } catch (DocumentException de) {
      System.out.println("incoming message:");
      System.out.println(new String(messageBytes));
      throw de;
    }
  }
Exemple #3
0
  public void setMessageContent(
      MimeMessage message, String subject, String bodyText, String bodyHtml) {
    try {
      message.setSubject(subject);

      MimeBodyPart textPart = new MimeBodyPart();
      textPart.setText(bodyText.toString(), "UTF-8");

      MimeBodyPart htmlPart = new MimeBodyPart();
      htmlPart.setContent(bodyHtml.toString(), "text/html; charset=UTF-8");

      MimeMultipart multiPart = new MimeMultipart();
      // "alternative" means display only one or the other, "mixed" means both
      multiPart.setSubType("alternative");

      // I read something on the internet saying to put the text part first
      // so sucktastic mail clients see it first
      multiPart.addBodyPart(textPart);
      multiPart.addBodyPart(htmlPart);

      message.setContent(multiPart);
    } catch (MessagingException e) {
      throw new RuntimeException("failed to put together MIME message", e);
    }
  }
  // http://jira.qos.ch/browse/LBCLASSIC-221
  @Test
  public void bufferShouldBeResetBetweenMessages() throws Exception {
    buildSMTPAppender(smtpServer.getSmtp().getPort(), SYNCHRONOUS);
    smtpAppender.setLayout(buildPatternLayout(lc, DEFAULT_PATTERN));
    smtpAppender.start();
    logger.addAppender(smtpAppender);
    String msg0 = "hello zero";
    logger.debug(msg0);
    logger.error("error zero");

    String msg1 = "hello one";
    logger.debug(msg1);
    logger.error("error one");

    waitUntilEmailIsSent();
    waitUntilEmailIsReceived(smtpServer, 2);

    MimeMessage[] mma = smtpServer.getReceivedMessages();
    assertNotNull(mma);
    assertEquals(2, mma.length);

    MimeMessage mm0 = mma[0];
    MimeMultipart content0 = (MimeMultipart) mm0.getContent();
    String body0 = GreenMailUtil.getBody(content0.getBodyPart(0));
    assertTrue(body0.contains(msg0));

    MimeMessage mm1 = mma[1];
    MimeMultipart content1 = (MimeMultipart) mm1.getContent();
    String body1 = GreenMailUtil.getBody(content1.getBodyPart(0));
    // second body should not contain content from first message
    assertFalse(body1.contains(msg0));
  }
 private void writeMultipartToNode(Session session, Node message, MimeMultipart multipart)
     throws RepositoryException, MessagingException, IOException {
   int count = multipart.getCount();
   for (int i = 0; i < count; i++) {
     createChildNodeForPart(session, i, multipart.getBodyPart(i), message);
   }
 }
  /** 根据传入的 Seesion 对象创建混合型的 MIME消息 */
  public MimeMessage createMessage(Session session) throws Exception {
    String from = "*****@*****.**";
    String to = "*****@*****.**";
    String subject = "创建内含附件、图文并茂的邮件!";
    String body =
        "<h4>内含附件、图文并茂的邮件测试!!!</h4> </br>"
            + "<a href = http://haolloyin.blog.51cto.com/> 蚂蚁</a></br>"
            + "<img src = \"cid:logo_jpg\"></a>";

    MimeMessage msg = new MimeMessage(session);
    msg.setFrom(new InternetAddress(from));
    msg.setRecipient(Message.RecipientType.TO, new InternetAddress(to));
    msg.setSubject(subject);

    // 创建邮件的各个 MimeBodyPart 部分
    MimeBodyPart attachment01 = createAttachment("F:\\java\\Snake.java");
    MimeBodyPart attachment02 = createAttachment("F:\\java\\meng.mp3");
    MimeBodyPart content = createContent(body, "F:\\java\\logo.jpg");

    // 将邮件中各个部分组合到一个"mixed"型的 MimeMultipart 对象
    MimeMultipart allPart = new MimeMultipart("mixed");
    allPart.addBodyPart(attachment01);
    allPart.addBodyPart(attachment02);
    allPart.addBodyPart(content);

    // 将上面混合型的 MimeMultipart 对象作为邮件内容并保存
    msg.setContent(allPart);
    msg.saveChanges();
    return msg;
  }
Exemple #7
0
  /**
   * Generate a MimeMessage with the specified attributes
   *
   * @param destEmailAddr The destination email address
   * @param fromEmailAddr The sender email address
   * @param fromName The senders display name
   * @param emailSubject The subject
   * @param emailPlainText The message body (plaintext)
   * @return The MimeMessage object
   * @throws Exception
   */
  public static MimeMessage generateMail(
      String destEmailAddr,
      String destPersonalName,
      String fromEmailAddr,
      String fromName,
      String emailSubject,
      String emailPlainText)
      throws Exception {

    MimeMessage message = new MimeMessage(Session.getDefaultInstance(System.getProperties(), null));

    InternetAddress[] toAddrs = InternetAddress.parse(destEmailAddr, false);
    if (destPersonalName != null) {
      toAddrs[0].setPersonal(destPersonalName);
    }
    InternetAddress from = new InternetAddress(fromEmailAddr);
    from.setPersonal(fromName);

    message.setRecipients(Message.RecipientType.TO, toAddrs);
    message.setFrom(from);
    message.setSubject(emailSubject);
    message.setSentDate(new java.util.Date());

    MimeMultipart msgbody = new MimeMultipart();
    MimeBodyPart html = new MimeBodyPart();
    html.setDataHandler(new DataHandler(new MailDataSource(emailPlainText, "text/plain")));
    msgbody.addBodyPart(html);
    message.setContent(msgbody);

    return message;
  }
 @Test
 public void savedWithoutError() throws Exception {
   Session session = Session.getDefaultInstance(new Properties());
   // Instantiate a Multipart object
   MimeMultipart mp = new MimeMultipart();
   // create the first bodypart object
   MimeBodyPart b1 = new MimeBodyPart();
   // create textual content
   // and add it to the bodypart object
   b1.setContent("Spaceport Map", "text/plain");
   mp.addBodyPart(b1);
   // Multipart messages usually have more than
   // one body part. Create a second body part
   // object, add new text to it, and place it
   // into the multipart message as well. This
   // second object holds postscript data.
   MimeBodyPart b2 = new MimeBodyPart();
   b2.setDataHandler(new DataHandler(new FileDataSource("project.xml")));
   mp.addBodyPart(b2);
   // Create a new message object as described above,
   // and set its attributes. Add the multipart
   // object to this message and call saveChanges()
   // to write other message headers automatically.
   Message msg = new MimeMessage(session);
   // Set message attrubutes as in a singlepart
   // message.
   msg.setContent(mp); // add Multipart
   msg.saveChanges(); // save changes
 }
  public Multipart generate(Email email) throws MessagingException, IOException, TemplateException {
    MimeMultipart multipart = new MimeMultipart("alternative");

    multipart.addBodyPart(bodyPartFactory.createPlainTextBodyPart(email));
    multipart.addBodyPart(bodyPartFactory.createHtmlBodyPart(email));
    return multipart;
  }
  // http://jira.qos.ch/browse/LBCLASSIC-221
  @Test
  public void bufferShouldBeResetBetweenMessages() throws Exception {
    buildSMTPAppender("bufferShouldBeResetBetweenMessages", SYNCHRONOUS);
    smtpAppender.setLayout(buildPatternLayout(DEFAULT_PATTERN));
    smtpAppender.start();
    logger.addAppender(smtpAppender);
    String msg0 = "hello zero";
    logger.debug(msg0);
    logger.error("error zero");

    String msg1 = "hello one";
    logger.debug(msg1);
    logger.error("error one");

    Thread.yield();
    int oldCount = 0;
    int expectedEmailCount = oldCount + 2;
    waitForServerToReceiveEmails(expectedEmailCount);

    MimeMessage[] mma = greenMailServer.getReceivedMessages();
    assertNotNull(mma);
    assertEquals(expectedEmailCount, mma.length);

    MimeMessage mm0 = mma[oldCount];
    MimeMultipart content0 = (MimeMultipart) mm0.getContent();
    String body0 = GreenMailUtil.getBody(content0.getBodyPart(0));

    MimeMessage mm1 = mma[oldCount + 1];
    MimeMultipart content1 = (MimeMultipart) mm1.getContent();
    String body1 = GreenMailUtil.getBody(content1.getBodyPart(0));
    // second body should not contain content from first message
    assertFalse(body1.contains(msg0));
  }
Exemple #11
0
  public boolean sendMail(String subject, String text, File attachmentFile) {
    try {
      MailAuthenticator auth = new MailAuthenticator(smtpUser, smtpPass);
      Properties properties = new Properties();
      properties.put("mail.smtp.host", smtpServer);
      properties.put("mail.smtp.auth", "true");

      Session session = Session.getDefaultInstance(properties, auth);
      Message msg = new MimeMessage(session);

      MimeMultipart content = new MimeMultipart("alternative");
      MimeBodyPart message = new MimeBodyPart();
      message.setText(text);
      message.setHeader("MIME-Version", "1.0" + "\n");
      message.setHeader("Content-Type", message.getContentType());
      content.addBodyPart(message);
      if (attachmentFile != null) {
        DataSource fileDataSource = new FileDataSource(attachmentFile);
        BodyPart messageBodyPart = new MimeBodyPart();
        messageBodyPart.setDataHandler(new DataHandler(fileDataSource));
        messageBodyPart.setFileName(attachmentFile.getName());
        content.addBodyPart(messageBodyPart);
      }
      msg.setContent(content);
      msg.setSentDate(new Date());
      msg.setFrom(new InternetAddress(smtpSender));
      msg.setRecipients(Message.RecipientType.TO, InternetAddress.parse(smtpReceiver, false));
      msg.setSubject(subject);
      Transport.send(msg);
      return true;
    } catch (Exception e) {
      // e.getMessage()
      return false;
    }
  }
  @Test
  public void testByteArrayToSMIME() {
    try {
      ByteArrayOutputStream out = new ByteArrayOutputStream();
      TEST_CASE1.writeTo(out);
      ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());

      ByteArraytoSMIME transformer = new ByteArraytoSMIME();

      Object object = transformer.transformMimeMessage(in, null);
      assertNotNull(object);
      assertTrue(object instanceof MimeMultipart);

      MimeMultipart mime = (MimeMultipart) object;

      assertEquals(TEST_CASE1.getBodyPart(0).getContent(), mime.getBodyPart(0).getContent());
      assertEquals(TEST_CASE1.getBodyPart(1).getContent(), mime.getBodyPart(1).getContent());

    } catch (TransformerException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      fail();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      fail();
    } catch (MessagingException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
      fail();
    }
  }
  @Test
  public void testSendMessageWithAttachment() throws Exception {
    final String ATTACHMENT_NAME = "boring-attachment.txt";

    // mock smtp server
    Wiser wiser = new Wiser();
    int port = 2525 + (int) (Math.random() * 100);
    mailSender.setPort(port);
    wiser.setPort(port);
    wiser.start();

    Date dte = new Date();
    String emailSubject = "grepster testSendMessageWithAttachment: " + dte;
    String emailBody = "Body of the grepster testSendMessageWithAttachment message sent at: " + dte;

    ClassPathResource cpResource = new ClassPathResource("/test-attachment.txt");
    // a null from should work
    mailEngine.sendMessage(
        new String[] {"*****@*****.**"}, null, cpResource, emailBody, emailSubject, ATTACHMENT_NAME);

    mailEngine.sendMessage(
        new String[] {"*****@*****.**"},
        mailMessage.getFrom(),
        cpResource,
        emailBody,
        emailSubject,
        ATTACHMENT_NAME);

    wiser.stop();
    // one without and one with from
    assertTrue(wiser.getMessages().size() == 2);

    WiserMessage wm = wiser.getMessages().get(0);
    MimeMessage mm = wm.getMimeMessage();

    Object o = wm.getMimeMessage().getContent();
    assertTrue(o instanceof MimeMultipart);
    MimeMultipart multi = (MimeMultipart) o;
    int numOfParts = multi.getCount();

    boolean hasTheAttachment = false;
    for (int i = 0; i < numOfParts; i++) {
      BodyPart bp = multi.getBodyPart(i);
      String disp = bp.getDisposition();
      if (disp == null) { // the body of the email
        Object innerContent = bp.getContent();
        MimeMultipart innerMulti = (MimeMultipart) innerContent;
        assertEquals(emailBody, innerMulti.getBodyPart(0).getContent());
      } else if (disp.equals(Part.ATTACHMENT)) { // the attachment to the email
        hasTheAttachment = true;
        assertEquals(ATTACHMENT_NAME, bp.getFileName());
      } else {
        fail("Did not expect to be able to get here.");
      }
    }
    assertTrue(hasTheAttachment);
    assertEquals(emailSubject, mm.getSubject());
  }
  /*
   * Writes/Sends an Email
   */
  public void writeConfirmationEmail(
      String firstName, String lastName, String username, String password, String email) {
    String to = email;
    String from = "*****@*****.**";
    String host = "smtp.ilstu.edu";
    Properties properties = System.getProperties();

    properties.setProperty("mail.smtp.host", host);
    properties.setProperty("mail.user", "cssumne"); // if needed
    properties.setProperty("mail.password", "stuC0rb!"); // if needed
    Session session = Session.getDefaultInstance(properties);

    try {
      MimeMessage message = new MimeMessage(session);
      MimeMultipart multipart = new MimeMultipart("related");
      BodyPart messageBodyPart = new MimeBodyPart();
      message.setFrom(new InternetAddress(from));
      message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
      message.setSubject("Profile Created!");

      String htmlText =
          "<h1>Congratulations, "
              + firstName
              + " "
              + lastName
              + "! Your Profile has been created!</h1>"
              + "<img src=\"cid:image\">"
              + "<p>Username: "******"</p>"
              + "<p>Email: "
              + email
              + "</p>"
              + "<p>Password: "******"</p>"
              + "<p>Thank You for Joining!</p>";

      messageBodyPart.setContent(htmlText, "text/html");
      multipart.addBodyPart(messageBodyPart);
      messageBodyPart = new MimeBodyPart();
      DataSource fds;
      fds =
          new FileDataSource(
              "C:\\Users\\Corbin\\Desktop\\Github\\WebDevSemesterProject\\SilentAuction\\web\\resources\\bf_logo.png");
      messageBodyPart.setDataHandler(new DataHandler(fds));
      messageBodyPart.setHeader("Content-ID", "<image>");
      multipart.addBodyPart(messageBodyPart);
      message.setContent(multipart);

      Transport.send(message);

      System.out.println("Sent message successfully....");
    } catch (MessagingException mex) {
      mex.printStackTrace();
    }
  }
  @Override
  public Collection<IridiumMessage> pollMessages(Date timeSince) throws Exception {

    if (askGmailPassword || gmailPassword == null || gmailUsername == null) {
      Pair<String, String> credentials =
          GuiUtils.askCredentials(
              ConfigFetch.getSuperParentFrame(),
              "Enter Gmail Credentials",
              getGmailUsername(),
              getGmailPassword());
      if (credentials == null) return null;
      setGmailUsername(credentials.first());
      setGmailPassword(credentials.second());
      PluginUtils.saveProperties("conf/rockblock.props", this);
      askGmailPassword = false;
    }

    Properties props = new Properties();
    props.put("mail.store.protocol", "imaps");
    ArrayList<IridiumMessage> messages = new ArrayList<>();
    try {
      Session session = Session.getDefaultInstance(props, null);
      Store store = session.getStore("imaps");
      store.connect("imap.gmail.com", getGmailUsername(), getGmailPassword());

      Folder inbox = store.getFolder("Inbox");
      inbox.open(Folder.READ_ONLY);
      int numMsgs = inbox.getMessageCount();

      for (int i = numMsgs; i > 0; i--) {
        Message m = inbox.getMessage(i);
        if (m.getReceivedDate().before(timeSince)) {
          break;
        } else {
          MimeMultipart mime = (MimeMultipart) m.getContent();
          for (int j = 0; j < mime.getCount(); j++) {
            BodyPart p = mime.getBodyPart(j);
            Matcher matcher = pattern.matcher(p.getContentType());
            if (matcher.matches()) {
              InputStream stream = (InputStream) p.getContent();
              byte[] data = IOUtils.toByteArray(stream);
              IridiumMessage msg = process(data, matcher.group(1));
              if (msg != null) messages.add(msg);
            }
          }
        }
      }
    } catch (NoSuchProviderException ex) {
      ex.printStackTrace();
      System.exit(1);
    } catch (MessagingException ex) {
      ex.printStackTrace();
      System.exit(2);
    }

    return messages;
  }
Exemple #16
0
  public static void collectMultipartContent(MimeMultipart multipart, MBMailMessage collector)
      throws Exception {

    for (int i = 0; i < multipart.getCount(); i++) {
      BodyPart part = multipart.getBodyPart(i);

      collectPartContent(part, collector);
    }
  }
    public void send(final Email email) throws MessagingException {
      if (email.getMessage().getSender().getFromName() == null) {
        logProblem("error.from.address.cannot.be.null");
        abort();
        return;
      }

      final String from =
          constructFromString(
              encode(email.getMessage().getFromName()), email.getMessage().getFromAddress());

      final String[] replyTos = email.replyTos();
      final Address[] replyToAddresses = new Address[replyTos == null ? 0 : replyTos.length];
      if (replyTos != null) {
        for (int i = 0; i < replyTos.length; i++) {
          try {
            replyToAddresses[i] = new InternetAddress(encode(replyTos[i]));
          } catch (final AddressException e) {
            logProblem("invalid.reply.to.address: " + replyTos[i]);
            abort();
            return;
          }
        }
      }

      setFrom(new InternetAddress(from));
      setSubject(encode(email.getSubject()));
      setReplyTo(replyToAddresses);

      final String body = email.getBody();
      final String htmlBody = getHtmlBody();

      final MimeMultipart mimeMultipart = createMimeMultipart(body, htmlBody);

      if (body != null && !body.trim().isEmpty()) {
        final BodyPart bodyPart = new MimeBodyPart();
        bodyPart.setText(body);
        mimeMultipart.addBodyPart(bodyPart);
      }

      if (htmlBody != null && !htmlBody.trim().isEmpty()) {
        final BodyPart bodyPart = new MimeBodyPart();
        bodyPart.setContent(htmlBody, "text/html; charset=utf-8");
        mimeMultipart.addBodyPart(bodyPart);
      }

      setContent(mimeMultipart);

      addRecipientsAux();

      LOG.info("Sending email {} with message id {}", email.getExternalId(), getMessageID());

      Transport.send(this);

      final Address[] allRecipients = getAllRecipients();
      setConfirmedAddresses(allRecipients);
    }
Exemple #18
0
  private static void readMultiPart(MultipartResult res, MimeMultipart multipart)
      throws MessagingException {
    for (int i = 0; i < multipart.getCount(); i++) {
      BodyPart part = multipart.getBodyPart(i);

      try {
        if (part.isMimeType("image/*") || part.isMimeType("application/*")) continue;
        Object content = null;
        try {
          content = part.getContent();
        } catch (UnsupportedEncodingException ex) {
          String body = ConvertUtil.inputStreamToString(part.getInputStream());
          res.body = body;
          continue;
        }

        if (part.isMimeType("text/plain")) {
          res.body = content.toString();
        } else if (part.isMimeType("text/*")) {
          res.bodyHtml = content.toString();
        } else if (content instanceof MimeMultipart) {
          readMultiPart(res, (MimeMultipart) content);
        } else if (content instanceof IMAPNestedMessage) {
          res.body = getBody((IMAPNestedMessage) content);
          return;
        } else if (content instanceof InputStream) {
          if (content instanceof IMAPInputStream) {
            String body = ConvertUtil.inputStreamToString(part.getInputStream());
            res.body = body;
          } else
            System.out.println(
                String.format(
                    "Ignoring binary content in mail: %s [%s]",
                    part.getContentType(), content.getClass()));
        } else if (part.isMimeType("message/*")) {
          res.body = content.toString();
        } else {
          System.out.println(
              String.format(
                  "Unknown content type in mail: %s [%s]",
                  part.getContentType(), content.getClass()));
        }

      } catch (IllegalStateException ex) {
        System.out.println(
            String.format("Could not read contents in mail: %s", part.getContentType()));
      } catch (UnsupportedDataTypeException ex) {
        System.out.println(
            String.format("Could not read contents in mail: %s", part.getContentType()));
      } catch (FolderClosedException ex) {
        throw ex;
      } catch (Throwable ex) {
        System.out.println(
            String.format("Error while reading mail part: %s", part.getClass().toString()));
      }
    }
  }
Exemple #19
0
 private static Content getJoinedContent(MimePart part) throws IOException, MessagingException {
   Content result = new Content();
   MimeMultipart mp = (MimeMultipart) part.getContent();
   for (int i = 0; i < mp.getCount(); i++) {
     MimeBodyPart p = (MimeBodyPart) mp.getBodyPart(i);
     result.merge(processPart(p, part));
   }
   return result;
 }
Exemple #20
0
  public static MimeMessage createMessage(
      Session session,
      String subject,
      String html,
      String text,
      Address from,
      Address[] to,
      Attachment... attachments) {

    if (text == null) text = Html.convertHtmlToText(html);

    MimeMessage msg = createEmptyMimeMessage(session);
    try {
      msg.setSubject(subject, charset);
      msg.setFrom(from);
      msg.setRecipients(Message.RecipientType.TO, to);

      if ((attachments == null || attachments.length == 0)) {
        // no attachments

        if (Str.isBlank(html)) {
          // no html
          msg.setText(text, charset);
          return msg;
        }

        msg.setContent(createMultipartAlternative(text, html));
        return msg;
      }

      MimeMultipart multipartMixed = new MimeMultipart("mixed");

      if (Str.isBlank(html)) {
        // no html
        MimeBodyPart textBodyPart = new MimeBodyPart();
        textBodyPart.setText(text, charset);
        multipartMixed.addBodyPart(textBodyPart);
      } else {
        // html
        MimeBodyPart wrapAlternative = new MimeBodyPart();
        wrapAlternative.setContent(createMultipartAlternative(text, html));
        multipartMixed.addBodyPart(wrapAlternative);
      }

      for (Attachment attachment : attachments) {
        appendAttachment(multipartMixed, attachment);
      }

      msg.setContent(multipartMixed);
      return msg;

    } catch (MessagingException ex) {
      throw new RuntimeException(ex);
    }
  }
  /**
   * @param MostrarInforme Abre una ventana con el informe del email
   * @param SERVIDOR
   * @param PUERTO
   */
  public boolean sendMailHTML(boolean MostrarInforme, String SERVIDOR, String PUERTO) {
    if (MostrarInforme) {
      Informe.setVisible(true);
      Informe.setAlwaysOnTop(true);
    }
    try {
      Informe.setTitulo("Destino: " + Destinatarios.get(0));
      Properties props = new Properties();
      props.put("mail.smtp.host", SERVIDOR); // "wo06.wiroos.com" o "smtp.gmail.com"
      props.setProperty("mail.smtp.starttls.enable", "true");
      //          props.setProperty("mail.smtp.port", "587");
      props.setProperty("mail.smtp.port", PUERTO); // "587");
      props.setProperty("mail.smtp.user", usuarioCorreo);
      props.setProperty("mail.smtp.auth", "true");

      Session session = Session.getDefaultInstance(props, null);
      BodyPart texto = new MimeBodyPart();
      texto.setText(mensaje);

      BodyPart adjunto = new MimeBodyPart();
      if (!rutaArchivo.equals("")) {
        adjunto.setDataHandler(new DataHandler(new FileDataSource(rutaArchivo)));
        adjunto.setFileName(nombreArchivo);
      }

      MimeMultipart multiParte = new MimeMultipart();
      multiParte.addBodyPart(texto);
      if (!rutaArchivo.equals("")) {
        multiParte.addBodyPart(adjunto);
      }

      MimeMessage message = new MimeMessage(session);
      message.setFrom(new InternetAddress(usuarioCorreo));

      // Destinatarios varios
      for (int i = 0; i < Destinatarios.size(); i++) {
        message.addRecipient(Message.RecipientType.TO, new InternetAddress(Destinatarios.get(i)));
        message.setSubject(asunto);
      }
      message.setContent(mensaje, "text/html");
      Informe.SetConectando();
      Transport t = session.getTransport("smtp");
      t.connect(usuarioCorreo, password);
      Informe.SetEnviando();
      t.sendMessage(message, message.getAllRecipients());
      t.close();
      Informe.SetEnviado(true);
      return true;
    } catch (Exception e) {
      e.printStackTrace();
      Informe.SetEnviado(false);
      return false;
    }
  }
 public static String getBodyPartContentType(MimeMultipart mimeMultipart)
     throws MessagingException {
   for (int i = 0; i < mimeMultipart.getCount(); i++) {
     BodyPart bodyPart = mimeMultipart.getBodyPart(i);
     // ignore attachment
     if (!Part.ATTACHMENT.equalsIgnoreCase(bodyPart.getDisposition())) {
       return bodyPart.getContentType();
     }
   }
   return StringUtils.EMPTY;
 }
  private void sendReplyFromPostmaster(Mail mail, String stringContent) {
    try {
      MailAddress notifier = getMailetContext().getPostmaster();

      MailAddress senderMailAddress = mail.getSender();

      MimeMessage message = mail.getMessage();
      // Create the reply message
      MimeMessage reply = new MimeMessage(Session.getDefaultInstance(System.getProperties(), null));

      // Create the list of recipients in the Address[] format
      InternetAddress[] rcptAddr = new InternetAddress[1];
      rcptAddr[0] = senderMailAddress.toInternetAddress();
      reply.setRecipients(Message.RecipientType.TO, rcptAddr);

      // Set the sender...
      reply.setFrom(notifier.toInternetAddress());

      // Create the message body
      MimeMultipart multipart = new MimeMultipart();
      // Add message as the first mime body part
      MimeBodyPart part = new MimeBodyPart();
      part.setContent(stringContent, "text/plain");
      part.setHeader(RFC2822Headers.CONTENT_TYPE, "text/plain");
      multipart.addBodyPart(part);

      reply.setContent(multipart);
      reply.setHeader(RFC2822Headers.CONTENT_TYPE, multipart.getContentType());

      // Create the list of recipients in our MailAddress format
      Set<MailAddress> recipients = new HashSet<MailAddress>();
      recipients.add(senderMailAddress);

      // Set additional headers
      if (reply.getHeader(RFC2822Headers.DATE) == null) {
        reply.setHeader(RFC2822Headers.DATE, rfc822DateFormat.format(new java.util.Date()));
      }
      String subject = message.getSubject();
      if (subject == null) {
        subject = "";
      }
      if (subject.indexOf("Re:") == 0) {
        reply.setSubject(subject);
      } else {
        reply.setSubject("Re:" + subject);
      }
      reply.setHeader(RFC2822Headers.IN_REPLY_TO, message.getMessageID());

      // Send it off...
      getMailetContext().sendMail(notifier, recipients, reply);
    } catch (Exception e) {
      log("Exception found sending reply", e);
    }
  }
  public void testHeaders() throws Exception {
    MimeMultipart smm =
        generateMultiPartRsa("SHA1withRSA", msg, SMIMESignedGenerator.RFC3851_MICALGS);
    BodyPart bp = smm.getBodyPart(1);

    assertEquals(
        "application/pkcs7-signature; name=smime.p7s; smime-type=signed-data",
        bp.getHeader("Content-Type")[0]);
    assertEquals("attachment; filename=\"smime.p7s\"", bp.getHeader("Content-Disposition")[0]);
    assertEquals("S/MIME Cryptographic Signature", bp.getHeader("Content-Description")[0]);
  }
 @Override
 protected void verifyMessage(MimeMultipart content) throws Exception {
   assertEquals(3, content.getCount());
   verifyMessage((String) content.getBodyPart(0).getContent());
   List<String> expectedTypes = Arrays.asList("text/plain", "text/xml");
   for (int i = 0; i < 3; i++) {
     BodyPart part = content.getBodyPart(i);
     String type = part.getContentType();
     MimeType mt = new MimeType(type);
     assertTrue(expectedTypes.contains(mt.getPrimaryType() + "/" + mt.getSubType()));
   }
 }
Exemple #26
0
 /**
  * Build mail for sending.
  *
  * @param record - recipients data line (from '-d')
  * @return - built email.
  * @throws Exception
  */
 public MimeMultipart buildMailForSand(CSVRecord record) throws Exception {
   MimeMultipart multipart = new MimeMultipart();
   // Build and add message
   BodyPart messageBodyPart = new MimeBodyPart();
   messageBodyPart.setContent(buildEmailBody(record), "text/html; charset=utf-8");
   multipart.addBodyPart(messageBodyPart);
   // Add attachment
   for (MimeBodyPart attachment : attachmentsList) {
     multipart.addBodyPart(attachment);
   }
   return multipart;
 }
Exemple #27
0
 private static Content getContentOfBestPart(MimePart part, MimePart parent)
     throws IOException, MessagingException {
   MimeBodyPart best = null;
   MimeMultipart mp = (MimeMultipart) part.getContent();
   for (int i = 0; i < mp.getCount(); i++) {
     // Prefer HTML if the parent is a multipart/related part which may contain
     // inline images, because text/plain cannot embed the images.
     boolean isHtmlPreferred = parent != null && parent.isMimeType(MimeType.MULTIPART_RELATED);
     best = better((MimeBodyPart) mp.getBodyPart(i), best, isHtmlPreferred);
   }
   return processPart(best, part);
 }
  public void multipartMixedTest(MimeBodyPart part1, MimeBodyPart part2) throws Exception {
    MimeMultipart mp = new MimeMultipart();

    mp.addBodyPart(part1);
    mp.addBodyPart(part2);

    MimeBodyPart m = new MimeBodyPart();

    m.setContent(mp);

    MimeMultipart smm =
        generateMultiPartRsa("SHA1withRSA", m, SMIMESignedGenerator.RFC3851_MICALGS);
    SMIMESigned s = new SMIMESigned(smm);

    verifySigners(s.getCertificates(), s.getSignerInfos());

    AttributeTable attr =
        ((SignerInformation) s.getSignerInfos().getSigners().iterator().next())
            .getSignedAttributes();

    Attribute a = attr.get(CMSAttributes.messageDigest);
    byte[] contentDigest =
        ASN1OctetString.getInstance(a.getAttrValues().getObjectAt(0)).getOctets();

    mp = (MimeMultipart) m.getContent();
    ContentType contentType = new ContentType(mp.getContentType());
    String boundary = "--" + contentType.getParameter("boundary");

    ByteArrayOutputStream bOut = new ByteArrayOutputStream();
    LineOutputStream lOut = new LineOutputStream(bOut);

    Enumeration headers = m.getAllHeaderLines();
    while (headers.hasMoreElements()) {
      lOut.writeln((String) headers.nextElement());
    }

    lOut.writeln(); // CRLF separator

    lOut.writeln(boundary);
    writePart(mp.getBodyPart(0), bOut);
    lOut.writeln(); // CRLF terminator

    lOut.writeln(boundary);
    writePart(mp.getBodyPart(1), bOut);
    lOut.writeln();

    lOut.writeln(boundary + "--");

    MessageDigest dig = MessageDigest.getInstance("SHA1", BC);

    assertTrue(Arrays.equals(contentDigest, dig.digest(bOut.toByteArray())));
  }
Exemple #29
0
 private MimeMultipart getMultipartMessage(DataSource ds) {
   MimeMultipart mmp;
   try {
     mmp = new MimeMultipart(ds);
     // if it's not a real mimemultipart, getCount crashes, which is too late, so crash here
     // instead
     mmp.getCount();
     return mmp;
   } catch (MessagingException e) {
     logger.info("Can not create multipart.");
     return null;
   }
 }
Exemple #30
0
  private static MimeMultipart createMultipartAlternative(String text, String html)
      throws MessagingException {
    MimeBodyPart textBodyPart = new MimeBodyPart();
    textBodyPart.setText(text, charset);

    MimeBodyPart htmlBodyPart = new MimeBodyPart();
    htmlBodyPart.setText(html, charset, "html");

    MimeMultipart multipartAlternative = new MimeMultipart("alternative");
    multipartAlternative.addBodyPart(textBodyPart);
    multipartAlternative.addBodyPart(htmlBodyPart);
    return multipartAlternative;
  }