chamilo/chamilo-lms

View on GitHub
public/main/inc/lib/course_request.lib.php

Summary

Maintainability
A
0 mins
Test Coverage

The method create_course_request() has an NPath complexity of 256. The configured NPath complexity threshold is 200.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

NPathComplexity

Since: 0.1

The NPath complexity of a method is the number of acyclic execution paths through that method. A threshold of 200 is generally considered the point where measures should be taken to reduce complexity.

Example

class Foo {
    function bar() {
        // lots of complicated code
    }
}

Source https://phpmd.org/rules/codesize.html#npathcomplexity

The method update_course_request has 10 parameters. Consider reducing the number of parameters to less than 10.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

The method update_course_request() has an NPath complexity of 720. The configured NPath complexity threshold is 200.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

NPathComplexity

Since: 0.1

The NPath complexity of a method is the number of acyclic execution paths through that method. A threshold of 200 is generally considered the point where measures should be taken to reduce complexity.

Example

class Foo {
    function bar() {
        // lots of complicated code
    }
}

Source https://phpmd.org/rules/codesize.html#npathcomplexity

The method update_course_request uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them.
Open

            } else {
                return false;
            }

ElseExpression

Since: 1.4.0

An if expression with an else branch is basically not necessary. You can rewrite the conditions in a way that the else clause is not necessary and the code becomes simpler to read. To achieve this, use early return statements, though you may need to split the code it several smaller methods. For very simple assignments you could also use the ternary operations.

Example

class Foo
{
    public function bar($flag)
    {
        if ($flag) {
            // one branch
        } else {
            // another branch
        }
    }
}

Source https://phpmd.org/rules/cleancode.html#elseexpression

Avoid assigning values to variables in if clauses and the like (line '27', column '13').
Open

    public static function course_code_exists($wanted_course_code)
    {
        if ($code_exists = CourseManager::course_code_exists($wanted_course_code)) {
            return $code_exists;
        }

IfStatementAssignment

Since: 2.7.0

Assignments in if clauses and the like are considered a code smell. Assignments in PHP return the right operand as their result. In many cases, this is an expected behavior, but can lead to many difficult to spot bugs, especially when the right operand could result in zero, null or an empty string and the like.

Example

class Foo
{
    public function bar($flag)
    {
        if ($foo = 'bar') { // possible typo
            // ...
        }
        if ($baz = 0) { // always false
            // ...
        }
    }
}

Source http://phpmd.org/rules/cleancode.html#ifstatementassignment

The method count_course_requests uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them.
Open

        } else {
            $status = (int) $status;
            $sql = "SELECT COUNT(id) AS number FROM ".$course_table."
                    WHERE status = ".$status;
        }

ElseExpression

Since: 1.4.0

An if expression with an else branch is basically not necessary. You can rewrite the conditions in a way that the else clause is not necessary and the code becomes simpler to read. To achieve this, use early return statements, though you may need to split the code it several smaller methods. For very simple assignments you could also use the ternary operations.

Example

class Foo
{
    public function bar($flag)
    {
        if ($flag) {
            // one branch
        } else {
            // another branch
        }
    }
}

Source https://phpmd.org/rules/cleancode.html#elseexpression

The method update_course_request uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them.
Open

            } else {
                $user_id = $course_request_info['code'];
            }

ElseExpression

Since: 1.4.0

An if expression with an else branch is basically not necessary. You can rewrite the conditions in a way that the else clause is not necessary and the code becomes simpler to read. To achieve this, use early return statements, though you may need to split the code it several smaller methods. For very simple assignments you could also use the ternary operations.

Example

class Foo
{
    public function bar($flag)
    {
        if ($flag) {
            // one branch
        } else {
            // another branch
        }
    }
}

Source https://phpmd.org/rules/cleancode.html#elseexpression

Avoid unused local variables such as '$directory'.
Open

        $directory = $keys['currentCourseRepository'];

UnusedLocalVariable

Since: 0.2

Detects when a local variable is declared and/or assigned, but not used.

Example

class Foo {
    public function doSomething()
    {
        $i = 5; // Unused
    }
}

Source https://phpmd.org/rules/unusedcode.html#unusedlocalvariable

Avoid unused local variables such as '$db_name'.
Open

        $db_name = isset($keys['currentCourseDbName']) ? $keys['currentCourseDbName'] : null;

UnusedLocalVariable

Since: 0.2

Detects when a local variable is declared and/or assigned, but not used.

Example

class Foo {
    public function doSomething()
    {
        $i = 5; // Unused
    }
}

Source https://phpmd.org/rules/unusedcode.html#unusedlocalvariable

The parameter $wanted_code is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseParameterName

Since: 0.2

It is considered best practice to use the camelCase notation to name parameters.

Example

class ClassName {
    public function doSomething($user_name) {
    }
}

Source

The parameter $category_code is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseParameterName

Since: 0.2

It is considered best practice to use the camelCase notation to name parameters.

Example

class ClassName {
    public function doSomething($user_name) {
    }
}

Source

The parameter $target_audience is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseParameterName

Since: 0.2

It is considered best practice to use the camelCase notation to name parameters.

Example

class ClassName {
    public function doSomething($user_name) {
    }
}

Source

The parameter $wanted_code is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseParameterName

Since: 0.2

It is considered best practice to use the camelCase notation to name parameters.

Example

class ClassName {
    public function doSomething($user_name) {
    }
}

Source

The parameter $wanted_course_code is not named in camelCase.
Open

    public static function course_code_exists($wanted_course_code)
    {
        if ($code_exists = CourseManager::course_code_exists($wanted_course_code)) {
            return $code_exists;
        }

CamelCaseParameterName

Since: 0.2

It is considered best practice to use the camelCase notation to name parameters.

Example

class ClassName {
    public function doSomething($user_name) {
    }
}

Source

The parameter $exemplary_content is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseParameterName

Since: 0.2

It is considered best practice to use the camelCase notation to name parameters.

Example

class ClassName {
    public function doSomething($user_name) {
    }
}

Source

The parameter $course_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseParameterName

Since: 0.2

It is considered best practice to use the camelCase notation to name parameters.

Example

class ClassName {
    public function doSomething($user_name) {
    }
}

Source

The parameter $target_audience is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseParameterName

Since: 0.2

It is considered best practice to use the camelCase notation to name parameters.

Example

class ClassName {
    public function doSomething($user_name) {
    }
}

Source

The parameter $user_id is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseParameterName

Since: 0.2

It is considered best practice to use the camelCase notation to name parameters.

Example

class ClassName {
    public function doSomething($user_name) {
    }
}

Source

The parameter $category_code is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseParameterName

Since: 0.2

It is considered best practice to use the camelCase notation to name parameters.

Example

class ClassName {
    public function doSomething($user_name) {
    }
}

Source

The parameter $exemplary_content is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseParameterName

Since: 0.2

It is considered best practice to use the camelCase notation to name parameters.

Example

class ClassName {
    public function doSomething($user_name) {
    }
}

Source

The parameter $user_id is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseParameterName

Since: 0.2

It is considered best practice to use the camelCase notation to name parameters.

Example

class ClassName {
    public function doSomething($user_name) {
    }
}

Source

The parameter $course_language is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseParameterName

Since: 0.2

It is considered best practice to use the camelCase notation to name parameters.

Example

class ClassName {
    public function doSomething($user_name) {
    }
}

Source

Variable "table_course_request" is not in valid camel caps format
Open

        $table_course_request = Database::get_main_table(TABLE_MAIN_COURSE_REQUEST);

Variable "tutor_name" is not in valid camel caps format
Open

        $tutor_name = api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $course_language);

