Allow Owners Packages to be archived

Summary: Fixes T8428. Adds status to packages, allows setting and application search. I presume though these need checked elsewhere?

Test Plan: New package, edit package, archive package, run search queries.

Reviewers: epriestley

Reviewed By: epriestley

Subscribers: Korvin

Maniphest Tasks: T8428

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

resources/sql/autopatches/20150815.owners.status.1.sql

···
+ALTER TABLE {$NAMESPACE}_owners.owners_package
+  ADD status VARCHAR(32) NOT NULL COLLATE {$COLLATE_TEXT};

resources/sql/autopatches/20150815.owners.status.2.sql

···
+UPDATE {$NAMESPACE}_owners.owners_package
+  SET status = 'active' WHERE status = '';

src/applications/differential/controller/DifferentialController.php

···
         if ($viewer->getPHID()) {
           $packages = id(new PhabricatorOwnersPackageQuery())
             ->setViewer($viewer)
+            ->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
             ->withAuthorityPHIDs(array($viewer->getPHID()))
             ->execute();
           $toc_view->setAuthorityPackages($packages);
···
 
         $control_query = id(new PhabricatorOwnersPackageQuery())
           ->setViewer($viewer)
+          ->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
           ->withControl($repository_phid, $paths);
         $control_query->execute();
       }

src/applications/diffusion/controller/DiffusionBrowseController.php

···
     if (PhabricatorApplication::isClassInstalled($owners)) {
       $package_query = id(new PhabricatorOwnersPackageQuery())
         ->setViewer($viewer)
+        ->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
         ->withControl(
           $repository->getPHID(),
           array(

src/applications/diffusion/controller/DiffusionCommitController.php

···
       if ($viewer->getPHID()) {
         $packages = id(new PhabricatorOwnersPackageQuery())
           ->setViewer($viewer)
+          ->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
           ->withAuthorityPHIDs(array($viewer->getPHID()))
           ->execute();
         $toc_view->setAuthorityPackages($packages);
···
 
       $control_query = id(new PhabricatorOwnersPackageQuery())
         ->setViewer($viewer)
+        ->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
         ->withControl($repository_phid, mpull($changesets, 'getFilename'));
       $control_query->execute();
     }

src/applications/owners/controller/PhabricatorOwnersDetailController.php

···
     $properties = $this->buildPackagePropertyView($package);
     $properties->setActionList($actions);
 
+    if ($package->isArchived()) {
+      $header_icon = 'fa-ban';
+      $header_name = pht('Archived');
+      $header_color = 'dark';
+    } else {
+      $header_icon = 'fa-check';
+      $header_name = pht('Active');
+      $header_color = 'bluegrey';
+    }
+
     $header = id(new PHUIHeaderView())
       ->setUser($viewer)
       ->setHeader($package->getName())
+      ->setStatus($header_icon, $header_color, $header_name)
       ->setPolicyObject($package);
 
     $panel = id(new PHUIObjectBoxView())

src/applications/owners/controller/PhabricatorOwnersEditController.php

···
     $v_owners = mpull($package->getOwners(), 'getUserPHID');
     $v_auditing = $package->getAuditingEnabled();
     $v_description = $package->getDescription();
+    $v_status = $package->getStatus();
 
 
     $errors = array();
···
       $v_owners = $request->getArr('owners');
       $v_auditing = ($request->getStr('auditing') == 'enabled');
       $v_description = $request->getStr('description');
+      $v_status = $request->getStr('status');
 
       $type_name = PhabricatorOwnersPackageTransaction::TYPE_NAME;
       $type_owners = PhabricatorOwnersPackageTransaction::TYPE_OWNERS;
       $type_auditing = PhabricatorOwnersPackageTransaction::TYPE_AUDITING;
       $type_description = PhabricatorOwnersPackageTransaction::TYPE_DESCRIPTION;
+      $type_status = PhabricatorOwnersPackageTransaction::TYPE_STATUS;
 
       $xactions[] = id(new PhabricatorOwnersPackageTransaction())
         ->setTransactionType($type_name)
···
       $xactions[] = id(new PhabricatorOwnersPackageTransaction())
         ->setTransactionType($type_description)
         ->setNewValue($v_description);
+
+      if (!$is_new) {
+        $xactions[] = id(new PhabricatorOwnersPackageTransaction())
+          ->setTransactionType($type_status)
+          ->setNewValue($v_status);
+      }
 
       $editor = id(new PhabricatorOwnersPackageTransactionEditor())
         ->setActor($viewer)
···
           ->setDatasource(new PhabricatorProjectOrUserDatasource())
           ->setLabel(pht('Owners'))
           ->setName('owners')
-          ->setValue($v_owners))
-      ->appendChild(
+          ->setValue($v_owners));
+
+      if (!$is_new) {
+        $form->appendChild(
+          id(new AphrontFormSelectControl())
+            ->setLabel(pht('Status'))
+            ->setName('status')
+            ->setValue($v_status)
+            ->setOptions($package->getStatusNameMap()));
+      }
+
+      $form->appendChild(
         id(new AphrontFormSelectControl())
           ->setName('auditing')
           ->setLabel(pht('Auditing'))

src/applications/owners/editor/PhabricatorOwnersPackageTransactionEditor.php

···
     $types[] = PhabricatorOwnersPackageTransaction::TYPE_AUDITING;
     $types[] = PhabricatorOwnersPackageTransaction::TYPE_DESCRIPTION;
     $types[] = PhabricatorOwnersPackageTransaction::TYPE_PATHS;
+    $types[] = PhabricatorOwnersPackageTransaction::TYPE_STATUS;
 
     return $types;
   }
···
       case PhabricatorOwnersPackageTransaction::TYPE_PATHS:
         $paths = $object->getPaths();
         return mpull($paths, 'getRef');
+      case PhabricatorOwnersPackageTransaction::TYPE_STATUS:
+        return $object->getStatus();
     }
   }
 
