/**
* Cleans up all the groups and groupings in a course (it does this best-effort
* i.e. if one deletion fails, it still attempts further deletions).
* IMPORTANT: Note that if the groups and groupings are used by other courses
* somehow, they will still be deleted - it doesn't protect against this.
* @param int $courseid The id of the course
* @return boolean True if the clean up was successful, false otherwise.
*/
function groups_cleanup_groups($courseid)
{
$success = true;
// Delete all the groupings
$groupings = groups_get_groupings($courseid);
if ($groupings != false) {
foreach ($groupings as $groupingid) {
$groupingdeleted = groups_delete_grouping($groupingid);
if (!$groupingdeleted) {
$success = false;
}
}
}
// Delete all the groups
$groupids = groups_get_groups($courseid);
if ($groupids != false) {
foreach ($groupids as $groupid) {
$groupdeleted = groups_delete_group($groupid);
if (!$groupdeleted) {
$success = false;
}
}
}
return $success;
}
public function test_grouping_deleted_event()
{
$this->resetAfterTest();
$course = $this->getDataGenerator()->create_course();
$group = $this->getDataGenerator()->create_grouping(array('courseid' => $course->id));
$sink = $this->redirectEvents();
groups_delete_grouping($group->id);
$events = $sink->get_events();
$this->assertCount(1, $events);
$event = reset($events);
$this->assertInstanceOf('\\core\\event\\grouping_deleted', $event);
$this->assertEventLegacyData($group, $event);
$this->assertSame('groups_grouping_deleted', $event->get_legacy_eventname());
$this->assertEquals(context_course::instance($course->id), $event->get_context());
$this->assertEquals($group->id, $event->objectid);
$url = new moodle_url('/group/groupings.php', array('id' => $event->courseid));
$this->assertEquals($url, $event->get_url());
}
/**
* Delete groupings
*
* @param array $groupingids array of grouping ids
* @return void
* @since Moodle 2.3
*/
public static function delete_groupings($groupingids)
{
global $CFG, $DB;
require_once "{$CFG->dirroot}/group/lib.php";
$params = self::validate_parameters(self::delete_groupings_parameters(), array('groupingids' => $groupingids));
$transaction = $DB->start_delegated_transaction();
foreach ($params['groupingids'] as $groupingid) {
if (!($grouping = groups_get_grouping($groupingid, 'id, courseid', IGNORE_MISSING))) {
// Silently ignore attempts to delete nonexisting groupings.
continue;
}
// Now security checks.
$context = context_course::instance($grouping->courseid);
try {
self::validate_context($context);
} catch (Exception $e) {
$exceptionparam = new stdClass();
$exceptionparam->message = $e->getMessage();
$exceptionparam->courseid = $grouping->courseid;
throw new moodle_exception('errorcoursecontextnotvalid', 'webservice', '', $exceptionparam);
}
require_capability('moodle/course:managegroups', $context);
groups_delete_grouping($grouping);
}
$transaction->allow_commit();
}
break;
}
$createdgroups[] = $groupid;
foreach ($group['members'] as $user) {
groups_add_member($groupid, $user->id);
}
if ($grouping) {
groups_assign_grouping($grouping->id, $groupid);
}
}
if ($failed) {
foreach ($createdgroups as $groupid) {
groups_delete_group($groupid);
}
if ($createdgrouping) {
groups_delete_grouping($createdgrouping);
}
} else {
redirect($returnurl);
}
}
}
/// Print header
print_header_simple($strgroups, ': ' . $strgroups, $navigation, '', '', true, '', navmenu($course));
print_heading($strautocreategroups);
if ($error != '') {
notify($error);
}
/// Display the form
$editform->display();
if ($preview !== '') {
/**
* Delete all groupings from course
*
* @param int $courseid
* @param bool $showfeedback
* @return bool success
*/
function groups_delete_groupings($courseid, $showfeedback = false)
{
global $DB, $OUTPUT;
$groupings = $DB->get_recordset_select('groupings', 'courseid = ?', array($courseid));
foreach ($groupings as $grouping) {
groups_delete_grouping($grouping);
}
// Invalidate the grouping cache for the course.
cache_helper::invalidate_by_definition('core', 'groupdata', array(), array($courseid));
// TODO MDL-41312 Remove events_trigger_legacy('groups_groupings_deleted').
// This event is kept here for backwards compatibility, because it cannot be
// translated to a new event as it is wrong.
events_trigger_legacy('groups_groupings_deleted', $courseid);
if ($showfeedback) {
echo $OUTPUT->notification(get_string('deleted') . ' - ' . get_string('groupings', 'group'), 'notifysuccess');
}
return true;
}
if ($id) {
if (!($grouping = get_record('groups_groupings', 'id', $id))) {
error('Grouping ID was incorrect');
}
$context = get_context_instance(CONTEXT_COURSE, $course->id);
require_capability('moodle/course:managegroups', $context);
}
/// First create the form
$editform = new grouping_edit_form('grouping.php', compact('grouping', 'courseid'));
/// Override defaults if group is set
if (!empty($grouping)) {
$editform->set_data($grouping);
}
// preprocess data
if ($delete) {
if (groups_delete_grouping($id)) {
redirect(groups_home_url($course->id));
} else {
print_error('erroreditgrouping', 'group', groups_home_url($course->id));
}
}
if ($editform->is_cancelled()) {
redirect(groups_home_url($courseid, false, $id, false));
} elseif ($data = $editform->get_data()) {
$success = true;
if (empty($grouping)) {
// New grouping
if (!($id = groups_create_grouping($course->id, $data))) {
print_error('erroreditgrouping');
} else {
$success = (bool) $id;
function blended_delete_sign_member_or_group($idteam, $member, $option)
{
global $DB;
$blended_teams = $DB->get_records('blended_team');
foreach ($blended_teams as $blended_team) {
if ($blended_team->id_team == $idteam) {
$f = $blended_team;
}
}
$g = $DB->get_record('groups', array('id' => $idteam));
$l = $DB->get_record('blended_assign_grouping', array('id_assign' => $f->id_assignment));
if ($option == 'member') {
$del = groups_remove_member($idteam, $member->userid);
blended_delete_team_member($idteam, $member->id);
}
if ($option == 'group') {
$del = groups_delete_group($idteam);
groups_unassign_grouping($l->id_grouping, $idteam);
blended_delete_team($idteam, $f->id_assignment);
blended_delete_team_member($idteam);
//Se debe realizar la comprobación de que si no hay mas equipos se borre el agrupamiento
if (!($teams = $DB->get_records('groupings_groups', array('groupingid' => $l->id_grouping)))) {
groups_delete_grouping($l->id_grouping);
$DB->delete_records('blended_assign_grouping', array('id_grouping' => $l->id_grouping));
}
}
}
public function test_groups_get_grouping()
{
$this->resetAfterTest(true);
$generator = $this->getDataGenerator();
// Create a course category and course.
$cat = $generator->create_category(array('parent' => 0));
$course = $generator->create_course(array('category' => $cat->id));
$name1 = 'Grouping 1';
$name2 = 'Grouping 2';
// Test with an empty and a null idnumber.
$this->assertFalse(groups_get_grouping_by_name($course->id, ''));
$this->assertFalse(groups_get_grouping_by_name($course->id, null));
// Even when a group exists.
$generator->create_group(array('courseid' => $course->id));
$this->assertFalse(groups_get_grouping_by_name($course->id, ''));
$this->assertFalse(groups_get_grouping_by_name($course->id, null));
// Test with a valid name, but one that doesn't exist yet.
$this->assertFalse(groups_get_grouping_by_name($course->id, $name1));
$this->assertFalse(groups_get_grouping_by_name($course->id, $name2));
// We should now have a valid group returned by the name search.
$group1 = $generator->create_grouping(array('courseid' => $course->id, 'name' => $name1));
$this->assertEquals($group1->id, groups_get_grouping_by_name($course->id, $name1));
$this->assertFalse(groups_get_grouping_by_name($course->id, $name2));
// We should now have a two valid groups returned by the name search.
$group2 = $generator->create_grouping(array('courseid' => $course->id, 'name' => $name2));
$this->assertEquals($group1->id, groups_get_grouping_by_name($course->id, $name1));
$this->assertEquals($group2->id, groups_get_grouping_by_name($course->id, $name2));
// Delete a group.
$this->assertTrue(groups_delete_grouping($group1));
$this->assertFalse(groups_get_grouping_by_name($course->id, $name1));
$this->assertEquals($group2->id, groups_get_grouping_by_name($course->id, $name2));
/*
* Group idnumbers are unique within a course so test that we don't
* retrieve groups for the first course.
*/
// Create a second course.
$course = $generator->create_course(array('category' => $cat->id));
// An empty name should always return a false value.
$this->assertFalse(groups_get_grouping_by_name($course->id, ''));
$this->assertFalse(groups_get_grouping_by_name($course->id, null));
// Our existing names shouldn't be returned here as we're in a different course.
$this->assertFalse(groups_get_grouping_by_name($course->id, $name1));
$this->assertFalse(groups_get_grouping_by_name($course->id, $name2));
// We should be able to reuse the idnumbers again since this is a different course.
$group1 = $generator->create_grouping(array('courseid' => $course->id, 'name' => $name1));
$this->assertEquals($group1->id, groups_get_grouping_by_name($course->id, $name1));
$group2 = $generator->create_grouping(array('courseid' => $course->id, 'name' => $name2));
$this->assertEquals($group2->id, groups_get_grouping_by_name($course->id, $name2));
}
/**
* Create a grouping for each selected groupmoodle-groups
*
* Uses $SESSION->grouptool->view_administration->use_all to determin if groupings for all
* or just selected groups should be created and also uses
* $SESSION->grouptool->view_administration->grouplist[$group->id]['active']
* to determin which groups have been selected
*
* @param int $courseid optional id of course to create for
* @param bool $previewonly optional only show preview of created groups
* @return array ( 0 => error, 1 => message )
*/
private function create_group_groupings($courseid = null, $previewonly = false)
{
global $SESSION, $PAGE, $OUTPUT;
require_capability('mod/grouptool:create_groupings', $this->context);
// Create groupings!
$created = array();
$error = false;
$return = "";
$table = new html_table();
$table->attributes['class'] = 'centeredblock';
$table->head = array(new html_table_cell(get_string('grouping', 'group')), new html_table_cell(get_string('info') . '/' . get_string('groups')));
// Get all course-groups!
if ($courseid == null) {
if (isset($this->course->id)) {
$courseid = $this->course->id;
} else {
print_error('coursemisconf');
}
}
$groups = groups_get_all_groups($courseid);
$ids = array();
foreach ($groups as $group) {
$row = array(new html_table_cell($group->name));
$active = $SESSION->grouptool->view_administration->grouplist[$group->id]['active'];
if (empty($SESSION->grouptool->view_administration->use_all) && !$active) {
continue;
}
$groupid = $group->id;
if (groups_get_grouping_by_name($courseid, $group->name)) {
// Creation of grouping failed!
if ($previewonly) {
$text = get_string('grouping_exists_error_prev', 'grouptool');
} else {
$text = get_string('grouping_exists_error', 'grouptool');
}
$cell = new html_table_cell($OUTPUT->notification($text, 'notifyproblem'));
$row[] = $cell;
$error = true;
} else {
$ids[] = $group->id;
$groupingid = groups_create_grouping($group);
if ($groupingid) {
if (!groups_assign_grouping($groupingid, $groupid)) {
if ($previewonly) {
$text = get_string('group_assign_error_prev', 'grouptool');
} else {
$text = get_string('group_assign_error', 'grouptool');
}
$cell = new html_table_cell($OUTPUT->notification($text, 'notifyproblem'));
$row[] = $cell;
$error = true;
} else {
if ($previewonly) {
$content = $group->name;
} else {
$content = $OUTPUT->notification(get_string('grouping_creation_success', 'grouptool', $group->name), 'notifysuccess');
}
$cell = new html_table_cell($content);
$row[] = $cell;
$created[] = $groupingid;
}
} else {
if ($previewonly) {
$text = get_string('grouping_creation_error_prev', 'grouptool');
} else {
$text = get_string('grouping_creation_error', 'grouptool');
}
$cell = new html_table_cell($OUTPUT->notification($text, 'notifyproblem'));
$row[] = $cell;
$error = true;
}
}
$table->data[] = new html_table_row($row);
$return = html_writer::table($table);
}
if ($previewonly || $error && !$previewonly) {
// Undo everything!
foreach ($created as $groupingid) {
$groupingsgroups = groups_get_all_groups($courseid, 0, $groupingid);
foreach ($groupingsgroups as $group) {
groups_unassign_grouping($groupingid, $group->id);
}
groups_delete_grouping($groupingid);
}
} else {
if (!$previewonly) {
// Trigger the event!
\mod_grouptool\event\groupings_created::create_from_object($this->cm, $ids)->trigger();
}
}
return array(0 => $error, 1 => $return);
}
function test_delete_grouping()
{
$this->assertTrue(groups_delete_grouping($this->groupingid));
$this->assertFalse(groups_grouping_exists($this->groupingid));
}
/// Add people to a group
if (!empty($data->nonmembers) && !empty($data->groupid) && is_numeric($data->groupid)) {
$groupmodified = false;
foreach ($data->nonmembers as $userid) {
groups_add_member($data->groupid, $userid);
}
}
$selectedgroup = $data->groupid;
} else {
if (!empty($data->groupsremove)) {
if (is_numeric($data->groups)) {
/// Remove a group, all members become nonmembers
groups_delete_group($data->groups);
} else {
$grpingid = substr($data->groups, 2);
groups_delete_grouping($grpingid);
}
} else {
if (!empty($data->groupsadd)) {
/// Create a new group
if (!empty($data->newgroupname)) {
$newgroup->name = $data->newgroupname;
$newgroup->courseid = $course->id;
$newgroup->description = '';
$newgroup->enrolmentkey = '';
$newgroup->picture = 0;
$newgroup->hidepicture = 0;
$newgroup->id = groups_create_group($newgroup);
if (!empty($data->groups) && !is_numeric($data->groups)) {
$groupingid = substr($data->groups, 2);
groups_assign_grouping($groupingid, $newgroup->id);
