public async Task <List <GitHubFile> > GetFiles(GitHubRepo repository, string path, Func <GitHubFile, bool> exp)
{
const string pathParam = "{+path}";
string contentUrl;
if (string.IsNullOrEmpty(path))
{
contentUrl = repository.ContentsUrl.Substring(0,
repository.ContentsUrl.Length -
pathParam.Length);
}
else
{
contentUrl = repository.ContentsUrl.Replace(pathParam, path);
}
var response = await _httpClient.GetAsync(contentUrl);
var content = await response.Content.ReadAsStringAsync();
var files = JsonConvert.DeserializeObject <List <GitHubFile> >(content);
return(files.Where(exp).ToList());
}
public async Task <List <GitHubFile> > GetCsProjFiles(GitHubRepo repository)
{
var files = new List <GitHubFile>();
var rootFiles = await GetFiles(repository, "src", f => f.IsDir());
if (!rootFiles.Any())
{
return(files);
}
// This assumes the solution follows the usual structure
var secondLevelDirectories = rootFiles.Where(x => x.IsDir());
var getFilesTasks = new List <Task <List <GitHubFile> > >();
foreach (var dir in secondLevelDirectories)
{
try
{
var getCsProjFilesTask = GetFiles(repository, dir.Path, f => f.IsCsProj());
getFilesTasks.Add(getCsProjFilesTask);
}
catch (Exception e)
{
Console.WriteLine($"Error parsing files for {dir}");
Console.WriteLine(e);
}
}
var tasksResult = await Task.WhenAll(getFilesTasks);
var csProjFiles = tasksResult.SelectMany(x => x).ToList();
return(csProjFiles);
}
public async void UpdatePullRequests(ItemState?state)
{
try
{
if (null == _gitHubRepoHelper)
{
_gitHubRepoHelper = new GitHubRepo(Settings.Default.GitHubRepoOwner, Settings.Default.GitHubUserName, Settings.Default.GitHubToken);
_gitHubRepoHelper.GetPullRequestsComplete += CustReports_GetPullRequestComplete;
}
await Task.Run(() =>
{
try
{
_gitHubRepoHelper.GetRequests(state, _daysBack, _repoNames);
}
catch (Exception ex)
{
ExceptionHandler(ex);
}
});
}
catch (Exception ex)
{
ExceptionHandler(ex);
}
}
public IMapRepo ToMap(GitHubRepo repo)
{
var mp = new MapRepo();
mp.Name = repo.Name;
return(mp);
}
public T GetGitHubApiData <T>(string url)
{
object obj;
Type listType = typeof(T);
if (listType == typeof(GitHubUser))
{
obj = new GitHubUser()
{
AvatarUrl = "http://www.example.com",
Location = "england",
UserName = "******"
};
}
else
{
var gitHubRepo = new GitHubRepo()
{
RepositoryUrl = "www.example.com",
RepositoryName = "example",
StarGazersCount = 20
};
var listOfRepos = new List <GitHubRepo>();
listOfRepos.Add(gitHubRepo);
obj = listOfRepos;
}
return((T)obj);
}
public async Task <IActionResult> RemoveGitRepo([FromBody] dynamic repository)
{
var removeRepo = new GitHubRepo
{
Id = repository.repository.id
};
bool result = await _service.RemoveGitRepository(removeRepo.Id);
return(Ok(result));
}
/// <summary>
/// gets some data from github api
/// </summary>
async void FillGitRepoAsync()
{
const string GitHubIdentity = "jacekstaniec";
const string GitHubProject = "ITC-WPF";
GitHubRepo gtavm = new GitHubRepo(GitHubIdentity, GitHubProject);
List <GitHub> myGitHubAttributes = await gtavm.GetGitHubRepoAsync();
dgGitHub.ItemsSource = null;
dgGitHub.ItemsSource = myGitHubAttributes;
}
public void ToMapTest()
{
//arrage
var githubRepo = new GitHubRepo();
githubRepo.Name = "repo-1";
var map = (MapRepo)mapRepo.ToMap(githubRepo);
Assert.Equal("repo-1", map.Name);
}
public async Task <IActionResult> AddGitRepo([FromBody] dynamic repository)
{
var newRepo = new GitHubRepo
{
Id = repository.repository.id,
Name = repository.repository.name,
Description = repository.repository.description
};
bool result = await _service.AddGitRepository(newRepo);
return(Ok(result));
}
private void CustReports_GetPullRequestComplete(object sender, EventArgs e)
{
try
{
GitHubRepo repo = (GitHubRepo)sender;
DisplayPullRequests(repo.PullRequests);
}
catch (Exception ex)
{
ExceptionHandler(ex);
}
}
private async Task <Project> GetProject(IGitHubClient client, GitHubRepo proj)
{
this._logger.LogInformation($"{nameof(GetProject)}: Getting project for '{proj.Owner}/{proj.Name}'...");
var projects = await client.Repository.Project.GetAllForOrganization(proj.Owner);
var project = projects.FirstOrDefault(p => p.Name == proj.Name);
if (project is null)
{
throw new ArgumentException($"Project '{proj.Owner}/{proj.Name}' not found");
}
return(project);
}
public IActionResult Search(String userName)
{
List <GitHubRepo> repoList = new List <GitHubRepo>();
GitHubRepo repo = null;
try
{
if (string.IsNullOrEmpty(userName))
{
throw new InvalidOperationException("EmptyInput");
}
GitHubRequestHandler handler = new GitHubRequestHandler();
if (!string.IsNullOrWhiteSpace(userName))
{
String url = "https://api.github.com/users/" + userName + "/repos";
var releases = handler.GetReleases(url);
//List out the retreived releases
foreach (JObject release in releases.Children())
{
Console.WriteLine("name: {0}", release.GetValue("name"));
Console.WriteLine("fullname: {0}", release.GetValue("full_name"));
Console.WriteLine();
repo = JsonConvert.DeserializeObject <GitHubRepo>(release.ToString(Newtonsoft.Json.Formatting.None));
repo.git_url = repo.git_url.Substring(6, repo.git_url.Length - 6);
repoList.Add(repo);
}
GitHubProfile profile = handler.GetReleases1("https://api.github.com/users/" + userName);
Console.WriteLine("login: {0}", profile.login);
Console.WriteLine("name: {0}", profile.name);
ViewData["accountName"] = profile.login;
ViewData["date"] = DateTime.Parse(profile.updated_at).ToString();
ViewData["followers"] = profile.followers;
ViewData["following"] = profile.following;
return(View(repoList));
}
else
{
Index();
}
}catch (Exception e) {}
return(View("404"));
}
public static GitHubRepo MapToModel(GitHubRepoViewModel vm)
{
if (vm == null)
return null;
GitHubRepo repoModel = new GitHubRepo();
repoModel.Name = vm.Name;
repoModel.Description = vm.Description;
repoModel.Language = vm.Language;
repoModel.OwnerAvatarUrl = vm.OwnerAvatarUrl;
repoModel.OwnerName = vm.OwnerLogin;
repoModel.GitHubRepoId = vm.GitHubRepoId;
return repoModel;
}
public async Task <IActionResult> TypedClient2()
{
GitHubRepo gitHubRepo = new GitHubRepo();
try
{
var repos = await _repoService.GetRepos();
gitHubRepo.GetRepoRequestsError = false;
gitHubRepo.RepoRequests = repos;
}
catch (HttpRequestException ex)
{
gitHubRepo.GetRepoRequestsError = true;
gitHubRepo.RepoRequests = Array.Empty <string>();
}
return(View(gitHubRepo));
}
public static GitHubRepoViewModel MapToViewModel(GitHubRepo repo, IEnumerable<GitHubUserDTO> contributors)
{
if (repo == null)
return null;
GitHubRepoViewModel vm = new GitHubRepoViewModel();
vm.Name = repo.Name;
vm.Description = repo.Description;
vm.Language = repo.Language;
vm.Updated_at = repo.UpdatedAt.ToString();
vm.OwnerLogin = repo.OwnerName;
vm.OwnerAvatarUrl = repo.OwnerAvatarUrl;
vm.GitHubRepoId = repo.GitHubRepoId;
if (contributors != null)
vm.Contributors = contributors.ToList();
return vm;
}
public async Task <bool> AddRepository(GitHubRepo repository)
{
bool result = false;
var newRepo = _db.GetCollection <GitHubRepo>("ChipinoGitRepos");
try
{
await newRepo.InsertOneAsync(repository);
result = true;
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message);
}
return(result);
}
private async Task <Milestone> GetOrCreateDefaultMilestone(GitHubClient client, GitHubRepo repo)
{
this._logger.LogInformation($"{nameof(GetOrCreateDefaultMilestone)}: Getting default milestone '{this._defaultMilestoneName}' for '{repo.Owner}/{repo.Name}'...");
var milestones = await client.Issue.Milestone.GetAllForRepository(repo.Owner, repo.Name);
var defaultMilestone = milestones.FirstOrDefault(m => m.Title == this._defaultMilestoneName);
if (defaultMilestone is null)
{
this._logger.LogInformation($"{nameof(GetOrCreateDefaultMilestone)}: Default milestone '{this._defaultMilestoneName}' not found for '{repo.Owner}/{repo.Name}'. Creating one...");
defaultMilestone = await client.Issue.Milestone.Create(repo.Owner, repo.Name, new NewMilestone(this._defaultMilestoneName));
}
else
{
this._logger.LogInformation($"{nameof(GetOrCreateDefaultMilestone)}: Found default milestone '{defaultMilestone.Title}[{defaultMilestone.Number}]' for '{repo.Owner}/{repo.Name}'.");
}
return(defaultMilestone);
}
public Task <bool> AddRepository(GitHubRepo repository)
{
throw new NotImplementedException();
}
public async Task <bool> AddGitRepository(GitHubRepo repository)
{
return(await _ctx.AddRepository(repository));
}
public void MarkAsFavoriteService_ReturnsException()
{
// Arrange
var mockGitHubRepoRepository = new Mock<IGitHubRepoRepository>();
var mockUnitOfWork = new Mock<IUnitOfWork>();
// create new repo fake
GitHubRepo repo = new GitHubRepo();
mockGitHubRepoRepository.Setup(s => s.AddandReturn(repo)).Throws(new System.Exception("Fake exception"));
var svc = new GitHubRepoService(mockGitHubRepoRepository.Object, mockUnitOfWork.Object);
// Act
var repoReturned = svc.MarkAsFavorite(repo);
// Assert
// automatic
}
public static GitHubSample.Model.GitHubRepo MapDtoToModel(GitHubRepoDTO dto)
{
GitHubSample.Model.GitHubRepo repoModel = new GitHubRepo();
repoModel.Name = dto.name;
repoModel.Description = dto.description;
repoModel.GitHubRepoId = dto.id;
repoModel.Language = dto.language;
repoModel.OwnerAvatarUrl = dto.owner.AvatarUrl;
repoModel.OwnerName = dto.owner.Login;
repoModel.UpdatedAt = ConvertToDateTime(dto.updated_at);
return repoModel;
}
/// <summary>
/// Unmark repository as favorite, removing from local database
/// </summary>
/// <param name="repository"></param>
public void UnMarkAsFavorite(GitHubRepo repository)
{
if (repository == null)
return;
try
{
this.gitHubRepoRepository.UnMarkAsFavorite(repository);
this.unitOfWork.Commit();
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Mark repository as favorite, adding to local database
/// </summary>
/// <param name="repository"></param>
/// <returns></returns>
public GitHubRepo MarkAsFavorite(GitHubRepo repository)
{
if (repository == null)
return null;
try
{
var ret = this.gitHubRepoRepository.AddandReturn(repository);
this.unitOfWork.Commit();
return ret;
}
catch (Exception)
{
throw;
}
}
private async Task SetDefaultMilestone(GitHubClient client, IEnumerable <Issue> issues, GitHubRepo repo)
{
var defaultMilestone = await this.GetOrCreateDefaultMilestone(client, repo);
foreach (var issue in issues)
{
this._logger.LogInformation($"{nameof(SetDefaultMilestone)}: Setting default milestone for issue '{issue.Number}'...");
await client.Issue.Update(repo.Owner, repo.Name, issue.Number, issue.ToUpdate().SetMilestone(defaultMilestone));
}
}
private bool UpdateGithub(Dependency dependency, CommitVersion version, Action <string> eventMessage)
{
var gh = new GitHubRepo(new StringUtils().SetGithubToken(dependency.GithubHttp, token, userGithub), this.branch, this.userGithub, this.mail);
string folder;
try
{
folder = gh.Clone();
}
catch (Exception e)
{
eventMessage?.Invoke($"{dependency.PackageName} fallo al clonar con la rama {branch} desde {dependency.GithubHttp}");
eventMessage?.Invoke($"este es el mensaje de error:");
eventMessage?.Invoke($"{e.Message}");
return(false);
}
eventMessage?.Invoke($"-------------------------------------------------------------------------------");
eventMessage?.Invoke($"{dependency.PackageName} es clonado en la carpeta temporal desde {dependency.GithubHttp}");
eventMessage?.Invoke($"-------------------------------------------------------------------------------");
eventMessage?.Invoke($"{folder}");
eventMessage?.Invoke($"-------------------------------------------------------------------------------");
eventMessage?.Invoke($" Desde url Github : {dependency.GithubHttp}");
eventMessage?.Invoke($"-------------------------------------------------------------------------------");
string contentFile;
eventMessage?.Invoke($"Se obtiene {dependency.pathPackageSettings}");
eventMessage?.Invoke($"-------------------------------------------------------------------------------");
eventMessage?.Invoke($"-------------------------------------------------------------------------------");
if (packageType == PackageType.npm)
{
contentFile = SetPackageJsonNpmVersion(dependency, version, folder);
}
else
{
contentFile = SetCsProjNugetVersion(dependency, version, folder);
}
eventMessage?.Invoke($"{dependency.pathPackageSettings} procesado");
Exception exception = null;
var intentos = 0;
while (intentos <= 3)
{
try
{
gh.SaveFile(dependency.pathPackageSettings, $"{packageName}.{version}", contentFile);
}
catch (Exception exc)
{
if (exc.Message.ToLower().Contains("nothing to commit"))
{
break;
}
exception = exc;
Thread.Sleep(2000);
gh.Cloned = string.Empty;
intentos++;
try
{
folder = gh.Clone();
}
catch (Exception e)
{
eventMessage?.Invoke($"{dependency.PackageName} fallo al clonar con la rama {branch} desde {dependency.GithubHttp}");
eventMessage?.Invoke($"este es el mensaje de error:");
eventMessage?.Invoke($"{e.Message}");
}
if (packageType == PackageType.npm)
{
contentFile = SetPackageJsonNpmVersion(dependency, version, folder);
}
else
{
contentFile = SetCsProjNugetVersion(dependency, version, folder);
}
eventMessage?.Invoke($"Se limpia carpeta temporal para reintento = {intentos}, mensaje = {exc.Message}");
}
}
if (exception != null)
{
throw exception;
}
eventMessage?.Invoke($"El paquete {dependency.PackageName} ha actualizado {packageName} a {version}");
return(true);
}
public static GitHubRepo GetRepoByName(string owner, string repoName)
{
if ((owner == null) || (repoName == null))
return null;
// MOCK
string desc = "Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknow";
string avatar_url = "https://avatars1.githubusercontent.com/u/167455?v=3&s=400";
GitHubRepo repoModel = new GitHubRepo();
repoModel.Name = repoName;
repoModel.Description = desc;
repoModel.Language = "javascript";
repoModel.UpdatedAt = new DateTime(2015, 1, 25);
repoModel.OwnerName = owner;
repoModel.OwnerAvatarUrl = avatar_url;
repoModel.GitHubRepoId = 1;
return repoModel;
}
