vendor/bestit/commercetools-odm/src/DocumentManager.php line 213

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace BestIt\CommercetoolsODM;
  7. use BestIt\CommercetoolsODM\Helper\QueryHelperAwareTrait;
  8. use BestIt\CommercetoolsODM\Mapping\ClassMetadataInterface;
  9. use Commercetools\Commons\Helper\QueryHelper;
  10. use Commercetools\Core\Client;
  11. use Commercetools\Core\Request\AbstractApiRequest;
  12. use Commercetools\Core\Request\AbstractCreateRequest;
  13. use Commercetools\Core\Request\AbstractDeleteRequest;
  14. use Commercetools\Core\Request\AbstractUpdateRequest;
  15. use Doctrine\Common\Persistence\Mapping\ClassMetadata;
  16. use Doctrine\Common\Persistence\Mapping\ClassMetadataFactory;
  17. use Doctrine\Common\Persistence\ObjectRepository;
  18. use DomainException;
  19. use InvalidArgumentException;
  20. use Psr\Log\LoggerAwareTrait;
  21. use Psr\Log\NullLogger;
  22. use ReflectionClass;
  23. use function class_exists;
  24. use function sprintf;
  26. /**
  27. * Basic manager for the commercetools processes.
  28. *
  29. * @author lange <lange@bestit-online.de>
  30. * @package BestIt\CommercetoolsODM
  31. * @todo Add api for multiple clients.
  32. */
  33. class DocumentManager implements DocumentManagerInterface
  34. {
  35. use ClientAwareTrait;
  36. use LoggerAwareTrait;
  37. use MetadataFactoryAwareTrait;
  38. use QueryHelperAwareTrait;
  40. /**
  41. * The unit of work for this manager.
  42. *
  43. * @var UnitOfWorkInterface
  44. */
  45. private $unitOfWork;
  47. /**
  48. * DocumentManager constructor.
  49. *
  50. * @param ClassMetadataFactory $metadataFactory
  51. * @param Client $client
  52. * @param QueryHelper $queryHelper
  53. * @param RepositoryFactoryInterface $repositoryFactory
  54. * @param UnitOfWorkFactoryInterface $unitOfWorkFactory
  55. */
  56. public function __construct(
  57. ClassMetadataFactory $metadataFactory,
  58. Client $client,
  59. QueryHelper $queryHelper,
  60. /**
  61. * The repository factory.
  62. */
  63. private RepositoryFactoryInterface $repositoryFactory,
  64. /**
  65. * The factory for the unit of work.
  66. */
  67. private UnitOfWorkFactoryInterface $unitOfWorkFactory
  68. ) {
  69. $this
  70. ->setClient($client)
  71. ->setMetadataFactory($metadataFactory)
  72. ->setQueryHelper($queryHelper)
  73. ->setLogger(new NullLogger());
  74. }
  76. /**
  77. * Clears the ObjectManager. All objects that are currently managed
  78. * by this ObjectManager become detached.
  79. *
  80. * @param string|null $objectName if given, only objects of this type will get detached.
  81. * @phpcsSuppress SlevomatCodingStandard.TypeHints.TypeHintDeclaration.MissingParameterTypeHint
  82. *
  83. * @return void
  84. */
  85. #[\Override]
  86. public function clear($objectName = null)
  87. {
  88. }
  90. /**
  91. * Checks if the $document is part of the current UnitOfWork and therefore managed.
  92. *
  93. * @param mixed $document
  94. *
  95. * @return bool
  96. */
  97. #[\Override]
  98. public function contains($document): bool
  99. {
  100. return $this->getUnitOfWork()->contains($document);
  101. }
  103. /**
  104. * Returns a request class for fetching/updating/deleting documents using the request map of the given class name.
  105. *
  106. * @throws InvalidArgumentException
  107. *
  108. * @param string $className
  109. * @param string $requestType
  110. * @param mixed $args The optional arguments.
  111. *
  112. * @return AbstractCreateRequest|AbstractUpdateRequest|AbstractDeleteRequest|AbstractApiRequest
  113. */
  114. #[\Override]
  115. public function createRequest(string $className, string $requestType = self::REQUEST_TYPE_QUERY, ...$args)
  116. {
  117. $requestType = $this->getRequestClass($className, $requestType);
  119. return (new ReflectionClass($requestType))->newInstanceArgs($args);
  120. }
  122. /**
  123. * Detaches an object from the ObjectManager, causing a managed object to
  124. * become detached. Unflushed changes made to the object if any
  125. * (including removal of the object), will not be synchronized to the database.
  126. * Objects which previously referenced the detached object will continue to
  127. * reference it.
  128. *
  129. * @param mixed $object The object to detach.
  130. *
  131. * @return void
  132. */
  133. #[\Override]
  134. public function detach($object)
  135. {
  136. $this->getUnitOfWork()->detach($object);
  137. }
  139. /**
  140. * Detaches the given object after flush.
  141. *
  142. * @param mixed $object
  143. *
  144. * @return void
  145. */
  146. #[\Override]
  147. public function detachDeferred($object)
  148. {
  149. $this->getUnitOfWork()->detachDeferred($object);
  150. }
  152. /**
  153. * Finds an object by its identifier.
  154. *
  155. * This is just a convenient shortcut for getRepository($className)->find($id).
  156. *
  157. * @param string $className The class name of the object to find.
  158. * @param mixed $id The identity of the object to find.
  159. *
  160. * @phpcsSuppress SlevomatCodingStandard.TypeHints.TypeHintDeclaration.MissingParameterTypeHint
  161. * @phpcsSuppress BestIt.TypeHints.ReturnTypeDeclaration.MissingReturnTypeHint
  162. *
  163. * @return mixed The found object.
  164. */
  165. #[\Override]
  166. public function find($className, $id)
  167. {
  168. return $this->repositoryFactory->getRepository($this, $className)->find($id);
  169. }
  171. /**
  172. * Flushes all changes to objects that have been queued up to now to the database.
  173. * This effectively synchronizes the in-memory state of managed objects with the
  174. * database.
  175. *
  176. * @return void
  177. */
  178. #[\Override]
  179. public function flush()
  180. {
  181. $this->getUnitOfWork()->flush();
  182. }
  184. /**
  185. * Returns the ClassMetadata descriptor for a class.
  186. *
  187. * The class name must be the fully-qualified class name without a leading backslash
  188. * (as it is returned by get_class($obj)).
  189. *
  190. * @param string $className
  191. * @phpcsSuppress SlevomatCodingStandard.TypeHints.TypeHintDeclaration.MissingParameterTypeHint
  192. * @todo Create a setter and lazy loading for this.
  193. *
  194. * @return ClassMetadata
  195. */
  196. #[\Override]
  197. public function getClassMetadata($className): ClassMetadata
  198. {
  199. return $this->getMetadataFactory()->getMetadataFor($className);
  200. }
  202. /**
  203. * Gets the repository for a class.
  204. *
  205. * @param string $className
  206. * @phpcsSuppress SlevomatCodingStandard.TypeHints.TypeHintDeclaration.MissingParameterTypeHint
  207. *
  208. * @return ObjectRepository
  209. */
  210. #[\Override]
  211. public function getRepository($className): ObjectRepository
  212. {
  213. return $this->repositoryFactory->getRepository($this, $className);
  214. }
  216. /**
  217. * Returns the full qualified class name for the given request type.
  218. *
  219. * @todo Remove out of this class!
  220. *
  221. * @param string $className The class name for which the request is fetched.
  222. * @param string $requestType The type of the request or the request class name it self.
  223. *
  224. * @return string
  225. */
  226. #[\Override]
  227. public function getRequestClass(string $className, string $requestType): string
  228. {
  229. if (!class_exists($requestType)) {
  230. $metadata = $this->getClassMetadata($className);
  232. if (!($metadata instanceof ClassMetadataInterface)) {
  233. throw new InvalidArgumentException('The given metadata class was of the wrong type.');
  234. }
  236. $map = $metadata->getRequestClassMap();
  238. if (!$map) {
  239. throw new InvalidArgumentException(sprintf(
  240. 'There is no request map for %s / %s.',
  241. $className,
  242. $requestType
  243. ));
  244. }
  246. $requestType = $map->{'get' . $requestType}();
  248. if (!class_exists($requestType)) {
  249. throw new DomainException(sprintf(
  250. 'The request type %s for class %s is not declared.',
  251. $requestType,
  252. $className
  253. ));
  254. }
  255. }
  257. return $requestType;
  258. }
  260. /**
  261. * Returns the unit of work for this manager.
  262. *
  263. * @return UnitOfWorkInterface
  264. */
  265. #[\Override]
  266. public function getUnitOfWork(): UnitOfWorkInterface
  267. {
  268. if (!$this->unitOfWork) {
  269. $this->setUnitOfWork($this->unitOfWorkFactory->getUnitOfWork($this));
  270. }
  272. return $this->unitOfWork;
  273. }
  275. /**
  276. * Helper method to initialize a lazy loading proxy or persistent collection.
  277. *
  278. * This method is a no-op for other objects.
  279. *
  280. * @param mixed $obj
  281. *
  282. * @return void
  283. */
  284. #[\Override]
  285. public function initializeObject($obj)
  286. {
  287. }
  289. /**
  290. * Merges the state of a detached object into the persistence context
  291. * of this ObjectManager and returns the managed copy of the object.
  292. * The object passed to merge will not become associated/managed with this ObjectManager.
  293. *
  294. * @param mixed $object
  295. * @phpcsSuppress BestIt.TypeHints.ReturnTypeDeclaration.MissingReturnTypeHint
  296. *
  297. * @return object
  298. */
  299. #[\Override]
  300. public function merge($object)
  301. {
  302. $this->getUnitOfWork()->registerAsManaged($object, $object->getId(), $object->getVersion());
  304. return $object;
  305. }
  307. /**
  308. * This method uses a callback to modify the given object to get conflict resolution in case of a 409 error.
  309. *
  310. * @param mixed $object
  311. * @param callable $change The callback is called with the given object.
  312. *
  313. * @return mixed Returns the changed object.
  314. */
  315. #[\Override]
  316. public function modify($object, callable $change)
  317. {
  318. return $this->getUnitOfWork()->modify($object, $change);
  319. }
  321. /**
  322. * Tells the ObjectManager to make an instance managed and persistent.
  323. *
  324. * The object will be entered into the database as a result of the flush operation.
  325. *
  326. * NOTE: The persist operation always considers objects that are not yet known to
  327. * this ObjectManager as NEW. Do not pass detached objects to the persist operation.
  328. *
  329. * @param mixed $object The instance to make managed and persistent.
  330. *
  331. * @return void
  332. */
  333. #[\Override]
  334. public function persist($object)
  335. {
  336. $this->getUnitOfWork()->scheduleSave($object);
  337. }
  339. /**
  340. * Refreshes the persistent state of an object from the database,
  341. * overriding any local changes that have not yet been persisted.
  342. *
  343. * @param mixed $object The object to refresh.
  344. * @param mixed $overwrite Commercetools returns a representation of the object for many update actions, so use
  345. * this responds directly.
  346. * @return void
  347. */
  348. #[\Override]
  349. public function refresh($object, $overwrite = null)
  350. {
  351. $this->getUnitOfWork()->refresh($object, $overwrite);
  352. }
  354. /**
  355. * Removes an object instance.
  356. *
  357. * A removed object will be removed from the database as a result of the flush operation.
  358. *
  359. * @param mixed $object The object instance to remove.
  360. *
  361. * @return void
  362. */
  363. #[\Override]
  364. public function remove($object)
  365. {
  366. $this->getUnitOfWork()->scheduleRemove($object);
  367. }
  369. /**
  370. * Sets the unit of work for this manager.
  371. *
  372. * @param UnitOfWorkInterface $unitOfWork
  373. *
  374. * @return DocumentManager
  375. */
  376. protected function setUnitOfWork(UnitOfWorkInterface $unitOfWork): DocumentManager
  377. {
  378. $this->unitOfWork = $unitOfWork;
  380. return $this;
  381. }
  382. }