src/Entity/Company.php line 25

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Library;
  6. use App\Entity\Part;
  7. use App\Repository\CompanyRepository;
  8. use Doctrine\Common\Collections\ArrayCollection;
  9. use Doctrine\Common\Collections\Collection;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Symfony\Component\HttpFoundation\File\File;
  12. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  13. use Symfony\Component\Validator\Constraints as Assert;
  14. use Symfony\Component\Serializer\Annotation\Groups;
  16. /**
  17.  * @ORM\Entity(repositoryClass=CompanyRepository::class)
  18.  * @Vich\Uploadable
  19.  * 
  20.  * @ORM\Table(name="company",indexes={
  21.  *     @ORM\Index(name="company_certifications", columns={"certifications"}),
  22.  *     @ORM\Index(name="company_name", columns={"name"})
  23.  * })
  24.  */
  25. class Company
  26. {
  27.     /**
  28.      * @ORM\Id
  29.      * @ORM\GeneratedValue
  30.      * @ORM\Column(type="integer")
  31.      * @Groups({"company"})
  32.      */
  33.     private $id; 
  35.     /**
  36.      * @ORM\Column(type="string", length=100)
  37.      * @Assert\NotBlank
  38.      * @Groups({"company"})
  39.      */
  40.     private $name;
  42.     /**
  43.      * @ORM\OneToMany(targetEntity=User::class, mappedBy="company")
  44.      * @Groups({"company"})
  45.      */
  46.     private $user;
  48.     /**
  49.      * @ORM\Column(type="datetime")
  50.      * @Groups({"company"})
  51.      */
  52.     private $created_at;
  54.     /**
  55.      * @ORM\OneToMany(targetEntity=Library::class, mappedBy="company", orphanRemoval=false)
  56.      */
  57.     private $libraries;
  59.     /**
  60.      * @ORM\OneToMany(targetEntity=Part::class, mappedBy="Company")
  61.      */
  62.     private $parts;
  64.     /**
  65.      * @ORM\Column(type="string", length=20)
  66.      * @Assert\NotBlank
  67.      * @Groups({"company"})
  68.      */
  69.     private $nif;
  71.     /**
  72.      * @ORM\Column(type="string", length=50)
  73.      * @Assert\NotBlank
  74.      * @Groups({"company"})
  75.      */
  76.     private $phone;
  78.     /**
  79.      * @ORM\Column(type="string", length=100)
  80.      * @Assert\NotBlank
  81.      * @Assert\Email()
  82.      * @Groups({"company"})
  83.      */
  84.     private $email;
  86.     /**
  87.      * @ORM\Column(type="string", length=255)
  88.      * @Assert\NotBlank
  89.      * @Groups({"company"})
  90.      */
  91.     private $address;
  93.     /**
  94.      * @ORM\Column(type="datetime", nullable=true)
  95.      * @Groups({"company"})
  96.      */
  97.     private $updated_at;
  99.     /**
  100.      * @ORM\Column(type="string", length=4, unique=true)
  101.      * @Groups({"company"})
  102.      */
  103.     private $ref;
  105.     /**
  106.      * @ORM\OneToMany(targetEntity=CompanySupplier::class, mappedBy="company")
  107.      */
  108.     private $companySuppliers;
  110.     /**
  111.      * @ORM\OneToMany(targetEntity=LicenseCompany::class, mappedBy="company")
  112.      */
  113.     private $licenseCompanies;
  115.     /**
  116.      * 1: Client, 2:Supplier
  117.      * 
  118.      * @ORM\OneToMany(targetEntity=Supplier::class, mappedBy="company")
  119.      */
  120.     private $suppliers;
  122.     /**
  123.      * 1:OEM (Cliente), 2:Service bureau (Proveedor)
  124.      * 
  125.      * @ORM\Column(type="integer")
  126.      * @Groups({"company"})
  127.      */
  128.     private $type;
  130.     /**
  131.      * @ORM\ManyToOne(targetEntity=LicenseCompany::class)
  132.      * @ORM\JoinColumn(onDelete="SET NULL")
  133.      */
  134.     private $licenseCompany;
  136.     /**
  137.      * @ORM\Column(type="string", length=510, nullable=true)
  138.      * @Assert\Length(
  139.      *      max = 510
  140.      * )
  141.      * @Groups({"company"})
  142.      */
  143.     private $certifications;
  145.     /**
  146.      * @ORM\Column(type="string", length=255, nullable=true)
  147.      * @Groups({"company"})
  148.      * @Assert\Length(
  149.      *      max = 255
  150.      * )
  151.      */
  152.     private $services;
  154.     /**
  155.      * @ORM\Column(type="string", length=255, nullable=true)
  156.      * @Groups({"company"})
  157.      * @Assert\Length(
  158.      *      max = 255
  159.      * )
  160.      */
  161.     private $web_page;
  163.     /**
  164.      * @ORM\Column(type="string", length=255, nullable=true)
  165.      * @Groups({"company"})
  166.      */
  167.     private $logo;
  169.     /**
  170.      * NOTE: This is not a mapped field of entity metadata, just a simple property.
  171.      * 
  172.      * @Vich\UploadableField(mapping="company_file", fileNameProperty="logo")
  173.      * @Assert\File(
  174.      *     maxSize = "2M",
  175.      *     mimeTypes = {"image/jpeg","image/gif","image/png"},
  176.      *     maxSizeMessage = "El tamaño máximo permitido del archivo es {{ limit }} MB.",
  177.      *     mimeTypesMessage = "El tipo de archivo no es válido ({{ type }}). Tipos de archivo permitidos {{ types }}"
  178.      * )
  179.      * 
  180.      * @var File|null
  181.      */
  182.     private $logoFile;
  184.     /**
  185.      * @ORM\Column(type="string", length=510, nullable=true)
  186.      * @Groups({"company"})
  187.      * @Assert\Length(
  188.      *      max = 510
  189.      * )
  190.      */
  191.     private $description;
  193.     /**
  194.      * @ORM\OneToMany(targetEntity=Equipment::class, mappedBy="company")
  195.      */
  196.     private $equipment;
  198.     /**
  199.      * @ORM\OneToMany(targetEntity=Material::class, mappedBy="company")
  200.      */
  201.     private $materials;
  203.     /**
  204.      * @ORM\OneToMany(targetEntity=CompanyAddress::class, mappedBy="company")
  205.      */
  206.     private $companyAddresses;
  208.     /**
  209.      * @ORM\Column(type="smallint", nullable=true)
  210.      */
  211.     private $currency;
  213.     /**
  214.      * @ORM\Column(type="smallint", nullable=true)
  215.      */
  216.     private $thema;
  218.     /**
  219.      * @ORM\Column(type="string", length=10, nullable=true)
  220.      */
  221.     private $color;
  223.     /**
  224.      * @ORM\OneToMany(targetEntity=CompanyClient::class, mappedBy="company")
  225.      */
  226.     private $companyClients;
  228.     /**
  229.      * @ORM\Column(type="string", length=10, nullable=true)
  230.      */
  231.     private $corporate_color;
  233.     /**
  234.      * 1:oscuro, 2:claro
  235.      * 
  236.      * @ORM\Column(type="smallint", nullable=true)
  237.      */
  238.     private $corporate_theme;
  240.     public function __construct()
  241.     {
  242.         $this->user = new ArrayCollection();
  243.         $this->created_at = new \DateTime();
  244.         $this->markAsUpdated();
  245.         $this->libraries = new ArrayCollection();
  246.         $this->parts = new ArrayCollection();
  247.         $this->companySuppliers = new ArrayCollection();
  248.         $this->licenseCompanies = new ArrayCollection();
  249.         $this->suppliers = new ArrayCollection();
  250.         $this->equipment = new ArrayCollection();
  251.         $this->materials = new ArrayCollection();
  252.         $this->companyAddresses = new ArrayCollection();
  253.         $this->companyClients = new ArrayCollection();
  254.     }
  256.     // Registra el método mágico para imprimir el nombre del estado, por ejemplo, California
  257.     public function __toString() {
  258.         return $this->name;
  259.     }
  261.     public function getId(): ?int
  262.     {
  263.         return $this->id;
  264.     }
  266.     public function getName(): ?string
  267.     {
  268.         return $this->name;
  269.     }
  271.     public function setName(string $name): self
  272.     {
  273.         $this->name = $name;
  275.         return $this;
  276.     }
  278.     /**
  279.      * @return Collection|User[]
  280.      */
  281.     public function getUser(): Collection
  282.     {
  283.         return $this->user;
  284.     }
  286.     public function addUser(User $user): self
  287.     {
  288.         if (!$this->user->contains($user)) {
  289.             $this->user[] = $user;
  290.             $user->setCompany($this);
  291.         }
  293.         return $this;
  294.     }
  296.     public function removeUser(User $user): self
  297.     {
  298.         if ($this->user->removeElement($user)) {
  299.             // set the owning side to null (unless already changed)
  300.             if ($user->getCompany() === $this) {
  301.                 $user->setCompany(null);
  302.             }
  303.         }
  305.         return $this;
  306.     }
  308.     public function getCreatedAt(): ?\DateTimeInterface
  309.     {
  310.         return $this->created_at;
  311.     }
  313.     /**
  314.      * @return Collection|Library[]
  315.      */
  316.     public function getLibraries(): Collection
  317.     {
  318.         return $this->libraries;
  319.     }
  321.     public function addLibrary(Library $library): self
  322.     {
  323.         if (!$this->libraries->contains($library)) {
  324.             $this->libraries[] = $library;
  325.             $library->setCompany($this);
  326.         }
  328.         return $this;
  329.     }
  331.     public function removeLibrary(Library $library): self
  332.     {
  333.         if ($this->libraries->removeElement($library)) {
  334.             // set the owning side to null (unless already changed)
  335.             if ($library->getCompany() === $this) {
  336.                 $library->setCompany(null);
  337.             }
  338.         }
  340.         return $this;
  341.     }
  343.     /**
  344.      * @return Collection|Part[]
  345.      */
  346.     public function getParts(): Collection
  347.     {
  348.         return $this->parts;
  349.     }
  351.     public function addPart(Part $part): self
  352.     {
  353.         if (!$this->parts->contains($part)) {
  354.             $this->parts[] = $part;
  355.             $part->setCompany($this);
  356.         }
  358.         return $this;
  359.     }
  361.     public function removePart(Part $part): self
  362.     {
  363.         if ($this->parts->removeElement($part)) {
  364.             // set the owning side to null (unless already changed)
  365.             if ($part->getCompany() === $this) {
  366.                 $part->setCompany(null);
  367.             }
  368.         }
  370.         return $this;
  371.     }
  373.     public function getNif(): ?string
  374.     {
  375.         return $this->nif;
  376.     }
  378.     public function setNif(?string $nif): self
  379.     {
  380.         $this->nif = $nif;
  382.         return $this;
  383.     }
  385.     public function getPhone(): ?string
  386.     {
  387.         return $this->phone;
  388.     }
  390.     public function setPhone(?string $phone): self
  391.     {
  392.         $this->phone = $phone;
  394.         return $this;
  395.     }
  397.     public function getEmail(): ?string
  398.     {
  399.         return $this->email;
  400.     }
  402.     public function setEmail(?string $email): self
  403.     {
  404.         $this->email = $email;
  406.         return $this;
  407.     }
  409.     public function getAddress(): ?string
  410.     {
  411.         return $this->address;
  412.     }
  414.     
  416.     public function setAddress(?string $address): self
  417.     {
  418.         $this->address = $address;
  420.         return $this;
  421.     }
  423.     public function getUpdatedAt(): ?\DateTimeInterface
  424.     {
  425.         return $this->updated_at;
  426.     }
  428.     /**
  429.      * Set the value of updatedAt
  430.      *
  431.      * @param \DateTime $updatedAt
  432.      */
  433.     public function markAsUpdated() : void
  434.     {
  435.         $this->updated_at = new \DateTime();
  436.     }
  438.     public function getRef(): ?string
  439.     {
  440.         return $this->ref;
  441.     }
  443.     public function setRef(string $ref): self
  444.     {
  445.         $ref++;
  446.         $this->ref = $ref;
  448.         return $this;
  449.     }
  451.     /**
  452.      * @return Collection|CompanySupplier[]
  453.      */
  454.     public function getCompanySuppliers(): Collection
  455.     {
  456.         return $this->companySuppliers;
  457.     }
  459.     public function addCompanySupplier(CompanySupplier $companySupplier): self
  460.     {
  461.         if (!$this->companySuppliers->contains($companySupplier)) {
  462.             $this->companySuppliers[] = $companySupplier;
  463.             $companySupplier->setCompany($this);
  464.         }
  466.         return $this;
  467.     }
  469.     public function removeCompanySupplier(CompanySupplier $companySupplier): self
  470.     {
  471.         if ($this->companySuppliers->removeElement($companySupplier)) {
  472.             // set the owning side to null (unless already changed)
  473.             if ($companySupplier->getCompany() === $this) {
  474.                 $companySupplier->setCompany(null);
  475.             }
  476.         }
  478.         return $this;
  479.     }
  481.     /**
  482.      * @return Collection<int, LicenseCompany>
  483.      */
  484.     public function getLicenseCompanies(): Collection
  485.     {
  486.         return $this->licenseCompanies;
  487.     }
  489.     public function addLicenseCompany(LicenseCompany $licenseCompany): self
  490.     {
  491.         if (!$this->licenseCompanies->contains($licenseCompany)) {
  492.             $this->licenseCompanies[] = $licenseCompany;
  493.             $licenseCompany->setCompany($this);
  494.         }
  496.         return $this;
  497.     }
  499.     public function removeLicenseCompany(LicenseCompany $licenseCompany): self
  500.     {
  501.         if ($this->licenseCompanies->removeElement($licenseCompany)) {
  502.             // set the owning side to null (unless already changed)
  503.             if ($licenseCompany->getCompany() === $this) {
  504.                 $licenseCompany->setCompany(null);
  505.             }
  506.         }
  508.         return $this;
  509.     }
  511.     /**
  512.      * @return Collection<int, Supplier>
  513.      */
  514.     public function getSuppliers(): Collection
  515.     {
  516.         return $this->suppliers;
  517.     }
  519.     public function addSupplier(Supplier $supplier): self
  520.     {
  521.         if (!$this->suppliers->contains($supplier)) {
  522.             $this->suppliers[] = $supplier;
  523.             $supplier->setCompany($this);
  524.         }
  526.         return $this;
  527.     }
  529.     public function removeSupplier(Supplier $supplier): self
  530.     {
  531.         if ($this->suppliers->removeElement($supplier)) {
  532.             // set the owning side to null (unless already changed)
  533.             if ($supplier->getCompany() === $this) {
  534.                 $supplier->setCompany(null);
  535.             }
  536.         }
  538.         return $this;
  539.     }
  541.     public function getType(): ?int
  542.     {
  543.         return $this->type;
  544.     }
  546.     public function setType(int $type): self
  547.     {
  548.         $this->type = $type;
  550.         return $this;
  551.     }
  553.     public function getLicenseCompany(): ?LicenseCompany
  554.     {
  555.         return $this->licenseCompany;
  556.     }
  558.     public function setLicenseCompany(?LicenseCompany $licenseCompany): self
  559.     {
  560.         $this->licenseCompany = $licenseCompany;
  562.         return $this;
  563.     }
  565.     public function getCertifications(): ?string
  566.     {
  567.         return $this->certifications;
  568.     }
  570.     public function setCertifications(string $certifications): self
  571.     {
  572.         $this->certifications = $certifications;
  574.         return $this;
  575.     }
  577.     public function getServices(): ?string
  578.     {
  579.         return $this->services;
  580.     }
  582.     public function setServices(?string $services): self
  583.     {
  584.         $this->services = $services;
  586.         return $this;
  587.     }
  589.     public function getWebPage(): ?string
  590.     {
  591.         return $this->web_page;
  592.     }
  594.     public function setWebPage(?string $web_page): self
  595.     {
  596.         $this->web_page = $web_page;
  598.         return $this;
  599.     }
  601.     public function getLogo(): ?string
  602.     {
  603.         return $this->logo;
  604.     }
  606.     public function setLogo(?string $logo): self
  607.     {
  608.         $this->logo = $logo;
  610.         return $this;
  611.     }
  613.     /**
  614.      * If manually uploading a file (i.e. not using Symfony Form) ensure an instance
  615.      * of 'UploadedFile' is injected into this setter to trigger the update. If this
  616.      * bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
  617.      * must be able to accept an instance of 'File' as the bundle will inject one here
  618.      * during Doctrine hydration.
  619.      *
  620.      * @param File|\Symfony\Component\HttpFoundation\File\UploadedFile|null $imageFile
  621.      */
  622.     public function setLogoFile(?File $logoFile = null): void
  623.     {
  624.         $this->logoFile = $logoFile;
  626.         if (null !== $logoFile) {
  627.             // It is required that at least one field changes if you are using doctrine
  628.             // otherwise the event listeners won't be called and the file is lost
  629.             $this->markAsUpdated();
  630.         }
  631.     }
  633.     public function getLogoFile(): ?File
  634.     {
  635.         return $this->logoFile;
  636.     }
  638.     public function getDescription(): ?string
  639.     {
  640.         return $this->description;
  641.     }
  643.     public function setDescription(?string $description): self
  644.     {
  645.         $this->description = $description;
  647.         return $this;
  648.     }
  650.     /**
  651.      * @return Collection<int, Equipment>
  652.      */
  653.     public function getEquipment(): Collection
  654.     {
  655.         return $this->equipment;
  656.     }
  658.     public function addEquipment(Equipment $equipment): self
  659.     {
  660.         if (!$this->equipment->contains($equipment)) {
  661.             $this->equipment[] = $equipment;
  662.             $equipment->setCompany($this);
  663.         }
  665.         return $this;
  666.     }
  668.     public function removeEquipment(Equipment $equipment): self
  669.     {
  670.         if ($this->equipment->removeElement($equipment)) {
  671.             // set the owning side to null (unless already changed)
  672.             if ($equipment->getCompany() === $this) {
  673.                 $equipment->setCompany(null);
  674.             }
  675.         }
  677.         return $this;
  678.     }
  680.     /**
  681.      * @return Collection<int, Material>
  682.      */
  683.     public function getMaterials(): Collection
  684.     {
  685.         return $this->materials;
  686.     }
  688.     public function addMaterial(Material $material): self
  689.     {
  690.         if (!$this->materials->contains($material)) {
  691.             $this->materials[] = $material;
  692.             $material->setCompany($this);
  693.         }
  695.         return $this;
  696.     }
  698.     public function removeMaterial(Material $material): self
  699.     {
  700.         if ($this->materials->removeElement($material)) {
  701.             // set the owning side to null (unless already changed)
  702.             if ($material->getCompany() === $this) {
  703.                 $material->setCompany(null);
  704.             }
  705.         }
  707.         return $this;
  708.     }
  710.     /**
  711.      * @return Collection<int, CompanyAddress>
  712.      */
  713.     public function getCompanyAddresses(): Collection
  714.     {
  715.         return $this->companyAddresses;
  716.     }
  718.     public function addCompanyAddress(CompanyAddress $companyAddress): self
  719.     {
  720.         if (!$this->companyAddresses->contains($companyAddress)) {
  721.             $this->companyAddresses[] = $companyAddress;
  722.             $companyAddress->setCompany($this);
  723.         }
  725.         return $this;
  726.     }
  728.     public function removeCompanyAddress(CompanyAddress $companyAddress): self
  729.     {
  730.         if ($this->companyAddresses->removeElement($companyAddress)) {
  731.             // set the owning side to null (unless already changed)
  732.             if ($companyAddress->getCompany() === $this) {
  733.                 $companyAddress->setCompany(null);
  734.             }
  735.         }
  737.         return $this;
  738.     }
  740.     public function getCurrency(): ?int
  741.     {
  742.         return $this->currency;
  743.     }
  745.     public function setCurrency(int $currency): self
  746.     {
  747.         $this->currency = $currency;
  749.         return $this;
  750.     }
  752.     public function getThema(): ?int
  753.     {
  754.         return $this->thema;
  755.     }
  757.     public function setThema(int $thema): self
  758.     {
  759.         $this->thema = $thema;
  761.         return $this;
  762.     }
  764.     public function getColor(): ?string
  765.     {
  766.         return $this->color;
  767.     }
  769.     public function setColor(?string $color): self
  770.     {
  771.         $this->color = $color;
  773.         return $this;
  774.     }
  776.     /**
  777.      * @return Collection<int, CompanyClient>
  778.      */
  779.     public function getCompanyClients(): Collection
  780.     {
  781.         return $this->companyClients;
  782.     }
  784.     public function addCompanyClient(CompanyClient $companyClient): self
  785.     {
  786.         if (!$this->companyClients->contains($companyClient)) {
  787.             $this->companyClients[] = $companyClient;
  788.             $companyClient->setCompany($this);
  789.         }
  791.         return $this;
  792.     }
  794.     public function removeCompanyClient(CompanyClient $companyClient): self
  795.     {
  796.         if ($this->companyClients->removeElement($companyClient)) {
  797.             // set the owning side to null (unless already changed)
  798.             if ($companyClient->getCompany() === $this) {
  799.                 $companyClient->setCompany(null);
  800.             }
  801.         }
  803.         return $this;
  804.     }
  806.     public function getCorporateColor(): ?string
  807.     {
  808.         return $this->corporate_color;
  809.     }
  811.     public function setCorporateColor(?string $corporate_color): self
  812.     {
  813.         $this->corporate_color = $corporate_color;
  815.         return $this;
  816.     }
  818.     public function getCorporateTheme(): ?int
  819.     {
  820.         return $this->corporate_theme;
  821.     }
  823.     public function setCorporateTheme(?int $corporate_theme): self
  824.     {
  825.         $this->corporate_theme = $corporate_theme;
  827.         return $this;
  828.     }
  829.     
  830. }