ExerciseLink::calc_score()

Complexity

Conditions	43
Paths	7

Size

Total Lines	244
Code Lines	156

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public function calc_score($stud_id = null, $type = null)
    {
        $allowStats = api_get_configuration_value('allow_gradebook_stats');

        if ($allowStats) {
            $link = $this->entity;
            if (!empty($link)) {
                $weight = $link->getScoreWeight();

The method getScoreWeight() does not exist on Chamilo\CoreBundle\Entity\GradebookLink.

                switch ($type) {
                    case 'best':
                        $bestResult = $link->getBestScore();

The method getBestScore() does not exist on Chamilo\CoreBundle\Entity\GradebookLink.

                        $result = [$bestResult, $weight];

                        return $result;
                        break;

break is not strictly necessary here and could be removed.

                    case 'average':
                        $count = count($this->getStudentList());
                        if (empty($count)) {
                            $result = [0, $weight];

                            return $result;
                        }
                        $sumResult = array_sum($link->getUserScoreList());

The method getUserScoreList() does not exist on Chamilo\CoreBundle\Entity\GradebookLink.

                        $result = [$sumResult / $count, $weight];

                        return $result;
                        break;
                    case 'ranking':
                        return '';

The expression return '' returns the type string which is incompatible with the documented return type array.

                        /*
                        $newList = [];
                        $ranking = AbstractLink::getCurrentUserRanking($stud_id, $link->getUserScoreList());
                        return $ranking;*/
                        break;
                    default:
                        if (!empty($stud_id)) {
                            $scoreList = $link->getUserScoreList();
                            $result = [0, $weight];
                            if (isset($scoreList[$stud_id])) {
                                $result = [$scoreList[$stud_id], $weight];
                            }

                            return $result;
                        } else {
                            $studentCount = count($this->getStudentList());
                            $sumResult = array_sum($link->getUserScoreList());
                            $result = [$sumResult, $studentCount];
                        }

                        return $result;
                        break;
                }
            }
        }

        $tblStats = Database::get_main_table(TABLE_STATISTIC_TRACK_E_EXERCISES);
        $tblHp = Database::get_main_table(TABLE_STATISTIC_TRACK_E_HOTPOTATOES);
        $tblDoc = Database::get_course_table(TABLE_DOCUMENT);

        /* the following query should be similar (in conditions) to the one used
        in exercise/exercise.php, look for note-query-exe-results marker*/
        $sessionId = $this->get_session_id();
        $courseId = $this->getCourseId();
        $exerciseData = $this->get_exercise_data();

        $exerciseId = isset($exerciseData['id']) ? $exerciseData['id'] : 0;
        $stud_id = (int) $stud_id;

        if (empty($exerciseId)) {
            return null;
        }

        $key = 'exercise_link_id:'.
            $this->get_id().
            'exerciseId:'.$exerciseId.'student:'.$stud_id.'session:'.$sessionId.'courseId:'.$courseId.'type:'.$type;

        $useCache = api_get_configuration_value('gradebook_use_apcu_cache');
        $cacheAvailable = api_get_configuration_value('apc') && $useCache;
        $cacheDriver = null;
        if ($cacheAvailable) {
            $cacheDriver = new \Doctrine\Common\Cache\ApcuCache();
            if ($cacheDriver->contains($key)) {
                return $cacheDriver->fetch($key);
            }
        }

        $exercise = new Exercise($courseId);
        $exercise->read($exerciseData['id']);

        if (!$this->is_hp) {
            if ($exercise->exercise_was_added_in_lp == false) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

                $sql = "SELECT * FROM $tblStats
                        WHERE
                            exe_exo_id = $exerciseId AND
                            orig_lp_id = 0 AND
                            orig_lp_item_id = 0 AND
                            status <> 'incomplete' AND
                            session_id = $sessionId AND
                            c_id = $courseId
                        ";
            } else {
                $lpId = null;
                if (!empty($exercise->lpList)) {
                    // Taking only the first LP
                    $lpId = current($exercise->lpList);
                    $lpId = $lpId['lp_id'];
                }

                $sql = "SELECT * 
                        FROM $tblStats
                        WHERE
                            exe_exo_id = $exerciseId AND
                            orig_lp_id = $lpId AND
                            status <> 'incomplete' AND
                            session_id = $sessionId AND
                            c_id = $courseId ";
            }

            if (!empty($stud_id) && $type != 'ranking') {
                $sql .= " AND exe_user_id = $stud_id ";
            }
            $sql .= ' ORDER BY exe_id DESC';
        } else {
            $sql = "SELECT * FROM $tblHp hp 
                    INNER JOIN $tblDoc doc
                    ON (hp.exe_name = doc.path AND doc.c_id = hp.c_id)
                    WHERE
                        hp.c_id = $courseId AND                        
                        doc.id = ".$exerciseId;

            if (!empty($stud_id)) {
                $sql .= " AND hp.exe_user_id = $stud_id ";
            }
        }

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

        if (isset($stud_id) && empty($type)) {
            // for 1 student
            if ($data = Database::fetch_array($scores)) {
                $result = [$data['score'], $data['max_score']];
                if ($cacheAvailable) {
                    $cacheDriver->save($key, $result);
                }

                return $result;
            } else {
                if ($cacheAvailable) {
                    $cacheDriver->save($key, null);
                }

                return null;
            }
        } else {
            // all students -> get average
            // normal way of getting the info
            $students = []; // user list, needed to make sure we only
            // take first attempts into account
            $student_count = 0;
            $sum = 0;
            $bestResult = 0;
            $weight = 0;
            $sumResult = 0;

            $studentList = $this->getStudentList();
            $studentIdList = [];
            if (!empty($studentList)) {
                $studentIdList = array_column($studentList, 'user_id');
            }

            while ($data = Database::fetch_array($scores, 'ASSOC')) {
                // Only take into account users in the current student list.
                if (!empty($studentIdList)) {
                    if (!in_array($data['exe_user_id'], $studentIdList)) {
                        continue;
                    }
                }

                if (!isset($students[$data['exe_user_id']])) {
                    if ($data['max_score'] != 0) {
                        $students[$data['exe_user_id']] = $data['score'];
                        $student_count++;
                        if ($data['score'] > $bestResult) {
                            $bestResult = $data['score'];
                        }
                        $sum += $data['score'] / $data['max_score'];
                        $sumResult += $data['score'];
                        $weight = $data['max_score'];
                    }
                }
            }

            if ($student_count == 0) {
                if ($cacheAvailable) {
                    $cacheDriver->save($key, null);
                }

                return null;
            } else {
                switch ($type) {
                    case 'best':
                        $result = [$bestResult, $weight];
                        if ($cacheAvailable) {
                            $cacheDriver->save($key, $result);
                        }

                        return $result;
                        break;
                    case 'average':
                        $count = count($this->getStudentList());
                        if (empty($count)) {
                            $result = [0, $weight];
                            if ($cacheAvailable) {
                                $cacheDriver->save($key, $result);
                            }

                            return $result;
                        }

                        $result = [$sumResult / $count, $weight];

                        if ($cacheAvailable) {
                            $cacheDriver->save($key, $result);
                        }

                        return $result;
                        break;
                    case 'ranking':
                        $ranking = AbstractLink::getCurrentUserRanking($stud_id, $students);
                        if ($cacheAvailable) {
                            $cacheDriver->save($key, $ranking);
                        }

                        return $ranking;
                        break;
                    default:
                        $result = [$sum, $student_count];
                        if ($cacheAvailable) {
                            $cacheDriver->save($key, $result);
                        }

                        return $result;
                        break;
                }