82a792d3911ea5e53f515c85d9ca1b0c0f5dd84b
[moodle.git] / grade / import / lib.php
1 <?php
3 // This file is part of Moodle - http://moodle.org/
4 //
5 // Moodle is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // Moodle is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
18 require_once($CFG->libdir.'/gradelib.php');
20 /**
21  * Returns new improtcode for current user
22  * @return int importcode
23  */
24 function get_new_importcode() {
25     global $USER, $DB;
27     $importcode = time();
28     while ($DB->get_record('grade_import_values', array('importcode' => $importcode, 'importer' => $USER->id))) {
29         $importcode--;
30     }
32     return $importcode;
33 }
35 /**
36  * given an import code, commits all entries in buffer tables
37  * (grade_import_value and grade_import_newitem)
38  * If this function is called, we assume that all data collected
39  * up to this point is fine and we can go ahead and commit
40  * @param int courseid - id of the course
41  * @param string importcode - import batch identifier
42  * @param feedback print feedback and continue button
43  * @return bool success
44  */
45 function grade_import_commit($courseid, $importcode, $importfeedback=true, $verbose=true) {
46     global $CFG, $USER, $DB, $OUTPUT;
48     $failed = false;
49     $executionerrors = false;
50     $commitstart = time(); // start time in case we need to roll back
51     $newitemids = array(); // array to hold new grade_item ids from grade_import_newitem table, mapping array
53     /// first select distinct new grade_items with this batch
54     $params = array($importcode, $USER->id);
55     if ($newitems = $DB->get_records_sql("SELECT *
56                                            FROM {grade_import_newitem}
57                                           WHERE importcode = ? AND importer=?", $params)) {
59         // instances of the new grade_items created, cached
60         // in case grade_update fails, so that we can remove them
61         $instances = array();
62         foreach ($newitems as $newitem) {
63             // get all grades with this item
65             $gradeimportparams = array('newgradeitem' => $newitem->id, 'importcode' => $importcode, 'importer' => $USER->id);
66             if ($grades = $DB->get_records('grade_import_values', $gradeimportparams)) {
67                 /// create a new grade item for this - must use false as second param!
68                 /// TODO: we need some bounds here too
69                 $gradeitem = new grade_item(array('courseid'=>$courseid, 'itemtype'=>'manual', 'itemname'=>$newitem->itemname), false);
70                 $gradeitem->insert('import');
71                 $instances[] = $gradeitem;
73                 // insert each individual grade to this new grade item
74                 foreach ($grades as $grade) {
75                     if (!$gradeitem->update_final_grade($grade->userid, $grade->finalgrade, 'import', $grade->feedback, FORMAT_MOODLE)) {
76                         $failed = true;
77                         break 2;
78                     }
79                 }
80             }
81         }
83         if ($failed) {
84             foreach ($instances as $instance) {
85                 $gradeitem->delete('import');
86             }
87             import_cleanup($importcode);
88             return false;
89         }
90     }
92     /// then find all existing items
94     if ($gradeitems = $DB->get_records_sql("SELECT DISTINCT (itemid)
95                                              FROM {grade_import_values}
96                                             WHERE importcode = ? AND importer=? AND itemid > 0",
97                                             array($importcode, $USER->id))) {
99         $modifieditems = array();
101         foreach ($gradeitems as $itemid=>$notused) {
103             if (!$gradeitem = new grade_item(array('id'=>$itemid))) {
104                 // not supposed to happen, but just in case
105                 import_cleanup($importcode);
106                 return false;
107             }
108             // get all grades with this item
109             $gradeimportparams = array('itemid' => $itemid, 'importcode' => $importcode, 'importer' => $USER->id);
110             if ($grades = $DB->get_records('grade_import_values', $gradeimportparams)) {
112                 // make the grades array for update_grade
113                 foreach ($grades as $grade) {
114                     if (!$importfeedback) {
115                         $grade->feedback = false; // ignore it
116                     }
117                     if ($grade->importonlyfeedback) {
118                         // False means do not change. See grade_itme::update_final_grade().
119                         $grade->finalgrade = false;
120                     }
121                     if (!$gradeitem->update_final_grade($grade->userid, $grade->finalgrade, 'import', $grade->feedback)) {
122                         $errordata = new stdClass();
123                         $errordata->itemname = $gradeitem->itemname;
124                         $errordata->userid = $grade->userid;
125                         $executionerrors[] = get_string('errorsettinggrade', 'grades', $errordata);
126                         $failed = true;
127                         break 2;
128                     }
129                 }
130                 //$itemdetails -> idnumber = $gradeitem->idnumber;
131                 $modifieditems[] = $itemid;
133             }
134         }
136         if ($failed) {
137             if ($executionerrors && $verbose) {
138                 echo $OUTPUT->notification(get_string('gradeimportfailed', 'grades'));
139                 foreach ($executionerrors as $errorstr) {
140                     echo $OUTPUT->notification($errorstr);
141                 }
142             }
143             import_cleanup($importcode);
144             return false;
145         }
146     }
148     if ($verbose) {
149         echo $OUTPUT->notification(get_string('importsuccess', 'grades'), 'notifysuccess');
150         $unenrolledusers = get_unenrolled_users_in_import($importcode, $courseid);
151         if ($unenrolledusers) {
152             $list = array();
153             foreach ($unenrolledusers as $u) {
154                 $u->fullname = fullname($u);
155                 $list[] = get_string('usergrade', 'grades', $u);
156             }
157             echo $OUTPUT->notification(get_string('unenrolledusersinimport', 'grades', html_writer::alist($list)), 'notifysuccess');
158         }
159         echo $OUTPUT->continue_button($CFG->wwwroot.'/grade/index.php?id='.$courseid);
160     }
161     // clean up
162     import_cleanup($importcode);
164     return true;
167 /**
168  * This function returns an array of grades that were included in the import,
169  * but where the user does not currently have a graded role on the course. These grades
170  * are still stored in the database, but will not be visible in the gradebook unless
171  * this user subsequently enrols on the course in a graded roles.
172  *
173  * The returned objects have fields user firstname, lastname and useridnumber, and gradeidnumber.
174  *
175  * @param integer $importcode import batch identifier
176  * @param integer $courseid the course we are importing to.
177  * @return mixed and array of user objects, or false if none.
178  */
179 function get_unenrolled_users_in_import($importcode, $courseid) {
180     global $CFG, $DB;
182     $coursecontext = context_course::instance($courseid);
184     // We want to query both the current context and parent contexts.
185     list($relatedctxsql, $relatedctxparams) = $DB->get_in_or_equal($coursecontext->get_parent_context_ids(true), SQL_PARAMS_NAMED, 'relatedctx');
187     // Users with a gradeable role.
188     list($gradebookrolessql, $gradebookrolesparams) = $DB->get_in_or_equal(explode(',', $CFG->gradebookroles), SQL_PARAMS_NAMED, 'grbr');
190     // Enrolled users.
191     $context = context_course::instance($courseid);
192     list($enrolledsql, $enrolledparams) = get_enrolled_sql($context);
193     list($sort, $sortparams) = users_order_by_sql('u');
195     $sql = "SELECT giv.id, u.firstname, u.lastname, u.idnumber AS useridnumber,
196                    COALESCE(gi.idnumber, gin.itemname) AS gradeidnumber
197               FROM {grade_import_values} giv
198               JOIN {user} u
199                    ON giv.userid = u.id
200               LEFT JOIN {grade_items} gi
201                         ON gi.id = giv.itemid
202               LEFT JOIN {grade_import_newitem} gin
203                         ON gin.id = giv.newgradeitem
204               LEFT JOIN ($enrolledsql) je
205                         ON je.id = u.id
206               LEFT JOIN {role_assignments} ra
207                         ON (giv.userid = ra.userid AND ra.roleid $gradebookrolessql AND ra.contextid $relatedctxsql)
208              WHERE giv.importcode = :importcode
209                    AND (ra.id IS NULL OR je.id IS NULL)
210           ORDER BY gradeidnumber, $sort";
211     $params = array_merge($gradebookrolesparams, $enrolledparams, $sortparams, $relatedctxparams);
212     $params['importcode'] = $importcode;
214     return $DB->get_records_sql($sql, $params);
217 /**
218  * removes entries from grade import buffer tables grade_import_value and grade_import_newitem
219  * after a successful import, or during an import abort
220  * @param string importcode - import batch identifier
221  */
222 function import_cleanup($importcode) {
223     global $USER, $DB;
225     // remove entries from buffer table
226     $DB->delete_records('grade_import_values', array('importcode' => $importcode, 'importer' => $USER->id));
227     $DB->delete_records('grade_import_newitem', array('importcode' => $importcode, 'importer' => $USER->id));