EntityManager::__construct() - Code Metrics - Inspection of "* meta" - Maslosoft/Mangan - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c8f19a...ddbfd2 )

by Peter

created 2018-01-23 11:45 UTC

EntityManager::__construct() A

↳ Parent: EntityManager

Complexity

Conditions	3
Paths	4

Size

Total Lines	18
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	15
CRAP Score	3.0021

Importance

Changes

Metric	Value
dl	0
loc	18
ccs	15
cts	16
cp	0.9375
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	12
nc	4
nop	2
crap	3.0021

<?php

/**
 * This software package is licensed under AGPL or Commercial license.
 *
 * @package maslosoft/mangan
 * @licence AGPL or Commercial
 * @copyright Copyright (c) Piotr Masełkowski <[email protected]>
 * @copyright Copyright (c) Maslosoft
 * @copyright Copyright (c) Others as mentioned in code
 * @link https://maslosoft.com/mangan/
 */

namespace Maslosoft\Mangan;

use Maslosoft\Addendum\Interfaces\AnnotatedInterface;
use Maslosoft\Mangan\Events\Event;
use Maslosoft\Mangan\Events\EventDispatcher;
use Maslosoft\Mangan\Events\ModelEvent;
use Maslosoft\Mangan\Exceptions\BadAttributeException;
use Maslosoft\Mangan\Exceptions\ManganException;
use Maslosoft\Mangan\Exceptions\PkException;
use Maslosoft\Mangan\Helpers\CollectionNamer;
use Maslosoft\Mangan\Helpers\PkManager;
use Maslosoft\Mangan\Interfaces\CriteriaInterface;
use Maslosoft\Mangan\Interfaces\EntityManagerInterface;
use Maslosoft\Mangan\Interfaces\ScenariosInterface;
use Maslosoft\Mangan\Meta\ManganMeta;
use Maslosoft\Mangan\Options\EntityOptions;
use Maslosoft\Mangan\Signals\AfterDelete;
use Maslosoft\Mangan\Signals\AfterSave;
use Maslosoft\Mangan\Signals\BeforeDelete;
use Maslosoft\Mangan\Signals\BeforeSave;
use Maslosoft\Mangan\Transformers\RawArray;
use Maslosoft\Mangan\Transformers\SafeArray;
use Maslosoft\Signals\Signal;
use MongoCollection;

/**
 * EntityManager
 *
 * @author Piotr Maselkowski <pmaselkowski at gmail.com>
 */
class EntityManager implements EntityManagerInterface
{

	/**
	 * Model
	 * @var AnnotatedInterface
	 */
	public $model = null;

	/**
	 *
	 * @var EventDispatcher
	 */
	public $ed = null;

	/**
	 *
	 * @var ScopeManager
	 */
	private $sm = null;

	/**
	 *
	 * @var
	 */
	public $meta = null;

	/**
	 * Options
	 * @var EntityOptions
	 */
	public $options = null;

	/**
	 * Current collection name
	 * @var string
	 */
	public $collectionName = '';

	/**
	 * Validator instance
	 * @var Validator
	 */
	private $validator = null;

	/**
	 * Current collection
	 * @var MongoCollection
	 */
	private $_collection = null;

	/**
	 * Create entity manager
	 * @param AnnotatedInterface $model
	 * @param Mangan $mangan
	 * @throws ManganException
	 */
	public function __construct(AnnotatedInterface $model, Mangan $mangan = null)
	{
		$this->model = $model;
		$this->sm = new ScopeManager($model);
		$this->options = new EntityOptions($model);
		$this->collectionName = CollectionNamer::nameCollection($model);
		$this->meta = ManganMeta::create($model);
		$this->validator = new Validator($model);
		if (null === $mangan)
		{
			$mangan = Mangan::fromModel($model);
		}
		if (!$this->collectionName)
		{
			throw new ManganException(sprintf('Invalid collection name for model: `%s`', $this->meta->type()->name));
		}
		$this->_collection = new MongoCollection($mangan->getDbInstance(), $this->collectionName);
	}

	/**
	 * Create model related entity manager.
	 * This will create customized entity manger if defined in model with EntityManager annotation.
	 * If no custom entity manager is defined this will return default EntityManager.
	 * @param AnnotatedInterface $model
	 * @param Mangan $mangan
	 * @return EntityManagerInterface
	 */
	public static function create($model, Mangan $mangan = null)
	{
		$emClass = ManganMeta::create($model)->type()->entityManager ?: static::class;
		return new $emClass($model, $mangan);
	}

	/**
	 * Set attributes en masse.
	 * Attributes will be filtered according to SafeAnnotation.
	 * Only attributes marked as safe will be set, other will be ignored.
	 *
	 * @param mixed[] $atributes
	 */
	public function setAttributes($atributes)
	{
		SafeArray::toModel($atributes, $this->model, $this->model);
	}

