Example #1
0
func (mc *MailCon) SendMail(a smtp.Auth, from string, to []string, subject string,
	body string) (err error) {
	mc.mutex.Lock()
	defer mc.mutex.Unlock()
	// 1) Create new SMTP message and send it
	m := email.NewMessage(subject, body)
	m.From = from
	m.To = to
	if mc.conf.SkipCertificateVerification {
		err = mc.sendMailSkipCert(a, from, m.Tolist(), m.Bytes())
	} else {
		err = email.Send(fmt.Sprintf("%s:%d", mc.conf.SMTPAddress, mc.conf.SMTPPort), a, m)
	}
	// 2) If that worked well, add this mail to the 'Sent' folder of the users inbox
	if nil == err {
		// Todo: Think about having this in its own go-routine -> how to handle a possible error?
		_, err = mc.createMailInFolder_internal(&Header{
			Date:     time.Now(),
			Subject:  subject,
			Sender:   from,
			Receiver: strings.Join(to, ", "),
			Folder:   "Sent",
		}, &Flags{Seen: true}, body)
	}
	return err
}
Example #2
0
func main() {
	// compose the message
	if len(os.Args) < 5 {
		os.Stdout.WriteString("帮助说明:\n\tsendMail.exe [email protected] passwd smtp.hupu.net 25")
		return
	}

	fromTo := os.Args[1]
	m := email.NewMessage("Hi", "this is iMan test email.\n监控平台邮件服务器测试成功.")
	m.From = mail.Address{Name: "监控平台测试邮件", Address: fromTo}
	m.To = []string{fromTo}

	// // add attachments
	// if err := m.Attach("main.go"); err != nil {
	// 	log.Fatal(err)
	// }

	// send it
	passwd := os.Args[2]
	smtpConfig := os.Args[3]
	port := os.Args[4]

	// username := base64.StdEncoding.EncodeToString([]byte(fromTo))
	// passwd = base64.StdEncoding.EncodeToString([]byte(passwd))
	server := smtp.ServerInfo{TLS: false}
	auth := smtp.PlainAuth("LOGIN", fromTo, passwd, smtpConfig)
	auth.Start(&server)
	if err := email.Send(smtpConfig+":"+port, auth, m); err != nil {
		log.Fatal(err)
	}
	os.Stdout.WriteString("测试邮件发送成功!\n")
	for {
	}
}
Example #3
0
func detectedMotion(im *opencv.IplImage) {
	t := time.Now()
	d := t.Sub(lastNotified)
	if d < *notifyInterval {
		return
	}
	lastNotified = t

	log.Printf("Motion detected!")

	const tempFile = "/tmp/im.png"
	opencv.SaveImage(tempFile, im, 0)
	m := email.NewMessage("Motion detected", fmt.Sprintf("Motion detected at %v\n", t))
	m.From = *user + "@gmail.com"
	m.To = []string{*user + "@gmail.com"}
	err := m.Attach(tempFile)
	if err != nil {
		log.Printf("Couldn't attach image: %v\n", err)
	}
	err = email.Send("smtp.gmail.com:587",
		smtp.PlainAuth("", *user, *password, "smtp.gmail.com"),
		m)
	if err != nil {
		log.Printf("Couldn't send mail: %v\n", err)
		return
	}

	log.Printf("Sent email...\n")
}
Example #4
0
// take the post, lookup list members, send email
func GomezAlert(w http.ResponseWriter, req *http.Request) {
	name := req.URL.Query().Get(":name")
	body, err := ioutil.ReadAll(req.Body)
	ringring := "URL"

	// FIXME: remove once I can get POSTs from Gomez to work:
	email_subject := "alert from gomez"

	email_from := "FROM"
	smtp_server := "smtp.gmail.com:587"
	smtp_login := "******"
	smtp_passwd := "PASSWORD"
	smtp_host := "smtp.gmail.com"

	// get the response and error for the "smart contact" url for the list
	// FIXME: we should define a list of folks to get alerted in case this
	// call fails - we can send out the regular alert plus a note about not
	// being able to talk to ringring for the oncall list.
	resp, err := http.Get(ringring + name)

	// it looks like if you define something (for this example, err) and you do not use it in any
	// way, go will throw an error at compile time about it.
	// FIXME: we should log + move on rather than print to stdout and exit
	if err != nil {
		fmt.Printf("%s", err)
		os.Exit(1)
	} else {

		// setting defer on this closes out the connection automatically
		// if we didn't set this we would have to do this manually.
		defer resp.Body.Close()
		email_addresses, err := ioutil.ReadAll(resp.Body)

		// FIXME: we need to parse the XML in the body from Gomez

		// FIXME: we should log + move on rather than print to stdout and exit
		if err != nil {
			fmt.Printf("%s", err)
			os.Exit(1)
		}

		// send the email
		m := email.NewMessage(email_subject, string(body))
		m.From = email_from
		m.To = strings.Split(string(email_addresses), "\n")
		err = email.Send(smtp_server, smtp.PlainAuth("", smtp_login, smtp_passwd, smtp_host), m)

	}
}
func SendEmail(from string, password string, to string, title string, message string, attach_path string) {
	m := email.NewMessage(title, message)
	m.From = from
	m.To = []string{to}

	err := m.Attach(attach_path)
	if err != nil {
		panic(err)
	}

	err = email.Send("smtp.gmail.com:587", smtp.PlainAuth("", from, password, "smtp.gmail.com"), m)
	if err != nil {
		panic(err)
	}
}
Example #6
0
func main() {
	m := email.NewMessage("Hi", "测试邮件发送,时间、附件都已调通.")
	m.From = "*****@*****.**"
	m.To = []string{"*****@*****.**", "*****@*****.**"}
	// err := m.Attach(`C:\Users\Administrator\Desktop\4点起床:最养生和高效的时间管理.pdf`)
	// if err != nil {
	//     log.Println(err)
	// }
	err := email.Send("192.168.119.141:25", smtp.PlainAuth("", "*****@*****.**", "aptech", "192.168.119.141"), m)
	if err != nil {
		log.Fatal(err)
	} else {
		log.Println("邮件发送成功...")
	}
}
Example #7
0
func main() {
	mail := email.NewMessage(Conf.Subject, Conf.Text)
	mail.From = Conf.From
	mail.To = []string{Conf.To}

	if len(Conf.Attach) > 0 {
		files := getfiles(Conf.Attach)

		for i := 0; i < len(files); i++ {
			mail.Attach(files[i])
		}
	}

	err := email.Send(Conf.Server+":"+Conf.Port, smtp.PlainAuth("", Conf.User, Conf.Pass, Conf.Server), mail)
	checkerr(err, "message not send", "message send to:"+Conf.To+" files:"+strconv.Itoa(len(Conf.Attach)))
}
Example #8
0
func Example() {
	// compose the message
	m := email.NewMessage("Hi", "this is the body")
	m.From = mail.Address{Name: "From", Address: "*****@*****.**"}
	m.To = []string{"*****@*****.**"}

	// add attachments
	if err := m.Attach("email.go"); err != nil {
		log.Fatal(err)
	}

	// send it
	auth := smtp.PlainAuth("", "*****@*****.**", "pwd", "smtp.zoho.com")
	if err := email.Send("smtp.zoho.com:587", auth, m); err != nil {
		log.Fatal(err)
	}
}
Example #9
0
func (a *emailAction) Run(ev *Event, h *Handler) error {
	if h.Email.Address == "" {
		return ErrNotConfigured
	}

	template := h.Email.Subject
	if template == "" {
		template = defaultSubject
	}

	subject := fmt.Sprintf(template, ev.Name, ev.Service.Name, Hostname)
	body := fmt.Sprintf(`
Resorcerer has detected an noteworthy event.

Time: %s
Host: %s
Service: %s
Event: %s

Value: %v
`, time.Now(), Hostname, ev.Service.Name, ev.Name, ev.Value)

	m := email.NewMessage(subject, body)

	if a.settings.From == "" {
		m.From = defaultFrom
	} else {
		m.From = a.settings.From
	}

	m.To = strings.Split(h.Email.Address, ",")

	show("Sending email:\n%s", string(m.Bytes()))

	if DryRun {
		return nil
	}

	host, _, _ := net.SplitHostPort(a.settings.Server)

	auth := smtp.PlainAuth("", a.settings.Username, a.settings.Password, host)
	return email.Send(a.settings.Server, auth, m)
}
Example #10
0
func handle(w http.ResponseWriter, r *http.Request) {

	folderPath, _ := osext.ExecutableFolder()

	/*
	   Preparing Logging
	*/
	log := l4g.NewLogger()
	flw := l4g.NewFileLogWriter(folderPath+LogFileName, false)
	clw := l4g.NewConsoleLogWriter()

	flw.SetFormat("[%D %T] [%L] (%S) %M")
	log.AddFilter("file", l4g.FINE, flw)
	log.AddFilter("stdout", l4g.FINE, clw)

	var items []LogRecord

	/*
	   Error cecking, data validation
	*/
	if r.Method != "POST" {
		w.WriteHeader(http.StatusMethodNotAllowed)
		fmt.Fprintf(w, "%s", "Cotnact admin!\n")
		log.Error("Method Not Allowed: %s", r.Method)
		return
	}

	if r.ParseForm() != nil {
		w.WriteHeader(http.StatusBadRequest)
		fmt.Fprintf(w, "%s", "Cotnact admin!\n")
		log.Error("Parse POST data failed!")
		return
	}

	if r.FormValue("postdata") == "" {
		w.WriteHeader(http.StatusExpectationFailed)
		fmt.Fprintf(w, "%s", "POST Data missing!\n")
		log.Error("POST Data missing")
		return
	}

	/*
	   Deciding file name
	*/
	const timeformat = "2006-01-02_15-04-05"
	var filename = time.Now().Format(timeformat) + ".log"
	if r.FormValue("username") != "" {
		filename = r.FormValue("username") + "_" + time.Now().Format(timeformat) + ".log"
	}

	/*
	   Json Parsing and data validation
	*/
	json.Unmarshal([]byte(r.FormValue("postdata")), &items)
	if len(items) == 0 {
		w.WriteHeader(http.StatusExpectationFailed)
		log.Error("Possible Json Parse Error: Nr of items: %d ", len(items))
		fmt.Fprintf(w, "Possible Json Parse Error: Nr of items: %d ", len(items))
		return
	}

	filebuffer := ""
	for _, item := range items {
		b, err := json.Marshal(item)
		if err != nil {
			log.Error("Json Parse Error: %s ", err)
		}
		filebuffer += string(b) + "\n"
	}

	log.Info("writing %d items to %s", len(items), filename)

	/*
	   File Creation
	*/
	f, err := os.Create(os.Args[2] + filename)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		log.Error("File create error (%s): %s ", filename, err)
		return

	}
	/*
	   File Write
	*/
	_, err = io.WriteString(f, filebuffer)
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		log.Error("File write error (%s): %s ", filename, err)
		return

	}
	f.Close()

	m := email.NewMessage("Socialeyes feedback", "The feedback file is attached!")
	m.From = "*****@*****.**"
	m.To = []string{"*****@*****.**", "*****@*****.**"}
	error := m.Attach(os.Args[2] + filename)
	if error != nil {
		log.Info("Successfully sent notification mail.")
	}

	error = email.Send("smtp.gmail.com:587", smtp.PlainAuth("", "*****@*****.**", "<password>", "smtp.gmail.com"), m)

	fmt.Fprintf(w, "%s", filename)
	log.Info("Successfully wrote data to: " + filename)
	log.Close()
}