EntityORM
Package | engine.orm |
---|---|
Inheritance | abstract class EntityORM » Entity » LsObject |
Since | 1.0 |
Source Code | /engine/classes/EntityORM.class.php |
$oUser=$this->User_GetUserById(1); $oUser->setName('Claus'); $oUser->Update();Возможно получать списки объектов по фильтру:
$aUsers=$this->User_GetUserItemsByAgeAndSex(18,'male'); // эквивалентно $aUsers=$this->User_GetUserItemsByFilter(array('age'=>18,'sex'=>'male')); // эквивалентно $aUsers=$this->User_GetUserItemsByFilter(array('#where'=>array('age = ?d and sex = ?' => array(18,'male'))));
Protected Properties
Property | Type | Description | Defined By |
---|---|---|---|
_aData | array | Данные сущности, на этот массив мапятся методы set* и get* | Entity |
_aManyToManyRelations | array | Объекты связей many_to_many | EntityORM |
_aOriginalData | array | Массив исходных данных сущности | EntityORM |
aFields | array | Список полей таблицы сущности | EntityORM |
aRelations | array | Список связей | EntityORM |
aRelationsData | array | Список данных связей | EntityORM |
aValidateErrors | array | Список ошибок валидации в разрезе полей, например | Entity |
aValidateRules | array | Список правил валидации полей | Entity |
bIsNew | bool | Флаг новая или нет сущность | EntityORM |
sPrimaryKey | null|string | Имя поля с первичным ключом в БД | Entity |
sValidateScenario | string | Сценарий валиадции полей | Entity |
Public Methods
Method | Description | Defined By |
---|---|---|
Add() | Добавление сущности в БД | EntityORM |
Delete() | Удаление сущности из БД | EntityORM |
Init() | Метод инициализации сущности, вызывается при её создании | Entity |
Reload() | Обновляет данные сущности из БД | EntityORM |
Save() | Сохранение сущности в БД (если новая то создается) | EntityORM |
ShowColumns() | Возвращает список полей сущности | EntityORM |
ShowPrimaryIndex() | Возвращает primary индекс сущности | EntityORM |
Update() | Обновление сущности в БД | EntityORM |
_SetIsNew() | Установка флага "новая" | EntityORM |
_Validate() | Выполняет валидацию данных сущности | Entity |
__call() | Ставим хук на вызов неизвестного метода и считаем что хотели вызвать метод какого либо модуля | EntityORM |
__construct() | Установка связей | EntityORM |
__get() | Используется для доступа к связанным данным типа MANY_TO_MANY | EntityORM |
_addValidateError() | Добавляет для поля ошибку в список ошибок | Entity |
_clearValidateErrors() | Очищает список всех ошибок или для конкретного поля | Entity |
_createValidators() | Создает и возвращает список валидаторов для сущности | Entity |
_getData() | Получает массив данных сущности | Entity |
_getDataArray() | Рекурсивное преобразование объекта и вложенных объектов в массив | Entity |
_getDataOne() | Возвращает данные по конкретному полю | Entity |
_getField() | Возвращает поле в нужном формате | EntityORM |
_getFields() | Возвращает список полей сущности | EntityORM |
_getOriginalData() | Возвращает все данные сущности | EntityORM |
_getPrimaryKey() | Получение primary key из схемы таблицы | EntityORM |
_getPrimaryKeyValue() | Получение значения primary key | EntityORM |
_getRelations() | Возвращает список связей | EntityORM |
_getRelationsData() | Возвращает список данный связей | EntityORM |
_getValidateError() | Возвращает первую ошибку для поля или среди всех полей | Entity |
_getValidateErrors() | Возвращает список ошибок для всех полей или одного поля | Entity |
_getValidateScenario() | Возвращает текущий сценарий валидации | Entity |
_getValidators() | Возвращает список валидаторов с учетом текущего сценария | Entity |
_hasValidateErrors() | Проверяет есть ли ошибки валидации | Entity |
_isNew() | Новая или нет сущность | EntityORM |
_setData() | Устанавливает данные сущности | EntityORM |
_setRelationsData() | Устанавливает данные связей | EntityORM |
_setValidateScenario() | Устанавливает сценарий валидации | Entity |
getAncestors() | Для сущности со связью RELATION_TYPE_TREE возвращает список всех предков | EntityORM |
getChildren() | Для сущности со связью RELATION_TYPE_TREE возвращает список прямых потомков | EntityORM |
getDescendants() | Для сущности со связью RELATION_TYPE_TREE возвращает список всех потомков | EntityORM |
getParent() | Для сущности со связью RELATION_TYPE_TREE возвращает предка | EntityORM |
resetRelationsData() | Сбрасывает данные необходимой связи | EntityORM |
setAncestors() | Для сущности со связью RELATION_TYPE_TREE устанавливает предков | EntityORM |
setChildren() | Для сущности со связью RELATION_TYPE_TREE устанавливает потомков | EntityORM |
setDescendants() | Для сущности со связью RELATION_TYPE_TREE устанавливает потомков | EntityORM |
setParent() | Для сущности со связью RELATION_TYPE_TREE устанавливает предка | EntityORM |
Protected Methods
Method | Description | Defined By |
---|---|---|
_Method() | Проксирует вызов методов в модуль сущности | EntityORM |
afterDelete() | Хук, срабатывает после удаления сущности | EntityORM |
afterSave() | Хук, срабатывает после сохранением сущности | EntityORM |
beforeDelete() | Хук, срабатывает перед удалением сущности | EntityORM |
beforeSave() | Хук, срабатывает перед сохранением сущности | EntityORM |
Property Details
Объекты связей many_to_many
Массив исходных данных сущности
Список полей таблицы сущности
Список связей
Список данных связей
Флаг новая или нет сущность
Method Details
public Entity|false Add()
| ||
{return} | Entity|false |
public function Add() {
if ($this->beforeSave())
if ($res=$this->_Method(__FUNCTION__)) {
$this->afterSave();
return $res;
}
return false;
}
Добавление сущности в БД
public Entity|false Delete()
| ||
{return} | Entity|false |
public function Delete() {
if ($this->beforeDelete())
if ($res=$this->_Method(__FUNCTION__)) {
$this->afterDelete();
return $res;
}
return false;
}
Удаление сущности из БД
public Entity|false Reload()
| ||
{return} | Entity|false |
public function Reload() {
return $this->_Method(__FUNCTION__);
}
Обновляет данные сущности из БД
public Entity|false Save()
| ||
{return} | Entity|false |
public function Save() {
if ($this->beforeSave())
if ($res=$this->_Method(__FUNCTION__)) {
$this->afterSave();
return $res;
}
return false;
}
Сохранение сущности в БД (если новая то создается)
public array ShowColumns()
| ||
{return} | array |
public function ShowColumns() {
return $this->_Method(__FUNCTION__ .'From');
}
Возвращает список полей сущности
public array ShowPrimaryIndex()
| ||
{return} | array |
public function ShowPrimaryIndex() {
return $this->_Method(__FUNCTION__ .'From');
}
Возвращает primary индекс сущности
public Entity|false Update()
| ||
{return} | Entity|false |
public function Update() {
if ($this->beforeSave())
if ($res=$this->_Method(__FUNCTION__)) {
$this->afterSave();
return $res;
}
return false;
}
Обновление сущности в БД
protected mixed _Method(string $sName)
| ||
$sName | string | Название метода |
{return} | mixed |
protected function _Method($sName) {
$sModuleName=Engine::GetModuleName($this);
$sEntityName=Engine::GetEntityName($this);
$sPluginPrefix=Engine::GetPluginPrefix($this);
/**
* If Module not exists, try to find its root Delegater
*/
$aClassInfo = Engine::GetClassInfo($sPluginPrefix.'Module_'.$sModuleName,Engine::CI_MODULE);
if(empty($aClassInfo[Engine::CI_MODULE]) && $sRootDelegater=$this->Plugin_GetRootDelegater('entity',get_class($this))) {
$sModuleName=Engine::GetModuleName($sRootDelegater);
$sPluginPrefix=Engine::GetPluginPrefix($sRootDelegater);
}
return Engine::GetInstance()->_CallModule("{$sPluginPrefix}{$sModuleName}_{$sName}{$sEntityName}",array($this));
}
Проксирует вызов методов в модуль сущности
public void _SetIsNew(bool $bIsNew)
| ||
$bIsNew | bool | Флаг - новая сущность или нет |
public function _SetIsNew($bIsNew) {
$this->bIsNew=$bIsNew;
}
Установка флага "новая"
public mixed __call(string $sName, array $aArgs)
| ||
$sName | string | Имя метода |
$aArgs | array | Аргументы |
{return} | mixed |
public function __call($sName,$aArgs) {
$sType=substr($sName,0,strpos(func_underscore($sName),'_'));
if (!strpos($sName,'_') and in_array($sType,array('get','set','reload'))) {
$sKey=func_underscore(preg_replace('/'.$sType.'/','',$sName, 1));
if ($sType=='get') {
if (isset($this->_aData[$sKey])) {
return $this->_aData[$sKey];
} else {
$sField=$this->_getField($sKey);
if($sField!=$sKey && isset($this->_aData[$sField])) {
return $this->_aData[$sField];
}
}
/**
* Проверяем на связи
*/
if (array_key_exists($sKey,$this->aRelations)) {
$sEntityRel=$this->aRelations[$sKey][1];
$sRelationType=$this->aRelations[$sKey][0];
$sRelationKey=$this->aRelations[$sKey][2];
$sRelationJoinTable=null;
$sRelationJoinTableKey=0; // foreign key в join-таблице для текущей сущности
if($sRelationType == self::RELATION_TYPE_MANY_TO_MANY && array_key_exists(3, $this->aRelations[$sKey])) {
$sRelationJoinTable=$this->aRelations[$sKey][3];
$sRelationJoinTableKey=isset($this->aRelations[$sKey][4]) ? $this->aRelations[$sKey][4] : $this->_getPrimaryKey();
}
/**
* Если связь уже загруженна, то возвращаем сразу результат
*/
if (array_key_exists($sKey,$this->aRelationsData)) {
return $this->aRelationsData[$sKey];
}
$sRelModuleName=Engine::GetModuleName($sEntityRel);
$sRelEntityName=Engine::GetEntityName($sEntityRel);
$sRelPluginPrefix=Engine::GetPluginPrefix($sEntityRel);
$sRelPrimaryKey='id';
if($oRelEntity=Engine::GetEntity($sEntityRel)) {
$sRelPrimaryKey=$oRelEntity->_getPrimaryKey();
}
$iPrimaryKeyValue=$this->_getDataOne($this->_getPrimaryKey());
$sCmd='';
$mCmdArgs=array();
switch ($sRelationType) {
case self::RELATION_TYPE_BELONGS_TO :
$sCmd="{$sRelPluginPrefix}{$sRelModuleName}_get{$sRelEntityName}By".func_camelize($sRelPrimaryKey);
$mCmdArgs=$this->_getDataOne($sRelationKey);
break;
case self::RELATION_TYPE_HAS_ONE :
$sCmd="{$sRelPluginPrefix}{$sRelModuleName}_get{$sRelEntityName}By".func_camelize($sRelationKey);
$mCmdArgs=$iPrimaryKeyValue;
break;
case self::RELATION_TYPE_HAS_MANY :
$sCmd="{$sRelPluginPrefix}{$sRelModuleName}_get{$sRelEntityName}ItemsByFilter";
$mCmdArgs=array($sRelationKey => $iPrimaryKeyValue);
break;
case self::RELATION_TYPE_MANY_TO_MANY :
$sCmd="{$sRelPluginPrefix}Module{$sRelModuleName}_get{$sRelEntityName}ItemsByJoinTable";
$mCmdArgs=array(
'#join_table' => Config::Get($sRelationJoinTable),
'#relation_key' => $sRelationKey,
'#by_key' => $sRelationJoinTableKey,
'#by_value' => $iPrimaryKeyValue,
'#index-from-primary' => true // Для MANY_TO_MANY необходимо индексами в $aRelationsData иметь первичные ключи сущностей
);
break;
default:
break;
}
// Нужно ли учитывать дополнительный фильтр
$bUseFilter = is_array($mCmdArgs) && array_key_exists(0,$aArgs) && is_array($aArgs[0]);
if($bUseFilter) {
$mCmdArgs = array_merge($mCmdArgs, $aArgs[0]);
}
$res=Engine::GetInstance()->_CallModule($sCmd, array($mCmdArgs));
// Сохраняем данные только в случае "чистой" выборки
if(!$bUseFilter) {
$this->aRelationsData[$sKey]=$res;
}
// Создаём объекты-обёртки для связей MANY_TO_MANY
if ($sRelationType == self::RELATION_TYPE_MANY_TO_MANY) {
$this->_aManyToManyRelations[$sKey] = new LS_ManyToManyRelation($res);
}
return $res;
}
return null;
} elseif ($sType=='set' and array_key_exists(0,$aArgs)) {
if (array_key_exists($sKey,$this->aRelations)) {
$this->aRelationsData[$sKey]=$aArgs[0];
} else {
$this->_aData[$this->_getField($sKey)]=$aArgs[0];
}
} elseif ($sType=='reload') {
if (array_key_exists($sKey,$this->aRelationsData)) {
unset($this->aRelationsData[$sKey]);
return $this->__call('get'.func_camelize($sKey),$aArgs);
}
}
} else {
return Engine::getInstance()->_CallModule($sName,$aArgs);
}
}
Ставим хук на вызов неизвестного метода и считаем что хотели вызвать метод какого либо модуля Также производит обработку методов set* и get* Учитывает связи и может возвращать связанные данные
See Also
public void __construct(bool $aParam=false)
| ||
$aParam | bool | Ассоциативный массив данных сущности |
public function __construct($aParam=false) {
parent::__construct($aParam);
$this->aRelations=$this->_getRelations();
}
Установка связей
See Also
public mixed __get(string $sName)
| ||
$sName | string | Название свойства к которому обращаемсяя |
{return} | mixed |
public function __get($sName) {
// Обработка обращений к обёрткам связей MANY_TO_MANY
// Если связь загружена, возвращаем объект связи
if (isset($this->_aManyToManyRelations[func_underscore($sName)])) {
return $this->_aManyToManyRelations[func_underscore($sName)];
// Есл не загружена, но связь с таким именем существет, пробуем загрузить и вернуть объект связи
} elseif (isset($this->aRelations[func_underscore($sName)]) && $this->aRelations[func_underscore($sName)][0] == self::RELATION_TYPE_MANY_TO_MANY) {
$sMethod = 'get' . func_camelize($sName);
$this->__call($sMethod, array());
if (isset($this->_aManyToManyRelations[func_underscore($sName)])) {
return $this->_aManyToManyRelations[func_underscore($sName)];
}
// В противном случае возвращаем то, что просили у объекта
} else {
return $this->$sName;
}
}
Используется для доступа к связанным данным типа MANY_TO_MANY
public null|string _getField(string $sField, int $iPersistence=3)
| ||
$sField | string | Название поля |
$iPersistence | int | Тип "глубины" определения поля |
{return} | null|string |
public function _getField($sField,$iPersistence=3) {
if($aFields=$this->_getFields()) {
if(in_array($sField,$aFields)) {
return $sField;
}
if($iPersistence==0) {
return null;
}
$sFieldU = func_camelize($sField);
$sEntityField = func_underscore(Engine::GetEntityName($this).$sFieldU);
if(in_array($sEntityField,$aFields)) {
return $sEntityField;
}
if($iPersistence==1) {
return null;
}
$sModuleEntityField = func_underscore(Engine::GetModuleName($this).Engine::GetEntityName($this).$sFieldU);
if(in_array($sModuleEntityField,$aFields)) {
return $sModuleEntityField;
}
if($iPersistence==2) {
return null;
}
$sModuleField = func_underscore(Engine::GetModuleName($this).$sFieldU);
if(in_array($sModuleField,$aFields)) {
return $sModuleField;
}
}
return $sField;
}
Возвращает поле в нужном формате
public array _getFields()
| ||
{return} | array |
public function _getFields() {
if(empty($this->aFields)) {
$this->aFields=$this->ShowColumns();
}
return $this->aFields;
}
Возвращает список полей сущности
public array _getOriginalData()
| ||
{return} | array |
public function _getOriginalData() {
return $this->_aOriginalData;
}
Возвращает все данные сущности
public string|array _getPrimaryKey()
| ||
{return} | string|array | Если индекс составной, то возвращает массив полей |
public function _getPrimaryKey() {
if(!$this->sPrimaryKey) {
if ($aIndex=$this->ShowPrimaryIndex()) {
if (count($aIndex)>1) {
// Составной индекс
$this->sPrimaryKey=$aIndex;
} else {
$this->sPrimaryKey=$aIndex[1];
}
}
}
return $this->sPrimaryKey;
}
Получение primary key из схемы таблицы
public string _getPrimaryKeyValue()
| ||
{return} | string |
public function _getPrimaryKeyValue() {
return $this->_getDataOne($this->_getPrimaryKey());
}
Получение значения primary key
public array _getRelations()
| ||
{return} | array |
public function _getRelations() {
$sParent=get_parent_class($this);
if(substr_count($sParent,'_Inherits_') || substr_count($sParent,'_Inherit_')) {
$sParent = get_parent_class($sParent);
}
$aParentRelations=array();
if(!in_array($sParent,array('Entity','EntityORM'))) {
$oEntityParent=new $sParent();
$aParentRelations=$oEntityParent->_getRelations();
}
return array_merge($aParentRelations,$this->aRelations);
}
Возвращает список связей
public array _getRelationsData()
| ||
{return} | array |
public function _getRelationsData() {
return $this->aRelationsData;
}
Возвращает список данный связей
public bool _isNew()
| ||
{return} | bool |
public function _isNew() {
return $this->bIsNew;
}
Новая или нет сущность Новая - еще не сохранялась в БД
public void _setData(array $aData)
| ||
$aData | array | Ассоциативный массив данных сущности |
public function _setData($aData) {
if(is_array($aData)) {
foreach ($aData as $sKey => $val) {
if (array_key_exists($sKey,$this->aRelations)) {
$this->aRelationsData[$sKey]=$val;
} else {
$this->_aData[$sKey] = $val;
}
}
$this->_aOriginalData = $this->_aData;
}
}
Устанавливает данные сущности
public void _setRelationsData(array $aData)
| ||
$aData | array | Список связанных данных |
public function _setRelationsData($aData) {
$this->aRelationsData=$aData;
}
Устанавливает данные связей
protected void afterDelete()
|
protected function afterDelete() {
}
Хук, срабатывает после удаления сущности
protected void afterSave()
|
protected function afterSave() {
}
Хук, срабатывает после сохранением сущности
protected bool beforeDelete()
| ||
{return} | bool |
protected function beforeDelete() {
return true;
}
Хук, срабатывает перед удалением сущности
protected bool beforeSave()
| ||
{return} | bool |
protected function beforeSave() {
return true;
}
Хук, срабатывает перед сохранением сущности
public array getAncestors()
| ||
{return} | array |
public function getAncestors() {
if(in_array(self::RELATION_TYPE_TREE,$this->aRelations)) {
return $this->_Method(__FUNCTION__ .'Of');
}
return $this->__call(__FUNCTION__,array());
}
Для сущности со связью RELATION_TYPE_TREE возвращает список всех предков
public array getChildren()
| ||
{return} | array |
public function getChildren() {
if(in_array(self::RELATION_TYPE_TREE,$this->aRelations)) {
return $this->_Method(__FUNCTION__ .'Of');
}
return $this->__call(__FUNCTION__,array());
}
Для сущности со связью RELATION_TYPE_TREE возвращает список прямых потомков
public array getDescendants()
| ||
{return} | array |
public function getDescendants() {
if(in_array(self::RELATION_TYPE_TREE,$this->aRelations)) {
return $this->_Method(__FUNCTION__ .'Of');
}
return $this->__call(__FUNCTION__,array());
}
Для сущности со связью RELATION_TYPE_TREE возвращает список всех потомков
public Entity getParent()
| ||
{return} | Entity |
public function getParent() {
if(in_array(self::RELATION_TYPE_TREE,$this->aRelations)) {
return $this->_Method(__FUNCTION__ .'Of');
}
return $this->__call(__FUNCTION__,array());
}
Для сущности со связью RELATION_TYPE_TREE возвращает предка
public void resetRelationsData(string $sKey)
| ||
$sKey | string | Ключ(поле) связи |
public function resetRelationsData($sKey) {
if (isset($this->aRelationsData[$sKey])) {
unset($this->aRelationsData[$sKey]);
}
}
Сбрасывает данные необходимой связи
public void setAncestors(array $oParent=NULL)
| ||
$oParent | array | Родитель |
public function setAncestors($oParent=null) {
if(in_array(self::RELATION_TYPE_TREE,$this->aRelations)) {
$this->aRelationsData['ancestors'] = $oParent;
} else {
$aArgs = func_get_args();
return $this->__call(__FUNCTION__,$aArgs);
}
}
Для сущности со связью RELATION_TYPE_TREE устанавливает предков
public void setChildren(array $aChildren=array (
))
| ||
$aChildren | array | Список потомков |
public function setChildren($aChildren=array()) {
if(in_array(self::RELATION_TYPE_TREE,$this->aRelations)) {
$this->aRelationsData['children'] = $aChildren;
} else {
$aArgs = func_get_args();
return $this->__call(__FUNCTION__,$aArgs);
}
}
Для сущности со связью RELATION_TYPE_TREE устанавливает потомков
public void setDescendants(array $aDescendants=array (
))
| ||
$aDescendants | array | Список потомков |
public function setDescendants($aDescendants=array()) {
if(in_array(self::RELATION_TYPE_TREE,$this->aRelations)) {
$this->aRelationsData['descendants'] = $aDescendants;
} else {
$aArgs = func_get_args();
return $this->__call(__FUNCTION__,$aArgs);
}
}
Для сущности со связью RELATION_TYPE_TREE устанавливает потомков
public void setParent(Entity $oParent=NULL)
| ||
$oParent | Entity | Родитель |
public function setParent($oParent=null) {
if(in_array(self::RELATION_TYPE_TREE,$this->aRelations)) {
$this->aRelationsData['parent'] = $oParent;
} else {
$aArgs = func_get_args();
return $this->__call(__FUNCTION__,$aArgs);
}
}
Для сущности со связью RELATION_TYPE_TREE устанавливает предка