1 <?php
2 /* --------------------------------------------------------------
3 OrderItemRepository.inc.php 2015-12-22
4 Gambio GmbH
5 http://www.gambio.de
6 Copyright (c) 2015 Gambio GmbH
7 Released under the GNU General Public License (Version 2)
8 [http://www.gnu.org/licenses/gpl-2.0.html]
9 --------------------------------------------------------------
10 */
11
12 MainFactory::load_class('OrderItemRepositoryInterface');
13
14 /**
15 * Class OrderItemRepository
16 *
17 * @category System
18 * @package Order
19 * @subpackage Repositories
20 */
21 class OrderItemRepository implements OrderItemRepositoryInterface
22 {
23 /**
24 * Order item attribute repository factory.
25 * @var OrderItemAttributeRepositoryFactoryInterface
26 */
27 protected $orderItemAttributeRepositoryFactory;
28
29 /**
30 * Order item repository reader.
31 * @var OrderItemRepositoryReaderInterface
32 */
33 protected $orderItemRepositoryReader;
34
35 /**
36 * Order item repository writer.
37 * @var OrderItemRepositoryWriterInterface
38 */
39 protected $orderItemRepositoryWriter;
40
41 /**
42 * Order item repository deleter.
43 * @var OrderItemRepositoryDeleterInterface
44 */
45 protected $orderItemRepositoryDeleter;
46
47 /**
48 * Addon value service.
49 * @var AddonValueServiceInterface
50 */
51 protected $addonValueService;
52
53
54 /**
55 * OrderItemRepository constructor.
56 *
57 * @param OrderItemAttributeRepositoryFactoryInterface $orderItemAttributeRepositoryFactory Factory to create
58 * order item attribute
59 * repositories.
60 * @param OrderItemRepositoryReaderInterface $orderItemRepositoryReader Db reader for order
61 * item repository.
62 * @param OrderItemRepositoryWriterInterface $orderItemRepositoryWriter Db writer for order
63 * item repository.
64 * @param OrderItemRepositoryDeleterInterface $orderItemRepositoryDeleter Db deleter for order
65 * item repository.
66 * @param AddonValueServiceInterface $addonValueService Addon value service.
67 */
68 public function __construct(OrderItemAttributeRepositoryFactoryInterface $orderItemAttributeRepositoryFactory,
69 OrderItemRepositoryReaderInterface $orderItemRepositoryReader,
70 OrderItemRepositoryWriterInterface $orderItemRepositoryWriter,
71 OrderItemRepositoryDeleterInterface $orderItemRepositoryDeleter,
72 AddonValueServiceInterface $addonValueService)
73 {
74 $this->orderItemAttributeRepositoryFactory = $orderItemAttributeRepositoryFactory;
75 $this->orderItemRepositoryReader = $orderItemRepositoryReader;
76 $this->orderItemRepositoryWriter = $orderItemRepositoryWriter;
77 $this->orderItemRepositoryDeleter = $orderItemRepositoryDeleter;
78 $this->addonValueService = $addonValueService;
79 }
80
81
82 /**
83 * Adds an order item to the order item repository.
84 *
85 * @param IdType $orderId Order ID.
86 * @param OrderItemInterface $orderItem Order item to add.
87 *
88 * @return int ID of the StoredOrderItem
89 */
90 public function addToOrder(IdType $orderId, OrderItemInterface $orderItem)
91 {
92 $storedOrderItemId = $this->orderItemRepositoryWriter->insertIntoOrder($orderId, $orderItem);
93
94 /** @var AddonValueContainerInterface $storedOrderItem */
95 $storedOrderItem = $this->getItemById(new IdType($storedOrderItemId));
96 $storedOrderItem->addAddonValues($orderItem->getAddonValues());
97 $this->addonValueService->storeAddonValues($storedOrderItem);
98
99 $this->_delegateToAttributeRepositories($orderItem, $storedOrderItemId);
100
101 return $storedOrderItemId;
102 }
103
104
105 /**
106 * Saves the order item in the repository.
107 *
108 * @param StoredOrderItemInterface $storedOrderItem Order item to save.
109 *
110 * @return OrderItemRepository Same instance for method chaining.
111 */
112 public function store(StoredOrderItemInterface $storedOrderItem)
113 {
114 $this->orderItemRepositoryWriter->update($storedOrderItem);
115 $this->addonValueService->storeAddonValues($storedOrderItem);
116
117 return $this->_delegateToAttributeRepositories($storedOrderItem);
118 }
119
120
121 /**
122 * Returns a stored order ID by the given order item ID.
123 *
124 * @param IdType $orderItemId ID of the stored order item.
125 *
126 * @return StoredOrderItemInterface Stored order item.
127 */
128 public function getItemById(IdType $orderItemId)
129 {
130 /** @var StoredOrderItemInterface|AddonValueContainerInterface $storedOrderItem */
131 $storedOrderItem = $this->orderItemRepositoryReader->getItemById($orderItemId);
132 $repositoryArray = $this->orderItemAttributeRepositoryFactory->createRepositoryArray();
133
134 /** @var StoredOrderItemAttributeCollection $attributeCollection */
135 $attributeCollection = null;
136 foreach($repositoryArray as $repository)
137 {
138 if(null === $attributeCollection)
139 {
140 $attributeCollection = $repository->getItemAttributesByOrderItemId(new IdType($storedOrderItem->getOrderItemId()));
141 }
142 else
143 {
144 $newCollection = $repository->getItemAttributesByOrderItemId(new IdType($storedOrderItem->getOrderItemId()));
145 $attributeCollection->addCollection($newCollection);
146 }
147 }
148
149 $storedOrderItem->setAttributes($attributeCollection);
150 $this->addonValueService->loadAddonValues($storedOrderItem);
151
152 return $storedOrderItem;
153 }
154
155
156 /**
157 * Returns a stored order item collection by the given order ID.
158 *
159 * @param IdType $orderId ID of the order.
160 *
161 * @return StoredOrderItemCollection Stored order item collection.
162 */
163 public function getItemsByOrderId(IdType $orderId)
164 {
165 $orderItemCollection = $this->orderItemRepositoryReader->getItemsByOrderId($orderId);
166 $attributeRepositoryArray = $this->orderItemAttributeRepositoryFactory->createRepositoryArray();
167
168 /** @var StoredOrderItemInterface|AddonValueContainerInterface $orderItem */
169 foreach($orderItemCollection->getArray() as $orderItem)
170 {
171 $orderItemId = $orderItem->getOrderItemId();
172
173 /** @var StoredOrderItemAttributeCollection $attributeCollection */
174 $attributeCollection = null;
175 foreach($attributeRepositoryArray as $attributeRepository)
176 {
177 if(null === $attributeCollection)
178 {
179 $attributeCollection = $attributeRepository->getItemAttributesByOrderItemId(new IdType($orderItemId));
180 }
181 else
182 {
183 $newCollection = $attributeRepository->getItemAttributesByOrderItemId(new IdType($orderItemId));
184 $attributeCollection->addCollection($newCollection);
185 }
186 }
187
188 $orderItem->setAttributes($attributeCollection);
189 $this->addonValueService->loadAddonValues($orderItem);
190 }
191
192 return $orderItemCollection;
193 }
194
195
196 /**
197 * Deletes an order item from the repository by the given order item ID.
198 *
199 * @param IdType $orderItemId Order item ID.
200 *
201 * @return OrderItemRepository Same instance for method chaining.
202 */
203 public function deleteItemById(IdType $orderItemId)
204 {
205 $repositoryArray = $this->orderItemAttributeRepositoryFactory->createRepositoryArray();
206
207 foreach($repositoryArray as $repository)
208 {
209 $repository->deleteItemAttributesByOrderItemId($orderItemId);
210 }
211
212 /** @var AddonValueContainerInterface $orderItem */
213 $orderItem = $this->orderItemRepositoryReader->getItemById($orderItemId);
214 $this->addonValueService->deleteAddonValues($orderItem);
215
216 $this->orderItemRepositoryDeleter->deleteItemById($orderItemId);
217
218 return $this;
219 }
220
221
222 /**
223 * Deletes order items from the repository by the given order ID.
224 *
225 * @param IdType $orderId Order ID.
226 *
227 * @return OrderItemRepository Same instance for method chaining.
228 */
229 public function deleteItemsByOrderId(IdType $orderId)
230 {
231 $orderItemCollection = $this->orderItemRepositoryReader->getItemsByOrderId($orderId);
232
233 /** @var StoredOrderItemInterface $orderItem */
234 foreach($orderItemCollection->getArray() as $orderItem)
235 {
236 $this->deleteItemById(new IdType($orderItem->getOrderItemId()));
237 }
238
239 return $this;
240 }
241
242
243 /**
244 * Delegate to the attribute repository and save the attributes of the passed order item.
245 *
246 * @param OrderItemInterface $orderItem Order item which contain the attributes.
247 * @param int|null $storedOrderItemId (Optional) Id of order item. When not set, its get by stored order
248 * item.
249 *
250 * @return $this Same instance to make chained method calls possible.
251 */
252 protected function _delegateToAttributeRepositories(OrderItemInterface $orderItem, $storedOrderItemId = null)
253 {
254 if(null === $storedOrderItemId && $orderItem instanceof StoredOrderItemInterface)
255 {
256 $storedOrderItemId = $orderItem->getOrderItemId();
257 }
258 $collection = $orderItem->getAttributes();
259 $attributeArray = $collection->getArray();
260
261 foreach($attributeArray as $attribute)
262 {
263 $repository = $this->orderItemAttributeRepositoryFactory->createRepositoryByAttributeObject($attribute);
264
265 if($attribute instanceof StoredOrderItemAttributeInterface)
266 {
267 $repository->store($attribute);
268 }
269 else
270 {
271 $repository->addToOrderItem(new IdType($storedOrderItemId), $attribute);
272 }
273 }
274
275 return $this;
276 }
277
278 }