private SearchRepositoriesRequest getSearchRepoRequest(SearchRepositoriesRequestParameters parameters)
{
SearchRepositoriesRequest repoRequest;
try
{
repoRequest = new SearchRepositoriesRequest(parameters.Term);
}
catch (Exception)
{
repoRequest = new SearchRepositoriesRequest();
}
Language language = (Language)Enum.Parse(typeof(Language), parameters.Language);
repoRequest.User = parameters.Owner;
repoRequest.Language = language;
repoRequest.SortField = getSortBy(parameters.SortBy);
repoRequest.Order = getSortDirection(parameters.Order);
repoRequest.Forks = pickRange(parameters.ForksChoice, parameters.Forks);
repoRequest.Stars = pickRange(parameters.StarsChoice, parameters.Stars);
repoRequest.Size = pickRange(parameters.SizeChoice, parameters.Size);
repoRequest.In = getInParameters(parameters.ReadmeIncluded, parameters.Term);
repoRequest.Created = getCreatedAtParameter(parameters.DateChoice, parameters.Date, parameters.EndDate);
repoRequest.Updated = getUpdatedAtParameter(parameters.UpdatedAt);
return(repoRequest);
}
public async Task <List <Repository> > RequestUserRepositories(string gitUser)
{
var request = new SearchRepositoriesRequest()
{
Fork = ForkQualifier.IncludeForks,
User = gitUser,
SortField = RepoSearchSort.Stars,
};
SearchRepositoryResult initialResult = await client.Search.SearchRepo(request);
List <Repository> results = initialResult.Items.ToList();
int maxPages = (int)Math.Ceiling((double)initialResult.TotalCount / 100);
if (maxPages > 1)
{
for (int i = 2; i <= maxPages; i++)
{
request.Page = i;
SearchRepositoryResult result = await client.Search.SearchRepo(request);
results = results.Concat(result.Items.ToList()).ToList();
}
}
return(results);
}
public async Task <List <Model.Repository> > searchRepos(SearchRepositoriesRequestParameters requestParameters, int firstPage, int lastPage)
{
List <Model.Repository> repos = new List <Model.Repository>();
SearchRepositoriesRequest repoRequest = getSearchRepoRequest(requestParameters);
for (int i = firstPage; i <= lastPage; i++)
{
repoRequest.Page = i;
SearchRepositoryResult result = await GlobalVariables.client.Search.SearchRepo(repoRequest);
repos.AddRange(result.Items.Select(repo => new Model.Repository
{
Name = repo.Name,
Owner = repo.Owner.Login,
Size = repo.Size,
CreatedAt = repo.CreatedAt,
UpdatedAt = repo.UpdatedAt,
StargazersCount = repo.StargazersCount,
HtmlUrl = repo.HtmlUrl,
Description = repo.Description,
ForksCount = repo.ForksCount,
Language = repo.Language
}).ToList());
}
return(repos);
}
public async Task <DiscordCommandResult> GitSearchReposAsync([Name("Search Query"), Remainder] string searchQuery)
{
var request = new SearchRepositoriesRequest(searchQuery);
var result = await _lexGithubClient.Search.SearchRepo(request);
switch (result.Items.Count)
{
case 0:
return(NoResultsFoundResponse());
default:
{
var fieldBuilders = new List <LocalEmbedField>(result.Items.Count);
foreach (var item in result.Items)
{
var description = GetRepoSearchResultDescription(item);
fieldBuilders.Add(new LocalEmbedField().WithName(item.Name)
.WithValue($"{description} {Markdown.Link("Link", item.HtmlUrl)}"));
}
var config =
FieldBasedPageProviderConfiguration.Default.WithContent(
$"I have found {result.Items.Count} results");
return(Pages(new FieldBasedPageProvider(fieldBuilders, config)));
}
}
}
public async Task <IActionResult> Search(string q, int pagesize = 30, int page = 0)
{
var srr = new SearchRepositoriesRequest(q)
{
PerPage = pagesize,
Page = page,
In = new[] { InQualifier.Name },
};
try
{
var result = await _githubClient.Search.SearchRepo(srr);
var ids = _localServiceClient.GetRepos()?
.Select(m => m.Id);
if (ids != null)
{
return(Json(result.Items.Where(i => !ids.Contains(i.Id.ToString()))));
}
return(Json(result.Items));
}
catch (Exception e)
{
_logger.LogError(e, "Problem");
return(Problem());
}
}
public IEnumerable <Uri> GetUris(int numberOfUris, SearchRepositoriesRequest searchRepositoriesRequest)
{
var uris = new List <Uri>();
if (numberOfUris < 1)
{
throw new GitHubActiveReposFinderException("Cannot look for less than 1 Uris");
}
if (numberOfUris > 999)
{
throw new GitHubActiveReposFinderException("Cannot look for more than 999 Uris");
}
var itemsPerPage = 100; // seems to be a maximum of 100 for GitHub
int pagesNeeded = (numberOfUris / itemsPerPage) + 1;
for (int page = 1; page <= pagesNeeded; page++)
{
searchRepositoriesRequest.PerPage = itemsPerPage;
searchRepositoriesRequest.Page = page;
SearchRepositoryResult result = _githubClient.Search.SearchRepo(searchRepositoriesRequest).Result;
uris.AddRange(result.Items.Select(repos => new Uri(repos.HtmlUrl)));
}
return(uris
.Distinct()
.Take(numberOfUris));;
}
//
// GET: /Home/
public ActionResult Index()
{
//github.Credentials = new Credentials("f0f911b0cbccb5cadd20a969cd7c1239df771d5f");
_github.Credentials = new Credentials((string)Session["token"]);
var searchRepositoriesRequest = new SearchRepositoriesRequest("erm")
{
Language = Language.CSharp,
Order = SortDirection.Descending,
PerPage = 10,
};
var repo = _github.Repository.Get("ermtech", "erm.trunk").Result;
var commits = _github.Repository.Commits.GetAll("ermtech", "erm.trunk").Result;
SearchRepositoryResult searchRepositoryResult = _github.Search.SearchRepo(searchRepositoriesRequest).Result;
return(View(searchRepositoryResult.Items));
}
public async Task <GitHubSearchApiResponse> GetResponse(SearchRepositoriesRequest request)
{
var apiResponse = await _client.Connection.Get <SearchRepositoryResult>(ApiUrls.SearchRepositories(), request.Parameters, null);
// According to RFC 2616, Http headers are case-insensitive. We should treat them as such.
var caseInsensitiveHeaders = apiResponse.HttpResponse.Headers
.AsEnumerable()
.GroupBy(x => x.Key, StringComparer.OrdinalIgnoreCase)
.ToDictionary(x => x.Key, x => x.First().Value, StringComparer.OrdinalIgnoreCase);
if (!caseInsensitiveHeaders.TryGetValue("Date", out var ghStrDate) ||
!DateTimeOffset.TryParseExact(ghStrDate.Replace("GMT", "+0"), "ddd',' dd MMM yyyy HH:mm:ss z", CultureInfo.InvariantCulture, DateTimeStyles.None, out var ghTime))
{
throw new InvalidDataException("Date is missing, has a wrong format or is not in GMT timezone");
}
if (!caseInsensitiveHeaders.TryGetValue("X-Ratelimit-Reset", out var ghStrResetLimit) ||
!long.TryParse(ghStrResetLimit, out var ghResetTime))
{
throw new InvalidDataException("X-Ratelimit-Reset is required to compute the throttling time.");
}
return(new GitHubSearchApiResponse(
apiResponse.Body.Items
.Select(repo => new WritableRepositoryInformation(
repo.FullName,
repo.HtmlUrl,
repo.StargazersCount,
repo.Description ?? "",
repo.DefaultBranch))
.ToList(),
ghTime,
DateTimeOffset.FromUnixTimeSeconds(ghResetTime)));
}
public async Task <GitHubSearchApiResponse> GetResponse(SearchRepositoriesRequest request)
{
var apiResponse = await _client.Connection.Get <SearchRepositoryResult>(ApiUrls.SearchRepositories(), request.Parameters, null);
if (!apiResponse.HttpResponse.Headers.TryGetValue("Date", out var ghStrDate) ||
!DateTimeOffset.TryParseExact(ghStrDate.Replace("GMT", "+0"), "ddd',' dd MMM yyyy HH:mm:ss z", CultureInfo.InvariantCulture, DateTimeStyles.None, out var ghTime))
{
throw new InvalidDataException("Date is missing, has a wrong format or is not in GMT timezone");
}
if (!apiResponse.HttpResponse.Headers.TryGetValue("X-Ratelimit-Reset", out var ghStrResetLimit) ||
!long.TryParse(ghStrResetLimit, out var ghResetTime))
{
throw new InvalidDataException("X-Ratelimit-Reset is required to compute the throttling time.");
}
return(new GitHubSearchApiResponse(
apiResponse.Body.Items
.Select(repo => new WritableRepositoryInformation(
repo.FullName,
repo.HtmlUrl,
repo.StargazersCount,
repo.Description ?? "",
repo.DefaultBranch))
.ToList(),
ghTime,
DateTimeOffset.FromUnixTimeSeconds(ghResetTime)));
}
public async Task <SearchRepositoryResult> GetRepository(string repositoryName)
{
var request = new SearchRepositoriesRequest(repositoryName);
var result = await _client.Search.SearchRepo(request);
return(result);
}
private static List <RepositoryInfo> CrawlGithub()
{
File.Delete(Program.VerboseCommits);
File.Delete(Program.Commits);
int numOfPages = Convert.ToInt32(Math.Ceiling(options.NumberOfRepos / 100.0));
int reposLeft = options.NumberOfRepos;
List <RepositoryInfo> repos = new List <RepositoryInfo>();
for (int pi = 0; pi < numOfPages; pi++)
{
var sc = new SearchRepositoriesRequest();
sc.Language = Language.C;
sc.Size = Range.LessThan(Program.ProgramSize);
sc.Page = pi;
var result = Program.GitHubClient.Search.SearchRepo(sc);
result.Wait();
foreach (var repo in result.Result.Items.Take(reposLeft))
{
var r = new RepositoryInfo(repo.Name, repo.Owner.Login, repo.GitUrl, repo.HtmlUrl);
repos.Add(r);
}
reposLeft -= result.Result.Items.Count;
}
PrintRepositories(repos);
return(repos);
}
private static async Task RepositoryAllFieldsExample(GitHubClient client)
{
var fromDate = new DateTime(2012, 3, 17);
var toDate = new DateTime(2019, 3, 17);
int fromNumber = 1;
int toNumber = 10000;
string term = "octokit";
string user = "******";
var request = new SearchRepositoriesRequest(term)
{
Archived = false,
Created = new DateRange(fromDate, toDate),
Fork = ForkQualifier.IncludeForks,
Forks = new Range(fromNumber, toNumber),
In = new InQualifier[] { InQualifier.Name },
Language = Language.CSharp,
Order = SortDirection.Descending,
Size = new Range(fromNumber, SearchQualifierOperator.GreaterThan),
SortField = RepoSearchSort.Stars,
Stars = new Range(fromNumber, SearchQualifierOperator.GreaterThanOrEqualTo),
Updated = new DateRange(fromDate, SearchQualifierOperator.GreaterThan),
User = user
};
SearchRepositoryResult result = await client.Search.SearchRepo(request);
Console.WriteLine($"Search.SearchRepo (All Fields): TotalCount={result.TotalCount}");
}
public ActionResult GetRepoOnly(string search_crit)
{
var request_repo = new SearchRepositoriesRequest(search_crit);
var result_repo = client.Search.SearchRepo(request_repo).Result;
return(Json(result_repo));
}
public async Task <IEnumerable <Repository> > GetRepositories(RepoSearchRequestViewModel repoRequest)
{
var github = new GitHubClient(new ProductHeaderValue("DanTest"));
var request = new SearchRepositoriesRequest(repoRequest.Term)
{
Language = repoRequest.Language,
Order = SortDirection.Descending,
SortField = RepoSearchSort.Updated,
Archived = repoRequest.IsArchived,
PerPage = 10
};
if ((int)repoRequest.Language != -1)
{
request.Language = repoRequest.Language;
}
var forksRange = BuildRange(repoRequest.ForkFrom, repoRequest.ForkTo);
var sizeRange = BuildRange(repoRequest.SizeFrom, repoRequest.SizeTo);
var starsRange = BuildRange(repoRequest.StarsFrom, repoRequest.StarsTo);
request.Forks = forksRange;
request.Size = sizeRange;
request.Stars = starsRange;
var repos = await github.Search.SearchRepo(request);
return(repos.Items);
}
public RepositoryExploreViewModel(ISessionService applicationService)
{
ShowRepositoryDescription = applicationService.Account.ShowRepositoryDescriptionInList;
Title = "Explore Repositories";
var gotoRepository = new Action <RepositoryItemViewModel>(x => {
var vm = this.CreateViewModel <RepositoryViewModel>();
vm.Init(x.Owner, x.Name, x.Repository);
NavigateTo(vm);
});
Items = InternalItems.CreateDerivedCollection(x =>
new RepositoryItemViewModel(x, true, gotoRepository));
var canSearch = this.WhenAnyValue(x => x.SearchKeyword).Select(x => !string.IsNullOrEmpty(x));
SearchCommand = ReactiveCommand.CreateAsyncTask(canSearch, async t => {
try
{
InternalItems.Clear();
var request = new SearchRepositoriesRequest(SearchKeyword);
var response = await applicationService.GitHubClient.Search.SearchRepo(request);
InternalItems.Reset(response.Items);
}
catch (Exception e)
{
var msg = string.Format("Unable to search for {0}. Please try again.", SearchKeyword.Humanize());
throw new Exception(msg, e);
}
});
}
public static async Task <Repository> GetRepoFromGitHub(ModUpdateInfo info, string repoName,
string repoAuthor = "")
{
if (repoName != "" && repoAuthor != "")
{
return(info.Client.Repository.Get(repoAuthor, repoName).Result);
}
var request = new SearchRepositoriesRequest(repoName)
{
Language = Language.CSharp,
Archived = false
};
var searchResult = await info.Client.Search.SearchRepo(request);
Repository repository = null;
if (searchResult?.Items?.Count > 0)
{
repository = searchResult.Items.First();
}
return(repository);
}
public async Task <bool> Synchronize()
{
Language[] languages = { Language.JavaScript, Language.CSharp, Language.Python, Language.Java, Language.Kotlin };
for (var cont = 0; cont < languages.Count(); cont++)
{
var request = new SearchRepositoriesRequest()
{
// Habilitei a busca para pegar apenas projetos com mais de 1000 estrelas
Stars = Range.GreaterThan(1000),
// Defini qual a linguagem de programação a ser pesquisada
Language = languages[cont],
// Defini a ordenação dos resultados pela quantidade de estrelas
SortField = RepoSearchSort.Stars
};
var response = await _client.Search.SearchRepo(request);
var result = response.Items.Take(25);
_projects.AddRange(result.Select(a => new Project
{
ProductOwner = a.Owner.Login,
ProjectName = a.Name,
ProjectLink = a.HtmlUrl,
Language = _languages[cont]
}).ToList());
}
AddOnDatabase();
return(true);
}
public async Task SearchForCSharpRepositories()
{
var request = new SearchRepositoriesRequest("csharp");
var repos = await _gitHubClient.Search.SearchRepo(request);
Assert.NotEmpty(repos.Items);
}
/// <summary>
/// Used to get different quearys depending on language, also set quesry sorted on date.
/// </summary>
/// <param name="language"></param>
/// <returns></returns>
public SearchRepositoriesRequest GetNewQuery(Language language)
{
var query = new SearchRepositoriesRequest(_searchWord);
query.Language = language;
query.SortField = RepoSearchSort.Updated;
return(query);
}
public static async Task <SearchRepositoryResult> SearchGitHub(string term)
{
SearchRepositoriesRequest srch = new SearchRepositoriesRequest();
srch.User = term;
var results = await client.Search.SearchRepo(srch);
return(results);
}
public HomeController(ILogger <HomeController> logger, ILinkGetter linkGetter, ILinkChecker linkChecker, SearchRepositoriesRequest searchRepositoriesRequest,
GitHubActiveReposFinder gitHubActiveReposFinder)
{
_logger = logger;
_linkGetter = linkGetter;
_linkChecker = linkChecker;
_searchRepositoriesRequest = searchRepositoriesRequest;
_gitHubActiveReposFinder = gitHubActiveReposFinder;
}
private void DisplayGitHubSearchRequestParameters(SearchRepositoriesRequest searchRepositoriesRequest)
{
Console.WriteLine("Searching for Repos with");
Console.WriteLine($" - Min Stars: {searchRepositoriesRequest.Stars.ToString()}");
Console.WriteLine($" - Udated: {searchRepositoriesRequest.Updated.ToString()}");
Console.WriteLine($" - SortField {searchRepositoriesRequest.SortField.ToString()}");
Console.WriteLine($" - Order {searchRepositoriesRequest.Order.ToString()}");
Console.WriteLine();
}
private static SearchRepositoriesRequest GetSearchRequestParams(string filter, int page)
{
var searchParams = new SearchRepositoriesRequest(filter);
searchParams.Page = page;
searchParams.PerPage = _RESULTS_PER_PAGE;
return(searchParams);
}
public List <UserActivityDTO> GetUserActivity(ActivityDTO activity)
{
List <UserActivityDTO> user_activities = new List <UserActivityDTO>();
var user_profiles = dc.UserProfiles.Where(i => i.ProfilePropertyDefinition.PropertyName == activity.settings["Profile"].ToString()).Select(i => new { user_id = i.UserID, gitHub_login = i.PropertyValue }).ToList();
GitHubClient gitHubClient = new GitHubClient(new ProductHeaderValue("Dnn.CommunityActivity"));
gitHubClient.Credentials = new Credentials(activity.settings["Credentials"].ToString());
List <Repository> repositories = new List <Repository>();
var totalCount = int.MaxValue;
var page = 1;
// get a list of all the repos matching the search criteria
while (repositories.Count() < totalCount)
{
var request = new SearchRepositoriesRequest(activity.settings["Query"].ToString())
{
Page = page,
};
var result = gitHubClient.Search.SearchRepo(request).Result;
totalCount = result.TotalCount;
repositories.AddRange(result.Items);
page++;
}
foreach (Repository repository in repositories)
{
IReadOnlyList <Octokit.User> users = gitHubClient.Activity.Starring.GetAllStargazers(repository.Id).Result;
foreach (Octokit.User user in users)
{
var user_profile = dc.UserProfiles.Where(i => i.ProfilePropertyDefinition.PropertyName == activity.settings["Profile"].ToString() && i.PropertyValue == user.Login).SingleOrDefault();
if (user_profile != null)
{
var user_activity = user_activities.Where(i => i.user_id == user_profile.UserID && i.activity_id == activity.id).Single();
if (user_activity == null)
{
user_activity = new UserActivityDTO()
{
user_id = user_profile.UserID,
activity_id = activity.id,
count = 0,
created_on_date = DateTime.Now,
date = DateTime.Now
};
user_activities.Add(user_activity);
}
user_activity.count++;
}
}
}
return(user_activities);
}
private async Task <IReadOnlyList <WritableRepositoryInformation> > GetResultsFromGitHub()
{
_logger.LogInformation("Starting GitHub search with configuration: {ConfigInfo}", GetConfigInfo());
_throttleResetTime = DateTimeOffset.UtcNow;
var upperStarBound = int.MaxValue;
var resultList = new List <WritableRepositoryInformation>();
var lastPage = Math.Ceiling(_maxGithubResultPerQuery / (double)_resultsPerPage);
while (upperStarBound >= _minStars)
{
var page = 0;
while (page < lastPage)
{
await CheckThrottle();
var request = new SearchRepositoriesRequest
{
Stars = new Range(_minStars, upperStarBound),
Language = Language.CSharp,
SortField = RepoSearchSort.Stars,
Order = SortDirection.Descending,
PerPage = _resultsPerPage,
Page = page + 1
};
var response = await SearchRepo(request);
if (response == null || !response.Any())
{
_logger.LogWarning("Search request didn't return any item. Page: {Page} {ConfigInfo}", request.Page, GetConfigInfo());
return(resultList);
}
// TODO: Block unwanted repos (https://github.com/NuGet/NuGetGallery/issues/7298)
resultList.AddRange(response);
page++;
if (page == lastPage && response.First().Stars == response.Last().Stars)
{
// GitHub throttles us after a certain number of results per query.
// We can only construct queries based on number of stars a repository has.
// As a result, if too many repositories have the same number of stars,
// we will lose data because we can't create another query that filters out the results that we have already seen with the same number of stars.
_logger.LogWarning("Last page results have the same star count! This may result in missing data. StarCount: {Stars} {ConfigInfo}",
response.First().Stars,
GetConfigInfo());
return(resultList);
}
}
upperStarBound = resultList.Last().Stars;
}
return(resultList);
}
public async Task SearchForForkedRepositories()
{
var request = new SearchRepositoriesRequest("octokit")
{
Fork = ForkQualifier.IncludeForks
};
var repos = await _gitHubClient.Search.SearchRepo(request);
Assert.Contains(repos.Items, x => x.Fork);
}
public void LanguageUsesParameterTranslation()
{
var request = new SearchRepositoriesRequest()
{
Language = Language.CPlusPlus
};
var result = request.MergedQualifiers();
Assert.Contains(result, x => string.Equals(x, "language:\"cpp\""));
}
public void LicenseUsesParameterTranslation()
{
var request = new SearchRepositoriesRequest()
{
License = RepoSearchLicense.Apache_2_0
};
var result = request.MergedQualifiers();
Assert.Contains(result, x => string.Equals(x, "license:apache-2.0"));
}
public async Task SearchForOnlyForkedRepositories()
{
var request = new SearchRepositoriesRequest("octokit")
{
Fork = ForkQualifier.OnlyForks
};
var repos = await _gitHubClient.Search.SearchRepo(request);
Assert.True(repos.Items.All(x => x.Fork));
}
public static IEnumerable <RepoResult> SearchRepositories(string term)
{
var client = new GitHubClient(new ProductHeaderValue("fnxExcersize"));
var request = new SearchRepositoriesRequest(term);
var itms = client.Search.SearchRepo(request).Result.Items;
return(itms.ToRepoResult());
}
public void TestingTheStarsQualifier()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
//get repos whos stargazers are greater than 500
var request = new SearchRepositoriesRequest("github");
request.Stars = Range.GreaterThan(500);
client.SearchRepo(request);
connection.Received().GetAll<Repository>(Arg.Is<Uri>(u => u.ToString() == "search/repositories"), Arg.Any<Dictionary<string, string>>());
}
public void TestingTheSortParameter()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
//get repos where the Description contains rails and user/org is 'github'
var request = new SearchRepositoriesRequest("rails");
request.Sort = RepoSearchSort.Forks;
client.SearchRepo(request);
connection.Received().Get<SearchRepositoryResult>(Arg.Is<Uri>(u => u.ToString() == "search/repositories"), Arg.Any<Dictionary<string, string>>());
}
public void TestingTheUpdatedQualifier()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
//get repos where the search contains 'github' and has been pushed before year jan 1 2013
var request = new SearchRepositoriesRequest("github");
request.Updated = DateRange.LessThan(new DateTime(2013, 1, 1));
client.SearchRepo(request);
connection.Received().Get<SearchRepositoryResult>(Arg.Is<Uri>(u => u.ToString() == "search/repositories"), Arg.Any<Dictionary<string, string>>());
}
public void TestingTheInQualifier()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
//get repos where the Description contains the test 'github'
var request = new SearchRepositoriesRequest("github");
request.In = new[] { InQualifier.Description };
client.SearchRepo(request);
connection.Received().Get<SearchRepositoryResult>(Arg.Is<Uri>(u => u.ToString() == "search/repositories"), Arg.Any<Dictionary<string, string>>());
}
public void TestingTheLangaugeQualifier()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
//get repos whos language is Ruby
var request = new SearchRepositoriesRequest("github");
request.Language = Language.Ruby;
client.SearchRepo(request);
connection.Received().Get<SearchRepositoryResult>(Arg.Is<Uri>(u => u.ToString() == "search/repositories"), Arg.Any<Dictionary<string, string>>());
}
public void TestingTheUpdatedQualifier_Between()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
var request = new SearchRepositoriesRequest("github");
request.Updated = DateRange.Between(new DateTime(2012, 4, 30), new DateTime(2012, 7, 4));
client.SearchRepo(request);
connection.Received().Get<SearchRepositoryResult>(Arg.Is<Uri>(u => u.ToString() == "search/repositories"),
Arg.Is<Dictionary<string, string>>(d => d["q"] == "github+pushed:2012-04-30..2012-07-04"));
}
public void TestingTheCreatedQualifier()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
//get repos where the search contains 'github' and has been created after year jan 1 2011
var request = new SearchRepositoriesRequest("github");
request.Created = DateRange.GreaterThan(new DateTime(2011, 1, 1));
client.SearchRepo(request);
connection.Received().GetAll<Repository>(Arg.Is<Uri>(u => u.ToString() == "search/repositories"), Arg.Any<Dictionary<string, string>>());
}
public void TestingTheInQualifier_Multiple()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
var request = new SearchRepositoriesRequest("github");
request.In = new[] { InQualifier.Readme, InQualifier.Description, InQualifier.Name };
client.SearchRepo(request);
connection.Received().Get<SearchRepositoryResult>(
Arg.Is<Uri>(u => u.ToString() == "search/repositories"),
Arg.Is<Dictionary<string, string>>(d => d["q"] == "github+in:Readme,Description,Name"));
}
/// <summary>
/// search repos
/// http://developer.github.com/v3/search/#search-repositories
/// </summary>
/// <param name="search"></param>
/// <returns>List of repositories</returns>
public IObservable<SearchRepositoryResult> SearchRepo(SearchRepositoriesRequest search)
{
Ensure.ArgumentNotNull(search, "search");
return _client.SearchRepo(search).ToObservable();
}
public void TestingTheSearchParameter()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
var request = new SearchRepositoriesRequest();
client.SearchRepo(request);
connection.Received().Get<SearchRepositoryResult>(
Arg.Is<Uri>(u => u.ToString() == "search/repositories"),
Arg.Is<Dictionary<string, string>>(d =>
String.IsNullOrEmpty(d["q"])));
}
public void TestingTheSortParameter()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
var request = new SearchRepositoriesRequest("github");
request.SortField = RepoSearchSort.Stars;
client.SearchRepo(request);
connection.Received().Get<SearchRepositoryResult>(
Arg.Is<Uri>(u => u.ToString() == "search/repositories"),
Arg.Is<Dictionary<string, string>>(d =>
d["q"] == "github" &&
d["sort"] == "stars"));
}
public void TestingTheUserQualifier()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
//get repos where search contains 'github' and user/org is 'github'
var request = new SearchRepositoriesRequest("github");
request.User = "******";
client.SearchRepo(request);
connection.Received().Get<SearchRepositoryResult>(Arg.Is<Uri>(u => u.ToString() == "search/repositories"),
Arg.Is<Dictionary<string, string>>(d => d["q"] == "github+user:rails"));
}
public void TestingTheStarsQualifier_LessThanOrEquals()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
//get repos whos stargazers are less than 500 or equal to
var request = new SearchRepositoriesRequest("github");
request.Stars = Range.LessThanOrEquals(500);
client.SearchRepo(request);
connection.Received().Get<SearchRepositoryResult>(
Arg.Is<Uri>(u => u.ToString() == "search/repositories"),
Arg.Is<Dictionary<string, string>>(d => d["q"] == "github+stars:<=500"));
}
public void TestingTheForksQualifier()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
//get repos which has forks that are greater than 50
var request = new SearchRepositoriesRequest("github");
request.Forks = Range.GreaterThan(50);
client.SearchRepo(request);
connection.Received().Get<SearchRepositoryResult>(Arg.Is<Uri>(u => u.ToString() == "search/repositories"),
Arg.Is<Dictionary<string, string>>(d => d["q"] == "github+forks:>50"));
}
/// <summary>
/// search repos
/// http://developer.github.com/v3/search/#search-repositories
/// </summary>
/// <param name="request"></param>
/// <returns>List of repositories</returns>
public IObservable<Repository> SearchRepo(SearchRepositoriesRequest request)
{
Ensure.ArgumentNotNull(request, "request");
return _connection.GetAndFlattenAllPages<Repository>(ApiUrls.SearchRepositories(), request.Parameters);
}
public void TestingTheSizeQualifier()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
//check sizes for repos that are greater than 50 MB
var request = new SearchRepositoriesRequest("github");
request.Size = Range.GreaterThan(50);
client.SearchRepo(request);
connection.Received().Get<SearchRepositoryResult>(Arg.Is<Uri>(u => u.ToString() == "search/repositories"), Arg.Any<Dictionary<string, string>>());
}
public void TestingTheUserQualifier()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
//get repos where the Description contains rails and user/org is 'github'
var request = new SearchRepositoriesRequest("rails");
request.User = "******";
client.SearchRepo(request);
connection.Received().GetAll<Repository>(Arg.Is<Uri>(u => u.ToString() == "search/repositories"), Arg.Any<Dictionary<string, string>>());
}
public void TestingTheForkQualifier()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
//search repos that contains rails and forks are included in the search
var request = new SearchRepositoriesRequest("rails");
request.Fork = ForkQualifier.IncludeForks;
client.SearchRepo(request);
connection.Received().Get<SearchRepositoryResult>(Arg.Is<Uri>(u => u.ToString() == "search/repositories"), Arg.Any<Dictionary<string, string>>());
}
public void TestingTheSizeQualifier()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
var request = new SearchRepositoriesRequest("github");
request.Size = Range.GreaterThan(1);
client.SearchRepo(request);
connection.Received().Get<SearchRepositoryResult>(
Arg.Is<Uri>(u => u.ToString() == "search/repositories"),
Arg.Is<Dictionary<string, string>>(d => d["q"] == "github+size:>1"));
}
public void TestingTheCreatedQualifier_LessThanOrEquals()
{
var connection = Substitute.For<IApiConnection>();
var client = new SearchClient(connection);
//get repos where the search contains 'github' and has been created after year jan 1 2011
var request = new SearchRepositoriesRequest("github");
request.Created = DateRange.LessThanOrEquals(new DateTime(2011, 1, 1));
client.SearchRepo(request);
connection.Received().Get<SearchRepositoryResult>(Arg.Is<Uri>(u => u.ToString() == "search/repositories"),
Arg.Is<Dictionary<string, string>>(d => d["q"] == "github+created:<=2011-01-01"));
}
