vendor/sulu/sulu/src/Sulu/Bundle/MediaBundle/Entity/FileVersion.php line 27

  1. <?php
  3. /*
  4.  * This file is part of Sulu.
  5.  *
  6.  * (c) Sulu GmbH
  7.  *
  8.  * This source file is subject to the MIT license that is bundled
  9.  * with this source code in the file LICENSE.
  10.  */
  12. namespace Sulu\Bundle\MediaBundle\Entity;
  14. use Doctrine\Common\Collections\ArrayCollection;
  15. use Doctrine\Common\Collections\Collection as DoctrineCollection;
  16. use JMS\Serializer\Annotation\Exclude;
  17. use Sulu\Bundle\AudienceTargetingBundle\Entity\TargetGroupInterface;
  18. use Sulu\Bundle\CategoryBundle\Entity\CategoryInterface;
  19. use Sulu\Bundle\TagBundle\Tag\TagInterface;
  20. use Sulu\Component\Persistence\Model\AuditableInterface;
  21. use Sulu\Component\Persistence\Model\AuditableTrait;
  22. use Symfony\Component\Mime\MimeTypes;
  24. /**
  25.  * FileVersion.
  26.  */
  27. class FileVersion implements AuditableInterface
  28. {
  29.     use AuditableTrait;
  31.     /**
  32.      * @var string
  33.      */
  34.     private $name;
  36.     /**
  37.      * @var int
  38.      */
  39.     private $version;
  41.     /**
  42.      * @var int
  43.      */
  44.     private $subVersion = 0;
  46.     /**
  47.      * @var int
  48.      */
  49.     private $size;
  51.     /**
  52.      * @var string|null
  53.      */
  54.     private $mimeType;
  56.     /**
  57.      * @var string|null
  58.      */
  59.     private $storageOptions;
  61.     /**
  62.      * @var int
  63.      */
  64.     private $downloadCounter = 0;
  66.     /**
  67.      * @var int
  68.      */
  69.     private $id;
  71.     /**
  72.      * @var DoctrineCollection<int, FileVersionContentLanguage>
  73.      */
  74.     private $contentLanguages;
  76.     /**
  77.      * @var DoctrineCollection<int, FileVersionPublishLanguage>
  78.      */
  79.     private $publishLanguages;
  81.     /**
  82.      * @var DoctrineCollection<int, FileVersionMeta>
  83.      */
  84.     private $meta;
  86.     /**
  87.      * @var DoctrineCollection<string, FormatOptions>
  88.      */
  89.     private $formatOptions;
  91.     /**
  92.      * @var File
  93.      *
  94.      * @Exclude
  95.      */
  96.     private $file;
  98.     /**
  99.      * @var DoctrineCollection<int, TagInterface>
  100.      */
  101.     private $tags;
  103.     /**
  104.      * @var FileVersionMeta
  105.      */
  106.     private $defaultMeta;
  108.     /**
  109.      * @var string|null
  110.      */
  111.     private $properties = '{}';
  113.     /**
  114.      * @var DoctrineCollection<int, CategoryInterface>
  115.      */
  116.     private $categories;
  118.     /**
  119.      * @var DoctrineCollection<int, TargetGroupInterface>
  120.      */
  121.     private $targetGroups;
  123.     /**
  124.      * @var int|null
  125.      */
  126.     private $focusPointX;
  128.     /**
  129.      * @var int|null
  130.      */
  131.     private $focusPointY;
  133.     /**
  134.      * Constructor.
  135.      */
  136.     public function __construct()
  137.     {
  138.         $this->contentLanguages = new ArrayCollection();
  139.         $this->publishLanguages = new ArrayCollection();
  140.         $this->meta = new ArrayCollection();
  141.         $this->formatOptions = new ArrayCollection();
  142.         $this->tags = new ArrayCollection();
  143.         $this->categories = new ArrayCollection();
  144.         $this->targetGroups = new ArrayCollection();
  145.     }
  147.     /**
  148.      * Set name.
  149.      *
  150.      * @param string $name
  151.      *
  152.      * @return FileVersion
  153.      */
  154.     public function setName($name)
  155.     {
  156.         $this->name = $name;
  158.         return $this;
  159.     }
  161.     /**
  162.      * Get name.
  163.      *
  164.      * @return string
  165.      */
  166.     public function getName()
  167.     {
  168.         return $this->name;
  169.     }
  171.     /**
  172.      * Set version.
  173.      *
  174.      * @param int $version
  175.      *
  176.      * @return FileVersion
  177.      */
  178.     public function setVersion($version)
  179.     {
  180.         $this->version = $version;
  182.         return $this;
  183.     }
  185.     /**
  186.      * Get version.
  187.      *
  188.      * @return int
  189.      */
  190.     public function getVersion()
  191.     {
  192.         return $this->version;
  193.     }
  195.     /**
  196.      * Increases the subversion. Required for cache busting on certain operations which change the image without
  197.      * creating a new file version.
  198.      *
  199.      * @return FileVersion
  200.      */
  201.     public function increaseSubVersion()
  202.     {
  203.         ++$this->subVersion;
  205.         return $this;
  206.     }
  208.     /**
  209.      * Get subVersion.
  210.      *
  211.      * @return int
  212.      */
  213.     public function getSubVersion()
  214.     {
  215.         return $this->subVersion;
  216.     }
  218.     /**
  219.      * Set size.
  220.      *
  221.      * @param int $size
  222.      *
  223.      * @return FileVersion
  224.      */
  225.     public function setSize($size)
  226.     {
  227.         $this->size = $size;
  229.         return $this;
  230.     }
  232.     /**
  233.      * Get size.
  234.      *
  235.      * @return int
  236.      */
  237.     public function getSize()
  238.     {
  239.         return $this->size;
  240.     }
  242.     /**
  243.      * Set mimeType.
  244.      *
  245.      * @param string $mimeType
  246.      *
  247.      * @return FileVersion
  248.      */
  249.     public function setMimeType($mimeType)
  250.     {
  251.         $this->mimeType = $mimeType;
  253.         return $this;
  254.     }
  256.     /**
  257.      * Get mimeType.
  258.      *
  259.      * @return string|null
  260.      */
  261.     public function getMimeType()
  262.     {
  263.         return $this->mimeType;
  264.     }
  266.     /**
  267.      * Get extension.
  268.      *
  269.      * @return null|string
  270.      */
  271.     public function getExtension()
  272.     {
  273.         $pathInfo = \pathinfo($this->getName());
  274.         $extension = MimeTypes::getDefault()->getExtensions($this->getMimeType() ?? '')[0] ?? null;
  275.         if ($extension) {
  276.             return $extension;
  277.         } elseif (isset($pathInfo['extension'])) {
  278.             return $pathInfo['extension'];
  279.         }
  281.         return null;
  282.     }
  284.     public function setStorageOptions(array $storageOptions)
  285.     {
  286.         $serializedText = \json_encode($storageOptions);
  287.         if (false === $serializedText) {
  288.             return;
  289.         }
  291.         $this->storageOptions = $serializedText;
  293.         return $this;
  294.     }
  296.     /**
  297.      * @return mixed[]
  298.      */
  299.     public function getStorageOptions(): array
  300.     {
  301.         $storageOptions = \json_decode($this->storageOptions ?? '', true);
  302.         if (!$storageOptions) {
  303.             return [];
  304.         }
  306.         return $storageOptions;
  307.     }
  309.     /**
  310.      * Set downloadCounter.
  311.      *
  312.      * @param int $downloadCounter
  313.      *
  314.      * @return FileVersion
  315.      */
  316.     public function setDownloadCounter($downloadCounter)
  317.     {
  318.         $this->downloadCounter = $downloadCounter;
  320.         return $this;
  321.     }
  323.     /**
  324.      * Get downloadCounter.
  325.      *
  326.      * @return int
  327.      */
  328.     public function getDownloadCounter()
  329.     {
  330.         return $this->downloadCounter;
  331.     }
  333.     /**
  334.      * Get id.
  335.      *
  336.      * @return int
  337.      */
  338.     public function getId()
  339.     {
  340.         return $this->id;
  341.     }
  343.     /**
  344.      * Add contentLanguages.
  345.      *
  346.      * @return FileVersion
  347.      */
  348.     public function addContentLanguage(FileVersionContentLanguage $contentLanguages)
  349.     {
  350.         $this->contentLanguages[] = $contentLanguages;
  352.         return $this;
  353.     }
  355.     /**
  356.      * Remove contentLanguages.
  357.      */
  358.     public function removeContentLanguage(FileVersionContentLanguage $contentLanguages)
  359.     {
  360.         $this->contentLanguages->removeElement($contentLanguages);
  361.     }
  363.     /**
  364.      * Get contentLanguages.
  365.      *
  366.      * @return DoctrineCollection<int, FileVersionContentLanguage>
  367.      */
  368.     public function getContentLanguages()
  369.     {
  370.         return $this->contentLanguages;
  371.     }
  373.     /**
  374.      * Add publishLanguages.
  375.      *
  376.      * @return FileVersion
  377.      */
  378.     public function addPublishLanguage(FileVersionPublishLanguage $publishLanguages)
  379.     {
  380.         $this->publishLanguages[] = $publishLanguages;
  382.         return $this;
  383.     }
  385.     /**
  386.      * Remove publishLanguages.
  387.      */
  388.     public function removePublishLanguage(FileVersionPublishLanguage $publishLanguages)
  389.     {
  390.         $this->publishLanguages->removeElement($publishLanguages);
  391.     }
  393.     /**
  394.      * Get publishLanguages.
  395.      *
  396.      * @return DoctrineCollection<int, FileVersionPublishLanguage>
  397.      */
  398.     public function getPublishLanguages()
  399.     {
  400.         return $this->publishLanguages;
  401.     }
  403.     /**
  404.      * Add meta.
  405.      *
  406.      * @return FileVersion
  407.      */
  408.     public function addMeta(FileVersionMeta $meta)
  409.     {
  410.         $this->meta[] = $meta;
  412.         return $this;
  413.     }
  415.     /**
  416.      * Remove meta.
  417.      */
  418.     public function removeMeta(FileVersionMeta $meta)
  419.     {
  420.         $this->meta->removeElement($meta);
  421.     }
  423.     /**
  424.      * Get meta.
  425.      *
  426.      * @return DoctrineCollection<int, FileVersionMeta>
  427.      */
  428.     public function getMeta()
  429.     {
  430.         return $this->meta;
  431.     }
  433.     /**
  434.      * Adds a format-options entity to the file-version.
  435.      *
  436.      * @return FileVersion
  437.      */
  438.     public function addFormatOptions(FormatOptions $formatOptions)
  439.     {
  440.         $this->formatOptions[$formatOptions->getFormatKey()] = $formatOptions;
  442.         return $this;
  443.     }
  445.     /**
  446.      * Get formatOptions.
  447.      *
  448.      * @return DoctrineCollection<string, FormatOptions>
  449.      */
  450.     public function getFormatOptions()
  451.     {
  452.         return $this->formatOptions;
  453.     }
  455.     /**
  456.      * Set file.
  457.      *
  458.      * @return FileVersion
  459.      */
  460.     public function setFile(?File $file = null)
  461.     {
  462.         $this->file = $file;
  464.         return $this;
  465.     }
  467.     /**
  468.      * Get file.
  469.      *
  470.      * @return File
  471.      */
  472.     public function getFile()
  473.     {
  474.         return $this->file;
  475.     }
  477.     /**
  478.      * Add tags.
  479.      *
  480.      * @return FileVersion
  481.      */
  482.     public function addTag(TagInterface $tags)
  483.     {
  484.         $this->tags[] = $tags;
  486.         return $this;
  487.     }
  489.     /**
  490.      * Remove tags.
  491.      */
  492.     public function removeTag(TagInterface $tags)
  493.     {
  494.         $this->tags->removeElement($tags);
  495.     }
  497.     /**
  498.      * Remove all tags.
  499.      */
  500.     public function removeTags()
  501.     {
  502.         $this->tags->clear();
  503.     }
  505.     /**
  506.      * Get tags.
  507.      *
  508.      * @return DoctrineCollection<int, TagInterface>
  509.      */
  510.     public function getTags()
  511.     {
  512.         return $this->tags;
  513.     }
  515.     /**
  516.      * Set defaultMeta.
  517.      *
  518.      * @return FileVersion
  519.      */
  520.     public function setDefaultMeta(?FileVersionMeta $defaultMeta = null)
  521.     {
  522.         $this->defaultMeta = $defaultMeta;
  524.         return $this;
  525.     }
  527.     /**
  528.      * Get defaultMeta.
  529.      *
  530.      * @return FileVersionMeta
  531.      */
  532.     public function getDefaultMeta()
  533.     {
  534.         return $this->defaultMeta;
  535.     }
  537.     /**
  538.      * don't clone id to create a new entities.
  539.      */
  540.     public function __clone()
  541.     {
  542.         if ($this->id) {
  543.             $this->id = null;
  544.             /** @var FileVersionMeta[] $newMetaList */
  545.             $newMetaList = [];
  546.             $defaultMetaLocale = $this->getDefaultMeta()->getLocale();
  547.             /** @var FileVersionContentLanguage[] $newContentLanguageList */
  548.             $newContentLanguageList = [];
  549.             /** @var FileVersionPublishLanguage[] $newPublishLanguageList */
  550.             $newPublishLanguageList = [];
  551.             /** @var FormatOptions[] $newFormatOptionsArray */
  552.             $newFormatOptionsArray = [];
  554.             foreach ($this->meta as $meta) {
  555.                 /* @var FileVersionMeta $meta */
  556.                 $newMetaList[] = clone $meta;
  557.             }
  559.             $this->meta->clear();
  560.             foreach ($newMetaList as $newMeta) {
  561.                 $newMeta->setFileVersion($this);
  562.                 $this->addMeta($newMeta);
  564.                 if ($newMeta->getLocale() === $defaultMetaLocale) {
  565.                     $this->setDefaultMeta($newMeta);
  566.                 }
  567.             }
  569.             foreach ($this->contentLanguages as $contentLanguage) {
  570.                 /* @var FileVersionContentLanguage $contentLanguage */
  571.                 $newContentLanguageList[] = clone $contentLanguage;
  572.             }
  574.             $this->contentLanguages->clear();
  575.             foreach ($newContentLanguageList as $newContentLanguage) {
  576.                 $newContentLanguage->setFileVersion($this);
  577.                 $this->addContentLanguage($newContentLanguage);
  578.             }
  580.             foreach ($this->publishLanguages as $publishLanguage) {
  581.                 /* @var FileVersionPublishLanguage $publishLanguage */
  582.                 $newPublishLanguageList[] = clone $publishLanguage;
  583.             }
  585.             $this->publishLanguages->clear();
  586.             foreach ($newPublishLanguageList as $newPublishLanguage) {
  587.                 $newPublishLanguage->setFileVersion($this);
  588.                 $this->addPublishLanguage($newPublishLanguage);
  589.             }
  591.             foreach ($this->formatOptions as $formatOptions) {
  592.                 /* @var FormatOptions $formatOptions */
  593.                 $newFormatOptionsArray[] = clone $formatOptions;
  594.             }
  596.             $this->formatOptions->clear();
  597.             foreach ($newFormatOptionsArray as $newFormatOptions) {
  598.                 /* @var FormatOptions $newFormatOptions */
  599.                 $newFormatOptions->setFileVersion($this);
  600.                 $this->addFormatOptions($newFormatOptions);
  601.             }
  602.         }
  603.     }
  605.     /**
  606.      * Is active.
  607.      *
  608.      * @return bool
  609.      */
  610.     public function isActive()
  611.     {
  612.         return $this->version === $this->file->getVersion();
  613.     }
  615.     /**
  616.      * @return mixed
  617.      */
  618.     public function getProperties()
  619.     {
  620.         return \json_decode($this->properties ?? '', true);
  621.     }
  623.     /**
  624.      * @return self
  625.      */
  626.     public function setProperties(array $properties)
  627.     {
  628.         $serializedText = \json_encode($properties);
  629.         if (false === $serializedText) {
  630.             return $this;
  631.         }
  632.         $this->properties = $serializedText;
  634.         return $this;
  635.     }
  637.     /**
  638.      * Add categories.
  639.      *
  640.      * @return self
  641.      */
  642.     public function addCategory(CategoryInterface $categories)
  643.     {
  644.         $this->categories[] = $categories;
  646.         return $this;
  647.     }
  649.     /**
  650.      * Remove categories.
  651.      */
  652.     public function removeCategories()
  653.     {
  654.         $this->categories->clear();
  655.     }
  657.     /**
  658.      * Get categories.
  659.      *
  660.      * @return DoctrineCollection<int, CategoryInterface>
  661.      */
  662.     public function getCategories()
  663.     {
  664.         return $this->categories;
  665.     }
  667.     /**
  668.      * Add a target group.
  669.      */
  670.     public function addTargetGroup(TargetGroupInterface $targetGroup)
  671.     {
  672.         $this->targetGroups[] = $targetGroup;
  673.     }
  675.     /**
  676.      * Remove all target groups.
  677.      */
  678.     public function removeTargetGroups()
  679.     {
  680.         if ($this->targetGroups) {
  681.             $this->targetGroups->clear();
  682.         }
  683.     }
  685.     /**
  686.      * @return DoctrineCollection<int, TargetGroupInterface>
  687.      */
  688.     public function getTargetGroups()
  689.     {
  690.         return $this->targetGroups;
  691.     }
  693.     /**
  694.      * Returns the x coordinate of the focus point.
  695.      *
  696.      * @return int|null
  697.      */
  698.     public function getFocusPointX()
  699.     {
  700.         return $this->focusPointX;
  701.     }
  703.     /**
  704.      * Sets the x coordinate of the focus point.
  705.      *
  706.      * @param int $focusPointX
  707.      */
  708.     public function setFocusPointX($focusPointX)
  709.     {
  710.         $this->focusPointX = $focusPointX;
  711.     }
  713.     /**
  714.      * Returns the y coordinate of the focus point.
  715.      *
  716.      * @return int|null
  717.      */
  718.     public function getFocusPointY()
  719.     {
  720.         return $this->focusPointY;
  721.     }
  723.     /**
  724.      * Sets the y coordinate of the focus point.
  725.      *
  726.      * @param int $focusPointY
  727.      */
  728.     public function setFocusPointY($focusPointY)
  729.     {
  730.         $this->focusPointY = $focusPointY;
  731.     }
  732. }