src/Pumukit/SchemaBundle/Document/MultimediaObject.php line 32

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Pumukit\SchemaBundle\Document;
  7. use ApiPlatform\Core\Annotation\ApiResource;
  8. use Doctrine\Common\Collections\ArrayCollection;
  9. use Doctrine\ODM\MongoDB\DocumentNotFoundException;
  10. use Doctrine\ODM\MongoDB\Mapping\Annotations as MongoDB;
  11. use Gedmo\Mapping\Annotation as Gedmo;
  12. use Pumukit\SchemaBundle\Document\MediaType\Document;
  13. use Pumukit\SchemaBundle\Document\MediaType\External;
  14. use Pumukit\SchemaBundle\Document\MediaType\Image;
  15. use Pumukit\SchemaBundle\Document\MediaType\MediaInterface;
  16. use Pumukit\SchemaBundle\Document\MediaType\Metadata\VideoAudio;
  17. use Pumukit\SchemaBundle\Document\MediaType\Track;
  18. use Pumukit\SchemaBundle\Document\ValueObject\Immutable;
  20. /**
  21.  * @MongoDB\Document(repositoryClass="Pumukit\SchemaBundle\Repository\MultimediaObjectRepository")
  22.  *
  23.  * @MongoDB\Index(name="text_index", keys={"textindex.text"="text", "secondarytextindex.text"="text"}, options={"language_override"="indexlanguage", "default_language"="none", "weights"={"textindex.text"=10, "secondarytextindex.text"=1}})
  24.  *
  25.  * @MongoDB\HasLifecycleCallbacks
  26.  *
  27.  * @ApiResource(
  28.  *       collectionOperations={"get"={"method"="GET", "access_control"="is_granted('ROLE_ACCESS_API')"}},
  29.  *       itemOperations={"get"={"method"="GET", "access_control"="is_granted('ROLE_ACCESS_API')"}}
  30.  *   )
  31.  */
  32. class MultimediaObject
  33. {
  34.     use Traits\Keywords;
  35.     use Traits\Properties;
  36.     use Traits\HeadAndTail;
  37.     use Traits\Link {
  38.         Traits\Link::__construct as private __LinkConstruct;
  39.     }
  40.     use Traits\Pic {
  41.         Traits\Pic::__construct as private __PicConstruct;
  42.     }
  43.     use Traits\Material {
  44.         Traits\Material::__construct as private __MaterialConstruct;
  45.     }
  47.     public const STATUS_PUBLISHED = 0;
  48.     public const STATUS_BLOCKED = 1;
  49.     public const STATUS_HIDDEN = 2;
  50.     public const STATUS_NEW = -1;
  51.     public const STATUS_PROTOTYPE = -2;
  53.     public const TYPE_UNKNOWN = 0;
  54.     public const TYPE_VIDEO = 1;
  55.     public const TYPE_AUDIO = 2;
  56.     public const TYPE_EXTERNAL = 3;
  57.     public const TYPE_LIVE = 4;
  58.     public const TYPE_IMAGE = 5;
  59.     public const TYPE_DOCUMENT = 6;
  61.     public static $statusTexts = [
  62.         self::STATUS_PUBLISHED => 'Published',
  63.         self::STATUS_BLOCKED => 'Blocked',
  64.         self::STATUS_HIDDEN => 'Hidden',
  65.         self::STATUS_NEW => 'New',
  66.         self::STATUS_PROTOTYPE => 'Prototype',
  67.     ];
  69.     public static $typeTexts = [
  70.         self::TYPE_UNKNOWN => '',
  71.         self::TYPE_VIDEO => 'Video',
  72.         self::TYPE_AUDIO => 'Audio',
  73.         self::TYPE_EXTERNAL => 'External',
  74.         self::TYPE_LIVE => 'Live',
  75.         self::TYPE_IMAGE => 'Image',
  76.         self::TYPE_DOCUMENT => 'Document',
  77.     ];
  79.     /**
  80.      * @MongoDB\Id
  81.      */
  82.     private $id;
  84.     /**
  85.      * @MongoDB\Field(type="int")
  86.      *
  87.      * @MongoDB\UniqueIndex()
  88.      */
  89.     private $numerical_id;
  91.     /**
  92.      * @MongoDB\EmbedOne(name="immutable", targetDocument="Pumukit\SchemaBundle\Document\ValueObject\Immutable")
  93.      */
  94.     private $immutable;
  96.     /**
  97.      * @MongoDB\Field(type="int")
  98.      *
  99.      * @MongoDB\Index
  100.      */
  101.     private $type = self::TYPE_UNKNOWN;
  103.     /**
  104.      * @MongoDB\Field(type="string")
  105.      *
  106.      * @MongoDB\Index
  107.      */
  108.     private $secret;
  110.     /**
  111.      * @MongoDB\ReferenceOne(targetDocument=Series::class, storeAs="id", inversedBy="multimedia_object", cascade={"persist"})
  112.      *
  113.      * @Gedmo\SortableGroup
  114.      *
  115.      * @MongoDB\Index
  116.      */
  117.     private $series;
  119.     /**
  120.      * NOTE: This field is for MongoDB Search Index purposes. Do not use this field and do not create setter and/or getter.
  121.      *
  122.      * @MongoDB\Field(type="raw")
  123.      */
  124.     private $seriesTitle = ['en' => ''];
  126.     /**
  127.      * @MongoDB\EmbedOne(targetDocument=EmbeddedBroadcast::class)
  128.      */
  129.     private $embeddedBroadcast;
  131.     /**
  132.      * @MongoDB\EmbedOne(targetDocument=EmbeddedEvent::class)
  133.      */
  134.     private $embeddedEvent;
  136.     /**
  137.      * @MongoDB\EmbedMany(targetDocument=EmbeddedSegment::class)
  138.      */
  139.     private $embeddedSegments;
  141.     /**
  142.      * @MongoDB\EmbedOne(targetDocument=EmbeddedSocial::class)
  143.      */
  144.     private $embeddedSocial;
  146.     /**
  147.      * @MongoDB\EmbedMany(targetDocument=EmbeddedTag::class)
  148.      */
  149.     private $tags;
  151.     /**
  152.      * @MongoDB\EmbedMany(targetDocument=Track::class)
  153.      */
  154.     private $tracks;
  156.     /**
  157.      * @MongoDB\EmbedMany(targetDocument=Document::class)
  158.      */
  159.     private $documents;
  161.     /**
  162.      * @MongoDB\EmbedMany(targetDocument=External::class)
  163.      */
  164.     private $external;
  166.     /**
  167.      * @MongoDB\EmbedMany(targetDocument=Image::class)
  168.      */
  169.     private $images;
  171.     /**
  172.      * @MongoDB\ReferenceMany(targetDocument=Group::class, storeAs="id", sort={"key":1}, strategy="setArray", cascade={"persist","remove"})
  173.      */
  174.     private $groups;
  176.     /**
  177.      * @MongoDB\Field(type="int")
  178.      *
  179.      * @Gedmo\SortablePosition
  180.      */
  181.     private $rank;
  183.     /**
  184.      * @MongoDB\Field(type="int")
  185.      */
  186.     private $status = self::STATUS_NEW;
  188.     /**
  189.      * @MongoDB\Field(type="date")
  190.      *
  191.      * @MongoDB\Index
  192.      */
  193.     private $record_date;
  195.     /**
  196.      * @MongoDB\Field(type="date")
  197.      *
  198.      * @MongoDB\Index
  199.      */
  200.     private $public_date;
  202.     /**
  203.      * @MongoDB\Field(type="raw")
  204.      */
  205.     private $title = ['en' => ''];
  207.     /**
  208.      * @MongoDB\Field(type="raw")
  209.      */
  210.     private $subtitle = ['en' => ''];
  212.     /**
  213.      * @MongoDB\Field(type="raw")
  214.      */
  215.     private $description = ['en' => ''];
  217.     /**
  218.      * @MongoDB\Field(type="string")
  219.      */
  220.     private $comments;
  222.     /**
  223.      * @MongoDB\Field(type="raw")
  224.      */
  225.     private $line2 = ['en' => ''];
  227.     /**
  228.      * @MongoDB\Field(type="string")
  229.      */
  230.     private $copyright;
  232.     /**
  233.      * @MongoDB\Field(type="string")
  234.      */
  235.     private $license;
  237.     /**
  238.      * @MongoDB\Field(type="int")
  239.      */
  240.     private $duration = 0;
  242.     /**
  243.      * @MongoDB\Field(type="int", strategy="increment")
  244.      */
  245.     private $numview = 0;
  247.     /**
  248.      * @MongoDB\EmbedMany(targetDocument=EmbeddedRole::class)
  249.      */
  250.     private $people;
  252.     /**
  253.      * @MongoDB\Field(type="bool")
  254.      */
  255.     private $head = false;
  257.     /**
  258.      * @MongoDB\Field(type="bool")
  259.      */
  260.     private $tail = false;
  262.     /**
  263.      * @MongoDB\Field(type="raw")
  264.      */
  265.     private $textindex = [];
  267.     /**
  268.      * @MongoDB\Field(type="raw")
  269.      */
  270.     private $secondarytextindex = [];
  272.     /**
  273.      * @MongoDB\Field(type="date")
  274.      */
  275.     private $updatedAt;
  277.     /**
  278.      * Used locale to override Translation listener`s locale this is not a mapped field of entity metadata, just a simple property.
  279.      */
  280.     private $locale = 'en';
  282.     public function __construct()
  283.     {
  284.         $this->secret = base_convert(sha1(uniqid((string) random_int(0, mt_getrandmax()), true)), 16, 36);
  285.         $this->tracks = new ArrayCollection();
  286.         $this->documents = new ArrayCollection();
  287.         $this->images = new ArrayCollection();
  288.         $this->external = new ArrayCollection();
  289.         $this->tags = new ArrayCollection();
  290.         $this->people = new ArrayCollection();
  291.         $this->groups = new ArrayCollection();
  293.         $this->__LinkConstruct();
  294.         $this->__PicConstruct();
  295.         $this->__MaterialConstruct();
  297.         $now = new \DateTime('now');
  298.         $this->setPublicDate($now);
  299.         $this->setRecordDate($now);
  300.         $this->setPropertyAsDateTime('created', $now);
  302.         $this->setUpdateAt();
  303.     }
  305.     public function __toString(): string
  306.     {
  307.         return $this->getTitle();
  308.     }
  310.     public function isCollection(): bool
  311.     {
  312.         return false;
  313.     }
  315.     public function getId()
  316.     {
  317.         return $this->id;
  318.     }
  320.     public function getNumericalID(): int
  321.     {
  322.         return $this->numerical_id;
  323.     }
  325.     public function setNumericalID(int $numericalID): void
  326.     {
  327.         $this->numerical_id = $numericalID;
  328.     }
  330.     public function getImmutable(): ?Immutable
  331.     {
  332.         return $this->immutable;
  333.     }
  335.     public function setImmutable(Immutable $immutable): void
  336.     {
  337.         $this->immutable = $immutable;
  338.     }
  340.     public function getSecret(): string
  341.     {
  342.         return $this->secret;
  343.     }
  345.     public function resetSecret(): string
  346.     {
  347.         $this->secret = base_convert(sha1(uniqid((string) random_int(0, mt_getrandmax()), true)), 16, 36);
  349.         return $this->secret;
  350.     }
  352.     public function setLocale(string $locale): void
  353.     {
  354.         $this->locale = $locale;
  355.     }
  357.     public function getLocale(): string
  358.     {
  359.         return $this->locale;
  360.     }
  362.     public function setRank(int $rank): void
  363.     {
  364.         $this->rank = $rank;
  365.     }
  367.     public function getRank(): int
  368.     {
  369.         return $this->rank;
  370.     }
  372.     public function isLive(): bool
  373.     {
  374.         return self::TYPE_LIVE === $this->type;
  375.     }
  377.     public function setType($type): void
  378.     {
  379.         $this->type = $type;
  380.     }
  382.     public function getType(): int
  383.     {
  384.         return $this->type;
  385.     }
  387.     public function setVideoType(): void
  388.     {
  389.         $this->type = self::TYPE_VIDEO;
  390.     }
  392.     public function isVideoAudioType(): bool
  393.     {
  394.         return $this->isVideoType() || $this->isAudioType();
  395.     }
  397.     public function isVideoType(): bool
  398.     {
  399.         return self::TYPE_VIDEO === $this->getType();
  400.     }
  402.     public function isAudioType(): bool
  403.     {
  404.         return self::TYPE_AUDIO === $this->getType();
  405.     }
  407.     public function setAudioType(): void
  408.     {
  409.         $this->type = self::TYPE_AUDIO;
  410.     }
  412.     public function setLiveType(): void
  413.     {
  414.         $this->type = self::TYPE_LIVE;
  415.     }
  417.     public function isLiveType(): bool
  418.     {
  419.         return self::TYPE_LIVE === $this->getType();
  420.     }
  422.     public function setImageType(): void
  423.     {
  424.         $this->type = self::TYPE_IMAGE;
  425.     }
  427.     public function isImageType(): bool
  428.     {
  429.         return self::TYPE_IMAGE === $this->getType();
  430.     }
  432.     public function setDocumentType(): void
  433.     {
  434.         $this->type = self::TYPE_DOCUMENT;
  435.     }
  437.     public function isDocumentType(): bool
  438.     {
  439.         return self::TYPE_DOCUMENT === $this->getType();
  440.     }
  442.     public function setExternalType(): void
  443.     {
  444.         $this->type = self::TYPE_EXTERNAL;
  445.     }
  447.     public function isExternalType(): bool
  448.     {
  449.         return self::TYPE_EXTERNAL === $this->getType();
  450.     }
  452.     public function getStringType($type): string
  453.     {
  454.         return self::$typeTexts[$type];
  455.     }
  457.     public function setStatus($status): void
  458.     {
  459.         $this->status = $status;
  460.     }
  462.     public function getStatus(): int
  463.     {
  464.         return $this->status;
  465.     }
  467.     public function getStringStatus($status): string
  468.     {
  469.         return self::$statusTexts[$status];
  470.     }
  472.     public function isPublished(): bool
  473.     {
  474.         return self::STATUS_PUBLISHED === $this->getStatus();
  475.     }
  477.     public function isBlocked(): bool
  478.     {
  479.         return self::STATUS_BLOCKED === $this->getStatus();
  480.     }
  482.     public function isHidden(): bool
  483.     {
  484.         return self::STATUS_HIDDEN === $this->getStatus();
  485.     }
  487.     public function isPrototype(): bool
  488.     {
  489.         return self::STATUS_PROTOTYPE === $this->getStatus();
  490.     }
  492.     public function setRecordDate($recordDate): void
  493.     {
  494.         $this->record_date = $recordDate;
  495.     }
  497.     public function getRecordDate()
  498.     {
  499.         return $this->record_date;
  500.     }
  502.     public function setPublicDate($publicDate): void
  503.     {
  504.         $this->public_date = $publicDate;
  505.     }
  507.     public function getPublicDate()
  508.     {
  509.         return $this->public_date;
  510.     }
  512.     public function setTitle($title, $locale = null): void
  513.     {
  514.         if (null === $locale) {
  515.             $locale = $this->locale;
  516.         }
  517.         $this->title[$locale] = $title;
  518.     }
  520.     public function getTitle($locale = null): string
  521.     {
  522.         if (null === $locale) {
  523.             $locale = $this->locale;
  524.         }
  526.         return $this->title[$locale] ?? '';
  527.     }
  529.     public function setI18nTitle(array $title): void
  530.     {
  531.         $this->title = $title;
  532.     }
  534.     public function getI18nTitle(): array
  535.     {
  536.         return $this->title;
  537.     }
  539.     public function setSubtitle($subtitle, $locale = null): void
  540.     {
  541.         if (null === $locale) {
  542.             $locale = $this->locale;
  543.         }
  544.         $this->subtitle[$locale] = $subtitle;
  545.     }
  547.     public function getSubtitle($locale = null): string
  548.     {
  549.         if (null === $locale) {
  550.             $locale = $this->locale;
  551.         }
  553.         return $this->subtitle[$locale] ?? '';
  554.     }
  556.     public function setI18nSubtitle(array $subtitle): void
  557.     {
  558.         $this->subtitle = $subtitle;
  559.     }
  561.     public function getI18nSubtitle(): array
  562.     {
  563.         return $this->subtitle;
  564.     }
  566.     public function setDescription($description, $locale = null): void
  567.     {
  568.         if (null === $locale) {
  569.             $locale = $this->locale;
  570.         }
  571.         $this->description[$locale] = $description;
  572.     }
  574.     public function getDescription($locale = null): string
  575.     {
  576.         if (null === $locale) {
  577.             $locale = $this->locale;
  578.         }
  580.         return $this->description[$locale] ?? '';
  581.     }
  583.     public function setI18nDescription(array $description): void
  584.     {
  585.         $this->description = $description;
  586.     }
  588.     public function getI18nDescription(): array
  589.     {
  590.         return $this->description;
  591.     }
  593.     public function setComments($comments): void
  594.     {
  595.         $this->comments = $comments;
  596.     }
  598.     public function getComments()
  599.     {
  600.         return $this->comments;
  601.     }
  603.     public function setLine2($line2, $locale = null): void
  604.     {
  605.         if (null === $locale) {
  606.             $locale = $this->locale;
  607.         }
  608.         $this->line2[$locale] = $line2;
  609.     }
  611.     public function getLine2($locale = null): string
  612.     {
  613.         if (null === $locale) {
  614.             $locale = $this->locale;
  615.         }
  617.         return $this->line2[$locale] ?? '';
  618.     }
  620.     public function setI18nLine2(array $line2): void
  621.     {
  622.         $this->line2 = $line2;
  623.     }
  625.     public function getI18nLine2(): array
  626.     {
  627.         return $this->line2;
  628.     }
  630.     public function setCopyright($copyright): void
  631.     {
  632.         $this->copyright = $copyright;
  633.     }
  635.     public function getCopyright()
  636.     {
  637.         return $this->copyright;
  638.     }
  640.     public function setLicense($license)
  641.     {
  642.         $this->license = $license;
  643.     }
  645.     public function getLicense()
  646.     {
  647.         return $this->license;
  648.     }
  650.     public function setDuration($duration): void
  651.     {
  652.         $this->duration = $duration;
  653.     }
  655.     public function getDuration(): int
  656.     {
  657.         return $this->duration;
  658.     }
  660.     public function getDurationString(): string
  661.     {
  662.         if ($this->duration > 0) {
  663.             $min = floor($this->duration / 60);
  664.             $seg = $this->duration % 60;
  666.             if ($seg < 10) {
  667.                 $seg = '0'.$seg;
  668.             }
  670.             if (0 === $min) {
  671.                 $aux = $seg."''";
  672.             } else {
  673.                 $aux = $min."' ".$seg."''";
  674.             }
  676.             return $aux;
  677.         }
  679.         return "0''";
  680.     }
  682.     public function setNumview($numview): void
  683.     {
  684.         $this->numview = $numview;
  685.     }
  687.     public function incNumview(): void
  688.     {
  689.         ++$this->numview;
  690.     }
  692.     public function getNumview(): int
  693.     {
  694.         return $this->numview;
  695.     }
  697.     public function setSeries(Series $series): void
  698.     {
  699.         $this->series = $series;
  700.         // NOTE: This field is for MongoDB Search Index purposes.
  701.         //       Do not use this field and do not create setter and/or getter.
  702.         if (!$series->isHide()) {
  703.             $this->seriesTitle = $series->getI18nTitle();
  704.         } else {
  705.             $this->seriesTitle = [];
  706.         }
  707.     }
  709.     public function getSeries()
  710.     {
  711.         // WORKAROUND: get the object series is it's hidden and the MongoDB filter is enabled.
  712.         try {
  713.             $this->series->isHide();
  714.         } catch (DocumentNotFoundException $e) {
  715.         }
  717.         return $this->series;
  718.     }
  720.     public function getSeriesTitle($locale = null): string
  721.     {
  722.         if (null === $locale) {
  723.             $locale = $this->locale;
  724.         }
  726.         return $this->seriesTitle[$locale] ?? '';
  727.     }
  729.     public function setEmbeddedBroadcast(EmbeddedBroadcast $embeddedBroadcast): void
  730.     {
  731.         $this->embeddedBroadcast = $embeddedBroadcast;
  732.     }
  734.     public function getEmbeddedEvent()
  735.     {
  736.         return $this->embeddedEvent;
  737.     }
  739.     public function setEmbeddedEvent(EmbeddedEvent $embeddedEvent): void
  740.     {
  741.         $this->embeddedEvent = $embeddedEvent;
  742.     }
  744.     public function getEmbeddedSegments()
  745.     {
  746.         return $this->embeddedSegments;
  747.     }
  749.     public function setEmbeddedSegments($embeddedSegments): void
  750.     {
  751.         $this->embeddedSegments = $embeddedSegments;
  752.     }
  754.     public function addEmbeddedSegment(EmbeddedSegment $embeddedSegment): void
  755.     {
  756.         $this->embeddedSegments[] = $embeddedSegment;
  757.     }
  759.     public function removeEmbeddedSegment(EmbeddedSegment $embeddedSegment): bool
  760.     {
  761.         foreach ($this->embeddedSegments as $segment) {
  762.             if ($segment->getId() === $embeddedSegment->getId()) {
  763.                 $removed = $this->embeddedSegments->removeElement($embeddedSegment);
  764.                 $this->embeddedSegments = new ArrayCollection(array_values($this->embeddedSegments->toArray()));
  766.                 return $removed;
  767.             }
  768.         }
  770.         return false;
  771.     }
  773.     public function getEmbeddedBroadcastNotNull(): EmbeddedBroadcast
  774.     {
  775.         if ($this->embeddedBroadcast) {
  776.             return $this->embeddedBroadcast;
  777.         }
  779.         return new EmbeddedBroadcast();
  780.     }
  782.     public function getEmbeddedBroadcast()
  783.     {
  784.         return $this->embeddedBroadcast;
  785.     }
  787.     public function isPublicEmbeddedBroadcast(): bool
  788.     {
  789.         return !$this->embeddedBroadcast || EmbeddedBroadcast::TYPE_PUBLIC === $this->embeddedBroadcast->getType();
  790.     }
  792.     public function setEmbeddedSocial(EmbeddedSocial $embeddedSocial): void
  793.     {
  794.         $this->embeddedSocial = $embeddedSocial;
  795.     }
  797.     public function getEmbeddedSocial()
  798.     {
  799.         return $this->embeddedSocial;
  800.     }
  802.     public function getTags()
  803.     {
  804.         return $this->tags;
  805.     }
  807.     public function setTags($tags): void
  808.     {
  809.         $this->tags = $tags;
  810.     }
  812.     public function addTag($tag): bool
  813.     {
  814.         if (!$this->containsTag($tag)) {
  815.             $embedTag = EmbeddedTag::getEmbeddedTag($this->tags, $tag);
  816.             $this->tags[] = $embedTag;
  818.             return true;
  819.         }
  821.         return false;
  822.     }
  824.     public function removeTag(TagInterface $tagToRemove): bool
  825.     {
  826.         foreach ($this->tags as $tag) {
  827.             if ($tag->getCod() === $tagToRemove->getCod()) {
  828.                 return $this->tags->removeElement($tag);
  829.             }
  830.         }
  832.         return false;
  833.     }
  835.     public function containsTag(TagInterface $tagToCheck): bool
  836.     {
  837.         foreach ($this->tags as $tag) {
  838.             if ($tag->getCod() === $tagToCheck->getCod()) {
  839.                 return true;
  840.             }
  841.         }
  843.         return false;
  844.     }
  846.     public function containsTagWithCod($tagCod): bool
  847.     {
  848.         foreach ($this->tags as $tag) {
  849.             if ($tag->getCod() === $tagCod) {
  850.                 return true;
  851.             }
  852.         }
  854.         return false;
  855.     }
  857.     public function containsAllTags(array $tags): bool
  858.     {
  859.         foreach ($tags as $tag) {
  860.             if (!$this->containsTag($tag)) {
  861.                 return false;
  862.             }
  863.         }
  865.         return true;
  866.     }
  868.     public function containsAllTagsWithCodes(array $tagCodes): bool
  869.     {
  870.         foreach ($tagCodes as $tagCode) {
  871.             if (!$this->containsTagWithCod($tagCode)) {
  872.                 return false;
  873.             }
  874.         }
  876.         return true;
  877.     }
  879.     public function containsAnyTag(array $tags): bool
  880.     {
  881.         foreach ($tags as $tag) {
  882.             if ($this->containsTag($tag)) {
  883.                 return true;
  884.             }
  885.         }
  887.         return false;
  888.     }
  890.     public function containsAnyTagWithCodes(array $tagCodes): bool
  891.     {
  892.         foreach ($tagCodes as $tagCode) {
  893.             if ($this->containsTagWithCod($tagCode)) {
  894.                 return true;
  895.             }
  896.         }
  898.         return false;
  899.     }
  901.     public function addTrack(Track $track): void
  902.     {
  903.         $this->tracks->add($track);
  905.         if ($track->metadata() instanceof VideoAudio && $track->metadata()->duration() > $this->getDuration()) {
  906.             $this->setDuration($track->metadata()->duration());
  907.         }
  908.     }
  910.     public function addDocument(Document $document): void
  911.     {
  912.         $this->documents->add($document);
  913.     }
  915.     public function addExternal(External $external): void
  916.     {
  917.         $this->external->add($external);
  918.     }
  920.     public function addImage(Image $image): void
  921.     {
  922.         $this->images->add($image);
  923.     }
  925.     public function removeTrack(Track $track): void
  926.     {
  927.         $this->tracks->removeElement($track);
  929.         $this->updateDuration();
  930.     }
  932.     public function removeDocument(Document $document): void
  933.     {
  934.         $this->removeMediaById($document->id());
  935.     }
  937.     public function removeImage(Image $image): void
  938.     {
  939.         $this->removeMediaById($image->id());
  940.     }
  942.     public function removeTrackById($trackId): void
  943.     {
  944.         $this->tracks = $this->tracks->filter(function (Track $track) use ($trackId) {
  945.             return $track->id() !== $trackId;
  946.         });
  948.         $this->updateDuration();
  949.     }
  951.     public function removeMediaById(string $id)
  952.     {
  953.         $this->tracks = $this->tracks->filter(function (Track $media) use ($id) {
  954.             return $media->id() !== $id;
  955.         });
  957.         $this->images = $this->images->filter(function (Image $media) use ($id) {
  958.             return $media->id() !== $id;
  959.         });
  961.         $this->documents = $this->documents->filter(function (Document $media) use ($id) {
  962.             return $media->id() !== $id;
  963.         });
  964.     }
  966.     public function removeAllMedias(): void
  967.     {
  968.         $this->tracks = new ArrayCollection();
  969.         $this->documents = new ArrayCollection();
  970.         $this->external = new ArrayCollection();
  971.         $this->images = new ArrayCollection();
  972.     }
  974.     public function upTrackById($trackId): void
  975.     {
  976.         $this->reorderTrackById($trackId);
  977.     }
  979.     public function downTrackById($trackId): void
  980.     {
  981.         $this->reorderTrackById($trackId, false);
  982.     }
  984.     public function containsTrack(Track $track): bool
  985.     {
  986.         return $this->tracks->contains($track);
  987.     }
  989.     public function getMedias(): array
  990.     {
  991.         return array_merge($this->tracks->toArray(), $this->documents->toArray(), $this->external->toArray(), $this->images->toArray());
  992.     }
  994.     public function getMediasWithoutExternal(): array
  995.     {
  996.         return array_merge($this->tracks->toArray(), $this->documents->toArray(), $this->images->toArray());
  997.     }
  999.     /**
  1000.      * Deprecated Use method tracks instead getTracks.
  1001.      */
  1002.     public function getTracks()
  1003.     {
  1004.         return $this->tracks();
  1005.     }
  1007.     public function tracks()
  1008.     {
  1009.         return $this->tracks;
  1010.     }
  1012.     public function documents()
  1013.     {
  1014.         return $this->documents;
  1015.     }
  1017.     public function external()
  1018.     {
  1019.         return $this->external;
  1020.     }
  1022.     public function images()
  1023.     {
  1024.         return $this->images;
  1025.     }
  1027.     /**
  1028.      * Deprecated use getMediaById instead.
  1029.      *
  1030.      * @param mixed $mediaId
  1031.      */
  1032.     public function getTrackById($mediaId)
  1033.     {
  1034.         return $this->getMediaById($mediaId);
  1035.     }
  1037.     public function getMediaById(?string $mediaId)
  1038.     {
  1039.         foreach ($this->getMedias() as $media) {
  1040.             if ($media->id() === $mediaId) {
  1041.                 return $media;
  1042.             }
  1043.         }
  1045.         return null;
  1046.     }
  1048.     public function getTracksWithTag($tag): array
  1049.     {
  1050.         $r = [];
  1052.         foreach ($this->getMedias() as $track) {
  1053.             if ($track->tags()->contains($tag)) {
  1054.                 $r[] = $track;
  1055.             }
  1056.         }
  1058.         return $r;
  1059.     }
  1061.     public function getTrackWithTag($tag)
  1062.     {
  1063.         foreach ($this->getMedias() as $track) {
  1064.             if ($track->tags()->contains($tag)) {
  1065.                 return $track;
  1066.             }
  1067.         }
  1069.         return null;
  1070.     }
  1072.     public function getTracksWithAllTags(array $tags): array
  1073.     {
  1074.         $r = [];
  1076.         foreach ($this->getMedias() as $track) {
  1077.             if ($track->tags()->containsAllTags($tags)) {
  1078.                 $r[] = $track;
  1079.             }
  1080.         }
  1082.         return $r;
  1083.     }
  1085.     public function getTrackWithAllTags(array $tags)
  1086.     {
  1087.         foreach ($this->getMedias() as $track) {
  1088.             if ($track->tags()->containsAllTags($tags)) {
  1089.                 return $track;
  1090.             }
  1091.         }
  1093.         return null;
  1094.     }
  1096.     public function getTracksWithAnyTag(array $tags): array
  1097.     {
  1098.         $r = [];
  1100.         foreach ($this->getMedias() as $track) {
  1101.             if ($track->tags()->containsAnyTag($tags)) {
  1102.                 $r[] = $track;
  1103.             }
  1104.         }
  1106.         return $r;
  1107.     }
  1109.     public function getTrackWithAnyTag(array $tags)
  1110.     {
  1111.         foreach ($this->getMedias() as $track) {
  1112.             if ($track->tags()->containsAnyTag($tags)) {
  1113.                 return $track;
  1114.             }
  1115.         }
  1117.         return null;
  1118.     }
  1120.     public function getRealDuration(): int
  1121.     {
  1122.         $master = $this->getMaster();
  1124.         if (!$master instanceof Track) {
  1125.             return 0;
  1126.         }
  1128.         try {
  1129.             $trackDuration = $master->metadata()->duration();
  1130.         } catch (\Exception $exception) {
  1131.             return 0;
  1132.         }
  1134.         if ($this->getDuration() < $master->metadata()->duration()) {
  1135.             return $master->metadata()->duration();
  1136.         }
  1138.         return $this->getDuration();
  1139.     }
  1141.     public function getMaster($any = true): ?MediaInterface
  1142.     {
  1143.         $master = $this->getTrackWithTag('master');
  1144.         if ($master) {
  1145.             return $master;
  1146.         }
  1148.         $isAudio = $this->isOnlyAudio();
  1150.         foreach ($this->getMedias() as $track) {
  1151.             if (($isAudio && $track->metadata()->isOnlyAudio()) || (!$isAudio && !$track->metadata()->isOnlyAudio())) {
  1152.                 return $track;
  1153.             }
  1154.         }
  1156.         return null;
  1157.     }
  1159.     public function getDisplayTrack()
  1160.     {
  1161.         return $this->isOnlyAudio() ? $this->getFilteredTrackWithTags(['display']) : $this->getFilteredTrackWithTags(['display'], [], ['audio']);
  1162.     }
  1164.     public function getFilteredTracksWithTags(array $any_tags = [], array $all_tags = [], array $not_any_tags = [], array $not_all_tags = [], $all = true): array
  1165.     {
  1166.         $r = [];
  1168.         foreach ($this->tracks as $track) {
  1169.             if ($all && $track->isHide()) {
  1170.                 continue;
  1171.             }
  1172.             if ($any_tags && !$track->tags()->containsAnyTag($any_tags)) {
  1173.                 continue;
  1174.             }
  1175.             if ($all_tags && !$track->tags()->containsAllTags($all_tags)) {
  1176.                 continue;
  1177.             }
  1178.             if ($not_any_tags && $track->tags()->containsAnyTag($not_any_tags)) {
  1179.                 continue;
  1180.             }
  1181.             if ($not_all_tags && $track->tags()->containsAllTags($not_all_tags)) {
  1182.                 continue;
  1183.             }
  1185.             $r[] = $track;
  1186.         }
  1188.         return $r;
  1189.     }
  1191.     public function getFilteredTrackWithTags(array $any_tags = [], array $all_tags = [], array $not_any_tags = [], array $not_all_tags = [], $all = true)
  1192.     {
  1193.         foreach ($this->getMedias() as $track) {
  1194.             if ($all && $track->isHide()) {
  1195.                 continue;
  1196.             }
  1197.             if ($any_tags && !$track->tags()->containsAnyTag($any_tags)) {
  1198.                 continue;
  1199.             }
  1200.             if ($all_tags && !$track->tags()->containsAllTags($all_tags)) {
  1201.                 continue;
  1202.             }
  1203.             if ($not_any_tags && $track->tags()->containsAnyTag($not_any_tags)) {
  1204.                 continue;
  1205.             }
  1206.             if ($not_all_tags && $track->tags()->containsAllTags($not_all_tags)) {
  1207.                 continue;
  1208.             }
  1210.             return $track;
  1211.         }
  1213.         return null;
  1214.     }
  1216.     public function getPeople(): array
  1217.     {
  1218.         $aux = [];
  1220.         foreach ($this->people as $role) {
  1221.             foreach ($role->getPeople() as $person) {
  1222.                 if (!in_array($person, $aux, true)) {
  1223.                     $aux[] = $person;
  1224.                 }
  1225.             }
  1226.         }
  1228.         return $aux;
  1229.     }
  1231.     public function getAllEmbeddedPeopleByPerson(PersonInterface $person): array
  1232.     {
  1233.         $aux = [];
  1235.         foreach ($this->people as $role) {
  1236.             foreach ($role->getPeople() as $embeddedPerson) {
  1237.                 if ($embeddedPerson->getId() === $person->getId()) {
  1238.                     $aux[] = $embeddedPerson;
  1239.                 }
  1240.             }
  1241.         }
  1243.         return $aux;
  1244.     }
  1246.     public function getAllEmbeddedRolesByPerson(PersonInterface $person): array
  1247.     {
  1248.         $aux = [];
  1250.         foreach ($this->people as $embeddedRole) {
  1251.             foreach ($embeddedRole->getPeople() as $embeddedPerson) {
  1252.                 if ($embeddedPerson->getId() === $person->getId()) {
  1253.                     $aux[] = $embeddedRole;
  1255.                     break;
  1256.                 }
  1257.             }
  1258.         }
  1260.         return $aux;
  1261.     }
  1263.     public function containsPerson(PersonInterface $person): bool
  1264.     {
  1265.         foreach ($this->getPeople() as $embeddedPerson) {
  1266.             if ($person->getId() === $embeddedPerson->getId()) {
  1267.                 return true;
  1268.             }
  1269.         }
  1271.         return false;
  1272.     }
  1274.     public function containsPersonWithRole(PersonInterface $person, RoleInterface $role): bool
  1275.     {
  1276.         foreach ($this->getPeopleByRole($role, true) as $embeddedPerson) {
  1277.             if ($person->getId() === $embeddedPerson->getId()) {
  1278.                 return true;
  1279.             }
  1280.         }
  1282.         return false;
  1283.     }
  1285.     public function containsPersonWithAllRoles(PersonInterface $person, array $roles): bool
  1286.     {
  1287.         foreach ($roles as $role) {
  1288.             if (!$this->containsPersonWithRole($person, $role)) {
  1289.                 return false;
  1290.             }
  1291.         }
  1293.         return true;
  1294.     }
  1296.     public function containsPersonWithAnyRole(PersonInterface $person, array $roles): bool
  1297.     {
  1298.         foreach ($roles as $role) {
  1299.             if ($this->containsPersonWithRole($person, $role)) {
  1300.                 return true;
  1301.             }
  1302.         }
  1304.         return false;
  1305.     }
  1307.     public function getPeopleByRole(?RoleInterface $role = null, $always = false): array
  1308.     {
  1309.         return $this->getPeopleByRoleCod($role ? $role->getCod() : null, $always);
  1310.     }
  1312.     public function getPeopleByRoleCod($roleCod = null, $always = false): array
  1313.     {
  1314.         $aux = [];
  1316.         if (null !== $roleCod) {
  1317.             foreach ($this->people as $embeddedRole) {
  1318.                 if ($roleCod === $embeddedRole->getCod()) {
  1319.                     if ($always || $embeddedRole->getDisplay()) {
  1320.                         foreach ($embeddedRole->getPeople() as $embeddedPerson) {
  1321.                             $aux[] = $embeddedPerson;
  1322.                         }
  1323.                     }
  1325.                     break;
  1326.                 }
  1327.             }
  1328.         } else {
  1329.             foreach ($this->people as $embeddedRole) {
  1330.                 if ($always || $embeddedRole->getDisplay()) {
  1331.                     foreach ($embeddedRole->getPeople() as $embeddedPerson) {
  1332.                         if (!in_array($embeddedPerson, $aux, true)) {
  1333.                             $aux[] = $embeddedPerson;
  1334.                         }
  1335.                     }
  1336.                 }
  1337.             }
  1338.         }
  1340.         return $aux;
  1341.     }
  1343.     public function addPersonWithRole(PersonInterface $person, RoleInterface $role): void
  1344.     {
  1345.         if (!$this->containsPersonWithRole($person, $role)) {
  1346.             if ($embeddedRole = $this->getEmbeddedRole($role)) {
  1347.                 $embeddedRole->addPerson($person);
  1348.             } else {
  1349.                 $embeddedRole = $this->createEmbeddedRole($role);
  1350.                 $embeddedRole->addPerson($person);
  1351.                 $this->people[] = $embeddedRole;
  1352.             }
  1353.         }
  1354.     }
  1356.     public function removePersonWithRole(PersonInterface $person, RoleInterface $role): bool
  1357.     {
  1358.         if (!$this->containsPersonWithRole($person, $role)) {
  1359.             return false;
  1360.         }
  1362.         $embeddedRole = $this->getEmbeddedRole($role);
  1364.         $hasRemoved = $embeddedRole->removePerson($person);
  1366.         if (0 === (is_countable($embeddedRole->getPeople()) ? count($embeddedRole->getPeople()) : 0)) {
  1367.             $this->people->removeElement($embeddedRole);
  1368.         }
  1370.         return $hasRemoved;
  1371.     }
  1373.     public function getPersonWithRole($person, $role): ?PersonInterface
  1374.     {
  1375.         if ($this->containsPersonWithRole($person, $role)) {
  1376.             return $this->getEmbeddedRole($role)->getEmbeddedPerson($person);
  1377.         }
  1379.         return null;
  1380.     }
  1382.     public function upPersonWithRole($person, $role): void
  1383.     {
  1384.         $this->reorderPersonWithRole($person, $role);
  1385.     }
  1387.     public function downPersonWithRole($person, $role): void
  1388.     {
  1389.         $this->reorderPersonWithRole($person, $role, false);
  1390.     }
  1392.     public function reorderPersonWithRole(PersonInterface $person, $role, $up = true): void
  1393.     {
  1394.         $people = array_values($this->getPeopleByRole($role, true));
  1395.         $this->getEmbeddedRole($role)->getPeople()->clear();
  1397.         $out = [];
  1398.         foreach ($people as $key => $embeddedPerson) {
  1399.             if ($person->getId() === $embeddedPerson->getId()) {
  1400.                 $out[($key * 10) + ($up ? -11 : 11)] = $embeddedPerson;
  1401.             } else {
  1402.                 $out[$key * 10] = $embeddedPerson;
  1403.             }
  1404.         }
  1406.         ksort($out);
  1407.         foreach ($out as $embeddedPerson) {
  1408.             $this->getEmbeddedRole($role)->addPerson($embeddedPerson);
  1409.         }
  1410.     }
  1412.     public function getEmbeddedRole(RoleInterface $role): ?RoleInterface
  1413.     {
  1414.         foreach ($this->people as $embeddedRole) {
  1415.             if ($role->getCod() === $embeddedRole->getCod()) {
  1416.                 return $embeddedRole;
  1417.             }
  1418.         }
  1420.         return null;
  1421.     }
  1423.     public function createEmbeddedRole(RoleInterface $role): RoleInterface
  1424.     {
  1425.         if ($role instanceof EmbeddedRole) {
  1426.             return $role;
  1427.         }
  1429.         return new EmbeddedRole($role);
  1430.     }
  1432.     public function getRoles()
  1433.     {
  1434.         return $this->people;
  1435.     }
  1437.     public function containsGroup(Group $group): bool
  1438.     {
  1439.         return $this->groups->contains($group);
  1440.     }
  1442.     public function addGroup(Group $group): void
  1443.     {
  1444.         $this->groups->add($group);
  1445.     }
  1447.     public function removeGroup(Group $group): void
  1448.     {
  1449.         $this->groups->removeElement($group);
  1450.     }
  1452.     public function getGroups()
  1453.     {
  1454.         return $this->groups;
  1455.     }
  1457.     public function isOnlyAudio(): bool
  1458.     {
  1459.         return self::TYPE_AUDIO === $this->type;
  1460.     }
  1462.     public function getDurationInMinutesAndSeconds(): array
  1463.     {
  1464.         $minutes = floor($this->getDuration() / 60);
  1466.         $seconds = $this->getDuration() % 60;
  1468.         return [
  1469.             'minutes' => $minutes,
  1470.             'seconds' => $seconds,
  1471.         ];
  1472.     }
  1474.     public function setDurationInMinutesAndSeconds($durationInMinutesAndSeconds): void
  1475.     {
  1476.         if ((!empty($durationInMinutesAndSeconds['minutes'])) && (!empty($durationInMinutesAndSeconds['seconds']))) {
  1477.             $this->duration = ($durationInMinutesAndSeconds['minutes'] * 60) + $durationInMinutesAndSeconds['seconds'];
  1478.         }
  1479.     }
  1481.     public function isMultistream(): bool
  1482.     {
  1483.         $presenterTracks = $this->getFilteredTracksWithTags(['presenter/delivery']);
  1484.         $presentationTracks = $this->getFilteredTracksWithTags(['presentation/delivery']);
  1486.         return $presenterTracks && $presentationTracks;
  1487.     }
  1489.     public function setTextIndex($textindex): void
  1490.     {
  1491.         $this->textindex = $textindex;
  1492.     }
  1494.     public function getTextIndex(): array
  1495.     {
  1496.         return $this->textindex;
  1497.     }
  1499.     public function setSecondaryTextIndex($secondarytextindex): void
  1500.     {
  1501.         $this->secondarytextindex = $secondarytextindex;
  1502.     }
  1504.     public function getSecondaryTextIndex(): array
  1505.     {
  1506.         return $this->secondarytextindex;
  1507.     }
  1509.     public function setHead(bool $isHead): void
  1510.     {
  1511.         $this->head = $isHead;
  1512.     }
  1514.     public function isHead(): bool
  1515.     {
  1516.         return $this->head;
  1517.     }
  1519.     public function setTail(bool $isTail): void
  1520.     {
  1521.         $this->tail = $isTail;
  1522.     }
  1524.     public function isTail(): bool
  1525.     {
  1526.         return $this->tail;
  1527.     }
  1529.     /**
  1530.      * @MongoDB\PreUpdate
  1531.      *
  1532.      * @MongoDB\PrePersist
  1533.      */
  1534.     public function setUpdateAt(): void
  1535.     {
  1536.         $this->updatedAt = new \DateTime();
  1537.     }
  1539.     public function isUpdatedAt(): \DateTime
  1540.     {
  1541.         return $this->updatedAt;
  1542.     }
  1544.     /**
  1545.      * Reorder track by id.
  1546.      *
  1547.      * @param string $trackId
  1548.      * @param bool   $up
  1549.      */
  1550.     private function reorderTrackById($trackId, $up = true)
  1551.     {
  1552.         $snapshot = array_values($this->tracks->toArray());
  1553.         $this->tracks->clear();
  1555.         $out = [];
  1556.         foreach ($snapshot as $key => $track) {
  1557.             if ($track->id() === $trackId) {
  1558.                 $out[($key * 10) + ($up ? -11 : 11)] = $track;
  1559.             } else {
  1560.                 $out[$key * 10] = $track;
  1561.             }
  1562.         }
  1564.         ksort($out);
  1565.         foreach ($out as $track) {
  1566.             $this->tracks->add($track);
  1567.         }
  1568.     }
  1570.     private function updateDuration(): void
  1571.     {
  1572.         if (0 === count($this->tracks)) {
  1573.             $this->setDuration(0);
  1575.             return;
  1576.         }
  1578.         $trackMinDuration = $this->tracks->first()->metadata()->duration();
  1579.         foreach ($this->tracks as $mmTrack) {
  1580.             if ($mmTrack->metadata()->duration() < $trackMinDuration) {
  1581.                 $trackMinDuration = $mmTrack->metadata()->duration();
  1582.             }
  1583.         }
  1585.         $minDuration = $this->getDuration();
  1586.         if ($minDuration > $trackMinDuration) {
  1587.             $this->setDuration($trackMinDuration);
  1588.         }
  1589.     }
  1590. }