wie zu überprüfen, ob das angegebene Feld ist alphanumerisch oder nicht in PlayFramework

Question

Ich muss entweder das Passwort-Feld ist alphanumerisch oder nicht überprüfen, und wenn nicht, wird es benutzerdefinierte Validierung Fehler Ich benutze Play-Framework, aber immer Kompilierung Fehler

value checkAlphanumeric is not a member of 
    play.api.libs.json.Reads[String] 
    - value checkAlphanumeric is not a member of 
    play.api.libs.json.Reads[String] 

vermag ich nicht meine gewünschte Ergebnis achive ich tue es falsch, das ist, warum ich hier brauchen, ist der Code

case class userUserSignUpValidation(firstName: String, 
             lastName: String, 
             email: String, 
             password: String) extends Serializable 

object UserSignUpValidation { 
    val allNumbers = """\d*""".r 
    val allLetters = """[A-Za-z]*""".r 
    var validationErrorMsg="" 
    implicit val readDirectUser: Reads[DirectUserSignUpValidation] = (
    (JsPath \ "firstName").read(minLength[String](1)) and 
    (JsPath \ "lastName").read(minLength[String](1)) and 
    (JsPath \ "email").read(email) and 
    (JsPath \ "password").read(minLength[String](8)checkAlphanumeric))(UserSignUpValidation.apply _) 
    def checkAlphanumeric(password:String)={ 
     val allNumbers = """\d*""".r 
     val allLetters = """[A-Za-z]*""".r 

     val errors = password match { 
      case allNumbers() => Seq(ValidationError("Password is all numbers")) 
      case allLetters() => Seq(ValidationError("Password is all letters")) 
      case _ => Nil 
     } 
    } 

ich erhalte den Fehler auf dieser Linie

(JsPath \ "password").read(minLength[String](8)checkAlphanumeric))(UserSignUpValidation.apply _) 

was ist der richtige Weg, um ein oben beschriebenes Szenario

Answer 1

Ihr Problem ist, dass Sie nicht Ihre checkAlphanumeric Methode, die Art und Weise nutzen können. Was Sie wahrscheinlich wollen, ist ein Filter auf der Reads, so würde ich vorschlagen, etwas wie folgt tun (ich änderte die Umsetzung für die Überprüfung, bereits bestehende Methoden):

implicit val readDirectUser: Reads[DirectUserSignUpValidation] = (
    (JsPath \ "firstName").read(minLength[String](1)) and 
    (JsPath \ "lastName").read(minLength[String](1)) and 
    (JsPath \ "email").read(email) and 
    (JsPath \ "password").read(minLength[String](8). 
     filterNot(ValidationError("Password is all numbers"))(_.forall(_.isDigit)). 
     filterNot(ValidationError("Password is all letters"))(_.forall(_.isLetter)) 
    )) (UserSignUpValidation.apply _) 

Answer 2

Nun frage ich mich, zu implementieren, warum Sie nicht Validierungen innerhalb Fall-Klasse?

case class userUserSignUpValidation(firstName: String, 
             lastName: String, 
             email: String, 
             password: String) { 

    assert(!password.matches("""[A-Za-z]*""") && !password.matches("""\d*"""), "Invalid password") 
    // have other field validations here 
} 

Und Sie UserSignUpValidation eine implizite Formatierer wie folgt verwenden:

object UserSignUpValidation { 
    implicit val userFormatter = JSON.format[userUserSignUpValidation] 

    // de-serialization code here 
}