Skip to content

Open-source event management and ticket selling platform — perfect for concerts, conferences, and everything in between 🎟️ If you find this project helpful, please consider giving us a star ⭐️

11.5 KB
Raw Blame
<?php

namespace HiEvents\Services\Domain\Event;

use HiEvents\DomainObjects\Enums\AttendeeDetailsCollectionMethod;
use HiEvents\DomainObjects\Enums\EventType;
use HiEvents\DomainObjects\Enums\HomepageBackgroundType;
use HiEvents\DomainObjects\Enums\ImageType;
use HiEvents\DomainObjects\Enums\PaymentProviders;
use HiEvents\DomainObjects\Enums\ProductTerminology;
use HiEvents\DomainObjects\EventDomainObject;
use HiEvents\DomainObjects\EventSettingDomainObject;
use HiEvents\DomainObjects\OrganizerDomainObject;
use HiEvents\DomainObjects\OrganizerSettingDomainObject;
use HiEvents\Enterprise\BoxOffice\Repository\Interfaces\BoxOfficeRepositoryInterface;
use HiEvents\Exceptions\OrganizerNotFoundException;
use HiEvents\Helper\DateHelper;
use HiEvents\Helper\IdHelper;
use HiEvents\Helper\StringHelper;
use HiEvents\Repository\Interfaces\CheckInListRepositoryInterface;
use HiEvents\Repository\Interfaces\EventOccurrenceRepositoryInterface;
use HiEvents\Repository\Interfaces\EventRepositoryInterface;
use HiEvents\Repository\Interfaces\EventSettingsRepositoryInterface;
use HiEvents\Repository\Interfaces\EventStatisticRepositoryInterface;
use HiEvents\Repository\Interfaces\ImageRepositoryInterface;
use HiEvents\Repository\Interfaces\OrganizerRepositoryInterface;
use HiEvents\Services\Infrastructure\HtmlPurifier\HtmlPurifierService;
use Illuminate\Config\Repository;
use Illuminate\Database\DatabaseManager;
use Illuminate\Filesystem\FilesystemManager;
use Throwable;

class CreateEventService
{
    public function __construct(
        private readonly EventRepositoryInterface $eventRepository,
        private readonly EventSettingsRepositoryInterface $eventSettingsRepository,
        private readonly OrganizerRepositoryInterface $organizerRepository,
        private readonly DatabaseManager $databaseManager,
        private readonly EventStatisticRepositoryInterface $eventStatisticsRepository,
        private readonly HtmlPurifierService $purifier,
        private readonly ImageRepositoryInterface $imageRepository,
        private readonly Repository $config,
        private readonly FilesystemManager $filesystemManager,
        private readonly EventOccurrenceRepositoryInterface $occurrenceRepository,
        private readonly CheckInListRepositoryInterface $checkInListRepository,
        private readonly BoxOfficeRepositoryInterface $boxOfficeRepository,
    ) {}

    /**
     * @throws Throwable
     */
    public function createEvent(
        EventDomainObject $eventData,
        ?string $startDate = null,
        ?string $endDate = null,
        ?EventSettingDomainObject $eventSettings = null,
    ): EventDomainObject {
        return $this->databaseManager->transaction(function () use ($eventData, $startDate, $endDate, $eventSettings) {
            $organizer = $this->getOrganizer(
                organizerId: $eventData->getOrganizerId(),
                accountId: $eventData->getAccountId()
            );

            $event = $this->handleEventCreate($eventData, $startDate, $endDate);

            $eventCoverCreated = $this->createEventCover($event);

            $this->createEventSettings(
                eventSettings: $eventSettings,
                event: $event,
                organizer: $organizer,
                eventCoverCreated: $eventCoverCreated,
            );

            $this->createEventStatistics($event);

            $this->createSystemDefaultCheckInList($event);
            $this->createSystemDefaultBoxOffice($event);

            return $event;
        });
    }

