PhabricatorProjectColumnPositionQuery.php
59a85e8845efstable

PhabricatorProjectColumnPositionQuery.php
View Options

			<?php

			final class PhabricatorProjectColumnPositionQuery
			extends PhabricatorCursorPagedPolicyAwareQuery {

			private $ids;
			private $boardPHIDs;
			private $objectPHIDs;
			private $columns;

			private $needColumns;
			private $skipImplicitCreate;

			public function withIDs(array $ids) {
			$this->ids = $ids;
			return $this;
			}

			public function withBoardPHIDs(array $board_phids) {
			$this->boardPHIDs = $board_phids;
			return $this;
			}

			public function withObjectPHIDs(array $object_phids) {
			$this->objectPHIDs = $object_phids;
			return $this;
			}

			/**
			* Find objects in specific columns.
			*
			* NOTE: Using this method activates logic which constructs virtual
			* column positions for objects not in any column, if you pass a default
			* column. Normally these results are not returned.
			*
			* @param list<PhabricatorProjectColumn> Columns to look for objects in.
			* @return this
			*/
			public function withColumns(array $columns) {
			assert_instances_of($columns, 'PhabricatorProjectColumn');
			$this->columns = $columns;
			return $this;
			}

			public function needColumns($need_columns) {
			$this->needColumns = true;
			return $this;
			}


			/**
			* Skip implicit creation of column positions which are implied but do not
			* yet exist.
			*
			* This is primarily useful internally.
			*
			* @param bool True to skip implicit creation of column positions.
			* @return this
			*/
			public function setSkipImplicitCreate($skip) {
			$this->skipImplicitCreate = $skip;
			return $this;
			}

			// NOTE: For now, boards are always attached to projects. However, they might
			// not be in the future. This generalization just anticipates a future where
			// we let other types of objects (like users) have boards, or let boards
			// contain other types of objects.

			private function newPositionObject() {
			return new PhabricatorProjectColumnPosition();
			}

			private function newColumnQuery() {
			return new PhabricatorProjectColumnQuery();
			}

			private function getBoardMembershipEdgeTypes() {
			return array(
			PhabricatorProjectProjectHasObjectEdgeType::EDGECONST,
			);
			}

			private function getBoardMembershipPHIDTypes() {
			return array(
			ManiphestTaskPHIDType::TYPECONST,
			);
			}

			protected function loadPage() {
			$table = $this->newPositionObject();
			$conn_r = $table->establishConnection('r');

			// We're going to find results by combining two queries: one query finds
			// objects on a board column, while the other query finds objects not on
			// any board column and virtually puts them on the default column.

			$unions = array();

			// First, find all the stuff that's actually on a column.

			$unions[] = qsprintf(
			$conn_r,
			'SELECT * FROM %T %Q',
			$table->getTableName(),
			$this->buildWhereClause($conn_r));

			// If we have a default column, find all the stuff that's not in any
			// column and put it in the default column.

			$must_type_filter = false;
			if ($this->columns && !$this->skipImplicitCreate) {
			$default_map = array();
			foreach ($this->columns as $column) {
			if ($column->isDefaultColumn()) {
			$default_map[$column->getProjectPHID()] = $column->getPHID();
			}
			}

			if ($default_map) {
			$where = array();

			// Find the edges attached to the boards we have default columns for.

			$where[] = qsprintf(
			$conn_r,
			'e.src IN (%Ls)',
			array_keys($default_map));

			// Find only edges which describe a board relationship.

			$where[] = qsprintf(
			$conn_r,
			'e.type IN (%Ld)',
			$this->getBoardMembershipEdgeTypes());

			if ($this->boardPHIDs !== null) {
			// This should normally be redundant, but construct it anyway if
			// the caller has told us to.
			$where[] = qsprintf(
			$conn_r,
			'e.src IN (%Ls)',
			$this->boardPHIDs);
			}

			if ($this->objectPHIDs !== null) {
			$where[] = qsprintf(
			$conn_r,
			'e.dst IN (%Ls)',
			$this->objectPHIDs);
			}

			$where[] = qsprintf(
			$conn_r,
			'p.id IS NULL');

			$where = $this->formatWhereClause($where);

			$unions[] = qsprintf(
			$conn_r,
			'SELECT NULL id, e.src boardPHID, NULL columnPHID, e.dst objectPHID,
			0 sequence
			FROM %T e LEFT JOIN %T p
			ON e.src = p.boardPHID AND e.dst = p.objectPHID
			%Q',
			PhabricatorEdgeConfig::TABLE_NAME_EDGE,
			$table->getTableName(),
			$where);

			$must_type_filter = true;
			}
			}

			$data = queryfx_all(
			$conn_r,
			'%Q %Q %Q',
			implode(' UNION ALL ', $unions),
			$this->buildOrderClause($conn_r),
			$this->buildLimitClause($conn_r));

			// If we've picked up objects not in any column, we need to filter out any
			// matched objects which have the wrong edge type.
			if ($must_type_filter) {
			$allowed_types = array_fuse($this->getBoardMembershipPHIDTypes());
			foreach ($data as $id => $row) {
			if ($row['columnPHID'] === null) {
			$object_phid = $row['objectPHID'];
			if (empty($allowed_types[phid_get_type($object_phid)])) {
			unset($data[$id]);
			}
			}
			}
			}

			$positions = $table->loadAllFromArray($data);

			// Find the implied positions which don't exist yet. If there are any,
			// we're going to create them.
			$create = array();
			foreach ($positions as $position) {
			if ($position->getColumnPHID() === null) {
			$column_phid = idx($default_map, $position->getBoardPHID());
			$position->setColumnPHID($column_phid);

			$create[] = $position;
			}
			}

			if ($create) {
			// If we're adding several objects to a column, insert the column
			// position objects in object ID order. This means that newly added
			// objects float to the top, and when a group of newly added objects
			// float up at the same time, the most recently created ones end up
			// highest in the list.

			$objects = id(new PhabricatorObjectQuery())
			->setViewer(PhabricatorUser::getOmnipotentUser())
			->withPHIDs(mpull($create, 'getObjectPHID'))
			->execute();
			$objects = mpull($objects, null, 'getPHID');
			$objects = msort($objects, 'getID');

			$create = mgroup($create, 'getObjectPHID');
			$create = array_select_keys($create, array_keys($objects)) + $create;

			$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();

			foreach ($create as $object_phid => $create_positions) {
			foreach ($create_positions as $create_position) {
			$create_position->save();
			}
			}

			unset($unguarded);
			}

			return $positions;
			}

			protected function willFilterPage(array $page) {

			if ($this->needColumns) {
			$column_phids = mpull($page, 'getColumnPHID');
			$columns = $this->newColumnQuery()
			->setParentQuery($this)
			->setViewer($this->getViewer())
			->withPHIDs($column_phids)
			->execute();
			$columns = mpull($columns, null, 'getPHID');

			foreach ($page as $key => $position) {
			$column = idx($columns, $position->getColumnPHID());
			if (!$column) {
			unset($page[$key]);
			continue;
			}

			$position->attachColumn($column);
			}
			}

			return $page;
			}

			private function buildWhereClause($conn_r) {
			$where = array();

			if ($this->ids !== null) {
			$where[] = qsprintf(
			$conn_r,
			'id IN (%Ld)',
			$this->ids);
			}

			if ($this->boardPHIDs !== null) {
			$where[] = qsprintf(
			$conn_r,
			'boardPHID IN (%Ls)',
			$this->boardPHIDs);
			}

			if ($this->objectPHIDs !== null) {
			$where[] = qsprintf(
			$conn_r,
			'objectPHID IN (%Ls)',
			$this->objectPHIDs);
			}

			if ($this->columns !== null) {
			$where[] = qsprintf(
			$conn_r,
			'columnPHID IN (%Ls)',
			mpull($this->columns, 'getPHID'));
			}

			// NOTE: Explicitly not building the paging clause here, since it won't
			// work with the UNION.

			return $this->formatWhereClause($where);
			}

			public function getQueryApplicationClass() {
			return 'PhabricatorProjectApplication';
			}

			}

phab/src/applications/project/query/PhabricatorProjectColumnPositionQuery.php59a85e8845efstable

PhabricatorProjectColumnPositionQuery.phpView Options

phab/src/applications/project/query/PhabricatorProjectColumnPositionQuery.php
59a85e8845efstable

PhabricatorProjectColumnPositionQuery.php
View Options