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.      * @param File $file
  459.      *
  460.      * @return FileVersion
  461.      */
  462.     public function setFile(File $file = null)
  463.     {
  464.         $this->file = $file;
  466.         return $this;
  467.     }
  469.     /**
  470.      * Get file.
  471.      *
  472.      * @return File
  473.      */
  474.     public function getFile()
  475.     {
  476.         return $this->file;
  477.     }
  479.     /**
  480.      * Add tags.
  481.      *
  482.      * @return FileVersion
  483.      */
  484.     public function addTag(TagInterface $tags)
  485.     {
  486.         $this->tags[] = $tags;
  488.         return $this;
  489.     }
  491.     /**
  492.      * Remove tags.
  493.      */
  494.     public function removeTag(TagInterface $tags)
  495.     {
  496.         $this->tags->removeElement($tags);
  497.     }
  499.     /**
  500.      * Remove all tags.
  501.      */
  502.     public function removeTags()
  503.     {
  504.         $this->tags->clear();
  505.     }
  507.     /**
  508.      * Get tags.
  509.      *
  510.      * @return DoctrineCollection<int, TagInterface>
  511.      */
  512.     public function getTags()
  513.     {
  514.         return $this->tags;
  515.     }
  517.     /**
  518.      * Set defaultMeta.
  519.      *
  520.      * @param FileVersionMeta $defaultMeta
  521.      *
  522.      * @return FileVersion
  523.      */
  524.     public function setDefaultMeta(FileVersionMeta $defaultMeta = null)
  525.     {
  526.         $this->defaultMeta = $defaultMeta;
  528.         return $this;
  529.     }
  531.     /**
  532.      * Get defaultMeta.
  533.      *
  534.      * @return FileVersionMeta
  535.      */
  536.     public function getDefaultMeta()
  537.     {
  538.         return $this->defaultMeta;
  539.     }
  541.     /**
  542.      * don't clone id to create a new entities.
  543.      */
  544.     public function __clone()
  545.     {
  546.         if ($this->id) {
  547.             $this->id = null;
  548.             /** @var FileVersionMeta[] $newMetaList */
  549.             $newMetaList = [];
  550.             $defaultMetaLocale = $this->getDefaultMeta()->getLocale();
  551.             /** @var FileVersionContentLanguage[] $newContentLanguageList */
  552.             $newContentLanguageList = [];
  553.             /** @var FileVersionPublishLanguage[] $newPublishLanguageList */
  554.             $newPublishLanguageList = [];
  555.             /** @var FormatOptions[] $newFormatOptionsArray */
  556.             $newFormatOptionsArray = [];
  558.             foreach ($this->meta as $meta) {
  559.                 /* @var FileVersionMeta $meta */
  560.                 $newMetaList[] = clone $meta;
  561.             }
  563.             $this->meta->clear();
  564.             foreach ($newMetaList as $newMeta) {
  565.                 $newMeta->setFileVersion($this);
  566.                 $this->addMeta($newMeta);
  568.                 if ($newMeta->getLocale() === $defaultMetaLocale) {
  569.                     $this->setDefaultMeta($newMeta);
  570.                 }
  571.             }
  573.             foreach ($this->contentLanguages as $contentLanguage) {
  574.                 /* @var FileVersionContentLanguage $contentLanguage */
  575.                 $newContentLanguageList[] = clone $contentLanguage;
  576.             }
  578.             $this->contentLanguages->clear();
  579.             foreach ($newContentLanguageList as $newContentLanguage) {
  580.                 $newContentLanguage->setFileVersion($this);
  581.                 $this->addContentLanguage($newContentLanguage);
  582.             }
  584.             foreach ($this->publishLanguages as $publishLanguage) {
  585.                 /* @var FileVersionPublishLanguage $publishLanguage */
  586.                 $newPublishLanguageList[] = clone $publishLanguage;
  587.             }
  589.             $this->publishLanguages->clear();
  590.             foreach ($newPublishLanguageList as $newPublishLanguage) {
  591.                 $newPublishLanguage->setFileVersion($this);
  592.                 $this->addPublishLanguage($newPublishLanguage);
  593.             }
  595.             foreach ($this->formatOptions as $formatOptions) {
  596.                 /* @var FormatOptions $formatOptions */
  597.                 $newFormatOptionsArray[] = clone $formatOptions;
  598.             }
  600.             $this->formatOptions->clear();
  601.             foreach ($newFormatOptionsArray as $newFormatOptions) {
  602.                 /* @var FormatOptions $newFormatOptions */
  603.                 $newFormatOptions->setFileVersion($this);
  604.                 $this->addFormatOptions($newFormatOptions);
  605.             }
  606.         }
  607.     }
  609.     /**
  610.      * Is active.
  611.      *
  612.      * @return bool
  613.      */
  614.     public function isActive()
  615.     {
  616.         return $this->version === $this->file->getVersion();
  617.     }
  619.     /**
  620.      * @return mixed
  621.      */
  622.     public function getProperties()
  623.     {
  624.         return \json_decode($this->properties ?? '', true);
  625.     }
  627.     /**
  628.      * @return self
  629.      */
  630.     public function setProperties(array $properties)
  631.     {
  632.         $serializedText = \json_encode($properties);
  633.         if (false === $serializedText) {
  634.             return $this;
  635.         }
  636.         $this->properties = $serializedText;
  638.         return $this;
  639.     }
  641.     /**
  642.      * Add categories.
  643.      *
  644.      * @return self
  645.      */
  646.     public function addCategory(CategoryInterface $categories)
  647.     {
  648.         $this->categories[] = $categories;
  650.         return $this;
  651.     }
  653.     /**
  654.      * Remove categories.
  655.      */
  656.     public function removeCategories()
  657.     {
  658.         $this->categories->clear();
  659.     }
  661.     /**
  662.      * Get categories.
  663.      *
  664.      * @return DoctrineCollection<int, CategoryInterface>
  665.      */
  666.     public function getCategories()
  667.     {
  668.         return $this->categories;
  669.     }
  671.     /**
  672.      * Add a target group.
  673.      */
  674.     public function addTargetGroup(TargetGroupInterface $targetGroup)
  675.     {
  676.         $this->targetGroups[] = $targetGroup;
  677.     }
  679.     /**
  680.      * Remove all target groups.
  681.      */
  682.     public function removeTargetGroups()
  683.     {
  684.         if ($this->targetGroups) {
  685.             $this->targetGroups->clear();
  686.         }
  687.     }
  689.     /**
  690.      * @return DoctrineCollection<int, TargetGroupInterface>
  691.      */
  692.     public function getTargetGroups()
  693.     {
  694.         return $this->targetGroups;
  695.     }
  697.     /**
  698.      * Returns the x coordinate of the focus point.
  699.      *
  700.      * @return int|null
  701.      */
  702.     public function getFocusPointX()
  703.     {
  704.         return $this->focusPointX;
  705.     }
  707.     /**
  708.      * Sets the x coordinate of the focus point.
  709.      *
  710.      * @param int $focusPointX
  711.      */
  712.     public function setFocusPointX($focusPointX)
  713.     {
  714.         $this->focusPointX = $focusPointX;
  715.     }
  717.     /**
  718.      * Returns the y coordinate of the focus point.
  719.      *
  720.      * @return int|null
  721.      */
  722.     public function getFocusPointY()
  723.     {
  724.         return $this->focusPointY;
  725.     }
  727.     /**
  728.      * Sets the y coordinate of the focus point.
  729.      *
  730.      * @param int $focusPointY
  731.      */
  732.     public function setFocusPointY($focusPointY)
  733.     {
  734.         $this->focusPointY = $focusPointY;
  735.     }
  736. }