api-utils/src/Utils/DataAccess/LuDataAccess.php

<?php

namespace Luticate\Utils\DataAccess;

use Illuminate\Database\Capsule\Manager as Capsule;
use Illuminate\Database\Connection;
use Illuminate\Database\Query\Builder;
use Luticate\Utils\Business\LuArrayUtils;
use Luticate\Utils\Business\LuStringUtils;
use Luticate\Utils\Dbo\LuDbo;
use Luticate\Utils\Dbo\LuPaginatedDbo;

abstract class LuDataAccess implements LuDatabaseProvider {

    protected static $_connection = "mydb";
    protected static $_table = "mydb_table";
    protected static $_table_as = "__t__";
    protected static $_dboClass = LuDbo::class;
    protected static $_dboArrayClass = null;
    protected static $_dboIgnoreList = [];

    public static function setupDatabases($databases)
    {
        $capsule = new Capsule;
        foreach ($databases as $database) {

            if ($database['driver'] == 'pgsql' || $database['driver'] == 'mysql' ||
                $database['driver'] == 'sqlite' || $database['driver'] == 'sqlsrv') {
                $default = [
                    'name'      => 'mydb',
                    'host'      => '172.17.0.1',
                    'database'  => 'luticate2',
                    'username'  => 'dev',
                    'password'  => 'dev',
                    'charset'   => 'utf8',
                    'collation' => 'utf8_unicode_ci',
                    'prefix'    => ''
                ];
                $db = array_merge($default, $database);
                $capsule->addConnection($db, $database['name']);
            }
        }
        $capsule->setAsGlobal();
    }

    public static function transact(\Closure $function)
    {
        return static::getConnection()->transaction($function);
    }

    /**
     * @return \PDO
     */
    public static function getPdo()
    {
        return self::getConnection()->getPdo();
    }

    /**
     * @return Connection
     */
    public static function getConnection()
    {
        return Capsule::connection(static::$_connection);
    }

    /**
     * @return Builder
     */
    public static function getTableAs()
    {
        return static::getConnection()->table(static::$_table . " as " . static::$_table_as);
    }

    /**
     * @return Builder
     */
    public static function getTable()
    {
        return static::getConnection()->table(static::$_table);
    }

    public static function getDboClassArray()
    {
        if (is_null(static::$_dboArrayClass)) {
            return static::$_dboClass . "[]";
        }
        return static::$_dboArrayClass;
    }

    /**
     * @param $query Builder|callable
     * @return Builder
     */
    public static function resolveQuery($query)
    {
        if (is_callable($query)) {
            $query = $query(static::getTableAs());
        }
        else if (is_null($query)) {
            return static::getTableAs();
        }
        return $query;
    }

    /**
     * @param $dbo LuDbo
     * @param array $ignoreList
     * @return array
     */
    public static function prepareDbo($dbo, $ignoreList = [])
    {
        $json = $dbo->jsonSerialize();
        foreach (array_merge(static::$_dboIgnoreList, $ignoreList) as $ignore) {
            unset($json[$ignore]);
        }
        $json = LuArrayUtils::camelCaseToSnake($json);
        return $json;
    }
    
    public static function getData($query)
    {
        $query = static::resolveQuery($query);
        $sql = $query->toSql();
        $string = static::getConnection()->select("WITH query AS (${sql}) SELECT COALESCE(json_agg(data), '[]'::json) AS data FROM query data", $query->getBindings())[0]->data;

        $data = LuStringUtils::convertJsonString($string);
        return $data;
    }

    /**
     * @param $query Builder|callable
     * @return LuDBo[]
     */
    public static function getMultiple($query)
    {
        $data = static::getData($query);
        
        return LuDbo::deserializeValue($data, static::$_dboClass . "[]");
    }

    /**
     * @param $query Builder|callable
     * @return LuDBo
     */
    public static function getSingle($query)
    {
        $data = static::getData($query);
        
        if (count($data) < 1) {
            return null;
        }

        return LuDbo::deserializeValue($data[0], static::$_dboClass);
    }
    
    public static function getMultiplePaginated($query, $page, $perPage)
    {
        $query = static::resolveQuery($query);
        $sql = $query->toSql();
        $count = static::getConnection()->select("WITH query AS (${sql}) SELECT count(data) AS data FROM query data", $query->getBindings())[0]->data;
        $query->take($perPage)->offset($page * $perPage);
        $data = self::getMultiple($query);
        return new LuPaginatedDbo($count, $data);
    }

    /**
     * @param $id
     * @return LuDbo
     */
    public static function getSingleById($id)
    {
        return static::getSingle(static::getTableAs()->where("id", "=", $id));
    }

    /**
     * @param $id
     * @return int
     */
    public static function deleteSingleById($id)
    {
        return static::getTableAs()->delete($id);
    }

    /**
     * @param $query Builder|callable
     * @return int
     */
    public static function deleteMultiple($query)
    {
        $query = static::resolveQuery($query);
        return $query->delete();
    }

    /**
     * @param $dbo LuDbo
     * @param string[] $ignoreList
     * @return bool
     */
    public static function addSingle($dbo, $ignoreList = [])
    {
        $json = static::prepareDbo($dbo, $ignoreList);
        return static::getTable()->insert($json);
    }

    /**
     * @param $dbo LuDbo
     * @param string[] $ignoreList
     * @return int
     */
    public static function addSingleId($dbo, $ignoreList = [])
    {
        $json = static::prepareDbo($dbo, $ignoreList);
        unset($json['id']);
        return static::getTable()->insertGetId($json);
    }

    /**
     * @param $dbo LuDbo
     * @param int $id
     * @param string[] $ignoreList
     * @return int
     */
    public static function editSingleById($dbo, $id = null, $ignoreList = [])
    {
        $json = static::prepareDbo($dbo, $ignoreList);
        if (is_null($id)) {
            $id = $json['id'];
            unset($json['id']);
        }
        return static::getTable()->where("id", "=", $id)->update($json);
    }

    /**
     * @param $dbo LuDbo
     * @param $query Builder|callable
     * @param string[] $ignoreList
     * @return int
     */
    public static function editMultiple($dbo, $query, $ignoreList = [])
    {
        $query = static::resolveQuery($query);
        $json = static::prepareDbo($dbo, $ignoreList);
        return $query->update($json);
    }
}