/**
* Called before each test method.
*/
public function setUp()
{
$this->group = new ElggGroup();
$this->group->membership = ACCESS_PUBLIC;
$this->group->access_id = ACCESS_PUBLIC;
$this->group->save();
$this->user = new ElggUser();
$this->user->username = '******' . rand();
$this->user->save();
}
/**
* Checks if additional select columns are readable as volatile data even if we hit the cache while fetching entity.
*
* https://github.com/Elgg/Elgg/issues/5544
*/
public function testSqlAdditionalSelectsAsVolatileDataWithCache()
{
// remove ignore access as it disables entity cache
$access = elgg_set_ignore_access(false);
// may not have groups in DB - let's create one
$group = new ElggGroup();
$group->name = 'test_group';
$group->access_id = ACCESS_PUBLIC;
$this->assertTrue($group->save() !== false);
foreach (array('site', 'user', 'group', 'object') as $type) {
$entities = elgg_get_entities(array('type' => $type, 'selects' => array('42 as added_col3'), 'limit' => 1));
$entity = array_shift($entities);
$this->assertTrue($entity instanceof ElggEntity);
$this->assertEqual($entity->added_col3, null, "Additional select columns are leaking to attributes for " . get_class($entity));
$this->assertEqual($entity->getVolatileData('select:added_col3'), 42);
// make sure we have cached the entity
$this->assertNotEqual(false, _elgg_retrieve_cached_entity($entity->guid));
}
// run these again but with different value to make sure cache does not interfere
foreach (array('site', 'user', 'group', 'object') as $type) {
$entities = elgg_get_entities(array('type' => $type, 'selects' => array('64 as added_col3'), 'limit' => 1));
$entity = array_shift($entities);
$this->assertTrue($entity instanceof ElggEntity);
$this->assertEqual($entity->added_col3, null, "Additional select columns are leaking to attributes for " . get_class($entity));
$this->assertEqual($entity->getVolatileData('select:added_col3'), 64, "Failed to overwrite volatile data in cached entity");
}
elgg_set_ignore_access($access);
$group->delete();
}
function CreateLTIGroup($user, $name, $context_id, $consumer_key)
{
$group_guid = 0;
$group = new ElggGroup($group_guid);
// Set the group properties that we can!
$group->name = $name;
$group->context_id = $context_id;
// This is a unique identifier from the consumer for this context
$group->consumer_key = $consumer_key;
// Which consumer is creating this group
$group->membership = ACCESS_PRIVATE;
$group->access_id = ACCESS_PUBLIC;
$group->briefdescription = elgg_echo('LTI:provision:group');
$consumer_instance = new LTI_Tool_Consumer_Instance($group->consumer_key, elgg_get_config('dbprefix'));
$context = new LTI_Context($consumer_instance, $group->context_id);
$group->description = $context->title;
$group->save();
$group->join($user);
// Add images
$prefix = 'groups/' . $group->guid;
$filename = GetImage($consumer_key, '.jpg');
$thumbtiny = get_resized_image_from_existing_file($filename, 25, 25, true);
$thumbsmall = get_resized_image_from_existing_file($filename, 40, 40, true);
$thumbmedium = get_resized_image_from_existing_file($filename, 100, 100, true);
$thumblarge = get_resized_image_from_existing_file($filename, 200, 200, false);
if ($thumbtiny) {
$thumb = new ElggFile();
$thumb->owner_guid = $group->owner_guid;
$thumb->setMimeType('image/jpeg');
$thumb->setFilename($prefix . "tiny.jpg");
$thumb->open("write");
$thumb->write($thumbtiny);
$thumb->close();
$thumb->setFilename($prefix . "small.jpg");
$thumb->open("write");
$thumb->write($thumbsmall);
$thumb->close();
$thumb->setFilename($prefix . "medium.jpg");
$thumb->open("write");
$thumb->write($thumbmedium);
$thumb->close();
$thumb->setFilename($prefix . "large.jpg");
$thumb->open("write");
$thumb->write($thumblarge);
$thumb->close();
$group->icontime = time();
}
// return the URL
return $group;
}
/**
* Called before each test object.
*/
public function __construct()
{
elgg_set_ignore_access(true);
$this->entities = array();
$this->subtypes = array('object' => array(), 'user' => array(), 'group' => array());
// sites are a bit wonky. Don't use them just now.
$this->types = array('object', 'user', 'group');
// create some fun objects to play with.
// 5 with random subtypes
for ($i = 0; $i < 5; $i++) {
$subtype = 'test_object_subtype_' . rand();
$e = new ElggObject();
$e->subtype = $subtype;
$e->save();
$this->entities[] = $e;
$this->subtypes['object'][] = $subtype;
}
// and users
for ($i = 0; $i < 5; $i++) {
$subtype = "test_user_subtype_" . rand();
$e = new ElggUser();
$e->username = "******" . rand();
$e->subtype = $subtype;
$e->save();
$this->entities[] = $e;
$this->subtypes['user'][] = $subtype;
}
// and groups
for ($i = 0; $i < 5; $i++) {
$subtype = "test_group_subtype_" . rand();
$e = new ElggGroup();
$e->subtype = $subtype;
$e->save();
$this->entities[] = $e;
$this->subtypes['group'][] = $subtype;
}
parent::__construct();
}
//$dgroup->files_enable = get_input('files_enable', 'yes');
//$dgroup->pages_enable = get_input('pages_enable', 'yes');
//$dgroup->forum_enable = get_input('forum_enable', 'yes');
// Set dgroup tool options
if (isset($CONFIG->dgroup_tool_options)) {
foreach ($CONFIG->dgroup_tool_options as $dgroup_option) {
$dgroup_option_toggle_name = $dgroup_option->name . "_enable";
if ($dgroup_option->default_on) {
$dgroup_option_default_value = 'yes';
} else {
$dgroup_option_default_value = 'no';
}
$dgroup->{$dgroup_option_toggle_name} = get_input($dgroup_option_toggle_name, $dgroup_option_default_value);
}
}
$dgroup->save();
if (!$dgroup->isMember($user)) {
$dgroup->join($user);
}
// Creator always a member
// Now see if we have a file icon
if (isset($_FILES['icon']) && substr_count($_FILES['icon']['type'], 'image/')) {
$prefix = "dgroups/" . $dgroup->guid;
$filehandler = new ElggFile();
$filehandler->owner_guid = $dgroup->owner_guid;
$filehandler->setFilename($prefix . ".jpg");
$filehandler->open("write");
$filehandler->write(get_uploaded_file('icon'));
$filehandler->close();
$thumbtiny = get_resized_image_from_existing_file($filehandler->getFilenameOnFilestore(), 25, 25, true);
$thumbsmall = get_resized_image_from_existing_file($filehandler->getFilenameOnFilestore(), 40, 40, true);
public function testJoinLeaveGroupACL()
{
if (!elgg_is_active_plugin('groups')) {
return;
}
$group = new ElggGroup();
$group->name = 'Test group';
$group->save();
$result = $group->join($this->user);
$this->assertTrue($result);
// disable security since we run as admin
$ia = elgg_set_ignore_access(false);
// need to set the page owner to emulate being in a group context.
// this is kinda hacky.
elgg_set_page_owner_guid($group->getGUID());
if ($result) {
$can_edit = can_edit_access_collection($group->group_acl, $this->user->guid);
$this->assertTrue($can_edit);
}
$result = $group->leave($this->user);
$this->assertTrue($result);
if ($result) {
$can_edit = can_edit_access_collection($group->group_acl, $this->user->guid);
$this->assertFalse($can_edit);
}
elgg_set_ignore_access($ia);
$group->delete();
}
foreach (array(hypefaker_get_group_content_access_mode('members_only'), hypefaker_get_group_content_access_mode('unrestricted')) as $content_access_mode) {
foreach (array(ACCESS_PRIVATE, ACCESS_PUBLIC) as $membership) {
for ($i = 0; $i < $count; $i++) {
$users = elgg_get_entities_from_metadata(array('types' => 'user', 'limit' => 1, 'order_by' => 'RAND()', 'metadata_names' => '__faker'));
$owner = $users[0];
$group = new ElggGroup();
$group->name = $faker->sentence(5);
$group->owner_guid = $owner->guid;
$group->container_guid = $owner->guid;
$group->description = $faker->text(500);
$group->briefdescription = $faker->bs;
$group->interests = $faker->words(10);
$group->access_id = ACCESS_PUBLIC;
$group->membership = $membership;
$group->content_access_mode = $content_access_mode;
$guid = $group->save();
if (!$guid) {
$errors++;
continue;
}
if ($visibility != ACCESS_PUBLIC && $visibility != ACCESS_LOGGED_IN) {
$visibility = $group->group_acl;
}
if ($group->access_id != $visibility) {
$group->access_id = $visibility;
}
$group->__faker = true;
// store this flag so we can easily find fake entities
$group->join($owner);
$icon_sizes = elgg_get_config('icon_sizes');
$files = array();
public function testElggObjectContainer()
{
$this->assertEqual($this->entity->getContainerGUID(), elgg_get_logged_in_user_guid());
// create and save to group
$group = new \ElggGroup();
$guid = $group->save();
$this->assertTrue($this->entity->setContainerGUID($guid));
// check container
$this->assertEqual($this->entity->getContainerGUID(), $guid);
$this->assertIdenticalEntities($group, $this->entity->getContainerEntity());
// clean up
$group->delete();
}
public function testElggObjectContainer()
{
$this->assertEqual($this->entity->getContainer(), get_loggedin_userid());
// fals when container not a group
$this->assertFalse($this->entity->getContainerEntity());
// create and save to group
$group = new ElggGroup();
$guid = $group->save();
$this->assertTrue($this->entity->setContainer($guid));
// check container
$this->assertEqual($this->entity->getContainer(), $guid);
$this->assertIdentical($group, $this->entity->getContainerEntity());
// clean up
$group->delete();
}
/**
* createGroups Create the groups in Elgg
*
* @return boolean
*/
function createGroups($post_data)
{
global $CONFIG;
$final_report = array();
/// Final report of the creation process
$this->headers = explode(',', $post_data['header']);
/// Create the groups from the $groups array
for ($i = 0; $i < $post_data['num_of_groups']; $i++) {
/// Get the group details from POST data for all headers
foreach ($this->headers as $header) {
$group[$header] = $post_data[$header][$i];
}
/// Add the basic fields to the report
$report = array('name' => $group['name'], 'subtype' => $group['subtype'], 'description' => $group['description'], 'membership' => $group['membership'], 'visibility' => $group['visibility'], 'container_guid' => $group['container_guid']);
/// Try to create the group
try {
$user = elgg_get_logged_in_user_entity();
$new_group = new ElggGroup();
$new_group->name = $group['name'];
$new_group->subtype = $group['subtype'];
$new_group->membership = $group['membership'];
$new_group->container_guid = $group['container_guid'];
$new_group->owner_guid = $user->guid;
$new_group->access_id = $group['visibility'];
$guid = $new_group->save();
if ($guid) {
elgg_set_page_owner_guid($group->guid);
$new_group->join($user);
add_to_river('river/group/create', 'create', $user->guid, $new_group->guid);
if (elgg_get_plugin_setting('hidden_groups', 'groups') == 'yes') {
$visibility = $group['visibility'];
if ($visibility != ACCESS_PUBLIC && $visibility != ACCESS_LOGGED_IN) {
$visibility = $new_group->group_acl;
}
if ($new_group->access_id != $visibility) {
$new_group->access_id = $visibility;
$new_group->save();
}
}
/// Add all other fields as metadata
foreach ($this->headers as $header) {
if (in_array($header, array('name', 'subtype', 'membership', 'visibility', 'description', 'container_guid'))) {
continue;
}
/// Metadata could be a comma separated list if the delimiter is something else than a comma
if ($this->delimiter != ',' && strpos($group[$header], ',')) {
/// Multiple tags found
$tags = string_to_tag_array($group[$header]);
foreach ($tags as $tag) {
create_metadata($guid, $header, $tag, 'text', $guid, ACCESS_PRIVATE, true);
}
} else {
create_metadata($guid, $header, $group[$header], 'text', $guid);
}
/// Add this metadata field to the report
$report[$header] = $group[$header];
}
/// Add status message to the report
$report['status'] = elgg_echo('upload_groups:success');
}
} catch (RegistrationException $r) {
//register_error($r->getMessage());
$report['status'] = '<span class="error">' . $r->getMessage() . '</span>';
$report['password'] = '';
/// Reset password in failed cases
$this->number_of_failed_groups++;
}
$final_report[] = $report;
}
$this->creation_report = $final_report;
return true;
}
/**
* Make sure entity is loaded from cache during save operations
* See #10612
*/
public function testNewGroupLoadedFromCacheDuringSaveOperations()
{
$group = new \ElggGroup();
$group->subtype = 'test_group_subtype';
// Add temporary metadata, annotation and private settings
// to extend the scope of tests and catch issues with save operations
$group->test_metadata = 'bar';
$group->annotate('test_annotation', 'baz');
$group->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);
$group->save();
elgg_unregister_event_handler('create', 'metadata', $metadata_event_handler);
elgg_unregister_event_handler('create', 'annotation', $annotation_event_handler);
$group->delete();
$this->assertTrue($metadata_called);
$this->assertTrue($annotation_called);
}
/**
* Ensure additional select columns do not end up in entity attributes.
*
* https://github.com/Elgg/Elgg/issues/5538
*/
public function test_extra_columns_dont_appear_in_attributes()
{
global $ENTITY_CACHE;
// may not have groups in DB - let's create one
$group = new ElggGroup();
$group->name = 'test_group';
$group->access_id = ACCESS_PUBLIC;
$this->assertTrue($group->save() !== false);
// entity cache interferes with our test
$ENTITY_CACHE = array();
foreach (array('site', 'user', 'group', 'object') as $type) {
$entities = elgg_get_entities(array('type' => $type, 'selects' => array('1 as _nonexistent_test_column'), 'limit' => 1));
if (!$this->assertTrue($entities, "Query for '{$type}' did not return an entity.")) {
continue;
}
$entity = $entities[0];
$this->assertNull($entity->_nonexistent_test_column, "Additional select columns are leaking to attributes for '{$type}'");
}
$group->delete();
}
if (!$request instanceof \Groups\Requests\Request) {
register_error(elgg_echo('group_requests:not_found'));
forward(REFERER);
}
$user = $request->getOwnerEntity();
if ($action == 'deny') {
$subject = elgg_echo('group_requests:denied:title', array(), $user->language);
$body = elgg_echo('group_requests:denied:body', array($user->name, $request->title), $user->language);
notify_user($request->owner_guid, elgg_get_site_entity()->guid, $subject, $body);
$request->delete();
system_message(elgg_echo('group_requests:deny:success'));
forward(REFERER);
}
$group = new ElggGroup();
$group->owner_guid = $request->owner_guid;
$group->container_guid = $request->container_guid;
$group->name = $request->title;
$group->access_id = ACCESS_PUBLIC;
if ($group->save()) {
// Besides being owner, user also needs to be a member
$group->join($user);
$subject = elgg_echo('group_requests:approved:title', array(), $user->language);
$body = elgg_echo('group_requests:approved:body', array($user->name, $group->name, elgg_normalize_url("groups/edit/{$group->guid}")), $user->language);
$params = array('action' => 'create', 'object' => $group);
notify_user($user->guid, elgg_get_site_entity()->guid, $subject, $body, $params);
$request->delete();
system_message(elgg_echo('group_requests:approve:success'));
} else {
register_error(elgg_echo('group_requests:approve:error'));
}
forward(REFERER);
/**
* Helper function to transfer the ownership of a group to a new user
*
* @param ElggGroup $group the group to transfer
* @param ElggUser $new_owner the new owner
*
* @return bool
*/
function group_tools_transfer_group_ownership(ElggGroup $group, ElggUser $new_owner)
{
if (!$group instanceof ElggGroup || !$group->canEdit()) {
return false;
}
if (!$new_owner instanceof ElggUser) {
return false;
}
$loggedin_user = elgg_get_logged_in_user_entity();
// register plugin hook to make sure transfer can complete
elgg_register_plugin_hook_handler('permissions_check', 'group', '\\ColdTrick\\GroupTools\\Access::allowGroupOwnerTransfer');
$old_owner = $group->getOwnerEntity();
// transfer ownership
$group->owner_guid = $new_owner->getGUID();
$group->container_guid = $new_owner->getGUID();
if (!$group->save()) {
return false;
}
// make sure user is added to the group
$group->join($new_owner);
// remove existing group administrator role for new owner
remove_entity_relationship($new_owner->getGUID(), 'group_admin', $group->getGUID());
// check for group icon
if (!empty($group->icontime)) {
$prefix = "groups/{$group->getGUID()}";
$sizes = elgg_get_icon_sizes($group->getType());
$ofh = new ElggFile();
$ofh->owner_guid = $old_owner->getGUID();
$nfh = new ElggFile();
$nfh->owner_guid = $group->getOwnerGUID();
foreach ($sizes as $size => $info) {
// set correct file to handle
$ofh->setFilename("{$prefix}{$size}.jpg");
if (!$ofh->exists()) {
// file doesn't exist
continue;
}
$nfh->setFilename("{$prefix}{$size}.jpg");
// open files
$ofh->open('read');
$nfh->open('write');
// copy file
$nfh->write($ofh->grabFile());
// close file
$ofh->close();
$nfh->close();
// cleanup old file
$ofh->delete();
}
$group->icontime = time();
}
// move metadata of the group to the new owner
$options = ['guid' => $group->getGUID(), 'limit' => false];
$metadata = elgg_get_metadata($options);
if (!empty($metadata)) {
foreach ($metadata as $md) {
if ($md->owner_guid == $old_owner->getGUID()) {
$md->owner_guid = $new_owner->getGUID();
$md->save();
}
}
}
// notify new owner
if ($new_owner->getGUID() !== $loggedin_user->getGUID()) {
$subject = elgg_echo('group_tools:notify:transfer:subject', [$group->name]);
$message = elgg_echo('group_tools:notify:transfer:message', [$new_owner->name, $loggedin_user->name, $group->name, $group->getURL()]);
notify_user($new_owner->getGUID(), $group->getGUID(), $subject, $message);
}
// unregister plugin hook to make sure transfer can complete
elgg_unregister_plugin_hook_handler('permissions_check', 'group', '\\ColdTrick\\GroupTools\\Access::allowGroupOwnerTransfer');
return true;
}
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();
}
$metadata = elgg_get_metadata(array('guid' => $group_guid, 'limit' => false));
if ($metadata) {
foreach ($metadata as $md) {
if ($md->owner_guid == $old_owner_guid) {
$md->owner_guid = $new_owner_guid;
$md->save();
}
}
}
// @todo Remove this when #4683 fixed
$owner_has_changed = true;
$old_icontime = $group->icontime;
}
}
$must_move_icons = $owner_has_changed && $old_icontime;
$group->save();
// Invisible group support
// @todo this requires save to be called to create the acl for the group. This
// is an odd requirement and should be removed. Either the acl creation happens
// in the action or the visibility moves to a plugin hook
if (elgg_get_plugin_setting('hidden_groups', 'groups') == 'yes') {
$visibility = (int) get_input('vis', '', false);
if ($visibility != ACCESS_PUBLIC && $visibility != ACCESS_LOGGED_IN) {
$visibility = $group->group_acl;
}
if ($group->access_id != $visibility) {
$group->access_id = $visibility;
}
}
$group->save();
// group saved so clear sticky form
/**
* Create all local groups
*/
function create_local_groups()
{
// first, creates country groups
$countrygroup_guid = array();
$options["type"] = 'group';
$options["limit"] = NULL;
$options["metadata_name_value_pairs"][] = array("name" => 'grouptype', "value" => 'local');
$options["metadata_name_value_pairs"][] = array("name" => 'localtype', "value" => 'national');
$existing_countrygroups = elgg_get_entities_from_metadata($options);
$country_data = get_country_data();
foreach ($country_data as $country) {
if (!is_group_name_existing($country, $existing_countrygroups)) {
$group = new ElggGroup();
$group->name = $country;
$group->description = "";
$group->grouptype = 'local';
$group->localtype = 'national';
$group->membership = ACCESS_PUBLIC;
$group->access_id = ACCESS_LOGGED_IN;
$group->save();
$countrygroup_guid[$country] = $group->guid;
}
}
// then, creates departement groups
$depgroup_guids = array();
$options["type"] = 'group';
$options["limit"] = NULL;
$options["metadata_name_value_pairs"][] = array("name" => 'grouptype', "value" => 'local');
$options["metadata_name_value_pairs"][] = array("name" => 'localtype', "value" => 'departemental');
$existing_depgroups = elgg_get_entities_from_metadata($options);
$departements_data = get_departement_data();
foreach ($departements_data as $num => $name) {
$groupname = $num . " - " . $name;
if (!is_group_name_existing($groupname, $existing_depgroups)) {
$group = new ElggGroup();
$group->name = $groupname;
$group->description = "";
$group->grouptype = 'local';
$group->localtype = 'departemental';
$group->membership = ACCESS_PUBLIC;
$group->access_id = ACCESS_LOGGED_IN;
$group->save();
$depgroup_guids[$num] = $group->guid;
}
}
// finally, creates region groups
$options["metadata_name_value_pairs"] = array(array('name' => 'grouptype', 'value' => 'local', 'operand' => '=', 'case_sensitive' => TRUE), array('name' => 'localtype', 'value' => 'regional', 'operand' => '=', 'case_sensitive' => TRUE));
$existing_region_groups = elgg_get_entities_from_metadata($options);
$regions_data = get_region_data();
foreach ($regions_data as $name => $dep_nums) {
if (!is_group_name_existing($name, $existing_region_groups)) {
$group = new ElggGroup();
$group->name = $name;
$group->grouptype = 'local';
$group->localtype = 'regional';
$group->membership = ACCESS_PUBLIC;
$group->access_id = ACCESS_LOGGED_IN;
$group->save();
//add relationship with departement groups
foreach ($dep_nums as $num) {
$depgroup = get_entity($depgroup_guids[$num]);
if ($depgroup) {
$group->addRelationship($depgroup->guid, 'child');
$depgroup->addRelationship($group->guid, 'parent');
$depgroup->save();
}
}
// add relationship with country group
$countrygroup = get_entity($countrygroup_guid['France']);
if ($countrygroup) {
$countrygroup->addRelationship($group->guid, 'child');
$group->addRelationship($countrygroup->guid, 'parent');
$countrygroup->save();
}
$group->save();
}
}
}
/**
* Ensure that \ElggBatch doesn't go into infinite loop when disabling annotations recursively when show hidden is enabled.
*
* https://github.com/Elgg/Elgg/issues/5952
*/
public function test_disabling_annotations_infinite_loop()
{
//let's have some entity
$group = new \ElggGroup();
$group->name = 'test_group';
$group->access_id = ACCESS_PUBLIC;
$this->assertTrue($group->save() !== false);
$total = 51;
//add some annotations
for ($cnt = 0; $cnt < $total; $cnt++) {
$group->annotate('test_annotation', 'value_' . $total);
}
//disable them
$show_hidden = access_get_show_hidden_status();
access_show_hidden_entities(true);
$options = array('guid' => $group->guid, 'limit' => $total);
elgg_disable_annotations($options);
access_show_hidden_entities($show_hidden);
//confirm all being disabled
$annotations = $group->getAnnotations(array('limit' => $total));
foreach ($annotations as $annotation) {
$this->assertTrue($annotation->enabled == 'no');
}
//delete group and annotations
$group->delete();
}
function hj_framework_edit_object_action()
{
$form_name = get_input('form_name', false);
elgg_make_sticky_form($form_name);
if (!hj_framework_validate_form($form_name)) {
return false;
}
$guid = get_input('guid', ELGG_ENTITIES_ANY_VALUE);
$event = $guid ? 'edit' : 'create';
$type = get_input('type');
$subtype = get_input('subtype');
$class = get_subtype_class($type, $subtype);
//get the attachments
$attachments = $_FILES['attachments'];
if ($class) {
$entity = new $class($guid);
} else {
switch (get_input('type', 'object')) {
case 'object':
$entity = new ElggObject($guid);
break;
case 'user':
$entity = new ElggUser($guid);
break;
case 'group':
$entity = new ElggGroup($guid);
break;
default:
return false;
break;
}
}
if ($guid) {
// Entity already exists
if ((int) get_input('container_guid', 0) > 0) {
$entity->container_guid = get_input('container_guid', ELGG_ENTITIES_ANY_VALUE);
}
if ($title = get_input('title', '')) {
$entity->title = $title;
}
if ($description = get_input('description', '')) {
$entity->description = $description;
}
if ($access_id = get_input('access_id', ACCESS_DEFAULT)) {
$entity->access_id = $access_id;
}
} else {
// Creating new entity
$entity->subtype = get_input('subtype', 'hjformsubmission');
if ($owner_guid = get_input('owner_guid', ELGG_ENTITIES_ANY_VALUE)) {
$entity->owner_guid = $owner_guid;
}
if ($container_guid = get_input('container_guid', ELGG_ENTITIES_ANY_VALUE)) {
$entity->container_guid = $container_guid;
}
$entity->title = get_input('title', '');
$entity->description = get_input('description', '');
$entity->access_id = get_input('access_id', ACCESS_DEFAULT);
}
$guid = $entity->save();
if (!$guid) {
register_error(elgg_echo('hj:framework:error:cannotcreateentity'));
return false;
} else {
//check to see if existing attachments
$existingAttachments = elgg_get_entities_from_relationship(array("relationship" => "attachment", "relationship_guid" => $guid, "inverse_relationship" => true));
foreach ($existingAttachments as $attachment) {
$updatedAttachment = new ElggFile($attachment->guid);
$updatedAttachment->access_id = $access_id;
$updatedAttachment->save();
}
//$entity = get_entity($guid);
if ($attachments) {
$count = count($attachments['name']);
for ($i = 0; $i < $count; $i++) {
if ($attachments['error'][$i] || !$attachments['name'][$i]) {
continue;
}
$name = $attachments['name'][$i];
$file = new ElggFile();
$file->container_guid = $guid;
$file->title = $name;
$file->access_id = (int) $entity->access_id;
$prefix = "file/";
$filestorename = elgg_strtolower(time() . $name);
$file->setFilename($prefix . $filestorename);
$file->open("write");
$file->close();
move_uploaded_file($attachments['tmp_name'][$i], $file->getFilenameOnFilestore());
$saved = $file->save();
if ($saved) {
$mime_type = ElggFile::detectMimeType($attachments['tmp_name'][$i], $attachments['type'][$i]);
$info = pathinfo($name);
$office_formats = array('docx', 'xlsx', 'pptx');
if ($mime_type == "application/zip" && in_array($info['extension'], $office_formats)) {
switch ($info['extension']) {
case 'docx':
$mime_type = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
break;
case 'xlsx':
$mime_type = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
break;
case 'pptx':
$mime_type = "application/vnd.openxmlformats-officedocument.presentationml.presentation";
break;
}
}
// check for bad ppt detection
if ($mime_type == "application/vnd.ms-office" && $info['extension'] == "ppt") {
$mime_type = "application/vnd.ms-powerpoint";
}
//add_metastring("projectId");
//$file->projectId = $project_guid;
$file->setMimeType($mime_type);
$file->originalfilename = $name;
if (elgg_is_active_plugin('file')) {
$file->simpletype = file_get_simple_type($mime_type);
}
$saved = $file->save();
if ($saved) {
$file->addRelationship($guid, 'attachment');
}
}
}
}
$accesslevel = get_input('accesslevel', false);
$params = array('entity' => $entity);
$form = hj_framework_prepare_form($form_name, $params);
$fields = $form['form']['fields'];
$ignore_fields = array('guid', 'type', 'subtype', 'owner_guid', 'container_guid', 'access_id', 'title', 'description');
foreach ($fields as $name => $options) {
if (in_array($name, $ignore_fields)) {
continue;
}
if (!$options) {
continue;
}
$type = elgg_extract('input_type', $options, 'text');
$accesslevel_id = isset($accesslevel[$name]) ? $accesslevel[$name] : $entity->access_id;
$params = array('name' => $name, 'form_name' => $form_name, 'field' => $options, 'access_id' => $accesslevel_id, 'entity' => $entity, 'event' => $event);
if (!elgg_trigger_plugin_hook('process:input', "form:input:name:{$name}", $params, false) && !elgg_trigger_plugin_hook('process:input', "form:input:type:{$type}", $params, false)) {
$value = get_input($name);
set_input($name, null);
// if (!$value) {
// elgg_delete_metadata(array(
// 'guid' => $entity->guid,
// 'metadata_name' => $name
// ));
//
// continue;
// }
//
// if (is_array($value) && count($value) > 1) {
// elgg_delete_metadata(array(
// 'guid' => $entity->guid,
// 'metadata_name' => $name
// ));
// foreach ($value as $val) {
// if (!empty($val)) {
// create_metadata($entity->guid, $name, $val, '', $entity->owner_guid, $accesslevel_id, true);
// }
// }
// } else {
// if (is_array($value)) {
// $value = implode(',', $value);
// }
// create_metadata($entity->guid, $name, $value, '', $entity->owner_guid, $accesslevel_id);
// }
$entity->{$name} = $value;
}
}
$entity->save();
elgg_trigger_plugin_hook('process:form', "form:{$form_name}", array('form_name' => $form_name, 'entity' => $entity), null);
}
$forward_url = elgg_trigger_plugin_hook('action:forward', 'form', array('entity' => $entity, 'form_name' => $form_name), $entity->getURL());
foreach ($_POST['user-callout-id'] as $callout_user) {
$callout_user_guids[] = $callout_user;
}
if ($callout_user_guids) {
$calloutUsers = new UserCallout(get_entity(elgg_get_logged_in_user_guid()), $callout_user_guids, "a forum post", $forward_url);
$calloutUsers->sendUserNotifications();
}
system_message(elgg_echo('hj:framework:submit:success'));
elgg_clear_sticky_form($form_name);
hj_framework_clear_form_validation_status($form_name);
return array('entity' => $entity, 'forward' => $forward_url);
}
