Bitrix-D7  20.5.0
payment.php
См. документацию.
1 <?php
2 
3 namespace Bitrix\Sale;
4 
6 use Bitrix\Main;
8 use Bitrix\Sale;
10 
11 Loc::loadMessages(__FILE__);
12 
13 /**
14  * Class Payment
15  * @package Bitrix\Sale
16  */
18 {
19  const RETURN_NONE = 'N';
20  const RETURN_INNER = 'Y';
21  const RETURN_PS = 'P';
22 
23  /** @var Sale\PaySystem\Service */
24  protected $service;
25 
26  /**
27  * Payment constructor.
28  * @param array $fields
29  * @throws Main\ArgumentNullException
30  */
31  protected function __construct(array $fields = [])
32  {
33  $priceFields = ['SUM', 'PRICE_COD'];
34 
35  foreach ($priceFields as $code)
36  {
37  if (isset($fields[$code]))
38  {
40  }
41  }
42 
44  }
45 
46  /**
47  * @return string|void
48  */
49  public static function getRegistryEntity()
50  {
52  }
53 
54  /**
55  * @param array $values
56  * @return array
57  */
58  protected function onBeforeSetFields(array $values)
59  {
60  if (isset($values['PAID']))
61  {
62  if ($this->getField('PAID') === 'Y')
63  {
64  if ($values['PAID'] === 'N')
65  {
66  $values = ['PAID' => $values['PAID']] + $values;
67  }
68  }
69  else
70  {
71  if ($values['PAID'] === 'Y')
72  {
73  // move to the end of array
74  unset($values['PAID']);
75  $values['PAID'] = 'Y';
76  }
77  }
78  }
79 
80  return $values;
81  }
82 
83  /**
84  * @return array
85  */
86  public static function getAvailableFields()
87  {
88  return [
89  'PAID',
90  'DATE_PAID',
91  'EMP_PAID_ID',
92  'PAY_SYSTEM_ID',
93  'PS_STATUS',
94  'PS_STATUS_CODE',
95  'PS_STATUS_DESCRIPTION',
96  'PS_STATUS_MESSAGE',
97  'PS_SUM',
98  'PS_CURRENCY',
99  'PS_RESPONSE_DATE',
100  'PS_RECURRING_TOKEN',
101  'PAY_VOUCHER_NUM',
102  'PAY_VOUCHER_DATE',
103  'DATE_PAY_BEFORE',
104  'DATE_BILL',
105  'XML_ID',
106  'SUM',
107  'CURRENCY',
108  'PAY_SYSTEM_NAME',
109  'COMPANY_ID',
110  'PAY_RETURN_NUM',
111  'PRICE_COD',
112  'PAY_RETURN_DATE',
113  'EMP_RETURN_ID',
114  'PAY_RETURN_COMMENT',
115  'RESPONSIBLE_ID',
116  'EMP_RESPONSIBLE_ID',
117  'DATE_RESPONSIBLE_ID',
118  'IS_RETURN',
119  'COMMENTS',
120  'ACCOUNT_NUMBER',
121  'UPDATED_1C',
122  'ID_1C',
123  'VERSION_1C',
124  'EXTERNAL_PAYMENT',
125  'PS_INVOICE_ID',
126  'MARKED',
127  'REASON_MARKED',
128  'DATE_MARKED',
129  'EMP_MARKED_ID',
130  ];
131  }
132 
133  /**
134  * @return array
135  */
136  protected static function getMeaningfulFields()
137  {
138  return ['PAY_SYSTEM_ID'];
139  }
140 
141  /**
142  * @param array $fields
143  * @return Payment
144  * @throws Main\ArgumentException
145  */
146  private static function createPaymentObject(array $fields = [])
147  {
148  $registry = Registry::getInstance(static::getRegistryType());
149  $paymentClassName = $registry->getPaymentClassName();
150 
151  return new $paymentClassName($fields);
152  }
153 
154  /**
155  * @return string
156  */
157  public static function getRegistryType()
158  {
160  }
161 
162  /**
163  * @param PaymentCollection $collection
164  * @param PaySystem\Service|null $paySystem
165  * @return Payment
166  * @throws Main\ArgumentException
167  * @throws Main\ArgumentOutOfRangeException
168  * @throws Main\NotImplementedException
169  * @throws Main\ObjectException
170  */
171  public static function create(PaymentCollection $collection, Sale\PaySystem\Service $paySystem = null)
172  {
173  $fields = [
174  'DATE_BILL' => new Main\Type\DateTime(),
175  'PAID' => 'N',
176  'XML_ID' => static::generateXmlId(),
177  'IS_RETURN' => static::RETURN_NONE,
178  'CURRENCY' => $collection->getOrder()->getCurrency()
179  ];
180 
181  $payment = static::createPaymentObject();
182  $payment->setFieldsNoDemand($fields);
183  $payment->setCollection($collection);
184 
185  if ($paySystem !== null)
186  {
187  $payment->setPaySystemService($paySystem);
188  }
189 
190  return $payment;
191  }
192 
193  /**
194  * @param PaySystem\Service $service
195  * @throws Main\ArgumentOutOfRangeException
196  * @throws Main\NotImplementedException
197  */
198  public function setPaySystemService(Sale\PaySystem\Service $service)
199  {
200  $this->service = $service;
201  $result = $this->setField("PAY_SYSTEM_ID", $service->getField('ID'));
202  if ($result->isSuccess())
203  {
204  $this->setField("PAY_SYSTEM_NAME", $service->getField('NAME'));
205  }
206  }
207 
208  /**
209  * @return string
210  */
211  protected static function generateXmlId()
212  {
213  return uniqid('bx_');
214  }
215 
216  /**
217  * @param $id
218  * @return Payment[]
219  * @throws Main\ArgumentException
220  * @throws Main\ArgumentNullException
221  * @throws Main\ObjectPropertyException
222  * @throws Main\SystemException
223  */
224  public static function loadForOrder($id)
225  {
226  if (intval($id) <= 0)
227  {
228  throw new Main\ArgumentNullException("id");
229  }
230 
231  $payments = [];
232 
233  $paymentDataList = static::getList(['filter' => ['=ORDER_ID' => $id]]);
234  while ($paymentData = $paymentDataList->fetch())
235  {
236  $payments[] = static::createPaymentObject($paymentData);
237  }
238 
239  return $payments;
240  }
241 
242  /**
243  * @internal
244  *
245  * @param $idOrder
246  * @return Result
247  * @throws Main\ArgumentException
248  * @throws Main\ObjectPropertyException
249  * @throws Main\SystemException
250  */
251  public static function deleteNoDemand($idOrder)
252  {
253  $result = new Result();
254 
255  $dbRes = static::getList([
256  "select" => ["ID"],
257  "filter" => ["=ORDER_ID" => $idOrder]
258  ]);
259 
260  while ($payment = $dbRes->fetch())
261  {
262  $r = static::deleteInternal($payment['ID']);
263  if (!$r->isSuccess())
264  {
265  $result->addErrors($r->getErrors());
266  }
267  }
268 
269  return $result;
270  }
271 
272  /**
273  * @return Result
274  * @throws Main\ArgumentOutOfRangeException
275  * @throws Main\ObjectNotFoundException
276  */
277  public function delete()
278  {
279  $result = new Result();
280 
281  if ($this->isPaid())
282  {
283  $result->addError(new ResultError(Loc::getMessage('SALE_PAYMENT_DELETE_EXIST_PAID'), 'SALE_PAYMENT_DELETE_EXIST_PAID'));
284  return $result;
285  }
286 
287  $r = $this->callEventOnBeforeEntityDeleted();
288  if (!$r->isSuccess())
289  {
290  return $result->addErrors($r->getErrors());
291  }
292 
293  $r = parent::delete();
294  if (!$r->isSuccess())
295  {
296  $result->addErrors($r->getErrors());
297  }
298 
299  $r = $this->callEventOnEntityDeleted();
300  if (!$r->isSuccess())
301  {
302  $result->addErrors($r->getErrors());
303  }
304 
305  return $result;
306  }
307 
308  /**
309  * @return Result
310  */
311  private function callEventOnBeforeEntityDeleted()
312  {
313  $result = new Result();
314 
315  /** @var Main\Event $event */
316  $event = new Main\Event('sale', "OnBeforeSalePaymentEntityDeleted", [
317  'ENTITY' => $this,
318  'VALUES' => $this->fields->getOriginalValues(),
319  ]);
320  $event->send();
321 
322  if ($event->getResults())
323  {
324  /** @var Main\EventResult $eventResult */
325  foreach($event->getResults() as $eventResult)
326  {
327  if ($eventResult->getType() == Main\EventResult::ERROR)
328  {
329  $errorMsg = new ResultError(
330  Loc::getMessage('SALE_EVENT_ON_BEFORE_SALEPAYMENT_ENTITY_DELETED_ERROR'),
331  'SALE_EVENT_ON_BEFORE_SALEPAYMENT_ENTITY_DELETED_ERROR'
332  );
333  if ($eventResultData = $eventResult->getParameters())
334  {
335  if (isset($eventResultData) && $eventResultData instanceof ResultError)
336  {
337  /** @var ResultError $errorMsg */
338  $errorMsg = $eventResultData;
339  }
340  }
341 
342  $result->addError($errorMsg);
343  }
344  }
345  }
346 
347  return $result;
348  }
349 
350  /**
351  * @return Result
352  */
353  private function callEventOnEntityDeleted()
354  {
355  $result = new Result();
356 
357  /** @var Main\Event $event */
358  $event = new Main\Event('sale', "OnSalePaymentEntityDeleted", [
359  'ENTITY' => $this,
360  'VALUES' => $this->fields->getOriginalValues(),
361  ]);
362  $event->send();
363 
364  if ($event->getResults())
365  {
366  /** @var Main\EventResult $eventResult */
367  foreach($event->getResults() as $eventResult)
368  {
369  if($eventResult->getType() == Main\EventResult::ERROR)
370  {
371  $errorMsg = new ResultError(
372  Loc::getMessage('SALE_EVENT_ON_SALEPAYMENT_ENTITY_DELETED_ERROR'),
373  'SALE_EVENT_ON_SALEPAYMENT_ENTITY_DELETED_ERROR'
374  );
375  if ($eventResultData = $eventResult->getParameters())
376  {
377  if (isset($eventResultData) && $eventResultData instanceof ResultError)
378  {
379  /** @var ResultError $errorMsg */
380  $errorMsg = $eventResultData;
381  }
382  }
383 
384  $result->addError($errorMsg);
385  }
386  }
387  }
388 
389  return $result;
390  }
391 
392  /**
393  * @param string $name
394  * @param mixed $oldValue
395  * @param mixed $value
396  * @return Result
397  * @throws Main\ArgumentNullException
398  * @throws Main\ArgumentOutOfRangeException
399  * @throws Main\NotImplementedException
400  * @throws Main\ObjectException
401  * @throws Main\SystemException
402  */
403  protected function onFieldModify($name, $oldValue, $value)
404  {
405  global $USER;
406 
407  $result = new Result();
408 
409  if ($name === "PAID")
410  {
411  if ($value === "Y")
412  {
413  $this->setField('DATE_PAID', new Main\Type\DateTime());
414  $this->setField('EMP_PAID_ID', $USER->GetID());
415 
416  if ($this->getField('IS_RETURN') === self::RETURN_INNER)
417  {
418  $paySystemId = Sale\PaySystem\Manager::getInnerPaySystemId();
419  }
420  else
421  {
422  $paySystemId = $this->getPaymentSystemId();
423  }
424 
426  if ($service)
427  {
428  $operationResult = $service->creditNoDemand($this);
429  if (!$operationResult->isSuccess())
430  {
431  return $result->addErrors($operationResult->getErrors());
432  }
433  }
434 
435  $this->setField('IS_RETURN', static::RETURN_NONE);
436 
438  'p'.$this->getInternalIndex(),
440  [
441  'ENTITY' => $this,
442  'VALUES' => $this->fields->getOriginalValues(),
443  ]
444  );
445  }
446 
447  $this->addCashboxChecks();
448  }
449  elseif ($name === "IS_RETURN")
450  {
451  if ($value === static::RETURN_NONE)
452  {
453  return $result;
454  }
455 
456  if ($oldValue === static::RETURN_NONE)
457  {
458  $this->setField('EMP_RETURN_ID', $USER->GetID());
459  }
460 
461  /** @var PaymentCollection $collection */
462  $collection = $this->getCollection();
463 
464  $creditSum = 0;
465  $overPaid = $collection->getPaidSum() - $collection->getOrder()->getPrice();
466 
467  if ($overPaid <= 0)
468  {
469  $creditSum = $this->getSum();
470  $overPaid = 0;
471  }
472  elseif ($this->getSum() - $overPaid > 0)
473  {
474  $creditSum = $this->getSum() - $overPaid;
475  }
476 
477  if ($value == static::RETURN_PS)
478  {
479  $psId = $this->getPaymentSystemId();
480  }
481  else
482  {
483  $psId = Sale\PaySystem\Manager::getInnerPaySystemId();
484  }
485 
487 
488  if ($service && $service->isRefundable())
489  {
490  if ($creditSum)
491  {
492  if ($value == static::RETURN_PS)
493  {
494  if ($overPaid > 0)
495  {
497  if (PriceMaths::roundPrecision($overPaid) > PriceMaths::roundPrecision($userBudget))
498  {
499  return $result->addError(
500  new Entity\EntityError(
501  Loc::getMessage('SALE_ORDER_PAYMENT_RETURN_PAID'),
502  'SALE_ORDER_PAYMENT_RETURN_PAID'
503  )
504  );
505  }
506  }
507  }
508 
509  $refResult = $service->refund($this);
510  if (!$refResult->isSuccess())
511  {
512  return $result->addErrors($refResult->getErrors());
513  }
514  }
515  }
516  else
517  {
518  return $result->addError(
519  new Entity\EntityError(
520  Loc::getMessage('SALE_ORDER_PAYMENT_RETURN_NO_SUPPORTED'),
521  'SALE_ORDER_PAYMENT_RETURN_NO_SUPPORTED'
522  )
523  );
524  }
525 
526  $r = $this->setField('PAID', 'N');
527  if (!$r->isSuccess())
528  {
529  return $result->addErrors($r->getErrors());
530  }
531  }
532  elseif($name === "SUM")
533  {
534  if($this->isPaid())
535  {
536  $result = new Result();
537 
538  return $result->addError(
539  new ResultError(
540  Loc::getMessage('SALE_PAYMENT_NOT_ALLOWED_CHANGE_SUM'),
541  'SALE_PAYMENT_NOT_ALLOWED_CHANGE_SUM'
542  )
543  );
544  }
545  }
546  elseif ($name === "MARKED")
547  {
548  if ($oldValue !== "Y")
549  {
550  $this->setField('DATE_MARKED', new Main\Type\DateTime());
551  $this->setField('EMP_MARKED_ID', $USER->GetID());
552  }
553  elseif ($value === "N")
554  {
555  $r = $this->setField('REASON_MARKED', '');
556  if (!$r->isSuccess())
557  {
558  return $result->addErrors($r->getErrors());
559  }
560  }
561  }
562  elseif ($name === 'RESPONSIBLE_ID')
563  {
564  $this->setField('DATE_RESPONSIBLE_ID', new Main\Type\DateTime());
565  }
566 
567  return parent::onFieldModify($name, $oldValue, $value);
568  }
569 
570  /**
571  * @internal
572  *
573  * @return Result
574  * @throws Main\ArgumentNullException
575  * @throws Main\ArgumentOutOfRangeException
576  * @throws Main\ObjectNotFoundException
577  * @throws \Exception
578  */
579  public function save()
580  {
581  $this->checkCallingContext();
582 
583  $result = new Result();
584 
585  $id = $this->getId();
586  $isNew = (int)$id <= 0;
587 
588  $this->callEventOnBeforeEntitySaved();
589 
590  if (!$this->isChanged())
591  {
592  return $result;
593  }
594 
595  if ($id > 0)
596  {
597  $r = $this->update();
598  }
599  else
600  {
601  $r = $this->add();
602  if ($r->getId() > 0)
603  {
604  $id = $r->getId();
605  }
606  }
607 
608  if (!$r->isSuccess())
609  {
610  $result->addErrors($r->getErrors());
611  return $result;
612  }
613 
614  if ($id > 0)
615  {
616  $result->setId($id);
617  }
618 
619  if ($this->fields->isChanged('PAID'))
620  {
621  $this->calculateStatistic();
622  }
623 
624  $this->callEventOnEntitySaved();
625 
626  $this->callDelayedEvents();
627 
628  $this->onAfterSave($isNew);
629 
630  return $result;
631  }
632 
633  /**
634  * @return void
635  */
636  private function checkCallingContext()
637  {
638  $order = $this->getOrder();
639 
640  if (!$order->isSaveRunning())
641  {
642  trigger_error("Incorrect call to the save process. Use method save() on \Bitrix\Sale\Order entity", E_USER_WARNING);
643  }
644  }
645 
646  /**
647  * @return Order
648  */
649  public function getOrder()
650  {
651  return $this->getCollection()->getOrder();
652  }
653 
654  /**
655  * @return void;
656  */
657  protected function addCashboxChecks()
658  {
659  $service = $this->getPaySystem();
660  if ($service && $service->getField("CAN_PRINT_CHECK") === "Y")
661  {
662  Cashbox\Internals\Pool::addDoc($this->getOrder()->getInternalId(), $this);
663  }
664  }
665 
666  /**
667  * @return void;
668  */
669  protected function calculateStatistic()
670  {
671  /** @var Order $order */
672  $order = $this->getOrder();
673 
674  BuyerStatistic::calculate($order->getUserId(), $order->getCurrency(), $order->getSiteId());
675  }
676 
677  /**
678  * @return Result
679  * @throws Main\ArgumentOutOfRangeException
680  * @throws Main\ObjectNotFoundException
681  * @throws \Exception
682  */
683  private function add()
684  {
685  $result = new Result();
686 
687  $registry = Registry::getInstance(static::getRegistryType());
688  /** @var OrderHistory $orderHistory */
689  $orderHistory = $registry->getOrderHistoryClassName();
690 
691  $this->setFieldNoDemand('ORDER_ID', $this->getOrder()->getId());
692 
693  $r = $this->addInternal($this->getFields()->getValues());
694  if (!$r->isSuccess())
695  {
696  $orderHistory::addAction(
697  'PAYMENT',
698  $this->getOrderId(),
699  'PAYMENT_ADD_ERROR',
700  null,
701  $this,
702  ["ERROR" => $r->getErrorMessages()]
703  );
704 
705  $result->addErrors($r->getErrors());
706  return $result;
707  }
708 
709  $id = $r->getId();
710  $this->setFieldNoDemand('ID', $id);
711  $result->setId($id);
712 
713  $this->setAccountNumber($id);
714 
715  $orderHistory::addAction(
716  'PAYMENT',
717  $this->getOrderId(),
718  'PAYMENT_ADDED',
719  $id,
720  $this
721  );
722 
723  return $result;
724  }
725 
726  /**
727  * @return Result
728  * @throws Main\ArgumentException
729  * @throws Main\ArgumentNullException
730  * @throws Main\ArgumentOutOfRangeException
731  */
732  private function update()
733  {
734  $result = new Result();
735 
736  $r = static::updateInternal($this->getId(), $this->getFields()->getChangedValues());
737  if (!$r->isSuccess())
738  {
739  $registry = Registry::getInstance(static::getRegistryType());
740 
741  /** @var OrderHistory $orderHistory */
742  $orderHistory = $registry->getOrderHistoryClassName();
743 
744  $orderHistory::addAction(
745  'PAYMENT',
746  $this->getOrderId(),
747  'PAYMENT_UPDATE_ERROR',
748  $this->getId(),
749  $this,
750  ["ERROR" => $r->getErrorMessages()]
751  );
752 
753  $result->addErrors($r->getErrors());
754  }
755 
756  return $result;
757  }
758 
759  /**
760  * @return void;
761  */
762  private function callEventOnBeforeEntitySaved()
763  {
764  /** @var Main\Entity\Event $event */
765  $event = new Main\Event('sale', 'OnBeforeSalePaymentEntitySaved', [
766  'ENTITY' => $this,
767  'VALUES' => $this->fields->getOriginalValues()
768  ]);
769 
770  $event->send();
771  }
772 
773  /**
774  * @return void;
775  */
776  private function callEventOnEntitySaved()
777  {
778  /** @var Main\Event $event */
779  $event = new Main\Event('sale', 'OnSalePaymentEntitySaved', [
780  'ENTITY' => $this,
781  'VALUES' => $this->fields->getOriginalValues(),
782  ]);
783 
784  $event->send();
785  }
786 
787  /**
788  * @throws Main\ArgumentException
789  */
790  private function callDelayedEvents()
791  {
792  $eventList = Internals\EventsPool::getEvents('p'.$this->getInternalIndex());
793  if ($eventList)
794  {
795  foreach ($eventList as $eventName => $eventData)
796  {
797  $event = new Main\Event('sale', $eventName, $eventData);
798  $event->send();
799 
800  $registry = Registry::getInstance(static::getRegistryType());
801 
802  /** @var Notify $notifyClassName */
803  $notifyClassName = $registry->getNotifyClassName();
804  $notifyClassName::callNotify($this, $eventName);
805  }
806 
808  }
809  }
810 
811  /**
812  * @param $isNew
813  */
814  protected function onAfterSave($isNew)
815  {
816  return;
817  }
818 
819  /**
820  * @return float
821  */
822  public function getSum()
823  {
824  return floatval($this->getField('SUM'));
825  }
826 
827  /**
828  * @return float
829  */
830  public function getSumPaid()
831  {
832  return $this->getField('PS_SUM');
833  }
834 
835  /**
836  * @return bool
837  */
838  public function isPaid()
839  {
840  return $this->getField('PAID') === 'Y';
841  }
842 
843  /**
844  * @return bool
845  */
846  public function isReturn()
847  {
848  return
849  $this->getField('IS_RETURN') === static::RETURN_INNER
850  ||
851  $this->getField('IS_RETURN') === static::RETURN_PS
852  ;
853  }
854 
855  /**
856  * @return int
857  */
858  public function getOrderId()
859  {
860  return $this->getField('ORDER_ID');
861  }
862 
863  /**
864  * @return PaySystem\Service
865  */
866  public function getPaySystem()
867  {
868  if ($this->service === null)
869  {
870  $this->service = $this->loadPaySystem();
871  }
872 
873  return $this->service;
874  }
875 
876  /**
877  * @return PaySystem\Service
878  */
879  protected function loadPaySystem()
880  {
881  if ($paySystemId = $this->getPaymentSystemId())
882  {
883  return Sale\PaySystem\Manager::getObjectById($paySystemId);
884  }
885 
886  return null;
887  }
888 
889  /**
890  * @return int
891  */
892  public function getPaymentSystemId()
893  {
894  return (int)$this->getField('PAY_SYSTEM_ID');
895  }
896 
897  /**
898  * @return string
899  */
900  public function getPaymentSystemName()
901  {
902  return $this->getField('PAY_SYSTEM_NAME');
903  }
904 
905  /**
906  * @param $value
907  * @return Result
908  * @throws Main\ArgumentOutOfRangeException
909  * @throws Main\ObjectNotFoundException
910  * @throws \Exception
911  */
912  public function setPaid($value)
913  {
914  $result = new Result();
915 
916  /** @var Result $r */
917  $r = $this->setField('PAID', $value);
918  if (!$r->isSuccess())
919  {
920  $result->addErrors($r->getErrors());
921  }
922  elseif($r->hasWarnings())
923  {
924  $result->addWarnings($r->getWarnings());
925  }
926 
927  return $result;
928  }
929 
930  /**
931  * @param $value
932  * @return Result
933  * @throws Main\ArgumentOutOfRangeException
934  * @throws Main\ObjectNotFoundException
935  * @throws \Exception
936  */
937  public function setReturn($value)
938  {
939  $result = new Result();
940 
941  if ($value === static::RETURN_INNER || $value === static::RETURN_PS)
942  {
943  if ($this->isReturn())
944  {
945  return new Result();
946  }
947  }
948  elseif($value === static::RETURN_NONE)
949  {
950  if (!$this->isReturn())
951  {
952  return new Result();
953  }
954  }
955  else
956  {
957  throw new Main\ArgumentOutOfRangeException('value');
958  }
959 
960  /** @var Result $r */
961  $r = $this->setField('IS_RETURN', $value);
962  if (!$r->isSuccess())
963  {
964  $result->addErrors($r->getErrors());
965  }
966 
967  return $result;
968  }
969 
970  /**
971  * @return bool
972  */
973  public function isInner()
974  {
975  return (int)$this->getPaymentSystemId() === (int)Sale\PaySystem\Manager::getInnerPaySystemId();
976  }
977 
978  /**
979  * @param $name
980  * @param $value
981  * @return Result
982  * @throws Main\ArgumentOutOfRangeException
983  * @throws Main\NotImplementedException
984  * @throws \Exception
985  */
986  public function setField($name, $value)
987  {
988  $priceFields = [
989  'SUM' => 'SUM',
990  'PRICE_COD' => 'PRICE_COD',
991  ];
992  if (isset($priceFields[$name]))
993  {
994  $value = PriceMaths::roundPrecision($value);
995  }
996 
997  if ($name === 'REASON_MARKED' && mb_strlen($value) > 255)
998  {
999  $value = mb_substr($value, 0, 255);
1000  }
1001 
1002  return parent::setField($name, $value);
1003  }
1004 
1005  /**
1006  * @param $name
1007  * @param $value
1008  * @return Result
1009  * @throws Main\ArgumentException
1010  */
1011  protected function checkValueBeforeSet($name, $value)
1012  {
1013  $result = parent::checkValueBeforeSet($name, $value);
1014 
1015  if ($name == "PAY_SYSTEM_ID")
1016  {
1017  if (intval($value) > 0 && !Sale\PaySystem\Manager::isExist($value))
1018  {
1019  $result->addError(
1020  new ResultError(
1021  Loc::getMessage('SALE_PAYMENT_WRONG_PAYMENT_SERVICE'),
1022  'SALE_PAYMENT_WRONG_PAYMENT_SERVICE'
1023  )
1024  );
1025  }
1026  }
1027  elseif ($name === 'ACCOUNT_NUMBER')
1028  {
1029  $dbRes = static::getList([
1030  'select' => ['ID'],
1031  'filter' => ['=ACCOUNT_NUMBER' => $value]
1032  ]);
1033 
1034  if ($dbRes->fetch())
1035  {
1036  $result->addError(
1037  new ResultError(
1038  Loc::getMessage('SALE_PAYMENT_ACCOUNT_NUMBER_EXISTS')
1039  )
1040  );
1041  }
1042  }
1043 
1044  return $result;
1045  }
1046 
1047  /**
1048  * @internal
1049  *
1050  * @param $name
1051  * @param $value
1052  * @throws Main\ArgumentNullException
1053  * @throws Main\ArgumentOutOfRangeException
1054  */
1055  public function setFieldNoDemand($name, $value)
1056  {
1057  $priceFields = [
1058  'SUM' => 'SUM',
1059  'PRICE_COD' => 'PRICE_COD',
1060  ];
1061  if (isset($priceFields[$name]))
1062  {
1063  $value = PriceMaths::roundPrecision($value);
1064  }
1065 
1066  if ($name === 'REASON_MARKED'
1067  && mb_strlen($value) > 255)
1068  {
1069  $value = mb_substr($value, 0, 255);
1070  }
1071 
1072  parent::setFieldNoDemand($name, $value);
1073  }
1074 
1075  /**
1076  * @param string $name
1077  * @param null $oldValue
1078  * @param null $value
1079  */
1080  protected function addChangesToHistory($name, $oldValue = null, $value = null)
1081  {
1082  if ($this->getId() > 0)
1083  {
1084  $order = $this->getOrder();
1085 
1086  if ($order && $order->getId() > 0)
1087  {
1089  'PAYMENT',
1090  $order->getId(),
1091  $name,
1092  $oldValue,
1093  $value,
1094  $this->getId(),
1095  $this
1096  );
1097  }
1098  }
1099  }
1100 
1101  /**
1102  * @return Result
1103  */
1104  public function verify()
1105  {
1106  $result = new Result();
1107  if ($this->getPaymentSystemId() <= 0)
1108  {
1109  $result->addError(new ResultError(Loc::getMessage("SALE_PAYMENT_PAYMENT_SERVICE_EMPTY"), 'SALE_PAYMENT_PAYMENT_SERVICE_EMPTY'));
1110  }
1111  return $result;
1112  }
1113 
1114  /**
1115  * @param $id
1116  *
1117  * @return Result
1118  * @throws Main\ObjectNotFoundException
1119  * @throws \Exception
1120  */
1121  public function setAccountNumber($id)
1122  {
1123  $result = new Sale\Result();
1124 
1126 
1127  try
1128  {
1129  $r = static::updateInternal($id, ["ACCOUNT_NUMBER" => $value]);
1130  $res = $r->isSuccess(true);
1131  }
1132  catch (\Exception $exception)
1133  {
1134  $res = false;
1135  }
1136 
1137  if ($res)
1138  {
1139  $this->setFieldNoDemand('ACCOUNT_NUMBER', $value);
1140  }
1141 
1142  return $result;
1143  }
1144 
1145  /**
1146  * @param $mapping
1147  * @return Payment|null|string
1148  */
1149  public function getBusinessValueProviderInstance($mapping)
1150  {
1151  $providerInstance = null;
1152 
1153  if (is_array($mapping))
1154  {
1155  switch ($mapping['PROVIDER_KEY'])
1156  {
1157  case 'PAYMENT':
1158  $providerInstance = $this;
1159  break;
1160  case 'COMPANY':
1161  $providerInstance = $this->getField('COMPANY_ID');
1162  break;
1163  default:
1164  $order = $this->getOrder();
1165  if ($order)
1166  {
1167  $providerInstance = $order->getBusinessValueProviderInstance($mapping);
1168  }
1169  }
1170  }
1171 
1172  return $providerInstance;
1173  }
1174 
1175  /**
1176  * @return int|null
1177  */
1178  public function getPersonTypeId()
1179  {
1180  $order = $this->getOrder();
1181  if ($order)
1182  {
1183  return $order->getPersonTypeId();
1184  }
1185 
1186  return null;
1187  }
1188 
1189  /**
1190  * @param array $parameters
1191  * @return Main\ORM\Query\Result
1192  * @throws Main\ArgumentException
1193  * @throws Main\ObjectPropertyException
1194  * @throws Main\SystemException
1195  */
1196  public static function getList(array $parameters = [])
1197  {
1198  return Internals\PaymentTable::getList($parameters);
1199  }
1200 
1201  /**
1202  * @internal
1203  *
1204  * @param \SplObjectStorage $cloneEntity
1205  * @return Internals\CollectableEntity|object
1206  */
1207  public function createClone(\SplObjectStorage $cloneEntity)
1208  {
1209  if ($this->isClone() && $cloneEntity->contains($this))
1210  {
1211  return $cloneEntity[$this];
1212  }
1213 
1214  /** @var Payment $paymentClone */
1215  $paymentClone = parent::createClone($cloneEntity);
1216 
1217  /** @var Sale\PaySystem\Service $paySystem */
1218  if ($paySystem = $this->getPaySystem())
1219  {
1220  if (!$cloneEntity->contains($paySystem))
1221  {
1222  $cloneEntity[$paySystem] = $paySystem->createClone($cloneEntity);
1223  }
1224 
1225  if ($cloneEntity->contains($paySystem))
1226  {
1227  $paymentClone->service = $cloneEntity[$paySystem];
1228  }
1229  }
1230 
1231  return $paymentClone;
1232  }
1233 
1234  /**
1235  * @return string
1236  * @throws Main\ArgumentNullException
1237  */
1238  public function getHash()
1239  {
1240  $order = $this->getOrder();
1241 
1242  return md5(
1243  $this->getId().
1245  $order->getId()
1246  );
1247  }
1248 
1249  /**
1250  * @deprecated
1251  *
1252  * @return bool
1253  * @throws Main\ArgumentException
1254  * @throws Main\ArgumentNullException
1255  * @throws Main\ArgumentOutOfRangeException
1256  * @throws Main\NotImplementedException
1257  */
1258  public function isAllowPay()
1259  {
1260  /** @var \Bitrix\Sale\Order $order */
1261  $order = $this->getOrder();
1262 
1263  return $order->isAllowPay();
1264  }
1265 
1266  /**
1267  * @return bool
1268  */
1269  public function isMarked()
1270  {
1271  return $this->getField('MARKED') == "Y";
1272  }
1273 
1274  /**
1275  * @param $value
1276  *
1277  * @return string
1278  */
1279  public function getErrorEntity($value)
1280  {
1281  static $className = null;
1282  $errorsList = static::getAutoFixErrorsList();
1283  if (is_array($errorsList) && in_array($value, $errorsList))
1284  {
1285  if ($className === null)
1286  $className = static::getClassName();
1287  }
1288 
1289  return $className;
1290  }
1291 
1292  /**
1293  * @param $value
1294  *
1295  * @return bool
1296  */
1297  public function canAutoFixError($value)
1298  {
1299  $autoFix = false;
1300  $errorsList = static::getAutoFixErrorsList();
1301  if (is_array($errorsList) && in_array($value, $errorsList))
1302  {
1303  $autoFix = true;
1304  }
1305  return $autoFix;
1306  }
1307 
1308  /**
1309  * @return array
1310  */
1311  public function getAutoFixErrorsList()
1312  {
1313  return [];
1314  }
1315 
1316  /**
1317  * @param $code
1318  *
1319  * @return Result
1320  */
1321  public function tryFixError($code)
1322  {
1323  return new Result();
1324  }
1325 
1326  /**
1327  * @return bool
1328  */
1329  public function canMarked()
1330  {
1331  return true;
1332  }
1333 
1334  /**
1335  * @return string
1336  */
1337  public function getMarkField()
1338  {
1339  return 'MARKED';
1340  }
1341 
1342  /**
1343  * @param array $data
1344  * @return Main\ORM\Data\AddResult
1345  * @throws \Exception
1346  *
1347  */
1348  protected function addInternal(array $data)
1349  {
1350  return Internals\PaymentTable::add($data);
1351  }
1352 
1353  /**
1354  * @param $primary
1355  * @param array $data
1356  * @return Main\ORM\Data\UpdateResult
1357  * @throws \Exception
1358  */
1359  protected function updateInternal($primary, array $data)
1360  {
1361  return Internals\PaymentTable::update($primary, $data);
1362  }
1363 
1364  /**
1365  * @param $primary
1366  * @return Main\ORM\Data\DeleteResult
1367  * @throws \Exception
1368  */
1369  protected static function deleteInternal($primary)
1370  {
1372  }
1373 
1374  /**
1375  * @return array
1376  */
1377  protected static function getFieldsMap()
1378  {
1380  }
1381 
1382  /**
1383  * @return null
1384  */
1385  public static function getUfId()
1386  {
1388  }
1389 
1390  /**
1391  * @return null|string
1392  * @internal
1393  *
1394  */
1395  public static function getEntityEventName()
1396  {
1397  return 'SalePayment';
1398  }
1399 
1400 }
Exception is thrown when "empty" value is passed to a function that does not accept it as a valid arg...
Exception is thrown when the value of an argument is outside the allowable range of values.
static loadMessages($file)
Loads language messages for specified file in a lazy way.
Definition: loc.php:67
static getMessage($code, $replace=null, $language=null)
Returns translation by message code.
Definition: loc.php:29
static calculate($userId, $currency, $lid)
Fill statistic for user for certain site and currency.
static resetEvents(Order $order=null)
Definition: eventspool.php:32
static addEvent(Order $order, $type, $event)
Definition: eventspool.php:24
static getEvents(Order $order)
Definition: eventspool.php:9
static generateForPayment(CollectableEntity $item)
static getUserBudgetByOrder(Sale\Order $order)
static addField($entityName, $orderId, $field, $oldValue=null, $value=null, $id=null, $entity=null, array $fields=array())
onAfterSave($isNew)
Definition: payment.php:814
onFieldModify($name, $oldValue, $value)
Definition: payment.php:403
static getRegistryEntity()
Definition: payment.php:49
updateInternal($primary, array $data)
Definition: payment.php:1359
createClone(\SplObjectStorage $cloneEntity)
Definition: payment.php:1207
checkValueBeforeSet($name, $value)
Definition: payment.php:1011
getBusinessValueProviderInstance($mapping)
Definition: payment.php:1149
static getMeaningfulFields()
Definition: payment.php:136
static create(PaymentCollection $collection, Sale\PaySystem\Service $paySystem=null)
Definition: payment.php:171
__construct(array $fields=[])
Payment constructor.
Definition: payment.php:31
static getFieldsMap()
Definition: payment.php:1377
static loadForOrder($id)
Definition: payment.php:224
static getEntityEventName()
Definition: payment.php:1395
static getAvailableFields()
Definition: payment.php:86
onBeforeSetFields(array $values)
Definition: payment.php:58
static deleteNoDemand($idOrder)
Definition: payment.php:251
addInternal(array $data)
Definition: payment.php:1348
canAutoFixError($value)
Definition: payment.php:1297
addChangesToHistory($name, $oldValue=null, $value=null)
Definition: payment.php:1080
setFieldNoDemand($name, $value)
Definition: payment.php:1055
static generateXmlId()
Definition: payment.php:211
static deleteInternal($primary)
Definition: payment.php:1369
setField($name, $value)
Definition: payment.php:986
getErrorEntity($value)
Definition: payment.php:1279
static getRegistryType()
Definition: payment.php:157
setPaySystemService(Sale\PaySystem\Service $service)
Definition: payment.php:198
static getList(array $parameters=[])
Definition: payment.php:1196
static roundPrecision($value)
Definition: pricemaths.php:17
__construct(Base $connector)
Constructor.
Definition: resultview.php:40
Class RestHandler \Handlers\PaySystem.