/** * {@inheritdoc} */ public function put(ParameterBag $params) { $owner = get_entity($params->guid); if (!$owner->canEdit()) { throw new GraphException("You are not allowed to modify this user's profile", HttpResponse::HTTP_FORBIDDEN); } $profile_fields = (array) elgg_get_config('profile_fields'); $access_id = $params->access_id !== null ? $params->access_id : get_default_access($owner); $input = array(); foreach ($profile_fields as $field => $valuetype) { // Making sure the consumer has sent these fields with the request if (isset($params->{$field}) && $this->request->get($field) !== null) { $value = $params->{$field}; $value = _elgg_html_decode($value); if (!is_array($value) && $valuetype != 'longtext' && elgg_strlen($value) > 250) { throw new GraphException(elgg_echo('profile:field_too_long', array(elgg_echo("profile:{$field}")), HttpResponse::HTTP_BAD_REQUEST)); } if ($value && $valuetype == 'url' && !preg_match('~^https?\\://~i', $value)) { $value = "http://{$value}"; } if ($valuetype == 'tags') { $value = string_to_tag_array($value); } if ($valuetype == 'email' && !empty($value) && !is_email_address($value)) { throw new GraphException(elgg_echo('profile:invalid_email', array(elgg_echo("profile:{$field}"))), HttpResponse::HTTP_BAD_REQUEST); } $input[$field] = $value; } } // go through custom fields if (sizeof($input) > 0) { foreach ($input as $shortname => $value) { $options = array('guid' => $owner->guid, 'metadata_name' => $shortname, 'limit' => false); elgg_delete_metadata($options); if (!is_null($value) && $value !== '') { // only create metadata for non empty values (0 is allowed) to prevent metadata records // with empty string values #4858 if (is_array($value)) { $i = 0; foreach ($value as $interval) { $i++; $multiple = $i > 1 ? TRUE : FALSE; create_metadata($owner->guid, $shortname, $interval, 'text', $owner->guid, $access_id, $multiple); } } else { create_metadata($owner->getGUID(), $shortname, $value, 'text', $owner->getGUID(), $access_id); } } } $owner->save(); // Notify of profile update elgg_trigger_event('profileupdate', $owner->type, $owner); } return $this->get($params); }
public function testElggDeleteMetadata() { $e = new \ElggObject(); $e->save(); for ($i = 0; $i < 30; $i++) { $name = "test_metadata{$i}"; $e->{$name} = rand(0, 10000); } $options = array('guid' => $e->getGUID(), 'limit' => 0); $md = elgg_get_metadata($options); $this->assertIdentical(30, count($md)); $this->assertTrue(elgg_delete_metadata($options)); $md = elgg_get_metadata($options); $this->assertTrue(empty($md)); $e->delete(); }
/** * Migrate old tree structure to new structure * * @param string $event the name of the event * @param string $type the type of the event * @param mixed $entity supplied entity * * @return void */ public static function migrateTreeStructure($event, $type, $entity) { // this process could take a while set_time_limit(0); // set entity options $options = ['type' => 'object', 'subtype' => \StaticPage::SUBTYPE, 'metadata_name' => 'parent_guid', 'site_guids' => false, 'limit' => false]; // set default metadata options $metadata_options = ['metadata_name' => 'parent_guid', 'site_guids' => false, 'limit' => false]; // make sure we can get all entities $ia = elgg_set_ignore_access(true); // create a batch for processing $batch = new \ElggBatch('elgg_get_entities_from_metadata', $options); $batch->setIncrementOffset(false); foreach ($batch as $entity) { $metadata_options['guid'] = $entity->getGUID(); $parent_guid = (int) $entity->parent_guid; if (empty($parent_guid)) { // workaround for multi-site elgg_delete_metadata($metadata_options); continue; } $parent = get_entity($parent_guid); if (empty($parent)) { // workaround for multi-site elgg_delete_metadata($metadata_options); continue; } // set correct container $entity->container_guid = $parent->getGUID(); $entity->save(); // find the root page for the tree $root = self::findOldRootPage($entity); if (empty($root)) { // workaround for multi-site elgg_delete_metadata($metadata_options); continue; } // add relationship to the correct tree remove_entity_relationships($entity->getGUID(), 'subpage_of'); $entity->addRelationship($root->getGUID(), 'subpage_of'); // workaround for multi-site elgg_delete_metadata($metadata_options); } // restore access elgg_set_ignore_access($ia); }
/** * auto join group define in plugin settings * */ function autosubscribegroup_join($event, $object_type, $object) { if ($object instanceof ElggUser && $event == 'create' && $object_type == 'user') { //auto submit relationships between user & groups //retrieve groups ids from plugin $groups = elgg_get_plugin_setting('systemgroups', 'autosubscribegroup'); $groups = split(',', $groups); //for each group ids foreach ($groups as $groupId) { $ia = elgg_set_ignore_access(true); $groupEnt = get_entity($groupId); elgg_set_ignore_access($ia); //if group exist : submit to group if ($groupEnt) { //join group succeed? if ($groupEnt->join($object)) { // Remove any invite or join request flags elgg_delete_metadata(array('guid' => $object->guid, 'metadata_name' => 'group_invite', 'metadata_value' => $groupEnt->guid, 'limit' => false)); elgg_delete_metadata(array('guid' => $object->guid, 'metadata_name' => 'group_join_request', 'metadata_value' => $groupEnt->guid, 'limit' => false)); } } } } }
/** *function to update the metadata *same as the update_metadata, only made metadata editable */ function izap_update_metadata($id, $name, $value, $value_type, $owner_guid, $access_id) { $id = (int) $id; if (!($md = elgg_get_metadata_from_id($id))) { return false; } // If memcached then we invalidate the cache for this entry static $metabyname_memcache; if (!$metabyname_memcache && is_memcache_available()) { $metabyname_memcache = new ElggMemcache('metabyname_memcache'); } if ($metabyname_memcache) { $metabyname_memcache->delete("{$md->entity_guid}:{$md->name_id}"); } $value_type = detect_extender_valuetype($value, sanitise_string(trim($value_type))); $owner_guid = (int) $owner_guid; if ($owner_guid == 0) { $owner_guid = elgg_get_logged_in_user_guid(); } $access_id = (int) $access_id; // Support boolean types (as integers) if (is_bool($value)) { if ($value) { $value = 1; } else { $value = 0; } } // Add the metastring $value = elgg_get_metastring_id($value); if (!$value) { return false; } $name = elgg_get_metastring_id($name); if (!$name) { return false; } // If ok then add it $db_prefix = elgg_get_config('dbprefix'); $result = update_data("UPDATE {$db_prefix}metadata set value_id='{$value}', value_type='{$value_type}', access_id={$access_id}, owner_guid={$owner_guid} where id={$id} and name_id='{$name}'"); if ($result !== false) { $obj = elgg_get_metadata_from_id($id); if (elgg_trigger_event('update', 'metadata', $obj)) { return true; } else { elgg_delete_metadata(array('metadata_id' => $id)); } } return $result; }
continue; } if (empty($value)) { $label = $metadata_name; if (elgg_language_key_exists("profile:{$metadata_name}")) { $label = elgg_echo("profile:{$metadata_name}"); } register_error(elgg_echo('wizard:action:steps:error:profile_field', [$label])); forward(REFERER); } $type = elgg_extract($metadata_name, $profile_fields); if ($type === 'tags') { $value = string_to_tag_array($value); } // cleanup existing metadata elgg_delete_metadata(['guid' => $user->getGUID(), 'metadata_name' => $metadata_name, 'limit' => false]); // save profile field if (!is_array($value)) { create_metadata($user->getGUID(), $metadata_name, $value, '', $user->getGUID(), ACCESS_LOGGED_IN); } else { // correctly save tag/array values foreach ($value as $v) { create_metadata($user->getGUID(), $metadata_name, $v, '', $user->getGUID(), ACCESS_LOGGED_IN, true); } } } } elgg_clear_sticky_form('wizard'); // user did this wizard $entity->addRelationship($user->getGUID(), 'done'); // cleanup session
/** * Deletes all metadata owned by this object (metadata.owner_guid = $this->guid). * If you pass a name, only metadata matching that name will be deleted. * * @param null|string $name The name of metadata to delete. * @return bool * @since 1.8 */ 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; }
<?php $options = array('type' => 'user', 'limit' => false); $all_users = new ElggBatch('elgg_get_entities', $options); foreach ($all_users as $user) { $options = array('guid' => $user->guid, 'metadata_name' => 'userpoints_points'); elgg_delete_metadata($options); $users_points = userpoints_get($user->guid); $users_approved_points = $users_points['approved']; $user->userpoints_points = (int) $users_approved_points; } system_message(elgg_echo("elggx_userpoints:restore_all:success")); forward(REFERER);
/** * Update the Elgg profile with LinkedIn data * * @param int $user_guid the user_guid of the profile to update * * @return void */ function socialink_linkedin_sync_profile_metadata($user_guid = 0) { global $CONFIG; if (empty($user_guid)) { $user_guid = elgg_get_logged_in_user_guid(); } // can we get a user if (($user = get_user($user_guid)) && socialink_linkedin_is_connected($user_guid)) { // does the user allow sync if (elgg_get_plugin_user_setting("linkedin_sync_allow", $user->getGUID(), "socialink") != "no") { // get configured fields and network fields if (($configured_fields = socialink_get_configured_network_fields("linkedin")) && ($network_fields = socialink_get_network_fields("linkedin"))) { // ask the api for all fields if ($api_result = socialink_linkedin_get_profile_information($user->getGUID())) { $api_result = json_decode($api_result); // check settings for each field foreach ($configured_fields as $setting_name => $profile_field) { $setting = "linkedin_sync_" . $setting_name; if (elgg_get_plugin_user_setting($setting, $user->getGUID(), "socialink") != "no") { $api_setting = $network_fields[$setting_name]; // get the correct value from api result if (stristr($api_setting, "->")) { $temp_fields = explode("->", $api_setting); $temp_result = $api_result; for ($i = 0; $i < count($temp_fields); $i++) { $temp_result = $temp_result->{$temp_fields}[$i]; } } else { $temp_result = $api_result->{$api_setting}; } // are we dealing with a tags profile field type if (!empty($CONFIG->profile) && is_array($CONFIG->profile)) { if (array_key_exists($profile_field, $CONFIG->profile) && $CONFIG->profile[$profile_field] == "tags") { $temp_result = string_to_tag_array($temp_result); } } // check if the user has this metadata field, to get access id $params = array("guid" => $user->getGUID(), "metadata_name" => $profile_field, "limit" => false); if ($metadata = elgg_get_metadata($params)) { if (is_array($metadata)) { $access_id = $metadata[0]->access_id; } else { $access_id = $metadata->access_id; } } else { $access_id = get_default_access($user); } // remove metadata to set new values elgg_delete_metadata($params); // make new metadata field if (!empty($temp_result)) { if (is_array($temp_result)) { foreach ($temp_result as $index => $temp_value) { if ($index > 0) { $multiple = true; } else { $multiple = false; } create_metadata($user->getGUID(), $profile_field, $temp_value, 'text', $user->getGUID(), $access_id, $multiple); } } else { create_metadata($user->getGUID(), $profile_field, $temp_result, 'text', $user->getGUID(), $access_id); } } } } } } // sync profile icon, only if the user has no icon if (empty($user->icontime)) { socialink_linkedin_sync_profile_icon($user->getGUID()); } } } }
/** * Update the Elgg profile with Facebook data * * @param int $user_guid the user_guid of the profile to update * * @return void */ function socialink_facebook_sync_profile_metadata($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)) { return; } $user = get_user($user_guid); if (empty($user) || !socialink_facebook_is_connected($user_guid)) { return; } // does the user allow sync if (elgg_get_plugin_user_setting("facebook_sync_allow", $user->getGUID(), "socialink") === "no") { return; } // get configured fields and network fields $profile_fields = elgg_get_config("profile_fields"); $configured_fields = socialink_get_configured_network_fields("facebook"); $network_fields = socialink_get_network_fields("facebook"); if (empty($profile_fields) || empty($configured_fields) || empty($network_fields)) { return; } // ask the api for all fields $api_result = socialink_facebook_get_profile_information($user->getGUID()); if (!empty($api_result)) { // check settings for each field foreach ($configured_fields as $setting_name => $profile_field) { $setting = "facebook_sync_" . $setting_name; if (elgg_get_plugin_user_setting($setting, $user->getGUID(), "socialink") === "no") { continue; } $api_setting = $network_fields[$setting_name]; $temp_result = call_user_func(array($api_result, $api_setting)); // are we dealing with a tags profile field type $field_type = elgg_extract($profile_field, $profile_fields); if ($field_type === "tags") { $temp_result = string_to_tag_array($temp_result); } // check if the user has this metadata field, to get access id $params = array("guid" => $user->getGUID(), "metadata_name" => $profile_field, "limit" => false); if ($metadata = elgg_get_metadata($params)) { if (is_array($metadata)) { $access_id = $metadata[0]->access_id; } else { $access_id = $metadata->access_id; } } else { $access_id = get_default_access($user); } // remove metadata to set new values elgg_delete_metadata($params); // make new metadata field if (empty($temp_result)) { continue; } if (is_array($temp_result)) { foreach ($temp_result as $index => $temp_value) { if ($index > 0) { $multiple = true; } else { $multiple = false; } create_metadata($user->getGUID(), $profile_field, $temp_value, 'text', $user->getGUID(), $access_id, $multiple); } } else { create_metadata($user->getGUID(), $profile_field, $temp_result, 'text', $user->getGUID(), $access_id); } } } // sync profile icon, only if the user has no icon if (empty($user->icontime)) { socialink_facebook_sync_profile_icon($user->getGUID()); } }
function hj_framework_process_tags_input($hook, $type, $return, $params) { $entity = elgg_extract('entity', $params, false); if (!elgg_instanceof($entity)) { return false; } $name = elgg_extract('name', $params, 'tags'); $access_id = elgg_extract('access_id', $params); $value = get_input($name, ''); $value = string_to_tag_array($value); elgg_delete_metadata(array('guid' => $entity->guid, 'metadata_names' => $name)); if ($value) { foreach ($value as $val) { create_metadata($entity->guid, $name, $val, '', $entity->owner_guid, $access_id, true); } } return true; }
public function testWritesInvalidate() { // elgg_delete_metadata $this->cache->inject($this->guid1, ['foo' => 'bar']); $this->cache->inject($this->guid2, ['bing' => 'bar']); elgg_delete_metadata(array('guid' => $this->guid1)); $this->assertFalse($this->cache->isLoaded($this->guid1)); $this->assertTrue($this->cache->isLoaded($this->guid2)); $this->cache->inject($this->guid1, ['foo' => 'bar']); $this->cache->inject($this->guid2, ['bing' => 'bar']); elgg_delete_metadata(['guids' => [$this->guid1, $this->guid2]]); $this->assertFalse($this->cache->isLoaded($this->guid1)); $this->assertFalse($this->cache->isLoaded($this->guid2)); // setMetadata $this->cache->inject($this->guid1, ['foo' => 'bar']); $this->obj1->setMetadata($this->name, $this->value); $this->assertFalse($this->cache->isLoaded($this->obj1)); // deleteMetadata $this->cache->inject($this->guid1, ['foo' => 'bar']); $this->obj1->deleteMetadata($this->name); $this->assertFalse($this->cache->isLoaded($this->guid1)); // create_metadata $this->cache->inject($this->guid1, ['foo' => 'bar']); create_metadata($this->guid1, 'foo', 'bar', 'text'); $this->assertFalse($this->cache->isLoaded($this->guid1)); // disableMetadata $this->obj1->setMetadata($this->name, $this->value); $this->cache->inject($this->guid1, ['foo' => 'bar']); $this->obj1->disableMetadata($this->name); $this->assertFalse($this->cache->isLoaded($this->guid1)); // enableMetadata $this->cache->inject($this->guid1, ['foo' => 'bar']); $this->obj1->enableMetadata($this->name); $this->assertFalse($this->cache->isLoaded($this->guid1)); }
/** * Web service to update profile information * * @param string $username username to update profile information * * @param $profile * @return bool * @throws InvalidParameterException */ function user_save_profile($username, $profile) { if (!$username) { $user = elgg_get_logged_in_user_entity(); } else { $user = get_user_by_username($username); } if (!$user) { throw new InvalidParameterException('registration:usernamenotvalid'); } $owner = get_entity($user->guid); $profile_fields = elgg_get_config('profile_fields'); foreach ($profile_fields as $shortname => $valuetype) { $value = $profile[$shortname]; $value = html_entity_decode($value, ENT_COMPAT, 'UTF-8'); if ($valuetype != 'longtext' && elgg_strlen($value) > 250) { $error = elgg_echo('profile:field_too_long', array(elgg_echo("profile:{$shortname}"))); return $error; } if ($valuetype == 'tags') { $value = string_to_tag_array($value); } $input[$shortname] = $value; } $name = strip_tags($profile['name']); if ($name) { if (elgg_strlen($name) > 50) { return elgg_echo('user:name:fail'); } elseif ($owner->name != $name) { $owner->name = $name; return $owner->save(); } } if (sizeof($input) > 0) { foreach ($input as $shortname => $value) { $options = array('guid' => $owner->guid, 'metadata_name' => $shortname); elgg_delete_metadata($options); if (isset($accesslevel[$shortname])) { $access_id = (int) $accesslevel[$shortname]; } else { // this should never be executed since the access level should always be set $access_id = ACCESS_DEFAULT; } if (is_array($value)) { $i = 0; foreach ($value as $interval) { $i++; $multiple = $i > 1 ? TRUE : FALSE; create_metadata($owner->guid, $shortname, $interval, 'text', $owner->guid, $access_id, $multiple); } } else { create_metadata($owner->guid, $shortname, $value, 'text', $owner->guid, $access_id); } } } return "Success"; }
if ($file->releaseDate < date("Y-m-d")) { $releaseFlag = true; } if ($file->releaseDate == date("Y-m-d")) { if ($file->releaseTime <= date('H:i', time())) { $releaseFlag = true; } } if ($releaseFlag === true) { $fileObj = new ElggFile($file->guid); $fileObj->access_id = $fileObj->releasedAccessId; if ($fileObj->save()) { elgg_delete_metadata(array('guid' => $file->guid, 'metadata_name' => 'isTimeReleased')); elgg_delete_metadata(array('guid' => $file->guid, 'metadata_name' => 'releaseDate')); elgg_delete_metadata(array('guid' => $file->guid, 'metadata_name' => 'releaseTime')); elgg_delete_metadata(array('guid' => $file->guid, 'metadata_name' => 'releasedAccessId')); } else { } } } $wheres = array("msv.string = 'isClosable'"); //get all files ready to be closed / deleted $content = elgg_get_entities(array('type' => 'object', 'subtype' => 'file', 'limit' => 5000, 'joins' => $joins, 'wheres' => $wheres)); foreach ($content as $file) { $deleteFlag = false; if ($file->closeDate == date("Y-m-d")) { if ($file->closeTime <= date('H:i', time())) { $deleteFlag = true; } } if ($file->closeDate < date("Y-m-d")) {
$repeat_weekly_days = get_input('repeat_weekly_days'); $repeat_weekly_days = is_array($repeat_weekly_days) ? $repeat_weekly_days : date('D', $event->getStartTimestamp()); $event->repeat_weekly_days = $repeat_weekly_days; break; case Util::FREQUENCY_MONTHLY: $repeat_monthly_by = get_input('repeat_monthly_by', Util::REPEAT_MONTHLY_BY_DATE); $event->repeat_monthly_by = $repeat_monthly_by; break; } $event->repeat_end_timestamp = $event->calculateRepeatEndTimestamp(); if (!$event->save()) { register_error(elgg_echo('events:error:save')); forward(REFERER); } $event->setLocation($location); elgg_delete_metadata(array('guids' => $event->guid, 'metadata_names' => 'reminder', 'limit' => 0)); $has_reminders = get_input('has_reminders'); $reminders = get_input('reminders', array()); if ($has_reminders && !empty($reminders)) { $size = count($reminders['value']) - 1; // last one is the template for ($i = 0; $i < $size; $i++) { $reminder_value = round($reminders['value'][$i]); switch ($reminders['increment'][$i]) { default: case 'minute': $reminder_value *= Util::SECONDS_IN_A_MINUTE; break; case 'hour': $reminder_value *= Util::SECONDS_IN_AN_HOUR; break;
$container = get_entity($page->container_guid); // Bring all child elements forward $parent = $page->parent_guid; $children = elgg_get_entities_from_metadata(array('metadata_name' => 'parent_guid', 'metadata_value' => $page->getGUID())); if ($children) { $db_prefix = elgg_get_config('dbprefix'); $subtype_id = (int) get_subtype_id('object', 'page_top'); $newentity_cache = is_memcache_available() ? new ElggMemcache('new_entity_cache') : null; foreach ($children as $child) { if ($parent) { $child->parent_guid = $parent; } else { // If no parent, we need to transform $child to a page_top $child_guid = (int) $child->guid; update_data("UPDATE {$db_prefix}entities\n\t\t\t\t\t\tSET subtype = {$subtype_id} WHERE guid = {$child_guid}"); elgg_delete_metadata(array('guid' => $child_guid, 'metadata_name' => 'parent_guid')); _elgg_invalidate_cache_for_entity($child_guid); if ($newentity_cache) { $newentity_cache->delete($child_guid); } } } } if ($page->delete()) { system_message(elgg_echo('pages:delete:success')); if ($parent) { if ($parent = get_entity($parent)) { forward($parent->getURL()); } } if (elgg_instanceof($container, 'group')) {
/** * {@inheritdoc} */ public function handle(\ElggEntity $entity) { $shortname = $this->getShortname(); if ($entity->guid) { $current_metadata = elgg_get_metadata(array('guids' => (int) $entity->guid, 'metadata_names' => $shortname, 'limit' => 0)); if (!empty($current_metadata)) { foreach ($current_metadata as $md) { $current_metadata_ids[] = $md->id; } } } if (empty($current_metadata_ids)) { $current_metadata_ids = array(); } $future_metadata = get_input($this->getShortname(), array()); $params = array('field' => $this, 'entity' => $entity, 'metadata_name' => $shortname, 'value' => $current_metadata, 'future_value' => $future_metadata); // Allow plugins to prevent metadata from being changed if (!elgg_trigger_plugin_hook('handle:metadata:before', 'prototyper', $params, true)) { return $entity; } $future_metadata_ids = elgg_extract('id', $future_metadata, array()); $to_delete = array_diff($current_metadata_ids, $future_metadata_ids); if (!empty($to_delete)) { elgg_delete_metadata(array('guids' => (int) $entity->guid, 'metadata_ids' => $to_delete, 'limit' => 0)); } $keys = array_keys(elgg_extract('name', $future_metadata, array())); $ids = array(); foreach ($keys as $i) { $id = $future_metadata['id'][$i]; $name = $future_metadata['name'][$i]; $value = $future_metadata['value'][$i]; $value_type = $this->getValueType(); $input_type = $this->getType(); if ($value_type == 'tags' || !$value_type && $input_type == 'tags') { $value = string_to_tag_array($value); } $access_id = $future_metadata['access_id'][$i]; $owner_guid = $future_metadata['owner_guid'][$i]; if (!is_array($value)) { if ($id) { update_metadata($id, $name, $value, '', $owner_guid, $access_id); } else { $id = create_metadata($entity->guid, $name, $value, '', $owner_guid, $access_id, true); } $ids[] = $id; } else { if ($id) { elgg_delete_metadata_by_id($id); } foreach ($value as $val) { $ids[] = create_metadata($entity->guid, $name, $val, '', $owner_guid, $access_id, true); } } } $params = array('field' => $this, 'entity' => $entity, 'metadata_name' => $shortname, 'value' => count($ids) ? elgg_get_metadata(array('metadata_ids' => $ids)) : array(), 'previous_value' => $current_metadata); elgg_trigger_plugin_hook('handle:metadata:after', 'prototyper', $params, true); return $entity; }
/** * Unsets entity coordinates * * @param integer $entity_guid * @return boolean */ function unset_entity_coordinates($entity_guid = 0, $lat = 0, $long = 0) { $entity = get_entity($entity_guid); if (!elgg_instanceof($entity)) { return false; } elgg_delete_metadata(array('guids' => $entity->guid, 'metadata_names' => array('geo:lat', 'geo:long'), 'limit' => 0)); $dbprefix = elgg_get_config('dbprefix'); $query = "DELETE LOW_PRIORITY FROM {$dbprefix}entity_geometry WHERE entity_guid = {$entity->guid}"; return delete_data($query); }
public function testWritesAreCached() { // delete should mark cache as known to be empty $this->obj1->deleteMetadata($this->name); $this->assertTrue($this->cache->isKnown($this->guid1, $this->name)); $this->assertNull($this->cache->load($this->guid1, $this->name)); // without name, delete should invalidate the entire entity $this->cache->save($this->guid1, $this->name, $this->value); elgg_delete_metadata(array('guid' => $this->guid1)); $this->assertFalse($this->cache->isKnown($this->guid1, $this->name)); // test set $this->obj1->setMetadata($this->name, $this->value); $this->assertIdentical($this->cache->load($this->guid1, $this->name), $this->value); // test set multiple $this->obj1->setMetadata($this->name, 1, 'integer', true); $this->assertIdentical($this->cache->load($this->guid1, $this->name), array($this->value, 1)); // writes when access is ignore should invalidate $tmp_ignore = elgg_set_ignore_access(true); $this->obj1->setMetadata($this->name, $this->value); $this->assertFalse($this->cache->isKnown($this->guid1, $this->name)); elgg_set_ignore_access($tmp_ignore); }
/** * Check for an existing pending invite for the given email address. * * @param string $email The amail address of the invited user * @return Bool Return true/false on pending record found or not */ function elggx_userpoints_registration_award($email) { $access = elgg_set_ignore_access(true); $guids = elggx_userpoints_invite_status(null, $email); if (!empty($guids)) { foreach ($guids as $guid) { $entity = get_entity($guid); $entity->meta_moderate = 'approved'; $user = get_user($entity->owner_guid); if (is_int($user->userpoints_points)) { $user->userpoints_points = (int) $user->userpoints_points + (int) $entity->meta_points; } else { $options = array('guid' => $user->guid, 'metadata_name' => 'userpoints_points'); elgg_delete_metadata($options); $users_points = userpoints_get($user->guid); $users_approved_points = $users_points['approved']; $user->userpoints_points = (int) $users_approved_points; } if (!elgg_trigger_plugin_hook('userpoints:update', 'object', array('entity' => $user), true)) { $user->userpoints_points = (int) $user->userpoints_points - (int) $entity->meta_points; } } } elgg_set_ignore_access($access); return; }
function hj_forum_1360948621() { $dbprefix = elgg_get_config('dbprefix'); /** * Upgrade : * 1. Former hjAnnotation's description is stored in annotation_value metadata. Needs updating */ $subtypeIdForumPost = get_subtype_id('object', 'hjforumpost'); $query = "\tUPDATE {$dbprefix}objects_entity oe\n\t\t\t\tJOIN {$dbprefix}metadata md ON md.entity_guid = oe.guid\n\t\t\t\tJOIN {$dbprefix}metastrings msn ON msn.id = md.name_id\n\t\t\t\tJOIN {$dbprefix}metastrings msv ON msv.id = md.value_id\n\t\t\t\tJOIN {$dbprefix}entities e on oe.guid = e.guid\n\t\t\t\tSET oe.description = msv.string\n\t\t\t\tWHERE e.subtype = {$subtypeIdForumPost} AND msn.string = 'annotation_value'"; update_data($query); elgg_delete_metadata(array('types' => 'object', 'subtypes' => 'hjforumpost', 'metadata_names' => array('annotation_name', 'annotation_value'))); }
$user = get_user($faq->owner_guid); // Was the question adjusted? if ($question == $orgQuestion) { $same = true; } else { $same = false; } if (!$same) { $faq->question = $question; } $faq->answer = $answer; $faq->category = $cat; $faq->access_id = $access; $faq->container_guid = elgg_get_config('site_guid'); $faq->owner_guid = elgg_get_config('site_guid'); if (elgg_delete_metadata(array('guid' => $faq->guid, 'metadata_name' => "userQuestion", 'metadata_value' => true, 'limit' => 0))) { if ($faq->save()) { $url = elgg_get_site_url() . "faq/list?categoryId=" . elgg_get_metastring_id($faq->category) . "#qID" . $faq->guid; $user_language = $user->language ? $user->language : (($site_language = elgg_get_config('language')) ? $site_language : 'en'); if ($same) { // notify user, question added and not adjusted $subject = elgg_echo("faq:answer:notify:subject", array(), $user_language); $body = elgg_echo("faq:answer:notify:message:added:same", array($question, $url), $user_language); } else { // notify user, question added and adjusted $subject = elgg_echo("faq:answer:notify:subject", array(), $user_language); $body = elgg_echo("faq:answer:notify:message:added:adjusted", array($orgQuestion, $question, $url), $user_language); } $result = array(); $result[$user->guid]['message'] = messages_send($subject, $body, $user->guid, elgg_get_logged_in_user_guid(), 0, false, false); $result[] = notify_user($user->guid, elgg_get_logged_in_user_guid(), $subject, $body, array(), 'email');
/** * Removes metadata on an entity with a particular name, optionally with a given value. * * @param int $guid The entity GUID * @param string $name The name of the metadata * @param string $value The value of the metadata (useful to remove a single item of a set) * * @return bool Depending on success * @deprecated 1.8 Use elgg_delete_metadata() */ function remove_metadata($guid, $name, $value = "") { elgg_deprecated_notice('delete_metadata() is deprecated by elgg_delete_metadata()', 1.8); // prevent them from deleting everything if (!$guid) { return false; } $options = array('guid' => $guid, 'metadata_name' => $name, 'limit' => 0); if ($value) { $options['metadata_value'] = $value; } return elgg_delete_metadata($options); }
/** * Removes an expiration date for an entry. * * @param $guid * @param $type * @return unknown_type */ function expirationdate_unset($id, $type = 'entities') { $access = elgg_set_ignore_access(true); if ($type == 'entities') { elgg_delete_metadata(array('guid' => $id, 'metadata_name' => 'expirationdate')); elgg_delete_metadata(array('guid' => $id, 'metadata_name' => 'expirationdate_disable_only')); } elgg_set_ignore_access($access); return true; }