xNightR00T File Manager

<?php

namespace Application\Model;

use Zend\ServiceManager\ServiceManager;
use Application\Db\TableGateway;
use Application\Db\Connector;
use Application\Element;
use Zend\Db\Sql\Expression;
use Zend\Db\Sql\Predicate\Operator;
use Zend\Db\Sql\Select;
use Zend\Db\Sql\Where;
use Application\Model\ModelFactory;

/**
 * General Object for db store data use
 *
 */
abstract class ModelAbstract extends Element
{
    /**
     * Json to object fields
     * @var array
     */
    protected $jsonToObjectFields = array();

    /**
     * Check if object was inserted
     * @var boolean
     */
    protected $isNew = false;

    /**
     * Option column name
     * @var string|null
     */
    protected $optionColumn = null;

    /**
     * Init relation lazy loading list
     * @var array
     */
    protected $lazyLoadinRelationList = array();

    /**
     * Existing columns from table
     * @var array
     */
    protected $existingColumns = array();

    /**
     * Existing columns from table
     * @var array
     */
    protected $blacklistColumns = array();

    /**
     * Origin data from db
     * @var array|null
     */
    protected $originData = null;

    /**
     * Unique table column
     * @var type
     */
    protected $uniqueTableColumn = array();

    /**
     * Private columns
     * @var array
     */
    protected $privateColumns = array('password', 'pass', 'objectManager');

    /**
     * Public columns
     * @var array
     */
    protected $publicColumns = array();

    /**
     * Flag if to allow update
     * @var bool
     */
    protected $allowUpdate = true;

    /**
     * TableGatway
     * @var TableGatway
     */
    protected $tableGateway;

    /**
     * Hold the request
     * @var array
     */
    protected $getAllWithRelationsData = array(
        'where_count' => array(),
        'where' => array(),
        'relations' => array()
    );

    /**
     * boolean fields
     * @var array
     */
    protected $booleanFields = [];

    /**
     * ServiceManager object
     * @var ServiceManager
     */
    protected $serviceManager;
    protected $addRelationsOnSave = array();

    protected $createdAtColumn = 'created_at';
    protected $updatedAtColumn = 'updated_at';



    /**
     * Init the object
     * @param array/int $data
     * @param string $session - session name
     */
    public function setServiceManager(ServiceManager &$sm)
    {
        $this->serviceManager = $sm;
        $this->initTableGateway();
        $this->initConfig();
    }

    public function initTableGateway()
    {
        $this->tableGateway = new TableGateway($this->getTableName(),
            $this->getServiceManager()->get($this->getConnectorName()));
    }

    /**
     * Config relation function
     */
    protected function initConfig()
    {

    }

    /**
     * Select fields to save on serialize
     * @return type
     */
    public function __sleep()
    {
        return array('data', 'originData', 'existingColumns', 'jsonToObjectFields',
        );
    }

    public function __wakeup()
    {
        // $this->database = $this->objectManager->get('Arbel\Database');
    }

    /**
     * Return lazy loading relation array
     * @param $key - wanted relation to retrieve
     * @return array|null
     */
    public function getLazyLoadinRelationList($key = null)
    {
        if (isset($key)) {
            return $this->lazyLoadinRelationList[$key] ?? null;
        }
        return $this->lazyLoadinRelationList;
    }

    /**
     * Get public data
     * @return array
     */
    public function getPublicData(): array
    {
        $data   = $this->getData();
        $result = array();
        foreach ($data as $key => $val) {
            if (!empty($this->publicColumns) && in_array($key, $this->publicColumns)) {
                $result[$key] = $val;
            } elseif (empty($this->publicColumns) && !in_array($key, $this->privateColumns)) {
                $result[$key] = $val;
            }
            if (isset($result[$key]) && is_object($result[$key])) {
                if (is_a($result[$key], ModelAbstract::class)) {
                    $result[$key] = $result[$key]->getPublicData();
                } elseif (is_a($result[$key], JsonObject::class)) {
                    $result[$key] = $result[$key]->getData();
                } else {
                    unset($result[$key]);
                }
            }
        }
        return $result;
    }

