Heute habe ich versucht ein per JSON geliefertes Objekt in einen Controller abzufangen und zu validieren. Zuerst wollte ich dies mit der von Zend angebotenen Klasse AbstractValidator lösen. Jedoch habe ich nach genaueren Nachforschungen herausgefunden, das dieser wohl nur für Validatoren gedacht ist, die eine Variable betrachten bzw. diese validieren. Daher habe ich mich entschlossen nur das ValidatorInterface zu implementieren. dieses verlangt lediglich die Methoden isValid($value) und getMessages().
Wobei ich hier die Methode getMessages() auf ein 2-dimensionales Array erweitere, so das ein Array z.B. so aussieht
{"nr":["fieldempty","errors"],"vorname":["fieldempty","errors"],"nachname":["fieldempty","errors"]}
Hierzu wird zwar das ValidatorInterface etwas zweckentfremdet, dies hat aber den Vorteil das nun alle Felder gleichzeitig „validiert“ werden und nicht wie bei der Möglichkeit mit den AbstractValidator, Feld für Feld validiert wird und sobald ein Fehler gefunden wird dieser zurückgegeben wird.
Felder die das JSON Objekt enthalten soll stehen in $fields. Diese können über die setter- Methode gesetzt werden oder per Konstruktor übergeben werden.
Außerdem wird eine Möglichkeit geboten die Felder auf einen Leerstring zu überprüfen, dies kann mit isEmptyStringChecked(boolean) aktiviert werden.
Meine Implementierung sieht also wie folgt aus:
JSONValidator BasisKlasse
<?php
class JSONValidator implements ValidatorInterface{
/** const messages */
const FIELD_MISSING = "fieldmissing";
const FIELD_EMPTY = "fieldempty";
/**
* Contains all error messages
* @var array|null
*/
private $messages = null;
/**
* Should contain all fields of the json object, that are expected
* @var array|null
*/
private $fields = null;
/**
* If set to true, fields must also be not empty strings
* @var boolean
*/
private $emptystring = false;
public function __construct($fields = array()){
$this->messages = array();
$this->fields = $fields;
}
/**
* Returns true if and only if $value meets the validation requirements
*
* If $value fails validation, then this method returns false, and
* getMessages() will return an array of messages that explain why the
* validation failed.
*
* @param array $value
* @return boolean
* @throws Exception\RuntimeException If validation of $value is impossible
*/
public function isValid($value){
$isValid = true;
foreach($this->fields as $field){
if(!array_key_exists($field, $value)){
$this->addMessage($field, self::FIELD_MISSING);
$isValid = false;
}else if($this->emptystring && $value[$field] == ""){
$this->addMessage($field, self::FIELD_EMPTY);
$isValid = false;
}
echo $value[$field];
}
return $isValid;
}
/**
* checks if field already has an error
* @param $field
* @return bool
*/
private function fieldHasError($field){
return !array_key_exists($field, $this->messages);
}
/**
* Returns an array which contains all the error messages
* if isValid($value) returned true, the array will only be status => ok and no messages, otherwise the message part will contain all the error
* messages. The key of the message array is the field which contained the error.
* @return array
*/
public function getMessages(){
return $this->messages;
}
/**
*
* @param array $messages
*/
public function setMessages(array $messages){
$this->messages = $messages;
}
public function addMessage($field, $message){
$this->messages[$field][] = $message;
}
/**
* @param array $fields
*/
public function setFields($fields){
$this->fields = $fields;
}
/**
* @return array
*/
public function getFields(){
return $this->fields;
}
/**
* @param boolean $checkempty
*/
public function checkEmptyString($checkempty = true){
$this->emptystring = $checkempty;
}
/**
* @return boolean
*/
public function isEmptyStringChecked(){
return $this->emptystring;
}
}
Und hier z.B. eine von JSONValidator abgeleitete Klasse, es wird nur der Konstruktor überschrieben, um die Felder des JSON Objekts festzulegen, weiters könnte man hier auch noch die die isValid()-Methode erweitern, wenn manche Felder eine spezielle Validation benötigen.
class PatStammValidator extends JSONValidator{
public function __construct(){
$fields = array( "nr", "vorname", "nachname", "anrede", "ort", "plz", "strasse", "gebDatum", "versicherungsnr", "versicherungsanstalt", "telnr", "email" );
parent::__construct($fields);
}
}
Und hier noch der Aufruf in der Action im Controller
...
$validator = new PatStammValidator();
$validator->checkEmptyString();
if($validator->isValid($patstammarray)){
$patstamm = $this->createPatStammFromRequest($patstammarray);
return new JsonModel($patstamm->toArray());
}else{
return new JsonModel(array("status"=>"error", "messages"=>$validator->getMessages()));
}
...
Somit können die meisten Formulare zumindest schnell auf Leerstrings geprüft werden und es kann geprüft werden, ob von der Clientseite überhaupt die richtigen Daten gesendet worden sind.
Die Ausgabe auf der Client Seite könnte in etwa mit JavaScript so aussehen:
var patStammView = (function(window, document, jQuery){
var module = {};
var settings = {
varstocheck: { "nr":"nr", "vorname":"name", "nachname":"name", "anrede":"name",
"ort":"plz", "plz":"plz", "strasse":"strasse", "gebDatum":"gebDatum",
"versicherungsnr":"versichnr", "versicherungsanstalt":"versichnr",
"telnr":"tel","email":"email"},
};
module.init = function(options){
$.extend(settings, options);
};
module.save = function(){
$('.control-group').each(function(){
$(this).removeClass("error");
$(this).children(".help-inline, .help-block").html("");
});
var jsonstring = $('#patient-form').serialize();
JSLogger.log(jsonstring);
$.ajax({
url: $('#basePath').val() + "/api/patient/put",
type: "PUT",
data: _getJSONFromForm(),
success: function(data){
if(data.hasOwnProperty("status") && data.status === "error"){
//$('#errormessage').html(data);
if(data.hasOwnProperty("messages")){
var messages = data.messages;
$.each(settings.varstocheck, function(index, value){
JSLogger.log(index);
if(messages.hasOwnProperty(index)){
$('#control-group-'+value).addClass("error");
$.each(messages[index], function(count, message){
$('#control-group-' + value).
children(".help-inline, .help-block").html("Bitte etwas eintragen!");
});
}
});
}
}
},
error: function(data){
alert("Fehler beim Speichern!");
},
fail: function(){
alert("Fehler beim Speichern!");
}
});
};
return module;
function _getJSONFromForm(){
...
return json;
}
}(window, document, jQuery));
Es wird in der Variable „varstocheck“ ein assoziatives Array angelegt, wobei der Key aus dem Feldnamen im zurückgelieferten JSON besteht, der Wert dazu der Name des Feldes ist, das „markiert“ werden soll.
Hier z.B. ein Teil der control-group id (Beispiel: „vorname“:name“ => „control-group-name“)
<div class="control-group" id="control-group-name">
<label class="control-label">Name:</label>
<input type="text" name="anrede" class="span2" id="patanrede" placeholder="Anrede" />
<input type="text" name="nachname" id="patnachname" placeholder="Nachname">
<input type="text" name="vorname" id="patvorname" placeholder="Vorname" />
<span class="help-block"></span>
</div>
Weiters könnte man hier noch die entsprechenden Fehler Codes abarbeiten und dementsprechende Fehler ausgeben, dies habe ich mir hier mal gespart.
Siehe auch: