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

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