Odiseo\SyliusReferralsPlugin\Mapping\AffiliateReferralAwareListener

Complexity

Total Complexity

11

Size/Duplication

Total Lines	64
Duplicated Lines	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	getSubscribedEvents()	0	4	1
A	loadClassMetadata()	0	17	5
A	__construct()	0	4	1
A	mapAffiliateReferralAware()	0	29	4

<?php

declare(strict_types=1);

namespace Odiseo\SyliusReferralsPlugin\Mapping;

use Doctrine\Common\EventSubscriber;
use Doctrine\ORM\Event\LoadClassMetadataEventArgs;
use Doctrine\ORM\Events;
use Doctrine\ORM\Mapping\ClassMetadata;
use Odiseo\SyliusReferralsPlugin\Entity\AffiliateReferralAwareInterface;
use Sylius\Component\Order\Model\OrderInterface;
use Sylius\Component\Resource\Metadata\RegistryInterface;

final class AffiliateReferralAwareListener implements EventSubscriber
{
    public function __construct(
        private RegistryInterface $resourceMetadataRegistry,
        private string $affiliateReferralClass,
    ) {
    }

    public function getSubscribedEvents(): array
    {
        return [
            Events::loadClassMetadata,
        ];
    }

    public function loadClassMetadata(LoadClassMetadataEventArgs $eventArgs): void
    {
        $classMetadata = $eventArgs->getClassMetadata();
        $reflection = $classMetadata->reflClass;

Accessing reflClass on the interface Doctrine\Persistence\Mapping\ClassMetadata suggest that you code against a concrete implementation. How about adding an instanceof check?

        /**
         * @phpstan-ignore-next-line
         */
        if ($reflection === null || $reflection->isAbstract()) {
            return;
        }

        if (
            $reflection->implementsInterface(OrderInterface::class) &&
            $reflection->implementsInterface(AffiliateReferralAwareInterface::class)
        ) {
            $this->mapAffiliateReferralAware($classMetadata, 'affiliate_referral_id');
        }
    }

    private function mapAffiliateReferralAware(
        ClassMetadata $metadata,
        string $joinColumn,
        ?string $inversedBy = null,
    ): void {
        try {
            $affiliateReferralMetadata = $this->resourceMetadataRegistry->getByClass($this->affiliateReferralClass);
        } catch (\InvalidArgumentException $exception) {
            return;
        }

        if (!$metadata->hasAssociation('affiliateReferral')) {
            $mapping = [
                'fieldName' => 'affiliateReferral',
                'targetEntity' => $affiliateReferralMetadata->getClass('model'),
                'joinColumns' => [
                    [
                        'name' => $joinColumn,
                        'referencedColumnName' => 'id',
                    ],
                ],
                'cascade' => ['persist'],
            ];

            if (null !== $inversedBy) {
                $mapping['inversedBy'] = $inversedBy;
            }

            $metadata->mapManyToOne($mapping);
        }
    }
}