chamilo/chamilo-lms

View on GitHub
public/main/gradebook/lib/be/result.class.php

Summary

Maintainability
A
0 mins
Test Coverage

The method load() has an NPath complexity of 2448. The configured NPath complexity threshold is 200.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

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

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

            $result = new Result();

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 '188', column '24').
Open

            $res = new Result();

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

        } else {
            exit('Error in Result add: required field empty');
        }

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

        } else {
            exit('Error in Result add: required field empty');
        }

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

            } else {
                $sql .= ' WHERE';
            }

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

                } else {
                    $sql = 'SELECT c_id, user_id, status
                            FROM '.$tbl_course_rel_course.'
                            WHERE status ="'.STUDENT.'" AND c_id = "'.api_get_course_int_id().'" ';
                }

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

            } else {
                $sql .= ' WHERE';
            }

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

        } else {
            $sql .= 'null';
        }

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

        } else {
            $sql .= " WHERE evaluation_id = {$this->evaluation}
                AND user_id = {$this->user_id}
            ";
        }

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 using count() function in for loops.
Open

                for ($i = 0; $i < count($list_user_course_list); $i++) {
                    $sql_verified = 'SELECT COUNT(*) AS count
                                    FROM '.$tbl_grade_results.'
                                    WHERE
                                        user_id="'.intval($list_user_course_list[$i]['user_id']).'" AND

CountInLoopExpression

Since: 2.7.0

Using count/sizeof in loops expressions is considered bad practice and is a potential source of many bugs, especially when the loop manipulates an array, as count happens on each iteration.

Example

class Foo {

  public function bar()
  {
    $array = array();

    for ($i = 0; count($array); $i++) {
      // ...
    }
  }
}

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

The parameter $evaluation_id is not named in camelCase.
Open

    public function set_evaluation_id($evaluation_id)
    {
        $this->evaluation = $evaluation_id;
    }

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

class Result
{
    private $id;
    private $user_id;
    private $evaluation;

CamelCasePropertyName

Since: 0.2

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

Example

class ClassName {
    protected $property_name;
}

Source

The parameter $evaluation_id is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

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

    public function set_date($creation_date)
    {
        $this->created_at = $creation_date;
    }

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 load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

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

class Result
{
    private $id;
    private $user_id;
    private $evaluation;

CamelCasePropertyName

Since: 0.2

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

Example

class ClassName {
    protected $property_name;
}

Source

The parameter $user_id is not named in camelCase.
Open

    public function set_user_id($user_id)
    {
        $this->user_id = $user_id;
    }

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

Missing function doc comment
Open

    public function get_user_id()

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

        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);

Missing function doc comment
Open

    public function get_evaluation_id()

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

                                       VALUES ("'.intval($list_user_course_list[$i]['user_id']).'","'.intval($evaluation_id).'","'.$current_date.'", null);';

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

            $arr = get_object_vars($arr_result[0]);

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

        $this->created_at = api_get_utc_datetime();

Missing parameter name
Open

     * @param $evaluation_id evaluation where this is a result for

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

        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);

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

                while ($row_course_rel_user = Database::fetch_assoc($res_course_rel_user)) {

Missing function doc comment
Open

    public function set_id($id)

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

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)

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

                $current_date = api_get_utc_datetime();

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

                INNER JOIN $tbl_user u

Missing function doc comment
Open

    public function get_score()

Missing function doc comment
Open

    public function set_user_id($user_id)

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

                            FROM '.$tbl_course_rel_course.'

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

                        $sql_insert = 'INSERT INTO '.$tbl_grade_results.'(user_id,evaluation_id,created_at,score)

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

                    FROM '.$tbl_grade_results.'

Method name "Result::get_evaluation_id" is not in camel caps format
Open

    public function get_evaluation_id()

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

        $this->created_at = $creation_date;

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

                            FROM '.$tbl_session_rel_course_user.'

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

        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

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

                    $list_user_course_list[] = $row_course_rel_user;

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

        if (is_null($id) && is_null($user_id) && !is_null($evaluation_id)) {

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

                    if (0 == $info_verified) {

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

                for ($i = 0; $i < count($list_user_course_list); $i++) {

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

                                       VALUES ("'.intval($list_user_course_list[$i]['user_id']).'","'.intval($evaluation_id).'","'.$current_date.'", null);';

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

                    $info_verified = Database::result($res_verified, 0, 0);

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

            $sql = "INSERT INTO ".$tbl_grade_results

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

            $arr_result = $result->load(null, $userid, $evaluationid);

Method name "Result::get_user_id" is not in camel caps format
Open

    public function get_user_id()

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

    public function set_user_id($user_id)

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

    public function set_date($creation_date)

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

        $this->created_at = $creation_date;

Method name "Result::set_id" is not in camel caps format
Open

    public function set_id($id)

Method name "Result::set_evaluation_id" is not in camel caps format
Open

    public function set_evaluation_id($evaluation_id)

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

        if (is_null($id) && is_null($user_id) && !is_null($evaluation_id)) {

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

        $tbl_session_rel_course_user = Database::get_main_table(TABLE_MAIN_SESSION_COURSE_USER);

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

            $sql .= ' gr.evaluation_id = '.intval($evaluation_id);

Missing function doc comment
Open

    public function get_date()

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

        return $this->user_id;

Method name "Result::get_score" is not in camel caps format
Open

    public function get_score()

Method name "Result::get_date" is not in camel caps format
Open

    public function get_date()

Method name "Result::set_score" is not in camel caps format
Open

    public function set_score($score)

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

                    WHERE evaluation_id="'.Database::escape_string($evaluation_id).'"';

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

                                    FROM '.$tbl_grade_results.'

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

                        Database::query($sql_insert);

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

                    $res_verified = Database::query($sql_verified);

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

        foreach ($list_user_course_list as $data) {

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

                                       VALUES ("'.intval($list_user_course_list[$i]['user_id']).'","'.intval($evaluation_id).'","'.$current_date.'", null);';

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

        if (isset($this->user_id) && isset($this->evaluation)) {

Missing function doc comment
Open

    public function get_id()

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

        return $this->created_at;

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

        $this->user_id = $user_id;

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

        $this->user_id = $user_id;

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

    public function set_evaluation_id($evaluation_id)

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

        $this->evaluation = $evaluation_id;

Method name "Result::set_date" is not in camel caps format
Open

    public function set_date($creation_date)

Missing parameter name
Open

     * @param $id result id

Missing parameter name
Open

     * @param $user_id user id (student)

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

        $list_user_course_list = [];

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

                        $sql_insert = 'INSERT INTO '.$tbl_grade_results.'(user_id,evaluation_id,created_at,score)

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

                FROM $tbl_grade_results gr

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

        if (!empty($user_id)) {

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

            $sql .= ' gr.user_id = '.intval($user_id);

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

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)

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

                    $sql_verified = 'SELECT COUNT(*) AS count

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

                                        evaluation_id="'.intval($evaluation_id).'";';

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

                    $res_verified = Database::query($sql_verified);

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

                    $info_verified = Database::result($res_verified, 0, 0);

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

        if (!empty($evaluation_id)) {

Method name "Result::set_user_id" is not in camel caps format
Open

    public function set_user_id($user_id)

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

                    $list_user_course_list[] = $row_course_rel_user;

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

            $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);

Method name "Result::get_id" is not in camel caps format
Open

    public function get_id()

Missing function doc comment
Open

    public function set_evaluation_id($evaluation_id)

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

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

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

                while ($row_course_rel_user = Database::fetch_assoc($res_course_rel_user)) {

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

                                        user_id="'.intval($list_user_course_list[$i]['user_id']).'" AND

The variable $row_course_rel_user is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $info_verified is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $current_date is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $tbl_grade_results is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $res_course_rel_user is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $sql_verified is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $evaluation_id is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

It is 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 function set_user_id($user_id)
    {
        $this->user_id = $user_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 $evaluation_id is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $res_verified is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $sql_insert is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $tbl_grade_results is not named in camelCase.
Open

    public function add()
    {
        if (isset($this->user_id) && isset($this->evaluation)) {
            $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
            $sql = "INSERT INTO ".$tbl_grade_results

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $list_user_course_list is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $row_course_rel_user is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $res_course_rel_user is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $list_user_course_list is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $list_user_course_list is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $tbl_user is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $evaluation_id is not named in camelCase.
Open

    public function set_evaluation_id($evaluation_id)
    {
        $this->evaluation = $evaluation_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 $tbl_grade_results is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $tbl_user is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $list_user_course_list is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $list_user_course_list is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $res_verified is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $creation_date is not named in camelCase.
Open

    public function set_date($creation_date)
    {
        $this->created_at = $creation_date;
    }

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $tbl_course_rel_course is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $evaluation_id is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $sql_insert is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $tbl_course_rel_course is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $tbl_grade_results is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $tbl_session_rel_course_user is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $list_user_course_list is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $tbl_grade_results is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $tbl_session_rel_course_user is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $tbl_grade_results is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $evaluation_id is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $tbl_grade_results is not named in camelCase.
Open

    public function add()
    {
        if (isset($this->user_id) && isset($this->evaluation)) {
            $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
            $sql = "INSERT INTO ".$tbl_grade_results

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $evaluation_id is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $evaluation_id is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $arr_result is not named in camelCase.
Open

    public function addResultLog($userid, $evaluationid)
    {
        if (isset($userid) && isset($evaluationid)) {
            $table = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT_LOG);
            $result = new Result();

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $arr_result is not named in camelCase.
Open

    public function addResultLog($userid, $evaluationid)
    {
        if (isset($userid) && isset($evaluationid)) {
            $table = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT_LOG);
            $result = new Result();

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $sql_verified is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $info_verified is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

It is 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 load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

It is 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 load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

It is 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 load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

Example

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

Source

The variable $current_date is not named in camelCase.
Open

    public static function load($id = null, $user_id = null, $evaluation_id = null, $loadEvalUsers = false)
    {
        $tbl_user = Database::get_main_table(TABLE_MAIN_USER);
        $tbl_grade_results = Database::get_main_table(TABLE_MAIN_GRADEBOOK_RESULT);
        $tbl_course_rel_course = Database::get_main_table(TABLE_MAIN_COURSE_USER);

CamelCaseVariableName

Since: 0.2

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

    public function get_user_id()
    {
        return $this->user_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 set_evaluation_id is not named in camelCase.
Open

    public function set_evaluation_id($evaluation_id)
    {
        $this->evaluation = $evaluation_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 get_date is not named in camelCase.
Open

    public function get_date()
    {
        return $this->created_at;
    }

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

    public function set_score($score)
    {
        $this->score = $score;
    }

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

    public function get_score()
    {
        return $this->score;
    }

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

    public function set_date($creation_date)
    {
        $this->created_at = $creation_date;
    }

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

    public function set_user_id($user_id)
    {
        $this->user_id = $user_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 get_id is not named in camelCase.
Open

    public function get_id()
    {
        return $this->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 get_evaluation_id is not named in camelCase.
Open

    public function get_evaluation_id()
    {
        return $this->evaluation;
    }

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

    public function set_id($id)
    {
        $this->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

There are no issues that match your filters.

Category
Status