public void postMail(String recipients[], String subject, String message, String from)
throws MessagingException {
boolean debug = false;
// Set the host smtp address
Properties props = new Properties();
props.put("mail.smtp.host", SMTP_HOST_NAME);
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.timeout", 60000);
Authenticator auth = new SMTPAuthenticator();
Session session = Session.getDefaultInstance(props, auth);
session.setDebug(debug);
// create a message
Message msg = new MimeMessage(session);
// set the from and to address
InternetAddress addressFrom = new InternetAddress(from);
msg.setFrom(addressFrom);
InternetAddress[] addressTo = new InternetAddress[recipients.length];
for (int i = 0; i < recipients.length; i++) {
addressTo[i] = new InternetAddress(recipients[i]);
}
msg.setRecipients(Message.RecipientType.TO, addressTo);
// Setting the Subject and Content Type
msg.setSubject(subject);
msg.setContent(message, "text/html");
Transport.send(msg);
}
public static void sfSendEmail(String subject, String message) throws Exception {
String SMTP_HOST_NAME = "smtp.gmail.com";
String SMTP_PORT = "465";
// message = "Test Email Notification From Monitor";
// subject = "Test Email Notification From Monitor";
String from = "*****@*****.**";
String[] recipients = {
"*****@*****.**", "*****@*****.**", "*****@*****.**"
};
String SSL_FACTORY = "javax.net.ssl.SSLSocketFactory";
// String[] recipients = { "*****@*****.**"};
// String[] recipients = { "*****@*****.**", "*****@*****.**",
// "*****@*****.**", "*****@*****.**", "*****@*****.**",
// "*****@*****.**", "*****@*****.**"};
// String[] recipients = {"*****@*****.**"};
Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());
boolean debug = true;
Properties props = new Properties();
props.put("mail.smtp.host", SMTP_HOST_NAME);
props.put("mail.smtp.auth", "true");
// props.put("mail.debug", "true");
props.put("mail.smtp.port", SMTP_PORT);
props.put("mail.smtp.socketFactory.port", SMTP_PORT);
props.put("mail.smtp.socketFactory.class", SSL_FACTORY);
props.put("mail.smtp.socketFactory.fallback", "false");
Session session =
Session.getDefaultInstance(
props,
new Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(
"*****@*****.**", "els102sensorweb");
}
});
// session.setDebug(debug);
Message msg = new MimeMessage(session);
InternetAddress addressFrom = new InternetAddress(from);
msg.setFrom(addressFrom);
InternetAddress[] addressTo = new InternetAddress[recipients.length];
for (int i = 0; i < recipients.length; i++) {
addressTo[i] = new InternetAddress(recipients[i]);
}
msg.setRecipients(Message.RecipientType.TO, addressTo);
// Setting the Subject and Content Type
msg.setSubject(subject);
msg.setContent(message, "text/plain");
Transport.send(msg);
System.out.println("Sucessfully Sent mail to All Users");
}
/** Returns the date the message was sent (or received if the sent date is null. */
public String getDate() throws MessagingException {
Date date;
SimpleDateFormat df = new SimpleDateFormat("EE M/d/yy");
if ((date = message.getSentDate()) != null) return (df.format(date));
else if ((date = message.getReceivedDate()) != null) return (df.format(date));
else return "";
}
// Prefered way of how it should be used.
public MailAgent(
String to,
String cc,
String bcc,
String from,
String subject,
String content,
String smtpHost)
throws FrameworkExecutionException {
try {
this.to = to;
this.cc = cc;
this.bcc = bcc;
this.from = from;
this.subject = subject;
this.content = content;
this.smtpHost = smtpHost;
message = createMessage();
message.setFrom(new InternetAddress(from));
setToCcBccRecipients();
message.setSentDate(new Date());
message.setSubject(subject);
message.setText(content);
} catch (AddressException ex) {
throw new FrameworkExecutionException(ex);
} catch (MessagingException ex) {
throw new FrameworkExecutionException(ex);
} finally {
}
}
/** Sends Emails to Customers who have not submitted their Bears */
public static void BearEmailSendMessage(String msgsubject, String msgText, String msgTo) {
try {
BearFrom = props.getProperty("BEARFROM");
// To = props.getProperty("TO");
SMTPHost = props.getProperty("SMTPHOST");
Properties mailprops = new Properties();
mailprops.put("mail.smtp.host", SMTPHost);
// create some properties and get the default Session
Session session = Session.getDefaultInstance(mailprops, null);
// create a message
Message msg = new MimeMessage(session);
// set the from
InternetAddress from = new InternetAddress(BearFrom);
msg.setFrom(from);
InternetAddress[] address = InternetAddress.parse(msgTo);
msg.setRecipients(Message.RecipientType.TO, address);
msg.setSubject(msgsubject);
msg.setContent(msgText, "text/plain");
Transport.send(msg);
} // end try
catch (MessagingException mex) {
USFEnv.getLog().writeCrit("Message not sent", null, null);
} catch (Exception ex) {
USFEnv.getLog().writeCrit("Message not sent", null, null);
}
} // end BearEmailSendMessage
/** Method for checking if the message has attachments. */
public boolean hasAttachments() throws java.io.IOException, MessagingException {
boolean hasAttachments = false;
if (message.isMimeType("multipart/*")) {
Multipart mp = (Multipart) message.getContent();
if (mp.getCount() > 1) hasAttachments = true;
}
return hasAttachments;
}
public static void main(String[] args) throws MessagingException, IOException {
IMAPFolder folder = null;
Store store = null;
String subject = null;
Flag flag = null;
try {
Properties props = System.getProperties();
props.setProperty("mail.store.protocol", "imaps");
props.setProperty("mail.imap.host", "imap.googlemail.com");
SimpleAuthenticator authenticator =
new SimpleAuthenticator("*****@*****.**", "hhy8611hhyy");
Session session = Session.getDefaultInstance(props, null);
// Session session = Session.getDefaultInstance(props, authenticator);
store = session.getStore("imaps");
// store.connect("imap.googlemail.com","*****@*****.**", "hhy8611hhyy");
// store.connect("imap.googlemail.com","*****@*****.**", "hhy8611hhyy");
store.connect("*****@*****.**", "hhy8611hhy");
// folder = (IMAPFolder) store.getFolder("[Gmail]/Spam"); // This doesn't work for other email
// account
folder = (IMAPFolder) store.getFolder("inbox"); // This works for both email account
if (!folder.isOpen()) folder.open(Folder.READ_WRITE);
Message[] messages = messages = folder.getMessages(150, 150); // folder.getMessages();
System.out.println("No of get Messages : " + messages.length);
System.out.println("No of Messages : " + folder.getMessageCount());
System.out.println("No of Unread Messages : " + folder.getUnreadMessageCount());
System.out.println("No of New Messages : " + folder.getNewMessageCount());
System.out.println(messages.length);
for (int i = 0; i < messages.length; i++) {
System.out.println(
"*****************************************************************************");
System.out.println("MESSAGE " + (i + 1) + ":");
Message msg = messages[i];
// System.out.println(msg.getMessageNumber());
// Object String;
// System.out.println(folder.getUID(msg)
subject = msg.getSubject();
System.out.println("Subject: " + subject);
System.out.println("From: " + msg.getFrom()[0]);
System.out.println("To: " + msg.getAllRecipients()[0]);
System.out.println("Date: " + msg.getReceivedDate());
System.out.println("Size: " + msg.getSize());
System.out.println(msg.getFlags());
System.out.println("Body: \n" + msg.getContent());
System.out.println(msg.getContentType());
}
} finally {
if (folder != null && folder.isOpen()) {
folder.close(true);
}
if (store != null) {
store.close();
}
}
}
@RequestMapping(method = RequestMethod.POST)
public ResponseEntity<String> sendNewPassword(@RequestBody String data)
throws UnsupportedEncodingException, JSONException {
JSONObject json = new JSONObject(data);
String email = (String) (json.get("email"));
List<User> users = userRepository.findByEmail(email);
if (users.size() > 0) {
User user = users.get(0);
String generatedString = UUID.randomUUID().toString().replaceAll("-", "");
user.setPassword(generatedString);
userRepository.save(user);
Properties props = new Properties();
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.smtp.host", "smtp.gmail.com");
props.put("mail.smtp.port", "587");
Session session =
Session.getInstance(
props,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication("perseuscontact", "PERSEUS1992");
}
});
try {
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress("*****@*****.**", "Perseus App"));
message.setRecipients(Message.RecipientType.TO, InternetAddress.parse(email));
message.setSubject("New password");
String text =
"Hello"
+ user.getName()
+ "!.<\br> Your new password is :<b>"
+ generatedString
+ "</b><br/>You can change the passsword again.";
message.setContent(text, "text/html; charset=utf-8");
Transport.send(message);
System.out.println(
"Message about new password sent to the user " + user.getEmail() + " - " + email);
} catch (MessagingException e) {
System.out.println("Error sending a 'user joined' message.");
throw new RuntimeException(e);
}
}
return new ResponseEntity<>(email, HttpStatus.CREATED);
}
/** Returns the body of the message (if it's plain text). */
public String getBody() throws MessagingException, java.io.IOException {
Object content = message.getContent();
if (message.isMimeType("text/plain")) {
return (String) content;
} else if (message.isMimeType("multipart/alternative")) {
Multipart mp = (Multipart) message.getContent();
int numParts = mp.getCount();
for (int i = 0; i < numParts; ++i) {
if (mp.getBodyPart(i).isMimeType("text/plain"))
return (String) mp.getBodyPart(i).getContent();
}
return "";
} else if (message.isMimeType("multipart/*")) {
Multipart mp = (Multipart) content;
if (mp.getBodyPart(0).isMimeType("text/plain"))
return (String) mp.getBodyPart(0).getContent();
else return "";
} else return "";
}
public static void sendSSLMessage(
String recipients[], String subject, String message, String from) throws MessagingException {
boolean debug = true;
/*Da errore ma non c'e' da preoccuparsi*/
Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());
Properties props = new Properties();
props.put("mail.smtp.host", SMTP_HOST_NAME);
props.put("mail.smtp.auth", "true");
props.put("mail.debug", "true");
props.put("mail.smtp.port", SMTP_PORT);
props.put("mail.smtp.socketFactory.port", SMTP_PORT);
props.put("mail.smtp.socketFactory.class", SSL_FACTORY);
props.put("mail.smtp.socketFactory.fallback", "false");
Session session =
Session.getDefaultInstance(
props,
new javax.mail.Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication("*****@*****.**", "magicrestaurant");
}
});
session.setDebug(debug);
Message msg = new MimeMessage(session);
InternetAddress addressFrom = new InternetAddress(from);
msg.setFrom(addressFrom);
InternetAddress[] addressTo = new InternetAddress[recipients.length];
for (int i = 0; i < recipients.length; i++) {
addressTo[i] = new InternetAddress(recipients[i]);
}
msg.setRecipients(Message.RecipientType.TO, addressTo);
// Setting the Subject and Content Type
msg.setSubject(subject);
msg.setContent(message, "text/plain");
Transport.send(msg);
}
private void setMessageRecipients(String recipient, Message.RecipientType recipientType)
throws FrameworkExecutionException {
InternetAddress[] addressArray = buildInternetAddressArray(recipient);
if ((addressArray != null) && (addressArray.length > 0)) {
try {
message.setRecipients(recipientType, addressArray);
} catch (MessagingException ex) {
throw new FrameworkExecutionException(ex);
}
}
}
public void collect(BufferedReader in, Message msg) throws MessagingException, IOException {
String line;
StringBuffer sb = new StringBuffer();
while ((line = in.readLine()) != null) {
sb.append(line);
sb.append("\n");
}
// If the desired charset is known, you can use
// setText(text, charset)
msg.setText(sb.toString());
}
public Object getValueAt(int row, int column) {
try {
Message message = getMessage(row);
switch (column) {
case 0:
// Answered?
return (message.isSet(Flags.Flag.ANSWERED) ? "R" : "");
case 1:
// From.
Address[] addresses = message.getFrom();
if (addresses == null || addresses.length == 0) {
return "(No sender)";
}
// Given "Personal Name <*****@*****.**>", choose "Personal Name" if it's available, and
// "*****@*****.**" if not.
InternetAddress address = (InternetAddress) addresses[0];
String name = address.getPersonal();
return (name != null) ? name : address.getAddress();
case 2:
// Subject.
String subject = message.getSubject();
return (subject != null) ? subject : "(No subject)";
case 3:
// Date.
Date date = message.getReceivedDate();
return (date != null) ? Mailer.dateToIsoString(date) : "Unknown";
default:
return "<no-column-" + column + ">";
}
} catch (MessagingException ex) {
ex.printStackTrace();
return "<error>";
}
}
public static void dumpEnvelope(Message m) throws Exception {
pr("This is the message envelope");
pr("---------------------------");
Address[] a;
// FROM
if ((a = m.getFrom()) != null) {
for (int j = 0; j < a.length; j++) pr("FROM: " + a[j].toString());
}
// TO
if ((a = m.getRecipients(Message.RecipientType.TO)) != null) {
for (int j = 0; j < a.length; j++) pr("TO: " + a[j].toString());
}
// SUBJECT
pr("SUBJECT: " + m.getSubject());
// DATE
Date d = m.getSentDate();
pr("SendDate: " + (d != null ? d.toString() : "UNKNOWN"));
// FLAGS
Flags flags = m.getFlags();
StringBuffer sb = new StringBuffer();
Flags.Flag[] sf = flags.getSystemFlags(); // get the system flags
boolean first = true;
for (int i = 0; i < sf.length; i++) {
String s;
Flags.Flag f = sf[i];
if (f == Flags.Flag.ANSWERED) s = "\\Answered";
else if (f == Flags.Flag.DELETED) s = "\\Deleted";
else if (f == Flags.Flag.DRAFT) s = "\\Draft";
else if (f == Flags.Flag.FLAGGED) s = "\\Flagged";
else if (f == Flags.Flag.RECENT) s = "\\Recent";
else if (f == Flags.Flag.SEEN) s = "\\Seen";
else continue; // skip it
if (first) first = false;
else sb.append(' ');
sb.append(s);
}
String[] uf = flags.getUserFlags(); // get the user flag strings
for (int i = 0; i < uf.length; i++) {
if (first) first = false;
else sb.append(' ');
sb.append(uf[i]);
}
pr("FLAGS: " + sb.toString());
// X-MAILER
String[] hdrs = m.getHeader("X-Mailer");
if (hdrs != null) pr("X-Mailer: " + hdrs[0]);
else pr("X-Mailer NOT available");
}
/** Method for checking if the message has the desired mime type. */
public boolean hasMimeType(String mimeType) throws MessagingException {
return message.isMimeType(mimeType);
}
public static void dumpPart(Part p) throws Exception {
if (p instanceof Message) {
Message m = (Message) p;
Address[] a;
// FROM
if ((a = m.getFrom()) != null) {
for (int j = 0; j < a.length; j++) System.out.println("FROM: " + a[j].toString());
}
// TO
if ((a = m.getRecipients(Message.RecipientType.TO)) != null) {
for (int j = 0; j < a.length; j++) System.out.println("TO: " + a[j].toString());
}
// SUBJECT
System.out.println("SUBJECT: " + m.getSubject());
// DATE
Date d = m.getSentDate();
System.out.println("SendDate: " + (d != null ? d.toLocaleString() : "UNKNOWN"));
// FLAGS:
Flags flags = m.getFlags();
StringBuffer sb = new StringBuffer();
Flags.Flag[] sf = flags.getSystemFlags(); // get the system flags
boolean first = true;
for (int i = 0; i < sf.length; i++) {
String s;
Flags.Flag f = sf[i];
if (f == Flags.Flag.ANSWERED) s = "\\Answered";
else if (f == Flags.Flag.DELETED) s = "\\Deleted";
else if (f == Flags.Flag.DRAFT) s = "\\Draft";
else if (f == Flags.Flag.FLAGGED) s = "\\Flagged";
else if (f == Flags.Flag.RECENT) s = "\\Recent";
else if (f == Flags.Flag.SEEN) s = "\\Seen";
else continue; // skip it
if (first) first = false;
else sb.append(' ');
sb.append(s);
}
String[] uf = flags.getUserFlags(); // get the user flag strings
for (int i = 0; i < uf.length; i++) {
if (first) first = false;
else sb.append(' ');
sb.append(uf[i]);
}
System.out.println("FLAGS = " + sb.toString());
}
System.out.println("CONTENT-TYPE: " + p.getContentType());
/* Dump input stream
InputStream is = ((MimeMessage)m).getInputStream();
int c;
while ((c = is.read()) != -1)
System.out.write(c);
*/
Object o = p.getContent();
if (o instanceof String) {
System.out.println("This is a String");
System.out.println((String) o);
} else if (o instanceof Multipart) {
System.out.println("This is a Multipart");
Multipart mp = (Multipart) o;
int count = mp.getCount();
for (int i = 0; i < count; i++) dumpPart(mp.getBodyPart(i));
} else if (o instanceof InputStream) {
System.out.println("This is just an input stream");
InputStream is = (InputStream) o;
int c;
while ((c = is.read()) != -1) System.out.write(c);
}
}
/** Returns the from field. */
public String getFrom() throws MessagingException {
return formatAddresses(message.getFrom());
}
/** Returns the address to reply to. */
public String getReplyTo() throws MessagingException {
Address[] a = message.getReplyTo();
if (a.length > 0) return ((InternetAddress) a[0]).getAddress();
else return "";
}
/** Returns the cc field. */
public String getCc() throws MessagingException {
return formatAddresses(message.getRecipients(Message.RecipientType.CC));
}
/** Returns the message number. */
public String getNum() {
return (Integer.toString(message.getMessageNumber()));
}
/** Method for checking if the message has a to field. */
public boolean hasTo() throws MessagingException {
return (message.getRecipients(Message.RecipientType.TO) != null);
}
/** Returns the sent date field. */
public String getSentDate() throws MessagingException {
if (hasSentDate()) return (message.getSentDate().toString());
else return "";
}
/** Method for checking if the message has a subject field. */
public boolean hasSubject() throws MessagingException {
return (message.getSubject() != null);
}
/** Method for checking if the message has a sent date field. */
public boolean hasSentDate() throws MessagingException {
return (message.getSentDate() != null);
}
/** Returns the subject field. */
public String getSubject() throws MessagingException {
if (hasSubject()) return message.getSubject();
else return "";
}
private void doit(String[] argv) {
String to = null,
subject = null,
from = null,
replyTo = null,
cc = null,
bcc = null,
url = null;
String mailhost = null;
String mailer = "MsgSend";
String protocol = null, host = null, user = null, password = null, record = null;
String filename = null, msg_text = null, inline_filename = null;
boolean debug = false;
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
int optind;
for (optind = 0; optind < argv.length; optind++) {
if (argv[optind].equals("-T")) {
protocol = argv[++optind];
} else if (argv[optind].equals("-X")) {
msg_text = argv[++optind];
} else if (argv[optind].equals("-H")) {
host = argv[++optind];
} else if (argv[optind].equals("-U")) {
user = argv[++optind];
} else if (argv[optind].equals("-P")) {
password = argv[++optind];
} else if (argv[optind].equals("-M")) {
mailhost = argv[++optind];
} else if (argv[optind].equals("-f")) {
filename = argv[++optind];
} else if (argv[optind].equals("-i")) {
inline_filename = argv[++optind];
} else if (argv[optind].equals("-s")) {
subject = argv[++optind];
} else if (argv[optind].equals("-o")) { // originator (from)
from = argv[++optind];
} else if (argv[optind].equals("-r")) { // reply-to
replyTo = argv[++optind];
} else if (argv[optind].equals("-c")) {
cc = argv[++optind];
} else if (argv[optind].equals("-b")) {
bcc = argv[++optind];
} else if (argv[optind].equals("-L")) {
url = argv[++optind];
} else if (argv[optind].equals("-d")) {
debug = true;
} else if (argv[optind].equals("--")) {
optind++;
break;
} else if (argv[optind].startsWith("-")) {
System.err.println(USAGE_TEXT);
System.exit(1);
} else {
break;
}
}
try {
if (optind < argv.length) {
// XXX - concatenate all remaining arguments
to = argv[optind];
System.out.println("To: " + to);
} else {
System.out.print("To: ");
System.out.flush();
to = in.readLine();
}
if (subject == null) {
System.out.print("Subject: ");
System.out.flush();
subject = in.readLine();
} else {
System.out.println("Subject: " + subject);
}
Properties props = System.getProperties();
// XXX - could use Session.getTransport() and Transport.connect()
// XXX - assume we're using SMTP
if (mailhost != null) props.put("mail.smtp.host", mailhost);
// Get a Session object
Session session = Session.getInstance(props, null);
if (debug) session.setDebug(true);
// construct the message
Message msg = new MimeMessage(session);
if (from != null) msg.setFrom(new InternetAddress(from));
else msg.setFrom();
if (reply_to_list == null && replyTo != null) {
reply_to_list = new InternetAddress[1];
reply_to_list[0] = new InternetAddress(replyTo);
msg.setReplyTo(reply_to_list);
} else msg.setReplyTo(reply_to_list);
if (dis_list == null) {
dis_list = new InternetAddress[1];
dis_list[0] = new InternetAddress(to);
}
msg.setRecipients(Message.RecipientType.TO, dis_list);
if (cc != null) msg.setRecipients(Message.RecipientType.CC, InternetAddress.parse(cc, false));
if (bcc != null)
msg.setRecipients(Message.RecipientType.BCC, InternetAddress.parse(bcc, false));
// in-line file contents if specified
if (inline_filename != null) {
msg_text = readFile(inline_filename);
}
// create and fill the first message part
MimeBodyPart mbp1 = new MimeBodyPart();
mbp1.setText(msg_text);
// create the Multipart and add the text part
Multipart mp = new MimeMultipart();
mp.addBodyPart(mbp1);
// create additional message part(s)
// attach the file or files to the message
if (filename != null) {
MimeBodyPart mbp = new MimeBodyPart();
FileDataSource fds = new FileDataSource(filename);
mbp.setDataHandler(new DataHandler(fds));
mbp.setFileName(fds.getName());
mp.addBodyPart(mbp);
mbp1.setText(msg_text + "\n\nAttachment: " + filename);
System.out.println("Added attachment: " + filename);
}
if (attachments != null) {
Iterator i = attachments.iterator();
StringBuffer list = null;
while (i.hasNext()) {
String name = (String) i.next();
MimeBodyPart mbp = new MimeBodyPart();
FileDataSource fds = new FileDataSource(name);
mbp.setDataHandler(new DataHandler(fds));
mbp.setFileName(fds.getName());
mp.addBodyPart(mbp);
if (list == null) {
list = new StringBuffer(name);
} else {
list.append(", " + name);
}
System.out.println("Added attachment: " + name);
mbp1.setText(msg_text + "\nAttachment(s): " + list);
}
}
// add the Multipart to the message
msg.setContent(mp);
msg.setSubject(subject);
// jgfrun collect(in, msg);
msg.setHeader("X-Mailer", mailer);
msg.setSentDate(new Date());
// send the thing off
Transport.send(msg);
System.out.println("Mail was sent successfully.");
// Keep a copy, if requested.
if (record != null) {
// Get a Store object
Store store = null;
if (url != null) {
URLName urln = new URLName(url);
store = session.getStore(urln);
store.connect();
} else {
if (protocol != null) store = session.getStore(protocol);
else store = session.getStore();
// Connect
if (host != null || user != null || password != null) store.connect(host, user, password);
else store.connect();
}
// Get record Folder. Create if it does not exist.
Folder folder = store.getFolder(record);
if (folder == null) {
System.err.println("Can't get record folder.");
System.exit(1);
}
if (!folder.exists()) folder.create(Folder.HOLDS_MESSAGES);
Message[] msgs = new Message[1];
msgs[0] = msg;
folder.appendMessages(msgs);
System.out.println("Mail was recorded successfully.");
}
} catch (Exception e) {
System.err.println("Could not MsgSend.doit");
e.printStackTrace();
}
} // doit
/** Method for checking if the message has a from field. */
public boolean hasFrom() throws MessagingException {
return (message.getFrom() != null);
}
/** Method for checking if the message has a received date field. */
public boolean hasReceivedDate() throws MessagingException {
return (message.getReceivedDate() != null);
}
public static void sendEmail(String subject, String message) throws Exception {
/*
String mailhost = "mail.vancouver.wsu.edu";
String cc = null;
String bcc = null;
boolean debug = false;
String file = null;
String mailer = "msgsend";
String sender = "mail.vancouver.wsu.edu";
Properties props = System.getProperties();
if (mailhost != null)
props.put("mail.smtp.host", mailhost);
// Get a Session object
Session session = Session.getInstance(props, null);
if (debug)
session.setDebug(true);
// construct the message
Message msg = new MimeMessage(session);
if (sender != null)
msg.setFrom(new InternetAddress(sender));
else
msg.setFrom();
msg.setRecipients(Message.RecipientType.TO,
InternetAddress.parse(receivers[0], false));
if (cc != null)
msg.setRecipients(Message.RecipientType.CC,
InternetAddress.parse(cc, false));
if (bcc != null)
msg.setRecipients(Message.RecipientType.BCC,
InternetAddress.parse(bcc, false));
msg.setSubject(subject);
String text = content;
if (file != null) {
// Attach the specified file.
// We need a multipart message to hold the attachment.
MimeBodyPart mbp1 = new MimeBodyPart();
mbp1.setText(text);
MimeBodyPart mbp2 = new MimeBodyPart();
mbp2.attachFile(file);
MimeMultipart mp = new MimeMultipart();
mp.addBodyPart(mbp1);
mp.addBodyPart(mbp2);
msg.setContent(mp);
} else {
// If the desired charset is known, you can use
// setText(text, charset)
msg.setText(text);
}
msg.setHeader("X-Mailer", mailer);
msg.setSentDate(new Date());
// send the thing off
Transport.send(msg);
System.out.println("\nMail was sent successfully.");
*/
// Xiaogang: checkbox
// System.out.println("sendemail"+MainFrame.EMAIL_ENABLE);
if (MainFrame.EMAIL_ENABLE == false) return;
String SMTP_HOST_NAME = "smtp.gmail.com";
String SMTP_PORT = "465";
// message = "Test Email Notification From Monitor";
// subject = "Test Email Notification From Monitor";
String from = "*****@*****.**";
String SSL_FACTORY = "javax.net.ssl.SSLSocketFactory";
String[] recipients = {
"*****@*****.**", "*****@*****.**", "*****@*****.**"
};
// String[] recipients = { "*****@*****.**"};
// String[] recipients = { , "*****@*****.**", "*****@*****.**",
// "*****@*****.**", "*****@*****.**"};
// String[] recipients = {"*****@*****.**"};
Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());
boolean debug = true;
Properties props = new Properties();
props.put("mail.smtp.host", SMTP_HOST_NAME);
props.put("mail.smtp.auth", "true");
// props.put("mail.debug", "true");
props.put("mail.smtp.port", SMTP_PORT);
props.put("mail.smtp.socketFactory.port", SMTP_PORT);
props.put("mail.smtp.socketFactory.class", SSL_FACTORY);
props.put("mail.smtp.socketFactory.fallback", "false");
Session session =
Session.getDefaultInstance(
props,
new Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(
"*****@*****.**", "els102sensorweb");
}
});
// session.setDebug(debug);
Message msg = new MimeMessage(session);
InternetAddress addressFrom = new InternetAddress(from);
msg.setFrom(addressFrom);
InternetAddress[] addressTo = new InternetAddress[recipients.length];
for (int i = 0; i < recipients.length; i++) {
addressTo[i] = new InternetAddress(recipients[i]);
}
msg.setRecipients(Message.RecipientType.TO, addressTo);
// Setting the Subject and Content Type
msg.setSubject(subject);
msg.setContent(message, "text/plain");
Transport.send(msg);
System.out.println("Sucessfully Sent mail to All Users");
}
