public async Task <Page <PullRequestListItemModel> > ReadPullRequests(
HostAddress address,
string owner,
string name,
string after,
PullRequestStateEnum[] states)
{
if (readPullRequests == null)
{
readPullRequests = new Query()
.Repository(Var(nameof(owner)), Var(nameof(name)))
.PullRequests(
first: 100,
after: Var(nameof(after)),
orderBy: new IssueOrder {
Direction = OrderDirection.Desc, Field = IssueOrderField.CreatedAt
},
states: Var(nameof(states)))
.Select(page => new Page <PullRequestListItemModel>
{
EndCursor = page.PageInfo.EndCursor,
HasNextPage = page.PageInfo.HasNextPage,
TotalCount = page.TotalCount,
Items = page.Nodes.Select(pr => new ListItemAdapter
{
Id = pr.Id.Value,
LastCommit = pr.Commits(null, null, 1, null).Nodes.Select(commit =>
new LastCommitSummaryModel
{
Statuses = commit.Commit.Status
.Select(context =>
context.Contexts.Select(statusContext => new StatusSummaryModel
{
State = (StatusState)statusContext.State,
}).ToList()
).SingleOrDefault()
}).ToList().FirstOrDefault(),
Author = new ActorModel
{
Login = pr.Author.Login,
AvatarUrl = pr.Author.AvatarUrl(null),
},
CommentCount = pr.Comments(0, null, null, null).TotalCount,
Number = pr.Number,
Reviews = pr.Reviews(null, null, null, null, null, null).AllPages().Select(review => new ReviewAdapter
{
Body = review.Body,
CommentCount = review.Comments(null, null, null, null).TotalCount,
}).ToList(),
State = (PullRequestStateEnum)pr.State,
Title = pr.Title,
UpdatedAt = pr.UpdatedAt,
}).ToList(),
}).Compile();
}
var graphql = await graphqlFactory.CreateConnection(address);
var vars = new Dictionary <string, object>
{
{ nameof(owner), owner },
{ nameof(name), name },
{ nameof(after), after },
{ nameof(states), states.Select(x => (PullRequestState)x).ToList() },
};
var result = await graphql.Run(readPullRequests, vars);
foreach (var item in result.Items.Cast <ListItemAdapter>())
{
item.CommentCount += item.Reviews.Sum(x => x.Count);
item.Reviews = null;
var hasStatuses = item.LastCommit.Statuses != null &&
item.LastCommit.Statuses.Any();
if (!hasStatuses)
{
item.Checks = PullRequestChecksState.None;
}
else
{
var statusHasFailure = item.LastCommit
.Statuses
.Any(status => status.State == StatusState.Failure);
var statusHasCompleteSuccess = true;
if (!statusHasFailure)
{
statusHasCompleteSuccess =
item.LastCommit.Statuses.All(status => status.State == StatusState.Success);
}
if (statusHasFailure)
{
item.Checks = PullRequestChecksState.Failure;
}
else if (statusHasCompleteSuccess)
{
item.Checks = PullRequestChecksState.Success;
}
else
{
item.Checks = PullRequestChecksState.Pending;
}
}
item.LastCommit = null;
}
return(result);
}
public async Task <Page <PullRequestListItemModel> > ReadPullRequests(
HostAddress address,
string owner,
string name,
string after,
PullRequestStateEnum[] states)
{
ICompiledQuery <Page <PullRequestListItemModel> > query;
if (address.IsGitHubDotCom())
{
if (readPullRequests == null)
{
readPullRequests = new Query()
.Repository(Var(nameof(owner)), Var(nameof(name)))
.PullRequests(
first: 100,
after: Var(nameof(after)),
orderBy: new IssueOrder {
Direction = OrderDirection.Desc, Field = IssueOrderField.CreatedAt
},
states: Var(nameof(states)))
.Select(page => new Page <PullRequestListItemModel>
{
EndCursor = page.PageInfo.EndCursor,
HasNextPage = page.PageInfo.HasNextPage,
TotalCount = page.TotalCount,
Items = page.Nodes.Select(pr => new ListItemAdapter
{
Id = pr.Id.Value,
LastCommit = pr.Commits(null, null, 1, null).Nodes.Select(commit =>
new LastCommitSummaryAdapter
{
CheckSuites = commit.Commit.CheckSuites(null, null, null, null, null).AllPages(10)
.Select(suite => new CheckSuiteSummaryModel
{
CheckRuns = suite.CheckRuns(null, null, null, null, null).AllPages(10)
.Select(run => new CheckRunSummaryModel
{
Conclusion = run.Conclusion.FromGraphQl(),
Status = run.Status.FromGraphQl()
}).ToList()
}).ToList(),
Statuses = commit.Commit.Status
.Select(context =>
context.Contexts.Select(statusContext => new StatusSummaryModel
{
State = statusContext.State.FromGraphQl(),
}).ToList()
).SingleOrDefault()
}).ToList().FirstOrDefault(),
Author = new ActorModel
{
Login = pr.Author.Login,
AvatarUrl = pr.Author.AvatarUrl(null),
},
CommentCount = pr.Comments(0, null, null, null).TotalCount,
Number = pr.Number,
Reviews = pr.Reviews(null, null, null, null, null, null).AllPages().Select(review => new ReviewAdapter
{
Body = review.Body,
CommentCount = review.Comments(null, null, null, null).TotalCount,
}).ToList(),
State = pr.State.FromGraphQl(),
Title = pr.Title,
UpdatedAt = pr.UpdatedAt,
}).ToList(),
}).Compile();
}
query = readPullRequests;
}
else
{
if (readPullRequestsEnterprise == null)
{
readPullRequestsEnterprise = new Query()
.Repository(Var(nameof(owner)), Var(nameof(name)))
.PullRequests(
first: 100,
after: Var(nameof(after)),
orderBy: new IssueOrder {
Direction = OrderDirection.Desc, Field = IssueOrderField.CreatedAt
},
states: Var(nameof(states)))
.Select(page => new Page <PullRequestListItemModel>
{
EndCursor = page.PageInfo.EndCursor,
HasNextPage = page.PageInfo.HasNextPage,
TotalCount = page.TotalCount,
Items = page.Nodes.Select(pr => new ListItemAdapter
{
Id = pr.Id.Value,
LastCommit = pr.Commits(null, null, 1, null).Nodes.Select(commit =>
new LastCommitSummaryAdapter
{
Statuses = commit.Commit.Status
.Select(context =>
context.Contexts.Select(statusContext => new StatusSummaryModel
{
State = statusContext.State.FromGraphQl(),
}).ToList()
).SingleOrDefault()
}).ToList().FirstOrDefault(),
Author = new ActorModel
{
Login = pr.Author.Login,
AvatarUrl = pr.Author.AvatarUrl(null),
},
CommentCount = pr.Comments(0, null, null, null).TotalCount,
Number = pr.Number,
Reviews = pr.Reviews(null, null, null, null, null, null).AllPages().Select(review => new ReviewAdapter
{
Body = review.Body,
CommentCount = review.Comments(null, null, null, null).TotalCount,
}).ToList(),
State = pr.State.FromGraphQl(),
Title = pr.Title,
UpdatedAt = pr.UpdatedAt,
}).ToList(),
}).Compile();
}
query = readPullRequestsEnterprise;
}
var graphql = await graphqlFactory.CreateConnection(address);
var vars = new Dictionary <string, object>
{
{ nameof(owner), owner },
{ nameof(name), name },
{ nameof(after), after },
{ nameof(states), states.Select(x => (PullRequestState)x).ToList() },
};
var result = await graphql.Run(query, vars);
foreach (var item in result.Items.Cast <ListItemAdapter>())
{
item.CommentCount += item.Reviews.Sum(x => x.Count);
item.Reviews = null;
var checkRuns = item.LastCommit?.CheckSuites?.SelectMany(model => model.CheckRuns).ToArray();
var hasCheckRuns = checkRuns?.Any() ?? false;
var hasStatuses = item.LastCommit?.Statuses?.Any() ?? false;
if (!hasCheckRuns && !hasStatuses)
{
item.Checks = PullRequestChecksState.None;
}
else
{
var checksHasFailure = false;
var checksHasCompleteSuccess = true;
if (hasCheckRuns)
{
checksHasFailure = checkRuns
.Any(model => model.Conclusion.HasValue &&
(model.Conclusion.Value == CheckConclusionState.Failure ||
model.Conclusion.Value == CheckConclusionState.ActionRequired));
if (!checksHasFailure)
{
checksHasCompleteSuccess = checkRuns
.All(model => model.Conclusion.HasValue &&
(model.Conclusion.Value == CheckConclusionState.Success ||
model.Conclusion.Value == CheckConclusionState.Neutral));
}
}
var statusHasFailure = false;
var statusHasCompleteSuccess = true;
if (!checksHasFailure && hasStatuses)
{
statusHasFailure = item.LastCommit
.Statuses
.Any(status => status.State == StatusState.Failure ||
status.State == StatusState.Error);
if (!statusHasFailure)
{
statusHasCompleteSuccess =
item.LastCommit.Statuses.All(status => status.State == StatusState.Success);
}
}
if (checksHasFailure || statusHasFailure)
{
item.Checks = PullRequestChecksState.Failure;
}
else if (statusHasCompleteSuccess && checksHasCompleteSuccess)
{
item.Checks = PullRequestChecksState.Success;
}
else
{
item.Checks = PullRequestChecksState.Pending;
}
}
item.LastCommit = null;
}
return(result);
}
/// <summary>
/// Query to remove documents from a collection.
/// </summary>
/// <param name="query"></param>
/// <param name="result"></param>
protected void QueryRemove(ICompiledQuery query, CollectionValue result) {
MongoCollection<BsonDocument> collection = this.Database.GetCollection(query.Collections.FirstOrDefault());
BsonArray conditions = BsonSerializer.Deserialize<BsonArray>(query.Conditions.FirstOrDefault());
WriteConcernResult writeConcernResult = collection.Remove(new QueryDocument(conditions.First().AsBsonDocument));
result.Add(
new Affected() {
new NumericValue() {
Long = (int)writeConcernResult.DocumentsAffected
}
}
);
}
/// <summary>
/// find and update, with upsert.
/// </summary>
/// <param name="query"></param>
/// <param name="result"></param>
protected void QueryMerge(ICompiledQuery query, CollectionValue result) {
MongoCollection<BsonDocument> collection = this.Database.GetCollection(query.Collections.FirstOrDefault());
ICompiledQuery save = query.Children.FirstOrDefault(child => child.Root is Save);
ICompiledQuery modify = query.Children.FirstOrDefault(child => child.Root is Modify);
if (save != null && modify != null) {
BsonArray conditions = BsonSerializer.Deserialize<BsonArray>(modify.Conditions.FirstOrDefault());
BsonArray assignments = BsonSerializer.Deserialize<BsonArray>(save.Assignments.FirstOrDefault());
BsonArray sortings = BsonSerializer.Deserialize<BsonArray>(modify.Sortings.FirstOrDefault());
QueryDocument queryDocument = new QueryDocument(conditions.First().AsBsonDocument);
IMongoSortBy sortByDocument = new SortByDocument(sortings.First().AsBsonDocument);
UpdateDocument updateDocument = new UpdateDocument(assignments.First().AsBsonDocument);
FindAndModifyResult findAndModifyResult = collection.FindAndModify(queryDocument, sortByDocument, updateDocument, true, true);
result.Add(this.ToDocument(findAndModifyResult.ModifiedDocument));
}
}
/// <summary>
/// Query anything that does not return any results
/// </summary>
/// <param name="query"></param>
/// <param name="result"></param>
/// <returns></returns>
protected CollectionValue Execute(ICompiledQuery query, CollectionValue result) {
if (this.Connection != null && this.Connection.State == ConnectionState.Open) {
using (IDbCommand command = this.Connection.CreateCommand()) {
command.CommandText = query.Compiled.FirstOrDefault();
result.Add(new Affected() {
new NumericValue() {
Long = command.ExecuteNonQuery()
}
});
}
}
return result;
}
/// <summary>
/// Select query on the database
/// </summary>
/// <param name="query"></param>
/// <param name="result"></param>
protected void QueryFind(ICompiledQuery query, CollectionValue result) {
MongoCollection<BsonDocument> collection = this.Database.GetCollection(query.Collections.FirstOrDefault());
BsonArray conditions = BsonSerializer.Deserialize<BsonArray>(query.Conditions.FirstOrDefault());
MongoCursor<BsonDocument> cursor = collection.Find(new QueryDocument(conditions.First().AsBsonDocument));
if (query.Limit != null) {
cursor.SetLimit((int)query.Limit.Value);
}
if (query.Skip != null) {
cursor.SetSkip((int)query.Skip.Value);
}
result.AddRange(cursor.Select(this.ToDocument));
}
public static SimpleQuery <T> GetMasterQuery <T>(this ICompiledQuery <T> query)
{
return(((PagedQuery <T>)query).MasterQuery);
}
public virtual async Task <PullRequestDetailModel> ReadPullRequestDetail(HostAddress address, string owner, string name, int number)
{
if (readPullRequest == null)
{
readPullRequest = new Query()
.Repository(owner: Var(nameof(owner)), name: Var(nameof(name)))
.PullRequest(Var(nameof(number)))
.Select(pr => new PullRequestDetailModel
{
Id = pr.Id.Value,
Number = pr.Number,
Author = new ActorModel
{
Login = pr.Author.Login,
AvatarUrl = pr.Author.AvatarUrl(null),
},
Title = pr.Title,
Body = pr.Body,
BaseRefSha = pr.BaseRefOid,
BaseRefName = pr.BaseRefName,
BaseRepositoryOwner = pr.Repository.Owner.Login,
HeadRefName = pr.HeadRefName,
HeadRefSha = pr.HeadRefOid,
HeadRepositoryOwner = pr.HeadRepositoryOwner != null ? pr.HeadRepositoryOwner.Login : null,
State = pr.State.FromGraphQl(),
UpdatedAt = pr.UpdatedAt,
Reviews = pr.Reviews(null, null, null, null, null, null).AllPages().Select(review => new PullRequestReviewModel
{
Id = review.Id.Value,
Body = review.Body,
CommitId = review.Commit.Oid,
State = review.State.FromGraphQl(),
SubmittedAt = review.SubmittedAt,
Author = new ActorModel
{
Login = review.Author.Login,
AvatarUrl = review.Author.AvatarUrl(null),
},
Comments = review.Comments(null, null, null, null).AllPages().Select(comment => new CommentAdapter
{
Id = comment.Id.Value,
PullRequestId = comment.PullRequest.Number,
DatabaseId = comment.DatabaseId.Value,
Author = new ActorModel
{
Login = comment.Author.Login,
AvatarUrl = comment.Author.AvatarUrl(null),
},
Body = comment.Body,
Path = comment.Path,
CommitSha = comment.Commit.Oid,
DiffHunk = comment.DiffHunk,
Position = comment.Position,
OriginalPosition = comment.OriginalPosition,
OriginalCommitId = comment.OriginalCommit.Oid,
ReplyTo = comment.ReplyTo != null ? comment.ReplyTo.Id.Value : null,
CreatedAt = comment.CreatedAt,
Url = comment.Url,
}).ToList(),
}).ToList(),
}).Compile();
}
var vars = new Dictionary <string, object>
{
{ nameof(owner), owner },
{ nameof(name), name },
{ nameof(number), number },
};
var connection = await graphqlFactory.CreateConnection(address);
var result = await connection.Run(readPullRequest, vars);
var apiClient = await apiClientFactory.Create(address);
var files = await apiClient.GetPullRequestFiles(owner, name, number).ToList();
var lastCommitModel = await GetPullRequestLastCommitAdapter(address, owner, name, number);
result.Statuses = (IReadOnlyList <StatusModel>)lastCommitModel.Statuses ?? Array.Empty <StatusModel>();
if (lastCommitModel.CheckSuites == null)
{
result.CheckSuites = Array.Empty <CheckSuiteModel>();
}
else
{
result.CheckSuites = lastCommitModel.CheckSuites;
foreach (var checkSuite in result.CheckSuites)
{
checkSuite.HeadSha = lastCommitModel.HeadSha;
}
}
result.ChangedFiles = files.Select(file => new PullRequestFileModel
{
FileName = file.FileName,
Sha = file.Sha,
Status = (PullRequestFileStatus)Enum.Parse(typeof(PullRequestFileStatus), file.Status, true),
}).ToList();
BuildPullRequestThreads(result);
return(result);
}
private static Action <TInclude> GetJoinListCallback(PropertyInfo property, IncludeResultOperator @operator, ICompiledQuery <TDoc, TOut> query)
{
var queryProperty = GetPropertyInfo(property, @operator);
var included = (IList <TInclude>)(queryProperty).GetValue(query);
if (included == null)
{
queryProperty.SetValue(query, new List <TInclude>());
included = (IList <TInclude>)queryProperty.GetValue(query);
}
return(included.Fill);
}
public TOut Query <TDoc, TOut>(ICompiledQuery <TDoc, TOut> query)
{
var handler = _schema.HandlerFactory.HandlerFor(query);
return(_connection.Fetch(handler, _identityMap.ForQuery()));
}
private static Action <TInclude> GetJoinCallback(PropertyInfo property, IncludeResultOperator @operator, ICompiledQuery <TDoc, TOut> query)
{
var queryProperty = GetPropertyInfo(property, @operator);
return(x => queryProperty.SetValue(query, x));
}
public DefaultIncludeCallbackResolver(ICompiledQuery <TDoc, TOut> query, IncludeResultOperator includeOperator)
{
_query = query;
_includeOperator = includeOperator;
}
private void Compile(DataContext context)
{
this.compiled = context.Provider.Compile(this.query);
this.mappingSource = context.Mapping.MappingSource;
}
private Action <TInclude> GetJoinDictionaryCallback(PropertyInfo property, IncludeResultOperator @operator, ICompiledQuery <TDoc, TOut> query)
{
var queryProperty = GetPropertyInfo(property, @operator);
var storage = _storage.StorageFor(typeof(TInclude));
var dictionary = (IDictionary <TKey, TInclude>)(queryProperty).GetValue(query);
if (dictionary == null)
{
queryProperty.SetValue(query, new Dictionary <TKey, TInclude>());
dictionary = (IDictionary <TKey, TInclude>)queryProperty.GetValue(query);
}
return(x =>
{
var id = storage.Identity(x).As <TKey>();
if (!dictionary.ContainsKey(id))
{
dictionary.Add(id, x);
}
});
}
public static IReadOnlyList <ISubquery> GetSubqueries <T>(this ICompiledQuery <T> query)
{
return(((PagedQuery <T>)query).Subqueries);
}
public static T Deserialize <T>(this ICompiledQuery <T> query, string data)
{
var q = (SimpleQuery <T>)query;
return(new ResponseDeserializer().Deserialize(q, data));
}
public static void AssertCompiledQueryExpressionEqual <T>(Expression expected, ICompiledQuery <T> actualCompiledQuery, params string[] subqueryPlaceholderReplacements)
{
var expectedString = expected.ToReadableString();
AssertCompiledQueryExpressionEqual(expectedString, actualCompiledQuery, subqueryPlaceholderReplacements);
}
/// <summary> /// Runs a compiled query /// </summary> /// <param name="query"></param> protected abstract List<IDatabaseObject> Query(ICompiledQuery query);
public static void AssertCompiledQueryExpressionEqual <T>(string expectedString, ICompiledQuery <T> actualCompiledQuery, params string[] subqueryPlaceholderReplacements)
{
var actualResultExpression = actualCompiledQuery.GetResultBuilderExpression();
var actualString = actualResultExpression.ToReadableString(settings => settings.NameAnonymousTypesUsing(_ => "object"));
expectedString = ReplaceSubqueryPlaceholders(expectedString, subqueryPlaceholderReplacements);
Assert.Equal(StripWhitespace(expectedString), StripWhitespace(actualString));
}
private IIncludeJoin GetJoin <TInclude>(ICompiledQuery <TDoc, TOut> query, IncludeResultOperator includeOperator) where TInclude : class
{
var resolver = new DefaultIncludeCallbackResolver <TInclude, TDoc, TOut>(query, includeOperator);
return(doGetJoin(query, includeOperator, resolver));
}
public DictionaryIncludeCallbackResolver(ICompiledQuery <TDoc, TOut> query, IncludeResultOperator includeOperator, IDocumentSchema schema)
{
_query = query;
_includeOperator = includeOperator;
_schema = schema;
}
/// <summary>
/// Modify all documents that match a query
/// </summary>
/// <param name="query"></param>
/// <param name="result"></param>
protected void QueryModify(ICompiledQuery query, CollectionValue result) {
MongoCollection<BsonDocument> collection = this.Database.GetCollection(query.Collections.FirstOrDefault());
BsonArray conditions = BsonSerializer.Deserialize<BsonArray>(query.Conditions.FirstOrDefault());
BsonArray assignments = BsonSerializer.Deserialize<BsonArray>(query.Assignments.FirstOrDefault());
QueryDocument queryDocument = new QueryDocument(conditions.First().AsBsonDocument);
UpdateDocument updateDocument = new UpdateDocument(assignments.First().AsBsonDocument);
WriteConcernResult writeConcernResult = collection.Update(queryDocument, updateDocument, UpdateFlags.Multi);
result.Add(
new Affected() {
new NumericValue() {
Long = (int)writeConcernResult.DocumentsAffected
}
}
);
}
public IObservable <AutoCompleteSuggestion> GetSuggestions()
{
var localRepositoryModel = teamExplorerContext.ActiveRepository;
var hostAddress = HostAddress.Create(localRepositoryModel.CloneUrl.Host);
var owner = localRepositoryModel.Owner;
var name = localRepositoryModel.Name;
string filter;
string after;
if (query == null)
{
query = new Query().Search(query: Var(nameof(filter)), SearchType.Issue, 100, after: Var(nameof(after)))
.Select(item => new Page <SuggestionItem>
{
Items = item.Nodes.Select(searchResultItem =>
searchResultItem.Switch <SuggestionItem>(selector => selector
.Issue(i => new SuggestionItem("#" + i.Number, i.Title)
{
LastModifiedDate = i.LastEditedAt
})
.PullRequest(p => new SuggestionItem("#" + p.Number, p.Title)
{
LastModifiedDate = p.LastEditedAt
}))
).ToList(),
EndCursor = item.PageInfo.EndCursor,
HasNextPage = item.PageInfo.HasNextPage,
TotalCount = item.IssueCount
})
.Compile();
}
filter = $"repo:{owner}/{name}";
return(Observable.FromAsync(async() =>
{
var results = new List <SuggestionItem>();
var variables = new Dictionary <string, object>
{
{ nameof(filter), filter },
};
var connection = await graphqlFactory.CreateConnection(hostAddress);
var searchResults = await connection.Run(query, variables);
results.AddRange(searchResults.Items);
while (searchResults.HasNextPage)
{
variables[nameof(after)] = searchResults.EndCursor;
searchResults = await connection.Run(query, variables);
results.AddRange(searchResults.Items);
}
return results.Select(item => new IssueAutoCompleteSuggestion(item, Prefix));
}).SelectMany(observable => observable));
}
/// <summary>
/// Drops a database or collection
/// </summary>
/// <param name="query"></param>
/// <param name="result"></param>
protected void QueryDrop(ICompiledQuery query, CollectionValue result) {
if (query.Databases.Any() == true && this.Database.Name == query.Databases.FirstOrDefault()) {
this.Database.Drop();
result.Add(
new Affected() {
new NumericValue() {
Long = 1
}
}
);
}
else {
MongoCollection<BsonDocument> collection = this.Database.GetCollection(query.Collections.FirstOrDefault());
CommandResult commandResult = collection.Drop();
result.Add(
new Affected() {
new NumericValue() {
Long = commandResult.Ok == true ? 1 : 0
}
}
);
}
}
protected Task <T> Run <T>(ICompiledQuery <T> query, Dictionary <string, object> variables = null)
{
return(_connection.Run(query, variables));
}
protected override List<IDatabaseObject> Query(ICompiledQuery query) {
List<IDatabaseObject> results = new List<IDatabaseObject>();
CollectionValue result = new CollectionValue();
try {
if (query.Root is Find) {
this.QueryFind(query, result);
}
else if (query.Root is Modify) {
this.QueryModify(query, result);
}
else if (query.Root is Remove) {
this.QueryRemove(query, result);
}
else if (query.Root is Drop) {
this.QueryDrop(query, result);
}
// Essentially ignore the create command and process the index children instead.
//else if (query.Root is Create) {
// this.QueryCreate(query, results);
//}
else if (query.Root is Merge) {
this.QueryMerge(query, result);
}
results.Add(result);
}
catch (Exception exception) {
results.Add(new Error() {
new StringValue() {
Data = exception.Message
}
});
}
foreach (ICompiledQuery child in query.Children) {
results.AddRange(this.Query(child));
}
return results;
}
public Task <TResult> Query <TDoc, TResult>(ICompiledQuery <TDoc, TResult> query)
{
var handler = _schema.HandlerFactory.HandlerFor(query);
return(AddItem(handler));
}
public async Task <Page <PullRequestListItemModel> > ReadPullRequests(
HostAddress address,
string owner,
string name,
string after,
PullRequestStateEnum[] states)
{
if (readPullRequests == null)
{
readPullRequests = new Query()
.Repository(Var(nameof(owner)), Var(nameof(name)))
.PullRequests(
first: 100,
after: Var(nameof(after)),
orderBy: new IssueOrder {
Direction = OrderDirection.Desc, Field = IssueOrderField.CreatedAt
},
states: Var(nameof(states)))
.Select(page => new Page <PullRequestListItemModel>
{
EndCursor = page.PageInfo.EndCursor,
HasNextPage = page.PageInfo.HasNextPage,
TotalCount = page.TotalCount,
Items = page.Nodes.Select(pr => new ListItemAdapter
{
Id = pr.Id.Value,
Author = new ActorModel
{
Login = pr.Author.Login,
AvatarUrl = pr.Author.AvatarUrl(null),
},
CommentCount = pr.Comments(0, null, null, null).TotalCount,
Number = pr.Number,
Reviews = pr.Reviews(null, null, null, null, null, null).AllPages().Select(review => new ReviewAdapter
{
Body = review.Body,
CommentCount = review.Comments(null, null, null, null).TotalCount,
}).ToList(),
State = (PullRequestStateEnum)pr.State,
Title = pr.Title,
UpdatedAt = pr.UpdatedAt,
}).ToList(),
}).Compile();
}
var graphql = await graphqlFactory.CreateConnection(address);
var vars = new Dictionary <string, object>
{
{ nameof(owner), owner },
{ nameof(name), name },
{ nameof(after), after },
{ nameof(states), states.Select(x => (PullRequestState)x).ToList() },
};
var result = await graphql.Run(readPullRequests, vars);
foreach (ListItemAdapter item in result.Items)
{
item.CommentCount += item.Reviews.Sum(x => x.Count);
item.Reviews = null;
}
return(result);
}
public TOut Query <TDoc, TOut>(ICompiledQuery <TDoc, TOut> query)
{
throw new NotImplementedException();
}
public DictionaryIncludeCallbackResolver(ICompiledQuery <TDoc, TOut> query, IncludeResultOperator includeOperator, StorageFeatures storage)
{
_query = query;
_includeOperator = includeOperator;
_storage = storage;
}
public Task <TOut> QueryAsync <TDoc, TOut>(ICompiledQuery <TDoc, TOut> query, CancellationToken token = new CancellationToken())
{
throw new NotImplementedException();
}
public static Expression GetResultBuilderExpression <T>(this ICompiledQuery <T> query)
{
return(ExpressionCompiler.GetSourceExpression(((SimpleQuery <T>)query).ResultBuilder));
}
public Task <TOut> QueryAsync <TDoc, TOut>(ICompiledQuery <TDoc, TOut> query, CancellationToken token = new CancellationToken())
{
return(_querySession.QueryAsync(query, token));
}
async Task <LastCommitAdapter> GetPullRequestLastCommitAdapter(HostAddress address, string owner, string name, int number)
{
ICompiledQuery <IEnumerable <LastCommitAdapter> > query;
if (address.IsGitHubDotCom())
{
if (readCommitStatuses == null)
{
readCommitStatuses = new Query()
.Repository(Var(nameof(owner)), Var(nameof(name)))
.PullRequest(Var(nameof(number))).Commits(last: 1).Nodes.Select(
commit => new LastCommitAdapter
{
CheckSuites = commit.Commit.CheckSuites(null, null, null, null, null).AllPages(10)
.Select(suite => new CheckSuiteModel
{
CheckRuns = suite.CheckRuns(null, null, null, null, null).AllPages(10)
.Select(run => new CheckRunModel
{
Conclusion = run.Conclusion.FromGraphQl(),
Status = run.Status.FromGraphQl(),
Name = run.Name,
DetailsUrl = run.Permalink,
Summary = run.Summary,
}).ToList()
}).ToList(),
Statuses = commit.Commit.Status
.Select(context =>
context.Contexts.Select(statusContext => new StatusModel
{
State = statusContext.State.FromGraphQl(),
Context = statusContext.Context,
TargetUrl = statusContext.TargetUrl,
Description = statusContext.Description,
}).ToList()
).SingleOrDefault()
}
).Compile();
}
query = readCommitStatuses;
}
else
{
if (readCommitStatusesEnterprise == null)
{
readCommitStatusesEnterprise = new Query()
.Repository(Var(nameof(owner)), Var(nameof(name)))
.PullRequest(Var(nameof(number))).Commits(last: 1).Nodes.Select(
commit => new LastCommitAdapter
{
Statuses = commit.Commit.Status
.Select(context =>
context.Contexts.Select(statusContext => new StatusModel
{
State = statusContext.State.FromGraphQl(),
Context = statusContext.Context,
TargetUrl = statusContext.TargetUrl,
Description = statusContext.Description,
}).ToList()
).SingleOrDefault()
}
).Compile();
}
query = readCommitStatusesEnterprise;
}
var vars = new Dictionary <string, object>
{
{ nameof(owner), owner },
{ nameof(name), name },
{ nameof(number), number },
};
var connection = await graphqlFactory.CreateConnection(address);
var result = await connection.Run(query, vars);
return(result.First());
}
public TOut Query <TDoc, TOut>(ICompiledQuery <TDoc, TOut> query)
{
return(_querySession.Query(query));
}
async Task <LastCommitAdapter> GetPullRequestLastCommitAdapter(HostAddress address, string owner, string name, int number)
{
ICompiledQuery <IEnumerable <LastCommitAdapter> > query;
if (address.IsGitHubDotCom())
{
if (readCommitStatuses == null)
{
readCommitStatuses = new Query()
.Repository(owner: Var(nameof(owner)), name: Var(nameof(name)))
.PullRequest(Var(nameof(number))).Commits(last: 1).Nodes.Select(
commit => new LastCommitAdapter
{
HeadSha = commit.Commit.Oid,
CheckSuites = commit.Commit.CheckSuites(null, null, null, null, null).AllPages(10)
.Select(suite => new CheckSuiteModel
{
CheckRuns = suite.CheckRuns(null, null, null, null, null).AllPages(10)
.Select(run => new CheckRunModel
{
Id = run.Id.Value,
Conclusion = run.Conclusion.FromGraphQl(),
Status = run.Status.FromGraphQl(),
Name = run.Name,
DetailsUrl = run.Permalink,
Summary = run.Summary,
Text = run.Text,
Annotations = run.Annotations(null, null, null, null).AllPages()
.Select(annotation => new CheckRunAnnotationModel
{
Title = annotation.Title,
Message = annotation.Message,
Path = annotation.Path,
AnnotationLevel = annotation.AnnotationLevel.Value.FromGraphQl(),
StartLine = annotation.Location.Start.Line,
EndLine = annotation.Location.End.Line,
}).ToList()
}).ToList(),
ApplicationName = suite.App != null ? suite.App.Name : "Private App"
}).ToList(),
Statuses = commit.Commit.Status
.Select(context =>
context.Contexts.Select(statusContext => new StatusModel
{
State = statusContext.State.FromGraphQl(),
Context = statusContext.Context,
TargetUrl = statusContext.TargetUrl,
Description = statusContext.Description
}).ToList()
).SingleOrDefault()
}
).Compile();
}
query = readCommitStatuses;
}
else
{
if (readCommitStatusesEnterprise == null)
{
readCommitStatusesEnterprise = new Query()
.Repository(owner: Var(nameof(owner)), name: Var(nameof(name)))
.PullRequest(Var(nameof(number))).Commits(last: 1).Nodes.Select(
commit => new LastCommitAdapter
{
Statuses = commit.Commit.Status == null ? null : commit.Commit.Status
.Select(context => context == null
? null
: context.Contexts
.Select(statusContext => new StatusModel
{
State = statusContext.State.FromGraphQl(),
Context = statusContext.Context,
TargetUrl = statusContext.TargetUrl,
Description = statusContext.Description,
}).ToList()
).SingleOrDefault()
}
).Compile();
}
query = readCommitStatusesEnterprise;
}
var vars = new Dictionary <string, object>
{
{ nameof(owner), owner },
{ nameof(name), name },
{ nameof(number), number },
};
var connection = await graphqlFactory.CreateConnection(address);
var result = await connection.Run(query, vars);
return(result.First());
}
public static CompiledQueryPlan BuildPlan <TDoc, TOut>(IMartenSession session, ICompiledQuery <TDoc, TOut> query,
StoreOptions storeOptions)
{
eliminateStringNulls(query);
var plan = new CompiledQueryPlan(query.GetType(), typeof(TOut));
plan.FindMembers();
assertValidityOfQueryType(plan, query.GetType());
// This *could* throw
var queryTemplate = plan.CreateQueryTemplate(query);
var statistics = plan.GetStatisticsIfAny(query);
var builder = BuildDatabaseCommand(session, queryTemplate, statistics, out var command);
plan.IncludePlans.AddRange(new List <IIncludePlan>());
var handler = builder.BuildHandler <TOut>();
if (handler is IIncludeQueryHandler <TOut> i)
{
handler = i.Inner;
}
plan.HandlerPrototype = handler;
plan.ReadCommand(command, storeOptions);
return(plan);
}
/// <summary>
/// Query a SELECT statement which returns results
/// </summary>
/// <param name="query"></param>
/// <param name="result"></param>
/// <returns></returns>
protected CollectionValue Read(ICompiledQuery query, CollectionValue result) {
if (this.Connection != null && this.Connection.State == ConnectionState.Open) {
using (IDbCommand command = this.Connection.CreateCommand()) {
command.CommandText = query.Compiled.FirstOrDefault();
using (IDataReader reader = command.ExecuteReader()) {
if (reader != null) {
while (reader.Read() == true) {
DocumentValue row = new DocumentValue();
for (int field = 0; field < reader.FieldCount; field++) {
row.Set(reader.GetName(field), reader.GetValue(field));
}
result.Add(row);
}
}
}
}
}
return result;
}
protected void QueryCreateIndex(ICompiledQuery query, CollectionValue result) {
if (query.Collections.Any() == true) {
MongoCollection<BsonDocument> collection = this.Database.GetCollection(query.Collections.FirstOrDefault());
BsonArray indices = BsonSerializer.Deserialize<BsonArray>(query.Indices.FirstOrDefault());
if (indices.Count > 1) {
collection.EnsureIndex(new IndexKeysDocument(indices.First().AsBsonDocument), new IndexOptionsDocument(indices.Last().AsBsonDocument));
}
else {
collection.EnsureIndex(new IndexKeysDocument(indices.First().AsBsonDocument));
}
}
}
protected override List<IDatabaseObject> Query(ICompiledQuery query) {
CollectionValue result = new CollectionValue();
List<IDatabaseObject> results = new List<IDatabaseObject>();
try {
results.Add(query.Root is Find ? this.Read(query, result) : this.Execute(query, result));
}
catch (Exception exception) {
results.Add(new Error() {
new StringValue() {
Data = exception.Message
}
});
}
// Execute any index calls.
foreach (ICompiledQuery child in query.Children.Where(child => !(child.Root is Merge))) {
results.AddRange(this.Query(child));
}
return results;
}
private IIncludeJoin GetDictionaryJoin <TKey, TInclude>(ICompiledQuery <TDoc, TOut> query, IncludeResultOperator includeOperator) where TInclude : class
{
var resolver = new DictionaryIncludeCallbackResolver <TKey, TInclude, TDoc, TOut>(query, includeOperator, _storage);
return(doGetJoin <TInclude>(query, includeOperator, resolver));
}
