diff --git a/course/externallib.php b/course/externallib.php
index ec8e627811c..2b09e1f6c39 100644
--- a/course/externallib.php
+++ b/course/externallib.php
@@ -16,11 +16,11 @@
 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
 
 /**
- * External user API
+ * External course API
  *
  * @package    core
  * @subpackage course
- * @copyright  2009 Moodle Pty Ltd (http://moodle.com)
+ * @copyright  2010 Moodle Pty Ltd (http://moodle.com)
  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
 
@@ -30,4 +30,336 @@ require_once("$CFG->libdir/externallib.php");
 
 class moodle_course_external extends external_api {
 
+    /**
+     * Returns description of method parameters
+     * @return external_function_parameters
+     */
+    public static function get_courses_parameters() {
+        return new external_function_parameters(
+                array('options' => new external_single_structure(
+                            array('ids' => new external_multiple_structure(
+                                        new external_value(PARAM_INT, 'Course id')
+                                        , 'List of course id. If empty return all courses
+                                            except front page course.',
+                                        VALUE_OPTIONAL)
+                            ), 'options - operator OR is used', VALUE_DEFAULT, array())
+                )
+        );
+    }
+
+    /**
+     * Get courses
+     * @param array $options
+     * @return array
+     */
+    public static function get_courses($options) {
+        global $CFG, $DB;
+        require_once($CFG->dirroot . "/course/lib.php");
+
+        //validate parameter
+        $params = self::validate_parameters(self::get_courses_parameters(),
+                        array('options' => $options));
+
+        //retrieve courses
+        if (!key_exists('ids', $params['options'])
+                or empty($params['options']['ids'])) {
+            $courses = $DB->get_records('course');
+        } else {
+            $courses = $DB->get_records_list('course', 'id', $params['options']['ids']);
+        }
+
+        //create return value
+        $coursesinfo = array();
+        foreach ($courses as $course) {
+
+            // now security checks
+            $context = get_context_instance(CONTEXT_COURSE, $course->id);
+            try {
+                self::validate_context($context);
+            } catch (Exception $e) {
+                $exceptionparam = new stdClass();
+                $exceptionparam->message = $e->getMessage();
+                $exceptionparam->courseid = $course->id;
+                throw new moodle_exception(
+                        get_string('errorcoursecontextnotvalid', 'webservice', $exceptionparam));
+            }
+            require_capability('moodle/course:view', $context);
+
+            $courseinfo = array();
+            $courseinfo['id'] = $course->id;
+            $courseinfo['fullname'] = $course->fullname;
+            $courseinfo['shortname'] = $course->shortname;
+            $courseinfo['categoryid'] = $course->category;
+            $courseinfo['summary'] = $course->summary;
+            $courseinfo['summaryformat'] = $course->summaryformat;
+            $courseinfo['format'] = $course->format;
+            $courseinfo['startdate'] = $course->startdate;
+            $courseinfo['numsections'] = $course->numsections;
+
+            //some field should be returned only if the user has update permission
+            $courseadmin = has_capability('moodle/course:update', $context);
+            if ($courseadmin) {
+                $courseinfo['categorysortorder'] = $course->sortorder;
+                $courseinfo['idnumber'] = $course->idnumber;
+                $courseinfo['showgrades'] = $course->showgrades;
+                $courseinfo['showreports'] = $course->showreports;
+                $courseinfo['newsitems'] = $course->newsitems;
+                $courseinfo['visible'] = $course->visible;
+                $courseinfo['maxbytes'] = $course->maxbytes;
+                $courseinfo['hiddensections'] = $course->hiddensections;
+                $courseinfo['groupmode'] = $course->groupmode;
+                $courseinfo['groupmodeforce'] = $course->groupmodeforce;
+                $courseinfo['defaultgroupingid'] = $course->defaultgroupingid;
+                $courseinfo['lang'] = $course->lang;
+                $courseinfo['timecreated'] = $course->timecreated;
+                $courseinfo['timemodified'] = $course->timemodified;
+                $courseinfo['forcetheme'] = $course->theme;
+                $courseinfo['enablecompletion'] = $course->enablecompletion;
+                $courseinfo['completionstartonenrol'] = $course->completionstartonenrol;
+                $courseinfo['completionnotify'] = $course->completionnotify;
+            }
+
+            if ($courseadmin or $course->visible
+                    or has_capability('moodle/course:viewhiddencourses', $context)) {
+                $coursesinfo[] = $courseinfo;
+            }
+        }
+
+        return $coursesinfo;
+    }
+
+    /**
+     * Returns description of method result value
+     * @return external_description
+     */
+    public static function get_courses_returns() {
+        return new external_multiple_structure(
+                new external_single_structure(
+                        array(
+                            'id' => new external_value(PARAM_INT, 'course id'),
+                            'shortname' => new external_value(PARAM_TEXT, 'course short name'),
+                            'categoryid' => new external_value(PARAM_INT, 'category id'),
+                            'categorysortorder' => new external_value(PARAM_INT,
+                                    'sort order into the category', VALUE_OPTIONAL),
+                            'fullname' => new external_value(PARAM_TEXT, 'full name'),
+                            'idnumber' => new external_value(PARAM_RAW, 'id number', VALUE_OPTIONAL),
+                            'summary' => new external_value(PARAM_RAW, 'summary'),
+                            'summaryformat' => new external_value(PARAM_INT,
+                                    'the summary text Moodle format'),
+                            'format' => new external_value(PARAM_ALPHANUMEXT,
+                                    'course format: weeks, topics, social, site,..'),
+                            'showgrades' => new external_value(PARAM_INT,
+                                    '1 if grades are shown, otherwise 0', VALUE_OPTIONAL),
+                            'newsitems' => new external_value(PARAM_INT,
+                                    'number of recent items appearing on the course page', VALUE_OPTIONAL),
+                            'startdate' => new external_value(PARAM_INT,
+                                    'timestamp when the course start'),
+                            'numsections' => new external_value(PARAM_INT, 'number of weeks/topics'),
+                            'maxbytes' => new external_value(PARAM_INT,
+                                    'largest size of file that can be uploaded into the course',
+                                    VALUE_OPTIONAL),
+                            'showreports' => new external_value(PARAM_INT,
+                                    'are activity report shown (yes = 1, no =0)', VALUE_OPTIONAL),
+                            'visible' => new external_value(PARAM_INT,
+                                    '1: available to student, 0:not available', VALUE_OPTIONAL),
+                            'hiddensections' => new external_value(PARAM_INT,
+                                    'How the hidden sections in the course are displayed to students',
+                                    VALUE_OPTIONAL),
+                            'groupmode' => new external_value(PARAM_INT, 'no group, separate, visible',
+                                    VALUE_OPTIONAL),
+                            'groupmodeforce' => new external_value(PARAM_INT, '1: yes, 0: no',
+                                    VALUE_OPTIONAL),
+                            'defaultgroupingid' => new external_value(PARAM_INT, 'default grouping id',
+                                    VALUE_OPTIONAL),
+                            'timecreated' => new external_value(PARAM_INT,
+                                    'timestamp when the course have been created', VALUE_OPTIONAL),
+                            'timemodified' => new external_value(PARAM_INT,
+                                    'timestamp when the course have been modified', VALUE_OPTIONAL),
+                            'enablecompletion' => new external_value(PARAM_INT,
+                                    'Enabled, control via completion and activity settings. Disbaled,
+                                        not shown in activity settings.',
+                                    VALUE_OPTIONAL),
+                            'completionstartonenrol' => new external_value(PARAM_INT,
+                                    '1: begin tracking a student\'s progress in course completion
+                                        after course enrolment. 0: does not',
+                                    VALUE_OPTIONAL),
+                            'completionnotify' => new external_value(PARAM_INT,
+                                    '1: yes 0: no', VALUE_OPTIONAL),
+                            'lang' => new external_value(PARAM_ALPHANUMEXT,
+                                    'forced course language', VALUE_OPTIONAL),
+                            'forcetheme' => new external_value(PARAM_ALPHANUMEXT,
+                                    'name of the force theme', VALUE_OPTIONAL),
+                        ), 'course'
+                )
+        );
+    }
+
+    /**
+     * Returns description of method parameters
+     * @return external_function_parameters
+     */
+    public static function create_courses_parameters() {
+        $courseconfig = get_config('moodlecourse'); //needed for many default values
+        return new external_function_parameters(
+            array(
+                'courses' => new external_multiple_structure(
+                    new external_single_structure(
+                        array(
+                            'fullname' => new external_value(PARAM_TEXT, 'full name'),
+                            'shortname' => new external_value(PARAM_TEXT, 'course short name'),
+                            'categoryid' => new external_value(PARAM_INT, 'category id'),
+                            'idnumber' => new external_value(PARAM_RAW, 'id number', VALUE_OPTIONAL),
+                            'summary' => new external_value(PARAM_RAW, 'summary', VALUE_OPTIONAL),
+                            'summaryformat' => new external_value(PARAM_INT,
+                                    'the summary text Moodle format', VALUE_DEFAULT, FORMAT_MOODLE),
+                            'format' => new external_value(PARAM_ALPHANUMEXT,
+                                    'course format: weeks, topics, social, site,..',
+                                    VALUE_DEFAULT, $courseconfig->format),
+                            'showgrades' => new external_value(PARAM_INT,
+                                    '1 if grades are shown, otherwise 0', VALUE_DEFAULT,
+                                    $courseconfig->showgrades),
+                            'newsitems' => new external_value(PARAM_INT,
+                                    'number of recent items appearing on the course page',
+                                    VALUE_DEFAULT, $courseconfig->newsitems),
+                            'startdate' => new external_value(PARAM_INT,
+                                    'timestamp when the course start', VALUE_OPTIONAL),
+                            'numsections' => new external_value(PARAM_INT, 'number of weeks/topics',
+                                    VALUE_DEFAULT, $courseconfig->numsections),
+                            'maxbytes' => new external_value(PARAM_INT,
+                                    'largest size of file that can be uploaded into the course',
+                                    VALUE_DEFAULT, $courseconfig->maxbytes),
+                            'showreports' => new external_value(PARAM_INT,
+                                    'are activity report shown (yes = 1, no =0)', VALUE_DEFAULT,
+                                    $courseconfig->showreports),
+                            'visible' => new external_value(PARAM_INT,
+                                    '1: available to student, 0:not available', VALUE_OPTIONAL),
+                            'hiddensections' => new external_value(PARAM_INT,
+                                    'How the hidden sections in the course are displayed to students',
+                                    VALUE_DEFAULT, $courseconfig->hiddensections),
+                            'groupmode' => new external_value(PARAM_INT, 'no group, separate, visible',
+                                    VALUE_DEFAULT, $courseconfig->groupmode),
+                            'groupmodeforce' => new external_value(PARAM_INT, '1: yes, 0: no',
+                                    VALUE_DEFAULT, $courseconfig->groupmodeforce),
+                            'defaultgroupingid' => new external_value(PARAM_INT, 'default grouping id',
+                                    VALUE_DEFAULT, 0),
+                            'enablecompletion' => new external_value(PARAM_INT,
+                                    'Enabled, control via completion and activity settings. Disbaled,
+                                        not shown in activity settings.',
+                                    VALUE_OPTIONAL),
+                            'completionstartonenrol' => new external_value(PARAM_INT,
+                                    '1: begin tracking a student\'s progress in course completion after
+                                        course enrolment. 0: does not',
+                                    VALUE_OPTIONAL),
+                            'completionnotify' => new external_value(PARAM_INT,
+                                    '1: yes 0: no', VALUE_OPTIONAL),
+                            'lang' => new external_value(PARAM_ALPHANUMEXT,
+                                    'forced course language', VALUE_OPTIONAL),
+                            'forcetheme' => new external_value(PARAM_ALPHANUMEXT,
+                                    'name of the force theme', VALUE_OPTIONAL),
+                        )
+                    ), 'courses to create'
+                )
+            )
+        );
+    }
+
+    /**
+     * Create  courses
+     * @param array $courses
+     * @return array courses (id and shortname only)
+     */
+    public static function create_courses($courses) {
+        global $CFG, $DB;
+        require_once($CFG->dirroot . "/course/lib.php");
+        require_once($CFG->libdir . '/completionlib.php');
+
+
+        $params = self::validate_parameters(self::create_courses_parameters(),
+                        array('courses' => $courses));
+
+        $availablethemes = get_plugin_list('theme');
+        $availablelangs = get_string_manager()->get_list_of_translations();
+
+        $transaction = $DB->start_delegated_transaction();
+
+        foreach ($params['courses'] as $course) {
+
+            // Ensure the current user is allowed to run this function
+            $context = get_context_instance(CONTEXT_COURSECAT, $course['categoryid']);
+            try {
+                self::validate_context($context);
+            } catch (Exception $e) {
+                $exceptionparam = new stdClass();
+                $exceptionparam->message = $e->getMessage();
+                $exceptionparam->catid = $course['categoryid'];
+                throw new moodle_exception(
+                        get_string('errorcatcontextnotvalid', 'webservice', $exceptionparam));
+            }
+            require_capability('moodle/course:create', $context);
+
+            // Make sure lang is valid
+            if (key_exists('lang', $course) and empty($availablelangs[$course['lang']])) {
+                throw new moodle_exception(
+                        get_string('errorinvalidparam', 'webservice', 'lang'));
+            }
+
+            // Make sure theme is valid
+            if (key_exists('forcetheme', $course)) {
+                if (!empty($CFG->allowcoursethemes)) {
+                    if (empty($availablethemes[$course['forcetheme']])) {
+                        throw new moodle_exception(
+                                get_string('errorinvalidparam', 'webservice', 'forcetheme'));
+                    } else {
+                        $course['theme'] = $course['forcetheme'];
+                    }
+                }
+            }
+
+            //force visibility if ws user doesn't have the permission to set it
+            $category = $DB->get_record('course_categories', array('id' => $course['categoryid']));
+            if (!has_capability('moodle/course:visibility', $context)) {
+                $course['visible'] = $category->visible;
+            }
+
+            //set default value for completion
+            if (completion_info::is_enabled_for_site()) {
+                if (!key_exists('enablecompletion', $course)) {
+                    $course['enablecompletion'] = $courseconfig->enablecompletion;
+                }
+                if (!key_exists('completionstartonenrol', $course)) {
+                    $course['completionstartonenrol'] = $courseconfig->completionstartonenrol;
+                }
+            } else {
+                $course['enablecompletion'] = 0;
+                $course['completionstartonenrol'] = 0;
+            }
+
+            $course['category'] = $course['categoryid'];
+
+            //Note: create_course() core function check shortname, idnumber, category
+            $course['id'] = create_course((object) $course)->id;
+
+            $resultcourses[] = array('id' => $course['id'], 'shortname' => $course['shortname']);
+        }
+
+        $transaction->allow_commit();
+
+        return $resultcourses;
+    }
+
+    /**
+     * Returns description of method result value
+     * @return external_description
+     */
+    public static function create_courses_returns() {
+        return new external_multiple_structure(
+            new external_single_structure(
+                array(
+                    'id'       => new external_value(PARAM_INT, 'course id'),
+                    'shortname' => new external_value(PARAM_TEXT, 'short name'),
+                )
+            )
+        );
+    }
+
 }
