ForumThreadLink::calc_score() - Code Metrics - Inspection of "Update webpack.config.js, update js libs" - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 21d25a...5506f9 )

by Julito

created 2021-03-12 14:00 UTC

ForumThreadLink::calc_score() C

↳ Parent: ForumThreadLink

Complexity

Conditions	17
Paths	62

Size

Total Lines	107
Code Lines	74

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	17
eloc	74
nc	62
nop	2
dl	0
loc	107
rs	5.2166
c	0
b	0
f	0

How to fix Long Method Complexity

<?php

/* For licensing terms, see /license.txt */

use Chamilo\CoreBundle\Framework\Container;
use Chamilo\CourseBundle\Entity\CForumThread;

/**
 * Class ForumThreadLink.
 *
 * @author Bert Steppé
 */
class ForumThreadLink extends AbstractLink
{
    private $forum_thread_table;

    /**
     * Constructor.
     */
    public function __construct()
    {
        parent::__construct();
        $this->set_type(LINK_FORUM_THREAD);
    }

    /**
     * @return string
     */
    public function get_type_name()
    {
        return get_lang('Forum threads');
    }

    /**
     * @return bool
     */
    public function is_allowed_to_change_name()
    {
        return false;
    }

    /**
     * Generate an array of all exercises available.
     *
     * @return array 2-dimensional array - every element contains 2 subelements (id, name)
     */
    public function get_all_links()
    {
        if (empty($this->course_code)) {
            return [];
        }

        $tbl_grade_links = Database::get_course_table(TABLE_FORUM_THREAD);
        $sessionId = $this->get_session_id();

        if ($sessionId) {
            $session_condition = 'tl.session_id='.$sessionId;
        } else {
            $session_condition = '(tl.session_id = 0 OR tl.session_id IS NULL)';
        }

        $repo = Container::getForumThreadRepository();
        $course = api_get_course_entity($this->course_id);
        $session = api_get_session_entity($sessionId);

        $qb = $repo->findAllByCourse($course, $session);
        /** @var CForumThread[] $threads */
        $threads = $qb->getQuery()->getResult();

        /*$sql = 'SELECT tl.iid as thread_id, tl.thread_title, tl.thread_title_qualify
                FROM '.$tbl_grade_links.' tl
                WHERE
                    tl.c_id = '.$this->course_id.' AND
                    '.$session_condition.'
                ';
        $result = Database::query($sql);*/
        $cats = [];
        foreach ($threads as $thread) {
            $title = $thread->getThreadTitle();
            $threadQualify = $thread->getThreadTitleQualify();
            if (!empty($threadQualify)) {
                $title = $threadQualify;
            }
            $cats[] = [$thread->getIid(), $title];
        }

        return $cats;
    }

    /**
     * Has anyone done this exercise yet ?
     *
     * @return bool
     */
    public function has_results()
    {
        $table = Database::get_course_table(TABLE_FORUM_POST);

        $sql = "SELECT count(*) AS number FROM $table
                WHERE
                    c_id = ".$this->course_id." AND
                    iid = '".$this->get_ref_id()."'
                ";
        $result = Database::query($sql);
        $number = Database::fetch_row($result);

        return 0 != $number[0];
    }

