src/applications/phortune/storage/PhortuneCart.php

   1 <?php
   2
   3 final class PhortuneCart extends PhortuneDAO
   4   implements
   5     PhabricatorApplicationTransactionInterface,
   6     PhabricatorPolicyInterface,
   7     PhabricatorExtendedPolicyInterface {
   8
   9   const STATUS_BUILDING = 'cart:building';
  10   const STATUS_READY = 'cart:ready';
  11   const STATUS_PURCHASING = 'cart:purchasing';
  12   const STATUS_CHARGED = 'cart:charged';
  13   const STATUS_HOLD = 'cart:hold';
  14   const STATUS_REVIEW = 'cart:review';
  15   const STATUS_PURCHASED = 'cart:purchased';
  16
  17   protected $accountPHID;
  18   protected $authorPHID;
  19   protected $merchantPHID;
  20   protected $subscriptionPHID;
  21   protected $cartClass;
  22   protected $status;
  23   protected $metadata = array();
  24   protected $mailKey;
  25   protected $isInvoice;
  26
  27   private $account = self::ATTACHABLE;
  28   private $purchases = self::ATTACHABLE;
  29   private $implementation = self::ATTACHABLE;
  30   private $merchant = self::ATTACHABLE;
  31
  32   public static function initializeNewCart(
  33     PhabricatorUser $actor,
  34     PhortuneAccount $account,
  35     PhortuneMerchant $merchant) {
  36     $cart = id(new PhortuneCart())
  37       ->setAuthorPHID($actor->getPHID())
  38       ->setStatus(self::STATUS_BUILDING)
  39       ->setAccountPHID($account->getPHID())
  40       ->setIsInvoice(0)
  41       ->attachAccount($account)
  42       ->setMerchantPHID($merchant->getPHID())
  43       ->attachMerchant($merchant);
  44
  45     $cart->account = $account;
  46     $cart->purchases = array();
  47
  48     return $cart;
  49   }
  50
  51   public function newPurchase(
  52     PhabricatorUser $actor,
  53     PhortuneProduct $product) {
  54
  55     $purchase = PhortunePurchase::initializeNewPurchase($actor, $product)
  56       ->setAccountPHID($this->getAccount()->getPHID())
  57       ->setCartPHID($this->getPHID())
  58       ->save();
  59
  60     $this->purchases[] = $purchase;
  61
  62     return $purchase;
  63   }
  64
  65   public static function getStatusNameMap() {
  66     return array(
  67       self::STATUS_BUILDING => pht('Building'),
  68       self::STATUS_READY => pht('Ready'),
  69       self::STATUS_PURCHASING => pht('Purchasing'),
  70       self::STATUS_CHARGED => pht('Charged'),
  71       self::STATUS_HOLD => pht('Hold'),
  72       self::STATUS_REVIEW => pht('Review'),
  73       self::STATUS_PURCHASED => pht('Purchased'),
  74     );
  75   }
  76
  77   public static function getNameForStatus($status) {
  78     return idx(self::getStatusNameMap(), $status, $status);
  79   }
  80
  81   public function activateCart() {
  82     $this->openTransaction();
  83       $this->beginReadLocking();
  84
  85         $copy = clone $this;
  86         $copy->reload();
  87
  88         if ($copy->getStatus() !== self::STATUS_BUILDING) {
  89           throw new Exception(
  90             pht(
  91               'Cart has wrong status ("%s") to call %s.',
  92               $copy->getStatus(),
  93               'willApplyCharge()'));
  94         }
  95
  96         $this->setStatus(self::STATUS_READY)->save();
  97
  98       $this->endReadLocking();
  99     $this->saveTransaction();
 100
 101     $this->recordCartTransaction(PhortuneCartTransaction::TYPE_CREATED);
 102
 103     return $this;
 104   }
 105
 106   public function willApplyCharge(
 107     PhabricatorUser $actor,
 108     PhortunePaymentProvider $provider,
 109     PhortunePaymentMethod $method = null) {
 110
 111     $account = $this->getAccount();
 112
 113     $charge = PhortuneCharge::initializeNewCharge()
 114       ->setAccountPHID($account->getPHID())
 115       ->setCartPHID($this->getPHID())
 116       ->setAuthorPHID($actor->getPHID())
 117       ->setMerchantPHID($this->getMerchant()->getPHID())
 118       ->setProviderPHID($provider->getProviderConfig()->getPHID())
 119       ->setAmountAsCurrency($this->getTotalPriceAsCurrency());
 120
 121     if ($method) {
 122       if (!$method->isActive()) {
 123         throw new Exception(
 124           pht(
 125             'Attempting to apply a charge using an inactive '.
 126             'payment method ("%s")!',
 127             $method->getPHID()));
 128       }
 129       $charge->setPaymentMethodPHID($method->getPHID());
 130     }
 131
 132     $this->openTransaction();
 133       $this->beginReadLocking();
 134
 135         $copy = clone $this;
 136         $copy->reload();
 137
 138         if ($copy->getStatus() !== self::STATUS_READY) {
 139           throw new Exception(
 140             pht(
 141               'Cart has wrong status ("%s") to call %s, expected "%s".',
 142               $copy->getStatus(),
 143               'willApplyCharge()',
 144               self::STATUS_READY));
 145         }
 146
 147         $charge->save();
 148         $this->setStatus(self::STATUS_PURCHASING)->save();
 149
 150       $this->endReadLocking();
 151     $this->saveTransaction();
 152
 153     return $charge;
 154   }
 155
 156   public function didHoldCharge(PhortuneCharge $charge) {
 157     $charge->setStatus(PhortuneCharge::STATUS_HOLD);
 158
 159     $this->openTransaction();
 160       $this->beginReadLocking();
 161
 162         $copy = clone $this;
 163         $copy->reload();
 164
 165         if ($copy->getStatus() !== self::STATUS_PURCHASING) {
 166           throw new Exception(
 167             pht(
 168               'Cart has wrong status ("%s") to call %s, expected "%s".',
 169               $copy->getStatus(),
 170               'didHoldCharge()',
 171               self::STATUS_PURCHASING));
 172         }
 173
 174         $charge->save();
 175         $this->setStatus(self::STATUS_HOLD)->save();
 176
 177       $this->endReadLocking();
 178     $this->saveTransaction();
 179
 180     $this->recordCartTransaction(PhortuneCartTransaction::TYPE_HOLD);
 181   }
 182
 183   public function didApplyCharge(PhortuneCharge $charge) {
 184     $charge->setStatus(PhortuneCharge::STATUS_CHARGED);
 185
 186     $this->openTransaction();
 187       $this->beginReadLocking();
 188
 189         $copy = clone $this;
 190         $copy->reload();
 191
 192         if (($copy->getStatus() !== self::STATUS_PURCHASING) &&
 193             ($copy->getStatus() !== self::STATUS_HOLD)) {
 194           throw new Exception(
 195             pht(
 196               'Cart has wrong status ("%s") to call %s.',
 197               $copy->getStatus(),
 198               'didApplyCharge()'));
 199         }
 200
 201         $charge->save();
 202         $this->setStatus(self::STATUS_CHARGED)->save();
 203
 204       $this->endReadLocking();
 205     $this->saveTransaction();
 206
 207     // TODO: Perform purchase review. Here, we would apply rules to determine
 208     // whether the charge needs manual review (maybe making the decision via
 209     // Herald, configuration, or by examining provider fraud data). For now,
 210     // don't require review.
 211     $needs_review = false;
 212
 213     if ($needs_review) {
 214       $this->willReviewCart();
 215     } else {
 216       $this->didReviewCart();
 217     }
 218
 219     return $this;
 220   }
 221
 222   public function willReviewCart() {
 223     $this->openTransaction();
 224       $this->beginReadLocking();
 225
 226         $copy = clone $this;
 227         $copy->reload();
 228
 229         if (($copy->getStatus() !== self::STATUS_CHARGED)) {
 230           throw new Exception(
 231             pht(
 232               'Cart has wrong status ("%s") to call %s!',
 233               $copy->getStatus(),
 234               'willReviewCart()'));
 235         }
 236
 237         $this->setStatus(self::STATUS_REVIEW)->save();
 238
 239       $this->endReadLocking();
 240     $this->saveTransaction();
 241
 242     $this->recordCartTransaction(PhortuneCartTransaction::TYPE_REVIEW);
 243
 244     return $this;
 245   }
 246
 247   public function didReviewCart() {
 248     $this->openTransaction();
 249       $this->beginReadLocking();
 250
 251         $copy = clone $this;
 252         $copy->reload();
 253
 254         if (($copy->getStatus() !== self::STATUS_CHARGED) &&
 255             ($copy->getStatus() !== self::STATUS_REVIEW)) {
 256           throw new Exception(
 257             pht(
 258               'Cart has wrong status ("%s") to call %s!',
 259               $copy->getStatus(),
 260               'didReviewCart()'));
 261         }
 262
 263         foreach ($this->purchases as $purchase) {
 264           $purchase->getProduct()->didPurchaseProduct($purchase);
 265         }
 266
 267         $this->setStatus(self::STATUS_PURCHASED)->save();
 268
 269       $this->endReadLocking();
 270     $this->saveTransaction();
 271
 272     $this->recordCartTransaction(PhortuneCartTransaction::TYPE_PURCHASED);
 273
 274     return $this;
 275   }
 276
 277   public function didFailCharge(PhortuneCharge $charge) {
 278     $charge->setStatus(PhortuneCharge::STATUS_FAILED);
 279
 280     $this->openTransaction();
 281       $this->beginReadLocking();
 282
 283         $copy = clone $this;
 284         $copy->reload();
 285
 286         if (($copy->getStatus() !== self::STATUS_PURCHASING) &&
 287             ($copy->getStatus() !== self::STATUS_HOLD)) {
 288           throw new Exception(
 289             pht(
 290               'Cart has wrong status ("%s") to call %s.',
 291               $copy->getStatus(),
 292               'didFailCharge()'));
 293         }
 294
 295         $charge->save();
 296
 297         // Move the cart back into STATUS_READY so the user can try
 298         // making the purchase again.
 299         $this->setStatus(self::STATUS_READY)->save();
 300
 301       $this->endReadLocking();
 302     $this->saveTransaction();
 303
 304     return $this;
 305   }
 306
 307
 308   public function willRefundCharge(
 309     PhabricatorUser $actor,
 310     PhortunePaymentProvider $provider,
 311     PhortuneCharge $charge,
 312     PhortuneCurrency $amount) {
 313
 314     if (!$amount->isPositive()) {
 315       throw new Exception(
 316         pht('Trying to refund non-positive amount of money!'));
 317     }
 318
 319     if ($amount->isGreaterThan($charge->getAmountRefundableAsCurrency())) {
 320       throw new Exception(
 321         pht('Trying to refund more money than remaining on charge!'));
 322     }
 323
 324     if ($charge->getRefundedChargePHID()) {
 325       throw new Exception(
 326         pht('Trying to refund a refund!'));
 327     }
 328
 329     if (($charge->getStatus() !== PhortuneCharge::STATUS_CHARGED) &&
 330         ($charge->getStatus() !== PhortuneCharge::STATUS_HOLD)) {
 331       throw new Exception(
 332         pht('Trying to refund an uncharged charge!'));
 333     }
 334
 335     $refund_charge = PhortuneCharge::initializeNewCharge()
 336       ->setAccountPHID($this->getAccount()->getPHID())
 337       ->setCartPHID($this->getPHID())
 338       ->setAuthorPHID($actor->getPHID())
 339       ->setMerchantPHID($this->getMerchant()->getPHID())
 340       ->setProviderPHID($provider->getProviderConfig()->getPHID())
 341       ->setPaymentMethodPHID($charge->getPaymentMethodPHID())
 342       ->setRefundedChargePHID($charge->getPHID())
 343       ->setAmountAsCurrency($amount->negate());
 344
 345     $charge->openTransaction();
 346       $charge->beginReadLocking();
 347
 348         $copy = clone $charge;
 349         $copy->reload();
 350
 351         if ($copy->getRefundingPHID() !== null) {
 352           throw new Exception(
 353             pht('Trying to refund a charge which is already refunding!'));
 354         }
 355
 356         $refund_charge->save();
 357         $charge->setRefundingPHID($refund_charge->getPHID());
 358         $charge->save();
 359
 360       $charge->endReadLocking();
 361     $charge->saveTransaction();
 362
 363     return $refund_charge;
 364   }
 365
 366   public function didRefundCharge(
 367     PhortuneCharge $charge,
 368     PhortuneCharge $refund) {
 369
 370     $refund->setStatus(PhortuneCharge::STATUS_CHARGED);
 371
 372     $this->openTransaction();
 373       $this->beginReadLocking();
 374
 375         $copy = clone $charge;
 376         $copy->reload();
 377
 378         if ($charge->getRefundingPHID() !== $refund->getPHID()) {
 379           throw new Exception(
 380             pht('Charge is in the wrong refunding state!'));
 381         }
 382
 383         $charge->setRefundingPHID(null);
 384
 385         // NOTE: There's some trickiness here to get the signs right. Both
 386         // these values are positive but the refund has a negative value.
 387         $total_refunded = $charge
 388           ->getAmountRefundedAsCurrency()
 389           ->add($refund->getAmountAsCurrency()->negate());
 390
 391         $charge->setAmountRefundedAsCurrency($total_refunded);
 392         $charge->save();
 393         $refund->save();
 394
 395       $this->endReadLocking();
 396     $this->saveTransaction();
 397
 398     $amount = $refund->getAmountAsCurrency()->negate();
 399     foreach ($this->purchases as $purchase) {
 400       $purchase->getProduct()->didRefundProduct($purchase, $amount);
 401     }
 402
 403     return $this;
 404   }
 405
 406   public function didFailRefund(
 407     PhortuneCharge $charge,
 408     PhortuneCharge $refund) {
 409
 410     $refund->setStatus(PhortuneCharge::STATUS_FAILED);
 411
 412     $this->openTransaction();
 413       $this->beginReadLocking();
 414
 415         $copy = clone $charge;
 416         $copy->reload();
 417
 418         if ($charge->getRefundingPHID() !== $refund->getPHID()) {
 419           throw new Exception(
 420             pht('Charge is in the wrong refunding state!'));
 421         }
 422
 423         $charge->setRefundingPHID(null);
 424         $charge->save();
 425         $refund->save();
 426
 427       $this->endReadLocking();
 428     $this->saveTransaction();
 429   }
 430
 431   private function recordCartTransaction($type) {
 432     $omnipotent_user = PhabricatorUser::getOmnipotentUser();
 433     $phortune_phid = id(new PhabricatorPhortuneApplication())->getPHID();
 434
 435     $xactions = array();
 436
 437     $xactions[] = id(new PhortuneCartTransaction())
 438       ->setTransactionType($type)
 439       ->setNewValue(true);
 440
 441     $content_source = PhabricatorContentSource::newForSource(
 442       PhabricatorPhortuneContentSource::SOURCECONST);
 443
 444     $editor = id(new PhortuneCartEditor())
 445       ->setActor($omnipotent_user)
 446       ->setActingAsPHID($phortune_phid)
 447       ->setContentSource($content_source)
 448       ->setContinueOnMissingFields(true)
 449       ->setContinueOnNoEffect(true);
 450
 451     $editor->applyTransactions($this, $xactions);
 452   }
 453
 454   public function getName() {
 455     return $this->getImplementation()->getName($this);
 456   }
 457
 458   public function getDoneURI() {
 459     return $this->getImplementation()->getDoneURI($this);
 460   }
 461
 462   public function getDoneActionName() {
 463     return $this->getImplementation()->getDoneActionName($this);
 464   }
 465
 466   public function getCancelURI() {
 467     return $this->getImplementation()->getCancelURI($this);
 468   }
 469
 470   public function getDescription() {
 471     return $this->getImplementation()->getDescription($this);
 472   }
 473
 474   public function getDetailURI() {
 475     return urisprintf(
 476       '/phortune/cart/%d/',
 477       $this->getID());
 478   }
 479
 480   public function getCheckoutURI() {
 481     return '/phortune/cart/'.$this->getID().'/checkout/';
 482   }
 483
 484   public function canCancelOrder() {
 485     try {
 486       $this->assertCanCancelOrder();
 487       return true;
 488     } catch (Exception $ex) {
 489       return false;
 490     }
 491   }
 492
 493   public function canRefundOrder() {
 494     try {
 495       $this->assertCanRefundOrder();
 496       return true;
 497     } catch (Exception $ex) {
 498       return false;
 499     }
 500   }
 501
 502   public function canVoidOrder() {
 503     try {
 504       $this->assertCanVoidOrder();
 505       return true;
 506     } catch (Exception $ex) {
 507       return false;
 508     }
 509   }
 510
 511   public function assertCanCancelOrder() {
 512     switch ($this->getStatus()) {
 513       case self::STATUS_BUILDING:
 514         throw new Exception(
 515           pht(
 516             'This order can not be cancelled because the application has not '.
 517             'finished building it yet.'));
 518       case self::STATUS_READY:
 519         throw new Exception(
 520           pht(
 521             'This order can not be cancelled because it has not been placed.'));
 522     }
 523
 524     return $this->getImplementation()->assertCanCancelOrder($this);
 525   }
 526
 527   public function assertCanRefundOrder() {
 528     switch ($this->getStatus()) {
 529       case self::STATUS_BUILDING:
 530         throw new Exception(
 531           pht(
 532             'This order can not be refunded because the application has not '.
 533             'finished building it yet.'));
 534       case self::STATUS_READY:
 535         throw new Exception(
 536           pht(
 537             'This order can not be refunded because it has not been placed.'));
 538     }
 539
 540     return $this->getImplementation()->assertCanRefundOrder($this);
 541   }
 542
 543   public function assertCanVoidOrder() {
 544     if (!$this->getIsInvoice()) {
 545       throw new Exception(
 546         pht(
 547           'This order can not be voided because it is not an invoice.'));
 548     }
 549
 550     switch ($this->getStatus()) {
 551       case self::STATUS_READY:
 552         break;
 553       default:
 554         throw new Exception(
 555           pht(
 556             'This order can not be voided because it is not ready for '.
 557             'payment.'));
 558     }
 559
 560     return null;
 561   }
 562
 563
 564   protected function getConfiguration() {
 565     return array(
 566       self::CONFIG_AUX_PHID => true,
 567       self::CONFIG_SERIALIZATION => array(
 568         'metadata' => self::SERIALIZATION_JSON,
 569       ),
 570       self::CONFIG_COLUMN_SCHEMA => array(
 571         'status' => 'text32',
 572         'cartClass' => 'text128',
 573         'mailKey' => 'bytes20',
 574         'subscriptionPHID' => 'phid?',
 575         'isInvoice' => 'bool',
 576       ),
 577       self::CONFIG_KEY_SCHEMA => array(
 578         'key_account' => array(
 579           'columns' => array('accountPHID'),
 580         ),
 581         'key_merchant' => array(
 582           'columns' => array('merchantPHID'),
 583         ),
 584         'key_subscription' => array(
 585           'columns' => array('subscriptionPHID'),
 586         ),
 587       ),
 588     ) + parent::getConfiguration();
 589   }
 590
 591   public function generatePHID() {
 592     return PhabricatorPHID::generateNewPHID(
 593       PhortuneCartPHIDType::TYPECONST);
 594   }
 595
 596   public function save() {
 597     if (!$this->getMailKey()) {
 598       $this->setMailKey(Filesystem::readRandomCharacters(20));
 599     }
 600     return parent::save();
 601   }
 602
 603   public function attachPurchases(array $purchases) {
 604     assert_instances_of($purchases, 'PhortunePurchase');
 605     $this->purchases = $purchases;
 606     return $this;
 607   }
 608
 609   public function getPurchases() {
 610     return $this->assertAttached($this->purchases);
 611   }
 612
 613   public function attachAccount(PhortuneAccount $account) {
 614     $this->account = $account;
 615     return $this;
 616   }
 617
 618   public function getAccount() {
 619     return $this->assertAttached($this->account);
 620   }
 621
 622   public function attachMerchant(PhortuneMerchant $merchant) {
 623     $this->merchant = $merchant;
 624     return $this;
 625   }
 626
 627   public function getMerchant() {
 628     return $this->assertAttached($this->merchant);
 629   }
 630
 631   public function attachImplementation(
 632     PhortuneCartImplementation $implementation) {
 633     $this->implementation = $implementation;
 634     return $this;
 635   }
 636
 637   public function getImplementation() {
 638     return $this->assertAttached($this->implementation);
 639   }
 640
 641   public function getTotalPriceAsCurrency() {
 642     $prices = array();
 643     foreach ($this->getPurchases() as $purchase) {
 644       $prices[] = $purchase->getTotalPriceAsCurrency();
 645     }
 646
 647     return PhortuneCurrency::newFromList($prices);
 648   }
 649
 650   public function setMetadataValue($key, $value) {
 651     $this->metadata[$key] = $value;
 652     return $this;
 653   }
 654
 655   public function getMetadataValue($key, $default = null) {
 656     return idx($this->metadata, $key, $default);
 657   }
 658
 659   public function getObjectName() {
 660     return pht('Order %d', $this->getID());
 661   }
 662
 663
 664 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 665
 666
 667   public function getApplicationTransactionEditor() {
 668     return new PhortuneCartEditor();
 669   }
 670
 671   public function getApplicationTransactionTemplate() {
 672     return new PhortuneCartTransaction();
 673   }
 674
 675
 676 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 677
 678
 679   public function getCapabilities() {
 680     return array(
 681       PhabricatorPolicyCapability::CAN_VIEW,
 682       PhabricatorPolicyCapability::CAN_EDIT,
 683     );
 684   }
 685
 686   public function getPolicy($capability) {
 687     return PhabricatorPolicies::getMostOpenPolicy();
 688   }
 689
 690   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
 691     if ($capability === PhabricatorPolicyCapability::CAN_VIEW) {
 692       $any_edit = PhortuneMerchantQuery::canViewersEditMerchants(
 693         array($viewer->getPHID()),
 694         array($this->getMerchantPHID()));
 695       if ($any_edit) {
 696         return true;
 697       }
 698     }
 699
 700     return false;
 701   }
 702
 703
 704 /* -(  PhabricatorExtendedPolicyInterface  )--------------------------------- */
 705
 706
 707   public function getExtendedPolicy($capability, PhabricatorUser $viewer) {
 708     if ($this->hasAutomaticCapability($capability, $viewer)) {
 709       return array();
 710     }
 711
 712     return array(
 713       array(
 714         $this->getAccount(),
 715         PhabricatorPolicyCapability::CAN_EDIT,
 716       ),
 717     );
 718   }
 719
 720 }