engine/classes/ElggEntity.php

Go to the documentation of this file.

<?php
abstract class ElggEntity extends ElggData implements
    Notable,    // Calendar interface
    Locatable,  // Geocoding interface
    Importable // Allow import of data
{

    protected $url_override;

    protected $icon_override;

    protected $temp_metadata = array();

    protected $temp_annotations = array();

    protected $temp_private_settings = array();

    protected $volatile = array();

    protected function initializeAttributes() {
        parent::initializeAttributes();

        $this->attributes['guid'] = NULL;
        $this->attributes['type'] = NULL;
        $this->attributes['subtype'] = NULL;

        $this->attributes['owner_guid'] = elgg_get_logged_in_user_guid();
        $this->attributes['container_guid'] = elgg_get_logged_in_user_guid();

        $this->attributes['site_guid'] = NULL;
        $this->attributes['access_id'] = ACCESS_PRIVATE;
        $this->attributes['time_created'] = NULL;
        $this->attributes['time_updated'] = NULL;
        $this->attributes['last_action'] = NULL;
        $this->attributes['enabled'] = "yes";

        // There now follows a bit of a hack
        /* Problem: To speed things up, some objects are split over several tables,
         * this means that it requires n number of database reads to fully populate
         * an entity. This causes problems for caching and create events
         * since it is not possible to tell whether a subclassed entity is complete.
         *
         * Solution: We have two counters, one 'tables_split' which tells whatever is
         * interested how many tables are going to need to be searched in order to fully
         * populate this object, and 'tables_loaded' which is how many have been
         * loaded thus far.
         *
         * If the two are the same then this object is complete.
         *
         * Use: isFullyLoaded() to check
         */
        $this->attributes['tables_split'] = 1;
        $this->attributes['tables_loaded'] = 0;
    }

    public function __clone() {
        $orig_entity = get_entity($this->guid);
        if (!$orig_entity) {
            elgg_log("Failed to clone entity with GUID $this->guid", "ERROR");
            return;
        }

        $metadata_array = elgg_get_metadata(array(
            'guid' => $this->guid,
            'limit' => 0
        ));

        $this->attributes['guid'] = "";

        $this->attributes['subtype'] = $orig_entity->getSubtype();

        // copy metadata over to new entity - slightly convoluted due to
        // handling of metadata arrays
        if (is_array($metadata_array)) {
            // create list of metadata names
            $metadata_names = array();
            foreach ($metadata_array as $metadata) {
                $metadata_names[] = $metadata['name'];
            }
            // arrays are stored with multiple enties per name
            $metadata_names = array_unique($metadata_names);

            // move the metadata over
            foreach ($metadata_names as $name) {
                $this->set($name, $orig_entity->$name);
            }
        }
    }

    public function get($name) {
        // See if its in our base attributes
        if (array_key_exists($name, $this->attributes)) {
            return $this->attributes[$name];
        }

        // No, so see if its in the meta data for this entity
        $meta = $this->getMetaData($name);

        // getMetaData returns NULL if $name is not found
        return $meta;
    }

    public function set($name, $value) {
        if (array_key_exists($name, $this->attributes)) {
            // Certain properties should not be manually changed!
            switch ($name) {
                case 'guid':
                case 'time_updated':
                case 'last_action':
                    return FALSE;
                    break;
                default:
                    $this->attributes[$name] = $value;
                    break;
            }
        } else {
            return $this->setMetaData($name, $value);
        }

        return TRUE;
    }

    public function getMetaData($name) {
        $guid = $this->getGUID();

        if (! $guid) {
            if (isset($this->temp_metadata[$name])) {
                // md is returned as an array only if more than 1 entry
                if (count($this->temp_metadata[$name]) == 1) {
                    return $this->temp_metadata[$name][0];
                } else {
                    return $this->temp_metadata[$name];
                }
            } else {
                return null;
            }
        }

        // upon first cache miss, just load/cache all the metadata and retry.
        // if this works, the rest of this function may not be needed!
        $cache = elgg_get_metadata_cache();
        if ($cache->isKnown($guid, $name)) {
            return $cache->load($guid, $name);
        } else {
            $cache->populateFromEntities(array($guid));
            // in case ignore_access was on, we have to check again...
            if ($cache->isKnown($guid, $name)) {
                return $cache->load($guid, $name);
            }
        }

        $md = elgg_get_metadata(array(
            'guid' => $guid,
            'metadata_name' => $name,
            'limit' => 0,
        ));

        $value = null;

        if ($md && !is_array($md)) {
            $value = $md->value;
        } elseif (count($md) == 1) {
            $value = $md[0]->value;
        } else if ($md && is_array($md)) {
            $value = metadata_array_to_values($md);
        }

        $cache->save($guid, $name, $value);

        return $value;
    }

    function __unset($name) {
        if (array_key_exists($name, $this->attributes)) {
            $this->attributes[$name] = "";
        } else {
            $this->deleteMetadata($name);
        }
    }

    public function setMetaData($name, $value, $value_type = null, $multiple = false) {

        // normalize value to an array that we will loop over
        // remove indexes if value already an array.
        if (is_array($value)) {
            $value = array_values($value);
        } else {
            $value = array($value);
        }

        // saved entity. persist md to db.
        if ($this->guid) {
            // if overwriting, delete first.
            if (!$multiple) {
                $options = array(
                    'guid' => $this->getGUID(),
                    'metadata_name' => $name,
                    'limit' => 0
                );
                // @todo in 1.9 make this return false if can't add metadata
                // http://trac.elgg.org/ticket/4520
                // 
                // need to remove access restrictions right now to delete
                // because this is the expected behavior
                $ia = elgg_set_ignore_access(true);
                if (false === elgg_delete_metadata($options)) {
                    return false;
                }
                elgg_set_ignore_access($ia);
            }

            // add new md
            $result = true;
            foreach ($value as $value_tmp) {
                // at this point $value should be appended because it was cleared above if needed.
                $md_id = create_metadata($this->getGUID(), $name, $value_tmp, $value_type,
                        $this->getOwnerGUID(), $this->getAccessId(), true);
                if (!$md_id) {
                    return false;
                }
            }

            return $result;
        } else {
            // unsaved entity. store in temp array
            // returning single entries instead of an array of 1 element is decided in
            // getMetaData(), just like pulling from the db.
            // 
            // if overwrite, delete first
            if (!$multiple || !isset($this->temp_metadata[$name])) {
                $this->temp_metadata[$name] = array();
            }

            // add new md
            $this->temp_metadata[$name] = array_merge($this->temp_metadata[$name], $value);
            return true;
        }
    }

    public function deleteMetadata($name = null) {

        if (!$this->guid) {
            return false;
        }

        $options = array(
            'guid' => $this->guid,
            'limit' => 0
        );
        if ($name) {
            $options['metadata_name'] = $name;
        }

        return elgg_delete_metadata($options);
    }

    public function deleteOwnedMetadata($name = null) {
        // access is turned off for this because they might
        // no longer have access to an entity they created metadata on.
        $ia = elgg_set_ignore_access(true);
        $options = array(
            'metadata_owner_guid' => $this->guid,
            'limit' => 0
        );
        if ($name) {
            $options['metadata_name'] = $name;
        }

        $r = elgg_delete_metadata($options);
        elgg_set_ignore_access($ia);
        return $r;
    }

    public function clearMetaData($name = '') {
        elgg_deprecated_notice('ElggEntity->clearMetadata() is deprecated by ->deleteMetadata()', 1.8);
        return $this->deleteMetadata($name);
    }

    public function disableMetadata($name = '') {
        $options = array(
            'guid' => $this->guid,
            'limit' => 0
        );
        if ($name) {
            $options['metadata_name'] = $name;
        }

        return elgg_disable_metadata($options);
    }

    public function enableMetadata($name = '') {
        $options = array(
            'guid' => $this->guid,
            'limit' => 0
        );
        if ($name) {
            $options['metadata_name'] = $name;
        }

        return elgg_enable_metadata($options);
    }

    public function getVolatileData($name) {
        if (!is_array($this->volatile)) {
            $this->volatile = array();
        }

        if (array_key_exists($name, $this->volatile)) {
            return $this->volatile[$name];
        } else {
            return NULL;
        }
    }

    public function setVolatileData($name, $value) {
        if (!is_array($this->volatile)) {
            $this->volatile = array();
        }

        $this->volatile[$name] = $value;
    }

    public function deleteRelationships() {
        remove_entity_relationships($this->getGUID());
        remove_entity_relationships($this->getGUID(), "", true);
        return true;
    }

    public function clearRelationships() {
        elgg_deprecated_notice('ElggEntity->clearRelationships() is deprecated by ->deleteRelationships()', 1.8);
        return $this->deleteRelationships();
    }

    public function addRelationship($guid, $relationship) {
        return add_entity_relationship($this->getGUID(), $relationship, $guid);
    }

    public function removeRelationship($guid, $relationship) {
        return remove_entity_relationship($this->getGUID(), $relationship, $guid);
    }

    function setPrivateSetting($name, $value) {
        if ((int) $this->guid > 0) {
            return set_private_setting($this->getGUID(), $name, $value);
        } else {
            $this->temp_private_settings[$name] = $value;
            return true;
        }
    }

    function getPrivateSetting($name) {
        if ((int) ($this->guid) > 0) {
            return get_private_setting($this->getGUID(), $name);
        } else {
            if (isset($this->temp_private_settings[$name])) {
                return $this->temp_private_settings[$name];
            }
        }
        return null;
    }

    function removePrivateSetting($name) {
        return remove_private_setting($this->getGUID(), $name);
    }

    public function deleteAnnotations($name = null) {
        $options = array(
            'guid' => $this->guid,
            'limit' => 0
        );
        if ($name) {
            $options['annotation_name'] = $name;
        }

        return elgg_delete_annotations($options);
    }

    public function deleteOwnedAnnotations($name = null) {
        // access is turned off for this because they might
        // no longer have access to an entity they created annotations on.
        $ia = elgg_set_ignore_access(true);
        $options = array(
            'annotation_owner_guid' => $this->guid,
            'limit' => 0
        );
        if ($name) {
            $options['annotation_name'] = $name;
        }

        $r = elgg_delete_annotations($options);
        elgg_set_ignore_access($ia);
        return $r;
    }

    public function disableAnnotations($name = '') {
        $options = array(
            'guid' => $this->guid,
            'limit' => 0
        );
        if ($name) {
            $options['annotation_name'] = $name;
        }

        return elgg_disable_annotations($options);
    }

    public function enableAnnotations($name = '') {
        $options = array(
            'guid' => $this->guid,
            'limit' => 0
        );
        if ($name) {
            $options['annotation_name'] = $name;
        }

        return elgg_enable_annotations($options);
    }

    private function getAnnotationCalculation($name, $calculation) {
        $options = array(
            'guid' => $this->getGUID(),
            'annotation_name' => $name,
            'annotation_calculation' => $calculation
        );

        return elgg_get_annotations($options);
    }

    function annotate($name, $value, $access_id = ACCESS_PRIVATE, $owner_id = 0, $vartype = "") {
        if ((int) $this->guid > 0) {
            return create_annotation($this->getGUID(), $name, $value, $vartype, $owner_id, $access_id);
        } else {
            $this->temp_annotations[$name] = $value;
        }
        return true;
    }

    function getAnnotations($name, $limit = 50, $offset = 0, $order = "asc") {
        if ((int) ($this->guid) > 0) {

            $options = array(
                'guid' => $this->guid,
                'annotation_name' => $name,
                'limit' => $limit,
                'offset' => $offset,
            );

            if ($order != 'asc') {
                $options['reverse_order_by'] = true;
            }

            return elgg_get_annotations($options);
        } else if (isset($this->temp_annotations[$name])) {
            return array($this->temp_annotations[$name]);
        } else {
            return array();
        }
    }

    function clearAnnotations($name = "") {
        elgg_deprecated_notice('ElggEntity->clearAnnotations() is deprecated by ->deleteAnnotations()', 1.8);
        return $this->deleteAnnotations($name);
    }

    function countAnnotations($name = "") {
        return $this->getAnnotationCalculation($name, 'count');
    }

    function getAnnotationsAvg($name) {
        return $this->getAnnotationCalculation($name, 'avg');
    }

    function getAnnotationsSum($name) {
        return $this->getAnnotationCalculation($name, 'sum');
    }

    function getAnnotationsMin($name) {
        return $this->getAnnotationCalculation($name, 'min');
    }

    function getAnnotationsMax($name) {
        return $this->getAnnotationCalculation($name, 'max');
    }

    function countComments() {
        $params = array('entity' => $this);
        $num = elgg_trigger_plugin_hook('comments:count', $this->getType(), $params);

        if (is_int($num)) {
            return $num;
        } else {
            return $this->getAnnotationCalculation('generic_comment', 'count');
        }
    }

    function getEntitiesFromRelationship($relationship, $inverse = false, $limit = 50, $offset = 0) {
        return elgg_get_entities_from_relationship(array(
            'relationship' => $relationship,
            'relationship_guid' => $this->getGUID(),
            'inverse_relationship' => $inverse,
            'limit' => $limit,
            'offset' => $offset
        ));
    }

    function countEntitiesFromRelationship($relationship, $inverse_relationship = FALSE) {
        return elgg_get_entities_from_relationship(array(
            'relationship' => $relationship,
            'relationship_guid' => $this->getGUID(),
            'inverse_relationship' => $inverse_relationship,
            'count' => TRUE
        ));
    }

    function canEdit($user_guid = 0) {
        return can_edit_entity($this->getGUID(), $user_guid);
    }

    function canEditMetadata($metadata = null, $user_guid = 0) {
        return can_edit_entity_metadata($this->getGUID(), $user_guid, $metadata);
    }

    public function canWriteToContainer($user_guid = 0, $type = 'all', $subtype = 'all') {
        return can_write_to_container($user_guid, $this->guid, $type, $subtype);
    }

    public function canComment($user_guid = 0) {
        if ($user_guid == 0) {
            $user_guid = elgg_get_logged_in_user_guid();
        }
        $user = get_entity($user_guid);

        // By default, we don't take a position of whether commenting is allowed
        // because it is handled by the subclasses of ElggEntity
        $params = array('entity' => $this, 'user' => $user);
        return elgg_trigger_plugin_hook('permissions_check:comment', $this->type, $params, null);
    }

    public function canAnnotate($user_guid = 0, $annotation_name = '') {
        if ($user_guid == 0) {
            $user_guid = elgg_get_logged_in_user_guid();
        }
        $user = get_entity($user_guid);

        $return = true;
        if (!$user) {
            $return = false;
        }

        $params = array(
            'entity' => $this,
            'user' => $user,
            'annotation_name' => $annotation_name,
        );
        return elgg_trigger_plugin_hook('permissions_check:annotate', $this->type, $params, $return);
    }

    public function getAccessID() {
        return $this->get('access_id');
    }

    public function getGUID() {
        return $this->get('guid');
    }

    public function getType() {
        return $this->get('type');
    }

    public function getSubtype() {
        // If this object hasn't been saved, then return the subtype string.
        if (!((int) $this->guid > 0)) {
            return $this->get('subtype');
        }

        return get_subtype_from_id($this->get('subtype'));
    }

    public function getOwnerGUID() {
        return $this->owner_guid;
    }

    public function getOwner() {
        elgg_deprecated_notice("ElggEntity::getOwner deprecated for ElggEntity::getOwnerGUID", 1.8);
        return $this->getOwnerGUID();
    }

    public function getOwnerEntity() {
        return get_entity($this->owner_guid);
    }

    public function setContainerGUID($container_guid) {
        $container_guid = (int)$container_guid;

        return $this->set('container_guid', $container_guid);
    }

    public function setContainer($container_guid) {
        elgg_deprecated_notice("ElggObject::setContainer deprecated for ElggEntity::setContainerGUID", 1.8);
        $container_guid = (int)$container_guid;

        return $this->set('container_guid', $container_guid);
    }

    public function getContainerGUID() {
        return $this->get('container_guid');
    }

    public function getContainer() {
        elgg_deprecated_notice("ElggObject::getContainer deprecated for ElggEntity::getContainerGUID", 1.8);
        return $this->get('container_guid');
    }

    public function getContainerEntity() {
        return get_entity($this->getContainerGUID());
    }

    public function getTimeUpdated() {
        return $this->get('time_updated');
    }

    public function getURL() {
        if (!empty($this->url_override)) {
            return $this->url_override;
        }
        return get_entity_url($this->getGUID());
    }

    public function setURL($url) {
        $this->url_override = $url;
        return $url;
    }

    public function getIconURL($size = 'medium') {
        $size = elgg_strtolower($size);

        if (isset($this->icon_override[$size])) {
            elgg_deprecated_notice("icon_override on an individual entity is deprecated", 1.8);
            return $this->icon_override[$size];
        }

        $type = $this->getType();
        $params = array(
            'entity' => $this,
            'size' => $size,
        );

        $url = elgg_trigger_plugin_hook('entity:icon:url', $type, $params, null);
        if ($url == null) {
            $url = "_graphics/icons/default/$size.png";
        }

        return elgg_normalize_url($url);
    }

    public function getIcon($size = 'medium') {
        elgg_deprecated_notice("getIcon() deprecated by getIconURL()", 1.8);
        return $this->getIconURL($size);
    }

    public function setIcon($url, $size = 'medium') {
        elgg_deprecated_notice("icon_override on an individual entity is deprecated", 1.8);

        $url = sanitise_string($url);
        $size = sanitise_string($size);

        if (!$this->icon_override) {
            $this->icon_override = array();
        }
        $this->icon_override[$size] = $url;

        return true;
    }

    public function isFullyLoaded() {
        return ! ($this->attributes['tables_loaded'] < $this->attributes['tables_split']);
    }

    public function save() {
        $guid = $this->getGUID();
        if ($guid > 0) {
            _elgg_cache_entity($this);

            return update_entity(
                $guid,
                $this->get('owner_guid'),
                $this->get('access_id'),
                $this->get('container_guid'),
                $this->get('time_created')
            );
        } else {
            // Create a new entity (nb: using attribute array directly
            // 'cos set function does something special!)
            $this->attributes['guid'] = create_entity($this->attributes['type'],
                $this->attributes['subtype'], $this->attributes['owner_guid'],
                $this->attributes['access_id'], $this->attributes['site_guid'],
                $this->attributes['container_guid']);

            if (!$this->attributes['guid']) {
                throw new IOException(elgg_echo('IOException:BaseEntitySaveFailed'));
            }

            // Save any unsaved metadata
            // @todo How to capture extra information (access id etc)
            if (sizeof($this->temp_metadata) > 0) {
                foreach ($this->temp_metadata as $name => $value) {
                    $this->$name = $value;
                    unset($this->temp_metadata[$name]);
                }
            }

            // Save any unsaved annotations.
            if (sizeof($this->temp_annotations) > 0) {
                foreach ($this->temp_annotations as $name => $value) {
                    $this->annotate($name, $value);
                    unset($this->temp_annotations[$name]);
                }
            }

            // Save any unsaved private settings.
            if (sizeof($this->temp_private_settings) > 0) {
                foreach ($this->temp_private_settings as $name => $value) {
                    $this->setPrivateSetting($name, $value);
                    unset($this->temp_private_settings[$name]);
                }
            }

            // set the subtype to id now rather than a string
            $this->attributes['subtype'] = get_subtype_id($this->attributes['type'],
                $this->attributes['subtype']);

            _elgg_cache_entity($this);

            return $this->attributes['guid'];
        }
    }

    protected function load($guid) {
        if ($guid instanceof stdClass) {
            $row = $guid;
        } else {
            $row = get_entity_as_row($guid);
        }

        if ($row) {
            // Create the array if necessary - all subclasses should test before creating
            if (!is_array($this->attributes)) {
                $this->attributes = array();
            }

            // Now put these into the attributes array as core values
            $objarray = (array) $row;
            foreach ($objarray as $key => $value) {
                $this->attributes[$key] = $value;
            }

            // Increment the portion counter
            if (!$this->isFullyLoaded()) {
                $this->attributes['tables_loaded']++;
            }

            // guid needs to be an int  http://trac.elgg.org/ticket/4111
            $this->attributes['guid'] = (int)$this->attributes['guid'];

            // Cache object handle
            if ($this->attributes['guid']) {
                _elgg_cache_entity($this);
            }

            return true;
        }

        return false;
    }

    public function disable($reason = "", $recursive = true) {
        if ($r = disable_entity($this->get('guid'), $reason, $recursive)) {
            $this->attributes['enabled'] = 'no';
        }

        return $r;
    }

    public function enable() {
        if ($r = enable_entity($this->get('guid'))) {
            $this->attributes['enabled'] = 'yes';
        }

        return $r;
    }

    public function isEnabled() {
        if ($this->enabled == 'yes') {
            return true;
        }

        return false;
    }

    public function delete($recursive = true) {
        return delete_entity($this->get('guid'), $recursive);
    }

    /*
     * LOCATABLE INTERFACE
     */

    public function getLocation() {
        return $this->location;
    }

    public function setLocation($location) {
        $this->location = $location;
        return true;
    }

    public function setLatLong($lat, $long) {
        $this->set('geo:lat', $lat);
        $this->set('geo:long', $long);

        return true;
    }

    public function getLatitude() {
        return (float)$this->get('geo:lat');
    }

    public function getLongitude() {
        return (float)$this->get('geo:long');
    }

    /*
     * NOTABLE INTERFACE
     */

    public function setCalendarTimeAndDuration($hour = NULL, $minute = NULL, $second = NULL,
    $day = NULL, $month = NULL, $year = NULL, $duration = NULL) {

        $start = mktime($hour, $minute, $second, $month, $day, $year);
        $end = $start + abs($duration);
        if (!$duration) {
            $end = get_day_end($day, $month, $year);
        }

        $this->calendar_start = $start;
        $this->calendar_end = $end;

        return true;
    }

    public function getCalendarStartTime() {
        return (int)$this->calendar_start;
    }

    public function getCalendarEndTime() {
        return (int)$this->calendar_end;
    }

    /*
     * EXPORTABLE INTERFACE
     */

    public function getExportableValues() {
        return array(
            'guid',
            'type',
            'subtype',
            'time_created',
            'time_updated',
            'container_guid',
            'owner_guid',
            'site_guid'
        );
    }

    public function export() {
        $tmp = array();

        // Generate uuid
        $uuid = guid_to_uuid($this->getGUID());

        // Create entity
        $odd = new ODDEntity(
            $uuid,
            $this->attributes['type'],
            get_subtype_from_id($this->attributes['subtype'])
        );

        $tmp[] = $odd;

        $exportable_values = $this->getExportableValues();

        // Now add its attributes
        foreach ($this->attributes as $k => $v) {
            $meta = NULL;

            if (in_array($k, $exportable_values)) {
                switch ($k) {
                    case 'guid':            // Dont use guid in OpenDD
                    case 'type':            // Type and subtype already taken care of
                    case 'subtype':
                        break;

                    case 'time_created':    // Created = published
                        $odd->setAttribute('published', date("r", $v));
                        break;

                    case 'site_guid':   // Container
                        $k = 'site_uuid';
                        $v = guid_to_uuid($v);
                        $meta = new ODDMetaData($uuid . "attr/$k/", $uuid, $k, $v);
                        break;

                    case 'container_guid':  // Container
                        $k = 'container_uuid';
                        $v = guid_to_uuid($v);
                        $meta = new ODDMetaData($uuid . "attr/$k/", $uuid, $k, $v);
                        break;

                    case 'owner_guid':          // Convert owner guid to uuid, this will be stored in metadata
                        $k = 'owner_uuid';
                        $v = guid_to_uuid($v);
                        $meta = new ODDMetaData($uuid . "attr/$k/", $uuid, $k, $v);
                        break;

                    default:
                        $meta = new ODDMetaData($uuid . "attr/$k/", $uuid, $k, $v);
                }

                // set the time of any metadata created
                if ($meta) {
                    $meta->setAttribute('published', date("r", $this->time_created));
                    $tmp[] = $meta;
                }
            }
        }

        // Now we do something a bit special.
        /*
         * This provides a rendered view of the entity to foreign sites.
         */

        elgg_set_viewtype('default');
        $view = elgg_view_entity($this, array('full_view' => true));
        elgg_set_viewtype();

        $tmp[] = new ODDMetaData($uuid . "volatile/renderedentity/", $uuid,
            'renderedentity', $view, 'volatile');

        return $tmp;
    }

    /*
     * IMPORTABLE INTERFACE
     */

    public function import(ODD $data) {
        if (!($data instanceof ODDEntity)) {
            throw new InvalidParameterException(elgg_echo('InvalidParameterException:UnexpectedODDClass'));
        }

        // Set type and subtype
        $this->attributes['type'] = $data->getAttribute('class');
        $this->attributes['subtype'] = $data->getAttribute('subclass');

        // Set owner
        $this->attributes['owner_guid'] = elgg_get_logged_in_user_guid(); // Import as belonging to importer.

        // Set time
        $this->attributes['time_created'] = strtotime($data->getAttribute('published'));
        $this->attributes['time_updated'] = time();

        return true;
    }

    /*
     * SYSTEM LOG INTERFACE
     */

    public function getSystemLogID() {
        return $this->getGUID();
    }

    public function getObjectFromID($id) {
        return get_entity($id);
    }

    public function getTags($tag_names = NULL) {
        if ($tag_names && !is_array($tag_names)) {
            $tag_names = array($tag_names);
        }

        $valid_tags = elgg_get_registered_tag_metadata_names();
        $entity_tags = array();

        foreach ($valid_tags as $tag_name) {
            if (is_array($tag_names) && !in_array($tag_name, $tag_names)) {
                continue;
            }

            if ($tags = $this->$tag_name) {
                // if a single tag, metadata returns a string.
                // if multiple tags, metadata returns an array.
                if (is_array($tags)) {
                    $entity_tags = array_merge($entity_tags, $tags);
                } else {
                    $entity_tags[] = $tags;
                }
            }
        }

        return $entity_tags;
    }
}

---