    private function createSystemDefaultBoxOffice(EventDomainObject $event): void
    {
        $this->boxOfficeRepository->create([
            'event_id' => $event->getId(),
            'short_id' => IdHelper::shortId(IdHelper::BOX_OFFICE_PREFIX),
            'name' => __('Box office'),
            'is_system_default' => true,
        ]);
    }

    private function createSystemDefaultCheckInList(EventDomainObject $event): void
    {
        $this->checkInListRepository->create([
            'event_id' => $event->getId(),
            'short_id' => IdHelper::shortId(IdHelper::CHECK_IN_LIST_PREFIX),
            'name' => __('Default check-in'),
            'is_system_default' => true,
            'public_show_attendee_notes' => false,
            'public_show_question_answers' => false,
            'public_show_order_details' => false,
        ]);
    }

    /**
     * @throws OrganizerNotFoundException
     */
    private function getOrganizer(int $organizerId, int $accountId): OrganizerDomainObject
    {
        $organizer = $this->organizerRepository
            ->loadRelation(OrganizerSettingDomainObject::class)
            ->findFirstWhere([
                'id' => $organizerId,
                'account_id' => $accountId,
            ]);

        if ($organizer === null) {
            throw new OrganizerNotFoundException(
                __('Organizer :id not found', ['id' => $organizerId])
            );
        }

        return $organizer;
    }

    private function handleEventCreate(EventDomainObject $eventData, ?string $startDate = null, ?string $endDate = null): EventDomainObject
    {
        $event = $this->eventRepository->create([
            'title' => StringHelper::stripControlCharacters($eventData->getTitle()),
            'organizer_id' => $eventData->getOrganizerId(),
            'description' => $this->purifier->purify($eventData->getDescription()),
            'timezone' => $eventData->getTimezone(),
            'currency' => $eventData->getCurrency(),
            'category' => $eventData->getCategory(),
            'account_id' => $eventData->getAccountId(),
            'user_id' => $eventData->getUserId(),
            'status' => $eventData->getStatus(),
            'short_id' => IdHelper::shortId(IdHelper::EVENT_PREFIX),
            'attributes' => $eventData->getAttributes(),
            'type' => $eventData->getType() ?? EventType::SINGLE->name,
            'recurrence_rule' => $eventData->getRecurrenceRule(),
        ]);

        if (($eventData->getType() ?? EventType::SINGLE->name) === EventType::SINGLE->name && $startDate !== null) {
            $this->occurrenceRepository->create([
                'event_id' => $event->getId(),
                'short_id' => IdHelper::shortId(IdHelper::OCCURRENCE_PREFIX),
                'start_date' => DateHelper::convertToUTC($startDate, $eventData->getTimezone()),
                'end_date' => $endDate ? DateHelper::convertToUTC($endDate, $eventData->getTimezone()) : null,
                'status' => 'ACTIVE',
                'used_capacity' => 0,
                'is_overridden' => false,
            ]);
        }

        return $event;
    }

    private function createEventStatistics(EventDomainObject $event): void
    {
        $this->eventStatisticsRepository->create([
            'event_id' => $event->getId(),
            'products_sold' => 0,
            'sales_total_gross' => 0,
            'sales_total_before_additions' => 0,
            'total_tax' => 0,
            'total_fee' => 0,
            'orders_created' => 0,
        ]);
    }

    /**
     * If a default cover image exists for the event category, it will be created.
     */
    private function createEventCover(EventDomainObject $event): bool
    {
        $disk = $this->config->get('filesystems.public');
        $defaultCoversPath = $this->config->get('app.event_categories_cover_images_path');

        $imageFilename = $event->getCategory().'.jpg';
        $imagePath = $defaultCoversPath.'/'.$imageFilename;

        if (! $this->filesystemManager->disk($disk)->exists($imagePath)) {
            return false;
        }

        $this->imageRepository->create([
            'account_id' => $event->getAccountId(),
            'entity_id' => $event->getId(),
            'entity_type' => EventDomainObject::class,
            'type' => ImageType::EVENT_COVER->name,
            'filename' => $imageFilename,
            'disk' => $this->config->get('filesystems.default'),
            'path' => $imagePath,
            'size' => 139673,
            'mime_type' => 'image/jpg',
        ]);

        return true;
    }

