CourseRepository::getSubscribedCoaches() - Code Metrics - Inspection of "Internal - Fix legacy code, use user.id instead of..." - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( fb8ba6...81d51d )

by Julito

created 2020-09-17 12:33 UTC

CourseRepository::getSubscribedCoaches() A

↳ Parent: CourseRepository

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	1
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?php

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

namespace Chamilo\CoreBundle\Repository;

use Chamilo\CoreBundle\Entity\AccessUrl;
use Chamilo\CoreBundle\Entity\Course;
use Chamilo\CoreBundle\Entity\ResourceNode;
use Chamilo\CoreBundle\Entity\Session;
use Chamilo\CoreBundle\Entity\User;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Criteria;
use Doctrine\ORM\Query\Expr\Join;
use Doctrine\ORM\QueryBuilder;

/**
 * Class CourseRepository.
 *
 * The functions inside this class must return an instance of QueryBuilder.
 */
class CourseRepository extends ResourceRepository
{
    /**
     * @param Session $session
     *
     * @return ArrayCollection
     */
    public function getTools(Course $course, Session $session = null)
    {
        $orWhere = Criteria::expr()->eq('sessionId', 0);

        if ($session) {
            $orWhere = Criteria::expr()->in('sessionId', [0, $session->getId()]);
        }

        $criteria = Criteria::create()
            ->where(Criteria::expr()->isNull('sessionId'))
            ->orWhere($orWhere);

        return $course->getTools()->matching($criteria);
    }

    public function deleteCourse(Course $course): void
    {
        $em = $this->getEntityManager();

        // Deleting all nodes connected to the course:
        $node = $course->getResourceNode();
        $children = $node->getChildren();
        /** @var ResourceNode $child */
        foreach ($children as $child) {
            $em->remove($child);
        }

        $em->remove($course);
        $em->flush();
    }

    public function findOneByCode(string $code): ?Course
    {
        return $this->findOneBy(['code' => $code]);
    }

    /**
     * Get all users that are registered in the course. No matter the status.
     *
     * @return QueryBuilder
     */
    public function getSubscribedUsers(Course $course)
    {
        // Course builder
        $queryBuilder = $this->getRepository()->createQueryBuilder('c');

        // Selecting user info.
        $queryBuilder->select('DISTINCT user');

        // Selecting courses for users.
        $queryBuilder->innerJoin('c.users', 'subscriptions');
        $queryBuilder->innerJoin(
            User::class,
            'user',
            Join::WITH,
            'subscriptions.user = user.id'
        );

        if (api_is_western_name_order()) {
            $queryBuilder->add('orderBy', 'user.firstname ASC');
        } else {
            $queryBuilder->add('orderBy', 'user.lastname ASC');
        }

        $wherePart = $queryBuilder->expr()->andx();

        // Get only users subscribed to this course
        $wherePart->add($queryBuilder->expr()->eq('c.id', $course->getId()));

        // $wherePart->add($queryBuilder->expr()->eq('c.status', $status));

        $queryBuilder->where($wherePart);

        return $queryBuilder;
    }

    /**
     * Gets students subscribed in the course.
     *
     * @return QueryBuilder
     */
    public function getSubscribedStudents(Course $course)
    {
        return $this->getSubscribedUsersByStatus($course, STUDENT);
    }

    /**
     * Gets the students subscribed in the course.
     *
     * @return QueryBuilder
     */
    public function getSubscribedCoaches(Course $course)
    {
        return $this->getSubscribedUsers($course);
    }

    /**
     * Gets the teachers subscribed in the course.
     *
     * @return QueryBuilder
     */
    public function getSubscribedTeachers(Course $course)
    {
        return $this->getSubscribedUsersByStatus($course, COURSEMANAGER);
    }

    /**
     * @param int $status use legacy chamilo constants COURSEMANAGER|STUDENT
     *
     * @return QueryBuilder
     */
    public function getSubscribedUsersByStatus(Course $course, $status)
    {
        $queryBuilder = $this->getSubscribedUsers($course);
        $queryBuilder
            ->andWhere(
                $queryBuilder->expr()->eq('subscriptions.status', $status)
            );

        return $queryBuilder;
    }

