src/applications/phortune/worker/PhortuneSubscriptionWorker.php

   1 <?php
   2
   3 final class PhortuneSubscriptionWorker extends PhabricatorWorker {
   4
   5   protected function doWork() {
   6     $subscription = $this->loadSubscription();
   7
   8     $range = $this->getBillingPeriodRange($subscription);
   9     list($last_epoch, $next_epoch) = $range;
  10
  11     $should_invoice = $subscription->shouldInvoiceForBillingPeriod(
  12       $last_epoch,
  13       $next_epoch);
  14     if (!$should_invoice) {
  15       return;
  16     }
  17
  18     $currency = $subscription->getCostForBillingPeriodAsCurrency(
  19       $last_epoch,
  20       $next_epoch);
  21     if (!$currency->isPositive()) {
  22       return;
  23     }
  24
  25
  26     $account = $subscription->getAccount();
  27     $merchant = $subscription->getMerchant();
  28
  29     $viewer = PhabricatorUser::getOmnipotentUser();
  30
  31     $product = id(new PhortuneProductQuery())
  32       ->setViewer($viewer)
  33       ->withClassAndRef('PhortuneSubscriptionProduct', $subscription->getPHID())
  34       ->executeOne();
  35
  36     $cart_implementation = id(new PhortuneSubscriptionCart())
  37       ->setSubscription($subscription);
  38
  39     // TODO: This isn't really ideal. It would be better to use an application
  40     // actor than a fairly arbitrary account member.
  41
  42     // However, for now, some of the stuff later in the pipeline requires a
  43     // valid actor with a real PHID. The subscription should eventually be
  44     // able to create these invoices "as" the application it is acting on
  45     // behalf of.
  46
  47     $members = id(new PhabricatorPeopleQuery())
  48       ->setViewer($viewer)
  49       ->withPHIDs($account->getMemberPHIDs())
  50       ->execute();
  51     $actor = null;
  52
  53     $any_disabled = false;
  54     foreach ($members as $member) {
  55
  56       // Don't act as a disabled user. If all of the users on the account are
  57       // disabled this means we won't charge the subscription, but that's
  58       // probably correct since it means no one can cancel or pay it anyway.
  59       if ($member->getIsDisabled()) {
  60         $any_disabled = true;
  61         continue;
  62       }
  63
  64       // For now, just pick the first valid user we encounter as the actor.
  65       $actor = $member;
  66       break;
  67     }
  68
  69     if (!$actor) {
  70       if ($any_disabled) {
  71         $message = pht(
  72           'All members of the account ("%s") for this subscription ("%s") '.
  73           'are disabled.',
  74           $account->getPHID(),
  75           $subscription->getPHID());
  76       } else if ($account->getMemberPHIDs()) {
  77         $message = pht(
  78           'Unable to load any of the members of the account ("%s") for this '.
  79           'subscription ("%s").',
  80           $account->getPHID(),
  81           $subscription->getPHID());
  82       } else {
  83         $message = pht(
  84           'The account ("%s") for this subscription ("%s") has no '.
  85           'members.',
  86           $account->getPHID(),
  87           $subscription->getPHID());
  88       }
  89       throw new PhabricatorWorkerPermanentFailureException($message);
  90     }
  91
  92     $cart = $account->newCart($actor, $cart_implementation, $merchant);
  93
  94     $purchase = $cart->newPurchase($actor, $product);
  95
  96     $purchase
  97       ->setBasePriceAsCurrency($currency)
  98       ->setMetadataValue('subscriptionPHID', $subscription->getPHID())
  99       ->setMetadataValue('epoch.start', $last_epoch)
 100       ->setMetadataValue('epoch.end', $next_epoch)
 101       ->save();
 102
 103     $cart
 104       ->setSubscriptionPHID($subscription->getPHID())
 105       ->setIsInvoice(1)
 106       ->save();
 107
 108     $cart->activateCart();
 109
 110     try {
 111       $issues = $this->chargeSubscription($actor, $subscription, $cart);
 112     } catch (Exception $ex) {
 113       $issues = array(
 114         pht(
 115           'There was a technical error while trying to automatically bill '.
 116           'this subscription: %s',
 117           $ex),
 118       );
 119     }
 120
 121     if (!$issues) {
 122       // We're all done; charging the cart sends a billing email as a side
 123       // effect.
 124       return;
 125     }
 126
 127     // We're shoving this through the CartEditor because it has all the logic
 128     // for sending mail about carts. This doesn't really affect the state of
 129     // the cart, but reduces the amount of code duplication.
 130
 131     $xactions = array();
 132     $xactions[] = id(new PhortuneCartTransaction())
 133       ->setTransactionType(PhortuneCartTransaction::TYPE_INVOICED)
 134       ->setNewValue(true);
 135
 136     $content_source = PhabricatorContentSource::newForSource(
 137       PhabricatorPhortuneContentSource::SOURCECONST);
 138
 139     $acting_phid = id(new PhabricatorPhortuneApplication())->getPHID();
 140     $editor = id(new PhortuneCartEditor())
 141       ->setActor($viewer)
 142       ->setActingAsPHID($acting_phid)
 143       ->setContentSource($content_source)
 144       ->setContinueOnMissingFields(true)
 145       ->setInvoiceIssues($issues)
 146       ->applyTransactions($cart, $xactions);
 147   }
 148
 149
 150   private function chargeSubscription(
 151     PhabricatorUser $viewer,
 152     PhortuneSubscription $subscription,
 153     PhortuneCart $cart) {
 154
 155     $issues = array();
 156     if (!$subscription->getDefaultPaymentMethodPHID()) {
 157       $issues[] = pht(
 158         'There is no payment method associated with this subscription, so '.
 159         'it could not be billed automatically. Add a default payment method '.
 160         'to enable automatic billing.');
 161       return $issues;
 162     }
 163
 164     $method = id(new PhortunePaymentMethodQuery())
 165       ->setViewer($viewer)
 166       ->withPHIDs(array($subscription->getDefaultPaymentMethodPHID()))
 167       ->withStatuses(
 168         array(
 169           PhortunePaymentMethod::STATUS_ACTIVE,
 170         ))
 171       ->executeOne();
 172     if (!$method) {
 173       $issues[] = pht(
 174         'The payment method associated with this subscription is invalid '.
 175         'or out of date, so it could not be automatically billed. Update '.
 176         'the default payment method to enable automatic billing.');
 177       return $issues;
 178     }
 179
 180     $provider = $method->buildPaymentProvider();
 181     $charge = $cart->willApplyCharge($viewer, $provider, $method);
 182
 183     try {
 184       $provider->applyCharge($method, $charge);
 185     } catch (Exception $ex) {
 186       $cart->didFailCharge($charge);
 187       $issues[] = pht(
 188         'Automatic billing failed: %s',
 189         $ex->getMessage());
 190       return $issues;
 191     }
 192
 193     $cart->didApplyCharge($charge);
 194   }
 195
 196
 197   /**
 198    * Load the subscription to generate an invoice for.
 199    *
 200    * @return PhortuneSubscription The subscription to invoice.
 201    */
 202   private function loadSubscription() {
 203     $viewer = PhabricatorUser::getOmnipotentUser();
 204
 205     $data = $this->getTaskData();
 206     $subscription_phid = idx($data, 'subscriptionPHID');
 207
 208     $subscription = id(new PhortuneSubscriptionQuery())
 209       ->setViewer($viewer)
 210       ->withPHIDs(array($subscription_phid))
 211       ->executeOne();
 212     if (!$subscription) {
 213       throw new PhabricatorWorkerPermanentFailureException(
 214         pht(
 215           'Failed to load subscription with PHID "%s".',
 216           $subscription_phid));
 217     }
 218
 219     return $subscription;
 220   }
 221
 222
 223   /**
 224    * Get the start and end epoch timestamps for this billing period.
 225    *
 226    * @param PhortuneSubscription The subscription being billed.
 227    * @return pair<int, int> Beginning and end of the billing range.
 228    */
 229   private function getBillingPeriodRange(PhortuneSubscription $subscription) {
 230     $data = $this->getTaskData();
 231
 232     $last_epoch = idx($data, 'trigger.last-epoch');
 233     if (!$last_epoch) {
 234       // If this is the first time the subscription is firing, use the
 235       // creation date as the start of the billing period.
 236       $last_epoch = $subscription->getDateCreated();
 237     }
 238     $this_epoch = idx($data, 'trigger.this-epoch');
 239
 240     if (!$last_epoch || !$this_epoch) {
 241       throw new PhabricatorWorkerPermanentFailureException(
 242         pht('Subscription is missing billing period information.'));
 243     }
 244
 245     $period_length = ($this_epoch - $last_epoch);
 246     if ($period_length <= 0) {
 247       throw new PhabricatorWorkerPermanentFailureException(
 248         pht(
 249           'Subscription has invalid billing period.'));
 250     }
 251
 252     if (empty($data['manual'])) {
 253       if (PhabricatorTime::getNow() < $this_epoch) {
 254         throw new Exception(
 255           pht(
 256             'Refusing to generate a subscription invoice for a billing period '.
 257             'which ends in the future.'));
 258       }
 259     }
 260
 261     return array($last_epoch, $this_epoch);
 262   }
 263
 264 }