	/**
	 * Inserts a row into the table based on this active record attributes.
	 * If the table's primary key is auto-incremental and is null before insertion,
	 * it will be populated with the actual value after insertion.
	 *
	 * Note, validation is not performed in this method. You may call {@link validate} to perform the validation.
	 * After the record is inserted to DB successfully, its {@link isNewRecord} property will be set false,
	 * and its {@link scenario} property will be set to be 'update'.
	 *
	 * @param AnnotatedInterface $model if want to insert different model than set in constructor
	 *
	 * @return boolean whether the attributes are valid and the record is inserted successfully.
	 * @throws ManganException if the record is not new
	 * @throws ManganException on fail of insert or insert of empty document
	 * @throws ManganException on fail of insert, when safe flag is set to true
	 * @throws ManganException on timeout of db operation , when safe flag is set to true
	 * @since v1.0
	 */
	public function insert(AnnotatedInterface $model = null)
	{
		$model = $model ?: $this->model;
		if ($this->_beforeSave($model, EntityManagerInterface::EventBeforeInsert))
		{
			$rawData = RawArray::fromModel($model);
			/**
			 * TODO Save options ara failing with message:
			 * Unrecognized write concern field: authMechanism
			 * $this->options->getSaveOptions()
			 */
			$rawResult = $this->_collection->insert($rawData);
			$result = $this->_result($rawResult, true);

			if ($result)
			{
				$this->_afterSave($model, EntityManagerInterface::EventAfterInsert);
				return true;
			}
			codecept_debug($rawResult);
			throw new ManganException('Can\t save the document to disk, or attempting to save an empty document. ' . ucfirst($rawResult['errmsg']), $rawResult['code']);
		}
		return false;
	}

	/**
	 * Updates the row represented by this active document.
	 * All loaded attributes will be saved to the database.
	 * Note, validation is not performed in this method. You may call {@link validate} to perform the validation.
	 *
	 * @param array $attributes list of attributes that need to be saved. Defaults to null,
	 * meaning all attributes that are loaded from DB will be saved.

	 * @return boolean whether the update is successful
	 * @throws ManganException if the record is new
	 * @throws ManganException on fail of update
	 * @throws ManganException on timeout of db operation , when safe flag is set to true
	 * @since v1.0
	 */
	public function update(array $attributes = null)
	{
		if ($this->_beforeSave($this->model, EntityManagerInterface::EventBeforeUpdate))
		{
			$criteria = PkManager::prepareFromModel($this->model);
			$result = $this->updateOne($criteria, $attributes);
			if ($result)
			{
				$this->_afterSave($this->model, EntityManagerInterface::EventAfterUpdate);
				return true;
			}
			throw new ManganException('Can\t save the document to disk, or attempting to save an empty document.');
		}
		return false;
	}

	/**
	 * Updates one document with the specified criteria and attributes
	 *
	 * This is more *raw* update:
	 *
	 * * Does not raise any events or signals
	 * * Does not perform any validation
	 *
	 * @param array|CriteriaInterface $criteria query criteria.
	 * @param array $attributes list of attributes that need to be saved. Defaults to null,
	 * @param bool Whether tu force update/upsert document
	 * meaning all attributes that are loaded from DB will be saved.
	 * @since v1.0
	 */
	public function updateOne($criteria = null, array $attributes = null, $modify = false)
	{
		$criteria = $this->sm->apply($criteria);
		$rawData = RawArray::fromModel($this->model);

		// filter attributes if set in param
		if ($attributes !== null)
		{
			$meta = ManganMeta::create($this->model);
			foreach ($attributes as $key)
			{
				if ($meta->$key === false)
				{
					throw new BadAttributeException(sprintf("Unknown attribute `%s` on model `%s`", $key, get_class($this->model)));
				}
			}
			$modify = true;
			foreach ($rawData as $key => $value)
			{
				if (!in_array($key, $attributes))
				{
					unset($rawData[$key]);
				}
			}
		}
		else
		{
			$fields = array_keys(ManganMeta::create($this->model)->fields());
			$setFields = array_keys($rawData);
			$diff = array_diff($fields, $setFields);

			if (!empty($diff))
			{
				$modify = true;
			}
		}
		if ($modify)
		{
			// Id could be altered, so skip it as it cannot be changed
			unset($rawData['_id']);
			$data = ['$set' => $rawData];
		}
		else
		{
			$data = $rawData;
		}

		$result = $this->getCollection()->update($criteria->getConditions(), $data, $this->options->getSaveOptions(['multiple' => false, 'upsert' => true]));
		return $this->_result($result);
	}

	/**
	 * Atomic, in-place update method.
	 *
	 * @since v1.3.6
	 * @param Modifier $modifier updating rules to apply
	 * @param CriteriaInterface $criteria condition to limit updating rules
	 * @return boolean
	 */
	public function updateAll(Modifier $modifier, CriteriaInterface $criteria = null)
	{
		if ($modifier->canApply())
		{
			$criteria = $this->sm->apply($criteria);
			$result = $this->getCollection()->update($criteria->getConditions(), $modifier->getModifiers(), $this->options->getSaveOptions([
						'upsert' => false,
						'multiple' => true
			]));
			return $this->_result($result);
		}
		else
		{
			return false;
		}
	}

