AccessUrl::getResourceIdentifier() - Code Metrics - Inspection of "Add access URL chooser for users with multiple act..." - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#6532)

by Angel Fernando Quiroz

created 2025-08-04 20:21 UTC

AccessUrl::getResourceIdentifier() A

↳ Parent: AccessUrl

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	0
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

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

namespace Chamilo\CoreBundle\Entity;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Link;
use Chamilo\CoreBundle\Controller\Api\UserAccessUrlsController;
use Chamilo\CoreBundle\Entity\Listener\AccessUrlListener;
use Chamilo\CoreBundle\Entity\Listener\ResourceListener;
use Chamilo\CoreBundle\Repository\Node\AccessUrlRepository;
use DateTime;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\Common\Collections\Criteria;
use Doctrine\ORM\Mapping as ORM;
use Gedmo\Mapping\Annotation as Gedmo;
use Stringable;
use Symfony\Component\Serializer\Annotation\Groups;
use Symfony\Component\Validator\Constraints as Assert;

#[ApiResource(
    normalizationContext: [
        'groups' => ['access_url:read'],
        'swagger_definition_name' => 'Read',
    ],
    denormalizationContext: [
        'groups' => ['access_url:write', 'course_category:write'],
    ],
    security: "is_granted('ROLE_ADMIN')"
)]
#[ORM\Table(name: 'access_url')]
#[Gedmo\Tree(type: 'nested')]
#[ORM\Entity(repositoryClass: AccessUrlRepository::class)]
#[ORM\EntityListeners([AccessUrlListener::class, ResourceListener::class])]
#[ApiResource(
    uriTemplate: '/users/{id}/access_urls',
    operations: [new GetCollection(controller: UserAccessUrlsController::class)],
    uriVariables: [
        'id' => new Link(description: 'User identifier'),
    ],
    normalizationContext: ['groups' => ['user_access_url:read']],
    paginationEnabled: false,
)]
class AccessUrl extends AbstractResource implements ResourceInterface, Stringable
{
    public const DEFAULT_ACCESS_URL = 'http://localhost/';
    #[ORM\Column(name: 'id', type: 'integer')]
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[Groups(['access_url:read', 'access_url:write'])]
    protected ?int $id = null;

    /**
     * @var Collection<int, AccessUrlRelCourse>
     */
    #[ORM\OneToMany(mappedBy: 'url', targetEntity: AccessUrlRelCourse::class, cascade: ['persist'], orphanRemoval: true)]
    protected Collection $courses;

    /**
     * @var Collection<int, AccessUrlRelSession>
     */
    #[ORM\OneToMany(mappedBy: 'url', targetEntity: AccessUrlRelSession::class, cascade: ['persist'], orphanRemoval: true)]
    protected Collection $sessions;

    /**
     * @var Collection<int, AccessUrlRelUser>
     */
    #[ORM\OneToMany(mappedBy: 'url', targetEntity: AccessUrlRelUser::class, cascade: ['persist'], orphanRemoval: true)]
    protected Collection $users;

    /**
     * @var Collection<int, SettingsCurrent>
     */
    #[ORM\OneToMany(mappedBy: 'url', targetEntity: SettingsCurrent::class, cascade: ['persist'], orphanRemoval: true)]
    protected Collection $settings;

    /**
     * @var Collection<int, SessionCategory>
     */
    #[ORM\OneToMany(mappedBy: 'url', targetEntity: SessionCategory::class, cascade: ['persist'], orphanRemoval: true)]
    protected Collection $sessionCategories;

    /**
     * @var Collection<int, AccessUrlRelCourseCategory>
     */
    #[ORM\OneToMany(mappedBy: 'url', targetEntity: AccessUrlRelCourseCategory::class, cascade: ['persist'], orphanRemoval: true)]
    protected Collection $courseCategory;

    #[ORM\JoinColumn(onDelete: 'CASCADE')]
    #[Gedmo\TreeParent]
    #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'children')]
    protected ?AccessUrl $parent = null;

    /**
     * @var Collection<int, AccessUrl>
     */
    #[ORM\OneToMany(mappedBy: 'parent', targetEntity: self::class)]
    #[ORM\OrderBy(['id' => 'ASC'])]
    protected Collection $children;

    #[Gedmo\TreeLeft]
    #[ORM\Column(name: 'lft', type: 'integer')]
    protected int $lft;

