DERHANSEN\SfEventMgt\Service\Notification\AttachmentService

Complexity

Total Complexity

27

Size/Duplication

Total Lines	194
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getAttachments()	0	35	3
A	__construct()	0	2	1
A	getSettingsPath()	0	19	5
A	getFileAttachments()	0	10	5
A	getObjectAttachments()	0	12	4
A	getAttachmentsFromProperty()	0	22	6
A	getICalAttachment()	0	27	3

<?php

declare(strict_types=1);

/*
 * This file is part of the Extension "sf_event_mgt" for TYPO3 CMS.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 */

namespace DERHANSEN\SfEventMgt\Service\Notification;

use DERHANSEN\SfEventMgt\Domain\Model\Dto\CustomNotification;
use DERHANSEN\SfEventMgt\Domain\Model\Registration;
use DERHANSEN\SfEventMgt\Service\ICalendarService;
use DERHANSEN\SfEventMgt\Utility\MessageType;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Extbase\Domain\Model\FileReference;

The type TYPO3\CMS\Extbase\Domain\Model\FileReference was not found. Maybe you did not declare it correctly or list all dependencies?

use TYPO3\CMS\Extbase\DomainObject\AbstractEntity;

The type TYPO3\CMS\Extbase\DomainObject\AbstractEntity was not found. Maybe you did not declare it correctly or list all dependencies?

use TYPO3\CMS\Extbase\Mvc\RequestInterface;

The type TYPO3\CMS\Extbase\Mvc\RequestInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use TYPO3\CMS\Extbase\Persistence\ObjectStorage;

The type TYPO3\CMS\Extbase\Persistence\ObjectStorage was not found. Maybe you did not declare it correctly or list all dependencies?

class AttachmentService
{
    public function __construct(protected readonly ICalendarService $iCalendarService)
    {
    }

    /**
     * Returns an array of absolute filenames to attach to notifications
     *
     * Attachments must be configured as following (example for "registrationNew"):
     *
     * registrationNew {
     *   attachments {
     *     user {
     *       fromFiles {
     *         1 = fileadmin/path-to-attachment.pdf
     *       }
     *       fromEventProperty {
     *         1 = files
     *         2 = image
     *       }
     *       fromRegistrationProperty {
     *         1 = propertyOfRegistration
     *       }
     *     }
     *     admin {
     *       fromFiles {}
     *       fromEventProperty {}
     *       fromRegistrationProperty {}
     *     }
     *   }
     * }
     */
    public function getAttachments(
        array $settings,
        Registration $registration,
        int $messageType,
        string $messageRecipient,
        ?CustomNotification $customNotification = null
    ): array {
        $attachments = [];
        $settingPath = $this->getSettingsPath($messageType);
        $attachmentSettings = $settings['notification'][$settingPath]['attachments'][$messageRecipient] ?? [];

        if ($customNotification) {
            $attachmentSettings = $settings['notification']['customNotifications'][$customNotification->getTemplate()]['attachments'][$messageRecipient] ?? [];
        }

        if (!empty($attachmentSettings)) {
            // Attachments globally from TypoScript
            $attachments = $this->getFileAttachments($attachmentSettings);

            // Attachments from Event properties
            $eventAttachments = $this->getObjectAttachments(
                $attachmentSettings['fromEventProperty'] ?? [],
                $registration->getEvent()

It seems like $registration->getEvent() can also be of type null; however, parameter $object of DERHANSEN\SfEventMgt\Service\Notification\AttachmentService::getObjectAttachments() does only seem to accept TYPO3\CMS\Extbase\DomainObject\AbstractEntity, maybe add an additional type check?

            );
            $attachments = array_merge($attachments, $eventAttachments);

            // Attachments from Registration properties
            $registrationAttachments = $this->getObjectAttachments(
                $attachmentSettings['fromRegistrationProperty'] ?? [],
                $registration
            );
            $attachments = array_merge($attachments, $registrationAttachments);
        }

        return $attachments;
    }

