[Summary view] [Print] [Text view]

   1  <?php
   2  
   3  final class FundInitiativeEditor
   4    extends PhabricatorApplicationTransactionEditor {
   5  
   6    public function getEditorApplicationClass() {
   7      return 'PhabricatorFundApplication';
   8    }
   9  
  10    public function getEditorObjectsDescription() {
  11      return pht('Fund Initiatives');
  12    }
  13  
  14    public function getTransactionTypes() {
  15      $types = parent::getTransactionTypes();
  16  
  17      $types[] = FundInitiativeTransaction::TYPE_NAME;
  18      $types[] = FundInitiativeTransaction::TYPE_DESCRIPTION;
  19      $types[] = FundInitiativeTransaction::TYPE_RISKS;
  20      $types[] = FundInitiativeTransaction::TYPE_STATUS;
  21      $types[] = FundInitiativeTransaction::TYPE_BACKER;
  22      $types[] = FundInitiativeTransaction::TYPE_REFUND;
  23      $types[] = FundInitiativeTransaction::TYPE_MERCHANT;
  24      $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
  25      $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
  26  
  27      return $types;
  28    }
  29  
  30    protected function getCustomTransactionOldValue(
  31      PhabricatorLiskDAO $object,
  32      PhabricatorApplicationTransaction $xaction) {
  33      switch ($xaction->getTransactionType()) {
  34        case FundInitiativeTransaction::TYPE_NAME:
  35          return $object->getName();
  36        case FundInitiativeTransaction::TYPE_DESCRIPTION:
  37          return $object->getDescription();
  38        case FundInitiativeTransaction::TYPE_RISKS:
  39          return $object->getRisks();
  40        case FundInitiativeTransaction::TYPE_STATUS:
  41          return $object->getStatus();
  42        case FundInitiativeTransaction::TYPE_BACKER:
  43        case FundInitiativeTransaction::TYPE_REFUND:
  44          return null;
  45        case FundInitiativeTransaction::TYPE_MERCHANT:
  46          return $object->getMerchantPHID();
  47      }
  48  
  49      return parent::getCustomTransactionOldValue($object, $xaction);
  50    }
  51  
  52    protected function getCustomTransactionNewValue(
  53      PhabricatorLiskDAO $object,
  54      PhabricatorApplicationTransaction $xaction) {
  55  
  56      switch ($xaction->getTransactionType()) {
  57        case FundInitiativeTransaction::TYPE_NAME:
  58        case FundInitiativeTransaction::TYPE_DESCRIPTION:
  59        case FundInitiativeTransaction::TYPE_RISKS:
  60        case FundInitiativeTransaction::TYPE_STATUS:
  61        case FundInitiativeTransaction::TYPE_BACKER:
  62        case FundInitiativeTransaction::TYPE_REFUND:
  63        case FundInitiativeTransaction::TYPE_MERCHANT:
  64          return $xaction->getNewValue();
  65      }
  66  
  67      return parent::getCustomTransactionNewValue($object, $xaction);
  68    }
  69  
  70    protected function applyCustomInternalTransaction(
  71      PhabricatorLiskDAO $object,
  72      PhabricatorApplicationTransaction $xaction) {
  73  
  74      $type = $xaction->getTransactionType();
  75      switch ($type) {
  76        case FundInitiativeTransaction::TYPE_NAME:
  77          $object->setName($xaction->getNewValue());
  78          return;
  79        case FundInitiativeTransaction::TYPE_DESCRIPTION:
  80          $object->setDescription($xaction->getNewValue());
  81          return;
  82        case FundInitiativeTransaction::TYPE_RISKS:
  83          $object->setRisks($xaction->getNewValue());
  84          return;
  85        case FundInitiativeTransaction::TYPE_MERCHANT:
  86          $object->setMerchantPHID($xaction->getNewValue());
  87          return;
  88        case FundInitiativeTransaction::TYPE_STATUS:
  89          $object->setStatus($xaction->getNewValue());
  90          return;
  91        case FundInitiativeTransaction::TYPE_BACKER:
  92        case FundInitiativeTransaction::TYPE_REFUND:
  93          $amount = $xaction->getMetadataValue(
  94            FundInitiativeTransaction::PROPERTY_AMOUNT);
  95          $amount = PhortuneCurrency::newFromString($amount);
  96  
  97          if ($type == FundInitiativeTransaction::TYPE_REFUND) {
  98            $total = $object->getTotalAsCurrency()->subtract($amount);
  99          } else {
 100            $total = $object->getTotalAsCurrency()->add($amount);
 101          }
 102  
 103          $object->setTotalAsCurrency($total);
 104          return;
 105        case PhabricatorTransactions::TYPE_SUBSCRIBERS:
 106        case PhabricatorTransactions::TYPE_EDGE:
 107        case PhabricatorTransactions::TYPE_VIEW_POLICY:
 108        case PhabricatorTransactions::TYPE_EDIT_POLICY:
 109          return;
 110      }
 111  
 112      return parent::applyCustomInternalTransaction($object, $xaction);
 113    }
 114  
 115    protected function applyCustomExternalTransaction(
 116      PhabricatorLiskDAO $object,
 117      PhabricatorApplicationTransaction $xaction) {
 118  
 119      $type = $xaction->getTransactionType();
 120      switch ($type) {
 121        case FundInitiativeTransaction::TYPE_NAME:
 122        case FundInitiativeTransaction::TYPE_DESCRIPTION:
 123        case FundInitiativeTransaction::TYPE_RISKS:
 124        case FundInitiativeTransaction::TYPE_STATUS:
 125        case FundInitiativeTransaction::TYPE_MERCHANT:
 126          return;
 127        case FundInitiativeTransaction::TYPE_BACKER:
 128        case FundInitiativeTransaction::TYPE_REFUND:
 129          $backer = id(new FundBackerQuery())
 130            ->setViewer($this->requireActor())
 131            ->withPHIDs(array($xaction->getNewValue()))
 132            ->executeOne();
 133          if (!$backer) {
 134            throw new Exception(pht('Unable to load FundBacker!'));
 135          }
 136  
 137          $subx = array();
 138  
 139          if ($type == FundInitiativeTransaction::TYPE_BACKER) {
 140            $subx[] = id(new FundBackerTransaction())
 141              ->setTransactionType(FundBackerTransaction::TYPE_STATUS)
 142              ->setNewValue(FundBacker::STATUS_PURCHASED);
 143          } else {
 144            $amount = $xaction->getMetadataValue(
 145              FundInitiativeTransaction::PROPERTY_AMOUNT);
 146            $subx[] = id(new FundBackerTransaction())
 147              ->setTransactionType(FundBackerTransaction::TYPE_STATUS)
 148              ->setNewValue($amount);
 149          }
 150  
 151          $editor = id(new FundBackerEditor())
 152            ->setActor($this->requireActor())
 153            ->setContentSource($this->getContentSource())
 154            ->setContinueOnMissingFields(true)
 155            ->setContinueOnNoEffect(true);
 156  
 157          $editor->applyTransactions($backer, $subx);
 158          return;
 159        case PhabricatorTransactions::TYPE_SUBSCRIBERS:
 160        case PhabricatorTransactions::TYPE_EDGE:
 161        case PhabricatorTransactions::TYPE_VIEW_POLICY:
 162        case PhabricatorTransactions::TYPE_EDIT_POLICY:
 163          return;
 164      }
 165  
 166      return parent::applyCustomExternalTransaction($object, $xaction);
 167    }
 168  
 169    protected function validateTransaction(
 170      PhabricatorLiskDAO $object,
 171      $type,
 172      array $xactions) {
 173  
 174      $errors = parent::validateTransaction($object, $type, $xactions);
 175  
 176      switch ($type) {
 177        case FundInitiativeTransaction::TYPE_NAME:
 178          $missing = $this->validateIsEmptyTextField(
 179            $object->getName(),
 180            $xactions);
 181  
 182          if ($missing) {
 183            $error = new PhabricatorApplicationTransactionValidationError(
 184              $type,
 185              pht('Required'),
 186              pht('Initiative name is required.'),
 187              nonempty(last($xactions), null));
 188  
 189            $error->setIsMissingFieldError(true);
 190            $errors[] = $error;
 191          }
 192          break;
 193        case FundInitiativeTransaction::TYPE_MERCHANT:
 194          $missing = $this->validateIsEmptyTextField(
 195            $object->getName(),
 196            $xactions);
 197          if ($missing) {
 198            $error = new PhabricatorApplicationTransactionValidationError(
 199              $type,
 200              pht('Required'),
 201              pht('Payable merchant is required.'),
 202              nonempty(last($xactions), null));
 203  
 204            $error->setIsMissingFieldError(true);
 205            $errors[] = $error;
 206          } else if ($xactions) {
 207            $merchant_phid = last($xactions)->getNewValue();
 208  
 209            // Make sure the actor has permission to edit the merchant they're
 210            // selecting. You aren't allowed to send payments to an account you
 211            // do not control.
 212            $merchants = id(new PhortuneMerchantQuery())
 213              ->setViewer($this->requireActor())
 214              ->withPHIDs(array($merchant_phid))
 215              ->requireCapabilities(
 216                array(
 217                  PhabricatorPolicyCapability::CAN_VIEW,
 218                  PhabricatorPolicyCapability::CAN_EDIT,
 219                ))
 220              ->execute();
 221            if (!$merchants) {
 222              $error = new PhabricatorApplicationTransactionValidationError(
 223                $type,
 224                pht('Invalid'),
 225                pht(
 226                  'You must specify a merchant account you control as the '.
 227                  'recipient of funds from this initiative.'),
 228                last($xactions));
 229              $errors[] = $error;
 230            }
 231          }
 232          break;
 233      }
 234  
 235      return $errors;
 236    }
 237  
 238    protected function shouldSendMail(
 239      PhabricatorLiskDAO $object,
 240      array $xactions) {
 241      return true;
 242    }
 243  
 244    public function getMailTagsMap() {
 245      return array(
 246        FundInitiativeTransaction::MAILTAG_BACKER =>
 247          pht('Someone backs an initiative.'),
 248        FundInitiativeTransaction::MAILTAG_STATUS =>
 249          pht("An initiative's status changes."),
 250        FundInitiativeTransaction::MAILTAG_OTHER =>
 251          pht('Other initiative activity not listed above occurs.'),
 252      );
 253    }
 254  
 255    protected function buildMailTemplate(PhabricatorLiskDAO $object) {
 256      $monogram = $object->getMonogram();
 257      $name = $object->getName();
 258  
 259      return id(new PhabricatorMetaMTAMail())
 260        ->setSubject("{$monogram}: {$name}")
 261        ->addHeader('Thread-Topic', $monogram);
 262    }
 263  
 264    protected function buildMailBody(
 265      PhabricatorLiskDAO $object,
 266      array $xactions) {
 267  
 268      $body = parent::buildMailBody($object, $xactions);
 269  
 270      $body->addLinkSection(
 271        pht('INITIATIVE DETAIL'),
 272        PhabricatorEnv::getProductionURI('/'.$object->getMonogram()));
 273  
 274      return $body;
 275    }
 276  
 277    protected function getMailTo(PhabricatorLiskDAO $object) {
 278      return array($object->getOwnerPHID());
 279    }
 280  
 281    protected function getMailSubjectPrefix() {
 282      return 'Fund';
 283    }
 284  
 285    protected function buildReplyHandler(PhabricatorLiskDAO $object) {
 286      return id(new FundInitiativeReplyHandler())
 287        ->setMailReceiver($object);
 288    }
 289  
 290    protected function shouldPublishFeedStory(
 291      PhabricatorLiskDAO $object,
 292      array $xactions) {
 293      return true;
 294    }
 295  
 296    protected function supportsSearch() {
 297      return true;
 298    }
 299  
 300  }