// Establish connection to MongoDB and write feedback to collection
func WriteFeedback(name string, email string, text string) int {
// We like only correct e-mails
if !govalidator.IsEmail(email) {
fmt.Printf("'%v' is not an email!\n", email)
return NOT_AN_EMAIL
}
// Length of name can't be less than four letters and more than thirty two letters
if !govalidator.IsByteLength(name, 4, 32) {
fmt.Printf("Name '%v' has invalid length!\n", name)
return INVALID_NAME
}
// Length of text should be between 16 and 1024 letters
if !govalidator.IsByteLength(text, 16, 1024) {
fmt.Printf("Feedback '%v' has invalid length!\n", text)
return INVALID_NAME
}
url := os.Getenv("DATABASE")
fmt.Printf("DB_URL is %v\n", url)
sess, err := mgo.Dial(url)
if err != nil {
fmt.Printf("Can't connect to mongo, go error %v\n", err)
return DB_UNAVAILABLE
}
defer sess.Close()
sess.SetMode(mgo.Monotonic, true)
c := sess.DB("asaskevich").C("feedback")
err = c.Insert(&Feedback{name, email, text})
if err != nil {
fmt.Printf("Can't write to mongo, go error %v\n", err)
return CANT_WRITE_TO_DB
}
return OK
}
func AddressIsValidFullFuzzy(address string, excludeExampleOrTest bool, excludeNumericTestAddress bool) bool {
address = strings.Trim(address, " ")
if len(address) < 6 { // [email protected]
return false
}
address = strings.ToLower(address)
valid, _, hostname := AddressIsValidFull(address)
if !valid {
return false
}
valid = govalidator.IsEmail(address)
if !valid {
return false
}
valid = HostnameIsValid(hostname)
if !valid {
return false
}
if excludeExampleOrTest {
test := DomainIsExampleOrTest(address)
if test {
return false
}
}
if excludeNumericTestAddress {
rsEmailFullNumeric := rxEmailFullNumeric.FindString(address)
if len(rsEmailFullNumeric) > 0 {
return false
}
}
return true
}
func verifyFormat(val string, format string) error {
switch format {
case "date-time":
_, err := time.Parse(time.RFC3339, val)
return err
case "email":
if !govalidator.IsEmail(val) {
return fmt.Errorf("%q is not a valid email", val)
}
case "hostname":
if !hostnameRe.MatchString(val) || len(val) > 255 {
return fmt.Errorf("%q is not a valid hostname", val)
}
case "ipv4":
if !govalidator.IsIPv4(val) {
return fmt.Errorf("%q is not a valid IPv4 address", val)
}
case "ipv6":
if !govalidator.IsIPv6(val) {
return fmt.Errorf("%q is not a valid IPv6 address", val)
}
case "uri":
u, err := url.Parse(val)
if err != nil {
return err
}
// XXX: \noideadog{this makes all the tests pass, not sure how it really should be validated}
if u.Host == "" {
return fmt.Errorf("%q is not absolute", val)
}
}
return nil
}
//edit email
func EditEmail(c web.C, w http.ResponseWriter, r *http.Request) {
var userId int
if CheckToken(r.FormValue("token"), w) == false {
return
}
//Get user_id by token render json error if crash ?
if userId = GetUserIdWithToken(r.FormValue("token"), w); userId == -1 {
return
}
var email = r.FormValue("email")
//delete all space in var email
email = strings.Replace(email, " ", "", -1)
//check if email's syntax is correct
if govalidator.IsEmail(email) == false {
RenderJSON(w, RenderStructError("email", "your email haven't a good syntax"), http.StatusBadRequest)
return
}
//check if email is already used
if IsEmailExist(email) == true {
RenderJSON(w, RenderStructError("email", "email is already used"), http.StatusBadRequest)
return
}
//query update email
_, err := gest.Db.Exec("UPDATE account SET email=$1 WHERE id=$2", email, userId)
LogFatalError(err)
RenderJSON(w, RenderStructOk(), http.StatusOK)
}
// Validate ...
// TODO: unify somehow, to have centralized place where email (or any other field) is validated
func (prr *PasswordRecoveryRequest) Validate(builder *lib.ValidationErrorBuilder) {
if !validator.IsByteLength(prr.Email, 6, 45) {
builder.Add("email", "validation_error.email_min_max_wrong")
} else if !validator.IsEmail(prr.Email) {
builder.Add("email", "Invalid email address.")
}
}
//EmailValidator for validation of email inputs
func EmailValidator(Error string) ItemValidator {
return NewValidator(func(field *FormItem) bool {
if !govalidator.IsEmail(field.Value) {
return false
}
return true
}, Error)
}
func ValidateFormatOfEmail(resource Resource, attribute string) {
value := reflect.ValueOf(resource).Elem()
value = reflect.Indirect(value).FieldByName(attribute)
if govalidator.IsEmail(value.String()) == false {
resource.Errors().Add(attribute, "is not email")
}
}
func (n *NewEmail) Decode() error {
n.Email = strings.Trim(strings.ToLower(n.Email), " ")
if n.Email == "" || !govalidator.IsEmail(n.Email) {
return Errors{
"email": "Valid email is required",
}
}
return nil
}
func validateChartMaintainer(cf *chart.Metadata) (lintError support.LintError) {
for _, maintainer := range cf.Maintainers {
if maintainer.Name == "" {
lintError = fmt.Errorf("Chart.yaml: maintainer requires a name")
} else if maintainer.Email != "" && !govalidator.IsEmail(maintainer.Email) {
lintError = fmt.Errorf("Chart.yaml: maintainer invalid email")
}
}
return
}
func validateChartMaintainer(cf *chart.Metadata) error {
for _, maintainer := range cf.Maintainers {
if maintainer.Name == "" {
return errors.New("each maintainer requires a name")
} else if maintainer.Email != "" && !govalidator.IsEmail(maintainer.Email) {
return fmt.Errorf("invalid email '%s' for maintainer '%s'", maintainer.Email, maintainer.Name)
}
}
return nil
}
// NewUserFunc creates the default parser of login HTTP request
func NewUserFunc(idName string) UserFunc {
return func(r *http.Request, us store.Store) (ou OAuth2User, err error) {
var c store.Conds
id := r.Form.Get(idName)
if id == "" {
serr := store.Error(http.StatusBadRequest, "empty user identifier")
err = serr
return
}
// different condition based on the user_id field format
if govalidator.IsEmail(id) {
c = store.NewConds().Add("email", id)
} else {
c = store.NewConds().Add("username", id)
}
// get user from database
u := us.AllocEntity()
err = us.One(c, u)
if err != nil {
serr := store.ExpandError(err)
if serr.Status != http.StatusNotFound {
serr.TellServer("Error searching user %#v: %s", id, serr.ServerMsg)
return
}
err = serr
return
}
// if user does not exists
if u == nil {
serr := store.Error(http.StatusBadRequest, "Username or Password incorrect")
serr.TellServer("Unknown user %#v attempt to login", id)
err = serr
return
}
// cast the user as OAuth2User
// and do password check
ou, ok := u.(OAuth2User)
if !ok {
serr := store.Error(http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError))
serr.TellServer("User cannot be cast as OAuth2User")
err = serr
return
}
return
}
}
// Valid validates email. If the email is temporary it returns false and an error explaining
// why it is not valid. For valid email it returns true, and the error is nil.
func Valid(email string) (bool, error) {
if !govalidator.IsEmail(email) {
return false, errors.New("Bad email address")
}
sep := strings.Split(email, "@")
_, err := checkDisposable(sep[1])
if err != nil {
return true, nil
}
return false, errors.New("This is a temporary email")
}
func (m *Order) validateContact() error {
if m.Contact == "" {
return nil
}
if govalidator.IsEmail(m.Contact) != true {
return errors.InvalidType("contact", "body", "email", m.Contact)
}
return nil
}
func (m *User) validateEmail() error {
if m.Email == "" {
return nil
}
if govalidator.IsEmail(m.Email) != true {
return errors.InvalidType("email", "body", "email", m.Email)
}
return nil
}
func checkEmails(emails []string) (errs []error) {
for _, addr := range emails {
if len(addr) == 0 {
return
}
if ok := valid.IsEmail(addr); !ok {
errs = append(errs, fmt.Errorf("Invalid email address. email: %s", addr))
}
}
return
}
func (Lst_users *All_users) Add_new_user(new_user *User, Db *sql.DB, Pass []byte) (bool, error) {
if len(new_user.Mail) > 0 {
if valid.IsEmail(new_user.Mail) != true {
return false, nil
}
}
err := Db.QueryRow("SELECT setsuserdata2($1, $2, $3, $4, $5, $6, $7, $8);", 1, "user_particulier", new_user.Coord.Lat, new_user.Coord.Lon, new_user.Stats.CreationDate, new_user.Log, new_user.Mail, Pass).Scan(&new_user.Id)
if err != nil {
Lst_users.Logger.Println("Add_new_user: ", err)
return false, err
}
return true, nil
}
func (u *User) Validate() map[string]string {
var errs = make(map[string]string)
switch {
case u.Mail == nil:
errs["mail"] = "is required"
case u.Mail != nil && !govalidator.IsEmail(*u.Mail):
errs["mail"] = "is not valid"
case u.Password == nil:
errs["password"] = "******"
}
return errs
}
//for now just return submited params
func registerHandler(c *gin.Context) {
username := c.PostForm("username")
email := c.PostForm("email")
//we are using external library to validate email and other things if needed
if govalidator.IsEmail(email) {
//c.String(200, "Username is: %s and e-mail %s", username, email)
//or we can return JSON as well
c.JSON(200, gin.H{"username": username, "email": email})
} else {
//email is not valid we can't register this user
c.String(400, "We are sorry but email: %s is not valid e-mail adress", email)
}
}
func (user *User) Validate(repo UserRepository) error {
if user.Email == "" {
return errors.New("Cannot create User without email.")
}
if !govalidator.IsEmail(user.Email) {
return UserInvalidEmail
}
u, _ := repo.FindByEmail(user.Email)
if u != nil {
return UserDuplicateEmail
}
return nil
}
// Validate returns an error if a User struct does not satisfy the following
// conditions:
// * Username is 3 or more characters
// * Username is composed solely of alphanumeric characters
// * Email is a valid email address
// * Password is 8 or more characters
func (u User) Validate() (err error) {
if !valid.IsEmail(u.Email) {
err = errors.New(fmt.Sprintf("'%s' is not a valid email address", u.Email))
}
if len(u.Username) < 3 {
err = errors.New(fmt.Sprintf("'%s' is less than 3 characters", u.Username))
}
if len(u.Password) < 8 {
err = errors.New("Password must be at least 8 characters long")
}
if !valid.IsAlphanumeric(u.Username) {
err = errors.New(fmt.Sprintf("'%s' is less than 3 characters", u.Username))
}
return err
}
func (this *LoginValidator) validateRequest(loginRequest *LoginRequest) (isValid bool, errorMessages []string) {
if loginRequest.UserId == "" {
errorMessages = append(errorMessages, this.ResourceProvider.GetString(configuration.R_LOGIN_USER_ID_REQUIRED))
} else if !valid.IsEmail(loginRequest.UserId) {
errorMessages = append(errorMessages, this.ResourceProvider.GetString(configuration.R_LOGIN_USER_ID_INVALID_EMAIL))
}
if loginRequest.Password == "" {
errorMessages = append(errorMessages, this.ResourceProvider.GetString(configuration.R_LOGIN_PASSWORD_REQUIRED))
} else if !valid.IsPrintableASCII(loginRequest.Password) {
errorMessages = append(errorMessages, this.ResourceProvider.GetString(configuration.R_LOGIN_PASSWORD_INVALID))
}
isValid = len(errorMessages) == 0
return isValid, errorMessages
}
func RegisterHandler(context *RegistrationContext, w http.ResponseWriter, r *http.Request) error {
if r.Method != "POST" {
w.Header().Set("Allow", "POST")
w.WriteHeader(http.StatusMethodNotAllowed)
json.NewEncoder(w).Encode(RegistrationError{"Method not allowed! Use POST"})
return nil
}
email, err := getEmailFromRequest(w, r)
if err != nil {
return err
}
if email != "" {
// validate email first
if !govalidator.IsEmail(email) {
w.WriteHeader(http.StatusBadRequest)
json.NewEncoder(w).Encode(RegistrationError{"Email not valid!"})
return nil
}
registerTime := time.Now()
err := context.RegisteredUserRepository.AddRegisteredUser(RegisteredUser{email, registerTime})
if err != nil {
if mgo.IsDup(err) {
w.WriteHeader(http.StatusConflict)
json.NewEncoder(w).Encode(RegistrationError{"Email exists!"})
return nil
}
return err
}
w.WriteHeader(http.StatusCreated)
json.NewEncoder(w).Encode(RegisteredUser{email, registerTime})
context.Mailer.SendWelcomeMessage(email)
return nil
}
w.WriteHeader(http.StatusBadRequest)
json.NewEncoder(w).Encode(RegistrationError{"Email missing!"})
return nil
}
// Validate ...
func (rr *RegistrationRequest) Validate(builder *lib.ValidationErrorBuilder) {
if !validator.IsByteLength(rr.Email, 6, 45) {
builder.Add("email", "validation_error.email_min_max_wrong")
} else if !validator.IsEmail(rr.Email) {
builder.Add("email", "Invalid email address.")
}
if !validator.IsByteLength(rr.Password, 6, 45) {
builder.Add("password", "validation_error.password_min_max_wrong")
}
if !validator.IsByteLength(rr.FirstName, 1, 45) {
builder.Add("firstName", "validation_error.firstname_max_len_wrong")
}
if !validator.IsByteLength(rr.LastName, 1, 45) {
builder.Add("lastName", "validation_error.lastname_max_len_wrong")
}
}
func ConfigureLdapClient(conf LdapConfig) (*mozldap.Client, error) {
// check if ldap email was entered
if govalidator.IsEmail(conf.Username) {
conf.Username = "******" + conf.Username + ",o=com,dc=" + conf.Dc
}
// instantiate an ldap client
ldapClient, err := mozldap.NewTLSClient(
conf.Uri,
conf.Username,
conf.Password,
conf.ClientCertFile,
conf.ClientKeyFile,
conf.CaCertFile,
&tls.Config{
InsecureSkipVerify: conf.Insecure,
},
)
return &ldapClient, err
}
// CreateUser create a new user. Checks for duplicate users and password-length requirement
func CreateUser(handle tools.Handle, db *mgo.DbQueue) (interface{}, error) {
var user models.User
user.Enable = true
user.Domains = nil
user.Variables = nil
err := rest.Parse(handle.R, &user)
if err != nil {
return nil, tools.NewError(err, 400, "bad request: couldn't parse body")
}
if user.Username == "" {
return nil, tools.NewError(nil, 400, "bad request: username is missing")
}
if user.Password == "" {
return nil, tools.NewError(nil, 400, "bad request: password is missing")
}
if len(user.Password) < handle.C.PasswordMinLength {
return nil, tools.NewError(nil, 400, "bad request: password is too short")
}
if user.Domains == nil || len(user.Domains) == 0 {
return nil, tools.NewError(nil, 400, "bad request: domains is missing")
}
if user.Variables == nil {
user.Variables = make(map[string]interface{})
}
if govalidator.IsEmail(user.Username) == false {
return nil, tools.NewError(nil, 400, "bad request: username must be a valid email")
}
user.Username, err = govalidator.NormalizeEmail(user.Username)
if err != nil {
return nil, tools.NewError(nil, 400, "bad request: username must be a valid email")
}
uid, err := user.Create(db)
return CreateResponse{
Status: "ok",
UserID: uid.Hex(),
}, err
}
func (s *Signup) Decode() error {
s.Name = strings.Trim(s.Name, " ")
s.Email = strings.ToLower(strings.Trim(s.Email, " "))
errors := make(Errors)
if len(s.Name) < minNameLength {
errors["name"] = fmt.Sprintf("Your name must be at least %d characters long", minNameLength)
}
if !govalidator.IsEmail(s.Email) {
errors["email"] = "Email address is required"
}
if len(s.Password) < minPasswordLength {
errors["password"] = fmt.Sprintf("Password must be at least %d characters long", minPasswordLength)
}
if len(errors) > 0 {
return errors
}
return nil
}
func UserCreate(db *Database, username string, password string, email string) (int, error) {
if email != "" && !govalidator.IsEmail(email) {
return 0, L.Error("invalid_email")
}
if len(username) < MIN_USERNAME_LENGTH || len(username) > MAX_USERNAME_LENGTH {
return 0, L.Errorf("username_length", MIN_USERNAME_LENGTH, MAX_USERNAME_LENGTH)
}
if !isPrintable(username) {
return 0, L.Error("invalid_username_format")
}
if len(password) < MIN_PASSWORD_LENGTH || len(password) > MAX_PASSWORD_LENGTH {
return 0, L.Errorf("password_length", MIN_PASSWORD_LENGTH, MAX_PASSWORD_LENGTH)
}
// ensure username not taken already
var userCount int
db.QueryRow("SELECT COUNT(*) FROM users WHERE username = ?", username).Scan(&userCount)
if userCount > 0 {
return 0, L.Error("username_in_use")
}
// ensure email not taken already
if email != "" {
db.QueryRow("SELECT COUNT(*) FROM users WHERE email = ?", email).Scan(&userCount)
if userCount > 0 {
return 0, L.Error("email_in_use")
}
}
// generate salt and hash password
result := db.Exec("INSERT INTO users (username, password, email) VALUES (?, ?, ?)", username, authMakePassword(password), email)
userId, _ := result.LastInsertId()
return int(userId), nil
}
func (email Email) Validate() error {
if !govalidator.IsEmail(email.String()) {
return ErrInvalidMail
}
return nil
}
func (i IsEmailChecker) IsFormat(data string) bool {
return govalidator.IsEmail(data)
}
func (s *service) extendedIsEmail(str string) bool {
return gov.IsEmail(str) && len(strings.TrimSpace(str)) >= 3
}