ControleOnline\Entity\ProductGroup

Complexity

Total Complexity

26

Size/Duplication

Total Lines	197
Duplicated Lines	0 %

Importance

Changes	6
Bugs	0	Features	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	getActive()	0	3	1
A	getPriceCalculation()	0	3	1
A	setMinimum()	0	4	1
A	addProduct()	0	7	2
A	getGroupOrder()	0	3	1
A	isActive()	0	3	1
A	setProductGroup()	0	4	1
A	setGroupOrder()	0	4	1
A	getMaximum()	0	3	1
A	setRequired()	0	4	1
A	isRequired()	0	3	1
A	__construct()	0	3	1
A	setActive()	0	4	1
A	setPriceCalculation()	0	4	1
A	removeProduct()	0	8	3
A	getProducts()	0	3	1
A	setMaximum()	0	4	1
A	getProductParent()	0	3	1
A	setProductParent()	0	4	1
A	getProductGroup()	0	3	1
A	getMinimum()	0	3	1
A	getRequired()	0	3	1
A	getId()	0	3	1

<?php

namespace ControleOnline\Entity;

use Symfony\Component\Serializer\Attribute\Groups;

The type Symfony\Component\Serializer\Attribute\Groups was not found. Maybe you did not declare it correctly or list all dependencies?

use ApiPlatform\Doctrine\Orm\Filter\OrderFilter;

The type ApiPlatform\Doctrine\Orm\Filter\OrderFilter was not found. Maybe you did not declare it correctly or list all dependencies?

use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;

The type ApiPlatform\Doctrine\Orm\Filter\SearchFilter was not found. Maybe you did not declare it correctly or list all dependencies?

use ApiPlatform\Metadata\ApiFilter;

The type ApiPlatform\Metadata\ApiFilter was not found. Maybe you did not declare it correctly or list all dependencies?

use ApiPlatform\Metadata\ApiResource;

The type ApiPlatform\Metadata\ApiResource was not found. Maybe you did not declare it correctly or list all dependencies?

use ApiPlatform\Metadata\Delete;

The type ApiPlatform\Metadata\Delete was not found. Maybe you did not declare it correctly or list all dependencies?

use ApiPlatform\Metadata\Get;

The type ApiPlatform\Metadata\Get was not found. Maybe you did not declare it correctly or list all dependencies?

use ApiPlatform\Metadata\GetCollection;

The type ApiPlatform\Metadata\GetCollection was not found. Maybe you did not declare it correctly or list all dependencies?

use ApiPlatform\Metadata\Post;

The type ApiPlatform\Metadata\Post was not found. Maybe you did not declare it correctly or list all dependencies?

use ApiPlatform\Metadata\Put;

The type ApiPlatform\Metadata\Put was not found. Maybe you did not declare it correctly or list all dependencies?

use ControleOnline\Listener\LogListener;

The type ControleOnline\Listener\LogListener was not found. Maybe you did not declare it correctly or list all dependencies?

use ControleOnline\Repository\ProductGroupRepository;
use Doctrine\Common\Collections\ArrayCollection;

The type Doctrine\Common\Collections\ArrayCollection was not found. Maybe you did not declare it correctly or list all dependencies?

use Doctrine\Common\Collections\Collection;

The type Doctrine\Common\Collections\Collection was not found. Maybe you did not declare it correctly or list all dependencies?

use Doctrine\ORM\Mapping as ORM;

The type Doctrine\ORM\Mapping was not found. Maybe you did not declare it correctly or list all dependencies?

#[ApiResource(
    operations: [
        new Get(security: 'is_granted(\'PUBLIC_ACCESS\')'),
        new Put(
            security: 'is_granted(\'ROLE_CLIENT\')',
            denormalizationContext: ['groups' => ['product_group:write']]
        ),
        new Delete(security: 'is_granted(\'ROLE_CLIENT\')'),
        new Post(securityPostDenormalize: 'is_granted(\'ROLE_CLIENT\')'),
        new GetCollection(security: 'is_granted(\'PUBLIC_ACCESS\')')
    ],
    formats: ['jsonld', 'json', 'html', 'jsonhal', 'csv' => ['text/csv']],
    normalizationContext: ['groups' => ['product_group:read']],
    denormalizationContext: ['groups' => ['product_group:write']]
)]
#[ApiFilter(OrderFilter::class, properties: ['productGroup'])]
#[ORM\Table(name: 'product_group')]
#[ORM\Entity(repositoryClass: ProductGroupRepository::class)]
class ProductGroup
{
    #[ApiFilter(filterClass: SearchFilter::class, properties: ['id' => 'exact'])]
    #[ORM\Column(name: 'id', type: 'integer', nullable: false)]
    #[ORM\Id]
    #[ORM\GeneratedValue(strategy: 'IDENTITY')]
    #[Groups(['product_group:read', 'product_group:write', 'order_product:read'])]
    private $id;