    public function getCoursesWithNoSession($urlId)
    {
        $queryBuilder = $this->getRepository()->createQueryBuilder('c');
        $queryBuilder = $queryBuilder
            ->select('c')
            ->leftJoin('c.urls', 'u')
            ->leftJoin('c.sessions', 's')
            /*->leftJoin(
                'ChamiloCoreBundle:SessionRelCourse',
                'sc',
                Join::WITH,
                'c != sc.course'
            )->leftJoin(
                'ChamiloCoreBundle:AccessUrlRelCourse',
                'ac',
                Join::WITH,
                'c = ac.course'
            )*/
            ->where($queryBuilder->expr()->isNull('s'))
            //->where($queryBuilder->expr()->eq('s', 0))
            ->where($queryBuilder->expr()->eq('u.url', $urlId))
            ->getQuery();

        $courses = $queryBuilder->getResult();
        $courseList = [];
        /** @var Course $course */
        foreach ($courses as $course) {
            if (empty(0 == $course->getSessions()->count())) {
                $courseList[] = $course;
            }
        }

        return $courseList;
    }

    /**
     * Get course user relationship based in the course_rel_user table.
     *
     * @return array
     */
    public function getCoursesByUser(User $user, AccessUrl $url)
    {
        $qb = $this->repository->createQueryBuilder('course');

        $qb
            ->innerJoin('user.courses', 'courseRelUser')
            ->innerJoin('courseRelUser.course', 'course')
            ->innerJoin('course.urls', 'accessUrlRelCourse')
            ->innerJoin('accessUrlRelCourse.url', 'url')
            ->where('user = :user')
            ->andWhere('url = :url')
            ->setParameters(['user' => $user, 'url' => $url])
            ->addSelect('courseRelUser')
        ;

        $query = $qb->getQuery();

        return $query->getResult();
    }
}