    public function toArray():array
    {
         $data   = $this->getData();
        $result = array();
        foreach ($data as $key => $val) {
            if (isset($result[$key]) && is_object($result[$key])) {
                if (is_a($result[$key], ModelAbstract::class)) {
                    $result[$key] = $result[$key]->getPublicData();
                } elseif (is_a($result[$key], JsonObject::class)) {
                    $result[$key] = $result[$key]->getData();
                } else {
                    unset($result[$key]);
                }
            }elseif(!is_object($val)){
                $result[$key] = $val;
            }
        }
        return $result;
    }

    /**
     * Get public data with relations ids
     * @return array
     */
    public function getPublicDataWithRelationsIds()
    {
        $data = $this->getPublicData();
        foreach ($this->getAllRelationsList() as $key => $params) {
            $data[$key]    = [];
            $relationsData = $this->get($key);
            foreach ($relationsData as $relationObject) {
                $data[$key][] = $relationObject->getId();
            }
        }
        return $data;
    }

    /**
     * Check if object is exist
     * @return bool
     */
    public function isExist(): bool
    {
        return (bool) $this->getId();
    }

    /**
     * Add json to object field flag
     * @param string $fieldName
     */
    public function addJsonField(string $fieldName)
    {
        $this->jsonToObjectFields[] = $fieldName;
    }

    /**
     * Generate code value from other field
     * @param type $sourceField
     * @param type $targetField
     */
    public function generateCode($sourceField = 'name', $targetField = 'code')
    {
        $key = strtolower(str_replace(" ", "_", $this->get($sourceField)));
        $this->set($targetField, $key);
    }

    /**
     * Generate name value from other field
     * @param type $sourceField
     * @param type $targetField
     */
    public function generateName($sourceField = 'code', $targetField = 'name')
    {
        $key = ucfirst(str_replace("_", " ", $this->get($sourceField)));
        $this->set($targetField, $key);
    }

    /**
     * Get table object
     * @return TableGateway
     */
    public function getTableGateway()
    {
        return $this->tableGateway;
    }

    /**
     * Load Object From Database By Id
     * @param int/string $id
     */
    public function load($id)
    {
        return $this->loadByKey($this->getPrimaryKey(), $id);
    }

    public function convertJsonToObjectFields($data)
    {
        foreach ($this->jsonToObjectFields as $fieldName) {
            if (array_key_exists($fieldName, $data)) {
                $data[$fieldName] = new JsonObject($data[$fieldName]);
            }
        }
        return $data;
    }

    public function convertParamToObject($key, &$value)
    {
        if (in_array($key, $this->jsonToObjectFields) && !is_object($value)) {
            $value = new JsonObject($value);
        }
    }

    public function convertJsonToObject(string $json)
    {
        return new JsonObject($json);
    }

    /**
     * Duplicate object and remove primary key
     * @param array $newData
     * @return $object
     */
    public function duplicate(array $newData = array())
    {
        $data = $this->getFilterdData();
        if (isset($data[$this->getPrimaryKey()])) {
            unset($data[$this->getPrimaryKey()]);
        }
        $object = clone $this;
        $object->setData($data);
        $object->updateData($newData);
        return $object;
    }

    /**
     * Get value by key
     * @param string $key - key
     * @param mixed $default - default value that return when not exist
     * @return JsonObject or array
     */
    public function get(string $key, $default = null)
    {
        $result = parent::get($key, $default);
        if (in_array($key, $this->jsonToObjectFields) && !is_object($result)) {
            $result = new JsonObject($result);
            $this->set($key, $result);
        }
        return $result;
    }

    /**
     * Convert json object to json fields
     * @param array $data
     * @return array
     */
    public function convertObjectToJsonFields(array &$data): array
    {
        foreach ($this->jsonToObjectFields as $fieldName) {
            if (isset($data[$fieldName]) && is_object($data[$fieldName])) {
                $data[$fieldName] = (string) $data[$fieldName];
            }
        }
        return $data;
    }

