Provide phame.post.edit Conduit API method

Summary:
Ref T9897. This one is a little more involved because of how getting a post on a blog works.

I also changed moving posts to be a real transaction (which shows up in history, now).

Test Plan: Created posts from web UI and conduit.

Reviewers: chad

Reviewed By: chad

Maniphest Tasks: T9897

Differential Revision: https://secure.phabricator.com/D14902

src/__phutil_library_map__.php

···
     'PhamePost' => 'applications/phame/storage/PhamePost.php',
     'PhamePostCommentController' => 'applications/phame/controller/post/PhamePostCommentController.php',
     'PhamePostController' => 'applications/phame/controller/post/PhamePostController.php',
+    'PhamePostEditConduitAPIMethod' => 'applications/phame/conduit/PhamePostEditConduitAPIMethod.php',
     'PhamePostEditController' => 'applications/phame/controller/post/PhamePostEditController.php',
     'PhamePostEditEngine' => 'applications/phame/editor/PhamePostEditEngine.php',
     'PhamePostEditor' => 'applications/phame/editor/PhamePostEditor.php',
···
     'ConduitMethodDoesNotExistException' => 'ConduitMethodNotFoundException',
     'ConduitMethodNotFoundException' => 'ConduitException',
     'ConduitPHIDListParameterType' => 'ConduitListParameterType',
-    'ConduitPHIDParameterType' => 'ConduitListParameterType',
+    'ConduitPHIDParameterType' => 'ConduitParameterType',
     'ConduitParameterType' => 'Phobject',
     'ConduitPingConduitAPIMethod' => 'ConduitAPIMethod',
     'ConduitProjectListParameterType' => 'ConduitListParameterType',
···
     ),
     'PhamePostCommentController' => 'PhamePostController',
     'PhamePostController' => 'PhameController',
+    'PhamePostEditConduitAPIMethod' => 'PhabricatorEditEngineAPIMethod',
     'PhamePostEditController' => 'PhamePostController',
     'PhamePostEditEngine' => 'PhabricatorEditEngine',
     'PhamePostEditor' => 'PhabricatorApplicationTransactionEditor',

src/applications/conduit/parametertype/ConduitPHIDParameterType.php

···
 <?php
 
 final class ConduitPHIDParameterType
-  extends ConduitListParameterType {
+  extends ConduitParameterType {
 
   protected function getParameterValue(array $request, $key) {
     $value = parent::getParameterValue($request, $key);

src/applications/phame/conduit/PhamePostEditConduitAPIMethod.php

···
+<?php
+
+final class PhamePostEditConduitAPIMethod
+  extends PhabricatorEditEngineAPIMethod {
+
+  public function getAPIMethodName() {
+    return 'phame.post.edit';
+  }
+
+  public function newEditEngine() {
+    return new PhamePostEditEngine();
+  }
+
+  public function getMethodSummary() {
+    return pht('Create or edit blog posts in Phame.');
+  }
+
+}

src/applications/phame/controller/post/PhamePostEditController.php

···
 
 final class PhamePostEditController extends PhamePostController {
 
+  private $blog;
+
+  public function setBlog(PhameBlog $blog) {
+    $this->blog = $blog;
+    return $this;
+  }
+
+  public function getBlog() {
+    return $this->blog;
+  }
+
   public function handleRequest(AphrontRequest $request) {
     $viewer = $request->getViewer();
     $id = $request->getURIData('id');
···
         ->withIDs(array($id))
         ->requireCapabilities(
           array(
+            PhabricatorPolicyCapability::CAN_VIEW,
             PhabricatorPolicyCapability::CAN_EDIT,
           ))
         ->executeOne();
···
           PhabricatorPolicyCapability::CAN_EDIT,
         ))
       ->executeOne();
-
     if (!$blog) {
       return new Aphront404Response();
     }
 
+    $this->setBlog($blog);
+
     return id(new PhamePostEditEngine())
       ->setController($this)
       ->setBlog($blog)
       ->buildResponse();
   }
+
+  protected function buildApplicationCrumbs() {
+    $crumbs = parent::buildApplicationCrumbs();
+
+    $blog = $this->getBlog();
+
+    $crumbs->addTextCrumb(
+      $blog->getName(),
+      $blog->getViewURI());
+
+    return $crumbs;
+  }
+
 
 }

src/applications/phame/controller/post/PhamePostMoveController.php

···
       return new Aphront404Response();
     }
 
