/** * Test the tag_set_add function. */ public function test_tag_set_add() { global $DB; // Create a course to tag. $course = $this->getDataGenerator()->create_course(); // Create the tag and tag instance. tag_set_add('course', $course->id, 'A random tag', 'core', context_course::instance($course->id)->id); // Get the tag instance that should have been created. $taginstance = $DB->get_record('tag_instance', array('itemtype' => 'course', 'itemid' => $course->id), '*', MUST_EXIST); $this->assertEquals('core', $taginstance->component); $this->assertEquals(context_course::instance($course->id)->id, $taginstance->contextid); // Remove the tag we just created. $tag = $DB->get_record('tag', array('rawname' => 'A random tag')); tag_delete($tag->id); // Now call the tag_set_add function without specifying the component or // contextid and ensure the function debugging is called. tag_set_add('course', $course->id, 'Another tag'); $this->assertDebuggingCalled(); }
/** * Clean up the tag tables, making sure all tagged object still exists. * * This should normally not be necessary, but in case related tags are not deleted * when the tagged record is removed, this should be done once in a while, perhaps on * an occasional cron run. On a site with lots of tags, this could become an expensive * function to call: don't run at peak time. */ function tag_cleanup() { global $CFG; $instances = get_recordset('tag_instance'); // cleanup tag instances while ($instance = rs_fetch_next_record($instances)) { $delete = false; if (!record_exists('tag', 'id', $instance->tagid)) { // if the tag has been removed, instance should be deleted. $delete = true; } else { switch ($instance->itemtype) { case 'user': // users are marked as deleted, but not actually deleted if (record_exists('user', 'id', $instance->itemid, 'deleted', 1)) { $delete = true; } break; default: // anything else, if the instance is not there, delete. if (!record_exists($instance->itemtype, 'id', $instance->itemid)) { $delete = true; } break; } } if ($delete) { tag_delete_instance($instance->itemtype, $instance->itemid, $instance->tagid); //debugging('deleting tag_instance #'. $instance->id .', linked to tag id #'. $instance->tagid, DEBUG_DEVELOPER); } } rs_close($instances); // TODO: this will only clean tags of type 'default'. This is good as // it won't delete 'official' tags, but the day we get more than two // types, we need to fix this. $unused_tags = get_recordset_sql("SELECT tg.id FROM {$CFG->prefix}tag tg WHERE tg.tagtype = 'default' AND NOT EXISTS (" . "SELECT 'x' FROM {$CFG->prefix}tag_instance ti WHERE ti.tagid = tg.id)"); // cleanup tags while ($unused_tag = rs_fetch_next_record($unused_tags)) { tag_delete($unused_tag->id); //debugging('deleting unused tag #'. $unused_tag->id, DEBUG_DEVELOPER); } rs_close($unused_tags); }
function delete_otags($tagids, $sitecontext) { foreach ($tagids as $tagid) { if (!($tag = tag_by_id($tagid))) { error('Can not delete tag, tag doesn\'t exist'); } if ($tag->tagtype != 'official') { continue; } if ($tag->tagtype == 'official' and !has_capability('moodle/blog:manageofficialtags', $sitecontext)) { //can not delete error('Can not delete tag, you don\'t have permission to delete an official tag'); } // Delete the tag itself if (!tag_delete($tagid)) { error('Can not delete tag'); } } }
/** * Test the tag deleted event. */ public function test_tag_deleted() { global $DB; $this->setAdminUser(); // Create a course. $course = $this->getDataGenerator()->create_course(); // Create tag we are going to delete. $tag = $this->getDataGenerator()->create_tag(); // Trigger and capture the event for deleting a tag. $sink = $this->redirectEvents(); tag_delete($tag->id); $events = $sink->get_events(); $event = reset($events); // Check that the tag was deleted and the event data is valid. $this->assertEquals(0, $DB->count_records('tag')); $this->assertInstanceOf('\\core\\event\\tag_deleted', $event); $this->assertEquals(context_system::instance(), $event->get_context()); // Create two tags we are going to delete to ensure passing multiple tags work. $tag = $this->getDataGenerator()->create_tag(); $tag2 = $this->getDataGenerator()->create_tag(); // Trigger and capture the events for deleting multiple tags. $sink = $this->redirectEvents(); tag_delete(array($tag->id, $tag2->id)); $events = $sink->get_events(); // Check that the tags were deleted and the events data is valid. $this->assertEquals(0, $DB->count_records('tag')); foreach ($events as $event) { $this->assertInstanceOf('\\core\\event\\tag_deleted', $event); $this->assertEquals(context_system::instance(), $event->get_context()); } // Create another tag to delete. $tag = $this->getDataGenerator()->create_tag(); // Add a tag instance to a course. tag_assign('course', $course->id, $tag->id, 0, 2, 'course', context_course::instance($course->id)->id); // Trigger and capture the event for deleting a personal tag for a user for a course. $sink = $this->redirectEvents(); coursetag_delete_keyword($tag->id, 2, $course->id); $events = $sink->get_events(); $event = $events[1]; // Check that the tag was deleted and the event data is valid. $this->assertEquals(0, $DB->count_records('tag')); $this->assertInstanceOf('\\core\\event\\tag_deleted', $event); $this->assertEquals(context_system::instance(), $event->get_context()); // Create a new tag we are going to delete. $tag = $this->getDataGenerator()->create_tag(); // Add the tag instance to the course again as it was deleted. tag_assign('course', $course->id, $tag->id, 0, 2, 'course', context_course::instance($course->id)->id); // Trigger and capture the event for deleting all tags in a course. $sink = $this->redirectEvents(); coursetag_delete_course_tags($course->id); $events = $sink->get_events(); $event = $events[1]; // Check that the tag was deleted and the event data is valid. $this->assertEquals(0, $DB->count_records('tag')); $this->assertInstanceOf('\\core\\event\\tag_deleted', $event); $this->assertEquals(context_system::instance(), $event->get_context()); // Create two tags we are going to delete to ensure passing multiple tags work. $tag = $this->getDataGenerator()->create_tag(); $tag2 = $this->getDataGenerator()->create_tag(); // Add multiple tag instances now and check that it still works. tag_assign('course', $course->id, $tag->id, 0, 2, 'course', context_course::instance($course->id)->id); tag_assign('course', $course->id, $tag2->id, 0, 2, 'course', context_course::instance($course->id)->id); // Trigger and capture the event for deleting all tags in a course. $sink = $this->redirectEvents(); coursetag_delete_course_tags($course->id); $events = $sink->get_events(); $events = array($events[2], $events[3]); // Check that the tags were deleted and the events data is valid. $this->assertEquals(0, $DB->count_records('tag')); foreach ($events as $event) { $this->assertInstanceOf('\\core\\event\\tag_deleted', $event); $this->assertEquals(context_system::instance(), $event->get_context()); } }
<?php # Mantis - a php based bugtracking system # Copyright (C) 2000 - 2002 Kenzaburo Ito - kenito@300baud.org # Copyright (C) 2002 - 2007 Mantis Team - mantisbt-dev@lists.sourceforge.net # Mantis is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 2 of the License, or # (at your option) any later version. # # Mantis is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Mantis. If not, see <http://www.gnu.org/licenses/>. # -------------------------------------------------------- # $Id: tag_delete.php,v 1.1.2.1 2007-10-13 22:34:44 giallu Exp $ # -------------------------------------------------------- require_once 'core.php'; $t_core_path = config_get('core_path'); require_once $t_core_path . 'tag_api.php'; form_security_validate('tag_delete'); access_ensure_global_level(config_get('tag_edit_threshold')); $f_tag_id = gpc_get_int('tag_id'); $t_tag_row = tag_get($f_tag_id); helper_ensure_confirmed(lang_get('tag_delete_message'), lang_get('tag_delete_button')); tag_delete($f_tag_id); form_security_purge('tag_delete'); print_successful_redirect(config_get('default_home_page'));
/** * * Deletes a tag * * @param string $p_username The user's username * @param string $p_password The user's password * @param unknown_type $p_tag_id * @param int $p_tag_id The id of the tag * @return soap_fault|boolean */ function mc_tag_delete($p_username, $p_password, $p_tag_id) { $t_user_id = mci_check_login($p_username, $p_password); if ($t_user_id === false) { return mci_soap_fault_login_failed(); } if (!access_has_global_level(config_get('tag_edit_threshold'))) { return mci_soap_fault_access_denied($t_user_id); } if (!tag_exists($p_tag_id)) { return SoapObjectsFactory::newSoapFault('Client', 'No tag with id ' . $p_tag_id); } return tag_delete($p_tag_id); }
// get all the possible tag types from db $existing_tagtypes = array(); if ($ptypes = $DB->get_records_sql("SELECT DISTINCT(tagtype) FROM {tag}")) { foreach ($ptypes as $ptype) { $existing_tagtypes[$ptype->tagtype] = $ptype->tagtype; } } $existing_tagtypes['official'] = get_string('tagtype_official', 'tag'); $existing_tagtypes['default'] = get_string('tagtype_default', 'tag'); switch ($action) { case 'delete': if (!data_submitted() or !confirm_sesskey()) { break; } $str_tagschecked = implode(', ', tag_get_name($tagschecked)); tag_delete($tagschecked); $notice = $str_tagschecked . ' -- ' . get_string('deleted', 'tag'); break; case 'reset': if (!data_submitted() or !confirm_sesskey()) { break; } $str_tagschecked = implode(', ', tag_get_name($tagschecked)); tag_unset_flag($tagschecked); $notice = $str_tagschecked . ' -- ' . get_string('reset', 'tag'); break; case 'changetype': if (!data_submitted() or !confirm_sesskey()) { break; } $changed = array();
/** * Clean up the tag tables, making sure all tagged object still exists. * * This should normally not be necessary, but in case related tags are not deleted * when the tagged record is removed, this should be done once in a while, perhaps on * an occasional cron run. On a site with lots of tags, this could become an expensive * function to call: don't run at peak time. */ function tag_cleanup() { global $DB; $instances = $DB->get_recordset('tag_instance'); // cleanup tag instances foreach ($instances as $instance) { $delete = false; if (!$DB->record_exists('tag', array('id' => $instance->tagid))) { // if the tag has been removed, instance should be deleted. $delete = true; } else { switch ($instance->itemtype) { case 'user': // users are marked as deleted, but not actually deleted if ($DB->record_exists('user', array('id' => $instance->itemid, 'deleted' => 1))) { $delete = true; } break; default: // anything else, if the instance is not there, delete. if (!$DB->record_exists($instance->itemtype, array('id' => $instance->itemid))) { $delete = true; } break; } } if ($delete) { tag_delete_instance($instance->itemtype, $instance->itemid, $instance->tagid); //debugging('deleting tag_instance #'. $instance->id .', linked to tag id #'. $instance->tagid, DEBUG_DEVELOPER); } } $instances->close(); // TODO: this will only clean tags of type 'default'. This is good as // it won't delete 'official' tags, but the day we get more than two // types, we need to fix this. $unused_tags = $DB->get_recordset_sql("SELECT tg.id\n FROM {tag} tg\n WHERE tg.tagtype = 'default'\n AND NOT EXISTS (\n SELECT 'x'\n FROM {tag_instance} ti\n WHERE ti.tagid = tg.id\n )"); // cleanup tags foreach ($unused_tags as $unused_tag) { tag_delete($unused_tag->id); //debugging('deleting unused tag #'. $unused_tag->id, DEBUG_DEVELOPER); } $unused_tags->close(); }
/** * Course tagging function used only during the deletion of a course (called by lib/moodlelib.php) to clean up associated tags * * @package core_tag * @param int $courseid the course we wish to delete tag instances from * @param bool $showfeedback if we should output a notification of the delete to the end user */ function coursetag_delete_course_tags($courseid, $showfeedback = false) { global $DB, $OUTPUT; if ($taginstances = $DB->get_fieldset_select('tag_instance', 'tagid', "itemtype = 'course' AND itemid = :courseid", array('courseid' => $courseid))) { tag_delete(array_values($taginstances)); } if ($showfeedback) { echo $OUTPUT->notification(get_string('deletedcoursetags', 'tag'), 'notifysuccess'); } }
$existing_tagtypes = array(); if ($ptypes = get_records_sql("SELECT DISTINCT(tagtype), id FROM {$CFG->prefix}tag")) { foreach ($ptypes as $ptype) { $existing_tagtypes[$ptype->tagtype] = $ptype->tagtype; } } $existing_tagtypes['official'] = get_string('tagtype_official', 'tag'); $existing_tagtypes['default'] = get_string('tagtype_default', 'tag'); switch ($action) { case 'delete': if (!data_submitted or !confirm_sesskey()) { break; } $str_tagschecked = tag_name_from_string(implode($tagschecked, ',')); $str_tagschecked = str_replace(',', ', ', $str_tagschecked); tag_delete(implode($tagschecked, ',')); $notice = $str_tagschecked . ' -- ' . get_string('deleted', 'tag'); break; case 'reset': if (!data_submitted or !confirm_sesskey()) { break; } $str_tagschecked = tag_name_from_string(implode($tagschecked, ',')); $str_tagschecked = str_replace(',', ', ', $str_tagschecked); tag_flag_reset(implode($tagschecked, ',')); $notice = $str_tagschecked . ' -- ' . get_string('reset', 'tag'); break; case 'changetype': if (!data_submitted or !confirm_sesskey()) { break; }
/** * Clean up the tag tables, making sure all tagged object still exists. * * This should normally not be necessary, but in case related tags are not deleted when the tagged record is removed, this should be * done once in a while, perhaps on an occasional cron run. On a site with lots of tags, this could become an expensive function to * call: don't run at peak time. * * @package core_tag * @access private * @todo MDL-31212 Update tag cleanup sql so that it supports multiple types of tags */ function tag_cleanup() { global $DB; // Get ids to delete from instances where the tag has been deleted. This should never happen apparently. $sql = "SELECT ti.id\n FROM {tag_instance} ti\n LEFT JOIN {tag} t ON t.id = ti.tagid\n WHERE t.id IS null"; $tagids = $DB->get_records_sql($sql); $tagarray = array(); foreach ($tagids as $tagid) { $tagarray[] = $tagid->id; } // Next get ids from instances that have an owner that has been deleted. $sql = "SELECT ti.id\n FROM {tag_instance} ti, {user} u\n WHERE ti.itemid = u.id\n AND ti.itemtype = 'user'\n AND u.deleted = 1"; $tagids = $DB->get_records_sql($sql); foreach ($tagids as $tagid) { $tagarray[] = $tagid->id; } // Get the other itemtypes. $sql = "SELECT itemtype\n FROM {tag_instance}\n WHERE itemtype <> 'user'\n GROUP BY itemtype"; $tagitemtypes = $DB->get_records_sql($sql); foreach ($tagitemtypes as $key => $notused) { $sql = 'SELECT ti.id FROM {tag_instance} ti LEFT JOIN {' . $key . '} it ON it.id = ti.itemid WHERE it.id IS null AND ti.itemtype = \'' . $key . '\''; $tagids = $DB->get_records_sql($sql); foreach ($tagids as $tagid) { $tagarray[] = $tagid->id; } } // Get instances for each of the ids to be deleted. if (count($tagarray) > 0) { list($sqlin, $params) = $DB->get_in_or_equal($tagarray); $sql = "SELECT ti.*, COALESCE(t.name, 'deleted') AS name, COALESCE(t.rawname, 'deleted') AS rawname\n FROM {tag_instance} ti\n LEFT JOIN {tag} t ON t.id = ti.tagid\n WHERE ti.id {$sqlin}"; $instances = $DB->get_records_sql($sql, $params); tag_bulk_delete_instances($instances); } // TODO MDL-31212 this will only clean tags of type 'default'. This is good as // it won't delete 'official' tags, but the day we get more than two // types, we need to fix this. $unused_tags = $DB->get_recordset_sql("SELECT tg.id\n FROM {tag} tg\n WHERE tg.tagtype = 'default'\n AND NOT EXISTS (\n SELECT 'x'\n FROM {tag_instance} ti\n WHERE ti.tagid = tg.id\n )"); // cleanup tags foreach ($unused_tags as $unused_tag) { tag_delete($unused_tag->id); //debugging('deleting unused tag #'. $unused_tag->id, DEBUG_DEVELOPER); } $unused_tags->close(); }
/** * Test the tag deleted event */ public function test_tag_deleted() { global $DB; $this->setAdminUser(); // Create a course and a user. $course = $this->getDataGenerator()->create_course(); $user = $this->getDataGenerator()->create_user(); // Create tag we are going to delete. $tag = $this->getDataGenerator()->create_tag(); // Trigger and capture the event for deleting a tag. $sink = $this->redirectEvents(); tag_delete($tag->id); $this->assertDebuggingCalled(); $events = $sink->get_events(); $event = reset($events); // Check that the tag was deleted and the event data is valid. $this->assertEquals(0, $DB->count_records('tag')); $this->assertInstanceOf('\\core\\event\\tag_deleted', $event); $this->assertEquals(context_system::instance(), $event->get_context()); // Create two tags we are going to delete to ensure passing multiple tags work. $tag = $this->getDataGenerator()->create_tag(); $tag2 = $this->getDataGenerator()->create_tag(); // Trigger and capture the events for deleting multiple tags. $sink = $this->redirectEvents(); tag_delete(array($tag->id, $tag2->id)); $this->assertDebuggingCalled(); $events = $sink->get_events(); // Check that the tags were deleted and the events data is valid. $this->assertEquals(0, $DB->count_records('tag')); foreach ($events as $event) { $this->assertInstanceOf('\\core\\event\\tag_deleted', $event); $this->assertEquals(context_system::instance(), $event->get_context()); } // Add a tag instance to a course. core_tag_tag::add_item_tag('core', 'course', $course->id, context_course::instance($course->id), 'cat', $user->id); // Trigger and capture the event for deleting a personal tag for a user for a course. $sink = $this->redirectEvents(); core_tag_tag::remove_item_tag('core', 'course', $course->id, 'cat', $user->id); $events = $sink->get_events(); $event = $events[1]; // Check that the tag was deleted and the event data is valid. $this->assertEquals(0, $DB->count_records('tag')); $this->assertInstanceOf('\\core\\event\\tag_deleted', $event); $this->assertEquals(context_system::instance(), $event->get_context()); // Add the tag instance to the course again as it was deleted. core_tag_tag::add_item_tag('core', 'course', $course->id, context_course::instance($course->id), 'dog', $user->id); // Trigger and capture the event for deleting all tags in a course. $sink = $this->redirectEvents(); core_tag_tag::remove_all_item_tags('core', 'course', $course->id); $events = $sink->get_events(); $event = $events[1]; // Check that the tag was deleted and the event data is valid. $this->assertEquals(0, $DB->count_records('tag')); $this->assertInstanceOf('\\core\\event\\tag_deleted', $event); $this->assertEquals(context_system::instance(), $event->get_context()); // Add multiple tag instances now and check that it still works. core_tag_tag::set_item_tags('core', 'course', $course->id, context_course::instance($course->id), array('fish', 'hamster'), $user->id); // Trigger and capture the event for deleting all tags in a course. $sink = $this->redirectEvents(); core_tag_tag::remove_all_item_tags('core', 'course', $course->id); $events = $sink->get_events(); $events = array($events[1], $events[3]); // Check that the tags were deleted and the events data is valid. $this->assertEquals(0, $DB->count_records('tag')); foreach ($events as $event) { $this->assertInstanceOf('\\core\\event\\tag_deleted', $event); $this->assertEquals(context_system::instance(), $event->get_context()); } }