chamilo/chamilo-lms

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

Summary

Maintainability
A
0 mins
Test Coverage

The method register_course() has an NPath complexity of 462385152. The configured NPath complexity threshold is 200.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

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 class AddCourse has a coupling between objects value of 22. Consider to reduce the number of dependencies under 13.
Open

class AddCourse
{
    public const FIRST_EXPIRATION_DATE = 31536000; // 365 days in seconds

    /**

CouplingBetweenObjects

Since: 1.1.0

A class with too many dependencies has negative impacts on several quality aspects of a class. This includes quality criteria like stability, maintainability and understandability

Example

class Foo {
    /**
     * @var \foo\bar\X
     */
    private $x = null;

    /**
     * @var \foo\bar\Y
     */
    private $y = null;

    /**
     * @var \foo\bar\Z
     */
    private $z = null;

    public function setFoo(\Foo $foo) {}
    public function setBar(\Bar $bar) {}
    public function setBaz(\Baz $baz) {}

    /**
     * @return \SplObjectStorage
     * @throws \OutOfRangeException
     * @throws \InvalidArgumentException
     * @throws \ErrorException
     */
    public function process(\Iterator $it) {}

    // ...
}

Source https://phpmd.org/rules/design.html#couplingbetweenobjects

Missing class import via use statement (line '527', column '23').
Open

        $answer = new Answer($questionId, $courseInfo['real_id']);

MissingImport

Since: 2.7.0

Importing all external classes in a file through use statements makes them clearly visible.

Example

function make() {
    return new \stdClass();
}

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

Missing class import via use statement (line '388', column '23').
Open

        $finder = new Symfony\Component\Finder\Finder();

MissingImport

Since: 2.7.0

Importing all external classes in a file through use statements makes them clearly visible.

Example

function make() {
    return new \stdClass();
}

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

Missing class import via use statement (line '501', column '25').
Open

        $exercise = new Exercise($course->getId());

MissingImport

Since: 2.7.0

Importing all external classes in a file through use statements makes them clearly visible.

Example

function make() {
    return new \stdClass();
}

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

Missing class import via use statement (line '459', column '21').
Open

        $link = new Link();

MissingImport

Since: 2.7.0

Importing all external classes in a file through use statements makes them clearly visible.

Example

function make() {
    return new \stdClass();
}

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

Missing class import via use statement (line '517', column '25').
Open

        $question = new MultipleAnswer();

MissingImport

Since: 2.7.0

Importing all external classes in a file through use statements makes them clearly visible.

Example

function make() {
    return new \stdClass();
}

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

Missing class import via use statement (line '609', column '42').
Open

        $gradebookLink->setCreatedAt(new \DateTime());

MissingImport

Since: 2.7.0

Importing all external classes in a file through use statements makes them clearly visible.

Example

function make() {
    return new \stdClass();
}

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

Missing class import via use statement (line '448', column '23').
Open

        $agenda = new Agenda('course');

MissingImport

Since: 2.7.0

Importing all external classes in a file through use statements makes them clearly visible.

Example

function make() {
    return new \stdClass();
}

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

Missing class import via use statement (line '667', column '27').
Open

        $app_plugin = new AppPlugin();

MissingImport

Since: 2.7.0

Importing all external classes in a file through use statements makes them clearly visible.

Example

function make() {
    return new \stdClass();
}

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

Missing class import via use statement (line '833', column '41').
Open

                ->setExpirationDate(new DateTime($expiration_date))

MissingImport

Since: 2.7.0

Importing all external classes in a file through use statements makes them clearly visible.

Example

function make() {
    return new \stdClass();
}

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

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

            } else {
                $realPath = str_replace($defaultPath, '', $file->getRealPath());
                $document = DocumentManager::addDocument(
                    $courseInfo,
                    $realPath,

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 register_course uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them.
Open

        } else {
            $expiration_date = api_get_utc_datetime($expiration_date);
        }

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 register_course uses an else expression. Else clauses are basically not necessary and you can simplify the code by not using them.
Open

        } else {
            $visibility = $params['visibility'];
        }

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 parameters such as '$prefix_for_base_name'.
Open

        $prefix_for_base_name = '',

UnusedFormalParameter

Since: 0.2

Avoid passing parameters to methods or constructors and then not using those parameters.

Example