    #[Gedmo\TreeLevel]
    #[ORM\Column(name: 'lvl', type: 'integer')]
    protected int $lvl;

    #[Gedmo\TreeRight]
    #[ORM\Column(name: 'rgt', type: 'integer')]
    protected int $rgt;

    #[Gedmo\TreeRoot]
    #[ORM\ManyToOne(targetEntity: self::class)]
    #[ORM\JoinColumn(name: 'tree_root', onDelete: 'CASCADE')]
    protected ?AccessUrl $root = null;

    #[Assert\NotBlank]
    #[Groups(['access_url:read', 'access_url:write', 'user_access_url:read'])]
    #[ORM\Column(name: 'url', type: 'string', length: 255)]
    protected string $url;

    #[Groups(['user_access_url:read'])]
    #[ORM\Column(name: 'description', type: 'text')]
    protected ?string $description = null;

    #[ORM\Column(name: 'active', type: 'integer')]
    protected int $active;

    #[ORM\Column(name: 'created_by', type: 'integer')]
    protected int $createdBy;

    #[ORM\Column(name: 'tms', type: 'datetime', nullable: true)]
    protected ?DateTime $tms;

    #[ORM\Column(name: 'url_type', type: 'boolean', nullable: true)]
    protected ?bool $urlType = null;

    #[ORM\Column(name: 'limit_courses', type: 'integer', nullable: true)]
    protected ?int $limitCourses = null;

    #[ORM\Column(name: 'limit_active_courses', type: 'integer', nullable: true)]
    protected ?int $limitActiveCourses = null;

    #[ORM\Column(name: 'limit_sessions', type: 'integer', nullable: true)]
    protected ?int $limitSessions = null;

    #[ORM\Column(name: 'limit_users', type: 'integer', nullable: true)]
    protected ?int $limitUsers = null;

    #[ORM\Column(name: 'limit_teachers', type: 'integer', nullable: true)]
    protected ?int $limitTeachers = null;

    #[ORM\Column(name: 'limit_disk_space', type: 'integer', nullable: true)]
    protected ?int $limitDiskSpace = null;

    #[Assert\Email]
    #[ORM\Column(name: 'email', type: 'string', length: 255, nullable: true)]
    protected ?string $email = null;

    /**
     * @var Collection<int, AccessUrlRelColorTheme>
     */
    #[ORM\OneToMany(mappedBy: 'url', targetEntity: AccessUrlRelColorTheme::class, cascade: ['persist'], orphanRemoval: true)]
    private Collection $colorThemes;

    /**
     * @var Collection<int, AccessUrlRelPlugin>
     */
    #[ORM\OneToMany(mappedBy: 'url', targetEntity: AccessUrlRelPlugin::class, fetch: 'EXTRA_LAZY', orphanRemoval: true)]
    private Collection $plugins;

    #[ORM\Column(options: ['default' => false])]
    private bool $isLoginOnly = false;

    public function __construct()
    {
        $this->description = '';
        $this->tms = new DateTime();
        $this->createdBy = 1;
        $this->courses = new ArrayCollection();
        $this->sessions = new ArrayCollection();
        $this->users = new ArrayCollection();
        $this->settings = new ArrayCollection();
        $this->sessionCategories = new ArrayCollection();
        $this->courseCategory = new ArrayCollection();
        $this->children = new ArrayCollection();
        $this->colorThemes = new ArrayCollection();
        $this->plugins = new ArrayCollection();
    }

    public function __toString(): string
    {
        return $this->getUrl();
    }

    public function getUrl(): string
    {
        return $this->url;
    }

    public function setUrl(string $url): self
    {
        $this->url = $url;

        return $this;
    }

    public function getDescription(): ?string
    {
        return $this->description;
    }

    public function setDescription(string $description): self
    {
        $this->description = $description;

        return $this;
    }

    public function getActive(): int
    {
        return $this->active;
    }

    public function setActive(int $active): self
    {
        $this->active = $active;

        return $this;
    }

    public function getCreatedBy(): int
    {
        return $this->createdBy;
    }

    public function setCreatedBy(int $createdBy): self
    {
        $this->createdBy = $createdBy;

        return $this;
    }

    public function getTms(): ?DateTime
    {
        return $this->tms;
    }

    public function setTms(DateTime $tms): self
    {
        $this->tms = $tms;

        return $this;
    }

