WSCourse::CreateCourse() - Code Metrics - Inspection of "Minor - Partial merge from 1.11.x" - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f41061...196bfc )

by Julito

created 2019-04-01 12:31 UTC

WSCourse::CreateCourse() A

↳ Parent: WSCourse

Complexity

Conditions	3
Paths	3

Size

Total Lines	34
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	19
nc	3
nop	11
dl	0
loc	34
rs	9.6333
c	0
b	0
f	0

How to fix Many Parameters

<?php
/* For licensing terms, see /license.txt */
/**
 * @package chamilo.webservices
 */
require_once __DIR__.'/../inc/global.inc.php';
require_once __DIR__.'/webservice.php';

/**
 * Web services available for the Course module. This class extends the WS class.
 */
class WSCourse extends WS
{
    /**
     * Deletes a course.
     *
     * @param string API secret key
     * @param string Course id field name
     * @param string Course id value
     */
    public function DeleteCourse(
        $secret_key,
        $course_id_field_name,
        $course_id_value
    ) {
        $verifKey = $this->verifyKey($secret_key);
        if ($verifKey instanceof WSError) {
            $this->handleError($verifKey);
        } else {
            $result = $this->deleteCourseHelper(
                $course_id_field_name,
                $course_id_value
            );
            if ($result instanceof WSError) {
                $this->handleError($result);
            }
        }
    }

    /**
     * Deletes multiple courses.
     *
     * @param string API secret key
     * @param array Array of courses with elements of the form
     * array('course_id_field_name' => 'name_of_field', 'course_id_value' => 'value')
     *
     * @return array Array with elements like
     *               array('course_id_value' => 'value', 'result' => array('code' => 0, 'message' => 'Operation was successful')).
     *               Note that if the result array contains a code different
     *               than 0, an error occured
     */
    public function DeleteCourses($secret_key, $courses)
    {
        $verifKey = $this->verifyKey($secret_key);
        if ($verifKey instanceof WSError) {
            $this->handleError($verifKey);
        } else {
            $results = [];
            foreach ($courses as $course) {
                $result_tmp = [];
                $result_op = $this->deleteCourseHelper(
                    $course['course_id_field_name'],
                    $course['course_id_value']
                );
                $result_tmp['course_id_value'] = $course['course_id_value'];
                if ($result_op instanceof WSError) {
                    // Return the error in the results
                    $result_tmp['result'] = $result_op->toArray();
                } else {
                    $result_tmp['result'] = $this->getSuccessfulResult();
                }
                $results[] = $result_tmp;
            }

            return $results;
        }
    }

    /**
     * Creates a course.
     *
     * @param string API secret key
     * @param string Title
     * @param string Category code
     * @param string Wanted code. If it's not defined, it will be generated automatically
     * @param string Tutor name
     * @param string Course admin user id field name
     * @param string Course admin user id value
     * @param string Course language
     * @param string Course id field name
     * @param string Course id value
     * @param array Course extra fields
     *
     * @return int Course id generated
     */
    public function CreateCourse(
        $secret_key,
        $title,
        $category_code,
        $wanted_code,
        $tutor_name,
        $course_admin_user_id_field_name,
        $course_admin_user_id_value,
        $language,
        $course_id_field_name,
        $course_id_value,
        $extras
    ) {
        // First, verify the secret key
        $verifKey = $this->verifyKey($secret_key);
        if ($verifKey instanceof WSError) {
            $this->handleError($verifKey);
        } else {
            $result = $this->createCourseHelper(
                $title,
                $category_code,
                $wanted_code,
                $tutor_name,
                $course_admin_user_id_field_name,
                $course_admin_user_id_value,
                $language,
                $course_id_field_name,
                $course_id_value,
                $extras
            );
            if ($result instanceof WSError) {
                $this->handleError($result);
            } else {
                return $result;
            }
        }
    }

    /**
     * Create multiple courses.
     *
     * @param string API secret key
     * @param array Courses to be created, with elements following the structure presented in CreateCourse
     *
     * @return array Array with elements of the form
     *               array('course_id_value' => 'original value sent', 'course_id_generated' => 'value_generated', 'result' => array('code' => 0, 'message' => 'Operation was successful'))
     */
    public function CreateCourses($secret_key, $courses)
    {
        // First, verify the secret key
        $verifKey = $this->verifyKey($secret_key);
        if ($verifKey instanceof WSError) {
            $this->handleError($verifKey);
        } else {
            $results = [];
            foreach ($courses as $course) {
                $result_tmp = [];
                // re-initialize variables just in case
                $title = $category_code = $wanted_code = $tutor_name = $course_admin_user_id_field_name = $course_admin_user_id_value = $language = $course_id_field_name = $course_id_value = $extras = 0;
                extract($course);
                $result = $this->createCourseHelper(
                    $title,
                    $category_code,
                    $wanted_code,
                    $tutor_name,
                    $course_admin_user_id_field_name,
                    $course_admin_user_id_value,
                    $language,
                    $course_id_field_name,
                    $course_id_value,
                    $extras
                );
                if ($result instanceof WSError) {
                    $result_tmp['result'] = $result->toArray();
                    $result_tmp['course_id_value'] = $course_id_value;
                    $result_tmp['course_id_generated'] = 0;
                } else {
                    $result_tmp['result'] = $this->getSuccessfulResult();
                    $result_tmp['course_id_value'] = $course_id_value;
                    $result_tmp['course_id_generated'] = $result;
                }
                $results[] = $result_tmp;
            }

            return $results;
        }
    }

