WebSVN – Moodle – Diff – /mod/workshop/locallib.php

      * @param stdClass $dbrecord Workshop instance data from {workshop} table
      * @param stdClass|cm_info $cm Course module record
      * @param stdClass $course Course record from {course} table
      * @param stdClass $context The context of the workshop instance
      */
-    public function __construct(stdclass $dbrecord, $cm, $course, stdclass $context=null) {
+    public function __construct(stdclass $dbrecord, $cm, $course, ?stdclass $context=null) {
         $this->dbrecord = $dbrecord;
         foreach ($this->dbrecord as $field => $value) {
             if (property_exists('workshop', $field)) {
                 $this->{$field} = $value;
+            }
      * @param int $limitfrom return a subset of records, starting at this point (optional, required if $limitnum is set)
      * @param int $limitnum return a subset containing this number of records (optional, required if $limitfrom is set)
      * @return array array[userid] => stdClass
      */
     public function get_potential_authors($musthavesubmission=true, $groupid=0, $limitfrom=0, $limitnum=0) {
-        global $DB;
-        list($sql, $params) = $this->get_users_with_capability_sql('mod/workshop:submit', $musthavesubmission, $groupid);
+        return $this->get_users_with_capability(['mod/workshop:submit'], $musthavesubmission, $groupid, $limitfrom, $limitnum);
-        if (empty($sql)) {
-            return array();
-        }
-        list($sort, $sortparams) = users_order_by_sql('tmp');
-        $sql = "SELECT *
-                  FROM ($sql) tmp
-              ORDER BY $sort";
-        return $DB->get_records_sql($sql, array_merge($params, $sortparams), $limitfrom, $limitnum);
+    }
     /**
      * Returns the total number of users that would be fetched by {@link self::get_potential_authors()}
+     *
      * @param bool $musthavesubmission if true, count only users who have already submitted
      * @param int $groupid 0 means ignore groups, any other value limits the result by group id
      * @return int
      */
-    public function count_potential_authors($musthavesubmission=true, $groupid=0) {
-        global $DB;
+    public function count_potential_authors($musthavesubmission=true, $groupid=0) {
-        list($sql, $params) = $this->get_users_with_capability_sql('mod/workshop:submit', $musthavesubmission, $groupid);
-        if (empty($sql)) {
-            return 0;
-        }
-        $sql = "SELECT COUNT(*)
-                  FROM ($sql) tmp";
-        return $DB->count_records_sql($sql, $params);
+        return count($this->get_users_with_capability(['mod/workshop:submit'], $musthavesubmission, $groupid));
+    }
     /**
      * @param int $limitfrom return a subset of records, starting at this point (optional, required if $limitnum is set)
      * @param int $limitnum return a subset containing this number of records (optional, required if $limitfrom is set)
      * @return array array[userid] => stdClass
      */
     public function get_potential_reviewers($musthavesubmission=false, $groupid=0, $limitfrom=0, $limitnum=0) {
-        global $DB;
-        list($sql, $params) = $this->get_users_with_capability_sql('mod/workshop:peerassess', $musthavesubmission, $groupid);
+        return $this->get_users_with_capability(['mod/workshop:peerassess'], $musthavesubmission, $groupid, $limitfrom, $limitnum);
-        if (empty($sql)) {
-            return array();
-        }
-        list($sort, $sortparams) = users_order_by_sql('tmp');
-        $sql = "SELECT *
-                  FROM ($sql) tmp
-              ORDER BY $sort";
-        return $DB->get_records_sql($sql, array_merge($params, $sortparams), $limitfrom, $limitnum);
+    }
     /**
      * Returns the total number of users that would be fetched by {@link self::get_potential_reviewers()}
+     *
      * @param bool $musthavesubmission if true, count only users who have already submitted
      * @param int $groupid 0 means ignore groups, any other value limits the result by group id
      * @return int
      */
-    public function count_potential_reviewers($musthavesubmission=false, $groupid=0) {
-        global $DB;
+    public function count_potential_reviewers($musthavesubmission=false, $groupid=0) {
-        list($sql, $params) = $this->get_users_with_capability_sql('mod/workshop:peerassess', $musthavesubmission, $groupid);
-        if (empty($sql)) {
-            return 0;
-        }
-        $sql = "SELECT COUNT(*)
-                  FROM ($sql) tmp";
         return count($this->get_users_with_capability(['mod/workshop:peerassess'], $musthavesubmission, $groupid));
         return $DB->count_records_sql($sql, $params);
+    }
      * @param int $limitfrom return a subset of records, starting at this point (optional, required if $limitnum is set)
      * @param int $limitnum return a subset containing this number of records (optional, required if $limitfrom is set)
      * @return array array[userid] => stdClass
      */
     public function get_participants($musthavesubmission=false, $groupid=0, $limitfrom=0, $limitnum=0) {
-        global $DB;
-        list($sql, $params) = $this->get_participants_sql($musthavesubmission, $groupid);
-        list($filteringsql, $filteringparams) = $this->get_users_with_initial_filtering_sql_where();
-        $wheresql = "";
-        if ($filteringsql) {
-            $wheresql .= $filteringsql;
-            $params = array_merge($params, $filteringparams);
-        }
-        if (empty($sql)) {
-            return array();
-        }
+        // Get any users who have either of these 2 capabilities on the activity.
-        list($sort, $sortparams) = users_order_by_sql('tmp');
+        return $this->get_users_with_capability(['mod/workshop:submit', 'mod/workshop:peerassess'],
-        $sql = "SELECT * FROM ($sql) tmp";
-        if ($wheresql) {
-            $sql .= " WHERE $wheresql";
-        }
-        $sql .= " ORDER BY $sort";
             $musthavesubmission, $groupid, $limitfrom, $limitnum);
         return $DB->get_records_sql($sql, array_merge($params, $sortparams), $limitfrom, $limitnum);
+    }
     /**
      * Returns the total number of records that would be returned by {@link self::get_participants()}
+     *
      * @param bool $musthavesubmission if true, return only users who have already submitted
      * @param int $groupid 0 means ignore groups, any other value limits the result by group id
-     * @return int
-     */
-    public function count_participants($musthavesubmission=false, $groupid=0) {
+     * @return int
-        global $DB;
-        list($sql, $params) = $this->get_participants_sql($musthavesubmission, $groupid);
-        if (empty($sql)) {
-            return 0;
-        }
-        $sql = "SELECT COUNT(*)
-                  FROM ($sql) tmp";
+     */
     public function count_participants($musthavesubmission=false, $groupid=0) {
-        return $DB->count_records_sql($sql, $params);
+        return count($this->get_participants($musthavesubmission, $groupid));
+    }
     /**
      * Checks if the given user is an actively enrolled participant in the workshop
+     *
+     * @param int $userid, defaults to the current $USER
-     * @param int $userid, defaults to the current $USER
+     * @return boolean
-     * @return boolean
+     */
-     */
+    public function is_participant($userid=null) {
     public function is_participant($userid=null) {
+        global $USER;
-        global $USER, $DB;
+        if (is_null($userid)) {
-        if (is_null($userid)) {
-            $userid = $USER->id;
-        }
-        list($sql, $params) = $this->get_participants_sql();
-        if (empty($sql)) {
-            return false;
-        }
-        $sql = "SELECT COUNT(*)
-                  FROM {user} uxx
-                  JOIN ({$sql}) pxx ON uxx.id = pxx.id
-                 WHERE uxx.id = :uxxid";
-        $params['uxxid'] = $userid;
+            $userid = $USER->id;
+        }
         if ($DB->count_records_sql($sql, $params)) {
-            return true;
+        // Get the participants on this activity and see if the user exists in that array.
+        }
         return $DB->count_records_sql($sql, $params);
+    }
+    /**
+     * Returns the total number of assessments in the workshop.
+     *
+     * @param bool $onlygraded If true, count only graded assessments
+     * @param int|null $groupid If not null, return only assessments by reviewers in the specified group
+     * @return int Number of assessments
+     */
+    public function count_assessments(bool $onlygraded = false, ?int $groupid = null): int {
+        global $DB;
+        $params = ['workshopid' => $this->id];
+        $sql = "SELECT COUNT(s.id)
+                  FROM {workshop_assessments} s
+                  JOIN {workshop_submissions} ws ON (s.submissionid = ws.id)
+                  JOIN {user} u ON (ws.authorid = u.id)
+                  JOIN {workshop} w ON (ws.workshopid = w.id)";
+        if ($groupid) {
+            $sql .= " JOIN {groups_members} gm ON (gm.userid = u.id AND gm.groupid = :groupid)";
+            $params['groupid'] = $groupid;
+        }
+        if ($onlygraded) {
+            $sql .= " WHERE s.grade IS NOT NULL AND w.id = :workshopid";
+        } else {
+            $sql .= " WHERE w.id = :workshopid";
+        }
+        return $DB->count_records_sql($sql, $params);
+    }
     /**
      * @param moodle_url $url absolute url as returned by {@see workshop::submission_url()} and friends
      * @param mixed $info additional info, usually id in a table
      * @param bool $return true to return the arguments for add_to_log.
      * @return void|array array of arguments for add_to_log if $return is true
      */
-    public function log($action, moodle_url $url = null, $info = null, $return = false) {
+    public function log($action, ?moodle_url $url = null, $info = null, $return = false) {
         debugging('The log method is now deprecated, please use event classes instead', DEBUG_DEVELOPER);
         if (is_null($url)) {
             $url = $this->view_url();
+            }
+        }
+    }
     /**
+     * This is a replacement for the old get_users_with_capability_sql method.
+     * The old method returned huge amounts of SQL for large courses, potentially 10s of thousands of lines
+     * with hundreds of UNIONS, which caused some poor performance. This new method aims to streamline it all
-     * Returns SQL to fetch all enrolled users with the given capability in the current workshop
+     * into one query.
-     *
-     * The returned array consists of string $sql and the $params array. Note that the $sql can be
+     *
-     * empty if a grouping is selected and it has no groups.
+     * Gets users with any of the specified capabilities on the workshop activity.
+     *
      * The list is automatically restricted according to any availability restrictions
      * that apply to user lists (e.g. group, grouping restrictions).
      *
-     * @param string $capability the name of the capability
+     * @param array $capabilities array of capability names (If the user has ANY of them, it returns true for that user)
-     * @param bool $musthavesubmission ff true, return only users who have already submitted
+     * @param bool $musthavesubmission if true, return only users who have already submitted
+     * @param int $groupid 0 means ignore groups, any other value limits the result by group id
+     * @param int $limitfrom return a subset of records, starting at this point (optional, required if $limitnum is set)
-     * @param int $groupid 0 means ignore groups, any other value limits the result by group id
+     * @param int $limitnum return a subset containing this number of records (optional, required if $limitfrom is set)
-     * @return array of (string)sql, (array)params
+     * @return array of users
      */
-    protected function get_users_with_capability_sql($capability, $musthavesubmission, $groupid) {
-        global $CFG;
-        /** @var int static counter used to generate unique parameter holders */
-        static $inc = 0;
-        $inc++;
-        // If the caller requests all groups and we are using a selected grouping,
-        // recursively call this function for each group in the grouping (this is
-        // needed because get_enrolled_sql only supports a single group).
-        if (empty($groupid) and $this->cm->groupingid) {
-            $groupingid = $this->cm->groupingid;
-            $groupinggroupids = array_keys(groups_get_all_groups($this->cm->course, 0, $this->cm->groupingid, 'g.id'));
-            $sql = array();
-            $params = array();
-            foreach ($groupinggroupids as $groupinggroupid) {
-                if ($groupinggroupid > 0) { // just in case in order not to fall into the endless loop
-                    list($gsql, $gparams) = $this->get_users_with_capability_sql($capability, $musthavesubmission, $groupinggroupid);
-                    $sql[] = $gsql;
+    protected function get_users_with_capability(array $capabilities, bool $musthavesubmission, int $groupid,
-                    $params = array_merge($params, $gparams);
-                }
-            }
-            $sql = implode(PHP_EOL." UNION ".PHP_EOL, $sql);
-            return array($sql, $params);
-        }
+            int $limitfrom = 0, int $limitnum = 0): array {
-        list($esql, $params) = get_enrolled_sql($this->context, $capability, $groupid, true);
+        global $CFG, $DB;
+        $params = [];
+        // This is from enrollib.php:get_enrolled_join(). It says it's better for caching to use round.
+        $now = round(time(), -2);
-        $userfieldsapi = \core_user\fields::for_userpic();
+        $userfieldsapi = \core_user\fields::for_name()->with_userpic();
+        $sqlarray = [];
-        $userfields = $userfieldsapi->get_sql('u', false, '', '', false)->selects;
+        $sqlarray['select'] = "SELECT DISTINCT u.id" . $userfieldsapi->get_sql('u')->selects;
+        $sqlarray['from'] = "FROM {user} u";
+        $sqlarray['join'] = [];
+        $sqlarray['join'][] = "JOIN {user_enrolments} ue ON ue.userid = u.id";
+        $sqlarray['join'][] = "JOIN {enrol} e ON e.id = ue.enrolid AND e.courseid = :courseid";
+        $sqlarray['where'] = [];
+        $sqlarray['where'][] = "WHERE u.deleted = 0";
+        $sqlarray['where'][] = "AND u.id <> :guestid";
+        $sqlarray['where'][] = "AND ue.status = :activestatus";
+        $sqlarray['where'][] = "AND e.status = :enabledstatus";
+        $sqlarray['where'][] = "AND ue.timestart < :timestart";
+        $sqlarray['where'][] = "AND (ue.timeend > :timeend OR ue.timeend = 0)";
+        // Apply sorting.
+        [$sortby, $sortbyparams] = users_order_by_sql('u');
+        $sqlarray['sort'] = "ORDER BY {$sortby}";
+        // Apply filtering.
+        [$filtersql, $filterparams] = $this->get_users_with_initial_filtering_sql_where('u');
+        if ($filtersql) {
+            $sqlarray['where'][] = "AND {$filtersql}";
+            $params = array_merge($params, $filterparams);
+        }
+        $params['courseid'] = $this->context->get_course_context()->instanceid;
+        $params['timestart'] = $now;
+        $params['timeend'] = $now;
         $params['guestid'] = $CFG->siteguest;
+        $params['activestatus'] = ENROL_USER_ACTIVE;
-        $sql = "SELECT $userfields
+        $params['enabledstatus'] = ENROL_INSTANCE_ENABLED;
-                  FROM {user} u
-                  JOIN ($esql) je ON (je.id = u.id AND u.deleted = 0) ";
+        // If we are filtering by users who have submitted.
+        if ($musthavesubmission) {
+            $sqlarray['join'][] = "JOIN {workshop_submissions} ws ON
+                (ws.authorid = u.id AND ws.example = 0 AND ws.workshopid = :workshopid) ";
+            $params['workshopid'] = $this->id;
+        }
-        if ($musthavesubmission) {
+        // Are we searching one specific group?
+        if ($groupid > 0) {
+            $sqlarray['join'][] = "JOIN {groups_members} gm ON (gm.userid = u.id AND gm.groupid = :groupid)";
+            $params['groupid'] = $groupid;
+        } else if ($this->cm->groupingid) {
+            // If not, is there a groupingid set on the activity?
-            $sql .= " JOIN {workshop_submissions} ws ON (ws.authorid = u.id AND ws.example = 0 AND ws.workshopid = :workshopid{$inc}) ";
+            $sqlarray['join'][] = "JOIN {groupings_groups} gg ON gg.groupingid = :groupingid";
-            $params['workshopid'.$inc] = $this->id;
+            $sqlarray['join'][] = "JOIN {groups_members} gm ON (gm.userid = u.id AND gm.groupid = gg.groupid)";
             $params['groupingid'] = $this->cm->groupingid;
+        }
         // If the activity is restricted so that only certain users should appear
-        // in user lists, integrate this into the same SQL.
+        // Is the activity restricted so only certain users can access it?
+        $info = new \core_availability\info_module($this->cm);
+        [$listsql, $listparams] = $info->get_user_list_sql(false);
+        if ($listsql) {
+            $sqlarray['join'][] = " JOIN ($listsql) restricted ON restricted.id = u.id";
+            $params = array_merge($params, $listparams);
+        }
+        // Join the role assignments to only return users with the right capabilities.
+        $capjoin = get_with_capability_join($this->context, $capabilities, 'u.id');
+        $sqlarray['join'][] = $capjoin->joins;
+        // Convert the sql array into a string.
+        $sql = $this->build_sql($sqlarray);
+        // We actually query the users here instead of returning SQL like it used to.
+        return $DB->get_records_sql($sql, $params, $limitfrom, $limitnum);
+    }
+    /**
+     * Build SQL string from array of clauses
+     *
+     * @param array $sqlarray ['select' => '', 'from' => '', 'join' => [], 'where' => [], 'sort' => '']
+     * @return string
+     */
+    protected function build_sql(array $sqlarray): string {
+        $sql = "";
+        foreach ($sqlarray as $el) {
-        $info = new \core_availability\info_module($this->cm);
+            if (is_array($el)) {
+                $sql .= implode(" ", $el) . " ";
-        list ($listsql, $listparams) = $info->get_user_list_sql(false);
+            } else {
-        if ($listsql) {
+                $sql .= " {$el} ";
             $sql .= " JOIN ($listsql) restricted ON restricted.id = u.id ";
             $params = array_merge($params, $listparams);
         return $sql;
-        return array($sql, $params);
+    }
     /**
-    /**
+     * Returns SQL to fetch all enrolled users with the first name or last name.
      * Returns SQL to fetch all enrolled users with the first name or last name.
      * @param string $table Table alias for users table
      * @return array
      */
-    protected function get_users_with_initial_filtering_sql_where(): array {
+    protected function get_users_with_initial_filtering_sql_where(string $table): array {
         global $DB;
         $conditions = [];
         $params = [];
         $ifirst = $this->get_initial_first();
         $ilast = $this->get_initial_last();
         if ($ifirst) {
-            $conditions[] = $DB->sql_like('LOWER(tmp.firstname)', ':i_first' , false, false);
+            $conditions[] = $DB->sql_like('LOWER(' . $table . '.firstname)', ':i_first' , false, false);
             $params['i_first'] = $DB->sql_like_escape($ifirst) . '%';
-        }
-        if ($ilast) {
-            $conditions[] = $DB->sql_like('LOWER(tmp.lastname)', ':i_last' , false, false);
-            $params['i_last'] = $DB->sql_like_escape($ilast) . '%';
-        }
-        return [implode(" AND ", $conditions), $params];
-    }
-    /**
-     * Returns SQL statement that can be used to fetch all actively enrolled participants in the workshop
-     *
-     * @param bool $musthavesubmission if true, return only users who have already submitted
-     * @param int $groupid 0 means ignore groups, any other value limits the result by group id
-     * @return array of (string)sql, (array)params
-     */
-    protected function get_participants_sql($musthavesubmission=false, $groupid=0) {
-        list($sql1, $params1) = $this->get_users_with_capability_sql('mod/workshop:submit', $musthavesubmission, $groupid);
-        list($sql2, $params2) = $this->get_users_with_capability_sql('mod/workshop:peerassess', $musthavesubmission, $groupid);
-        if (empty($sql1) or empty($sql2)) {
-            if (empty($sql1) and empty($sql2)) {
-                return array('', array());
-            } else if (empty($sql1)) {
-                $sql = $sql2;
-                $params = $params2;
-            } else {
-                $sql = $sql1;
-                $params = $params1;
-            }
         } else {
-            $sql = $sql1.PHP_EOL." UNION ".PHP_EOL.$sql2;
+        if ($ilast) {
-            $params = array_merge($params1, $params2);
+            $conditions[] = $DB->sql_like('LOWER(' . $table . '.lastname)', ':i_last' , false, false);
             $params['i_last'] = $DB->sql_like_escape($ilast) . '%';
+        }

Proyectos de Subversion Moodle

(root)/mod/workshop/locallib.php – Rev 1 → 1441