public function testCanGetEntitiesByAnnotationCreationTime()
{
$prefix = elgg_get_config('dbprefix');
$users = elgg_get_entities(array('type' => 'user', 'limit' => 1));
// create some test annotations
$subtypes = $this->getRandomValidSubtypes(array('object'), 1);
$subtype = $subtypes[0];
$annotation_name = 'test_annotation_name_' . rand();
// our targets
$valid1 = new \ElggObject();
$valid1->subtype = $subtype;
$valid1->save();
$id1 = $valid1->annotate($annotation_name, 1, ACCESS_PUBLIC, $users[0]->guid);
// this one earlier
$yesterday = time() - 86400;
update_data("\n\t\t\tUPDATE {$prefix}annotations\n\t\t\tSET time_created = {$yesterday}\n\t\t\tWHERE id = {$id1}\n\t\t");
$valid2 = new \ElggObject();
$valid2->subtype = $subtype;
$valid2->save();
$valid2->annotate($annotation_name, 1, ACCESS_PUBLIC, $users[0]->guid);
$options = array('annotation_owner_guid' => $users[0]->guid, 'annotation_created_time_lower' => time() - 3600, 'annotation_name' => $annotation_name);
$entities = elgg_get_entities_from_annotations($options);
$this->assertEqual(1, count($entities));
$this->assertEqual($valid2->guid, $entities[0]->guid);
$options = array('annotation_owner_guid' => $users[0]->guid, 'annotation_created_time_upper' => time() - 3600, 'annotation_name' => $annotation_name);
$entities = elgg_get_entities_from_annotations($options);
$this->assertEqual(1, count($entities));
$this->assertEqual($valid1->guid, $entities[0]->guid);
$valid1->delete();
$valid2->delete();
}
function delete()
{
try {
$this->startSession();
$this->get_pad_client()->deletePad($this->getMetaData('pname'));
} catch (Exception $e) {
return false;
}
return parent::delete();
}
/**
* Condense annotation into object
*
* @param ElggObject $topic
*/
function groups_2011030101($topic)
{
$annotation = $topic->getAnnotations('group_topic_post', 1);
if (!$annotation) {
// no text for this forum post so we delete (probably caused by #2624)
return $topic->delete();
}
$topic->description = $annotation[0]->value;
$topic->save();
return $annotation[0]->delete();
}
public function testElggUserLoad()
{
// new object
$object = new ElggObject();
$this->AssertEqual($object->getGUID(), 0);
$guid = $object->save();
$this->AssertNotEqual($guid, 0);
// fail on wrong type
$this->assertFalse(get_user($guid));
// clean up
$object->delete();
}
public function delete()
{
$result = false;
$event = get_entity($this->event_guid);
$result = remove_entity_relationship($this->event_guid, ZHAOHU_MANAGER_RELATION_ATTENDING, $this->user_guid);
if (!$result) {
elgg_log("ZHError ,coupon:delete, failed to remove_entity_relationship, coupon_id {$this->guid}", "ERROR");
return false;
}
parent::delete();
return true;
}
function delete($recursive = true)
{
if ($widgets = $this->getWidgets(false)) {
foreach ($widgets as $col => $col_widgets) {
if (!empty($col_widgets)) {
foreach ($col_widgets as $widget) {
$widget->delete();
}
}
}
}
return parent::delete($recursive);
}
public function testElggDeleteAnnotations()
{
$e = new ElggObject();
$e->save();
for ($i = 0; $i < 30; $i++) {
$e->annotate('test_annotation', rand(0, 10000));
}
$options = array('guid' => $e->getGUID(), 'limit' => 0);
$annotations = elgg_get_annotations($options);
$this->assertIdentical(30, count($annotations));
$this->assertTrue(elgg_delete_annotations($options));
$annotations = elgg_get_annotations($options);
$this->assertTrue(empty($annotations));
$this->assertTrue($e->delete());
}
/**
* Condense first annotation into object
*
* @param ElggObject $topic
*/
function groups_2011030101($topic)
{
// do not upgrade topics that have already been upgraded
if ($topic->description) {
return true;
}
$annotation = $topic->getAnnotations(array('annotation_name' => 'group_topic_post', 'limit' => 1));
if (!$annotation) {
// no text for this forum post so we delete (probably caused by #2624)
return $topic->delete();
}
$topic->description = $annotation[0]->value;
$topic->save();
return $annotation[0]->delete();
}
public function testDefaultOrderedById()
{
$ia = elgg_set_ignore_access(true);
$obj = new ElggObject();
$obj->owner_guid = elgg_get_site_entity()->guid;
$obj->container_guid = elgg_get_site_entity()->guid;
$obj->access_id = ACCESS_PUBLIC;
$obj->save();
$obj->test_md = [1, 2, 3];
$time = time();
$prefix = _elgg_services()->db->getTablePrefix();
// reverse the times
$mds = elgg_get_metadata(['metadata_owner_guids' => $obj->guid, 'metadata_names' => 'test_md', 'order_by' => 'n_table.id ASC']);
foreach ($mds as $i => $md) {
update_data("\n\t\t\t\tUPDATE {$prefix}metadata\n\t\t\t\tSET time_created = " . ($time - $i) . "\n\t\t\t\tWHERE id = {$md->id}\n\t\t\t");
}
// verify ID order
$mds = elgg_get_metadata(['guid' => $obj->guid, 'metadata_names' => 'test_md']);
$md_values = array_map(function (ElggMetadata $md) {
return (int) $md->value;
}, $mds);
$this->assertEqual($md_values, [1, 2, 3]);
// ignore access bypasses the MD cache, so we try it both ways
elgg_set_ignore_access(false);
_elgg_services()->metadataCache->clear($obj->guid);
$md_values = $obj->test_md;
$this->assertEqual($md_values, [1, 2, 3]);
elgg_set_ignore_access(true);
_elgg_services()->metadataCache->clear($obj->guid);
$md_values = $obj->test_md;
$this->assertEqual($md_values, [1, 2, 3]);
$obj->delete();
elgg_set_ignore_access($ia);
}
/**
* Delete this file.
*
* @return bool
*/
public function delete()
{
$fs = $this->getFilestore();
$result = $fs->delete($this);
if ($this->getGUID() && $result) {
$result = parent::delete();
}
return $result;
}
/**
* Also remove API user when deleting the object
*
* @param boolean $recursive if the delete should be recursive
*
* @return boolean
*
* @see ElggEntity::delete()
*/
function delete($recursive = true)
{
if ($keys = $this->getApiKeys()) {
remove_api_user($this->site_guid, $keys["api_key"]);
}
return parent::delete($recursive);
}
/**
* Called after each test method.
*/
public function tearDown()
{
$this->obj1->delete();
$this->obj2->delete();
elgg_set_ignore_access($this->ignoreAccess);
}
public function testElggApiGettersEntityNoValueSubtypeSet()
{
global $CONFIG;
// create an entity we can later delete.
// order by time created and limit by 1 should == this entity.
$subtype = 'subtype_' . rand();
$e_subtype = new \ElggObject();
$e_subtype->subtype = $subtype;
$e_subtype->save();
$e = new \ElggObject();
$e->save();
$options = array('type' => 'object', 'subtype' => ELGG_ENTITIES_NO_VALUE, 'limit' => 1, 'order_by' => 'guid desc');
// grab ourself again to fill out attributes.
$e = get_entity($e->getGUID());
$entities = elgg_get_entities($options);
$this->assertEqual(count($entities), 1);
// this entity should NOT be the entity we just created
// and should have no subtype
foreach ($entities as $entity) {
$this->assertEqual($entity->subtype_id, 0);
}
$e_subtype->delete();
$e->delete();
$q = "DELETE FROM {$CONFIG->dbprefix}entity_subtypes WHERE subtype = '{$subtype}'";
delete_data($q);
}
*/
$title = get_input('title');
$description = get_input('description');
$address = get_input('address');
$access = ACCESS_PRIVATE;
//this is private and only admins can see it
if ($title && $address) {
$entity = new ElggObject();
$entity->subtype = "reported_content";
$entity->owner_guid = $_SESSION['user']->getGUID();
$entity->title = $title;
$entity->address = $address;
$entity->description = $description;
$entity->access_id = $access;
if ($entity->save()) {
if (!trigger_plugin_hook('reportedcontent:add', $reported->type, array('entity' => $reported), true)) {
$entity->delete();
register_error(elgg_echo('reportedcontent:failed'));
} else {
system_message(elgg_echo('reportedcontent:success'));
$entity->state = "active";
}
forward($address);
} else {
register_error(elgg_echo('reportedcontent:failed'));
forward($address);
}
} else {
register_error(elgg_echo('reportedcontent:failed'));
forward($address);
}
public function testElggAnnotationExists()
{
$e = new ElggObject();
$e->save();
$guid = $e->getGUID();
$this->assertFalse(elgg_annotation_exists($guid, 'test_annotation'));
$e->annotate('test_annotation', rand(0, 10000));
$this->assertTrue(elgg_annotation_exists($guid, 'test_annotation'));
// this metastring should always exist but an annotation of this name should not
$this->assertFalse(elgg_annotation_exists($guid, 'email'));
$options = array('guid' => $guid, 'limit' => 0);
$this->assertTrue(elgg_disable_annotations($options));
$this->assertTrue(elgg_annotation_exists($guid, 'test_annotation'));
$this->assertTrue($e->delete());
$this->assertFalse(elgg_annotation_exists($guid, 'test_annotation'));
}
/**
* Removes the thumbnail of the object prior to the deletion of the object
*
* @see ElggEntity::delete()
*/
public function delete($recursive = true)
{
$this->removeThumbnail();
return parent::delete($recursive);
}
public function testElggRiverDisableEnable()
{
$user = new \ElggUser();
$user->save();
$entity = new \ElggObject();
$entity->save();
$params = array('view' => 'river/relationship/friend/create', 'action_type' => 'create', 'subject_guid' => $user->guid, 'object_guid' => $entity->guid);
$id = elgg_create_river_item($params);
$river = elgg_get_river(array('ids' => array($id)));
$this->assertIdentical($river[0]->enabled, 'yes');
$user->disable();
// should no longer be able to get the river
$river = elgg_get_river(array('ids' => array($id)));
$this->assertIdentical($river, array());
// renabling the user should re-enable the river
access_show_hidden_entities(true);
$user->enable();
access_show_hidden_entities(false);
$river = elgg_get_river(array('ids' => array($id)));
$this->assertIdentical($river[0]->enabled, 'yes');
$user->delete();
$entity->delete();
}
/**
* Called after each test method.
*/
public function tearDown()
{
$this->container->delete();
$this->comment->delete();
}
public function testElggRecursiveDelete()
{
$types = array('\\ElggGroup', '\\ElggObject', '\\ElggUser', '\\ElggSite');
$db_prefix = elgg_get_config('dbprefix');
foreach ($types as $type) {
$parent = new $type();
$this->assertTrue($parent->save());
$child = new \ElggObject();
$child->container_guid = $parent->guid;
$this->assertTrue($child->save());
$grandchild = new \ElggObject();
$grandchild->container_guid = $child->guid;
$this->assertTrue($grandchild->save());
$this->assertTrue($parent->delete(true));
$q = "SELECT * FROM {$db_prefix}entities WHERE guid = {$parent->guid}";
$r = get_data($q);
$this->assertFalse($r);
$q = "SELECT * FROM {$db_prefix}entities WHERE guid = {$child->guid}";
$r = get_data($q);
$this->assertFalse($r);
$q = "SELECT * FROM {$db_prefix}entities WHERE guid = {$grandchild->guid}";
$r = get_data($q);
$this->assertFalse($r);
}
// object that owns itself
// can't check container_guid because of infinite loops in can_edit_entity()
$obj = new \ElggObject();
$obj->save();
$obj->owner_guid = $obj->guid;
$obj->save();
$q = "SELECT * FROM {$db_prefix}entities WHERE guid = {$obj->guid}";
$r = get_data_row($q);
$this->assertEqual($obj->guid, $r->owner_guid);
$this->assertTrue($obj->delete(true));
$q = "SELECT * FROM {$db_prefix}entities WHERE guid = {$obj->guid}";
$r = get_data_row($q);
$this->assertFalse($r);
}
/**
* Make sure changes related to #5775 do not affect inverse relationship queries
* @covers elgg_get_entities_from_relationship()
*/
public function testElggApiGettersEntityRelationshipDistinctResultInverse()
{
$obj1 = new ElggObject();
$obj1->save();
$obj2 = new ElggObject();
$obj2->save();
$obj3 = new ElggObject();
$obj3->save();
add_entity_relationship($obj2->guid, 'test_5775_inverse', $obj1->guid);
add_entity_relationship($obj3->guid, 'test_5775_inverse', $obj1->guid);
$options = array('relationship' => 'test_5775_inverse', 'inverse_relationship' => true, 'count' => true);
$count = elgg_get_entities_from_relationship($options);
$this->assertIdentical($count, 2);
unset($options['count']);
$objects = elgg_get_entities_from_relationship($options);
$this->assertTrue(is_array($objects));
$this->assertIdentical(count($objects), 2);
$obj1->delete();
$obj2->delete();
$obj3->delete();
}
/**
* Delete album
*
* @return bool
*/
public function delete()
{
$this->deleteImages();
$this->deleteAlbumDir();
return parent::delete();
}
public function testElggEntityRecursiveDisableAndEnable()
{
global $CONFIG;
$obj1 = new \ElggObject();
$obj1->container_guid = $this->entity->getGUID();
$obj1->save();
$obj2 = new \ElggObject();
$obj2->container_guid = $this->entity->getGUID();
$obj2->save();
// disable $obj2 before disabling the container
$this->assertTrue($obj2->disable());
// disable entities container by $this->entity
$this->assertTrue($this->entity->disable());
$entity = get_data_row("SELECT * FROM {$CONFIG->dbprefix}entities WHERE guid = '{$obj1->guid}'");
$this->assertIdentical($entity->enabled, 'no');
// enable entities that were disabled with the container (but not $obj2)
$this->assertTrue($this->entity->enable());
$entity = get_data_row("SELECT * FROM {$CONFIG->dbprefix}entities WHERE guid = '{$obj1->guid}'");
$this->assertIdentical($entity->enabled, 'yes');
$entity = get_data_row("SELECT * FROM {$CONFIG->dbprefix}entities WHERE guid = '{$obj2->guid}'");
$this->assertIdentical($entity->enabled, 'no');
// cleanup
$this->assertTrue($obj2->enable());
$this->assertTrue($obj2->delete());
$this->assertTrue($obj1->delete());
}
/**
* Delete this file.
*
* @return bool
*/
public function delete()
{
$fs = $this->getFilestore();
if ($fs->delete($this)) {
return parent::delete();
}
}
public function testElggBatchDeleteHandlesBrokenEntities()
{
$num_test_entities = 8;
$guids = array();
for ($i = $num_test_entities; $i > 0; $i--) {
$entity = new \ElggObject();
$entity->type = 'object';
$entity->subtype = 'test_5357_subtype';
$entity->access_id = ACCESS_PUBLIC;
$entity->save();
$guids[] = $entity->guid;
_elgg_invalidate_cache_for_entity($entity->guid);
}
// break entities such that the first fetch has one incomplete
// and the second and third fetches have only incompletes!
$db_prefix = elgg_get_config('dbprefix');
delete_data("\n\t\t\tDELETE FROM {$db_prefix}objects_entity\n\t\t\tWHERE guid IN ({$guids[1]}, {$guids[2]}, {$guids[3]}, {$guids[4]}, {$guids[5]})\n\t\t");
$options = array('type' => 'object', 'subtype' => 'test_5357_subtype', 'order_by' => 'e.guid');
$entities_visited = array();
$batch = new \ElggBatch('elgg_get_entities', $options, null, 2, false);
/* @var \ElggEntity[] $batch */
foreach ($batch as $entity) {
$entities_visited[] = $entity->guid;
$entity->delete();
}
// The broken entities should not have been visited
$this->assertEqual($entities_visited, array($guids[0], $guids[6], $guids[7]));
// cleanup (including leftovers from previous tests)
$entity_rows = elgg_get_entities(array_merge($options, array('callback' => '', 'limit' => false)));
$guids = array();
foreach ($entity_rows as $row) {
$guids[] = $row->guid;
}
delete_data("DELETE FROM {$db_prefix}entities WHERE guid IN (" . implode(',', $guids) . ")");
delete_data("DELETE FROM {$db_prefix}objects_entity WHERE guid IN (" . implode(',', $guids) . ")");
}
public function testElggUserLoad()
{
// new object
$object = new ElggObject();
$this->AssertEqual($object->getGUID(), 0);
$guid = $object->save();
$this->AssertNotEqual($guid, 0);
// fail on wrong type
try {
$error = new ElggUserTest($guid);
$this->assertTrue(FALSE);
} catch (Exception $e) {
$this->assertIsA($e, 'InvalidClassException');
$message = sprintf(elgg_echo('InvalidClassException:NotValidElggStar'), $guid, 'ElggUser');
$this->assertIdentical($e->getMessage(), $message);
}
// clean up
$object->delete();
}
/**
* Delete this file.
*
* @param bool $follow_symlinks If true, will also delete the target file if the current file is a symlink
* @return bool
*/
public function delete($follow_symlinks = true)
{
$result = $this->getFilestore()->delete($this, $follow_symlinks);
if ($this->getGUID() && $result) {
$result = parent::delete();
}
return $result;
}
public function test_elgg_metadata_multiple_values()
{
$u1 = new ElggUser();
$u1->username = rand();
$u1->save();
$u2 = new ElggUser();
$u2->username = rand();
$u2->save();
$obj = new ElggObject();
$obj->owner_guid = $u1->guid;
$obj->container_guid = $u1->guid;
$obj->access_id = ACCESS_PUBLIC;
$obj->save();
$md_values = array('one', 'two', 'three');
// need to fake different logins.
// good times without mocking.
$original_user = elgg_get_logged_in_user_entity();
$_SESSION['user'] = $u1;
elgg_set_ignore_access(false);
// add metadata as one user
$obj->test = $md_values;
// check only these md exists
$db_prefix = elgg_get_config('dbprefix');
$q = "SELECT * FROM {$db_prefix}metadata WHERE entity_guid = {$obj->guid}";
$data = get_data($q);
$this->assertEqual(count($md_values), count($data));
foreach ($data as $md_row) {
$md = elgg_get_metadata_from_id($md_row->id);
$this->assertTrue(in_array($md->value, $md_values));
$this->assertEqual('test', $md->name);
}
// add md w/ same name as a different user
$_SESSION['user'] = $u2;
$md_values2 = array('four', 'five', 'six', 'seven');
$obj->test = $md_values2;
$q = "SELECT * FROM {$db_prefix}metadata WHERE entity_guid = {$obj->guid}";
$data = get_data($q);
$this->assertEqual(count($md_values2), count($data));
foreach ($data as $md_row) {
$md = elgg_get_metadata_from_id($md_row->id);
$this->assertTrue(in_array($md->value, $md_values2));
$this->assertEqual('test', $md->name);
}
$_SESSION['user'] = $original_user;
$obj->delete();
$u1->delete();
$u2->delete();
}
function testElggApiGettersEntityMetadataValueInvalidMultiple()
{
$subtypes = $this->getRandomValidSubtypes(array('object'), 1);
$subtype = $subtypes[0];
$md_name = 'test_metadata_name_' . rand();
$md_value = 'test_metadata_value_' . rand();
$e = new \ElggObject();
$e->subtype = $subtype;
$e->{$md_name} = $md_value;
$e->save();
$md_invalid_values = array();
$md_invalid_values[] = 'test_metadata_value_' . rand();
$md_invalid_values[] = 'test_metadata_value_' . rand();
$options = array('type' => 'object', 'subtype' => $subtype, 'metadata_values' => $md_invalid_values);
$entities = elgg_get_entities_from_metadata($options);
$this->assertIdentical(array(), $entities);
$e->delete();
}
function test_can_write_to_container()
{
$user = new \ElggUser();
$user->username = '******' . rand();
$user->name = 'test_user_name_' . rand();
$user->email = '*****@*****.**';
$user->container_guid = 0;
$user->owner_guid = 0;
$user->save();
$object = new \ElggObject();
$object->save();
$group = new \ElggGroup();
$group->save();
// disable access overrides because we're admin.
$ia = elgg_set_ignore_access(false);
$this->assertFalse(can_write_to_container($user->guid, $object->guid));
global $elgg_test_user;
$elgg_test_user = $user;
// register hook to allow access
function can_write_to_container_test_hook($hook, $type, $value, $params)
{
global $elgg_test_user;
if ($params['user']->getGUID() == $elgg_test_user->getGUID()) {
return true;
}
}
elgg_register_plugin_hook_handler('container_permissions_check', 'all', 'can_write_to_container_test_hook');
$this->assertTrue(can_write_to_container($user->guid, $object->guid));
elgg_unregister_plugin_hook_handler('container_permissions_check', 'all', 'can_write_to_container_test_hook');
$this->assertFalse(can_write_to_container($user->guid, $group->guid));
$group->join($user);
$this->assertTrue(can_write_to_container($user->guid, $group->guid));
elgg_set_ignore_access($ia);
$user->delete();
$object->delete();
$group->delete();
}
/**
* Make sure entity is loaded from cache during save operations
* See #10612
*/
public function testNewObjectLoadedFromCacheDuringSaveOperations()
{
$object = new \ElggObject();
$object->subtype = 'elgg_entity_test_subtype';
// Add temporary metadata, annotation and private settings
// to extend the scope of tests and catch issues with save operations
$object->test_metadata = 'bar';
$object->annotate('test_annotation', 'baz');
$object->setPrivateSetting('test_setting', 'foo');
$metadata_called = false;
$metadata_event_handler = function ($event, $type, $metadata) use(&$metadata_called) {
/* @var $metadata \ElggMetadata */
$entity = get_entity($metadata->entity_guid);
$this->assertEqual($metadata->entity_guid, $entity->guid);
$metadata_called = true;
};
$annotation_called = false;
$annotation_event_handler = function ($event, $type, $annotation) use(&$annotation_called) {
/* @var $metadata \ElggAnnotation */
$entity = get_entity($annotation->entity_guid);
$this->assertEqual($annotation->entity_guid, $entity->guid);
$annotation_called = true;
};
elgg_register_event_handler('create', 'metadata', $metadata_event_handler);
elgg_register_event_handler('create', 'annotation', $annotation_event_handler);
$object->save();
elgg_unregister_event_handler('create', 'metadata', $metadata_event_handler);
elgg_unregister_event_handler('create', 'annotation', $annotation_event_handler);
$object->delete();
$this->assertTrue($metadata_called);
$this->assertTrue($annotation_called);
}