    /**
     * Edits a course.
     *
     * @param string API secret key
     * @param string Course id field name
     * @param string Course id value
     * @param string Title
     * @param string Category code
     * @param string Department name
     * @param string Department url
     * @param string Course language
     * @param int Visibility
     * @param int Subscribe (0 = denied, 1 = allowed)
     * @param int Unsubscribe (0 = denied, 1 = allowed)
     * @param string Visual code
     * @param array Course extra fields
     */
    public function EditCourse(
        $secret_key,
        $course_id_field_name,
        $course_id_value,
        $title,
        $category_code,
        $department_name,
        $department_url,
        $language,
        $visibility,
        $subscribe,
        $unsubscribe,
        $visual_code,
        $extras
    ) {
        $verifKey = $this->verifyKey($secret_key);
        if ($verifKey instanceof WSError) {
            $this->handleError($verifKey);
        } else {
            $result = $this->editCourseHelper(
                $course_id_field_name,
                $course_id_value,
                $title,
                $category_code,
                $department_name,
                $department_url,
                $language,
                $visibility,
                $subscribe,
                $unsubscribe,
                $visual_code,
                $extras
            );
            if ($result instanceof WSError) {
                $this->handleError($result);
            }
        }
    }

    /**
     * List courses.
     *
     * @param string API secret key
     * @param string A list of visibility filter we want to apply
     *
     * @return array An array with elements of the form
     *               ('id' => 'Course internal id', 'code' => 'Course code', 'title' => 'Course title', 'language' => 'Course language', 'visibility' => 'Course visibility',
     *               'category_name' => 'Name of the category of the course', 'number_students' => 'Number of students in the course', 'external_course_id' => 'External course id')
     */
    public function ListCourses(
        $secret_key,
        $visibility = 'public,public-registered,private,closed'
    ) {
        $verifKey = $this->verifyKey($secret_key);
        if ($verifKey instanceof WSError) {
            $this->handleError($verifKey);
        } else {
            $visibilities = split(',', $visibility);
            $vis = [
                'public' => '3',
                'public-registered' => '2',
                'private' => '1',
                'closed' => '0',
            ];
            foreach ($visibilities as $p => $visibility) {
                $visibilities[$p] = $vis[$visibility];
            }
            $courses_result = [];
            $category_names = [];

            $courses = CourseManager::get_courses_list();
            foreach ($courses as $course) {
                //skip elements that do not match required visibility
                if (!in_array($course['visibility'], $visibilities)) {
                    continue;
                }
                $course_tmp = [];
                $course_tmp['id'] = $course['id'];
                $course_tmp['code'] = $course['code'];
                $course_tmp['title'] = $course['title'];
                $course_tmp['language'] = $course['course_language'];
                $course_tmp['visibility'] = $course['visibility'];

                // Determining category name
                if ($category_names[$course['category_code']]) {
                    $course_tmp['category_name'] = $category_names[$course['category_code']];
                } else {
                    $category = CourseManager::get_course_category(
                        $course['category_code']
                    );
                    $category_names[$course['category_code']] = $category['name'];
                    $course_tmp['category_name'] = $category['name'];
                }

                // Determining number of students registered in course
                $user_list = CourseManager::get_user_list_from_course_code(
                    $course['code'],
                    0
                );
                $course_tmp['number_students'] = count($user_list);

                // Determining external course id - this code misses the external course id field name
                // $course_tmp['external_course_id'] = CourseManager::get_course_extra_field_value($course_field_name, $course['code']);

                $courses_result[] = $course_tmp;
            }

            return $courses_result;
        }
    }

    /**
     * Subscribe user to a course.
     *
     * @param string API secret key
     * @param string Course id field name. Use "chamilo_course_id" to use internal id
     * @param string course id value
     * @param string User id field name. Use "chamilo_user_id" to use internal id
     * @param string User id value
     * @param int Status (1 = Teacher, 5 = Student)
     */
    public function SubscribeUserToCourse(
        $secret_key,
        $course_id_field_name,
        $course_id_value,
        $user_id_field_name,
        $user_id_value,
        $status
    ) {
        $verifKey = $this->verifyKey($secret_key);
        if ($verifKey instanceof WSError) {
            $this->handleError($verifKey);
        } else {
            $result = $this->changeUserSubscription(
                $course_id_field_name,
                $course_id_value,
                $user_id_field_name,
                $user_id_value,
                1,
                $status
            );
            if ($result instanceof WSError) {
                $this->handleError($result);
            }
        }
    }

