parse.json de solicitud de partida autenticado

Question

He configurado la autenticación en mi aplicación como esta, permitir siempre un nombre de usuario cuando se suministra y la clave de API es de 123:

object Auth { 
    def IsAuthenticated(block: => String => Request[AnyContent] => Result) = { 
     Security.Authenticated(RetrieveUser, HandleUnauthorized) { user => 
     Action { request => 
      block(user)(request) 
     } 
     } 
    } 

    def RetrieveUser(request: RequestHeader) = { 

     val auth = new String(base64Decode(request.headers.get("AUTHORIZATION").get.replaceFirst("Basic", ""))) 
     val split = auth.split(":") 
     val user = split(0) 
     val pass = split(1) 
     Option(user) 
    } 

    def HandleUnauthorized(request: RequestHeader) = { 
     Results.Forbidden 
    } 

    def APIKey(apiKey: String)(f: => String => Request[AnyContent] => Result) = IsAuthenticated { user => request => 

     if(apiKey == "123") 
     f(user)(request) 
     else 
     Results.Forbidden 
    } 

} 

Quiero a continuación para definir una método en mi controlador (testOut en este caso) que utiliza la solicitud como application/json solamente. Ahora, antes de agregar la autenticación, diría "def testOut = Action (parse.json) {...}", pero ahora que estoy usando la autenticación, ¿cómo puedo agregar parse.json en la mezcla y hacer ¿este trabajo?

def testOut = Auth.APIKey("123") { username => implicit request => 

    var props:Map[String, JsValue] = Map[String, JsValue]() 
    request.body match { 
     case JsObject(fields) => { props = fields.toMap } 
     case _ => {} // Ok("received something else: " + request.body + '\n') 
    } 

    if(!props.contains("UUID")) 
     props.+("UUID" -> UniqueIdGenerator.uuid) 

    if (!props.contains("entity")) 
     props.+("entity" -> "unset") 

    props.+("username" -> username) 

    Ok(props.toString) 
    } 

Como pregunta extra, ¿por qué sólo se UUID añadir al mapa apoyos, no entidad y nombre de usuario?

Lo siento por el factor novato, estoy tratando de aprender Scala y Play al mismo tiempo. :-)

Saludos

Nik

Answer 1

Resulta que no necesito usar una bodyparser en absoluto, request.body tiene una función asJson que puedo usar. Así que exploté esto para hacer lo siguiente. Este trabajo, y puedo continuar mi trabajo, pero todavía no entiendo cómo obtener un analizador de cuerpo JSON aquí. El aprendizaje en curso ... ;-)

def testOut = Auth.APIKey("123") { username => request => 

    var props:Map[String, JsValue] = Map[String, JsValue]() 
    request.body.asJson match { 
    case None => {} 
    case Some(x) => { 
     x match { 
     case JsObject(fields) => { props = fields.toMap } 
     case _ => {} // Ok("received something else: " + request.body + '\n') 
     } 
    } 
    } 

    if(!props.contains("UUID")) 
    props += "UUID" -> toJson(UniqueIdGenerator.uuid) 

    if(!props.contains("entity")) 
    props += "entity" -> toJson("unset") 

    props += "should" -> toJson("appear") 
    props += "username" -> toJson(username) 

    Ok(props.toString) 
} 

Answer 2

Véase mi respuesta a esta pregunta aquí: Play 2.0 Framework, using a BodyParser with an authenticated request

Lo esencial es que el método sobrecargado IsAuthenticated tomar BodyParser como parámetro y llamar Action con él.