    public function getUrlType(): ?bool
    {
        return $this->urlType;
    }

    public function setUrlType(bool $urlType): self
    {
        $this->urlType = $urlType;

        return $this;
    }

    public function getLimitActiveCourses(): ?int
    {
        return $this->limitActiveCourses;
    }

    public function setLimitActiveCourses(int $limitActiveCourses): self
    {
        $this->limitActiveCourses = $limitActiveCourses;

        return $this;
    }

    public function getLimitSessions(): ?int
    {
        return $this->limitSessions;
    }

    public function setLimitSessions(int $limitSessions): self
    {
        $this->limitSessions = $limitSessions;

        return $this;
    }

    public function getLimitUsers(): ?int
    {
        return $this->limitUsers;
    }

    public function setLimitUsers(int $limitUsers): self
    {
        $this->limitUsers = $limitUsers;

        return $this;
    }

    public function getLimitTeachers(): ?int
    {
        return $this->limitTeachers;
    }

    public function setLimitTeachers(int $limitTeachers): self
    {
        $this->limitTeachers = $limitTeachers;

        return $this;
    }

    public function getLimitDiskSpace(): ?int
    {
        return $this->limitDiskSpace;
    }

    public function setLimitDiskSpace(int $limitDiskSpace): self
    {
        $this->limitDiskSpace = $limitDiskSpace;

        return $this;
    }

    public function getEmail(): ?string
    {
        return $this->email;
    }

    public function setEmail(string $email): self
    {
        $this->email = $email;

        return $this;
    }

    /**
     * @return Collection<int, SettingsCurrent>
     */
    public function getSettings(): Collection
    {
        return $this->settings;
    }

    /**
     * @param Collection<int, SettingsCurrent> $settings
     */
    public function setSettings(Collection $settings): self
    {
        $this->settings = $settings;

        return $this;
    }

    public function getLimitCourses(): ?int
    {
        return $this->limitCourses;
    }

    public function setLimitCourses(int $limitCourses): self
    {
        $this->limitCourses = $limitCourses;

        return $this;
    }

    /**
     * @return Collection<int, AccessUrlRelCourse>
     */
    public function getCourses(): Collection
    {
        return $this->courses;
    }

    public function setCourses(Collection $courses): self
    {
        $this->courses = $courses;

        return $this;
    }

    public function addCourse(Course $course): self
    {
        if (!$this->hasCourse($course)) {
            $urlRelCourse = (new AccessUrlRelCourse())->setUrl($this);
            $course->addUrls($urlRelCourse);

            $this->courses->add($urlRelCourse);
        }

        return $this;
    }

    public function hasCourse(Course $course): bool
    {
        if ($this->courses->count() > 0) {
            $criteria = Criteria::create()->where(Criteria::expr()->eq('course', $course));
            $found = $this->courses->matching($criteria);

            return $found->count() > 0;
        }

        return false;
    }

    /**
     * @return Collection<int, SessionCategory>
     */
    public function getSessionCategories(): Collection
    {
        return $this->sessionCategories;
    }

    public function setSessionCategories(Collection $sessionCategories): self
    {
        $this->sessionCategories = $sessionCategories;

        return $this;
    }

    /**
     * @return Collection<int, AccessUrlRelSession>
     */
    public function getSessions(): Collection
    {
        return $this->sessions;
    }

    /**
     * @return Collection<int, AccessUrl>
     */
    public function getChildren(): Collection
    {
        return $this->children;
    }

    /**
     * @return Collection<int, AccessUrlRelUser>
     */
    public function getUsers(): Collection
    {
        return $this->users;
    }

    public function addUser(User $user): self
    {
        if (!$this->hasUser($user)) {
            $accessUrlRelUser = (new AccessUrlRelUser())->setUser($user)->setUrl($this);
            $this->users->add($accessUrlRelUser);
        }

        return $this;
    }

    public function hasUser(User $user): bool
    {
        if (0 !== $this->users->count()) {
            $criteria = Criteria::create()->where(Criteria::expr()->eq('user', $user));
            $relation = $this->users->matching($criteria);

            return $relation->count() > 0;
        }

        return false;
    }

    /**
     * @return Collection<int, AccessUrlRelCourseCategory>
     */
    public function getCourseCategory(): Collection
    {
        return $this->courseCategory;
    }