    /**
     * Unsusbscribe user from course.
     *
     * @param string API secret key
     * @param string Course id field name. Use "chamilo_course_id" to use internal id
     * @param string course id value
     * @param string User id field name. Use "chamilo_user_id" to use internal id
     * @param string User id value
     */
    public function UnsubscribeUserFromCourse(
        $secret_key,
        $course_id_field_name,
        $course_id_value,
        $user_id_field_name,
        $user_id_value
    ) {
        $verifKey = $this->verifyKey($secret_key);
        if ($verifKey instanceof WSError) {
            $this->handleError($verifKey);
        } else {
            $result = $this->changeUserSubscription(
                $course_id_field_name,
                $course_id_value,
                $user_id_field_name,
                $user_id_value,
                0
            );
            if ($result instanceof WSError) {
                $this->handleError($result);
            }
        }
    }

    /**
     * Returns the descriptions of a course, along with their id.
     *
     * @param string API secret key
     * @param string Course id field name
     * @param string Course id value
     *
     * @return array Returns an array with elements of the form
     *               array('course_desc_id' => 1, 'course_desc_title' => 'Title', 'course_desc_content' => 'Content')
     */
    public function GetCourseDescriptions(
        $secret_key,
        $course_id_field_name,
        $course_id_value
    ) {
        $verifKey = $this->verifyKey($secret_key);
        if ($verifKey instanceof WSError) {
            $this->handleError($verifKey);
        } else {
            $course_id = $this->getCourseId(
                $course_id_field_name,
                $course_id_value
            );
            if ($course_id instanceof WSError) {
                return $course_id;
            } else {
                // Course exists, get its descriptions
                $descriptions = CourseDescription::get_descriptions($course_id);
                $results = [];
                foreach ($descriptions as $description) {
                    $results[] = [
                        'course_desc_id' => $description->get_description_type(
                        ),
                        'course_desc_title' => $description->get_title(),
                        'course_desc_content' => $description->get_content(),
                    ];
                }

                return $results;
            }
        }
    }

    /**
     * Edit course description.
     *
     * @param string API secret key
     * @param string Course id field name
     * @param string Course id value
     * @param int Category id from course description
     * @param string Description title
     * @param string Course description content
     */
    public function EditCourseDescription(
        $secret_key,
        $course_id_field_name,
        $course_id_value,
        $course_desc_id,
        $course_desc_title,
        $course_desc_content
    ) {
        $verifKey = $this->verifyKey($secret_key);
        if ($verifKey instanceof WSError) {
            $this->handleError($verifKey);
        } else {
            $course_id = $this->getCourseId(
                $course_id_field_name,
                $course_id_value
            );
            if ($course_id instanceof WSError) {
                return $course_id;
            } else {
                // Create the new course description
                $cd = new CourseDescription();
                $cd->set_description_type($course_desc_id);
                $cd->set_title($course_desc_title);
                $cd->set_content($course_desc_content);
                $cd->set_session_id(0);
                // Get course info
                $course_info = CourseManager::get_course_information(
                    CourseManager::get_course_code_from_course_id($course_id)
                );
                $cd->set_course_id($course_info['real_id']);
                // Check if this course description exists
                $descriptions = CourseDescription::get_descriptions($course_id);
                $exists = false;
                foreach ($descriptions as $description) {
                    if ($description->get_description_type() == $course_desc_id) {
                        $exists = true;
                    }
                }
                if (!$exists) {
                    $cd->set_progress(0);
                    $cd->insert();
                } else {
                    $cd->update();
                }
            }
        }
    }

    /**
     * Deletes a course (helper method).
     *
     * @param string Course id field name
     * @param string Course id value
     *
     * @return mixed True if the course was successfully deleted, WSError otherwise
     */
    protected function deleteCourseHelper(
        $course_id_field_name,
        $course_id_value
    ) {
        $course_id = $this->getCourseId(
            $course_id_field_name,
            $course_id_value
        );
        if ($course_id instanceof WSError) {
            return $course_id;
        } else {
            $course_code = CourseManager::get_course_code_from_course_id(
                $course_id
            );
            CourseManager::delete_course($course_code);

            return true;
        }
    }

    /**
     * Creates a course (helper method).
     *
     * @param string Title
     * @param string Category code
     * @param string Wanted code. If it's not defined, it will be generated automatically
     * @param string Tutor name
     * @param string Course admin user id field name
     * @param string Course admin user id value
     * @param string Course language
     * @param string Course id field name
     * @param string Course id value
     * @param array Course extra fields
     *
     * @return mixed Generated id if creation was successful, WSError otherwise
     */
    protected function createCourseHelper(
        $title,
        $category_code,
        $wanted_code,
        $tutor_name,
        $course_admin_user_id_field_name,
        $course_admin_user_id_value,
        $language,
        $course_id_field_name,
        $course_id_value,
        $extras
    ) {
        // Add the original course id field name and value to the extra fields if needed
        $extras_associative = [];
        if ($course_id_field_name != "chamilo_course_id") {
            $extras_associative[$course_id_field_name] = $course_id_value;
        }
        foreach ($extras as $extra) {
            $extras_associative[$extra['field_name']] = $extra['field_value'];
        }
        $course_admin_id = $this->getUserId(
            $course_admin_user_id_field_name,
            $course_admin_user_id_value
        );
        if ($course_admin_id instanceof WSError) {
            return $course_admin_id;
        }
        if ($wanted_code == '') {
            $wanted_code = CourseManager::generate_course_code($title);
        }
        $result = create_course(
            $wanted_code,
            $title,
            $tutor_name,
            $category_code,
            $language,
            $course_admin_id,
            $this->_configuration['db_prefix'],
            0
        );
        if (!$result) {
            return new WSError(202, 'There was an error creating the course');
        } else {
            // Update extra fields
            foreach ($extras_associative as $fname => $fvalue) {
                CourseManager::update_course_extra_field_value(
                    $result,
                    $fname,
                    $fvalue
                );
            }
            // Get course id
            $course_info = CourseManager::get_course_information($result);

            return $course_info['real_id'];
        }
    }

