Cadre de fonctions CRUD universel dans le backend rapide du framework IcePHP (6) Classe de champ SCrudField

/**
* Classe de terrain CRUD
* @author bluehire
*
*/
class SCrudField extends SCrudSub {
// Les propriétés suivantes proviennent de la base de données (fichier de configuration, config/crud/*.config.php)
public $ name; / / Nom du champ
private $scale; // Précision
private $type; // Type complet
private $maxLength; // Longueur maximale
public $simpleType;
private $notNull; // NULL n'est pas autorisé
public $primaryKey; // Si la clé primaire
private $autoIncrement; // Si elle est auto-incrémentée
private $binary; Qu'il soit binaire
private $unsigned; // Unsigned
private $hasDefault; // Existe-t-il une valeur par défaut
public $defaultValue; // Valeur par défaut
public $description;

// Valeur par défaut recalculée, peut être modifiée
public $title; // Titre du champ

//Les attributs suivants sont tous booléens, peuvent être définis
public $isPassword ; // Si le champ du mot de passe est
public $ isAbandon; // S'il doit être abandonné
public $inGrid; // S'il doit participer à la liste
public $inInsert; création
public $inUpdate; // S'il faut participer à la modification
public $inView; // S'il faut participer au visionnage
public $inSort; // S'il faut participer au tri
public $isCreated ; // S'il faut créer un champ temporel
public $isUpdated; // S'il faut modifier un champ temporel

public $showType; //Type de champ CRUD Text/Image/Date/Time/String
public $updateType; //Type de champ CRUD Text/Image/Date/Time/String
public $searchType; //Type de recherche LIKE/EQUAL/DATE/TIME/RANGE/DATERANGE/CHECK/RADIO/TREE/ LIST

public $enum; //Ce champ est une énumération, définissez ici la correspondance entre la valeur de stockage du champ et la valeur affichée
public $foreignKey; //Ce champ est une clé étrangère d'une autre table; . Définissez ici le nom de la table principale et le nom du champ de la table principale

public $regular; //Expression régulière utilisée pour la vérification frontale et back-end

public $width = false; Paramètres de largeur de l'image
public $height = false; //Paramètres de hauteur de l'image
public $style = false; //Paramètres de style d'image
public $css = false; 🎜>public $alt = false; //Définissez le texte de remplacement de l'image
public $format; //Format

public $searchDefault; / /Valeur par défaut des conditions de recherche
public $searchMax ; //La limite supérieure de la plage de recherche
public $searchMin; //La limite inférieure de la plage de recherche

private $config; //Enregistrer la configuration d'origine

/* *
* @param SCrud $objet CRUD principal du père
* @param array $c configuration de la base de données
*/
fonction publique __construct(SCrud $père, tableau $c) {
$this->crud = $père;
$this->config = $c;

//Toutes les valeurs de configuration sont enregistrées dans les attributs de cet objet
foreach($c as $k=>$v){
$this->$k=$ v;
}

//Gérer les valeurs par défaut de certains attributs
$t=$c['simpleType'];
$n=$c['name'];

$default = array (
'title' => $c ['description'] ? : $n, //Valeur par défaut du titre : remarques/nom du champ
'inSort' => ; strpos ( '>CIRNDT', $t ), //S'il faut participer au tri : C/I/N/D/T
'inGrid' => strpos ( '>CIRLNDT', $t ) , // S'il faut participer à la liste
'inInsert' => strpos ( '>CILNDTX', $t ) et ! $c ['primaryKey'], // S'il faut participer à la création
' inUpdate' => strpos ( ' >CILNDTX', $t ) et ! $c ['primaryKey'], //S'il faut participer à l'édition
'inView' => t ), //S'il faut participer à display
'isCreated' => strpos ( '>CIDT', $t ) et ($n == 'created' ou $n == 'create_time'), // Qu'il s'agisse d'un champ d'heure de création
'isUpdated ' => strpos ( '>CIDT', $t ) et ($n == 'updated' ou $n == 'update_time'), //Qu'il s'agisse est un champ d'heure de modification
);

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

//Définir le type CRUD par défaut du champ
switch($t){
//Date
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;
//Grand texte
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'=>'Non', '1'=>'is');
break;
//integer
case 'I':
$this ->showType='String';
$this->updateType='String';
$this->searchType='Range';
break;
//Entier à augmentation automatique
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;
par défaut :
$this->showType='String';
$this->updateType='String';
$this->searchType=null ;
}
}

/**
* Traitez à nouveau le champ avant utilisation
*/
public function process() {
// Traiter les clés étrangères en énumérations
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'] );
>

//Le mot de passe ne participe pas à la recherche. Lorsqu'il est modifié/créé, il s'affiche en fonction du mot de passe
if ($this->isPassword) {
$this->. ;searchType = null;
$this->updateType = 'Password';
}
}

