Пример #1
0
// Send sends an email Message.
func (m *Mailer) Send(msg *email.Email) error {
	err := msg.Send(
		m.Address,
		m.Auth,
	)
	if err != nil {
		return errors.New("Error sending email: " + err.Error())
	}

	return nil
}
Пример #2
0
func NotifyEmail(cfg *Config, o *Object, r *Revision) error {
	var (
		e   *email.Email
		err error
	)

	// First version.
	if r.Version == 1 {
		e, err = newObjectEmail(cfg, o)
	} else {
		e, err = changedObjectEmail(cfg, o, r)
	}

	if err != nil {
		return err
	}

	q := bson.M{
		"subscribed": true,
	}

	p := bson.M{
		"email": 1,
	}

	var subs []*Subscriber

	if err = cfg.Mongo.Subscribers().Find(q).Select(p).All(&subs); err != nil {
		return err
	}

	// No subscribers.
	if len(subs) == 0 {
		return nil
	}

	e.From = cfg.SMTP.From
	e.To = make([]string, 1)

	for _, sub := range subs {
		e.To[0] = sub.Email

		if err = e.Send(cfg.SMTP.Addr(), cfg.SMTP.Auth()); err != nil {
			log.Printf("error sending email: %s", err)
		}
	}

	return nil
}
Пример #3
0
// SendEmail connects to an email server at host:port and sends an email from
// address from, to address to, with subject line subject with message body.
func SendEmail(username string, password string, host string, port int, to []string, subject string, body string) error {
	auth := smtp.PlainAuth("", username, password, host)
	addr := host + ":" + strconv.Itoa(port)

	message := email.Email{
		From:    username,
		To:      to,
		Subject: subject,
		Text:    []byte(body),
	}
	if err := message.Send(addr, auth); err != nil {
		return errors.Trace(err)
	}
	return nil
}
Пример #4
0
func processCampaign(c *models.Campaign) {
	Logger.Printf("Worker received: %s", c.Name)
	err := c.UpdateStatus(models.CAMPAIGN_IN_PROGRESS)
	if err != nil {
		Logger.Println(err)
	}
	e := email.Email{
		Subject: c.Template.Subject,
		From:    c.SMTP.FromAddress,
	}
	var auth smtp.Auth
	if c.SMTP.Username != "" && c.SMTP.Password != "" {
		auth = smtp.PlainAuth("", c.SMTP.Username, c.SMTP.Password, strings.Split(c.SMTP.Host, ":")[0])
	}
	f, err := mail.ParseAddress(c.SMTP.FromAddress)
	if err != nil {
		Logger.Println(err)
	}
	ft := f.Name
	if ft == "" {
		ft = f.Address
	}
	for _, t := range c.Results {
		td := struct {
			models.Result
			URL         string
			TrackingURL string
			Tracker     string
			From        string
		}{
			t,
			c.URL + "?rid=" + t.RId,
			c.URL + "/track?rid=" + t.RId,
			"<img src='" + c.URL + "/track?rid=" + t.RId + "'/>",
			ft,
		}
		// Parse the templates
		var subjBuff bytes.Buffer
		var htmlBuff bytes.Buffer
		var textBuff bytes.Buffer
		tmpl, err := template.New("html_template").Parse(c.Template.HTML)
		if err != nil {
			Logger.Println(err)
		}
		err = tmpl.Execute(&htmlBuff, td)
		if err != nil {
			Logger.Println(err)
		}
		e.HTML = htmlBuff.Bytes()
		tmpl, err = template.New("text_template").Parse(c.Template.Text)
		if err != nil {
			Logger.Println(err)
		}
		err = tmpl.Execute(&textBuff, td)
		if err != nil {
			Logger.Println(err)
		}
		e.Text = textBuff.Bytes()
		tmpl, err = template.New("text_template").Parse(c.Template.Subject)
		if err != nil {
			Logger.Println(err)
		}
		err = tmpl.Execute(&subjBuff, td)
		if err != nil {
			Logger.Println(err)
		}
		e.Subject = string(subjBuff.Bytes())
		Logger.Println("Creating email using template")
		e.To = []string{t.Email}
		Logger.Printf("Sending Email to %s\n", t.Email)
		err = e.Send(c.SMTP.Host, auth)
		if err != nil {
			Logger.Println(err)
			err = t.UpdateStatus(models.ERROR)
			if err != nil {
				Logger.Println(err)
			}
		} else {
			err = t.UpdateStatus(models.EVENT_SENT)
			if err != nil {
				Logger.Println(err)
			}
			err = c.AddEvent(models.Event{Email: t.Email, Message: models.EVENT_SENT})
			if err != nil {
				Logger.Println(err)
			}
		}
	}
	err = c.UpdateStatus(models.CAMPAIGN_EMAILS_SENT)
	if err != nil {
		Logger.Println(err)
	}
}
Пример #5
0
func SendTestEmail(s *models.SendTestEmailRequest) error {
	e := email.Email{
		Subject: s.Template.Subject,
		From:    s.SMTP.FromAddress,
	}
	var auth smtp.Auth
	if s.SMTP.Username != "" && s.SMTP.Password != "" {
		auth = smtp.PlainAuth("", s.SMTP.Username, s.SMTP.Password, strings.Split(s.SMTP.Host, ":")[0])
	}
	f, err := mail.ParseAddress(s.SMTP.FromAddress)
	if err != nil {
		Logger.Println(err)
		return err
	}
	ft := f.Name
	if ft == "" {
		ft = f.Address
	}
	Logger.Println("Creating email using template")
	// Parse the templates
	var subjBuff bytes.Buffer
	var htmlBuff bytes.Buffer
	var textBuff bytes.Buffer
	tmpl, err := template.New("html_template").Parse(s.Template.HTML)
	if err != nil {
		Logger.Println(err)
	}
	err = tmpl.Execute(&htmlBuff, s)
	if err != nil {
		Logger.Println(err)
	}
	e.HTML = htmlBuff.Bytes()
	tmpl, err = template.New("text_template").Parse(s.Template.Text)
	if err != nil {
		Logger.Println(err)
	}
	err = tmpl.Execute(&textBuff, s)
	if err != nil {
		Logger.Println(err)
	}
	e.Text = textBuff.Bytes()
	tmpl, err = template.New("text_template").Parse(s.Template.Subject)
	if err != nil {
		Logger.Println(err)
	}
	err = tmpl.Execute(&subjBuff, s)
	if err != nil {
		Logger.Println(err)
	}
	e.Subject = string(subjBuff.Bytes())
	e.To = []string{s.Email}
	Logger.Printf("Sending Email to %s\n", s.Email)
	err = e.Send(s.SMTP.Host, auth)
	if err != nil {
		Logger.Println(err)
		// For now, let's split the error and return
		// the last element (the most descriptive error message)
		serr := strings.Split(err.Error(), ":")
		return errors.New(serr[len(serr)-1])
	}
	return err
}
Пример #6
0
func processCampaign(c *models.Campaign) {
	Logger.Printf("Worker received: %s", c.Name)
	err := c.UpdateStatus(models.CAMPAIGN_IN_PROGRESS)
	if err != nil {
		Logger.Println(err)
	}
	e := email.Email{
		Subject: c.Template.Subject,
		From:    c.SMTP.FromAddress,
	}
	var auth smtp.Auth
	if c.SMTP.Username != "" && c.SMTP.Password != "" {
		auth = smtp.PlainAuth("", c.SMTP.Username, c.SMTP.Password, strings.Split(c.SMTP.Host, ":")[0])
	}
	ips, err := net.InterfaceAddrs()
	if err != nil {
		Logger.Println(err)
	}
	for _, i := range ips {
		Logger.Println(i.String())
	}
	for _, t := range c.Results {
		td := struct {
			models.Result
			URL         string
			Tracker     string
			TrackingURL string
		}{
			t,
			"http://" + ips[0].String() + "?rid=" + t.RId,
			"<img src='http://" + ips[0].String() + "/track?rid=" + t.RId + "'/>",
			"http://" + ips[0].String() + "/track?rid=" + t.RId,
		}
		// Parse the templates
		var subjBuff bytes.Buffer
		var htmlBuff bytes.Buffer
		var textBuff bytes.Buffer
		tmpl, err := template.New("html_template").Parse(c.Template.HTML)
		if err != nil {
			Logger.Println(err)
		}
		err = tmpl.Execute(&htmlBuff, td)
		if err != nil {
			Logger.Println(err)
		}
		e.HTML = htmlBuff.Bytes()
		tmpl, err = template.New("text_template").Parse(c.Template.Text)
		if err != nil {
			Logger.Println(err)
		}
		err = tmpl.Execute(&textBuff, td)
		if err != nil {
			Logger.Println(err)
		}
		e.Text = textBuff.Bytes()
		tmpl, err = template.New("text_template").Parse(c.Template.Subject)
		if err != nil {
			Logger.Println(err)
		}
		err = tmpl.Execute(&subjBuff, td)
		if err != nil {
			Logger.Println(err)
		}
		e.Subject = string(subjBuff.Bytes())
		Logger.Println("Creating email using template")
		e.To = []string{t.Email}
		Logger.Printf("Sending Email to %s\n", t.Email)
		err = e.Send(c.SMTP.Host, auth)
		if err != nil {
			Logger.Println(err)
			err = t.UpdateStatus("Error")
			if err != nil {
				Logger.Println(err)
			}
		} else {
			err = t.UpdateStatus(models.EVENT_SENT)
			if err != nil {
				Logger.Println(err)
			}
		}
		time.Sleep(1)
	}
}