    /**
     * Edits a course (helper method).
     *
     * @param string Course id field name
     * @param string Course id value
     * @param string Title
     * @param string Category code
     * @param string Department name
     * @param string Department url
     * @param string Course language
     * @param int Visibility
     * @param int Subscribe (0 = denied, 1 = allowed)
     * @param int Unsubscribe (0 = denied, 1 = allowed)
     * @param string Visual code
     * @param array Course extra fields
     *
     * @return mixed True in case of success, WSError otherwise
     */
    protected function editCourseHelper(
        $course_id_field_name,
        $course_id_value,
        $title,
        $category_code,
        $department_name,
        $department_url,
        $language,
        $visibility,
        $subscribe,
        $unsubscribe,
        $visual_code,
        $extras
    ) {
        $course_id = $this->getCourseId(
            $course_id_field_name,
            $course_id_value
        );
        if ($course_id instanceof WSError) {
            return $course_id;
        } else {
            $attributes = [];
            if (!empty($title)) {
                $attributes['title'] = $title;
            }
            if (!empty($category_code)) {
                $attributes['category_code'] = $category_code;
            }
            if (!empty($department_name)) {
                $attributes['department_name'] = $department_name;
            }
            if (!empty($department_url)) {
                $attributes['department_url'] = $department_url;
            }
            if (!empty($language)) {
                $attributes['course_language'] = $language;
            }
            if ($visibility != '') {
                $attributes['visibility'] = (int) $visibility;
            }
            if ($subscribe != '') {
                $attributes['subscribe'] = (int) $subscribe;
            }
            if ($unsubscribe != '') {
                $attributes['unsubscribe'] = (int) $unsubscribe;
            }
            if (!empty($visual_code)) {
                $attributes['visual_code'] = $visual_code;
            }
            if (!empty($attributes)) {
                CourseManager::update_attributes($course_id, $attributes);
            }
            if (!empty($extras)) {
                $course_code = CourseManager::get_course_code_from_course_id(
                    $course_id
                );
                $extras_associative = [];
                foreach ($extras as $extra) {
                    $extras_associative[$extra['field_name']] = $extra['field_value'];
                }
                foreach ($extras_associative as $fname => $fvalue) {
                    CourseManager::update_extra_field_value(
                        $course_code,
                        $fname,
                        $fvalue
                    );
                }
            }

            return true;
        }
    }

    /**
     * Subscribe or unsubscribe user to a course (helper method).
     *
     * @param string Course id field name. Use "chamilo_course_id" to use internal id
     * @param string course id value
     * @param string User id field name. Use "chamilo_user_id" to use internal id
     * @param string User id value
     * @param int Set to 1 to subscribe, 0 to unsubscribe
     * @param int Status (STUDENT or TEACHER) Used for subscription only
     *
     * @return mixed True if subscription or unsubscription was successful, false otherwise
     */
    protected function changeUserSubscription(
        $course_id_field_name,
        $course_id_value,
        $user_id_field_name,
        $user_id_value,
        $state,
        $status = STUDENT
    ) {
        $course_id = $this->getCourseId(
            $course_id_field_name,
            $course_id_value
        );
        if ($course_id instanceof WSError) {
            return $course_id;
        } else {
            $user_id = $this->getUserId($user_id_field_name, $user_id_value);
            if ($user_id instanceof WSError) {
                return $user_id;
            } else {
                $course_code = CourseManager::get_course_code_from_course_id(
                    $course_id
                );
                if ($state == 0) {
                    // Unsubscribe user
                    CourseManager::unsubscribe_user($user_id, $course_code);

                    return true;
                } else {
                    // Subscribe user
                    if (CourseManager::subscribeUser(
                        $user_id,
                        $course_code,
                        $status
                    )
                    ) {
                        return true;
                    } else {
                        return new WSError(
                            203,
                            'An error occured subscribing to this course'
                        );
                    }
                }
            }
        }
    }
}