	/**
	 * Replaces the current document.
	 *
	 * **NOTE: This will overwrite entire document.**
	 * Any filtered out properties will be removed as well.
	 *
	 * The record is inserted as a documnent into the database collection, if exists it will be replaced.
	 *
	 * Validation will be performed before saving the record. If the validation fails,
	 * the record will not be saved. You can call {@link getErrors()} to retrieve the
	 * validation errors.
	 *
	 * @param boolean $runValidation whether to perform validation before saving the record.
	 * If the validation fails, the record will not be saved to database.
	 *
	 * @return boolean whether the saving succeeds
	 * @since v1.0
	 */
	public function replace($runValidation = true)
	{
		if (!$runValidation || $this->validator->validate())
		{
			$model = $this->model;
			if ($this->_beforeSave($model))
			{
				$data = RawArray::fromModel($model);
				$rawResult = $this->_collection->save($data, $this->options->getSaveOptions());
				$result = $this->_result($rawResult, true);

				if ($result)
				{
					$this->_afterSave($model);
					return true;
				}
				$msg = '';
				if(!empty($rawResult['errmsg']))
				{
					$msg = $rawResult['errmsg'];
				}
				throw new ManganException("Can't save the document to disk, or attempting to save an empty document. $msg");
			}
			return false;
		}
		else
		{
			return false;
		}
	}

	/**
	 * Saves the current document.
	 *
	 * The record is inserted as a document into the database collection or updated if exists.
	 *
	 * Filtered out properties will remain in database - it is partial safe.
	 *
	 * Validation will be performed before saving the record. If the validation fails,
	 * the record will not be saved. You can call {@link getErrors()} to retrieve the
	 * validation errors.
	 *
	 * @param boolean $runValidation whether to perform validation before saving the record.
	 * If the validation fails, the record will not be saved to database.
	 *
	 * @return boolean whether the saving succeeds
	 * @since v1.0
	 */
	public function save($runValidation = true)
	{
		return $this->upsert($runValidation);
	}

	/**
	 * Updates or inserts the current document. This will try to update existing fields.
	 * Will keep already stored data if present in document.
	 *
	 * If document does not exist, a new one will be inserted.
	 *
	 * @param boolean $runValidation
	 * @return boolean
	 * @throws ManganException
	 */
	public function upsert($runValidation = true)
	{
		if (!$runValidation || $this->validator->validate())
		{
			$model = $this->model;
			if ($this->_beforeSave($model))
			{
				$criteria = PkManager::prepareFromModel($this->model);
				foreach ($criteria->getConditions() as $field => $value)
				{
					if (empty($this->model->$field))
					{
						$this->model->$field = $value;
					}
				}
				$result = $this->updateOne($criteria);

				if ($result)
				{
					$this->_afterSave($model);
					return true;
				}
				throw new ManganException("Can't save the document to disk, or attempting to save an empty document");
			}
			return false;
		}
		else
		{
			return false;
		}
	}

	/**
	 * Reloads document from database.
	 * It return true if document is reloaded and false if it's no longer exists.
	 *
	 * @return boolean
	 */
	public function refresh()
	{
		$conditions = PkManager::prepareFromModel($this->model)->getConditions();
		$data = $this->getCollection()->findOne($conditions);
		if (null !== $data)
		{
			RawArray::toModel($data, $this->model, $this->model);
			return true;
		}
		else
		{
			return false;
		}
	}

	/**
	 * Deletes the document from database.
	 * @return boolean whether the deletion is successful.
	 * @throws ManganException if the record is new
	 */
	public function delete()
	{
		if ($this->_beforeDelete())
		{
			$result = $this->deleteOne(PkManager::prepareFromModel($this->model));

			if ($result !== false)
			{
				$this->_afterDelete();
				return true;
			}
			else
			{
				return false;
			}
		}
		else
		{
			return false;
		}
	}

	/**
	 * Deletes one document with the specified primary keys.
	 * <b>Does not raise beforeDelete</b>
	 * See {@link find()} for detailed explanation about $condition and $params.
	 * @param array|CriteriaInterface $criteria query criteria.
	 * @since v1.0
	 */
	public function deleteOne($criteria = null)
	{
		$criteria = $this->sm->apply($criteria);

		$result = $this->getCollection()->remove($criteria->getConditions(), $this->options->getSaveOptions([
					'justOne' => true
		]));
		return $this->_result($result);
	}