-    $view_uri = '/post/view/'.$post->getID().'/';
-    $view_uri = $this->getApplicationURI($view_uri);
+    $view_uri = $post->getViewURI();
+    $v_blog = $post->getBlog()->getPHID();
 
     if ($request->isFormPost()) {
-      $blog = id(new PhameBlogQuery())
-        ->setViewer($viewer)
-        ->withIDs(array($request->getInt('blog')))
-        ->requireCapabilities(
-          array(
-            PhabricatorPolicyCapability::CAN_EDIT,
-          ))
-        ->executeOne();
+      $v_blog = $request->getStr('blogPHID');
 
-      if ($blog) {
-        $post->setBlogPHID($blog->getPHID());
-        $post->save();
+      $xactions = array();
+      $xactions[] = id(new PhamePostTransaction())
+        ->setTransactionType(PhamePostTransaction::TYPE_BLOG)
+        ->setNewValue($v_blog);
 
-        return id(new AphrontRedirectResponse())
-          ->setURI($view_uri.'?moved=1');
-      }
+      $editor = id(new PhamePostEditor())
+        ->setActor($viewer)
+        ->setContentSourceFromRequest($request)
+        ->setContinueOnMissingFields(true)
+        ->setContinueOnNoEffect(true);
+
+      $editor->applyTransactions($post, $xactions);
+
+      $view_uri = $post->getViewURI();
+
+      return id(new AphrontRedirectResponse())
+        ->setURI($view_uri.'?moved=1');
     }
 
     $blogs = id(new PhameBlogQuery())
       ->setViewer($viewer)
       ->requireCapabilities(
         array(
+          PhabricatorPolicyCapability::CAN_VIEW,
           PhabricatorPolicyCapability::CAN_EDIT,
         ))
       ->execute();
 
-    $options = mpull($blogs, 'getName', 'getID');
+    $options = mpull($blogs, 'getName', 'getPHID');
     asort($options);
 
-    $selected_value = null;
-    if ($post && $post->getBlog()) {
-      $selected_value = $post->getBlog()->getID();
-    }
-
     $form = id(new PHUIFormLayoutView())
       ->setUser($viewer)
       ->appendChild(
         id(new AphrontFormSelectControl())
           ->setLabel(pht('Blog'))
-          ->setName('blog')
+          ->setName('blogPHID')
           ->setOptions($options)
-          ->setValue($selected_value));
+          ->setValue($v_blog));
 
     return $this->newDialog()
       ->setTitle(pht('Move Post'))
       ->appendChild($form)
       ->addSubmitButton(pht('Move Post'))
       ->addCancelButton($view_uri);
-
     }
 
 }

src/applications/phame/editor/PhamePostEditEngine.php

···
   }
 
   protected function buildCustomEditFields($object) {
-
-    if ($this->blog) {
-      $blog_title = pht('Blog: %s', $this->blog->getName());
-    } else {
-      $blog_title = pht('Sample Blog Title');
-    }
+    $blog_phid = $object->getBlog()->getPHID();
 
     return array(
-      id(new PhabricatorInstructionsEditField())
-        ->setValue($blog_title),
+      id(new PhabricatorHandlesEditField())
+        ->setKey('blog')
+        ->setLabel(pht('Blog'))
+        ->setDescription(pht('Blog to publish this post to.'))
+        ->setConduitDescription(
+          pht('Choose a blog to create a post on (or move a post to).'))
+        ->setConduitTypeDescription(pht('PHID of the blog.'))
+        ->setAliases(array('blogPHID'))
+        ->setTransactionType(PhamePostTransaction::TYPE_BLOG)
+        ->setHandleParameterType(new AphrontPHIDListHTTPParameterType())
+        ->setSingleValue($blog_phid)
+        ->setIsReorderable(false)
+        ->setIsDefaultable(false)
+        ->setIsLockable(false)
+        ->setIsLocked(true),
       id(new PhabricatorTextEditField())
         ->setKey('title')
         ->setLabel(pht('Title'))

src/applications/phame/editor/PhamePostEditor.php

···
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
+    $types[] = PhamePostTransaction::TYPE_BLOG;
     $types[] = PhamePostTransaction::TYPE_TITLE;
     $types[] = PhamePostTransaction::TYPE_BODY;
     $types[] = PhamePostTransaction::TYPE_VISIBILITY;
···
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
+      case PhamePostTransaction::TYPE_BLOG:
+        return $object->getBlogPHID();
       case PhamePostTransaction::TYPE_TITLE:
         return $object->getTitle();
       case PhamePostTransaction::TYPE_BODY:
···
       case PhamePostTransaction::TYPE_TITLE:
       case PhamePostTransaction::TYPE_BODY:
       case PhamePostTransaction::TYPE_VISIBILITY:
+      case PhamePostTransaction::TYPE_BLOG:
         return $xaction->getNewValue();
     }
   }
···
         return $object->setTitle($xaction->getNewValue());
       case PhamePostTransaction::TYPE_BODY:
         return $object->setBody($xaction->getNewValue());
+      case PhamePostTransaction::TYPE_BLOG:
+        return $object->setBlogPHID($xaction->getNewValue());
       case PhamePostTransaction::TYPE_VISIBILITY:
         if ($xaction->getNewValue() == PhameConstants::VISIBILITY_DRAFT) {
           $object->setDatePublished(0);
···
       case PhamePostTransaction::TYPE_TITLE:
       case PhamePostTransaction::TYPE_BODY:
       case PhamePostTransaction::TYPE_VISIBILITY:
+      case PhamePostTransaction::TYPE_BLOG:
         return;
     }
 