    public function getLft(): int
    {
        return $this->lft;
    }

    public function getLvl(): int
    {
        return $this->lvl;
    }

    public function getRgt(): int
    {
        return $this->rgt;
    }

    public function getRoot(): ?self
    {
        return $this->root;
    }

    public function getResourceIdentifier(): int
    {
        return $this->getId();

    }

    public function getId(): ?int
    {
        return $this->id;
    }

    public function getResourceName(): string
    {
        $url = $this->getUrl();
        $url = parse_url($url);

        return $url['host'];
    }

    public function setResourceName(string $name): self
    {
        return $this->setUrl($name);
    }

    public function getActiveColorTheme(): ?AccessUrlRelColorTheme
    {
        $criteria = Criteria::create();
        $criteria->where(
            Criteria::expr()->eq('active', true)
        );

        return $this->colorThemes->matching($criteria)->first() ?: null;
    }

    /**
     * @return Collection<int, AccessUrlRelColorTheme>
     */
    public function getColorThemes(): Collection
    {
        return $this->colorThemes;
    }

    public function addColorTheme(AccessUrlRelColorTheme $colorTheme): static
    {
        if (!$this->colorThemes->contains($colorTheme)) {
            $this->colorThemes->add($colorTheme);
            $colorTheme->setUrl($this);
        }

        return $this;
    }

    public function removeColorTheme(AccessUrlRelColorTheme $colorTheme): static
    {
        if ($this->colorThemes->removeElement($colorTheme)) {
            // set the owning side to null (unless already changed)
            if ($colorTheme->getUrl() === $this) {
                $colorTheme->setUrl(null);
            }
        }

        return $this;
    }

    public function getColorThemeByTheme(ColorTheme $theme): ?AccessUrlRelColorTheme
    {
        $criteria = Criteria::create();
        $criteria->where(
            Criteria::expr()->eq('colorTheme', $theme)
        );

        return $this->colorThemes->matching($criteria)->first() ?: null;
    }

    /**
     * @return Collection<int, AccessUrlRelPlugin>
     */
    public function getPlugins(): Collection
    {
        return $this->plugins;
    }

    public function addPlugin(AccessUrlRelPlugin $plugin): static
    {
        if (!$this->plugins->contains($plugin)) {
            $this->plugins->add($plugin);
            $plugin->setUrl($this);
        }

        return $this;
    }

    public function removePlugin(AccessUrlRelPlugin $plugin): static
    {
        if ($this->plugins->removeElement($plugin)) {
            // set the owning side to null (unless already changed)
            if ($plugin->getUrl() === $this) {
                $plugin->setUrl(null);
            }
        }

        return $this;
    }

    public function isLoginOnly(): bool
    {
        return $this->isLoginOnly;
    }

    public function setIsLoginOnly(bool $isLoginOnly): static
    {
        $this->isLoginOnly = $isLoginOnly;

        return $this;
    }

    public function setSuperior(?AccessUrl $accessUrl): static
    {
        $this->parent = $accessUrl;

        return $this;
    }

