[Summary view] [Print] [Text view]

   1  <?php
   2  
   3  final class PholioMockEditor extends PhabricatorApplicationTransactionEditor {
   4  
   5    private $newImages = array();
   6  
   7    public function getEditorApplicationClass() {
   8      return 'PhabricatorPholioApplication';
   9    }
  10  
  11    public function getEditorObjectsDescription() {
  12      return pht('Pholio Mocks');
  13    }
  14  
  15    private function setNewImages(array $new_images) {
  16      assert_instances_of($new_images, 'PholioImage');
  17      $this->newImages = $new_images;
  18      return $this;
  19    }
  20    private function getNewImages() {
  21      return $this->newImages;
  22    }
  23  
  24    public function getTransactionTypes() {
  25      $types = parent::getTransactionTypes();
  26  
  27      $types[] = PhabricatorTransactions::TYPE_EDGE;
  28      $types[] = PhabricatorTransactions::TYPE_COMMENT;
  29      $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
  30      $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
  31  
  32      $types[] = PholioTransactionType::TYPE_NAME;
  33      $types[] = PholioTransactionType::TYPE_DESCRIPTION;
  34      $types[] = PholioTransactionType::TYPE_STATUS;
  35      $types[] = PholioTransactionType::TYPE_INLINE;
  36  
  37      $types[] = PholioTransactionType::TYPE_IMAGE_FILE;
  38      $types[] = PholioTransactionType::TYPE_IMAGE_NAME;
  39      $types[] = PholioTransactionType::TYPE_IMAGE_DESCRIPTION;
  40      $types[] = PholioTransactionType::TYPE_IMAGE_REPLACE;
  41      $types[] = PholioTransactionType::TYPE_IMAGE_SEQUENCE;
  42  
  43      return $types;
  44    }
  45  
  46    protected function getCustomTransactionOldValue(
  47      PhabricatorLiskDAO $object,
  48      PhabricatorApplicationTransaction $xaction) {
  49  
  50      switch ($xaction->getTransactionType()) {
  51        case PholioTransactionType::TYPE_NAME:
  52          return $object->getName();
  53        case PholioTransactionType::TYPE_DESCRIPTION:
  54          return $object->getDescription();
  55        case PholioTransactionType::TYPE_STATUS:
  56          return $object->getStatus();
  57        case PholioTransactionType::TYPE_IMAGE_FILE:
  58          $images = $object->getImages();
  59          return mpull($images, 'getPHID');
  60        case PholioTransactionType::TYPE_IMAGE_NAME:
  61          $name = null;
  62          $phid = null;
  63          $image = $this->getImageForXaction($object, $xaction);
  64          if ($image) {
  65            $name = $image->getName();
  66            $phid = $image->getPHID();
  67          }
  68          return array($phid => $name);
  69        case PholioTransactionType::TYPE_IMAGE_DESCRIPTION:
  70          $description = null;
  71          $phid = null;
  72          $image = $this->getImageForXaction($object, $xaction);
  73          if ($image) {
  74            $description = $image->getDescription();
  75            $phid = $image->getPHID();
  76          }
  77          return array($phid => $description);
  78        case PholioTransactionType::TYPE_IMAGE_REPLACE:
  79          $raw = $xaction->getNewValue();
  80          return $raw->getReplacesImagePHID();
  81        case PholioTransactionType::TYPE_IMAGE_SEQUENCE:
  82          $sequence = null;
  83          $phid = null;
  84          $image = $this->getImageForXaction($object, $xaction);
  85          if ($image) {
  86            $sequence = $image->getSequence();
  87            $phid = $image->getPHID();
  88          }
  89          return array($phid => $sequence);
  90      }
  91    }
  92  
  93    protected function getCustomTransactionNewValue(
  94      PhabricatorLiskDAO $object,
  95      PhabricatorApplicationTransaction $xaction) {
  96  
  97      switch ($xaction->getTransactionType()) {
  98        case PholioTransactionType::TYPE_NAME:
  99        case PholioTransactionType::TYPE_DESCRIPTION:
 100        case PholioTransactionType::TYPE_STATUS:
 101        case PholioTransactionType::TYPE_IMAGE_NAME:
 102        case PholioTransactionType::TYPE_IMAGE_DESCRIPTION:
 103        case PholioTransactionType::TYPE_IMAGE_SEQUENCE:
 104          return $xaction->getNewValue();
 105        case PholioTransactionType::TYPE_IMAGE_REPLACE:
 106          $raw = $xaction->getNewValue();
 107          return $raw->getPHID();
 108        case PholioTransactionType::TYPE_IMAGE_FILE:
 109          $raw_new_value = $xaction->getNewValue();
 110          $new_value = array();
 111          foreach ($raw_new_value as $key => $images) {
 112            $new_value[$key] = mpull($images, 'getPHID');
 113          }
 114          $xaction->setNewValue($new_value);
 115          return $this->getPHIDTransactionNewValue($xaction);
 116      }
 117    }
 118  
 119    protected function extractFilePHIDsFromCustomTransaction(
 120      PhabricatorLiskDAO $object,
 121      PhabricatorApplicationTransaction $xaction) {
 122  
 123      switch ($xaction->getTransactionType()) {
 124        case PholioTransactionType::TYPE_IMAGE_FILE:
 125          $new = $xaction->getNewValue();
 126          $phids = array();
 127          foreach ($new as $key => $images) {
 128            $phids[] = mpull($images, 'getFilePHID');
 129          }
 130          return array_mergev($phids);
 131        case PholioTransactionType::TYPE_IMAGE_REPLACE:
 132          return array($xaction->getNewValue()->getFilePHID());
 133      }
 134  
 135      return array();
 136    }
 137  
 138  
 139    protected function transactionHasEffect(
 140      PhabricatorLiskDAO $object,
 141      PhabricatorApplicationTransaction $xaction) {
 142  
 143      switch ($xaction->getTransactionType()) {
 144        case PholioTransactionType::TYPE_INLINE:
 145          return true;
 146      }
 147  
 148      return parent::transactionHasEffect($object, $xaction);
 149    }
 150  
 151    protected function shouldApplyInitialEffects(
 152      PhabricatorLiskDAO $object,
 153      array $xactions) {
 154  
 155      foreach ($xactions as $xaction) {
 156        switch ($xaction->getTransactionType()) {
 157          case PholioTransactionType::TYPE_IMAGE_FILE:
 158          case PholioTransactionType::TYPE_IMAGE_REPLACE:
 159            return true;
 160            break;
 161        }
 162      }
 163      return false;
 164    }
 165  
 166    protected function applyInitialEffects(
 167      PhabricatorLiskDAO $object,
 168      array $xactions) {
 169  
 170      $new_images = array();
 171      foreach ($xactions as $xaction) {
 172        switch ($xaction->getTransactionType()) {
 173          case PholioTransactionType::TYPE_IMAGE_FILE:
 174            $new_value = $xaction->getNewValue();
 175            foreach ($new_value as $key => $txn_images) {
 176              if ($key != '+') {
 177                continue;
 178              }
 179              foreach ($txn_images as $image) {
 180                $image->save();
 181                $new_images[] = $image;
 182              }
 183            }
 184            break;
 185          case PholioTransactionType::TYPE_IMAGE_REPLACE:
 186            $image = $xaction->getNewValue();
 187            $image->save();
 188            $new_images[] = $image;
 189            break;
 190        }
 191      }
 192      $this->setNewImages($new_images);
 193    }
 194  
 195    protected function applyCustomInternalTransaction(
 196      PhabricatorLiskDAO $object,
 197      PhabricatorApplicationTransaction $xaction) {
 198  
 199      switch ($xaction->getTransactionType()) {
 200        case PholioTransactionType::TYPE_NAME:
 201          $object->setName($xaction->getNewValue());
 202          if ($object->getOriginalName() === null) {
 203            $object->setOriginalName($xaction->getNewValue());
 204          }
 205          break;
 206        case PholioTransactionType::TYPE_DESCRIPTION:
 207          $object->setDescription($xaction->getNewValue());
 208          break;
 209        case PholioTransactionType::TYPE_STATUS:
 210          $object->setStatus($xaction->getNewValue());
 211          break;
 212        case PhabricatorTransactions::TYPE_EDGE:
 213          return;
 214      }
 215    }
 216  
 217    private function getImageForXaction(
 218      PholioMock $mock,
 219      PhabricatorApplicationTransaction $xaction) {
 220      $raw_new_value = $xaction->getNewValue();
 221      $image_phid = key($raw_new_value);
 222      $images = $mock->getImages();
 223      foreach ($images as $image) {
 224        if ($image->getPHID() == $image_phid) {
 225          return $image;
 226        }
 227      }
 228      return null;
 229    }
 230  
 231    protected function applyCustomExternalTransaction(
 232      PhabricatorLiskDAO $object,
 233      PhabricatorApplicationTransaction $xaction) {
 234  
 235      switch ($xaction->getTransactionType()) {
 236        case PholioTransactionType::TYPE_IMAGE_FILE:
 237          $old_map = array_fuse($xaction->getOldValue());
 238          $new_map = array_fuse($xaction->getNewValue());
 239  
 240          $obsolete_map = array_diff_key($old_map, $new_map);
 241          $images = $object->getImages();
 242          foreach ($images as $seq => $image) {
 243            if (isset($obsolete_map[$image->getPHID()])) {
 244              $image->setIsObsolete(1);
 245              $image->save();
 246              unset($images[$seq]);
 247            }
 248          }
 249          $object->attachImages($images);
 250          break;
 251        case PholioTransactionType::TYPE_IMAGE_REPLACE:
 252          $old = $xaction->getOldValue();
 253          $images = $object->getImages();
 254          foreach ($images as $seq => $image) {
 255            if ($image->getPHID() == $old) {
 256              $image->setIsObsolete(1);
 257              $image->save();
 258              unset($images[$seq]);
 259            }
 260          }
 261          $object->attachImages($images);
 262          break;
 263        case PholioTransactionType::TYPE_IMAGE_NAME:
 264          $image = $this->getImageForXaction($object, $xaction);
 265          $value = (string) head($xaction->getNewValue());
 266          $image->setName($value);
 267          $image->save();
 268          break;
 269        case PholioTransactionType::TYPE_IMAGE_DESCRIPTION:
 270          $image = $this->getImageForXaction($object, $xaction);
 271          $value = (string) head($xaction->getNewValue());
 272          $image->setDescription($value);
 273          $image->save();
 274          break;
 275        case PholioTransactionType::TYPE_IMAGE_SEQUENCE:
 276          $image = $this->getImageForXaction($object, $xaction);
 277          $value = (int) head($xaction->getNewValue());
 278          $image->setSequence($value);
 279          $image->save();
 280          break;
 281        case PhabricatorTransactions::TYPE_EDGE:
 282          return;
 283      }
 284    }
 285  
 286    protected function applyFinalEffects(
 287      PhabricatorLiskDAO $object,
 288      array $xactions) {
 289  
 290      $images = $this->getNewImages();
 291      foreach ($images as $image) {
 292        $image->setMockID($object->getID());
 293        $image->save();
 294      }
 295  
 296      return $xactions;
 297    }
 298  
 299    protected function mergeTransactions(
 300      PhabricatorApplicationTransaction $u,
 301      PhabricatorApplicationTransaction $v) {
 302  
 303      $type = $u->getTransactionType();
 304      switch ($type) {
 305        case PholioTransactionType::TYPE_NAME:
 306        case PholioTransactionType::TYPE_DESCRIPTION:
 307        case PholioTransactionType::TYPE_STATUS:
 308          return $v;
 309        case PholioTransactionType::TYPE_IMAGE_REPLACE:
 310          $u_img = $u->getNewValue();
 311          $v_img = $v->getNewValue();
 312          if ($u_img->getReplacesImagePHID() == $v_img->getReplacesImagePHID()) {
 313            return $v;
 314          }
 315          break;
 316        case PholioTransactionType::TYPE_IMAGE_FILE:
 317          return $this->mergePHIDOrEdgeTransactions($u, $v);
 318        case PholioTransactionType::TYPE_IMAGE_NAME:
 319        case PholioTransactionType::TYPE_IMAGE_DESCRIPTION:
 320        case PholioTransactionType::TYPE_IMAGE_SEQUENCE:
 321          $raw_new_value_u = $u->getNewValue();
 322          $raw_new_value_v = $v->getNewValue();
 323          $phid_u = key($raw_new_value_u);
 324          $phid_v = key($raw_new_value_v);
 325          if ($phid_u == $phid_v) {
 326            return $v;
 327          }
 328          break;
 329      }
 330  
 331      return parent::mergeTransactions($u, $v);
 332    }
 333  
 334    protected function shouldSendMail(
 335      PhabricatorLiskDAO $object,
 336      array $xactions) {
 337      return true;
 338    }
 339  
 340    protected function buildReplyHandler(PhabricatorLiskDAO $object) {
 341      return id(new PholioReplyHandler())
 342        ->setMailReceiver($object);
 343    }
 344  
 345    protected function buildMailTemplate(PhabricatorLiskDAO $object) {
 346      $id = $object->getID();
 347      $name = $object->getName();
 348      $original_name = $object->getOriginalName();
 349  
 350      return id(new PhabricatorMetaMTAMail())
 351        ->setSubject("M{$id}: {$name}")
 352        ->addHeader('Thread-Topic', "M{$id}: {$original_name}");
 353    }
 354  
 355    protected function getMailTo(PhabricatorLiskDAO $object) {
 356      return array(
 357        $object->getAuthorPHID(),
 358        $this->requireActor()->getPHID(),
 359      );
 360    }
 361  
 362    protected function buildMailBody(
 363      PhabricatorLiskDAO $object,
 364      array $xactions) {
 365  
 366      $body = new PhabricatorMetaMTAMailBody();
 367      $headers = array();
 368      $comments = array();
 369      $inline_comments = array();
 370  
 371      foreach ($xactions as $xaction) {
 372        if ($xaction->shouldHide()) {
 373          continue;
 374        }
 375        $comment = $xaction->getComment();
 376        switch ($xaction->getTransactionType()) {
 377          case PholioTransactionType::TYPE_INLINE:
 378            if ($comment && strlen($comment->getContent())) {
 379              $inline_comments[] = $comment;
 380            }
 381            break;
 382          case PhabricatorTransactions::TYPE_COMMENT:
 383            if ($comment && strlen($comment->getContent())) {
 384              $comments[] = $comment->getContent();
 385            }
 386          // fallthrough
 387          default:
 388            $headers[] = id(clone $xaction)
 389              ->setRenderingTarget('text')
 390              ->getTitle();
 391            break;
 392        }
 393      }
 394  
 395      $body->addRawSection(implode("\n", $headers));
 396  
 397      foreach ($comments as $comment) {
 398        $body->addRawSection($comment);
 399      }
 400  
 401      if ($inline_comments) {
 402        $body->addRawSection(pht('INLINE COMMENTS'));
 403        foreach ($inline_comments as $comment) {
 404          $text = pht(
 405            'Image %d: %s',
 406            $comment->getImageID(),
 407            $comment->getContent());
 408          $body->addRawSection($text);
 409        }
 410      }
 411  
 412      $body->addLinkSection(
 413        pht('MOCK DETAIL'),
 414        PhabricatorEnv::getProductionURI('/M'.$object->getID()));
 415  
 416      return $body;
 417    }
 418  
 419    protected function getMailSubjectPrefix() {
 420      return PhabricatorEnv::getEnvConfig('metamta.pholio.subject-prefix');
 421    }
 422  
 423    public function getMailTagsMap() {
 424      return array(
 425        MetaMTANotificationType::TYPE_PHOLIO_STATUS =>
 426          pht("A mock's status changes."),
 427        MetaMTANotificationType::TYPE_PHOLIO_COMMENT =>
 428          pht('Someone comments on a mock.'),
 429        MetaMTANotificationType::TYPE_PHOLIO_UPDATED =>
 430          pht('Mock images or descriptions change.'),
 431        MetaMTANotificationType::TYPE_PHOLIO_OTHER =>
 432          pht('Other mock activity not listed above occurs.'),
 433      );
 434    }
 435  
 436    protected function shouldPublishFeedStory(
 437      PhabricatorLiskDAO $object,
 438      array $xactions) {
 439      return true;
 440    }
 441  
 442    protected function supportsSearch() {
 443      return true;
 444    }
 445  
 446    protected function shouldApplyHeraldRules(
 447      PhabricatorLiskDAO $object,
 448      array $xactions) {
 449      return true;
 450    }
 451  
 452    protected function buildHeraldAdapter(
 453      PhabricatorLiskDAO $object,
 454      array $xactions) {
 455  
 456      return id(new HeraldPholioMockAdapter())
 457        ->setMock($object);
 458    }
 459  
 460    protected function didApplyHeraldRules(
 461      PhabricatorLiskDAO $object,
 462      HeraldAdapter $adapter,
 463      HeraldTranscript $transcript) {
 464  
 465      $xactions = array();
 466  
 467      $cc_phids = $adapter->getCcPHIDs();
 468      if ($cc_phids) {
 469        $value = array_fuse($cc_phids);
 470        $xactions[] = id(new PholioTransaction())
 471          ->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)
 472          ->setNewValue(array('+' => $value));
 473      }
 474  
 475      return $xactions;
 476    }
 477  
 478    protected function sortTransactions(array $xactions) {
 479      $head = array();
 480      $tail = array();
 481  
 482      // Move inline comments to the end, so the comments precede them.
 483      foreach ($xactions as $xaction) {
 484        $type = $xaction->getTransactionType();
 485        if ($type == PholioTransactionType::TYPE_INLINE) {
 486          $tail[] = $xaction;
 487        } else {
 488          $head[] = $xaction;
 489        }
 490      }
 491  
 492      return array_values(array_merge($head, $tail));
 493    }
 494  
 495    protected function shouldImplyCC(
 496      PhabricatorLiskDAO $object,
 497      PhabricatorApplicationTransaction $xaction) {
 498  
 499      switch ($xaction->getTransactionType()) {
 500        case PholioTransactionType::TYPE_INLINE:
 501          return true;
 502      }
 503  
 504      return parent::shouldImplyCC($object, $xaction);
 505    }
 506  
 507  }