AppBundle\Variable\Service

Complexity

Total Complexity

19

Size/Duplication

Total Lines	174
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Test Coverage

Coverage

61.36%

Importance

Changes	6
Bugs	1	Features	2

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	getDoctrine()	0	4	1
A	get()	0	11	2
A	getDayHistory()	0	20	1
A	getLastValue()	0	18	1
D	set()	0	92	13

<?php

namespace AppBundle\Variable;

use AppBundle\Action\Executor\ExecutorInterface;
use AppBundle\Entity\Variable;
use AppBundle\Entity\VariableHistory;
use AppBundle\Variable\Parser\ParserInterface;
use Doctrine\Bundle\DoctrineBundle\Registry;
use Doctrine\ORM\EntityManager;
use Symfony\Component\Config\Definition\Exception\Exception;

class Service
{

    private $doctrine;
    private $needSync = false;
    private $syncHost;
    private $actionService;

    public function __construct(Registry $doctrine, \AppBundle\Action\Service $actionService, $needSync, $syncHost)
    {
        $this->doctrine = $doctrine;
        $this->needSync = $needSync;
        $this->syncHost = $syncHost;
        $this->actionService = $actionService;
    }

    private function getDoctrine()
    {
        return $this->doctrine;
    }

    public function get($varName)
    {
        $vars = $this->getDoctrine()->getRepository('AppBundle:Variable');

        /** @var Variable $var */
        $var = $vars->findOneBy(['name'=>$varName]);
        if (!$var) {
            throw new Exception('Variable '.$varName.' not found');
        }
        return $var;
    }

    public function set($varName, $value)
    {
        $vars = $this->getDoctrine()->getRepository('AppBundle:Variable');

        /** @var Variable $var */
        $var = $vars->findOneBy(['name'=>$varName]);
        if (!$var) {
            throw new Exception('Variable '.$varName.' not found');
        }

        $parser = 'AppBundle\Variable\Parser\\'.ucfirst($var->getParser());

        if (!class_exists($parser)) {
            throw new Exception('Unknown parser: '.$parser);
        }

        /** @var ParserInterface $parser */
        $parser = new $parser();

        $value = $parser->parse($value);

        if (!$value) {
            return false;
        }

        if ($this->needSync) {
            if ($var->needSync) {
                @file_get_contents($this->syncHost.'set/'.$varName.'?value='.$value);

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

            }
        }

        $var->setValue($value);
        $var->setLaststatus(200);
        $var->setLastupdate(new \DateTime());

        $this->getDoctrine()->getManagerForClass('AppBundle:Variable')->persist($var);

        if ($var->needHistory) {
            $state = new VariableHistory();
            $state->setVar($var);
            $state->setTime(new \DateTime());
            $state->setValue($value);

            $this->getDoctrine()->getManagerForClass('AppBundle:VariableHistory')->persist($state);
            $this->getDoctrine()->getManagerForClass('AppBundle:VariableHistory')->flush();
        }

        $this->getDoctrine()->getManagerForClass('AppBundle:Variable')->flush();

        // hooks run

        $hooks = $this->getDoctrine()->getManager()->getRepository('AppBundle:VarHook')->findBy(['variable'=>$var]);

        foreach ($hooks as $varHook) {
            list($executor, $method) = explode(':', $varHook->getExecutor());

            $executor = 'AppBundle\Action\Executor\\'.ucfirst($executor);

            if (!class_exists($executor)) {
                throw new \Exception('Unknown executor: '.$executor);
            }

            /** @var ExecutorInterface $executor */
            $executor = new $executor();
            $executor->setDoctrine($this->getDoctrine());


            if (!method_exists($executor, $method)) {
                throw new \Exception('Unknown executor method: '.$varHook->getExecutor().'()');
            }

            $executor->setParameters(json_decode($varHook->getArguments(), true));

            try {
                $result = $executor->{$method}($varHook);
            } catch (\Exception $exception) {
                $result = $exception->getMessage();
            }

            if ($varHook->getType() == 'decider') {
                if ($result === true) {
                    $this->actionService->executeReal(
                        $varHook->getAction(),
                        'hook',
                        json_decode($varHook->getArguments(), true)
                    );
                }
            }
        }

        return $value;
    }

    /**
     * @param Variable $variable
     * @return array
     */
    public function getDayHistory(Variable $variable)
    {
        /** @var EntityManager $em */
        $em = $this->getDoctrine()->getManager();

        $q = $em->createQueryBuilder();
        $res = $q->
            select('AVG(vh.value) as av')->
            addSelect('DATE_FORMAT(vh.time,\'%Y-%m-%d %H:00\') as df')->
            from('AppBundle:VariableHistory', 'vh')->
            where('vh.time >= :date')->
            setParameter('date', new \DateTime('-48 hour'))->
            andWhere('vh.var = :var_id')->
            setParameter('var_id', $variable->getId())->
            groupBy('df')->
            orderBy('df', 'asc')->
            getQuery();

        return $res->getArrayResult();
    }

    /**
     * @param Variable $variable
     * @return array
     */
    public function getLastValue(Variable $variable)
    {
        /** @var EntityManager $em */
        $em = $this->getDoctrine()->getManager();

        $q = $em->createQueryBuilder();
        $res = $q->
        select('vh.value as av')->
        addSelect('vh.time as df')->
        from('AppBundle:VariableHistory', 'vh')->
        where('vh.var = :var_id')->
        setParameter('var_id', $variable->getId())->
        orderBy('df', 'desc')->
        setMaxResults(1)->
        getQuery();

        return $res->getSingleResult();
    }
}