public GetDiffDiscussions(ReviewIdentifier reviewId, HashSet commits, ClientFileId fileId, string rightFileName)
{
ReviewId = reviewId;
Commits = commits;
FileId = fileId;
RightFileName = rightFileName;
}
public static async Task CreateRef(ReviewIdentifier reviewId, int revision, string commitRef, string refType, IRepository api)
{
await api.CreateRef(
projectId : reviewId.ProjectId,
name : $"reviewer/{reviewId.ReviewId}/r{revision}/{refType}",
commit : commitRef);
}
public GetFileDiff(ReviewIdentifier reviewId, HashSet hashes, string oldPath, string newPath)
{
OldPath = oldPath;
NewPath = newPath;
ReviewId = reviewId;
Hashes = hashes;
}
ReviewRevision ISessionAdapter.GetRevision(ReviewIdentifier reviewId, RevisionId revisionId)
{
Assert.That(revisionId, Is.InstanceOf <RevisionId.Selected>());
var s = (RevisionId.Selected)revisionId;
return(Revisions[s.Revision - 1]);
}
private async Task Update(ReviewIdentifier reviewId)
{
var commitStatus = await _query.Query(new GetCommitStatus(reviewId));
using (var innerScope = _scope.BeginLifetimeScope(UseGlobalAccessToken))
{
var api = innerScope.Resolve <IRepository>();
await api.SetCommitStatus(reviewId.ProjectId, commitStatus);
}
}
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 static async Task <IEnumerable <FileDiff> > Filter(IEnumerable <FileDiff> diff, //
IEnumerable <IGrouping <Guid, FileHistoryEntry> > fileHistoryEntries,
ReviewIdentifier reviewId,
string baseCommit,
string headCommit,
IRepository _api)
{
var relevantFileDiffs = await _api.GetDiff(reviewId.ProjectId, baseCommit, headCommit);
Func <FileDiff, bool> isDiffFileAlreadyInHistory = (FileDiff pd) => fileHistoryEntries.Any(history => history.Any(asd => asd.FileName == pd.Path.NewPath));
Func <FileDiff, bool> isDiffFileDirectlyOnCurrentBranch = (FileDiff pd) => relevantFileDiffs.Any(rd => rd.Path.NewPath == pd.Path.NewPath);
return(diff.Where(pd => isDiffFileAlreadyInHistory(pd) || isDiffFileDirectlyOnCurrentBranch(pd)));
}
public async Task <Review> FindOrCreateReview(PublishReview command, ReviewIdentifier reviewId, Guid revisionId)
{
var review = _sessionAdapter.GetReview(revisionId, _user);
if (review == null)
{
review = new Review
{
Id = GuidComb.Generate(),
RevisionId = revisionId,
UserId = _user.Id
};
}
review.ReviewedAt = DateTimeOffset.Now;
_sessionAdapter.Save(review);
return(review);
}
public GetFileMatrix(ReviewIdentifier reviewId)
{
ReviewId = reviewId;
}
public GetReviewEmoji(ReviewIdentifier reviewId)
{
ReviewId = reviewId;
}
public async Task <(Guid RevisionId, Dictionary <ClientFileId, Guid> ClientFileIdMap, Dictionary <string, Guid> ByName)> FindOrCreateRevision(ReviewIdentifier reviewId, PublishReview.RevisionCommits commits, FeatureToggle features)
{
var existingRevision = await _sessionAdapter.GetRevision(reviewId, commits);
if (existingRevision != null)
{
var fileHistory = _sessionAdapter.GetFileHistoryEntries(existingRevision);
var idMap = fileHistory.ToDictionary(x => ClientFileId.Persistent(x.FileId), x => x.FileId);
var nameMap = fileHistory.GroupBy(x => x.FileName).ToDictionary(x => x.Key, x => x.First().FileId);
return(existingRevision.Id, idMap, nameMap);
}
// create revision
var nextNumber = _sessionAdapter.GetNextRevisionNumber(reviewId);
await CreateRef(reviewId, nextNumber, commits.Base, "base", _api);
try
{
await CreateRef(reviewId, nextNumber, commits.Head, "head", _api);
}
catch (ExistingRefConflictException unexpectedException)
{
// The base ref is already created, we must add the record to database no matter what
Console.WriteLine("Failed to create ref for head commit - ignoring");
Console.WriteLine(unexpectedException.ToString());
}
var revision = await _factory.Create(reviewId, nextNumber, commits.Base, commits.Head);
await _sessionAdapter.Save(revision);
var clientFileIdMap = await new FillFileHistory(_sessionAdapter, _api, revision, features).Fill();
var byClientId = clientFileIdMap.ToDictionary(x => x.Key, x => x.Value.Item2);
var byName = clientFileIdMap.GroupBy(x => x.Value.Item1).ToDictionary(x => x.Key, x => x.First().Value.Item2);
return(RevisionId : revision.Id, ClientFileIdMap : byClientId, byName);
}
int ISessionAdapter.GetNextRevisionNumber(ReviewIdentifier reviewId)
{
return(Revisions.Count + 1);
}
async Task <ReviewRevision> ISessionAdapter.GetRevision(ReviewIdentifier reviewId, PublishReview.RevisionCommits commits)
{
return(Revisions.SingleOrDefault(x => x.BaseCommit == commits.Base && x.HeadCommit == commits.Head));
}
public ReviewChangedExternallyEvent(ReviewIdentifier reviewId)
{
ReviewId = reviewId;
}
public NewReview(ReviewIdentifier reviewId)
{
ReviewId = reviewId;
}
public HandleReviewChange(ReviewIdentifier reviewId)
{
ReviewId = reviewId;
}
public GetCommitStatus(ReviewIdentifier reviewId)
{
ReviewId = reviewId;
}
public ReviewPublishedEvent(ReviewIdentifier reviewId)
{
ReviewId = reviewId;
}
public HandleNewReview(ReviewIdentifier reviewId)
{
ReviewId = reviewId;
}
public static string CacheKey(ReviewIdentifier id) => $"CommitStatus_{id.ProjectId}_{id.ReviewId}";
public GetReviewStatus(ReviewIdentifier reviewId)
{
ReviewId = reviewId;
}
Dictionary <RevisionId, Review> ISessionAdapter.GetReviews(ReviewIdentifier reviewId, ReviewUser reviewUser)
{
return(Reviews.ForKey1(reviewUser).ToDictionary(x => (RevisionId) new RevisionId.Selected(x.Key.RevisionNumber), x => x.Value));
}
public GetReviewInfo(int projectId, int reviewId)
{
_reviewId = new ReviewIdentifier(projectId, reviewId);
}