1			<?php
2
3			/* For licensing terms, see /license.txt */
4
5			namespace Chamilo\CoreBundle\Repository;
6
7			use Chamilo\CoreBundle\Entity\AccessUrl;
8			use Chamilo\CoreBundle\Entity\Course;
9			use Chamilo\CoreBundle\Entity\ResourceNode;
10			use Chamilo\CoreBundle\Entity\Session;
11			use Chamilo\CoreBundle\Entity\User;
12			use Doctrine\Common\Collections\ArrayCollection;
13			use Doctrine\Common\Collections\Criteria;
14			use Doctrine\ORM\Query\Expr\Join;
15			use Doctrine\ORM\QueryBuilder;
16
17			/**
18			* Class CourseRepository.
19			*
20			* The functions inside this class must return an instance of QueryBuilder.
21			*/
22			class CourseRepository extends ResourceRepository
23			{
24			/**
25			* @param Session $session
26			*
27			* @return ArrayCollection
28			*/
29			public function getTools(Course $course, Session $session = null)
30			{
31			$orWhere = Criteria::expr()->eq('sessionId', 0);
32
33			if ($session) {
34			$orWhere = Criteria::expr()->in('sessionId', [0, $session->getId()]);
35			}
36
37			$criteria = Criteria::create()
38			->where(Criteria::expr()->isNull('sessionId'))
39			->orWhere($orWhere);
40
41			return $course->getTools()->matching($criteria);
42			}
43
44			public function deleteCourse(Course $course): void
45			{
46			$em = $this->getEntityManager();
47
48			// Deleting all nodes connected to the course:
49			$node = $course->getResourceNode();
50			$children = $node->getChildren();
51			/** @var ResourceNode $child */
52			foreach ($children as $child) {
53			$em->remove($child);
54			}
55
56			$em->remove($course);
57			$em->flush();
58			}
59
60			public function findOneByCode(string $code): ?Course
61			{
62			return $this->findOneBy(['code' => $code]);
63			}
64
65			/**
66			* Get all users that are registered in the course. No matter the status.
67			*
68			* @return QueryBuilder
69			*/
70			public function getSubscribedUsers(Course $course)
71			{
72			// Course builder
73			$queryBuilder = $this->getRepository()->createQueryBuilder('c');
74
75			// Selecting user info.
76			$queryBuilder->select('DISTINCT user');
77
78			// Selecting courses for users.
79			$queryBuilder->innerJoin('c.users', 'subscriptions');
80			$queryBuilder->innerJoin(
81			User::class,
82			'user',
83			Join::WITH,
84			'subscriptions.user = user.id'
85			);
86
87			if (api_is_western_name_order()) {
88			$queryBuilder->add('orderBy', 'user.firstname ASC');
89			} else {
90			$queryBuilder->add('orderBy', 'user.lastname ASC');
91			}
92
93			$wherePart = $queryBuilder->expr()->andx();
94
95			// Get only users subscribed to this course
96			$wherePart->add($queryBuilder->expr()->eq('c.id', $course->getId()));
97
98			// $wherePart->add($queryBuilder->expr()->eq('c.status', $status));
99
100			$queryBuilder->where($wherePart);
101
102			return $queryBuilder;
103			}
104
105			/**
106			* Gets students subscribed in the course.
107			*
108			* @return QueryBuilder
109			*/
110			public function getSubscribedStudents(Course $course)
111			{
112			return $this->getSubscribedUsersByStatus($course, STUDENT);
113			}
114
115			/**
116			* Gets the students subscribed in the course.
117			*
118			* @return QueryBuilder
119			*/
120			public function getSubscribedCoaches(Course $course)
121			{
122			return $this->getSubscribedUsers($course);
123			}
124
125			/**
126			* Gets the teachers subscribed in the course.
127			*
128			* @return QueryBuilder
129			*/
130			public function getSubscribedTeachers(Course $course)
131			{
132			return $this->getSubscribedUsersByStatus($course, COURSEMANAGER);
133			}
134
135			/**
136			* @param int $status use legacy chamilo constants COURSEMANAGER\|STUDENT
137			*
138			* @return QueryBuilder
139			*/
140			public function getSubscribedUsersByStatus(Course $course, $status)
141			{
142			$queryBuilder = $this->getSubscribedUsers($course);
143			$queryBuilder
144			->andWhere(
145			$queryBuilder->expr()->eq('subscriptions.status', $status)
146			);
147
148			return $queryBuilder;
149			}
150
151			public function getCoursesWithNoSession($urlId)
152			{
153			$queryBuilder = $this->getRepository()->createQueryBuilder('c');
154			$queryBuilder = $queryBuilder
155			->select('c')
156			->leftJoin('c.urls', 'u')
157			->leftJoin('c.sessions', 's')
158			/*->leftJoin(
159			'ChamiloCoreBundle:SessionRelCourse',
160			'sc',
161			Join::WITH,
162			'c != sc.course'
163			)->leftJoin(
164			'ChamiloCoreBundle:AccessUrlRelCourse',
165			'ac',
166			Join::WITH,
167			'c = ac.course'
168			)*/
169			->where($queryBuilder->expr()->isNull('s'))
170			//->where($queryBuilder->expr()->eq('s', 0))
171			->where($queryBuilder->expr()->eq('u.url', $urlId))
172			->getQuery();
173
174			$courses = $queryBuilder->getResult();
175			$courseList = [];
176			/** @var Course $course */
177			foreach ($courses as $course) {
178			if (empty(0 == $course->getSessions()->count())) {
179			$courseList[] = $course;
180			}
181			}
182
183			return $courseList;
184			}
185
186			/**
187			* Get course user relationship based in the course_rel_user table.
188			*
189			* @return array
190			*/
191			public function getCoursesByUser(User $user, AccessUrl $url)
192			{
193			$qb = $this->repository->createQueryBuilder('course');
194
195			$qb
196			->innerJoin('user.courses', 'courseRelUser')
197			->innerJoin('courseRelUser.course', 'course')
198			->innerJoin('course.urls', 'accessUrlRelCourse')
199			->innerJoin('accessUrlRelCourse.url', 'url')
200			->where('user = :user')
201			->andWhere('url = :url')
202			->setParameters(['user' => $user, 'url' => $url])
203			->addSelect('courseRelUser')
204			;
205
206			$query = $qb->getQuery();
207
208			return $query->getResult();
209			}
210			}
211

chamilo / chamilo-lms

Push — master ( fb8ba6...81d51d )

CourseRepository::getSubscribedCoaches() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like