groupmanager.lib.php

完美的在线教育系统

		$group_ids = is_array($group_ids) ? $group_ids : array ($group_ids);
		global $_course;
		$category = GroupManager :: get_category_from_group($group_ids[0]);
		$groups_per_user = $category['groups_per_user'];
		$course_user_table = Database :: get_main_table(TABLE_MAIN_COURSE_USER);
		$group_table = Database :: get_course_table(TABLE_GROUP);
		$group_user_table = Database :: get_course_table(TABLE_GROUP_USER);
		$complete_user_list = CourseManager :: get_real_and_linked_user_list($_course['sysCode']);
        $number_groups_per_user = ($groups_per_user == GROUP_PER_MEMBER_NO_LIMIT ? INFINITE : $groups_per_user);
		/*
		 * Retrieve all the groups where enrollment is still allowed
		 * (reverse) ordered by the number of place available
		 */
		$sql = "SELECT g.id gid, g.max_student-count(ug.user_id) nbPlaces, g.max_student
				FROM ".$group_table." g
				LEFT JOIN  ".$group_user_table." ug
				ON    `g`.`id` = `ug`.`group_id`
				WHERE g.id IN (".implode(',', $group_ids).")
				GROUP BY (`g`.`id`)
				HAVING (nbPlaces > 0 OR g.max_student = ".MEMBER_PER_GROUP_NO_LIMIT.")
				ORDER BY nbPlaces DESC";
		$sql_result = api_sql_query($sql,__FILE__,__LINE__);
		$group_available_place = array ();
		while ($group = Database::fetch_array($sql_result, 'ASSOC'))
		{
			$group_available_place[$group['gid']] = $group['nbPlaces'];
		}
		/*
		 * Retrieve course users (reverse) ordered by the number
		 * of group they are already enrolled
		 */
		for ($i = 0; $i < count($complete_user_list); $i ++)
		{
			
			//find # of groups the user is enrolled in
			$number_of_groups = GroupManager :: user_in_number_of_groups($complete_user_list[$i]["user_id"],$category['id']);
			//add # of groups to user list
			$complete_user_list[$i]['number_groups_left'] = $number_groups_per_user - $number_of_groups;
		}
		//first sort by user_id to filter out duplicates
		$complete_user_list = TableSort :: sort_table($complete_user_list, 'user_id');
		$complete_user_list = GroupManager :: filter_duplicates($complete_user_list, "user_id");
		$complete_user_list = GroupManager :: filter_only_students($complete_user_list);
		//now sort by # of group left
		$complete_user_list = TableSort :: sort_table($complete_user_list, 'number_groups_left', SORT_DESC);
		$userToken = array ();
		foreach ($complete_user_list as $this_user)
		{
			
			if ($this_user['number_groups_left'] > 0)
			{
				$userToken[$this_user['user_id']] = $this_user['number_groups_left'];
			}
		}
		/*
		 * Retrieve the present state of the users repartion in groups
		 */
		$sql = "SELECT user_id uid, group_id gid FROM ".$group_user_table;
		$result = api_sql_query($sql,__FILE__,__LINE__);
		while ($member = Database::fetch_array($result, 'ASSOC'))
		{
			$groupUser[$member['gid']][] = $member['uid'];
		}
		$changed = true;
		while ($changed)
		{
			
			$changed = false;
			reset($group_available_place);
			arsort($group_available_place);
			reset($userToken);
			arsort($userToken);
			foreach ($group_available_place as $group_id => $place)
			{
				foreach ($userToken as $user_id => $places)
				{
					if (GroupManager :: can_user_subscribe($user_id, $group_id))
					{
						
						GroupManager :: subscribe_users($user_id, $group_id);
						$group_available_place[$group_id]--;
						$userToken[$user_id]--;
						$changed = true;
						break;
					}
				}
				if ($changed)
				{
					break;
				}
			}
		}
	}


	/**
	 * Get the number of students in a group.
	 * @param int $group_id
	 * @return int Number of students in the given group.
	 */
	function number_of_students($group_id)
	{
		$table_group_user = Database :: get_course_table(TABLE_GROUP_USER);
		$db_result = api_sql_query('SELECT  COUNT(*) AS number_of_students FROM '.$table_group_user.' WHERE group_id = '.$group_id);
		$db_object = mysql_fetch_object($db_result);
		return $db_object->number_of_students;
	}
	/**
	 * Maximum number of students in a group
	 * @param int $group_id
	 * @return int Maximum number of students in the given group.
	 */
	function maximum_number_of_students($group_id)
	{
		$table_group = Database :: get_course_table(TABLE_GROUP);
		$db_result = api_sql_query('SELECT   max_student  FROM '.$table_group.' WHERE id = '.$group_id);
		$db_object = mysql_fetch_object($db_result);
		if ($db_object->max_student == 0)
		{
			return INFINITE;
		}
		return $db_object->max_student;
	}
	/**
	 * Number of groups of a user
	 * @param int $user_id
	 * @return int The number of groups the user is subscribed in.
	 */
	function user_in_number_of_groups($user_id, $cat_id)
	{
		$table_group_user = Database :: get_course_table(TABLE_GROUP_USER);
		$table_group = Database :: get_course_table(TABLE_GROUP);
		$sql = 'SELECT  COUNT(*) AS number_of_groups FROM '.$table_group_user.' gu, '.$table_group.' g WHERE gu.user_id = \''.$user_id.'\' AND g.id = gu.group_id AND g.category_id=  \''.$cat_id.'\'';
		$db_result = api_sql_query($sql,__FILE__,__LINE__);
		$db_object = mysql_fetch_object($db_result);
		return $db_object->number_of_groups;
	}
	/**
	 * Is sef-registration allowed?
	 * @param int $user_id
	 * @param int $group_id
	 * @return bool TRUE if self-registration is allowed in the given group.
	 */
	function is_self_registration_allowed($user_id, $group_id)
	{
		if (!$user_id > 0)
			return false;
		$table_group = Database :: get_course_table(TABLE_GROUP);
		$sql = 'SELECT  self_registration_allowed FROM '.$table_group.' WHERE id = '.$group_id;
		$db_result = api_sql_query($sql,__FILE__,__LINE__);
		$db_object = mysql_fetch_object($db_result);
		return $db_object->self_registration_allowed == 1 && GroupManager :: can_user_subscribe($user_id, $group_id);
	}
	/**
	 * Is sef-unregistration allowed?
	 * @param int $user_id
	 * @param int $group_id
	 * @return bool TRUE if self-unregistration is allowed in the given group.
	 */
	function is_self_unregistration_allowed($user_id, $group_id)
	{
		if (!$user_id > 0)
			return false;
		$table_group = Database :: get_course_table(TABLE_GROUP);
		$db_result = api_sql_query('SELECT  self_unregistration_allowed FROM '.$table_group.' WHERE id = '.$group_id);
		$db_object = mysql_fetch_object($db_result);
		return $db_object->self_unregistration_allowed == 1 && GroupManager :: can_user_unsubscribe($user_id, $group_id);
	}
	/**
	 * Is user subscribed in group?
	 * @param int $user_id
	 * @param int $group_id
	 * @return bool TRUE if given user is subscribed in given group
	 */
	function is_subscribed($user_id, $group_id)
	{
		if(empty($user_id) or empty($group_id)){return false;}
		$table_group_user = Database :: get_course_table(TABLE_GROUP_USER);
		$sql = 'SELECT 1 FROM '.$table_group_user.' WHERE group_id = '.$group_id.' AND user_id = '.$user_id;
		$db_result = api_sql_query($sql);
		return Database::num_rows($db_result) > 0;
	}
	/**
	 * Can a user subscribe to a specified group in a course
	 * @param int $user_id
	 * @param int $group_id
	 * @return bool TRUE if given user  can be subscribed in given group
	 */
	function can_user_subscribe($user_id, $group_id)
	{
		global $_course;
		$course_code = $_course['sysCode'];
		$category = GroupManager :: get_category_from_group($group_id);
		$result = CourseManager :: is_user_subscribed_in_real_or_linked_course($user_id, $course_code);
		$result = !GroupManager :: is_subscribed($user_id, $group_id);
		$result &= (GroupManager :: number_of_students($group_id) < GroupManager :: maximum_number_of_students($group_id));
		if ($category['groups_per_user'] == GROUP_PER_MEMBER_NO_LIMIT)
		{
			$category['groups_per_user'] = INFINITE;
		}
		$result &= (GroupManager :: user_in_number_of_groups($user_id, $category['id']) < $category['groups_per_user']);
		$result &= !GroupManager :: is_tutor($user_id);
		return $result;
	}
	/**
	 * Can a user unsubscribe to a specified group in a course
	 * @param int $user_id
	 * @param int $group_id
	 * @return bool TRUE if given user  can be unsubscribed from given group
	 * @internal for now, same as GroupManager::is_subscribed($user_id,$group_id)
	 */
	function can_user_unsubscribe($user_id, $group_id)
	{
		$result = GroupManager :: is_subscribed($user_id, $group_id);
		return $result;
	}
	/**
	 * Get all subscribed users from a group
	 * @param int $group_id
	 * @return array An array with information of all users from the given group.
	 *               (user_id, firstname, lastname, email)
	 */
	function get_subscribed_users($group_id)
	{
		$table_user = Database :: get_main_table(TABLE_MAIN_USER);
		$table_group_user = Database :: get_course_table(TABLE_GROUP_USER);
		$sql = "SELECT `ug`.`id`, `u`.`user_id`, `u`.`lastname`, `u`.`firstname`, `u`.`email`
					FROM ".$table_user." u, ".$table_group_user." ug
					WHERE `ug`.`group_id`='".$group_id."'
					AND `ug`.`user_id`=`u`.`user_id`
					ORDER BY UPPER(`u`.`lastname`), UPPER(`u`.`firstname`)";
		$db_result = api_sql_query($sql,__FILE__,__LINE__);
		$users = array ();
		while ($user = mysql_fetch_object($db_result))
		{
			$member['user_id'] = $user->user_id;
			$member['firstname'] = $user->firstname;
			$member['lastname'] = $user->lastname;
			$member['email'] = $user->email;
			$users[] = $member;
		}
		return $users;
	}

	/**
	 * @author Patrick Cool <[e-mail]>, Ghent University
	 * Get all subscribed tutors of a group
	 * @param int $group_id
	 * @return array An array with information of all users from the given group.
	 *               (user_id, firstname, lastname, email)
	 */
	function get_subscribed_tutors($group_id,$id_only=false)
	{
		$table_user = Database :: get_main_table(TABLE_MAIN_USER);
		$table_group_tutor = Database :: get_course_table(TABLE_GROUP_TUTOR);
		$sql = "SELECT `tg`.`id`, `u`.`user_id`, `u`.`lastname`, `u`.`firstname`, `u`.`email`
					FROM ".$table_user." u, ".$table_group_tutor." tg
					WHERE `tg`.`group_id`='".$group_id."'
					AND `tg`.`user_id`=`u`.`user_id`
					ORDER BY UPPER(`u`.`lastname`), UPPER(`u`.`firstname`)";
		$db_result = api_sql_query($sql,__FILE__,__LINE__);
		$users = array ();
		while ($user = mysql_fetch_object($db_result))
		{
			if ($id_only==false)
			{
				$member['user_id'] = $user->user_id;
				$member['firstname'] = $user->firstname;
				$member['lastname'] = $user->lastname;
				$member['email'] = $user->email;
				$users[] = $member;
			}
			else
			{
				$users[]=$user->user_id;
			}
		}
		return $users;
	}
	/**
	 * Subscribe user(s) to a specified group in current course
	 * @param mixed $user_ids Can be an array with user-id's or a single user-id
	 * @param int $group_id
	 * @return bool TRUE if successfull
	 */
	function subscribe_users($user_ids, $group_id)
	{
		$user_ids = is_array($user_ids) ? $user_ids : array ($user_ids);
		$result = true;
		foreach ($user_ids as $index => $user_id)
		{
			$table_group_user = Database :: get_course_table(TABLE_GROUP_USER);
			$sql = "INSERT INTO ".$table_group_user." (user_id, group_id) VALUES ('".$user_id."', '".$group_id."')";
			$result &= api_sql_query($sql,__FILE__,__LINE__);
		}
		return $result;
	}

	/**
	 * Subscribe tutor(s) to a specified group in current course
	 * @param mixed $user_ids Can be an array with user-id's or a single user-id
	 * @param int $group_id
	 * @author Patrick Cool <[e-mail]>, Ghent University
	 * @see subscribe_users. This function is almost an exact copy of that function.
	 * @return bool TRUE if successfull
	 */
	function subscribe_tutors($user_ids, $group_id)
	{
		$user_ids = is_array($user_ids) ? $user_ids : array ($user_ids);
		$result = true;
		foreach ($user_ids as $index => $user_id)
		{
			$table_group_tutor = Database :: get_course_table(TABLE_GROUP_TUTOR);
			$sql = "INSERT INTO ".$table_group_tutor." (user_id, group_id) VALUES ('".$user_id."', '".$group_id."')";
			$result &= api_sql_query($sql,__FILE__,__LINE__);
		}
		return $result;
	}

	/**
	 * Unsubscribe user(s) from a specified group in current course
	 * @param mixed $user_ids Can be an array with user-id's or a single user-id
	 * @param int $group_id
	 * @return bool TRUE if successfull
	 */
	function unsubscribe_users($user_ids, $group_id)
	{
		$user_ids = is_array($user_ids) ? $user_ids : array ($user_ids);
		$table_group_user = Database :: get_course_table(TABLE_GROUP_USER);
		$result &= api_sql_query('DELETE FROM '.$table_group_user.' WHERE group_id = '.$group_id.' AND user_id IN ('.implode(',', $user_ids).')');
	}
	/**
	 * Unsubscribe all users from one or more groups
	 * @param mixed $group_id Can be an array with group-id's or a single group-id
	 * @return bool TRUE if successfull
	 */
	function unsubscribe_all_users($group_ids)
	{
		$group_ids = is_array($group_ids) ? $group_ids : array ($group_ids);
		if( count($group_ids) > 0)
		{
			$table_group_user = Database :: get_course_table(TABLE_GROUP_USER);
			$sql = 'DELETE FROM '.$table_group_user.' WHERE group_id IN ('.implode(',', $group_ids).')';
			$result = api_sql_query($sql,__FILE__,__LINE__);
			return $result;
		}
		return true;