func (a *Agent) ValidateInsert(v *revel.Validation) {
	v.Check(a.LoginPass,
		revel.MinSize{Min: 1},
		revel.MaxSize{Max: 30},
	).Key("agent.LoginPass").Message("登录密码大于1个字符小于30个字符")
	a.Validate(v)
}

func (r *Role) Validate(v *revel.Validation) {
	v.Check(r.IsUse, revel.Required{})
	v.Check(r.ParentID, revel.MaxSize{50})
	v.Check(r.RoleCode, revel.Required{}, revel.MaxSize{50}, revel.MinSize{10})
	v.Check(r.RoleName, revel.Required{}, revel.MaxSize{10}, revel.MinSize{2})
	v.Check(r.Sort, revel.Required{})
}

func (e *Episode) Validate(v *revel.Validation) {
	v.Check(e.Name,
		revel.Required{},
		revel.MinSize{1},
		revel.MaxSize{255},
	)
}

func (p *Pagination) isValidPage(v *revel.Validation,
	bean interface{}, index ...int64) {
	n, err := engine.Count(bean)
	if err != nil {
		e := &revel.ValidationError{
			Message: "bean error",
			Key:     reflect.TypeOf(bean).Name(),
		}
		v.Errors = append(v.Errors, e)
	}
	//modify n to 0
	if n < 0 {
		n = 0
	}
	//current page number
	var c int64
	if len(index) == 0 {
		c = 1
	} else {
		c = index[0]
		if c == 0 {
			c = 1
		}
	}
	if c*perPage > n+perPage || c < 1 {
		e := &revel.ValidationError{
			Message: fmt.Sprintf("%d is out of range %d",
				c, n/perPage),
			Key: reflect.TypeOf(bean).Name(),
		}
		v.Errors = append(v.Errors, e)
	}
}

func (s *Series) Validate(v *revel.Validation) {
	v.Check(s.Name,
		revel.Required{},
		revel.MinSize{1},
		revel.MaxSize{255},
	)
}

func ValidatePassword(v *revel.Validation, password string) *revel.ValidationResult {
	return v.Check(password,
		revel.Required{},
		revel.MaxSize{15},
		revel.MinSize{5},
	)
}

func (requests Requests) Validate(v *revel.Validation) {
	v.Required(requests.User)
	v.Required(requests.RequestType)
	v.Required(requests.RequestCount)
	v.Required(requests.RequestTime)
	v.Required(requests.RequestPlace)
}

func (doc *Document) saveChain(v *revel.Validation) bool {
	if v != nil {
		doc.callCB("BeforeValidation")
		doc.Validate(v)
		if v.HasErrors() {
			return false
		}
		doc.callCB("AfterValidation")
	}
	doc.callCB("BeforeSave")
	if doc.IsNew() {
		doc.callCB("BeforeCreate")
	} else {
		doc.callCB("BeforeUpdate")
	}
	saved := doc.save()
	if doc.IsNew() {
		doc.callCB("AfterCreate")
	} else {
		doc.callCB("AfterUpdate")
	}
	doc.callCB("AfterSave")

	return saved
}

func (si SiteInfo) Validate(v *revel.Validation) {
	v.MaxSize(si.AboutUsTitle, 1024)

	v.Required(si.AboutUsTitle)
	v.Required(si.AboutUsContent)
	v.Required(si.TwitterURL)
	v.Required(si.FacebookURL)
}

func (u *UserMaillist) Validate(v *revel.Validation) {
	v.Required(u.Email).
		Message("Email required").
		Key("usermaillist.Email")
	v.Email(u.Email).
		Message("Valid email required").
		Key("usermaillist.Email")
}

func (c *Cmd) ValidateUpdate(v *revel.Validation) {
	c.Validate(v)

	c.CmdId = strings.TrimSpace(c.CmdId)
	v.Check(c.CmdId,
		revel.Required{},
	).Key("cmd.CmdId").Message("CmdId不能为空")
}

func (self *Server) Validate(v *revel.Validation) {
	//	TODO: use it in controller
	v.Check(self.Label,
		revel.Required{},
		revel.MaxSize{63},
		revel.MinSize{1},
		revel.Match{userRegex},
	)
}

func (a *Account) Validate(v *revel.Validation) {
	v.Check(a.Email,
		revel.Required{},
		revel.MinSize{4},
		revel.Match{emailRegex},
	)

	ValidatePassword(v, a.Password).
		Key("account.Password")
}

func (user *User) Validate(v *revel.Validation) {
	v.Required(user.Name)
	v.Required(user.Email)
	valid := v.Email(user.Email)
	if user.Password != user.ConfirmPassword {
		v.Errors = append(v.Errors, &revel.ValidationError{Message: "两次密码不一致", Key: "user.Password"})
	}

	if user.HasName() {
		fmt.Println("has name")
		err := &revel.ValidationError{
			Message: "该用户名已经被注册",
			Key:     "user.Name",
		}
		v.Errors = append(v.Errors, err)
	}

	if valid.Ok {
		if user.HasEmail() {
			fmt.Println("has email")
			err := &revel.ValidationError{
				Message: "该邮箱已经被用于注册",
				Key:     "user.Email",
			}
			v.Errors = append(v.Errors, err)
		}
	}
}

func Validate(v *revel.Validation, user models.User) {
	v.Check(user.Username,
		revel.Required{},
		revel.MaxSize{18},
		revel.MinSize{2},
		revel.Match{userRegex},
	)

	validatePassword(v, user.Password).Key("user.Password")

}

func (tg *TaskGroup) Validate(v *revel.Validation) {
	tg.GroupName = strings.TrimSpace(tg.GroupName)
	tg.Description = strings.TrimSpace(tg.Description)

	v.Check(tg.GroupName,
		revel.Required{},
	).Key("taskGroup.GroupName").Message("组名不能为空")
	v.Check(tg.Description,
		revel.Required{},
	).Key("taskGroup.Description").Message("描述不能为空")
}

func (category Category) Validate(v *revel.Validation) {
	v.Required(category.Name).Message("请输入名称")

	if category.HasName() {
		err := &revel.ValidationError{
			Message: "名称已存在",
			Key:     "category.Name",
		}
		v.Errors = append(v.Errors, err)
	}
}

func (c *Cmd) Validate(v *revel.Validation) {
	c.Shell = strings.TrimSpace(c.Shell)
	c.AgentId = strings.TrimSpace(c.AgentId)

	v.Check(c.AgentId,
		revel.Required{},
	).Key("cmd.AgentId").Message("AgentId不能为空")

	v.Check(c.Shell,
		revel.Required{},
	).Key("cmd.Shell").Message("脚本不能为空")
}

func (message *Message) Validate(v *revel.Validation) {
	v.Check(message.Email,
		revel.Required{},
		revel.MaxSize{50})
	v.Email(message.Email)
	v.Check(message.QQ, revel.MaxSize{20})
	v.Check(message.Url, revel.MaxSize{200})
	v.Check(message.Content,
		revel.Required{},
		revel.MinSize{1},
		revel.MaxSize{1000})
}

func (user *User) Validate(v *revel.Validation) {
	v.Check(user.Alias,
		revel.Required{},
		revel.MaxSize{15},
		revel.MinSize{4},
		revel.Match{userRegex},
	)

	v.Check(user.Name,
		revel.Required{},
		revel.MaxSize{100},
	)
}