public function testIfWillSetDeleteScenarioOnDeletedObject()
{
$model = new BaseAttributesScenario();
(new EntityManager($model))->save();
(new EntityManager($model))->delete();
$this->assertSame(ScenarioManager::getScenario($model), ScenariosInterface::Delete);
}
public function testIfWillSetDeleteScenarioOnDeletedObject()
{
$model = new DocumentBaseAttributes();
$model->save();
$model->delete();
$this->assertSame(ScenarioManager::getScenario($model), ScenariosInterface::Delete);
}
public function testIfWillFailValidationExceptInsertAndRegister()
{
$model = new ModelWithValidationExceptInsertAndRegister();
$validator = new Validator($model);
$valid = $validator->validate();
$this->assertTrue($valid);
ScenarioManager::setScenario($model, 'register');
$valid2 = $validator->validate();
$this->assertTrue($valid2);
ScenarioManager::setScenario($model, 'update');
$valid3 = $validator->validate();
$this->assertFalse($valid3);
}
/**
* Restore trashed item
* @return boolean
* @throws Exception
* @Ignored
*/
public function restore()
{
if (!$this instanceof TrashInterface) {
// When trying to restore normal document instead of trash item
throw new Exception(sprintf('Restore can be performed only on `%s` instance', TrashInterface::class));
}
$em = new EntityManager($this->data);
// Set scenario to `restore` for model, which is just about to be restored
ScenarioManager::setScenario($this->data, TrashInterface::ScenarioRestore);
if (!Event::valid($this->data, TrashInterface::EventBeforeRestore)) {
return false;
}
$saved = $em->save();
if (!$saved) {
return false;
}
$finder = new Finder($this->data);
$model = $finder->find(PkManager::prepareFromModel($this->data));
if (!$model) {
return false;
}
$eventAfter = new RestoreEvent();
$eventAfter->setTrashed($this->data);
$eventAfter->setTrash($this);
if (!Event::valid($model, TrashInterface::EventAfterRestore, $eventAfter)) {
return false;
}
$trashEm = new EntityManager($this);
$this->data = null;
// Use deleteOne, to avoid beforeDelete event,
// which should be raised only when really removing document:
// when emtying trash
return $trashEm->deleteOne(PkManager::prepareFromModel($this));
}
/**
* Validates the attribute of the object.
* If there is any error, the error message is added to the object.
* @param AnnotatedInterface $model the object being validated
* @param string $attribute the attribute being validated
*/
public function isValid(AnnotatedInterface $model, $attribute)
{
$value = $model->{$attribute};
if ($this->allowEmpty && empty($value)) {
return true;
}
$className = empty($this->className) ? get_class($model) : $this->className;
$compareModel = new $className();
$criteria = (new Criteria())->decorateWith($compareModel);
$criteria->addCond($attribute, '==', $value);
if ($this->criteria !== []) {
$criteria->mergeWith($this->criteria);
}
ScenarioManager::setScenario($compareModel, ValidatorInterface::ScenarioValidate);
$finder = new Finder($compareModel);
$found = $finder->find($criteria);
// Not found entirely
if (null === $found) {
return true;
}
// Same pk
if (PkManager::compare($found, $model)) {
return true;
}
$label = ManganMeta::create($model)->field($attribute)->label;
$this->addError('msgTaken', ['{attribute}' => $label, '{value}' => $value]);
return false;
}
private function validateEntity($name, $validators)
{
$valid = [];
foreach ($validators as $validatorMeta) {
// Filter out validators based on scenarios
if (!empty($validatorMeta->on)) {
$on = (array) $validatorMeta->on;
$enabled = false;
foreach ($on as $scenario) {
if ($scenario === ScenarioManager::getScenario($this->model)) {
$enabled = true;
break;
}
}
if (!$enabled) {
continue;
}
}
if (!empty($validatorMeta->except)) {
$except = (array) $validatorMeta->except;
$enabled = true;
foreach ($except as $scenario) {
if ($scenario === ScenarioManager::getScenario($this->model)) {
$enabled = false;
break;
}
}
if (!$enabled) {
continue;
}
}
// Create validator and validate
$validator = Factory::create($this->model, $validatorMeta, $name);
if ($validator->isValid($this->model, $name)) {
$valid[] = true;
} else {
$valid[] = false;
$this->errors[$name] = array_merge($this->errors[$name], $validator->getErrors());
// Set errors to model instance if it implements ValidatableInterface
if ($this->model instanceof ValidatableInterface) {
$this->model->setErrors($this->errors);
}
}
}
return count($valid) === array_sum($valid);
}
/**
* This method is invoked before deleting a record.
* The default implementation raises the {@link onBeforeDelete} event.
* You may override this method to do any preparation work for record deletion.
* Make sure you call the parent implementation so that the event is raised properly.
* @return boolean whether the record should be deleted. Defaults to true.
* @since v1.0
*/
private function _beforeDelete()
{
$result = Event::valid($this->model, EntityManagerInterface::EventBeforeDelete);
if ($result) {
(new Signal())->emit(new BeforeDelete($this->model));
ScenarioManager::setScenario($this->model, ScenariosInterface::Delete);
}
return $result;
}
/**
* Creates an model with the given attributes.
* This method is internally used by the find methods.
* @param mixed[] $data attribute values (column name=>column value)
* @return AnnotatedInterface|null the newly created document. The class of the object is the same as the model class.
* Null is returned if the input data is false.
* @since v1.0
*/
protected function populateRecord($data)
{
if ($data !== null) {
if (!empty($data['$err'])) {
throw new ManganException(sprintf("There is an error in query: %s", $data['$err']));
}
$model = RawArray::toModel($data, $this->model);
ScenarioManager::setScenario($model, ScenariosInterface::Update);
Event::trigger($model, FinderInterface::EventAfterFind);
return $model;
} else {
return null;
}
}