	/**
	 * Deletes document with the specified primary key.
	 * See {@link find()} for detailed explanation about $condition and $params.
	 * @param mixed $pkValue primary key value(s). Use array for multiple primary keys. For composite key, each key value must be an array (column name=>column value).
	 * @param array|CriteriaInterface $criteria query criteria.
	 * @since v1.0
	 */
	public function deleteByPk($pkValue, $criteria = null)
	{
		if ($this->_beforeDelete())
		{
			$criteria = $this->sm->apply($criteria);
			$criteria->mergeWith(PkManager::prepare($this->model, $pkValue));

			$result = $this->getCollection()->remove($criteria->getConditions(), $this->options->getSaveOptions([
						'justOne' => true
			]));
			return $this->_result($result);
		}
		return false;
	}

	/**
	 * Deletes documents with the specified primary keys.
	 * See {@link find()} for detailed explanation about $condition and $params.
	 * @param mixed[] $pkValues Primary keys array
	 * @param array|CriteriaInterface $criteria query criteria.
	 * @since v1.0
	 */
	public function deleteAllByPk($pkValues, $criteria = null)
	{
		if ($this->_beforeDelete())
		{
			$criteria = $this->sm->apply($criteria);
			$criteria->mergeWith(PkManager::prepareAll($this->model, $pkValues, $criteria));
			$result = $this->getCollection()->remove($criteria->getConditions(), $this->options->getSaveOptions([
						'justOne' => false
			]));
			return $this->_result($result);
		}
		return false;
	}

	/**
	 * Deletes documents with the specified primary keys.
	 *
	 * **Does not raise beforeDelete event and does not emit signals**
	 *
	 * See {@link find()} for detailed explanation about $condition and $params.
	 *
	 * @param array|CriteriaInterface $criteria query criteria.
	 * @since v1.0
	 */
	public function deleteAll($criteria = null)
	{
		$criteria = $this->sm->apply($criteria);

		$result = $this->getCollection()->remove($criteria->getConditions(), $this->options->getSaveOptions([
					'justOne' => false
		]));
		return $this->_result($result);
	}

	public function getCollection()
	{
		return $this->_collection;
	}

	/**
	 * Make status uniform
	 * @param bool|array $result
	 * @param bool $insert Set to true for inserts
	 * @return bool Return true if secceed
	 */
	private function _result($result, $insert = false)
	{
		if (is_array($result))
		{
			if ($insert)
			{
				return (bool) $result['ok'];
			}
			return (bool) $result['n'];
		}
		return $result;
	}

// <editor-fold defaultstate="collapsed" desc="Event and Signal handling">

	/**
	 * Take care of EventBeforeSave
	 * @see EventBeforeSave
	 * @return boolean
	 */
	private function _beforeSave($model, $event = null)
	{
		$result = Event::Valid($model, EntityManagerInterface::EventBeforeSave);
		if ($result)
		{
			if (!empty($event))
			{
				Event::trigger($model, $event);
			}
			(new Signal)->emit(new BeforeSave($model));
		}
		return $result;
	}

	/**
	 * Take care of EventAfterSave
	 * @see EventAfterSave
	 */
	private function _afterSave($model, $event = null)
	{
		Event::trigger($model, EntityManagerInterface::EventAfterSave);
		if (!empty($event))
		{
			Event::trigger($model, $event);
		}
		(new Signal)->emit(new AfterSave($model));
		ScenarioManager::setScenario($model, ScenariosInterface::Update);
	}

	/**
	 * 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;
	}

	/**
	 * This method is invoked after deleting a record.
	 * The default implementation raises the {@link onAfterDelete} event.
	 * You may override this method to do postprocessing after the record is deleted.
	 * Make sure you call the parent implementation so that the event is raised properly.
	 * @since v1.0
	 */
	private function _afterDelete()
	{
		$event = new ModelEvent($this->model);
		Event::trigger($this->model, EntityManagerInterface::EventAfterDelete, $event);
		(new Signal)->emit(new AfterDelete($this->model));
	}

// </editor-fold>
}


