DeviceBundle/EventListener/DeviceListener.php

<?php

namespace DeviceBundle\EventListener;

use Doctrine\ORM\Event\LifecycleEventArgs;
use DeviceBundle\Interfaces\DeviceInterface;
use WebserviceBundle\Services\Webservice;
use Buzz\Message\RequestInterface as HttpRequestInterface;
use Symfony\Bundle\FrameworkBundle\Console\Application;
use Symfony\Component\Console\Input\ArrayInput;
use Symfony\Component\Console\Output\BufferedOutput;
use Symfony\Component\HttpKernel\KernelInterface;

class DeviceListener
{

    /**
     * @var Webservice
     */
    private $webservice;

    /**
     * @var string
     */
    private $devicePostUrl;

    /**
     * @var string
     */
    private $deviceDeletePostUrl;

    /**
     * @var string
     */
    private $devicePutUrl;

    private $serviceContainer;
    

    /**
     * @param Webservice $webservice
     * @param string $devicePostUrl
     * @param string $deviceDeletePostUrl
     * @param string $devicePutUrl
     * @param ContainerInterface $serviceContainer
     */
    public function __construct(Webservice $webservice, $devicePostUrl, $deviceDeletePostUrl, $devicePutUrl, $serviceContainer)
    {
        $this->webservice = $webservice;
        $this->devicePostUrl = $devicePostUrl;
        $this->deviceDeletePostUrl = $deviceDeletePostUrl;
        $this->devicePutUrl = $devicePutUrl;
        $this->enabled = true;
        $this->serviceContainer = $serviceContainer;
    }

    /**
     * @param LifecycleEventArgs $args
     */
    public function postPersist(LifecycleEventArgs $args)
    {
        if (!$this->enabled) {
            return;
        }

        $entity = $args->getEntity();
        $cmd_args = array(
            'type:' . get_class($entity),
            '--id:' . $entity->getId(),
        );
        $this->runCommand('device:create', $cmd_args);
    }
    
    /**
     * Corro el comando para crear el device por AMQP
     * @global kernel $kernel
     * 
     * @param string $name
     * @param array $args
     * 
     * @return string
     */
    public function runCommand($name, $cmd_args = array())
    {
        $kernel = $this->serviceContainer->get('kernel');
        
        $application = new Application($kernel);
        $application->setAutoExit(false);
        
        $input = new ArrayInput(array(
           'command' => 'amqp:remote',
           'name' => $name,
           '--args' => $cmd_args,
        ));
        
        $output = new BufferedOutput();
        $application->run($input, $output);

        return $output->fetch();
    }

    /**
     * @param LifecycleEventArgs $args
     * 
     * @return mixed
     */
    public function preRemove(LifecycleEventArgs $args)
    {
        if (!$this->enabled) {
            return;
        }

        $entity = $args->getEntity();
        if ($entity instanceof DeviceInterface) {
            if ($deviceId = $this->getRemoteDeviceId($entity)) {
                $data = array('id' => $deviceId);
                
                return $this->webservice->makeGetRequest($this->deviceDeletePostUrl, HttpRequestInterface::METHOD_DELETE, $data);
            }
        }
    }

    /**
     * @param LifecycleEventArgs $args
     */
    public function postUpdate(LifecycleEventArgs $args)
    {
        if (!$this->enabled) {
            return;
        }

        $entity = $args->getEntity();
        if ($entity instanceof DeviceInterface) {
            if ($deviceId = $this->getRemoteDeviceId($entity)) {
                $url = "{$this->devicePutUrl}{$deviceId}";
                $this->send($entity, $url, HttpRequestInterface::METHOD_PUT);
            } else {
                $this->send($entity, $this->devicePostUrl, HttpRequestInterface::METHOD_POST);
            }
        }
    }

    /**
     * @param DeviceInterface $entity
     * @param string $url
     * @param string $method
     * @param array $credentials username y password
     * 
     * @return mixed
     */
    public function send($entity, $url, $method, $credentials = array())
    {
        if (!$this->enabled) {
            return;
        }

        if ($entity instanceof DeviceInterface) {
            $data = $entity->getDeviceData();
            $data = $this->addLocationData($entity, $data);

            return $this->webservice->makeGetRequest($url, $method, $data, $credentials);
        }
    }

    /**
     * Agrega la ubicación de $entity si implementa LocationInterface
     *
     * @param Entity $entity
     * @param array $data
     *
     * @return array
     */
    private function addLocationData($entity, $data)
    {
        if (!$this->enabled) {
            return;
        }

        $locationInterface = 'MapBundle\Entity\Interfaces\LocationInterface';
        if (interface_exists($locationInterface) && is_a($entity, $locationInterface)) {
            $extraData = json_decode($data['extraData'], true);
            $extraData['location'] = $entity->getLocation() ? $entity->getLocation()->getData() : array();
            $data['extraData'] = json_encode($extraData);
        }

        return $data;
    }

    /**
     * @param object $entity
     * 
     * @return mixed
     */
    private function getRemoteDeviceId($entity)
    {
        if (!$this->enabled) {
            return;
        }

        $deviceId = $entity->getId();
        $deviceType = get_class($entity);
        $tenancyId = $entity->getTenancyId();

        $filters = array('deviceId' => $deviceId, 'deviceType' => $deviceType, 'tenancyId' => $tenancyId);
        $data = $this->webservice->getData("device_post_url", $filters);

//        file_put_contents("/var/flowdat/error.log",json_encode($data));

        $deviceId = null;
        if (isset($data[0]))
            $deviceId = $data[0]['id'];

        return $deviceId;
    }

    /**
     * @param boolean $enabled
     */
    function remoteCheck($enabled = true)
    {
        $this->enabled = $enabled;
    }

    /**
     * Se utiliza para las pruebas de phpunit
     * @param Webservice $webservice
     */
    public function setWebservice($webservice)
    {
        $this->webservice = $webservice;
    }

}