    /**
     * Get date/time format of existing date/time value
     * @param string $key - targeted key of data
     * @param string $targetFormat - the target format - if null return timestamp
     * @return type
     */
    public function format(string $key, string $targetFormat = null)
    {
        $val = $this->get($key);
        if (is_numeric($val)) {
            $dateTime = new DateTime();
            $dateTime->setTimestamp($val);
        } elseif (!empty($val)) {
            if (strpos($val, ' ') !== false) {
                $dateTime = \DateTime::createFromFormat('Y-m-d H:i:s', $val);
            } elseif (strpos($val, '-') !== false) {
                $dateTime = \DateTime::createFromFormat('Y-m-d', $val);
            } else {
                $dateTime = \DateTime::createFromFormat('H:i:s', $val);
            }
        } else {
            return null;
        }
        if ($targetFormat) {
            return $dateTime->format($targetFormat);
        } else {
            return $dateTime->getTimestamp();
        }
    }

    /**
     * Get date/time object of existing date/time value
     * @param string $key - targeted key of data
     * @param string $targetFormat - the target format - if null return timestamp
     * @return type
     */
    public function datetime(string $key)
    {
        $val = $this->get($key);
        if (is_numeric($val)) {
            $dateTime = new \DateTime();
            $dateTime->setTimestamp($val);
        } elseif (!empty($val)) {
            if (strpos($val, ' ') !== false) {
                $dateTime = \DateTime::createFromFormat('Y-m-d H:i:s', $val);
            } elseif (strpos($val, '-') !== false) {
                $dateTime = \DateTime::createFromFormat('Y-m-d', $val);
            } else {
                $dateTime = \DateTime::createFromFormat('H:i:s', $val);
            }
        } else {
            return null;
        }
        return $dateTime;
    }

    /**
     * Return diff datetime from value
     * @param string $key
     * @param \DateTime $target
     * @return type
     */
    public function diff(string $key, \DateTime $target = null)
    {
        if (!isset($target)) {
            $target = new \DateTime();
        }
        $current = $this->datetime($key);
        return $current ? $current->diff($target) : null;
    }

    /**
     * Load Object From Database By Id
     * @param string $key
     * @param string $val
     */
    public function loadByKey(string $key, string $val)
    {
        $table = $this->getTableGateway();
        $data  = $table->select([$key => $val])->toArray();
        if (!empty($data)) {
            $data = $data[key($data)];
        }
        $table->getTableColumns();
        $this->initExistingColumns();
        $this->convertJsonToObjectFields($data);
        $this->originData = $data;
        $this->setData($data);
        if ($this->needToSaveInSession()) {
            $this->updateSession();
        }
        $this->init();

        return $this;
    }

    /**
     * Load Object From Database By params
     * @param Where|\Closure|string|array $data
     */
    public function loadBy($data)
    {
        $data             = $this->getTableGateway()->select($data)->toArray();
//        if (!empty($data) && is_numeric($data[key($data)])) {
//            $data = $data[key($data)];
//        }
        $this->initExistingColumns();
        $this->convertJsonToObjectFields($data);
        $this->originData = $data;
        $this->setData($data);
        if ($this->needToSaveInSession()) {
            $this->updateSession();
        }
        $this->init();

        return $this;
    }

    /**
     * Init object by Key
     * @param string $key
     * @param string $val
     * @return className
     */
    public function initByKey(string $key, string $val)
    {
        $className = get_class($this);
        $object    = $this->getModel($className);
        $object->loadByKey($key, $val);
        return $object;
    }

    /**
     * Init object by Params
     * @param array $params
     * @return className
     */
    public function initBy(array $params)
    {
        $className = get_class($this);
        $object    = $this->getModel($className);
        $object->loadBy($params);
        return $object;
    }

