ControleOnline\Service\ExtraDataService

Complexity

Total Complexity

33

Size/Duplication

Total Lines	166
Duplicated Lines	0 %

Importance

Changes	29
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	discoveryUser()	0	7	4
A	__construct()	0	9	1
A	getEntityName()	0	3	1
A	discoveryExtraData()	0	16	2
A	getUserIp()	0	3	1
A	persist()	0	9	2
B	discoveryDevice()	0	10	7
A	getEntityByExtraData()	0	12	2
A	discoveryExtraFields()	0	21	2
A	noChange()	0	3	1
B	persistData()	0	45	10

<?php

namespace ControleOnline\Service;

use ControleOnline\Entity\Device;
use ControleOnline\Entity\DeviceConfig;
use ControleOnline\Entity\ExtraData;
use ControleOnline\Entity\ExtraFields;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface

The type Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface was not found. Maybe you did not declare it correctly or list all dependencies?

as Security;
use Symfony\Component\HttpFoundation\RequestStack;

The type Symfony\Component\HttpFoundation\RequestStack was not found. Maybe you did not declare it correctly or list all dependencies?

use Doctrine\ORM\EntityManagerInterface;

The type Doctrine\ORM\EntityManagerInterface was not found. Maybe you did not declare it correctly or list all dependencies?

class ExtraDataService
{
    private static $persisted = false;
    private $request;
    public function __construct(
        private EntityManagerInterface $manager,
        private RequestStack $requestStack,
        private Security $security,
        private DeviceService $deviceService,
        private SkyNetService $skyNetService

    ) {
        $this->request = $requestStack->getCurrentRequest();
    }


    public function getEntityByExtraData(ExtraFields $extraFields,  string $code, object | string $entity)
    {
        $class = $this->getEntityName($entity);
        $extraData = $this->manager->getRepository(ExtraData::class)->findOneBy([
            'extra_fields' => $extraFields,
            'entity_name' => $class->getShortName(),
            'value' => $code
        ]);
        if ($extraData)
            return $this->manager->getRepository($class->getName())->find($extraData->getEntityId());

        return null;
    }


    public function discoveryExtraData(int|string $entityId, ExtraFields $extraFields, string $code, object | string $entity)
    {
        $class = $this->getEntityName($entity);

        $extraData = $this->getEntityByExtraData($extraFields,  $code,  $entity);
        if ($extraData) return $extraData;

        $extraData = new ExtraData();
        $extraData->setEntityId($entityId);
        $extraData->setExtraFields($extraFields);
        $extraData->setValue($code);
        $extraData->setEntityName($class->getShortName());
        $this->manager->persist($extraData);
        $this->manager->flush();

        return $this->manager->getRepository($class->getName())->find($extraData->getEntityId());
    }

    public function discoveryExtraFields(string $fieldName, string $context, ?string $configs = '{}',  ?string $fieldType = 'text', ?bool $required = false): ExtraFields
    {

        $extraFields = $this->manager->getRepository(ExtraFields::class)->findOneBy([
            'name' => $fieldName,
            'type' => $fieldType,
            'context' => $context
        ]);

        if (!$extraFields) {
            $extraFields = new ExtraFields();
            $extraFields->setName($fieldName);
            $extraFields->setContext($context);
            $extraFields->setConfigs($configs);
            $extraFields->setType($fieldType);

It seems like $fieldType can also be of type null; however, parameter $type of ControleOnline\Entity\ExtraFields::setType() does only seem to accept string, maybe add an additional type check?

            $extraFields->setRequired($required);
            $this->manager->persist($extraFields);
            $this->manager->flush();
        }

        return $extraFields;
    }


    private function getUserIp()
    {
        return $this->request->getClientIp();
    }

    public function discoveryDevice(&$entity)
    {
        if ($entity instanceof Device || $entity instanceof DeviceConfig || !$this->request->headers)
            return;

        $deviceId = $this->request->headers->get('DEVICE') ?: $this->getUserIp();
        if (method_exists($entity, 'setDevice')) {
            if ($entity->getDevice()) return;
            $device = $this->deviceService->discoveryDevice($deviceId);
            $entity->setDevice($device);
        }
    }

    public function discoveryUser(&$entity)
    {
        $token = $this->security->getToken();
        $user = $token ? $token->getUser() : $this->skyNetService->getBotUser();

        if (method_exists($entity, 'setUser') && !$entity->getUser())
            $entity->setUser($user);
    }

    public function persist(&$entity)
    {
        if (self::$persisted == true)

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            return;
        self::$persisted = true;

        //$this->manager->persist($entity);
        //$this->manager->flush();
        $this->persistData($entity);
    }

    private function getEntityName(object | string $entity): \ReflectionClass
    {
        return (new \ReflectionClass($entity));
    }

    private function persistData(&$entity = null)
    {

        if ($entity) {
            $entity_id = $entity->getId();
            $entity_name = $this->getEntityName($entity)->getShortName();

            //$this->manager->persist($entity);
        } else {
            $json =       json_decode($this->request->getContent(), true);
            $extra_data = isset($json['extra-data']) ? $json['extra-data'] : null;
            if (!$extra_data)
                return;
            $entity_id = $extra_data['entity_id'];
            $entity_name = $extra_data['entity_name'];
        }


        if (!$entity_id || !$entity_name)
            return;

        if (!isset($extra_data) || !isset($extra_data['data']))
            return;

        foreach ($extra_data['data'] as $key => $data) {
            $extra_fields = $this->manager->getRepository(ExtraFields::class)->find($key);

            $extraData = $this->manager->getRepository(ExtraData::class)->findOneBy([
                'entity_id' => $entity_id,
                'entity_name' => $entity_name,
                'extra_fields' => $extra_fields
            ]);

            if (!$extraData)
                $extraData = new ExtraData();

            $extraData->setExtraFields($extra_fields);
            $extraData->setEntityName($entity_name);
            $extraData->setEntityId($entity_id);
            $extraData->setValue($data);
            $this->manager->persist($extraData);
        }


        $this->manager->flush();
    }

    public function  noChange()
    {
        $this->persistData();
    }
}