/**
* Déterminer si ce champ peut être trié
* @return boolean
*/
public function isSortable(){
if($this ->isAbandon ou $this->simpleType=='X' ou $this->simpleType=='B' ou $this->simpleType=='L' ou $this ->isPassword ou !$ this->inGrid){
return false;
}

return $this->inSort;
}

/* *
* Déterminer si ce champ participe à la création
* @return boolean
*/
public function isInsertable(){
if($this->isAbandon ou $this->simpleType=='B' ou $this->isCreated ou $this-> ;isUpdated ou $this-> ;autoIncrement ou $this->primaryKey){
return false;
>
return $this->inInsert;
}

/ **
* Déterminer si ce champ participe à l'édition
* @return boolean
*/
public function isUpdatable(){
if($this->isAbandon ou $this->simpleType=='B' ou $this->isCreated ou $this- >isUpdated ou $this- >autoIncrement ou $this->primaryKey){
return false;
>
return $this->inInsert;
}

/**
* Déterminer si ce champ participe à l'affichage de la liste
* @return boolean
* /
public function isGridable(){
if($this->isAbandon ou $this->simpleType=='X' ou $this->simpleType==' B' ou $this-> ;isPassword){
return false;
}

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

return $this->inGrid;
}

/**
* Déterminer si ce champ participe au visionnage
* @return boolean
*/
public function isViewable(){
if($this-> isAbandon ou $this->simpleType=='B' ou $this->isPassword){
return false;
}
if($this->primaryKey ){
return true ;
}
return $this->inView;
}

/**
* Enregistrer la fonction de décodage
* @var Closure
*/
public $decode;

/**
* Définir la fonction de décodage/décodage
* @param Closure|mixed $decode
* @return SCrudField
*/
public function decode($decode) {
if ($decode instanceof Closure) {
//Définir la fonction de décodage
$this-> ;decode = $decode;
return $this;
} else {
//Décodage spécifique
$closure = $this->decode;
return $closure ( $decode );
}
}

/**
* Enregistrer la fonction d'encodage
* @var Closure
*/
public $encode;

/**
* Définir la fonction d'encodage
* @param Closure|mixed $encode
* @return SCrudField
*/
public function encode( $encode) {
if ($encode instanceof Closure) {
//Définir la fonction d'encodage
$this->encode = $encode;
return $this;
} else {
//Encodage spécifique
$closure = $this->encode;
return $closure ( $encode );
}
}

/**
* Afficher ce champ dans la liste/vue
*
* @param $value field value
* @return string
*/
public function show ($value) {
//Enumeration, affiché par valeur de performance
if ($this->enum) {
$value = $this->enum [ $value];
>

switch ($this->showType) {
case 'Image' :
return $this->crud->display ( 'grid_image' , tableau (
' src' => $value,
'width' => $this->width,
'height' => $this->height,
'style' => $this->style,
'css' => $this->css,
'alt' => $this->alt
) );
cas 'Heure' :
$format = $this->format ? : 'Y-m-d H:i:s';
date de retour ( $format, $value );
case 'Date' :
$format = $this->format ? : 'Y-m-d';
date de retour ( $format, $value );
case 'Text' :
return $this->showString ( $value );
default :
if ($this->decode) {
return $this->decode ( $value );
>
return $value;
}
}

/**
* Affiché lors de la création/modification
* @param string $default
*/
public function showUpdate($v=''){ 
$tpl = 'update_' . strtolower ( $this->updateType );
$this->crud->display ( $tpl, array (
'field' => $this,
'value'=> $v
) );
}

/**
* Déterminer si vous souhaitez participer à la recherche
* @return boolean
*/
public function isSearchable(){
if($this->isAbandon ou !$this ->searchType ou $this->isPassword){
return false;
}
return true;
}

/**
* Afficher un critère de recherche
* @param string $default
*/
public function 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' => $this->searchDefault,
'min. ' => $this->searchMin,
'max' => $this->searchMax,
'enum'=>$enum, 
) );
}

/**
* Déterminer s'il y a des caractères non autorisés
* @param inconnu $v
* @param inconnu $chars
* @return boolean
*/
fonction privée antiInject($v,$chars){
for($i=0;$i if(strpos($v,$chars[$i])!==false)
return false;
}
return true;
}

/* *
* Construire des conditions de requête à correspondance floue
* @param SRequest $req
* @return boolean|string
*/
fonction privée 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.'%"';
}

/**
* Construire des conditions de requête correspondantes exactes
* @param SRequest $req
* @return boolean|multitype:string
*/
fonction privéewhereEqual (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' ou strtolower($v)=='true')?1:0);
case 'N':
return array($this-> ;name=>floatval($v));
case 'D':
$p=strtotime($v);
if(!$p){
return false;
}
tableau de retour ($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)) ;
}

//返回条件
tableau de retour ($this->name=>$v);
}

