src/Entity/Sales/Contract.php line 101

  1. <?php
  3. namespace App\Entity\Sales;
  5. use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
  6. use ApiPlatform\Metadata\ApiFilter;
  7. use ApiPlatform\Metadata\ApiProperty;
  8. use ApiPlatform\Metadata\ApiResource;
  9. use ApiPlatform\Metadata\GetCollection;
  10. use ApiPlatform\Metadata\Link;
  11. use ApiPlatform\Metadata\Post;
  12. use ApiPlatform\OpenApi\Model;
  13. use App\Controller\Upload\CreateAttachmentAction;
  14. use App\Doctrine\Type\Sales\ContractStatus;
  15. use App\Doctrine\Type\Sales\ContractType;
  16. use App\Dto\Sales\ContractInput;
  17. use App\Dto\Sales\ContractStatusInput;
  18. use App\Entity\Common\Blameable;
  19. use App\Entity\Common\Company;
  20. use App\Entity\Common\Trackable;
  21. use App\Entity\File\Upload;
  22. use App\Processor\Sales\ContractInputProcessor;
  23. use App\Processor\Sales\ContractStatusInputProcessor;
  24. use ArrayObject;
  25. use DateTimeInterface;
  26. use Doctrine\Common\Collections\ArrayCollection;
  27. use Doctrine\Common\Collections\Collection;
  28. use Doctrine\DBAL\Types\Types;
  29. use Doctrine\ORM\Mapping as ORM;
  30. use Gedmo\Mapping\Annotation as Gedmo;
  31. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  32. use Symfony\Component\Validator\Constraints as Assert;
  34. #[ORM\Table(name: 'contract')]
  35. #[ORM\Index(columns: ['tenant_id'], name: 'contract_tenant_id_idx')]
  36. #[ORM\Index(columns: ['client_id'], name: 'contract_client_id_idx')]
  37. #[ORM\Index(columns: ['created_by'], name: 'contract_created_by_idx')]
  38. #[ORM\Index(columns: ['updated_by'], name: 'contract_updated_by_idx')]
  39. #[ORM\UniqueConstraint(name: 'contract_slug_key', columns: ['slug'])]
  40. #[ORM\UniqueConstraint(name: 'contract_number_key', columns: ['number'])]
  41. #[ORM\Entity]
  42. #[UniqueEntity('number')]
  43. #[ApiResource(
  44.     routePrefix: '/sales',
  45.     input: ContractInput::class,
  46.     processor: ContractInputProcessor::class,
  47. )]
  48. #[ApiResource(
  49.     operations: [
  50.         new Post(
  51.             uriTemplate: '/sales/contracts/{slug}/status',
  52.             input: ContractStatusInput::class,
  53.             processor: ContractStatusInputProcessor::class,
  54.         ),
  55.     ],
  56. )]
  57. #[ApiResource(
  58.     uriTemplate: '/sales/assets/{asset}/contracts',
  59.     operations: [
  60.         new GetCollection(),
  61.     ],
  62.     uriVariables: [
  63.         'asset' => new Link(toProperty: 'assets', fromClass: Asset::class),
  64.     ],
  65. )]
  66. #[ApiResource(
  67.     // FIXME : This does not work well with docker
  68.     uriTemplate: '/sales/contracts/{slug}/attachments',
  69.     operations: [
  70.         new Post(
  71.             controller: CreateAttachmentAction::class,
  72.             openapi: new Model\Operation(
  73.                 requestBody: new Model\RequestBody(
  74.                     content: new ArrayObject([
  75.                         'multipart/form-data' => [
  76.                             'schema' => [
  77.                                 'type' => 'object',
  78.                                 'properties' => [
  79.                                     'file' => [
  80.                                         'type' => 'string',
  81.                                         'format' => 'binary'
  82.                                     ]
  83.                                 ]
  84.                             ]
  85.                         ]
  86.                     ])
  87.                 )
  88.             ),
  89.             shortName: 'Upload',
  90.             validationContext: ['groups' => ['Default', 'upload:create']],
  91.             deserialize: false
  92.         )
  93.     ],
  94. )]
  95. #[ApiFilter(SearchFilter::class, properties: [
  96.     'number' => 'ipartial',
  97.     'client.name' => 'exact',
  98.     'client.code' => 'exact',
  99.     'status' => 'exact',
  100. ])]
  101. class Contract
  102. {
  103.     use Blameable;
  104.     use Trackable;
  106.     #[ORM\Id]
  107.     #[ORM\GeneratedValue(strategy: 'IDENTITY')]
  108.     #[ORM\SequenceGenerator(sequenceName: 'contract_id_seq')]
  109.     #[ORM\Column(type: Types::INTEGER)]
  110.     #[ApiProperty(identifier: false)]
  111.     private ?int $id = null;
  113.     #[Gedmo\Slug(fields: ['number'])]
  114.     #[ORM\Column(type: Types::STRING)]
  115.     #[ApiProperty(identifier: true)]
  116.     private string $slug;
  118.     #[Assert\Length(min: 5)]
  119.     #[ORM\Column(type: Types::STRING)]
  120.     private ?string $number = null;
  122.     #[Assert\NotNull]
  123.     #[Assert\NotEqualTo(propertyPath: 'client')]
  124.     #[ORM\ManyToOne(targetEntity: Company::class)]
  125.     #[ORM\JoinColumn(name: 'tenant_id', nullable: false)]
  126.     private ?Company $tenant = null;
  128.     #[Assert\NotNull]
  129.     #[ORM\ManyToOne(targetEntity: Company::class)]
  130.     #[ORM\JoinColumn(name: 'client_id', nullable: false)]
  131.     #[ApiProperty(readableLink: true)]
  132.     private ?Company $client = null;
  134.     /** @var Collection<int, Asset> */
  135.     #[ORM\ManyToMany(targetEntity: Asset::class, inversedBy: 'contracts')]
  136.     #[ORM\JoinTable(name: 'contract_asset_map')]
  137.     #[ORM\JoinColumn(name: 'contract_id')]
  138.     #[ORM\InverseJoinColumn(name: 'asset_id')]
  139.     private Collection $assets;
  141.     /** @var Collection<int, WorkOrder> */
  142.     #[ApiProperty(readable: false)]
  143.     #[ORM\OneToMany(mappedBy: 'contract', targetEntity: WorkOrder::class)]
  144.     private Collection $workOrders;
  146.     /** @var Collection<int, CallOffOrder> */
  147.     #[ORM\ManyToMany(targetEntity: CallOffOrder::class, mappedBy: 'contracts')]
  148.     private Collection $callOffOrders;
  150.     /** @var Collection<int, Upload> */
  151.     #[ORM\ManyToMany(targetEntity: Upload::class)]
  152.     #[ORM\JoinTable(name: 'contract_file_map')]
  153.     #[ORM\JoinColumn(name: 'contract_id')]
  154.     #[ORM\InverseJoinColumn(name: 'file_id')]
  155.     #[ApiProperty(readableLink: true)]
  156.     private Collection $attachments;
  158.     #[Assert\NotNull]
  159.     #[ORM\Column(type: Types::DATE_MUTABLE, options: ['default' => 'CURRENT_DATE'])]
  160.     private ?DateTimeInterface $startingOn = null;
  162.     #[Assert\GreaterThan(propertyPath: 'startingOn')]
  163.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  164.     private ?DateTimeInterface $endingOn = null;
  166.     #[Assert\NotNull]
  167.     #[ORM\Column(type: Types::STRING, enumType: ContractType::class)]
  168.     private ?ContractType $type = null;
  170.     #[Assert\NotNull]
  171.     #[ORM\Column(type: Types::STRING, enumType: ContractStatus::class, options: ['default' => 'ONGOING'])]
  172.     private ?ContractStatus $status = ContractStatus::ONGOING;
  174.     public function __construct()
  175.     {
  176.         $this->assets = new ArrayCollection();
  177.         $this->attachments = new ArrayCollection();
  178.         $this->callOffOrders = new ArrayCollection();
  179.         $this->workOrders = new ArrayCollection();
  180.     }
  182.     public function getId(): ?int
  183.     {
  184.         return $this->id;
  185.     }
  187.     public function getSlug(): ?string
  188.     {
  189.         return $this->slug;
  190.     }
  192.     public function setSlug(string $slug): self
  193.     {
  194.         $this->slug = $slug;
  196.         return $this;
  197.     }
  199.     public function getNumber(): ?string
  200.     {
  201.         return $this->number;
  202.     }
  204.     public function setNumber(?string $number): self
  205.     {
  206.         $this->number = $number;
  208.         return $this;
  209.     }
  211.     public function getTenant(): ?Company
  212.     {
  213.         return $this->tenant;
  214.     }
  216.     public function setTenant(?Company $tenant): self
  217.     {
  218.         $this->tenant = $tenant;
  220.         return $this;
  221.     }
  223.     public function getClient(): ?Company
  224.     {
  225.         return $this->client;
  226.     }
  228.     public function setClient(?Company $client): self
  229.     {
  230.         $this->client = $client;
  232.         return $this;
  233.     }
  235.     /**
  236.      * @return Collection<int, Asset>
  237.      */
  238.     public function getAssets(): Collection
  239.     {
  240.         return $this->assets;
  241.     }
  243.     public function addAsset(Asset $asset): self
  244.     {
  245.         if (!$this->assets->contains($asset)) {
  246.             $this->assets->add($asset);
  247.         }
  249.         return $this;
  250.     }
  252.     public function removeAsset(Asset $asset): self
  253.     {
  254.         $this->assets->removeElement($asset);
  256.         return $this;
  257.     }
  259.     /** @return Collection<int, WorkOrder> */
  260.     public function getWorkOrders(): Collection
  261.     {
  262.         return $this->workOrders;
  263.     }
  265.     public function addWorkOrder(WorkOrder $workOrder): static
  266.     {
  267.         if (!$this->workOrders->contains($workOrder)) {
  268.             $this->workOrders[] = $workOrder;
  269.             $workOrder->setContract($this);
  270.         }
  272.         return $this;
  273.     }
  275.     public function removeWorkOrder(WorkOrder $workOrder): static
  276.     {
  277.         if ($this->workOrders->removeElement($workOrder)) {
  278.             // set the owning side to null (unless already changed)
  279.             if ($workOrder->getContract() === $this) {
  280.                 $workOrder->setContract(null);
  281.             }
  282.         }
  284.         return $this;
  285.     }
  287.     /**
  288.      * @return Collection<int, CallOffOrder>
  289.      */
  290.     public function getCallOffOrders(): Collection
  291.     {
  292.         return $this->callOffOrders;
  293.     }
  295.     public function addCallOffOrder(CallOffOrder $callOffOrder): self
  296.     {
  297.         if (!$this->callOffOrders->contains($callOffOrder)) {
  298.             $this->callOffOrders->add($callOffOrder);
  299.             $callOffOrder->addContract($this);
  300.         }
  302.         return $this;
  303.     }
  305.     public function removeCallOffOrder(CallOffOrder $callOffOrder): self
  306.     {
  307.         if ($this->callOffOrders->removeElement($callOffOrder)) {
  308.             $callOffOrder->removeContract($this);
  309.         }
  311.         return $this;
  312.     }
  314.     /**
  315.      * @return Collection<int, Upload>
  316.      */
  317.     public function getAttachments(): Collection
  318.     {
  319.         return $this->attachments;
  320.     }
  322.     public function addAttachment(Upload $attachment): self
  323.     {
  324.         if (!$this->attachments->contains($attachment)) {
  325.             $this->attachments->add($attachment);
  326.         }
  328.         return $this;
  329.     }
  331.     public function removeAttachment(Upload $attachment): self
  332.     {
  333.         $this->attachments->removeElement($attachment);
  335.         return $this;
  336.     }
  338.     public function getStartingOn(): DateTimeInterface
  339.     {
  340.         return $this->startingOn;
  341.     }
  343.     public function setStartingOn(DateTimeInterface $startingOn): self
  344.     {
  345.         $this->startingOn = $startingOn;
  347.         return $this;
  348.     }
  350.     public function getEndingOn(): ?DateTimeInterface
  351.     {
  352.         return $this->endingOn;
  353.     }
  355.     public function setEndingOn(?DateTimeInterface $endingOn): self
  356.     {
  357.         $this->endingOn = $endingOn;
  359.         return $this;
  360.     }
  362.     public function getType(): ?ContractType
  363.     {
  364.         return $this->type;
  365.     }
  367.     public function setType(ContractType $type): self
  368.     {
  369.         $this->type = $type;
  371.         return $this;
  372.     }
  374.     public function getStatus(): ?ContractStatus
  375.     {
  376.         return $this->status;
  377.     }
  379.     public function setStatus(ContractStatus $status): self
  380.     {
  381.         $this->status = $status;
  383.         return $this;
  384.     }
  385. }