No OneTemporary
Actions

Size

71 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/diffusion/controller/DiffusionLastModifiedController.php b/src/applications/diffusion/controller/DiffusionLastModifiedController.php
	index 0fea238249..8a4debfcea 100644
	--- a/src/applications/diffusion/controller/DiffusionLastModifiedController.php
	+++ b/src/applications/diffusion/controller/DiffusionLastModifiedController.php
	@@ -1,168 +1,168 @@
	<?php

	final class DiffusionLastModifiedController extends DiffusionController {

	public function shouldAllowPublic() {
	return true;
	}

	public function handleRequest(AphrontRequest $request) {
	$response = $this->loadDiffusionContext();
	if ($response) {
	return $response;
	}

	$viewer = $this->getViewer();
	$drequest = $this->getDiffusionRequest();

	$paths = $request->getStr('paths');
	try {
	$paths = phutil_json_decode($paths);
	} catch (PhutilJSONParserException $ex) {
	return new Aphront400Response();
	}

	$modified_map = $this->callConduitWithDiffusionRequest(
	'diffusion.lastmodifiedquery',
	array(
	'paths' => array_fill_keys($paths, $drequest->getCommit()),
	));

	if ($modified_map) {
	$commit_map = id(new DiffusionCommitQuery())
	->setViewer($viewer)
	->withRepository($drequest->getRepository())
	->withIdentifiers(array_values($modified_map))
	->needCommitData(true)
	->execute();
	$commit_map = mpull($commit_map, null, 'getCommitIdentifier');
	} else {
	$commit_map = array();
	}

	$commits = array();
	foreach ($paths as $path) {
	$modified_at = idx($modified_map, $path);
	if ($modified_at) {
	$commit = idx($commit_map, $modified_at);
	if ($commit) {
	$commits[$path] = $commit;
	}
	}
	}

	$phids = array();
	foreach ($commits as $commit) {
	$data = $commit->getCommitData();
	$phids[] = $data->getCommitDetail('authorPHID');
	$phids[] = $data->getCommitDetail('committerPHID');
	}
	$phids = array_filter($phids);
	$handles = $this->loadViewerHandles($phids);

	$branch = $drequest->loadBranch();
	if ($branch && $commits) {
	$lint_query = id(new DiffusionLintCountQuery())
	->withBranchIDs(array($branch->getID()))
	->withPaths(array_keys($commits));

	if ($drequest->getLint()) {
	$lint_query->withCodes(array($drequest->getLint()));
	}

	$lint = $lint_query->execute();
	} else {
	$lint = array();
	}

	$output = array();
	foreach ($commits as $path => $commit) {
	$prequest = clone $drequest;
	$prequest->setPath($path);

	$output[$path] = $this->renderColumns(
	$prequest,
	$handles,
	$commit,
	idx($lint, $path));
	}

	return id(new AphrontAjaxResponse())->setContent($output);
	}

	private function renderColumns(
	DiffusionRequest $drequest,
	array $handles,
	PhabricatorRepositoryCommit $commit = null,
	$lint = null) {
	assert_instances_of($handles, 'PhabricatorObjectHandle');
	$viewer = $this->getRequest()->getUser();

	if ($commit) {
	$epoch = $commit->getEpoch();
	$modified = DiffusionView::linkCommit(
	$drequest->getRepository(),
	$commit->getCommitIdentifier());
	- $date = phabricator_datetime($epoch, $viewer);
	+ $date = $viewer->formatShortDateTime($epoch);
	} else {
	$modified = '';
	$date = '';
	}

	$data = $commit->getCommitData();
	if ($data) {
	$author_phid = $data->getCommitDetail('authorPHID');
	if ($author_phid && isset($handles[$author_phid])) {
	$author = $handles[$author_phid]->renderLink();
	} else {
	$author = DiffusionView::renderName($data->getAuthorName());
	}

	$committer = $data->getCommitDetail('committer');
	if ($committer) {
	$committer_phid = $data->getCommitDetail('committerPHID');
	if ($committer_phid && isset($handles[$committer_phid])) {
	$committer = $handles[$committer_phid]->renderLink();
	} else {
	$committer = DiffusionView::renderName($committer);
	}
	if ($author != $committer) {
	$author = hsprintf('%s/%s', $author, $committer);
	}
	}

	$details = AphrontTableView::renderSingleDisplayLine($data->getSummary());
	} else {
	$author = '';
	$details = '';
	}

	$return = array(
	'commit' => $modified,
	'date' => $date,
	'author' => $author,
	'details' => $details,
	);

	if ($lint !== null) {
	$return['lint'] = phutil_tag(
	'a',
	array(
	'href' => $drequest->generateURI(array(
	'action' => 'lint',
	'lint' => null,
	)),
	),
	number_format($lint));
	}

	// The client treats these results as markup, so make sure they have been
	// escaped correctly.
	foreach ($return as $key => $value) {
	$return[$key] = hsprintf('%s', $value);
	}

	return $return;
	}

	}
	diff --git a/src/applications/diffusion/view/DiffusionBranchTableView.php b/src/applications/diffusion/view/DiffusionBranchTableView.php
	index 462f296bcb..b75228a0ce 100644
	--- a/src/applications/diffusion/view/DiffusionBranchTableView.php
	+++ b/src/applications/diffusion/view/DiffusionBranchTableView.php
	@@ -1,165 +1,165 @@
	<?php

	final class DiffusionBranchTableView extends DiffusionView {

	private $branches;
	private $commits = array();

	public function setBranches(array $branches) {
	assert_instances_of($branches, 'DiffusionRepositoryRef');
	$this->branches = $branches;
	return $this;
	}

	public function setCommits(array $commits) {
	assert_instances_of($commits, 'PhabricatorRepositoryCommit');
	$this->commits = mpull($commits, null, 'getCommitIdentifier');
	return $this;
	}

	public function render() {
	$drequest = $this->getDiffusionRequest();
	$current_branch = $drequest->getBranch();
	$repository = $drequest->getRepository();
	$commits = $this->commits;
	$viewer = $this->getUser();

	$buildables = $this->loadBuildables($commits);
	$have_builds = false;

	$can_close_branches = ($repository->isHg());

	Javelin::initBehavior('phabricator-tooltips');

	$doc_href = PhabricatorEnv::getDoclink('Diffusion User Guide: Autoclose');

	$rows = array();
	$rowc = array();
	foreach ($this->branches as $branch) {
	$commit = idx($commits, $branch->getCommitIdentifier());
	if ($commit) {
	$details = $commit->getSummary();
	- $datetime = phabricator_datetime($commit->getEpoch(), $viewer);
	+ $datetime = $viewer->formatShortDateTime($commit->getEpoch());
	$buildable = idx($buildables, $commit->getPHID());
	if ($buildable) {
	$build_status = $this->renderBuildable($buildable);
	$have_builds = true;
	} else {
	$build_status = null;
	}
	} else {
	$datetime = null;
	$details = null;
	$build_status = null;
	}

	switch ($repository->shouldSkipAutocloseBranch($branch->getShortName())) {
	case PhabricatorRepository::BECAUSE_REPOSITORY_IMPORTING:
	$icon = 'fa-times bluegrey';
	$tip = pht('Repository Importing');
	break;
	case PhabricatorRepository::BECAUSE_AUTOCLOSE_DISABLED:
	$icon = 'fa-times bluegrey';
	$tip = pht('Repository Autoclose Disabled');
	break;
	case PhabricatorRepository::BECAUSE_BRANCH_UNTRACKED:
	$icon = 'fa-times bluegrey';
	$tip = pht('Branch Untracked');
	break;
	case PhabricatorRepository::BECAUSE_BRANCH_NOT_AUTOCLOSE:
	$icon = 'fa-times bluegrey';
	$tip = pht('Branch Autoclose Disabled');
	break;
	case null:
	$icon = 'fa-check bluegrey';
	$tip = pht('Autoclose Enabled');
	break;
	default:
	$icon = 'fa-question';
	$tip = pht('Status Unknown');
	break;
	}

	$status_icon = id(new PHUIIconView())
	->setIcon($icon)
	->addSigil('has-tooltip')
	->setHref($doc_href)
	->setMetadata(
	array(
	'tip' => $tip,
	'size' => 200,
	));

	$fields = $branch->getRawFields();
	$closed = idx($fields, 'closed');
	if ($closed) {
	$status = pht('Closed');
	} else {
	$status = pht('Open');
	}

	$rows[] = array(
	$this->linkBranchHistory($branch->getShortName()),
	phutil_tag(
	'a',
	array(
	'href' => $drequest->generateURI(
	array(
	'action' => 'browse',
	'branch' => $branch->getShortName(),
	)),
	),
	$branch->getShortName()),
	self::linkCommit(
	$drequest->getRepository(),
	$branch->getCommitIdentifier()),
	$build_status,
	$status,
	AphrontTableView::renderSingleDisplayLine($details),
	$status_icon,
	$datetime,
	);
	if ($branch->getShortName() == $current_branch) {
	$rowc[] = 'highlighted';
	} else {
	$rowc[] = null;
	}
	}

	$view = new AphrontTableView($rows);
	$view->setHeaders(
	array(
	null,
	pht('Branch'),
	pht('Head'),
	null,
	pht('State'),
	pht('Details'),
	null,
	pht('Committed'),
	));
	$view->setColumnClasses(
	array(
	'',
	'pri',
	'',
	'icon',
	'',
	'wide',
	'',
	- '',
	+ 'right',
	));
	$view->setColumnVisibility(
	array(
	true,
	true,
	true,
	$have_builds,
	$can_close_branches,
	));
	$view->setRowClasses($rowc);
	return $view->render();
	}


	}
	diff --git a/src/applications/diffusion/view/DiffusionBrowseTableView.php b/src/applications/diffusion/view/DiffusionBrowseTableView.php
	index fa5342ad9d..ffc5ce61ed 100644
	--- a/src/applications/diffusion/view/DiffusionBrowseTableView.php
	+++ b/src/applications/diffusion/view/DiffusionBrowseTableView.php
	@@ -1,158 +1,158 @@
	<?php

	final class DiffusionBrowseTableView extends DiffusionView {

	private $paths;
	private $handles = array();

	public function setPaths(array $paths) {
	assert_instances_of($paths, 'DiffusionRepositoryPath');
	$this->paths = $paths;
	return $this;
	}

	public function setHandles(array $handles) {
	assert_instances_of($handles, 'PhabricatorObjectHandle');
	$this->handles = $handles;
	return $this;
	}

	public function render() {
	$request = $this->getDiffusionRequest();
	$repository = $request->getRepository();

	$base_path = trim($request->getPath(), '/');
	if ($base_path) {
	$base_path = $base_path.'/';
	}

	$need_pull = array();
	$rows = array();
	$show_edit = false;
	foreach ($this->paths as $path) {
	$full_path = $base_path.$path->getPath();

	$dir_slash = null;
	$file_type = $path->getFileType();
	if ($file_type == DifferentialChangeType::FILE_DIRECTORY) {
	$browse_text = $path->getPath().'/';
	$dir_slash = '/';

	$browse_link = phutil_tag('strong', array(), $this->linkBrowse(
	$full_path.$dir_slash,
	array(
	'type' => $file_type,
	'name' => $browse_text,
	)));

	$history_path = $full_path.'/';
	} else if ($file_type == DifferentialChangeType::FILE_SUBMODULE) {
	$browse_text = $path->getPath().'/';
	$browse_link = phutil_tag('strong', array(), $this->linkBrowse(
	null,
	array(
	'type' => $file_type,
	'name' => $browse_text,
	'hash' => $path->getHash(),
	'external' => $path->getExternalURI(),
	)));

	$history_path = $full_path.'/';
	} else {
	$browse_text = $path->getPath();
	$browse_link = $this->linkBrowse(
	$full_path,
	array(
	'type' => $file_type,
	'name' => $browse_text,
	));

	$history_path = $full_path;
	}

	$history_link = $this->linkHistory($history_path);

	$dict = array(
	'lint' => celerity_generate_unique_node_id(),
	'commit' => celerity_generate_unique_node_id(),
	'date' => celerity_generate_unique_node_id(),
	'author' => celerity_generate_unique_node_id(),
	'details' => celerity_generate_unique_node_id(),
	);

	$need_pull[$full_path.$dir_slash] = $dict;
	foreach ($dict as $k => $uniq) {
	$dict[$k] = phutil_tag('span', array('id' => $uniq), '');
	}

	$rows[] = array(
	$history_link,
	$browse_link,
	idx($dict, 'lint'),
	$dict['commit'],
	$dict['details'],
	$dict['date'],
	);
	}

	if ($need_pull) {
	Javelin::initBehavior(
	'diffusion-pull-lastmodified',
	array(
	'uri' => (string)$request->generateURI(
	array(
	'action' => 'lastmodified',
	'stable' => true,
	)),
	'map' => $need_pull,
	));
	}

	$branch = $this->getDiffusionRequest()->loadBranch();
	$show_lint = ($branch && $branch->getLintCommit());
	$lint = $request->getLint();

	$view = new AphrontTableView($rows);
	$view->setHeaders(
	array(
	null,
	pht('Path'),
	($lint ? $lint : pht('Lint')),
	pht('Modified'),
	pht('Details'),
	pht('Committed'),
	));
	$view->setColumnClasses(
	array(
	'nudgeright',
	'',
	'',
	'',
	'wide',
	- '',
	+ 'right',
	));
	$view->setColumnVisibility(
	array(
	true,
	true,
	$show_lint,
	true,
	true,
	true,
	));

	$view->setDeviceVisibility(
	array(
	true,
	true,
	false,
	false,
	true,
	false,
	));


	return $view->render();
	}

	}
	diff --git a/src/applications/diffusion/view/DiffusionHistoryTableView.php b/src/applications/diffusion/view/DiffusionHistoryTableView.php
	index e62c4382c9..a9fb34e683 100644
	--- a/src/applications/diffusion/view/DiffusionHistoryTableView.php
	+++ b/src/applications/diffusion/view/DiffusionHistoryTableView.php
	@@ -1,384 +1,384 @@
	<?php

	final class DiffusionHistoryTableView extends DiffusionView {

	private $history;
	private $revisions = array();
	private $handles = array();
	private $isHead;
	private $isTail;
	private $parents;

	public function setHistory(array $history) {
	assert_instances_of($history, 'DiffusionPathChange');
	$this->history = $history;
	return $this;
	}

	public function loadRevisions() {
	$commit_phids = array();
	foreach ($this->history as $item) {
	if ($item->getCommit()) {
	$commit_phids[] = $item->getCommit()->getPHID();
	}
	}

	// TODO: Get rid of this.
	$this->revisions = id(new DifferentialRevision())
	->loadIDsByCommitPHIDs($commit_phids);
	return $this;
	}

	public function setHandles(array $handles) {
	assert_instances_of($handles, 'PhabricatorObjectHandle');
	$this->handles = $handles;
	return $this;
	}

	private function getRequiredHandlePHIDs() {
	$phids = array();
	foreach ($this->history as $item) {
	$data = $item->getCommitData();
	if ($data) {
	if ($data->getCommitDetail('authorPHID')) {
	$phids[$data->getCommitDetail('authorPHID')] = true;
	}
	if ($data->getCommitDetail('committerPHID')) {
	$phids[$data->getCommitDetail('committerPHID')] = true;
	}
	}
	}
	return array_keys($phids);
	}

	public function setParents(array $parents) {
	$this->parents = $parents;
	return $this;
	}

	public function setIsHead($is_head) {
	$this->isHead = $is_head;
	return $this;
	}

	public function setIsTail($is_tail) {
	$this->isTail = $is_tail;
	return $this;
	}

	public function render() {
	$drequest = $this->getDiffusionRequest();

	$viewer = $this->getUser();

	$buildables = $this->loadBuildables(mpull($this->history, 'getCommit'));
	$has_any_build = false;

	$show_revisions = PhabricatorApplication::isClassInstalledForViewer(
	'PhabricatorDifferentialApplication',
	$viewer);

	$handles = $viewer->loadHandles($this->getRequiredHandlePHIDs());

	$graph = null;
	if ($this->parents) {
	$graph = $this->renderGraph();
	}

	$show_builds = PhabricatorApplication::isClassInstalledForViewer(
	'PhabricatorHarbormasterApplication',
	$this->getUser());

	$rows = array();
	$ii = 0;
	foreach ($this->history as $history) {
	$epoch = $history->getEpoch();

	if ($epoch) {
	- $committed = phabricator_datetime($epoch, $viewer);
	+ $committed = $viewer->formatShortDateTime($epoch);
	} else {
	$committed = null;
	}

	$data = $history->getCommitData();
	$author_phid = $committer = $committer_phid = null;
	if ($data) {
	$author_phid = $data->getCommitDetail('authorPHID');
	$committer_phid = $data->getCommitDetail('committerPHID');
	$committer = $data->getCommitDetail('committer');
	}

	if ($author_phid && isset($handles[$author_phid])) {
	$author = $handles[$author_phid]->renderLink();
	} else {
	$author = self::renderName($history->getAuthorName());
	}

	$different_committer = false;
	if ($committer_phid) {
	$different_committer = ($committer_phid != $author_phid);
	} else if ($committer != '') {
	$different_committer = ($committer != $history->getAuthorName());
	}
	if ($different_committer) {
	if ($committer_phid && isset($handles[$committer_phid])) {
	$committer = $handles[$committer_phid]->renderLink();
	} else {
	$committer = self::renderName($committer);
	}
	$author = hsprintf('%s/%s', $author, $committer);
	}

	// We can show details once the message and change have been imported.
	$partial_import = PhabricatorRepositoryCommit::IMPORTED_MESSAGE \|
	PhabricatorRepositoryCommit::IMPORTED_CHANGE;

	$commit = $history->getCommit();
	if ($commit && $commit->isPartiallyImported($partial_import) && $data) {
	$summary = AphrontTableView::renderSingleDisplayLine(
	$history->getSummary());
	} else {
	$summary = phutil_tag('em', array(), pht("Importing\xE2\x80\xA6"));
	}

	$build = null;
	if ($show_builds) {
	$buildable = idx($buildables, $commit->getPHID());
	if ($buildable !== null) {
	$build = $this->renderBuildable($buildable);
	$has_any_build = true;
	}
	}

	$browse = $this->linkBrowse(
	$history->getPath(),
	array(
	'commit' => $history->getCommitIdentifier(),
	'branch' => $drequest->getBranch(),
	'type' => $history->getFileType(),
	));

	$rows[] = array(
	$graph ? $graph[$ii++] : null,
	$browse,
	self::linkCommit(
	$drequest->getRepository(),
	$history->getCommitIdentifier()),
	$build,
	($commit ?
	self::linkRevision(idx($this->revisions, $commit->getPHID())) :
	null),
	$author,
	$summary,
	$committed,
	);
	}

	$view = new AphrontTableView($rows);
	$view->setHeaders(
	array(
	null,
	null,
	pht('Commit'),
	null,
	null,
	pht('Author/Committer'),
	pht('Details'),
	pht('Committed'),
	));
	$view->setColumnClasses(
	array(
	'threads',
	'nudgeright',
	'',
	'icon',
	'',
	'',
	'wide',
	- '',
	+ 'right',
	));
	$view->setColumnVisibility(
	array(
	$graph ? true : false,
	true,
	true,
	$has_any_build,
	$show_revisions,
	));
	$view->setDeviceVisibility(
	array(
	$graph ? true : false,
	true,
	true,
	true,
	true,
	false,
	true,
	false,
	));
	return $view->render();
	}

	/**
	* Draw a merge/branch graph from the parent revision data. We're basically
	* building up a bunch of strings like this:
	*
	* ^
	* \|^
	* o\|
	* \|o
	* o
	*
	* ...which form an ASCII representation of the graph we eventually want to
	* draw.
	*
	* NOTE: The actual implementation is black magic.
	*/
	private function renderGraph() {
	// This keeps our accumulated information about each line of the
	// merge/branch graph.
	$graph = array();

	// This holds the next commit we're looking for in each column of the
	// graph.
	$threads = array();

	// This is the largest number of columns any row has, i.e. the width of
	// the graph.
	$count = 0;

	foreach ($this->history as $key => $history) {
	$joins = array();
	$splits = array();

	$parent_list = $this->parents[$history->getCommitIdentifier()];

	// Look for some thread which has this commit as the next commit. If
	// we find one, this commit goes on that thread. Otherwise, this commit
	// goes on a new thread.

	$line = '';
	$found = false;
	$pos = count($threads);
	for ($n = 0; $n < $count; $n++) {
	if (empty($threads[$n])) {
	$line .= ' ';
	continue;
	}

	if ($threads[$n] == $history->getCommitIdentifier()) {
	if ($found) {
	$line .= ' ';
	$joins[] = $n;
	unset($threads[$n]);
	} else {
	$line .= 'o';
	$found = true;
	$pos = $n;
	}
	} else {

	// We render a "\|" for any threads which have a commit that we haven't
	// seen yet, this is later drawn as a vertical line.
	$line .= '\|';
	}
	}

	// If we didn't find the thread this commit goes on, start a new thread.
	// We use "o" to mark the commit for the rendering engine, or "^" to
	// indicate that there's nothing after it so the line from the commit
	// upward should not be drawn.

	if (!$found) {
	if ($this->isHead) {
	$line .= '^';
	} else {
	$line .= 'o';
	foreach ($graph as $k => $meta) {
	// Go back across all the lines we've already drawn and add a
	// "\|" to the end, since this is connected to some future commit
	// we don't know about.
	for ($jj = strlen($meta['line']); $jj <= $count; $jj++) {
	$graph[$k]['line'] .= '\|';
	}
	}
	}
	}

	// Update the next commit on this thread to the commit's first parent.
	// This might have the effect of making a new thread.
	$threads[$pos] = head($parent_list);

	// If we made a new thread, increase the thread count.
	$count = max($pos + 1, $count);

	// Now, deal with splits (merges). I picked this terms opposite to the
	// underlying repository term to confuse you.
	foreach (array_slice($parent_list, 1) as $parent) {
	$found = false;

	// Try to find the other parent(s) in our existing threads. If we find
	// them, split to that thread.

	foreach ($threads as $idx => $thread_commit) {
	if ($thread_commit == $parent) {
	$found = true;
	$splits[] = $idx;
	}
	}

	// If we didn't find the parent, we don't know about it yet. Find the
	// first free thread and add it as the "next" commit in that thread.
	// This might create a new thread.

	if (!$found) {
	for ($n = 0; $n < $count; $n++) {
	if (empty($threads[$n])) {
	break;
	}
	}
	$threads[$n] = $parent;
	$splits[] = $n;
	$count = max($n + 1, $count);
	}
	}

	$graph[] = array(
	'line' => $line,
	'split' => $splits,
	'join' => $joins,
	);
	}

	// If this is the last page in history, replace the "o" with an "x" so we
	// do not draw a connecting line downward, and replace "^" with an "X" for
	// repositories with exactly one commit.
	if ($this->isTail && $graph) {
	$last = array_pop($graph);
	$last['line'] = str_replace('o', 'x', $last['line']);
	$last['line'] = str_replace('^', 'X', $last['line']);
	$graph[] = $last;
	}

	// Render into tags for the behavior.

	foreach ($graph as $k => $meta) {
	$graph[$k] = javelin_tag(
	'div',
	array(
	'sigil' => 'commit-graph',
	'meta' => $meta,
	),
	'');
	}

	Javelin::initBehavior(
	'diffusion-commit-graph',
	array(
	'count' => $count,
	));

	return $graph;
	}

	}
	diff --git a/src/applications/diffusion/view/DiffusionPushLogListView.php b/src/applications/diffusion/view/DiffusionPushLogListView.php
	index 7cc02a49b4..73a44794e8 100644
	--- a/src/applications/diffusion/view/DiffusionPushLogListView.php
	+++ b/src/applications/diffusion/view/DiffusionPushLogListView.php
	@@ -1,128 +1,128 @@
	<?php

	final class DiffusionPushLogListView extends AphrontView {

	private $logs;
	private $handles;

	public function setLogs(array $logs) {
	assert_instances_of($logs, 'PhabricatorRepositoryPushLog');
	$this->logs = $logs;
	return $this;
	}

	public function setHandles(array $handles) {
	$this->handles = $handles;
	return $this;
	}

	public function render() {
	$logs = $this->logs;
	$viewer = $this->getUser();
	$handles = $this->handles;

	// Figure out which repositories are editable. We only let you see remote
	// IPs if you have edit capability on a repository.
	$editable_repos = array();
	if ($logs) {
	$editable_repos = id(new PhabricatorRepositoryQuery())
	->setViewer($viewer)
	->requireCapabilities(
	array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	))
	->withPHIDs(mpull($logs, 'getRepositoryPHID'))
	->execute();
	$editable_repos = mpull($editable_repos, null, 'getPHID');
	}

	$rows = array();
	foreach ($logs as $log) {
	$repository = $log->getRepository();

	// Reveal this if it's valid and the user can edit the repository.
	$remote_address = '-';
	if (isset($editable_repos[$log->getRepositoryPHID()])) {
	$remote_address = $log->getPushEvent()->getRemoteAddress();
	}

	$event_id = $log->getPushEvent()->getID();

	$old_ref_link = null;
	if ($log->getRefOld() != DiffusionCommitHookEngine::EMPTY_HASH) {
	$old_ref_link = phutil_tag(
	'a',
	array(
	'href' => $repository->getCommitURI($log->getRefOld()),
	),
	$log->getRefOldShort());
	}

	$rows[] = array(
	phutil_tag(
	'a',
	array(
	'href' => '/diffusion/pushlog/view/'.$event_id.'/',
	),
	$event_id),
	phutil_tag(
	'a',
	array(
	'href' => $repository->getURI(),
	),
	$repository->getDisplayName()),
	$handles[$log->getPusherPHID()]->renderLink(),
	$remote_address,
	$log->getPushEvent()->getRemoteProtocol(),
	$log->getRefType(),
	$log->getRefName(),
	$old_ref_link,
	phutil_tag(
	'a',
	array(
	'href' => $repository->getCommitURI($log->getRefNew()),
	),
	$log->getRefNewShort()),

	// TODO: Make these human-readable.
	$log->getChangeFlags(),
	$log->getPushEvent()->getRejectCode(),
	- phabricator_datetime($log->getEpoch(), $viewer),
	+ $viewer->formatShortDateTime($log->getEpoch()),
	);
	}

	$table = id(new AphrontTableView($rows))
	->setHeaders(
	array(
	pht('Push'),
	pht('Repository'),
	pht('Pusher'),
	pht('From'),
	pht('Via'),
	pht('Type'),
	pht('Name'),
	pht('Old'),
	pht('New'),
	pht('Flags'),
	pht('Code'),
	pht('Date'),
	))
	->setColumnClasses(
	array(
	'',
	'',
	'',
	'',
	'',
	'',
	'wide',
	'n',
	'n',
	- 'date',
	+ 'right',
	));

	return $table;
	}

	}
	diff --git a/src/applications/diffusion/view/DiffusionTagListView.php b/src/applications/diffusion/view/DiffusionTagListView.php
	index 923fa30fc5..df59925522 100644
	--- a/src/applications/diffusion/view/DiffusionTagListView.php
	+++ b/src/applications/diffusion/view/DiffusionTagListView.php
	@@ -1,138 +1,140 @@
	<?php

	final class DiffusionTagListView extends DiffusionView {

	private $tags;
	private $commits = array();
	private $handles = array();

	public function setTags($tags) {
	$this->tags = $tags;
	return $this;
	}

	public function setCommits(array $commits) {
	$this->commits = mpull($commits, null, 'getCommitIdentifier');
	return $this;
	}

	public function setHandles(array $handles) {
	$this->handles = $handles;
	return $this;
	}

	public function getRequiredHandlePHIDs() {
	return array_filter(mpull($this->commits, 'getAuthorPHID'));
	}

	public function render() {
	$drequest = $this->getDiffusionRequest();
	$repository = $drequest->getRepository();
	+ $viewer = $this->getViewer();

	$buildables = $this->loadBuildables($this->commits);
	$has_builds = false;

	$rows = array();
	foreach ($this->tags as $tag) {
	$commit = idx($this->commits, $tag->getCommitIdentifier());

	$tag_link = phutil_tag(
	'a',
	array(
	'href' => $drequest->generateURI(
	array(
	'action' => 'browse',
	'commit' => $tag->getName(),
	)),
	),
	$tag->getName());

	$commit_link = phutil_tag(
	'a',
	array(
	'href' => $drequest->generateURI(
	array(
	'action' => 'commit',
	'commit' => $tag->getCommitIdentifier(),
	)),
	),
	$repository->formatCommitName(
	$tag->getCommitIdentifier()));

	$author = null;
	if ($commit && $commit->getAuthorPHID()) {
	$author = $this->handles[$commit->getAuthorPHID()]->renderLink();
	} else if ($commit && $commit->getCommitData()) {
	$author = self::renderName($commit->getCommitData()->getAuthorName());
	} else {
	$author = self::renderName($tag->getAuthor());
	}

	$description = null;
	if ($tag->getType() == 'git/tag') {
	// In Git, a tag may be a "real" tag, or just a reference to a commit.
	// If it's a real tag, use the message on the tag, since this may be
	// unique data which isn't otherwise available.
	$description = $tag->getDescription();
	} else {
	if ($commit) {
	$description = $commit->getSummary();
	} else {
	$description = $tag->getDescription();
	}
	}

	$build = null;
	if ($commit) {
	$buildable = idx($buildables, $commit->getPHID());
	if ($buildable) {
	$build = $this->renderBuildable($buildable);
	$has_builds = true;
	}
	}

	$history = $this->linkTagHistory($tag->getName());

	$rows[] = array(
	$history,
	$tag_link,
	$commit_link,
	$build,
	$author,
	$description,
	- phabricator_datetime($tag->getEpoch(), $this->getViewer()),
	+ $viewer->formatShortDateTime($tag->getEpoch()),
	);
	}

	$table = id(new AphrontTableView($rows))
	->setHeaders(
	array(
	null,
	pht('Tag'),
	pht('Commit'),
	null,
	pht('Author'),
	pht('Description'),
	pht('Created'),
	))
	->setColumnClasses(
	array(
	'nudgeright',
	'pri',
	'',
	'',
	'',
	'wide',
	+ 'right',
	))
	->setColumnVisibility(
	array(
	true,
	true,
	true,
	$has_builds,
	));

	return $table->render();
	}

	}
	diff --git a/src/applications/people/storage/PhabricatorUser.php b/src/applications/people/storage/PhabricatorUser.php
	index 07c5695945..ed6fceba1e 100644
	--- a/src/applications/people/storage/PhabricatorUser.php
	+++ b/src/applications/people/storage/PhabricatorUser.php
	@@ -1,1329 +1,1361 @@
	<?php

	/**
	* @task availability Availability
	* @task image-cache Profile Image Cache
	* @task factors Multi-Factor Authentication
	* @task handles Managing Handles
	*/
	final class PhabricatorUser
	extends PhabricatorUserDAO
	implements
	PhutilPerson,
	PhabricatorPolicyInterface,
	PhabricatorCustomFieldInterface,
	PhabricatorDestructibleInterface,
	PhabricatorSSHPublicKeyInterface,
	PhabricatorFlaggableInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorFulltextInterface {

	const SESSION_TABLE = 'phabricator_session';
	const NAMETOKEN_TABLE = 'user_nametoken';
	const MAXIMUM_USERNAME_LENGTH = 64;

	protected $userName;
	protected $realName;
	protected $sex;
	protected $translation;
	protected $passwordSalt;
	protected $passwordHash;
	protected $profileImagePHID;
	protected $profileImageCache;
	protected $availabilityCache;
	protected $availabilityCacheTTL;
	protected $timezoneIdentifier = '';

	protected $consoleEnabled = 0;
	protected $consoleVisible = 0;
	protected $consoleTab = '';

	protected $conduitCertificate;

	protected $isSystemAgent = 0;
	protected $isMailingList = 0;
	protected $isAdmin = 0;
	protected $isDisabled = 0;
	protected $isEmailVerified = 0;
	protected $isApproved = 0;
	protected $isEnrolledInMultiFactor = 0;

	protected $accountSecret;

	private $profileImage = self::ATTACHABLE;
	private $profile = null;
	private $availability = self::ATTACHABLE;
	private $preferences = null;
	private $omnipotent = false;
	private $customFields = self::ATTACHABLE;
	private $badgePHIDs = self::ATTACHABLE;

	private $alternateCSRFString = self::ATTACHABLE;
	private $session = self::ATTACHABLE;

	private $authorities = array();
	private $handlePool;
	private $csrfSalt;

	protected function readField($field) {
	switch ($field) {
	case 'timezoneIdentifier':
	// If the user hasn't set one, guess the server's time.
	return nonempty(
	$this->timezoneIdentifier,
	date_default_timezone_get());
	// Make sure these return booleans.
	case 'isAdmin':
	return (bool)$this->isAdmin;
	case 'isDisabled':
	return (bool)$this->isDisabled;
	case 'isSystemAgent':
	return (bool)$this->isSystemAgent;
	case 'isMailingList':
	return (bool)$this->isMailingList;
	case 'isEmailVerified':
	return (bool)$this->isEmailVerified;
	case 'isApproved':
	return (bool)$this->isApproved;
	default:
	return parent::readField($field);
	}
	}


	/**
	* Is this a live account which has passed required approvals? Returns true
	* if this is an enabled, verified (if required), approved (if required)
	* account, and false otherwise.
	*
	* @return bool True if this is a standard, usable account.
	*/
	public function isUserActivated() {
	if ($this->isOmnipotent()) {
	return true;
	}

	if ($this->getIsDisabled()) {
	return false;
	}

	if (!$this->getIsApproved()) {
	return false;
	}

	if (PhabricatorUserEmail::isEmailVerificationRequired()) {
	if (!$this->getIsEmailVerified()) {
	return false;
	}
	}

	return true;
	}

	public function canEstablishWebSessions() {
	if ($this->getIsMailingList()) {
	return false;
	}

	if ($this->getIsSystemAgent()) {
	return false;
	}

	return true;
	}

	public function canEstablishAPISessions() {
	if (!$this->isUserActivated()) {
	return false;
	}

	if ($this->getIsMailingList()) {
	return false;
	}

	return true;
	}

	public function canEstablishSSHSessions() {
	if (!$this->isUserActivated()) {
	return false;
	}

	if ($this->getIsMailingList()) {
	return false;
	}

	return true;
	}

	/**
	* Returns `true` if this is a standard user who is logged in. Returns `false`
	* for logged out, anonymous, or external users.
	*
	* @return bool `true` if the user is a standard user who is logged in with
	* a normal session.
	*/
	public function getIsStandardUser() {
	$type_user = PhabricatorPeopleUserPHIDType::TYPECONST;
	return $this->getPHID() && (phid_get_type($this->getPHID()) == $type_user);
	}

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'userName' => 'sort64',
	'realName' => 'text128',
	'sex' => 'text4?',
	'translation' => 'text64?',
	'passwordSalt' => 'text32?',
	'passwordHash' => 'text128?',
	'profileImagePHID' => 'phid?',
	'consoleEnabled' => 'bool',
	'consoleVisible' => 'bool',
	'consoleTab' => 'text64',
	'conduitCertificate' => 'text255',
	'isSystemAgent' => 'bool',
	'isMailingList' => 'bool',
	'isDisabled' => 'bool',
	'isAdmin' => 'bool',
	'timezoneIdentifier' => 'text255',
	'isEmailVerified' => 'uint32',
	'isApproved' => 'uint32',
	'accountSecret' => 'bytes64',
	'isEnrolledInMultiFactor' => 'bool',
	'profileImageCache' => 'text255?',
	'availabilityCache' => 'text255?',
	'availabilityCacheTTL' => 'uint32?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'key_phid' => null,
	'phid' => array(
	'columns' => array('phid'),
	'unique' => true,
	),
	'userName' => array(
	'columns' => array('userName'),
	'unique' => true,
	),
	'realName' => array(
	'columns' => array('realName'),
	),
	'key_approved' => array(
	'columns' => array('isApproved'),
	),
	),
	self::CONFIG_NO_MUTATE => array(
	'profileImageCache' => true,
	'availabilityCache' => true,
	'availabilityCacheTTL' => true,
	),
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	PhabricatorPeopleUserPHIDType::TYPECONST);
	}

	public function setPassword(PhutilOpaqueEnvelope $envelope) {
	if (!$this->getPHID()) {
	throw new Exception(
	pht(
	'You can not set a password for an unsaved user because their PHID '.
	'is a salt component in the password hash.'));
	}

	if (!strlen($envelope->openEnvelope())) {
	$this->setPasswordHash('');
	} else {
	$this->setPasswordSalt(md5(Filesystem::readRandomBytes(32)));
	$hash = $this->hashPassword($envelope);
	$this->setPasswordHash($hash->openEnvelope());
	}
	return $this;
	}

	// To satisfy PhutilPerson.
	public function getSex() {
	return $this->sex;
	}

	public function getMonogram() {
	return '@'.$this->getUsername();
	}

	public function isLoggedIn() {
	return !($this->getPHID() === null);
	}

	public function save() {
	if (!$this->getConduitCertificate()) {
	$this->setConduitCertificate($this->generateConduitCertificate());
	}

	if (!strlen($this->getAccountSecret())) {
	$this->setAccountSecret(Filesystem::readRandomCharacters(64));
	}

	$result = parent::save();

	if ($this->profile) {
	$this->profile->save();
	}

	$this->updateNameTokens();

	PhabricatorSearchWorker::queueDocumentForIndexing($this->getPHID());

	return $result;
	}

	public function attachSession(PhabricatorAuthSession $session) {
	$this->session = $session;
	return $this;
	}

	public function getSession() {
	return $this->assertAttached($this->session);
	}

	public function hasSession() {
	return ($this->session !== self::ATTACHABLE);
	}

	private function generateConduitCertificate() {
	return Filesystem::readRandomCharacters(255);
	}

	public function comparePassword(PhutilOpaqueEnvelope $envelope) {
	if (!strlen($envelope->openEnvelope())) {
	return false;
	}
	if (!strlen($this->getPasswordHash())) {
	return false;
	}

	return PhabricatorPasswordHasher::comparePassword(
	$this->getPasswordHashInput($envelope),
	new PhutilOpaqueEnvelope($this->getPasswordHash()));
	}

	private function getPasswordHashInput(PhutilOpaqueEnvelope $password) {
	$input =
	$this->getUsername().
	$password->openEnvelope().
	$this->getPHID().
	$this->getPasswordSalt();

	return new PhutilOpaqueEnvelope($input);
	}

	private function hashPassword(PhutilOpaqueEnvelope $password) {
	$hasher = PhabricatorPasswordHasher::getBestHasher();

	$input_envelope = $this->getPasswordHashInput($password);
	return $hasher->getPasswordHashForStorage($input_envelope);
	}

	const CSRF_CYCLE_FREQUENCY = 3600;
	const CSRF_SALT_LENGTH = 8;
	const CSRF_TOKEN_LENGTH = 16;
	const CSRF_BREACH_PREFIX = 'B@';

	const EMAIL_CYCLE_FREQUENCY = 86400;
	const EMAIL_TOKEN_LENGTH = 24;

	private function getRawCSRFToken($offset = 0) {
	return $this->generateToken(
	time() + (self::CSRF_CYCLE_FREQUENCY * $offset),
	self::CSRF_CYCLE_FREQUENCY,
	PhabricatorEnv::getEnvConfig('phabricator.csrf-key'),
	self::CSRF_TOKEN_LENGTH);
	}

	public function getCSRFToken() {
	if ($this->isOmnipotent()) {
	// We may end up here when called from the daemons. The omnipotent user
	// has no meaningful CSRF token, so just return `null`.
	return null;
	}

	if ($this->csrfSalt === null) {
	$this->csrfSalt = Filesystem::readRandomCharacters(
	self::CSRF_SALT_LENGTH);
	}

	$salt = $this->csrfSalt;

	// Generate a token hash to mitigate BREACH attacks against SSL. See
	// discussion in T3684.
	$token = $this->getRawCSRFToken();
	$hash = PhabricatorHash::digest($token, $salt);
	return self::CSRF_BREACH_PREFIX.$salt.substr(
	$hash, 0, self::CSRF_TOKEN_LENGTH);
	}

	public function validateCSRFToken($token) {
	// We expect a BREACH-mitigating token. See T3684.
	$breach_prefix = self::CSRF_BREACH_PREFIX;
	$breach_prelen = strlen($breach_prefix);
	if (strncmp($token, $breach_prefix, $breach_prelen) !== 0) {
	return false;
	}

	$salt = substr($token, $breach_prelen, self::CSRF_SALT_LENGTH);
	$token = substr($token, $breach_prelen + self::CSRF_SALT_LENGTH);

	// When the user posts a form, we check that it contains a valid CSRF token.
	// Tokens cycle each hour (every CSRF_CYLCE_FREQUENCY seconds) and we accept
	// either the current token, the next token (users can submit a "future"
	// token if you have two web frontends that have some clock skew) or any of
	// the last 6 tokens. This means that pages are valid for up to 7 hours.
	// There is also some Javascript which periodically refreshes the CSRF
	// tokens on each page, so theoretically pages should be valid indefinitely.
	// However, this code may fail to run (if the user loses their internet
	// connection, or there's a JS problem, or they don't have JS enabled).
	// Choosing the size of the window in which we accept old CSRF tokens is
	// an issue of balancing concerns between security and usability. We could
	// choose a very narrow (e.g., 1-hour) window to reduce vulnerability to
	// attacks using captured CSRF tokens, but it's also more likely that real
	// users will be affected by this, e.g. if they close their laptop for an
	// hour, open it back up, and try to submit a form before the CSRF refresh
	// can kick in. Since the user experience of submitting a form with expired
	// CSRF is often quite bad (you basically lose data, or it's a big pain to
	// recover at least) and I believe we gain little additional protection
	// by keeping the window very short (the overwhelming value here is in
	// preventing blind attacks, and most attacks which can capture CSRF tokens
	// can also just capture authentication information [sniffing networks]
	// or act as the user [xss]) the 7 hour default seems like a reasonable
	// balance. Other major platforms have much longer CSRF token lifetimes,
	// like Rails (session duration) and Django (forever), which suggests this
	// is a reasonable analysis.
	$csrf_window = 6;

	for ($ii = -$csrf_window; $ii <= 1; $ii++) {
	$valid = $this->getRawCSRFToken($ii);

	$digest = PhabricatorHash::digest($valid, $salt);
	$digest = substr($digest, 0, self::CSRF_TOKEN_LENGTH);
	if (phutil_hashes_are_identical($digest, $token)) {
	return true;
	}
	}

	return false;
	}

	private function generateToken($epoch, $frequency, $key, $len) {
	if ($this->getPHID()) {
	$vec = $this->getPHID().$this->getAccountSecret();
	} else {
	$vec = $this->getAlternateCSRFString();
	}

	if ($this->hasSession()) {
	$vec = $vec.$this->getSession()->getSessionKey();
	}

	$time_block = floor($epoch / $frequency);
	$vec = $vec.$key.$time_block;

	return substr(PhabricatorHash::digest($vec), 0, $len);
	}

	public function getUserProfile() {
	return $this->assertAttached($this->profile);
	}

	public function attachUserProfile(PhabricatorUserProfile $profile) {
	$this->profile = $profile;
	return $this;
	}

	public function loadUserProfile() {
	if ($this->profile) {
	return $this->profile;
	}

	$profile_dao = new PhabricatorUserProfile();
	$this->profile = $profile_dao->loadOneWhere('userPHID = %s',
	$this->getPHID());

	if (!$this->profile) {
	$this->profile = PhabricatorUserProfile::initializeNewProfile($this);
	}

	return $this->profile;
	}

	public function loadPrimaryEmailAddress() {
	$email = $this->loadPrimaryEmail();
	if (!$email) {
	throw new Exception(pht('User has no primary email address!'));
	}
	return $email->getAddress();
	}

	public function loadPrimaryEmail() {
	return $this->loadOneRelative(
	new PhabricatorUserEmail(),
	'userPHID',
	'getPHID',
	'(isPrimary = 1)');
	}

	public function loadPreferences() {
	if ($this->preferences) {
	return $this->preferences;
	}

	$preferences = null;
	if ($this->getPHID()) {
	$preferences = id(new PhabricatorUserPreferences())->loadOneWhere(
	'userPHID = %s',
	$this->getPHID());
	}

	if (!$preferences) {
	$preferences = new PhabricatorUserPreferences();
	$preferences->setUserPHID($this->getPHID());

	$default_dict = array(
	PhabricatorUserPreferences::PREFERENCE_TITLES => 'glyph',
	PhabricatorUserPreferences::PREFERENCE_EDITOR => '',
	PhabricatorUserPreferences::PREFERENCE_MONOSPACED => '',
	PhabricatorUserPreferences::PREFERENCE_DARK_CONSOLE => 0,
	);

	$preferences->setPreferences($default_dict);
	}

	$this->preferences = $preferences;
	return $preferences;
	}

	public function loadEditorLink(
	$path,
	$line,
	PhabricatorRepository $repository = null) {

	$editor = $this->loadPreferences()->getPreference(
	PhabricatorUserPreferences::PREFERENCE_EDITOR);

	if (is_array($path)) {
	$multiedit = $this->loadPreferences()->getPreference(
	PhabricatorUserPreferences::PREFERENCE_MULTIEDIT);
	switch ($multiedit) {
	case '':
	$path = implode(' ', $path);
	break;
	case 'disable':
	return null;
	}
	}

	if (!strlen($editor)) {
	return null;
	}

	if ($repository) {
	$callsign = $repository->getCallsign();
	} else {
	$callsign = null;
	}

	$uri = strtr($editor, array(
	'%%' => '%',
	'%f' => phutil_escape_uri($path),
	'%l' => phutil_escape_uri($line),
	'%r' => phutil_escape_uri($callsign),
	));

	// The resulting URI must have an allowed protocol. Otherwise, we'll return
	// a link to an error page explaining the misconfiguration.

	$ok = PhabricatorHelpEditorProtocolController::hasAllowedProtocol($uri);
	if (!$ok) {
	return '/help/editorprotocol/';
	}

	return (string)$uri;
	}

	public function getAlternateCSRFString() {
	return $this->assertAttached($this->alternateCSRFString);
	}

	public function attachAlternateCSRFString($string) {
	$this->alternateCSRFString = $string;
	return $this;
	}

	/**
	* Populate the nametoken table, which used to fetch typeahead results. When
	* a user types "linc", we want to match "Abraham Lincoln" from on-demand
	* typeahead sources. To do this, we need a separate table of name fragments.
	*/
	public function updateNameTokens() {
	$table = self::NAMETOKEN_TABLE;
	$conn_w = $this->establishConnection('w');

	$tokens = PhabricatorTypeaheadDatasource::tokenizeString(
	$this->getUserName().' '.$this->getRealName());

	$sql = array();
	foreach ($tokens as $token) {
	$sql[] = qsprintf(
	$conn_w,
	'(%d, %s)',
	$this->getID(),
	$token);
	}

	queryfx(
	$conn_w,
	'DELETE FROM %T WHERE userID = %d',
	$table,
	$this->getID());
	if ($sql) {
	queryfx(
	$conn_w,
	'INSERT INTO %T (userID, token) VALUES %Q',
	$table,
	implode(', ', $sql));
	}
	}

	public function sendWelcomeEmail(PhabricatorUser $admin) {
	if (!$this->canEstablishWebSessions()) {
	throw new Exception(
	pht(
	'Can not send welcome mail to users who can not establish '.
	'web sessions!'));
	}

	$admin_username = $admin->getUserName();
	$admin_realname = $admin->getRealName();
	$user_username = $this->getUserName();
	$is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');

	$base_uri = PhabricatorEnv::getProductionURI('/');

	$engine = new PhabricatorAuthSessionEngine();
	$uri = $engine->getOneTimeLoginURI(
	$this,
	$this->loadPrimaryEmail(),
	PhabricatorAuthSessionEngine::ONETIME_WELCOME);

	$body = pht(
	"Welcome to Phabricator!\n\n".
	"%s (%s) has created an account for you.\n\n".
	" Username: %s\n\n".
	"To login to Phabricator, follow this link and set a password:\n\n".
	" %s\n\n".
	"After you have set a password, you can login in the future by ".
	"going here:\n\n".
	" %s\n",
	$admin_username,
	$admin_realname,
	$user_username,
	$uri,
	$base_uri);

	if (!$is_serious) {
	$body .= sprintf(
	"\n%s\n",
	pht("Love,\nPhabricator"));
	}

	$mail = id(new PhabricatorMetaMTAMail())
	->addTos(array($this->getPHID()))
	->setForceDelivery(true)
	->setSubject(pht('[Phabricator] Welcome to Phabricator'))
	->setBody($body)
	->saveAndSend();
	}

	public function sendUsernameChangeEmail(
	PhabricatorUser $admin,
	$old_username) {

	$admin_username = $admin->getUserName();
	$admin_realname = $admin->getRealName();
	$new_username = $this->getUserName();

	$password_instructions = null;
	if (PhabricatorPasswordAuthProvider::getPasswordProvider()) {
	$engine = new PhabricatorAuthSessionEngine();
	$uri = $engine->getOneTimeLoginURI(
	$this,
	null,
	PhabricatorAuthSessionEngine::ONETIME_USERNAME);
	$password_instructions = sprintf(
	"%s\n\n %s\n\n%s\n",
	pht(
	"If you use a password to login, you'll need to reset it ".
	"before you can login again. You can reset your password by ".
	"following this link:"),
	$uri,
	pht(
	"And, of course, you'll need to use your new username to login ".
	"from now on. If you use OAuth to login, nothing should change."));
	}

	$body = sprintf(
	"%s\n\n %s\n %s\n\n%s",
	pht(
	'%s (%s) has changed your Phabricator username.',
	$admin_username,
	$admin_realname),
	pht(
	'Old Username: %s',
	$old_username),
	pht(
	'New Username: %s',
	$new_username),
	$password_instructions);

	$mail = id(new PhabricatorMetaMTAMail())
	->addTos(array($this->getPHID()))
	->setForceDelivery(true)
	->setSubject(pht('[Phabricator] Username Changed'))
	->setBody($body)
	->saveAndSend();
	}

	public static function describeValidUsername() {
	return pht(
	'Usernames must contain only numbers, letters, period, underscore and '.
	'hyphen, and can not end with a period. They must have no more than %d '.
	'characters.',
	new PhutilNumber(self::MAXIMUM_USERNAME_LENGTH));
	}

	public static function validateUsername($username) {
	// NOTE: If you update this, make sure to update:
	//
	// - Remarkup rule for @mentions.
	// - Routing rule for "/p/username/".
	// - Unit tests, obviously.
	// - describeValidUsername() method, above.

	if (strlen($username) > self::MAXIMUM_USERNAME_LENGTH) {
	return false;
	}

	return (bool)preg_match('/^[a-zA-Z0-9._-]*[a-zA-Z0-9_-]\z/', $username);
	}

	public static function getDefaultProfileImageURI() {
	return celerity_get_resource_uri('/rsrc/image/avatar.png');
	}

	public function attachProfileImageURI($uri) {
	$this->profileImage = $uri;
	return $this;
	}

	public function getProfileImageURI() {
	return $this->assertAttached($this->profileImage);
	}

	public function getFullName() {
	if (strlen($this->getRealName())) {
	return $this->getUsername().' ('.$this->getRealName().')';
	} else {
	return $this->getUsername();
	}
	}

	public function getTimeZone() {
	return new DateTimeZone($this->getTimezoneIdentifier());
	}

	+ public function formatShortDateTime($when, $now = null) {
	+ if ($now === null) {
	+ $now = PhabricatorTime::getNow();
	+ }
	+
	+ try {
	+ $when = new DateTime('@'.$when);
	+ $now = new DateTime('@'.$now);
	+ } catch (Exception $ex) {
	+ return null;
	+ }
	+
	+ $zone = $this->getTimeZone();
	+
	+ $when->setTimeZone($zone);
	+ $now->setTimeZone($zone);
	+
	+ if ($when->format('Y') !== $now->format('Y')) {
	+ // Different year, so show "Feb 31 2075".
	+ $format = 'M j Y';
	+ } else if ($when->format('Ymd') !== $now->format('Ymd')) {
	+ // Same year but different month and day, so show "Feb 31".
	+ $format = 'M j';
	+ } else {
	+ // Same year, month and day so show a time of day.
	+ $pref_time = PhabricatorUserPreferences::PREFERENCE_TIME_FORMAT;
	+ $format = $this->getPreference($pref_time);
	+ }
	+
	+ return $when->format($format);
	+ }
	+
	public function getPreference($key) {
	$preferences = $this->loadPreferences();

	// TODO: After T4103 and T7707 this should eventually be pushed down the
	// stack into modular preference definitions and role profiles. This is
	// just fixing T8601 and mildly anticipating those changes.
	$value = $preferences->getPreference($key);

	$allowed_values = null;
	switch ($key) {
	case PhabricatorUserPreferences::PREFERENCE_TIME_FORMAT:
	$allowed_values = array(
	'g:i A',
	'H:i',
	);
	break;
	case PhabricatorUserPreferences::PREFERENCE_DATE_FORMAT:
	$allowed_values = array(
	'Y-m-d',
	'n/j/Y',
	'd-m-Y',
	);
	break;
	}

	if ($allowed_values !== null) {
	$allowed_values = array_fuse($allowed_values);
	if (empty($allowed_values[$value])) {
	$value = head($allowed_values);
	}
	}

	return $value;
	}

	public function __toString() {
	return $this->getUsername();
	}

	public static function loadOneWithEmailAddress($address) {
	$email = id(new PhabricatorUserEmail())->loadOneWhere(
	'address = %s',
	$address);
	if (!$email) {
	return null;
	}
	return id(new PhabricatorUser())->loadOneWhere(
	'phid = %s',
	$email->getUserPHID());
	}

	public function getDefaultSpacePHID() {
	// TODO: We might let the user switch which space they're "in" later on;
	// for now just use the global space if one exists.

	// If the viewer has access to the default space, use that.
	$spaces = PhabricatorSpacesNamespaceQuery::getViewerActiveSpaces($this);
	foreach ($spaces as $space) {
	if ($space->getIsDefaultNamespace()) {
	return $space->getPHID();
	}
	}

	// Otherwise, use the space with the lowest ID that they have access to.
	// This just tends to keep the default stable and predictable over time,
	// so adding a new space won't change behavior for users.
	if ($spaces) {
	$spaces = msort($spaces, 'getID');
	return head($spaces)->getPHID();
	}

	return null;
	}


	/**
	* Grant a user a source of authority, to let them bypass policy checks they
	* could not otherwise.
	*/
	public function grantAuthority($authority) {
	$this->authorities[] = $authority;
	return $this;
	}


	/**
	* Get authorities granted to the user.
	*/
	public function getAuthorities() {
	return $this->authorities;
	}


	/* -( Availability )------------------------------------------------------- */


	/**
	* @task availability
	*/
	public function attachAvailability(array $availability) {
	$this->availability = $availability;
	return $this;
	}


	/**
	* Get the timestamp the user is away until, if they are currently away.
	*
	* @return int\|null Epoch timestamp, or `null` if the user is not away.
	* @task availability
	*/
	public function getAwayUntil() {
	$availability = $this->availability;

	$this->assertAttached($availability);
	if (!$availability) {
	return null;
	}

	return idx($availability, 'until');
	}


	/**
	* Describe the user's availability.
	*
	* @param PhabricatorUser Viewing user.
	* @return string Human-readable description of away status.
	* @task availability
	*/
	public function getAvailabilityDescription(PhabricatorUser $viewer) {
	$until = $this->getAwayUntil();
	if ($until) {
	return pht('Away until %s', phabricator_datetime($until, $viewer));
	} else {
	return pht('Available');
	}
	}


	/**
	* Get cached availability, if present.
	*
	* @return wild\|null Cache data, or null if no cache is available.
	* @task availability
	*/
	public function getAvailabilityCache() {
	$now = PhabricatorTime::getNow();
	if ($this->availabilityCacheTTL <= $now) {
	return null;
	}

	try {
	return phutil_json_decode($this->availabilityCache);
	} catch (Exception $ex) {
	return null;
	}
	}


	/**
	* Write to the availability cache.
	*
	* @param wild Availability cache data.
	* @param int\|null Cache TTL.
	* @return this
	* @task availability
	*/
	public function writeAvailabilityCache(array $availability, $ttl) {
	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	queryfx(
	$this->establishConnection('w'),
	'UPDATE %T SET availabilityCache = %s, availabilityCacheTTL = %nd
	WHERE id = %d',
	$this->getTableName(),
	json_encode($availability),
	$ttl,
	$this->getID());
	unset($unguarded);

	return $this;
	}


	/* -( Profile Image Cache )------------------------------------------------ */


	/**
	* Get this user's cached profile image URI.
	*
	* @return string\|null Cached URI, if a URI is cached.
	* @task image-cache
	*/
	public function getProfileImageCache() {
	$version = $this->getProfileImageVersion();

	$parts = explode(',', $this->profileImageCache, 2);
	if (count($parts) !== 2) {
	return null;
	}

	if ($parts[0] !== $version) {
	return null;
	}

	return $parts[1];
	}


	/**
	* Generate a new cache value for this user's profile image.
	*
	* @return string New cache value.
	* @task image-cache
	*/
	public function writeProfileImageCache($uri) {
	$version = $this->getProfileImageVersion();
	$cache = "{$version},{$uri}";

	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	queryfx(
	$this->establishConnection('w'),
	'UPDATE %T SET profileImageCache = %s WHERE id = %d',
	$this->getTableName(),
	$cache,
	$this->getID());
	unset($unguarded);
	}


	/**
	* Get a version identifier for a user's profile image.
	*
	* This version will change if the image changes, or if any of the
	* environment configuration which goes into generating a URI changes.
	*
	* @return string Cache version.
	* @task image-cache
	*/
	private function getProfileImageVersion() {
	$parts = array(
	PhabricatorEnv::getCDNURI('/'),
	PhabricatorEnv::getEnvConfig('cluster.instance'),
	$this->getProfileImagePHID(),
	);
	$parts = serialize($parts);
	return PhabricatorHash::digestForIndex($parts);
	}


	/* -( Multi-Factor Authentication )---------------------------------------- */


	/**
	* Update the flag storing this user's enrollment in multi-factor auth.
	*
	* With certain settings, we need to check if a user has MFA on every page,
	* so we cache MFA enrollment on the user object for performance. Calling this
	* method synchronizes the cache by examining enrollment records. After
	* updating the cache, use @{method:getIsEnrolledInMultiFactor} to check if
	* the user is enrolled.
	*
	* This method should be called after any changes are made to a given user's
	* multi-factor configuration.
	*
	* @return void
	* @task factors
	*/
	public function updateMultiFactorEnrollment() {
	$factors = id(new PhabricatorAuthFactorConfig())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());

	$enrolled = count($factors) ? 1 : 0;
	if ($enrolled !== $this->isEnrolledInMultiFactor) {
	$unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
	queryfx(
	$this->establishConnection('w'),
	'UPDATE %T SET isEnrolledInMultiFactor = %d WHERE id = %d',
	$this->getTableName(),
	$enrolled,
	$this->getID());
	unset($unguarded);

	$this->isEnrolledInMultiFactor = $enrolled;
	}
	}


	/**
	* Check if the user is enrolled in multi-factor authentication.
	*
	* Enrolled users have one or more multi-factor authentication sources
	* attached to their account. For performance, this value is cached. You
	* can use @{method:updateMultiFactorEnrollment} to update the cache.
	*
	* @return bool True if the user is enrolled.
	* @task factors
	*/
	public function getIsEnrolledInMultiFactor() {
	return $this->isEnrolledInMultiFactor;
	}


	/* -( Omnipotence )-------------------------------------------------------- */


	/**
	* Returns true if this user is omnipotent. Omnipotent users bypass all policy
	* checks.
	*
	* @return bool True if the user bypasses policy checks.
	*/
	public function isOmnipotent() {
	return $this->omnipotent;
	}


	/**
	* Get an omnipotent user object for use in contexts where there is no acting
	* user, notably daemons.
	*
	* @return PhabricatorUser An omnipotent user.
	*/
	public static function getOmnipotentUser() {
	static $user = null;
	if (!$user) {
	$user = new PhabricatorUser();
	$user->omnipotent = true;
	$user->makeEphemeral();
	}
	return $user;
	}


	/**
	* Get a scalar string identifying this user.
	*
	* This is similar to using the PHID, but distinguishes between ominpotent
	* and public users explicitly. This allows safe construction of cache keys
	* or cache buckets which do not conflate public and omnipotent users.
	*
	* @return string Scalar identifier.
	*/
	public function getCacheFragment() {
	if ($this->isOmnipotent()) {
	return 'u.omnipotent';
	}

	$phid = $this->getPHID();
	if ($phid) {
	return 'u.'.$phid;
	}

	return 'u.public';
	}


	/* -( Managing Handles )--------------------------------------------------- */


	/**
	* Get a @{class:PhabricatorHandleList} which benefits from this viewer's
	* internal handle pool.
	*
	* @param list<phid> List of PHIDs to load.
	* @return PhabricatorHandleList Handle list object.
	* @task handle
	*/
	public function loadHandles(array $phids) {
	if ($this->handlePool === null) {
	$this->handlePool = id(new PhabricatorHandlePool())
	->setViewer($this);
	}

	return $this->handlePool->newHandleList($phids);
	}


	/**
	* Get a @{class:PHUIHandleView} for a single handle.
	*
	* This benefits from the viewer's internal handle pool.
	*
	* @param phid PHID to render a handle for.
	* @return PHUIHandleView View of the handle.
	* @task handle
	*/
	public function renderHandle($phid) {
	return $this->loadHandles(array($phid))->renderHandle($phid);
	}


	/**
	* Get a @{class:PHUIHandleListView} for a list of handles.
	*
	* This benefits from the viewer's internal handle pool.
	*
	* @param list<phid> List of PHIDs to render.
	* @return PHUIHandleListView View of the handles.
	* @task handle
	*/
	public function renderHandleList(array $phids) {
	return $this->loadHandles($phids)->renderList();
	}

	public function attachBadgePHIDs(array $phids) {
	$this->badgePHIDs = $phids;
	return $this;
	}

	public function getBadgePHIDs() {
	return $this->assertAttached($this->badgePHIDs);
	}


	/* -( PhabricatorPolicyInterface )----------------------------------------- */


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	PhabricatorPolicyCapability::CAN_EDIT,
	);
	}

	public function getPolicy($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_VIEW:
	return PhabricatorPolicies::POLICY_PUBLIC;
	case PhabricatorPolicyCapability::CAN_EDIT:
	if ($this->getIsSystemAgent() \|\| $this->getIsMailingList()) {
	return PhabricatorPolicies::POLICY_ADMIN;
	} else {
	return PhabricatorPolicies::POLICY_NOONE;
	}
	}
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	return $this->getPHID() && ($viewer->getPHID() === $this->getPHID());
	}

	public function describeAutomaticCapability($capability) {
	switch ($capability) {
	case PhabricatorPolicyCapability::CAN_EDIT:
	return pht('Only you can edit your information.');
	default:
	return null;
	}
	}


	/* -( PhabricatorCustomFieldInterface )------------------------------------ */


	public function getCustomFieldSpecificationForRole($role) {
	return PhabricatorEnv::getEnvConfig('user.fields');
	}

	public function getCustomFieldBaseClass() {
	return 'PhabricatorUserCustomField';
	}

	public function getCustomFields() {
	return $this->assertAttached($this->customFields);
	}

	public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
	$this->customFields = $fields;
	return $this;
	}


	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$this->delete();

	$externals = id(new PhabricatorExternalAccount())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($externals as $external) {
	$external->delete();
	}

	$prefs = id(new PhabricatorUserPreferences())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($prefs as $pref) {
	$pref->delete();
	}

	$profiles = id(new PhabricatorUserProfile())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($profiles as $profile) {
	$profile->delete();
	}

	$keys = id(new PhabricatorAuthSSHKey())->loadAllWhere(
	'objectPHID = %s',
	$this->getPHID());
	foreach ($keys as $key) {
	$key->delete();
	}

	$emails = id(new PhabricatorUserEmail())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($emails as $email) {
	$email->delete();
	}

	$sessions = id(new PhabricatorAuthSession())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($sessions as $session) {
	$session->delete();
	}

	$factors = id(new PhabricatorAuthFactorConfig())->loadAllWhere(
	'userPHID = %s',
	$this->getPHID());
	foreach ($factors as $factor) {
	$factor->delete();
	}

	$this->saveTransaction();
	}


	/* -( PhabricatorSSHPublicKeyInterface )----------------------------------- */


	public function getSSHPublicKeyManagementURI(PhabricatorUser $viewer) {
	if ($viewer->getPHID() == $this->getPHID()) {
	// If the viewer is managing their own keys, take them to the normal
	// panel.
	return '/settings/panel/ssh/';
	} else {
	// Otherwise, take them to the administrative panel for this user.
	return '/settings/'.$this->getID().'/panel/ssh/';
	}
	}

	public function getSSHKeyDefaultName() {
	return 'id_rsa_phabricator';
	}


	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new PhabricatorUserProfileEditor();
	}

	public function getApplicationTransactionObject() {
	return $this;
	}

	public function getApplicationTransactionTemplate() {
	return new PhabricatorUserTransaction();
	}

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {
	return $timeline;
	}


	/* -( PhabricatorFulltextInterface )--------------------------------------- */


	public function newFulltextEngine() {
	return new PhabricatorUserFulltextEngine();
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Apr 28, 12:57 AM (6 h, 36 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 107581
Default Alt Text: (71 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions