// Send an email using the given host and SMTP auth (optional), returns any error thrown by smtp.SendMail
// This function merges the To, Cc, and Bcc fields and calls the smtp.SendMail function using the Email.Bytes() output as the message
func (e *Email) Send(addr string, a smtp.Auth) error {
// Merge the To, Cc, and Bcc fields
to := make([]string, 0, len(e.To)+len(e.Cc)+len(e.Bcc))
to = append(append(append(to, e.To...), e.Cc...), e.Bcc...)
for i := 0; i < len(to); i++ {
addr, err := mail.ParseAddress(to[i])
if err != nil {
return err
}
to[i] = addr.Address
}
// Check to make sure there is at least one recipient and one "From" address
if e.From == "" || len(to) == 0 {
return errors.New("Must specify at least one From address and one To address")
}
from, err := mail.ParseAddress(e.From)
if err != nil {
return err
}
raw, err := e.Bytes()
if err != nil {
return err
}
return smtp.SendMail(addr, a, from.Address, to, raw)
}
func sendMail(from, to, subject, htmlContent string, mailer *mail.Mailer,
debug bool, success chan *email.Email, fail chan error) {
parsedSender, err := stdMail.ParseAddress(from)
if err != nil {
fail <- err
return
}
parsedTo, err := stdMail.ParseAddress(to)
if err != nil {
fail <- err
return
}
message, err := mail.NewMessage(
parsedSender,
parsedTo,
subject,
htmlContent,
)
if err != nil {
fail <- err
return
}
if err := mailer.Send(message); err != nil {
fail <- err
return
}
success <- message
}
func testValidate(t *testing.T, s *Service) {
// Valid
userEmail, pwd, err := getUserCreds(t)
if e(t, err) {
return
}
eml, err := mail.ParseAddress(userEmail)
if e(t, err) {
return
}
valid, err := s.Validate(*eml, pwd)
if e(t, err) {
return
}
if !valid {
t.Errorf("expected Validate to return true but returned %t", valid)
}
// Invalid
eml, err = mail.ParseAddress("*****@*****.**")
if e(t, err) {
return
}
valid, err = s.Validate(*eml, "invalidpassword")
if e(t, err) {
return
}
if valid {
t.Errorf("expected Validate to return false but returned %t", valid)
}
}
func (s *EmailServer) dispatchMessage(m *Message) error {
var e email.Email
//err := ds.LoadStruct(&e, []byte(m.Data))
err := ds.Load(&e, []byte(m.Data))
if err != nil {
return err
}
// Merge the To, Cc, and Bcc fields
to := make([]string, 0, len(e.To)+len(e.Cc)+len(e.Bcc))
to = append(append(append(to, e.To...), e.Cc...), e.Bcc...)
for i := 0; i < len(to); i++ {
addr, err := mail.ParseAddress(to[i])
if err != nil {
return err
}
to[i] = addr.Address
}
// Check to make sure there is at least one recipient and one "From" address
if e.From == "" || len(to) == 0 {
return errors.New("Must specify at least one From address and one To address")
}
from, err := mail.ParseAddress(e.From)
if err != nil {
return err
}
raw, err := e.Bytes()
if err != nil {
return err
}
return smtp.SendMail(s.address, s.auth, from.Address, to, raw)
}
func testAccountAvailabilityCheck(t *testing.T, s *Service) {
// Available
eml, err := mail.ParseAddress("*****@*****.**")
if e(t, err) {
return
}
avail, err := s.AccountAvailabilityCheck(*eml)
if e(t, err) {
return
}
if !avail {
t.Errorf("expected AccountAvailabilityCheck to return true but returned %t", avail)
}
// UnAvailable
userEmail, _, err := getUserCreds(t)
if e(t, err) {
return
}
eml, err = mail.ParseAddress(userEmail)
if e(t, err) {
return
}
avail, err = s.AccountAvailabilityCheck(*eml)
if e(t, err) {
return
}
if avail {
t.Errorf("expected AccountAvailabilityCheck to return false but returned %t", avail)
return
}
}
// NewMailAuthHook creates a hook to be added to an instance of logger.
func NewMailAuthHook(appname string, host string, port int, from string, to string, username string, password string) (*MailAuthHook, error) {
// Check if server listens on that port.
conn, err := net.DialTimeout("tcp", host+":"+strconv.Itoa(port), 3*time.Second)
if err != nil {
return nil, err
} else {
defer conn.Close()
}
// Validate sender and recipient
sender, err := mail.ParseAddress(from)
if err != nil {
return nil, err
}
receiver, err := mail.ParseAddress(to)
if err != nil {
return nil, err
}
return &MailAuthHook{
AppName: appname,
Host: host,
Port: port,
From: sender,
To: receiver,
Username: username,
Password: password}, nil
}
func sendMail(recipient Recipient, emailField string, mailer *mail.Mailer,
success chan Recipient, fail chan error) {
parsedSender, err := stdMail.ParseAddress(sender)
if err != nil {
fail <- err
return
}
parsedTo, err := stdMail.ParseAddress(recipient[emailField])
if err != nil {
fail <- err
return
}
message, err := mail.NewMessage(
parsedSender,
parsedTo,
subject,
textTemplatePath,
htmlTemplatePath,
recipient,
)
if err != nil {
fail <- err
return
}
if err := mailer.Send(message); err != nil {
fail <- err
return
}
success <- recipient
}
// NewMailHook creates a hook to be added to an instance of logger.
func NewMailHook(appname string, host string, port int, from string, to string) (*MailHook, error) {
// Connect to the remote SMTP server.
c, err := smtp.Dial(host + ":" + strconv.Itoa(port))
if err != nil {
return nil, err
}
// Validate sender and recipient
sender, err := mail.ParseAddress(from)
if err != nil {
return nil, err
}
recipient, err := mail.ParseAddress(to)
if err != nil {
return nil, err
}
// Set the sender and recipient.
if err := c.Mail(sender.Address); err != nil {
return nil, err
}
if err := c.Rcpt(recipient.Address); err != nil {
return nil, err
}
return &MailHook{
AppName: appname,
c: c,
}, nil
}
func sendEmail(headers map[string]string, body string, address string, gConfig map[string]string) {
host := gConfig["REMOTE_SMTP_HOST"]
port := gConfig["REMOTE_SMTP_PORT"]
user := gConfig["REMOTE_SMTP_USER"]
password := gConfig["REMOTE_SMTP_PASS"]
m := email.NewMessage(headers["Subject"], body)
fromAddress := "Unknown"
fromHeader, ok := headers["From"]
if ok {
from, _ := mail.ParseAddress(fromHeader)
fromAddress = from.Address
}
to, _ := mail.ParseAddress(address)
toAddress := to.Address
m.From = fromAddress
m.To = []string{toAddress}
if gConfig["PGP_ATTACH_BODY"] == "Y" {
m.AttachData("message.asc", []byte(body))
}
err := email.Send(host+":"+port, smtp.PlainAuth("", user, password, host), m)
logging.CheckFatal(err)
}
func (p *Post) Validate() error {
if p.Replyto != "" {
t := ""
if !strings.Contains(p.Replyto, "<") || !strings.Contains(p.Replyto, ">") {
t = p.Replyto + " <" + p.Replyto + ">"
}
a, err := mail.ParseAddress(t)
if err != nil {
return err
}
p.Replyto = a.Address
}
if len(p.CC) > 0 {
for k, v := range p.CC {
t := ""
if !strings.Contains(v, "<") || !strings.Contains(v, ">") {
t = v + " <" + v + ">"
}
a, err := mail.ParseAddress(t)
if err != nil {
return err
}
p.CC[k] = a.Address
}
}
return nil
}
// NewSESHook creates a hook to be added to an instance of logger.
func NewSESHook(appName string, level log.Level) (*SESHook, error) {
// Validate sender and recipient
sender, err := mail.ParseAddress(getFrom())
if err != nil {
return nil, err
}
receiver, err := mail.ParseAddress(getTo())
if err != nil {
return nil, err
}
// Get SES specific username and password
username := getUsername()
if len(username) == 0 {
return nil, errors.New("SES_ACCESS_KEY_ID not set.")
}
password := getPassword()
if len(password) == 0 {
return nil, errors.New("SES_SECRET_ACCESS_KEY not set.")
}
return &SESHook{
AppName: appName,
From: sender,
To: receiver,
Auth: smtp.PlainAuth("", username, password, SESServer),
Level: level,
}, nil
}
func (s *SMTPDeliverer) Deliver(ctx scope.Context, ref *EmailRef) error {
// Connect and authenticate to SMTP server.
c, err := smtp.Dial(s.addr)
if err != nil {
return fmt.Errorf("%s: dial error: %s", s, err)
}
defer c.Quit()
if err := c.Hello(s.localName); err != nil {
return fmt.Errorf("%s: ehlo error: %s", s, err)
}
if s.tlsConfig != nil {
if err := c.StartTLS(s.tlsConfig); err != nil {
return fmt.Errorf("%s: starttls error: %s", s, err)
}
}
if s.auth != nil {
if err := c.Auth(s.auth); err != nil {
return fmt.Errorf("%s: auth error: %s", s, err)
}
}
// Send email.
if ref.SendFrom == "" {
ref.SendFrom = "noreply@" + s.localName
}
sendFrom, err := mail.ParseAddress(ref.SendFrom)
if err != nil {
return fmt.Errorf("%s: from address error: %s", s, err)
}
if err := c.Mail(sendFrom.Address); err != nil {
return fmt.Errorf("%s: mail error: %s", s, err)
}
sendTo, err := mail.ParseAddress(ref.SendTo)
if err != nil {
return fmt.Errorf("%s: to address error: %s", s, err)
}
if err := c.Rcpt(sendTo.Address); err != nil {
return fmt.Errorf("%s: rcpt error: %s", s, err)
}
wc, err := c.Data()
if err != nil {
return fmt.Errorf("%s: data error: %s", s, err)
}
if _, err := wc.Write(ref.Message); err != nil {
return fmt.Errorf("%s: write error: %s", s, err)
}
if err := wc.Close(); err != nil {
return fmt.Errorf("%s: close error: %s", s, err)
}
ref.Delivered = time.Now()
return nil
}
// Dequeue returns jobs from the queue. It maps hosts to the packages
// that need to be delivered to them. If anything goes wrong, Dequeue
// returns an error. Dequeue will never return more hosts than the
// current MaxHostsPerDequeue value.
func (mb mailBox) Dequeue() (map[string]Package, error) {
rows, err := mb.dequeueStmt.Query(MaxHostsPerDequeue)
if err != nil {
return nil, err
}
defer rows.Close()
jobs := make(map[string]Package)
cache := make(map[uint64]*Message)
for rows.Next() {
var row struct {
User, Host string
Date pq.NullTime
Attempts int
MID uint64
MRaw, MFrom string
}
err := rows.Scan(&row.Host, &row.MID, &row.User, &row.Date,
&row.Attempts, &row.MRaw, &row.MFrom)
if err != nil {
return jobs, err
}
if jobs[row.Host] == nil {
jobs[row.Host] = make(Package)
}
msg, ok := cache[row.MID]
if !ok {
msg = &Message{
ID: row.MID,
Raw: row.MRaw,
}
addr, err := mail.ParseAddress(row.MFrom)
if err != nil {
return nil, err
}
msg.SetFrom(addr)
cache[row.MID] = msg
}
if jobs[row.Host][msg] == nil {
jobs[row.Host][msg] = make([]*mail.Address, 0, 1)
}
dest, err := mail.ParseAddress(row.User + "@" + row.Host)
if err != nil {
return nil, err
}
jobs[row.Host][msg] = append(jobs[row.Host][msg], dest)
}
return jobs, nil
}
func insertTargetIntoGroup(t Target, gid int64) error {
if _, err = mail.ParseAddress(t.Email); err != nil {
Logger.Printf("Invalid email %s\n", t.Email)
return err
}
trans := db.Begin()
trans.Where(t).FirstOrCreate(&t)
if err != nil {
Logger.Printf("Error adding target: %s\n", t.Email)
return err
}
err = trans.Where("group_id=? and target_id=?", gid, t.Id).Find(&GroupTarget{}).Error
if err == gorm.RecordNotFound {
err = trans.Save(&GroupTarget{GroupId: gid, TargetId: t.Id}).Error
if err != nil {
Logger.Println(err)
return err
}
}
if err != nil {
Logger.Printf("Error adding many-many mapping for %s\n", t.Email)
return err
}
err = trans.Commit().Error
if err != nil {
Logger.Printf("Error committing db changes\n")
return err
}
return nil
}
// LoadConfig will try to search around for the corresponding config file.
// It will search /tmp/fileName then attempt ./config/fileName,
// then ../config/fileName and last it will look at fileName
func LoadConfig(fileName string) {
fileName = findConfigFile(fileName)
l4g.Info("Loading config file at " + fileName)
file, err := os.Open(fileName)
if err != nil {
panic("Error opening config file=" + fileName + ", err=" + err.Error())
}
decoder := json.NewDecoder(file)
config := Config{}
err = decoder.Decode(&config)
if err != nil {
panic("Error decoding configuration " + err.Error())
}
// Check for a valid email for feedback, if not then do feedback@domain
if _, err := mail.ParseAddress(config.EmailSettings.FeedbackEmail); err != nil {
config.EmailSettings.FeedbackEmail = "feedback@localhost"
l4g.Error("Misconfigured feedback email setting: %s", config.EmailSettings.FeedbackEmail)
}
configureLog(config.LogSettings)
Cfg = &config
SanitizeOptions = getSanitizeOptions()
// Validates our mail settings
if err := CheckMailSettings(); err != nil {
l4g.Error("Email settings are not valid err=%v", err)
}
}
func (e *Email) From() (*EmailAddr, error) {
mailAddr, err := mail.ParseAddress(e.msg.Header.Get("From"))
if err != nil {
return nil, err
}
return NewEmailAddr(mailAddr.Address), nil
}
// SetMandrill sets the Mandrill API for sending emails. This function is not
// recursive and returns nil. @todo
func SetMandrill(opts ...MandrillOptions) DaemonOption {
return func(da *Daemon) DaemonOption {
// this whole func is just a quick write down. no idea if it's working
// and refactor ... 8-)
apiKey := da.Config.GetString(config.ScopeStore(da.ScopeID), config.Path(PathSmtpMandrillAPIKey))
if apiKey == "" {
da.lastErrs = append(da.lastErrs, errors.New("Mandrill API Key is empty."))
return nil
}
md, err := gochimp.NewMandrill(apiKey)
if err != nil {
da.lastErrs = append(da.lastErrs, err)
return nil
}
for _, o := range opts {
o(md)
}
da.sendFunc = func(from string, to []string, msg io.WriterTo) error {
// @todo figure out if "to" contains To, CC and BCC addresses.
addr, err := mail.ParseAddress(from)
if err != nil {
return log.Error("mail.daemon.Mandrill.ParseAddress", "err", err, "from", from, "to", to)
}
r := gochimp.Recipient{
Name: addr.Name,
Email: addr.Address,
}
var buf bytes.Buffer
if _, err := msg.WriteTo(&buf); err != nil {
return log.Error("mail.daemon.Mandrill.MessageWriteTo", "err", err, "from", from, "to", to, "msg", buf.String())
}
resp, err := md.MessageSendRaw(buf.String(), to, r, false)
if err != nil {
return log.Error("mail.daemon.Mandrill.MessageSendRaw", "err", err, "from", from, "to", to, "msg", buf.String())
}
if log.IsDebug() {
log.Debug("mail.daemon.Mandrill.MessageSendRaw", "resp", resp, "from", from, "to", to, "msg", buf.String())
}
// The last arg in MessageSendRaw means async in the Mandrill API:
// Async: enable a background sending mode that is optimized for bulk sending.
// In async mode, messages/send will immediately return a status of "queued"
// for every recipient. To handle rejections when sending in async mode, set
// up a webhook for the 'reject' event. Defaults to false for messages with
// no more than 10 recipients; messages with more than 10 recipients are
// always sent asynchronously, regardless of the value of async.
return nil
}
da.dialer = nil
return nil
}
}
// RFC 2821 4.1.1.3 RECIPIENT (RCPT)
func cmdRCPT(ctx *transaction, param string) error {
switch {
case ctx.Mode == stateHELO:
return ctx.notify(reply{503, "5.5.1 Say HELO/EHLO first."})
case ctx.Mode == stateMAIL:
return ctx.notify(reply{503, "5.5.1 Error: need MAIL command"})
case !strings.HasPrefix(strings.ToUpper(param), "TO:"):
return ctx.notify(reply{501, "5.5.4 Syntax: RCPT TO:<address>"})
}
addr, err := mail.ParseAddress(param[len("TO:"):])
if err != nil {
return ctx.notify(reply{501, "5.1.7 Bad recipient address syntax"})
}
switch ctx.host.query(addr) {
case mailbox.QueryNotFound:
return ctx.notify(reply{550, "5.1.1 No such user here."})
case mailbox.QueryNotLocal:
if flags := ctx.host.settings(); !flags.Has("relay") {
return ctx.notify(reply{550, "5.1.1 No such user here."})
}
ctx.Message.AddOutbound(addr)
ctx.Mode = stateDATA
return ctx.notify(reply{251, "User not local; will forward to <forward-path>"})
case mailbox.QuerySuccess:
ctx.Message.AddInbound(addr)
ctx.Mode = stateDATA
return ctx.notify(reply{250, "2.1.5 Ok"})
}
return ctx.notify(replyErrorProcessing)
}
func SMSHandler(w http.ResponseWriter, r *http.Request) {
sms := r.URL.Query().Get("Body")
sms = strings.Trim(sms, "8575-2838")
if sms == "" {
log.Println("Blank body.")
SendSMS(w, r, "Please send a text with: \"Name\" \"email@address\"")
return
}
info := strings.Fields(sms)
name := strings.Join(info[:len(info)-1], " ")
email := info[len(info)-1]
name = strings.Trim(name, "\"")
if name == "" {
log.Println("Blank name.")
SendSMS(w, r, "Please send a text with: \"Name\" \"email@address\"")
return
}
email = strings.Trim(email, "\"")
address := fmt.Sprintf("%s <%s>", name, email)
_, err := mail.ParseAddress(address)
if err != nil {
SendSMS(w, r, "Please try again with a valid email address.")
return
}
signup := Signup{Name: name, Email: email, Raw: sms, Timestamp: time.Now()}
log.Println(signup)
c := mgoSession.DB("sms_signup").C("signups")
err = c.Insert(signup)
if err != nil {
log.Println(err.Error())
}
SendSMS(w, r, fmt.Sprintf("Thanks for signing up, %s!", info[0]))
}
// parseAddress parses a single RFC 5322 address and returns the
// e-mail address portion.
// e.g. "Barry Gibbs <*****@*****.**>" would return "*****@*****.**".
func parseAddress(address string) (string, error) {
a, err := mail.ParseAddress(address)
if err != nil {
return "", err
}
return a.Address, err
}
func getEmail(interactor interaction.Interactor) (string, error) {
for {
res, err := interactor.Prompt(&interaction.Challenge{
Title: "E. Mail Address Required",
ResponseType: interaction.RTLineString,
Prompt: "E. mail address: ",
Body: `Please enter an e. mail address where you can be reached. Although entering an e. mail address is optional, it is highly recommended.`,
UniqueID: "acme-enter-email",
})
if err != nil {
return "", err
}
if res.Value == "" {
return "", nil
}
if res.Cancelled {
return "-", nil
}
addr, err := mail.ParseAddress(res.Value)
if err != nil {
continue
}
return addr.Address, nil
}
}
func validateEmail(address string, resolver bdns.DNSResolver) (prob *probs.ProblemDetails) {
_, err := mail.ParseAddress(address)
if err != nil {
return &probs.ProblemDetails{
Type: probs.InvalidEmailProblem,
Detail: unparseableEmailDetail,
}
}
splitEmail := strings.SplitN(address, "@", -1)
domain := strings.ToLower(splitEmail[len(splitEmail)-1])
var resultMX []string
var resultA []net.IP
resultMX, err = resolver.LookupMX(domain)
if err == nil && len(resultMX) == 0 {
resultA, err = resolver.LookupHost(domain)
if err == nil && len(resultA) == 0 {
return &probs.ProblemDetails{
Type: probs.InvalidEmailProblem,
Detail: emptyDNSResponseDetail,
}
}
}
if err != nil {
dnsProblem := bdns.ProblemDetailsFromDNSError(err)
return &probs.ProblemDetails{
Type: probs.InvalidEmailProblem,
Detail: dnsProblem.Detail,
}
}
return nil
}
// Send will send out the mail
func (e *Email) Send() error {
if e.Auth == nil {
e.Auth = smtp.PlainAuth(e.Identity, e.Username, e.Password, e.Host)
}
// Merge the To, Cc, and Bcc fields
to := make([]string, 0, len(e.To)+len(e.Cc)+len(e.Bcc))
to = append(append(append(to, e.To...), e.Cc...), e.Bcc...)
// Check to make sure there is at least one recipient and one "From" address
if len(to) == 0 {
return errors.New("Must specify at least one To address")
}
from, err := mail.ParseAddress(e.Username)
if err != nil {
return err
}
if len(e.From) == 0 {
e.From = e.Username
}
// use mail's RFC 2047 to encode any string
e.Subject = qEncode("utf-8", e.Subject)
raw, err := e.Bytes()
if err != nil {
return err
}
return smtp.SendMail(e.Host+":"+strconv.Itoa(e.Port), e.Auth, from.Address, to, raw)
}
func (validator *Validator) Validate(user *User) (models.ValidationErrors, error) {
errs := make(models.ValidationErrors)
if user.Username == "" {
errs.Add("Username", "Username must be provided.")
}
if user.HashedPassword == "" {
errs.Add("Password", "Password must be provided.")
}
if user.Email == "" {
errs.Add("Email", "Email must be provided.")
} else if _, err := mail.ParseAddress(user.Email); err != nil {
errs.Add("Email", "Invalid email address.")
}
savedUser, err := validator.Dao.GetByUsername(user.Username)
if err != nil {
return nil, err
}
if savedUser != nil && savedUser.ID != user.ID {
errs.Add("Username", "A user with this username already exists.")
}
return errs, nil
}
func (r registrant) Validate() bool {
if r.Name == "" {
return false
}
names := strings.Split(r.Name, " ")
if len(names) != 2 {
return false
}
if r.Email == "" {
return false
}
_, err := mail.ParseAddress(r.Email)
if err != nil {
return false
}
if r.Password == "" {
return false
}
if r.Template != "M" && r.Template != "F" {
return false
}
return true
}
// Function to mock a domain object
func newDomain() model.Domain {
var domain model.Domain
domain.FQDN = "rafael.net.br"
domain.Nameservers = []model.Nameserver{
{
Host: "ns1.rafael.net.br",
IPv4: net.ParseIP("127.0.0.1"),
IPv6: net.ParseIP("::1"),
},
{
Host: "ns2.rafael.net.br",
IPv4: net.ParseIP("127.0.0.2"),
},
}
domain.DSSet = []model.DS{
{
Keytag: 1234,
Algorithm: model.DSAlgorithmRSASHA1,
Digest: "A790A11EA430A85DA77245F091891F73AA740483",
},
}
owner, _ := mail.ParseAddress("*****@*****.**")
domain.Owners = []model.Owner{
{
Email: owner,
Language: "pt-BR",
},
}
return domain
}
// ContactInfo returns a *ContactInfo struct
func (user *User) ContactInfo() *ContactInfo {
// Errors should never occurs, since values are stored in db after have been controlled
yahoo, _ := mail.ParseAddress(user.Profile.Yahoo)
website, _ := url.Parse(user.Profile.Website)
github, _ := url.Parse(user.Profile.Github)
facebook, _ := url.Parse(user.Profile.Facebook)
twitter, _ := url.Parse(user.Profile.Twitter)
// Set Address.Name field
emailName := user.Surname + " " + user.Name
// yahoo address can be nil
if yahoo != nil {
yahoo.Name = emailName
}
return &ContactInfo{
Website: website,
GitHub: github,
Skype: user.Profile.Skype,
Jabber: user.Profile.Jabber,
Yahoo: yahoo,
Facebook: facebook,
Twitter: twitter,
Steam: user.Profile.Steam}
}
// Login initializes a User struct if login (id | email | username) and password are correct
func Login(login, password string) (*User, error) {
var email *mail.Address
var username string
var id uint64
var e error
if email, e = mail.ParseAddress(login); e == nil { // is a mail
if e = Db().Model(User{}).Select("username").Where(&User{Email: email.Address}).Scan(&username); e != nil {
return nil, e
}
} else if id, e = strconv.ParseUint(login, 10, 64); e == nil { // if login the user ID
if e = Db().Model(User{}).Select("username").Where(&User{Counter: id}).Scan(&username); e != nil {
return nil, e
}
} else { // otherwise is the username
username = login
}
var logged bool
var counter uint64
if e = Db().Model(User{}).Select("login(?, ?) AS logged, counter", username, password).Where("LOWER(username) = ?", username).Scan(&logged, &counter); e != nil {
return nil, e
}
if !logged {
return nil, errors.New("wrong username or password")
}
return NewUser(counter)
}
func TestRegisteredTypeParser(t *testing.T) {
var d time.Duration
RegisterTypeParser(reflect.TypeOf(d), func(blank bool, val string) (interface{}, error) {
if blank {
return nil, nil
}
return time.ParseDuration(val)
})
RegisterTypeParser(reflect.TypeOf(mail.Address{}), func(blank bool, val string) (interface{}, error) {
if blank {
return nil, nil
}
return mail.ParseAddress(val)
})
for _, tt := range []stTestCase{
{"[reg-types-1]\nduration1=5m", &cRegTypes{Reg_Types_1: cRegTypes1{Duration1: 5 * time.Minute}}, true},
{"[reg-types-1]\nduration1=1m30s", &cRegTypes{Reg_Types_1: cRegTypes1{Duration1: 90 * time.Second}}, true},
{"[reg-types-1]\nduration1=1m1m", &cRegTypes{Reg_Types_1: cRegTypes1{Duration1: time.Duration(2 * time.Minute)}}, true},
{"[reg-types-1]\nduration1=30", &cRegTypes{Reg_Types_1: cRegTypes1{Duration1: time.Duration(0)}}, false},
{"[reg-types-1]\nduration1=m", &cRegTypes{Reg_Types_1: cRegTypes1{Duration1: time.Duration(0)}}, false},
{"[reg-types-1]\nduration2=5m", &cRegTypes{Reg_Types_1: cRegTypes1{Duration2: []time.Duration{5 * time.Minute}}}, true},
{"[reg-types-1]\[email protected]", &cRegTypes{Reg_Types_1: cRegTypes1{Email1: &mail.Address{"", "*****@*****.**"}}}, true},
{"[reg-types-1]\nemail1=<*****@*****.**>", &cRegTypes{Reg_Types_1: cRegTypes1{Email1: &mail.Address{"", "*****@*****.**"}}}, true},
{"[reg-types-1]\nemail1=\"foo bar\" <*****@*****.**>", &cRegTypes{Reg_Types_1: cRegTypes1{Email1: &mail.Address{"foo bar", "*****@*****.**"}}}, true},
{"[reg-types-1]\nemail1=foo bar <*****@*****.**>", &cRegTypes{Reg_Types_1: cRegTypes1{Email1: &mail.Address{"foo bar", "*****@*****.**"}}}, true},
{"[reg-types-1]\nemail1=foo bar <*****@*****.**>", &cRegTypes{Reg_Types_1: cRegTypes1{Email1: &mail.Address{"foo bar", "*****@*****.**"}}}, true},
{"[reg-types-1]\nemail1=<foo bar> <*****@*****.**>", &cRegTypes{Reg_Types_1: cRegTypes1{}}, false},
{"[reg-types-1]\nemail1=<foo@[email protected]>", &cRegTypes{Reg_Types_1: cRegTypes1{}}, false},
{"[reg-types-1]\[email protected]", &cRegTypes{Reg_Types_1: cRegTypes1{Email2: mail.Address{"", "*****@*****.**"}}}, true},
{"[reg-types-1]\[email protected]", &cRegTypes{Reg_Types_1: cRegTypes1{Email3: []*mail.Address{&mail.Address{"", "*****@*****.**"}}}}, true},
{"[reg-types-1]\[email protected]", &cRegTypes{Reg_Types_1: cRegTypes1{Email4: []mail.Address{mail.Address{"", "*****@*****.**"}}}}, true},
} {
assert(&tt, t)
}
}
func getSingleAddress(raw string) *mail.Address {
addr, err := mail.ParseAddress(raw)
if err != nil {
return nil
}
return addr
}