\ No newline at end of file
diff --git a/lang/en/webservice.php b/lang/en/webservice.php
index 2051dbd981c..3a638bae649 100644
--- a/lang/en/webservice.php
+++ b/lang/en/webservice.php
@@ -69,8 +69,10 @@ $string['enablews'] = 'Enable web services';
 $string['enablewsdescription'] = 'Web services must be enabled in Advanced features.';
 $string['entertoken'] = 'Enter a security key/token:';
 $string['error'] = 'Error: {$a}';
+$string['errorcatcontextnotvalid'] = 'You cannot execute functions in the category context (category id:{$a->catid}). The context error message was: {$a->message}';
 $string['errorcodes'] = 'Error message';
 $string['errorcoursecontextnotvalid'] = 'You cannot execute functions in the course context (course id:{$a->courseid}). The context error message was: {$a->message}';
+$string['errorinvalidparam'] = 'The param "{$a}" is invalid.';
 $string['errorinvalidparamsapi'] = 'Invalid external api parameter';
 $string['errorinvalidparamsdesc'] = 'Invalid external api description';
 $string['errorinvalidresponseapi'] = 'Invalid external api response';
diff --git a/lib/db/services.php b/lib/db/services.php
index 660677806b1..a33b75ed61d 100644
--- a/lib/db/services.php
+++ b/lib/db/services.php
@@ -177,4 +177,24 @@ $functions = array(
         'capabilities'=> 'moodle/role:assign',
     ),
 
