597 lines
20 KiB
PHP
597 lines
20 KiB
PHP
<?php
|
|
/**
|
|
* Class: Model
|
|
* The basis for the Models system.
|
|
*/
|
|
class Model {
|
|
# Array: $caches
|
|
# Caches every loaded model into a clone of the object.
|
|
private static $caches = array();
|
|
|
|
# Array: $data
|
|
# Stores dynamic attributes for the loaded model.
|
|
private $data = array();
|
|
|
|
# Boolean: $no_results
|
|
# Did the query for this model return no results?
|
|
public $no_results = false;
|
|
|
|
# Array: $belongs_to
|
|
# An array of models that this Model belongs to.
|
|
# This model should have a [modelname]_id column.
|
|
public $belongs_to = array();
|
|
|
|
# Array: $has_many
|
|
# An array of models that belong to this Model.
|
|
# They should have a [thismodel]_id column.
|
|
public $has_many = array();
|
|
|
|
# Array: $has_one
|
|
# An array of models that this model has only one of.
|
|
# The models should have a [thismodel]_id column.
|
|
public $has_one = array();
|
|
|
|
/**
|
|
* Function: __get
|
|
* Handles model relationships, deferred and dynamic attributes.
|
|
*
|
|
* Returns:
|
|
* @mixed@
|
|
*/
|
|
public function &__get($name): mixed {
|
|
$trigger = Trigger::current();
|
|
$model_name = strtolower(get_class($this));
|
|
|
|
if (isset($this->data[$name]))
|
|
return $this->data[$name];
|
|
|
|
if ($trigger->exists($model_name."_".$name."_attr")) {
|
|
$filtered = null;
|
|
$trigger->filter($filtered, $model_name."_".$name."_attr", $this);
|
|
$this->data[$name] = $filtered;
|
|
return $this->data[$name];
|
|
}
|
|
|
|
$this->belongs_to = (array) $this->belongs_to;
|
|
$this->has_many = (array) $this->has_many;
|
|
$this->has_one = (array) $this->has_one;
|
|
|
|
if (
|
|
in_array($name, $this->belongs_to) or
|
|
isset($this->belongs_to[$name])
|
|
) {
|
|
if (isset($this->belongs_to[$name])) {
|
|
$opts =& $this->belongs_to[$name];
|
|
|
|
$model = isset($opts["model"]) ?
|
|
$opts["model"] :
|
|
$name ;
|
|
|
|
$match = isset($opts["by"]) ?
|
|
$opts["by"] :
|
|
strtolower($name) ;
|
|
|
|
fallback(
|
|
$opts["where"],
|
|
array("id" => $this->data[$match."_id"])
|
|
);
|
|
|
|
$opts["where"] = (array) $opts["where"];
|
|
} else {
|
|
$model = $name;
|
|
$opts = array(
|
|
"where" => array("id" => $this->data[$name."_id"])
|
|
);
|
|
}
|
|
|
|
$this->data[$name] = new $model(null, $opts);
|
|
return $this->data[$name];
|
|
|
|
} elseif (
|
|
in_array($name, $this->has_many) or
|
|
isset($this->has_many[$name])
|
|
) {
|
|
if (isset($this->has_many[$name])) {
|
|
$opts =& $this->has_many[$name];
|
|
|
|
$model = isset($opts["model"]) ?
|
|
$opts["model"] :
|
|
depluralize($name) ;
|
|
|
|
$match = isset($opts["by"]) ?
|
|
$opts["by"] :
|
|
strtolower($name) ;
|
|
|
|
fallback(
|
|
$opts["where"],
|
|
array($match."_id" => $this->data["id"])
|
|
);
|
|
|
|
$opts["where"] = (array) $opts["where"];
|
|
} else {
|
|
$model = depluralize($name);
|
|
$match = ($model_name == "visitor") ? "user" : $model_name ;
|
|
$opts = array(
|
|
"where" => array($match."_id" => $this->data["id"])
|
|
);
|
|
}
|
|
|
|
$this->data[$name] = call_user_func(array($model, "find"), $opts);
|
|
return $this->data[$name];
|
|
|
|
} elseif (
|
|
in_array($name, $this->has_one) or
|
|
isset($this->has_one[$name])
|
|
) {
|
|
if (isset($this->has_one[$name])) {
|
|
$opts =& $this->has_one[$name];
|
|
|
|
$model = isset($opts["model"]) ?
|
|
$opts["model"] :
|
|
depluralize($name) ;
|
|
|
|
$match = isset($opts["by"]) ?
|
|
$opts["by"] :
|
|
strtolower($name) ;
|
|
|
|
fallback(
|
|
$opts["where"],
|
|
array($match."_id" => $this->data["id"])
|
|
);
|
|
|
|
$opts["where"] = (array) $opts["where"];
|
|
} else {
|
|
$model = depluralize($name);
|
|
|
|
$match = ($model_name == "visitor") ?
|
|
"user" :
|
|
$model_name ;
|
|
|
|
$opts = array(
|
|
"where" => array($match."_id" => $this->data["id"])
|
|
);
|
|
}
|
|
|
|
$this->data[$name] = new $model(null, $opts);
|
|
return $this->data[$name];
|
|
}
|
|
|
|
$this->data[$name] = null;
|
|
return $this->data[$name];
|
|
}
|
|
|
|
/**
|
|
* Function __set
|
|
* Handles dynamic attributes.
|
|
*/
|
|
public function __set($name, $value): void {
|
|
$this->data[$name] = $value;
|
|
}
|
|
|
|
/**
|
|
* Function: __isset
|
|
* Handles model relationships, deferred and dynamic attributes.
|
|
*/
|
|
public function __isset($name): bool {
|
|
$trigger = Trigger::current();
|
|
$model_name = strtolower(get_class($this));
|
|
|
|
if ($trigger->exists($model_name."_".$name."_attr"))
|
|
return true;
|
|
|
|
if (isset($this->data[$name]))
|
|
return true;
|
|
|
|
$this->belongs_to = (array) $this->belongs_to;
|
|
$this->has_many = (array) $this->has_many;
|
|
$this->has_one = (array) $this->has_one;
|
|
|
|
if (
|
|
in_array($name, $this->belongs_to) or
|
|
isset($this->belongs_to[$name])
|
|
)
|
|
return true;
|
|
|
|
if (
|
|
in_array($name, $this->has_many) or
|
|
isset($this->has_many[$name])
|
|
)
|
|
return true;
|
|
|
|
if (
|
|
in_array($name, $this->has_one) or
|
|
isset($this->has_one[$name])
|
|
)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Function: grab
|
|
* Grabs a single model from the database.
|
|
*
|
|
* Parameters:
|
|
* $model - The instantiated model class to pass the object to (e.g. Post).
|
|
* $id - The ID of the model to grab. Can be null.
|
|
* $options - An array of options, mostly SQL things.
|
|
*
|
|
* Options:
|
|
* select - What to grab from the table.
|
|
* from - Which table(s) to grab from?
|
|
* left_join - A @LEFT JOIN@ associative array.
|
|
* where - A string or array of conditions.
|
|
* params - An array of parameters to pass to the SQL driver.
|
|
* group - A string or array of "GROUP BY" conditions.
|
|
* order - What to order the SQL result by.
|
|
* offset - Offset for SQL query.
|
|
* read_from - An array to read from instead of performing another query.
|
|
* ignore_dupes - An array of columns in which duplicate values will be retained.
|
|
*/
|
|
protected static function grab($model, $id, $options = array()): void {
|
|
$model_name = strtolower(get_class($model));
|
|
|
|
if ($model_name == "visitor")
|
|
$model_name = "user";
|
|
|
|
if (!isset($id) and isset($options["where"]["id"]))
|
|
$id = $options["where"]["id"];
|
|
|
|
$cache_id = (isset($id) and !is_numeric($id)) ?
|
|
serialize($id) :
|
|
$id ;
|
|
|
|
# Return cached results if available.
|
|
if (empty($options["read_from"])) {
|
|
if (
|
|
isset($cache_id) and
|
|
isset(self::$caches[$model_name][$cache_id])
|
|
) {
|
|
foreach (self::$caches[$model_name][$cache_id] as $attr => $val)
|
|
$model->$attr = $val;
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
fallback($options["select"], "*");
|
|
fallback(
|
|
$options["from"],
|
|
($model_name == "visitor" ? "users" : pluralize($model_name))
|
|
);
|
|
fallback($options["left_join"], array());
|
|
fallback($options["where"], array());
|
|
fallback($options["params"], array());
|
|
fallback($options["group"], array());
|
|
fallback($options["order"], "id DESC");
|
|
fallback($options["offset"], null);
|
|
fallback($options["read_from"], array());
|
|
fallback($options["ignore_dupes"], array());
|
|
|
|
$options["where"] = (array) $options["where"];
|
|
$options["from"] = (array) $options["from"];
|
|
$options["select"] = (array) $options["select"];
|
|
|
|
if (is_numeric($id)) {
|
|
$options["where"]["id"] = $id;
|
|
} elseif (is_array($id)) {
|
|
$options["where"] = array_merge($options["where"], $id);
|
|
}
|
|
|
|
$sql = SQL::current();
|
|
$trigger = Trigger::current();
|
|
|
|
$trigger->filter($options, $model_name."_grab");
|
|
|
|
if (!empty($options["read_from"])) {
|
|
$read = $options["read_from"];
|
|
} else {
|
|
$query = $sql->select(
|
|
tables:$options["from"],
|
|
fields:$options["select"],
|
|
conds:$options["where"],
|
|
order:$options["order"],
|
|
params:$options["params"],
|
|
offset:$options["offset"],
|
|
group:$options["group"],
|
|
left_join:$options["left_join"]
|
|
);
|
|
$all = $query->fetchAll();
|
|
|
|
if (count($all) == 1) {
|
|
$read = $all[0];
|
|
} else {
|
|
$merged = array();
|
|
|
|
foreach ($all as $index => $row) {
|
|
foreach ($row as $column => $val)
|
|
$merged[$row["id"]][$column][] = $val;
|
|
}
|
|
|
|
foreach ($all as $index => &$row)
|
|
$row = $merged[$row["id"]];
|
|
|
|
if (count($all)) {
|
|
$keys = array_keys($all);
|
|
$read = $all[$keys[0]];
|
|
|
|
foreach ($read as $name => &$column) {
|
|
if (!in_array($name, $options["ignore_dupes"]))
|
|
$column = array_unique($column);
|
|
|
|
if (count($column) == 1)
|
|
$column = $column[0];
|
|
}
|
|
} else {
|
|
$read = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!$read or !count($read)) {
|
|
$model->no_results = true;
|
|
return;
|
|
} else {
|
|
$model->no_results = false;
|
|
}
|
|
|
|
foreach ($read as $key => $val) {
|
|
if (!is_int($key))
|
|
$model->$key = $val;
|
|
}
|
|
|
|
if (isset($query) and isset($query->queryString))
|
|
$model->queryString = $query->queryString;
|
|
|
|
if (isset($model->updated_at))
|
|
$model->updated = (
|
|
!empty($model->updated_at) and
|
|
!is_datetime_zero($model->updated_at)
|
|
);
|
|
|
|
# Clone the object and cache it.
|
|
$clone = clone $model;
|
|
self::$caches[$model_name][$read["id"]] = $clone;
|
|
|
|
if (isset($id) and !is_numeric($id))
|
|
self::$caches[$model_name][$cache_id] = $clone;
|
|
}
|
|
|
|
/**
|
|
* Function: search
|
|
* Returns an array of model objects that are found by the $options array.
|
|
*
|
|
* Parameters:
|
|
* $options - An array of options, mostly SQL things.
|
|
* $options_for_object - An array of options for the instantiation of the model.
|
|
*
|
|
* Options:
|
|
* select - What to grab from the table.
|
|
* from - Which table(s) to grab from?
|
|
* left_join - A @LEFT JOIN@ associative array.
|
|
* where - A string or array of conditions.
|
|
* params - An array of parameters to pass to the SQL driver.
|
|
* group - A string or array of "GROUP BY" conditions.
|
|
* order - What to order the SQL result by.
|
|
* offset - Offset for SQL query.
|
|
* limit - Limit for SQL query.
|
|
* placeholders - Return an array of arrays instead of an array of objects?
|
|
* ignore_dupes - An array of columns in which duplicate values will be retained.
|
|
*
|
|
* See Also:
|
|
* <Model.grab>
|
|
*/
|
|
protected static function search(
|
|
$model,
|
|
$options = array(),
|
|
$options_for_object = array()
|
|
): array {
|
|
$trigger = Trigger::current();
|
|
$model_name = strtolower($model);
|
|
|
|
fallback($options["select"], "*");
|
|
fallback($options["from"], pluralize(strtolower($model)));
|
|
fallback($options["left_join"], array());
|
|
fallback($options["where"], null);
|
|
fallback($options["params"], array());
|
|
fallback($options["group"], array());
|
|
fallback($options["order"], "id DESC");
|
|
fallback($options["offset"], null);
|
|
fallback($options["limit"], null);
|
|
fallback($options["placeholders"], false);
|
|
fallback($options["ignore_dupes"], array());
|
|
|
|
$options["where"] = (array) $options["where"];
|
|
$options["from"] = (array) $options["from"];
|
|
$options["select"] = (array) $options["select"];
|
|
|
|
$trigger->filter($options, pluralize(strtolower($model_name))."_get");
|
|
|
|
$grab = SQL::current()->select(
|
|
tables:$options["from"],
|
|
fields:$options["select"],
|
|
conds:$options["where"],
|
|
order:$options["order"],
|
|
params:$options["params"],
|
|
limit:$options["limit"],
|
|
offset:$options["offset"],
|
|
group:$options["group"],
|
|
left_join:$options["left_join"]
|
|
)->fetchAll();
|
|
|
|
$results = array();
|
|
$rows = array();
|
|
|
|
foreach ($grab as $row) {
|
|
foreach ($row as $column => $val)
|
|
$rows[$row["id"]][$column][] = $val;
|
|
}
|
|
|
|
foreach ($rows as &$row) {
|
|
foreach ($row as $name => &$column) {
|
|
if (!in_array($name, $options["ignore_dupes"]))
|
|
$column = array_unique($column);
|
|
|
|
if (count($column) == 1)
|
|
$column = $column[0];
|
|
}
|
|
}
|
|
|
|
foreach ($rows as $result) {
|
|
if ($options["placeholders"]) {
|
|
$results[] = $result;
|
|
continue;
|
|
}
|
|
|
|
$options_for_object["read_from"] = $result;
|
|
$result = new $model(null, $options_for_object);
|
|
$results[] = $result;
|
|
}
|
|
|
|
return ($options["placeholders"]) ?
|
|
array($results, $model_name) :
|
|
$results ;
|
|
}
|
|
|
|
/**
|
|
* Function: delete
|
|
* Deletes a given object.
|
|
*
|
|
* Parameters:
|
|
* $model - The model name.
|
|
* $id - The ID of the object to delete.
|
|
* $options_for_object - An array of options for the instantiation of the model.
|
|
*/
|
|
protected static function destroy(
|
|
$model,
|
|
$id,
|
|
$options_for_object = array()
|
|
): void {
|
|
$model = strtolower($model);
|
|
$trigger = Trigger::current();
|
|
|
|
if ($trigger->exists("delete_".$model))
|
|
$trigger->call("delete_".$model, new $model($id, $options_for_object));
|
|
|
|
SQL::current()->delete(
|
|
table:pluralize($model),
|
|
conds:array("id" => $id)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Function: deletable
|
|
* Checks if the <User> can delete the object.
|
|
*/
|
|
public function deletable($user = null): bool {
|
|
if ($this->no_results)
|
|
return false;
|
|
|
|
$name = strtolower(get_class($this));
|
|
|
|
fallback($user, Visitor::current());
|
|
return $user->group->can("delete_".$name);
|
|
}
|
|
|
|
/**
|
|
* Function: editable
|
|
* Checks if the <User> can edit the object.
|
|
*/
|
|
public function editable($user = null): bool {
|
|
if ($this->no_results)
|
|
return false;
|
|
|
|
$name = strtolower(get_class($this));
|
|
|
|
fallback($user, Visitor::current());
|
|
return $user->group->can("edit_".$name);
|
|
}
|
|
|
|
/**
|
|
* Function: edit_link
|
|
* Outputs an edit link for the model, if the visitor's <Group.can> edit_[model].
|
|
*
|
|
* Parameters:
|
|
* $text - The text to show for the link.
|
|
* $before - If the link can be shown, show this before it.
|
|
* $after - If the link can be shown, show this after it.
|
|
* $classes - Extra CSS classes for the link, space-delimited.
|
|
*/
|
|
public function edit_link(
|
|
$text = null,
|
|
$before = null,
|
|
$after = null,
|
|
$classes = ""
|
|
): void {
|
|
if (!$this->editable())
|
|
return;
|
|
|
|
fallback($text, __("Edit"));
|
|
|
|
$name = strtolower(get_class($this));
|
|
|
|
$url = url(
|
|
"edit_".$name."/id/".$this->id,
|
|
AdminController::current()
|
|
);
|
|
|
|
$classes = $classes.' '.$name.'_edit_link edit_link';
|
|
|
|
echo $before.'<a href="'.$url.'" class="'.trim($classes).
|
|
'" id="'.$name.'_edit_'.$this->id.'">'.$text.'</a>'.$after;
|
|
}
|
|
|
|
/**
|
|
* Function: delete_link
|
|
* Outputs a delete link for the post, if the <User.can> delete_[model].
|
|
*
|
|
* Parameters:
|
|
* $text - The text to show for the link.
|
|
* $before - If the link can be shown, show this before it.
|
|
* $after - If the link can be shown, show this after it.
|
|
* $classes - Extra CSS classes for the link, space-delimited.
|
|
*/
|
|
public function delete_link(
|
|
$text = null,
|
|
$before = null,
|
|
$after = null,
|
|
$classes = ""
|
|
): void {
|
|
if (!$this->deletable())
|
|
return;
|
|
|
|
fallback($text, __("Delete"));
|
|
|
|
$name = strtolower(get_class($this));
|
|
|
|
$url = url(
|
|
"delete_".$name."/id/".$this->id,
|
|
AdminController::current()
|
|
);
|
|
|
|
$classes = $classes.' '.$name.'_delete_link delete_link';
|
|
|
|
echo $before.'<a href="'.$url.'" class="'.trim($classes).
|
|
'" id="'.$name.'_delete_'.$this->id.'">'.$text.'</a>'.$after;
|
|
}
|
|
|
|
/**
|
|
* Function: etag
|
|
* Generates an Etag for the object.
|
|
*/
|
|
public function etag(): string|false {
|
|
if ($this->no_results)
|
|
return false;
|
|
|
|
$array = array(get_class($this), $this->id);
|
|
|
|
if (isset($this->created_at))
|
|
$array[] = $this->created_at;
|
|
|
|
if (isset($this->updated_at))
|
|
$array[] = $this->updated_at;
|
|
|
|
return (isset($this->updated_at) ? '"' : 'W/"').token($array).'"';
|
|
}
|
|
}
|