Elgg  Version 5.1
ElggEntity.php
Go to the documentation of this file.
1 <?php
2 
10 
46 abstract class ElggEntity extends \ElggData implements EntityIcon {
47 
48  use Subscriptions;
49 
50  public const PRIMARY_ATTR_NAMES = [
51  'guid',
52  'type',
53  'subtype',
54  'owner_guid',
55  'container_guid',
56  'access_id',
57  'time_created',
58  'time_updated',
59  'last_action',
60  'enabled',
61  ];
62 
66  protected const INTEGER_ATTR_NAMES = [
67  'guid',
68  'owner_guid',
69  'container_guid',
70  'access_id',
71  'time_created',
72  'time_updated',
73  'last_action',
74  ];
75 
81  protected $temp_metadata = [];
82 
88  protected $temp_annotations = [];
89 
95  protected $volatile = [];
96 
101  protected $orig_attributes = [];
102 
106  protected $_is_cacheable = true;
107 
118  protected $_cached_metadata;
119 
134  public function __construct(stdClass $row = null) {
135  $this->initializeAttributes();
136 
137  if (!empty($row) && !$this->load($row)) {
138  throw new IOException('Failed to load new ' . get_class() . " for GUID: {$row->guid}");
139  }
140  }
141 
149  protected function initializeAttributes() {
150  parent::initializeAttributes();
151 
152  $this->attributes['guid'] = null;
153  $this->attributes['type'] = $this->getType();
154  $this->attributes['subtype'] = null;
155 
156  $this->attributes['owner_guid'] = _elgg_services()->session_manager->getLoggedInUserGuid();
157  $this->attributes['container_guid'] = _elgg_services()->session_manager->getLoggedInUserGuid();
158 
159  $this->attributes['access_id'] = ACCESS_PRIVATE;
160  $this->attributes['time_updated'] = null;
161  $this->attributes['last_action'] = null;
162  $this->attributes['enabled'] = 'yes';
163  }
164 
175  public function __clone() {
176  $orig_entity = get_entity($this->guid);
177  if (!$orig_entity) {
178  _elgg_services()->logger->error("Failed to clone entity with GUID $this->guid");
179  return;
180  }
181 
182  $metadata_array = elgg_get_metadata([
183  'guid' => $this->guid,
184  'limit' => false,
185  ]);
186 
187  $this->attributes['guid'] = null;
188  $this->attributes['time_created'] = null;
189  $this->attributes['time_updated'] = null;
190  $this->attributes['last_action'] = null;
191 
192  $this->attributes['subtype'] = $orig_entity->getSubtype();
193 
194  // copy metadata over to new entity - slightly convoluted due to
195  // handling of metadata arrays
196  if (is_array($metadata_array)) {
197  // create list of metadata names
198  $metadata_names = [];
199  foreach ($metadata_array as $metadata) {
200  $metadata_names[] = $metadata->name;
201  }
202 
203  // arrays are stored with multiple enties per name
204  $metadata_names = array_unique($metadata_names);
205 
206  // move the metadata over
207  foreach ($metadata_names as $name) {
208  $this->__set($name, $orig_entity->$name);
209  }
210  }
211  }
212 
228  public function __set($name, $value) {
229  if ($this->$name === $value) {
230  // quick return if value is not changing
231  return;
232  }
233 
234  if (array_key_exists($name, $this->attributes)) {
235  // if an attribute is 1 (integer) and it's set to "1" (string), don't consider that a change.
236  if (is_int($this->attributes[$name])
237  && is_string($value)
238  && ((string) $this->attributes[$name] === $value)) {
239  return;
240  }
241 
242  // keep original values
243  if ($this->guid && !array_key_exists($name, $this->orig_attributes)) {
244  $this->orig_attributes[$name] = $this->attributes[$name];
245  }
246 
247  // Certain properties should not be manually changed!
248  switch ($name) {
249  case 'guid':
250  case 'last_action':
251  case 'time_updated':
252  case 'type':
253  return;
254  case 'subtype':
255  throw new ElggInvalidArgumentException(elgg_echo('ElggEntity:Error:SetSubtype', ['setSubtype()']));
256  case 'enabled':
257  throw new ElggInvalidArgumentException(elgg_echo('ElggEntity:Error:SetEnabled', ['enable() / disable()']));
258  case 'access_id':
259  case 'owner_guid':
260  case 'container_guid':
261  if ($value !== null) {
262  $this->attributes[$name] = (int) $value;
263  } else {
264  $this->attributes[$name] = null;
265  }
266  break;
267  default:
268  $this->attributes[$name] = $value;
269  break;
270  }
271 
272  return;
273  }
274 
275  $this->setMetadata($name, $value);
276  }
277 
283  public function getOriginalAttributes(): array {
284  return $this->orig_attributes;
285  }
286 
299  public function __get($name) {
300  if (array_key_exists($name, $this->attributes)) {
301  return $this->attributes[$name];
302  }
303 
304  return $this->getMetadata($name);
305  }
306 
312  public function getDisplayName(): string {
313  return (string) $this->name;
314  }
315 
322  public function setDisplayName(string $display_name): void {
323  $this->name = $display_name;
324  }
325 
333  public function getMetadata(string $name) {
334  $metadata = $this->getAllMetadata();
335  return elgg_extract($name, $metadata);
336  }
337 
343  public function getAllMetadata(): array {
344  if (!$this->guid) {
345  return array_map(function($values) {
346  return count($values) > 1 ? $values : $values[0];
348  }
349 
350  $this->_cached_metadata = _elgg_services()->metadataCache->getAll($this->guid);
351 
353  }
354 
370  public function setMetadata(string $name, $value, string $value_type = '', bool $multiple = false): bool {
371 
372  if ($value === null || $value === '') {
373  return $this->deleteMetadata($name);
374  }
375 
376  // normalize value to an array that we will loop over
377  // remove indexes if value already an array.
378  if (is_array($value)) {
379  $value = array_values($value);
380  } else {
381  $value = [$value];
382  }
383 
384  // strip null values from array
385  $value = array_filter($value, function($var) {
386  return !is_null($var);
387  });
388 
389  if (empty($this->guid)) {
390  // unsaved entity. store in temp array
391  return $this->setTempMetadata($name, $value, $multiple);
392  }
393 
394  // saved entity. persist md to db.
395  if (!$multiple) {
396  $current_metadata = $this->getMetadata($name);
397 
398  if ((is_array($current_metadata) || count($value) > 1 || $value === []) && isset($current_metadata)) {
399  // remove current metadata if needed
400  // need to remove access restrictions right now to delete
401  // because this is the expected behavior
402  $delete_result = elgg_call(ELGG_IGNORE_ACCESS, function() use ($name) {
403  return elgg_delete_metadata([
404  'guid' => $this->guid,
405  'metadata_name' => $name,
406  'limit' => false,
407  ]);
408  });
409 
410  if ($delete_result === false) {
411  return false;
412  }
413  }
414 
415  if (count($value) > 1) {
416  // new value is a multiple valued metadata
417  $multiple = true;
418  }
419  }
420 
421  // create new metadata
422  foreach ($value as $value_tmp) {
423  $metadata = new ElggMetadata();
424  $metadata->entity_guid = $this->guid;
425  $metadata->name = $name;
426  $metadata->value = $value_tmp;
427 
428  if (!empty($value_type)) {
429  $metadata->value_type = $value_type;
430  }
431 
432  $md_id = _elgg_services()->metadataTable->create($metadata, $multiple);
433  if ($md_id === false) {
434  return false;
435  }
436  }
437 
438  return true;
439  }
440 
451  protected function setTempMetadata(string $name, $value, bool $multiple = false): bool {
452  // if overwrite, delete first
453  if (!$multiple) {
454  unset($this->temp_metadata[$name]);
455  if (count($value)) {
456  // only save if value array contains data
457  $this->temp_metadata[$name] = $value;
458  }
459 
460  return true;
461  }
462 
463  if (!isset($this->temp_metadata[$name])) {
464  $this->temp_metadata[$name] = [];
465  }
466 
467  $this->temp_metadata[$name] = array_merge($this->temp_metadata[$name], $value);
468 
469  return true;
470  }
471 
483  public function deleteMetadata(string $name = null): bool {
484 
485  if (!$this->guid) {
486  // remove from temp_metadata
487  if (isset($name)) {
488  if (isset($this->temp_metadata[$name])) {
489  unset($this->temp_metadata[$name]);
490  }
491  } else {
492  $this->temp_metadata = [];
493  }
494 
495  return true;
496  }
497 
498  return elgg_delete_metadata([
499  'guid' => $this->guid,
500  'limit' => false,
501  'metadata_name' => $name,
502  ]);
503  }
504 
512  public function getVolatileData(string $name) {
513  return array_key_exists($name, $this->volatile) ? $this->volatile[$name] : null;
514  }
515 
524  public function setVolatileData(string $name, $value): void {
525  $this->volatile[$name] = $value;
526  }
527 
539  public function addRelationship(int $guid_two, string $relationship): bool {
540  return _elgg_services()->relationshipsTable->add($this->guid, (string) $relationship, (int) $guid_two);
541  }
542 
554  public function hasRelationship(int $guid_two, string $relationship): bool {
555  return (bool) _elgg_services()->relationshipsTable->check($this->guid, $relationship, $guid_two);
556  }
557 
567  public function getRelationship(int $guid_two, string $relationship): ?\ElggRelationship {
568  return _elgg_services()->relationshipsTable->check($this->guid, $relationship, $guid_two) ?: null;
569  }
570 
581  public function getEntitiesFromRelationship(array $options = []) {
582  $options['relationship_guid'] = $this->guid;
583  return elgg_get_entities($options);
584  }
585 
594  public function countEntitiesFromRelationship(string $relationship, bool $inverse_relationship = false): int {
595  return elgg_count_entities([
596  'relationship' => $relationship,
597  'relationship_guid' => $this->guid,
598  'inverse_relationship' => $inverse_relationship,
599  ]);
600  }
601 
610  public function removeRelationship(int $guid_two, string $relationship): bool {
611  return _elgg_services()->relationshipsTable->remove($this->guid, (string) $relationship, (int) $guid_two);
612  }
613 
627  public function removeAllRelationships(string $relationship = '', bool $inverse_relationship = false): bool {
628  return _elgg_services()->relationshipsTable->removeAll($this->guid, $relationship, $inverse_relationship);
629  }
630 
636  public function removeAllRelatedRiverItems(): void {
637  elgg_delete_river(['subject_guid' => $this->guid, 'limit' => false]);
638  elgg_delete_river(['object_guid' => $this->guid, 'limit' => false]);
639  elgg_delete_river(['target_guid' => $this->guid, 'limit' => false]);
640  }
641 
652  public function deleteAnnotations(string $name = null): bool {
653  if ($this->guid) {
654  return elgg_delete_annotations([
655  'guid' => $this->guid,
656  'limit' => false,
657  'annotation_name' => $name,
658  ]);
659  }
660 
661  if ($name) {
662  unset($this->temp_annotations[$name]);
663  } else {
664  $this->temp_annotations = [];
665  }
666 
667  return true;
668  }
669 
678  public function deleteOwnedAnnotations(string $name = null): bool {
679  // access is turned off for this because they might
680  // no longer have access to an entity they created annotations on
681  return elgg_call(ELGG_IGNORE_ACCESS, function() use ($name) {
682  return elgg_delete_annotations([
683  'annotation_owner_guid' => $this->guid,
684  'limit' => false,
685  'annotation_name' => $name,
686  ]);
687  });
688  }
689 
697  public function disableAnnotations(string $name = null): bool {
698  return elgg_disable_annotations([
699  'guid' => $this->guid,
700  'limit' => false,
701  'annotation_name' => $name,
702  ]);
703  }
704 
712  public function enableAnnotations(string $name = null) {
713  return elgg_enable_annotations([
714  'guid' => $this->guid,
715  'limit' => false,
716  'annotation_name' => $name,
717  ]);
718  }
719 
727  private function getAnnotationCalculation($name, $calculation) {
728  $options = [
729  'guid' => $this->getGUID(),
730  'distinct' => false,
731  'annotation_name' => $name,
732  'annotation_calculation' => $calculation
733  ];
734 
736  }
737 
757  public function annotate($name, $value, $access_id = ACCESS_PRIVATE, $owner_guid = 0, $value_type = '') {
758  if (!$this->guid) {
759  $this->temp_annotations[$name] = $value;
760  return true;
761  }
762 
763  if (!$owner_guid) {
764  $owner_guid = _elgg_services()->session_manager->getLoggedInUserGuid();
765  }
766 
767  $annotation = new ElggAnnotation();
768  $annotation->entity_guid = $this->guid;
769  $annotation->name = $name;
770  $annotation->value = $value;
771  $annotation->owner_guid = $owner_guid;
772  $annotation->access_id = $access_id;
773 
774  if (!empty($value_type)) {
775  $annotation->value_type = $value_type;
776  }
777 
778  if ($annotation->save()) {
779  return $annotation->id;
780  }
781 
782  return false;
783  }
784 
796  public function getAnnotations(array $options = []) {
797  if ($this->guid) {
798  $options['guid'] = $this->guid;
799 
801  } else {
802  $name = elgg_extract('annotation_name', $options, '');
803 
804  if (isset($this->temp_annotations[$name])) {
805  return [$this->temp_annotations[$name]];
806  }
807  }
808 
809  return [];
810  }
811 
819  public function countAnnotations(string $name = ''): int {
820  return $this->getAnnotationCalculation($name, 'count');
821  }
822 
830  public function getAnnotationsAvg(string $name) {
831  return $this->getAnnotationCalculation($name, 'avg');
832  }
833 
841  public function getAnnotationsSum(string $name) {
842  return $this->getAnnotationCalculation($name, 'sum');
843  }
844 
852  public function getAnnotationsMin(string $name) {
853  return $this->getAnnotationCalculation($name, 'min');
854  }
855 
863  public function getAnnotationsMax(string $name) {
864  return $this->getAnnotationCalculation($name, 'max');
865  }
866 
873  public function countComments(): int {
874  if (!$this->hasCapability('commentable')) {
875  return 0;
876  }
877 
878  $params = ['entity' => $this];
879  $num = _elgg_services()->events->triggerResults('comments:count', $this->getType(), $params);
880 
881  if (is_int($num)) {
882  return $num;
883  }
884 
885  return \Elgg\Comments\DataService::instance()->getCommentsCount($this);
886  }
887 
898  public function getOwnedAccessCollections(array $options = []): array {
899  $options['owner_guid'] = $this->guid;
900  return _elgg_services()->accessCollections->getEntityCollections($options);
901  }
902 
914  if ($subtype === '') {
915  throw new ElggInvalidArgumentException(__METHOD__ . ' requires $subtype to be non empty');
916  }
917 
918  $acls = $this->getOwnedAccessCollections([
919  'subtype' => $subtype,
920  ]);
921 
922  return elgg_extract(0, $acls);
923  }
924 
933  public function hasAccess(int $user_guid = 0): bool {
934  return _elgg_services()->accessCollections->hasAccessToEntity($this, $user_guid);
935  }
936 
946  public function canEdit(int $user_guid = 0): bool {
947  return _elgg_services()->userCapabilities->canEdit($this, $user_guid);
948  }
949 
960  public function canDelete(int $user_guid = 0): bool {
961  return _elgg_services()->userCapabilities->canDelete($this, $user_guid);
962  }
963 
974  public function canWriteToContainer(int $user_guid = 0, string $type = '', string $subtype = ''): bool {
975  if (empty($type) || empty($subtype)) {
976  throw new ElggInvalidArgumentException(__METHOD__ . ' requires $type and $subtype to be set');
977  }
978 
979  return _elgg_services()->userCapabilities->canWriteToContainer($this, $type, $subtype, $user_guid);
980  }
981 
991  public function canComment(int $user_guid = 0): bool {
992  return _elgg_services()->userCapabilities->canComment($this, $user_guid);
993  }
994 
1009  public function canAnnotate(int $user_guid = 0, string $annotation_name = ''): bool {
1010  return _elgg_services()->userCapabilities->canAnnotate($this, $user_guid, $annotation_name);
1011  }
1012 
1018  public function getGUID(): ?int {
1019  return $this->guid;
1020  }
1021 
1027  public function getType(): string {
1028  // this is just for the PHPUnit mocking framework
1029  return (string) $this->type;
1030  }
1031 
1040  public function setSubtype(string $subtype): void {
1041  // keep original values
1042  if ($this->guid && !array_key_exists('subtype', $this->orig_attributes)) {
1043  $this->orig_attributes['subtype'] = $this->attributes['subtype'];
1044  }
1045 
1046  $this->attributes['subtype'] = $subtype;
1047  }
1048 
1054  public function getSubtype(): string {
1055  return (string) $this->attributes['subtype'];
1056  }
1057 
1063  public function getOwnerGUID(): int {
1064  return (int) $this->owner_guid;
1065  }
1066 
1072  public function getOwnerEntity(): ?\ElggEntity {
1073  return $this->owner_guid ? get_entity($this->owner_guid) : null;
1074  }
1075 
1083  public function setContainerGUID(int $container_guid): void {
1085  }
1086 
1092  public function getContainerGUID(): int {
1093  return (int) $this->container_guid;
1094  }
1095 
1102  public function getContainerEntity(): ?\ElggEntity {
1103  return $this->container_guid ? get_entity($this->getContainerGUID()) : null;
1104  }
1105 
1111  public function getTimeUpdated(): int {
1112  return (int) $this->time_updated;
1113  }
1114 
1123  public function getURL(): string {
1124  $url = elgg_generate_entity_url($this, 'view');
1125 
1126  $url = _elgg_services()->events->triggerResults('entity:url', $this->getType(), ['entity' => $this], $url);
1127 
1128  if (empty($url)) {
1129  return '';
1130  }
1131 
1132  return elgg_normalize_url($url);
1133  }
1134 
1143  public function saveIconFromUploadedFile(string $input_name, string $type = 'icon', array $coords = []): bool {
1144  return _elgg_services()->iconService->saveIconFromUploadedFile($this, $input_name, $type, $coords);
1145  }
1146 
1155  public function saveIconFromLocalFile(string $filename, string $type = 'icon', array $coords = []): bool {
1156  return _elgg_services()->iconService->saveIconFromLocalFile($this, $filename, $type, $coords);
1157  }
1158 
1167  public function saveIconFromElggFile(\ElggFile $file, string $type = 'icon', array $coords = []): bool {
1168  return _elgg_services()->iconService->saveIconFromElggFile($this, $file, $type, $coords);
1169  }
1170 
1179  public function getIcon(string $size, string $type = 'icon'): \ElggIcon {
1180  return _elgg_services()->iconService->getIcon($this, $size, $type);
1181  }
1182 
1189  public function deleteIcon(string $type = 'icon'): bool {
1190  return _elgg_services()->iconService->deleteIcon($this, $type);
1191  }
1192 
1201  public function getIconLastChange(string $size, string $type = 'icon'): ?int {
1202  return _elgg_services()->iconService->getIconLastChange($this, $size, $type);
1203  }
1204 
1212  public function hasIcon(string $size, string $type = 'icon'): bool {
1213  return _elgg_services()->iconService->hasIcon($this, $size, $type);
1214  }
1215 
1227  public function getIconURL(string|array $params = []): string {
1228  return _elgg_services()->iconService->getIconURL($this, $params);
1229  }
1230 
1234  public function save(): bool {
1235  if ($this->guid > 0) {
1236  $result = $this->update();
1237  } else {
1238  $result = $this->create() !== false;
1239  }
1240 
1241  if ($result) {
1242  $this->cache();
1243  }
1244 
1245  return $result;
1246  }
1247 
1260  protected function create() {
1261 
1262  $type = $this->attributes['type'];
1263  if (!in_array($type, \Elgg\Config::ENTITY_TYPES)) {
1264  throw new ElggDomainException('Entity type must be one of the allowed types: ' . implode(', ', \Elgg\Config::ENTITY_TYPES));
1265  }
1266 
1267  $subtype = $this->attributes['subtype'];
1268  if (!$subtype) {
1269  throw new ElggInvalidArgumentException('All entities must have a subtype');
1270  }
1271 
1272  $owner_guid = (int) $this->attributes['owner_guid'];
1273  $access_id = (int) $this->attributes['access_id'];
1274  $now = $this->getCurrentTime()->getTimestamp();
1275  $time_created = isset($this->attributes['time_created']) ? (int) $this->attributes['time_created'] : $now;
1276 
1277  $container_guid = $this->attributes['container_guid'];
1278  if ($container_guid == 0) {
1280  $this->attributes['container_guid'] = $container_guid;
1281  }
1282 
1284 
1285  if ($access_id == ACCESS_DEFAULT) {
1286  throw new ElggInvalidArgumentException('ACCESS_DEFAULT is not a valid access level. See its documentation in constants.php');
1287  }
1288 
1289  if ($access_id == ACCESS_FRIENDS) {
1290  throw new ElggInvalidArgumentException('ACCESS_FRIENDS is not a valid access level. See its documentation in constants.php');
1291  }
1292 
1293  $user_guid = _elgg_services()->session_manager->getLoggedInUserGuid();
1294 
1295  // If given an owner, verify it can be loaded
1296  if (!empty($owner_guid)) {
1297  $owner = $this->getOwnerEntity();
1298  if (!$owner instanceof \ElggEntity) {
1299  $error = "User {$user_guid} tried to create a ({$type}, {$subtype}),";
1300  $error .= " but the given owner {$owner_guid} could not be loaded.";
1301  _elgg_services()->logger->error($error);
1302  return false;
1303  }
1304 
1305  // If different owner than logged in, verify can write to container.
1306  if ($user_guid !== $owner_guid && !$owner->canEdit() && !$owner->canWriteToContainer($user_guid, $type, $subtype)) {
1307  $error = "User {$user_guid} tried to create a ({$type}, {$subtype}) with owner {$owner_guid},";
1308  $error .= " but the user wasn't permitted to write to the owner's container.";
1309  _elgg_services()->logger->error($error);
1310  return false;
1311  }
1312  }
1313 
1314  // If given a container, verify it can be loaded and that the current user can write to it
1315  if (!empty($container_guid)) {
1316  $container = $this->getContainerEntity();
1317  if (!$container instanceof \ElggEntity) {
1318  $error = "User {$user_guid} tried to create a ({$type}, {$subtype}),";
1319  $error .= " but the given container {$container_guid} could not be loaded.";
1320  _elgg_services()->logger->error($error);
1321  return false;
1322  }
1323 
1324  if (!$container->canWriteToContainer($user_guid, $type, $subtype)) {
1325  $error = "User {$user_guid} tried to create a ({$type}, {$subtype}),";
1326  $error .= " but was not permitted to write to container {$container_guid}.";
1327  _elgg_services()->logger->error($error);
1328  return false;
1329  }
1330  }
1331 
1332  if (!_elgg_services()->events->triggerBefore('create', $this->type, $this)) {
1333  return false;
1334  }
1335 
1336  // Create primary table row
1337  $guid = _elgg_services()->entityTable->insertRow((object) [
1338  'type' => $type,
1339  'subtype' => $subtype,
1340  'owner_guid' => $owner_guid,
1341  'container_guid' => $container_guid,
1342  'access_id' => $access_id,
1343  'time_created' => $time_created,
1344  'time_updated' => $now,
1345  'last_action' => $now,
1346  ], $this->attributes);
1347 
1348  if (!$guid) {
1349  throw new IOException("Unable to save new object's base entity information!");
1350  }
1351 
1352  $this->attributes['subtype'] = $subtype;
1353  $this->attributes['guid'] = (int) $guid;
1354  $this->attributes['time_created'] = (int) $time_created;
1355  $this->attributes['time_updated'] = (int) $now;
1356  $this->attributes['last_action'] = (int) $now;
1357  $this->attributes['container_guid'] = (int) $container_guid;
1358 
1359  // We are writing this new entity to cache to make sure subsequent calls
1360  // to get_entity() load the entity from cache and not from the DB. This
1361  // MUST come before the metadata and annotation writes below!
1362  $this->cache();
1363 
1364  // Save any unsaved metadata
1365  if (count($this->temp_metadata) > 0) {
1366  foreach ($this->temp_metadata as $name => $value) {
1367  // temp metadata is always an array, but if there is only one value return just the value
1368  $this->setMetadata($name, $value, '', count($value) > 1);
1369  }
1370 
1371  $this->temp_metadata = [];
1372  }
1373 
1374  // Save any unsaved annotations.
1375  if (count($this->temp_annotations) > 0) {
1376  foreach ($this->temp_annotations as $name => $value) {
1377  $this->annotate($name, $value);
1378  }
1379 
1380  $this->temp_annotations = [];
1381  }
1382 
1383  if (isset($container) && !$container instanceof \ElggUser) {
1384  // users have their own logic for setting last action
1385  $container->updateLastAction();
1386  }
1387 
1388  // for BC reasons this event is still needed (for example for notifications)
1389  _elgg_services()->events->trigger('create', $this->type, $this);
1390 
1391  _elgg_services()->events->triggerAfter('create', $this->type, $this);
1392 
1393  return $guid;
1394  }
1395 
1403  protected function update(): bool {
1404 
1405  if (!$this->canEdit()) {
1406  return false;
1407  }
1408 
1409  // give old update event a chance to stop the update
1410  if (!_elgg_services()->events->trigger('update', $this->type, $this)) {
1411  return false;
1412  }
1413 
1414  $this->invalidateCache();
1415 
1416  // See #6225. We copy these after the update event in case a handler changed one of them.
1417  $guid = (int) $this->guid;
1418  $owner_guid = (int) $this->owner_guid;
1419  $access_id = (int) $this->access_id;
1420  $container_guid = (int) $this->container_guid;
1421  $time_created = (int) $this->time_created;
1422  $time = $this->getCurrentTime()->getTimestamp();
1423 
1424  if ($access_id == ACCESS_DEFAULT) {
1425  throw new ElggInvalidArgumentException('ACCESS_DEFAULT is not a valid access level. See its documentation in constants.php');
1426  }
1427 
1428  if ($access_id == ACCESS_FRIENDS) {
1429  throw new ElggInvalidArgumentException('ACCESS_FRIENDS is not a valid access level. See its documentation in constants.php');
1430  }
1431 
1432  // Update primary table
1433  $ret = _elgg_services()->entityTable->updateRow($guid, (object) [
1434  'owner_guid' => $owner_guid,
1435  'container_guid' => $container_guid,
1436  'access_id' => $access_id,
1437  'time_created' => $time_created,
1438  'time_updated' => $time,
1439  'guid' => $guid,
1440  ]);
1441  if ($ret === false) {
1442  return false;
1443  }
1444 
1445  $this->attributes['time_updated'] = $time;
1446 
1447  _elgg_services()->events->triggerAfter('update', $this->type, $this);
1448 
1449  $this->orig_attributes = [];
1450 
1451  $this->cache();
1452 
1453  // Handle cases where there was no error BUT no rows were updated!
1454  return true;
1455  }
1456 
1464  protected function load(stdClass $row): bool {
1465  $attributes = array_merge($this->attributes, (array) $row);
1466 
1467  if (array_diff(self::PRIMARY_ATTR_NAMES, array_keys($attributes)) !== []) {
1468  // Some primary attributes are missing
1469  return false;
1470  }
1471 
1472  foreach ($attributes as $name => $value) {
1473  if (!in_array($name, self::PRIMARY_ATTR_NAMES)) {
1474  $this->setVolatileData("select:{$name}", $value);
1475  unset($attributes[$name]);
1476  continue;
1477  }
1478 
1479  if (in_array($name, static::INTEGER_ATTR_NAMES)) {
1480  $attributes[$name] = (int) $value;
1481  }
1482  }
1483 
1484  $this->attributes = $attributes;
1485 
1486  $this->cache();
1487 
1488  return true;
1489  }
1490 
1508  public function disable(string $reason = '', bool $recursive = true): bool {
1509  if (!$this->guid) {
1510  return false;
1511  }
1512 
1513  if (!_elgg_services()->events->trigger('disable', $this->type, $this)) {
1514  return false;
1515  }
1516 
1517  if (!$this->canEdit()) {
1518  return false;
1519  }
1520 
1521  if ($this instanceof ElggUser && !$this->isBanned()) {
1522  // temporarily ban to prevent using the site during disable
1523  // not using ban function to bypass events
1524  $this->setMetadata('banned', 'yes');
1525  $unban_after = true;
1526  } else {
1527  $unban_after = false;
1528  }
1529 
1530  if (!empty($reason)) {
1531  $this->disable_reason = $reason;
1532  }
1533 
1534  $guid = (int) $this->guid;
1535 
1536  if ($recursive) {
1537  elgg_call(ELGG_IGNORE_ACCESS | ELGG_HIDE_DISABLED_ENTITIES, function () use ($guid, $reason) {
1538  $base_options = [
1539  'wheres' => [
1540  function(QueryBuilder $qb, $main_alias) use ($guid) {
1541  return $qb->compare("{$main_alias}.guid", '!=', $guid, ELGG_VALUE_GUID);
1542  },
1543  ],
1544  'limit' => false,
1545  'batch' => true,
1546  'batch_inc_offset' => false,
1547  ];
1548 
1549  foreach (['owner_guid', 'container_guid'] as $db_column) {
1550  $options = $base_options;
1551  $options[$db_column] = $guid;
1552 
1553  $subentities = elgg_get_entities($options);
1554  /* @var $subentity \ElggEntity */
1555  foreach ($subentities as $subentity) {
1556  if (!$subentity->isEnabled()) {
1557  continue;
1558  }
1559 
1560  $subentity->addRelationship($guid, 'disabled_with');
1561  $subentity->disable($reason, true);
1562  }
1563  }
1564  });
1565  }
1566 
1567  $this->disableAnnotations();
1568 
1569  $disabled = _elgg_services()->entityTable->disable($this);
1570 
1571  if ($unban_after) {
1572  $this->setMetadata('banned', 'no');
1573  }
1574 
1575  if ($disabled) {
1576  $this->invalidateCache();
1577 
1578  $this->attributes['enabled'] = 'no';
1579  _elgg_services()->events->triggerAfter('disable', $this->type, $this);
1580  }
1581 
1582  return $disabled;
1583  }
1584 
1592  public function enable(bool $recursive = true): bool {
1593  if (empty($this->guid)) {
1594  return false;
1595  }
1596 
1597  if (!_elgg_services()->events->trigger('enable', $this->type, $this)) {
1598  return false;
1599  }
1600 
1601  if (!$this->canEdit()) {
1602  return false;
1603  }
1604 
1605  $result = elgg_call(ELGG_IGNORE_ACCESS | ELGG_SHOW_DISABLED_ENTITIES, function() use ($recursive) {
1606  $result = _elgg_services()->entityTable->enable($this);
1607 
1608  $this->deleteMetadata('disable_reason');
1609  $this->enableAnnotations();
1610 
1611  if ($recursive) {
1612  $disabled_with_it = elgg_get_entities([
1613  'relationship' => 'disabled_with',
1614  'relationship_guid' => $this->guid,
1615  'inverse_relationship' => true,
1616  'limit' => false,
1617  'batch' => true,
1618  'batch_inc_offset' => false,
1619  ]);
1620 
1621  foreach ($disabled_with_it as $e) {
1622  $e->enable($recursive);
1623  $e->removeRelationship($this->guid, 'disabled_with');
1624  }
1625  }
1626 
1627  return $result;
1628  });
1629 
1630  if ($result) {
1631  $this->attributes['enabled'] = 'yes';
1632  _elgg_services()->events->triggerAfter('enable', $this->type, $this);
1633  }
1634 
1635  return $result;
1636  }
1637 
1643  public function isEnabled(): bool {
1644  return $this->enabled == 'yes';
1645  }
1646 
1664  public function delete(bool $recursive = true): bool {
1665  // first check if we can delete this entity
1666  // NOTE: in Elgg <= 1.10.3 this was after the delete event,
1667  // which could potentially remove some content if the user didn't have access
1668  if (!$this->canDelete()) {
1669  return false;
1670  }
1671 
1672  try {
1673  return _elgg_services()->entityTable->delete($this, $recursive);
1674  } catch (DatabaseException $ex) {
1675  elgg_log($ex, 'ERROR');
1676  return false;
1677  }
1678  }
1679 
1686  public function toObject(array $params = []) {
1687  $object = $this->prepareObject(new \Elgg\Export\Entity());
1688 
1689  $params['entity'] = $this;
1690 
1691  return _elgg_services()->events->triggerResults('to:object', 'entity', $params, $object);
1692  }
1693 
1700  protected function prepareObject(\Elgg\Export\Entity $object) {
1701  $object->guid = $this->guid;
1702  $object->type = $this->getType();
1703  $object->subtype = $this->getSubtype();
1704  $object->owner_guid = $this->getOwnerGUID();
1705  $object->container_guid = $this->getContainerGUID();
1706  $object->time_created = date('c', $this->getTimeCreated());
1707  $object->time_updated = date('c', $this->getTimeUpdated());
1708  $object->url = $this->getURL();
1709  $object->read_access = (int) $this->access_id;
1710  return $object;
1711  }
1712 
1721  public function setLatLong(float $lat, float $long): void {
1722  $this->{'geo:lat'} = $lat;
1723  $this->{'geo:long'} = $long;
1724  }
1725 
1731  public function getLatitude(): float {
1732  return (float) $this->{'geo:lat'};
1733  }
1734 
1740  public function getLongitude(): float {
1741  return (float) $this->{'geo:long'};
1742  }
1743 
1744  /*
1745  * SYSTEM LOG INTERFACE
1746  */
1747 
1751  public function getSystemLogID(): int {
1752  return (int) $this->getGUID();
1753  }
1754 
1763  public function getObjectFromID(int $id): ?\ElggEntity {
1764  return get_entity($id);
1765  }
1766 
1774  public function getTags($tag_names = null) {
1775  if (!isset($tag_names)) {
1776  $tag_names = ['tags'];
1777  }
1778 
1779  if ($tag_names && !is_array($tag_names)) {
1780  $tag_names = [$tag_names];
1781  }
1782 
1783  $entity_tags = [];
1784  foreach ($tag_names as $tag_name) {
1785  $tags = $this->$tag_name;
1786  if (elgg_is_empty($tags)) {
1787  continue;
1788  }
1789 
1790  // if a single tag, metadata returns a string.
1791  // if multiple tags, metadata returns an array.
1792  if (is_array($tags)) {
1793  $entity_tags = array_merge($entity_tags, $tags);
1794  } else {
1795  $entity_tags[] = $tags;
1796  }
1797  }
1798 
1799  return $entity_tags;
1800  }
1801 
1809 
1810  if (!$this->guid) {
1811  return false;
1812  }
1813 
1814  if ($this->type !== 'user') {
1815  return true;
1816  }
1817 
1818  $ac = _elgg_services()->accessCollections;
1819 
1820  $collections = $ac->getCollectionsByMember($this->guid);
1821  if (empty($collections)) {
1822  return true;
1823  }
1824 
1825  $result = true;
1826  foreach ($collections as $collection) {
1827  $result &= $ac->removeUser($this->guid, $collection->id);
1828  }
1829 
1830  return $result;
1831  }
1832 
1839  public function deleteOwnedAccessCollections() {
1840 
1841  if (!$this->guid) {
1842  return false;
1843  }
1844 
1845  $collections = $this->getOwnedAccessCollections();
1846  if (empty($collections)) {
1847  return true;
1848  }
1849 
1850  $result = true;
1851  foreach ($collections as $collection) {
1852  $result = $result & $collection->delete();
1853  }
1854 
1855  return $result;
1856  }
1857 
1868  public function updateLastAction(int $posted = null): int {
1869  $posted = _elgg_services()->entityTable->updateLastAction($this, $posted);
1870 
1871  $this->attributes['last_action'] = $posted;
1872  $this->cache();
1873 
1874  return $posted;
1875  }
1876 
1883  public function disableCaching(): void {
1884  $this->_is_cacheable = false;
1885  if ($this->guid) {
1886  _elgg_services()->entityCache->delete($this->guid);
1887  }
1888  }
1889 
1896  public function enableCaching(): void {
1897  $this->_is_cacheable = true;
1898  }
1899 
1906  public function isCacheable(): bool {
1907  if (!$this->guid) {
1908  return false;
1909  }
1910 
1911  if (_elgg_services()->session_manager->getIgnoreAccess()) {
1912  return false;
1913  }
1914 
1915  return $this->_is_cacheable;
1916  }
1917 
1926  public function cache(bool $persist = true): void {
1927  if (!$this->isCacheable()) {
1928  return;
1929  }
1930 
1931  _elgg_services()->entityCache->save($this);
1932 
1933  if (!$persist) {
1934  return;
1935  }
1936 
1937  $tmp = $this->volatile;
1938 
1939  // don't store volatile data
1940  $this->volatile = [];
1941 
1942  _elgg_services()->sessionCache->entities->save($this->guid, $this);
1943 
1944  $this->volatile = $tmp;
1945  }
1946 
1953  public function invalidateCache(): void {
1954  if (!$this->guid) {
1955  return;
1956  }
1957 
1958  _elgg_services()->entityCache->delete($this->guid);
1959  _elgg_services()->dataCache->get('metadata')->delete($this->guid);
1960  }
1961 
1970  public function hasCapability(string $capability): bool {
1971  return _elgg_services()->entity_capabilities->hasCapability($this->getType(), $this->getSubtype(), $capability);
1972  }
1973 }
elgg_call(int $flags, Closure $closure)
Calls a callable autowiring the arguments using public DI services and applying logic based on flags...
Definition: elgglib.php:299
$display_name
Definition: delete.php:20
deleteOwnedAccessCollections()
Remove all access collections owned by this entity.
getSubtype()
Get the entity subtype.
setMetadata(string $name, $value, string $value_type= '', bool $multiple=false)
Set metadata on this entity.
Definition: ElggEntity.php:370
$user_guid
Definition: login_as.php:10
getOwnerGUID()
Get the guid of the entity&#39;s owner.
getTimeCreated()
Returns the UNIX epoch time that this entity was created.
Definition: ElggData.php:99
Entities that support icons should implement this interface.
Definition: EntityIcon.php:7
enableAnnotations(string $name=null)
Enables annotations for this entity, optionally based on name.
Definition: ElggEntity.php:712
__clone()
Clone an entity.
Definition: ElggEntity.php:175
$input_name
Definition: crop.php:24
$params
Saves global plugin settings.
Definition: save.php:13
saveIconFromLocalFile(string $filename, string $type= 'icon', array $coords=[])
Saves icons using a local file as the source.
setVolatileData(string $name, $value)
Set a piece of volatile (non-persisted) data on this entity.
Definition: ElggEntity.php:524
__get($name)
Get an attribute or metadata value.
Definition: ElggEntity.php:299
getOwnerEntity()
Gets the that owns this entity.
$owner
Definition: upload.php:7
const ACCESS_DEFAULT
Controls access levels on entities, metadata, and annotations.
Definition: constants.php:9
getIconLastChange(string $size, string $type= 'icon')
Returns the timestamp of when the icon was changed.
if($id< 1) $annotation
Definition: delete.php:11
An IO Exception, throw when an IO Exception occurs.
Definition: IOException.php:12
canWriteToContainer(int $user_guid=0, string $type= '', string $subtype= '')
Can a user add an entity to this container.
Definition: ElggEntity.php:974
const PRIMARY_ATTR_NAMES
Definition: ElggEntity.php:50
elgg_delete_annotations(array $options)
Deletes annotations based on $options.
Definition: annotations.php:87
if(!$user||!$user->canDelete()) $name
Definition: delete.php:22
canDelete(int $user_guid=0)
Can a user delete this entity?
Definition: ElggEntity.php:960
const INTEGER_ATTR_NAMES
Definition: ElggEntity.php:66
invalidateCache()
Invalidate cache for entity.
canComment(int $user_guid=0)
Can a user comment on an entity?
Definition: ElggEntity.php:991
initializeAttributes()
Initialize the attributes array.
Definition: ElggEntity.php:149
const ACCESS_FRIENDS
Definition: constants.php:13
if(!$user instanceof\ElggUser) $time_created
Definition: online.php:13
saveIconFromElggFile(\ElggFile $file, string $type= 'icon', array $coords=[])
Saves icons using a file located in the data store as the source.
deleteOwnedAnnotations(string $name=null)
Deletes all annotations owned by this object (annotations.owner_guid = $this->guid).
Definition: ElggEntity.php:678
elgg_get_annotations(array $options=[])
Fetch annotations or perform a calculation on them.
Definition: annotations.php:52
countComments()
Count the number of comments attached to this entity.
Definition: ElggEntity.php:873
elgg_delete_river(array $options=[])
Delete river items based on $options.
Definition: river.php:135
getVolatileData(string $name)
Get a piece of volatile (non-persisted) data on this entity.
Definition: ElggEntity.php:512
c Accompany it with the information you received as to the offer to distribute corresponding source complete source code means all the source code for all modules it plus any associated interface definition plus the scripts used to control compilation and installation of the executable as a special the source code distributed need not include anything that is normally and so on of the operating system on which the executable unless that component itself accompanies the executable If distribution of executable or object code is made by offering access to copy from a designated then offering equivalent access to copy the source code from the same place counts as distribution of the source even though third parties are not compelled to copy the source along with the object code You may not or distribute the Program except as expressly provided under this License Any attempt otherwise to sublicense or distribute the Program is void
Definition: LICENSE.txt:215
countEntitiesFromRelationship(string $relationship, bool $inverse_relationship=false)
Gets the number of entities from a specific relationship type.
Definition: ElggEntity.php:594
elgg_echo(string $message_key, array $args=[], string $language= '')
Elgg language module Functions to manage language and translations.
Definition: languages.php:17
enable(bool $recursive=true)
Enable the entity.
$relationship
Elgg default relationship view.
Definition: default.php:10
if(!$annotation instanceof ElggAnnotation) $time
Definition: time.php:20
Entity Annotation.
const ELGG_VALUE_GUID
Definition: constants.php:113
cache(bool $persist=true)
Cache the entity in a session and persisted caches.
prepareObject(\Elgg\Export\Entity $object)
Prepare an object copy for toObject()
Database abstraction query builder.
getGUID()
Returns the guid.
getIconURL(string|array $params=[])
Get the URL for this entity&#39;s icon.
$time_updated
Definition: time.php:21
getContainerGUID()
Gets the container GUID for this entity.
$type
Definition: delete.php:22
getTimeUpdated()
Returns the UNIX epoch time that this entity was last updated.
enableCaching()
Enable runtime caching for entity.
deleteAnnotations(string $name=null)
Deletes all annotations on this object (annotations.entity_guid = $this->guid).
Definition: ElggEntity.php:652
addRelationship(int $guid_two, string $relationship)
Add a relationship between this an another entity.
Definition: ElggEntity.php:539
canAnnotate(int $user_guid=0, string $annotation_name= '')
Can a user annotate an entity?
disableAnnotations(string $name=null)
Disables annotations for this entity, optionally based on name.
Definition: ElggEntity.php:697
$options
Elgg admin footer.
Definition: footer.php:6
canEdit(int $user_guid=0)
Can a user edit this entity?
Definition: ElggEntity.php:946
getEntitiesFromRelationship(array $options=[])
Gets an array of entities with a relationship to this entity.
Definition: ElggEntity.php:581
setTempMetadata(string $name, $value, bool $multiple=false)
Set temp metadata on this entity.
Definition: ElggEntity.php:451
$value
Definition: generic.php:51
elgg_is_empty($value)
Check if a value isn&#39;t empty, but allow 0 and &#39;0&#39;.
Definition: input.php:176
const ELGG_HIDE_DISABLED_ENTITIES
Definition: constants.php:133
elgg_extract($key, $array, $default=null, bool $strict=true)
Checks for $array[$key] and returns its value if it exists, else returns $default.
Definition: elgglib.php:254
getAnnotationsSum(string $name)
Get the sum of integer type annotations of a given name.
Definition: ElggEntity.php:841
elgg_disable_annotations(array $options)
Disables annotations based on $options.
getObjectFromID(int $id)
For a given ID, return the object associated with it.
countAnnotations(string $name= '')
Count annotations.
Definition: ElggEntity.php:819
getCurrentTime($modifier= '')
Get the (cloned) time.
Definition: TimeUsing.php:25
const ELGG_IGNORE_ACCESS
elgg_call() flags
Definition: constants.php:130
$owner_guid
$error
Bad request error.
Definition: 400.php:6
getTags($tag_names=null)
Returns tags for this entity.
getRelationship(int $guid_two, string $relationship)
Return the relationship if this entity has a relationship with another entity.
Definition: ElggEntity.php:567
disableCaching()
Disable runtime caching for entity.
hasRelationship(int $guid_two, string $relationship)
Check if this entity has a relationship with another entity.
Definition: ElggEntity.php:554
setSubtype(string $subtype)
Set the subtype of the entity.
getAnnotationsMin(string $name)
Get the minimum of integer type annotations of given name.
Definition: ElggEntity.php:852
const ACCESS_PRIVATE
Definition: constants.php:10
const ELGG_SHOW_DISABLED_ENTITIES
Definition: constants.php:132
removeAllRelatedRiverItems()
Removes all river items related to this entity.
Definition: ElggEntity.php:636
get_entity(int $guid)
Loads and returns an entity object from a guid.
Definition: entities.php:67
elgg_get_entities(array $options=[])
Fetches/counts entities or performs a calculation on their properties.
Definition: entities.php:504
getAnnotationsAvg(string $name)
Get the average of an integer type annotation.
Definition: ElggEntity.php:830
hasAccess(int $user_guid=0)
Check if the given user has access to this entity.
Definition: ElggEntity.php:933
load(stdClass $row)
Loads attributes from the entities table into the object.
elgg_log($message, $level=\Psr\Log\LogLevel::NOTICE)
Log a message.
Definition: elgglib.php:86
elgg_generate_entity_url(ElggEntity $entity, string $resource= 'view', string $subresource=null, array $parameters=[])
Generate entity URL from a named route.
elgg_count_entities(array $options=[])
Returns a count of entities.
Definition: entities.php:515
A generic parent class for database exceptions.
compare($x, $comparison, $y=null, $type=null, $case_sensitive=null)
Build value comparison clause.
__set($name, $value)
Set an attribute or metadata value for this entity.
Definition: ElggEntity.php:228
deleteMetadata(string $name=null)
Deletes all metadata on this object (metadata.entity_guid = $this->guid).
Definition: ElggEntity.php:483
$container
Definition: delete.php:24
saveIconFromUploadedFile(string $input_name, string $type= 'icon', array $coords=[])
Saves icons using an uploaded file as the source.
getIcon(string $size, string $type= 'icon')
Returns entity icon as an ElggIcon object The icon file may or may not exist on filestore.
toObject(array $params=[])
Export an entity.
ElggMetadata.
elgg_enable_annotations(array $options)
Enables annotations based on $options.
getAnnotations(array $options=[])
Gets an array of annotations.
Definition: ElggEntity.php:796
setLatLong(float $lat, float $long)
Set latitude and longitude metadata tags for a given entity.
hasCapability(string $capability)
Checks a specific capability is enabled for the entity type/subtype.
A generic class that contains shared code among , , and .
Definition: ElggData.php:10
deleteAccessCollectionMemberships()
Remove the membership of all access collections for this entity (if the entity is a user) ...
isEnabled()
Is this entity enabled?
$size
Definition: thumb.php:23
update()
Update the entity in the database.
annotate($name, $value, $access_id=ACCESS_PRIVATE, $owner_guid=0, $value_type= '')
Adds an annotation to an entity.
Definition: ElggEntity.php:757
elgg_get_metadata(array $options=[])
Fetch metadata or perform a calculation on them.
Definition: metadata.php:32
if($entity instanceof\ElggComment) $comment container_guid
Definition: save.php:54
$posted
Definition: comment.php:89
$comment access_id
Definition: save.php:55
if($email instanceof\Elgg\Email) $object
Definition: body.php:24
elgg_delete_metadata(array $options)
Deletes metadata based on $options.
Definition: metadata.php:49
$metadata
Output annotation metadata.
Definition: metadata.php:9
removeAllRelationships(string $relationship= '', bool $inverse_relationship=false)
Remove all relationships to or from this entity.
Definition: ElggEntity.php:627
getType()
Returns the entity type.
$subtype
Definition: delete.php:23
getOwnedAccessCollection(string $subtype)
Returns the first ACL owned by the entity with a given subtype.
Definition: ElggEntity.php:913
foreach($plugin_guids as $guid) if(empty($deactivated_plugins)) $url
Definition: deactivate.php:39
removeRelationship(int $guid_two, string $relationship)
Remove a relationship.
Definition: ElggEntity.php:610
$access_id
Definition: access.php:10
create()
Create a new entry in the entities table.
setContainerGUID(int $container_guid)
Set the container for this object.
getAllMetadata()
Get all entity metadata.
Definition: ElggEntity.php:343
Entity icon class.
Definition: ElggIcon.php:8
_elgg_services()
Get the global service provider.
Definition: elgglib.php:346
getOriginalAttributes()
Get the original values of attribute(s) that have been modified since the entity was persisted...
Definition: ElggEntity.php:283
isCacheable()
Is entity cacheable in the runtime cache.
getLatitude()
Return the entity&#39;s latitude.
__construct(stdClass $row=null)
Create a new entity.
Definition: ElggEntity.php:134
$container_guid
getContainerEntity()
Get the container entity for this object.
elgg_normalize_url(string $url)
Definition: output.php:163
$tags
Output object tags.
Definition: tags.php:9
disable(string $reason= '', bool $recursive=true)
Disable this entity.
$site name
Definition: settings.php:15
updateLastAction(int $posted=null)
Update the last_action column in the entities table.
getSystemLogID()
{}
$id
Generic annotation delete action.
Definition: delete.php:6
$qb
Definition: queue.php:11
getAnnotationsMax(string $name)
Get the maximum of integer type annotations of a given name.
Definition: ElggEntity.php:863
getOwnedAccessCollections(array $options=[])
Returns the ACLs owned by the entity.
Definition: ElggEntity.php:898
getURL()
Gets the URL for this entity.
setDisplayName(string $display_name)
Sets the title or name of this entity.
Definition: ElggEntity.php:322
getMetadata(string $name)
Return the value of a piece of metadata.
Definition: ElggEntity.php:333
getDisplayName()
Get the entity&#39;s display name.
Definition: ElggEntity.php:312
deleteIcon(string $type= 'icon')
Removes all icon files and metadata for the passed type of icon.
$guid
Reset an ElggUpgrade.
Definition: reset.php:6
getLongitude()
Return the entity&#39;s longitude.
hasIcon(string $size, string $type= 'icon')
Returns if the entity has an icon of the passed type.