Variable "course_language" is not in valid camel caps format
Open

        $tutor_name = api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $course_language);

Variable "email_body" is not in valid camel caps format
Open

        $email_body = get_lang('We registered the following request for a new course:', $email_language)."\n\n";

Variable "email_body" is not in valid camel caps format
Open

        $email_body_admin = $email_body;

Variable "email_language" is not in valid camel caps format
Open

        $email_body_admin .= "\n".get_lang('This course request can be approved on the following page:', $email_language).' '.api_get_path(WEB_CODE_PATH).'admin/course_request_edit.php?id='.$last_insert_id."\n";

Variable "user_info" is not in valid camel caps format
Open

        $sender_email_teacher = $user_info['mail'];

Variable "code_exists" is not in valid camel caps format
Open

            return $code_exists;

Variable "request_date" is not in valid camel caps format
Open

        $request_date = api_get_utc_datetime();

Variable "wanted_code" is not in valid camel caps format
Open

        $keys = AddCourse::define_course_keys($wanted_code, '');

Variable "db_name" is not in valid camel caps format
Open

        $db_name = isset($keys['currentCourseDbName']) ? $keys['currentCourseDbName'] : null;

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= get_lang('Course name', $email_language).': '.$title."\n";

Variable "user_info" is not in valid camel caps format
Open

        $email_body .= get_lang('Professor', $email_language).': '.api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $email_language)."\n";

Variable "user_info" is not in valid camel caps format
Open

        $email_body .= get_lang('Email', $email_language).': '.$user_info['mail']."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Description', $email_language).': '.$description."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Fill with demo content', $email_language).': '.($exemplary_content ? get_lang('Yes', $email_language) : get_lang('No', $email_language))."\n";

Variable "user_info" is not in valid camel caps format
Open

        $user_info = api_get_user_info($user_id);

Variable "tutor_name" is not in valid camel caps format
Open

            Database::escape_string($tutor_name),

Variable "email_language" is not in valid camel caps format
Open

        $email_language = api_get_setting('platformLanguage');

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Course name', $email_language).': '.$title."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Professor', $email_language).': '.api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $email_language)."\n";

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= get_lang('Target audience', $email_language).': '.$target_audience."\n";

Variable "user_info" is not in valid camel caps format
Open

        $email_body_teacher .= api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $email_language).",\n\n";

Variable "email_body_teacher" is not in valid camel caps format
Open

            $email_body_teacher,

Variable "course_request_info" is not in valid camel caps format
Open

        $visual_code = $course_request_info['visual_code'];

Variable "course_request_info" is not in valid camel caps format
Open

        $status = $course_request_info['status'];

Variable "result_sql" is not in valid camel caps format
Open

        $result_sql = Database::query($sql);

Variable "user_id" is not in valid camel caps format
Open

        $user_info = api_get_user_info($user_id);

Variable "exemplary_content" is not in valid camel caps format
Open

        $exemplary_content = (int) $exemplary_content;

Variable "category_code" is not in valid camel caps format
Open

            Database::escape_string($category_code),

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= get_lang('Professor', $email_language).': '.api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $email_language)."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body_admin .= "\n".get_lang('The information about this course request is considered protected; it can be used only to open a new course within our e-learning portal; it should not be revealed to third parties.', $email_language)."\n";

Variable "user_info" is not in valid camel caps format
Open

        $sender_name_teacher = api_get_person_name($user_info['firstname'], $user_info['lastname'], null, PERSON_NAME_EMAIL_ADDRESS);

Variable "recipient_name_admin" is not in valid camel caps format
Open

            $recipient_name_admin,

Variable "email_language" is not in valid camel caps format
Open

        $email_body_teacher .= get_lang('Manager', $email_language).' '.api_get_setting('siteName')."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body_teacher .= "\n".get_lang('The information about this course request is considered protected; it can be used only to open a new course within our e-learning portal; it should not be revealed to third parties.', $email_language)."\n";

Variable "visual_code" is not in valid camel caps format
Open

        $visual_code = $course_request_info['visual_code'];

