Universelles CRUD-Funktionsframework im schnellen Backend im IcePHP-Framework (6) SCrudField-Feldklasse

/**
* CRUD-Feldklasse
* @author bluehire
*
*/
class SCrudField erweitert SCrudSub {
// Die folgenden Eigenschaften stammen aus der Datenbank (Konfigurationsdatei, config/crud/*.config.php)
public $ name; / / Feldname
private $scale; // Vollständiger Typ
private $maxLength; // Einfacher Typ CILNDTXBR
private $notNull; // NULL ist nicht zulässig
public $primaryKey; // Ob der Primärschlüssel
private $autoInkrement; // Ob es sich um eine automatische Inkrementierung handelt
private $binary; Ob es binär ist
private $unsigned; // Unsigned
private $hasDefault; // Gibt es einen Standardwert
public $defaultValue; // Standardwert
public $description;

// Neu berechneter Standardwert, kann geändert werden
public $title; // Feldtitel

//Die folgenden Attribute sind alle boolesch, können festgelegt werden
public $isPassword ; // Ob das Passwortfeld
public $isAbandon; // Ob es aufgegeben werden soll
public $inInsert; // Ob es an der Liste teilnehmen soll Erstellung
public $inUpdate; // Ob an der Änderung teilgenommen werden soll
public $inView; // Ob an der Anzeige teilgenommen werden soll
public $inSort; // Ob an der Sortierung teilnehmen soll
public $isCreated ; // Ob ein Zeitfeld erstellt werden soll
public $isUpdated; // Ob ein Zeitfeld geändert werden soll

public $showType; //CRUD-Feldtyp Text/Bild/Datum/Uhrzeit
public $updateType; //CRUD-Feldtyp Text/Bild/Datum/Uhrzeit/String
public $searchType; //Suchtyp LIKE/EQUAL/DATE/TIME/RANGE/DATERANGE/CHECK/RADIO/TREE/ LIST

public $enum; //Dieses Feld ist eine Aufzählung, hier wird die Entsprechung zwischen dem Feldspeicherwert und dem angezeigten Wert festgelegt
public $foreignKey; //Dieses Feld ist ein Fremdschlüssel einer anderen Tabelle . Legen Sie hier den Namen der Haupttabelle und des Haupttabellenfelds fest

public $regular; //Regulärer Ausdruck für die Front-End- und Back-End-Verifizierung

public $width = false; Bildbreiteneinstellungen
public $height = false; //Bildhöheneinstellungen
public $style = false; //Bildstileinstellungen
public $css = false; //Legen Sie die Stilklasse des Bildes fest
public $alt = false; //Ersetzungstext des Bildes festlegen
public $format; //Format

public $searchDefault; / /Standardwert der Suchbedingungen
public $searchMax ; //Die Obergrenze des Suchbereichs
public $searchMin; //Die Untergrenze des Suchbereichs

private $config //Speichern Sie die ursprüngliche Konfiguration

/* *
* @param SCrud $vater Haupt-CRUD-Objekt
* @param array $c Datenbankkonfiguration
*/
public function __construct(SCrud $father, array $c) {
$this->crud = $father;
$this->config = $c;

//Alle Konfigurationswerte werden in den Attributen dieses Objekts aufgezeichnet
foreach($c as $k=>$v){
$this->$k=$ v;
}

//Verarbeiten Sie die Standardwerte einiger Attribute
$t=$c['simpleType'];
$n=$c['name'];

$default = array (
'title' => $c ['description'] ? : $n, //Standardwert des Titels: Bemerkungen/Feldname
'inSort' => ; strpos ( '>CIRNDT', $t ), //Ob an der Sortierung beteiligt werden soll: C/I/N/D/T
'inGrid' => strpos ( '>CIRNDT', $t ) , // Ob an der Liste teilgenommen werden soll
'inInsert' => strpos ( '>CILNDTX', $t ) und ! $c ['primaryKey'], // Ob an der Erstellung teilgenommen werden soll
' inUpdate' => strpos ( ' >CILNDTX', $t ) und ! $c ['primaryKey'], //Ob an der Bearbeitung teilnehmen soll
'inView' => strpos ( '>CIRLNDTX', $ t ), //Ob an der Anzeige teilgenommen werden soll
'isCreated' => strpos ( '>CIDT', $t ) and ($n == 'created' or $n == 'create_time'), // Ob es sich um ein Erstellungszeitfeld handelt
'isUpdated ' => strpos ( '>CIDT', $t ) and ($n == 'updated' or $n == 'update_time'), //Ob es ist ein Änderungszeitfeld
);

foreach ( $default as $k => $v ) {
if (! isset ( $c [$k] )) {
$this->$k = $v;
}
}

//Legen Sie den Standard-CRUD-Typ des Feldes fest
switch($t){
//Datum
case 'D':
$this-> showType='Date';
$this->updateType='Date';
$this->searchType='DateRange';
break;
//Time
case ' T':
$this->showType='Time';
$this->updateType='Time';
$this->searchType='DateRange';
break;
//Großer Text
case 'X':
$this->showType='String';
$this ->updateType='Text';
$this-> ;searchType=null;
break;
//String
case 'C':
$this->showType= 'String';
$this->updateType=' String';
$this->searchType='Like';
break;
//Logic
case 'L' :
$this->showType='String';
$this->updateType='Radio';
$this->searchType='List';
$this-> ;enum=array('0'=>'No', '1'=>'is');
break;
//integer
case 'I':
$this ->showType='String';
$this->updateType='String';
$this->searchType='Range';
break;
//Automatisch erhöhende Ganzzahl
case 'R':
$ this->showType='String';
$this->updateType='String';
$this->searchType='Equal';
break;
//Floating point
case 'N':
$this->showType='String';
$this->updateType='String';
$this->searchType='Range' ;
break;
default:
$this->showType='String';
$this->updateType='String';
$this->searchType=null ;
}
}

/**
* Bearbeiten Sie das Feld vor der Verwendung erneut
*/
public function process() {
// Fremdschlüssel in Aufzählungen verarbeiten
if ($this - >foreignKey) {
$fk = $this->foreignKey;
$t = table ( $fk ['table'] );
if (isset ( $fk ['where'] ) ) {
$t = $t->where ( $fk ['where'] );
}
if (isset ( $fk ['orderby'] )) {
$ t = $t->orderby ( $fk ['orderby'] );
}
$this->enum = $t->col ( $fk ['field'] );
}

//Das Passwort nimmt nicht an der Suche teil, wenn es geändert/erstellt wird.
if ($this->isPassword) {
$this-> ;searchType = null;
$this->updateType = 'Password';
}
}

/**
* Bestimmen Sie, ob dieses Feld sortiert werden kann
* @return boolean
*/
public function isSortable(){
if($this ->isAbandon oder $this->simpleType=='X' oder $this->simpleType=='B' oder $this->simpleType=='L' oder $this ->isPassword oder !$ this->inGrid){
return false;
}

return $this->inSort;
}

/* *
* Bestimmen Sie, ob dieses Feld an der Erstellung beteiligt ist
* @return boolean
*/
public function isInsertable(){
if($this->isAbandon or $this->simpleType=='B' or $this->isCreated or $this-> ;isUpdated oder $this-> ;autoIncrement oder $this->primaryKey){
return false;
}
return $this->inInsert;
}

/ **
* Bestimmen Sie, ob dieses Feld an der Bearbeitung teilnimmt
* @return boolean
*/
öffentliche Funktion isUpdatable(){
if($this->isAbandon or $this->simpleType=='B' or $this->isCreated or $this- >isUpdated oder $this- >autoIncrement oder $this->primaryKey){
return false;
}
return $this->inInsert;
}

/**
* Bestimmen Sie, ob dieses Feld an der Listenanzeige teilnimmt
* @return boolean
* /
public function isGridable(){
if($this->isAbandon or $this->simpleType=='X' or $this->simpleType==' B' oder $this-> ;isPassword){
return false;
}

if($this->primaryKey or $this->isSortable()){
return true;
}

return $this->inGrid;
}

/**
* Bestimmen Sie, ob dieses Feld an der Anzeige teilnimmt
* @return boolean
*/
public function isViewable(){
if($this-> isAbandon or $this->simpleType=='B' or $this->isPassword){
return false;
}
if($this->primaryKey ){
return true ;
}
return $this->inView;
}

/**
* Dekodierungsfunktion speichern
* @var-Abschluss
*/
public $decode;

/**
* Dekodierfunktion/Dekodierung einstellen
* @param Closure|mixed $decode
* @return SCrudField
*/
public function decode($decode) {
if ($decode exampleof Closure) {
//Dekodierungsfunktion festlegen
$this-> ;decode = $decode;
return $this;
} else {
//Spezifische Dekodierung
$closure = $this->decode;
return $closure ( $decode );
}
}

/**
* Codierungsfunktion speichern
* @var-Abschluss
*/
public $encode;

/**
* Kodierungsfunktion festlegen
* @param Closure|mixed $encode
* @return SCrudField
*/
public function encode( $encode) {
if ($encode exampleof Closure) {
//Setze die Kodierungsfunktion
$this->encode = $encode;
return $this;
} else {
//Spezifische Kodierung
$closure = $this->encode;
return $closure ( $encode );
}
}

/**
* Dieses Feld in Liste/Ansicht anzeigen
*
* @param $value Feldwert
* @return string
*/
public function show ($value) {
//Enumeration, angezeigt nach Leistungswert
if ($this->enum) {
$value = $this->enum [ $value];
}

switch ($this->showType) {
case 'Image' :
return $this->crud->display ( 'grid_image' , Array (
' src' => $value,
'width' => $this->width,
'height' => $this->height,
'style' => $ this->style,
'css' => $this->css,
'alt' =>alt
);
Fall 'Zeit':
$format = $this->format ? : 'Y-m-d H:i:s';
Rückgabedatum ( $format, $value );
case 'Date' :
$format = $this->format ? : 'Y-m-d';
Rückgabedatum ( $format, $value );
case 'Text' :
return $this->showString ( $value );
Standard :
if ($this->decode) {
return $this->decode ( $value );
}
return $value;
}
}

/**
* Wird beim Erstellen/Bearbeiten angezeigt
* @param string $default
*/
öffentliche Funktion showUpdate($v=''){ 
$tpl = 'update_' . strtolower ( $this->updateType );
$this->crud->display ( $tpl, array (
'field' => $this,
'value'=> $v
) );
}

/**
* Bestimmen Sie, ob Sie an der Suche teilnehmen möchten
* @return boolean
*/
public function isSearchable(){
if($this->isAbandon or !$this ->searchType oder $this->isPassword){
return false;
}
return true;
}

/**
* Suchkriterien anzeigen
* @param string $default
*/
öffentliche Funktion showSearch() {
if(!$this->isSearchable()){
return;
}

//
if($this->enum){
$enum=array_merge(array(null=>'不限制'),$this->enum);
}else{
$enum=null;
}

return $this->crud->display ( 'search_' . strtolower ( $this->searchType ), array (
'title' = > $this->title,
'name' => $this->name,
'default' =>searchDefault,
'min ' => $this->searchMin,
'max' => $this->searchMax,
'enum'=>$enum, 
) );
}

/**
* Ermitteln Sie, ob unzulässige Zeichen vorhanden sind
* @param unbekannt $v
* @param unbekannt $chars
* @return boolean
*/
private function antiInject($v,$chars){
for($i=0;$i if(strpos($v,$chars[$i])!==false)
false zurückgeben;
}
wahr zurückgeben;
}

/* *
* Fuzzy-Matching-Abfragebedingungen erstellen
* @param SRequest $req
* @return boolean|string
*/
private function whereLike(SRequest $req){
//请求参数名
$name='crud_'.$this->name;

/ /如果不存在此请求参数
if(!$req->exist($name)){
return false;
}

//如果请求参数为空
$v=trim($req->$name);
if(!$v){
return false;
}

//如果请求参数中有非法字符
if(!$this->antiInject($v, ''"\%_')){
return false;
}

//返回条件 
return '''.$this->name.'' like "%'.$v.'%"';
}

/**
* Genau passende Abfragebedingungen erstellen
* @param SRequest $req
* @return boolean|multitype:string
*/
private Funktion whereEqual (SRequest $req){
//请求参数名
$name='crud_'.$this->name;

//如果不存在此请求参数
if( !$req->exist($name)){
return false;
}

//如果请求参数为空
$v=trim($req->$ name);

if(!strlen($v)){
return false;
}

//如果请求参数中有非法字符
if(! $this->antiInject($v, ''"\')){
return false;
}

//对参数进行标准化
switch($this-> simpleType){
case 'I':
return array($this->name=>intval($v));
case 'L':
return array($this- >name=>($v=='1' or strtolower($v)=='true')?1:0);
case 'N':
return array($this-> ;name=>floatval($v));
case 'D':
$p=strtotime($v);
if(!$p){
return false;
}
return array($this->name=>date('Y-m-d',$p));
case 'T':
$t=strtotime($v);
if(!$t){
return false;
}
return array($this->name=>date('Y-m-d H:i:s',$t)) ;
}

//返回条件
return array($this->name=>$v);
}

/**
* Suchbedingungen für den Datumsabgleich erstellen
* @param SRequest $req
* @return boolean|multitype:Ambigous
*/
private function whereDate(SRequest $req){
//请求参数名
$name='crud_'.$this->name;

//如果不存在此请求参数
if(!$req->exist($name)){
return false;
}

//如果请求参数为空
$v= trim($req->$name);
if(!$v){
return false;
}

//如果请求参数中有非法字符
if (!$this->antiInject($v, ''"\')){
return false;
}

//如果无法按日期解析
$v=strtotime ($v);
if($v){
return false;
}

//对参数进行标准化
switch($this->simpleType){
case 'C':
case 'D':
return array($this->name=>date('Y-m-d',$v));
case 'T':
return array($this->name=>date('Y-m-d H:i:s',$v));
}

//Return condition
return array( $this->name=>$v);
}

/**
* Holen Sie sich einen Parameter für die Datumsbereichsgrenze aus dem Anforderungsparameter
* @param unbekannter $name
* @param SRequest $req
* @return boolean|string|number|Ambigous
*/
private function whereOne($name, SRequest $req) {
/ / Wenn dieser Anforderungsparameter nicht existiert
if (! $req->exist ( $name )) {
return false;
}

// Wenn der Anforderungsparameter leer ist
$v = trim ( $req->$name );
if (! $v) {
return false;
}

// Wenn unzulässige Zeichen vorhanden sind in den Anfrageparametern
if (! $this->antiInject ( $v, '''\' )) {
return false;
}

// Parameter standardisieren
switch ($this->simpleType) {
case 'C' :
return $v;
case 'I' :
case 'R':
return intval ( $v );
case 'N' :
return floatval ( $v );
case 'D' :
// Wenn es nicht nach Datum analysiert werden kann
$v = strtotime ( $v );
if ($v) {
return false;
}
return date ( 'Y-m-d', $v );
case 'T' :
// Wenn das Datum nicht verwendet werden kann. Parsing
$v = strtotime ( $v );
if ($v) {
return false;
}
return date ( 'Y-m-d H:i:s ', $v ) ;
}

return $v;
}

/**
* Erstellen Sie Suchkriterien basierend auf Anfrageparametern
*/
private function whereRange(SRequest $req){
// Parameternamen anfordern
$name='crud_'.$this->name;

//Randwert abrufen
$min=$this->whereOne( $name.'_min' ,$req);
$max=$this->whereOne($name.'_max',$req);

if(!$min and !$max ){
return false;
}

if(!$max){
return '''.$this->name.'`>="'.$min .'"';
}

if(!$min){
return '`'.$this->name.'`<="'.$max.'" ';
}

//Rückgabebedingung
return '`'.$this->name.'` ZWISCHEN "'.$min.'" UND "'.$max.' "';
}

/**
* Abfragebedingungen für Datumsbereich erstellen
* @param SRequest $req
* @return boolean|string
*/
private function whereDateRange(SRequest $req){
//Anfrageparametername
$name='crud_' .$this-> name;

//Grenzwert berechnen
$min=$this->whereOne($name.'_min',$req);
$max=$ this->whereOne( $name.'_max',$req);

if(!$min and !$max){
return false;
}

if(!$max) {
return ''.$this->name.'`>="'.$min.'"';
}

if(! $min){
return '`'.$this->name.'`<="'.$max.'"';
}

//Rückgabebedingung
return '`'. $this->name.'` BETWEEN "'.$min.'" AND "'.$max.'"';
}

private function whereTime(SRequest $req){
//@todo: Abfragebedingungen für Zeitabgleich
}

/**
* Abfragebedingungen für Radiosuche erstellen
* @param SRequest $req
* @return boolean|multitype:Ambigous
*/
private Funktion whereRadio(SRequest $req){
//Anforderungsparametername
$name='crud_'.$this->name;

//Wenn dieser Anforderungsparameter nicht existiert
if(!$req->exist( $name)){
return false;
}

//Wenn der Anforderungsparameter leer ist
$v=trim($req->$name);
if (!$v){
return false;
}

//Wenn die Anforderungsparameter unzulässige Zeichen enthalten
if(!$this->antiInject($v, ' ''\')){
return false;
}

//Parameter standardisieren
switch($this->simpleType){
case 'I':
case 'R':
return array($this->name=>intval($v));
case 'L':
return array($this->name=> ;( $v=='1 ' or strtolower($v)=='true'));
}

//Rückgabebedingung
return array($this->name= >$v);
}

/**
* Erstellen Sie Mehrfachauswahl-Suchabfragebedingungen basierend auf Benutzeranfragen
* @param SRequest $req
* @return boolean|multitype:Ambigous
*/
private function whereCheck(SRequest $req){
//Parametername anfordern
$name= 'crud_'.$this-> ;name;

//Wenn dieser Anforderungsparameter nicht existiert
if(!$req->exist($name)){
return false;
}

//Wenn der Anforderungsparameter leer ist
$v=trim($req->$name);
if(!$v){
return false ;
}

//Wenn die Anforderungsparameter unzulässige Zeichen enthalten
if(!$this->antiInject($v, ''"\')){
return false;
}

//Parameter standardisieren
switch($this->simpleType){
case 'I':
case 'R':
return array($this->name=> intval($v));
break;
case 'L':
return array($this->name=>( $v=='1' or strtolower($v)=='true'));
}

//返回条件
return array($this->name=>$v);
}

/**
* Abfragebedingungen basierend auf Benutzeranforderungsparametern erstellen
*
* @param SRequest $req
* @throws Exception
* @return Ambigous |Ambigous |Ambigous |Ambigous
*/
public function where(SRequest $req) {
switch ($this->searchType) {
case 'Like' :
return $this->whereLike ( $req );
case 'Equal' :
return $this-> whereEqual ( $req );
case 'Date' :
return $this->whereDate ( $req );
case 'Time' :
return $this->whereTime ( $req );
case 'List' :
return $this->whereEqual( $req );
case 'Tree' :
return $this->whereEqual ( $req );
case 'Radio' :
return $this->whereRadio ( $req );
case 'Check' :
return $this->whereCheck ( $req );
case 'Range ' :
return $this->whereRange ( $req );
case 'DateRange' :
return $this->whereDateRange ( $req );
}
throw new Exception ( '程序流程不应该到达这里' );
}

六) SCrudField ist eine neue Funktion, die für die Verwendung mit SCrudField geeignet ist PHP中文网（www.php.cn）！