    public function getSuperior(): ?AccessUrl
    {
        return $this->parent;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/* For licensing terms, see /license.txt */
6
7			namespace Chamilo\CoreBundle\Entity;
8
9			use ApiPlatform\Metadata\ApiResource;
10			use ApiPlatform\Metadata\GetCollection;
11			use ApiPlatform\Metadata\Link;
12			use Chamilo\CoreBundle\Controller\Api\UserAccessUrlsController;
13			use Chamilo\CoreBundle\Entity\Listener\AccessUrlListener;
14			use Chamilo\CoreBundle\Entity\Listener\ResourceListener;
15			use Chamilo\CoreBundle\Repository\Node\AccessUrlRepository;
16			use DateTime;
17			use Doctrine\Common\Collections\ArrayCollection;
18			use Doctrine\Common\Collections\Collection;
19			use Doctrine\Common\Collections\Criteria;
20			use Doctrine\ORM\Mapping as ORM;
21			use Gedmo\Mapping\Annotation as Gedmo;
22			use Stringable;
23			use Symfony\Component\Serializer\Annotation\Groups;
24			use Symfony\Component\Validator\Constraints as Assert;
25
26			#[ApiResource(
27			normalizationContext: [
28			'groups' => ['access_url:read'],
29			'swagger_definition_name' => 'Read',
30			],
31			denormalizationContext: [
32			'groups' => ['access_url:write', 'course_category:write'],
33			],
34			security: "is_granted('ROLE_ADMIN')"
35			)]
36			#[ORM\Table(name: 'access_url')]
37			#[Gedmo\Tree(type: 'nested')]
38			#[ORM\Entity(repositoryClass: AccessUrlRepository::class)]
39			#[ORM\EntityListeners([AccessUrlListener::class, ResourceListener::class])]
40			#[ApiResource(
41			uriTemplate: '/users/{id}/access_urls',
42			operations: [new GetCollection(controller: UserAccessUrlsController::class)],
43			uriVariables: [
44			'id' => new Link(description: 'User identifier'),
45			],
46			normalizationContext: ['groups' => ['user_access_url:read']],
47			paginationEnabled: false,
48			)]
49			class AccessUrl extends AbstractResource implements ResourceInterface, Stringable
50			{
51			public const DEFAULT_ACCESS_URL = 'http://localhost/';
52			#[ORM\Column(name: 'id', type: 'integer')]
53			#[ORM\Id]
54			#[ORM\GeneratedValue]
55			#[Groups(['access_url:read', 'access_url:write'])]
56			protected ?int $id = null;
57
58			/**
59			* @var Collection<int, AccessUrlRelCourse>
60			*/
61			#[ORM\OneToMany(mappedBy: 'url', targetEntity: AccessUrlRelCourse::class, cascade: ['persist'], orphanRemoval: true)]
62			protected Collection $courses;
63
64			/**
65			* @var Collection<int, AccessUrlRelSession>
66			*/
67			#[ORM\OneToMany(mappedBy: 'url', targetEntity: AccessUrlRelSession::class, cascade: ['persist'], orphanRemoval: true)]
68			protected Collection $sessions;
69
70			/**
71			* @var Collection<int, AccessUrlRelUser>
72			*/
73			#[ORM\OneToMany(mappedBy: 'url', targetEntity: AccessUrlRelUser::class, cascade: ['persist'], orphanRemoval: true)]
74			protected Collection $users;
75
76			/**
77			* @var Collection<int, SettingsCurrent>
78			*/
79			#[ORM\OneToMany(mappedBy: 'url', targetEntity: SettingsCurrent::class, cascade: ['persist'], orphanRemoval: true)]
80			protected Collection $settings;
81
82			/**
83			* @var Collection<int, SessionCategory>
84			*/
85			#[ORM\OneToMany(mappedBy: 'url', targetEntity: SessionCategory::class, cascade: ['persist'], orphanRemoval: true)]
86			protected Collection $sessionCategories;
87
88			/**
89			* @var Collection<int, AccessUrlRelCourseCategory>
90			*/
91			#[ORM\OneToMany(mappedBy: 'url', targetEntity: AccessUrlRelCourseCategory::class, cascade: ['persist'], orphanRemoval: true)]
92			protected Collection $courseCategory;
93
94			#[ORM\JoinColumn(onDelete: 'CASCADE')]
95			#[Gedmo\TreeParent]
96			#[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'children')]
97			protected ?AccessUrl $parent = null;
98
99			/**
100			* @var Collection<int, AccessUrl>
101			*/
102			#[ORM\OneToMany(mappedBy: 'parent', targetEntity: self::class)]
103			#[ORM\OrderBy(['id' => 'ASC'])]
104			protected Collection $children;
105
106			#[Gedmo\TreeLeft]
107			#[ORM\Column(name: 'lft', type: 'integer')]
108			protected int $lft;
109
110			#[Gedmo\TreeLevel]
111			#[ORM\Column(name: 'lvl', type: 'integer')]
112			protected int $lvl;
113
114			#[Gedmo\TreeRight]
115			#[ORM\Column(name: 'rgt', type: 'integer')]
116			protected int $rgt;
117
118			#[Gedmo\TreeRoot]
119			#[ORM\ManyToOne(targetEntity: self::class)]
120			#[ORM\JoinColumn(name: 'tree_root', onDelete: 'CASCADE')]
121			protected ?AccessUrl $root = null;
122
123			#[Assert\NotBlank]
124			#[Groups(['access_url:read', 'access_url:write', 'user_access_url:read'])]
125			#[ORM\Column(name: 'url', type: 'string', length: 255)]
126			protected string $url;
127
128			#[Groups(['user_access_url:read'])]
129			#[ORM\Column(name: 'description', type: 'text')]
130			protected ?string $description = null;
131
132			#[ORM\Column(name: 'active', type: 'integer')]
133			protected int $active;
134
135			#[ORM\Column(name: 'created_by', type: 'integer')]
136			protected int $createdBy;
137
138			#[ORM\Column(name: 'tms', type: 'datetime', nullable: true)]
139			protected ?DateTime $tms;
140
141			#[ORM\Column(name: 'url_type', type: 'boolean', nullable: true)]
142			protected ?bool $urlType = null;
143
144			#[ORM\Column(name: 'limit_courses', type: 'integer', nullable: true)]
145			protected ?int $limitCourses = null;
146
147			#[ORM\Column(name: 'limit_active_courses', type: 'integer', nullable: true)]
148			protected ?int $limitActiveCourses = null;
149
150			#[ORM\Column(name: 'limit_sessions', type: 'integer', nullable: true)]
151			protected ?int $limitSessions = null;
152
153			#[ORM\Column(name: 'limit_users', type: 'integer', nullable: true)]
154			protected ?int $limitUsers = null;
155
156			#[ORM\Column(name: 'limit_teachers', type: 'integer', nullable: true)]
157			protected ?int $limitTeachers = null;
158
159			#[ORM\Column(name: 'limit_disk_space', type: 'integer', nullable: true)]
160			protected ?int $limitDiskSpace = null;
161
162			#[Assert\Email]
163			#[ORM\Column(name: 'email', type: 'string', length: 255, nullable: true)]
164			protected ?string $email = null;
165
166			/**
167			* @var Collection<int, AccessUrlRelColorTheme>
168			*/
169			#[ORM\OneToMany(mappedBy: 'url', targetEntity: AccessUrlRelColorTheme::class, cascade: ['persist'], orphanRemoval: true)]
170			private Collection $colorThemes;
171
172			/**
173			* @var Collection<int, AccessUrlRelPlugin>
174			*/
175			#[ORM\OneToMany(mappedBy: 'url', targetEntity: AccessUrlRelPlugin::class, fetch: 'EXTRA_LAZY', orphanRemoval: true)]
176			private Collection $plugins;
177
178			#[ORM\Column(options: ['default' => false])]
179			private bool $isLoginOnly = false;
180
181			public function __construct()
182			{
183			$this->description = '';
184			$this->tms = new DateTime();
185			$this->createdBy = 1;
186			$this->courses = new ArrayCollection();
187			$this->sessions = new ArrayCollection();
188			$this->users = new ArrayCollection();
189			$this->settings = new ArrayCollection();
190			$this->sessionCategories = new ArrayCollection();
191			$this->courseCategory = new ArrayCollection();
192			$this->children = new ArrayCollection();
193			$this->colorThemes = new ArrayCollection();
194			$this->plugins = new ArrayCollection();
195			}
196
197			public function __toString(): string
198			{
199			return $this->getUrl();
200			}
201
202			public function getUrl(): string
203			{
204			return $this->url;
205			}
206
207			public function setUrl(string $url): self
208			{
209			$this->url = $url;
210
211			return $this;
212			}
213
214			public function getDescription(): ?string
215			{
216			return $this->description;
217			}
218
219			public function setDescription(string $description): self
220			{
221			$this->description = $description;
222
223			return $this;
224			}
225
226			public function getActive(): int
227			{
228			return $this->active;
229			}
230
231			public function setActive(int $active): self
232			{
233			$this->active = $active;
234
235			return $this;
236			}
237
238			public function getCreatedBy(): int
239			{
240			return $this->createdBy;
241			}
242
243			public function setCreatedBy(int $createdBy): self
244			{
245			$this->createdBy = $createdBy;
246
247			return $this;
248			}
249
250			public function getTms(): ?DateTime
251			{
252			return $this->tms;
253			}
254
255			public function setTms(DateTime $tms): self
256			{
257			$this->tms = $tms;
258
259			return $this;
260			}
261
262			public function getUrlType(): ?bool
263			{
264			return $this->urlType;
265			}
266
267			public function setUrlType(bool $urlType): self
268			{
269			$this->urlType = $urlType;
270
271			return $this;
272			}
273
274			public function getLimitActiveCourses(): ?int
275			{
276			return $this->limitActiveCourses;
277			}
278
279			public function setLimitActiveCourses(int $limitActiveCourses): self
280			{
281			$this->limitActiveCourses = $limitActiveCourses;
282
283			return $this;
284			}
285
286			public function getLimitSessions(): ?int
287			{
288			return $this->limitSessions;
289			}
290
291			public function setLimitSessions(int $limitSessions): self
292			{
293			$this->limitSessions = $limitSessions;
294
295			return $this;
296			}
297
298			public function getLimitUsers(): ?int
299			{
300			return $this->limitUsers;
301			}
302
303			public function setLimitUsers(int $limitUsers): self
304			{
305			$this->limitUsers = $limitUsers;
306
307			return $this;
308			}
309
310			public function getLimitTeachers(): ?int
311			{
312			return $this->limitTeachers;
313			}
314
315			public function setLimitTeachers(int $limitTeachers): self
316			{
317			$this->limitTeachers = $limitTeachers;
318
319			return $this;
320			}
321
322			public function getLimitDiskSpace(): ?int
323			{
324			return $this->limitDiskSpace;
325			}
326
327			public function setLimitDiskSpace(int $limitDiskSpace): self
328			{
329			$this->limitDiskSpace = $limitDiskSpace;
330
331			return $this;
332			}
333
334			public function getEmail(): ?string
335			{
336			return $this->email;
337			}
338
339			public function setEmail(string $email): self
340			{
341			$this->email = $email;
342
343			return $this;
344			}
345
346			/**
347			* @return Collection<int, SettingsCurrent>
348			*/
349			public function getSettings(): Collection
350			{
351			return $this->settings;
352			}
353
354			/**
355			* @param Collection<int, SettingsCurrent> $settings
356			*/
357			public function setSettings(Collection $settings): self
358			{
359			$this->settings = $settings;
360
361			return $this;
362			}
363
364			public function getLimitCourses(): ?int
365			{
366			return $this->limitCourses;
367			}
368
369			public function setLimitCourses(int $limitCourses): self
370			{
371			$this->limitCourses = $limitCourses;
372
373			return $this;
374			}
375
376			/**
377			* @return Collection<int, AccessUrlRelCourse>
378			*/
379			public function getCourses(): Collection
380			{
381			return $this->courses;
382			}
383
384			public function setCourses(Collection $courses): self
385			{
386			$this->courses = $courses;
387
388			return $this;
389			}
390
391			public function addCourse(Course $course): self
392			{
393			if (!$this->hasCourse($course)) {
394			$urlRelCourse = (new AccessUrlRelCourse())->setUrl($this);
395			$course->addUrls($urlRelCourse);
396
397			$this->courses->add($urlRelCourse);
398			}
399
400			return $this;
401			}
402
403			public function hasCourse(Course $course): bool
404			{
405			if ($this->courses->count() > 0) {
406			$criteria = Criteria::create()->where(Criteria::expr()->eq('course', $course));
407			$found = $this->courses->matching($criteria);
408
409			return $found->count() > 0;
410			}
411
412			return false;
413			}
414
415			/**
416			* @return Collection<int, SessionCategory>
417			*/
418			public function getSessionCategories(): Collection
419			{
420			return $this->sessionCategories;
421			}
422
423			public function setSessionCategories(Collection $sessionCategories): self
424			{
425			$this->sessionCategories = $sessionCategories;
426
427			return $this;
428			}
429
430			/**
431			* @return Collection<int, AccessUrlRelSession>
432			*/
433			public function getSessions(): Collection
434			{
435			return $this->sessions;
436			}
437
438			/**
439			* @return Collection<int, AccessUrl>
440			*/
441			public function getChildren(): Collection
442			{
443			return $this->children;
444			}
445
446			/**
447			* @return Collection<int, AccessUrlRelUser>
448			*/
449			public function getUsers(): Collection
450			{
451			return $this->users;
452			}
453
454			public function addUser(User $user): self
455			{
456			if (!$this->hasUser($user)) {
457			$accessUrlRelUser = (new AccessUrlRelUser())->setUser($user)->setUrl($this);
458			$this->users->add($accessUrlRelUser);
459			}
460
461			return $this;
462			}
463
464			public function hasUser(User $user): bool
465			{
466			if (0 !== $this->users->count()) {
467			$criteria = Criteria::create()->where(Criteria::expr()->eq('user', $user));
468			$relation = $this->users->matching($criteria);
469
470			return $relation->count() > 0;
471			}
472
473			return false;
474			}
475
476			/**
477			* @return Collection<int, AccessUrlRelCourseCategory>
478			*/
479			public function getCourseCategory(): Collection
480			{
481			return $this->courseCategory;
482			}
483
484			public function getLft(): int
485			{
486			return $this->lft;
487			}
488
489			public function getLvl(): int
490			{
491			return $this->lvl;
492			}
493
494			public function getRgt(): int
495			{
496			return $this->rgt;
497			}
498
499			public function getRoot(): ?self
500			{
501			return $this->root;
502			}
503
504			public function getResourceIdentifier(): int
505			{
506			return $this->getId();
			0 ignored issues – show Bug Best Practice introduced 2023-12-31 00:18 UTC by Report Bug Copy Issue Report The expression `return $this->getId()` could return the type `null` which is incompatible with the type-hinted return `integer`. Consider adding an additional type-check to rule them out. Loading history...
507			}
508
509			public function getId(): ?int
510			{
511			return $this->id;
512			}
513
514			public function getResourceName(): string
515			{
516			$url = $this->getUrl();
517			$url = parse_url($url);
518
519			return $url['host'];
520			}
521
522			public function setResourceName(string $name): self
523			{
524			return $this->setUrl($name);
525			}
526
527			public function getActiveColorTheme(): ?AccessUrlRelColorTheme
528			{
529			$criteria = Criteria::create();
530			$criteria->where(
531			Criteria::expr()->eq('active', true)
532			);
533
534			return $this->colorThemes->matching($criteria)->first() ?: null;
535			}
536
537			/**
538			* @return Collection<int, AccessUrlRelColorTheme>
539			*/
540			public function getColorThemes(): Collection
541			{
542			return $this->colorThemes;
543			}
544
545			public function addColorTheme(AccessUrlRelColorTheme $colorTheme): static
546			{
547			if (!$this->colorThemes->contains($colorTheme)) {
548			$this->colorThemes->add($colorTheme);
549			$colorTheme->setUrl($this);
550			}
551
552			return $this;
553			}
554
555			public function removeColorTheme(AccessUrlRelColorTheme $colorTheme): static
556			{
557			if ($this->colorThemes->removeElement($colorTheme)) {
558			// set the owning side to null (unless already changed)
559			if ($colorTheme->getUrl() === $this) {
560			$colorTheme->setUrl(null);
561			}
562			}
563
564			return $this;
565			}
566
567			public function getColorThemeByTheme(ColorTheme $theme): ?AccessUrlRelColorTheme
568			{
569			$criteria = Criteria::create();
570			$criteria->where(
571			Criteria::expr()->eq('colorTheme', $theme)
572			);
573
574			return $this->colorThemes->matching($criteria)->first() ?: null;
575			}
576
577			/**
578			* @return Collection<int, AccessUrlRelPlugin>
579			*/
580			public function getPlugins(): Collection
581			{
582			return $this->plugins;
583			}
584
585			public function addPlugin(AccessUrlRelPlugin $plugin): static
586			{
587			if (!$this->plugins->contains($plugin)) {
588			$this->plugins->add($plugin);
589			$plugin->setUrl($this);
590			}
591
592			return $this;
593			}
594
595			public function removePlugin(AccessUrlRelPlugin $plugin): static
596			{
597			if ($this->plugins->removeElement($plugin)) {
598			// set the owning side to null (unless already changed)
599			if ($plugin->getUrl() === $this) {
600			$plugin->setUrl(null);
601			}
602			}
603
604			return $this;
605			}
606
607			public function isLoginOnly(): bool
608			{
609			return $this->isLoginOnly;
610			}
611
612			public function setIsLoginOnly(bool $isLoginOnly): static
613			{
614			$this->isLoginOnly = $isLoginOnly;
615
616			return $this;
617			}
618
619			public function setSuperior(?AccessUrl $accessUrl): static
620			{
621			$this->parent = $accessUrl;
622
623			return $this;
624			}
625
626			public function getSuperior(): ?AccessUrl
627			{
628			return $this->parent;
629			}
630			}
631

chamilo / chamilo-lms

Pull Request — master (#6532)

AccessUrl::getResourceIdentifier() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like