    private function createEventSettings(
        ?EventSettingDomainObject $eventSettings,
        EventDomainObject $event,
        OrganizerDomainObject $organizer,
        bool $eventCoverCreated = false
    ): void {
        if ($eventSettings !== null) {
            $eventSettings->setEventId($event->getId());
            $eventSettingsArray = $eventSettings->toArray();

            unset($eventSettingsArray['id']);

            $this->eventSettingsRepository->create($eventSettingsArray);

            return;
        }

        $organizerSettings = $organizer->getOrganizerSettings();
        $organizerThemeSettings = $organizerSettings->getHomepageThemeSettings() ?? [];
        $terminology = ProductTerminology::forCategory($event->getCategory());

        $homepageThemeSettings = [
            'accent' => $organizerThemeSettings['accent'] ?? '#7c3aed',
            'background' => $organizerThemeSettings['background'] ?? '#f5f3ff',
            'mode' => $organizerThemeSettings['mode'] ?? 'light',
            'background_type' => $eventCoverCreated
                ? HomepageBackgroundType::MIRROR_COVER_IMAGE->name
                : ($organizerThemeSettings['background_type'] ?? HomepageBackgroundType::COLOR->name),
        ];

        if (! empty($organizerThemeSettings['font_family'])) {
            $homepageThemeSettings['font_family'] = $organizerThemeSettings['font_family'];
        }

        $this->eventSettingsRepository->create([
            'event_id' => $event->getId(),

            'homepage_theme_settings' => $homepageThemeSettings,

            'homepage_primary_color' => $homepageThemeSettings['accent'],
            'homepage_body_background_color' => $homepageThemeSettings['background'],
            'homepage_background_type' => $homepageThemeSettings['background_type'],
            'homepage_background_color' => '#ffffff',
            'homepage_primary_text_color' => '#000000',
            'homepage_secondary_text_color' => '#ffffff',
            'homepage_secondary_color' => $homepageThemeSettings['accent'],

            'continue_button_text' => $terminology->defaultContinueButtonText(),
            'get_tickets_button_text' => $terminology->defaultGetTicketsButtonText(),
            'support_email' => $organizer->getEmail(),

            'payment_providers' => [PaymentProviders::STRIPE->value],
            'offline_payment_instructions' => null,

            'enable_invoicing' => false,
            'invoice_label' => __('Invoice'),
            'invoice_prefix' => 'INV-',
            'invoice_start_number' => 1,
            'require_billing_address' => false,
            'organization_name' => $organizer->getName(),
            'organization_address' => null,
            'invoice_tax_details' => null,

            'attendee_details_collection_method' => $event->getType() === EventType::RECURRING->name
                ? AttendeeDetailsCollectionMethod::PER_ORDER->value
                : $organizerSettings->getDefaultAttendeeDetailsCollectionMethod(),
            'show_marketing_opt_in' => $organizerSettings->getDefaultShowMarketingOptIn(),
            'allow_copy_details_to_all_attendees' => true,
            'pass_platform_fee_to_buyer' => $organizerSettings->getDefaultPassPlatformFeeToBuyer(),
            'allow_attendee_self_edit' => $organizerSettings->getDefaultAllowAttendeeSelfEdit(),
            'ticket_design_settings' => [
                'accent_color' => $homepageThemeSettings['accent'] ?? '#333',
            ],

            'waitlist_auto_process' => true,
            'waitlist_offer_timeout_minutes' => 120,
        ]);
    }
}