Merge branch 'MDL-70476_310' of https://github.com/timhunt/moodle into MOODLE_310_STABLE
[moodle.git] / grade / export / 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->dirroot.'/lib/gradelib.php');
19 require_once($CFG->dirroot.'/grade/lib.php');
20 require_once($CFG->dirroot.'/grade/export/grade_export_form.php');
22 /**
23  * Base export class
24  */
25 abstract class grade_export {
27     public $plugin; // plgin name - must be filled in subclasses!
29     public $grade_items; // list of all course grade items
30     public $groupid;     // groupid, 0 means all groups
31     public $course;      // course object
32     public $columns;     // array of grade_items selected for export
34     public $export_letters;  // export letters
35     public $export_feedback; // export feedback
36     public $userkey;         // export using private user key
38     public $updatedgradesonly; // only export updated grades
40     /**
41      *  Grade display type (real, percentages or letter).
42      *
43      *  This attribute is an integer for XML file export. Otherwise is an array for all other formats (ODS, XLS and TXT).
44      *
45      *  @var $displaytype Grade display type constant (1, 2 or 3) or an array of display types where the key is the name
46      *                    and the value is the grade display type constant or 0 for unchecked display types.
47      * @access public.
48      */
49     public $displaytype;
50     public $decimalpoints; // number of decimal points for exports
51     public $onlyactive; // only include users with an active enrolment
52     public $usercustomfields; // include users custom fields
54     /**
55      * @deprecated since Moodle 2.8
56      * @var $previewrows Number of rows in preview.
57      */
58     public $previewrows;
60     /**
61      * Constructor should set up all the private variables ready to be pulled.
62      *
63      * This constructor used to accept the individual parameters as separate arguments, in
64      * 2.8 this was simplified to just accept the data from the moodle form.
65      *
66      * @access public
67      * @param object $course
68      * @param int $groupid
69      * @param stdClass|null $formdata
70      * @note Exporting as letters will lead to data loss if that exported set it re-imported.
71      */
72     public function __construct($course, $groupid, $formdata) {
73         if (func_num_args() != 3 || ($formdata != null && get_class($formdata) != "stdClass")) {
74             $args = func_get_args();
75             return call_user_func_array(array($this, "deprecated_constructor"), $args);
76         }
77         $this->course = $course;
78         $this->groupid = $groupid;
80         $this->grade_items = grade_item::fetch_all(array('courseid'=>$this->course->id));
82         $this->process_form($formdata);
83     }
85     /**
86      * Old deprecated constructor.
87      *
88      * This deprecated constructor accepts the individual parameters as separate arguments, in
89      * 2.8 this was simplified to just accept the data from the moodle form.
90      *
91      * @deprecated since 2.8 MDL-46548. Instead call the shortened constructor which accepts the data
92      * directly from the grade_export_form.
93      */
94     protected function deprecated_constructor($course,
95                                               $groupid=0,
96                                               $itemlist='',
97                                               $export_feedback=false,
98                                               $updatedgradesonly = false,
99                                               $displaytype = GRADE_DISPLAY_TYPE_REAL,
100                                               $decimalpoints = 2,
101                                               $onlyactive = false,
102                                               $usercustomfields = false) {
104         debugging('Many argument constructor for class "grade_export" is deprecated. Call the 3 argument version instead.', DEBUG_DEVELOPER);
106         $this->course = $course;
107         $this->groupid = $groupid;
109         $this->grade_items = grade_item::fetch_all(array('courseid'=>$this->course->id));
110         //Populating the columns here is required by /grade/export/(whatever)/export.php
111         //however index.php, when the form is submitted, will construct the collection here
112         //with an empty $itemlist then reconstruct it in process_form() using $formdata
113         $this->columns = array();
114         if (!empty($itemlist)) {
115             if ($itemlist=='-1') {
116                 //user deselected all items
117             } else {
118                 $itemids = explode(',', $itemlist);
119                 // remove items that are not requested
120                 foreach ($itemids as $itemid) {
121                     if (array_key_exists($itemid, $this->grade_items)) {
122                         $this->columns[$itemid] =& $this->grade_items[$itemid];
123                     }
124                 }
125             }
126         } else {
127             foreach ($this->grade_items as $itemid=>$unused) {
128                 $this->columns[$itemid] =& $this->grade_items[$itemid];
129             }
130         }
132         $this->export_feedback = $export_feedback;
133         $this->userkey         = '';
134         $this->previewrows     = false;
135         $this->updatedgradesonly = $updatedgradesonly;
137         $this->displaytype = $displaytype;
138         $this->decimalpoints = $decimalpoints;
139         $this->onlyactive = $onlyactive;
140         $this->usercustomfields = $usercustomfields;
141     }
143     /**
144      * Init object based using data from form
145      * @param object $formdata
146      */
147     function process_form($formdata) {
148         global $USER;
150         $this->columns = array();
151         if (!empty($formdata->itemids)) {
152             if ($formdata->itemids=='-1') {
153                 //user deselected all items
154             } else {
155                 foreach ($formdata->itemids as $itemid=>$selected) {
156                     if ($selected and array_key_exists($itemid, $this->grade_items)) {
157                         $this->columns[$itemid] =& $this->grade_items[$itemid];
158                     }
159                 }
160             }
161         } else {
162             foreach ($this->grade_items as $itemid=>$unused) {
163                 $this->columns[$itemid] =& $this->grade_items[$itemid];
164             }
165         }
167         if (isset($formdata->key)) {
168             if ($formdata->key == 1 && isset($formdata->iprestriction) && isset($formdata->validuntil)) {
169                 // Create a new key
170                 $formdata->key = create_user_key('grade/export', $USER->id, $this->course->id, $formdata->iprestriction, $formdata->validuntil);
171             }
172             $this->userkey = $formdata->key;
173         }
175         if (isset($formdata->decimals)) {
176             $this->decimalpoints = $formdata->decimals;
177         }
179         if (isset($formdata->export_letters)) {
180             $this->export_letters = $formdata->export_letters;
181         }
183         if (isset($formdata->export_feedback)) {
184             $this->export_feedback = $formdata->export_feedback;
185         }
187         if (isset($formdata->export_onlyactive)) {
188             $this->onlyactive = $formdata->export_onlyactive;
189         }
191         if (isset($formdata->previewrows)) {
192             $this->previewrows = $formdata->previewrows;
193         }
195         if (isset($formdata->display)) {
196             $this->displaytype = $formdata->display;
198             // Used by grade exports which accept multiple display types.
199             // If the checkbox value is 0 (unchecked) then remove it.
200             if (is_array($formdata->display)) {
201                 $this->displaytype = array_filter($formdata->display);
202             }
203         }
205         if (isset($formdata->updatedgradesonly)) {
206             $this->updatedgradesonly = $formdata->updatedgradesonly;
207         }
208     }
210     /**
211      * Update exported field in grade_grades table
212      * @return boolean
213      */
214     public function track_exports() {
215         global $CFG;
217         /// Whether this plugin is entitled to update export time
218         if ($expplugins = explode(",", $CFG->gradeexport)) {
219             if (in_array($this->plugin, $expplugins)) {
220                 return true;
221             } else {
222                 return false;
223           }
224         } else {
225             return false;
226         }
227     }
229     /**
230      * Returns string representation of final grade
231      * @param object $grade instance of grade_grade class
232      * @param integer $gradedisplayconst grade display type constant.
233      * @return string
234      */
235     public function format_grade($grade, $gradedisplayconst = null) {
236         $displaytype = $this->displaytype;
237         if (is_array($this->displaytype) && !is_null($gradedisplayconst)) {
238             $displaytype = $gradedisplayconst;
239         }
241         $gradeitem = $this->grade_items[$grade->itemid];
243         // We are going to store the min and max so that we can "reset" the grade_item for later.
244         $grademax = $gradeitem->grademax;
245         $grademin = $gradeitem->grademin;
247         // Updating grade_item with this grade_grades min and max.
248         $gradeitem->grademax = $grade->get_grade_max();
249         $gradeitem->grademin = $grade->get_grade_min();
251         $formattedgrade = grade_format_gradevalue($grade->finalgrade, $gradeitem, false, $displaytype, $this->decimalpoints);
253         // Resetting the grade item in case it is reused.
254         $gradeitem->grademax = $grademax;
255         $gradeitem->grademin = $grademin;
257         return $formattedgrade;
258     }
260     /**
261      * Returns the name of column in export
262      * @param object $grade_item
263      * @param boolean $feedback feedback colum
264      * @param string $gradedisplayname grade display name.
265      * @return string
266      */
267     public function format_column_name($grade_item, $feedback=false, $gradedisplayname = null) {
268         $column = new stdClass();
270         if ($grade_item->itemtype == 'mod') {
271             $column->name = get_string('modulename', $grade_item->itemmodule).get_string('labelsep', 'langconfig').$grade_item->get_name();
272         } else {
273             $column->name = $grade_item->get_name(true);
274         }
276         // We can't have feedback and display type at the same time.
277         $column->extra = ($feedback) ? get_string('feedback') : get_string($gradedisplayname, 'grades');
279         return html_to_text(get_string('gradeexportcolumntype', 'grades', $column), 0, false);
280     }
282     /**
283      * Returns formatted grade feedback
284      * @param object $feedback object with properties feedback and feedbackformat
285      * @param object $grade Grade object with grade properties
286      * @return string
287      */
288     public function format_feedback($feedback, $grade = null) {
289         $string = $feedback->feedback;
290         if (!empty($grade)) {
291             // Rewrite links to get the export working for 36, refer MDL-63488.
292             $string = file_rewrite_pluginfile_urls(
293                 $feedback->feedback,
294                 'pluginfile.php',
295                 $grade->get_context()->id,
296                 GRADE_FILE_COMPONENT,
297                 GRADE_FEEDBACK_FILEAREA,
298                 $grade->id
299             );
300         }
302         return strip_tags(format_text($string, $feedback->feedbackformat));
303     }
305     /**
306      * Implemented by child class
307      */
308     public abstract function print_grades();
310     /**
311      * Prints preview of exported grades on screen as a feedback mechanism
312      * @param bool $require_user_idnumber true means skip users without idnumber
313      * @deprecated since 2.8 MDL-46548. Previews are not useful on export.
314      */
315     public function display_preview($require_user_idnumber=false) {
316         global $OUTPUT;
318         debugging('function grade_export::display_preview is deprecated.', DEBUG_DEVELOPER);
320         $userprofilefields = grade_helper::get_user_profile_fields($this->course->id, $this->usercustomfields);
321         $formatoptions = new stdClass();
322         $formatoptions->para = false;
324         echo $OUTPUT->heading(get_string('previewrows', 'grades'));
326         echo '<table>';
327         echo '<tr>';
328         foreach ($userprofilefields as $field) {
329             echo '<th>' . $field->fullname . '</th>';
330         }
331         if (!$this->onlyactive) {
332             echo '<th>'.get_string("suspended")."</th>";
333         }
334         foreach ($this->columns as $grade_item) {
335             echo '<th>'.$this->format_column_name($grade_item).'</th>';
337             /// add a column_feedback column
338             if ($this->export_feedback) {
339                 echo '<th>'.$this->format_column_name($grade_item, true).'</th>';
340             }
341         }
342         echo '</tr>';
343         /// Print all the lines of data.
344         $i = 0;
345         $gui = new graded_users_iterator($this->course, $this->columns, $this->groupid);
346         $gui->require_active_enrolment($this->onlyactive);
347         $gui->allow_user_custom_fields($this->usercustomfields);
348         $gui->init();
349         while ($userdata = $gui->next_user()) {
350             // number of preview rows
351             if ($this->previewrows and $this->previewrows <= $i) {
352                 break;
353             }
354             $user = $userdata->user;
355             if ($require_user_idnumber and empty($user->idnumber)) {
356                 // some exports require user idnumber so we can match up students when importing the data
357                 continue;
358             }
360             $gradeupdated = false; // if no grade is update at all for this user, do not display this row
361             $rowstr = '';
362             foreach ($this->columns as $itemid=>$unused) {
363                 $gradetxt = $this->format_grade($userdata->grades[$itemid]);
365                 // get the status of this grade, and put it through track to get the status
366                 $g = new grade_export_update_buffer();
367                 $grade_grade = new grade_grade(array('itemid'=>$itemid, 'userid'=>$user->id));
368                 $status = $g->track($grade_grade);
370                 if ($this->updatedgradesonly && ($status == 'nochange' || $status == 'unknown')) {
371                     $rowstr .= '<td>'.get_string('unchangedgrade', 'grades').'</td>';
372                 } else {
373                     $rowstr .= "<td>$gradetxt</td>";
374                     $gradeupdated = true;
375                 }
377                 if ($this->export_feedback) {
378                     $rowstr .=  '<td>'.$this->format_feedback($userdata->feedbacks[$itemid]).'</td>';
379                 }
380             }
382             // if we are requesting updated grades only, we are not interested in this user at all
383             if (!$gradeupdated && $this->updatedgradesonly) {
384                 continue;
385             }
387             echo '<tr>';
388             foreach ($userprofilefields as $field) {
389                 $fieldvalue = grade_helper::get_user_field_value($user, $field);
390                 // @see profile_field_base::display_data().
391                 echo '<td>' . format_text($fieldvalue, FORMAT_MOODLE, $formatoptions) . '</td>';
392             }
393             if (!$this->onlyactive) {
394                 $issuspended = ($user->suspendedenrolment) ? get_string('yes') : '';
395                 echo "<td>$issuspended</td>";
396             }
397             echo $rowstr;
398             echo "</tr>";
400             $i++; // increment the counter
401         }
402         echo '</table>';
403         $gui->close();
404     }
406     /**
407      * Returns array of parameters used by dump.php and export.php.
408      * @return array
409      */
410     public function get_export_params() {
411         $itemids = array_keys($this->columns);
412         $itemidsparam = implode(',', $itemids);
413         if (empty($itemidsparam)) {
414             $itemidsparam = '-1';
415         }
417         // We have a single grade display type constant.
418         if (!is_array($this->displaytype)) {
419             $displaytypes = $this->displaytype;
420         } else {
421             // Implode the grade display types array as moodle_url function doesn't accept arrays.
422             $displaytypes = implode(',', $this->displaytype);
423         }
425         if (!empty($this->updatedgradesonly)) {
426             $updatedgradesonly = $this->updatedgradesonly;
427         } else {
428             $updatedgradesonly = 0;
429         }
430         $params = array('id'                => $this->course->id,
431                         'groupid'           => $this->groupid,
432                         'itemids'           => $itemidsparam,
433                         'export_letters'    => $this->export_letters,
434                         'export_feedback'   => $this->export_feedback,
435                         'updatedgradesonly' => $updatedgradesonly,
436                         'decimalpoints'     => $this->decimalpoints,
437                         'export_onlyactive' => $this->onlyactive,
438                         'usercustomfields'  => $this->usercustomfields,
439                         'displaytype'       => $displaytypes,
440                         'key'               => $this->userkey);
442         return $params;
443     }
445     /**
446      * Either prints a "Export" box, which will redirect the user to the download page,
447      * or prints the URL for the published data.
448      *
449      * @deprecated since 2.8 MDL-46548. Call get_export_url and set the
450      *             action of the grade_export_form instead.
451      * @return void
452      */
453     public function print_continue() {
454         global $CFG, $OUTPUT;
456         debugging('function grade_export::print_continue is deprecated.', DEBUG_DEVELOPER);
457         $params = $this->get_export_params();
459         echo $OUTPUT->heading(get_string('export', 'grades'));
461         echo $OUTPUT->container_start('gradeexportlink');
463         if (!$this->userkey) {
464             // This button should trigger a download prompt.
465             $url = new moodle_url('/grade/export/'.$this->plugin.'/export.php', $params);
466             echo $OUTPUT->single_button($url, get_string('download', 'admin'));
468         } else {
469             $paramstr = '';
470             $sep = '?';
471             foreach($params as $name=>$value) {
472                 $paramstr .= $sep.$name.'='.$value;
473                 $sep = '&';
474             }
476             $link = $CFG->wwwroot.'/grade/export/'.$this->plugin.'/dump.php'.$paramstr.'&key='.$this->userkey;
478             echo get_string('download', 'admin').': ' . html_writer::link($link, $link);
479         }
480         echo $OUTPUT->container_end();
482         return;
483     }
485     /**
486      * Generate the export url.
487      *
488      * Get submitted form data and create the url to be used on the grade publish feature.
489      *
490      * @return moodle_url the url of grade publishing export.
491      */
492     public function get_export_url() {
493         return new moodle_url('/grade/export/'.$this->plugin.'/dump.php', $this->get_export_params());
494     }
496     /**
497      * Convert the grade display types parameter into the required array to grade exporting class.
498      *
499      * In order to export, the array key must be the display type name and the value must be the grade display type
500      * constant.
501      *
502      * Note: Added support for combined display types constants like the (GRADE_DISPLAY_TYPE_PERCENTAGE_REAL) as
503      *       the $CFG->grade_export_displaytype config is still used on 2.7 in case of missing displaytype url param.
504      *       In these cases, the file will be exported with a column for each display type.
505      *
506      * @param string $displaytypes can be a single or multiple display type constants comma separated.
507      * @return array $types
508      */
509     public static function convert_flat_displaytypes_to_array($displaytypes) {
510         $types = array();
512         // We have a single grade display type constant.
513         if (is_int($displaytypes)) {
514             $displaytype = clean_param($displaytypes, PARAM_INT);
516             // Let's set a default value, will be replaced below by the grade display type constant.
517             $display[$displaytype] = 1;
518         } else {
519             // Multiple grade display types constants.
520             $display = array_flip(explode(',', $displaytypes));
521         }
523         // Now, create the array in the required format by grade exporting class.
524         foreach ($display as $type => $value) {
525             $type = clean_param($type, PARAM_INT);
526             if ($type == GRADE_DISPLAY_TYPE_LETTER) {
527                 $types['letter'] = GRADE_DISPLAY_TYPE_LETTER;
528             } else if ($type == GRADE_DISPLAY_TYPE_PERCENTAGE) {
529                 $types['percentage'] = GRADE_DISPLAY_TYPE_PERCENTAGE;
530             } else if ($type == GRADE_DISPLAY_TYPE_REAL) {
531                 $types['real'] = GRADE_DISPLAY_TYPE_REAL;
532             } else if ($type == GRADE_DISPLAY_TYPE_REAL_PERCENTAGE) {
533                 $types['real'] = GRADE_DISPLAY_TYPE_REAL;
534                 $types['percentage'] = GRADE_DISPLAY_TYPE_PERCENTAGE;
535             } else if ($type == GRADE_DISPLAY_TYPE_REAL_LETTER) {
536                 $types['real'] = GRADE_DISPLAY_TYPE_REAL;
537                 $types['letter'] = GRADE_DISPLAY_TYPE_LETTER;
538             } else if ($type == GRADE_DISPLAY_TYPE_LETTER_REAL) {
539                 $types['letter'] = GRADE_DISPLAY_TYPE_LETTER;
540                 $types['real'] = GRADE_DISPLAY_TYPE_REAL;
541             } else if ($type == GRADE_DISPLAY_TYPE_LETTER_PERCENTAGE) {
542                 $types['letter'] = GRADE_DISPLAY_TYPE_LETTER;
543                 $types['percentage'] = GRADE_DISPLAY_TYPE_PERCENTAGE;
544             } else if ($type == GRADE_DISPLAY_TYPE_PERCENTAGE_LETTER) {
545                 $types['percentage'] = GRADE_DISPLAY_TYPE_PERCENTAGE;
546                 $types['letter'] = GRADE_DISPLAY_TYPE_LETTER;
547             } else if ($type == GRADE_DISPLAY_TYPE_PERCENTAGE_REAL) {
548                 $types['percentage'] = GRADE_DISPLAY_TYPE_PERCENTAGE;
549                 $types['real'] = GRADE_DISPLAY_TYPE_REAL;
550             }
551         }
552         return $types;
553     }
555     /**
556      * Convert the item ids parameter into the required array to grade exporting class.
557      *
558      * In order to export, the array key must be the grade item id and all values must be one.
559      *
560      * @param string $itemids can be a single item id or many item ids comma separated.
561      * @return array $items correctly formatted array.
562      */
563     public static function convert_flat_itemids_to_array($itemids) {
564         $items = array();
566         // We just have one single item id.
567         if (is_int($itemids)) {
568             $itemid = clean_param($itemids, PARAM_INT);
569             $items[$itemid] = 1;
570         } else {
571             // Few grade items.
572             $items = array_flip(explode(',', $itemids));
573             foreach ($items as $itemid => $value) {
574                 $itemid = clean_param($itemid, PARAM_INT);
575                 $items[$itemid] = 1;
576             }
577         }
578         return $items;
579     }
581     /**
582      * Create the html code of the grade publishing feature.
583      *
584      * @return string $output html code of the grade publishing.
585      */
586     public function get_grade_publishing_url() {
587         $url = $this->get_export_url();
588         $output =  html_writer::start_div();
589         $output .= html_writer::tag('p', get_string('gradepublishinglink', 'grades', html_writer::link($url, $url)));
590         $output .=  html_writer::end_div();
591         return $output;
592     }
594     /**
595      * Create a stdClass object from URL parameters to be used by grade_export class.
596      *
597      * @param int $id course id.
598      * @param string $itemids grade items comma separated.
599      * @param bool $exportfeedback export feedback option.
600      * @param bool $onlyactive only enrolled active students.
601      * @param string $displaytype grade display type constants comma separated.
602      * @param int $decimalpoints grade decimal points.
603      * @param null $updatedgradesonly recently updated grades only (Used by XML exporting only).
604      * @param null $separator separator character: tab, comma, colon and semicolon (Used by TXT exporting only).
605      *
606      * @return stdClass $formdata
607      */
608     public static function export_bulk_export_data($id, $itemids, $exportfeedback, $onlyactive, $displaytype,
609                                                    $decimalpoints, $updatedgradesonly = null, $separator = null) {
611         $formdata = new \stdClass();
612         $formdata->id = $id;
613         $formdata->itemids = self::convert_flat_itemids_to_array($itemids);
614         $formdata->exportfeedback = $exportfeedback;
615         $formdata->export_onlyactive = $onlyactive;
616         $formdata->display = self::convert_flat_displaytypes_to_array($displaytype);
617         $formdata->decimals = $decimalpoints;
619         if (!empty($updatedgradesonly)) {
620             $formdata->updatedgradesonly = $updatedgradesonly;
621         }
623         if (!empty($separator)) {
624             $formdata->separator = $separator;
625         }
627         return $formdata;
628     }
631 /**
632  * This class is used to update the exported field in grade_grades.
633  * It does internal buffering to speedup the db operations.
634  */
635 class grade_export_update_buffer {
636     public $update_list;
637     public $export_time;
639     /**
640      * Constructor - creates the buffer and initialises the time stamp
641      */
642     public function __construct() {
643         $this->update_list = array();
644         $this->export_time = time();
645     }
647     /**
648      * Old syntax of class constructor. Deprecated in PHP7.
649      *
650      * @deprecated since Moodle 3.1
651      */
652     public function grade_export_update_buffer() {
653         debugging('Use of class name as constructor is deprecated', DEBUG_DEVELOPER);
654         self::__construct();
655     }
657     public function flush($buffersize) {
658         global $CFG, $DB;
660         if (count($this->update_list) > $buffersize) {
661             list($usql, $params) = $DB->get_in_or_equal($this->update_list);
662             $params = array_merge(array($this->export_time), $params);
664             $sql = "UPDATE {grade_grades} SET exported = ? WHERE id $usql";
665             $DB->execute($sql, $params);
666             $this->update_list = array();
667         }
668     }
670     /**
671      * Track grade export status
672      * @param object $grade_grade
673      * @return string $status (unknow, new, regrade, nochange)
674      */
675     public function track($grade_grade) {
677         if (empty($grade_grade->exported) or empty($grade_grade->timemodified)) {
678             if (is_null($grade_grade->finalgrade)) {
679                 // grade does not exist yet
680                 $status = 'unknown';
681             } else {
682                 $status = 'new';
683                 $this->update_list[] = $grade_grade->id;
684             }
686         } else if ($grade_grade->exported < $grade_grade->timemodified) {
687             $status = 'regrade';
688             $this->update_list[] = $grade_grade->id;
690         } else if ($grade_grade->exported >= $grade_grade->timemodified) {
691             $status = 'nochange';
693         } else {
694             // something is wrong?
695             $status = 'unknown';
696         }
698         $this->flush(100);
700         return $status;
701     }
703     /**
704      * Flush and close the buffer.
705      */
706     public function close() {
707         $this->flush(0);
708     }
711 /**
712  * Verify that there is a valid set of grades to export.
713  * @param $courseid int The course being exported
714  */
715 function export_verify_grades($courseid) {
716     if (grade_needs_regrade_final_grades($courseid)) {
717         throw new moodle_exception('gradesneedregrading', 'grades');
718     }