src/applications/phortune/storage/PhortuneAccount.php

   1 <?php
   2
   3 /**
   4  * An account represents a purchasing entity. An account may have multiple users
   5  * on it (e.g., several employees of a company have access to the company
   6  * account), and a user may have several accounts (e.g., a company account and
   7  * a personal account).
   8  */
   9 final class PhortuneAccount extends PhortuneDAO
  10   implements
  11     PhabricatorApplicationTransactionInterface,
  12     PhabricatorPolicyInterface {
  13
  14   protected $name;
  15   protected $billingName;
  16   protected $billingAddress;
  17
  18   private $memberPHIDs = self::ATTACHABLE;
  19   private $merchantPHIDs = self::ATTACHABLE;
  20
  21   public static function initializeNewAccount(PhabricatorUser $actor) {
  22     return id(new self())
  23       ->setBillingName('')
  24       ->setBillingAddress('')
  25       ->attachMerchantPHIDs(array())
  26       ->attachMemberPHIDs(array());
  27   }
  28
  29   public static function createNewAccount(
  30     PhabricatorUser $actor,
  31     PhabricatorContentSource $content_source) {
  32
  33     $account = self::initializeNewAccount($actor);
  34
  35     $xactions = array();
  36     $xactions[] = id(new PhortuneAccountTransaction())
  37       ->setTransactionType(PhortuneAccountNameTransaction::TRANSACTIONTYPE)
  38       ->setNewValue(pht('Default Account'));
  39
  40     $xactions[] = id(new PhortuneAccountTransaction())
  41       ->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
  42       ->setMetadataValue(
  43         'edge:type',
  44         PhortuneAccountHasMemberEdgeType::EDGECONST)
  45       ->setNewValue(
  46         array(
  47           '=' => array($actor->getPHID() => $actor->getPHID()),
  48         ));
  49
  50     $editor = id(new PhortuneAccountEditor())
  51       ->setActor($actor)
  52       ->setContentSource($content_source);
  53
  54     // We create an account for you the first time you visit Phortune.
  55     $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
  56
  57       $editor->applyTransactions($account, $xactions);
  58
  59     unset($unguarded);
  60
  61     return $account;
  62   }
  63
  64   public function newCart(
  65     PhabricatorUser $actor,
  66     PhortuneCartImplementation $implementation,
  67     PhortuneMerchant $merchant) {
  68
  69     $cart = PhortuneCart::initializeNewCart($actor, $this, $merchant);
  70
  71     $cart->setCartClass(get_class($implementation));
  72     $cart->attachImplementation($implementation);
  73
  74     $implementation->willCreateCart($actor, $cart);
  75
  76     return $cart->save();
  77   }
  78
  79   protected function getConfiguration() {
  80     return array(
  81       self::CONFIG_AUX_PHID => true,
  82       self::CONFIG_COLUMN_SCHEMA => array(
  83         'name' => 'text255',
  84         'billingName' => 'text255',
  85         'billingAddress' => 'text',
  86       ),
  87     ) + parent::getConfiguration();
  88   }
  89
  90   public function generatePHID() {
  91     return PhabricatorPHID::generateNewPHID(
  92       PhortuneAccountPHIDType::TYPECONST);
  93   }
  94
  95   public function getMemberPHIDs() {
  96     return $this->assertAttached($this->memberPHIDs);
  97   }
  98
  99   public function attachMemberPHIDs(array $phids) {
 100     $this->memberPHIDs = $phids;
 101     return $this;
 102   }
 103
 104   public function getURI() {
 105     return urisprintf(
 106       '/phortune/account/%d/',
 107       $this->getID());
 108   }
 109
 110   public function getDetailsURI() {
 111     return urisprintf(
 112       '/phortune/account/%d/details/',
 113       $this->getID());
 114   }
 115
 116   public function getOrdersURI() {
 117     return urisprintf(
 118       '/phortune/account/%d/orders/',
 119       $this->getID());
 120   }
 121
 122   public function getOrderListURI($path = '') {
 123     return urisprintf(
 124       '/phortune/account/%d/orders/list/%s',
 125       $this->getID(),
 126       $path);
 127   }
 128
 129   public function getSubscriptionsURI() {
 130     return urisprintf(
 131       '/phortune/account/%d/subscriptions/',
 132       $this->getID());
 133   }
 134
 135   public function getEmailAddressesURI() {
 136     return urisprintf(
 137       '/phortune/account/%d/addresses/',
 138       $this->getID());
 139   }
 140
 141   public function getPaymentMethodsURI() {
 142     return urisprintf(
 143       '/phortune/account/%d/methods/',
 144       $this->getID());
 145   }
 146
 147   public function getChargesURI() {
 148     return urisprintf(
 149       '/phortune/account/%d/charges/',
 150       $this->getID());
 151   }
 152
 153   public function getChargeListURI($path = '') {
 154     return urisprintf(
 155       '/phortune/account/%d/charges/list/%s',
 156       $this->getID(),
 157       $path);
 158   }
 159
 160   public function attachMerchantPHIDs(array $merchant_phids) {
 161     $this->merchantPHIDs = $merchant_phids;
 162     return $this;
 163   }
 164
 165   public function getMerchantPHIDs() {
 166     return $this->assertAttached($this->merchantPHIDs);
 167   }
 168
 169   public function writeMerchantEdge(PhortuneMerchant $merchant) {
 170     $edge_src = $this->getPHID();
 171     $edge_type = PhortuneAccountHasMerchantEdgeType::EDGECONST;
 172     $edge_dst = $merchant->getPHID();
 173
 174     id(new PhabricatorEdgeEditor())
 175       ->addEdge($edge_src, $edge_type, $edge_dst)
 176       ->save();
 177
 178     return $this;
 179   }
 180
 181   public function isUserAccountMember(PhabricatorUser $user) {
 182     $user_phid = $user->getPHID();
 183     if (!$user_phid) {
 184       return null;
 185     }
 186
 187     $member_map = array_fuse($this->getMemberPHIDs());
 188
 189     return isset($member_map[$user_phid]);
 190   }
 191
 192 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 193
 194
 195   public function getApplicationTransactionEditor() {
 196     return new PhortuneAccountEditor();
 197   }
 198
 199   public function getApplicationTransactionTemplate() {
 200     return new PhortuneAccountTransaction();
 201   }
 202
 203
 204 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 205
 206
 207   public function getCapabilities() {
 208     return array(
 209       PhabricatorPolicyCapability::CAN_VIEW,
 210       PhabricatorPolicyCapability::CAN_EDIT,
 211     );
 212   }
 213
 214   public function getPolicy($capability) {
 215     switch ($capability) {
 216       case PhabricatorPolicyCapability::CAN_VIEW:
 217       case PhabricatorPolicyCapability::CAN_EDIT:
 218         if ($this->getPHID() === null) {
 219           // Allow a user to create an account for themselves.
 220           return PhabricatorPolicies::POLICY_USER;
 221         } else {
 222           return PhabricatorPolicies::POLICY_NOONE;
 223         }
 224     }
 225   }
 226
 227   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
 228     if ($this->isUserAccountMember($viewer)) {
 229       return true;
 230     }
 231
 232     // See T13366. If the viewer can edit any merchant that this payment
 233     // account has a relationship with, they can see the payment account.
 234     if ($capability == PhabricatorPolicyCapability::CAN_VIEW) {
 235       $viewer_phids = array($viewer->getPHID());
 236       $merchant_phids = $this->getMerchantPHIDs();
 237
 238       $any_edit = PhortuneMerchantQuery::canViewersEditMerchants(
 239         $viewer_phids,
 240         $merchant_phids);
 241
 242       if ($any_edit) {
 243         return true;
 244       }
 245     }
 246
 247     return false;
 248   }
 249
 250   public function describeAutomaticCapability($capability) {
 251     return array(
 252       pht('Members of an account can always view and edit it.'),
 253       pht('Merchants an account has established a relationship can view it.'),
 254     );
 255   }
 256
 257
 258 }