Diffusion Phabricator (feature/testing) Browse

testing

ConpherenceThreadSearchEngine.php
View Options

			<?php

			final class ConpherenceThreadSearchEngine
			extends PhabricatorApplicationSearchEngine {

			public function getResultTypeDescription() {
			return pht('Conpherence Rooms');
			}

			public function getApplicationClassName() {
			return 'PhabricatorConpherenceApplication';
			}

			public function newQuery() {
			return id(new ConpherenceThreadQuery())
			->needProfileImage(true);
			}

			protected function buildCustomSearchFields() {
			return array(
			id(new PhabricatorUsersSearchField())
			->setLabel(pht('Participants'))
			->setKey('participants')
			->setAliases(array('participant')),
			id(new PhabricatorSearchDatasourceField())
			->setLabel(pht('Rooms'))
			->setKey('phids')
			->setDescription(pht('Search by room titles.'))
			->setDatasource(id(new ConpherenceThreadDatasource())),
			id(new PhabricatorSearchTextField())
			->setLabel(pht('Room Contains Words'))
			->setKey('fulltext'),
			);
			}

			protected function getDefaultFieldOrder() {
			return array(
			'participants',
			'...',
			);
			}

			protected function shouldShowOrderField() {
			return false;
			}

			protected function buildQueryFromParameters(array $map) {
			$query = $this->newQuery();
			if ($map['participants']) {
			$query->withParticipantPHIDs($map['participants']);
			}
			if ($map['fulltext']) {
			$query->withFulltext($map['fulltext']);
			}
			if ($map['phids']) {
			$query->withPHIDs($map['phids']);
			}
			return $query;
			}

			protected function getURI($path) {
			return '/conpherence/search/'.$path;
			}

			protected function getBuiltinQueryNames() {
			$names = array();

			$names['all'] = pht('All Rooms');

			if ($this->requireViewer()->isLoggedIn()) {
			$names['participant'] = pht('Joined Rooms');
			}

			return $names;
			}

			public function buildSavedQueryFromBuiltin($query_key) {

			$query = $this->newSavedQuery();
			$query->setQueryKey($query_key);

			switch ($query_key) {
			case 'all':
			return $query;
			case 'participant':
			return $query->setParameter(
			'participants',
			array($this->requireViewer()->getPHID()));
			}

			return parent::buildSavedQueryFromBuiltin($query_key);
			}

			protected function renderResultList(
			array $conpherences,
			PhabricatorSavedQuery $query,
			array $handles) {
			assert_instances_of($conpherences, 'ConpherenceThread');

			$viewer = $this->requireViewer();

			$policy_objects = ConpherenceThread::loadViewPolicyObjects(
			$viewer,
			$conpherences);

			$engines = array();

			$fulltext = $query->getParameter('fulltext');
			if (strlen($fulltext) && $conpherences) {
			$context = $this->loadContextMessages($conpherences, $fulltext);

			$author_phids = array();
			foreach ($context as $phid => $messages) {
			$conpherence = $conpherences[$phid];

			$engine = id(new PhabricatorMarkupEngine())
			->setViewer($viewer)
			->setContextObject($conpherence);

			foreach ($messages as $group) {
			foreach ($group as $message) {
			$xaction = $message['xaction'];
			if ($xaction) {
			$author_phids[] = $xaction->getAuthorPHID();
			$engine->addObject(
			$xaction->getComment(),
			PhabricatorApplicationTransactionComment::MARKUP_FIELD_COMMENT);
			}
			}
			}
			$engine->process();

			$engines[$phid] = $engine;
			}

			$handles = $viewer->loadHandles($author_phids);
			$handles = iterator_to_array($handles);
			} else {
			$context = array();
			}

			$content = array();
			$list = new PHUIObjectItemListView();
			$list->setUser($viewer);
			foreach ($conpherences as $conpherence_phid => $conpherence) {
			$created = phabricator_date($conpherence->getDateCreated(), $viewer);
			$title = $conpherence->getTitle();
			$monogram = $conpherence->getMonogram();

			$icon_name = $conpherence->getPolicyIconName($policy_objects);
			$icon = id(new PHUIIconView())
			->setIcon($icon_name);

			if (!strlen($fulltext)) {
			$item = id(new PHUIObjectItemView())
			->setObjectName($conpherence->getMonogram())
			->setHeader($title)
			->setHref('/'.$conpherence->getMonogram())
			->setObject($conpherence)
			->setImageURI($conpherence->getProfileImageURI())
			->addIcon('none', $created)
			->addIcon(
			'none',
			pht('Messages: %d', $conpherence->getMessageCount()))
			->addAttribute(
			array(
			$icon,
			' ',
			pht(
			'Last updated %s',
			phabricator_datetime($conpherence->getDateModified(), $viewer)),
			));
			$list->addItem($item);
			} else {
			$messages = idx($context, $conpherence_phid);
			$box = array();
			$list = null;
			if ($messages) {
			foreach ($messages as $group) {
			$rows = array();
			foreach ($group as $message) {
			$xaction = $message['xaction'];
			if (!$xaction) {
			continue;
			}

			$view = id(new ConpherenceTransactionView())
			->setUser($viewer)
			->setHandles($handles)
			->setMarkupEngine($engines[$conpherence_phid])
			->setConpherenceThread($conpherence)
			->setConpherenceTransaction($xaction)
			->setSearchResult(true)
			->addClass('conpherence-fulltext-result');

			if ($message['match']) {
			$view->addClass('conpherence-fulltext-match');
			}

			$rows[] = $view;
			}
			$box[] = id(new PHUIBoxView())
			->appendChild($rows)
			->addClass('conpherence-fulltext-results');
			}
			}
			$header = id(new PHUIHeaderView())
			->setHeader($title)
			->setHeaderIcon($icon_name)
			->setHref('/'.$monogram);

			$content[] = id(new PHUIObjectBoxView())
			->setHeader($header)
			->appendChild($box);
			}
			}

			if ($list) {
			$content = $list;
			} else {
			$content = id(new PHUIBoxView())
			->addClass('conpherence-search-room-results')
			->appendChild($content);
			}

			$result = new PhabricatorApplicationSearchResultView();
			$result->setContent($content);
			$result->setNoDataString(pht('No results found.'));

			return $result;
			}

			private function loadContextMessages(array $threads, $fulltext) {
			$phids = mpull($threads, 'getPHID');

			// We want to load a few messages for each thread in the result list, to
			// show some of the actual content hits to help the user find what they
			// are looking for.

			// This method is trying to batch this lookup in most cases, so we do
			// between one and "a handful" of queries instead of one per thread in
			// most cases. To do this:
			//
			// - Load a big block of results for all of the threads.
			// - If we didn't get a full block back, we have everything that matches
			// the query. Sort it out and exit.
			// - Otherwise, some threads had a ton of hits, so we might not be
			// getting everything we want (we could be getting back 1,000 hits for
			// the first thread). Remove any threads which we have enough results
			// for and try again.
			// - Repeat until we have everything or every thread has enough results.
			//
			// In the worst case, we could end up degrading to one query per thread,
			// but this is incredibly unlikely on real data.

			// Size of the result blocks we're going to load.
			$limit = 1000;

			// Number of messages we want for each thread.
			$want = 3;

			$need = $phids;
			$hits = array();
			while ($need) {
			$rows = id(new ConpherenceFulltextQuery())
			->withThreadPHIDs($need)
			->withFulltext($fulltext)
			->setLimit($limit)
			->execute();

			foreach ($rows as $row) {
			$hits[$row['threadPHID']][] = $row;
			}

			if (count($rows) < $limit) {
			break;
			}

			foreach ($need as $key => $phid) {
			if (count($hits[$phid]) >= $want) {
			unset($need[$key]);
			}
			}
			}

			// Now that we have all the fulltext matches, throw away any extras that we
			// aren't going to render so we don't need to do lookups on them.
			foreach ($hits as $phid => $rows) {
			if (count($rows) > $want) {
			$hits[$phid] = array_slice($rows, 0, $want);
			}
			}

			// For each fulltext match, we want to render a message before and after
			// the match to give it some context. We already know the transactions
			// before each match because the rows have a "previousTransactionPHID",
			// but we need to do one more query to figure out the transactions after
			// each match.

			// Collect the transactions we want to find the next transactions for.
			$after = array();
			foreach ($hits as $phid => $rows) {
			foreach ($rows as $row) {
			$after[] = $row['transactionPHID'];
			}
			}

			// Look up the next transactions.
			if ($after) {
			$after_rows = id(new ConpherenceFulltextQuery())
			->withPreviousTransactionPHIDs($after)
			->execute();
			} else {
			$after_rows = array();
			}

			// Build maps from PHIDs to the previous and next PHIDs.
			$prev_map = array();
			$next_map = array();
			foreach ($after_rows as $row) {
			$next_map[$row['previousTransactionPHID']] = $row['transactionPHID'];
			}

			foreach ($hits as $phid => $rows) {
			foreach ($rows as $row) {
			$prev = $row['previousTransactionPHID'];
			if ($prev) {
			$prev_map[$row['transactionPHID']] = $prev;
			$next_map[$prev] = $row['transactionPHID'];
			}
			}
			}

			// Now we're going to collect the actual transaction PHIDs, in order, that
			// we want to show for each thread.
			$groups = array();
			foreach ($hits as $thread_phid => $rows) {
			$rows = ipull($rows, null, 'transactionPHID');
			$done = array();
			foreach ($rows as $phid => $row) {
			if (isset($done[$phid])) {
			continue;
			}
			$done[$phid] = true;

			$group = array();

			// Walk backward, finding all the previous results. We can just keep
			// going until we run out of results because we've only loaded things
			// that we want to show.
			$prev = $phid;
			while (true) {
			if (!isset($prev_map[$prev])) {
			// No previous transaction, so we're done.
			break;
			}

			$prev = $prev_map[$prev];

			if (isset($rows[$prev])) {
			$match = true;
			$done[$prev] = true;
			} else {
			$match = false;
			}

			$group[] = array(
			'phid' => $prev,
			'match' => $match,
			);
			}

			if (count($group) > 1) {
			$group = array_reverse($group);
			}

			$group[] = array(
			'phid' => $phid,
			'match' => true,
			);

			$next = $phid;
			while (true) {
			if (!isset($next_map[$next])) {
			break;
			}

			$next = $next_map[$next];

			if (isset($rows[$next])) {
			$match = true;
			$done[$next] = true;
			} else {
			$match = false;
			}

			$group[] = array(
			'phid' => $next,
			'match' => $match,
			);
			}

			$groups[$thread_phid][] = $group;
			}
			}

			// Load all the actual transactions we need.
			$xaction_phids = array();
			foreach ($groups as $thread_phid => $group) {
			foreach ($group as $list) {
			foreach ($list as $item) {
			$xaction_phids[] = $item['phid'];
			}
			}
			}

			if ($xaction_phids) {
			$xactions = id(new ConpherenceTransactionQuery())
			->setViewer($this->requireViewer())
			->withPHIDs($xaction_phids)
			->needComments(true)
			->execute();
			$xactions = mpull($xactions, null, 'getPHID');
			} else {
			$xactions = array();
			}

			foreach ($groups as $thread_phid => $group) {
			foreach ($group as $key => $list) {
			foreach ($list as $lkey => $item) {
			$xaction = idx($xactions, $item['phid']);
			if ($xaction->shouldHide()) {
			continue;
			}
			$groups[$thread_phid][$key][$lkey]['xaction'] = $xaction;
			}
			}
			}

			// TODO: Sort the groups chronologically?

			return $groups;
			}

			}

phab/src/applications/conpherence/query/ConpherenceThreadSearchEngine.php8567e3cacaa3feature/testing

ConpherenceThreadSearchEngine.phpView Options

phab/src/applications/conpherence/query/ConpherenceThreadSearchEngine.php
8567e3cacaa3feature/testing

ConpherenceThreadSearchEngine.php
View Options