Variable "course_request_info" is not in valid camel caps format
Open

        if ($wanted_code != $course_request_info['code']) {

Variable "tutor_name" is not in valid camel caps format
Open

            Database::escape_string($tutor_name),

Variable "email_language" is not in valid camel caps format
Open

            $email_language = api_get_setting('platformLanguage');

Variable "email_subject" is not in valid camel caps format
Open

            $email_subject = sprintf(

Variable "user_info" is not in valid camel caps format
Open

                    $user_info['lastname'],

Variable "target_audience" is not in valid camel caps format
Open

            Database::escape_string($target_audience),

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= get_lang('Ln', $email_language).': '.$course_language."\n";

Variable "exemplary_content" is not in valid camel caps format
Open

        $email_body .= get_lang('Fill with demo content', $email_language).': '.($exemplary_content ? get_lang('Yes', $email_language) : get_lang('No', $email_language))."\n";

Variable "user_info" is not in valid camel caps format
Open

        $sender_name_teacher = api_get_person_name($user_info['firstname'], $user_info['lastname'], null, PERSON_NAME_EMAIL_ADDRESS);

Variable "email_subject" is not in valid camel caps format
Open

            $email_subject,

Variable "recipient_name_admin" is not in valid camel caps format
Open

        $sender_name_admin = $recipient_name_admin;

Variable "wanted_code" is not in valid camel caps format
Open

        $code = $wanted_code;

Variable "result_array" is not in valid camel caps format
Open

            $result_array = Database::fetch_array($result, 'NUM');

Variable "result_sql" is not in valid camel caps format
Open

        if (!$result_sql) {

Variable "last_insert_id" is not in valid camel caps format
Open

        $last_insert_id = Database::insert_id();

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Fac', $email_language).': '.$category_code."\n";

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= get_lang('Email', $email_language).': '.$user_info['mail']."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Target audience', $email_language).': '.$target_audience."\n";

Variable "course_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Ln', $email_language).': '.$course_language."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Fill with demo content', $email_language).': '.($exemplary_content ? get_lang('Yes', $email_language) : get_lang('No', $email_language))."\n";

Variable "email_body" is not in valid camel caps format
Open

        $email_body_teacher .= $email_body;

Multi-line function call not indented correctly; expected 12 spaces but found 16
Open

                null,

Variable "email_language" is not in valid camel caps format
Open

                $email_language

Variable "sender_email_admin" is not in valid camel caps format
Open

        $sender_email_admin = $recipient_email_admin;

Variable "recipient_name_teacher" is not in valid camel caps format
Open

        $recipient_name_teacher = $sender_name_teacher;

Variable "user_id" is not in valid camel caps format
Open

        $user_id,

Variable "exemplary_content" is not in valid camel caps format
Open

        $exemplary_content

Variable "request_date" is not in valid camel caps format
Open

        $request_date = $course_request_info['request_date'];

Variable "user_info" is not in valid camel caps format
Open

                    $user_info['firstname'],

Variable "user_id" is not in valid camel caps format
Open

            $user_info = api_get_user_info($user_id);

Variable "course_request_info" is not in valid camel caps format
Open

        $params['user_id'] = $course_request_info['user_id'];

Variable "wanted_course_code" is not in valid camel caps format
Open

        if ($code_exists = CourseManager::course_code_exists($wanted_course_code)) {

Variable "wanted_course_code" is not in valid camel caps format
Open

        $wanted_course_code = Database::escape_string($wanted_course_code);

Variable "wanted_course_code" is not in valid camel caps format
Open

        $wanted_course_code = Database::escape_string($wanted_course_code);

Variable "wanted_course_code" is not in valid camel caps format
Open

            $wanted_course_code

Variable "wanted_code" is not in valid camel caps format
Open

        if ('' == $wanted_code) {

Variable "email_language" is not in valid camel caps format
Open

        $email_subject = sprintf(get_lang('%s A request for a new course %s', $email_language), '['.api_get_setting('siteName').']', $code);

Variable "sender_email_admin" is not in valid camel caps format
Open

            $sender_email_admin,

Variable "target_audience" is not in valid camel caps format
Open

        $target_audience,

Variable "wanted_code" is not in valid camel caps format
Open

        if ('' == $wanted_code) {

Variable "course_request_info" is not in valid camel caps format
Open

        $tutor_name = $course_request_info['tutor_name'];

Variable "user_id" is not in valid camel caps format
Open

            intval($user_id),

Variable "exemplary_content" is not in valid camel caps format
Open

            Database::escape_string($exemplary_content)

Variable "course_table" is not in valid camel caps format
Open

            $sql = "SELECT COUNT(id) AS number FROM ".$course_table;

Variable "course_request_info" is not in valid camel caps format
Open

        if (!is_array($course_request_info)) {

Variable "user_info" is not in valid camel caps format
Open

        $user_info = api_get_user_info($user_id);

Variable "email_language" is not in valid camel caps format
Open

            $email_body = get_lang('Dear', $email_language).' ';

Variable "wanted_course_code" is not in valid camel caps format
Open

    public static function course_code_exists($wanted_course_code)

Variable "exemplary_content" is not in valid camel caps format
Open

        $exemplary_content = (int) $exemplary_content;

Variable "user_info" is not in valid camel caps format
Open

        $tutor_name = api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $course_language);

Variable "result_sql" is not in valid camel caps format
Open

        $result_sql = Database::query($sql);

Variable "email_language" is not in valid camel caps format
Open

        $email_body = get_lang('We registered the following request for a new course:', $email_language)."\n\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Fill with demo content', $email_language).': '.($exemplary_content ? get_lang('Yes', $email_language) : get_lang('No', $email_language))."\n";

Variable "email_body_admin" is not in valid camel caps format
Open

        $email_body_admin .= "\n".get_lang('This course request can be approved on the following page:', $email_language).' '.api_get_path(WEB_CODE_PATH).'admin/course_request_edit.php?id='.$last_insert_id."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body_teacher = get_lang('Dear', $email_language).' ';

Variable "email_language" is not in valid camel caps format
Open

        $email_body_teacher .= get_lang('Email', $email_language).': '.api_get_setting('emailAdministrator', null, $email_language)."\n";

Variable "recipient_email_teacher" is not in valid camel caps format
Open

            $recipient_email_teacher,

Variable "course_request_info" is not in valid camel caps format
Open

        $course_request_info = self::get_course_request_info($id);

Variable "course_request_info" is not in valid camel caps format
Open

        $directory = $course_request_info['directory'];

Variable "visual_code" is not in valid camel caps format
Open

                $visual_code = $keys['currentCourseCode'];

Variable "user_id" is not in valid camel caps format
Open

            $user_info = api_get_user_info($user_id);

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    null,

Variable "exemplary_content" is not in valid camel caps format
Open

            $exemplary_content

Variable "category_code" is not in valid camel caps format
Open

        $email_body .= get_lang('Fac', $email_language).': '.$category_code."\n";

Variable "sender_email_teacher" is not in valid camel caps format
Open

        $sender_email_teacher = $user_info['mail'];

Variable "email_body_teacher" is not in valid camel caps format
Open

        $email_body_teacher .= "\n".get_lang('The information about this course request is considered protected; it can be used only to open a new course within our e-learning portal; it should not be revealed to third parties.', $email_language)."\n";

Variable "course_language" is not in valid camel caps format
Open

        $course_language,

Variable "wanted_code" is not in valid camel caps format
Open

            if (self::course_code_exists($wanted_code)) {

Variable "db_name" is not in valid camel caps format
Open

                $db_name = $keys['currentCourseDbName'];

Variable "course_language" is not in valid camel caps format
Open

        if ($course_language != $course_request_info['course_language']) {

Variable "course_table" is not in valid camel caps format
Open

            $sql = "SELECT COUNT(id) AS number FROM ".$course_table."

Variable "user_id" is not in valid camel caps format
Open

        if ($user_id <= 0) {

Variable "course_request_info" is not in valid camel caps format
Open

        $params['title'] = $course_request_info['title'];

Variable "email_language" is not in valid camel caps format
Open

                get_lang('%s The course request %s has been approved', $email_language),

Variable "email_body" is not in valid camel caps format
Open

            $email_body .= api_get_person_name(

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    $user_info['firstname'],

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    null,

Variable "table_course_request" is not in valid camel caps format
Open

            $table_course_request,

Variable "target_audience" is not in valid camel caps format
Open

        $target_audience,

Variable "user_id" is not in valid camel caps format
Open

        $user_id,

Variable "exemplary_content" is not in valid camel caps format
Open

        $exemplary_content = 0

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= get_lang('Course code', $email_language).': '.$code."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Professor', $email_language).': '.api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $email_language)."\n";

Variable "recipient_email_admin" is not in valid camel caps format
Open

            $recipient_email_admin,

Variable "email_body_admin" is not in valid camel caps format
Open

            $email_body_admin,

Variable "user_info" is not in valid camel caps format
Open

        $email_body_teacher .= api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $email_language).",\n\n";

Variable "email_body_teacher" is not in valid camel caps format
Open

        $email_body_teacher .= get_lang('Email', $email_language).': '.api_get_setting('emailAdministrator', null, $email_language)."\n";

Variable "tutor_name" is not in valid camel caps format
Open

        $tutor_name = $course_request_info['tutor_name'];

Variable "wanted_code" is not in valid camel caps format
Open

            $keys = AddCourse::define_course_keys($wanted_code, '');

Variable "user_info" is not in valid camel caps format
Open

            $user_info = api_get_user_info($user_id);

Variable "visual_code" is not in valid camel caps format
Open

            Database::escape_string($visual_code),

Method name "CourseRequestManager::get_course_request_info" is not in camel caps format
Open

    public static function get_course_request_info($id)

Variable "course_request_info" is not in valid camel caps format
Open

        $params['exemplary_content'] = intval($course_request_info['exemplary_content']) > 0;

Variable "user_info" is not in valid camel caps format
Open

                    $user_info['firstname'],

Method name "CourseRequestManager::course_code_exists" is not in camel caps format
Open

    public static function course_code_exists($wanted_course_code)

Variable "code_exists" is not in valid camel caps format
Open

        if ($code_exists = CourseManager::course_code_exists($wanted_course_code)) {

Variable "user_id" is not in valid camel caps format
Open

        $user_id = (int) $user_id;

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Objectives', $email_language).': '.$objectives."\n";

Variable "sender_name_teacher" is not in valid camel caps format
Open

        $sender_name_teacher = api_get_person_name($user_info['firstname'], $user_info['lastname'], null, PERSON_NAME_EMAIL_ADDRESS);

Variable "sender_email_teacher" is not in valid camel caps format
Open

            $sender_email_teacher

Multi-line function call not indented correctly; expected 12 spaces but found 16
Open

                api_get_setting('administratorSurname'),

Multi-line function call not indented correctly; expected 12 spaces but found 16
Open

                null,

Multi-line function call not indented correctly; expected 8 spaces but found 12
Open

            )."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body_teacher .= get_lang('Email', $email_language).': '.api_get_setting('emailAdministrator', null, $email_language)."\n";

Method name "CourseRequestManager::update_course_request" is not in camel caps format
Open

    public static function update_course_request(

Variable "exemplary_content" is not in valid camel caps format
Open

        $exemplary_content = (bool) $exemplary_content ? 1 : 0;

Variable "tutor_name" is not in valid camel caps format
Open

                $tutor_name = api_get_person_name(

Variable "course_language" is not in valid camel caps format
Open

                    $course_language

Method name "CourseRequestManager::delete_course_request" is not in camel caps format
Open

    public static function delete_course_request($id)

Variable "result_array" is not in valid camel caps format
Open

                return $result_array[0];

Variable "course_request_info" is not in valid camel caps format
Open

        $course_request_info = self::get_course_request_info($id);

Variable "course_request_info" is not in valid camel caps format
Open

        $params['wanted_code'] = $course_request_info['code'];

Variable "course_request_info" is not in valid camel caps format
Open

            $category = CourseCategory::getCategory($course_request_info['category_code']);

Variable "user_id" is not in valid camel caps format
Open

        $user_id = (int) $user_id;

Variable "user_id" is not in valid camel caps format
Open

            $user_id,

Variable "visual_code" is not in valid camel caps format
Open

            Database::escape_string($visual_code),

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Course code', $email_language).': '.$code."\n";

Variable "email_body_teacher" is not in valid camel caps format
Open

        $email_body_teacher .= api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $email_language).",\n\n";

Variable "email_body_teacher" is not in valid camel caps format
Open

        $email_body_teacher .= get_lang('Phone', $email_language).': '.api_get_setting('administratorTelephone')."\n";

Variable "recipient_name_teacher" is not in valid camel caps format
Open

            $recipient_name_teacher,

Variable "category_code" is not in valid camel caps format
Open

        $category_code,

Variable "user_id" is not in valid camel caps format
Open

        $user_id = (int) $user_id;

Variable "user_info" is not in valid camel caps format
Open

            $user_info = api_get_user_info($user_id);

Variable "user_info" is not in valid camel caps format
Open

                    $user_info['lastname'],

Variable "course_language" is not in valid camel caps format
Open

                    $course_language

Variable "result_sql" is not in valid camel caps format
Open

        return false !== $result_sql;

Variable "result_array" is not in valid camel caps format
Open

            if (is_array($result_array)) {

Variable "course_request_info" is not in valid camel caps format
Open

        $params['course_language'] = $course_request_info['course_language'];

Variable "user_info" is not in valid camel caps format
Open

        $params['tutor_name'] = api_get_person_name($user_info['firstname'], $user_info['lastname']);

Variable "course_request_info" is not in valid camel caps format
Open

        if (!empty($course_request_info['category_code'])) {

Variable "user_id" is not in valid camel caps format
Open

        if ($user_id <= 0) {

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= get_lang('Fac', $email_language).': '.$category_code."\n";

Variable "target_audience" is not in valid camel caps format
Open

        $email_body .= get_lang('Target audience', $email_language).': '.$target_audience."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Ln', $email_language).': '.$course_language."\n";

Variable "email_body_admin" is not in valid camel caps format
Open

        $email_body_admin .= "\n".get_lang('The information about this course request is considered protected; it can be used only to open a new course within our e-learning portal; it should not be revealed to third parties.', $email_language)."\n";

Variable "recipient_name_admin" is not in valid camel caps format
Open

        $recipient_name_admin = api_get_person_name(

Variable "email_body_teacher" is not in valid camel caps format
Open

        $email_body_teacher = get_lang('Dear', $email_language).' ';

Multi-line function call not indented correctly; expected 12 spaces but found 16
Open

                api_get_setting('administratorName'),

Variable "recipient_email_admin" is not in valid camel caps format
Open

        $sender_email_admin = $recipient_email_admin;

Variable "course_request_info" is not in valid camel caps format
Open

        if (!is_array($course_request_info)) {

Variable "course_request_info" is not in valid camel caps format
Open

        $info = $course_request_info['info'];

Variable "user_id" is not in valid camel caps format
Open

                $user_id = $course_request_info['code'];

Variable "user_info" is not in valid camel caps format
Open

            if (is_array($user_info)) {

Variable "user_info" is not in valid camel caps format
Open

                    $user_info['firstname'],

Variable "category_code" is not in valid camel caps format
Open

            Database::escape_string($category_code),

Variable "course_table" is not in valid camel caps format
Open

        $course_table = Database::get_main_table(TABLE_MAIN_COURSE_REQUEST);

Variable "email_body" is not in valid camel caps format
Open

            $email_body = get_lang('Dear', $email_language).' ';

Variable "wanted_code" is not in valid camel caps format
Open

        $wanted_code,

Variable "category_code" is not in valid camel caps format
Open

        $category_code,

Variable "wanted_code" is not in valid camel caps format
Open

        $wanted_code = trim($wanted_code);

Variable "user_id" is not in valid camel caps format
Open

        $user_info = api_get_user_info($user_id);

Variable "user_info" is not in valid camel caps format
Open

        $tutor_name = api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $course_language);

Variable "email_subject" is not in valid camel caps format
Open

        $email_subject = sprintf(get_lang('%s A request for a new course %s', $email_language), '['.api_get_setting('siteName').']', $code);

Variable "user_info" is not in valid camel caps format
Open

        $email_body .= get_lang('Professor', $email_language).': '.api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $email_language)."\n";

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= get_lang('Objectives', $email_language).': '.$objectives."\n";

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= get_lang('Fill with demo content', $email_language).': '.($exemplary_content ? get_lang('Yes', $email_language) : get_lang('No', $email_language))."\n";

Variable "email_body_admin" is not in valid camel caps format
Open

        $email_body_admin = $email_body;

Variable "recipient_email_admin" is not in valid camel caps format
Open

        $recipient_email_admin = api_get_setting('emailAdministrator');

Variable "sender_name_teacher" is not in valid camel caps format
Open

            $sender_name_teacher,

Variable "email_body_teacher" is not in valid camel caps format
Open

        $email_body_teacher .= "\n".get_lang('Formula', $email_language)."\n";

Variable "email_subject" is not in valid camel caps format
Open

            $email_subject,

Variable "wanted_code" is not in valid camel caps format
Open

        $wanted_code,

Variable "user_info" is not in valid camel caps format
Open

                    $user_info['lastname'],

Variable "course_request_info" is not in valid camel caps format
Open

        if ($course_language != $course_request_info['course_language']) {

Variable "tutor_name" is not in valid camel caps format
Open

                $tutor_name = api_get_person_name(

Variable "db_name" is not in valid camel caps format
Open

            Database::escape_string($db_name),

Variable "course_language" is not in valid camel caps format
Open

            Database::escape_string($course_language),

Variable "request_date" is not in valid camel caps format
Open

            Database::escape_string($request_date),

Method name "CourseRequestManager::accept_course_request" is not in camel caps format
Open

    public static function accept_course_request($id)

Variable "user_id" is not in valid camel caps format
Open

        $user_id = (int) $course_request_info['user_id'];

Variable "user_info" is not in valid camel caps format
Open

        $params['tutor_name'] = api_get_person_name($user_info['firstname'], $user_info['lastname']);

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    $user_info['lastname'],

Variable "email_language" is not in valid camel caps format
Open

        $email_body_teacher .= "\n".get_lang('Formula', $email_language)."\n";

Variable "email_body_teacher" is not in valid camel caps format
Open

        $email_body_teacher .= get_lang('Manager', $email_language).' '.api_get_setting('siteName')."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body_teacher .= get_lang('Phone', $email_language).': '.api_get_setting('administratorTelephone')."\n";

Variable "wanted_code" is not in valid camel caps format
Open

        if ($wanted_code != $course_request_info['code']) {

Method name "CourseRequestManager::get_course_request_code" is not in camel caps format
Open

    public static function get_course_request_code($id)

Method name "CourseRequestManager::create_course_request" is not in camel caps format
Open

    public static function create_course_request(

Variable "course_language" is not in valid camel caps format
Open

        $course_language,

Variable "wanted_code" is not in valid camel caps format
Open

        $wanted_code = trim($wanted_code);

Variable "wanted_code" is not in valid camel caps format
Open

        if (self::course_code_exists($wanted_code)) {

Variable "user_info" is not in valid camel caps format
Open

        if (!is_array($user_info)) {

Variable "course_language" is not in valid camel caps format
Open

            Database::escape_string($course_language),

Variable "request_date" is not in valid camel caps format
Open

            Database::escape_string($request_date),

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= get_lang('Description', $email_language).': '.$description."\n";

Variable "last_insert_id" is not in valid camel caps format
Open

        $email_body_admin .= "\n".get_lang('This course request can be approved on the following page:', $email_language).' '.api_get_path(WEB_CODE_PATH).'admin/course_request_edit.php?id='.$last_insert_id."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body_teacher .= api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $email_language).",\n\n";

Variable "sender_name_admin" is not in valid camel caps format
Open

        $sender_name_admin = $recipient_name_admin;

Variable "sender_name_teacher" is not in valid camel caps format
Open

        $recipient_name_teacher = $sender_name_teacher;

Variable "sender_name_admin" is not in valid camel caps format
Open

            $sender_name_admin,

Variable "user_info" is not in valid camel caps format
Open

        if (!is_array($user_info)) {

Variable "visual_code" is not in valid camel caps format
Open

        $visual_code = $keys['currentCourseCode'];

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Email', $email_language).': '.$user_info['mail']."\n";

Variable "email_body_teacher" is not in valid camel caps format
Open

        $email_body_teacher .= $email_body;

Variable "sender_email_teacher" is not in valid camel caps format
Open

        $recipient_email_teacher = $sender_email_teacher;

Variable "last_insert_id" is not in valid camel caps format
Open

        return $last_insert_id;

Variable "wanted_code" is not in valid camel caps format
Open

        $wanted_code = trim($wanted_code);

Variable "wanted_code" is not in valid camel caps format
Open

        $wanted_code = trim($wanted_code);

Variable "user_id" is not in valid camel caps format
Open

        $user_id = (int) $user_id;

Variable "exemplary_content" is not in valid camel caps format
Open

        $exemplary_content = (bool) $exemplary_content ? 1 : 0;

Variable "user_id" is not in valid camel caps format
Open

        if ($user_id <= 0) {

Variable "course_request_info" is not in valid camel caps format
Open

        $request_date = $course_request_info['request_date'];

Variable "user_id" is not in valid camel caps format
Open

        if ($user_id != $course_request_info['code']) {

Variable "course_request_info" is not in valid camel caps format
Open

        if ($user_id != $course_request_info['code']) {

Variable "user_info" is not in valid camel caps format
Open

            if (is_array($user_info)) {

Variable "course_request_info" is not in valid camel caps format
Open

                $user_id = $course_request_info['code'];

Method name "CourseRequestManager::count_course_requests" is not in camel caps format
Open

    public static function count_course_requests($status = null)

Variable "course_request_info" is not in valid camel caps format
Open

        $user_id = (int) $course_request_info['user_id'];

Variable "email_body_teacher" is not in valid camel caps format
Open

        $email_body_teacher .= api_get_person_name(

Multi-line function call not indented correctly; expected 12 spaces but found 16
Open

                $email_language

Variable "recipient_email_teacher" is not in valid camel caps format
Open

        $recipient_email_teacher = $sender_email_teacher;

Variable "target_audience" is not in valid camel caps format
Open

            Database::escape_string($target_audience),

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    $email_language

Variable "sender_name" is not in valid camel caps format
Open

            $sender_name = api_get_person_name(

Variable "course_request_info" is not in valid camel caps format
Open

        $user_id = intval($course_request_info['user_id']);

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= get_lang('Email', $email_language).': '.api_get_setting('emailAdministrator', null, $email_language)."\n";

Method name "CourseRequestManager::ask_for_additional_info" is not in camel caps format
Open

    public static function ask_for_additional_info($id)

Variable "email_subject" is not in valid camel caps format
Open

        $email_subject = sprintf(get_lang('%s A request for additional information about the course request %s', $email_language), '['.api_get_setting('siteName').']', $code);

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Email', $email_language).': '.api_get_setting('emailAdministrator')."\n";

Variable "email_language" is not in valid camel caps format
Open

            $email_body .= get_lang('Manager', $email_language).' '.api_get_setting('siteName')."\n";

Variable "user_info" is not in valid camel caps format
Open

        $user_info = api_get_user_info($user_id);

Variable "recipient_name" is not in valid camel caps format
Open

        $recipient_name = api_get_person_name(

Variable "course_request_info" is not in valid camel caps format
Open

        if (!is_array($course_request_info)) {

Variable "user_info" is not in valid camel caps format
Open

            $user_info['firstname'],

Variable "recipient_email" is not in valid camel caps format
Open

        $recipient_email = $user_info['mail'];

Variable "email_body" is not in valid camel caps format
Open

            $email_body .= sprintf(

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    $course->getCode(),

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    null,

Variable "email_language" is not in valid camel caps format
Open

            $email_body .= get_lang('Email', $email_language).': '.api_get_setting('emailAdministrator', null, $email_language)."\n";

Variable "email_language" is not in valid camel caps format
Open

            $email_body .= get_lang('Email', $email_language).': '.api_get_setting('emailAdministrator', null, $email_language)."\n";

Variable "user_id" is not in valid camel caps format
Open

        if ($user_id <= 0) {

Variable "course_request_info" is not in valid camel caps format
Open

        $code = $course_request_info['code'];

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Email', $email_language).': '.api_get_setting('emailAdministrator', null, $email_language)."\n";

Variable "user_info" is not in valid camel caps format
Open

            $user_info['firstname'],

Variable "email_body" is not in valid camel caps format
Open

        $email_body = get_lang('Dear', $email_language).' ';

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= sprintf(get_lang('We have received your request for a new course with code %s. Before we consider it for approval, we need some additional information.\n\nPlease, provide brief information about the course content (description), the objectives, the learners or the users that are to be involved in the proposed course. If it is applicable, mention the name of the institution or the unit on which behalf you made the course request.', $email_language), $code)."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Manager', $email_language).' '.api_get_setting('siteName')."\n";

Multi-line function call not indented correctly; expected 12 spaces but found 16
Open

                ).",\n\n";

Variable "email_language" is not in valid camel caps format
Open

            $email_body .= "\n".get_lang('Formula', $email_language)."\n";

Variable "user_id" is not in valid camel caps format
Open

        $user_id = intval($course_request_info['user_id']);

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Phone', $email_language).': '.api_get_setting('administratorTelephone')."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_subject = sprintf(get_lang('%s A request for additional information about the course request %s', $email_language), '['.api_get_setting('siteName').']', $code);

Variable "recipient_name" is not in valid camel caps format
Open

            $recipient_name,

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= sprintf(get_lang('To our regret we have to inform you that your course request %s has been rejected due to not fulfilling the requirements of our Terms and Conditions.', $email_language), $code)."\n";

Variable "user_id" is not in valid camel caps format
Open

        if ($user_id <= 0) {

Variable "email_language" is not in valid camel caps format
Open

                        $email_language

Variable "email_language" is not in valid camel caps format
Open

            $email_body .= get_lang('Phone', $email_language).': '.api_get_setting('administratorTelephone')."\n";

Variable "recipient_name" is not in valid camel caps format
Open

            $recipient_name = api_get_person_name(

Variable "user_info" is not in valid camel caps format
Open

                $user_info['firstname'],

Variable "recipient_email" is not in valid camel caps format
Open

            $recipient_email = $user_info['mail'];

Variable "sender_email" is not in valid camel caps format
Open

                $sender_email

Variable "email_language" is not in valid camel caps format
Open

        $email_subject = sprintf(get_lang('%s The course request %s has been rejected', $email_language), '['.api_get_setting('siteName').']', $code);

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    api_get_setting('administratorSurname'),

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= get_lang('Phone', $email_language).': '.api_get_setting('administratorTelephone')."\n";

Variable "email_language" is not in valid camel caps format
Open

            $email_body .= "\n".get_lang('The information about this course request is considered protected; it can be used only to open a new course within our e-learning portal; it should not be revealed to third parties.', $email_language)."\n";

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= "\n".get_lang('The information about this course request is considered protected; it can be used only to open a new course within our e-learning portal; it should not be revealed to third parties.', $email_language)."\n";

Variable "recipient_name" is not in valid camel caps format
Open

            $recipient_name,

Variable "sender_email" is not in valid camel caps format
Open

            $sender_email = api_get_setting('emailAdministrator');

Variable "email_subject" is not in valid camel caps format
Open

            $email_subject,

Variable "course_request_info" is not in valid camel caps format
Open

        $course_request_info = self::get_course_request_info($id);

Variable "course_request_info" is not in valid camel caps format
Open

        $code = $course_request_info['code'];

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= get_lang('Manager', $email_language).' '.api_get_setting('siteName')."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body = get_lang('Dear', $email_language).' ';

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= "\n".get_lang('The information about this course request is considered protected; it can be used only to open a new course within our e-learning portal; it should not be revealed to third parties.', $email_language)."\n";

Variable "user_info" is not in valid camel caps format
Open

        $email_body .= api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $email_language).",\n\n";

Variable "sender_name" is not in valid camel caps format
Open

            $sender_name,

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= sprintf(get_lang('We have received your request for a new course with code %s. Before we consider it for approval, we need some additional information.\n\nPlease, provide brief information about the course content (description), the objectives, the learners or the users that are to be involved in the proposed course. If it is applicable, mention the name of the institution or the unit on which behalf you made the course request.', $email_language), $code)."\n";

Variable "course_request_info" is not in valid camel caps format
Open

        $course_request_info = self::get_course_request_info($id);

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= "\n".get_lang('Formula', $email_language)."\n";

Variable "user_id" is not in valid camel caps format
Open

        $user_id = intval($course_request_info['user_id']);

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= get_lang('Email', $email_language).': '.api_get_setting('emailAdministrator')."\n";

Variable "course_request_info" is not in valid camel caps format
Open

        $user_id = intval($course_request_info['user_id']);

Variable "sender_email" is not in valid camel caps format
Open

        $sender_email = api_get_setting('emailAdministrator');

Variable "user_info" is not in valid camel caps format
Open

        $email_body .= api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $email_language).",\n\n";

Variable "user_info" is not in valid camel caps format
Open

            $user_info['lastname'],

Variable "email_body" is not in valid camel caps format
Open

            $email_body,

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= get_lang('Manager', $email_language).' '.api_get_setting('siteName')."\n";

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= get_lang('Phone', $email_language).': '.api_get_setting('administratorTelephone')."\n";

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    $course->getCode(),

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    $email_language

Variable "email_body" is not in valid camel caps format
Open

            $email_body .= get_lang('Manager', $email_language).' '.api_get_setting('siteName')."\n";

Variable "email_body" is not in valid camel caps format
Open

            $email_body .= get_lang('Phone', $email_language).': '.api_get_setting('administratorTelephone')."\n";

Variable "email_body" is not in valid camel caps format
Open

            $email_body .= "\n".get_lang('The information about this course request is considered protected; it can be used only to open a new course within our e-learning portal; it should not be revealed to third parties.', $email_language)."\n";

Variable "user_info" is not in valid camel caps format
Open

                $user_info['lastname'],

Variable "sender_name" is not in valid camel caps format
Open

        $sender_name = api_get_person_name(

Variable "recipient_email" is not in valid camel caps format
Open

            $recipient_email,

Variable "user_id" is not in valid camel caps format
Open

        $user_info = api_get_user_info($user_id);

Variable "email_language" is not in valid camel caps format
Open

                    $email_language

Variable "email_language" is not in valid camel caps format
Open

                    $email_language

Variable "email_subject" is not in valid camel caps format
Open

                $email_subject,

Variable "user_id" is not in valid camel caps format
Open

        $user_info = api_get_user_info($user_id);

Variable "user_info" is not in valid camel caps format
Open

        if (!is_array($user_info)) {

Variable "email_subject" is not in valid camel caps format
Open

        $email_subject = sprintf(get_lang('%s The course request %s has been rejected', $email_language), '['.api_get_setting('siteName').']', $code);

Variable "recipient_email" is not in valid camel caps format
Open

        $recipient_email = $user_info['mail'];

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    null,

Multi-line function call not indented correctly; expected 12 spaces but found 16
Open

                )."\n";

Method name "CourseRequestManager::reject_course_request" is not in camel caps format
Open

    public static function reject_course_request($id)

Variable "email_language" is not in valid camel caps format
Open

        $email_language = api_get_setting('platformLanguage');

Variable "sender_email" is not in valid camel caps format
Open

        $sender_email = api_get_setting('emailAdministrator');

Variable "user_info" is not in valid camel caps format
Open

        $recipient_email = $user_info['mail'];

Variable "course_request_info" is not in valid camel caps format
Open

        $info = intval($course_request_info['info']);

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $email_language).",\n\n";

Variable "sender_name" is not in valid camel caps format
Open

        $sender_name = api_get_person_name(

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    api_get_course_url($course->getId())

Variable "email_body" is not in valid camel caps format
Open

            $email_body .= api_get_person_name(

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $email_language).",\n\n";

Variable "user_info" is not in valid camel caps format
Open

        $email_body .= api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $email_language).",\n\n";

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= "\n".get_lang('Formula', $email_language)."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= "\n".get_lang('Formula', $email_language)."\n";

Variable "recipient_email" is not in valid camel caps format
Open

            $recipient_email,

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    api_get_setting('administratorName'),

Variable "user_info" is not in valid camel caps format
Open

            $recipient_email = $user_info['mail'];

Variable "course_request_info" is not in valid camel caps format
Open

        if (!is_array($course_request_info)) {

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    get_lang(

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $email_language).",\n\n";

Variable "email_body" is not in valid camel caps format
Open

            $email_body,

Variable "user_info" is not in valid camel caps format
Open

        if (!is_array($user_info)) {

Multi-line function call not indented correctly; expected 12 spaces but found 16
Open

                )."\n";

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= "\n".get_lang('The information about this course request is considered protected; it can be used only to open a new course within our e-learning portal; it should not be revealed to third parties.', $email_language)."\n";

Variable "recipient_email" is not in valid camel caps format
Open

                $recipient_email,

Variable "user_info" is not in valid camel caps format
Open

        $email_body .= api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $email_language).",\n\n";

Variable "user_info" is not in valid camel caps format
Open

            $user_info['lastname'],

Variable "email_language" is not in valid camel caps format
Open

        $email_language = api_get_setting('platformLanguage');

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= "\n".get_lang('The information about this course request is considered protected; it can be used only to open a new course within our e-learning portal; it should not be revealed to third parties.', $email_language)."\n";

Variable "email_body" is not in valid camel caps format
Open

        $email_body = get_lang('Dear', $email_language).' ';

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= api_get_person_name(api_get_setting('administratorName'), api_get_setting('administratorSurname'), null, null, $email_language)."\n";

Variable "sender_email" is not in valid camel caps format
Open

            $sender_email

Variable "email_subject" is not in valid camel caps format
Open

            $email_subject,

Variable "sender_email" is not in valid camel caps format
Open

            $sender_email

Variable "recipient_name" is not in valid camel caps format
Open

                $recipient_name,

Variable "email_language" is not in valid camel caps format
Open

        $email_body = get_lang('Dear', $email_language).' ';

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= "\n".get_lang('Formula', $email_language)."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Manager', $email_language).' '.api_get_setting('siteName')."\n";

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= api_get_person_name($user_info['firstname'], $user_info['lastname'], null, null, $email_language).",\n\n";

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= api_get_person_name(api_get_setting('administratorName'), api_get_setting('administratorSurname'))."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Phone', $email_language).': '.api_get_setting('administratorTelephone')."\n";

Variable "recipient_name" is not in valid camel caps format
Open

        $recipient_name = api_get_person_name(

Variable "user_info" is not in valid camel caps format
Open

        $recipient_email = $user_info['mail'];

Variable "email_body" is not in valid camel caps format
Open

            $email_body .= "\n".get_lang('Formula', $email_language)."\n";

Variable "email_body" is not in valid camel caps format
Open

            $email_body .= get_lang('Email', $email_language).': '.api_get_setting('emailAdministrator', null, $email_language)."\n";

Variable "email_body" is not in valid camel caps format
Open

                $email_body,

Variable "sender_name" is not in valid camel caps format
Open

                $sender_name,

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= sprintf(get_lang('To our regret we have to inform you that your course request %s has been rejected due to not fulfilling the requirements of our Terms and Conditions.', $email_language), $code)."\n";

Variable "email_body" is not in valid camel caps format
Open

        $email_body .= api_get_person_name(api_get_setting('administratorName'), api_get_setting('administratorSurname'), null, null, $email_language)."\n";

Variable "email_language" is not in valid camel caps format
Open

        $email_body .= get_lang('Email', $email_language).': '.api_get_setting('emailAdministrator', null, $email_language)."\n";

Variable "user_info" is not in valid camel caps format
Open

        $user_info = api_get_user_info($user_id);

Variable "sender_name" is not in valid camel caps format
Open

            $sender_name,

Method name "CourseRequestManager::additional_info_asked" is not in camel caps format
Open

    public static function additional_info_asked($id)

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    null,

Multi-line function call not indented correctly; expected 12 spaces but found 16
Open

                null,

Multi-line function call not indented correctly; expected 8 spaces but found 12
Open

            )."\n";

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    $email_language

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    $user_info['lastname'],

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    $user_info['firstname'],

Multi-line function call not indented correctly; expected 12 spaces but found 16
Open

                api_get_setting('administratorName'),

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    null,

Multi-line function call not indented correctly; expected 12 spaces but found 16
Open

                api_get_setting('administratorSurname'),

Multi-line function call not indented correctly; expected 12 spaces but found 16
Open

                null,

Multi-line function call not indented correctly; expected 12 spaces but found 16
Open

                $email_language

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    api_get_setting('administratorName'),

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    $course->getCode(),

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    api_get_setting('administratorSurname'),

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    null,

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    $email_language

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    null,

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    api_get_course_url($course->getId())

Multi-line function call not indented correctly; expected 12 spaces but found 16
Open

                )."\n";

Multi-line function call not indented correctly; expected 12 spaces but found 16
Open

                ).",\n\n";

Multi-line function call not indented correctly; expected 12 spaces but found 16
Open

                )."\n";

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    get_lang(

Multi-line function call not indented correctly; expected 16 spaces but found 20
Open

                    $course->getCode(),

The variable $course_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $wanted_course_code is not named in camelCase.
Open

    public static function course_code_exists($wanted_course_code)
    {
        if ($code_exists = CourseManager::course_code_exists($wanted_course_code)) {
            return $code_exists;
        }

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $exemplary_content is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $target_audience is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $exemplary_content is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $last_insert_id is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $exemplary_content is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $visual_code is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $result_sql is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $table_course_request is not named in camelCase.
Open

    public static function course_code_exists($wanted_course_code)
    {
        if ($code_exists = CourseManager::course_code_exists($wanted_course_code)) {
            return $code_exists;
        }

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $wanted_code is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_name_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_email_admin is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_language is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $result_array is not named in camelCase.
Open

    public static function get_course_request_code($id)
    {
        $id = (int) $id;
        $sql = "SELECT code
                FROM ".Database::get_main_table(TABLE_MAIN_COURSE_REQUEST)."

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $wanted_course_code is not named in camelCase.
Open

    public static function course_code_exists($wanted_course_code)
    {
        if ($code_exists = CourseManager::course_code_exists($wanted_course_code)) {
            return $code_exists;
        }

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $exemplary_content is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $wanted_code is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $request_date is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $visual_code is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $result_sql is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body_admin is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_email_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_email_admin is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $wanted_code is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $tutor_name is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $wanted_course_code is not named in camelCase.
Open

    public static function course_code_exists($wanted_course_code)
    {
        if ($code_exists = CourseManager::course_code_exists($wanted_course_code)) {
            return $code_exists;
        }

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $wanted_code is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $result_sql is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_email_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_email_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $wanted_code is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $target_audience is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $wanted_code is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $visual_code is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_name_admin is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $result_sql is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $table_course_request is not named in camelCase.
Open

    public static function course_code_exists($wanted_course_code)
    {
        if ($code_exists = CourseManager::course_code_exists($wanted_course_code)) {
            return $code_exists;
        }

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_name_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_subject is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_table is not named in camelCase.
Open

    public static function count_course_requests($status = null)
    {
        $course_table = Database::get_main_table(TABLE_MAIN_COURSE_REQUEST);
        if (is_null($status)) {
            $sql = "SELECT COUNT(id) AS number FROM ".$course_table;

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $request_date is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $exemplary_content is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_email_admin is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_name_admin is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $category_code is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $tutor_name is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_table is not named in camelCase.
Open

    public static function count_course_requests($status = null)
    {
        $course_table = Database::get_main_table(TABLE_MAIN_COURSE_REQUEST);
        if (is_null($status)) {
            $sql = "SELECT COUNT(id) AS number FROM ".$course_table;

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $result_array is not named in camelCase.
Open

    public static function get_course_request_code($id)
    {
        $id = (int) $id;
        $sql = "SELECT code
                FROM ".Database::get_main_table(TABLE_MAIN_COURSE_REQUEST)."

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $last_insert_id is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_name_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $tutor_name is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_language is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $code_exists is not named in camelCase.
Open

    public static function course_code_exists($wanted_course_code)
    {
        if ($code_exists = CourseManager::course_code_exists($wanted_course_code)) {
            return $code_exists;
        }

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $db_name is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $category_code is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_email_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $wanted_code is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $request_date is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_language is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $db_name is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $category_code is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $target_audience is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body_admin is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_name_admin is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_name_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $wanted_code is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $tutor_name is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_subject is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_email_admin is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_name_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $request_date is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $exemplary_content is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $code_exists is not named in camelCase.
Open

    public static function course_code_exists($wanted_course_code)
    {
        if ($code_exists = CourseManager::course_code_exists($wanted_course_code)) {
            return $code_exists;
        }

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $wanted_course_code is not named in camelCase.
Open

    public static function course_code_exists($wanted_course_code)
    {
        if ($code_exists = CourseManager::course_code_exists($wanted_course_code)) {
            return $code_exists;
        }

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $tutor_name is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $tutor_name is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $last_insert_id is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body_admin is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body_admin is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_email_admin is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_email_teacher is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $wanted_code is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $visual_code is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_email is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_subject is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $wanted_code is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $exemplary_content is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $wanted_code is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_language is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $visual_code is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_name is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_subject is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_email is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_name_admin is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_subject is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_name_admin is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $wanted_code is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $db_name is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_table is not named in camelCase.
Open

    public static function count_course_requests($status = null)
    {
        $course_table = Database::get_main_table(TABLE_MAIN_COURSE_REQUEST);
        if (is_null($status)) {
            $sql = "SELECT COUNT(id) AS number FROM ".$course_table;

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_email is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_name is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_email is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_name is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_email is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_name is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_subject is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_name is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_email is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_name is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $result_array is not named in camelCase.
Open

    public static function get_course_request_code($id)
    {
        $id = (int) $id;
        $sql = "SELECT code
                FROM ".Database::get_main_table(TABLE_MAIN_COURSE_REQUEST)."

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_name is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_subject is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_name is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_email is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_email is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_email is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_subject is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_email is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_name is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_name is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_name is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_email is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_subject is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $sender_email is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $recipient_name is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_language is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $email_body is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_info is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $user_id is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The variable $course_request_info is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseVariableName

Since: 0.2

It is considered best practice to use the camelCase notation to name variables.

Example

class ClassName {
    public function doSomething() {
        $data_module = new DataModule();
    }
}

Source

The method create_course_request is not named in camelCase.
Open

    public static function create_course_request(
        $wanted_code,
        $title,
        $description,
        $category_code,

CamelCaseMethodName

Since: 0.2

It is considered best practice to use the camelCase notation to name methods.

Example

class ClassName {
    public function get_name() {
    }
}

Source

The method course_code_exists is not named in camelCase.
Open

    public static function course_code_exists($wanted_course_code)
    {
        if ($code_exists = CourseManager::course_code_exists($wanted_course_code)) {
            return $code_exists;
        }

CamelCaseMethodName

Since: 0.2

It is considered best practice to use the camelCase notation to name methods.

Example

class ClassName {
    public function get_name() {
    }
}

Source

The method get_course_request_info is not named in camelCase.
Open

    public static function get_course_request_info($id)
    {
        $id = (int) $id;
        $sql = "SELECT *
                FROM ".Database::get_main_table(TABLE_MAIN_COURSE_REQUEST)."

CamelCaseMethodName

Since: 0.2

It is considered best practice to use the camelCase notation to name methods.

Example

class ClassName {
    public function get_name() {
    }
}

Source

The method update_course_request is not named in camelCase.
Open

    public static function update_course_request(
        $id,
        $wanted_code,
        $title,
        $description,

CamelCaseMethodName

Since: 0.2

It is considered best practice to use the camelCase notation to name methods.

Example

class ClassName {
    public function get_name() {
    }
}

Source

The method delete_course_request is not named in camelCase.
Open

    public static function delete_course_request($id)
    {
        $id = (int) $id;
        $sql = "DELETE FROM ".Database::get_main_table(TABLE_MAIN_COURSE_REQUEST)."
                WHERE id = ".$id;

CamelCaseMethodName

Since: 0.2

It is considered best practice to use the camelCase notation to name methods.

Example

class ClassName {
    public function get_name() {
    }
}

Source

The method count_course_requests is not named in camelCase.
Open

    public static function count_course_requests($status = null)
    {
        $course_table = Database::get_main_table(TABLE_MAIN_COURSE_REQUEST);
        if (is_null($status)) {
            $sql = "SELECT COUNT(id) AS number FROM ".$course_table;

CamelCaseMethodName

Since: 0.2

It is considered best practice to use the camelCase notation to name methods.

Example

class ClassName {
    public function get_name() {
    }
}

Source

The method ask_for_additional_info is not named in camelCase.
Open

    public static function ask_for_additional_info($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseMethodName

Since: 0.2

It is considered best practice to use the camelCase notation to name methods.

Example

class ClassName {
    public function get_name() {
    }
}

Source

The method get_course_request_code is not named in camelCase.
Open

    public static function get_course_request_code($id)
    {
        $id = (int) $id;
        $sql = "SELECT code
                FROM ".Database::get_main_table(TABLE_MAIN_COURSE_REQUEST)."

CamelCaseMethodName

Since: 0.2

It is considered best practice to use the camelCase notation to name methods.

Example

class ClassName {
    public function get_name() {
    }
}

Source

The method accept_course_request is not named in camelCase.
Open

    public static function accept_course_request($id)
    {
        $id = (int) $id;

        // Retrieve request's data

CamelCaseMethodName

Since: 0.2

It is considered best practice to use the camelCase notation to name methods.

Example

class ClassName {
    public function get_name() {
    }
}

Source

The method reject_course_request is not named in camelCase.
Open

    public static function reject_course_request($id)
    {
        $id = (int) $id;
        // Retrieve request's data
        $course_request_info = self::get_course_request_info($id);

CamelCaseMethodName

Since: 0.2

It is considered best practice to use the camelCase notation to name methods.

Example

class ClassName {
    public function get_name() {
    }
}

Source

The method additional_info_asked is not named in camelCase.
Open

    public static function additional_info_asked($id)
    {
        $id = (int) $id;
        $sql = "SELECT id FROM ".Database::get_main_table(TABLE_MAIN_COURSE_REQUEST)."
                WHERE (id = ".$id." AND info > 0)";

CamelCaseMethodName

Since: 0.2

It is considered best practice to use the camelCase notation to name methods.

Example

class ClassName {
    public function get_name() {
    }
}

Source

There are no issues that match your filters.

Category
Status