    /**
     * Init object by Id
     * @param string $id
     * @return ModelAbstract
     */
    public function initById(string $id)
    {
        $className = get_class($this);
        return $this->getModel($className)->initByKey($this->getModel($className)->getPrimaryKey(), $id);
    }

    /**
     * Check if the data was change from the last loading
     * @return boolean
     */
    public function hasChanged()
    {

        $originData = $this->originData;
        if (isset($originData)) {
            $this->removeBlacklistColumns($originData);
        }
        $currentData = $this->getFilterdData();
        return ($originData != $currentData);
    }

    /**
     * Init existing columns
     * @param array $data - data that load from db
     */
    public function initExistingColumns(array $data = null)
    {
        if (!empty($this->existingColumns)) {
            return;
        }
        if (isset($data)) {
            $this->existingColumns = array_keys($data);
        } else {
            $this->existingColumns = $this->getTableGateway()
                ->getTableColumns();
        }
    }

    /**
     * Get existing columns
     * @return array - get existing columns from db
     */
    public function getExistingColumns(): array
    {
        if (empty($this->existingColumns)) {
            $this->initExistingColumns();
        }
        return $this->existingColumns;
    }

    /**
     * Check if column name exist in the db
     * @param string $key
     * @return bool
     */
    public function isExistingColumn(string $key): bool
    {
        return array_key_exists($key, $this->existingColumns);
    }

    /**
     * Set data and run init function
     * @param mixed $data
     * @param mixed $value
     * @return $this
     */
    public function setData($data, $value = null)
    {
        parent::setData($data, $value);
        $this->init();
        return $this;
    }

    /**
     * Empty function for override option that will called when the object is loaded
     */
    public function init()
    {

    }

    /**
     * Get collection of objects
     * @param array | Where $params - filter conditions :
     * example 1 : array('key' => val)
     * example 2 : array('key' => array('>','now()'))
     *
     * @param string $orderBy - order by string
     * @param array $joinParams - example - array (array('right',['alias' => 'table_name'], 't.a = main_s.b'))
     * @param array $byKey - the value key to get the objects
     * @param array $limit - limit number of rows
     * @return ModelAbstract[] - collections of objects
     */
    public function getAll($params = array(), string $orderBy = null, array $joinParams = null, int $limit = null,
                           int $offset = null)
    {
        $result    = array();
        $className = get_class($this);
        $queryResult = $this->getTableGateway()->getAll($params, $orderBy, $joinParams,$limit, $offset);
        foreach ($queryResult as $row) {
             $result[] = $this->getModel($className)->factory((array)$row);
        }
        return $result;
    }

    /**
     * Delete all by params
     * @param type $params
     * @return int number of deleted
     */
    public function deleteAll(array $params)
    {
        $className = get_class($this);

        /** @var Database $table */
        $table = $this->getModel($className)->getTableGateway();
        $table->delete($params);
        return $table->lastRowCount;
    }

    /**
     * Get one object
     * @param array $params - filter conditions
     * @param string $orderBy - order by string
     * @param array $joinParams - example - array (array('join','table as t', 't.a = main_s.b'))
     * @return Object/null
     */
    public function getOne(array $params = array(), string $orderBy = null, array $joinParams = null, $byKey = null)
    {
        $result = $this->getAll($params, $orderBy, $joinParams, $byKey, 1);
        if (!empty($result)) {
            return current($result);
        } else {
            return null;
        }
    }

    /**
     * Get Primary key value
     * @return string
     */
    public function getId()
    {
        return $this->get($this->getPrimaryKey());
    }

    /**
     *
     * @param string $val
     * @return $this
     */
    public function setId($val)
    {
        return $this->set($this->getPrimaryKey(), $val);
    }

    /**
     * Get all result by sql
     * @return  []
     */
    public function sql(string $sql, array $params = [])
    {
        $className   = get_class($this);
        $tableResult = $this->getTableGateway()->getAdapter()->query($sql, $params);
        $result      = [];
        foreach ($tableResult as $row) {
            $clone    = clone ($this);
            $result[] = $clone->setData($row);
        }
        return $result;
    }