/**
* Construire les conditions de recherche correspondant à la date
* @param SRequest $req
* @return boolean|multitype:Ambigous
*/
fonction privée WhereDate(SRequest $req){
//请求参数名
$name='crud_'.$this->name;

//如果不存在如果请求参数为空
$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':
tableau de retour ($this->name=>date('Y-m-d H:i:s',$v));
}

//Condition de retour
tableau de retour( $this->name=>$v);
}

/**
* Obtenez un paramètre de limite de plage de dates à partir du paramètre de requête
* @param inconnu $name
* @param SRequest $req
* @return boolean|string|number|Ambigous
*/
fonction privée WhereOne($name, SRequest $req) {
/ / Si ce paramètre de requête n'existe pas
if (! $req->exist ( $name )) {
return false;
}

// Si le paramètre de requête est vide
$v = trim ( $req->$name );
if (! $v) {
return false;
}

// S'il y a des caractères illégaux dans les paramètres de la requête
if (! $this->antiInject ( $v, '''\' )) {
return false;
}

// Standardiser les paramètres
switch ($this->simpleType) {
case 'C' :
return $v;
case 'I' :
case 'R':
return intval ( $v );
case 'N' :
return floatval ( $v );
case 'D' :
// S'il ne peut pas être analysé par date
$v = strtotime ( $v );
if ($v) {
return false;
}
date de retour ( 'Y-m-d', $v );
case 'T' :
// Si la date ne peut pas être utilisée Parsing
$v = strtotime ( $v );
if ($v) {
return false;
>
return date ( 'Y-m-d H:i:s ', $v ) ;
}

return $v;
}

/**
* Créer des critères de recherche basés sur les paramètres de la demande
*/
fonction privée WhereRange(SRequest $req){
// Nom du paramètre de requête
$name='crud_'.$this->name;

//Obtenir la valeur limite
$min=$this->whereOne( $name.'_min' ,$req);
$max=$this->whereOne($name.'_max',$req);

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

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

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

//Condition de retour
return '`'.$this->name.'` ENTRE "'.$min.'" ET "'.$max.' "';
}

/**
* Construire des conditions de requête pour la plage de dates
* @param SRequest $req
* @return boolean|string
*/
fonction privéewhereDateRange(SRequest $req){
//Nom du paramètre de requête
$name='crud_' .$this-> name;

//Calculer la valeur limite
$min=$this->whereOne($name.'_min',$req);
$max=$ this->whereOne( $name.'_max',$req);

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

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

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

//Condition de retour
return '`'. $this->name.'` ENTRE "'.$min.'" ET "'.$max.'"';
>

fonction privéewhereTime(SRequest $req){
//@todo : Conditions de requête pour la correspondance temporelle
}

/**
* Construire les conditions de requête pour la recherche à sélection unique
* @param SRequest $req
* @return boolean|multitype:Ambigous
*/
fonction privée WhereRadio(SRequest $req){
//Nom du paramètre de requête
$name='crud_'.$this->name;

//Si ce paramètre de requête n'existe pas
if(!$req->exist( $name)){
return false;
}

//Si le paramètre de requête est vide
$v=trim($req->$name);
if (!$v){
return false;
}

//S'il y a des caractères illégaux dans les paramètres de la requête
if(!$this->antiInject($v, ' "\')){
return false;
}

//Standardiser les paramètres
switch($this->simpleType){
case 'I' :
case 'R' :
tableau de retour ($this->name=>intval($v));
case 'L' :
tableau de retour ($this->name=> ( $v=='1 ' ou strtolower($v)=='true'));
}

//Condition de retour
tableau de retour($this->name=> ;$v);
}

/**
* Construire des conditions de requête de recherche à sélection multiple en fonction des demandes des utilisateurs
* @param SRequest $req
* @return boolean|multitype:Ambigous
*/
fonction privée WhereCheck(SRequest $req){
//Nom du paramètre de requête
$name=' crud_'.$this-> ;name;

//Si ce paramètre de requête n'existe pas
if(!$req->exist($name)){
return false;
}

//Si le paramètre de requête est vide
$v=trim($req->$name);
if(!$v){
return false;
}

//S'il y a des caractères illégaux dans les paramètres de la requête
if(!$this->antiInject($v, ''"\')){
return false ;
}

//Standardiser les paramètres
switch($this->simpleType){
case 'I':
case 'R':
tableau de retour ($this->name=> intval($v));
break;
case 'L':
return array($this->name=>( $v=='1' ou strtolower($v)=='true'));
}

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

/**
* Construire des conditions de requête basées sur les paramètres de requête de l'utilisateur
*
* @param SRequest $req
* @throws Exception
* @return Ambigous |Ambigous |Ambigous |Ambigous
*/
fonction publique où(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 );
>
lancer une nouvelle exception ( '程序流程不应该到达这里' );
}

 以上就是IcePHP框架中的快速后台中的通用CRUD功能框架(六) SCrudField 字段类的内容，更多相关内容请关注PHP中文网（www.php.cn）！