    #[ApiFilter(filterClass: SearchFilter::class, properties: ['productGroup' => 'exact'])]
    #[ORM\Column(name: 'product_group', type: 'string', length: 255, nullable: false)]
    #[Groups(['product_group:read', 'product_group:write', 'order_product:read'])]
    private $productGroup;

    #[ApiFilter(filterClass: SearchFilter::class, properties: ['priceCalculation' => 'exact'])]
    #[ORM\Column(name: 'price_calculation', type: 'string', length: 0, nullable: false, options: ['default' => "'sum'"])]
    #[Groups(['product_group:read', 'product_group:write', 'order_product:read'])]
    private $priceCalculation = 'sum';

    #[ORM\Column(name: 'required', type: 'boolean', nullable: false)]
    #[Groups(['product_group:read', 'product_group:write', 'order_product:read'])]
    private $required = false;

    #[ORM\Column(name: 'minimum', type: 'integer', nullable: true, options: ['default' => 'NULL'])]
    #[Groups(['product_group:read', 'product_group:write', 'order_product:read'])]
    private $minimum = null;

    #[ORM\Column(name: 'maximum', type: 'integer', nullable: true, options: ['default' => 'NULL'])]
    #[Groups(['product_group:read', 'product_group:write', 'order_product:read'])]
    private $maximum = null;

    #[ORM\Column(name: 'active', type: 'boolean', nullable: false, options: ['default' => '1'])]
    #[Groups(['product_group:read', 'product_group:write', 'order_product:read'])]
    private $active = true;

    #[ORM\Column(name: 'group_order', type: 'integer', nullable: false)]
    #[Groups(['product_group:read', 'product_group:write', 'order_product:read'])]
    private $groupOrder = 0;

    #[ORM\OneToMany(targetEntity: ProductGroupProduct::class, mappedBy: 'productGroup', orphanRemoval: true)]
    #[Groups(['product_group:write'])]
    private $products;

    #[ApiFilter(filterClass: SearchFilter::class, properties: ['productParent' => 'exact'])]
    #[ORM\JoinColumn(nullable: false)]
    #[ORM\ManyToOne(targetEntity: Product::class)]
    #[Groups(['product_group:read', 'product_group:write'])]
    private $productParent;

    public function __construct()
    {
        $this->products = new ArrayCollection();
    }

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

    public function getProductGroup(): string
    {
        return $this->productGroup;
    }

    public function setProductGroup(string $productGroup): self
    {
        $this->productGroup = $productGroup;
        return $this;
    }

    public function getPriceCalculation(): string
    {
        return $this->priceCalculation;
    }

    public function setPriceCalculation(string $priceCalculation): self
    {
        $this->priceCalculation = $priceCalculation;
        return $this;
    }

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

    public function setRequired(bool $required): self
    {
        $this->required = $required;
        return $this;
    }

    public function getMinimum(): ?int
    {
        return $this->minimum;
    }

    public function setMinimum(?int $minimum): self
    {
        $this->minimum = $minimum;
        return $this;
    }

    public function getMaximum(): ?int
    {
        return $this->maximum;
    }

    public function setMaximum(?int $maximum): self
    {
        $this->maximum = $maximum;
        return $this;
    }

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

    public function setActive(bool $active): self
    {
        $this->active = $active;
        return $this;
    }

    public function getGroupOrder()
    {
        return $this->groupOrder;
    }

    public function setGroupOrder($groupOrder): self
    {
        $this->groupOrder = $groupOrder;
        return $this;
    }

    public function getRequired(): ?bool
    {
        return $this->required;
    }

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

    public function getProducts(): Collection
    {
        return $this->products;
    }

    public function addProduct(ProductGroupProduct $product): self
    {
        if (!$this->products->contains($product)) {
            $this->products[] = $product;
            $product->setProductGroup($this);
        }
        return $this;
    }

    public function removeProduct(ProductGroupProduct $product): self
    {
        if ($this->products->removeElement($product)) {
            if ($product->getProductGroup() === $this) {
                $product->setProductGroup(null);
            }
        }
        return $this;
    }

    public function getProductParent()
    {
        return $this->productParent;
    }

    public function setProductParent($productParent): self
    {
        $this->productParent = $productParent;
        return $this;
    }
}