src/Entity/Studio.php line 67

  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Doctrine\Orm\Filter\ExistsFilter;
  6. use ApiPlatform\Doctrine\Orm\Filter\OrderFilter;
  7. use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
  8. use ApiPlatform\Metadata\ApiFilter;
  9. use ApiPlatform\Metadata\ApiResource;
  10. use ApiPlatform\Metadata\Get;
  11. use ApiPlatform\Metadata\GetCollection;
  12. use ApiPlatform\Metadata\Patch;
  13. use ApiPlatform\Metadata\Post;
  14. use ApiPlatform\Metadata\Put;
  15. use ApiPlatform\Serializer\Filter\PropertyFilter;
  16. use App\Repository\StudioRepository;
  17. use DateTimeImmutable;
  18. use Doctrine\Common\Collections\ArrayCollection;
  19. use Doctrine\Common\Collections\Collection;
  20. use Doctrine\DBAL\Types\Types;
  21. use Doctrine\ORM\Mapping as ORM;
  22. use Doctrine\ORM\Mapping\OrderBy;
  23. use Symfony\Component\HttpFoundation\Request;
  24. use Symfony\Component\Serializer\Annotation\Groups;
  26. #[ORM\Entity(repositoryClass: StudioRepository::class)]
  27. #[ApiFilter(PropertyFilter::class)]
  28. #[ApiResource(
  29.     shortName: 'Studio',
  30.     description: 'Studio API',
  31.     operations: [
  32.         new Get(uriTemplate: '/studio/{id}'),
  33.        // new POST(uriTemplate: '/studio/{id}',security: "is_granted('ROLE_OAUTH2_BASIC')"),
  34.         new GetCollection(uriTemplate: '/studio', paginationEnabled: false),
  35.         new Patch(uriTemplate: '/studio/{id}',security: "is_granted('ROLE_OAUTH2_BASIC')"),
  36.     ],
  37.     //,security: "is_granted('ROLE_OAUTH2_BASIC')"
  38.     formats: [
  39.         'jsonld',
  40.         'json',
  41.         'jsonhal',
  42.         'csv' => 'text/csv',
  43.     ],
  44.     normalizationContext: [
  45.         'groups' => ['studio:read'],
  46.     ],
  47.     denormalizationContext: [
  48.         'groups' => ['studio:write'],
  49.     ],
  50.     // paginationItemsPerPage: 10,
  51. ),
  52.     ApiFilter(
  53.         OrderFilter::class,
  54.         properties: [
  55.             'position',
  56.             'createdAt'
  57.         ],
  58.     ),
  59.     ApiFilter(
  60.         ExistsFilter::class,
  61.         properties: [
  62.             'siteSeo',
  63.         ],
  64.     ),
  66. ]
  67. class Studio
  68. {
  69.     #[ORM\Id]
  70.     #[ORM\GeneratedValue]
  71.     #[ORM\Column]
  72.     #[Groups(['studio:read','news:read','seo:read'])]
  73.     #[ApiFilter(SearchFilter::class, strategy: 'exact')]
  74.     private ?int $id = null;
  76.     #[ORM\Column(length: 64)]
  77.     #[Groups(['studio:read','news:read','seo:read'])]
  78.     #[ApiFilter(SearchFilter::class, strategy: 'exact')]
  79.     private ?string $bezeichnung = null;
  81.     #[ORM\Column(length: 64)]
  82.     #[Groups(['studio:read','news:read', 'seo:read'])]
  83.     #[ApiFilter(SearchFilter::class, strategy: 'exact')]
  84.     private ?string $slug = null;
  86.     #[ORM\Column(type: Types::SMALLINT)]
  87.     #[Groups(['studio:read','news:read'])]
  88.     #[ApiFilter(SearchFilter::class, strategy: 'exact')]
  89.     private ?int $inPlanung = null;
  92.     #[ORM\Column(type: Types::SMALLINT, nullable: true)]
  93.     #[ApiFilter(SearchFilter::class, strategy: 'exact')]
  94.     #[Groups(['studio:read','news:read'])]
  95.     private ?int $geschlossen = null;
  97.     #[ORM\ManyToOne(inversedBy: 'studio')]
  98.     #[ORM\JoinColumn(nullable: true)]
  99.     //  #[ORM\JoinColumn(name: 'id',referencedColumnName: 'franchise_nehmer_id', nullable: true)]
  100.     protected ?FranchiseNehmer $franchiseNehmer;
  102.     #[ORM\OneToOne(inversedBy: "studio", targetEntity: GeoData::class, cascade: ["persist", "remove"])]
  103.     #[ORM\JoinColumn(name: "geodaten", nullable: true)]
  104.     #[Groups(['studio:read'])]
  105.     protected ?GeoData $geodaten;
  107.     #[ORM\OneToOne(inversedBy: "studio", targetEntity: StudioContent::class, cascade: ["persist", "remove"])]
  108.     #[ORM\JoinColumn(name: "studioContent", nullable: true)]
  109.     #[ApiFilter(SearchFilter::class, strategy: 'exact')]
  110.     #[Groups(['studio:read'])]
  111.     protected ?StudioContent $studioContent;
  113.     #[ORM\OneToOne(inversedBy: "studio", targetEntity: StudioZeiten::class, cascade: ["persist", "remove"])]
  114.     #[ORM\JoinColumn(name: "zeiten", nullable: true)]
  115.     protected ?StudioZeiten $zeiten;
  117.     #[ORM\OneToOne(inversedBy: "studio", targetEntity: SaunaZeiten::class, cascade: ["persist", "remove"])]
  118.     #[ORM\JoinColumn(name: "saunaZeiten", nullable: true)]
  119.     protected ?SaunaZeiten $saunazeiten;
  121.     #[ORM\OneToOne(inversedBy: "studio", targetEntity: AccessZeiten::class, cascade: ["persist", "remove"])]
  122.     #[ORM\JoinColumn(name: "accessZeiten", nullable: true)]
  123.     protected ?AccessZeiten $accesszeiten;
  125.     #[ORM\OneToOne(inversedBy: "studio", targetEntity: SupportZeiten::class, cascade: ["persist", "remove"])]
  126.     #[ORM\JoinColumn(name: "supportZeiten", nullable: true)]
  127.     protected ?SupportZeiten $supportZeiten;
  129.     #[ORM\OneToOne(inversedBy: "studio", targetEntity: OpeningTimes::class, cascade: ["persist", "remove"])]
  130.     #[ORM\JoinColumn(name: "openingTimes", nullable: true)]
  131.     protected ?OpeningTimes $openingTimes;
  133.     #[ORM\OneToOne(inversedBy: "studio", targetEntity: SiteSeo::class, cascade: ["persist", "remove"])]
  134.     #[ORM\JoinColumn(name: "siteSeo", nullable: true)]
  135.     #[Groups(['seo:read', 'seo:write','studio:write'])]
  136.     protected ?SiteSeo $siteSeo;
  138.     #[ORM\OneToOne(inversedBy: "studio", targetEntity: StudioKurse::class, cascade: ["persist", "remove"])]
  139.     #[ORM\JoinColumn(name: "studioKurse", nullable: true)]
  140.     //#[Groups(['studio:read'])]
  141.     protected ?StudioKurse $studioKurse;
  143.     // #[ORM\OneToMany(mappedBy: 'studio', targetEntity: Mediathek::class, cascade: ["persist"], orphanRemoval: true)]
  144.     //#[Groups(['studio:read'])]
  145.     // public Collection $mediathek;
  148.     #[ORM\OneToMany(mappedBy: 'studio', targetEntity: StudioVideo::class, cascade: ["persist"], orphanRemoval: true)]
  149.     #[Groups(['studio:read'])]
  150.     public Collection $studioVideo;
  152.     #[ORM\OneToMany(mappedBy: 'studio', targetEntity: StudioMedia::class, cascade: ["persist"], orphanRemoval: true)]
  153.     #[Groups(['studio:read', 'seo:read'])]
  154.     #[OrderBy(['position' => 'ASC'])]
  155.     protected Collection $studioMedia;
  157.     #[Groups(['studio:read'])]
  158.     #[ApiFilter(SearchFilter::class, strategy: 'exact')]
  159.     #[ORM\OneToMany(mappedBy: 'studio', targetEntity: News::class, cascade: ["persist"], orphanRemoval: true)]
  160.     protected Collection $news;
  162.     #[ORM\Column]
  163.     private ?DateTimeImmutable $createdAt = null;
  165.     #[ORM\Column(length: 128, nullable: true)]
  166.     #[Groups(['studio:read'])]
  167.     private ?string $website = null;
  169.     #[ORM\Column(length: 32, nullable: true)]
  170.     #[Groups(['studio:read'])]
  171.     private ?string $telefon = null;
  173.     #[ORM\Column(length: 32, nullable: true)]
  174.     #[Groups(['studio:read'])]
  175.     private ?string $mobil = null;
  177.     #[ORM\Column(length: 32, nullable: true)]
  178.     #[Groups(['studio:read'])]
  179.     private ?string $fax = null;
  181.     #[ORM\Column(length: 8, nullable: true)]
  182.     #[Groups(['studio:read'])]
  183.     private ?string $plz = null;
  185.     #[ORM\Column(length: 64, nullable: true)]
  186.     #[Groups(['studio:read'])]
  187.     private ?string $ort = null;
  189.     #[ORM\Column(length: 128, nullable: true)]
  190.     #[Groups(['studio:read'])]
  191.     private ?string $strasse = null;
  193.     #[ORM\Column(length: 64, nullable: true)]
  194.     #[Groups(['studio:read'])]
  195.     private ?string $email = null;
  197.     #[ORM\Column(nullable: true, options: ['default' => 0])]
  198.     #[Groups(['studio:read'])]
  199.     private ?int $position = null;
  201.     #[ORM\Column(nullable: true)]
  202.     private array $leistungen = [];
  204.     public function __construct(
  205.     )
  206.     {
  207.         $this->createdAt = new DateTimeImmutable();
  208.         $this->studioVideo = new ArrayCollection();
  209.         $this->studioMedia = new ArrayCollection();
  210.         $this->leistungen = [];
  211.         $this->position = 0;
  212.         $this->news = new ArrayCollection();
  213.         $this->siteSeo = NULL;
  215.     }
  217.     public function getId(): ?int
  218.     {
  219.         return $this->id;
  220.     }
  222.     public function getBezeichnung(): ?string
  223.     {
  224.         return $this->bezeichnung;
  225.     }
  227.     public function setBezeichnung(string $bezeichnung): self
  228.     {
  229.         $this->bezeichnung = $bezeichnung;
  231.         return $this;
  232.     }
  234.     public function getSlug(): ?string
  235.     {
  236.         return $this->slug;
  237.     }
  239.     public function setSlug(string $slug): self
  240.     {
  241.         $this->slug = $slug;
  243.         return $this;
  244.     }
  246.     public function getInPlanung(): ?int
  247.     {
  248.         return $this->inPlanung;
  249.     }
  251.     public function setInPlanung(int $inPlanung): self
  252.     {
  253.         $this->inPlanung = $inPlanung;
  255.         return $this;
  256.     }
  258.     public function getGeschlossen(): ?int
  259.     {
  260.         return $this->geschlossen;
  261.     }
  263.     public function setGeschlossen(int $geschlossen): self
  264.     {
  265.         $this->geschlossen = $geschlossen;
  267.         return $this;
  268.     }
  270.     public function getCreatedAt(): ?DateTimeImmutable
  271.     {
  272.         return $this->createdAt;
  273.     }
  275.     public function setCreatedAt(DateTimeImmutable $createdAt): self
  276.     {
  277.         $this->createdAt = $createdAt;
  279.         return $this;
  280.     }
  282.     #[Groups(['seo:read', 'studio:read'])]
  283.     public function getOrderCreatedAt(): ?DateTimeImmutable
  284.     {
  285.         return $this->createdAt;
  286.     }
  288.     public function getFranchiseNehmer(): ?FranchiseNehmer
  289.     {
  290.         return $this->franchiseNehmer;
  291.     }
  293.     public function setFranchiseNehmer(?FranchiseNehmer $franchiseNehmer): self
  294.     {
  295.         $this->franchiseNehmer = $franchiseNehmer;
  297.         return $this;
  298.     }
  300.     public function getWebsite(): ?string
  301.     {
  302.         return $this->website;
  303.     }
  305.     public function setWebsite(?string $website): self
  306.     {
  307.         $this->website = $website;
  309.         return $this;
  310.     }
  312.     public function getTelefon(): ?string
  313.     {
  314.         return $this->telefon;
  315.     }
  317.     public function setTelefon(?string $telefon): self
  318.     {
  319.         $this->telefon = $telefon;
  321.         return $this;
  322.     }
  324.     public function getMobil(): ?string
  325.     {
  326.         return $this->mobil;
  327.     }
  329.     public function setMobil(?string $mobil): self
  330.     {
  331.         $this->mobil = $mobil;
  333.         return $this;
  334.     }
  336.     public function getFax(): ?string
  337.     {
  338.         return $this->fax;
  339.     }
  341.     public function setFax(?string $fax): self
  342.     {
  343.         $this->fax = $fax;
  345.         return $this;
  346.     }
  348.     public function getPlz(): ?string
  349.     {
  350.         return $this->plz;
  351.     }
  353.     public function setPlz(?string $plz): self
  354.     {
  355.         $this->plz = $plz;
  357.         return $this;
  358.     }
  360.     public function getOrt(): ?string
  361.     {
  362.         return $this->ort;
  363.     }
  365.     public function setOrt(?string $ort): self
  366.     {
  367.         $this->ort = $ort;
  369.         return $this;
  370.     }
  372.     public function getStrasse(): ?string
  373.     {
  374.         return $this->strasse;
  375.     }
  377.     public function setStrasse(?string $strasse): self
  378.     {
  379.         $this->strasse = $strasse;
  381.         return $this;
  382.     }
  384.     public function getEmail(): ?string
  385.     {
  386.         return $this->email;
  387.     }
  389.     public function setEmail(?string $email): self
  390.     {
  391.         $this->email = $email;
  393.         return $this;
  394.     }
  396.     public function getGeodaten(): ?GeoData
  397.     {
  398.         return $this->geodaten;
  399.     }
  401.     public function setGeodaten(?GeoData $geodaten): self
  402.     {
  403.         $this->geodaten = $geodaten;
  405.         return $this;
  406.     }
  409.     public function getZeiten(): ?StudioZeiten
  410.     {
  411.         return $this->zeiten;
  412.     }
  414.     public function setZeiten(?StudioZeiten $zeiten): self
  415.     {
  416.         $this->zeiten = $zeiten;
  418.         return $this;
  419.     }
  421.     #[Groups(['studio:read'])]
  422.     public function getSaunaZeiten(): ?SaunaZeiten
  423.     {
  424.         return $this->saunazeiten;
  425.     }
  427.     public function setSaunaZeiten(?SaunaZeiten $saunazeiten): self
  428.     {
  429.         $this->saunazeiten = $saunazeiten;
  431.         return $this;
  432.     }
  434.     #[Groups(['studio:read'])]
  435.     public function getAccessZeiten(): ?AccessZeiten
  436.     {
  437.         return $this->accesszeiten;
  438.     }
  440.     public function setAccessZeiten(?AccessZeiten $accesszeiten): self
  441.     {
  442.         $this->accesszeiten = $accesszeiten;
  444.         return $this;
  445.     }
  447.     #[Groups(['studio:read'])]
  448.     public function getSupportZeiten(): ?SupportZeiten
  449.     {
  450.         return $this->supportZeiten;
  451.     }
  453.     public function setSupportZeiten(?SupportZeiten $supportZeiten): self
  454.     {
  455.         $this->supportZeiten = $supportZeiten;
  457.         return $this;
  458.     }
  460.     #[Groups(['studio:read'])]
  461.     public function getOpeningTimes(): ?OpeningTimes
  462.     {
  463.         return $this->openingTimes;
  464.     }
  466.     public function setOpeningTimes(?OpeningTimes $openingTimes): self
  467.     {
  468.         $this->openingTimes = $openingTimes;
  470.         return $this;
  471.     }
  473.     #[Groups(['studio:read'])]
  474.     public function getSiteSeo(): ?SiteSeo
  475.     {
  476.         return $this->siteSeo;
  477.     }
  479.     public function setSiteSeo(?SiteSeo $siteSeo): self
  480.     {
  481.         $this->siteSeo = $siteSeo;
  483.         return $this;
  484.     }
  486.     /**
  487.      * @return Collection<int, StudioVideo>
  488.      */
  489.     public function getStudioVideo(): Collection
  490.     {
  491.         return $this->studioVideo;
  492.     }
  494.     public function addStudioVideo(StudioVideo $studioVideo): self
  495.     {
  496.         if (!$this->studioVideo->contains($studioVideo)) {
  497.             $this->studioVideo->add($studioVideo);
  498.             $studioVideo->setStudio($this);
  499.         }
  501.         return $this;
  502.     }
  505.     public function removeStudioVideo(StudioVideo $studioVideo): self
  506.     {
  507.         if ($this->studioVideo->removeElement($studioVideo)) {
  508.             // set the owning side to null (unless already changed)
  509.             if ($studioVideo->getStudio() === $this) {
  510.                 $studioVideo->setStudio(null);
  511.             }
  512.         }
  514.         return $this;
  515.     }
  517.     /**
  518.      * @return Collection<int, StudioMedia>
  519.      */
  520.     public function getStudioMedia(): Collection
  521.     {
  522.         return $this->studioMedia;
  523.     }
  525.     public function addStudioMedium(StudioMedia $studioMedium): self
  526.     {
  527.         if (!$this->studioMedia->contains($studioMedium)) {
  528.             $this->studioMedia->add($studioMedium);
  529.             $studioMedium->setStudio($this);
  530.         }
  532.         return $this;
  533.     }
  535.     public function removeStudioMedium(StudioMedia $studioMedium): self
  536.     {
  537.         if ($this->studioMedia->removeElement($studioMedium)) {
  538.             // set the owning side to null (unless already changed)
  539.             if ($studioMedium->getStudio() === $this) {
  540.                 $studioMedium->setStudio(null);
  541.             }
  542.         }
  544.         return $this;
  545.     }
  547.     public function getPosition(): ?int
  548.     {
  549.         return $this->position;
  550.     }
  552.     public function setPosition(?int $position): self
  553.     {
  554.         $this->position = $position;
  556.         return $this;
  557.     }
  559.     // #[Groups(['studio:read'])]
  560.     public function getLogo(): ?array
  561.     {
  562.         $data = [];
  563.         $request = Request::createFromGlobals();
  564.         $selfUrl = $request->getSchemeAndHttpHost();
  565.         foreach ($this->studioMedia as $tmp) {
  566.             if ($tmp->getHandle() == 'studio-logo') {
  567.                 if ($tmp->getType() == 'image') {
  568.                     $full = '/uploads/full/';
  569.                     $large = '/uploads/large/';
  570.                     $medium = '/uploads/medium/';
  571.                     $thumb = '/uploads/thumb/';
  572.                 } else {
  573.                     $full = '/uploads/data/';
  574.                     $large = '/uploads/data/';
  575.                     $medium = '/uploads/data/';
  576.                     $thumb = '/uploads/data/';
  577.                 }
  578.                 $data = [
  579.                     'id' => $tmp->getId(),
  580.                     'filename' => $tmp->getFilename(),
  581.                     'original' => $tmp->getOriginal(),
  582.                     'title' => $tmp->getTitle(),
  583.                     'alt' => $tmp->getAlt(),
  584.                     'description' => $tmp->getDescription(),
  585.                     'custom' => $tmp->getCustom(),
  586.                     'self_url' => $selfUrl,
  587.                     'size' => $tmp->getSize(),
  588.                     'mimeType' => $tmp->getMimeType(),
  589.                     'variant' => [
  590.                         'full' => $full,
  591.                         'large' => $large,
  592.                         'medium' => $medium,
  593.                         'thumb' => $thumb
  594.                     ],
  595.                 ];
  596.             }
  597.         }
  598.         return [$data];
  599.     }
  601.     // #[Groups(['studio:read'])]
  602.     public function getTitleImage(): ?array
  603.     {
  604.         $data = [];
  605.         $request = Request::createFromGlobals();
  606.         $selfUrl = $request->getSchemeAndHttpHost();
  607.         foreach ($this->studioMedia as $tmp) {
  608.             if ($tmp->getHandle() == 'studio-titel') {
  609.                 if ($tmp->getType() == 'image') {
  610.                     $full = '/uploads/full/';
  611.                     $large = '/uploads/large/';
  612.                     $medium = '/uploads/medium/';
  613.                     $thumb = '/uploads/thumb/';
  614.                 } else {
  615.                     $full = '/uploads/data/';
  616.                     $large = '/uploads/data/';
  617.                     $medium = '/uploads/data/';
  618.                     $thumb = '/uploads/data/';
  619.                 }
  620.                 $data = [
  621.                     'id' => $tmp->getId(),
  622.                     'filename' => $tmp->getFilename(),
  623.                     'original' => $tmp->getOriginal(),
  624.                     'title' => $tmp->getTitle(),
  625.                     'alt' => $tmp->getAlt(),
  626.                     'description' => $tmp->getDescription(),
  627.                     'custom' => $tmp->getCustom(),
  628.                     'self_url' => $selfUrl,
  629.                     'size' => $tmp->getSize(),
  630.                     'mimeType' => $tmp->getMimeType(),
  631.                     'variant' => [
  632.                         'full' => $full,
  633.                         'large' => $large,
  634.                         'medium' => $medium,
  635.                         'thumb' => $thumb
  636.                     ],
  637.                 ];
  639.             }
  640.         }
  641.         return [$data];
  642.     }
  644.     // #[Groups(['studio:read'])]
  645.     public function getGalerie(): ?array
  646.     {
  647.         $a = [];
  648.         $request = Request::createFromGlobals();
  649.         $selfUrl = $request->getSchemeAndHttpHost();
  650.         foreach ($this->studioMedia as $tmp) {
  651.             if ($tmp->getHandle() == 'studio-galerie') {
  652.                 if ($tmp->getType() == 'image') {
  653.                     $full = '/uploads/full/';
  654.                     $large = '/uploads/large/';
  655.                     $medium = '/uploads/medium/';
  656.                     $thumb = '/uploads/thumb/';
  657.                 } else {
  658.                     $full = '/uploads/data/';
  659.                     $large = '/uploads/data/';
  660.                     $medium = '/uploads/data/';
  661.                     $thumb = '/uploads/data/';
  662.                 }
  663.                 $i = [
  664.                     'id' => $tmp->getId(),
  665.                     'filename' => $tmp->getFilename(),
  666.                     'original' => $tmp->getOriginal(),
  667.                     'title' => $tmp->getTitle(),
  668.                     'alt' => $tmp->getAlt(),
  669.                     'description' => $tmp->getDescription(),
  670.                     'custom' => $tmp->getCustom(),
  671.                     'self_url' => $selfUrl,
  672.                     'size' => $tmp->getSize(),
  673.                     'mimeType' => $tmp->getMimeType(),
  674.                     'variant' => [
  675.                         'full' => $full,
  676.                         'large' => $large,
  677.                         'medium' => $medium,
  678.                         'thumb' => $thumb
  679.                     ],
  680.                 ];
  681.                 $a[] = $i;
  682.             }
  683.         }
  684.         return [$a];
  685.     }
  687.     //  #[Groups(['studio:read'])]
  688.     public function getVideo(): ?array
  689.     {
  690.         $map = $this->studioVideo;
  691.         $t = [];
  692.         foreach ($map as $tmp) {
  693.             $item = [
  694.                 'filename' => $tmp->getFilename(),
  695.                 'cover' => $tmp->getCoverImg(),
  696.                 'mime_type' => $tmp->getMimeType(),
  697.                 'size' => $tmp->getFileSizeConvert()
  698.             ];
  699.             $t[] = $item;
  700.         }
  702.         return [$t];
  703.     }
  705.     //  #[Groups(['studio:read'])]
  706.     public function getStudioZeiten(): ?array
  707.     {
  708.         if ($this->zeiten) {
  709.             $montag = $this->zeiten->getMontag();
  710.             $montag = json_decode($montag['data'], true);
  711.             $montag['closed'] ? $montagZeiten = [] : $montagZeiten = $montag['zeiten'];
  713.             $dienstag = $this->zeiten->getDienstag();
  714.             $dienstag = json_decode($dienstag['data'], true);
  715.             $dienstag['closed'] ? $dienstagZeiten = [] : $dienstagZeiten = $dienstag['zeiten'];
  717.             $mittwoch = $this->zeiten->getMittwoch();
  718.             $mittwoch = json_decode($mittwoch['data'], true);
  719.             $mittwoch['closed'] ? $mittwochZeiten = [] : $mittwochZeiten = $mittwoch['zeiten'];
  721.             $donnerstag = $this->zeiten->getDonnerstag();
  722.             $donnerstag = json_decode($donnerstag['data'], true);
  723.             $donnerstag['closed'] ? $donnerstagZeiten = [] : $donnerstagZeiten = $donnerstag['zeiten'];
  725.             $freitag = $this->zeiten->getFreitag();
  726.             $freitag = json_decode($freitag['data'], true);
  727.             $freitag['closed'] ? $freitagZeiten = [] : $freitagZeiten = $freitag['zeiten'];
  729.             $samstag = $this->zeiten->getSamstag();
  730.             $samstag = json_decode($samstag['data'], true);
  731.             $samstag['closed'] ? $samstagZeiten = [] : $samstagZeiten = $samstag['zeiten'];
  733.             $sonntag = $this->zeiten->getSonntag();
  734.             $sonntag = json_decode($sonntag['data'], true);
  735.             $sonntag['closed'] ? $sonntagZeiten = [] : $sonntagZeiten = $sonntag['zeiten'];
  737.             return [
  738.                 'open247' => $this->zeiten->isOpen247(),
  739.                 'extraInfo' => $this->zeiten->getInfo(),
  740.                 'montag' => [
  741.                     'bezeichnung' => $montag['bezeichnung'],
  742.                     'closed' => $montag['closed'],
  743.                     'zeiten' => $montagZeiten
  744.                 ],
  745.                 'dienstag' => [
  746.                     'bezeichnung' => $dienstag['bezeichnung'],
  747.                     'closed' => $dienstag['closed'],
  748.                     'zeiten' => $dienstagZeiten
  749.                 ],
  750.                 'mittwoch' => [
  751.                     'bezeichnung' => $mittwoch['bezeichnung'],
  752.                     'closed' => $mittwoch['closed'],
  753.                     'zeiten' => $mittwochZeiten
  754.                 ],
  755.                 'donnerstag' => [
  756.                     'bezeichnung' => $donnerstag['bezeichnung'],
  757.                     'closed' => $donnerstag['closed'],
  758.                     'zeiten' => $donnerstagZeiten
  759.                 ],
  760.                 'freitag' => [
  761.                     'bezeichnung' => $freitag['bezeichnung'],
  762.                     'closed' => $freitag['closed'],
  763.                     'zeiten' => $freitagZeiten
  764.                 ],
  765.                 'samstag' => [
  766.                     'bezeichnung' => $samstag['bezeichnung'],
  767.                     'closed' => $samstag['closed'],
  768.                     'zeiten' => $samstagZeiten
  769.                 ],
  770.                 'sonntag' => [
  771.                     'bezeichnung' => $sonntag['bezeichnung'],
  772.                     'closed' => $sonntag['closed'],
  773.                     'zeiten' => $sonntagZeiten
  774.                 ],
  776.             ];
  777.         }
  778.         return [];
  779.     }
  781.     // #[Groups(['studio:read'])]
  782.     public function getStudioGeo(): array
  783.     {
  784.         if ($this->geodaten) {
  785.             $geoJson = $this->geodaten->getGeoJson();
  786.             if ($geoJson) {
  787.                 $geoJson = json_decode($geoJson['data'], true);
  788.             }
  790.             $boundingBox = $this->geodaten->getBoundingBox();
  791.             if ($boundingBox) {
  792.                 $boundingBox = json_decode($boundingBox['data'], true);
  793.             }
  795.             return [
  796.                 'id' => $this->geodaten->getId(),
  797.                 'osm_id' => $this->geodaten->getOsmId(),
  798.                 'place_id' => $this->geodaten->getPlaceId(),
  799.                 'display_name' => $this->geodaten->getDisplayName(),
  800.                 'importance' => $this->geodaten->getImportance(),
  801.                 'lon' => $this->geodaten->getGeoLon(),
  802.                 'lat' => $this->geodaten->getGeoLat(),
  803.                 'polygon' => $geoJson,
  804.                 'bounding_box' => $boundingBox,
  805.             ];
  806.         }
  808.         return [];
  809.     }
  811.     /**
  812.      * @return Collection<int, News>
  813.      */
  815.     public function getNews(): Collection
  816.     {
  817.         return $this->news;
  818.     }
  820.     public function addNews(News $news): self
  821.     {
  822.         if (!$this->news->contains($news)) {
  823.             $this->news->add($news);
  824.             $news->setStudio($this);
  825.         }
  827.         return $this;
  828.     }
  830.     public function removeNews(News $news): self
  831.     {
  832.         if ($this->news->removeElement($news)) {
  833.             // set the owning side to null (unless already changed)
  834.             if ($news->getStudio() === $this) {
  835.                 $news->setStudio(null);
  836.             }
  837.         }
  839.         return $this;
  840.     }
  842.     public function setStudioContent(?StudioContent $studioContent): self
  843.     {
  844.         $this->studioContent = $studioContent;
  846.         return $this;
  847.     }
  849.     public function getStudioContent(): ?StudioContent
  850.     {
  851.         return $this->studioContent;
  852.     }
  854.    // #[Groups(['studio:read','content:read'])]
  855.     public function getStudioImpressum(): string
  856.     {
  857.         $impressum = $this->studioContent;
  858.         $impressum->getImpressum();
  859.         return $impressum->getImpressum();
  860.     }
  862.     public function getStudioKurse(): ?StudioKurse
  863.     {
  865.         return $this->studioKurse;
  866.     }
  868.     public function setStudioKurse(?StudioKurse $studioKurse): self
  869.     {
  870.         $this->studioKurse = $studioKurse;
  872.         return $this;
  873.     }
  875.     public function getLeistungen(): array
  876.     {
  877.         return $this->leistungen;
  878.     }
  880.     public function setLeistungen(?array $leistungen): self
  881.     {
  882.         $this->leistungen = $leistungen;
  884.         return $this;
  885.     }
  887.     #[Groups(['studio:read'])]
  888.     public function getStudioLeistungen(): array
  889.     {
  890.         $request = Request::createFromGlobals();
  891.         $selfUrl = $request->getSchemeAndHttpHost();
  892.         $leistungArr = [];
  893.         if ($this->getLeistungen()) {
  894.             $leistungen = json_decode($this->leistungen['data'], true);
  895.             $id = '';
  896.             $title = '';
  897.             $description =  '';
  898.             $color =  '';
  899.             $position = '';
  900.             foreach ($leistungen as $tmp) {
  901.                 if(isset($tmp['category'])){
  902.                     $id = $tmp['category']['id'];
  903.                     $title = $tmp['category']['title'];
  904.                     $description = $tmp['category']['description'];
  905.                     $color = $tmp['category']['color'];
  906.                     $position = $tmp['category']['position'];
  907.                 }
  908.                 $item = [
  909.                     'id' => $tmp['id'],
  910.                     'url' => '/api/leistung/' . $tmp['id'],
  911.                     'title' => $tmp['title'] ?? '',
  912.                     'description' => $tmp['description'] ?? '',
  913.                     'preis' => $tmp['preis'] ?? '',
  914.                     'position' => $tmp['position'] ?? '',
  915.                     'inklusiv' => $tmp['inklusiv'] ?? '',
  916.                     'sonstiges' => $tmp['sonstiges'] ?? '',
  917.                     'icon_img' => $tmp['icon_img'] ?? '',
  918.                     'icon_img_type' => $tmp['icon_img_type'] ?? '',
  919.                     'leistung_img' => $tmp['leistung_img'] ?? '',
  920.                     'leistung_img_type' => $tmp['leistung_img_type'] ?? '',
  921.                     'category' => [
  922.                         'id' => $id,
  923.                         'title' => $title,
  924.                         'description' => $description,
  925.                         'color' => $color,
  926.                         'position' => $position,
  927.                     ],
  928.                 ];
  929.                 $leistungArr[] = $item;
  930.             }
  931.         }
  932.         return [
  933.             'self' => $selfUrl,
  934.             'data' => $leistungArr
  935.         ];
  936.     }
  939.     #[Groups(['studio:read'])]
  940.     public function getKurse(): ?array
  941.     {
  942.         if ($this->studioKurse) {
  943.             $montag = json_decode($this->studioKurse->getMontag()['data'], true) ?? [];
  944.             $dienstag = json_decode($this->studioKurse->getDienstag()['data'], true) ?? [];
  945.             $mittwoch = json_decode($this->studioKurse->getMittwoch()['data'], true) ?? [];
  946.             $donnerstag = json_decode($this->studioKurse->getDonnerstag()['data'], true) ?? [];
  947.             $freitag = json_decode($this->studioKurse->getFreitag()['data'], true) ?? [];
  948.             $samstag = json_decode($this->studioKurse->getSamstag()['data'], true) ?? [];
  949.             $sonntag = json_decode($this->studioKurse->getSonntag()['data'], true) ?? [];
  950.             return [
  951.                 'montag' => $montag,
  952.                 'dienstag' => $dienstag,
  953.                 'mittwoch' => $mittwoch,
  954.                 'donnerstag' => $donnerstag,
  955.                 'freitag' => $freitag,
  956.                 'samstag' => $samstag,
  957.                 'sonntag' => $sonntag
  958.             ];
  959.         }
  961.         return [];
  962.     }
  963. }