    /**
     * Returns the absolute filename for to an iCal File of the event, if the iCalFile setting is set for
     * the given messageType
     *
     * Example:
     *
     *  registrationNew {
     *    attachments {
     *      user {
     *        iCalFile = 1
     *      }
     *   }
     * }
     */
    public function getICalAttachment(
        RequestInterface $request,
        array $settings,
        Registration $registration,
        int $messageType,
        string $messageRecipient,
        ?CustomNotification $customNotification = null
    ): string {
        $file = '';
        $settingPath = $this->getSettingsPath($messageType);

        $attachICalFile = (bool)($settings['notification'][$settingPath]['attachments'][$messageRecipient]['iCalFile'] ?? false);

        if ($customNotification) {
            $attachICalFile = (bool)($settings['notification']['customNotifications'][$customNotification->getTemplate()]['attachments'][$messageRecipient]['iCalFile'] ?? false);
        }

        if ($attachICalFile) {
            $file = GeneralUtility::tempnam(
                'event-' . $registration->getEvent()->getUid() . '-',
                '.ics'
            );
            $content = $this->iCalendarService->getiCalendarContent($request, $registration->getEvent());

It seems like $registration->getEvent() can also be of type null; however, parameter $event of DERHANSEN\SfEventMgt\Service\ICalendarService::getiCalendarContent() does only seem to accept DERHANSEN\SfEventMgt\Domain\Model\Event, maybe add an additional type check?

            GeneralUtility::writeFile($file, $content);
        }

        return $file;
    }

    /**
     * Returns the settingspath for the given messagetype
     */
    protected function getSettingsPath(int $messageType): string
    {
        $settingPath = '';
        switch ($messageType) {
            case MessageType::REGISTRATION_NEW:
                $settingPath = 'registrationNew';
                break;
            case MessageType::REGISTRATION_WAITLIST_NEW:
                $settingPath = 'registrationWaitlistNew';
                break;
            case MessageType::REGISTRATION_CONFIRMED:
                $settingPath = 'registrationConfirmed';
                break;
            case MessageType::REGISTRATION_WAITLIST_CONFIRMED:
                $settingPath = 'registrationWaitlistConfirmed';
                break;
        }

        return $settingPath;
    }

    /**
     * Returns configured fromFiles attachments from TypoScript settings
     */
    protected function getFileAttachments(array $settings): array
    {
        $attachments = [];
        if (isset($settings['fromFiles']) && is_array($settings['fromFiles']) && count($settings['fromFiles']) > 0) {
            foreach ($settings['fromFiles'] as $file) {
                $attachments[] = GeneralUtility::getFileAbsFileName($file);
            }
        }

        return $attachments;
    }

    /**
     * Returns the attachments from an object of all configured properties
     */
    protected function getObjectAttachments(array $propertyNames, AbstractEntity $object): array
    {
        $attachments = [];
        if (count($propertyNames) > 0) {
            foreach ($propertyNames as $propertyName) {
                if ($object->_hasProperty($propertyName)) {
                    $attachments = array_merge($attachments, $this->getAttachmentsFromProperty($object, $propertyName));
                }
            }
        }

        return $attachments;
    }

    /**
     * Returns an array wih the absolute path to all FAL files in the given object-property
     */
    protected function getAttachmentsFromProperty(AbstractEntity $object, string $propertyName): array
    {
        $attachments = [];
        if ($propertyName === '') {
            return $attachments;
        }

        $property = $object->_getProperty($propertyName);

        if ($property instanceof ObjectStorage) {
            foreach ($property as $fileRefetrenceObject) {
                if ($fileRefetrenceObject instanceof FileReference) {
                    $attachments[] = $fileRefetrenceObject->getOriginalResource()->getForLocalProcessing(false);
                }
            }
        }

        if ($property instanceof FileReference) {
            $attachments[] = $property->getOriginalResource()->getForLocalProcessing(false);
        }

        return $attachments;
    }
}