Cleanup
This commit is contained in:
@ -1,156 +0,0 @@
|
||||
<?php
|
||||
namespace ProVM\Common\Alias;
|
||||
|
||||
use \Model as BaseModel;
|
||||
use ProVM\Common\Define\Model as ModelInterface;
|
||||
use ProVM\Common\Factory\Model as ModelFactory;
|
||||
|
||||
abstract class Model extends BaseModel implements ModelInterface {
|
||||
const SELF_KEY = 'self_key';
|
||||
const PARENT_KEY = 'parent_key';
|
||||
const CHILD_KEY = 'child_key';
|
||||
const SIBLING_KEY = 'sibling_key';
|
||||
const SELF_CONNECT_KEY = 'self_connect_key';
|
||||
const SIBLING_CONNECT_KEY = 'sibling_connect_key';
|
||||
|
||||
public function getTable(): string {
|
||||
return static::$_table;
|
||||
}
|
||||
|
||||
protected $factory;
|
||||
public function setFactory(ModelFactory $factory): ModelInterface {
|
||||
$this->factory = $factory;
|
||||
return $this;
|
||||
}
|
||||
|
||||
protected function checkDefinitions(array $definitions, array $required, array $default) {
|
||||
foreach ($default as $key => $value) {
|
||||
if (!isset($definitions[$key])) {
|
||||
$definitions[$key] = $value;
|
||||
}
|
||||
}
|
||||
foreach ($required as $definition) {
|
||||
if (!isset($definitions[$definition])) {
|
||||
$trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 1);
|
||||
throw new \InvalidArgumentException($definition . ' is required for ' . $trace[1]['function'] . ' in ' . get_called_class());
|
||||
}
|
||||
}
|
||||
return $definitions;
|
||||
}
|
||||
public function parentOf(string $child_model_class, array $relation_definitions): ?array {
|
||||
$relation_definitions = $this->checkDefinitions($relation_definitions, [
|
||||
Model::SELF_KEY,
|
||||
Model::CHILD_KEY
|
||||
], [
|
||||
Model::SELF_KEY => 'id'
|
||||
]);
|
||||
return $this->factory
|
||||
->find($child_model_class)
|
||||
->where([
|
||||
[
|
||||
$relation_definitions[Model::CHILD_KEY],
|
||||
$this->{$relation_definitions[Model::SELF_KEY]}
|
||||
]
|
||||
])
|
||||
->many();
|
||||
}
|
||||
public function childOf(string $parent_model_class, array $relation_definitions): ?ModelInterface {
|
||||
$relation_definitions = $this->checkDefinitions($relation_definitions, [
|
||||
Model::SELF_KEY,
|
||||
Model::PARENT_KEY
|
||||
], [
|
||||
Model::PARENT_KEY => 'id'
|
||||
]);
|
||||
$parent_table = (new $parent_model_class())->getTable();
|
||||
return $this->factory
|
||||
->find($parent_model_class)
|
||||
->where([
|
||||
[
|
||||
$relation_definitions[Model::PARENT_KEY],
|
||||
$this->{$relation_definitions[Model::SELF_KEY]}
|
||||
]
|
||||
])
|
||||
->one();
|
||||
}
|
||||
public function siblingOf(string $sibling_model_class, string $connecting_table, array $relation_definitions): ?array {
|
||||
$relation_definitions = $this->checkDefinitions($relation_definitions, [
|
||||
Model::SELF_KEY,
|
||||
Model::SIBLING_KEY,
|
||||
Model::SELF_CONNECT_KEY,
|
||||
Model::SIBLING_CONNECT_KEY
|
||||
], [
|
||||
Model::SELF_KEY => 'id',
|
||||
Model::SIBLING_KEY => 'id'
|
||||
]);
|
||||
$sibling_table = (new $sibling_model_class())->getTable();
|
||||
return $this->find($sibling_model_class)
|
||||
->select([
|
||||
[
|
||||
$sibling_table,
|
||||
'*'
|
||||
],
|
||||
[
|
||||
$connecting_table,
|
||||
'*'
|
||||
]
|
||||
])
|
||||
->join([
|
||||
[
|
||||
$connecting_table,
|
||||
implode('.', [
|
||||
$connecting_table,
|
||||
$relation_definitions[Model::SIBLING_CONNECT_KEY]
|
||||
]),
|
||||
implode('.', [
|
||||
$sibling_table,
|
||||
$relation_definitions[Model::SIBLING_KEY]
|
||||
])
|
||||
]
|
||||
])
|
||||
->where([
|
||||
[
|
||||
implode('.', [
|
||||
$connecting_table,
|
||||
$relation_definitions[Model::SELF_CONNECT_KEY]
|
||||
]),
|
||||
$this->{$relation_definitions[Model::SELF_KEY]}
|
||||
]
|
||||
])
|
||||
->many();
|
||||
}
|
||||
|
||||
public function toArray(): array {
|
||||
return $this->asArray();
|
||||
}
|
||||
|
||||
protected static function parseInput($input): array {
|
||||
return array_intersect_key((array) $input, array_combine(static::$fields, static::$fields));
|
||||
}
|
||||
public static function add(ModelFactory $factory, $input): ?ModelInterface {
|
||||
$data = static::parseInput($input);
|
||||
$class = get_called_class();
|
||||
if (method_exists($class, 'find')) {
|
||||
$obj = static::find($factory, $input);
|
||||
} else {
|
||||
$where = $data;
|
||||
array_walk($where, function(&$item, $key) {
|
||||
$item = [$key, $item];
|
||||
});
|
||||
$where = array_values($where);
|
||||
$obj = $factory->find($class)->where($where)->one();
|
||||
}
|
||||
if ($obj === null) {
|
||||
$obj = $factory->create($class, $data);
|
||||
}
|
||||
return $obj;
|
||||
}
|
||||
public function edit($input): bool {
|
||||
$data = static::parseInput($input);
|
||||
foreach (static::$fields as $field) {
|
||||
if ($this->{$field} != $data[$field]) {
|
||||
$this->{$field} = $data[$field];
|
||||
}
|
||||
}
|
||||
return $this->save();
|
||||
}
|
||||
}
|
||||
@ -1,17 +0,0 @@
|
||||
<?php
|
||||
namespace ProVM\Common\Define;
|
||||
|
||||
use ProVM\Common\Factory\Model as ModelFactory;
|
||||
|
||||
interface Model {
|
||||
public function getTable(): string;
|
||||
public function setFactory(ModelFactory $factory): Model;
|
||||
public function parentOf(string $child_model_class, array $relation_definitions): ?array;
|
||||
public function childOf(string $parent_model_class, array $relation_definitions): ?Model;
|
||||
public function siblingOf(string $sibling_model_class, string $connecting_table, array $relation_definitions): ?array;
|
||||
|
||||
public function toArray(): array;
|
||||
|
||||
public static function add(ModelFactory $factory, $input): ?Model;
|
||||
public function edit($input): bool;
|
||||
}
|
||||
@ -1,13 +0,0 @@
|
||||
<?php
|
||||
namespace ProVM\Common\Define\Model;
|
||||
|
||||
use Carbon\Carbon;
|
||||
|
||||
trait Date {
|
||||
public function date(\DateTime $date = null) {
|
||||
if ($date === null) {
|
||||
return Carbon::parse($this->date);
|
||||
}
|
||||
$this->date = $data->format('Y-m-d');
|
||||
}
|
||||
}
|
||||
@ -1,13 +0,0 @@
|
||||
<?php
|
||||
namespace ProVM\Common\Define\Model;
|
||||
|
||||
use Carbon\Carbon;
|
||||
|
||||
trait DateTime {
|
||||
public function dateTime(\DateTime $date_time = null) {
|
||||
if ($date_time === null) {
|
||||
return Carbon::parse($this->date_time);
|
||||
}
|
||||
$this->date_time = $date_time->format('c');
|
||||
}
|
||||
}
|
||||
@ -1,13 +0,0 @@
|
||||
<?php
|
||||
namespace ProVM\Common\Define\Model;
|
||||
|
||||
use Carbon\Carbon;
|
||||
|
||||
trait Time {
|
||||
public function time(\DateTime $time = null) {
|
||||
if ($time === null) {
|
||||
return Carbon::parse($this->time);
|
||||
}
|
||||
$this->time = $time->format('H:i:s e');
|
||||
}
|
||||
}
|
||||
@ -1,393 +0,0 @@
|
||||
<?php
|
||||
namespace ProVM\Common\Factory;
|
||||
|
||||
use ORM;
|
||||
use Model as BaseModel;
|
||||
use ProVM\Common\Define\Model as ModelInterface;
|
||||
|
||||
class Model {
|
||||
public function reset(): Model {
|
||||
$reset = [
|
||||
'class',
|
||||
'columns',
|
||||
'joins',
|
||||
'conditions',
|
||||
'grouping',
|
||||
'ordering',
|
||||
'limit',
|
||||
'offset'
|
||||
];
|
||||
foreach ($reset as $p) {
|
||||
$this->{$p} = null;
|
||||
}
|
||||
return $this;
|
||||
}
|
||||
public function create(string $model_class, array $data = null): ModelInterface {
|
||||
if ($data !== null) {
|
||||
$model = $this->find($model_class);
|
||||
foreach ($data as $f => $v) {
|
||||
$model = $model->where([[$f, $v]]);
|
||||
}
|
||||
$model = $model->one();
|
||||
if ($model !== null) {
|
||||
return $model;
|
||||
}
|
||||
}
|
||||
$model = BaseModel::factory($model_class)->create($data);
|
||||
$model->setFactory($this);
|
||||
return $model;
|
||||
}
|
||||
protected $class;
|
||||
public function find(string $model_class): Model {
|
||||
if (!class_exists($model_class)) {
|
||||
throw new \InvalidArgumentException('El modelo ' . $model_class . ' no existe.');
|
||||
}
|
||||
$this->reset();
|
||||
$this->class = $model_class;
|
||||
return $this;
|
||||
}
|
||||
protected $columns;
|
||||
public function select($columns): Model {
|
||||
if ($this->columns === null) {
|
||||
$this->columns = [];
|
||||
}
|
||||
if (!is_array($columns)) {
|
||||
$columns = [$columns];
|
||||
}
|
||||
foreach ($columns as $c) {
|
||||
$col = (object) [
|
||||
'table' => '',
|
||||
'column' => $c
|
||||
];
|
||||
if (is_array($c)) {
|
||||
$col = (object) [
|
||||
'table' => $c['table'] ?? $c[0],
|
||||
'column' => $c['column'] ?? $c[1]
|
||||
];
|
||||
}
|
||||
$this->columns []= $col;
|
||||
}
|
||||
return $this;
|
||||
}
|
||||
protected $joins;
|
||||
public function join(array $joins): Model {
|
||||
if ($this->joins === null) {
|
||||
$this->joins = [];
|
||||
}
|
||||
foreach ($joins as $j) {
|
||||
$join = (object) [
|
||||
'table' => $j['table'] ?? $j[0],
|
||||
'from' => $j['from'] ?? $j[1],
|
||||
'to' => $j['to'] ?? $j[2],
|
||||
'symb' => $j['symb'] ?? ($j[3] ?? '='),
|
||||
'alias' => $j['alias'] ?? '',
|
||||
'type' => strtolower($j['type'] ?? ''),
|
||||
'params' => $j['params'] ?? ''
|
||||
];
|
||||
$this->joins []= $join;
|
||||
}
|
||||
return $this;
|
||||
}
|
||||
protected $conditions;
|
||||
public function where(array $conditions): Model {
|
||||
if ($this->conditions === null) {
|
||||
$this->conditions = [];
|
||||
}
|
||||
foreach ($conditions as $c) {
|
||||
$cond = (object) [
|
||||
'column' => $c['column'] ?? $c[0],
|
||||
'value' => $c['value'] ?? $c[1],
|
||||
'symb' => strtolower($c['symb'] ?? ($c[2] ?? '=')),
|
||||
'type' => strtolower($c['type'] ?? '')
|
||||
];
|
||||
$this->conditions []= $cond;
|
||||
}
|
||||
return $this;
|
||||
}
|
||||
protected $grouping;
|
||||
public function group($groups): Model {
|
||||
if ($this->grouping === null) {
|
||||
$this->grouping = [];
|
||||
}
|
||||
if (!is_array($groups)) {
|
||||
$groups = [$groups];
|
||||
}
|
||||
foreach ($groups as $g) {
|
||||
$this->grouping []= $g;
|
||||
}
|
||||
return $this;
|
||||
}
|
||||
protected $ordering;
|
||||
public function order($orders): Model {
|
||||
if ($this->ordering === null) {
|
||||
$this->ordering = [];
|
||||
}
|
||||
if (!is_array($orders)) {
|
||||
$orders = [$orders];
|
||||
}
|
||||
foreach ($orders as $o) {
|
||||
$order = (object) [
|
||||
'column' => $o,
|
||||
'direction' => 'asc'
|
||||
];
|
||||
if (is_array($o)) {
|
||||
$order = (object) [
|
||||
'column' => $o['column'] ?? $o[0],
|
||||
'direction' => strtolower($o['direction']) ?? $o[1]
|
||||
];
|
||||
}
|
||||
$this->ordering []= $order;
|
||||
}
|
||||
return $this;
|
||||
}
|
||||
protected $limit;
|
||||
public function limit(int $limit): Model {
|
||||
$this->limit = $limit;
|
||||
}
|
||||
protected $offset;
|
||||
public function offset(int $offset): Model {
|
||||
$this->offset = $offset;
|
||||
}
|
||||
|
||||
protected function parseSelect(ORM $orm): ORM {
|
||||
if ($this->columns === null) {
|
||||
return $orm;
|
||||
}
|
||||
foreach ($this->columns as $col) {
|
||||
$orm = $orm->select(trim(implode('.', (array) $col), '.'));
|
||||
}
|
||||
return $orm;
|
||||
}
|
||||
protected function parseJoin(ORM $orm): ORM {
|
||||
if ($this->joins === null) {
|
||||
return $orm;
|
||||
}
|
||||
foreach ($this->joins as $join) {
|
||||
$method = 'join';
|
||||
switch ($join->type) {
|
||||
case 'raw':
|
||||
$method = 'rawJoin';
|
||||
break;
|
||||
case 'inner':
|
||||
$method = 'innerJoin';
|
||||
break;
|
||||
case 'left':
|
||||
case 'left outer':
|
||||
case 'left_outer':
|
||||
case 'leftouter':
|
||||
$method = 'leftOuterJoin';
|
||||
break;
|
||||
case 'right':
|
||||
case 'right outer':
|
||||
case 'right_outer':
|
||||
case 'rightouter':
|
||||
$method = 'rightOuterJoin';
|
||||
break;
|
||||
case 'full':
|
||||
case 'full outer':
|
||||
case 'full_outer':
|
||||
case 'fullouter':
|
||||
$method = 'fullOuterJoin';
|
||||
break;
|
||||
}
|
||||
if ($join->type == 'raw') {
|
||||
$orm = $orm->{$method}($join->table, [$join->from, $join->symb, $join->to], $join->alias, $join->params);
|
||||
} elseif ($join->alias !== '') {
|
||||
$orm = $orm->{$method}($join->table, [$join->from, $join->symb, $join->to], $join->alias);
|
||||
} else {
|
||||
$orm = $orm->{$method}($join->table, [$join->from, $join->symb, $join->to]);
|
||||
}
|
||||
}
|
||||
return $orm;
|
||||
}
|
||||
protected function parseWhere(ORM $orm): ORM {
|
||||
if ($this->conditions === null) {
|
||||
return $orm;
|
||||
}
|
||||
foreach ($this->conditions as $cond) {
|
||||
$method = 'where';
|
||||
switch ($cond->symb) {
|
||||
case '<':
|
||||
$method = 'whereLt';
|
||||
break;
|
||||
case '<=':
|
||||
$method = 'whereLte';
|
||||
break;
|
||||
case '>':
|
||||
$method = 'whereGt';
|
||||
break;
|
||||
case '>=':
|
||||
$method = 'whereGte';
|
||||
break;
|
||||
case '!=':
|
||||
$method = 'whereNotEqual';
|
||||
break;
|
||||
case 'like':
|
||||
$method = 'whereLike';
|
||||
break;
|
||||
case 'not like':
|
||||
case 'not_like':
|
||||
case 'notlike':
|
||||
$method = 'whereNotLike';
|
||||
break;
|
||||
}
|
||||
switch ($cond->type) {
|
||||
case 'equal':
|
||||
$method = 'whereEqual';
|
||||
break;
|
||||
case 'not equal':
|
||||
case 'not_equal':
|
||||
case 'notequal':
|
||||
$method = 'whereNotEqual';
|
||||
break;
|
||||
case 'less':
|
||||
case 'less than':
|
||||
case 'less_than':
|
||||
case 'lessthan':
|
||||
case 'lt':
|
||||
$method = 'whereLt';
|
||||
break;
|
||||
case 'less equal':
|
||||
case 'less_equal':
|
||||
case 'lessequal':
|
||||
case 'less than equal':
|
||||
case 'less_than_equal':
|
||||
case 'lessthanequal':
|
||||
case 'lte':
|
||||
$method = 'whereLte';
|
||||
break;
|
||||
case 'greater':
|
||||
case 'greater than':
|
||||
case 'greater_than':
|
||||
case 'greaterthan':
|
||||
case 'gt':
|
||||
$method = 'whereGt';
|
||||
break;
|
||||
case 'greater equal':
|
||||
case 'greater_equal':
|
||||
case 'greaterequal':
|
||||
case 'greater than equal':
|
||||
case 'greater_than_equal':
|
||||
case 'greaterthanequal':
|
||||
case 'gte':
|
||||
$method = 'whereGte';
|
||||
break;
|
||||
case 'like':
|
||||
$method = 'whereLike';
|
||||
break;
|
||||
case 'not like':
|
||||
case 'not_like':
|
||||
case 'notlike':
|
||||
$method = 'whereNotLike';
|
||||
break;
|
||||
case 'in':
|
||||
$method = 'whereIn';
|
||||
break;
|
||||
case 'not in':
|
||||
case 'not_in':
|
||||
case 'notin':
|
||||
$method = 'whereNotIn';
|
||||
break;
|
||||
case 'raw':
|
||||
$method = 'rawWhere';
|
||||
break;
|
||||
}
|
||||
$orm = $orm->{$method}($cond->column, $cond->value);
|
||||
}
|
||||
return $orm;
|
||||
}
|
||||
protected function parseGroup(ORM $orm): ORM {
|
||||
if ($this->grouping === null) {
|
||||
return $orm;
|
||||
}
|
||||
foreach ($this->grouping as $group) {
|
||||
if (strpos($group, '(') !== false) {
|
||||
$orm = $orm->groupByExpr($group);
|
||||
} else {
|
||||
$orm = $orm->groupBy($group);
|
||||
}
|
||||
}
|
||||
return $orm;
|
||||
}
|
||||
protected function parseOrder(ORM $orm): ORM {
|
||||
if ($this->ordering === null) {
|
||||
return $orm;
|
||||
}
|
||||
foreach ($this->ordering as $order) {
|
||||
if (strpos($order->column, '(') !== false) {
|
||||
$orm = $orm->orderByExpr($order->column);
|
||||
continue;
|
||||
}
|
||||
switch ($order->direction) {
|
||||
case 'asc':
|
||||
case 'ascending':
|
||||
$orm = $orm->orderByAsc($order->column);
|
||||
break;
|
||||
case 'desc':
|
||||
case 'descending':
|
||||
$orm = $orm->orderByDesc($order->column);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return $orm;
|
||||
}
|
||||
protected function parseLimit(ORM $orm): ORM {
|
||||
if ($this->limit === null) {
|
||||
return $orm;
|
||||
}
|
||||
return $orm->limit($this->limit);
|
||||
}
|
||||
protected function parseOffset(ORM $orm): ORM {
|
||||
if ($this->offset === null) {
|
||||
return $orm;
|
||||
}
|
||||
return $orm->offset($this->offset);
|
||||
}
|
||||
|
||||
public function one($id = null): ?ModelInterface {
|
||||
$result = $this->build()->findOne($id);
|
||||
if (!$result) {
|
||||
return null;
|
||||
}
|
||||
$result->setFactory($this);
|
||||
return $result;
|
||||
}
|
||||
public function many(): ?array {
|
||||
$results = $this->build()->findMany();
|
||||
if (!$results) {
|
||||
return null;
|
||||
}
|
||||
foreach ($results as &$r) {
|
||||
$r->setFactory($this);
|
||||
}
|
||||
return $results;
|
||||
}
|
||||
public function array(): ?array {
|
||||
$results = $this->many();
|
||||
if (!$results or $results === null) {
|
||||
return null;
|
||||
}
|
||||
array_walk($results, function(&$item) {
|
||||
$item = $item->toArray();
|
||||
});
|
||||
return $results;
|
||||
}
|
||||
|
||||
protected function build(): ORM {
|
||||
$orm = BaseModel::factory($this->class);
|
||||
$methods = [
|
||||
'select',
|
||||
'join',
|
||||
'where',
|
||||
'group',
|
||||
'order',
|
||||
'limit',
|
||||
'offset'
|
||||
];
|
||||
foreach ($methods as $m) {
|
||||
$method = 'parse' . ucfirst($m);
|
||||
$orm = $this->{$method}($orm);
|
||||
}
|
||||
return $orm;
|
||||
}
|
||||
}
|
||||
@ -1,6 +0,0 @@
|
||||
<?php
|
||||
namespace ProVM\Common\Form;
|
||||
|
||||
use ProVM\Common\Alias\Model as BaseModel;
|
||||
|
||||
abstract class Model extends BaseModel {}
|
||||
Reference in New Issue
Block a user