events/Classes/Service/DestinationDataImportService.php

453 lines
16 KiB
PHP
Raw Normal View History

2019-08-12 07:43:37 +02:00
<?php
declare(strict_types=1);
namespace WerkraumMedia\Events\Service;
2019-08-12 07:43:37 +02:00
use Exception;
use TYPO3\CMS\Core\EventDispatcher\EventDispatcher;
use TYPO3\CMS\Core\Log\Logger;
use TYPO3\CMS\Core\Log\LogManager;
2019-08-12 07:43:37 +02:00
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Configuration\ConfigurationManager;
use TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface;
use TYPO3\CMS\Extbase\Persistence\Generic\PersistenceManager;
use WerkraumMedia\Events\Caching\CacheManager;
use WerkraumMedia\Events\Domain\Model\Event;
use WerkraumMedia\Events\Domain\Model\Import;
use WerkraumMedia\Events\Domain\Model\Organizer;
use WerkraumMedia\Events\Domain\Model\Region;
use WerkraumMedia\Events\Domain\Repository\DateRepository;
use WerkraumMedia\Events\Domain\Repository\EventRepository;
use WerkraumMedia\Events\Domain\Repository\OrganizerRepository;
use WerkraumMedia\Events\Service\DestinationDataImportService\CategoriesAssignment;
use WerkraumMedia\Events\Service\DestinationDataImportService\CategoriesAssignment\Import as CategoryImport;
use WerkraumMedia\Events\Service\DestinationDataImportService\DataFetcher;
use WerkraumMedia\Events\Service\DestinationDataImportService\DataHandler;
use WerkraumMedia\Events\Service\DestinationDataImportService\DataHandler\Assignment;
use WerkraumMedia\Events\Service\DestinationDataImportService\DatesFactory;
use WerkraumMedia\Events\Service\DestinationDataImportService\Events\CategoriesAssignEvent;
use WerkraumMedia\Events\Service\DestinationDataImportService\Events\EventImportEvent;
use WerkraumMedia\Events\Service\DestinationDataImportService\FilesAssignment;
use WerkraumMedia\Events\Service\DestinationDataImportService\LocationAssignment;
use WerkraumMedia\Events\Service\DestinationDataImportService\Slugger;
2019-08-12 07:43:37 +02:00
final class DestinationDataImportService
{
private Import $import;
private Event $tmpCurrentEvent;
2019-08-12 07:43:37 +02:00
/**
* @var Logger
2019-08-12 07:43:37 +02:00
*/
private $logger;
2019-08-12 07:43:37 +02:00
/**
* ImportService constructor.
*/
public function __construct(
private readonly EventRepository $eventRepository,
private readonly OrganizerRepository $organizerRepository,
private readonly DateRepository $dateRepository,
private readonly ConfigurationManager $configurationManager,
private readonly PersistenceManager $persistenceManager,
private readonly DataFetcher $dataFetcher,
private readonly DatesFactory $datesFactory,
private readonly FilesAssignment $filesAssignment,
private readonly CategoriesAssignment $categoriesAssignment,
private readonly LocationAssignment $locationAssignment,
private readonly Slugger $slugger,
private readonly CacheManager $cacheManager,
private readonly DataHandler $dataHandler,
private readonly EventDispatcher $eventDispatcher
2019-08-12 07:43:37 +02:00
) {
2019-08-12 15:49:52 +02:00
}
2019-08-12 07:43:37 +02:00
public function import(
Import $import
): int {
$this->import = $import;
2019-08-12 15:49:52 +02:00
// Get configuration
2019-08-12 07:43:37 +02:00
$frameworkConfiguration = $this->configurationManager->getConfiguration(
ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK
);
2019-08-12 15:49:52 +02:00
// Set storage pid
2019-08-12 07:43:37 +02:00
$persistenceConfiguration = [
'persistence' => [
'storagePid' => $this->import->getStoragePid(),
2019-08-12 07:43:37 +02:00
],
];
2019-08-12 15:49:52 +02:00
// Set Configuration
2019-08-12 07:43:37 +02:00
$this->configurationManager->setConfiguration(array_merge($frameworkConfiguration, $persistenceConfiguration));
$this->logger = GeneralUtility::makeInstance(LogManager::class)->getLogger(self::class);
2019-10-09 15:03:58 +02:00
$this->logger->info('Starting Destination Data Import Service');
2019-08-12 07:43:37 +02:00
try {
$data = $this->dataFetcher->fetchSearchResult($import);
} catch (Exception) {
2019-08-13 09:12:30 +02:00
$this->logger->error('Could not receive data.');
2019-08-12 07:43:37 +02:00
return 1;
}
return $this->processData($data);
}
public function processData(array $data): int
{
2019-10-09 15:03:58 +02:00
$this->logger->info('Processing json ' . count($data['items']));
// Get selected region
$selectedRegion = $this->import->getRegion();
2019-08-12 07:43:37 +02:00
foreach ($data['items'] as $event) {
$this->logger->info('Processing event ' . substr((string)$event['title'], 0, 20));
2019-08-12 15:49:52 +02:00
// Event already exists? If not create one!
$this->tmpCurrentEvent = $this->getOrCreateEvent($event['global_id'], $event['title']);
$existingEvent = clone $this->tmpCurrentEvent;
2020-10-01 08:34:13 +02:00
// Set language UID
$this->tmpCurrentEvent->setLanguageUid(-1);
2019-08-12 07:43:37 +02:00
// Set selected Region
2021-12-14 16:22:29 +01:00
if ($selectedRegion instanceof Region) {
$this->tmpCurrentEvent->setRegion($selectedRegion);
}
2019-08-12 07:43:37 +02:00
// Set Title
$this->tmpCurrentEvent->setTitle(substr((string)$event['title'], 0, 254));
2019-08-12 07:43:37 +02:00
// Set Highlight (Is only set in rest if true)
if ($event['highlight'] ?? false) {
2019-08-12 07:43:37 +02:00
$this->tmpCurrentEvent->setHighlight($event['highlight']);
}
2019-08-12 07:43:37 +02:00
// Set Texts
if ($event['texts'] ?? false) {
$this->setTexts($event['texts']);
}
2022-08-02 15:56:18 +02:00
$this->tmpCurrentEvent->setLocation(
$this->locationAssignment->getLocation($event)
);
2019-09-23 15:41:41 +02:00
2019-08-12 07:43:37 +02:00
// Set Organizer
if ($event['addresses'] ?? false) {
$this->setOrganizer($event['addresses']);
}
2020-10-01 09:45:32 +02:00
// Set Social
if ($event['media_objects'] ?? false) {
2020-08-19 11:30:13 +02:00
$this->setSocial($event['media_objects']);
}
2020-08-19 11:30:13 +02:00
2022-08-02 15:56:18 +02:00
if ($event['web'] ?? false) {
$this->tmpCurrentEvent->setWeb($event['web']);
}
2020-10-01 09:45:32 +02:00
// Set Tickets
if ($event['media_objects'] ?? false) {
2020-10-01 09:45:32 +02:00
$this->setTickets($event['media_objects']);
}
2020-10-01 09:45:32 +02:00
2019-08-12 07:43:37 +02:00
// Set Dates
if ($event['timeIntervals'] ?? false) {
$this->setDates(
$event['timeIntervals'],
(bool)$this->getAttributeValue($event, 'DETAILS_ABGESAGT')
);
}
2019-08-12 15:49:52 +02:00
// Set Assets
if ($event['media_objects'] ?? false) {
$this->setAssets($event['media_objects']);
}
if ($event['source'] ?? false) {
$this->setSource($event['source']);
}
$this->eventDispatcher->dispatch(new EventImportEvent(
$existingEvent,
$this->tmpCurrentEvent
));
2019-08-12 15:49:52 +02:00
// Update and persist
$this->logger->info('Persist database');
$this->eventRepository->update($this->tmpCurrentEvent);
$this->persistenceManager->persistAll();
// Apply changes via DataHandler (The new way)
$eventUid = $this->tmpCurrentEvent->getUid();
if (is_int($eventUid) === false) {
throw new Exception('Could not persist and fetch uid of event.', 1701244570);
}
$this->logger->info('Apply changes via DataHandler');
$this->dataHandler->updateEvent(
$eventUid,
[
new Assignment('keywords', implode(', ', $event['keywords'] ?? [])),
$this->getCategories($event['categories'] ?? []),
$this->getFeatures($event['features'] ?? []),
]
);
$this->logger->info('Update slugs');
$this->slugger->update('tx_events_domain_model_event');
$this->slugger->update('tx_events_domain_model_date');
2019-08-12 15:49:52 +02:00
}
2022-11-23 10:59:55 +01:00
$this->logger->info('Flushing cache');
$this->cacheManager->clearAllCacheTags();
2019-10-09 15:03:58 +02:00
$this->logger->info('Finished import');
2019-08-12 15:49:52 +02:00
return 0;
}
2019-08-12 07:43:37 +02:00
private function getCategories(array $categories): Assignment
{
$categories = $this->categoriesAssignment->getCategories(new CategoryImport(
$this->import->getCategoryParent(),
$this->import->getCategoriesPid(),
$categories
));
$event = new CategoriesAssignEvent(
$this->tmpCurrentEvent,
$categories
);
$this->eventDispatcher->dispatch($event);
return Assignment::createFromDomainObjects(
'categories',
$event->getCategories()->toArray()
);
}
private function getFeatures(array $features): Assignment
{
$features = $this->categoriesAssignment->getCategories(new CategoryImport(
$this->import->getFeaturesParent(),
$this->import->getFeaturesPid(),
$features,
true
));
return Assignment::createFromDomainObjects(
'features',
$features->toArray()
);
2019-08-13 09:12:30 +02:00
}
private function setDates(
array $timeIntervals,
bool $canceled
): void {
2019-10-09 15:03:58 +02:00
// @TODO: does not seem to work -->
2019-08-12 15:49:52 +02:00
//$currentEventDates = $this->tmpCurrentEvent->getDates();
//$this->tmpCurrentEvent->removeAllDates($currentEventDates);
// <--
// TODO: Workaround delete dates
$currentEventDates = $this->tmpCurrentEvent->getDates();
$this->logger->info('Found ' . count($currentEventDates) . ' to delete');
foreach ($currentEventDates as $currentDate) {
$this->dateRepository->remove($currentDate);
}
2019-08-12 07:43:37 +02:00
$dates = $this->datesFactory->createDates($timeIntervals, $canceled);
foreach ($dates as $date) {
$this->tmpCurrentEvent->addDate($date);
2019-08-12 15:49:52 +02:00
}
2019-10-11 15:12:07 +02:00
$this->logger->info('Finished setup dates');
2019-08-12 15:49:52 +02:00
}
2019-08-12 07:43:37 +02:00
private function setOrganizer(array $addresses): void
{
foreach ($addresses as $address) {
if ($address['rel'] == 'organizer') {
2019-08-12 15:49:52 +02:00
$tmpOrganizer = $this->organizerRepository->findOneByName($address['name']);
2019-08-13 11:17:34 +02:00
if ($tmpOrganizer) {
2019-08-12 15:49:52 +02:00
$this->tmpCurrentEvent->setOrganizer($tmpOrganizer);
2019-08-13 11:17:34 +02:00
continue;
2019-08-12 15:49:52 +02:00
}
$tmpOrganizer = GeneralUtility::makeInstance(Organizer::class);
2020-10-01 08:34:13 +02:00
$tmpOrganizer->setLanguageUid(-1);
$tmpOrganizer->setName($address['name'] ?? '');
$tmpOrganizer->setCity($address['city'] ?? '');
$tmpOrganizer->setZip($address['zip'] ?? '');
$tmpOrganizer->setStreet($address['street'] ?? '');
$tmpOrganizer->setPhone($address['phone'] ?? '');
$tmpOrganizer->setWeb($address['web'] ?? '');
$tmpOrganizer->setEmail($address['email'] ?? '');
$tmpOrganizer->setDistrict($address['district'] ?? '');
2019-08-13 11:17:34 +02:00
$this->organizerRepository->add($tmpOrganizer);
$this->tmpCurrentEvent->setOrganizer($tmpOrganizer);
2019-08-12 15:49:52 +02:00
}
}
}
2019-08-12 07:43:37 +02:00
private function setSocial(array $media): void
{
foreach ($media as $link) {
if ($link['rel'] == 'socialmedia' && $link['value'] == 'Facebook') {
2020-08-19 11:30:13 +02:00
$this->tmpCurrentEvent->setFacebook($link['url']);
}
if ($link['rel'] == 'socialmedia' && $link['value'] == 'YouTube') {
2020-08-19 11:30:13 +02:00
$this->tmpCurrentEvent->setYouTube($link['url']);
}
if ($link['rel'] == 'socialmedia' && $link['value'] == 'Instagram') {
2020-08-19 11:30:13 +02:00
$this->tmpCurrentEvent->setInstagram($link['url']);
}
2020-10-01 09:45:32 +02:00
}
}
private function setTickets(array $media): void
{
foreach ($media as $link) {
if (isset($link['rel']) === false) {
continue;
}
if ($link['rel'] === 'ticket') {
2020-10-01 09:45:32 +02:00
$this->tmpCurrentEvent->setTicket($link['url']);
return;
}
if (
$link['rel'] === 'booking'
&& !$this->hasRelation('ticket', $media)
) {
2020-08-19 11:30:13 +02:00
$this->tmpCurrentEvent->setTicket($link['url']);
return;
}
if (
$link['rel'] === 'PRICE_KARTENLINK'
&& !$this->hasRelation('ticket', $media)
&& !$this->hasRelation('booking', $media)
) {
2020-10-01 09:45:32 +02:00
$this->tmpCurrentEvent->setTicket($link['url']);
return;
2020-10-01 09:45:32 +02:00
}
}
}
private function hasRelation(string $needle, array $haystack): bool
{
foreach ($haystack as $key => $value) {
if (isset($haystack['rel']) && $haystack['rel'] === $needle) {
2020-10-01 09:45:32 +02:00
return true;
}
if (is_array($value) && $this->hasRelation($needle, $value)) {
return true;
2020-10-01 09:45:32 +02:00
}
2020-08-19 11:30:13 +02:00
}
2020-10-01 09:45:32 +02:00
return false;
2020-08-19 11:30:13 +02:00
}
private function setTexts(array $texts): void
{
foreach ($texts as $text) {
if (isset($text['value']) === false) {
continue;
}
if ($text['rel'] == 'details' && $text['type'] == 'text/plain') {
$this->tmpCurrentEvent->setDetails(str_replace("\n\n", "\n", (string)$text['value']));
2019-08-12 15:49:52 +02:00
}
if ($text['rel'] == 'teaser' && $text['type'] == 'text/plain') {
$this->tmpCurrentEvent->setTeaser(str_replace("\n\n", "\n", (string)$text['value']));
2019-08-12 15:49:52 +02:00
}
if ($text['rel'] == 'PRICE_INFO' && $text['type'] == 'text/plain') {
$this->tmpCurrentEvent->setPriceInfo(str_replace("\n\n", "\n", (string)$text['value']));
2020-03-16 14:06:03 +01:00
}
2019-08-12 15:49:52 +02:00
}
}
2019-08-12 07:43:37 +02:00
private function getOrCreateEvent(string $globalId, string $title): Event
{
2019-08-12 15:49:52 +02:00
$event = $this->eventRepository->findOneByGlobalId($globalId);
2019-08-12 07:43:37 +02:00
if ($event instanceof Event) {
$this->logger->info(
'Found "' . substr($title, 0, 20) . '..." with global id ' . $globalId . ' in database'
);
2019-08-13 11:17:34 +02:00
return $event;
2019-08-12 15:49:52 +02:00
}
2019-08-12 07:43:37 +02:00
2019-08-13 11:17:34 +02:00
// New event is created
$this->logger->info(substr($title, 0, 20) . ' does not exist');
$event = GeneralUtility::makeInstance(Event::class);
2019-08-13 11:17:34 +02:00
// Create event and persist
$event->setGlobalId($globalId);
$this->eventRepository->add($event);
$this->persistenceManager->persistAll();
$this->logger->info(
'Not found "' . substr($title, 0, 20) . '..." with global id ' . $globalId . ' in database.'
. ' Created new one.'
);
2019-08-12 15:49:52 +02:00
return $event;
}
2019-08-12 07:43:37 +02:00
private function setAssets(array $assets): void
{
$this->logger->info('Set assets');
$images = $this->filesAssignment->getImages(
$this->import,
$this->tmpCurrentEvent,
$assets
);
$this->tmpCurrentEvent->setImages($images);
2019-08-12 07:43:37 +02:00
}
private function setSource(array $source): void
{
if (isset($source['value'])) {
$this->tmpCurrentEvent->setSourceName($source['value']);
}
if (isset($source['url'])) {
$this->tmpCurrentEvent->setSourceUrl($source['url']);
}
}
/**
* Fetch the boolean value for requested attribute.
*
* Returns first if multiple attributes with same key exist.
* Casts "true" and "false" to true and false.
*/
private function getAttributeValue(
array $event,
string $attributeKey
): bool {
$attributes = array_filter($event['attributes'] ?? [], function (array $attribute) use ($attributeKey) {
$currentKey = $attribute['key'] ?? '';
return $currentKey === $attributeKey;
});
if ($attributes === []) {
return false;
}
$value = $attributes[0]['value'] ?? null;
if ($value === 'true') {
return true;
}
if ($value === 'false') {
return false;
}
return (bool)$value;
}
2019-10-09 15:03:58 +02:00
}