+    // === course related functions ===
+
+    'moodle_course_get_courses' => array(
+        'classname'   => 'moodle_course_external',
+        'methodname'  => 'get_courses',
+        'classpath'   => 'course/externallib.php',
+        'description' => 'Return course details',
+        'type'        => 'read',
+        'capabilities'=> 'moodle/course:view,moodle/course:update,moodle/course:viewhiddencourses',
+    ),
+
+    'moodle_course_create_courses' => array(
+        'classname'   => 'moodle_course_external',
+        'methodname'  => 'create_courses',
+        'classpath'   => 'course/externallib.php',
+        'description' => 'Create new courses',
+        'type'        => 'write',
+        'capabilities'=> 'moodle/course:create,moodle/course:visibility',
+    ),
+
 );
diff --git a/user/externallib.php b/user/externallib.php
index 2c1be99b2be..3409a7c6f22 100644
--- a/user/externallib.php
+++ b/user/externallib.php
@@ -68,7 +68,7 @@ class moodle_user_external extends external_api {
                                         'type'  => new external_value(PARAM_ALPHANUMEXT, 'The name of the custom field'),
                                         'value' => new external_value(PARAM_RAW, 'The value of the custom field')
                                     )
-                                ), 'User custom fields', VALUE_OPTIONAL)
+                                ), 'User custom fields (also known as user profil fields)', VALUE_OPTIONAL)
                         )
                     )
                 )
