/** * Check if resharing of this entity is allowed * * @param \ElggEntity $entity the entity to check * * @return bool */ protected static function canReshareEntity(\ElggEntity $entity) { if (!$entity instanceof \ElggEntity) { return false; } // only allow objects and groups if (!$entity instanceof \ElggObject && !$entity instanceof \ElggGroup) { return false; } // comments and discussion replies are never allowed $blocked_subtypes = ['comment', 'discussion_reply']; if (in_array($entity->getSubtype(), $blocked_subtypes)) { return false; } // by default allow searchable entities $reshare_allowed = false; if ($entity instanceof \ElggGroup) { $reshare_allowed = true; } else { $searchable_entities = get_registered_entity_types($entity->getType()); if (!empty($searchable_entities)) { $reshare_allowed = in_array($entity->getSubtype(), $searchable_entities); } } // trigger hook to allow others to change $params = ['entity' => $entity, 'user' => elgg_get_logged_in_user_entity()]; return (bool) elgg_trigger_plugin_hook('reshare', $entity->getType(), $params, $reshare_allowed); }
public function testGetSubtype() { $guid = $this->entity->guid; $this->assertEqual($this->entity->getSubtype(), 'elgg_entity_test_subtype'); _elgg_invalidate_cache_for_entity($guid); $this->entity = null; $this->entity = get_entity($guid); $this->assertEqual($this->entity->getSubtype(), 'elgg_entity_test_subtype'); }
/** * Check if entity type is registered for feature/unfeature * * @param ElggEntity $entity Entity to be featured * @return bool */ function actions_feature_is_allowed_type(ElggEntity $entity) { $type = $entity->getType(); $subtype = $entity->getSubtype(); $hook_type = implode(':', array_filter([$type, $subtype])); return elgg_trigger_plugin_hook('feature', $hook_type, ['entity' => $entity], false); }
/** * Checks if the given $entity is registered for notifications by * register_notification_object() * * @param ElggEntity $entity the entity to check * @param bool $subject return the subject string (default=false) * * @return bool|string */ function advanced_notifications_is_registered_notification_entity(ElggEntity $entity, $subject = false) { $result = false; if (!empty($entity) && $entity instanceof ElggEntity) { $type = $entity->getType(); if (empty($type)) { $type = "__BLANK__"; } $subtype = $entity->getSubtype(); if (empty($subtype)) { $subtype = "__BLANK__"; } // get the registered entity -> type/subtype $notifications = elgg_get_config("register_objects"); if (!empty($notifications) && is_array($notifications)) { if (isset($notifications[$type]) && isset($notifications[$type][$subtype])) { if ($subject) { $result = $notifications[$type][$subtype]; } else { $result = true; } } } } return $result; }
public function testSimpleGetters() { $this->obj->type = 'foo'; $this->obj->subtype = 'subtype'; $this->obj->owner_guid = 77; $this->obj->access_id = 2; $this->obj->time_created = 123456789; $this->assertEquals($this->obj->getGUID(), $this->obj->guid); $this->assertEquals($this->obj->getType(), $this->obj->type); // Note: before save() subtype returns string, int after // see https://github.com/Elgg/Elgg/issues/5920#issuecomment-25246298 $this->assertEquals($this->obj->getSubtype(), $this->obj->subtype); $this->assertEquals($this->obj->getOwnerGUID(), $this->obj->owner_guid); $this->assertEquals($this->obj->getAccessID(), $this->obj->access_id); $this->assertEquals($this->obj->getTimeCreated(), $this->obj->time_created); $this->assertEquals($this->obj->getTimeUpdated(), $this->obj->time_updated); }
/** * @param \ElggEntity $entity * @return bool|notification */ public function Build($entity) { switch ($entity->getSubtype()) { case 'sub_comment_notification': return new \WizmassNotifier\Notifications\SubCommentNotification($entity); case 'rate_comment_notification': return new \WizmassNotifier\Notifications\RateCommentNotification($entity); default: return false; } }
/** * Prepares object type string * @return string */ public function getObjectType() { $type = $this->object->getType(); $subtype = $this->object->getSubtype() ?: 'default'; $keys = ["interactions:{$type}:{$subtype}", $this->object instanceof Comment ? "interactions:comment" : "interactions:post"]; foreach ($keys as $key) { if (elgg_language_key_exists($key, $this->language)) { return elgg_echo($key, array(), $this->language); } } return elgg_echo('interactions:post', $this->language); }
/** * Set priority of an element in a list * * @see ElggEntity::$priority * * @param ElggEntity $entity * @return bool */ function hj_framework_set_entity_priority($entity, $priority = null) { if ($priority) { $entity->priority = $priority; return true; } $count = elgg_get_entities(array('type' => $entity->getType(), 'subtype' => $entity->getSubtype(), 'owner_guid' => $entity->owner_guid, 'container_guid' => $entity->container_guid, 'count' => true)); if (!$entity->priority) { $entity->priority = $count + 1; } return true; }
/** * @requires PHP 5.3.2 */ public function testSimpleGetters() { $this->obj->type = 'foo'; $this->obj->subtype = 'subtype'; $this->obj->owner_guid = 77; $this->obj->access_id = 2; $this->obj->time_created = 123456789; $this->assertEquals($this->obj->getGUID(), $this->obj->guid); $this->assertEquals($this->obj->getType(), $this->obj->type); $this->assertEquals($this->obj->getSubtype(), $this->obj->subtype); $this->assertEquals($this->obj->getOwnerGUID(), $this->obj->owner_guid); $this->assertEquals($this->obj->getAccessID(), $this->obj->access_id); $this->assertEquals($this->obj->getTimeCreated(), $this->obj->time_created); $this->assertEquals($this->obj->getTimeUpdated(), $this->obj->time_updated); }
/** * {@inheritdoc} */ public function getValues(\ElggEntity $entity) { $sticky = $this->getStickyValue(); if ($sticky) { return $sticky; } $name = $this->getShortname(); switch ($name) { default: return $entity->{$name} ?: $this->getDefaultValue(); case 'type': return $entity->getType(); case 'subtype': return $entity->getSubtype(); } }
/** * Track certain events on ElggEntity's * * @param string $event the event * @param string $type the type of the ElggEntity * @param \ElggEntity $object the entity for the event * * @return void */ public static function events($event, $type, $object) { if (!$object instanceof \ElggEntity) { return; } if (!analytics_google_track_events_enabled()) { return; } switch ($object->getType()) { case 'object': analytics_track_event($object->getSubtype(), $event, $object->title); break; case 'group': case 'user': analytics_track_event($object->getType(), $event, $object->name); break; } }
function evan_user_can($verb, Entity $object, Entity $target = NULL) { switch ($verb) { case 'post': if (!$target) { $target = elgg_get_logged_in_user_entity(); } $result = $target->canWriteToContainer(0, $object->getType(), $object->getSubtype()); break; case 'update': $result = $object->canEdit(); break; default: $result = false; break; } return elgg_trigger_plugin_hook("permission", $verb, array('actor' => elgg_get_logged_in_user_entity(), 'verb' => $verb, 'object' => $object, 'target' => $target), $result); }
/** * Listen to the 'publish','object' event and send out notifications * to interested users, as well as anyone tagged * * @param string $event Equals 'publish' * @param string $entity_type Equals 'object' * @param ElggEntity $entity Published entity */ function send_custom_notifications($event, $entity_type, $entity) { if ($entity->origin !== 'wall') { return true; } // We only want to notify about wire posts and wall posts, all content created therewith is implied $accepted_subtypes = array('hjwall', 'thewire'); if (!in_array($entity->getSubtype(), $accepted_subtypes)) { return true; } $poster = $entity->getOwnerEntity(); $container = $entity->getContainerEntity(); $message = format_wall_message($entity, true); $sent = array(elgg_get_logged_in_user_guid(), $poster->guid, $container->guid); // Notify wall owner if ($poster->guid !== $container->guid && elgg_instanceof($container, 'user')) { $to = $container->guid; $from = $poster->guid; $target = elgg_echo("wall:target:{$entity->getSubtype()}"); $ownership = elgg_echo('wall:ownership:your', array($target)); $subject = elgg_echo('wall:new:notification:subject', array($poster->name, $ownership)); $summary = elgg_view('output/url', array('text' => $subject, 'href' => $entity->getURL())); $body = elgg_echo('wall:new:notification:message', array($poster->name, $ownership, $message, $entity->getURL())); notify_user($to, $from, $subject, $body, array('summary' => $summary, 'object' => $entity, 'action' => 'received')); } // Notify tagged users $tagged_friends = get_tagged_friends($entity); foreach ($tagged_friends as $tagged_friend) { // user tagged herself or the wall owner if ($tagged_friend->guid == $poster->guid || $tagged_friend->guid == $container->guid || in_array($tagged_friend->guid, $sent)) { continue; } $sent[] = $tagged_friend->guid; $to = $tagged_friend->guid; $from = $poster->guid; $subject = elgg_echo('wall:tagged:notification:subject', array($poster->name)); $summary = elgg_view('output/url', array('text' => $subject, 'href' => $entity->getURL())); $body = elgg_echo('wall:tagged:notification:message', array($poster->name, $message, $entity->getURL())); notify_user($to, $from, $subject, $body, array('summary' => $summary, 'object' => $entity, 'action' => 'tagged')); } return true; }
/** * Checks if a user can subscribe to a content item * * @param ElggEntity $entity the entity to check * @param int $user_guid the user to check (default: current user) * * @return bool */ function content_subscriptions_can_subscribe(ElggEntity $entity, $user_guid = 0) { $user_guid = sanitise_int($user_guid, false); if (empty($user_guid)) { $user_guid = elgg_get_logged_in_user_guid(); } if (empty($user_guid) || !$entity instanceof ElggEntity) { return false; } if ($entity->getOwnerGUID() === $user_guid) { // owner cant subscribe to own content return false; } $supported_entity_types = content_subscriptions_get_supported_entity_types(); if (empty($supported_entity_types)) { return false; } $type = $entity->getType(); if (!isset($supported_entity_types[$type])) { return false; } $subtype = $entity->getSubtype(); if (!empty($subtype)) { return in_array($subtype, $supported_entity_types[$type]); } return true; }
/** * Creates default widgets * * This plugin hook handler is registered for events based on what kinds of * default widgets have been registered. See elgg_default_widgets_init() for * information on registering new default widget contexts. * * @param string $event The event * @param string $type The type of object * @param \ElggEntity $entity The entity being created * @return void * @access private */ function _elgg_create_default_widgets($event, $type, $entity) { $default_widget_info = elgg_get_config('default_widget_info'); if (!$default_widget_info || !$entity) { return; } $type = $entity->getType(); $subtype = $entity->getSubtype(); // event is already guaranteed by the hook registration. // need to check subtype and type. foreach ($default_widget_info as $info) { if ($info['entity_type'] == $type) { if ($info['entity_subtype'] == ELGG_ENTITIES_ANY_VALUE || $info['entity_subtype'] == $subtype) { // need to be able to access everything $old_ia = elgg_set_ignore_access(true); elgg_push_context('create_default_widgets'); // pull in by widget context with widget owners as the site // not using elgg_get_widgets() because it sorts by columns and we don't care right now. $options = array('type' => 'object', 'subtype' => 'widget', 'owner_guid' => elgg_get_site_entity()->guid, 'private_setting_name' => 'context', 'private_setting_value' => $info['widget_context'], 'limit' => 0); $widgets = elgg_get_entities_from_private_settings($options); /* @var \ElggWidget[] $widgets */ foreach ($widgets as $widget) { // change the container and owner $new_widget = clone $widget; $new_widget->container_guid = $entity->guid; $new_widget->owner_guid = $entity->guid; // pull in settings $settings = get_all_private_settings($widget->guid); foreach ($settings as $name => $value) { $new_widget->{$name} = $value; } $new_widget->save(); } elgg_set_ignore_access($old_ia); elgg_pop_context(); } } } }
/** * Returns rendered comments and a comment form for an entity. * * @tip Plugins can override the output by registering a handler * for the comments, $entity_type hook. The handler is responsible * for formatting the comments and the add comment form. * * @param ElggEntity $entity The entity to view comments of * @param bool $add_comment Include a form to add comments? * @param array $vars Variables to pass to comment view * * @return string|false Rendered comments or false on failure */ function elgg_view_comments($entity, $add_comment = true, array $vars = array()) { if (!$entity instanceof ElggEntity) { return false; } $vars['entity'] = $entity; $vars['show_add_form'] = $add_comment; $vars['class'] = elgg_extract('class', $vars, "{$entity->getSubtype()}-comments"); $output = elgg_trigger_plugin_hook('comments', $entity->getType(), $vars, false); if ($output) { return $output; } else { return elgg_view('page/elements/comments', $vars); } }
public static function getExtraValues(ElggEntity $entity) { global $CONFIG; if (!$entity) { return FALSE; } $return['url'] = $entity->getURL(); $return['subtype'] = $entity->getSubtype(); $return['title'] = $entity->title; $return['icon_small'] = $entity->getIcon('small'); $return['icon_medium'] = $entity->getIcon('medium'); $return['icon_large'] = $entity->getIcon('large'); $return['access_id'] = $entity->access_id; $return['site_url'] = $CONFIG->wwwroot; if ($entity->canEdit()) { $return['canedit'] = $entity->canEdit(); } if ((string) $entity->container_name == '') { $container_entity = get_entity($entity->container_guid); if ($container_entity) { $return['container_name'] = $container_entity->name; $return['container_username'] = $container_entity->username; $return['container_url'] = $container_entity->getURL(); $return['container_icon'] = str_replace('size=medium', 'size=small', $container_entity->getIcon()); } } else { $return['container_name'] = $entity->name; $return['container_username'] = $entity->username; $return['container_url'] = $entity->getURL(); $return['container_icon'] = str_replace('size=medium', 'size=small', $entity->getIcon()); } return $return; }
/** * Generate icons for an entity * * @param ElggEntity $entity * @param ElggFile $filehandler Valid $filehandler on Elgg filestore to grab the file from | can be null if $entity is instance of ElggFile * @param array $coords Coordinates for cropping * @return boolean */ function hj_framework_generate_entity_icons($entity, $filehandler = null, $coords = array()) { $icon_sizes = hj_framework_get_thumb_sizes($entity->getSubtype()); if (!$filehandler && $entity instanceof hjFile) { $filehandler = $entity; } if (!$filehandler) { return false; } $prefix = "icons/" . $entity->getGUID(); foreach ($icon_sizes as $size => $values) { if (!empty($coords) && in_array($size, array('topbar', 'tiny', 'small', 'medium', 'large'))) { $thumb_resized = get_resized_image_from_existing_file($filehandler->getFilenameOnFilestore(), $values['w'], $values['h'], $values['square'], $coords['x1'], $coords['y1'], $coords['x2'], $coords['y2'], $values['upscale']); } else { if (empty($coords)) { $thumb_resized = get_resized_image_from_existing_file($filehandler->getFilenameOnFilestore(), $values['w'], $values['h'], $values['square'], 0, 0, 0, 0, $values['upscale']); } } if ($thumb_resized) { $thumb = new hjFile(); $thumb->owner_guid = $entity->owner_guid; $thumb->setMimeType('image/jpeg'); $thumb->setFilename($prefix . "{$size}.jpg"); $thumb->open("write"); $thumb->write($thumb_resized); $thumb->close(); $icontime = true; } } if ($icontime) { $entity->icontime = time(); return true; } return false; }
/** * Get icon size config * * @param \ElggEntity $entity Entity * @param array $icon_sizes Predefined icon sizes * @return array */ public function getSizes(\ElggEntity $entity, array $icon_sizes = array()) { $defaults = $entity && $entity->getSubtype() == 'file' ? $this->config->getFileIconSizes() : $this->config->getGlobalIconSizes(); $sizes = array_merge($defaults, $icon_sizes); return elgg_trigger_plugin_hook('entity:icon:sizes', $entity->getType(), array('entity' => $entity, 'subtype' => $entity->getSubtype()), $sizes); }
/** * Checks if media type is allowed for given entity * * @param \ElggEntity $entity Entity * @param string $type Media type * @return bool */ function elgg_media_get_thumb_sizes(\ElggEntity $entity, $type = 'icon') { $hook_type = implode(':', array_filter([$entity->getType(), $entity->getSubtype()])); $hook_params = ['type' => $type, 'entity' => $entity]; return elgg_trigger_plugin_hook("entity:{$type}:sizes", $hook_type, $hook_params, []); }
/** * Populates entity doc with default index fields * * @param DocumentInterface $doc Solr document * @param ElggEntity $entity Elgg entity * @return DocumentInterface */ function elgg_solr_prepare_entity_doc(DocumentInterface $doc, ElggEntity $entity) { $doc->id = $entity->guid; $doc->type = $entity->type; $doc->subtype = (string) $entity->getSubtype(); $doc->owner_guid = $entity->owner_guid; $doc->container_guid = $entity->container_guid; $doc->access_id = $entity->access_id; $doc->title = elgg_strip_tags($entity->title); $doc->name = elgg_strip_tags($entity->name); $doc->description = elgg_strip_tags($entity->description); $doc->time_created = $entity->time_created; $doc->time_updated_i = $entity->time_updated; $doc = elgg_solr_add_tags($doc, $entity); $doc->enabled = $entity->enabled; if (is_callable([$entity, 'hasIcon'])) { $doc->has_icon_b = $entity->hasIcon('small'); } else { $doc->has_icon_b = (bool) $entity->icontime; } if ($entity instanceof ElggFile) { $mimetype = (string) $entity->getMimeType(); $doc->simpletype_s = (string) elgg_get_file_simple_type($mimetype); $doc->mimetype_s = $mimetype; $doc->originalfilename_s = $entity->originalfilename; if ($entity->exists()) { $doc->exists_b = true; $doc->filestorename_s = $entity->getFilenameOnFilestore(); $doc->filesize_i = (int) $entity->getSize(); } else { $doc->exists_b = false; } } // Store comment/reply thread information to allow grouping if ($entity instanceof ElggComment) { $container = $entity->getContainerEntity(); while ($container instanceof ElggComment) { $container = $container->getContainerEntity(); } $doc->responses_thread_i = $container->guid; } else { $doc->responses_thread_i = $entity->guid; } // Store comment/reply guids $responses = []; $responses_batch = new ElggBatch('elgg_get_entities', ['types' => 'object', 'subtypes' => ['comment', 'discussion_reply'], 'container_guid' => $entity->guid, 'limit' => 0, 'callback' => false]); foreach ($responses_batch as $response) { $responses[] = $response->guid; } $doc->responses_is = $responses; $doc->responses_count_i = count($responses); $doc->likes_i = $entity->countAnnotations('likes'); $params = array('entity' => $entity); $doc = elgg_trigger_plugin_hook('elgg_solr:index', $entity->type, $params, $doc); if ($entity->getSubtype()) { $doc = elgg_trigger_plugin_hook('elgg_solr:index', "{$entity->type}:{$entity->getSubtype()}", $params, $doc); } return $doc; }
function entity_view_counter_is_counted(ElggEntity $entity) { if (php_sapi_name() === 'cli') { return true; } if (!entity_view_counter_is_configured_entity_type($entity->getType(), $entity->getSubtype())) { return true; } if (isset($_SERVER["HTTP_USER_AGENT"]) && preg_match('/bot|crawl|slurp|spider/i', $_SERVER["HTTP_USER_AGENT"])) { return true; } $user = elgg_get_logged_in_user_entity(); if ($user && $user->getGUID() == $entity->getOwnerGUID()) { return true; } if (is_memcache_available()) { $cache = new ElggMemcache('entity_view_counter'); $key = "view_" . session_id() . "_" . $entity->guid; if ($cache->load($key)) { return true; } } if (entity_view_counter_ignore_ip()) { return true; } return false; }
/** * When an entity is updated, resets the access ID on all of its child metadata * * @param string $event The name of the event * @param string $object_type The type of object * @param \ElggEntity $object The entity itself * * @return true * @access private Set as private in 1.9.0 */ function handleUpdate($event, $object_type, $object) { if ($object instanceof \ElggEntity) { if (!$this->isMetadataIndependent($object->getType(), $object->getSubtype())) { $access_id = (int) $object->access_id; $guid = (int) $object->getGUID(); $query = "update {$this->table} set access_id = {$access_id} where entity_guid = {$guid}"; $this->db->updateData($query); } } return true; }
/** * Prepare entity SEF data * * @param \ElggEntity $entity Entity * @return array|false */ function seo_prepare_entity_data(\ElggEntity $entity) { $path = seo_get_path($entity->getURL()); if (!$path || $path == '/') { return false; } $type = $entity->getType(); switch ($type) { case 'user': if (elgg_is_active_plugin('profile')) { $sef_path = "/profile/{$entity->username}"; } break; case 'group': $subtype = $entity->getSubtype(); $registered = (array) get_registered_entity_types('group'); if (!$subtype || in_array($subtype, $registered)) { if ($subtype && elgg_language_key_exists("item:group:{$subtype}", 'en')) { $prefix = elgg_get_friendly_title(elgg_echo("item:group:{$subtype}", array(), 'en')); } else { $prefix = elgg_get_friendly_title(elgg_echo('item:group', array(), 'en')); } $friendly_title = elgg_get_friendly_title($entity->getDisplayName() ?: ''); $sef_path = "/{$prefix}/{$entity->guid}-{$friendly_title}"; } break; case 'object': $subtype = $entity->getSubtype(); $registered = (array) get_registered_entity_types('object'); if (in_array($subtype, $registered)) { if (elgg_language_key_exists("item:object:{$subtype}", 'en')) { $prefix = elgg_get_friendly_title(elgg_echo("item:object:{$subtype}", array(), 'en')); } else { $prefix = elgg_get_friendly_title($subtype); } $friendly_title = elgg_get_friendly_title($entity->getDisplayName() ?: ''); $sef_path = "/{$prefix}/{$entity->guid}-{$friendly_title}"; } break; } if (!$sef_path) { $sef_path = $path; } $sef_data = seo_get_data($entity->getURL()); if (!is_array($sef_data)) { $sef_data = array(); } $entity_sef_data = ['path' => $path, 'sef_path' => $sef_path, 'title' => $entity->getDisplayName(), 'description' => elgg_get_excerpt($entity->description), 'keywords' => is_array($entity->tags) ? implode(',', $entity->tags) : $entity->tags, 'guid' => $entity->guid]; if ($entity->guid != $entity->owner_guid) { $owner = $entity->getOwnerEntity(); if ($owner) { $entity_sef_data['owner'] = seo_prepare_entity_data($owner); } } if ($entity->guid != $entity->container_guid && $entity->owner_guid != $entity->container_guid) { $container = $entity->getContainerEntity(); if ($container) { $entity_sef_data['container'] = seo_prepare_entity_data($container); } } if (empty($sef_data['admin_defined'])) { $sef_data = array_merge($sef_data, $entity_sef_data); } else { foreach ($entity_sef_data as $key => $value) { if (empty($sef_data[$key])) { $sef_data[$key] = $value; } } } $entity_sef_metatags = elgg_trigger_plugin_hook('metatags', 'discovery', ['entity' => $entity, 'url' => elgg_normalize_url($sef_path)], []); if (!empty($entity_sef_metatags)) { foreach ($entity_sef_metatags as $key => $value) { if (empty($sef_data['admin_defined']) || empty($sef_data['metatags'][$key])) { $sef_data['metatags'][$key] = $value; } } } return $sef_data; }
/** * When an entity is updated, resets the access ID on all of its child metadata * * @param string $event The name of the event * @param string $object_type The type of object * @param ElggEntity $object The entity itself * * @return true * @access private Set as private in 1.9.0 */ function metadata_update($event, $object_type, $object) { if ($object instanceof ElggEntity) { if (!is_metadata_independent($object->getType(), $object->getSubtype())) { $db_prefix = elgg_get_config('dbprefix'); $access_id = (int) $object->access_id; $guid = (int) $object->getGUID(); $query = "update {$db_prefix}metadata set access_id = {$access_id} where entity_guid = {$guid}"; update_data($query); } } return true; }
/** * When an entity is updated, resets the access ID on all of its child metadata * * @param string $event The name of the event * @param string $object_type The type of object * @param ElggEntity $object The entity itself */ function metadata_update($event, $object_type, $object) { if ($object instanceof ElggEntity) { if (!is_metadata_independent($object->getType(), $object->getSubtype())) { global $CONFIG; $access_id = (int) $object->access_id; $guid = (int) $object->getGUID(); update_data("update {$CONFIG->dbprefix}metadata set access_id = {$access_id} where entity_guid = {$guid}"); } } return true; }
/** * When given an entity, views it intelligently. * * Expects a view to exist called entity-type/subtype, or for the entity to have a parameter * 'view' which lists a different view to display. In both cases, elgg_view will be called with * array('entity' => $entity, 'full' => $full) as its parameters, and therefore this is what * the view should expect to receive. * * @param ElggEntity $entity The entity to display * @param boolean $full Determines whether or not to display the full version of an object, or a smaller version for use in aggregators etc * @param boolean $bypass If set to true, elgg_view will bypass any specified alternative template handler; by default, it will hand off to this if requested (see set_template_handler) * @param boolean $debug If set to true, the viewer will complain if it can't find a view * @return string HTML to display or false */ function elgg_view_entity(ElggEntity $entity, $full = false, $bypass = true, $debug = false) { global $autofeed; $autofeed = true; // No point continuing if entity is null if (!$entity) { return ''; } if (!$entity instanceof ElggEntity) { return false; } // if this entity has a view defined, use it $view = $entity->view; if (is_string($view)) { return elgg_view($view, array('entity' => $entity, 'full' => $full), $bypass, $debug); } $entity_type = $entity->getType(); $subtype = $entity->getSubtype(); if (empty($subtype)) { $subtype = $entity_type; } $contents = ''; if (elgg_view_exists("{$entity_type}/{$subtype}")) { $contents = elgg_view("{$entity_type}/{$subtype}", array('entity' => $entity, 'full' => $full), $bypass, $debug); } if (empty($contents)) { $contents = elgg_view("{$entity_type}/default", array('entity' => $entity, 'full' => $full), $bypass, $debug); } // Marcus Povey 20090616 : Speculative and low impact approach for fixing #964 if ($full) { $annotations = elgg_view_entity_annotations($entity, $full); if ($annotations) { $contents .= $annotations; } } return $contents; }
/** * Return the icon URL for an entity. * * @tip Can be overridden by registering a plugin hook for entity:icon:url, $entity_type. * * @internal This is passed an entity rather than a guid to handle non-created entities. * * @param ElggEntity $entity The entity * @param string $size Icon size * * @return string URL to the entity icon. * @deprecated 1.8 Use $entity->getIconURL() */ function get_entity_icon_url(ElggEntity $entity, $size = 'medium') { elgg_deprecated_notice("get_entity_icon_url() deprecated for getIconURL()", 1.8); global $CONFIG; $size = sanitise_string($size); switch (strtolower($size)) { case 'master': $size = 'master'; break; case 'large': $size = 'large'; break; case 'topbar': $size = 'topbar'; break; case 'tiny': $size = 'tiny'; break; case 'small': $size = 'small'; break; case 'medium': default: $size = 'medium'; } $url = false; $viewtype = elgg_get_viewtype(); // Step one, see if anyone knows how to render this in the current view $params = array('entity' => $entity, 'viewtype' => $viewtype, 'size' => $size); $url = elgg_trigger_plugin_hook('entity:icon:url', $entity->getType(), $params, $url); // Fail, so use default if (!$url) { $type = $entity->getType(); $subtype = $entity->getSubtype(); if (!empty($subtype)) { $overrideurl = elgg_view("icon/{$type}/{$subtype}/{$size}", array('entity' => $entity)); if (!empty($overrideurl)) { return $overrideurl; } } $overrideurl = elgg_view("icon/{$type}/default/{$size}", array('entity' => $entity)); if (!empty($overrideurl)) { return $overrideurl; } $url = "_graphics/icons/default/{$size}.png"; } return elgg_normalize_url($url); }
/** * Check if the given entity is searchable (and needs to be in Elasticsearch) * * @param \ElggEntity $entity the entity * * @return bool */ protected static function isSearchableEntity(\ElggEntity $entity) { if (empty($entity) || !$entity instanceof \ElggEntity) { return false; } $type = $entity->getType(); $type_subtypes = elasticsearch_get_registered_entity_types(); if (!isset($type_subtypes[$type])) { return false; } $subtype = $entity->getSubtype(); if (empty($subtype)) { // eg. user, group, site return true; } return in_array($subtype, $type_subtypes[$type]); }