···
       case PhabricatorOwnersPackageTransaction::TYPE_NAME:
       case PhabricatorOwnersPackageTransaction::TYPE_DESCRIPTION:
       case PhabricatorOwnersPackageTransaction::TYPE_PATHS:
+      case PhabricatorOwnersPackageTransaction::TYPE_STATUS:
         return $xaction->getNewValue();
       case PhabricatorOwnersPackageTransaction::TYPE_AUDITING:
         return (int)$xaction->getNewValue();
···
       case PhabricatorOwnersPackageTransaction::TYPE_OWNERS:
       case PhabricatorOwnersPackageTransaction::TYPE_PATHS:
         return;
+      case PhabricatorOwnersPackageTransaction::TYPE_STATUS:
+        $object->setStatus($xaction->getNewValue());
+        return;
     }
 
     return parent::applyCustomInternalTransaction($object, $xaction);
···
       case PhabricatorOwnersPackageTransaction::TYPE_NAME:
       case PhabricatorOwnersPackageTransaction::TYPE_DESCRIPTION:
       case PhabricatorOwnersPackageTransaction::TYPE_AUDITING:
+      case PhabricatorOwnersPackageTransaction::TYPE_STATUS:
         return;
       case PhabricatorOwnersPackageTransaction::TYPE_OWNERS:
         $old = $xaction->getOldValue();

src/applications/owners/query/PhabricatorOwnersPackageQuery.php

···
   private $repositoryPHIDs;
   private $paths;
   private $namePrefix;
+  private $statuses;
 
   private $controlMap = array();
   private $controlResults;
···
 
   public function withPaths(array $paths) {
     $this->paths = $paths;
+    return $this;
+  }
+
+  public function withStatuses(array $statuses) {
+    $this->statuses = $statuses;
     return $this;
   }
 
···
         $conn,
         'rpath.path IN (%Ls)',
         $this->getFragmentsForPaths($this->paths));
