src/Entity/StockProduct.php line 16

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\StockProductRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Component\HttpFoundation\File\File;
  10. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  12. /**
  13.  * @ORM\Entity(repositoryClass=StockProductRepository::class)
  14.  * @Vich\Uploadable
  15.  */
  16. class StockProduct
  17. {
  18.     /**
  19.      * @ORM\Id
  20.      * @ORM\GeneratedValue
  21.      * @ORM\Column(type="integer")
  22.      */
  23.     private $id;
  25.     /**
  26.      * @ORM\Column(type="string", length=128)
  27.      */
  28.     private $name;
  30.     /**
  31.      * @ORM\Column(type="float", nullable=true)
  32.     */
  33.     private $sale_price;
  35.     /**
  36.      * @ORM\Column(type="float", nullable=true)
  37.     */
  38.     private $purchase_price;
  40.     /**
  41.      * @ORM\Column(type="float", nullable=true)
  42.     */
  43.     private $quantity_available_for_kit;
  45.     /**
  46.      * @ORM\Column(type="float", nullable=true)
  47.     */
  48.     private $quantity_available_for_out;
  50.     /**
  51.      * @ORM\Column(type="boolean", options={"default": false})
  52.      */
  53.     private $is_available_for_restaurant = false;
  55.     /**
  56.      * @ORM\Column(type="float", nullable=true)
  57.      */
  58.     private $restaurant_price;
  60.     /**
  61.      * @ORM\Column(type="float", nullable=true)
  62.      */
  63.     private $quantity_available_for_restaurant;
  65.     /**
  66.      * @ORM\Column(type="string", length=255, nullable=true)
  67.      */
  68.     private $image;
  70.     /**
  71.      * NOTE: This is not a mapped field of entity metadata, just a simple property.
  72.      * @Vich\UploadableField(mapping="stock_products", fileNameProperty="image")
  73.      * @var File|null
  74.      */
  75.     private $imageFile;
  77.     /**
  78.      * @ORM\ManyToOne(targetEntity=Establishment::class, inversedBy="stockProducts")
  79.      * @ORM\JoinColumn(nullable=false)
  80.      */
  81.     private $establishment;
  83.     /**
  84.      * @ORM\Column(type="datetime_immutable")
  85.     */
  86.     private $created_at;
  88.     /**
  89.      * @ORM\Column(type="datetime_immutable")
  90.      */
  91.     private $updated_at;
  93.     /**
  94.      * @ORM\Column(type="integer")
  95.      */
  96.     private $created_by;
  98.     /**
  99.      * @ORM\Column(type="integer")
  100.      */
  101.     private $updated_by;
  103.     /**
  104.      * @ORM\OneToMany(targetEntity=StockKitProduct::class, mappedBy="product")
  105.      */
  106.     private $stockKitProducts;
  108.     /**
  109.      * @ORM\OneToMany(targetEntity=StockProductEntryLine::class, mappedBy="product")
  110.      */
  111.     private $stockProductEntryLines;
  113.     /**
  114.      * @ORM\OneToMany(targetEntity=StockProviderKitEntryLine::class, mappedBy="product")
  115.      */
  116.     private $stockProviderKitEntryLines;
  118.     /**
  119.      * @ORM\OneToMany(targetEntity=StockStudentKitEntryLine::class, mappedBy="product")
  120.      */
  121.     private $stockStudentKitEntryLines;
  123.     /**
  124.      * @ORM\OneToMany(targetEntity=StockKitOutLine::class, mappedBy="product")
  125.      */
  126.     private $stockKitOutLines;
  128.     /**
  129.      * @ORM\OneToMany(targetEntity=StockProductOut::class, mappedBy="product")
  130.      */
  131.     private $stockProductOuts;
  133.     /**
  134.      * @ORM\OneToMany(targetEntity=StockMovement::class, mappedBy="stockProduct")
  135.      */
  136.     private $stockMovements;
  138.     /**
  139.      * @ORM\OneToMany(targetEntity=StockDeliveryNoteLine::class, mappedBy="stockProduct")
  140.      */
  141.     private $stockDeliveryNoteLines;
  143.     /**
  144.      * @ORM\OneToMany(targetEntity=StockReceptionVoucherLine::class, mappedBy="stockProduct")
  145.      */
  146.     private $stockReceptionVoucherLines;
  148.     /**
  149.      * @ORM\OneToMany(targetEntity=StockExitSlip::class, mappedBy="stockProduct")
  150.      */
  151.     private $stockExitSlips;
  153.     /**
  154.      * @ORM\OneToMany(targetEntity=StockinventoryLine::class, mappedBy="stockProduct")
  155.      */
  156.     private $stockinventoryLines;
  158.     /**
  159.      * @ORM\OneToMany(targetEntity=StocktransferLine::class, mappedBy="stockProduct")
  160.      */
  161.     private $stocktransferLines;
  163.     public function __construct()
  164.     {
  165.         $this->stockKitProducts = new ArrayCollection();
  166.         $this->stockProductEntryLines = new ArrayCollection();
  167.         $this->stockProviderKitEntryLines = new ArrayCollection();
  168.         $this->stockStudentKitEntryLines = new ArrayCollection();
  169.         $this->stockKitOutLines = new ArrayCollection();
  170.         $this->stockProductOuts = new ArrayCollection();
  171.         $this->stockMovements = new ArrayCollection();
  172.         $this->stockDeliveryNoteLines = new ArrayCollection();
  173.         $this->stockReceptionVoucherLines = new ArrayCollection();
  174.         $this->stockExitSlips = new ArrayCollection();
  175.         $this->stockinventoryLines = new ArrayCollection();
  176.         $this->stocktransferLines = new ArrayCollection();
  177.     }
  179.     public function __toString()
  180.     {
  181.         return $this->name;
  182.     }
  184.     public function getId(): ?int
  185.     {
  186.         return $this->id;
  187.     }
  189.     public function getName(): ?string
  190.     {
  191.         return $this->name;
  192.     }
  194.     public function setName(string $name): self
  195.     {
  196.         $this->name = $name;
  198.         return $this;
  199.     }
  201.     public function getEstablishment(): ?Establishment
  202.     {
  203.         return $this->establishment;
  204.     }
  206.     public function setEstablishment(?Establishment $establishment): self
  207.     {
  208.         $this->establishment = $establishment;
  210.         return $this;
  211.     }
  213.     public function getCreatedAt(): ?\DateTimeImmutable
  214.     {
  215.         return $this->created_at;
  216.     }
  218.     public function setCreatedAt(\DateTimeImmutable $created_at): self
  219.     {
  220.         $this->created_at = $created_at;
  222.         return $this;
  223.     }
  225.     public function getUpdatedAt(): ?\DateTimeImmutable
  226.     {
  227.         return $this->updated_at;
  228.     }
  230.     public function setUpdatedAt(\DateTimeImmutable $updated_at): self
  231.     {
  232.         $this->updated_at = $updated_at;
  234.         return $this;
  235.     }
  237.     public function getCreatedBy(): ?int
  238.     {
  239.         return $this->created_by;
  240.     }
  242.     public function setCreatedBy(int $created_by): self
  243.     {
  244.         $this->created_by = $created_by;
  246.         return $this;
  247.     }
  249.     public function getUpdatedBy(): ?int
  250.     {
  251.         return $this->updated_by;
  252.     }
  254.     public function setUpdatedBy(int $updated_by): self
  255.     {
  256.         $this->updated_by = $updated_by;
  258.         return $this;
  259.     }
  261.     /**
  262.      * @return Collection|StockKitProduct[]
  263.      */
  264.     public function getStockKitProducts(): Collection
  265.     {
  266.         return $this->stockKitProducts;
  267.     }
  269.     public function addStockKitProduct(StockKitProduct $stockKitProduct): self
  270.     {
  271.         if (!$this->stockKitProducts->contains($stockKitProduct)) {
  272.             $this->stockKitProducts[] = $stockKitProduct;
  273.             $stockKitProduct->setProduct($this);
  274.         }
  276.         return $this;
  277.     }
  279.     public function removeStockKitProduct(StockKitProduct $stockKitProduct): self
  280.     {
  281.         if ($this->stockKitProducts->removeElement($stockKitProduct)) {
  282.             // set the owning side to null (unless already changed)
  283.             if ($stockKitProduct->getProduct() === $this) {
  284.                 $stockKitProduct->setProduct(null);
  285.             }
  286.         }
  288.         return $this;
  289.     }
  291.     /**
  292.      * @return Collection|StockProductEntryLine[]
  293.      */
  294.     public function getStockProductEntryLines(): Collection
  295.     {
  296.         return $this->stockProductEntryLines;
  297.     }
  299.     public function addStockProductEntryLine(StockProductEntryLine $stockProductEntryLine): self
  300.     {
  301.         if (!$this->stockProductEntryLines->contains($stockProductEntryLine)) {
  302.             $this->stockProductEntryLines[] = $stockProductEntryLine;
  303.             $stockProductEntryLine->setProduct($this);
  304.         }
  306.         return $this;
  307.     }
  309.     public function removeStockProductEntryLine(StockProductEntryLine $stockProductEntryLine): self
  310.     {
  311.         if ($this->stockProductEntryLines->removeElement($stockProductEntryLine)) {
  312.             // set the owning side to null (unless already changed)
  313.             if ($stockProductEntryLine->getProduct() === $this) {
  314.                 $stockProductEntryLine->setProduct(null);
  315.             }
  316.         }
  318.         return $this;
  319.     }
  321.     /**
  322.      * @return Collection|StockProviderKitEntryLine[]
  323.      */
  324.     public function getStockProviderKitEntryLines(): Collection
  325.     {
  326.         return $this->stockProviderKitEntryLines;
  327.     }
  329.     public function addStockProviderKitEntryLine(StockProviderKitEntryLine $stockProviderKitEntryLine): self
  330.     {
  331.         if (!$this->stockProviderKitEntryLines->contains($stockProviderKitEntryLine)) {
  332.             $this->stockProviderKitEntryLines[] = $stockProviderKitEntryLine;
  333.             $stockProviderKitEntryLine->setProduct($this);
  334.         }
  336.         return $this;
  337.     }
  339.     public function removeStockProviderKitEntryLine(StockProviderKitEntryLine $stockProviderKitEntryLine): self
  340.     {
  341.         if ($this->stockProviderKitEntryLines->removeElement($stockProviderKitEntryLine)) {
  342.             // set the owning side to null (unless already changed)
  343.             if ($stockProviderKitEntryLine->getProduct() === $this) {
  344.                 $stockProviderKitEntryLine->setProduct(null);
  345.             }
  346.         }
  348.         return $this;
  349.     }
  351.     /**
  352.      * @return Collection|StockStudentKitEntryLine[]
  353.      */
  354.     public function getStockStudentKitEntryLines(): Collection
  355.     {
  356.         return $this->stockStudentKitEntryLines;
  357.     }
  359.     public function addStockStudentKitEntryLine(StockStudentKitEntryLine $stockStudentKitEntryLine): self
  360.     {
  361.         if (!$this->stockStudentKitEntryLines->contains($stockStudentKitEntryLine)) {
  362.             $this->stockStudentKitEntryLines[] = $stockStudentKitEntryLine;
  363.             $stockStudentKitEntryLine->setProduct($this);
  364.         }
  366.         return $this;
  367.     }
  369.     public function removeStockStudentKitEntryLine(StockStudentKitEntryLine $stockStudentKitEntryLine): self
  370.     {
  371.         if ($this->stockStudentKitEntryLines->removeElement($stockStudentKitEntryLine)) {
  372.             // set the owning side to null (unless already changed)
  373.             if ($stockStudentKitEntryLine->getProduct() === $this) {
  374.                 $stockStudentKitEntryLine->setProduct(null);
  375.             }
  376.         }
  378.         return $this;
  379.     }
  381.     /**
  382.      * @return Collection|StockKitOutLine[]
  383.      */
  384.     public function getStockKitOutLines(): Collection
  385.     {
  386.         return $this->stockKitOutLines;
  387.     }
  389.     public function addStockKitOutLine(StockKitOutLine $stockKitOutLine): self
  390.     {
  391.         if (!$this->stockKitOutLines->contains($stockKitOutLine)) {
  392.             $this->stockKitOutLines[] = $stockKitOutLine;
  393.             $stockKitOutLine->setProduct($this);
  394.         }
  396.         return $this;
  397.     }
  399.     public function removeStockKitOutLine(StockKitOutLine $stockKitOutLine): self
  400.     {
  401.         if ($this->stockKitOutLines->removeElement($stockKitOutLine)) {
  402.             // set the owning side to null (unless already changed)
  403.             if ($stockKitOutLine->getProduct() === $this) {
  404.                 $stockKitOutLine->setProduct(null);
  405.             }
  406.         }
  408.         return $this;
  409.     }
  411.     /**
  412.      * @return Collection|StockProductOut[]
  413.      */
  414.     public function getStockProductOuts(): Collection
  415.     {
  416.         return $this->stockProductOuts;
  417.     }
  419.     public function addStockProductOut(StockProductOut $stockProductOut): self
  420.     {
  421.         if (!$this->stockProductOuts->contains($stockProductOut)) {
  422.             $this->stockProductOuts[] = $stockProductOut;
  423.             $stockProductOut->setProduct($this);
  424.         }
  426.         return $this;
  427.     }
  429.     public function removeStockProductOut(StockProductOut $stockProductOut): self
  430.     {
  431.         if ($this->stockProductOuts->removeElement($stockProductOut)) {
  432.             // set the owning side to null (unless already changed)
  433.             if ($stockProductOut->getProduct() === $this) {
  434.                 $stockProductOut->setProduct(null);
  435.             }
  436.         }
  438.         return $this;
  439.     }
  441.     public function getQuantityAvailableForKit(): ?float
  442.     {
  443.         return $this->quantity_available_for_kit;
  444.     }
  446.     public function setQuantityAvailableForKit(?float $quantity_available_for_kit): self
  447.     {
  448.         $this->quantity_available_for_kit = $quantity_available_for_kit;
  450.         return $this;
  451.     }
  453.     public function getQuantityAvailableForOut(): ?float
  454.     {
  455.         return $this->quantity_available_for_out;
  456.     }
  458.     public function setQuantityAvailableForOut(?float $quantity_available_for_out): self
  459.     {
  460.         $this->quantity_available_for_out = $quantity_available_for_out;
  462.         return $this;
  463.     }
  465.     public function getSalePrice(): ?float
  466.     {
  467.         return $this->sale_price;
  468.     }
  470.     public function setSalePrice(?float $sale_price): self
  471.     {
  472.         $this->sale_price = $sale_price;
  474.         return $this;
  475.     }
  477.     public function getPurchasePrice(): ?float
  478.     {
  479.         return $this->purchase_price;
  480.     }
  482.     public function setPurchasePrice(?float $purchase_price): self
  483.     {
  484.         $this->purchase_price = $purchase_price;
  486.         return $this;
  487.     }
  489.     /**
  490.      * @return Collection|StockMovement[]
  491.      */
  492.     public function getStockMovements(): Collection
  493.     {
  494.         return $this->stockMovements;
  495.     }
  497.     public function addStockMovement(StockMovement $stockMovement): self
  498.     {
  499.         if (!$this->stockMovements->contains($stockMovement)) {
  500.             $this->stockMovements[] = $stockMovement;
  501.             $stockMovement->setStockProduct($this);
  502.         }
  504.         return $this;
  505.     }
  507.     public function removeStockMovement(StockMovement $stockMovement): self
  508.     {
  509.         if ($this->stockMovements->removeElement($stockMovement)) {
  510.             // set the owning side to null (unless already changed)
  511.             if ($stockMovement->getStockProduct() === $this) {
  512.                 $stockMovement->setStockProduct(null);
  513.             }
  514.         }
  516.         return $this;
  517.     }
  519.     /**
  520.      * @return Collection|StockDeliveryNoteLine[]
  521.      */
  522.     public function getStockDeliveryNoteLines(): Collection
  523.     {
  524.         return $this->stockDeliveryNoteLines;
  525.     }
  527.     public function addStockDeliveryNoteLine(StockDeliveryNoteLine $stockDeliveryNoteLine): self
  528.     {
  529.         if (!$this->stockDeliveryNoteLines->contains($stockDeliveryNoteLine)) {
  530.             $this->stockDeliveryNoteLines[] = $stockDeliveryNoteLine;
  531.             $stockDeliveryNoteLine->setStockProduct($this);
  532.         }
  534.         return $this;
  535.     }
  537.     public function removeStockDeliveryNoteLine(StockDeliveryNoteLine $stockDeliveryNoteLine): self
  538.     {
  539.         if ($this->stockDeliveryNoteLines->removeElement($stockDeliveryNoteLine)) {
  540.             // set the owning side to null (unless already changed)
  541.             if ($stockDeliveryNoteLine->getStockProduct() === $this) {
  542.                 $stockDeliveryNoteLine->setStockProduct(null);
  543.             }
  544.         }
  546.         return $this;
  547.     }
  549.     /**
  550.      * @return Collection|StockReceptionVoucherLine[]
  551.      */
  552.     public function getStockReceptionVoucherLines(): Collection
  553.     {
  554.         return $this->stockReceptionVoucherLines;
  555.     }
  557.     public function addStockReceptionVoucherLine(StockReceptionVoucherLine $stockReceptionVoucherLine): self
  558.     {
  559.         if (!$this->stockReceptionVoucherLines->contains($stockReceptionVoucherLine)) {
  560.             $this->stockReceptionVoucherLines[] = $stockReceptionVoucherLine;
  561.             $stockReceptionVoucherLine->setStockProduct($this);
  562.         }
  564.         return $this;
  565.     }
  567.     public function removeStockReceptionVoucherLine(StockReceptionVoucherLine $stockReceptionVoucherLine): self
  568.     {
  569.         if ($this->stockReceptionVoucherLines->removeElement($stockReceptionVoucherLine)) {
  570.             // set the owning side to null (unless already changed)
  571.             if ($stockReceptionVoucherLine->getStockProduct() === $this) {
  572.                 $stockReceptionVoucherLine->setStockProduct(null);
  573.             }
  574.         }
  576.         return $this;
  577.     }
  579.     /**
  580.      * @return Collection|StockExitSlip[]
  581.      */
  582.     public function getStockExitSlips(): Collection
  583.     {
  584.         return $this->stockExitSlips;
  585.     }
  587.     public function addStockExitSlip(StockExitSlip $stockExitSlip): self
  588.     {
  589.         if (!$this->stockExitSlips->contains($stockExitSlip)) {
  590.             $this->stockExitSlips[] = $stockExitSlip;
  591.             $stockExitSlip->setStockProduct($this);
  592.         }
  594.         return $this;
  595.     }
  597.     public function removeStockExitSlip(StockExitSlip $stockExitSlip): self
  598.     {
  599.         if ($this->stockExitSlips->removeElement($stockExitSlip)) {
  600.             // set the owning side to null (unless already changed)
  601.             if ($stockExitSlip->getStockProduct() === $this) {
  602.                 $stockExitSlip->setStockProduct(null);
  603.             }
  604.         }
  606.         return $this;
  607.     }
  609.     /**
  610.      * @return Collection|StockinventoryLine[]
  611.      */
  612.     public function getStockinventoryLines(): Collection
  613.     {
  614.         return $this->stockinventoryLines;
  615.     }
  617.     public function addStockinventoryLine(StockinventoryLine $stockinventoryLine): self
  618.     {
  619.         if (!$this->stockinventoryLines->contains($stockinventoryLine)) {
  620.             $this->stockinventoryLines[] = $stockinventoryLine;
  621.             $stockinventoryLine->setStockProduct($this);
  622.         }
  624.         return $this;
  625.     }
  627.     public function removeStockinventoryLine(StockinventoryLine $stockinventoryLine): self
  628.     {
  629.         if ($this->stockinventoryLines->removeElement($stockinventoryLine)) {
  630.             // set the owning side to null (unless already changed)
  631.             if ($stockinventoryLine->getStockProduct() === $this) {
  632.                 $stockinventoryLine->setStockProduct(null);
  633.             }
  634.         }
  636.         return $this;
  637.     }
  639.     /**
  640.      * @return Collection|StocktransferLine[]
  641.      */
  642.     public function getStocktransferLines(): Collection
  643.     {
  644.         return $this->stocktransferLines;
  645.     }
  647.     public function addStocktransferLine(StocktransferLine $stocktransferLine): self
  648.     {
  649.         if (!$this->stocktransferLines->contains($stocktransferLine)) {
  650.             $this->stocktransferLines[] = $stocktransferLine;
  651.             $stocktransferLine->setStockProduct($this);
  652.         }
  654.         return $this;
  655.     }
  657.     public function removeStocktransferLine(StocktransferLine $stocktransferLine): self
  658.     {
  659.         if ($this->stocktransferLines->removeElement($stocktransferLine)) {
  660.             // set the owning side to null (unless already changed)
  661.             if ($stocktransferLine->getStockProduct() === $this) {
  662.                 $stocktransferLine->setStockProduct(null);
  663.             }
  664.         }
  666.         return $this;
  667.     }
  669.     public function computeQuantityInStock(): ?float
  670.     {
  671.         $quantity_in_stock = 0;
  672.         foreach ($this->getStockMovements() as $stockMovement) {
  673.             if($stockMovement->getType() === StockMovement::TYPE_ENTREE) {
  674.                 $quantity_in_stock += $stockMovement->getQuantity();
  675.             } 
  676.         }
  677.         return $quantity_in_stock;
  678.     }
  680.     public function computeQuantityOutStock(): ?float
  681.     {
  682.         $quantity_out_stock = 0;
  683.         foreach ($this->getStockMovements() as $stockMovement) {
  684.             if($stockMovement->getType() === StockMovement::TYPE_SORTIE) {
  685.                 $quantity_out_stock += $stockMovement->getQuantity();
  686.             } 
  687.         }
  688.         return $quantity_out_stock;
  689.     }
  691.     public function computeQuantityAvailable(): ?float
  692.     {
  693.         $quantity_available = $this->computeQuantityInStock() - $this->computeQuantityOutStock();
  694.         return $quantity_available;
  695.     }
  697.     public function computeQuantityInStockByWarehouse(StockWarehouse $stockWarehouse): ?float
  698.     {
  699.         $quantity_in_stock = 0;
  700.         foreach ($this->getStockMovements() as $stockMovement) {
  701.             if($stockMovement->getType() === StockMovement::TYPE_ENTREE && $stockMovement->getStockWarehouse()->getId() === $stockWarehouse->getId()) {
  702.                 $quantity_in_stock += $stockMovement->getQuantity();
  703.             } 
  704.         }
  705.         return $quantity_in_stock;
  706.     }
  708.     public function computeQuantityOutStockByWarehouse(StockWarehouse $stockWarehouse): ?float
  709.     {
  710.         $quantity_out_stock = 0;
  711.         foreach ($this->getStockMovements() as $stockMovement) {
  712.             if($stockMovement->getType() === StockMovement::TYPE_SORTIE && $stockMovement->getStockWarehouse()->getId() === $stockWarehouse->getId()) {
  713.                 $quantity_out_stock += $stockMovement->getQuantity();
  714.             } 
  715.         }
  716.         return $quantity_out_stock;
  717.     }
  719.     public function computeQuantityAvailableByWarehouse(StockWarehouse $stockWarehouse): ?float
  720.     {
  721.         $quantity_available = $this->computeQuantityInStockByWarehouse($stockWarehouse) - $this->computeQuantityOutStockByWarehouse($stockWarehouse);
  722.         return $quantity_available;
  723.     }
  725.     // Restaurant fields getters and setters
  727.     public function getIsAvailableForRestaurant(): ?bool
  728.     {
  729.         return $this->is_available_for_restaurant;
  730.     }
  732.     public function setIsAvailableForRestaurant(bool $is_available_for_restaurant): self
  733.     {
  734.         $this->is_available_for_restaurant = $is_available_for_restaurant;
  736.         return $this;
  737.     }
  739.     public function getRestaurantPrice(): ?float
  740.     {
  741.         return $this->restaurant_price;
  742.     }
  744.     public function setRestaurantPrice(?float $restaurant_price): self
  745.     {
  746.         $this->restaurant_price = $restaurant_price;
  748.         return $this;
  749.     }
  751.     public function getQuantityAvailableForRestaurant(): ?float
  752.     {
  753.         return $this->quantity_available_for_restaurant;
  754.     }
  756.     public function setQuantityAvailableForRestaurant(?float $quantity_available_for_restaurant): self
  757.     {
  758.         $this->quantity_available_for_restaurant = $quantity_available_for_restaurant;
  760.         return $this;
  761.     }
  763.     public function getImage(): ?string
  764.     {
  765.         return $this->image;
  766.     }
  768.     public function setImage(?string $image): self
  769.     {
  770.         $this->image = $image;
  772.         return $this;
  773.     }
  775.     public function getImageFile(): ?File
  776.     {
  777.         return $this->imageFile;
  778.     }
  780.     public function setImageFile(?File $imageFile = null): self
  781.     {
  782.         $this->imageFile = $imageFile;
  784.         // VERY IMPORTANT: It is required that at least one field changes if you are using Doctrine,
  785.         // otherwise the event listeners won't be called and the file is lost
  786.         if ($imageFile) {
  787.             // if 'updatedAt' is not defined in your entity, use another field
  788.             $this->updated_at = new \DateTimeImmutable();
  789.         }
  791.         return $this;
  792.     }
  793.     
  794. }