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);
}
private async void SearchBox_OnSuggestionsRequested(SearchBox sender, SearchBoxSuggestionsRequestedEventArgs args)
{
if (string.IsNullOrWhiteSpace(args.QueryText))
{
return;
}
var deferral = args.Request.GetDeferral();
SearchRepositoryResult result = await Util.Search(args.QueryText);
foreach (Repository item in result.Items)
{
if (args.Request.IsCanceled)
{
return;
}
args.Request.SearchSuggestionCollection.AppendResultSuggestion(
item.FullName,
item.Description ?? "No description",
item.Id.ToString(),
RandomAccessStreamReference.CreateFromUri(new Uri(item.Owner.AvatarUrl)),
"NoImage"
);
}
deferral.Complete();
}
/// <summary>
/// Enumerate repositories.
/// </summary>
/// <returns>The list of repositories.</returns>
public static async Task <List <GitHubRepository> > EnumerateRepositories()
{
List <GitHubRepository> Result = new();
if (await Connect())
{
LastRepositorySearchTime = DateTimeOffset.UtcNow;
SearchRepositoriesRequest Request = new() { User = User.Login };
SearchRepositoryResult RequestResult = await Client.Search.SearchRepo(Request);
foreach (Repository Repository in RequestResult.Items)
{
if (Repository.Archived)
{
continue;
}
Result.Add(new GitHubRepository(Repository));
}
}
lock (RepositoryActivityList)
{
RepositoryActivityList.Clear();
RepositoryActivityList.AddRange(Result);
}
return(Result);
}
}
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 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);
}
//
// 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 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));;
}
private void ProcessForDB(int currentBatch, int currentPage, SearchRepositoryResult searchResult)
{
lock (_lockDBWriter)
{
try
{
int alreadyProcessedInBlock = 0;
foreach (var repo in searchResult.Items)
{
if (AlreadyProcessedRepoIds.Contains(repo.Id))
{
alreadyProcessedInBlock++;
continue;
}
var repoInfo = new RepositoryInfo
{
GitHubId = repo.Id,
Archived = repo.Archived,
CreatedAt = repo.CreatedAt,
DefaultBranch = repo.DefaultBranch,
Description = repo.Description,
Fork = repo.Fork,
ForksCount = repo.ForksCount,
HasDownloads = repo.HasDownloads,
HasIssues = repo.HasIssues,
HasPages = repo.HasPages,
HasWiki = repo.HasWiki,
Homepage = repo.Homepage,
HtmlUrl = repo.HtmlUrl,
IsTemplate = repo.IsTemplate,
Language = repo.Language,
LicenseKey = repo.License?.Key,
MirrorUrl = repo.MirrorUrl,
Name = repo.Name,
NodeId = repo.NodeId,
OpenIssuesCount = repo.OpenIssuesCount,
OwnerLoginName = repo.Owner.Login,
PushedAt = repo.PushedAt,
Size = repo.Size,
StargazersCount = repo.StargazersCount,
UpdatedAt = repo.UpdatedAt,
WatchersCount = repo.WatchersCount
};
Context.RepositoryInfos.Add(repoInfo);
AlreadyProcessedRepoIds.Add(repo.Id);
}
Log.Info($"Processed changes of #{currentBatch}/({currentPage})={searchResult.Items.Count - alreadyProcessedInBlock}; already processed repos={alreadyProcessedInBlock}");
}
catch (Exception ex)
{
Log.Error($"Failed to process for DB #{currentBatch}/({currentPage})", ex);
}
}
}
public async Task <SearchRepositoryResult> searchGitHubRepository(string searchTerm)
{
var githubClient = new GitHubClient(new ProductHeaderValue("TesteAteliware"));
var request = new SearchRepositoriesRequest(searchTerm);
var result = await githubClient.Search.SearchRepo(request);
this.result = result;
return(result);
}
//Octokit doesnt seems to return forked repositories ...
public async Task <List <Repository> > getUserMostStarredRepositoriesAsync(string login, int limit)
{
var request = new SearchRepositoriesRequest()
{
Fork = ForkQualifier.IncludeForks,
User = login
};
SearchRepositoryResult searchResult = await _client.Search.SearchRepo(request);
return(searchResult.Items.OrderByDescending(r => r.StargazersCount).Take(limit).ToList());
}
private void CarregarRepository(SearchRepositoryResult result)
{
List <UsuarioRepository> listaRepository = new List <UsuarioRepository>();
foreach (var repositoryUsuario in result.Items)
{
//armazena os dados de Id, Name e URL
listaRepository.Add(new UsuarioRepository(repositoryUsuario.Id, repositoryUsuario.Name, repositoryUsuario.Url));
}
dataGrid.ItemsSource = listaRepository;
}
private void ListarRepositoryUsuario()
{
var consultarUsuario = new SearchRepositoriesRequest()
{
User = txtNome.Text
};
SearchRepositoryResult resultadoConsulta = gitHubClient.Search.SearchRepo(consultarUsuario).Result;
CarregarRepository(resultadoConsulta);
//carrega os dados Id, Name e URL na dataGrid
dataGrid.ItemsSource = resultadoConsulta.Items.Select(i => new { i.Name, i.Url });
}
private void TrySetLastRepo(int currentBatch, int currentPage, SearchRepositoryResult searchResult, Action <Repository> onLastRepo)
{
var lastRepo = searchResult.Items.Last();
if (lastRepo == null)
{
Log.Warn($"Unable to find last repo for search-page ({currentPage}) of batch #{currentBatch} skipping it");
}
else
{
onLastRepo?.Invoke(lastRepo);
}
}
public static async Task <SearchRepositoryResult> SearchRepositories(string searchedVal)
{
try
{
var client = new GitHubClient(new Octokit.ProductHeaderValue("octokit"));
SearchRepositoryResult repos = await client.Search.SearchRepo(new SearchRepositoriesRequest(searchedVal));
return(repos);
}
catch (Exception ex)
{
throw ex;
}
}
private async void searchButton_Click(object sender, EventArgs e)
{
var term = searchBox.Text;
var results = await GitHubClientActions.SearchGitHub(term);
searchResults = results;
foreach (var res in searchResults.Items)
{
SearchResultGrid result = new SearchResultGrid {
FullName = res.FullName, URL = new Uri(res.Url), Stars = res.StargazersCount.ToString(), Language = res.Language, OpenIssues = res.OpenIssuesCount.ToString()
};
gridData.Add(result);
}
resultsGrid.DataSource = gridData;
}
public async Task <IEnumerable <GitRemoteRepository> > SearchAsync(
Guid serviceId,
string searchString,
CancellationToken cancellationToken)
{
GitHubConnectedService service = await _clientFactory.ConnectAsync(serviceId, cancellationToken);
GitHubClient client = _clientFactory.CreateClient(serviceId);
var request = new SearchRepositoriesRequest(searchString);
request.User = service.Owner;
SearchRepositoryResult searchResult = await client.Search.SearchRepo(request);
return(searchResult.Items.Select(x => ToRemoteRepository(service, x)));
}
private static void OnActivitySearchComplete(SearchRepositoryResult searchResult)
{
List <long> ModifiedRepositoryIdList = new();
foreach (Repository Repository in searchResult.Items)
{
if (Repository.Archived)
{
continue;
}
ModifiedRepositoryIdList.Add(Repository.Id);
}
NotifyActivityReported(ModifiedRepositoryIdList);
}
private static void ActivityTimerCallback(object parameter)
{
switch (State)
{
default:
case ActivityTimerState.Init:
case ActivityTimerState.GetRemainingRequests:
GetRateLimitsTask = Client.Miscellaneous.GetRateLimits();
State = ActivityTimerState.Reconnect;
break;
case ActivityTimerState.Reconnect:
if (GetRateLimitsTask == null || !GetRateLimitsTask.IsCompleted)
{
return;
}
RemainingRequests = TranslateRateLimits(GetRateLimitsTask.Result);
GetRateLimitsTask = null;
if (RemainingRequests >= RemainingRequestsThreshold)
{
ScheduleActivityCheck();
State = ActivityTimerState.EnumerateRepositories;
}
else
{
State = ActivityTimerState.GetRemainingRequests;
}
break;
case ActivityTimerState.EnumerateRepositories:
if (RepositoryActivityTask == null || !RepositoryActivityTask.IsCompleted)
{
return;
}
SearchRepositoryResult SearchResult = RepositoryActivityTask.Result;
RepositoryActivityTask = null;
OnActivitySearchComplete(SearchResult);
State = ActivityTimerState.GetRemainingRequests;
break;
}
}
private static List <RepositorioGitDTO> ObterRepositoriosGitDoUsuarioLogado()
{
repositoriosGitDTO = new List <RepositorioGitDTO>();
var buscaRepositoriosGitUsuario = new SearchRepositoriesRequest()
{
User = ConfigConsumoGitWebServices.UsuarioGit
};
SearchRepositoryResult repositoriosGitUsuario = gitHubClient.Search.SearchRepo(buscaRepositoriosGitUsuario).Result;
foreach (var item in repositoriosGitUsuario.Items)
{
repositoriosGitDTO.Add(new RepositorioGitDTO {
Id = item.Id, Nome = item.Name, CloneUrl = item.CloneUrl, Url = item.Url
});
}
return(repositoriosGitDTO);
}
private static async Task RepositoryExamples(GitHubClient client)
{
Repository repository = await client.Repository.Get("octokit", "octokit.net");
Console.WriteLine($"Repository.Get: Id={repository.Id}");
Branch branch = await client.Repository.Branch.Get("octokit", "octokit.net", "master");
Console.WriteLine($"Repository.Branch.Get: Name={branch.Name}");
SearchRepositoryResult result = await client.Search.SearchRepo(
new SearchRepositoriesRequest("octokit")
{
In = new InQualifier[] { InQualifier.Name }
});
Console.WriteLine($"Search.SearchRepo (Simple Search): TotalCount={result.TotalCount}");
await RepositoryAllFieldsExample(client);
}
public ServiceTests()
{
//Configure db
var optionsBuilder =
new DbContextOptionsBuilder <GithubReposContext>()
.UseInMemoryDatabase("githubReposTestDB");
var _dbContext = new GithubReposContext(optionsBuilder.Options);
//Mock octokit
ReadOnlyCollection <Repository> mockedRepos = new ReadOnlyCollection <Repository>(GetRepos());
var response = new SearchRepositoryResult(ListSize, false, mockedRepos);
var mockedClient = new Mock <IGitHubClient>();
mockedClient.Setup(githubService =>
githubService.Search.SearchRepo(It.IsAny <SearchRepositoriesRequest>()))
.Returns(Task.Factory.StartNew(() => response));
//Mount service
_service = new GithubService(_dbContext, mockedClient.Object);
}
public async Task <int> getNumberOfPages(Model.SearchRepositoriesRequestParameters requestParameters)
{
SearchRepositoriesRequest repoRequest = getSearchRepoRequest(requestParameters);
SearchRepositoryResult result = await GlobalVariables.client.Search.SearchRepo(repoRequest);
if (result.TotalCount == 0)
{
return(0);
}
if (result.TotalCount > 1000)
{
return(GlobalVariables.MaximumNumberOfPages);
}
if (result.TotalCount % repoRequest.PerPage == 0)
{
return(result.TotalCount / repoRequest.PerPage);
}
return(result.TotalCount / repoRequest.PerPage + 1);
}
private async Task InfoFromGIT()
{
var client = new GitHubClient(new ProductHeaderValue("CRUD"));
var user = await client.User.Get("elektronika96");
Console.WriteLine("Cos");
var request = new SearchRepositoriesRequest()
{
User = "******",
};
labUser.Text = "Właściciel repozytorium: " + request.User;
SearchRepositoryResult result = await client.Search.SearchRepo(request);
var items = result.Items.Where(x => x.Name == "CRUD");
foreach (var item in items)
{
lab_CreateDate.Text = "Data utworzenia: " + item.CreatedAt.ToString().Remove(19);
lab_URL.Text = item.HtmlUrl;
}
}
private async void GetRepositoryInformation(CommandMessage command)
{
try
{
GitHubClient github = new GitHubClient(new ProductHeaderValue("CombotIRCBot"));
if (GetOptionValue("Token").ToString() != string.Empty)
{
string token = GetOptionValue("Token").ToString();
github.Credentials = new Credentials(token);
}
SearchRepositoryResult foundRepo = await github.Search.SearchRepo(new SearchRepositoriesRequest(command.Arguments["Repository"]));
if (foundRepo.TotalCount > 0)
{
Repository repo = foundRepo.Items.First();
string repoMessage = string.Format("\u0002{0}\u0002 | Created On \u0002{1}\u0002 | \u0002{2}\u0002 Open Issues | \u0002{3}\u0002 Forks | \u0002{4}\u0002 Stargazers | {5}", repo.FullName, repo.CreatedAt.ToString("d"), repo.OpenIssuesCount, repo.ForksCount, repo.StargazersCount, repo.HtmlUrl);
SendResponse(command.MessageType, command.Location, command.Nick.Nickname, repoMessage);
if (repo.Description != string.Empty)
{
SendResponse(command.MessageType, command.Location, command.Nick.Nickname, repo.Description);
}
}
else
{
SendResponse(command.MessageType, command.Location, command.Nick.Nickname, string.Format("Repository \u0002{0}\u0002 does not exist.", command.Arguments["Repository"]));
}
}
catch (Octokit.RateLimitExceededException ex)
{
ThrowError(ex);
}
catch (Octokit.ApiValidationException ex)
{
ThrowError(ex);
return;
}
}
public async Task <string> GetUserData(string username)
{
User user = null;
SearchRepositoryResult result = null;
client.Credentials = currentCredentials;
try
{
user = await client.User.Get(username);
}
catch (Exception ex)
{
return(JsonConvert.SerializeObject(new JObject(
new JProperty("message", "User error")
)));
}
try
{
var customRequest = new SearchRepositoriesRequest()
{
User = username
};
result = await client.Search.SearchRepo(customRequest);
}
catch (Exception ex)
{
return(JsonConvert.SerializeObject(new JObject(
new JProperty("message", "Repository search error")
)));
}
JArray repositoriesArray = new JArray();
foreach (Repository repository in result.Items)
{
repositoriesArray.Add(
new JObject(
new JProperty("name", repository.Name),
new JProperty("createdAt", repository.CreatedAt),
new JProperty("updatedAt", repository.UpdatedAt),
new JProperty("language", repository.Language),
new JProperty("stars", repository.StargazersCount),
new JProperty("forks", repository.ForksCount)
)
);
}
JObject userData = new JObject(
new JProperty("login", user.Login),
new JProperty("username", user.Name),
new JProperty("email", user.Email),
new JProperty("publicRepos", user.PublicRepos)
);
return(JsonConvert.SerializeObject(new JObject(
new JProperty("message", "Ok"),
new JProperty("userData", userData),
new JProperty("repositories", repositoriesArray)
)));
}
private async void ListUserReposAsync(GitHubClient ghCliente)
{
// //Populando Objeto de linguagem C#
#region
var searchRepositoriesRequest = new SearchRepositoriesRequest()
{
Language = Language.CSharp,
SortField = RepoSearchSort.Stars,
Order = SortDirection.Descending,
PerPage = 1
};
SearchRepositoryResult searchRepositoryResult = await ghCliente.Search.SearchRepo(searchRepositoriesRequest);
repoCsharp.CreatedAt = searchRepositoryResult.Items[0].CreatedAt.DateTime;
repoCsharp.Description = searchRepositoryResult.Items[0].Description;
repoCsharp.hasDownloads = Convert.ToByte(searchRepositoryResult.Items[0].HasDownloads);
repoCsharp.hasIssues = Convert.ToByte(searchRepositoryResult.Items[0].HasIssues);
repoCsharp.htmlURL = searchRepositoryResult.Items[0].HtmlUrl;
repoCsharp.Language = searchRepositoryResult.Items[0].Language;
repoCsharp.UpdatedAt = searchRepositoryResult.Items[0].UpdatedAt.DateTime;
repoCsharp.Stars = searchRepositoryResult.Items[0].StargazersCount;
repoCsharp.Name = searchRepositoryResult.Items[0].Name;
#endregion
//Populando Objeto de linguagem javaScript
#region
searchRepositoriesRequest = new SearchRepositoriesRequest()
{
Language = Language.JavaScript,
SortField = RepoSearchSort.Stars,
Order = SortDirection.Descending,
PerPage = 1
};
searchRepositoryResult = await ghCliente.Search.SearchRepo(searchRepositoriesRequest);
repoJavaScript.CreatedAt = searchRepositoryResult.Items[0].CreatedAt.DateTime;
repoJavaScript.Description = searchRepositoryResult.Items[0].Description;
repoJavaScript.hasDownloads = Convert.ToByte(searchRepositoryResult.Items[0].HasDownloads);
repoJavaScript.hasIssues = Convert.ToByte(searchRepositoryResult.Items[0].HasIssues);
repoJavaScript.htmlURL = searchRepositoryResult.Items[0].HtmlUrl;
repoJavaScript.Language = searchRepositoryResult.Items[0].Language;
repoJavaScript.UpdatedAt = searchRepositoryResult.Items[0].UpdatedAt.DateTime;
repoJavaScript.Stars = searchRepositoryResult.Items[0].StargazersCount;
repoJavaScript.Name = searchRepositoryResult.Items[0].Name;
#endregion
//Populando Objeto de linguagem Arduino(Wiring)
#region
searchRepositoriesRequest = new SearchRepositoriesRequest()
{
Language = Language.Arduino,
SortField = RepoSearchSort.Stars,
Order = SortDirection.Descending,
PerPage = 1
};
searchRepositoryResult = await ghCliente.Search.SearchRepo(searchRepositoriesRequest);
repoArduino.CreatedAt = searchRepositoryResult.Items[0].CreatedAt.DateTime;
repoArduino.Description = searchRepositoryResult.Items[0].Description;
repoArduino.hasDownloads = Convert.ToByte(searchRepositoryResult.Items[0].HasDownloads);
repoArduino.hasIssues = Convert.ToByte(searchRepositoryResult.Items[0].HasIssues);
repoArduino.htmlURL = searchRepositoryResult.Items[0].HtmlUrl;
repoArduino.Language = searchRepositoryResult.Items[0].Language;
repoArduino.UpdatedAt = searchRepositoryResult.Items[0].UpdatedAt.DateTime;
repoArduino.Stars = searchRepositoryResult.Items[0].StargazersCount;
repoArduino.Name = searchRepositoryResult.Items[0].Name;
#endregion
//Populando Objeto de linguagem Groovy
#region
searchRepositoriesRequest = new SearchRepositoriesRequest()
{
Language = Language.Groovy,
SortField = RepoSearchSort.Stars,
Order = SortDirection.Descending,
PerPage = 1
};
searchRepositoryResult = await ghCliente.Search.SearchRepo(searchRepositoriesRequest);
repoGroovy.CreatedAt = searchRepositoryResult.Items[0].CreatedAt.DateTime;
repoGroovy.Description = searchRepositoryResult.Items[0].Description;
repoGroovy.hasDownloads = Convert.ToByte(searchRepositoryResult.Items[0].HasDownloads);
repoGroovy.hasIssues = Convert.ToByte(searchRepositoryResult.Items[0].HasIssues);
repoGroovy.htmlURL = searchRepositoryResult.Items[0].HtmlUrl;
repoGroovy.Language = searchRepositoryResult.Items[0].Language;
repoGroovy.UpdatedAt = searchRepositoryResult.Items[0].UpdatedAt.DateTime;
repoGroovy.Stars = searchRepositoryResult.Items[0].StargazersCount;
repoGroovy.Name = searchRepositoryResult.Items[0].Name;
#endregion
//Populando Objeto de linguagem Ruby on Rails
#region
searchRepositoriesRequest = new SearchRepositoriesRequest()
{
Language = Language.Ruby,
SortField = RepoSearchSort.Stars,
Order = SortDirection.Descending,
PerPage = 1
};
searchRepositoryResult = await ghCliente.Search.SearchRepo(searchRepositoriesRequest);
repoRuby.CreatedAt = searchRepositoryResult.Items[0].CreatedAt.DateTime;
repoRuby.Description = searchRepositoryResult.Items[0].Description;
repoRuby.hasDownloads = Convert.ToByte(searchRepositoryResult.Items[0].HasDownloads);
repoRuby.hasIssues = Convert.ToByte(searchRepositoryResult.Items[0].HasIssues);
repoRuby.htmlURL = searchRepositoryResult.Items[0].HtmlUrl;
repoRuby.Language = searchRepositoryResult.Items[0].Language;
repoRuby.UpdatedAt = searchRepositoryResult.Items[0].UpdatedAt.DateTime;
repoRuby.Stars = searchRepositoryResult.Items[0].StargazersCount;
repoRuby.Name = searchRepositoryResult.Items[0].Name;
#endregion
}
/// <summary>
/// Gets the repositories using Search. Not used as the information is
/// incomplete.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void OnGetUserRepositoriesClick1(object sender, EventArgs e)
{
if (client == null)
{
WriteLineInfo(NL + "Get User Repositories: No client defined");
return;
}
string userName;
string msg = "Enter ";
InputDialog dlg = new InputDialog("Repository Name", msg,
Properties.Settings.Default.RepositoryOwner);
DialogResult res = dlg.ShowDialog();
if (res == DialogResult.OK)
{
userName = dlg.Value;
Properties.Settings.Default.RepositoryOwner = userName;
Properties.Settings.Default.Save();
if (!String.IsNullOrEmpty(userName))
{
WriteLineInfo(NL + "Searching for Repositories for " + userName);
}
else
{
WriteLineInfo(NL + "Searching for repositories: Invalid user name: "
+ userName);
return;
}
}
else
{
return;
}
User user = await client.User.Get(userName);
if (user == null)
{
WriteLineInfo("User not found: " + userName);
return;
}
List <Repository> repositories = new List <Repository>();
int page = 1;
// Handle more than 1 page
while (true)
{
SearchRepositoryResult reposResult = await client.Search.SearchRepo(new SearchRepositoriesRequest()
{
User = userName,
PerPage = 100,
Page = page++
});
IReadOnlyList <Repository> repositories1 = reposResult.Items;
if (repositories1 == null)
{
WriteLineInfo("Error finding repositories");
return;
}
foreach (Repository repos in repositories1)
{
repositories.Add(repos);
}
//WriteLineInfo($"Items.Count={reposResult.Items.Count} " +
// $"TotalCount={reposResult.TotalCount} " +
// $"IncompleteResults={reposResult.IncompleteResults}");
if (repositories1.Count < 100)
{
break;
}
}
if (repositories.Count == 0)
{
WriteLineInfo("No repositories found");
return;
}
await GetRepositories(userName, repositories);
}
