Merge branch 'MDL-32941' of git://github.com/mouneyrac/moodle
authorEloy Lafuente (stronk7) <stronk7@moodle.org>
Thu, 17 May 2012 20:35:57 +0000 (22:35 +0200)
committerEloy Lafuente (stronk7) <stronk7@moodle.org>
Thu, 17 May 2012 20:35:57 +0000 (22:35 +0200)
Conflicts:
course/externallib.php
lib/db/services.php
version.php

1  2 
course/externallib.php
course/lib.php
lang/en/error.php
lib/db/services.php
version.php

@@@ -248,6 -248,298 +248,298 @@@ class core_course_external extends exte
          );
      }
  
 -     * @since Moodle 2.2
+     /**
+      * Returns description of method parameters
+      *
+      * @return external_function_parameters
++     * @since Moodle 2.3
+      */
+     public static function get_categories_parameters() {
+         return new external_function_parameters(
+             array(
+                 'criteria' => new external_multiple_structure(
+                     new external_single_structure(
+                         array(
+                             'key' => new external_value(PARAM_ALPHA,
+                                          'The category column to search, expected keys (value format) are:'.
+                                          '"id" (int) the category id,'.
+                                          '"name" (string) the category name,'.
+                                          '"parent" (int) the parent category id,'.
+                                          '"idnumber" (string) category idnumber'.
+                                          ' - user must have \'moodle/category:manage\' to search on idnumber,'.
+                                          '"visible" (int) whether the category is visible or not'.
+                                          ' - user must have \'moodle/category:manage\' or \'moodle/category:viewhiddencategories\' to search on visible,'.
+                                          '"theme" (string) category theme'.
+                                          ' - user must have \'moodle/category:manage\' to search on theme'),
+                             'value' => new external_value(PARAM_RAW, 'the value to match')
+                         )
+                     ), VALUE_DEFAULT, array()
+                 ),
+                 'addsubcategories' => new external_value(PARAM_BOOL, 'return the sub categories infos
+                                           (1 - default) otherwise only the category info (0)', VALUE_DEFAULT, 1)
+             )
+         );
+     }
+     /**
+      * Get categories
+      *
+      * @param array $criteria Criteria to match the results
+      * @param booln $addsubcategories obtain only the category (false) or its subcategories (true - default)
+      * @return array list of categories
+      * @since Moodle 2.3
+      */
+     public static function get_categories($criteria = array(), $addsubcategories = true) {
+         global $CFG, $DB;
+         require_once($CFG->dirroot . "/course/lib.php");
+         // Validate parameters.
+         $params = self::validate_parameters(self::get_categories_parameters(),
+                 array('criteria' => $criteria, 'addsubcategories' => $addsubcategories));
+         // Retrieve the categories.
+         $categories = array();
+         if (!empty($params['criteria'])) {
+             $conditions = array();
+             $wheres = array();
+             foreach ($params['criteria'] as $crit) {
+                 $key = trim($crit['key']);
+                 // Trying to avoid duplicate keys.
+                 if (!isset($conditions[$key])) {
+                     $context = context_system::instance();
+                     $value = null;
+                     switch ($key) {
+                         case 'id':
+                             $value = clean_param($crit['value'], PARAM_INT);
+                             break;
+                         case 'idnumber':
+                             if (has_capability('moodle/category:manage', $context)) {
+                                 $value = clean_param($crit['value'], PARAM_RAW);
+                             } else {
+                                 // We must throw an exception.
+                                 // Otherwise the dev client would think no idnumber exists.
+                                 throw new moodle_exception('criteriaerror',
+                                         'webservice', '', null,
+                                         'You don\'t have the permissions to search on the "idnumber" field.');
+                             }
+                             break;
+                         case 'name':
+                             $value = clean_param($crit['value'], PARAM_TEXT);
+                             break;
+                         case 'parent':
+                             $value = clean_param($crit['value'], PARAM_INT);
+                             break;
+                         case 'visible':
+                             if (has_capability('moodle/category:manage', $context)
+                                 or has_capability('moodle/category:viewhiddencategories',
+                                         context_system::instance())) {
+                                 $value = clean_param($crit['value'], PARAM_INT);
+                             } else {
+                                 throw new moodle_exception('criteriaerror',
+                                         'webservice', '', null,
+                                         'You don\'t have the permissions to search on the "visible" field.');
+                             }
+                             break;
+                         case 'theme':
+                             if (has_capability('moodle/category:manage', $context)) {
+                                 $value = clean_param($crit['value'], PARAM_THEME);
+                             } else {
+                                 throw new moodle_exception('criteriaerror',
+                                         'webservice', '', null,
+                                         'You don\'t have the permissions to search on the "theme" field.');
+                             }
+                             break;
+                         default:
+                             throw new moodle_exception('criteriaerror',
+                                     'webservice', '', null,
+                                     'You can not search on this criteria: ' . $key);
+                     }
+                     if (isset($value)) {
+                         $conditions[$key] = $crit['value'];
+                         $wheres[] = $key . " = :" . $key;
+                     }
+                 }
+             }
+             if (!empty($wheres)) {
+                 $wheres = implode(" AND ", $wheres);
+                 $categories = $DB->get_records_select('course_categories', $wheres, $conditions);
+                 // Retrieve its sub subcategories (all levels).
+                 if ($categories and !empty($params['addsubcategories'])) {
+                     $newcategories = array();
+                     foreach ($categories as $category) {
+                         $sqllike = $DB->sql_like('path', ':path');
+                         $sqlparams = array('path' => $category->path.'/%'); // It will NOT include the specified category.
+                         $subcategories = $DB->get_records_select('course_categories', $sqllike, $sqlparams);
+                         $newcategories = $newcategories + $subcategories;   // Both arrays have integer as keys.
+                     }
+                     $categories = $categories + $newcategories;
+                 }
+             }
+         } else {
+             // Retrieve all categories in the database.
+             $categories = $DB->get_records('course_categories');
+         }
+         // The not returned categories. key => category id, value => reason of exclusion.
+         $excludedcats = array();
+         // The returned categories.
+         $categoriesinfo = array();
+         // We need to sort the categories by path.
+         // The parent cats need to be checked by the algo first.
+         usort($categories, "core_course_external::compare_categories_by_path");
+         foreach ($categories as $category) {
+             // Check if the category is a child of an excluded category, if yes exclude it too (excluded => do not return).
+             $parents = explode('/', $category->path);
+             unset($parents[0]); // First key is always empty because path start with / => /1/2/4.
+             foreach ($parents as $parentid) {
+                 // Note: when the parent exclusion was due to the context,
+                 // the sub category could still be returned.
+                 if (isset($excludedcats[$parentid]) and $excludedcats[$parentid] != 'context') {
+                     $excludedcats[$category->id] = 'parent';
+                 }
+             }
+             // Check category depth is <= maxdepth (do not check for user who can manage categories).
+             if ((!empty($CFG->maxcategorydepth) && count($parents) > $CFG->maxcategorydepth)
+                     and !has_capability('moodle/category:manage', $context)) {
+                 $excludedcats[$category->id] = 'depth';
+             }
+             // Check the user can use the category context.
+             $context = context_coursecat::instance($category->id);
+             try {
+                 self::validate_context($context);
+             } catch (Exception $e) {
+                 $excludedcats[$category->id] = 'context';
+                 // If it was the requested category then throw an exception.
+                 if (isset($params['categoryid']) && $category->id == $params['categoryid']) {
+                     $exceptionparam = new stdClass();
+                     $exceptionparam->message = $e->getMessage();
+                     $exceptionparam->catid = $category->id;
+                     throw new moodle_exception('errorcatcontextnotvalid', 'webservice', '', $exceptionparam);
+                 }
+             }
+             // Return the category information.
+             if (!isset($excludedcats[$category->id])) {
+                 // Final check to see if the category is visible to the user.
+                 if ($category->visible
+                         or has_capability('moodle/category:viewhiddencategories', context_system::instance())
+                         or has_capability('moodle/category:manage', $context)) {
+                     $categoryinfo = array();
+                     $categoryinfo['id'] = $category->id;
+                     $categoryinfo['name'] = $category->name;
+                     $categoryinfo['description'] = file_rewrite_pluginfile_urls($category->description,
+                             'webservice/pluginfile.php', $context->id, 'coursecat', 'description', null);
+                     $options = new stdClass;
+                     $options->noclean = true;
+                     $options->para = false;
+                     $categoryinfo['description'] = format_text($categoryinfo['description'],
+                             $category->descriptionformat, $options);
+                     $categoryinfo['parent'] = $category->parent;
+                     $categoryinfo['sortorder'] = $category->sortorder;
+                     $categoryinfo['coursecount'] = $category->coursecount;
+                     $categoryinfo['depth'] = $category->depth;
+                     $categoryinfo['path'] = $category->path;
+                     // Some fields only returned for admin.
+                     if (has_capability('moodle/category:manage', $context)) {
+                         $categoryinfo['idnumber'] = $category->idnumber;
+                         $categoryinfo['visible'] = $category->visible;
+                         $categoryinfo['visibleold'] = $category->visibleold;
+                         $categoryinfo['timemodified'] = $category->timemodified;
+                         $categoryinfo['theme'] = $category->theme;
+                     }
+                     $categoriesinfo[] = $categoryinfo;
+                 } else {
+                     $excludedcats[$category->id] = 'visibility';
+                 }
+             }
+         }
+         // Sorting the resulting array so it looks a bit better for the client developer.
+         usort($categoriesinfo, "core_course_external::compare_categories_by_sortorder");
+         return $categoriesinfo;
+     }
+     /**
+      * Sort categories array by path
+      * private function: only used by get_categories
+      *
+      * @param array $category1
+      * @param array $category2
+      * @return int result of strcmp
+      * @since Moodle 2.3
+      */
+     private static function compare_categories_by_path($category1, $category2) {
+         return strcmp($category1->path, $category2->path);
+     }
+     /**
+      * Sort categories array by sortorder
+      * private function: only used by get_categories
+      *
+      * @param array $category1
+      * @param array $category2
+      * @return int result of strcmp
+      * @since Moodle 2.3
+      */
+     private static function compare_categories_by_sortorder($category1, $category2) {
+         return strcmp($category1['sortorder'], $category2['sortorder']);
+     }
+     /**
+      * Returns description of method result value
+      *
+      * @return external_description
+      * @since Moodle 2.3
+      */
+     public static function get_categories_returns() {
+         return new external_multiple_structure(
+             new external_single_structure(
+                 array(
+                     'id' => new external_value(PARAM_INT, 'category id'),
+                     'name' => new external_value(PARAM_TEXT, 'category name'),
+                     'idnumber' => new external_value(PARAM_RAW, 'category id number', VALUE_OPTIONAL),
+                     'description' => new external_value(PARAM_RAW, 'category description'),
+                     'parent' => new external_value(PARAM_INT, 'parent category id'),
+                     'sortorder' => new external_value(PARAM_INT, 'category sorting order'),
+                     'coursecount' => new external_value(PARAM_INT, 'number of courses in this category'),
+                     'visible' => new external_value(PARAM_INT, '1: available, 0:not available', VALUE_OPTIONAL),
+                     'visibleold' => new external_value(PARAM_INT, '1: available, 0:not available', VALUE_OPTIONAL),
+                     'timemodified' => new external_value(PARAM_INT, 'timestamp', VALUE_OPTIONAL),
+                     'depth' => new external_value(PARAM_INT, 'category depth'),
+                     'path' => new external_value(PARAM_TEXT, 'category path'),
+                     'theme' => new external_value(PARAM_THEME, 'category theme', VALUE_OPTIONAL),
+                 ), 'List of categories'
+             )
+         );
+     }
      /**
       * Returns description of method parameters
       *
          return null;
      }
  
 +    /**
 +     * Returns description of method parameters
 +     *
 +     * @return external_function_parameters
 +     * @since Moodle 2.3
 +     */
 +    public static function duplicate_course_parameters() {
 +        return new external_function_parameters(
 +            array(
 +                'courseid' => new external_value(PARAM_INT, 'course to duplicate id'),
 +                'fullname' => new external_value(PARAM_TEXT, 'duplicated course full name'),
 +                'shortname' => new external_value(PARAM_TEXT, 'duplicated course short name'),
 +                'categoryid' => new external_value(PARAM_INT, 'duplicated course category parent'),
 +                'visible' => new external_value(PARAM_INT, 'duplicated course visible, default to yes', VALUE_DEFAULT, 1),
 +                'options' => new external_multiple_structure(
 +                    new external_single_structure(
 +                        array(
 +                                'name' => new external_value(PARAM_ALPHA, 'The backup option name:
 +                                            "activities" (int) Include course activites (default to 1 that is equal to yes),
 +                                            "blocks" (int) Include course blocks (default to 1 that is equal to yes),
 +                                            "filters" (int) Include course filters  (default to 1 that is equal to yes),
 +                                            "users" (int) Include users (default to 0 that is equal to no),
 +                                            "role_assignments" (int) Include role assignments  (default to 0 that is equal to no),
 +                                            "user_files" (int) Include user files  (default to 0 that is equal to no),
 +                                            "comments" (int) Include user comments  (default to 0 that is equal to no),
 +                                            "completion_information" (int) Include user course completion information  (default to 0 that is equal to no),
 +                                            "logs" (int) Include course logs  (default to 0 that is equal to no),
 +                                            "histories" (int) Include histories  (default to 0 that is equal to no)'
 +                                            ),
 +                                'value' => new external_value(PARAM_RAW, 'the value for the option 1 (yes) or 0 (no)'
 +                            )
 +                        )
 +                    ), VALUE_DEFAULT, array()
 +                ),
 +            )
 +        );
 +    }
 +
 +    /**
 +     * Duplicate a course
 +     *
 +     * @param int $courseid
 +     * @param string $fullname Duplicated course fullname
 +     * @param string $shortname Duplicated course shortname
 +     * @param int $categoryid Duplicated course parent category id
 +     * @param int $visible Duplicated course availability
 +     * @param array $options List of backup options
 +     * @return array New course info
 +     * @since Moodle 2.3
 +     */
 +    public static function duplicate_course($courseid, $fullname, $shortname, $categoryid, $visible, $options) {
 +        global $CFG, $USER, $DB;
 +        require_once($CFG->dirroot . '/backup/util/includes/backup_includes.php');
 +        require_once($CFG->dirroot . '/backup/util/includes/restore_includes.php');
 +
 +        // Parameter validation.
 +        $params = self::validate_parameters(
 +                self::duplicate_course_parameters(),
 +                array(
 +                      'courseid' => $courseid,
 +                      'fullname' => $fullname,
 +                      'shortname' => $shortname,
 +                      'categoryid' => $categoryid,
 +                      'visible' => $visible,
 +                      'options' => $options
 +                )
 +        );
 +
 +        // Context validation.
 +
 +        if (! ($course = $DB->get_record('course', array('id'=>$params['courseid'])))) {
 +            throw new moodle_exception('invalidcourseid', 'error', '', $params['courseid']);
 +        }
 +
 +        // Category where duplicated course is going to be created.
 +        $categorycontext = context_coursecat::instance($params['categoryid']);
 +        self::validate_context($categorycontext);
 +
 +        // Course to be duplicated.
 +        $coursecontext = context_course::instance($course->id);
 +        self::validate_context($coursecontext);
 +
 +        $backupdefaults = array(
 +            'activities' => 1,
 +            'blocks' => 1,
 +            'filters' => 1,
 +            'users' => 0,
 +            'role_assignments' => 0,
 +            'user_files' => 0,
 +            'comments' => 0,
 +            'completion_information' => 0,
 +            'logs' => 0,
 +            'histories' => 0
 +        );
 +
 +        $backupsettings = array();
 +        // Check for backup and restore options.
 +        if (!empty($params['options'])) {
 +            foreach ($params['options'] as $option) {
 +
 +                // Strict check for a correct value (allways 1 or 0, true or false).
 +                $value = clean_param($option['value'], PARAM_INT);
 +
 +                if ($value !== 0 and $value !== 1) {
 +                    throw new moodle_exception('invalidextparam', 'webservice', '', $option['name']);
 +                }
 +
 +                if (!isset($backupdefaults[$option['name']])) {
 +                    throw new moodle_exception('invalidextparam', 'webservice', '', $option['name']);
 +                }
 +
 +                $backupsettings[$option['name']] = $value;
 +            }
 +        }
 +
 +        // Capability checking.
 +
 +        // The backup controller check for this currently, this may be redundant.
 +        require_capability('moodle/course:create', $categorycontext);
 +        require_capability('moodle/restore:restorecourse', $categorycontext);
 +        require_capability('moodle/backup:backupcourse', $coursecontext);
 +
 +        if (!empty($backupsettings['users'])) {
 +            require_capability('moodle/backup:userinfo', $coursecontext);
 +            require_capability('moodle/restore:userinfo', $categorycontext);
 +        }
 +
 +        // Check if the shortname is used.
 +        if ($foundcourses = $DB->get_records('course', array('shortname'=>$shortname))) {
 +            foreach ($foundcourses as $foundcourse) {
 +                $foundcoursenames[] = $foundcourse->fullname;
 +            }
 +
 +            $foundcoursenamestring = implode(',', $foundcoursenames);
 +            throw new moodle_exception('shortnametaken', '', '', $foundcoursenamestring);
 +        }
 +
 +        // Backup the course.
 +
 +        $bc = new backup_controller(backup::TYPE_1COURSE, $course->id, backup::FORMAT_MOODLE,
 +        backup::INTERACTIVE_NO, backup::MODE_SAMESITE, $USER->id);
 +
 +        foreach ($backupsettings as $name => $value) {
 +            $bc->get_plan()->get_setting($name)->set_value($value);
 +        }
 +
 +        $backupid       = $bc->get_backupid();
 +        $backupbasepath = $bc->get_plan()->get_basepath();
 +
 +        $bc->execute_plan();
 +        $results = $bc->get_results();
 +        $file = $results['backup_destination'];
 +
 +        $bc->destroy();
 +
 +        // Restore the backup immediately.
 +
 +        // Check if we need to unzip the file because the backup temp dir does not contains backup files.
 +        if (!file_exists($backupbasepath . "/moodle_backup.xml")) {
 +            $file->extract_to_pathname(get_file_packer(), $backupbasepath);
 +        }
 +
 +        // Create new course.
 +        $newcourseid = restore_dbops::create_new_course($params['fullname'], $params['shortname'], $params['categoryid']);
 +
 +        $rc = new restore_controller($backupid, $newcourseid,
 +                backup::INTERACTIVE_NO, backup::MODE_SAMESITE, $USER->id, backup::TARGET_NEW_COURSE);
 +
 +        foreach ($backupsettings as $name => $value) {
 +            $setting = $rc->get_plan()->get_setting($name);
 +            if ($setting->get_status() == backup_setting::NOT_LOCKED) {
 +                $setting->set_value($value);
 +            }
 +        }
 +
 +        if (!$rc->execute_precheck()) {
 +            $precheckresults = $rc->get_precheck_results();
 +            if (is_array($precheckresults) && !empty($precheckresults['errors'])) {
 +                if (empty($CFG->keeptempdirectoriesonbackup)) {
 +                    fulldelete($backupbasepath);
 +                }
 +
 +                $errorinfo = '';
 +
 +                foreach ($precheckresults['errors'] as $error) {
 +                    $errorinfo .= $error;
 +                }
 +
 +                if (array_key_exists('warnings', $precheckresults)) {
 +                    foreach ($precheckresults['warnings'] as $warning) {
 +                        $errorinfo .= $warning;
 +                    }
 +                }
 +
 +                throw new moodle_exception('backupprecheckerrors', 'webservice', '', $errorinfo);
 +            }
 +        }
 +
 +        $rc->execute_plan();
 +        $rc->destroy();
 +
 +        $course = $DB->get_record('course', array('id' => $newcourseid), '*', MUST_EXIST);
 +        $course->fullname = $params['fullname'];
 +        $course->shortname = $params['shortname'];
 +        $course->visible = $params['visible'];
 +
 +        // Set shortname and fullname back.
 +        $DB->update_record('course', $course);
 +
 +        if (empty($CFG->keeptempdirectoriesonbackup)) {
 +            fulldelete($backupbasepath);
 +        }
 +
 +        // Delete the course backup file created by this WebService. Originally located in the course backups area.
 +        $file->delete();
 +
 +        return array('id' => $course->id, 'shortname' => $course->shortname);
 +    }
 +
 +    /**
 +     * Returns description of method result value
 +     *
 +     * @return external_description
 +     * @since Moodle 2.3
 +     */
 +    public static function duplicate_course_returns() {
 +        return new external_single_structure(
 +            array(
 +                'id'       => new external_value(PARAM_INT, 'course id'),
 +                'shortname' => new external_value(PARAM_TEXT, 'short name'),
 +            )
 +        );
 +    }
 +
+     /**
+      * Returns description of method parameters
+      * @return external_function_parameters
+      * @since Moodle 2.3
+      */
+     public static function delete_categories_parameters() {
+         return new external_function_parameters(
+             array(
+                 'categories' => new external_multiple_structure(
+                     new external_single_structure(
+                         array(
+                             'id' => new external_value(PARAM_INT, 'category id to delete'),
+                             'newparent' => new external_value(PARAM_INT,
+                                 'the parent category to move the contents to, if specified', VALUE_OPTIONAL),
+                             'recursive' => new external_value(PARAM_BOOL, '1: recursively delete all contents inside this
+                                 category, 0 (default): move contents to newparent or current parent category (except if parent is root)', VALUE_DEFAULT, 0)
+                         )
+                     )
+                 )
+             )
+         );
+     }
+     /**
+      * Delete categories
+      * @param array $categories A list of category ids
+      * @return array
+      * @since Moodle 2.3
+      */
+     public static function delete_categories($categories) {
+         global $CFG, $DB;
+         require_once($CFG->dirroot . "/course/lib.php");
+         // Validate parameters.
+         $params = self::validate_parameters(self::delete_categories_parameters(), array('categories' => $categories));
+         foreach ($params['categories'] as $category) {
+             if (!$deletecat = $DB->get_record('course_categories', array('id' => $category['id']))) {
+                 throw new moodle_exception('unknowcategory');
+             }
+             $context = context_coursecat::instance($deletecat->id);
+             require_capability('moodle/category:manage', $context);
+             self::validate_context($context);
+             self::validate_context(get_category_or_system_context($deletecat->parent));
+             if ($category['recursive']) {
+                 // If recursive was specified, then we recursively delete the category's contents.
+                 category_delete_full($deletecat, false);
+             } else {
+                 // In this situation, we don't delete the category's contents, we either move it to newparent or parent.
+                 // If the parent is the root, moving is not supported (because a course must always be inside a category).
+                 // We must move to an existing category.
+                 if (!empty($category['newparent'])) {
+                     if (!$DB->record_exists('course_categories', array('id' => $category['newparent']))) {
+                         throw new moodle_exception('unknowcategory');
+                     }
+                     $newparent = $category['newparent'];
+                 } else {
+                     $newparent = $deletecat->parent;
+                 }
+                 // This operation is not allowed. We must move contents to an existing category.
+                 if ($newparent == 0) {
+                     throw new moodle_exception('movecatcontentstoroot');
+                 }
+                 $parentcontext = get_category_or_system_context($newparent);
+                 require_capability('moodle/category:manage', $parentcontext);
+                 self::validate_context($parentcontext);
+                 category_delete_move($deletecat, $newparent, false);
+             }
+         }
+     }
+     /**
+      * Returns description of method parameters
+      * @return external_function_parameters
+      * @since Moodle 2.3
+      */
+     public static function delete_categories_returns() {
+         return null;
+     }
+     /**
+      * Returns description of method parameters
+      * @return external_function_parameters
+      * @since Moodle 2.3
+      */
+     public static function update_categories_parameters() {
+         return new external_function_parameters(
+             array(
+                 'categories' => new external_multiple_structure(
+                     new external_single_structure(
+                         array(
+                             'id'       => new external_value(PARAM_INT, 'course id'),
+                             'name' => new external_value(PARAM_TEXT, 'category name', VALUE_OPTIONAL),
+                             'idnumber' => new external_value(PARAM_RAW, 'category id number', VALUE_OPTIONAL),
+                             'parent' => new external_value(PARAM_INT, 'parent category id', VALUE_OPTIONAL),
+                             'description' => new external_value(PARAM_RAW, 'category description', VALUE_OPTIONAL),
+                             'theme' => new external_value(PARAM_THEME,
+                                     'the category theme. This option must be enabled on moodle', VALUE_OPTIONAL),
+                         )
+                     )
+                 )
+             )
+         );
+     }
+     /**
+      * Update categories
+      * @param array $categories The list of categories to update
+      * @return null
+      * @since Moodle 2.3
+      */
+     public static function update_categories($categories) {
+         global $CFG, $DB;
+         require_once($CFG->dirroot . "/course/lib.php");
+         // Validate parameters.
+         $params = self::validate_parameters(self::update_categories_parameters(), array('categories' => $categories));
+         $transaction = $DB->start_delegated_transaction();
+         foreach ($params['categories'] as $cat) {
+             if (!$category = $DB->get_record('course_categories', array('id' => $cat['id']))) {
+                 throw new moodle_exception('unknowcategory');
+             }
+             $categorycontext = context_coursecat::instance($cat['id']);
+             self::validate_context($categorycontext);
+             require_capability('moodle/category:manage', $categorycontext);
+             if (!empty($cat['name'])) {
+                 if (textlib::strlen($cat['name'])>255) {
+                      throw new moodle_exception('categorytoolong');
+                 }
+                 $category->name = $cat['name'];
+             }
+             if (!empty($cat['idnumber'])) {
+                 if (textlib::strlen($cat['idnumber'])>100) {
+                     throw new moodle_exception('idnumbertoolong');
+                 }
+                 $category->idnumber = $cat['idnumber'];
+             }
+             if (!empty($cat['description'])) {
+                 $category->description = $cat['description'];
+                 $category->descriptionformat = FORMAT_HTML;
+             }
+             if (!empty($cat['theme'])) {
+                 $category->theme = $cat['theme'];
+             }
+             if (!empty($cat['parent']) && ($category->parent != $cat['parent'])) {
+                 // First check if parent exists.
+                 if (!$parent_cat = $DB->get_record('course_categories', array('id' => $cat['parent']))) {
+                     throw new moodle_exception('unknowcategory');
+                 }
+                 // Then check if we have capability.
+                 self::validate_context(get_category_or_system_context((int)$cat['parent']));
+                 require_capability('moodle/category:manage', get_category_or_system_context((int)$cat['parent']));
+                 // Finally move the category.
+                 move_category($category, $parent_cat);
+                 $category->parent = $cat['parent'];
+             }
+             $DB->update_record('course_categories', $category);
+         }
+         $transaction->allow_commit();
+     }
+     /**
+      * Returns description of method result value
+      * @return external_description
+      */
+     public static function update_categories_returns() {
+         return null;
+     }
  }
  
  /**
diff --cc course/lib.php
Simple merge
Simple merge
@@@ -487,15 -449,24 +505,33 @@@ $functions = array
          'capabilities'=> 'moodle/course:delete',
      ),
  
 +    'core_course_duplicate_course' => array(
 +        'classname'   => 'core_course_external',
 +        'methodname'  => 'duplicate_course',
 +        'classpath'   => 'course/externallib.php',
 +        'description' => 'Duplicate an existing course (creating a new one) without user data',
 +        'type'        => 'write',
 +        'capabilities'=> 'moodle/backup:backupcourse,moodle/restore:restorecourse,moodle/course:create',
 +    ),
 +
+     'core_course_create_categories' => array(
+         'classname'   => 'core_course_external',
+         'methodname'  => 'create_categories',
+         'classpath'   => 'course/externallib.php',
+         'description' => 'Create course categories',
+         'type'        => 'write',
+         'capabilities'=> 'moodle/category:manage',
+     ),
+     'core_course_delete_categories' => array(
+         'classname'   => 'core_course_external',
+         'methodname'  => 'delete_categories',
+         'classpath'   => 'course/externallib.php',
+         'description' => 'Delete course categories',
+         'type'        => 'write',
+         'capabilities'=> 'moodle/category:manage',
+     ),
      // === message related functions ===
  
      'moodle_message_send_instantmessages' => array(
diff --cc version.php
@@@ -30,7 -30,7 +30,7 @@@
  defined('MOODLE_INTERNAL') || die();
  
  
- $version  = 2012051700.00;              // YYYYMMDD      = weekly release date of this DEV branch
 -$version  = 2012051100.01;              // YYYYMMDD      = weekly release date of this DEV branch
++$version  = 2012051700.01;              // YYYYMMDD      = weekly release date of this DEV branch
                                          //         RR    = release increments - 00 in DEV branches
                                          //           .XX = incremental changes