    /**
     * @param int    $studentId
     * @param string $type
     *
     * @return array|null
     */
    public function calc_score($studentId = null, $type = null)
    {
        $threadInfo = $this->getThreadData();
        $thread_qualify = Database::get_course_table(TABLE_FORUM_THREAD_QUALIFY);
        $sessionId = $this->get_session_id();
        $sessionCondition = api_get_session_condition(
            $sessionId,
            true,
            false,
            'session_id'
        );

        $sql = 'SELECT thread_qualify_max
                FROM '.Database::get_course_table(TABLE_FORUM_THREAD)."
                WHERE
                    c_id = ".$this->course_id." AND
                    iid = '".$this->get_ref_id()."'
                    $sessionCondition
                ";
        $query = Database::query($sql);
        $assignment = Database::fetch_array($query);

        $sql = "SELECT * FROM $thread_qualify
                WHERE
                    c_id = ".$this->course_id." AND
                    iid = ".$this->get_ref_id()."
                    $sessionCondition
                ";
        if (isset($studentId)) {
            $sql .= ' AND user_id = '.intval($studentId);
        }

        // order by id, that way the student's first attempt is accessed first
        $sql .= ' ORDER BY qualify_time DESC';
        $scores = Database::query($sql);

        // for 1 student
        if (isset($studentId)) {
            if (0 == $threadInfo['thread_peer_qualify']) {
                // Classic way of calculate score
                if ($data = Database::fetch_array($scores)) {
                    return [
                        $data['qualify'],
                        $assignment['thread_qualify_max'],
                    ];
                } else {
                    // We sent the 0/thread_qualify_max instead of null for correct calculations
                    return [0, $assignment['thread_qualify_max']];
                }
            } else {
                // Take average
                $score = 0;
                $counter = 0;
                if (Database::num_rows($scores)) {
                    while ($data = Database::fetch_array($scores, 'ASSOC')) {
                        $score += $data['qualify'];
                        $counter++;
                    }
                }
                // If no result
                if (empty($counter) || $counter <= 2) {
                    return [0, $assignment['thread_qualify_max']];
                }

                return [$score / $counter, $assignment['thread_qualify_max']];
            }
        } else {
            // All students -> get average
            $students = []; // user list, needed to make sure we only
            // take first attempts into account
            $counter = 0;
            $sum = 0;
            $bestResult = 0;
            $weight = 0;
            $sumResult = 0;

            while ($data = Database::fetch_array($scores)) {
                if (!(array_key_exists($data['user_id'], $students))) {
                    if (0 != $assignment['thread_qualify_max']) {
                        $students[$data['user_id']] = $data['qualify'];
                        $counter++;
                        $sum += $data['qualify'] / $assignment['thread_qualify_max'];
                        $sumResult += $data['qualify'];
                        if ($data['qualify'] > $bestResult) {
                            $bestResult = $data['qualify'];
                        }
                        $weight = $assignment['thread_qualify_max'];
                    }
                }
            }

            if (0 == $counter) {
                return [null, null];
            } else {
                switch ($type) {
                    case 'best':
                        return [$bestResult, $weight];
                        break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
                    case 'average':
                        return [$sumResult / $counter, $weight];
                        break;
                    case 'ranking':
                        return AbstractLink::getCurrentUserRanking($studentId, $students);
                        break;
                    default:
                        return [$sum, $counter];
                        break;
                }
            }
        }
    }

    public function needs_name_and_description()
    {
        return false;
    }

    public function needs_max()
    {
        return false;
    }

    public function needs_results()
    {
        return false;
    }

    /**
     * @return string
     */
    public function get_name()
    {
        $this->getThreadData();
        $thread_title = isset($this->exercise_data['thread_title']) ? $this->exercise_data['thread_title'] : '';
        $thread_title_qualify = isset($this->exercise_data['thread_title_qualify']) ? $this->exercise_data['thread_title_qualify'] : '';
        if (isset($thread_title_qualify) && '' != $thread_title_qualify) {
            return $this->exercise_data['thread_title_qualify'];
        }

        return $thread_title;
    }

    /**
     * @return string
     */
    public function get_description()
    {
        return ''; //$this->exercise_data['description'];
    }

    /**
     * Check if this still links to an exercise.
     */
    public function is_valid_link()
    {
        $sessionId = $this->get_session_id();
        $sql = 'SELECT count(iid) FROM '.$this->get_forum_thread_table().'
                WHERE
                    c_id = '.$this->course_id.' AND
                    iid = '.$this->get_ref_id().' AND
                    session_id='.$sessionId;
        $result = Database::query($sql);
        $number = Database::fetch_row($result);

        return 0 != $number[0];
    }

    public function get_link()
    {
        $sessionId = $this->get_session_id();
        $sql = 'SELECT * FROM '.$this->get_forum_thread_table()."
                WHERE
                    c_id = {$this->course_id} AND
                    iid = '".$this->get_ref_id()."' AND
                    session_id = $sessionId ";
        $result = Database::query($sql);
        $row = Database::fetch_array($result, 'ASSOC');

        if ($row) {
            $forum_id = $row['forum_id'];

            return api_get_path(WEB_CODE_PATH).'forum/viewthread.php?'.
                api_get_cidreq_params($this->getCourseId(), $sessionId).
                '&thread='.$this->get_ref_id().'&gradebook=view&forum='.$forum_id;
        }

        return '';
    }

