PhpMob\Settings\Manager\SettingManager

Complexity

Total Complexity

31

Size/Duplication

Total Lines	206
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

0%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	14	1
A	getUserSettings()	0	8	2
A	loadSettings()	0	8	4
A	filter()	0	10	3
A	findSetting()	0	8	2
B	assertSectionScope()	0	12	6
A	setSetting()	0	16	3
A	getSetting()	0	10	2
A	flush()	0	15	4
A	get()	0	10	2
A	set()	0	10	2

<?php

/*
 * This file is part of the PhpMob package.
 *
 * (c) Ishmael Doss <nukboon@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace PhpMob\Settings\Manager;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\Common\Persistence\ManagerRegistry;
use Doctrine\Common\Persistence\ObjectManager;
use PhpMob\Settings\Model\Setting;
use PhpMob\Settings\Model\SettingInterface;
use PhpMob\Settings\Provider\SettingProviderInterface;
use PhpMob\Settings\Schema\SettingSchemaRegistryInterface;
use PhpMob\Settings\Type\TypeTransformerInterface;

/**
 * @author Ishmael Doss <nukboon@gmail.com>
 */
class SettingManager implements SettingManagerInterface
{
    /**
     * @var ObjectManager
     */
    private $manager;

    /**
     * @var SettingSchemaRegistryInterface
     */
    private $schemaRegistry;

    /**
     * @var SettingProviderInterface
     */
    private $provider;

    /**
     * @var TypeTransformerInterface
     */
    private $transformer;

    /**
     * @var SettingInterface[]|Collection
     */
    private $globalSettings;

    /**
     * @var Collection
     */
    private $userSettings;

    public function __construct(
        ManagerRegistry $managerRegistry,
        SettingProviderInterface $provider,
        SettingSchemaRegistryInterface $schemaRegistry,
        TypeTransformerInterface $transformer
    ) {
        $this->manager = $managerRegistry->getManagerForClass(Setting::class);
        $this->provider = $provider;
        $this->schemaRegistry = $schemaRegistry;
        $this->transformer = $transformer;

        $this->globalSettings = new ArrayCollection();
        $this->userSettings = new ArrayCollection();
    }

    /**
     * @param string $owner
     *
     * @return mixed|null
     */
    private function getUserSettings(string $owner)
    {
        if (!$this->userSettings->get($owner)) {
            $this->userSettings->set($owner, $this->provider->findUserSettings($owner));
        }

        return $this->userSettings->get($owner);
    }

    /**
     * @param string|null $owner
     */
    private function loadSettings(?string $owner)
    {
        $owner && $this->getUserSettings($owner);

The expression $owner of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

        if (!$owner && $this->globalSettings->isEmpty()) {

The expression $owner of type string|null is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === null instead.

            $this->globalSettings = $this->provider->findGlobalSettings();
        }
    }

    /**
     * @param Collection $settings
     * @param string $section
     * @param string $key
     * @param string|null $owner
     *
     * @return Collection
     */
    private function filter(Collection $settings, string $section, string $key, ?string $owner)
    {
        return $settings->filter(
            function (SettingInterface $setting) use ($section, $key, $owner) {
                return $section === $setting->getSection()
                    && $key === $setting->getKey()
                    && $owner === $setting->getOwner();
            }
        );
    }

    /**
     * @param $section
     * @param $key
     * @param string|null $owner
     *
     * @return SettingInterface|null
     */
    private function findSetting($section, $key, ?string $owner)
    {
        $this->loadSettings($owner);

        return $owner
            ? $this->filter($this->getUserSettings($owner), $section, $key, $owner)->first()
            : $this->filter($this->globalSettings, $section, $key, null)->first();

It seems like $this->globalSettings can also be of type array<integer,object<PhpMob\Settings\Model\SettingInterface>>; however, PhpMob\Settings\Manager\SettingManager::filter() does only seem to accept object<Doctrine\Common\Collections\Collection>, maybe add an additional type check?

    }

    /**
     * @param $section
     * @param string|null $owner
     */
    private function assertSectionScope($section, ?string $owner)
    {
        try {
            $section = $this->schemaRegistry->getSection($section);
        } catch (\InvalidArgumentException $e) {
            throw new \LogicException($e->getMessage());
        }

        if ((!empty($owner) && !$section->isOwnerAware()) || (empty($owner) && $section->isOwnerAware())) {
            throw new \LogicException('Wrong section accessing.');
        }
    }

    /**
     * {@inheritdoc}
     */
    public function setSetting(string $section, string $key, $value, ?string $owner = null, $autoFlush = false): void
    {
        $this->assertSectionScope($section, $owner);

        $setting = $this->findSetting($section, $key, $owner) ?: new Setting();
        $setting->setOwner($owner);
        $setting->setSection($section);
        $setting->setKey($key);
        $setting->setValue($this->transformer->transform($section, $key, $value));
        $setting->setUpdatedAt(new \DateTime());

        if ($autoFlush) {
            $this->manager->persist($setting);
            $this->manager->flush();
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getSetting(string $section, string $key, ?string $owner = null)
    {
        $this->assertSectionScope($section, $owner);

        if (!$setting = $this->findSetting($section, $key, $owner)) {
            return null;
        }

        return $this->transformer->reverse($section, $key, $setting->getValue());
    }

    /**
     * {@inheritdoc}
     */
    public function flush(): void
    {
        foreach ($this->globalSettings->toArray() as $setting) {
            $this->manager->persist($setting);
        }

        /** @var Collection $userSettings */
        foreach ($this->userSettings->toArray() as $userSettings) {
            foreach ($userSettings->toArray() as $setting) {
                $this->manager->persist($setting);
            }
        }

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

    /**
     * {@inheritdoc}
     */
    public function get(string $path, ?string $owner = null)
    {
        @list($section, $key) = explode('.', $path);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

        if (empty($key)) {
            return null;
        }

        return $this->getSetting($section, $key, $owner);
    }

    /**
     * {@inheritdoc}
     */
    public function set(string $path, $value, ?string $owner = null): void
    {
        @list($section, $key) = explode('.', $path);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

        if (empty($key)) {
            throw new \InvalidArgumentException("The $path should be something like: `section.key`.");
        }

        $this->setSetting($section, $key, $value, $owner, true);
    }
}