admin/tool/recyclebin/classes/category_bin.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /**
  18  * The main interface for recycle bin methods.
  19  *
  20  * @package    tool_recyclebin
  21  * @copyright  2015 University of Kent
  22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23  */
  24
  25 namespace tool_recyclebin;
  26
  27 defined('MOODLE_INTERNAL') || die();
  28
  29 define('TOOL_RECYCLEBIN_COURSECAT_BIN_FILEAREA', 'recyclebin_coursecat');
  30
  31 /**
  32  * Represents a category's recyclebin.
  33  *
  34  * @package    tool_recyclebin
  35  * @copyright  2015 University of Kent
  36  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  37  */
  38 class category_bin extends base_bin {
  39
  40     /**
  41      * @var int The category id.
  42      */
  43     protected $_categoryid;
  44
  45     /**
  46      * Constructor.
  47      *
  48      * @param int $categoryid The category id.
  49      */
  50     public function __construct($categoryid) {
  51         $this->_categoryid = $categoryid;
  52     }
  53
  54     /**
  55      * Is this recyclebin enabled?
  56      *
  57      * @return bool true if enabled, false if not.
  58      */
  59     public static function is_enabled() {
  60         return get_config('tool_recyclebin', 'categorybinenable');
  61     }
  62
  63     /**
  64      * Returns an item from the recycle bin.
  65      *
  66      * @param int $itemid Item ID to retrieve.
  67      * @return \stdClass the item.
  68      */
  69     public function get_item($itemid) {
  70         global $DB;
  71
  72         $item = $DB->get_record('tool_recyclebin_category', array(
  73             'id' => $itemid
  74         ), '*', MUST_EXIST);
  75
  76         $item->name = get_course_display_name_for_list($item);
  77
  78         return $item;
  79     }
  80
  81     /**
  82      * Returns a list of items in the recycle bin for this course.
  83      *
  84      * @return array the list of items.
  85      */
  86     public function get_items() {
  87         global $DB;
  88
  89         $items = $DB->get_records('tool_recyclebin_category', array(
  90             'categoryid' => $this->_categoryid
  91         ));
  92
  93         foreach ($items as $item) {
  94             $item->name = get_course_display_name_for_list($item);
  95         }
  96
  97         return $items;
  98     }
  99
 100     /**
 101      * Store a course in the recycle bin.
 102      *
 103      * @param \stdClass $course Course
 104      * @throws \moodle_exception
 105      */
 106     public function store_item($course) {
 107         global $CFG, $DB;
 108
 109         require_once($CFG->dirroot . '/backup/util/includes/backup_includes.php');
 110
 111         // Backup the course.
 112         $user = get_admin();
 113         $controller = new \backup_controller(
 114             \backup::TYPE_1COURSE,
 115             $course->id,
 116             \backup::FORMAT_MOODLE,
 117             \backup::INTERACTIVE_NO,
 118             \backup::MODE_GENERAL,
 119             $user->id
 120         );
 121         $controller->execute_plan();
 122
 123         // Grab the result.
 124         $result = $controller->get_results();
 125         if (!isset($result['backup_destination'])) {
 126             throw new \moodle_exception('Failed to backup activity prior to deletion.');
 127         }
 128
 129         // Have finished with the controller, let's destroy it, freeing mem and resources.
 130         $controller->destroy();
 131
 132         // Grab the filename.
 133         $file = $result['backup_destination'];
 134         if (!$file->get_contenthash()) {
 135             throw new \moodle_exception('Failed to backup activity prior to deletion (invalid file).');
 136         }
 137
 138         // Record the activity, get an ID.
 139         $item = new \stdClass();
 140         $item->categoryid = $course->category;
 141         $item->shortname = $course->shortname;
 142         $item->fullname = $course->fullname;
 143         $item->timecreated = time();
 144         $binid = $DB->insert_record('tool_recyclebin_category', $item);
 145
 146         // Create the location we want to copy this file to.
 147         $filerecord = array(
 148             'contextid' => \context_coursecat::instance($course->category)->id,
 149             'component' => 'tool_recyclebin',
 150             'filearea' => TOOL_RECYCLEBIN_COURSECAT_BIN_FILEAREA,
 151             'itemid' => $binid,
 152             'timemodified' => time()
 153         );
 154
 155         // Move the file to our own special little place.
 156         $fs = get_file_storage();
 157         if (!$fs->create_file_from_storedfile($filerecord, $file)) {
 158             // Failed, cleanup first.
 159             $DB->delete_records('tool_recyclebin_category', array(
 160                 'id' => $binid
 161             ));
 162
 163             throw new \moodle_exception("Failed to copy backup file to recyclebin.");
 164         }
 165
 166         // Delete the old file.
 167         $file->delete();
 168
 169         // Fire event.
 170         $event = \tool_recyclebin\event\category_bin_item_created::create(array(
 171             'objectid' => $binid,
 172             'context' => \context_coursecat::instance($course->category)
 173         ));
 174         $event->trigger();
 175     }
 176
 177     /**
 178      * Restore an item from the recycle bin.
 179      *
 180      * @param \stdClass $item The item database record
 181      * @throws \moodle_exception
 182      */
 183     public function restore_item($item) {
 184         global $CFG, $OUTPUT, $PAGE;
 185
 186         require_once($CFG->dirroot . '/backup/util/includes/restore_includes.php');
 187         require_once($CFG->dirroot . '/course/lib.php');
 188
 189         $user = get_admin();
 190
 191         // Grab the course category context.
 192         $context = \context_coursecat::instance($this->_categoryid);
 193
 194         // Get the backup file.
 195         $fs = get_file_storage();
 196         $files = $fs->get_area_files($context->id, 'tool_recyclebin', TOOL_RECYCLEBIN_COURSECAT_BIN_FILEAREA, $item->id,
 197             'itemid, filepath, filename', false);
 198
 199         if (empty($files)) {
 200             throw new \moodle_exception('Invalid recycle bin item!');
 201         }
 202
 203         if (count($files) > 1) {
 204             throw new \moodle_exception('Too many files found!');
 205         }
 206
 207         // Get the backup file.
 208         $file = reset($files);
 209
 210         // Get a temp directory name and create it.
 211         $tempdir = \restore_controller::get_tempdir_name($context->id, $user->id);
 212         $fulltempdir = make_temp_directory('/backup/' . $tempdir);
 213
 214         // Extract the backup to tmpdir.
 215         $fb = get_file_packer('application/vnd.moodle.backup');
 216         $fb->extract_to_pathname($file, $fulltempdir);
 217
 218         // Build a course.
 219         $course = new \stdClass();
 220         $course->category = $this->_categoryid;
 221         $course->shortname = $item->shortname;
 222         $course->fullname = $item->fullname;
 223         $course->summary = '';
 224
 225         // Create a new course.
 226         $course = create_course($course);
 227         if (!$course) {
 228             throw new \moodle_exception("Could not create course to restore into.");
 229         }
 230
 231         // Define the import.
 232         $controller = new \restore_controller(
 233             $tempdir,
 234             $course->id,
 235             \backup::INTERACTIVE_NO,
 236             \backup::MODE_GENERAL,
 237             $user->id,
 238             \backup::TARGET_NEW_COURSE
 239         );
 240
 241         // Prechecks.
 242         if (!$controller->execute_precheck()) {
 243             $results = $controller->get_precheck_results();
 244
 245             // Check if errors have been found.
 246             if (!empty($results['errors'])) {
 247                 // Delete the temporary file we created.
 248                 fulldelete($fulltempdir);
 249
 250                 // Delete the course we created.
 251                 delete_course($course, false);
 252
 253                 echo $OUTPUT->header();
 254                 $backuprenderer = $PAGE->get_renderer('core', 'backup');
 255                 echo $backuprenderer->precheck_notices($results);
 256                 echo $OUTPUT->continue_button(new \moodle_url('/course/index.php', array('categoryid' => $this->_categoryid)));
 257                 echo $OUTPUT->footer();
 258                 exit();
 259             }
 260         }
 261
 262         // Run the import.
 263         $controller->execute_plan();
 264
 265         // Have finished with the controller, let's destroy it, freeing mem and resources.
 266         $controller->destroy();
 267
 268         // Fire event.
 269         $event = \tool_recyclebin\event\category_bin_item_restored::create(array(
 270             'objectid' => $item->id,
 271             'context' => $context
 272         ));
 273         $event->add_record_snapshot('tool_recyclebin_category', $item);
 274         $event->trigger();
 275
 276         // Cleanup.
 277         fulldelete($fulltempdir);
 278         $this->delete_item($item);
 279     }
 280
 281     /**
 282      * Delete an item from the recycle bin.
 283      *
 284      * @param \stdClass $item The item database record
 285      * @throws \coding_exception
 286      */
 287     public function delete_item($item) {
 288         global $DB;
 289
 290         // Grab the course category context.
 291         $context = \context_coursecat::instance($this->_categoryid);
 292
 293         // Delete the files.
 294         $fs = get_file_storage();
 295         $files = $fs->get_area_files($context->id, 'tool_recyclebin', TOOL_RECYCLEBIN_COURSECAT_BIN_FILEAREA, $item->id);
 296         foreach ($files as $file) {
 297             $file->delete();
 298         }
 299
 300         // Delete the record.
 301         $DB->delete_records('tool_recyclebin_category', array(
 302             'id' => $item->id
 303         ));
 304
 305         // Fire event.
 306         $event = \tool_recyclebin\event\category_bin_item_deleted::create(array(
 307             'objectid' => $item->id,
 308             'context' => \context_coursecat::instance($item->categoryid)
 309         ));
 310         $event->add_record_snapshot('tool_recyclebin_category', $item);
 311         $event->trigger();
 312     }
 313
 314     /**
 315      * Can we view items in this recycle bin?
 316      *
 317      * @return bool returns true if they can view, false if not
 318      */
 319     public function can_view() {
 320         $context = \context_coursecat::instance($this->_categoryid);
 321         return has_capability('tool/recyclebin:viewitems', $context);
 322     }
 323
 324     /**
 325      * Can we restore items in this recycle bin?
 326      *
 327      * @return bool returns true if they can restore, false if not
 328      */
 329     public function can_restore() {
 330         $context = \context_coursecat::instance($this->_categoryid);
 331         return has_capability('tool/recyclebin:restoreitems', $context);
 332     }
 333
 334     /**
 335      * Can we delete items in this recycle bin?
 336      *
 337      * @return bool returns true if they can delete, false if not
 338      */
 339     public function can_delete() {
 340         $context = \context_coursecat::instance($this->_categoryid);
 341         return has_capability('tool/recyclebin:deleteitems', $context);
 342     }
 343 }