1C-Bitrix 25.700.0
Загрузка...
Поиск...
Не найдено
annotationtrait.php
См. документацию.
1<?php
2
3namespace Bitrix\Main\ORM\Annotations;
4
5use Bitrix\Main\Authentication\Context;
6use Bitrix\Main\DB\SqlExpression;
7use Bitrix\Main\Loader;
8use Bitrix\Main\ORM\Data\AddResult;
9use Bitrix\Main\ORM\Data\DataManager;
10use Bitrix\Main\ORM\Data\Result;
11use Bitrix\Main\ORM\Data\UpdateResult;
12use Bitrix\Main\ORM\Entity;
13use Bitrix\Main\ORM\Fields\ExpressionField;
14use Bitrix\Main\ORM\Fields\FieldTypeMask;
15use Bitrix\Main\ORM\Fields\Relations\ManyToMany;
16use Bitrix\Main\ORM\Fields\Relations\OneToMany;
17use Bitrix\Main\ORM\Fields\Relations\Reference;
18use Bitrix\Main\ORM\Fields\ScalarField;
19use Bitrix\Main\ORM\Fields\UserTypeField;
20use Bitrix\Main\ORM\Objectify\Collection;
21use Bitrix\Main\ORM\Objectify\State;
22use Bitrix\Main\ORM\Query\Query;
23use Bitrix\Main\Text\StringHelper;
24use Bitrix\Main\Type\Dictionary;
25
32
33trait AnnotationTrait
34{
41 public static function annotateEntity(Entity $entity, $ufOnly = false, $separateTable = false)
42 {
43 $entityNamespace = trim($entity->getNamespace(), '\\');
44 $dataClass = $entity->getDataClass();
45
46 $objectClass = $entity->getObjectClass();
47 $objectClassName = $entity->getObjectClassName();
48 $objectDefaultClassName = Entity::getDefaultObjectClassName($entity->getName());
49
50 $collectionClass = $entity->getCollectionClass();
51 $collectionClassName = $entity->getCollectionClassName();
52 $collectionDefaultClassName = Entity::getDefaultCollectionClassName($entity->getName());
53
54 $code = [];
55 $objectCode = [];
56 $collectionCode = [];
57
58 $code[] = "namespace {$entityNamespace} {"; // start namespace
59 $code[] = "\t/**"; // start class annotations
60 $code[] = "\t * {$objectClassName}";
61 $code[] = "\t * @see {$dataClass}";
62 $code[] = "\t *";
63 $code[] = "\t * Custom methods:";
64 $code[] = "\t * ---------------";
65 $code[] = "\t *";
66
67 $exceptions = [];
68
69 foreach ($entity->getFields() as $field)
70 {
71 $objectFieldCode = [];
72 $collectionFieldCode = [];
73
74 if ($ufOnly && !($field instanceof UserTypeField))
75 {
76 continue;
77 }
78
79 try
80 {
81 if ($field instanceof ScalarField)
82 {
83 [$objectFieldCode, $collectionFieldCode] = static::annotateScalarField($field);
84 }
85 elseif ($field instanceof UserTypeField)
86 {
87 [$objectFieldCode, $collectionFieldCode] = static::annotateUserType($field);
88 }
89 elseif ($field instanceof ExpressionField)
90 {
91 [$objectFieldCode, $collectionFieldCode] = static::annotateExpression($field);
92 }
93 elseif ($field instanceof Reference)
94 {
95 [$objectFieldCode, $collectionFieldCode] = static::annotateReference($field);
96 }
97 elseif ($field instanceof OneToMany)
98 {
99 [$objectFieldCode, $collectionFieldCode] = static::annotateOneToMany($field);
100 }
101 elseif ($field instanceof ManyToMany)
102 {
103 [$objectFieldCode, $collectionFieldCode] = static::annotateManyToMany($field);
104 }
105
106 $objectCode = array_merge($objectCode, $objectFieldCode);
107 $collectionCode = array_merge($collectionCode, $collectionFieldCode);
108 }
109 catch (\Exception $e)
110 {
111 $exceptions[] = new \Exception(
112 "Can not annotate `{$entity->getFullName()}.{$field->getName()}` field", 0, $e
113 );
114 }
115 }
116
117 // return if there is no fields to annotate (e.g. empty uf)
118 if ($ufOnly && empty($objectCode))
119 {
120 return null;
121 }
122
123 $code = array_merge($code, $objectCode);
124
125 if (!$ufOnly)
126 {
127 // common class methods
128 $code[] = "\t *";
129 $code[] = "\t * Common methods:";
130 $code[] = "\t * ---------------";
131 $code[] = "\t *";
132 $code[] = "\t * @property-read \\".Entity::class." \$entity";
133 $code[] = "\t * @property-read array \$primary";
134 $code[] = "\t * @property-read int \$state @see \\".State::class;
135 $code[] = "\t * @property-read \\".Dictionary::class." \$customData";
136 $code[] = "\t * @property \\".Context::class." \$authContext";
137 $code[] = "\t * @method mixed get(\$fieldName)";
138 $code[] = "\t * @method mixed remindActual(\$fieldName)";
139 $code[] = "\t * @method mixed require(\$fieldName)";
140 $code[] = "\t * @method bool has(\$fieldName)";
141 $code[] = "\t * @method bool isFilled(\$fieldName)";
142 $code[] = "\t * @method bool isChanged(\$fieldName)";
143 $code[] = "\t * @method {$objectClass} set(\$fieldName, \$value)";
144 $code[] = "\t * @method {$objectClass} reset(\$fieldName)";
145 $code[] = "\t * @method {$objectClass} unset(\$fieldName)";
146 $code[] = "\t * @method void addTo(\$fieldName, \$value)";
147 $code[] = "\t * @method void removeFrom(\$fieldName, \$value)";
148 $code[] = "\t * @method void removeAll(\$fieldName)";
149 $code[] = "\t * @method \\".Result::class." delete()";
150 $code[] = "\t * @method mixed fill(\$fields = \\".FieldTypeMask::class."::ALL) flag or array of field names";
151 $code[] = "\t * @method mixed[] collectValues(\$valuesType = \Bitrix\Main\ORM\Objectify\Values::ALL, \$fieldsMask = \Bitrix\Main\ORM\Fields\FieldTypeMask::ALL)";
152 $code[] = "\t * @method \\".AddResult::class."|\\".UpdateResult::class."|\\".Result::class." save()";
153 $code[] = "\t * @method static {$objectClass} wakeUp(\$data)";
154 }
155
156 //$code[] = "\t *";
157 //$code[] = "\t * for parent class, @see \\".EntityObject::class;
158 // xTODO we can put path to the original file here
159 $code[] = "\t */"; // end class annotations
160 $code[] = "\tclass {$objectDefaultClassName} {";
161 $code[] = "\t\t/* @var {$dataClass} */";
162 $code[] = "\t\tstatic public \$dataClass = '{$dataClass}';";
163 $code[] = "\t\t/**";
164 $code[] = "\t\t * @param bool|array \$setDefaultValues";
165 $code[] = "\t\t */";
166 $code[] = "\t\tpublic function __construct(\$setDefaultValues = true) {}";
167 $code[] = "\t}"; // end class
168
169 // compatibility with default classes
170 if (!str_starts_with($objectClassName, Entity::DEFAULT_OBJECT_PREFIX)) // better to compare full classes definitions
171 {
172 $defaultObjectClassName = Entity::getDefaultObjectClassName($entity->getName());
173
174 // no need anymore as far as custom class inherits EO_
175 //$code[] = "\tclass_alias('{$objectClass}', '{$entityNamespace}\\{$defaultObjectClassName}');";
176 }
177
178 $code[] = "}"; // end namespace
179
180 // annotate collection class
181 $code[] = "namespace {$entityNamespace} {"; // start namespace
182 $code[] = "\t/**";
183 $code[] = "\t * {$collectionClassName}";
184 $code[] = "\t *";
185 $code[] = "\t * Custom methods:";
186 $code[] = "\t * ---------------";
187 $code[] = "\t *";
188
189 $code = array_merge($code, $collectionCode);
190
191 if (!$ufOnly)
192 {
193 $code[] = "\t *";
194 $code[] = "\t * Common methods:";
195 $code[] = "\t * ---------------";
196 $code[] = "\t *";
197 $code[] = "\t * @property-read \\".Entity::class." \$entity";
198 $code[] = "\t * @method void add({$objectClass} \$object)";
199 $code[] = "\t * @method bool has({$objectClass} \$object)";
200 $code[] = "\t * @method bool hasByPrimary(\$primary)";
201 $code[] = "\t * @method {$objectClass} getByPrimary(\$primary)";
202 $code[] = "\t * @method {$objectClass}[] getAll()";
203 $code[] = "\t * @method bool remove({$objectClass} \$object)";
204 $code[] = "\t * @method void removeByPrimary(\$primary)";
205 $code[] = "\t * @method array|\\".Collection::class."|null fill(\$fields = \\".FieldTypeMask::class."::ALL) flag or array of field names";
206 $code[] = "\t * @method static {$collectionClass} wakeUp(\$data)";
207 $code[] = "\t * @method \\".Result::class." save(\$ignoreEvents = false)";
208 $code[] = "\t * @method void offsetSet() ArrayAccess";
209 $code[] = "\t * @method void offsetExists() ArrayAccess";
210 $code[] = "\t * @method void offsetUnset() ArrayAccess";
211 $code[] = "\t * @method void offsetGet() ArrayAccess";
212 $code[] = "\t * @method void rewind() Iterator";
213 $code[] = "\t * @method {$objectClass} current() Iterator";
214 $code[] = "\t * @method mixed key() Iterator";
215 $code[] = "\t * @method void next() Iterator";
216 $code[] = "\t * @method bool valid() Iterator";
217 $code[] = "\t * @method int count() Countable";
218 $code[] = "\t * @method {$collectionClass} merge(?{$collectionClass} \$collection)";
219 $code[] = "\t * @method bool isEmpty()";
220 $code[] = "\t * @method array collectValues(int \$valuesType = \Bitrix\Main\ORM\Objectify\Values::ALL, int \$fieldsMask = \Bitrix\Main\ORM\Fields\FieldTypeMask::ALL, bool \$recursive = false)";
221 }
222
223 // xTODO we can put path to the original file here
224 $code[] = "\t */";
225 $code[] = "\tclass {$collectionDefaultClassName} implements \ArrayAccess, \Iterator, \Countable {";
226 $code[] = "\t\t/* @var {$dataClass} */";
227 $code[] = "\t\tstatic public \$dataClass = '{$dataClass}';";
228 $code[] = "\t}"; // end class
229
230 // compatibility with default classes
231 if (!str_starts_with($collectionClassName, Entity::DEFAULT_OBJECT_PREFIX)) // better to compare full classes definitions
232 {
233 $defaultCollectionClassName = Entity::getDefaultCollectionClassName($entity->getName());
234
235 // no need anymore as far as custom class inherits EO_
236 //$code[] = "\tclass_alias('{$entityNamespace}\\{$collectionClassName}', '{$entityNamespace}\\{$defaultCollectionClassName}');";
237 }
238
239 $code[] = "}"; // end namespace
240
241 if (!$ufOnly)
242 {
243 // annotate Table class
244 $dataClassName = $entity->getName().'Table';
245 $resultClassName = Entity::DEFAULT_OBJECT_PREFIX.$entity->getName().'_Result';
246 $entityClassName = Entity::DEFAULT_OBJECT_PREFIX.$entity->getName().'_Entity';
247 $eoQueryClassName = Entity::DEFAULT_OBJECT_PREFIX.$entity->getName().'_Query';
248
249 // custom query class
250 if ($entity->getDataClass()::getQueryClass() !== Query::class)
251 {
252 $queryClassName = '\\'.$entity->getDataClass()::getQueryClass();
253 $reflectionClass = new \ReflectionClass($queryClassName);
254
255 if ($reflectionClass->getNamespaceName() === $entityNamespace)
256 {
257 // short syntax for the same namespace
258 $queryClassName = $reflectionClass->getShortName();
259 }
260 }
261 else
262 {
263 $queryClassName = $eoQueryClassName;
264 }
265
266 $code[] = "namespace {$entityNamespace} {"; // start namespace
267
268 if (!$separateTable)
269 {
270 $code[] = "\t/**";
271 }
272
273 $codeTable = [];
274 $codeTable[] = " * @method static {$queryClassName} query()";
275 $codeTable[] = " * @method static {$resultClassName} getByPrimary(\$primary, array \$parameters = [])";
276 $codeTable[] = " * @method static {$resultClassName} getById(\$id)";
277 $codeTable[] = " * @method static {$resultClassName} getList(array \$parameters = [])";
278 $codeTable[] = " * @method static {$entityClassName} getEntity()";
279 $codeTable[] = " * @method static {$objectClass} createObject(\$setDefaultValues = true)";
280 $codeTable[] = " * @method static {$collectionClass} createCollection()";
281 $codeTable[] = " * @method static {$objectClass} wakeUpObject(\$row)";
282 $codeTable[] = " * @method static {$collectionClass} wakeUpCollection(\$rows)";
283
284 if (!$separateTable)
285 {
286 // add tabs
287 foreach ($codeTable as $i => $line)
288 {
289 $codeTable[$i] = "\t".$line;
290 }
291
292 $code = array_merge($code, $codeTable);
293 $code[] = "\t */";
294 $code[] = "\tclass {$dataClassName} extends \\".DataManager::class." {}";
295 }
296
297 // annotate Query class
298 $code[] = "\t/**";
299 $code[] = "\t * Common methods:";
300 $code[] = "\t * ---------------";
301 $code[] = "\t *";
302 $code[] = "\t * @method {$resultClassName} exec()";
303 $code[] = "\t * @method {$objectClass} fetchObject()";
304 $code[] = "\t * @method {$collectionClass} fetchCollection()";
305
306 $customQueryMethodsCode = [];
307
308 foreach (get_class_methods($dataClass) as $method)
309 {
310 // search for with* methods
311 if (str_starts_with($method, 'with'))
312 {
313 $reflectionMethod = new \ReflectionMethod($dataClass, $method);
314
315 if ($reflectionMethod->isStatic())
316 {
317 $arguments = [];
318
319 // get parameters except the first one (query itself)
320 foreach (array_slice($reflectionMethod->getParameters(), 1) as $parameter)
321 {
322 $arguments[] = '$'.$parameter->getName();
323 }
324
325 $argumentsMeta = join(', ', $arguments);
326
327 $customQueryMethodsCode[] = "\t * @see {$dataClass}::{$method}()";
328 $customQueryMethodsCode[] = "\t * @method self {$method}({$argumentsMeta})";
329 }
330 }
331 }
332
333 if (!empty($customQueryMethodsCode))
334 {
335 $code[] = "\t *";
336 $code[] = "\t * Custom methods:";
337 $code[] = "\t * ---------------";
338 $code[] = "\t *";
339
340 array_push($code, $customQueryMethodsCode);
341 }
342
343 $code[] = "\t */";
344 $code[] = "\tclass {$eoQueryClassName} extends \\".Query::class." {}";
345
346 // annotate Result class
347 $code[] = "\t/**";
348 $code[] = "\t * @method {$objectClass} fetchObject()";
349 $code[] = "\t * @method {$collectionClass} fetchCollection()";
350 $code[] = "\t */";
351 $code[] = "\tclass {$resultClassName} extends \\".\Bitrix\Main\ORM\Query\Result::class." {}";
352
353 // annotate Entity class
354 $code[] = "\t/**";
355 $code[] = "\t * @method {$objectClass} createObject(\$setDefaultValues = true)";
356 $code[] = "\t * @method {$collectionClass} createCollection()";
357 $code[] = "\t * @method {$objectClass} wakeUpObject(\$row)";
358 $code[] = "\t * @method {$collectionClass} wakeUpCollection(\$rows)";
359 $code[] = "\t */";
360 $code[] = "\tclass {$entityClassName} extends \\".Entity::class." {}";
361
362 $code[] = "}"; // end namespace
363 }
364
365 if (!$separateTable)
366 {
367 return join("\n", $code);
368 }
369 else
370 {
371 return [
372 join("\n", $codeTable),
373 join("\n", $code),
374 $exceptions
375 ];
376 }
377 }
378
379 public static function annotateScalarField(ScalarField $field)
380 {
381 // TODO no setter if it is reference-elemental (could expressions become elemental?)
382
383 $objectClass = $field->getEntity()->getObjectClass();
384 $getterDataType = $field->getGetterTypeHint();
385 $setterDataType = $field->getSetterTypeHint();
386 list($lName, $uName) = static::getFieldNameCamelCase($field->getName());
387
388 $objectCode = [];
389 $collectionCode = [];
390
391 $objectCode[] = "\t * @method {$getterDataType} get{$uName}()";
392 $objectCode[] = "\t * @method {$objectClass} set{$uName}({$setterDataType}|\\".SqlExpression::class." \${$lName})";
393
394 $objectCode[] = "\t * @method bool has{$uName}()";
395 $objectCode[] = "\t * @method bool is{$uName}Filled()";
396 $objectCode[] = "\t * @method bool is{$uName}Changed()";
397
398 $collectionCode[] = "\t * @method {$getterDataType}[] get{$uName}List()";
399
400 if (!$field->isPrimary())
401 {
402 $objectCode[] = "\t * @method {$getterDataType} remindActual{$uName}()";
403 $objectCode[] = "\t * @method {$getterDataType} require{$uName}()";
404
405 $objectCode[] = "\t * @method {$objectClass} reset{$uName}()";
406 $objectCode[] = "\t * @method {$objectClass} unset{$uName}()";
407
408 $objectCode[] = "\t * @method {$getterDataType} fill{$uName}()";
409 $collectionCode[] = "\t * @method {$getterDataType}[] fill{$uName}()";
410 }
411
412 return [$objectCode, $collectionCode];
413 }
414
415 public static function annotateUserType(UserTypeField $field)
416 {
417 // no setter
418 $objectClass = $field->getEntity()->getObjectClass();
419
421 $scalarFieldClass = $field->getValueType();
422 $dataType = (new $scalarFieldClass('TMP'))->getSetterTypeHint();
423 $dataType = $field->isMultiple() ? $dataType.'[]' : $dataType;
424 list($lName, $uName) = static::getFieldNameCamelCase($field->getName());
425
426 list($objectCode, $collectionCode) = static::annotateExpression($field);
427
428 // add setter
429 $objectCode[] = "\t * @method {$objectClass} set{$uName}({$dataType} \${$lName})";
430
431 $objectCode[] = "\t * @method bool is{$uName}Changed()";
432
433 return [$objectCode, $collectionCode];
434 }
435
436 public static function annotateExpression(ExpressionField $field)
437 {
438 // no setter
439 $objectClass = $field->getEntity()->getObjectClass();
440
441 $scalarFieldClass = $field->getValueType();
442 $dataType = (new $scalarFieldClass('TMP'))->getGetterTypeHint();
443 list($lName, $uName) = static::getFieldNameCamelCase($field->getName());
444
445 $objectCode = [];
446 $collectionCode = [];
447
448 $objectCode[] = "\t * @method {$dataType} get{$uName}()";
449 $objectCode[] = "\t * @method {$dataType} remindActual{$uName}()";
450 $objectCode[] = "\t * @method {$dataType} require{$uName}()";
451
452 $objectCode[] = "\t * @method bool has{$uName}()";
453 $objectCode[] = "\t * @method bool is{$uName}Filled()";
454
455 $collectionCode[] = "\t * @method {$dataType}[] get{$uName}List()";
456
457 $objectCode[] = "\t * @method {$objectClass} unset{$uName}()";
458
459 $objectCode[] = "\t * @method {$dataType} fill{$uName}()";
460 $collectionCode[] = "\t * @method {$dataType}[] fill{$uName}()";
461
462 return [$objectCode, $collectionCode];
463 }
464
465 public static function annotateReference(Reference $field)
466 {
467 if (!static::tryToFindEntity($field->getRefEntityName()))
468 {
469 return [[], []];
470 }
471
472 $objectClass = $field->getEntity()->getObjectClass();
473 $collectionClass = $field->getEntity()->getCollectionClass();
474 $collectionDataType = $field->getRefEntity()->getCollectionClass();
475
476 $getterTypeHint = $field->getGetterTypeHint();
477 $setterTypeHint = $field->getSetterTypeHint();
478
479 list($lName, $uName) = static::getFieldNameCamelCase($field->getName());
480
481 $objectCode = [];
482 $collectionCode = [];
483
484 $objectCode[] = "\t * @method {$getterTypeHint} get{$uName}()";
485 $objectCode[] = "\t * @method {$getterTypeHint} remindActual{$uName}()";
486 $objectCode[] = "\t * @method {$getterTypeHint} require{$uName}()";
487
488 $objectCode[] = "\t * @method {$objectClass} set{$uName}({$setterTypeHint} \$object)";
489 $objectCode[] = "\t * @method {$objectClass} reset{$uName}()";
490 $objectCode[] = "\t * @method {$objectClass} unset{$uName}()";
491
492 $objectCode[] = "\t * @method bool has{$uName}()";
493 $objectCode[] = "\t * @method bool is{$uName}Filled()";
494 $objectCode[] = "\t * @method bool is{$uName}Changed()";
495
496 $collectionCode[] = "\t * @method {$getterTypeHint}[] get{$uName}List()";
497 $collectionCode[] = "\t * @method {$collectionClass} get{$uName}Collection()";
498
499 $objectCode[] = "\t * @method {$getterTypeHint} fill{$uName}()";
500 $collectionCode[] = "\t * @method {$collectionDataType} fill{$uName}()";
501
502 return [$objectCode, $collectionCode];
503 }
504
505 public static function annotateOneToMany(OneToMany $field)
506 {
507 if (!static::tryToFindEntity($field->getRefEntityName()))
508 {
509 return [[], []];
510 }
511
512 $objectClass = $field->getEntity()->getObjectClass();
513 $collectionDataType = $field->getRefEntity()->getCollectionClass();
514 $objectVarName = lcfirst($field->getRefEntity()->getName());
515
516 $setterTypeHint = $field->getSetterTypeHint();
517
518 list($lName, $uName) = static::getFieldNameCamelCase($field->getName());
519
520 $objectCode = [];
521 $collectionCode = [];
522
523 $objectCode[] = "\t * @method {$collectionDataType} get{$uName}()";
524 $objectCode[] = "\t * @method {$collectionDataType} require{$uName}()";
525 $objectCode[] = "\t * @method {$collectionDataType} fill{$uName}()";
526
527 $objectCode[] = "\t * @method bool has{$uName}()";
528 $objectCode[] = "\t * @method bool is{$uName}Filled()";
529 $objectCode[] = "\t * @method bool is{$uName}Changed()";
530
531 $objectCode[] = "\t * @method void addTo{$uName}({$setterTypeHint} \${$objectVarName})";
532 $objectCode[] = "\t * @method void removeFrom{$uName}({$setterTypeHint} \${$objectVarName})";
533 $objectCode[] = "\t * @method void removeAll{$uName}()";
534
535 $objectCode[] = "\t * @method {$objectClass} reset{$uName}()";
536 $objectCode[] = "\t * @method {$objectClass} unset{$uName}()";
537
538 $collectionCode[] = "\t * @method {$collectionDataType}[] get{$uName}List()";
539 $collectionCode[] = "\t * @method {$collectionDataType} get{$uName}Collection()";
540 $collectionCode[] = "\t * @method {$collectionDataType} fill{$uName}()";
541
542 return [$objectCode, $collectionCode];
543 }
544
545 public static function annotateManyToMany(ManyToMany $field)
546 {
547 if (!static::tryToFindEntity($field->getRefEntityName()))
548 {
549 return [[], []];
550 }
551
552 $objectClass = $field->getEntity()->getObjectClass();
553 $collectionDataType = $field->getRefEntity()->getCollectionClass();
554 $objectVarName = lcfirst($field->getRefEntity()->getName());
555
556 $setterTypeHint = $field->getSetterTypeHint();
557
558 list($lName, $uName) = static::getFieldNameCamelCase($field->getName());
559
560 $objectCode = [];
561 $collectionCode = [];
562
563 $objectCode[] = "\t * @method {$collectionDataType} get{$uName}()";
564 $objectCode[] = "\t * @method {$collectionDataType} require{$uName}()";
565 $objectCode[] = "\t * @method {$collectionDataType} fill{$uName}()";
566
567 $objectCode[] = "\t * @method bool has{$uName}()";
568 $objectCode[] = "\t * @method bool is{$uName}Filled()";
569 $objectCode[] = "\t * @method bool is{$uName}Changed()";
570
571 $objectCode[] = "\t * @method void addTo{$uName}({$setterTypeHint} \${$objectVarName})";
572 $objectCode[] = "\t * @method void removeFrom{$uName}({$setterTypeHint} \${$objectVarName})";
573 $objectCode[] = "\t * @method void removeAll{$uName}()";
574
575 $objectCode[] = "\t * @method {$objectClass} reset{$uName}()";
576 $objectCode[] = "\t * @method {$objectClass} unset{$uName}()";
577
578 $collectionCode[] = "\t * @method {$collectionDataType}[] get{$uName}List()";
579 $collectionCode[] = "\t * @method {$collectionDataType} get{$uName}Collection()";
580 $collectionCode[] = "\t * @method {$collectionDataType} fill{$uName}()";
581
582 return [$objectCode, $collectionCode];
583 }
584
585 public static function tryToFindEntity($entityClass)
586 {
587 $entityClass = Entity::normalizeEntityClass($entityClass);
588
589 if (!class_exists($entityClass))
590 {
591 // try to find remote entity
592 $classParts = array_values(array_filter(
593 explode('\\', strtolower($entityClass))
594 ));
595
596 if ($classParts[0] == 'bitrix')
597 {
598 $moduleName = $classParts[1];
599 }
600 else
601 {
602 $moduleName = $classParts[0].'.'.$classParts[1];
603 }
604
605 if (!Loader::includeModule($moduleName) || !class_exists($entityClass))
606 {
607 return false;
608 }
609 }
610
611 if ((new \ReflectionClass($entityClass))->isAbstract())
612 {
613 return false;
614 }
615
616 return true;
617 }
618
619 protected static function getFieldNameCamelCase($fieldName)
620 {
621 $upperFirstName = StringHelper::snake2camel($fieldName);
622 $lowerFirstName = lcfirst($upperFirstName);
623
624 return [$lowerFirstName, $upperFirstName];
625 }
626}
Bitrix\Main\Loader\includeModule
static includeModule($moduleName)
Определения loader.php:67
Bitrix\Main\ORM\Data\DataManager\$collectionClass
static $collectionClass
Определения datamanager.php:53
Bitrix\Main\ORM\Data\DataManager\$objectClass
static $objectClass
Определения datamanager.php:50
Bitrix\Main\ORM\Entity\normalizeEntityClass
static normalizeEntityClass($entityName)
Определения entity.php:770
Bitrix\Main\ORM\Entity\getDefaultObjectClassName
static getDefaultObjectClassName($entityName)
Определения entity.php:364
Bitrix\Main\ORM\Entity\$code
$code
Определения entity.php:53
Bitrix\Main\ORM\Entity\getDefaultCollectionClassName
static getDefaultCollectionClassName($entityName)
Определения entity.php:397
Bitrix\Main\ORM\Entity\DEFAULT_OBJECT_PREFIX
const DEFAULT_OBJECT_PREFIX
Определения entity.php:66
Bitrix\Main\Entity
Определения ufield.php:9
elseif
if( $daysToExpire >=0 &&$daysToExpire< 60 elseif)( $daysToExpire< 0)
Определения prolog_main_admin.php:393
$method
$method
Определения index.php:27