class Foo
{
    private function bar($howdy)
    {
        // $howdy is not used
    }
}

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

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

                    $certificateId = $document->getIid();

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 '$gradebook'.
Open

        $gradebook = self::createRootGradebook($course);

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 parameters such as '$counter'.
Open

    public static function insertDocument($courseInfo, $counter, $file, $authorId = 0)

UnusedFormalParameter

Since: 0.2

Avoid passing parameters to methods or constructors and then not using those parameters.

Example

class Foo
{
    private function bar($howdy)
    {
        // $howdy is not used
    }
}

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

Avoid unused parameters such as '$authorId'.
Open

    public static function insertDocument($courseInfo, $counter, $file, $authorId = 0)

UnusedFormalParameter

Since: 0.2

Avoid passing parameters to methods or constructors and then not using those parameters.

Example

class Foo
{
    private function bar($howdy)
    {
        // $howdy is not used
    }
}

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

The parameter $prefix_for_all is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

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 $prefix_for_base_name is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

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 $add_unique_prefix is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

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 $use_code_indepedent_keys is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

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 $prefix_for_path is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

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 define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

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

Method name "AddCourse::define_course_keys" is not in camel caps format
Open

    public static function define_course_keys(

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

        $keys_course_code = $wanted_code;

Expected 17 spaces after parameter name; 1 found
Open

     * @param int $authorId The ID of the user who is considered the author of the exemplary content. Defaults to the

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

        if (empty($expiration_date)) {

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

            $course_id = $course->getId();

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

            $unique_prefix = substr(md5(uniqid(rand())), 0, 10);

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

            $keys_course_repository = $prefix_for_path.$unique_prefix.$wanted_code.$final_suffix['CourseDir'];

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

        $exercise->results_disabled = 0;

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

            $visibility = $default_course_visibility ?? Course::OPEN_PLATFORM;

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

            $error_msg[] = 'courseRepository is missing';

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

            $error_msg[] = 'title is missing';

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

                ->setExpirationDate(new DateTime($expiration_date))

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

                        $recipient_name,

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

        $wanted_code = CourseManager::generate_course_code($wanted_code);

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

                ->setDepartmentUrl($department_url)

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

        $keys_course_code = $wanted_code;

Missing parameter name
Open

     * @param string    Prefix added for paths only

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

            $keys_course_id = $prefix_for_all.$unique_prefix.$wanted_code.$final_suffix['CourseId'];

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

        $prefix_for_path = '',

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

            if (($try_new_fsc_id + $try_new_fsc_db + $try_new_fsc_dir) > $limit_numb_try) {

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

        $add_unique_prefix = false,

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

            if (($try_new_fsc_id + $try_new_fsc_db + $try_new_fsc_dir) > $limit_numb_try) {

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

        $try_new_fsc_id = $try_new_fsc_db = $try_new_fsc_dir = 0;

Expected 4 spaces after parameter type; 1 found
Open

     * @param Course $course The course entity to be populated.

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

            $expiration_date = api_get_utc_datetime($expiration_date);

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

        global $error_msg;

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

            $department_url = 'http://'.$department_url;

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

            $error_msg[] = 'courseScreenCode is missing';

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

                ->setVisualCode($visual_code)

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

                    $recipient_email = api_get_setting('emailAdministrator');

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

        $wanted_code,

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

        $unique_prefix = '';

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

            $keys_course_id = $prefix_for_all.$unique_prefix.$wanted_code.$final_suffix['CourseId'];

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

            $keys_course_repository = $prefix_for_path.$unique_prefix.$wanted_code.$final_suffix['CourseDir'];

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

        $course_language = !empty($params['course_language']) ? $params['course_language'] : api_get_setting(

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

            $disk_quota = api_get_setting('default_document_quotum');

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

                ->setCourseLanguage($course_language)

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

                ->setDiskQuota($disk_quota)

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

                        $recipient_email,

Missing parameter name
Open

     * @param string    The code you want for this course

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

            $keys_course_id = $prefix_for_all.$unique_prefix.$wanted_code.$final_suffix['CourseId'];

Expected 7 spaces after parameter type; 1 found
Open

     * @param int $authorId The ID of the user who is considered the author of the exemplary content. Defaults to the

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

            $error_msg[] = 'courseSysCode is missing';

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

        if (empty($visual_code)) {

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

        if (empty($disk_quota)) {

Missing parameter name
Open

     * @param string    Prefix added for ALL keys

Missing parameter name
Open

     * @param bool      Add unique prefix

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

        $prefix_for_base_name = '',

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

            $wanted_code = '';

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

        while (!$keys_are_unique) {

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

            if (($try_new_fsc_id + $try_new_fsc_db + $try_new_fsc_dir) > $limit_numb_try) {

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

            $keys_course_id = $prefix_for_all.$unique_prefix.$wanted_code.$final_suffix['CourseId'];

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

            $query = "SELECT 1 FROM $course_table

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

        $keys['currentCourseRepository'] = $keys_course_repository;

Method name "AddCourse::get_course_tables" is not in camel caps format
Open

    public static function get_course_tables()

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

        $app_plugin->install_course_plugins($courseId);

Method name "AddCourse::drop_course_tables" is not in camel caps format
Open

    public static function drop_course_tables()

Expected 19 spaces after parameter name; 1 found
Open

     * @param Course $course The course entity to be populated.

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

        $expiration_date = $params['expiration_date'] ?? null;

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

        if (false === stripos($department_url, 'http://') && false === stripos($department_url, 'https://')) {

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

                    $recipient_name = api_get_person_name(

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

                    $message .= get_lang('Language').' '.$course_language;

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

        $wanted_code = CourseManager::generate_course_code($wanted_code);

Missing parameter name
Open

     * @param string    Prefix added for databases only

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

        if ($add_unique_prefix) {

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

        $limit_numb_try = 100;

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

        $keys['currentCourseId'] = $keys_course_id;

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

            $keys_are_unique = true;

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

                if ('true' === $send_mail_to_admin) {

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

                $keys_are_unique = false;

Expected 52 spaces after parameter type; 1 found
Open

     * @param string $type

Method name "AddCourse::sort_pictures" is not in camel caps format
Open

    public static function sort_pictures($files, $type)

Declare public methods first,then protected ones and finally private ones
Open

    public static function insertDocument($courseInfo, $counter, $file, $authorId = 0)

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

        $disk_quota = $params['disk_quota'] ?? null;

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

        if (false === stripos($department_url, 'http://') && false === stripos($department_url, 'https://')) {

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

            $department_url = '';

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

        $prefix_for_all = '',

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

        $use_code_indepedent_keys = true

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

        $course_table = Database::get_main_table(TABLE_MAIN_COURSE);

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

        if (!$use_code_indepedent_keys) {

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

            $keys_course_repository = $prefix_for_path.$unique_prefix.$wanted_code.$final_suffix['CourseDir'];

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

        $try_new_fsc_id = $try_new_fsc_db = $try_new_fsc_dir = 0;

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

                      WHERE code='".$keys_course_id."'

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

        $final_suffix = ['CourseId' => '', 'CourseDb' => '', 'CourseDir' => ''];

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

                $try_new_fsc_id++;

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

            if (($try_new_fsc_id + $try_new_fsc_db + $try_new_fsc_dir) > $limit_numb_try) {

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

                $final_suffix['CourseId'] = substr(md5(uniqid(rand())), 0, 4);

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

        $try_new_fsc_id = $try_new_fsc_db = $try_new_fsc_dir = 0;

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

        $keys['currentCourseCode'] = $keys_course_code;

Missing parameter name
Open

     * @param array List of files (sthg like array(0=>array('png'=>1)))

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

            $keys_course_repository = $prefix_for_path.$unique_prefix.$wanted_code.$final_suffix['CourseDir'];

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

        $visual_code = $params['visual_code'];

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

        if ('http://' === $department_url) {

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

            $default_course_visibility = api_get_setting('courses_default_creation_visibility');

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

        $app_plugin = new AppPlugin();

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

            $expiration_date = api_get_utc_datetime(

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

                ->setDepartmentName((string) $department_name)

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

            $keys_course_id = $prefix_for_all.$unique_prefix.$wanted_code.$final_suffix['CourseId'];

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

                    $course_id

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

            $error_msg[] = 'visibility is invalid';

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

            $keys_course_repository = $prefix_for_path.$unique_prefix.$wanted_code.$final_suffix['CourseDir'];

Method name "AddCourse::register_course" is not in camel caps format
Open

    public static function register_course(array $params): ?Course

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

            if ($course_id) {

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

        $tutor_name = $params['tutor_name'] ?? null;

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

        $department_url = $params['department_url'] ?? null;

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

                $send_mail_to_admin = api_get_setting('send_email_to_admin_when_create_course');

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

                    $message .= get_lang('Coach').' '.$tutor_name."\n";

Missing parameter name
Open

     * @param bool      Use code-independent keys

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

        $keys_are_unique = false;

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

        $department_name = $params['department_name'] ?? null;

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

            $expiration_date = api_get_utc_datetime($expiration_date);

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

            $department_url = 'http://'.$department_url;

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

                    $message = get_lang('Dear').' '.$recipient_name.",\n\n".

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

                        $recipient_email,

The variable $use_code_indepedent_keys is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $keys_course_code is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $app_plugin is not named in camelCase.
Open

    private static function installCoursePlugins(int $courseId): void
    {
        $app_plugin = new AppPlugin();
        $app_plugin->install_course_plugins($courseId);
    }

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $disk_quota is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $department_url is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $department_url is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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 register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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 define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $error_msg is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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 register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $expiration_date is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $error_msg is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $keys_course_code is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $try_new_fsc_id is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $keys_course_id is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $try_new_fsc_dir is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $limit_numb_try is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $expiration_date is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $error_msg is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $expiration_date is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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 define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $final_suffix is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $keys_are_unique is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

It is 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 register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $disk_quota is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $expiration_date is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $department_url is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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_id is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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 define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $keys_course_id is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $prefix_for_path is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

It is 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 register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $default_course_visibility is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $error_msg is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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 define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $TABLESETTING is not named in camelCase.
Open

    private static function insertCourseSettings(Course $course): void
    {

        $TABLESETTING = Database::get_course_table(TABLE_COURSE_SETTING);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $app_plugin is not named in camelCase.
Open

    private static function installCoursePlugins(int $courseId): void
    {
        $app_plugin = new AppPlugin();
        $app_plugin->install_course_plugins($courseId);
    }

CamelCaseVariableName

Since: 0.2

It is 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 define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $try_new_fsc_db is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $keys_course_id is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $disk_quota is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $disk_quota is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $try_new_fsc_db is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $try_new_fsc_dir is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $final_suffix is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $TABLESETTING is not named in camelCase.
Open

    private static function insertCourseSettings(Course $course): void
    {

        $TABLESETTING = Database::get_course_table(TABLE_COURSE_SETTING);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $department_url is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $department_name is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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 define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $department_name is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $default_course_visibility is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $expiration_date is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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_id is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $unique_prefix is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $unique_prefix is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $unique_prefix is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $try_new_fsc_id is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $department_url is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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 define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $final_suffix is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

It is 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_id is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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 define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $unique_prefix is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $keys_are_unique is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $prefix_for_all is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $keys_course_repository is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

It is 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 register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $send_mail_to_admin is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $keys_are_unique is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $try_new_fsc_id is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $keys_course_repository is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $department_url is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $error_msg is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $department_url is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $department_url is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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 register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $final_suffix is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $keys_are_unique is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $error_msg is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $expiration_date is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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 register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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 register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $add_unique_prefix is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $limit_numb_try is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

CamelCaseVariableName

Since: 0.2

It is 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 register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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 register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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 register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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 register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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 register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $send_mail_to_admin is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It is 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 register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

CamelCaseVariableName

Since: 0.2

It 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 define_course_keys is not named in camelCase.
Open

    public static function define_course_keys(
        $wanted_code,
        $prefix_for_all = '',
        $prefix_for_base_name = '',
        $prefix_for_path = '',

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 drop_course_tables is not named in camelCase.
Open

    public static function drop_course_tables()
    {
        $list = self::get_course_tables();
        foreach ($list as $table) {
            $sql = "DROP TABLE IF EXISTS ".DB_COURSE_PREFIX.$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 get_course_tables is not named in camelCase.
Open

    public static function get_course_tables()
    {
        $tables = [];
        //$tables[] = 'item_property';
        $tables[] = 'tool';

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 sort_pictures is not named in camelCase.
Open

    public static function sort_pictures($files, $type)
    {
        $pictures = [];
        foreach ($files as $value) {
            if (isset($value[$type]) && '' != $value[$type]) {

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 register_course is not named in camelCase.
Open

    public static function register_course(array $params): ?Course
    {
        global $error_msg;
        $title = $params['title'];
        // Fix amp

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