    /**
     * get select with where
     * @param type $whereParam
     * @return \Arbel\Base\Sql\Select
     */
    public function where($whereParam, $combination = \Zend\Db\Sql\Predicate\PredicateSet::OP_AND): \Arbel\Base\Sql\Select
    {
        $className = get_class($this);
        return $this->getModel($className)->select()->where($whereParam, $combination);
    }

    /**
     * Get Primary Key
     * @return string - key
     */
    abstract static function getPrimaryKey(): string;

    /**
     * Remove object from database
     */
    public function delete()
    {
        $this->getTableGateway()
            ->delete([
                $this->getPrimaryKey() =>
                $this->getId()
                ]
        );
    }

    /**
     * Set data and run init
     * If set relation object the update the relation id
     * @param string $key
     * @param mixed $val
     * @return $this
     */
    public function set(string $key, $val)
    {
        $this->convertParamToObject($key, $val);

        return parent::set($key, $val);
    }

    /**
     * Remove relation data
     * @param array $data
     */
    public function removeNonExistingColumns(array &$data)
    {
        $exitingColumns = $this->getExistingColumns();
        foreach ($data as $key => $rowData) {
            if (!array_key_exists($key, $exitingColumns)) {
                unset($data[$key]);
            }
        } 
    }

    /**
     * Remove relation data
     * @param array $data
     */
    public function removeBlacklistColumns(array &$data)
    {
        $blacklistColumns = $this->blacklistColumns;
        foreach ($data as $key => $rowData) {
            if (in_array($key, $blacklistColumns)) {
                unset($data[$key]);
            }
        }
    }

    /**
     * Get filtered data for saving db
     * @return mixed
     */
    public function getFilterdData()
    {
        $data = $this->getData();
        $this->convertObjectToJsonFields($data);
        $this->removeNonExistingColumns($data);
        $this->removeBlacklistColumns($data);
        if (isset($data[$this->getPrimaryKey()])) {
            unset($data[$this->getPrimaryKey()]);
        }
        return $data;
    }

    /**
     * Check if is new object
     * @return bool
     */
    public function isNew(): bool
    {
        return $this->isNew;
    }

    /**
     * Get Object Table Name
     */
    abstract static public function getTableName(): string;

    /**
     * Get Connector Name
     */
    abstract static public function getConnectorName(): string;

    /**
     * Init created at fileds
     */
    public function initTimeFields(){
        $exitingColumns = $this->getExistingColumns();
        if(!$this->getId() && $this->createdAtColumn && isset($exitingColumns[$this->createdAtColumn])){
            if($exitingColumns[$this->updatedAtColumn] == TableGateway::INTEGER_COLUMN_TYPE){
                $this->set($this->createdAtColumn,time());
            }else{
                $this->set($this->createdAtColumn,date("Y-m-d H:i:s"));
            }
        }
        if($this->updatedAtColumn && isset($exitingColumns[$this->updatedAtColumn])){
            if($exitingColumns[$this->updatedAtColumn] == TableGateway::INTEGER_COLUMN_TYPE){
                $this->set($this->updatedAtColumn,time());
            }else{
                $this->set($this->updatedAtColumn,date("Y-m-d H:i:s"));
            }
        }
    }

    /**
     * Save the object after check if object already exist
     * @param bool $isInsertOrUpdate- is to update when key exist
     * @param bool $isInsertIfNoExist- is ignore
     * @return ModelAbstract
     */
    public function save(bool $isInsertOrUpdate = false, bool $isInsertIfNoExist = false)
    {
        $this->initTimeFields();
        if (!$this->getId() && $this->hasUniqueFields()) {
            $dataFromDb = $this->getDataByUniqueFields();
            if (!empty($dataFromDb)) {
                $this->addData($dataFromDb);
            }
        }

        if (!$this->getId() && $isInsertIfNoExist) {
            $this->insertIfNoExist();
        } elseif (!$this->getId() && $isInsertOrUpdate && $this->allowUpdate) {
            $this->insertOrUpdate();
        } elseif ($this->getId() && $this->allowUpdate) {
            $this->update();
        } elseif (!$this->getId()) {
            $this->insert();
        }
        if (!$this->get('created_at')) {
            $this->set('created_at', date("Y-m-d H:i:s"));
            $this->set('updated_at', date("Y-m-d H:i:s"));
        }

        return $this;
    }

