string and array utils; db dataaccess

composer.json

         }
     ],
     "require": {
+        "php": "7.0.*",
         "guzzlehttp/guzzle": "^6.1",
         "nikic/fast-route": "^1.0",
         "nesbot/carbon": "^1.21",
-        "cboden/ratchet": "^0.3.5"
+        "cboden/ratchet": "^0.3.5",
+        "illuminate/database": "^5.2"
     },
     "require-dev": {
         "phpunit/phpunit": "5.3.*"

src/Utils/Business/LuArrayUtils.php

+<?php
+/**
+ * Created by PhpStorm.
+ * User: robin
+ * Date: 6/7/16
+ * Time: 5:04 PM
+ */
+
+namespace Luticate\Utils\Business;
+
+
+class LuArrayUtils
+{
+    public static function snakeToCamelCase($array)
+    {
+        if (!is_array($array))
+        {
+            return $array;
+        }
+        $camelCase = [];
+        foreach ($array as $key => $value)
+        {
+            $camelCase[LuStringUtils::snakeToCamelCase($key, true)] = self::snakeToCamelCase($value);
+        }
+        return $camelCase;
+    }
+    public static function camelCaseToSnake($array)
+    {
+        if (!is_array($array))
+        {
+            return $array;
+        }
+        $camelCase = [];
+        foreach ($array as $key => $value)
+        {
+            $camelCase[LuStringUtils::camelCaseToSnake($key, false)] = self::camelCaseToSnake($value);
+        }
+        return $camelCase;
+    }
+
+    public static function convertJsonString($json)
+    {
+        return LuStringUtils::convertJsonString($json);
+    }
+
+    public static function objectToArray($d)
+    {
+        if (is_object($d)) {
+            $d = get_object_vars($d);
+        }
+
+        if (is_array($d)) {
+            $data = [];
+            foreach ($d as $key => $value) {
+                $data[$key] = self::objectToArray($value);
+            }
+            return self::snakeToCamelCase($data);
+        }
+        else {
+            return $d;
+        }
+    }
+
+}

src/Utils/Business/LuStringUtils.php

 
 class LuStringUtils
 {
-    public static function stringSnakeToCamelCase($string, $capitalizeFirstCharacter) {
+    public static function snakeToCamelCase($string, $capitalizeFirstCharacter)
+    {
         $str = preg_replace_callback("/_[a-zA-Z]/", function($matches)
         {
             return strtoupper($matches[0][1]);
         }, $string);
-        if ($capitalizeFirstCharacter)
+        if ($capitalizeFirstCharacter && !empty($str)) {
             $str[0] = strtoupper($str[0]);
+        }
         return $str;
     }
-
-    public static function arraySnakeToCamelCase($array)
+    
+    public static function camelCaseToSnake($string, $underscoreFirstCharacter)
     {
-        if (!is_array($array))
+        $str = preg_replace_callback("/[A-Z]/", function($matches)
         {
-            return $array;
-        }
-        $camelCase = [];
-        foreach ($array as $key => $value)
-        {
-            $camelCase[self::stringSnakeToCamelCase($key, true)] = self::arraySnakeToCamelCase($value);
+            return strtolower("_" . $matches[0]);
+        }, $string);
+        if (!$underscoreFirstCharacter && !empty($str) && $str[0] == "_") {
+            $str = substr($str, 1, strlen($str) - 1);
         }
-        return $camelCase;
+        return $str;
     }
 
     public static function convertJsonString($json)
     {
         $array = json_decode($json, true);
-        return self::arraySnakeToCamelCase($array);
+        return LuArrayUtils::snakeToCamelCase($array);
     }
 
     public static function parseDate($str)

src/Utils/Controller/LuticateApplication.php

 use Ratchet\Http\HttpServer;
 use Ratchet\Server\IoServer;
 use Ratchet\WebSocket\WsServer;
+use Illuminate\Database\Capsule\Manager as Capsule;
 
 class LuticateApplication implements MessageComponentInterface
 {
         $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();

src/Utils/DataAccess/LuDataAccess.php

 <?php
 
-namespace Luticate\Utils;
+namespace Luticate\Utils\DataAccess;
 
-use DB;
+use Illuminate\Database\Capsule\Manager as Capsule;
+use Illuminate\Database\Connection;
+use Illuminate\Database\Query\Builder;
+use Luticate\Utils\Business\LuArrayUtils;
 use Luticate\Utils\Dbo\LuDbo;
-use Luticate\Utils\Dbo\LuMultipleDbo;
 
 abstract class LuDataAccess {
 
+    protected static $_connection = "mydb";
+    protected static $_table = "mydb_table";
+    protected static $_table_as = "__t__";
+    protected static $_dboClass = LuDbo::class;
+    protected static $_dboArrayClass = LuDbo::class;
+    protected static $_dboIgnoreList = [];
+
     public static function transact(\Closure $function)
     {
-        DB::transaction($function);
+        return static::getConnection()->transaction($function);
     }
 
     /**
-     * @param $data LuModel[]
-     * @return LuDbo[]
+     * @return Connection
      */
-    protected static function arrayToDbo($data)
+    public static function getConnection()
     {
-        $tab = [];
-        foreach ($data as $q) {
-            if (!is_null($q)) {
-                $tab[] = $q->toDbo();
-            }
-        }
-        return $tab;
+        return Capsule::connection(static::$_connection);
     }
 
     /**
-     * @param $id int
-     * @return LuModel
+     * @return Builder
      */
-    protected static function _getModelById($id)
+    public static function getTableAs()
     {
-        return static::getModel()->where('id', '=', $id)->first();
+        return static::getConnection()->table(static::$_table . " as " . static::$_table_as);
     }
 
     /**
-     * @param $id int
-     * @return LuDbo|null
+     * @return Builder
      */
-    public static function getById($id)
+    public static function getTable()
     {
-        $data = self::_getModelById($id);
-        if (is_null($data))
-            return null;
-        return $data->toDbo();
+        return static::getConnection()->table(static::$_table);
     }
 
     /**
-     * @param $id int
-     * @return bool
+     * @param $query Builder|callable
+     * @return Builder
      */
-    public static function deleteById($id)
+    public static function resolveQuery($query)
     {
-        $data = self::_getModelById($id);
-        if (is_null($data))
-            return false;
-        $data->delete();
-        return true;
+        if (is_callable($query)) {
+            $query = $query(static::getTableAs());
+        }
+        return $query;
     }
 
     /**
-     * @param $data LuDbo
-     * @return int
+     * @param $dbo LuDbo
+     * @param array $ignoreList
+     * @return array
      */
-    public static function addId($data)
+    public static function prepareDbo($dbo, $ignoreList = [])
     {
-        $data = static::getModel()->fromDbo($data);
-        unset($data->id);
-        $data->save();
-        return $data->id;
+        $json = $dbo->jsonSerialize();
+        foreach (array_merge(static::$_dboIgnoreList, $ignoreList) as $ignore) {
+            unset($json[$ignore]);
+        }
+        $json = LuArrayUtils::camelCaseToSnake($json);
+        return $json;
     }
 
     /**
-     * @param $data LuDbo
+     * @param $query Builder|callable
+     * @return LuDBo[]
      */
-    public static function add($data)
+    public static function getMultiple($query)
     {
-        $data = static::getModel()->fromDbo($data);
-        $data->save();
+        $query = static::resolveQuery($query);
+        $string = $query->aggregate("json_agg", [static::$_table_as]);
+        $json = json_decode($string, true);
+        $data = LuArrayUtils::snakeToCamelCase($json);
+        
+        return call_user_func([static::$_dboArrayClass, 'jsonDeserialize'], $data);
     }
 
     /**
-     * @param $id int
-     * @param $data LuDbo
-     * @return LuDbo|null
+     * @param $query Builder|callable
+     * @return LuDBo
      */
-    public static function editById($id, $data)
+    public static function getSingle($query)
     {
-        return static::getModel()->fromDbo($data, self::_getModelById($id))->save();
+        $query = static::resolveQuery($query);
+        $string = $query->take(1)->aggregate("json_agg", [static::$_table_as]);
+        if (is_null($string)) {
+            return null;
+        }
+        $json = json_decode($string, true);
+        $data = LuArrayUtils::snakeToCamelCase($json);
+        if (count($data) < 1) {
+            return null;
+        }
+
+        return call_user_func([static::$_dboClass, 'jsonDeserialize'], $data[0]);
     }
 
     /**
-     * @param $predicates array
-     * @param $orders array
-     * @param int $page
-     * @param int $perPage
-     * @return LuMultipleDbo
+     * @param $id
+     * @return LuDbo
      */
-    public static function getMultiple($predicates, $orders, $page = 0, $perPage = PHP_INT_MAX)
+    public static function getSingleById($id)
     {
-        /**
-         * @var $model LuModel
-         */
-        $model = static::getModel();
-        foreach($predicates as $predicate) {
-            $column = $predicate[0];
-            $operator = $predicate[1];
-            $value = $predicate[2];
-            $boolean = isset($predicate[3]) ? $predicate[3] : null;
-            $model = $model->where($column, $operator, $value, $boolean);
-        }
-        $count = $model->count();
-        foreach($orders as $order) {
-            $model = $model->orderBy($order[0], $order[1]);
-        }
-        $data = $model->take($perPage)->offset($page * $perPage)->get();
-        $dbo = self::arrayToDbo($data);
+        return static::getSingle(static::getTableAs()->where("id", "=", $id));
+    }
+
+    /**
+     * @param $id
+     * @return int
+     */
+    public static function deleteSingleById($id)
+    {
+        return static::getTableAs()->delete($id);
+    }
 
-        return new LuMultipleDbo($count, $dbo);
+    /**
+     * @param $query Builder|callable
+     * @return int
+     */
+    public static function deleteMultiple($query)
+    {
+        $query = static::resolveQuery($query);
+        return $query->delete();
     }
 
     /**
-     * @return LuModel
+     * @param $dbo LuDbo
+     * @param string[] $ignoreList
+     * @return bool
      */
-    protected static function getModel()
+    public static function addSingle($dbo, $ignoreList = [])
     {
-        return null;
+        $json = static::prepareDbo($dbo, $ignoreList);
+        return static::getTable()->insert($json);
     }
 
     /**
-     * @return array
+     * @param $dbo LuDbo
+     * @param string[] $ignoreList
+     * @return int
      */
-    protected static function getOrderBy()
+    public static function addSingleId($dbo, $ignoreList = [])
     {
-        return array();
+        $json = static::prepareDbo($dbo, $ignoreList);
+        unset($json['id']);
+        return static::getTable()->insertGetId($json);
     }
 
     /**
-     * @param $query
-     * @return array
+     * @param $dbo LuDbo
+     * @param string[] $ignoreList
+     * @return int
      */
-    protected static function getQueryPredicate($query)
+    public static function editSingleById($dbo, $ignoreList = [])
     {
-        return array();
+        $json = static::prepareDbo($dbo, $ignoreList);
+        $id = $json['id'];
+        unset($json['id']);
+        return static::getTable()->where("id", "=", $id)->update($json);
     }
 
-    public static function getAll($page = 0, $perPage = PHP_INT_MAX, $query = "")
+    /**
+     * @param $dbo LuDbo
+     * @param $query Builder|callable
+     * @param string[] $ignoreList
+     * @return int
+     */
+    public static function editMultiple($dbo, $query, $ignoreList = [])
     {
-        $predicates = (is_null($query) || $query == "") ? array() : static::getQueryPredicate($query);
-        return self::getMultiple($predicates, static::getOrderBy(), $page, $perPage);
+        $query = static::resolveQuery($query);
+        $json = static::prepareDbo($dbo, $ignoreList);
+        return $query->update($json);
     }
 }

src/Utils/DataAccess/LuModel.php

-<?php
-
-namespace Luticate\Utils;
-
-use Illuminate\Database\Eloquent\Collection;
-use Illuminate\Database\Eloquent\Model;
-use Luticate\Utils\Dbo\LuDbo;
-
-/**
- * LuModel
- *
- * @method static LuModel where($column, $operator = null, $value = null, $boolean = 'and')
- * @method static LuModel orWhere($column, $operator = null, $value = null)
- * @method static LuModel orderBy($column, $direction = 'asc')
- * @method static LuModel take($value)
- * @method static LuModel offset($value)
- * @method static LuModel rightJoin($table, $first, $operator = null, $second = null)
- * @method static LuModel leftJoin($table, $first, $operator = null, $second = null)
- * @method static LuModel join($table, $one, $operator = null, $two = null, $type = 'inner', $where = false)
- * @method static LuModel groupBy(...$columns)
- * @method static LuModel[] get($columns = ['*'])
- * @method static LuModel first($columns = ['*'])
- * @method static LuModel find($id, $columns = ['*'])
- * @method static LuModel select($columns = ['*'])
- * @method static int count($columns = '*')
- */
-abstract class LuModel extends Model
-{
-    /**
-     * Mapping from DBO model to business model.
-     * If this model has no DBO equivalent, do nothing in this function
-     * @return LuDbo
-     */
-    public abstract function toDbo();
-
-    /**
-     * @param $dbo LuDbo
-     * @param $dal LuModel|null
-     * @return LuModel
-     */
-    public abstract function fromDbo($dbo, $dal = null);
-}

src/Utils/Dbo/LuDbo.php

     {
         return json_encode($this);
     }
-    
+
+    /**
+     * @return array
+     */
     public function jsonSerialize()
     {
         $json = [];
         $reflect = new \ReflectionClass(static::class);
         $properties = $reflect->getProperties();
         foreach ($properties as $property) {
-            $name = LuStringUtils::stringSnakeToCamelCase($property->getName(), true);
+            $name = LuStringUtils::snakeToCamelCase($property->getName(), true);
             $property->setAccessible(true);
             $value = $property->getValue($this);
             if (is_array($value)) {
             $dbo->checkConstraints($constraints);
             return $dbo->getString();
         }
-        else if ($type == "int") {
+        else if ($type == "int" || $type == "integer") {
             $dbo = LuIntDbo::jsonDeserialize($value);
             $dbo->checkConstraints($constraints);
             return $dbo->getInt();
             $dbo->checkConstraints($constraints);
             return $dbo->getFloat();
         }
-        else if ($type == "bool") {
+        else if ($type == "bool" || $type == "boolean") {
             $dbo = LuBoolDbo::jsonDeserialize($value);
             $dbo->checkConstraints($constraints);
             return $dbo->getBool();
         $properties = $reflect->getProperties();
         foreach ($properties as $property) {
             $parser = new LuPropertyDocParser($property->getDocComment());
-            $name = LuStringUtils::stringSnakeToCamelCase($property->getName(), true);
+            $name = LuStringUtils::snakeToCamelCase($property->getName(), true);
             $doc = $parser->parse();
             $type = is_null($doc) ? null : $doc->getType();
 

tests/DatabaseTest.php

+<?php
+use Luticate\Utils\Controller\LuticateApplication;
+use Illuminate\Database\Capsule\Manager as Capsule;
+use Luticate\Utils\DataAccess\LuDataAccess;
+use Luticate\Utils\Dbo\LuDbo;
+use Luticate\Utils\Dbo\LuDboDeserializeException;
+
+/**
+ * Created by PhpStorm.
+ * User: robin
+ * Date: 6/7/16
+ * Time: 2:57 PM
+ */
+
+class TestTableDbo extends LuDbo
+{
+    /**
+     * @var $_id int
+     */
+    private $_id;
+
+    /**
+     * @var $_someText string
+     */
+    private $_someText;
+
+    /**
+     * @var $_someIntegerArray int[]
+     */
+    private $_someIntegerArray;
+
+    /**
+     * @return int
+     */
+    public function getId()
+    {
+        return $this->_id;
+    }
+
+    /**
+     * @param int $id
+     */
+    public function setId($id)
+    {
+        $this->_id = $id;
+    }
+
+    /**
+     * @return string
+     */
+    public function getSomeText()
+    {
+        return $this->_someText;
+    }
+
+    /**
+     * @param string $someText
+     */
+    public function setSomeText($someText)
+    {
+        $this->_someText = $someText;
+    }
+
+    /**
+     * @return int[]
+     */
+    public function getSomeIntegerArray()
+    {
+        return $this->_someIntegerArray;
+    }
+
+    /**
+     * @param int[] $someIntegerArray
+     */
+    public function setSomeIntegerArray($someIntegerArray)
+    {
+        $this->_someIntegerArray = $someIntegerArray;
+    }
+}
+
+class TestTableDboArray extends LuDbo
+{
+    /**
+     * @var TestTableDbo[]
+     */
+    protected $_array;
+    public function getArray()
+    {
+        return $this->_array;
+    }
+    public function setArray($value)
+    {
+        $this->_array = $value;
+    }
+
+    public function jsonSerialize()
+    {
+        return $this->_array;
+    }
+
+    public static function jsonDeserialize($json)
+    {
+        if (!is_array($json)) {
+            throw new LuDboDeserializeException("Invalid array value");
+        }
+        $dbo = new self();
+        $array = [];
+        foreach ($json as $data) {
+            $array[] = TestTableDbo::jsonDeserialize($data);
+        }
+        $dbo->setArray($array);
+        return $dbo;
+    }
+
+    public static function generateSample()
+    {
+        return [
+            TestTableDbo::generateSample(),
+            TestTableDbo::generateSample()
+        ];
+    }
+
+}
+
+class TestTableDataAccess extends LuDataAccess
+{
+    protected static $_connection = "mydb";
+    protected static $_table = "test_table";
+    protected static $_dboClass = TestTableDbo::class;
+    protected static $_dboArrayClass = TestTableDboArray::class;
+}
+
+class DatabaseTest extends \PHPUnit_Framework_TestCase
+{
+    public function testSetup()
+    {
+//        $config = ['databases' => [
+//            [
+//                'name'      => 'mydb',
+//                'driver'    => 'pgsql',
+//                'host'      => '172.17.0.1',
+//                'database'  => 'luticate2',
+//                'username'  => 'dev',
+//                'password'  => 'dev'
+//            ]
+//        ]];
+//        $app = new LuticateApplication($config);
+//        $app->setupDatabases();
+        
+//        $dbo = new TestTableDbo();
+//        $dbo->setId(11);
+//        $dbo->setSomeIntegerArray('{}');
+//        $dbo->setSomeText("lol2");
+
+//        var_dump(TestTableDataAccess::getSingleById(1));
+//        var_dump(TestTableDataAccess::deleteMultiple(function($q)
+//        {
+//            return $q->where("some_text", "=", "lol");
+//        }));
+//        var_dump(TestTableDataAccess::addSingleId($dbo));
+//        var_dump(TestTableDataAccess::addSingle($dbo, ['Id']));
+//        var_dump(TestTableDataAccess::editSingleById($dbo));
+//        var_dump(TestTableDataAccess::editMultiple($dbo, function($q)
+//        {
+//            return $q->where("some_text", "like", "lol%");
+//        }, ['Id']));
+    }
+}