1			<?php
2			/* For licensing terms, see /license.txt */
3			/**
4			* @package chamilo.webservices
5			*/
6			require_once __DIR__.'/../inc/global.inc.php';
7			require_once __DIR__.'/webservice.php';
8
9			/**
10			* Web services available for the Course module. This class extends the WS class.
11			*/
12			class WSCourse extends WS
13			{
14			/**
15			* Deletes a course.
16			*
17			* @param string API secret key
18			* @param string Course id field name
19			* @param string Course id value
20			*/
21			public function DeleteCourse(
22			$secret_key,
23			$course_id_field_name,
24			$course_id_value
25			) {
26			$verifKey = $this->verifyKey($secret_key);
27			if ($verifKey instanceof WSError) {
28			$this->handleError($verifKey);
29			} else {
30			$result = $this->deleteCourseHelper(
31			$course_id_field_name,
32			$course_id_value
33			);
34			if ($result instanceof WSError) {
35			$this->handleError($result);
36			}
37			}
38			}
39
40			/**
41			* Deletes multiple courses.
42			*
43			* @param string API secret key
44			* @param array Array of courses with elements of the form
45			* array('course_id_field_name' => 'name_of_field', 'course_id_value' => 'value')
46			*
47			* @return array Array with elements like
48			* array('course_id_value' => 'value', 'result' => array('code' => 0, 'message' => 'Operation was successful')).
49			* Note that if the result array contains a code different
50			* than 0, an error occured
51			*/
52			public function DeleteCourses($secret_key, $courses)
53			{
54			$verifKey = $this->verifyKey($secret_key);
55			if ($verifKey instanceof WSError) {
56			$this->handleError($verifKey);
57			} else {
58			$results = [];
59			foreach ($courses as $course) {
60			$result_tmp = [];
61			$result_op = $this->deleteCourseHelper(
62			$course['course_id_field_name'],
63			$course['course_id_value']
64			);
65			$result_tmp['course_id_value'] = $course['course_id_value'];
66			if ($result_op instanceof WSError) {
67			// Return the error in the results
68			$result_tmp['result'] = $result_op->toArray();
69			} else {
70			$result_tmp['result'] = $this->getSuccessfulResult();
71			}
72			$results[] = $result_tmp;
73			}
74
75			return $results;
76			}
77			}
78
79			/**
80			* Creates a course.
81			*
82			* @param string API secret key
83			* @param string Title
84			* @param string Category code
85			* @param string Wanted code. If it's not defined, it will be generated automatically
86			* @param string Tutor name
87			* @param string Course admin user id field name
88			* @param string Course admin user id value
89			* @param string Course language
90			* @param string Course id field name
91			* @param string Course id value
92			* @param array Course extra fields
93			*
94			* @return int Course id generated
95			*/
96			public function CreateCourse(
97			$secret_key,
98			$title,
99			$category_code,
100			$wanted_code,
101			$tutor_name,
102			$course_admin_user_id_field_name,
103			$course_admin_user_id_value,
104			$language,
105			$course_id_field_name,
106			$course_id_value,
107			$extras
108			) {
109			// First, verify the secret key
110			$verifKey = $this->verifyKey($secret_key);
111			if ($verifKey instanceof WSError) {
112			$this->handleError($verifKey);
113			} else {
114			$result = $this->createCourseHelper(
115			$title,
116			$category_code,
117			$wanted_code,
118			$tutor_name,
119			$course_admin_user_id_field_name,
120			$course_admin_user_id_value,
121			$language,
122			$course_id_field_name,
123			$course_id_value,
124			$extras
125			);
126			if ($result instanceof WSError) {
127			$this->handleError($result);
128			} else {
129			return $result;
130			}
131			}
132			}
133
134			/**
135			* Create multiple courses.
136			*
137			* @param string API secret key
138			* @param array Courses to be created, with elements following the structure presented in CreateCourse
139			*
140			* @return array Array with elements of the form
141			* array('course_id_value' => 'original value sent', 'course_id_generated' => 'value_generated', 'result' => array('code' => 0, 'message' => 'Operation was successful'))
142			*/
143			public function CreateCourses($secret_key, $courses)
144			{
145			// First, verify the secret key
146			$verifKey = $this->verifyKey($secret_key);
147			if ($verifKey instanceof WSError) {
148			$this->handleError($verifKey);
149			} else {
150			$results = [];
151			foreach ($courses as $course) {
152			$result_tmp = [];
153			// re-initialize variables just in case
154			$title = $category_code = $wanted_code = $tutor_name = $course_admin_user_id_field_name = $course_admin_user_id_value = $language = $course_id_field_name = $course_id_value = $extras = 0;
155			extract($course);
156			$result = $this->createCourseHelper(
157			$title,
158			$category_code,
159			$wanted_code,
160			$tutor_name,
161			$course_admin_user_id_field_name,
162			$course_admin_user_id_value,
163			$language,
164			$course_id_field_name,
165			$course_id_value,
166			$extras
167			);
168			if ($result instanceof WSError) {
169			$result_tmp['result'] = $result->toArray();
170			$result_tmp['course_id_value'] = $course_id_value;
171			$result_tmp['course_id_generated'] = 0;
172			} else {
173			$result_tmp['result'] = $this->getSuccessfulResult();
174			$result_tmp['course_id_value'] = $course_id_value;
175			$result_tmp['course_id_generated'] = $result;
176			}
177			$results[] = $result_tmp;
178			}
179
180			return $results;
181			}
182			}
183
184			/**
185			* Edits a course.
186			*
187			* @param string API secret key
188			* @param string Course id field name
189			* @param string Course id value
190			* @param string Title
191			* @param string Category code
192			* @param string Department name
193			* @param string Department url
194			* @param string Course language
195			* @param int Visibility
196			* @param int Subscribe (0 = denied, 1 = allowed)
197			* @param int Unsubscribe (0 = denied, 1 = allowed)
198			* @param string Visual code
199			* @param array Course extra fields
200			*/
201			public function EditCourse(
202			$secret_key,
203			$course_id_field_name,
204			$course_id_value,
205			$title,
206			$category_code,
207			$department_name,
208			$department_url,
209			$language,
210			$visibility,
211			$subscribe,
212			$unsubscribe,
213			$visual_code,
214			$extras
215			) {
216			$verifKey = $this->verifyKey($secret_key);
217			if ($verifKey instanceof WSError) {
218			$this->handleError($verifKey);
219			} else {
220			$result = $this->editCourseHelper(
221			$course_id_field_name,
222			$course_id_value,
223			$title,
224			$category_code,
225			$department_name,
226			$department_url,
227			$language,
228			$visibility,
229			$subscribe,
230			$unsubscribe,
231			$visual_code,
232			$extras
233			);
234			if ($result instanceof WSError) {
235			$this->handleError($result);
236			}
237			}
238			}
239
240			/**
241			* List courses.
242			*
243			* @param string API secret key
244			* @param string A list of visibility filter we want to apply
245			*
246			* @return array An array with elements of the form
247			* ('id' => 'Course internal id', 'code' => 'Course code', 'title' => 'Course title', 'language' => 'Course language', 'visibility' => 'Course visibility',
248			* 'category_name' => 'Name of the category of the course', 'number_students' => 'Number of students in the course', 'external_course_id' => 'External course id')
249			*/
250			public function ListCourses(
251			$secret_key,
252			$visibility = 'public,public-registered,private,closed'
253			) {
254			$verifKey = $this->verifyKey($secret_key);
255			if ($verifKey instanceof WSError) {
256			$this->handleError($verifKey);
257			} else {
258			$visibilities = split(',', $visibility);
259			$vis = [
260			'public' => '3',
261			'public-registered' => '2',
262			'private' => '1',
263			'closed' => '0',
264			];
265			foreach ($visibilities as $p => $visibility) {
266			$visibilities[$p] = $vis[$visibility];
267			}
268			$courses_result = [];
269			$category_names = [];
270
271			$courses = CourseManager::get_courses_list();
272			foreach ($courses as $course) {
273			//skip elements that do not match required visibility
274			if (!in_array($course['visibility'], $visibilities)) {
275			continue;
276			}
277			$course_tmp = [];
278			$course_tmp['id'] = $course['id'];
279			$course_tmp['code'] = $course['code'];
280			$course_tmp['title'] = $course['title'];
281			$course_tmp['language'] = $course['course_language'];
282			$course_tmp['visibility'] = $course['visibility'];
283
284			// Determining category name
285			if ($category_names[$course['category_code']]) {
286			$course_tmp['category_name'] = $category_names[$course['category_code']];
287			} else {
288			$category = CourseManager::get_course_category(
289			$course['category_code']
290			);
291			$category_names[$course['category_code']] = $category['name'];
292			$course_tmp['category_name'] = $category['name'];
293			}
294
295			// Determining number of students registered in course
296			$user_list = CourseManager::get_user_list_from_course_code(
297			$course['code'],
298			0
299			);
300			$course_tmp['number_students'] = count($user_list);
301
302			// Determining external course id - this code misses the external course id field name
303			// $course_tmp['external_course_id'] = CourseManager::get_course_extra_field_value($course_field_name, $course['code']);
304
305			$courses_result[] = $course_tmp;
306			}
307
308			return $courses_result;
309			}
310			}
311
312			/**
313			* Subscribe user to a course.
314			*
315			* @param string API secret key
316			* @param string Course id field name. Use "chamilo_course_id" to use internal id
317			* @param string course id value
318			* @param string User id field name. Use "chamilo_user_id" to use internal id
319			* @param string User id value
320			* @param int Status (1 = Teacher, 5 = Student)
321			*/
322			public function SubscribeUserToCourse(
323			$secret_key,
324			$course_id_field_name,
325			$course_id_value,
326			$user_id_field_name,
327			$user_id_value,
328			$status
329			) {
330			$verifKey = $this->verifyKey($secret_key);
331			if ($verifKey instanceof WSError) {
332			$this->handleError($verifKey);
333			} else {
334			$result = $this->changeUserSubscription(
335			$course_id_field_name,
336			$course_id_value,
337			$user_id_field_name,
338			$user_id_value,
339			1,
340			$status
341			);
342			if ($result instanceof WSError) {
343			$this->handleError($result);
344			}
345			}
346			}
347
348			/**
349			* Unsusbscribe user from course.
350			*
351			* @param string API secret key
352			* @param string Course id field name. Use "chamilo_course_id" to use internal id
353			* @param string course id value
354			* @param string User id field name. Use "chamilo_user_id" to use internal id
355			* @param string User id value
356			*/
357			public function UnsubscribeUserFromCourse(
358			$secret_key,
359			$course_id_field_name,
360			$course_id_value,
361			$user_id_field_name,
362			$user_id_value
363			) {
364			$verifKey = $this->verifyKey($secret_key);
365			if ($verifKey instanceof WSError) {
366			$this->handleError($verifKey);
367			} else {
368			$result = $this->changeUserSubscription(
369			$course_id_field_name,
370			$course_id_value,
371			$user_id_field_name,
372			$user_id_value,
373			0
374			);
375			if ($result instanceof WSError) {
376			$this->handleError($result);
377			}
378			}
379			}
380
381			/**
382			* Returns the descriptions of a course, along with their id.
383			*
384			* @param string API secret key
385			* @param string Course id field name
386			* @param string Course id value
387			*
388			* @return array Returns an array with elements of the form
389			* array('course_desc_id' => 1, 'course_desc_title' => 'Title', 'course_desc_content' => 'Content')
390			*/
391			public function GetCourseDescriptions(
392			$secret_key,
393			$course_id_field_name,
394			$course_id_value
395			) {
396			$verifKey = $this->verifyKey($secret_key);
397			if ($verifKey instanceof WSError) {
398			$this->handleError($verifKey);
399			} else {
400			$course_id = $this->getCourseId(
401			$course_id_field_name,
402			$course_id_value
403			);
404			if ($course_id instanceof WSError) {
405			return $course_id;
406			} else {
407			// Course exists, get its descriptions
408			$descriptions = CourseDescription::get_descriptions($course_id);
409			$results = [];
410			foreach ($descriptions as $description) {
411			$results[] = [
412			'course_desc_id' => $description->get_description_type(
413			),
414			'course_desc_title' => $description->get_title(),
415			'course_desc_content' => $description->get_content(),
416			];
417			}
418
419			return $results;
420			}
421			}
422			}
423
424			/**
425			* Edit course description.
426			*
427			* @param string API secret key
428			* @param string Course id field name
429			* @param string Course id value
430			* @param int Category id from course description
431			* @param string Description title
432			* @param string Course description content
433			*/
434			public function EditCourseDescription(
435			$secret_key,
436			$course_id_field_name,
437			$course_id_value,
438			$course_desc_id,
439			$course_desc_title,
440			$course_desc_content
441			) {
442			$verifKey = $this->verifyKey($secret_key);
443			if ($verifKey instanceof WSError) {
444			$this->handleError($verifKey);
445			} else {
446			$course_id = $this->getCourseId(
447			$course_id_field_name,
448			$course_id_value
449			);
450			if ($course_id instanceof WSError) {
451			return $course_id;
452			} else {
453			// Create the new course description
454			$cd = new CourseDescription();
455			$cd->set_description_type($course_desc_id);
456			$cd->set_title($course_desc_title);
457			$cd->set_content($course_desc_content);
458			$cd->set_session_id(0);
459			// Get course info
460			$course_info = CourseManager::get_course_information(
461			CourseManager::get_course_code_from_course_id($course_id)
462			);
463			$cd->set_course_id($course_info['real_id']);
464			// Check if this course description exists
465			$descriptions = CourseDescription::get_descriptions($course_id);
466			$exists = false;
467			foreach ($descriptions as $description) {
468			if ($description->get_description_type() == $course_desc_id) {
469			$exists = true;
470			}
471			}
472			if (!$exists) {
473			$cd->set_progress(0);
474			$cd->insert();
475			} else {
476			$cd->update();
477			}
478			}
479			}
480			}
481
482			/**
483			* Deletes a course (helper method).
484			*
485			* @param string Course id field name
486			* @param string Course id value
487			*
488			* @return mixed True if the course was successfully deleted, WSError otherwise
489			*/
490			protected function deleteCourseHelper(
491			$course_id_field_name,
492			$course_id_value
493			) {
494			$course_id = $this->getCourseId(
495			$course_id_field_name,
496			$course_id_value
497			);
498			if ($course_id instanceof WSError) {
499			return $course_id;
500			} else {
501			$course_code = CourseManager::get_course_code_from_course_id(
502			$course_id
503			);
504			CourseManager::delete_course($course_code);
505
506			return true;
507			}
508			}
509
510			/**
511			* Creates a course (helper method).
512			*
513			* @param string Title
514			* @param string Category code
515			* @param string Wanted code. If it's not defined, it will be generated automatically
516			* @param string Tutor name
517			* @param string Course admin user id field name
518			* @param string Course admin user id value
519			* @param string Course language
520			* @param string Course id field name
521			* @param string Course id value
522			* @param array Course extra fields
523			*
524			* @return mixed Generated id if creation was successful, WSError otherwise
525			*/
526			protected function createCourseHelper(
527			$title,
528			$category_code,
529			$wanted_code,
530			$tutor_name,
531			$course_admin_user_id_field_name,
532			$course_admin_user_id_value,
533			$language,
534			$course_id_field_name,
535			$course_id_value,
536			$extras
537			) {
538			// Add the original course id field name and value to the extra fields if needed
539			$extras_associative = [];
540			if ($course_id_field_name != "chamilo_course_id") {
541			$extras_associative[$course_id_field_name] = $course_id_value;
542			}
543			foreach ($extras as $extra) {
544			$extras_associative[$extra['field_name']] = $extra['field_value'];
545			}
546			$course_admin_id = $this->getUserId(
547			$course_admin_user_id_field_name,
548			$course_admin_user_id_value
549			);
550			if ($course_admin_id instanceof WSError) {
551			return $course_admin_id;
552			}
553			if ($wanted_code == '') {
554			$wanted_code = CourseManager::generate_course_code($title);
555			}
556			$result = create_course(
557			$wanted_code,
558			$title,
559			$tutor_name,
560			$category_code,
561			$language,
562			$course_admin_id,
563			$this->_configuration['db_prefix'],
564			0
565			);
566			if (!$result) {
567			return new WSError(202, 'There was an error creating the course');
568			} else {
569			// Update extra fields
570			foreach ($extras_associative as $fname => $fvalue) {
571			CourseManager::update_course_extra_field_value(
572			$result,
573			$fname,
574			$fvalue
575			);
576			}
577			// Get course id
578			$course_info = CourseManager::get_course_information($result);
579
580			return $course_info['real_id'];
581			}
582			}
583
584			/**
585			* Edits a course (helper method).
586			*
587			* @param string Course id field name
588			* @param string Course id value
589			* @param string Title
590			* @param string Category code
591			* @param string Department name
592			* @param string Department url
593			* @param string Course language
594			* @param int Visibility
595			* @param int Subscribe (0 = denied, 1 = allowed)
596			* @param int Unsubscribe (0 = denied, 1 = allowed)
597			* @param string Visual code
598			* @param array Course extra fields
599			*
600			* @return mixed True in case of success, WSError otherwise
601			*/
602			protected function editCourseHelper(
603			$course_id_field_name,
604			$course_id_value,
605			$title,
606			$category_code,
607			$department_name,
608			$department_url,
609			$language,
610			$visibility,
611			$subscribe,
612			$unsubscribe,
613			$visual_code,
614			$extras
615			) {
616			$course_id = $this->getCourseId(
617			$course_id_field_name,
618			$course_id_value
619			);
620			if ($course_id instanceof WSError) {
621			return $course_id;
622			} else {
623			$attributes = [];
624			if (!empty($title)) {
625			$attributes['title'] = $title;
626			}
627			if (!empty($category_code)) {
628			$attributes['category_code'] = $category_code;
629			}
630			if (!empty($department_name)) {
631			$attributes['department_name'] = $department_name;
632			}
633			if (!empty($department_url)) {
634			$attributes['department_url'] = $department_url;
635			}
636			if (!empty($language)) {
637			$attributes['course_language'] = $language;
638			}
639			if ($visibility != '') {
640			$attributes['visibility'] = (int) $visibility;
641			}
642			if ($subscribe != '') {
643			$attributes['subscribe'] = (int) $subscribe;
644			}
645			if ($unsubscribe != '') {
646			$attributes['unsubscribe'] = (int) $unsubscribe;
647			}
648			if (!empty($visual_code)) {
649			$attributes['visual_code'] = $visual_code;
650			}
651			if (!empty($attributes)) {
652			CourseManager::update_attributes($course_id, $attributes);
653			}
654			if (!empty($extras)) {
655			$course_code = CourseManager::get_course_code_from_course_id(
656			$course_id
657			);
658			$extras_associative = [];
659			foreach ($extras as $extra) {
660			$extras_associative[$extra['field_name']] = $extra['field_value'];
661			}
662			foreach ($extras_associative as $fname => $fvalue) {
663			CourseManager::update_extra_field_value(
664			$course_code,
665			$fname,
666			$fvalue
667			);
668			}
669			}
670
671			return true;
672			}
673			}
674
675			/**
676			* Subscribe or unsubscribe user to a course (helper method).
677			*
678			* @param string Course id field name. Use "chamilo_course_id" to use internal id
679			* @param string course id value
680			* @param string User id field name. Use "chamilo_user_id" to use internal id
681			* @param string User id value
682			* @param int Set to 1 to subscribe, 0 to unsubscribe
683			* @param int Status (STUDENT or TEACHER) Used for subscription only
684			*
685			* @return mixed True if subscription or unsubscription was successful, false otherwise
686			*/
687			protected function changeUserSubscription(
688			$course_id_field_name,
689			$course_id_value,
690			$user_id_field_name,
691			$user_id_value,
692			$state,
693			$status = STUDENT
694			) {
695			$course_id = $this->getCourseId(
696			$course_id_field_name,
697			$course_id_value
698			);
699			if ($course_id instanceof WSError) {
700			return $course_id;
701			} else {
702			$user_id = $this->getUserId($user_id_field_name, $user_id_value);
703			if ($user_id instanceof WSError) {
704			return $user_id;
705			} else {
706			$course_code = CourseManager::get_course_code_from_course_id(
707			$course_id
708			);
709			if ($state == 0) {
710			// Unsubscribe user
711			CourseManager::unsubscribe_user($user_id, $course_code);
712
713			return true;
714			} else {
715			// Subscribe user
716			if (CourseManager::subscribeUser(
717			$user_id,
718			$course_code,
719			$status
720			)
721			) {
722			return true;
723			} else {
724			return new WSError(
725			203,
726			'An error occured subscribing to this course'
727			);
728			}
729			}
730			}
731			}
732			}
733			}
734

chamilo / chamilo-lms

Push — master ( f41061...196bfc )

WSCourse::CreateCourse() A

Complexity

Size

Duplication

Importance

How to fix Many Parameters

Many Parameters

Duplication Side-by-Side

Filter issues like