631 lines
21 KiB
PHP
Executable File
631 lines
21 KiB
PHP
Executable File
<?php
|
|
|
|
namespace ORM;
|
|
|
|
abstract class Entity {
|
|
|
|
const _tableName = '';
|
|
const _connectionName = 'default';
|
|
const _softdelete = false;
|
|
const _ignore = Array(
|
|
'classname',
|
|
'_properties',
|
|
'_ignore',
|
|
'_connectionName',
|
|
'_timestamps',
|
|
'_softdelete',
|
|
'_tableName',
|
|
'_idPolice',
|
|
'_ignore'
|
|
);
|
|
const _properties = Array();
|
|
|
|
/*
|
|
* [type] = nextval| manual | empty is the default
|
|
* [max] = maximum value allowed
|
|
* [min] = minumul value allowed
|
|
* [step] = increment by n each id
|
|
*/
|
|
const _idPolice = Array();
|
|
|
|
function __construct($assignment = '') {
|
|
|
|
@$this->_ignore = array_merge($this->_ignore, self::_ignore);
|
|
|
|
if (isset($this->_timestamps) && $this->_timestamps) {
|
|
$this->created_at = date('Y-m-d h:m:s');
|
|
$this->updated_at = date('Y-m-d h:m:s');
|
|
}
|
|
|
|
// Mass Assign
|
|
if(is_array($assignment)){
|
|
$this->charge($assignment);
|
|
}
|
|
}
|
|
|
|
public function __set($property, $value) {
|
|
if (in_array($property, static::_ignore)) {
|
|
return;
|
|
}
|
|
$this->$property = $value;
|
|
}
|
|
|
|
public function __get($key) {
|
|
if (!isset($this->$key)) {
|
|
return 0;
|
|
}
|
|
return $this->$key;
|
|
}
|
|
|
|
public function __toString() {
|
|
if (isset($this->name)) {
|
|
return $this->name;
|
|
}
|
|
if (isset($this->nome)) {
|
|
return $this->nome;
|
|
}
|
|
return static::class;
|
|
}
|
|
|
|
/*public function __call($name, $arguments){
|
|
dd($name);
|
|
}*/
|
|
|
|
public function charge($payload) {
|
|
|
|
$properties = [];
|
|
|
|
foreach( get_object_vars($this) as $key => $property){
|
|
if(substr($key, 0, 1) != '_'){
|
|
$properties[] = $key;
|
|
}
|
|
}
|
|
|
|
$elements = array_diff(array_merge($properties, static::_properties), self::_ignore);
|
|
|
|
foreach ($elements as $key => $property) {
|
|
if ($property == 'id' && !isset($payload[$property])) {
|
|
continue;
|
|
}
|
|
if(empty($payload[$property])){
|
|
continue;
|
|
}
|
|
$this->$property = $payload[$property];
|
|
}
|
|
return [];
|
|
}
|
|
|
|
public static function get_properties() {
|
|
$properties = Array();
|
|
foreach (static::_properties as $propertie) {
|
|
$obj = new \stdClass();
|
|
$obj->data = $propertie;
|
|
$properties[] = $obj;
|
|
}
|
|
return json_encode($properties);
|
|
}
|
|
|
|
public function save() {
|
|
if (isset($this->id)) {
|
|
$this->update();
|
|
} else {
|
|
$this->create();
|
|
}
|
|
}
|
|
|
|
private function update() {
|
|
//First check if the record exist. If not, we might have a idPolice
|
|
if (!DBInstance::queryOne("SELECT id FROM {" . static::_tableName . "} WHERE id = ?", Array($this->id))) {
|
|
$this->create();
|
|
return;
|
|
}
|
|
|
|
$updatekeys = static::_ignore;
|
|
$updatekeys[] = 'id';
|
|
$columns = array_diff(array_keys(get_object_vars($this)), $updatekeys);
|
|
$obj = (array) $this;
|
|
|
|
$update_string = '';
|
|
$update_data = Array();
|
|
$update_data['_update_id'] = $this->id;
|
|
|
|
if (isset($this->_timestamps) && $this->_timestamps) {
|
|
$this->updated_at = date('Y-m-d h:m:s');
|
|
}
|
|
|
|
foreach ($columns as $column) {
|
|
$update_string .= $column . " = :$column, ";
|
|
$update_data[$column] = $obj[$column];
|
|
}
|
|
|
|
$update_string = rtrim($update_string, ', ');
|
|
|
|
$sql = "UPDATE {" . static::_tableName . "} SET $update_string WHERE id = :_update_id";
|
|
DBInstance::execute($sql, $update_data, static::_connectionName);
|
|
}
|
|
|
|
private function create() {
|
|
//First, let's verify id polices
|
|
//Manual and empty don't need special treatments
|
|
if (!empty(static::_idPolice) && static::_idPolice['type'] != 'manual') {
|
|
//Get the actual max value of the key
|
|
$maxVal = DBInstance::queryOne("SELECT max(id) as id FROM {" . static::_tableName . "}");
|
|
$maxVal = ($maxVal) ? $maxVal : 0;
|
|
|
|
// If the next val is smaller than the minumum value
|
|
if (isset(static::_idPolice['min']) && static::_idPolice['min'] > $maxVal->id + 1) {
|
|
// The id value shpuld assume the min value
|
|
$this->id = static::_idPolice['min'];
|
|
} else {
|
|
// The id is bigger than the min or min is not set
|
|
if (isset(static::_idPolice['step'])) {
|
|
//If sted is defined, increment by step multiples
|
|
$this->id = $maxVal->id + static::_idPolice['step'];
|
|
} else {
|
|
$this->id = $maxVal->id + 1;
|
|
}
|
|
}
|
|
//If the id is bigger than the max value. There is problems
|
|
if (isset(static::_idPolice['max']) && $maxVal->id > static::_idPolice['max']) {
|
|
//Do not store the register
|
|
return false;
|
|
}
|
|
}
|
|
|
|
$columns = array_diff(array_keys(get_object_vars($this)), static::_ignore);
|
|
$obj = (array) $this;
|
|
|
|
$first_argument = '';
|
|
$second_argument = '';
|
|
$insert_data = Array();
|
|
|
|
foreach ($columns as $column) {
|
|
$first_argument .= $column . ', ';
|
|
|
|
$insert_data[$column] = $obj[$column];
|
|
$second_argument .= ":$column, ";
|
|
}
|
|
|
|
$first_argument = rtrim($first_argument, ', ');
|
|
$second_argument = rtrim($second_argument, ', ');
|
|
|
|
$sql = "INSERT INTO {" . static::_tableName . "} ($first_argument) VALUES ($second_argument)";
|
|
|
|
DBInstance::execute($sql, $insert_data, static::_connectionName);
|
|
// If there is a id pollice applied, do not get the inserted id
|
|
if (empty(static::_idPolice)) {
|
|
$this->id = DBInstance::lastInsert();
|
|
}
|
|
}
|
|
|
|
|
|
public function load($id = false) {
|
|
if (!$id) {
|
|
return;
|
|
}
|
|
|
|
$sql = "SELECT * FROM {" . static::_tableName . "} WHERE id = ?";
|
|
|
|
$this->fill(DBInstance::queryPrepare($sql, Array($id), static::_connectionName)[0]);
|
|
}
|
|
|
|
public function delete() {
|
|
if (isset($this->_softdelete) && $this->_softdelete) {
|
|
$this->deleted_at = date('Y-m-d h:m:s');
|
|
$this->update();
|
|
}else{
|
|
$this->purge();
|
|
}
|
|
}
|
|
|
|
public function purge() {
|
|
$sql = "DELETE FROM {" . static::_tableName . "} WHERE id = :id";
|
|
DBInstance::execute($sql, Array('id' => $this->id), static::_connectionName);
|
|
}
|
|
|
|
public function restore(){
|
|
if (isset($this->_softdelete) && $this->_softdelete) {
|
|
$this->deleted_at = null;
|
|
$this->update();
|
|
}else{
|
|
throw new \Exception('Not soft deleteble');
|
|
}
|
|
}
|
|
|
|
private function fill($data) {
|
|
$data = (array) $data;
|
|
|
|
foreach ($data as $key => $value) {
|
|
$this->$key = $value;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Find All
|
|
*
|
|
* This method will load all instances from the class.
|
|
* Limits are avaliable for paginations.
|
|
*
|
|
* @param Array $select Columns to select. Array('id', 'name')
|
|
* @param Array $limits Array( 'offset'=> 10, 'limit' => 10 )
|
|
* @param boolean $trashed Bring trashed elements?
|
|
*/
|
|
public static function findAll($select = Array('*'), $limits = Array(), $trashed = false) : Collection {
|
|
$criteria = '';
|
|
$limits_sql = '';
|
|
|
|
foreach ($select as $value) {
|
|
$criteria .= $value . ', ';
|
|
}
|
|
|
|
$criteria = rtrim($criteria, ', ');
|
|
|
|
foreach ($limits as $key => $value) {
|
|
$limits_sql .= "$key $value ";
|
|
}
|
|
|
|
if (static::_softdelete && !$trashed) {
|
|
$sql = "SELECT $criteria FROM {" . static::_tableName . "} WHERE deleted_at is null $limits_sql";
|
|
} else {
|
|
$sql = "SELECT $criteria FROM {" . static::_tableName . "} $limits_sql";
|
|
}
|
|
|
|
$results = DBInstance::query($sql, Array(), static::_connectionName);
|
|
$objects = new Collection;
|
|
|
|
foreach ($results as $value) {
|
|
$static = static::class;
|
|
$object = new $static;
|
|
$object->fill($value);
|
|
$objects->addItem($object);
|
|
}
|
|
return $objects;
|
|
}
|
|
|
|
/**
|
|
* Count
|
|
*
|
|
* Count how many records there is on the database
|
|
* in relation with this class with the parameters filter
|
|
*
|
|
* @param Array $criterias Criteras for WHERE Array('id' => Array('=', 10) )
|
|
* @param boolean $trashed Bring trashed registers?
|
|
*
|
|
*/
|
|
public static function count($criterias = Array(), $trashed = false) {
|
|
$criteria_sql = "";
|
|
$criteria_data = Array();
|
|
foreach ($criterias as $key => $criteria) {
|
|
if ($criteria_sql != "") {
|
|
$criteria_sql .= " AND ";
|
|
} else {
|
|
$criteria_sql .= " WHERE ";
|
|
}
|
|
if (is_array($criteria[1])) {
|
|
$crit_temp = '';
|
|
foreach ($criteria[1] as $crit) {
|
|
$crit_temp .= '?, ';
|
|
$criteria_data[] = $crit;
|
|
}
|
|
$crit_temp = rtrim($crit_temp, ', ');
|
|
$criteria_sql .= "$key $criteria[0] ($crit_temp)";
|
|
} else {
|
|
$criteria_sql .= "$key $criteria[0] (?) ";
|
|
$criteria_data[] = $criteria[1];
|
|
}
|
|
}
|
|
if (static::_softdelete && !$trashed) {
|
|
$sql = "SELECT COUNT(*) FROM {" . static::_tableName . "} $criteria_sql AND deleted_at is null";
|
|
} else {
|
|
$sql = "SELECT COUNT(*) FROM {" . static::_tableName . "} $criteria_sql";
|
|
}
|
|
|
|
$results = DBInstance::queryOne($sql, $criteria_data, static::_connectionName);
|
|
return $results->count;
|
|
}
|
|
|
|
/**
|
|
* Find One
|
|
*
|
|
* @param Array/Int $criterias Array('id' => Array('in', Array(10, 20, 30)))
|
|
* @param Array $select Array(id, fullname)
|
|
* @param Boolan $trashed true, false
|
|
*/
|
|
public static function findOne($criterias = Array(), $select = Array('*'), $trashed = false) {
|
|
if(empty($criterias)){
|
|
$criterias = Array(1 => ['=', 1]);
|
|
}
|
|
|
|
$select_sql = "";
|
|
$criteria_sql = "";
|
|
$limits_sql = "";
|
|
$criteria_data = Array();
|
|
|
|
$limits = Array("LIMIT" => 1);
|
|
|
|
if (is_numeric($criterias)) {
|
|
$criteria_sql = "WHERE id = ? ";
|
|
$criteria_data[] = $criterias;
|
|
} else {
|
|
foreach ($criterias as $key => $criteria) {
|
|
if ($criteria_sql != "") {
|
|
$criteria_sql .= " AND ";
|
|
} else if ($criteria_sql == "") {
|
|
$criteria_sql .= " WHERE ";
|
|
} else {
|
|
$criteria_sql .= " ";
|
|
}
|
|
if (is_array($criteria[1])) {
|
|
$crit_temp = '';
|
|
foreach ($criteria[1] as $crit) {
|
|
$crit_temp .= '?, ';
|
|
$criteria_data[] = $crit;
|
|
}
|
|
$crit_temp = rtrim($crit_temp, ', ');
|
|
$criteria_sql .= "$key $criteria[0] ($crit_temp)";
|
|
} else {
|
|
$criteria_sql .= "$key $criteria[0] (?) ";
|
|
$criteria_data[] = $criteria[1];
|
|
}
|
|
}
|
|
}
|
|
foreach ($select as $value) {
|
|
$select_sql .= $value . ', ';
|
|
}
|
|
$select_sql = rtrim($select_sql, ', ');
|
|
|
|
foreach ($limits as $key => $value) {
|
|
$limits_sql .= "$key $value ";
|
|
}
|
|
|
|
if (static::_softdelete && !$trashed) {
|
|
$sql = "SELECT $select_sql FROM {" . static::_tableName . "} $criteria_sql AND deleted_at is null $limits_sql";
|
|
} else {
|
|
$sql = "SELECT $select_sql FROM {" . static::_tableName . "} $criteria_sql $limits_sql";
|
|
}
|
|
|
|
$results = DBInstance::query($sql, $criteria_data, static::_connectionName);
|
|
$objects = new Collection();
|
|
|
|
foreach ($results as $value) {
|
|
$class = static::class;
|
|
$object = new $class;
|
|
$object->fill($value);
|
|
$objects->addItem($object);
|
|
}
|
|
|
|
if (empty($objects)) {
|
|
return false; //new $this->classname;
|
|
}
|
|
|
|
return $objects[0];
|
|
}
|
|
|
|
/**
|
|
* Find Many
|
|
*
|
|
* @param Array $criterias Description
|
|
* @param Array $select Description
|
|
* @param Array $limits Description
|
|
* @param boolean $trashed Description
|
|
*
|
|
*/
|
|
public static function findMany($criterias = Array(), $select = Array('*'), $limits = Array(), $trashed = false) {
|
|
$select_sql = "";
|
|
$criteria_sql = "";
|
|
$limits_sql = "";
|
|
|
|
foreach ($limits as $key => $value) {
|
|
$limits_sql .= "$key $value ";
|
|
}
|
|
|
|
foreach ($criterias as $key => $criteria) {
|
|
if ($criteria_sql != "" && substr($criteria[0], 0, 2) == 'OR') {
|
|
$criteria_sql .= " ";
|
|
} else if ($criteria_sql != "" ) {
|
|
$criteria_sql .= " ";
|
|
} else if ($criteria_sql != "" ) {
|
|
$criteria_sql .= " AND ";
|
|
} else if ($criteria_sql == "") {
|
|
$criteria_sql .= " WHERE ";
|
|
} else {
|
|
$criteria_sql .= " ";
|
|
}
|
|
|
|
if (substr($criteria[0], 0, 2) == "OR") {
|
|
$criteria[0] = str_replace('OR', '', $criteria[0]);
|
|
$criteria_sql .= "OR $key $criteria[0] ('%$criteria[1]%')";
|
|
} else if (is_string($criteria[1])) {
|
|
$criteria_sql .= "$key $criteria[0] '$criteria[1]'";
|
|
} else if (is_array($criteria[1])) {
|
|
$criteria_sql .= "$key $criteria[0] (" . implode(', ', $criteria[1]) . ")";
|
|
} else {
|
|
$criteria_sql .= "$key $criteria[0] $criteria[1]";
|
|
}
|
|
}
|
|
|
|
$criteria_sql = str_replace('WHERE OR', 'WHERE ', $criteria_sql);
|
|
|
|
foreach ($select as $value) {
|
|
$select_sql .= $value . ', ';
|
|
}
|
|
|
|
$select_sql = rtrim($select_sql, ', ');
|
|
|
|
if (static::_softdelete && !$trashed) {
|
|
$sql = "SELECT $select_sql FROM {" . static::_tableName . "} $criteria_sql AND deleted_at is null $limits_sql";
|
|
} else {
|
|
$sql = "SELECT $select_sql FROM {" . static::_tableName . "} $criteria_sql $limits_sql";
|
|
}
|
|
|
|
$results = DBInstance::query($sql, Array(), static::_connectionName);
|
|
$objects = new Collection();
|
|
|
|
foreach ($results as $value) {
|
|
$class = static::class;
|
|
$object = new $class;
|
|
$object->fill($value);
|
|
$objects->addItem($object);
|
|
}
|
|
|
|
if (empty($objects)) {
|
|
return Array();
|
|
}
|
|
|
|
return $objects;
|
|
}
|
|
|
|
/**
|
|
* Has One Local
|
|
*
|
|
* Defines that, this object has a child an only one,
|
|
* object in other class.
|
|
*
|
|
* Table user = (id, name)
|
|
* Table phone = (id, number, userid)
|
|
*
|
|
* This relation will be created on the User class
|
|
* making reference to the Phone class
|
|
*
|
|
* @ctag $this->hasOne('foreign_object', 'field_in_remote');
|
|
*
|
|
* @param Object $foreign_object Class instance from the remote object
|
|
* @param (int, string) $field_in_remote Field in local object matchin the remote id
|
|
*
|
|
* @return Object Instance of the remote class
|
|
*
|
|
*/
|
|
protected function hasOne($foreign_object, $field_in_remote) {
|
|
return new HasOne($foreign_object, $field_in_remote, $this);
|
|
}
|
|
|
|
/**
|
|
* Has Many
|
|
*
|
|
* Defines that, this object has many instances of other Object
|
|
*
|
|
* Table Post = (id, name, content)
|
|
* Table Comment = (id, name, content, postid)
|
|
*
|
|
* This relation will be created on the Post class
|
|
* Making reference to the Comment class
|
|
*
|
|
* @ctag $this->hasMany('foreign_object', 'field_in_foreign');
|
|
*
|
|
* @param type $foreign_object Instance of a remote class
|
|
* @param (int, string) $field_in_foreign The field to match the local id
|
|
*
|
|
*/
|
|
protected function hasMany($foreign_object, $field_in_foreign) {
|
|
return new HasMany($foreign_object, $field_in_foreign, $this);
|
|
}
|
|
|
|
/**
|
|
* Belongs To
|
|
*
|
|
* Defines that, this object is part of an other class.
|
|
* The local field must match the id of an other class.
|
|
*
|
|
* Table Post = (id, name, content)
|
|
* Table Comment = (id, name, content, postid)
|
|
*
|
|
* This relation will be created on the comment class
|
|
* Making reference to the post class
|
|
*
|
|
* @ctag $this->belongsTo('foreign_object', 'local_field');
|
|
* @ctag $this->belongsTo('foreign_object', 'local_field', 'id');
|
|
*
|
|
* @param Object $foreign_object Instance of a remote class
|
|
* @param (int, String) $local_field Remote field relate to local Object
|
|
* @param string $remote_field
|
|
*/
|
|
protected function belongsTo($foreignObject, $localField, $remoteField = 'id') {
|
|
return new BelongsTo($foreignObject, $localField, $remoteField, $this);
|
|
}
|
|
|
|
/**
|
|
* Belongs to Many
|
|
*
|
|
* Defines that this object is related to many other instances
|
|
* of other classes throw a pivot table.
|
|
*
|
|
* Table Post = (id, name, content)
|
|
* Table Tag = (id, name)
|
|
* Table Post_Tag = (id, postid, tagid)
|
|
*
|
|
* This relation will be created in both classes
|
|
*
|
|
* @ctag $this->belongsToMany('foreign_object', 'pivot_table', 'local_in_pivot', 'remote_in_pivot');
|
|
* @ctag $this->belongsToMany('foreign_object', 'pivot_table', 'local_in_pivot', 'remote_in_pivot', $remote_filter = Array());
|
|
* @ctag $this->belongsToMany('foreign_object', 'pivot_table', 'local_in_pivot', 'remote_in_pivot', $remote_filter = Array(), $remote_limit = Array());
|
|
*
|
|
* @param Object $foreign_object Instance of the remote class
|
|
* @param string $pivot_table Name of the pivot table
|
|
* @param int $local_in_pivot Name of field on the pivot in relation of the local class
|
|
* @param int $remote_in_pivot Name of field on the pivot in relation of the remote class
|
|
* @param Array $remote_filter Filters to the remote Array('id', Array('>', 50) )
|
|
* @param Array $remote_limit Array( 'offset'=> 10, 'limit' => 10 )
|
|
*/
|
|
protected function belongsToMany($foreignObject, $pivot_table, $local_in_pivot, $remote_in_pivot, $remote_filter = Array(), $remote_limit = Array()) {
|
|
return new BelongsToMany($this, $foreignObject, $pivot_table, $local_in_pivot, $remote_in_pivot, $remote_filter, $remote_limit);
|
|
}
|
|
|
|
/**
|
|
* Belongs to Many Extended
|
|
*
|
|
* Defines that this object is related to many other instances
|
|
* of other classes throw a pivot table.
|
|
* This relation will bring the pivot table with the elements inside
|
|
*
|
|
* Table Post = (id, name, content)
|
|
* Table Tag = (id, name)
|
|
* Table Post_Tag = (id, postid, tagid)
|
|
*
|
|
* @ctag $this->belongsToManyExtended('foreign_object', 'pivot_table', 'local_in_pivot', 'remote_in_pivot');
|
|
* @ctag $this->belongsToManyExtended('foreign_object', 'pivot_table', 'local_in_pivot', 'remote_in_pivot', $remote_filter = Array());
|
|
* @ctag $this->belongsToManyExtended('foreign_object', 'pivot_table', 'local_in_pivot', 'remote_in_pivot', $remote_filter = Array(), $pivot_limits = Array());
|
|
*
|
|
* This relation will be created in both classes
|
|
*
|
|
* @param Object $foreign_object Instance of the remote class
|
|
* @param string $pivot_table Name of the pivot table
|
|
* @param int $local_in_pivot Name of field on the pivot in relation of the local class
|
|
* @param int $remote_in_pivot Name of field on the pivot in relation of the remote class
|
|
* @param Array $remote_filter Filters to the remote Array('id', Array('>', 50) )
|
|
* @param Array $pivot_limits Array( 'offset'=> 10, 'limit' => 10 )
|
|
*/
|
|
protected function belongsToManyExtended($foreignObject, $pivot_table, $local_in_pivot, $remote_in_pivot, $remote_filter = Array(), $pivot_limit = Array()) {
|
|
return new BelongsToManyExtended($this, $foreignObject, $pivot_table, $local_in_pivot, $remote_in_pivot, $remote_filter, $pivot_limit);
|
|
}
|
|
|
|
/**
|
|
* With
|
|
*
|
|
* Eager load relations on this entity
|
|
*
|
|
**/
|
|
public function with($relations = null, $propagate = null){
|
|
if(is_string($relations)){
|
|
$relations = [$relations];
|
|
}
|
|
|
|
if(!$relations){
|
|
return $this;
|
|
}
|
|
|
|
$possibleRelations = get_class_methods(static::class);
|
|
|
|
foreach($relations as $relation){
|
|
if(in_array($relation, $possibleRelations)){
|
|
$this->$relation = $this->$relation()->get();
|
|
}
|
|
if($this->$relation){
|
|
$this->$relation->with($propagate);
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
}
|