    /**
     * Create new of current object
     * @return ModelAbstract
     */
    public function create()
    {
        $name = get_class($this);
        return $this->getModel($name);
    }

    /**
     * Insert row on the database
     * @return $this
     */
    public function insert()
    {
        $data  = $this->getFilterdData();
        $table = $this->getTableGateway();
        $id    = $table->insert($data);
        $this->setId($id);
        if ($id) {
            $this->isNew = true;
        }
        return $this;
    }

    /**
     * Insert row on the database
     * @return $this
     */
    public function insertOrUpdate()
    {
        $data        = $this->getFilterdData();
        $changedData = $this->getChangedData();
        $table       = $this->getTableGateway();
        $id          = $table->insert(
            $this->getTableName()
            , $data, $changedData);
        $this->setId($id);
        if ($id) {
            $this->isNew = true;
        }
        return $this;
    }

    /**
     * Insert ignore row on the database
     * @return $this
     */
    public function insertIfNoExist()
    {
        $data  = $this->getFilterdData();
        $table = $this->getTableGateway();
        $id    = $table->insert(
            $this->getTableName()
            , $data, array(), true);
        $this->setId($id);
        if ($id) {
            $this->isNew = true;
        }
        return $this;
    }

    /**
     * Get changed data only
     * @return array
     */
    public function getChangedData(): array
    {
        $result = array();
        $data   = $this->getFilterdData();

        foreach ($data as $key => $val) {
            if ($this->originData && isset($this->originData[$key]) &&
                $this->originData[$key] != $val || (!$this->originData || !isset($this->originData[$key]))) {
                $result[$key] = $val;
            }
        }
        return $result;
    }

    /**
     * Update row on the database
     * if is no change then skip the update
     */
    public function update()
    {
        $data  = $this->getChangedData();
        $table = $this->getTableGateway();
        unset($data[$this->getPrimaryKey()]);
        if (!empty($data)) {
            $table->update(
                $data, array($this->getPrimaryKey() => $this->getId()));
        }
        return $this;
    }

    /**
     * Update all rows
     * @param array $whereParams
     * @param array $newData
     */
    public function updateAll(array $whereParams, array $newData)
    {
        $table     = $this->getTableGateway();
        $table->update($newData,$whereParams);
    }

    /**
     * Get data by unique fields
     * @return array - sql result
     */
    public function getDataByUniqueFields()
    {
        $uniqueFields = $this->getUniqueFields();
        $table        = $this->getTableGateway();
        $dataFromDb   = $table->getAll($uniqueFields);
        return $dataFromDb;
    }

    /**
     * Check if has unique fields
     * @return bool
     */
    public function hasUniqueFields(): bool
    {
        $uniqueFields = $this->getUniqueFields();
        return !empty($uniqueFields);
    }

    /**
     * Get unique fields data
     * @return array - result
     */
    public function getUniqueFields(): array
    {
        $data   = $this->getFilterdData();
        $result = $this->getValuesByKeys($this->uniqueTableColumn, $data);
        return $result;
    }

    /**
     * General function that create instances
     * @param array $data
     * @return type
     */
    public function factory(array $data = array())
    {
        return $this->setData($data);
    }

    /**
     * Get object manager
     * @return ServiceManager
     */
    public function getServiceManager()
    {
        return $this->serviceManager;
    }

    /**
     * Alias name for get object manager
     * @param string $modelName
     * @return ModelAbstract
     */
    public function getModel(string $modelName)
    {
        return $this->getServiceManager()->get(ModelFactory::class)->init($modelName);
    }
}