···
           $error->setIsMissingFieldError(true);
           $errors[] = $error;
         }
+        break;
+      case PhamePostTransaction::TYPE_BLOG:
+        if ($this->getIsNewObject()) {
+          if (!$xactions) {
+            $error = new PhabricatorApplicationTransactionValidationError(
+              $type,
+              pht('Required'),
+              pht(
+                'When creating a post, you must specify which blog it '.
+                'should belong to.'),
+              null);
+
+            $error->setIsMissingFieldError(true);
+
+            $errors[] = $error;
+            break;
+          }
+        }
+
+        foreach ($xactions as $xaction) {
+          $new_phid = $xaction->getNewValue();
+
+          $blog = id(new PhameBlogQuery())
+            ->setViewer($this->getActor())
+            ->withPHIDs(array($new_phid))
+            ->requireCapabilities(
+              array(
+                PhabricatorPolicyCapability::CAN_VIEW,
+                PhabricatorPolicyCapability::CAN_EDIT,
+              ))
+            ->execute();
+
+          if ($blog) {
+            continue;
+          }
+
+          $errors[] = new PhabricatorApplicationTransactionValidationError(
+            $type,
+            pht('Invalid'),
+            pht(
+              'The specified blog PHID ("%s") is not valid. You can only '.
+              'create a post on (or move a post into) a blog which you '.
+              'have permission to see and edit.',
+              $new_phid),
+            $xaction);
+        }
+
         break;
     }
     return $errors;

src/applications/phame/storage/PhamePostTransaction.php

···
   const TYPE_PHAME_TITLE      = 'phame.post.phame.title';
   const TYPE_BODY             = 'phame.post.body';
   const TYPE_VISIBILITY       = 'phame.post.visibility';
+  const TYPE_BLOG             = 'phame.post.blog';
 
   const MAILTAG_CONTENT       = 'phame-post-content';
   const MAILTAG_SUBSCRIBERS   = 'phame-post-subscribers';
···
     return parent::shouldHide();
   }
 
+  public function getRequiredHandlePHIDs() {
+    $phids = parent::getRequiredHandlePHIDs();
+
+    switch ($this->getTransactionType()) {
+      case self::TYPE_BLOG:
+        $old = $this->getOldValue();
+        $new = $this->getNewValue();
+
+        if ($old) {
+          $phids[] = $old;
+        }
+
+        if ($new) {
+          $phids[] = $new;
+        }
+        break;
+    }
+
+    return $phids;
+  }
+
+
   public function getIcon() {
     $old = $this->getOldValue();
     switch ($this->getTransactionType()) {
···
 
     $type = $this->getTransactionType();
     switch ($type) {
+      case PhabricatorTransactions::TYPE_CREATE:
+        return pht(
+          '%s created this post.',
+          $this->renderHandleLink($author_phid));
+      case self::TYPE_BLOG:
+        return pht(
+          '%s moved this post from "%s" to "%s".',
+          $this->renderHandleLink($author_phid),
+          $this->renderHandleLink($old),
+          $this->renderHandleLink($new));
       case self::TYPE_TITLE:
         if ($old === null) {
           return pht(
···
 
     $type = $this->getTransactionType();
     switch ($type) {
+      case self::TYPE_BLOG:
+        return pht(
+          '%s moved post "%s" from "%s" to "%s".',
+          $this->renderHandleLink($author_phid),
+          $this->renderHandleLink($object_phid),
+          $this->renderHandleLink($old),
+          $this->renderHandleLink($new));
       case self::TYPE_TITLE:
         if ($old === null) {
           return pht(

src/applications/transactions/editengine/PhabricatorEditEngine.php

···
       // Let the parameter type interpret the value. This allows you to
       // use usernames in list<user> fields, for example.
       $parameter_type = $type->getConduitParameterType();
-      $xaction['value'] = $parameter_type->getValue($xaction, 'value');
+
+      try {
+        $xaction['value'] = $parameter_type->getValue($xaction, 'value');
+      } catch (Exception $ex) {
+        throw new PhutilProxyException(
+          pht(
+            'Exception when processing transaction of type "%s".',
+            $xaction['type']),
+          $ex);
+      }
 
       $type_xactions = $type->generateTransactions(
         clone $template,

src/applications/transactions/editfield/PhabricatorPHIDListEditField.php

···
   }
 
   protected function newConduitParameterType() {
-    return new ConduitPHIDListParameterType();
+    if ($this->getIsSingleValue()) {
+      return new ConduitPHIDParameterType();
+    } else {
+      return new ConduitPHIDListParameterType();
+    }
   }
 
   protected function getValueFromRequest(AphrontRequest $request, $key) {