api-utils/src/Utils/Controller/LuticateApplication.php

<?php
/**
 * Created by PhpStorm.
 * User: robin
 * Date: 6/4/16
 * Time: 10:06 PM
 */

namespace Luticate\Utils\Controller;

use Luticate\Utils\Business\LuBusinessException;
use Luticate\Utils\Business\LuLog;
use Luticate\Utils\Dbo\LuRequestDbo;
use Ratchet\ConnectionInterface;
use Ratchet\MessageComponentInterface;
use Ratchet\Http\HttpServer;
use Ratchet\Server\IoServer;
use Ratchet\WebSocket\WsServer;
use Illuminate\Database\Capsule\Manager as Capsule;

class LuticateApplication implements MessageComponentInterface
{
    private $_version = 1.0;
    private $_config = null;
    private $_clients = null;
    private $_router = null;
    
    private static $_app = null;
    
    public static function getInstance()
    {
        return self::$_app;
    }

    /**
     * @param $configuration array
     */
    public function __construct($configuration)
    {
        $this->_config = $configuration;
        $this->_clients = new \SplObjectStorage;
        $this->_router = new LuRoute();
        LuLog::setLogFilePath(__DIR__ . "/../../../../../../". $this->_config["logs"]);
        self::$_app = $this;
    }

    /**
     * @return LuRoute
     */
    public function getRouter()
    {
        return $this->_router;
    }

    /**
     * @param LuRoute|null $router
     */
    public function setRouter($router)
    {
        $this->_router = $router;
    }

    /**
     * @param $version float
     */
    public function setVersion($version)
    {
        $this->_version = $version;
    }

    /**
     * @return float
     */
    public function getVersion()
    {
        return $this->_version;
    }
    
    public function setupRoutes()
    {
        $app = $this;
        require_once __DIR__ . '/../../../../../../app/routes.php';
        
        $this->_router->setup();
    }
    
    public function setupDatabases()
    {
        $capsule = new Capsule;
        foreach ($this->_config['databases'] as $database) {

            $default = [
                'name'      => 'mydb',
                'driver'    => 'pgsql',
                'host'      => '172.17.0.1',
                'database'  => 'luticate2',
                'username'  => 'dev',
                'password'  => 'dev',
                'charset'   => 'utf8',
                'collation' => 'utf8_unicode_ci',
                'prefix'    => ''
            ];
            $capsule->addConnection(array_merge($default, $database), $database['name']);
        }
        $capsule->setAsGlobal();
    }
    
    private function dispatch($httpMethod, $url, $parameters)
    {
        $r = new LuRequestDbo();
        $r->setVersion($this->getVersion());

        try {
            $result = $this->_router->dispatch($httpMethod, $url, $parameters);
            $r->setData($result);
            $r->setStatusCode(200);
        }
        catch (LuBusinessException $e)
        {
            LuLog::log($e);
            $r->setStatusCode($e->getCode());
            $r->setMessage($e->getMessage());
        }
        catch (\Exception $e)
        {
            LuLog::log($e);
            $r->setStatusCode(500);
            $r->setMessage("Internal Error");
        }
        catch (\Error $e)
        {
            LuLog::log($e);
            $r->setStatusCode(500);
            $r->setMessage("Internal Error");
        }
        return $r;
    }
    
    public function runHttp()
    {
        $httpMethod = $_SERVER['REQUEST_METHOD'];
        $url = $_SERVER['REQUEST_URI'];
        $parameters = array_merge($_GET, $_POST);
        
        $r = $this->dispatch($httpMethod, $url, $parameters);
        http_response_code($r->getStatusCode());
        header("content-type: application/json");
        echo $r->__toString();
    }
    
    public function runWs()
    {
        $server = IoServer::factory(
            new HttpServer(
                new WsServer(
                    $this
                )
            ),
            $this->_config['websocket']['port'],
            $this->_config['websocket']['address']
        );

        $server->run();
    }

    function onMessage(ConnectionInterface $from, $msg)
    {
        // TODO: Implement onMessage() method.
    }

    function onOpen(ConnectionInterface $conn)
    {
        $this->_clients->attach($conn);
    }

    function onClose(ConnectionInterface $conn)
    {
        $this->_clients->detach($conn);
    }

    function onError(ConnectionInterface $conn, \Exception $e)
    {
        $conn->close();
    }
}