    public function get_icon_name()
    {
        return 'forum';
    }

    public function save_linked_data()
    {
        $weight = $this->get_weight();
        $ref_id = $this->get_ref_id();

        if (!empty($ref_id)) {
            $sql = 'UPDATE '.$this->get_forum_thread_table().' SET
                    thread_weight='.api_float_val($weight).'
                    WHERE c_id = '.$this->course_id.' AND iid = '.$ref_id;
            Database::query($sql);
        }
    }

    public function delete_linked_data()
    {
        $ref_id = $this->get_ref_id();
        if (!empty($ref_id)) {
            // Cleans forum
            $sql = 'UPDATE '.$this->get_forum_thread_table().' SET
                    thread_qualify_max = 0,
                    thread_weight = 0,
                    thread_title_qualify = ""
                    WHERE c_id = '.$this->course_id.' AND iid = '.$ref_id;
            Database::query($sql);
        }
    }

    /**
     * Lazy load function to get the database table of the student publications.
     */
    private function get_forum_thread_table()
    {
        return $this->forum_thread_table = Database::get_course_table(TABLE_FORUM_THREAD);
    }

    private function getThreadData()
    {
        $sessionId = $this->get_session_id();
        if ($sessionId) {
            $session_condition = 'session_id = '.$sessionId;
        } else {
            $session_condition = '(session_id = 0 OR session_id IS NULL)';
        }

        if (!isset($this->exercise_data)) {
            $sql = 'SELECT * FROM '.$this->get_forum_thread_table().'
                    WHERE
                        c_id = '.$this->course_id.' AND
                        iid = '.$this->get_ref_id().' AND
                        '.$session_condition;
            $query = Database::query($sql);
            $this->exercise_data = Database::fetch_array($query);
        }

        return $this->exercise_data;
    }
}