1		<?php
2
3		/**
4		* This software package is licensed under AGPL or Commercial license.
5		*
6		* @package maslosoft/mangan
7		* @licence AGPL or Commercial
8		* @copyright Copyright (c) Piotr Masełkowski <[email protected]>
9		* @copyright Copyright (c) Maslosoft
10		* @copyright Copyright (c) Others as mentioned in code
11		* @link https://maslosoft.com/mangan/
12		*/
13
14		namespace Maslosoft\Mangan;
15
16		use Maslosoft\Addendum\Interfaces\AnnotatedInterface;
17		use Maslosoft\Mangan\Events\Event;
18		use Maslosoft\Mangan\Events\EventDispatcher;
19		use Maslosoft\Mangan\Events\ModelEvent;
20		use Maslosoft\Mangan\Exceptions\BadAttributeException;
21		use Maslosoft\Mangan\Exceptions\ManganException;
22		use Maslosoft\Mangan\Exceptions\PkException;
23		use Maslosoft\Mangan\Helpers\CollectionNamer;
24		use Maslosoft\Mangan\Helpers\PkManager;
25		use Maslosoft\Mangan\Interfaces\CriteriaInterface;
26		use Maslosoft\Mangan\Interfaces\EntityManagerInterface;
27		use Maslosoft\Mangan\Interfaces\ScenariosInterface;
28		use Maslosoft\Mangan\Meta\ManganMeta;
29		use Maslosoft\Mangan\Options\EntityOptions;
30		use Maslosoft\Mangan\Signals\AfterDelete;
31		use Maslosoft\Mangan\Signals\AfterSave;
32		use Maslosoft\Mangan\Signals\BeforeDelete;
33		use Maslosoft\Mangan\Signals\BeforeSave;
34		use Maslosoft\Mangan\Transformers\RawArray;
35		use Maslosoft\Mangan\Transformers\SafeArray;
36		use Maslosoft\Signals\Signal;
37		use MongoCollection;
38
39		/**
40		* EntityManager
41		*
42		* @author Piotr Maselkowski <pmaselkowski at gmail.com>
43		*/
44		class EntityManager implements EntityManagerInterface
45		{
46
47		/**
48		* Model
49		* @var AnnotatedInterface
50		*/
51		public $model = null;
52
53		/**
54		*
55		* @var EventDispatcher
56		*/
57		public $ed = null;
58
59		/**
60		*
61		* @var ScopeManager
62		*/
63		private $sm = null;
64
65		/**
66		*
67		* @var
68		*/
69		public $meta = null;
70
71		/**
72		* Options
73		* @var EntityOptions
74		*/
75		public $options = null;
76
77		/**
78		* Current collection name
79		* @var string
80		*/
81		public $collectionName = '';
82
83		/**
84		* Validator instance
85		* @var Validator
86		*/
87		private $validator = null;
88
89		/**
90		* Current collection
91		* @var MongoCollection
92		*/
93		private $_collection = null;
94
95		/**
96		* Create entity manager
97		* @param AnnotatedInterface $model
98		* @param Mangan $mangan
99		* @throws ManganException
100		*/
101	110	public function __construct(AnnotatedInterface $model, Mangan $mangan = null)
102		{
103	110	$this->model = $model;
104	110	$this->sm = new ScopeManager($model);
105	110	$this->options = new EntityOptions($model);
106	110	$this->collectionName = CollectionNamer::nameCollection($model);
107	110	$this->meta = ManganMeta::create($model);
108	110	$this->validator = new Validator($model);
109	110	if (null === $mangan)
110	110	{
111	107	$mangan = Mangan::fromModel($model);
112	107	}
113	110	if (!$this->collectionName)
114	110	{
115		throw new ManganException(sprintf('Invalid collection name for model: `%s`', $this->meta->type()->name));
116		}
117	110	$this->_collection = new MongoCollection($mangan->getDbInstance(), $this->collectionName);
118	110	}
119
120		/**
121		* Create model related entity manager.
122		* This will create customized entity manger if defined in model with EntityManager annotation.
123		* If no custom entity manager is defined this will return default EntityManager.
124		* @param AnnotatedInterface $model
125		* @param Mangan $mangan
126		* @return EntityManagerInterface
127		*/
128	101	public static function create($model, Mangan $mangan = null)
129		{
130	101	$emClass = ManganMeta::create($model)->type()->entityManager ?: static::class;
131	101	return new $emClass($model, $mangan);
132		}
133
134		/**
135		* Set attributes en masse.
136		* Attributes will be filtered according to SafeAnnotation.
137		* Only attributes marked as safe will be set, other will be ignored.
138		*
139		* @param mixed[] $atributes
140		*/
141		public function setAttributes($atributes)
142		{
143		SafeArray::toModel($atributes, $this->model, $this->model);
144		}
145
146		/**
147		* Inserts a row into the table based on this active record attributes.
148		* If the table's primary key is auto-incremental and is null before insertion,
149		* it will be populated with the actual value after insertion.
150		*
151		* Note, validation is not performed in this method. You may call {@link validate} to perform the validation.
152		* After the record is inserted to DB successfully, its {@link isNewRecord} property will be set false,
153		* and its {@link scenario} property will be set to be 'update'.
154		*
155		* @param AnnotatedInterface $model if want to insert different model than set in constructor
156		*
157		* @return boolean whether the attributes are valid and the record is inserted successfully.
158		* @throws ManganException if the record is not new
159		* @throws ManganException on fail of insert or insert of empty document
160		* @throws ManganException on fail of insert, when safe flag is set to true
161		* @throws ManganException on timeout of db operation , when safe flag is set to true
162		* @since v1.0
163		*/
164	36	public function insert(AnnotatedInterface $model = null)
165		{
166	36	$model = $model ?: $this->model;
167	36	if ($this->_beforeSave($model, EntityManagerInterface::EventBeforeInsert))
168	36	{
169	36	$rawData = RawArray::fromModel($model);
170		/**
171		* TODO Save options ara failing with message:
172		* Unrecognized write concern field: authMechanism
173		* $this->options->getSaveOptions()
174		*/
175	36	$rawResult = $this->_collection->insert($rawData);
176	36	$result = $this->_result($rawResult, true);
177
178		if ($result)
179	36	{
180	36	$this->_afterSave($model, EntityManagerInterface::EventAfterInsert);
181	36	return true;
182		}
183		codecept_debug($rawResult);
184		throw new ManganException('Can\t save the document to disk, or attempting to save an empty document. ' . ucfirst($rawResult['errmsg']), $rawResult['code']);
185		}
186		return false;
187		}
188
189		/**
190		* Updates the row represented by this active document.
191		* All loaded attributes will be saved to the database.
192		* Note, validation is not performed in this method. You may call {@link validate} to perform the validation.
193		*
194		* @param array $attributes list of attributes that need to be saved. Defaults to null,
195		* meaning all attributes that are loaded from DB will be saved.
196
197		* @return boolean whether the update is successful
198		* @throws ManganException if the record is new
199		* @throws ManganException on fail of update
200		* @throws ManganException on timeout of db operation , when safe flag is set to true
201		* @since v1.0
202		*/
203	6	public function update(array $attributes = null)
204		{
205	6	if ($this->_beforeSave($this->model, EntityManagerInterface::EventBeforeUpdate))
206	6	{
207	6	$criteria = PkManager::prepareFromModel($this->model);
208	6	$result = $this->updateOne($criteria, $attributes);
209		if ($result)
210	5	{
211	5	$this->_afterSave($this->model, EntityManagerInterface::EventAfterUpdate);
212	5	return true;
213		}
214		throw new ManganException('Can\t save the document to disk, or attempting to save an empty document.');
215		}
216		return false;
217		}
218
219		/**
220		* Updates one document with the specified criteria and attributes
221		*
222		* This is more raw update:
223		*
224		* * Does not raise any events or signals
225		* * Does not perform any validation
226		*
227		* @param array\|CriteriaInterface $criteria query criteria.
228		* @param array $attributes list of attributes that need to be saved. Defaults to null,
229		* @param bool Whether tu force update/upsert document
230		* meaning all attributes that are loaded from DB will be saved.
231		* @since v1.0
232		*/
233	73	public function updateOne($criteria = null, array $attributes = null, $modify = false)
234		{
235	73	$criteria = $this->sm->apply($criteria);
236	73	$rawData = RawArray::fromModel($this->model);
237
238		// filter attributes if set in param
239	73	if ($attributes !== null)
240	73	{
241	2	$meta = ManganMeta::create($this->model);
242	2	foreach ($attributes as $key)
243		{
244	2	if ($meta->$key === false)
245	2	{
246	1	throw new BadAttributeException(sprintf("Unknown attribute `%s` on model `%s`", $key, get_class($this->model)));
247		}
248	2	}
249	1	$modify = true;
250	1	foreach ($rawData as $key => $value)
251		{
252	1	if (!in_array($key, $attributes))
253	1	{
254	1	unset($rawData[$key]);
255	1	}
256	1	}
257	1	}
258		else
259		{
260	73	$fields = array_keys(ManganMeta::create($this->model)->fields());
261	73	$setFields = array_keys($rawData);
262	73	$diff = array_diff($fields, $setFields);
263
264	73	if (!empty($diff))
265	73	{
266	6	$modify = true;
267	6	}
268		}
269		if ($modify)
270	73	{
271		// Id could be altered, so skip it as it cannot be changed
272	7	unset($rawData['_id']);
273	7	$data = ['$set' => $rawData];
274	7	}
275		else
276		{
277	70	$data = $rawData;
278		}
279
280	73	$result = $this->getCollection()->update($criteria->getConditions(), $data, $this->options->getSaveOptions(['multiple' => false, 'upsert' => true]));
281	73	return $this->_result($result);
282		}
283
284		/**
285		* Atomic, in-place update method.
286		*
287		* @since v1.3.6
288		* @param Modifier $modifier updating rules to apply
289		* @param CriteriaInterface $criteria condition to limit updating rules
290		* @return boolean
291		*/
292	1	public function updateAll(Modifier $modifier, CriteriaInterface $criteria = null)
293		{
294	1	if ($modifier->canApply())
295	1	{
296	1	$criteria = $this->sm->apply($criteria);
297	1	$result = $this->getCollection()->update($criteria->getConditions(), $modifier->getModifiers(), $this->options->getSaveOptions([
298	1	'upsert' => false,
299		'multiple' => true
300	1	]));
301	1	return $this->_result($result);
302		}
303		else
304		{
305		return false;
306		}
307		}
308
309		/**
310		* Replaces the current document.
311		*
312		* NOTE: This will overwrite entire document.
313		* Any filtered out properties will be removed as well.
314		*
315		* The record is inserted as a documnent into the database collection, if exists it will be replaced.
316		*
317		* Validation will be performed before saving the record. If the validation fails,
318		* the record will not be saved. You can call {@link getErrors()} to retrieve the
319		* validation errors.
320		*
321		* @param boolean $runValidation whether to perform validation before saving the record.
322		* If the validation fails, the record will not be saved to database.
323		*
324		* @return boolean whether the saving succeeds
325		* @since v1.0
326		*/
327		public function replace($runValidation = true)
328		{
329		if (!$runValidation \|\| $this->validator->validate())
330		{
331		$model = $this->model;
332		if ($this->_beforeSave($model))
333		{
334		$data = RawArray::fromModel($model);
335		$rawResult = $this->_collection->save($data, $this->options->getSaveOptions());
336		$result = $this->_result($rawResult, true);
337
338		if ($result)
339		{
340		$this->_afterSave($model);
341		return true;
342		}
343		$msg = '';
344		if(!empty($rawResult['errmsg']))
345		{
346		$msg = $rawResult['errmsg'];
347		}
348		throw new ManganException("Can't save the document to disk, or attempting to save an empty document. $msg");
349		}
350		return false;
351		}
352		else
353		{
354		return false;
355		}
356		}
357
358		/**
359		* Saves the current document.
360		*
361		* The record is inserted as a document into the database collection or updated if exists.
362		*
363		* Filtered out properties will remain in database - it is partial safe.
364		*
365		* Validation will be performed before saving the record. If the validation fails,
366		* the record will not be saved. You can call {@link getErrors()} to retrieve the
367		* validation errors.
368		*
369		* @param boolean $runValidation whether to perform validation before saving the record.
370		* If the validation fails, the record will not be saved to database.
371		*
372		* @return boolean whether the saving succeeds
373		* @since v1.0
374		*/
375	70	public function save($runValidation = true)
376		{
377	70	return $this->upsert($runValidation);
378		}
379
380		/**
381		* Updates or inserts the current document. This will try to update existing fields.
382		* Will keep already stored data if present in document.
383		*
384		* If document does not exist, a new one will be inserted.
385		*
386		* @param boolean $runValidation
387		* @return boolean
388		* @throws ManganException
389		*/
390	74	public function upsert($runValidation = true)
391		{
392	74	if (!$runValidation \|\| $this->validator->validate())
393	74	{
394	74	$model = $this->model;
395	74	if ($this->_beforeSave($model))
396	74	{
397	71	$criteria = PkManager::prepareFromModel($this->model);
398	71	foreach ($criteria->getConditions() as $field => $value)
399		{
400	71	if (empty($this->model->$field))
401	71	{
402	16	$this->model->$field = $value;
403	16	}
404	71	}
405	71	$result = $this->updateOne($criteria);
406
407		if ($result)
408	71	{
409	71	$this->_afterSave($model);
410	71	return true;
411		}
412		throw new ManganException("Can't save the document to disk, or attempting to save an empty document");
413		}
414	3	return false;
415		}
416		else
417		{
418	3	return false;
419		}
420		}
421
422		/**
423		* Reloads document from database.
424		* It return true if document is reloaded and false if it's no longer exists.
425		*
426		* @return boolean
427		*/
428	2	public function refresh()
429		{
430	2	$conditions = PkManager::prepareFromModel($this->model)->getConditions();
431	2	$data = $this->getCollection()->findOne($conditions);
432	2	if (null !== $data)
433	2	{
434	2	RawArray::toModel($data, $this->model, $this->model);
435	2	return true;
436		}
437		else
438		{
439	2	return false;
440		}
441		}
442
443		/**
444		* Deletes the document from database.
445		* @return boolean whether the deletion is successful.
446		* @throws ManganException if the record is new
447		*/
448	10	public function delete()
449		{
450	10	if ($this->_beforeDelete())
451	10	{
452	9	$result = $this->deleteOne(PkManager::prepareFromModel($this->model));
453
454	9	if ($result !== false)
455	9	{
456	9	$this->_afterDelete();
457	9	return true;
458		}
459		else
460		{
461	1	return false;
462		}
463		}
464		else
465		{
466	1	return false;
467		}
468		}
469
470		/**
471		* Deletes one document with the specified primary keys.
472		* <b>Does not raise beforeDelete</b>
473		* See {@link find()} for detailed explanation about $condition and $params.
474		* @param array\|CriteriaInterface $criteria query criteria.
475		* @since v1.0
476		*/
477	11	public function deleteOne($criteria = null)
478		{
479	11	$criteria = $this->sm->apply($criteria);
480
481	11	$result = $this->getCollection()->remove($criteria->getConditions(), $this->options->getSaveOptions([
482		'justOne' => true
483	11	]));
484	11	return $this->_result($result);
485		}
486
487		/**
488		* Deletes document with the specified primary key.
489		* See {@link find()} for detailed explanation about $condition and $params.
490		* @param mixed $pkValue primary key value(s). Use array for multiple primary keys. For composite key, each key value must be an array (column name=>column value).
491		* @param array\|CriteriaInterface $criteria query criteria.
492		* @since v1.0
493		*/
494	2	public function deleteByPk($pkValue, $criteria = null)
495		{
496	2	if ($this->_beforeDelete())
497	2	{
498	1	$criteria = $this->sm->apply($criteria);
499	1	$criteria->mergeWith(PkManager::prepare($this->model, $pkValue));
500
501	1	$result = $this->getCollection()->remove($criteria->getConditions(), $this->options->getSaveOptions([
502		'justOne' => true
503	1	]));
504	1	return $this->_result($result);
505		}
506	1	return false;
507		}
508
509		/**
510		* Deletes documents with the specified primary keys.
511		* See {@link find()} for detailed explanation about $condition and $params.
512		* @param mixed[] $pkValues Primary keys array
513		* @param array\|CriteriaInterface $criteria query criteria.
514		* @since v1.0
515		*/
516	2	public function deleteAllByPk($pkValues, $criteria = null)
517		{
518	2	if ($this->_beforeDelete())
519	2	{
520	1	$criteria = $this->sm->apply($criteria);
521	1	$criteria->mergeWith(PkManager::prepareAll($this->model, $pkValues, $criteria));
522	1	$result = $this->getCollection()->remove($criteria->getConditions(), $this->options->getSaveOptions([
523		'justOne' => false
524	1	]));
525	1	return $this->_result($result);
526		}
527	1	return false;
528		}
529
530		/**
531		* Deletes documents with the specified primary keys.
532		*
533		* Does not raise beforeDelete event and does not emit signals
534		*
535		* See {@link find()} for detailed explanation about $condition and $params.
536		*
537		* @param array\|CriteriaInterface $criteria query criteria.
538		* @since v1.0
539		*/
540	7	public function deleteAll($criteria = null)
541		{
542	7	$criteria = $this->sm->apply($criteria);
543
544	7	$result = $this->getCollection()->remove($criteria->getConditions(), $this->options->getSaveOptions([
545		'justOne' => false
546	7	]));
547	7	return $this->_result($result);
548		}
549
550	105	public function getCollection()
551		{
552	105	return $this->_collection;
553		}
554
555		/**
556		* Make status uniform
557		* @param bool\|array $result
558		* @param bool $insert Set to true for inserts
559		* @return bool Return true if secceed
560		*/
561	104	private function _result($result, $insert = false)
562		{
563	104	if (is_array($result))
564	104	{
565		if ($insert)
566	104	{
567	36	return (bool) $result['ok'];
568		}
569	73	return (bool) $result['n'];
570		}
571		return $result;
572		}
573
574		// <editor-fold defaultstate="collapsed" desc="Event and Signal handling">
575
576		/**
577		* Take care of EventBeforeSave
578		* @see EventBeforeSave
579		* @return boolean
580		*/
581	106	private function _beforeSave($model, $event = null)
582		{
583	106	$result = Event::Valid($model, EntityManagerInterface::EventBeforeSave);
584		if ($result)
585	106	{
586	103	if (!empty($event))
587	103	{
588	42	Event::trigger($model, $event);
589	42	}
590	103	(new Signal)->emit(new BeforeSave($model));
591	103	}
592	106	return $result;
593		}
594
595		/**
596		* Take care of EventAfterSave
597		* @see EventAfterSave
598		*/
599	103	private function _afterSave($model, $event = null)
600		{
601	103	Event::trigger($model, EntityManagerInterface::EventAfterSave);
602	103	if (!empty($event))
603	103	{
604	41	Event::trigger($model, $event);
605	41	}
606	103	(new Signal)->emit(new AfterSave($model));
607	103	ScenarioManager::setScenario($model, ScenariosInterface::Update);
608	103	}
609
610		/**
611		* This method is invoked before deleting a record.
612		* The default implementation raises the {@link onBeforeDelete} event.
613		* You may override this method to do any preparation work for record deletion.
614		* Make sure you call the parent implementation so that the event is raised properly.
615		* @return boolean whether the record should be deleted. Defaults to true.
616		* @since v1.0
617		*/
618	12	private function _beforeDelete()
619		{
620	12	$result = Event::valid($this->model, EntityManagerInterface::EventBeforeDelete);
621		if ($result)
622	12	{
623	11	(new Signal)->emit(new BeforeDelete($this->model));
624	11	ScenarioManager::setScenario($this->model, ScenariosInterface::Delete);
625	11	}
626	12	return $result;
627		}
628
629		/**
630		* This method is invoked after deleting a record.
631		* The default implementation raises the {@link onAfterDelete} event.
632		* You may override this method to do postprocessing after the record is deleted.
633		* Make sure you call the parent implementation so that the event is raised properly.
634		* @since v1.0
635		*/
636	9	private function _afterDelete()
637		{
638	9	$event = new ModelEvent($this->model);
639	9	Event::trigger($this->model, EntityManagerInterface::EventAfterDelete, $event);
640	9	(new Signal)->emit(new AfterDelete($this->model));
641	9	}
642
643		// </editor-fold>
644		}
645

Maslosoft / Mangan

Push — master ( c8f19a...ddbfd2 )

EntityManager::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like