Ubiquity  2.0.3
php rapid development framework
OrmUtils.php
Go to the documentation of this file.
1 <?php
2 
3 namespace Ubiquity\orm;
4 
10 
16 class OrmUtils {
17  private static $modelsMetadatas;
18 
19  public static function getModelMetadata($className) {
20  if (!isset(self::$modelsMetadatas[$className])) {
21  self::$modelsMetadatas[$className]=CacheManager::getOrmModelCache($className);
22  }
23  return self::$modelsMetadatas[$className];
24  }
25 
26  public static function isSerializable($class, $member) {
27  $ret=self::getAnnotationInfo($class, "#notSerializable");
28  if ($ret !== false)
29  return \array_search($member, $ret) === false;
30  else
31  return true;
32  }
33 
34  public static function isNullable($class, $member) {
35  $ret=self::getAnnotationInfo($class, "#nullable");
36  if ($ret !== false)
37  return \array_search($member, $ret) !== false;
38  else
39  return false;
40  }
41 
42  public static function getFieldName($class, $member) {
43  $ret=self::getAnnotationInfo($class, "#fieldNames");
44  if ($ret === false)
45  $ret=$member;
46  else
47  $ret=$ret[$member];
48  return $ret;
49  }
50 
51  public static function getFieldNames($model){
52  $fields=self::getAnnotationInfo($model, "#fieldNames");
53  $result=[];
54  $serializables=self::getSerializableFields($model);
55  foreach ($fields as $member=>$field){
56  if(\array_search($member, $serializables)!==false)
57  $result[$field]=$member;
58  }
59  return $result;
60  }
61 
62  public static function getTableName($class) {
63  if(isset(self::getModelMetadata($class)["#tableName"]))
64  return self::getModelMetadata($class)["#tableName"];
65  }
66 
67  public static function getKeyFieldsAndValues($instance) {
68  $kf=self::getAnnotationInfo(get_class($instance), "#primaryKeys");
69  return self::getMembersAndValues($instance, $kf);
70  }
71 
72  public static function getKeyFields($instance) {
73  if(!\is_string($instance)){
74  $instance=\get_class($instance);
75  }
76  return self::getAnnotationInfo($instance, "#primaryKeys");
77  }
78 
79  public static function getMembers($className) {
80  $fieldNames=self::getAnnotationInfo($className, "#fieldNames");
81  if ($fieldNames !== false)
82  return \array_keys($fieldNames);
83  return [ ];
84  }
85 
86  public static function getFieldTypes($className) {
87  $fieldTypes=self::getAnnotationInfo($className, "#fieldTypes");
88  if ($fieldTypes !== false)
89  return $fieldTypes;
90  return [ ];
91  }
92 
93  public static function getFieldType($className,$field){
94  $types= self::getFieldTypes($className);
95  if(isset($types[$field]))
96  return $types[$field];
97  return "int";
98  }
99 
100  public static function getMembersAndValues($instance, $members=NULL) {
101  $ret=array ();
102  $className=get_class($instance);
103  if (is_null($members))
104  $members=self::getMembers($className);
105  foreach ( $members as $member ) {
106  if (OrmUtils::isSerializable($className, $member)) {
107  $v=Reflexion::getMemberValue($instance, $member);
108  if (self::isNotNullOrNullAccepted($v, $className, $member)) {
109  $name=self::getFieldName($className, $member);
110  $ret[$name]=$v;
111  }
112  }
113  }
114  return $ret;
115  }
116 
117  public static function isNotNullOrNullAccepted($v, $className, $member) {
118  $notNull=UString::isNotNull($v);
119  return ($notNull) || (!$notNull && OrmUtils::isNullable($className, $member));
120  }
121 
122  public static function getFirstKey($class) {
123  $kf=self::getAnnotationInfo($class, "#primaryKeys");
124  return \reset($kf);
125  }
126 
127  public static function getFirstKeyValue($instance) {
128  $fkv=self::getKeyFieldsAndValues($instance);
129  return \reset($fkv);
130  }
131 
137  public static function getManyToOneMembersAndValues($instance) {
138  $ret=array ();
139  $class=get_class($instance);
140  $members=self::getAnnotationInfo($class, "#manyToOne");
141  if ($members !== false) {
142  foreach ( $members as $member ) {
143  $memberAccessor="get" . ucfirst($member);
144  if (method_exists($instance, $memberAccessor)) {
145  $memberInstance=$instance->$memberAccessor();
146  if (isset($memberInstance)) {
147  $keyValues=self::getKeyFieldsAndValues($memberInstance);
148  if (sizeof($keyValues) > 0) {
149  $fkName=self::getJoinColumnName($class, $member);
150  $ret[$fkName]=reset($keyValues);
151  }
152  }
153  }
154  }
155  }
156  return $ret;
157  }
158 
159  public static function getMembersWithAnnotation($class, $annotation) {
160  if (isset(self::getModelMetadata($class)[$annotation]))
161  return self::getModelMetadata($class)[$annotation];
162  return [ ];
163  }
164 
172  public static function exists($instance, $memberKey, $array) {
173  $accessor="get" . ucfirst($memberKey);
174  if (method_exists($instance, $accessor)) {
175  if ($array !== null) {
176  foreach ( $array as $value ) {
177  if ($value->$accessor() == $instance->$accessor())
178  return true;
179  }
180  }
181  }
182  return false;
183  }
184 
185  public static function getJoinColumnName($class, $member) {
186  $annot=self::getAnnotationInfoMember($class, "#joinColumn", $member);
187  if ($annot !== false) {
188  $fkName=$annot["name"];
189  } else {
190  $fkName="id" . ucfirst(self::getTableName(ucfirst($member)));
191  }
192  return $fkName;
193  }
194 
195  public static function getAnnotationInfo($class, $keyAnnotation) {
196  if (isset(self::getModelMetadata($class)[$keyAnnotation]))
197  return self::getModelMetadata($class)[$keyAnnotation];
198  return false;
199  }
200 
201  public static function getAnnotationInfoMember($class, $keyAnnotation, $member) {
202  $info=self::getAnnotationInfo($class, $keyAnnotation);
203  if ($info !== false) {
204  if(UArray::isAssociative($info)){
205  if (isset($info[$member])) {
206  return $info[$member];
207  }
208  }else{
209  if(\array_search($member, $info)!==false){
210  return $member;
211  }
212  }
213  }
214  return false;
215  }
216 
217  public static function getSerializableFields($class) {
218  $notSerializable=self::getAnnotationInfo($class, "#notSerializable");
219  $fieldNames=\array_keys(self::getAnnotationInfo($class, "#fieldNames"));
220  return \array_diff($fieldNames, $notSerializable);
221  }
222 
223  public static function getFieldsInRelations($class) {
224  $result=[ ];
225  if ($manyToOne=self::getAnnotationInfo($class, "#manyToOne")) {
226  $result=\array_merge($result, $manyToOne);
227  }
228  if ($oneToMany=self::getAnnotationInfo($class, "#oneToMany")) {
229  $result=\array_merge($result, \array_keys($oneToMany));
230  }
231  if ($manyToMany=self::getAnnotationInfo($class, "#manyToMany")) {
232  $result=\array_merge($result, \array_keys($manyToMany));
233  }
234  return $result;
235  }
236 
237  public static function getManyToOneFields($class) {
238  return self::getAnnotationInfo($class, "#manyToOne");
239  }
240 
241  public static function getManyToManyFields($class) {
242  $result=self::getAnnotationInfo($class, "#manyToMany");
243  if($result!==false)
244  return \array_keys($result);
245  return [];
246  }
247 
248  public static function getDefaultFk($classname) {
249  return "id" . \ucfirst(self::getTableName($classname));
250  }
251 
252  public static function getMemberJoinColumns($instance,$member,$metaDatas=NULL){
253  if(!isset($metaDatas)){
254  $class=get_class($instance);
255  $metaDatas=self::getModelMetadata($class);
256  }
257  $invertedJoinColumns=$metaDatas["#invertedJoinColumn"];
258  foreach ($invertedJoinColumns as $field=>$invertedJoinColumn){
259  if($invertedJoinColumn["member"]===$member){
260  return [$field,$invertedJoinColumn];
261  }
262  }
263  return null;
264  }
265 
266  public static function objectAsJSON($instance){
267  $formatter=new ResponseFormatter();
268  $datas=$formatter->cleanRestObject($instance);
269  return $formatter->format(["pk"=>self::getFirstKeyValue($instance),"object"=>$datas]);
270  }
271 }
static getManyToOneMembersAndValues($instance)
Definition: OrmUtils.php:137
static getMemberJoinColumns($instance, $member, $metaDatas=NULL)
Definition: OrmUtils.php:252
static getFieldsInRelations($class)
Definition: OrmUtils.php:223
static getMembers($className)
Definition: OrmUtils.php:79
static getAnnotationInfo($class, $keyAnnotation)
Definition: OrmUtils.php:195
static getDefaultFk($classname)
Definition: OrmUtils.php:248
static getAnnotationInfoMember($class, $keyAnnotation, $member)
Definition: OrmUtils.php:201
static isNotNullOrNullAccepted($v, $className, $member)
Definition: OrmUtils.php:117
static getFieldType($className, $field)
Definition: OrmUtils.php:93
Utilitaires de mappage Objet/relationnel.
Definition: OrmUtils.php:16
static getFirstKey($class)
Definition: OrmUtils.php:122
static getFirstKeyValue($instance)
Definition: OrmUtils.php:127
static getKeyFieldsAndValues($instance)
Definition: OrmUtils.php:67
static isNullable($class, $member)
Definition: OrmUtils.php:34
static isSerializable($class, $member)
Definition: OrmUtils.php:26
static objectAsJSON($instance)
Definition: OrmUtils.php:266
static isAssociative($array)
Tests if array is associative.
Definition: UArray.php:17
static exists($instance, $memberKey, $array)
Definition: OrmUtils.php:172
static getMemberValue($instance, $member)
Definition: Reflexion.php:34
static getFieldTypes($className)
Definition: OrmUtils.php:86
static getMembersAndValues($instance, $members=NULL)
Definition: OrmUtils.php:100
static getFieldNames($model)
Definition: OrmUtils.php:51
static getModelMetadata($className)
Definition: OrmUtils.php:19
static getManyToManyFields($class)
Definition: OrmUtils.php:241
static getJoinColumnName($class, $member)
Definition: OrmUtils.php:185
static getTableName($class)
Definition: OrmUtils.php:62
static getFieldName($class, $member)
Definition: OrmUtils.php:42
static getManyToOneFields($class)
Definition: OrmUtils.php:237
static getKeyFields($instance)
Definition: OrmUtils.php:72
static getMembersWithAnnotation($class, $annotation)
Definition: OrmUtils.php:159
static getSerializableFields($class)
Definition: OrmUtils.php:217