@@ -263,7 +263,7 @@ class moodle_user_external extends external_api {
                                         'type'  => new external_value(PARAM_ALPHANUMEXT, 'The name of the custom field'),
                                         'value' => new external_value(PARAM_RAW, 'The value of the custom field')
                                     )
-                                ), 'User custom fields', VALUE_OPTIONAL),
+                                ), 'User custom fields (also known as user profil fields)', VALUE_OPTIONAL),
                             'preferences' => new external_multiple_structure(
                                 new external_single_structure(
                                     array(
@@ -437,7 +437,7 @@ class moodle_user_external extends external_api {
                                                 'type'  => new external_value(PARAM_ALPHANUMEXT, 'The name of the custom field'),
                                                 'value' => new external_value(PARAM_RAW, 'The value of the custom field')
                                             )
-                                    ), 'User custom fields', VALUE_OPTIONAL)
+                                    ), 'User custom fields (also known as user profil fields)', VALUE_OPTIONAL)
                         )
                 )
         );
diff --git a/webservice/simpletest/testwebservice.php b/webservice/simpletest/testwebservice.php
index c7ca5ed7e02..db6f7654652 100644
--- a/webservice/simpletest/testwebservice.php
+++ b/webservice/simpletest/testwebservice.php
@@ -23,14 +23,15 @@
  * @package web service
  */
 if (!defined('MOODLE_INTERNAL')) {
-    die('Direct access to this script is forbidden.');    ///  It must be included from a Moodle page
+    ///  It must be included from a Moodle page
+    die('Direct access to this script is forbidden.');
 }
 
 /**
  * How to configure this unit tests:
  * 0- Enable the web service you wish to test in the Moodle administration
  * 1- Create a service with all functions in the Moodle administration
- * 2- Create a token associate this service and to an admin (so you get all capabilities)
+ * 2- Create a token associate this service and to an admin (or a user with all required capabilities)
  * 3- Configure setUp() function:
  *      a- write the token
  *      b- activate the protocols you wish to test
@@ -58,21 +59,24 @@ class webservice_test extends UnitTestCase {
 
     function setUp() {
         //token to test
-        $this->testtoken = '793e26aeddea7f0a696795d14dfccb0f';
+        $this->testtoken = '72d338d58ff881cc293f8cd1d96d7a57';
 
         //protocols to test
         $this->testrest = false; //Does not work till XML => PHP is implemented (MDL-22965)
         $this->testxmlrpc = false;
         $this->testsoap = false;
 
-        ////// DB READ-ONLY tests ////
+        ////// READ-ONLY DB tests ////
         $this->readonlytests = array(
-            'moodle_group_get_groups' => false
+            'moodle_group_get_groups' => false,
+            'moodle_course_get_courses' => false,
+            'moodle_user_get_users_by_id' => false,
         );
 
-        ////// DB WRITE tests ////
+        ////// WRITE DB tests ////
         $this->writetests = array(
-            'moodle_user_create_users' => false
+            'moodle_user_create_users' => false,
+            'moodle_course_create_courses' => false,
         );
 
         //performance testing: number of time the web service are run
@@ -194,87 +198,341 @@ class webservice_test extends UnitTestCase {
         $this->assertEqual(count($groups), count($groupids));
     }
 
-    function moodle_user_create_users($client) {
+    function moodle_user_get_users_by_id($client) {
         global $DB;
-        //do not run the test if users already exists
-        $users = $DB->get_records_list('user', 'username',
-                        array('testusername1', 'testusername2'));
-        if (!empty($users)) {
-            throw new moodle_exception('testuseralreadyexist');
-        } else {
-            //a full user
-            $user1 = new stdClass();
-            $user1->username = 'testusername1';
-            $user1->password = 'testpassword1';
-            $user1->firstname = 'testfirstname1';
-            $user1->lastname = 'testlastname1';
-            $user1->email = 'testemail1@moodle.com';
-            $user1->auth = 'manual';
-            $user1->idnumber = 'testidnumber1';
-            $user1->emailstop = 1;
-            $user1->lang = 'en';
-            $user1->theme = 'standard';
-            $user1->timezone = 99;
-            $user1->mailformat = 0;
-            $user1->description = 'Hello World!';
-            $user1->city = 'testcity1';
-            $user1->country = 'au';
-            $user1->preferences = array(
-                array('type' => 'preference1', 'value' => 'value1'),
-                array('type' => 'preference2', 'value' => 'value2'));
-            $user1->customfields = array(
-                array('type' => 'type', 'value' => 'value'),
-                array('type' => 'type2', 'value' => 'value2'));
+        $dbusers = $DB->get_records('user');
+        $userids = array();
+        foreach ($dbusers as $dbuser) {
+            $userids[] = $dbuser->id;
+        }
+        $function = 'moodle_user_get_users_by_id';
 
-            //a minimum user
-            $user2 = new stdClass();
-            $user2->username = 'testusername2';
-            $user2->password = 'testpassword2';
-            $user2->firstname = 'testfirstname2';
-            $user2->lastname = 'testlastname2';
-            $user2->email = 'testemail1@moodle.com';
+        $params = array('userids' => $userids);
+        $users = $client->call($function, $params);
 
-            $users = array($user1, $user2);
+        $this->assertEqual(count($users), count($userids));
+    }
 
-            $function = 'moodle_user_create_users';
-            $params = array('users' => $users);
-            $resultusers = $client->call($function, $params);
-            $this->assertEqual(count($users), count($resultusers));
+    function moodle_course_get_courses($client) {
+        global $DB;
 
-            //retrieve users from the DB and check values
-            $dbuser1 = $DB->get_record('user', array('username' => 'testusername1'));
-            $this->assertEqual($dbuser1->firstname, $user1->firstname);
-            $this->assertEqual($dbuser1->password,
-                    hash_internal_user_password($user1->password));
-            $this->assertEqual($dbuser1->lastname, $user1->lastname);
-            $this->assertEqual($dbuser1->email, $user1->email);
-            $this->assertEqual($dbuser1->auth, $user1->auth);
-            $this->assertEqual($dbuser1->idnumber, $user1->idnumber);
-            $this->assertEqual($dbuser1->emailstop, $user1->emailstop);
-            $this->assertEqual($dbuser1->lang, $user1->lang);
-            $this->assertEqual($dbuser1->theme, $user1->theme);
-            $this->assertEqual($dbuser1->timezone, $user1->timezone);
-            $this->assertEqual($dbuser1->mailformat, $user1->mailformat);
-            $this->assertEqual($dbuser1->description, $user1->description);
-            $this->assertEqual($dbuser1->city, $user1->city);
-            $this->assertEqual($dbuser1->country, $user1->country);
-            $user1preference1 = get_user_preferences('preference1', null, $dbuser1->id);
-            $this->assertEqual('value1', $user1preference1);
-            $user1preference2 = get_user_preferences('preference2', null, $dbuser1->id);
-            $this->assertEqual('value2', $user1preference2);
+        $function = 'moodle_course_get_courses';
 
-            //retrieve users from the DB and check values
-            $dbuser2 = $DB->get_record('user', array('username' => 'testusername2'));
-            $this->assertEqual($dbuser2->firstname, $user2->firstname);
-            $this->assertEqual($dbuser2->password,
-                    hash_internal_user_password($user2->password));
-            $this->assertEqual($dbuser2->lastname, $user2->lastname);
-            $this->assertEqual($dbuser2->email, $user2->email);
+        //retrieve all courses from db
+        $dbcourses = $DB->get_records('course');
+        $courseids = array();
+        foreach ($dbcourses as $dbcourse) {
+            $courseids[] = $dbcourse->id;
+        }
 
-            //delete users from DB
-            $DB->delete_records_list('user', 'id',
-                    array($dbuser1->id, $dbuser2->id));
+        //retrieve all courses by id
+        $params = array('options' => array('ids' => $courseids));
+        $courses = $client->call($function, $params);
+
+        //check it is the same course count
+        $this->assertEqual(count($courses), count($courseids));
+
+        //check all course values are identic
+        foreach ($courses as $course) {
+            $this->assertEqual($course['fullname'],
+                    $dbcourses[$course['id']]->fullname);
+            $this->assertEqual($course['shortname'],
+                    $dbcourses[$course['id']]->shortname);
+            $this->assertEqual($course['categoryid'],
+                    $dbcourses[$course['id']]->category);
+            $this->assertEqual($course['categorysortorder'],
+                    $dbcourses[$course['id']]->sortorder);
+            $this->assertEqual($course['idnumber'],
+                    $dbcourses[$course['id']]->idnumber);
+            $this->assertEqual($course['summary'],
+                    $dbcourses[$course['id']]->summary);
+            $this->assertEqual($course['summaryformat'],
+                    $dbcourses[$course['id']]->summaryformat);
+            $this->assertEqual($course['format'],
+                    $dbcourses[$course['id']]->format);
+            $this->assertEqual($course['showgrades'],
+                    $dbcourses[$course['id']]->showgrades);
+            $this->assertEqual($course['newsitems'],
+                    $dbcourses[$course['id']]->newsitems);
+            $this->assertEqual($course['startdate'],
+                    $dbcourses[$course['id']]->startdate);
+            $this->assertEqual($course['numsections'],
+                    $dbcourses[$course['id']]->numsections);
+            $this->assertEqual($course['maxbytes'],
+                    $dbcourses[$course['id']]->maxbytes);
+            $this->assertEqual($course['visible'],
+                    $dbcourses[$course['id']]->visible);
+            $this->assertEqual($course['hiddensections'],
+                    $dbcourses[$course['id']]->hiddensections);
+            $this->assertEqual($course['groupmode'],
+                    $dbcourses[$course['id']]->groupmode);
+            $this->assertEqual($course['groupmodeforce'],
+                    $dbcourses[$course['id']]->groupmodeforce);
+            $this->assertEqual($course['defaultgroupingid'],
+                    $dbcourses[$course['id']]->defaultgroupingid);
+            $this->assertEqual($course['lang'],
+                    $dbcourses[$course['id']]->lang);
+            $this->assertEqual($course['timecreated'],
+                    $dbcourses[$course['id']]->timecreated);
+            $this->assertEqual($course['timemodified'],
+                    $dbcourses[$course['id']]->timemodified);
+            if (key_exists('enablecompletion', $course)) {
+                $this->assertEqual($course['enablecompletion'],
+                        $dbcourses[$course['id']]->enablecompletion);
+            }
+            if (key_exists('completionstartonenrol', $course)) {
+                $this->assertEqual($course['completionstartonenrol'],
+                        $dbcourses[$course['id']]->completionstartonenrol);
+            }
+            if (key_exists('completionnotify', $course)) {
+                $this->assertEqual($course['completionnotify'],
+                        $dbcourses[$course['id']]->completionnotify);
+            }
+            $this->assertEqual($course['forcetheme'],
+                    $dbcourses[$course['id']]->theme);
         }
     }
 
+    function moodle_course_create_courses($client) {
+        global $DB, $CFG;
+
+        ///Test data
+        $courseconfig = get_config('moodlecourse');
+
+        $themeobjects = get_list_of_themes();
+        $theme = key($themeobjects);
+        $categoryid = $DB->get_record('course_categories', array(), '*', IGNORE_MULTIPLE)->id;
+        $categoryid = empty($categoryid)?0:$categoryid;
+
+        $course1 = new stdClass();
+        $course1->fullname = 'Test Data create course 1';
+        $course1->shortname = 'testdatacourse1';
+        $course1->categoryid = $categoryid;
+        $course1->idnumber = '328327982372342343234';
+        $course1->summary = 'This is a summary';
+        $course1->summaryformat = FORMAT_HTML;
+        $course1->format = $courseconfig->format;
+        $course1->showgrades = $courseconfig->showgrades;
+        $course1->showreports = $courseconfig->showreports;
+        $course1->newsitems = $courseconfig->newsitems;
+        $course1->startdate = time();
+        $course1->numsections = $courseconfig->numsections;
+        $course1->maxbytes = $courseconfig->maxbytes;
+        $course1->visible = $courseconfig->visible;
+        $course1->hiddensections = $courseconfig->hiddensections;
+        $course1->groupmode = $courseconfig->groupmode;
+        $course1->groupmodeforce = $courseconfig->groupmodeforce;
+        $course1->defaultgroupingid = 0;
+        if (!empty($courseconfig->lang)) {
+            $course1->lang = $courseconfig->lang;
+        }
+        $course1->enablecompletion = $courseconfig->enablecompletion;
+        $course1->completionstartonenrol = $courseconfig->completionstartonenrol;
+        $course1->completionnotify = 0;
+        $course1->forcetheme = $theme;
+
+        $course2 = new stdClass();
+        $course2->fullname = 'Test Data create course 2';
+        $course2->shortname = 'testdatacourse2';
+        $course2->categoryid = $categoryid;
+
+        $courses = array($course1, $course2);
+
+        //do not run the test if course1 or course2 already exists
+        $existingcourses = $DB->get_records_list('course', 'fullname',
+                        array($course1->fullname, $course2->fullname));
+        if (!empty($existingcourses)) {
+            throw new moodle_exception('testdatacoursesalreadyexist');
+        }
+
+        $function = 'moodle_course_create_courses';
+        $params = array('courses' => $courses);
+        $resultcourses = $client->call($function, $params);
+        $this->assertEqual(count($courses), count($resultcourses));
+
+        //retrieve user1 from the DB and check values
+        $dbcourse1 = $DB->get_record('course', array('fullname' => $course1->fullname));
+        $this->assertEqual($dbcourse1->fullname, $course1->fullname);
+        $this->assertEqual($dbcourse1->shortname, $course1->shortname);
+        $this->assertEqual($dbcourse1->category, $course1->categoryid);
+        $this->assertEqual($dbcourse1->idnumber, $course1->idnumber);
+        $this->assertEqual($dbcourse1->summary, $course1->summary);
+        $this->assertEqual($dbcourse1->summaryformat, $course1->summaryformat);
+        $this->assertEqual($dbcourse1->format, $course1->format);
+        $this->assertEqual($dbcourse1->showgrades, $course1->showgrades);
+        $this->assertEqual($dbcourse1->showreports, $course1->showreports);
+        $this->assertEqual($dbcourse1->newsitems, $course1->newsitems);
+        $this->assertEqual($dbcourse1->startdate, $course1->startdate);
+        $this->assertEqual($dbcourse1->numsections, $course1->numsections);
+        $this->assertEqual($dbcourse1->maxbytes, $course1->maxbytes);
+        $this->assertEqual($dbcourse1->visible, $course1->visible);
+        $this->assertEqual($dbcourse1->hiddensections, $course1->hiddensections);
+        $this->assertEqual($dbcourse1->groupmode, $course1->groupmode);
+        $this->assertEqual($dbcourse1->groupmodeforce, $course1->groupmodeforce);
+        $this->assertEqual($dbcourse1->defaultgroupingid, $course1->defaultgroupingid);
+        if (!empty($courseconfig->lang)) {
+            $this->assertEqual($dbcourse1->lang, $course1->lang);
+        }
+        if (completion_info::is_enabled_for_site()) {
+            $this->assertEqual($dbcourse1->enablecompletion, $course1->enablecompletion);
+            $this->assertEqual($dbcourse1->completionstartonenrol, $course1->completionstartonenrol);
+        }
+        $this->assertEqual($dbcourse1->completionnotify, $course1->completionnotify);
+        if (!empty($CFG->allowcoursethemes)) {
+            $this->assertEqual($dbcourse1->theme, $course1->forcetheme);
+        }
+
+        //retrieve user2 from the DB and check values
+        $dbcourse2 = $DB->get_record('course', array('fullname' => $course2->fullname));
+        $this->assertEqual($dbcourse2->fullname, $course2->fullname);
+        $this->assertEqual($dbcourse2->shortname, $course2->shortname);
+        $this->assertEqual($dbcourse2->category, $course2->categoryid );
+        $this->assertEqual($dbcourse2->summaryformat, FORMAT_MOODLE);
+        $this->assertEqual($dbcourse2->format, $courseconfig->format);
+        $this->assertEqual($dbcourse2->showgrades, $courseconfig->showgrades);
+        $this->assertEqual($dbcourse2->showreports, $courseconfig->showreports);
+        $this->assertEqual($dbcourse2->newsitems, $courseconfig->newsitems);
+        $this->assertEqual($dbcourse2->numsections, $courseconfig->numsections);
+        $this->assertEqual($dbcourse2->maxbytes, $courseconfig->maxbytes);
+        $this->assertEqual($dbcourse2->visible, $courseconfig->visible);
+        $this->assertEqual($dbcourse2->hiddensections, $courseconfig->hiddensections);
+        $this->assertEqual($dbcourse2->groupmode, $courseconfig->groupmode);
+        $this->assertEqual($dbcourse2->groupmodeforce, $courseconfig->groupmodeforce);
+        $this->assertEqual($dbcourse2->defaultgroupingid, 0);
+
+        //delete users from DB
+        $DB->delete_records_list('course', 'id',
+                array($dbcourse1->id, $dbcourse2->id));
+    }
+
+    function moodle_user_create_users($client) {
+        global $DB, $CFG;
+
+        //Test data
+        //a full user: user1
+        $user1 = new stdClass();
+        $user1->username = 'testusername1';
+        $user1->password = 'testpassword1';
+        $user1->firstname = 'testfirstname1';
+        $user1->lastname = 'testlastname1';
+        $user1->email = 'testemail1@moodle.com';
+        $user1->auth = 'manual';
+        $user1->idnumber = 'testidnumber1';
+        $user1->emailstop = 1;
+        $user1->lang = 'en';
+        $user1->theme = 'standard';
+        $user1->timezone = 99;
+        $user1->mailformat = 0;
+        $user1->description = 'Hello World!';
+        $user1->city = 'testcity1';
+        $user1->country = 'au';
+        $preferencename1 = 'preference1';
+        $preferencename2 = 'preference2';
+        $user1->preferences = array(
+            array('type' => $preferencename1, 'value' => 'preferencevalue1'),
+            array('type' => $preferencename2, 'value' => 'preferencevalue2'));
+        $customfieldname1 = 'testdatacustom1';
+        $customfieldname2 = 'testdatacustom2';
+        $user1->customfields = array(
+            array('type' => $customfieldname1, 'value' => 'customvalue'),
+            array('type' => $customfieldname2, 'value' => 'customvalue2'));
+        //a small user: user2
+        $user2 = new stdClass();
+        $user2->username = 'testusername2';
+        $user2->password = 'testpassword2';
+        $user2->firstname = 'testfirstname2';
+        $user2->lastname = 'testlastname2';
+        $user2->email = 'testemail1@moodle.com';
+
+        $users = array($user1, $user2);
+
+        //do not run the test if user1 or user2 already exists
+        $existingusers = $DB->get_records_list('user', 'username',
+                        array($user1->username, $user2->username));
+        if (!empty($existingusers)) {
+            throw new moodle_exception('testdatausersalreadyexist');
+        }
+
+        //do not run the test if data test custom fields already exists
+        $existingcustomfields = $DB->get_records_list('user_info_field', 'shortname',
+                        array($customfieldname1, $customfieldname2));
+        if (!empty($existingcustomfields)) {
+            throw new moodle_exception('testdatacustomfieldsalreadyexist');
+        }
+
+        //create the custom fields
+        $customfield = new stdClass();
+        $customfield->shortname = $customfieldname1;
+        $customfield->name = $customfieldname1;
+        $customfield->datatype = 'text';
+        $DB->insert_record('user_info_field', $customfield);
+        $customfield = new stdClass();
+        $customfield->shortname = $customfieldname2;
+        $customfield->name = $customfieldname2;
+        $customfield->datatype = 'text';
+        $DB->insert_record('user_info_field', $customfield);
+
+        $function = 'moodle_user_create_users';
+        $params = array('users' => $users);
+        $resultusers = $client->call($function, $params);
+        $this->assertEqual(count($users), count($resultusers));
+
+        //retrieve user1 from the DB and check values
+        $dbuser1 = $DB->get_record('user', array('username' => $user1->username));
+        $this->assertEqual($dbuser1->firstname, $user1->firstname);
+        $this->assertEqual($dbuser1->password,
+                hash_internal_user_password($user1->password));
+        $this->assertEqual($dbuser1->lastname, $user1->lastname);
+        $this->assertEqual($dbuser1->email, $user1->email);
+        $this->assertEqual($dbuser1->auth, $user1->auth);
+        $this->assertEqual($dbuser1->idnumber, $user1->idnumber);
+        $this->assertEqual($dbuser1->emailstop, $user1->emailstop);
+        $this->assertEqual($dbuser1->lang, $user1->lang);
+        $this->assertEqual($dbuser1->theme, $user1->theme);
+        $this->assertEqual($dbuser1->timezone, $user1->timezone);
+        $this->assertEqual($dbuser1->mailformat, $user1->mailformat);
+        $this->assertEqual($dbuser1->description, $user1->description);
+        $this->assertEqual($dbuser1->city, $user1->city);
+        $this->assertEqual($dbuser1->country, $user1->country);
+        $user1preference1 = get_user_preferences($user1->preferences[0]['type'],
+                        null, $dbuser1->id);
+        $this->assertEqual($user1->preferences[0]['value'], $user1preference1);
+        $user1preference2 = get_user_preferences($user1->preferences[1]['type'],
+                        null, $dbuser1->id);
+        $this->assertEqual($user1->preferences[1]['value'], $user1preference2);
+        require_once($CFG->dirroot . "/user/profile/lib.php");
+        $customfields = profile_user_record($dbuser1->id);
+
+        $customfields = (array) $customfields;
+        $customfieldname1 = $user1->customfields[0]['type'];
+        $customfieldname2 = $user1->customfields[1]['type'];
+        $this->assertEqual($customfields[$customfieldname1],
+                $user1->customfields[0]['value']);
+        $this->assertEqual($customfields[$customfieldname2],
+                $user1->customfields[1]['value']);
+
+
+        //retrieve user2 from the DB and check values
+        $dbuser2 = $DB->get_record('user', array('username' => $user2->username));
+        $this->assertEqual($dbuser2->firstname, $user2->firstname);
+        $this->assertEqual($dbuser2->password,
+                hash_internal_user_password($user2->password));
+        $this->assertEqual($dbuser2->lastname, $user2->lastname);
+        $this->assertEqual($dbuser2->email, $user2->email);
+
+        //unset preferences
+        $DB->delete_records('user_preferences', array('userid' => $dbuser1->id));
+
+        //clear custom fields data
+        $DB->delete_records('user_info_data', array('userid' => $dbuser1->id));
+
+        //delete custom fields
+        $DB->delete_records_list('user_info_field', 'shortname',
+                array($customfieldname1, $customfieldname2));
+
+        //delete users from DB
+        $DB->delete_records_list('user', 'id',
+                array($dbuser1->id, $dbuser2->id));
+    }
+
 }