+    }
+
+    if ($this->statuses !== null) {
+      $where[] = qsprintf(
+        $conn,
+        'p.status IN (%Ls)',
+        $this->statuses);
     }
 
     if (strlen($this->namePrefix)) {

src/applications/owners/query/PhabricatorOwnersPackageSearchEngine.php

···
         ->setLabel(pht('Paths'))
         ->setKey('paths')
         ->setAliases(array('path')),
+      id(new PhabricatorSearchCheckboxesField())
+        ->setKey('statuses')
+        ->setLabel(pht('Status'))
+        ->setOptions(
+          id(new PhabricatorOwnersPackage())
+            ->getStatusNameMap()),
     );
   }
 
···
       $query->withPaths($map['paths']);
     }
 
+    if ($map['statuses']) {
+      $query->withStatuses($map['statuses']);
+    }
+
     return $query;
   }
 
···
     }
 
     $names += array(
+      'active' => pht('Active Packages'),
       'all' => pht('All Packages'),
     );
 
···
     switch ($query_key) {
       case 'all':
         return $query;
+      case 'active':
+        return $query->setParameter(
+          'statuses',
+          array(
+            PhabricatorOwnersPackage::STATUS_ACTIVE,
+          ));
       case 'authority':
         return $query->setParameter(
           'authorityPHIDs',
···
         ->setObjectName(pht('Package %d', $id))
         ->setHeader($package->getName())
         ->setHref('/owners/package/'.$id.'/');
+
+      if ($package->isArchived()) {
+        $item->setDisabled(true);
+      }
 
       $list->addItem($item);
     }

src/applications/owners/storage/PhabricatorOwnersPackage.php

···
   protected $description;
   protected $primaryOwnerPHID;
   protected $mailKey;
+  protected $status;
 
   private $paths = self::ATTACHABLE;
   private $owners = self::ATTACHABLE;
 
+  const STATUS_ACTIVE = 'active';
+  const STATUS_ARCHIVED = 'archived';
+
   public static function initializeNewPackage(PhabricatorUser $actor) {
     return id(new PhabricatorOwnersPackage())
       ->setAuditingEnabled(0)
       ->attachPaths(array())
+      ->setStatus(self::STATUS_ACTIVE)
       ->attachOwners(array());
   }
 
···
     return null;
   }
 
+  public static function getStatusNameMap() {
+    return array(
+      self::STATUS_ACTIVE => pht('Active'),
+      self::STATUS_ARCHIVED => pht('Archived'),
+    );
+  }
+
   protected function getConfiguration() {
     return array(
       // This information is better available from the history table.
···
         'primaryOwnerPHID' => 'phid?',
         'auditingEnabled' => 'bool',
         'mailKey' => 'bytes20',
+        'status' => 'text32',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_phid' => null,
···
     }
 
     return parent::save();
+  }
+
+  public function isArchived() {
+    return ($this->getStatus() == self::STATUS_ARCHIVED);
   }
 
   public function setName($name) {

src/applications/owners/storage/PhabricatorOwnersPackageTransaction.php

···
   const TYPE_AUDITING = 'owners.auditing';
   const TYPE_DESCRIPTION = 'owners.description';
   const TYPE_PATHS = 'owners.paths';
+  const TYPE_STATUS = 'owners.status';
 
   public function getApplicationName() {
     return 'owners';
···
         return pht(
           '%s updated paths for this package.',
           $this->renderHandleLink($author_phid));
+      case self::TYPE_STATUS:
+        if ($new == PhabricatorOwnersPackage::STATUS_ACTIVE) {
+          return pht(
+            '%s activated this package.',
+            $this->renderHandleLink($author_phid));
+        } else if ($new == PhabricatorOwnersPackage::STATUS_ARCHIVED) {
+          return pht(
+            '%s archived this package.',
+            $this->renderHandleLink($author_phid));
+        }
     }
 
     return parent::getTitle();