private static ReviewIdentifier[] FindPotentialMergeRequests(RunArchiverVerb options, ISession session)
{
var thresholdDate = options.ThresholdDate;
ReviewRevision revision = null;
Review review = null;
var reviewsQuery = session.QueryOver <ReviewRevision>(() => revision).Where(() => revision.ArchiveState == (int)ArchiveState.NotArchived)
.JoinEntityAlias(() => review, () => revision.Id == review.RevisionId)
.Where(() => review.ReviewedAt < thresholdDate);
if (options.ProjectId.HasValue)
{
reviewsQuery = reviewsQuery.Where(() => revision.ReviewId.ProjectId == options.ProjectId.Value);
}
IEnumerable <ReviewIdentifier> idList = reviewsQuery
.Select(Projections.Distinct(Projections.Property(() => revision.ReviewId)))
.List <ReviewIdentifier>();
if (options.BatchSize.HasValue)
{
idList = idList.Take(options.BatchSize.Value);
}
var mergeRequests = idList.ToArray();
Console.WriteLine($"Total of {mergeRequests.Length} potential archive merge requests.");
return(mergeRequests);
}
public FillFileHistory(ISessionAdapter sessionAdapter, IRepository api, ReviewRevision currentRevision, FeatureToggle features)
{
_sessionAdapter = sessionAdapter;
_api = api;
_currentRevision = currentRevision;
_features = features;
}
async Task ISessionAdapter.Save(ReviewRevision revision)
{
if (Revisions.Contains(revision))
{
return;
}
Assert.That(revision.RevisionNumber, Is.EqualTo(Revisions.Count + 1));
Revisions.Add(revision);
}
List <FileHistoryEntry> ISessionAdapter.GetFileHistoryEntries(ReviewRevision revision)
{
if (FileHistory.TryGetValue(revision, out var history))
{
return(history);
}
else
{
return(new List <FileHistoryEntry>());
}
}
ReviewRevision ISessionAdapter.GetPreviousRevision(ReviewRevision revision)
{
Assert.That(revision, Is.AnyOf(Revisions.OfType <object>().ToArray()));
if (revision.RevisionNumber == 1)
{
return(null);
}
return(Revisions.Single(x => x.RevisionNumber == revision.RevisionNumber - 1));
}
public async Task <Paged <Item> > Execute(GetReviewList query)
{
var activeMergeRequest = await _repository.MergeRequests(query.Args);
var projects = await Task.WhenAll(activeMergeRequest.Items.Select(x => x.ProjectId).Distinct().Select(async x => await _repository.Project(x)));
var reviewIds = activeMergeRequest.Items.Select(x => new ReviewIdentifier(x.ProjectId, x.Id)).ToList();
ReviewRevision revision = null;
var reviewIdCriterion = reviewIds.Select(id => Restrictions.And(
Restrictions.Eq(Projections.Property(() => revision.ReviewId.ProjectId), id.ProjectId),
Restrictions.Eq(Projections.Property(() => revision.ReviewId.ReviewId), id.ReviewId)
)).Disjunction();
Review review = null;
var reviewerFor = _session.QueryOver <ReviewRevision>(() => revision)
.Where(reviewIdCriterion)
.JoinEntityAlias(() => review, () => revision.Id == review.RevisionId)
.Where(() => review.UserId == _currentUser.Id)
.Select(Projections.Distinct(Projections.Property(() => revision.ReviewId)))
.List <ReviewIdentifier>();
// todo: extend with reviewer-specific information
var items = (from mr in activeMergeRequest.Items
join project in projects on mr.ProjectId equals project.Id
let reviewId = new ReviewIdentifier(mr.ProjectId, mr.Id)
select new Item
{
ReviewId = reviewId,
Author = mr.Author,
Title = mr.Title,
Project = $"{project.Namespace}/{project.Name}",
WebUrl = mr.WebUrl,
SourceBranch = mr.SourceBranch,
TargetBranch = mr.TargetBranch,
IsCreatedByMe = mr.Author.Username == _currentUser.UserName,
AmIReviewer = reviewerFor.Contains(reviewId)
}
).ToList();
return(new Paged <Item>
{
Items = items,
TotalItems = activeMergeRequest.TotalItems,
TotalPages = activeMergeRequest.TotalPages,
PerPage = activeMergeRequest.PerPage,
Page = activeMergeRequest.Page
});
}
public async Task <ReviewRevision> Create(ReviewIdentifier reviewId, int number, string baseCommit, string headCommit)
{
var revision = new ReviewRevision
{
Id = GuidComb.Generate(),
ReviewId = reviewId,
RevisionNumber = number,
BaseCommit = baseCommit,
HeadCommit = headCommit
};
return(revision);
}
public ReviewRevision MarkRevision(PublishReview.RevisionCommits commits)
{
var revision = new ReviewRevision
{
BaseCommit = commits.Base,
HeadCommit = commits.Head,
ReviewId = ReviewId,
RevisionNumber = Revisions.Count + 1,
Id = Guid.NewGuid()
};
Revisions.Add(revision);
return(revision);
}
private static bool DeleteTag(RunArchiverVerb options, ReviewRevision revision, string tagName, GitLabApi gitLab)
{
if (options.DeleteTags)
{
try
{
Console.WriteLine($"Deleting {tagName} from project {revision.ReviewId.ProjectId}");
gitLab.DeleteRef(revision.ReviewId.ProjectId, tagName).Wait();
}
catch (System.AggregateException)
{
Console.WriteLine($"Failed to delete {tagName}");
return(false);
}
}
else
{
Console.WriteLine($"Would delete {tagName} from project {revision.ReviewId.ProjectId}");
}
return(true);
}
public Guid FileIdInRevision(ReviewRevision revision, string fileName)
{
return(FileHistory[revision].Single(x => x.FileName == fileName).FileId);
}
private string FileNameInRevision(ReviewRevision revision, Guid fileId)
{
return(FileHistory[revision].Single(x => x.FileId == fileId).FileName);
}
public async Task <Result> Execute(GetReviewStatus query)
{
var mergeRequest = await _repository.GetMergeRequestInfo(query.ReviewId.ProjectId, query.ReviewId.ReviewId);
var latestRevision = await _session.Query <ReviewRevision>()
.Where(x => x.ReviewId == query.ReviewId)
.OrderByDescending(x => x.RevisionNumber)
.FirstOrDefaultAsync();
IList <FileStatus> fileStatuses;
{
Review review = null;
ReviewRevision revision = null;
FileReview file = null;
FileStatus dto = null;
FileHistoryEntry historyEntry = null;
fileStatuses = await _session.QueryOver(() => review)
.JoinEntityAlias(() => revision, () => revision.Id == review.RevisionId)
.JoinAlias(() => review.Files, () => file)
.JoinEntityAlias(() => historyEntry, () => historyEntry.RevisionId == revision.Id && historyEntry.FileId == file.FileId)
.Where(() => revision.ReviewId == query.ReviewId)
.Select(
Projections.Property(() => revision.RevisionNumber).WithAlias(() => dto.RevisionNumber),
Projections.Property(() => review.UserId).WithAlias(() => dto.ReviewedBy),
Projections.Property(() => historyEntry.FileName).WithAlias(() => dto.Path),
Projections.Property(() => file.Status).WithAlias(() => dto.Status)
)
.TransformUsing(Transformers.AliasToBean <FileStatus>())
.ListAsync <FileStatus>();
}
List <DiscussionItem> discussions;
{
var q = from discussion in _session.Query <Discussion>()
join revision in _session.Query <ReviewRevision>() on discussion.RevisionId equals revision.Id
where revision.ReviewId == query.ReviewId
join review in _session.Query <Review>() on discussion.RootComment.PostedInReviewId equals review.Id
join author in _session.Query <ReviewUser>() on review.UserId equals author.Id
select new DiscussionItem()
{
Author = author.UserName,
State = discussion.State
};
discussions = await q.ToListAsync();
}
return(new Result
{
Title = mergeRequest.Title,
Description = mergeRequest.Description,
SourceBranch = mergeRequest.SourceBranch,
TargetBranch = mergeRequest.TargetBranch,
WebUrl = mergeRequest.WebUrl,
MergeRequestState = mergeRequest.State,
MergeStatus = mergeRequest.MergeStatus,
RevisionForCurrentHead = mergeRequest.HeadCommit == latestRevision?.HeadCommit,
LatestRevision = latestRevision?.RevisionNumber,
CurrentHead = mergeRequest.HeadCommit,
CurrentBase = mergeRequest.BaseCommit,
FileStatuses = fileStatuses,
FileSummary = fileStatuses
.GroupBy(x => x.Path)
.ToDictionary(x => x.Key, x => (object)new
{
ReviewedAt = x.Where(r => r.Status == FileReviewStatus.Reviewed).Select(r => r.RevisionNumber),
ReviewedBy = x.Where(r => r.Status == FileReviewStatus.Reviewed).Select(r => r.ReviewedBy)
}),
UnresolvedDiscussions = discussions.Count(x => x.State == CommentState.NeedsResolution),
ResolvedDiscussions = discussions.Count(x => x.State == CommentState.Resolved),
Discussions = discussions,
Author = mergeRequest.Author,
});
}