1			<?php
2
3			/* For licensing terms, see /license.txt */
4
5			use Chamilo\CoreBundle\Framework\Container;
6			use Chamilo\CourseBundle\Entity\CForumThread;
7
8			/**
9			* Class ForumThreadLink.
10			*
11			* @author Bert Steppé
12			*/
13			class ForumThreadLink extends AbstractLink
14			{
15			private $forum_thread_table;
16
17			/**
18			* Constructor.
19			*/
20			public function __construct()
21			{
22			parent::__construct();
23			$this->set_type(LINK_FORUM_THREAD);
24			}
25
26			/**
27			* @return string
28			*/
29			public function get_type_name()
30			{
31			return get_lang('Forum threads');
32			}
33
34			/**
35			* @return bool
36			*/
37			public function is_allowed_to_change_name()
38			{
39			return false;
40			}
41
42			/**
43			* Generate an array of all exercises available.
44			*
45			* @return array 2-dimensional array - every element contains 2 subelements (id, name)
46			*/
47			public function get_all_links()
48			{
49			if (empty($this->course_code)) {
50			return [];
51			}
52
53			$tbl_grade_links = Database::get_course_table(TABLE_FORUM_THREAD);
54			$sessionId = $this->get_session_id();
55
56			if ($sessionId) {
57			$session_condition = 'tl.session_id='.$sessionId;
58			} else {
59			$session_condition = '(tl.session_id = 0 OR tl.session_id IS NULL)';
60			}
61
62			$repo = Container::getForumThreadRepository();
63			$course = api_get_course_entity($this->course_id);
64			$session = api_get_session_entity($sessionId);
65
66			$qb = $repo->findAllByCourse($course, $session);
67			/** @var CForumThread[] $threads */
68			$threads = $qb->getQuery()->getResult();
69
70			/*$sql = 'SELECT tl.iid as thread_id, tl.thread_title, tl.thread_title_qualify
71			FROM '.$tbl_grade_links.' tl
72			WHERE
73			tl.c_id = '.$this->course_id.' AND
74			'.$session_condition.'
75			';
76			$result = Database::query($sql);*/
77			$cats = [];
78			foreach ($threads as $thread) {
79			$title = $thread->getThreadTitle();
80			$threadQualify = $thread->getThreadTitleQualify();
81			if (!empty($threadQualify)) {
82			$title = $threadQualify;
83			}
84			$cats[] = [$thread->getIid(), $title];
85			}
86
87			return $cats;
88			}
89
90			/**
91			* Has anyone done this exercise yet ?
92			*
93			* @return bool
94			*/
95			public function has_results()
96			{
97			$table = Database::get_course_table(TABLE_FORUM_POST);
98
99			$sql = "SELECT count(*) AS number FROM $table
100			WHERE
101			c_id = ".$this->course_id." AND
102			iid = '".$this->get_ref_id()."'
103			";
104			$result = Database::query($sql);
105			$number = Database::fetch_row($result);
106
107			return 0 != $number[0];
108			}
109
110			/**
111			* @param int $studentId
112			* @param string $type
113			*
114			* @return array\|null
115			*/
116			public function calc_score($studentId = null, $type = null)
117			{
118			$threadInfo = $this->getThreadData();
119			$thread_qualify = Database::get_course_table(TABLE_FORUM_THREAD_QUALIFY);
120			$sessionId = $this->get_session_id();
121			$sessionCondition = api_get_session_condition(
122			$sessionId,
123			true,
124			false,
125			'session_id'
126			);
127
128			$sql = 'SELECT thread_qualify_max
129			FROM '.Database::get_course_table(TABLE_FORUM_THREAD)."
130			WHERE
131			c_id = ".$this->course_id." AND
132			iid = '".$this->get_ref_id()."'
133			$sessionCondition
134			";
135			$query = Database::query($sql);
136			$assignment = Database::fetch_array($query);
137
138			$sql = "SELECT * FROM $thread_qualify
139			WHERE
140			c_id = ".$this->course_id." AND
141			iid = ".$this->get_ref_id()."
142			$sessionCondition
143			";
144			if (isset($studentId)) {
145			$sql .= ' AND user_id = '.intval($studentId);
146			}
147
148			// order by id, that way the student's first attempt is accessed first
149			$sql .= ' ORDER BY qualify_time DESC';
150			$scores = Database::query($sql);
151
152			// for 1 student
153			if (isset($studentId)) {
154			if (0 == $threadInfo['thread_peer_qualify']) {
155			// Classic way of calculate score
156			if ($data = Database::fetch_array($scores)) {
157			return [
158			$data['qualify'],
159			$assignment['thread_qualify_max'],
160			];
161			} else {
162			// We sent the 0/thread_qualify_max instead of null for correct calculations
163			return [0, $assignment['thread_qualify_max']];
164			}
165			} else {
166			// Take average
167			$score = 0;
168			$counter = 0;
169			if (Database::num_rows($scores)) {
170			while ($data = Database::fetch_array($scores, 'ASSOC')) {
171			$score += $data['qualify'];
172			$counter++;
173			}
174			}
175			// If no result
176			if (empty($counter) \|\| $counter <= 2) {
177			return [0, $assignment['thread_qualify_max']];
178			}
179
180			return [$score / $counter, $assignment['thread_qualify_max']];
181			}
182			} else {
183			// All students -> get average
184			$students = []; // user list, needed to make sure we only
185			// take first attempts into account
186			$counter = 0;
187			$sum = 0;
188			$bestResult = 0;
189			$weight = 0;
190			$sumResult = 0;
191
192			while ($data = Database::fetch_array($scores)) {
193			if (!(array_key_exists($data['user_id'], $students))) {
194			if (0 != $assignment['thread_qualify_max']) {
195			$students[$data['user_id']] = $data['qualify'];
196			$counter++;
197			$sum += $data['qualify'] / $assignment['thread_qualify_max'];
198			$sumResult += $data['qualify'];
199			if ($data['qualify'] > $bestResult) {
200			$bestResult = $data['qualify'];
201			}
202			$weight = $assignment['thread_qualify_max'];
203			}
204			}
205			}
206
207			if (0 == $counter) {
208			return [null, null];
209			} else {
210			switch ($type) {
211			case 'best':
212			return [$bestResult, $weight];
213			break;
			0 ignored issues – show Unused Code introduced 2018-01-05 13:33 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
214			case 'average':
215			return [$sumResult / $counter, $weight];
216			break;
217			case 'ranking':
218			return AbstractLink::getCurrentUserRanking($studentId, $students);
219			break;
220			default:
221			return [$sum, $counter];
222			break;
223			}
224			}
225			}
226			}
227
228			public function needs_name_and_description()
229			{
230			return false;
231			}
232
233			public function needs_max()
234			{
235			return false;
236			}
237
238			public function needs_results()
239			{
240			return false;
241			}
242
243			/**
244			* @return string
245			*/
246			public function get_name()
247			{
248			$this->getThreadData();
249			$thread_title = isset($this->exercise_data['thread_title']) ? $this->exercise_data['thread_title'] : '';
250			$thread_title_qualify = isset($this->exercise_data['thread_title_qualify']) ? $this->exercise_data['thread_title_qualify'] : '';
251			if (isset($thread_title_qualify) && '' != $thread_title_qualify) {
252			return $this->exercise_data['thread_title_qualify'];
253			}
254
255			return $thread_title;
256			}
257
258			/**
259			* @return string
260			*/
261			public function get_description()
262			{
263			return ''; //$this->exercise_data['description'];
264			}
265
266			/**
267			* Check if this still links to an exercise.
268			*/
269			public function is_valid_link()
270			{
271			$sessionId = $this->get_session_id();
272			$sql = 'SELECT count(iid) FROM '.$this->get_forum_thread_table().'
273			WHERE
274			c_id = '.$this->course_id.' AND
275			iid = '.$this->get_ref_id().' AND
276			session_id='.$sessionId;
277			$result = Database::query($sql);
278			$number = Database::fetch_row($result);
279
280			return 0 != $number[0];
281			}
282
283			public function get_link()
284			{
285			$sessionId = $this->get_session_id();
286			$sql = 'SELECT * FROM '.$this->get_forum_thread_table()."
287			WHERE
288			c_id = {$this->course_id} AND
289			iid = '".$this->get_ref_id()."' AND
290			session_id = $sessionId ";
291			$result = Database::query($sql);
292			$row = Database::fetch_array($result, 'ASSOC');
293
294			if ($row) {
295			$forum_id = $row['forum_id'];
296
297			return api_get_path(WEB_CODE_PATH).'forum/viewthread.php?'.
298			api_get_cidreq_params($this->getCourseId(), $sessionId).
299			'&thread='.$this->get_ref_id().'&gradebook=view&forum='.$forum_id;
300			}
301
302			return '';
303			}
304
305			public function get_icon_name()
306			{
307			return 'forum';
308			}
309
310			public function save_linked_data()
311			{
312			$weight = $this->get_weight();
313			$ref_id = $this->get_ref_id();
314
315			if (!empty($ref_id)) {
316			$sql = 'UPDATE '.$this->get_forum_thread_table().' SET
317			thread_weight='.api_float_val($weight).'
318			WHERE c_id = '.$this->course_id.' AND iid = '.$ref_id;
319			Database::query($sql);
320			}
321			}
322
323			public function delete_linked_data()
324			{
325			$ref_id = $this->get_ref_id();
326			if (!empty($ref_id)) {
327			// Cleans forum
328			$sql = 'UPDATE '.$this->get_forum_thread_table().' SET
329			thread_qualify_max = 0,
330			thread_weight = 0,
331			thread_title_qualify = ""
332			WHERE c_id = '.$this->course_id.' AND iid = '.$ref_id;
333			Database::query($sql);
334			}
335			}
336
337			/**
338			* Lazy load function to get the database table of the student publications.
339			*/
340			private function get_forum_thread_table()
341			{
342			return $this->forum_thread_table = Database::get_course_table(TABLE_FORUM_THREAD);
343			}
344
345			private function getThreadData()
346			{
347			$sessionId = $this->get_session_id();
348			if ($sessionId) {
349			$session_condition = 'session_id = '.$sessionId;
350			} else {
351			$session_condition = '(session_id = 0 OR session_id IS NULL)';
352			}
353
354			if (!isset($this->exercise_data)) {
355			$sql = 'SELECT * FROM '.$this->get_forum_thread_table().'
356			WHERE
357			c_id = '.$this->course_id.' AND
358			iid = '.$this->get_ref_id().' AND
359			'.$session_condition;
360			$query = Database::query($sql);
361			$this->exercise_data = Database::fetch_array($query);
362			}
363
364			return $this->exercise_data;
365			}
366			}
367

chamilo / chamilo-lms

Push — master ( 21d25a...5506f9 )

ForumThreadLink::calc_score() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like