1 <?php
  2 
  3 namespace RetailCrm;
  4 
  5 use RetailCrm\Http\Client;
  6 use RetailCrm\Response\ApiResponse;
  7 
  8 /**
  9  *  retailCRM API client class
 10  */
 11 class ApiClient
 12 {
 13     const VERSION = 'v3';
 14 
 15     protected $client;
 16 
 17     /**
 18      * Client creating
 19      *
 20      * @param  string $url
 21      * @param  string $apiKey
 22      * @return mixed
 23      */
 24     public function __construct($url, $apiKey)
 25     {
 26         if ('/' != substr($url, strlen($url) - 1, 1)) {
 27             $url .= '/';
 28         }
 29 
 30         $url = $url . 'api/' . self::VERSION;
 31 
 32         $this->client = new Client($url, array('apiKey' => $apiKey));
 33     }
 34 
 35     /**
 36      * Create a order
 37      *
 38      * @param  array       $order
 39      * @return ApiResponse
 40      */
 41     public function ordersCreate(array $order)
 42     {
 43         if (!sizeof($order)) {
 44             throw new \InvalidArgumentException('Parameter `order` must contains a data');
 45         }
 46 
 47         return $this->client->makeRequest("/orders/create", Client::METHOD_POST, array(
 48             'order' => json_encode($order)
 49         ));
 50     }
 51 
 52     /**
 53      * Edit a order
 54      *
 55      * @param  array       $order
 56      * @return ApiResponse
 57      */
 58     public function ordersEdit(array $order, $by = 'externalId')
 59     {
 60         if (!sizeof($order)) {
 61             throw new \InvalidArgumentException('Parameter `order` must contains a data');
 62         }
 63 
 64         $this->checkIdParameter($by);
 65 
 66         if (!isset($order[$by])) {
 67             throw new \InvalidArgumentException(sprintf('Order array must contain the "%s" parameter.', $by));
 68         }
 69 
 70         return $this->client->makeRequest("/orders/" . $order[$by] . "/edit", Client::METHOD_POST, array(
 71             'order' => json_encode($order),
 72             'by' => $by,
 73         ));
 74     }
 75 
 76     /**
 77      * Upload array of the orders
 78      *
 79      * @param  array       $orders
 80      * @return ApiResponse
 81      */
 82     public function ordersUpload(array $orders)
 83     {
 84         if (!sizeof($orders)) {
 85             throw new \InvalidArgumentException('Parameter `orders` must contains array of the orders');
 86         }
 87 
 88         return $this->client->makeRequest("/orders/upload", Client::METHOD_POST, array(
 89             'orders' => json_encode($orders),
 90         ));
 91     }
 92 
 93     /**
 94      * Get order by id or externalId
 95      *
 96      * @param  string      $id
 97      * @param  string      $by (default: 'externalId')
 98      * @return ApiResponse
 99      */
100     public function ordersGet($id, $by = 'externalId')
101     {
102         $this->checkIdParameter($by);
103 
104         return $this->client->makeRequest("/orders/$id", Client::METHOD_GET, array('by' => $by));
105     }
106 
107     /**
108      * Returns a orders history
109      *
110      * @param  \DateTime   $startDate (default: null)
111      * @param  \DateTime   $endDate (default: null)
112      * @param  int         $limit (default: 100)
113      * @param  int         $offset (default: 0)
114      * @param  bool        $skipMyChanges (default: true)
115      * @return ApiResponse
116      */
117     public function ordersHistory(
118         \DateTime $startDate = null,
119         \DateTime $endDate = null,
120         $limit = 100,
121         $offset = 0,
122         $skipMyChanges = true
123     ) {
124         $parameters = array();
125 
126         if ($startDate) {
127             $parameters['startDate'] = $startDate->format('Y-m-d H:i:s');
128         }
129         if ($endDate) {
130             $parameters['endDate'] = $endDate->format('Y-m-d H:i:s');
131         }
132         if ($limit) {
133             $parameters['limit'] = (int) $limit;
134         }
135         if ($offset) {
136             $parameters['offset'] = (int) $offset;
137         }
138         if ($skipMyChanges) {
139             $parameters['skipMyChanges'] = (bool) $skipMyChanges;
140         }
141 
142         return $this->client->makeRequest('/orders/history', Client::METHOD_GET, $parameters);
143     }
144 
145     /**
146      * Returns filtered orders list
147      *
148      * @param  array       $filter (default: array())
149      * @param  int         $page (default: null)
150      * @param  int         $limit (default: null)
151      * @return ApiResponse
152      */
153     public function ordersList(array $filter = array(), $page = null, $limit = null)
154     {
155         $parameters = array();
156 
157         if (sizeof($filter)) {
158             $parameters['filter'] = $filter;
159         }
160         if (null !== $page) {
161             $parameters['page'] = (int) $page;
162         }
163         if (null !== $limit) {
164             $parameters['limit'] = (int) $limit;
165         }
166 
167         return $this->client->makeRequest('/orders', Client::METHOD_GET, $parameters);
168     }
169 
170     /**
171      * Save order IDs' (id and externalId) association in the CRM
172      *
173      * @param  array       $ids
174      * @return ApiResponse
175      */
176     public function ordersFixExternalIds(array $ids)
177     {
178         if (!sizeof($ids)) {
179             throw new \InvalidArgumentException('Method parameter must contains at least one IDs pair');
180         }
181 
182         return $this->client->makeRequest("/orders/fix-external-ids", Client::METHOD_POST, array(
183             'orders' => json_encode($ids),
184         ));
185     }
186 
187     /**
188      * Create a customer
189      *
190      * @param  array       $customer
191      * @return ApiResponse
192      */
193     public function customersCreate(array $customer)
194     {
195         if (!sizeof($customer)) {
196             throw new \InvalidArgumentException('Parameter `customer` must contains a data');
197         }
198 
199         return $this->client->makeRequest("/customers/create", Client::METHOD_POST, array(
200             'customer' => json_encode($customer)
201         ));
202     }
203 
204     /**
205      * Edit a customer
206      *
207      * @param  array       $customer
208      * @return ApiResponse
209      */
210     public function customersEdit(array $customer, $by = 'externalId')
211     {
212         if (!sizeof($customer)) {
213             throw new \InvalidArgumentException('Parameter `customer` must contains a data');
214         }
215 
216         $this->checkIdParameter($by);
217 
218         if (!isset($customer[$by])) {
219             throw new \InvalidArgumentException(sprintf('Customer array must contain the "%s" parameter.', $by));
220         }
221 
222         return $this->client->makeRequest("/customers/" . $customer[$by] . "/edit", Client::METHOD_POST, array(
223             'customer' => json_encode($customer),
224             'by' => $by,
225         ));
226     }
227 
228     /**
229      * Upload array of the customers
230      *
231      * @param  array       $customers
232      * @return ApiResponse
233      */
234     public function customersUpload(array $customers)
235     {
236         if (!sizeof($customers)) {
237             throw new \InvalidArgumentException('Parameter `customers` must contains array of the customers');
238         }
239 
240         return $this->client->makeRequest("/customers/upload", Client::METHOD_POST, array(
241             'customers' => json_encode($customers),
242         ));
243     }
244 
245     /**
246      * Get customer by id or externalId
247      *
248      * @param  string      $id
249      * @param  string      $by (default: 'externalId')
250      * @return ApiResponse
251      */
252     public function customersGet($id, $by = 'externalId')
253     {
254         $this->checkIdParameter($by);
255 
256         return $this->client->makeRequest("/customers/$id", Client::METHOD_GET, array('by' => $by));
257     }
258 
259     /**
260      * Returns filtered customers list
261      *
262      * @param  array       $filter (default: array())
263      * @param  int         $page (default: null)
264      * @param  int         $limit (default: null)
265      * @return ApiResponse
266      */
267     public function customersList(array $filter = array(), $page = null, $limit = null)
268     {
269         $parameters = array();
270 
271         if (sizeof($filter)) {
272             $parameters['filter'] = $filter;
273         }
274         if (null !== $page) {
275             $parameters['page'] = (int) $page;
276         }
277         if (null !== $limit) {
278             $parameters['limit'] = (int) $limit;
279         }
280 
281         return $this->client->makeRequest('/customers', Client::METHOD_GET, $parameters);
282     }
283 
284     /**
285      * Save customer IDs' (id and externalId) association in the CRM
286      *
287      * @param  array       $ids
288      * @return ApiResponse
289      */
290     public function customersFixExternalIds(array $ids)
291     {
292         if (!sizeof($ids)) {
293             throw new \InvalidArgumentException('Method parameter must contains at least one IDs pair');
294         }
295 
296         return $this->client->makeRequest("/customers/fix-external-ids", Client::METHOD_POST, array(
297             'customers' => json_encode($ids),
298         ));
299     }
300 
301     /**
302      * Returns deliveryServices list
303      *
304      * @return ApiResponse
305      */
306     public function deliveryServicesList()
307     {
308         return $this->client->makeRequest('/reference/delivery-services', Client::METHOD_GET);
309     }
310 
311     /**
312      * Returns deliveryTypes list
313      *
314      * @return ApiResponse
315      */
316     public function deliveryTypesList()
317     {
318         return $this->client->makeRequest('/reference/delivery-types', Client::METHOD_GET);
319     }
320 
321     /**
322      * Returns orderMethods list
323      *
324      * @return ApiResponse
325      */
326     public function orderMethodsList()
327     {
328         return $this->client->makeRequest('/reference/order-methods', Client::METHOD_GET);
329     }
330 
331     /**
332      * Returns orderTypes list
333      *
334      * @return ApiResponse
335      */
336     public function orderTypesList()
337     {
338         return $this->client->makeRequest('/reference/order-types', Client::METHOD_GET);
339     }
340 
341     /**
342      * Returns paymentStatuses list
343      *
344      * @return ApiResponse
345      */
346     public function paymentStatusesList()
347     {
348         return $this->client->makeRequest('/reference/payment-statuses', Client::METHOD_GET);
349     }
350 
351     /**
352      * Returns paymentTypes list
353      *
354      * @return ApiResponse
355      */
356     public function paymentTypesList()
357     {
358         return $this->client->makeRequest('/reference/payment-types', Client::METHOD_GET);
359     }
360 
361     /**
362      * Returns productStatuses list
363      *
364      * @return ApiResponse
365      */
366     public function productStatusesList()
367     {
368         return $this->client->makeRequest('/reference/product-statuses', Client::METHOD_GET);
369     }
370 
371     /**
372      * Returns statusGroups list
373      *
374      * @return ApiResponse
375      */
376     public function statusGroupsList()
377     {
378         return $this->client->makeRequest('/reference/status-groups', Client::METHOD_GET);
379     }
380 
381     /**
382      * Returns statuses list
383      *
384      * @return ApiResponse
385      */
386     public function statusesList()
387     {
388         return $this->client->makeRequest('/reference/statuses', Client::METHOD_GET);
389     }
390 
391     /**
392      * Edit deliveryService
393      *
394      * @param array $data delivery service data
395      * @return ApiResponse
396      */
397     public function deliveryServicesEdit(array $data)
398     {
399         if (!isset($data['code'])) {
400             throw new \InvalidArgumentException('Data must contain "code" parameter.');
401         }
402 
403         return $this->client->makeRequest(
404             '/reference/delivery-services/' . $data['code'] . '/edit',
405             Client::METHOD_POST,
406             array(
407                 'deliveryService' => json_encode($data)
408             )
409         );
410     }
411 
412     /**
413      * Edit deliveryType
414      *
415      * @param array $data delivery type data
416      * @return ApiResponse
417      */
418     public function deliveryTypesEdit(array $data)
419     {
420         if (!isset($data['code'])) {
421             throw new \InvalidArgumentException('Data must contain "code" parameter.');
422         }
423 
424         return $this->client->makeRequest(
425             '/reference/delivery-types/' . $data['code'] . '/edit',
426             Client::METHOD_POST,
427             array(
428                 'deliveryType' => json_encode($data)
429             )
430         );
431     }
432 
433     /**
434      * Edit orderMethod
435      *
436      * @param array $data order method data
437      * @return ApiResponse
438      */
439     public function orderMethodsEdit(array $data)
440     {
441         if (!isset($data['code'])) {
442             throw new \InvalidArgumentException('Data must contain "code" parameter.');
443         }
444 
445         return $this->client->makeRequest(
446             '/reference/order-methods/' . $data['code'] . '/edit',
447             Client::METHOD_POST,
448             array(
449                 'orderMethod' => json_encode($data)
450             )
451         );
452     }
453 
454     /**
455      * Edit orderType
456      *
457      * @param array $data order type data
458      * @return ApiResponse
459      */
460     public function orderTypesEdit(array $data)
461     {
462         if (!isset($data['code'])) {
463             throw new \InvalidArgumentException('Data must contain "code" parameter.');
464         }
465 
466         return $this->client->makeRequest(
467             '/reference/order-types/' . $data['code'] . '/edit',
468             Client::METHOD_POST,
469             array(
470                 'orderType' => json_encode($data)
471             )
472         );
473     }
474 
475     /**
476      * Edit paymentStatus
477      *
478      * @param array $data payment status data
479      * @return ApiResponse
480      */
481     public function paymentStatusesEdit(array $data)
482     {
483         if (!isset($data['code'])) {
484             throw new \InvalidArgumentException('Data must contain "code" parameter.');
485         }
486 
487         return $this->client->makeRequest(
488             '/reference/payment-statuses/' . $data['code'] . '/edit',
489             Client::METHOD_POST,
490             array(
491                 'paymentStatus' => json_encode($data)
492             )
493         );
494     }
495 
496     /**
497      * Edit paymentType
498      *
499      * @param array $data payment type data
500      * @return ApiResponse
501      */
502     public function paymentTypesEdit(array $data)
503     {
504         if (!isset($data['code'])) {
505             throw new \InvalidArgumentException('Data must contain "code" parameter.');
506         }
507 
508         return $this->client->makeRequest(
509             '/reference/payment-types/' . $data['code'] . '/edit',
510             Client::METHOD_POST,
511             array(
512                 'paymentType' => json_encode($data)
513             )
514         );
515     }
516 
517     /**
518      * Edit productStatus
519      *
520      * @param array $data product status data
521      * @return ApiResponse
522      */
523     public function productStatusesEdit(array $data)
524     {
525         if (!isset($data['code'])) {
526             throw new \InvalidArgumentException('Data must contain "code" parameter.');
527         }
528 
529         return $this->client->makeRequest(
530             '/reference/product-statuses/' . $data['code'] . '/edit',
531             Client::METHOD_POST,
532             array(
533                 'productStatus' => json_encode($data)
534             )
535         );
536     }
537 
538     /**
539      * Edit order status
540      *
541      * @param array $data status data
542      * @return ApiResponse
543      */
544     public function statusesEdit(array $data)
545     {
546         if (!isset($data['code'])) {
547             throw new \InvalidArgumentException('Data must contain "code" parameter.');
548         }
549 
550         return $this->client->makeRequest(
551             '/reference/statuses/' . $data['code'] . '/edit',
552             Client::METHOD_POST,
553             array(
554                 'status' => json_encode($data)
555             )
556         );
557     }
558 
559     /**
560      * Update CRM basic statistic
561      *
562      * @return ApiResponse
563      */
564     public function statisticUpdate()
565     {
566         return $this->client->makeRequest('/statistic/update', Client::METHOD_GET);
567     }
568 
569     /**
570      * Check ID parameter
571      *
572      * @param  string $by
573      * @return bool
574      */
575     protected function checkIdParameter($by)
576     {
577         $allowedForBy = array('externalId', 'id');
578         if (!in_array($by, $allowedForBy)) {
579             throw new \InvalidArgumentException(sprintf(
580                 'Value "%s" for parameter "by" is not valid. Allowed values are %s.',
581                 $by,
582                 implode(', ', $allowedForBy)
583             ));
584         }
585 
586         return true;
587     }
588 }

retailCRM PHP API client API documentation generated by ApiGen