public void RepositorySelected(Repository repository)
{
_navigationService.UriFor<RepositoryDetailsViewModel>()
.WithParam(v => v.Owner, repository.Owner.Login)
.WithParam(v => v.Name, repository.Name)
.Navigate();
}
public RepositoryViewModel Init(string repositoryOwner, string repositoryName, Octokit.Repository repository = null)
{
RepositoryOwner = repositoryOwner;
RepositoryName = repositoryName;
Repository = repository;
return(this);
}
public override async Task <VersionData> GetVersionFile(string[] fileArray, Action <string> updateLabel)
{
var versionData = new VersionData();
try
{
updateLabel?.Invoke("Get Repository..");
GetRepository = await Client.Repository.Get(OwnerSpaceName, RepositoryName);
updateLabel?.Invoke("Check Version Data..");
var existingFile = await Client.Repository.Content.GetAllContentsByRef(OwnerSpaceName, RepositoryName, VersionDataPath, ReferenceName);
var versionInfo = existingFile.First().Content;
versionData.AddVerionData(versionInfo);
}
catch (NotFoundException)
{
foreach (var path in fileArray)
{
var fileName = Path.GetFileNameWithoutExtension(path);
versionData.AddNewVerionData(fileName);
}
}
return(versionData);
}
public Repository(string url, string htmlUrl, string cloneUrl, string gitUrl, string sshUrl, string svnUrl, string mirrorUrl, long id, User owner, string name, string fullName, string description, string homepage, string language, bool @private, bool fork, int forksCount, int stargazersCount, string defaultBranch, int openIssuesCount, DateTimeOffset? pushedAt, DateTimeOffset createdAt, DateTimeOffset updatedAt, RepositoryPermissions permissions, Repository parent, Repository source, bool hasIssues, bool hasWiki, bool hasDownloads, bool? allowRebaseMerge, bool? allowSquashMerge, bool? allowMergeCommit)
{
Url = url;
HtmlUrl = htmlUrl;
CloneUrl = cloneUrl;
GitUrl = gitUrl;
SshUrl = sshUrl;
SvnUrl = svnUrl;
MirrorUrl = mirrorUrl;
Id = id;
Owner = owner;
Name = name;
FullName = fullName;
Description = description;
Homepage = homepage;
Language = language;
Private = @private;
Fork = fork;
ForksCount = forksCount;
StargazersCount = stargazersCount;
DefaultBranch = defaultBranch;
OpenIssuesCount = openIssuesCount;
PushedAt = pushedAt;
CreatedAt = createdAt;
UpdatedAt = updatedAt;
Permissions = permissions;
Parent = parent;
Source = source;
HasIssues = hasIssues;
HasWiki = hasWiki;
HasDownloads = hasDownloads;
AllowRebaseMerge = allowRebaseMerge;
AllowSquashMerge = allowSquashMerge;
AllowMergeCommit = allowMergeCommit;
}
public void PushGitRepo(Repository gitHubRepository, string gitRepoPath)
{
using (var repo = new LibGit2Sharp.Repository(gitRepoPath))
{
if (repo.Network.Remotes.Any(r => r.Name == "github"))
{
repo.Network.Remotes.Remove("github");
}
var remote = repo.Network.Remotes.Add("github", gitHubRepository.CloneUrl, "+refs/*:refs/*");
repo.Config.Set("remote.github.mirror", true);
var pushOptions = new PushOptions
{
CredentialsProvider = (url, fromUrl, types) =>
new UsernamePasswordCredentials()
{
Username = _gitHubSettings.AccessToken,
Password = string.Empty
}
};
var refs = repo.Refs.Select(r => r.CanonicalName);
repo.Network.Push(remote, refs, pushOptions);
}
}
private RepositoryWrapper CreateWrapper(int id, string name)
{
var repository = new Repository(null, null, null, null, null, null, null, id, null, name, "", "", "", "",
false, false, 0, 0, 0, "master", 1, null, DateTimeOffset.Now, DateTimeOffset.Now, null, null, null, null,
true, true, true);
return new RepositoryWrapper(repository);
}
async Task<IEnumerable<InvolvedIssue>> GetInvolvedIssuesForRepo(Repository repo, string username)
{
var mentionedFilter = new RepositoryIssueRequest { State = ItemState.Open, Mentioned = username };
var assigneeFilter = new RepositoryIssueRequest { State = ItemState.Open, Assignee = username };
var creatorFilter = new RepositoryIssueRequest { State = ItemState.Open, Creator = username };
var mentionedQuery = Task.Run(
async () => await client.Issue.GetAllForRepository("Particular", repo.Name, mentionedFilter));
var assigneeQuery = Task.Run(
async () => await client.Issue.GetAllForRepository("Particular", repo.Name, assigneeFilter));
var creatorQuery = Task.Run(
async () => await client.Issue.GetAllForRepository("Particular", repo.Name, creatorFilter));
await Task.WhenAll(mentionedQuery, assigneeQuery, creatorQuery);
return
mentionedQuery.Result
.Where(issue => ExtractTeam(issue.Body).ToArray()
.Contains(username, StringComparer.InvariantCultureIgnoreCase))
.Concat(
assigneeQuery.Result)
.Concat(
creatorQuery.Result
.Where(issue => issue.PullRequest != null))
.GroupBy(issue => issue.Url)
.Select(g => g.First())
.Select(issue => new InvolvedIssue { Issue = issue, Repo = repo });
}
public IssueEditorViewModel()
{
if (GitHubApi.Repository != null)
_repository = GitHubApi.Repository.Repository;
Assignees = new BindingList<User>();
Labels = new BindingList<LabelModel>();
foreach (var label in GitHubApi.Labels)
Labels.Add(new LabelModel(label));
Milestones = new BindingList<Milestone>();
foreach (var milestone in GitHubApi.Milestones)
Milestones.Add(milestone);
// The lists contain non-items
if (Labels.Count > 0) Labels.RemoveAt(0);
if (Milestones.Count > 0) Milestones.RemoveAt(0);
if (Milestones.Count > 0) Milestones.RemoveAt(0);
SaveCommand = new RelayCommand(Save, p => CanSave());
CancelCommand = new RelayCommand(Cancel, p => true);
ClearAssigneeCommand = new RelayCommand(p => Assignee = null, p => Assignee != null);
ClearMilestoneCommand = new RelayCommand(p => Milestone = null, p => Milestone != null);
SetLabelsCommand = new RelayCommand(SetLabels, p => true);
CloseLabelPickerCommand = new RelayCommand(CloseLabelPicker, p => true);
}
async Task<Repository> GetRepositoryInternal()
{
await sem.WaitAsync();
try
{
if (owner == null && OriginalUrl != null)
{
var own = OriginalUrl.GetUser();
var name = OriginalUrl.GetRepo();
if (own != null && name != null)
{
var repo = await client.Repository.Get(own, name);
if (repo != null)
{
hasWiki = await HasWikiInternal(repo);
isEnterprise = await IsEnterpriseInternal();
repositoryCache = repo;
}
owner = own;
}
}
}
// it'll throw if it's private
catch {}
finally
{
sem.Release();
}
return repositoryCache;
}
public GitTag(string url, string label, string @ref, string sha, User user, Repository repository, string tag, string message, Committer tagger, TagObject objectVar)
: base(url, label, @ref, sha, user, repository)
{
Tag = tag;
Message = message;
Tagger = tagger;
Object = objectVar;
}
public void GetReleaseReportForRepo1()
{
var repository = new Octokit.Repository(MockServer.repositoryId);
var result = _zenhubClient.GetRepositoryClient(repository).GetReleaseReportsAsync().GetAwaiter().GetResult();
Assert.AreEqual("59cbf2fde010f7a5207406e8", result.Value[0].ReleaseId);
}
public CombinedCommitStatus(CommitState state, string sha, int totalCount, IReadOnlyList<CommitStatus> statuses, Repository repository)
{
State = state;
Sha = sha;
TotalCount = totalCount;
Statuses = statuses;
Repository = repository;
}
private async Task <Milestone> GetMilestone(string milestoneName, Octokit.Repository githubRepo)
{
IReadOnlyList <Milestone> milestones = await GetAllMilestones(githubRepo);
var relatedMilestone = milestones.SingleOrDefault(m => m.Title.Equals(milestoneName, StringComparison.InvariantCultureIgnoreCase));
return(relatedMilestone);
}
public async Task <Octokit.Issue> GetIssue(string title, Octokit.Repository githubRepo)
{
IReadOnlyList <Octokit.Issue> allIssues = await GitHubClient.Issue.GetAllForRepository(githubRepo.Id);
var foundIssue = allIssues.SingleOrDefault(i => i.Title.Equals(title, StringComparison.InvariantCultureIgnoreCase));
return(foundIssue);
}
public async Task InitializeAsync(GitHubRepo repo)
{
Repository = repo;
Branch[] branches = await RepositoryManager.GetBranchesAsync(repo);
Branches = new List <Branch>(branches);
}
/// <summary>
/// Creates/updates the github issue.
/// </summary>
/// <param name="updateHistoryError">Error info for which github issue has to be created</param>
/// <param name="issueRepo">Repository where the github issue is created</param>
/// <param name="shouldReplaceDescription">Func that carries info the description has to be replaced </param>
/// <param name="description">Description for the issue body / comment body</param>
/// <returns></returns>
private async Task CreateOrUpdateGithubIssueAsync(
RepositoryBranchUpdateHistoryEntry updateHistoryError,
string issueRepo,
Func <string, string, bool> shouldReplaceDescription,
string description)
{
_logger.LogInformation($"Error Message : '{updateHistoryError.ErrorMessage}' in repository : '{updateHistoryError.Repository}'");
IReliableDictionary <(string repository, string branch), int> gitHubIssueEvaluator =
await _stateManager.GetOrAddAsync <IReliableDictionary <(string repository, string branch), int> >("gitHubIssueEvaluator");
GitHubClient client = await AuthenticateGitHubClient(issueRepo);
var parseRepoUri = ParseRepoUri(issueRepo);
Octokit.Repository repo = await client.Repository.Get(
parseRepoUri.owner,
parseRepoUri.repo);
var issueNumber = new ConditionalValue <int>();
using (ITransaction tx = _stateManager.CreateTransaction())
{
issueNumber = await gitHubIssueEvaluator.TryGetValueAsync(
tx,
(updateHistoryError.Repository,
updateHistoryError.Branch));
await tx.CommitAsync();
}
if (issueNumber.HasValue)
{
Issue issue = await client.Issue.Get(repo.Id, issueNumber.Value);
// check if the issue is open only then update it else create a new issue and update the dictionary.
if (issue.State.Equals("Open"))
{
_logger.LogInformation($@"Updating a gitHub issue number : '{issueNumber}' for the error : '{updateHistoryError.ErrorMessage}' for the repository : '{updateHistoryError.Repository}'");
await UpdateIssueAsync(
client,
updateHistoryError,
shouldReplaceDescription,
description,
issue,
repo.Id);
return;
}
}
// Create a new issue for the error if the issue is already closed or the issue does not exists.
_logger.LogInformation($@"Creating a new gitHub issue for dependency Update Error, for the error message : '{updateHistoryError.ErrorMessage} for the repository : '{updateHistoryError.Repository}'");
await CreateIssueAsync(
client,
updateHistoryError,
gitHubIssueEvaluator,
description,
repo.Id,
issueRepo);
}
public static async Task InitializeRepositoryAsync(GitHubRepo repo, string branchName)
{
Repository = repo;
Branches = await GetBranchesAsync();
BranchDefault = GetBranch(branchName);
BranchDefaultName = branchName;
}
public void GetDependencyForRepo1()
{
var repository = new Octokit.Repository(MockServer.repositoryId);
var result = _zenhubClient.GetRepositoryClient(repository).GetDependenciesAsync().GetAwaiter().GetResult();
Assert.NotNull(result);
Assert.AreEqual(3953, result.Value.Dependencies[0].Blocking.IssueNumber);
}
public void GetZenHubBoard2()
{
var repository = new Octokit.Repository(MockServer.repositoryId);
var result = _zenhubClient.GetRepositoryClient(repository).GetOldestZenHubBoardAsync().GetAwaiter().GetResult();
Assert.NotNull(result);
Assert.AreEqual("595d430add03f01d32460080", result.Value.Pipelines[0].Id);
}
public GitReference(string url, string label, string @ref, string sha, User user, Repository repository)
{
Url = url;
Label = label;
Ref = @ref;
Sha = sha;
User = user;
Repository = repository;
}
public Activity(string type, bool @public, Repository repo, User actor, Organization org, DateTimeOffset createdAt, string id)
{
Type = type;
Public = @public;
Repo = repo;
Actor = actor;
Org = org;
CreatedAt = createdAt;
Id = id;
}
public SearchCode(string name, string path, string sha, Uri url, Uri gitUrl, Uri htmlUrl, Repository repository)
{
Name = name;
Path = path;
Sha = sha;
Url = url;
GitUrl = gitUrl;
HtmlUrl = htmlUrl;
Repository = repository;
}
private async Task <CSTRepository?> FetchGithubRepositoryMetadata(PackageURL purl)
{
try
{
GitHubClient github = new(new ProductHeaderValue("OSSGadget"));
GHRepository ghRepository = await github.Repository.Get(purl.Namespace, purl.Name);
if (ghRepository is null)
{
return(null);
}
Archived = ghRepository.Archived;
CreatedAt = ghRepository.CreatedAt;
UpdatedAt = ghRepository.UpdatedAt;
Description = OssUtilities.GetMaxClippedLength(ghRepository.Description);
IsFork = ghRepository.Fork;
Forks = ghRepository.ForksCount;
Homepage = OssUtilities.GetMaxClippedLength(ghRepository.Homepage);
Id = ghRepository.Id;
Language = OssUtilities.GetMaxClippedLength(ghRepository.Language);
Name = ghRepository.Name;
OpenIssuesCount = ghRepository.OpenIssuesCount;
Parent = ghRepository.Parent?.Url;
PushedAt = ghRepository.PushedAt;
Size = ghRepository.Size;
FollowersCount = ghRepository.StargazersCount;
Uri = OssUtilities.GetMaxClippedLength(ghRepository.Url);
StakeholdersCount = ghRepository.WatchersCount;
if (ghRepository.License is not null)
{
Licenses ??= new List <Model.License>();
Licenses.Add(new Model.License()
{
Name = ghRepository.License.Name,
Url = ghRepository.License.Url,
SPIX_ID = ghRepository.License.SpdxId
});
}
Owner ??= new Model.User()
{
Id = ghRepository.Owner.Id,
Name = ghRepository.Owner.Name,
Email = ghRepository.Owner.Email,
Url = ghRepository.Owner.Url,
Active = !ghRepository.Owner.Suspended
};
}
catch (Exception ex)
{
Logger.Debug($"Exception occurred while retrieving repository data: {ex}");
}
return(this);
}
public Notification(string id, Repository repository, NotificationInfo subject, string reason, bool unread, string updatedAt, string lastReadAt, string url)
{
Id = id;
Repository = repository;
Subject = subject;
Reason = reason;
Unread = unread;
UpdatedAt = updatedAt;
LastReadAt = lastReadAt;
Url = url;
}
public async Task CreateMilestone(Model.Milestone milestone, Octokit.Repository githubRepo)
{
var newMilestone = new NewMilestone(milestone.Title)
{
Description = milestone.Description
};
var createdMilestone = await GitHubClient.Issue.Milestone.Create(githubRepo.Id, newMilestone);
Log($"Milestone '{createdMilestone.Title}' created (Number: {createdMilestone.Number})");
}
public static async Task <GitHubRepo> GetRepositoryAsync(string owner, string name)
{
if (!string.IsNullOrEmpty(owner) && !string.IsNullOrWhiteSpace(name))
{
GitHubRepo repo = await GitManager.Client.Repository.Get(owner, name);
return(repo);
}
return(null);
}
public async Task CreateLabel(Label label, Octokit.Repository githubRepo)
{
var newLabel = new NewLabel(label.Name, label.Color)
{
Description = label.Description
};
var createdLabel = await GitHubClient.Issue.Labels.Create(githubRepo.Id, newLabel);
Log($"Label '{createdLabel.Name}' created");
}
public RepositoryInvitation(int id, Repository repository, User invitee, User inviter, InvitationPermissionType permissions, DateTimeOffset createdAt, string url, string htmlUrl)
{
Id = id;
Repository = repository;
Invitee = invitee;
Inviter = inviter;
Permissions = permissions;
CreatedAt = createdAt;
Url = url;
HtmlUrl = htmlUrl;
}
public async Task CreateMilestoneIfNotExists(Model.Milestone milestone, Octokit.Repository githubRepo)
{
var foundMilestone = await GetMilestone(milestone.Title, githubRepo);
if (foundMilestone != null)
{
Log($"Milestone '{foundMilestone.Title}' already exists (Number: {foundMilestone.Number})");
return;
}
await CreateMilestone(milestone, githubRepo);
}
public Commit(string url, string label, string @ref, string sha, User user, Repository repository, string message, Committer author, Committer committer, GitReference tree, IEnumerable<GitReference> parents, int commentCount)
: base(url, label, @ref, sha, user, repository)
{
Ensure.ArgumentNotNull(parents, "parents");
Message = message;
Author = author;
Committer = committer;
Tree = tree;
Parents = new ReadOnlyCollection<GitReference>(parents.ToList());
CommentCount = commentCount;
}
public GitHubCommit(string url, string label, string @ref, string sha, User user, Repository repository, Author author, string commentsUrl, Commit commit, Author committer, string htmlUrl, GitHubCommitStats stats, IReadOnlyList<GitReference> parents, IReadOnlyList<GitHubCommitFile> files)
: base(url, label, @ref, sha, user, repository)
{
Author = author;
CommentsUrl = commentsUrl;
Commit = commit;
Committer = committer;
HtmlUrl = htmlUrl;
Stats = stats;
Parents = parents;
Files = files;
}
public async Task CreateLabelIfNotExists(Label label, Octokit.Repository githubRepo)
{
try
{
await GetLabel(label.Name, githubRepo);
Log($"Label '{label.Name}' already exists");
}
catch (NotFoundException)
{
await CreateLabel(label, githubRepo);
}
}
private async Task AsyncMain()
{
_config = Toml.ReadFile <ProxyConfig>("config.toml");
_defaultSignature = new Signature(new Identity(_config.DefaultAuthor.Name, _config.DefaultAuthor.Email),
DateTimeOffset.Now);
_ghClient = new GitHubClient(new ProductHeaderValue("GitHubProxy"))
{
Credentials = new GitHubCredentials(_config.Token)
};
_ghUser = await _ghClient.User.Current();
Logger.Debug(_ghUser.Id);
Logger.Info($"Logged in to GitHub as {_ghUser.Name} ({_ghUser.Login})");
_ghSrc = await _ghClient.Repository.Get(_config.Source.User, _config.Source.Repo);
_ghDest = await _ghClient.Repository.Get(_config.Destination.User, _config.Destination.Repo);
Logger.Debug(_ghSrc.Id);
Logger.Debug(_ghDest.Id);
Logger.Info($"Proxying {_ghSrc.Owner.Login}/{_ghSrc.Name} to {_ghDest.Owner.Login}/{_ghDest.Name}");
await SetupSrcRepo();
using (var srcRepo = new GitRepository("srcRepo"))
{
Logger.Debug(srcRepo.Info.Path);
foreach (var branch in srcRepo.Branches)
{
Logger.Debug(branch.ToString());
}
}
while (true)
{
Console.WriteLine();
Logger.Info("Proxying...");
await ProxyCommits();
_ghSrc = await _ghClient.Repository.Get(_config.Source.User, _config.Source.Repo);
_ghDest = await _ghClient.Repository.Get(_config.Destination.User, _config.Destination.Repo);
await ProxyReleases();
Logger.Info("Done.");
await Task.Delay(_config.Interval * 60 * 1000);
}
}
void ValidateNeedsLabels(Issue issue, ValidationErrors validationErrors, Repository repository)
{
var lastActivityOnIssue = issue.UpdatedAt; //todo: does this include comments?
if (issue.Labels.Any(l => l.Name == "Type: Bug") && !issue.Labels.Any(l => l.Name.StartsWith("Needs:")))
{
if (lastActivityOnIssue < DateTime.UtcNow.AddDays(-3))
{
validationErrors.Add(new ValidationError
{
Reason = "This bug doesn't seem to be triaged, use one of the `Needs: X` labels to remember what the next steps are",
Issue = issue,
Repository = repository
});
}
return;
}
if (issue.Labels.Any(l => l.Name == "Needs: Triage") && lastActivityOnIssue < DateTime.UtcNow.AddDays(-3))
{
validationErrors.Add(new ValidationError
{
Reason = "Issue needs triage but hasn't been updated for 3 days",
Issue = issue,
Repository = repository
});
}
if (issue.Labels.Any(l => l.Name == "Needs: Reproduction") && lastActivityOnIssue < DateTime.UtcNow.AddDays(-7))
{
validationErrors.Add(new ValidationError
{
Reason = "Issue needs a repro but hasn't been touched in the last 7 days",
Issue = issue,
Repository = repository
});
}
if (issue.Labels.Any(l => l.Name == "Needs: Scheduling") && lastActivityOnIssue < DateTime.UtcNow.AddMonths(-3))
{
validationErrors.Add(new ValidationError
{
Reason = "Issue needs scheduling but hasn't been touched in the last 3 months",
Issue = issue,
Repository = repository
});
}
}
public GhRepository(Octokit.Repository repository)
{
Url = repository.Url;
GitUrl = repository.GitUrl;
SshUrl = repository.SshUrl;
Id = repository.Id;
Owner = repository.Owner;
Name = repository.Name;
FullName = repository.FullName;
Description = repository.Description;
Homepage = repository.Homepage;
Language = repository.Language;
ForksCount = repository.ForksCount;
StargazersCount = repository.StargazersCount;
}
public StarRowViewModel(Repository starredRepo)
{
// Visit homepage command
var hasHomepage = this.WhenAny(x => x.Homepage, x => !string.IsNullOrEmpty(x.Value));
VisitHomepage = new ReactiveCommand(hasHomepage);
// Initialize properties
Owner = starredRepo.Owner.Login;
RepoName = starredRepo.Name;
Homepage = starredRepo.Homepage;
// Launch the page in the browser
VisitHomepage.Subscribe(_ =>
{
Process.Start(this.Homepage);
});
}
public async Task CreateIssueIfNotExists(Issue issue, Octokit.Repository githubRepo)
{
var foundIssue = await GetIssue(issue.Title, githubRepo);
if (foundIssue != null)
{
Log($"Issue '{foundIssue.Title}' already exists (#{foundIssue.Id})");
return;
}
var relatedMilestone = await GetMilestone(issue.MilestoneName, githubRepo);
if (relatedMilestone == null)
{
throw new Exception($"Milestone '{issue.MilestoneName}' was not found");
}
await CreateIssue(issue, githubRepo, relatedMilestone);
}
public async Task CreateIssue(Issue issue, Octokit.Repository githubRepo, Milestone relatedMilestone)
{
var optimizedDescription = issue.Description.Replace("- [ ]", "\r\n- [ ]");
var newIssue = new NewIssue(issue.Title)
{
Body = optimizedDescription,
Milestone = relatedMilestone.Number
};
foreach (var label in issue.Labels)
{
newIssue.Labels.Add(label);
}
var createdIssue = await GitHubClient.Issue.Create(githubRepo.Id, newIssue);
Log($"Issue '{createdIssue.Title}' created (#{createdIssue.Number})");
}
public List <Issue> GetIssues(Octokit.Repository repo)
{
bool err = false;
Task <IReadOnlyList <Octokit.Issue> > issues = _client.Issue.GetForRepository(repo.Owner.Login, repo.Name);
try
{
issues.Wait();
}
catch
{
err = true;
}
if ((!err) && (issues.Result != null))
{
return(issues.Result.ToList());
}
return(new List <Issue>());
}
public async Task CreateIssues(Repository repository, ICollection <TransferObjects.Issue> issues, ICollection <TransferObjects.Milestone> milestones, StringBuilder logMessages)
{
var sortedIssues = issues.OrderBy(i => i.Id);
foreach (var issue in sortedIssues)
{
var issueAssignees = issue.AssigneeUserNames.Select(name => _userMapper.MapToGitHubUserName(name)).ToList();
var newIssue = new NewIssue(issue.Title);
newIssue.Body = ComposeBody(issue, issueAssignees);
if (issueAssignees.Contains(repository.Owner.Login))
{
newIssue.Assignees.Add(repository.Owner.Login);
issueAssignees.Remove(repository.Owner.Login);
}
foreach (var label in issue.Labels)
{
newIssue.Labels.Add(label);
}
if (issue.MilestoneId.HasValue)
{
newIssue.Milestone = milestones.Single(ms => ms.SourceId == issue.MilestoneId.Value)?.TargetId;
}
var createdIssue = await _gitHubClient.Issue.Create(repository.Id, newIssue);
foreach (var comment in issue.Comments.Where(c => !c.System).OrderBy(c => c.Id))
{
await _gitHubClient.Issue.Comment.Create(repository.Id, createdIssue.Number, ComposeBody(comment));
}
if (issue.Closed)
{
var issueUpdate = createdIssue.ToUpdate();
issueUpdate.State = ItemState.Closed;
await _gitHubClient.Issue.Update(repository.Id, createdIssue.Number, issueUpdate);
}
issueAssignees.ForEach(username => logMessages.AppendLine($"User >{username}< not automatically assigned to Issue >{createdIssue.HtmlUrl}<"));
}
}
public async Task CreateCollaborators(Repository repository, ICollection <string> usernames, StringBuilder logMessages)
{
var existingCollaborators = await _gitHubClient.Repository.Collaborator.GetAll(repository.Id);
var existingCollaboratorUsernames = existingCollaborators.Select(c => c.Login).ToList();
var neededCollaboratorUsernames = usernames.Select(user => _userMapper.MapToGitHubUserName(user)).ToList();
var newCollaboratorUsernames = neededCollaboratorUsernames.Except(existingCollaboratorUsernames);
foreach (var newCollaboratorUsername in newCollaboratorUsernames)
{
try
{
await _gitHubClient.Repository.Collaborator.Add(repository.Id, newCollaboratorUsername);
}
catch (Exception)
{
logMessages.AppendLine($"Cannot create User >{newCollaboratorUsername}>. Maybe it does not exists in User Mappings or on GitHub.");
}
}
}
public GitHubApiMock(ICache settingsCache)
: base(settingsCache)
{
// Log in
Login("test", "test", null);
// Set up a repository
var repository = new Repository(null, null, null, null, null, null, null, 1, null, "test", "test\\test",
"Test repository",
null, null, false, false, 1, 1, 1, "master", 1, DateTimeOffset.Now.AddDays(-1),
DateTimeOffset.Now.AddDays(-2), DateTimeOffset.Now.AddDays(-1),
null,
new User(null, null, null, 1, null, DateTimeOffset.Now, 1, "*****@*****.**", 1, 1, true, null, 1, 1,
null, "test", "test", 1, null, 0, 0, 0, null, false),
null, null, true, false, true);
var wrapper = new RepositoryWrapper(repository);
Repository = wrapper;
Repositories.Add(wrapper);
GetLabels();
GetMilestones();
}
public Repository(string url, string htmlUrl, string cloneUrl, string gitUrl, string sshUrl, string svnUrl, string mirrorUrl, int id, User owner, string name, string fullName, string description, string homepage, string language, bool @private, bool fork, int forksCount, int stargazersCount, int subscribersCount, string defaultBranch, int openIssuesCount, DateTimeOffset? pushedAt, DateTimeOffset createdAt, DateTimeOffset updatedAt, RepositoryPermissions permissions, User organization, Repository parent, Repository source, bool hasIssues, bool hasWiki, bool hasDownloads)
{
Url = url;
HtmlUrl = htmlUrl;
CloneUrl = cloneUrl;
GitUrl = gitUrl;
SshUrl = sshUrl;
SvnUrl = svnUrl;
MirrorUrl = mirrorUrl;
Id = id;
Owner = owner;
Name = name;
FullName = fullName;
Description = description;
Homepage = homepage;
Language = language;
Private = @private;
Fork = fork;
ForksCount = forksCount;
StargazersCount = stargazersCount;
#pragma warning disable 612,618
SubscribersCount = subscribersCount;
#pragma warning restore 612,618
DefaultBranch = defaultBranch;
OpenIssuesCount = openIssuesCount;
PushedAt = pushedAt;
CreatedAt = createdAt;
UpdatedAt = updatedAt;
Permissions = permissions;
#pragma warning disable 612, 618
Organization = organization;
#pragma warning restore 612, 618
Parent = parent;
Source = source;
HasIssues = hasIssues;
HasWiki = hasWiki;
HasDownloads = hasDownloads;
}
public async Task<WikiProbeResult> ProbeAsync(Repository repo)
{
var repoUri = new Uri(repo.HtmlUrl);
var baseUri = new Uri(repo.HtmlUrl.Replace(repoUri.AbsolutePath, ""));
var request = new Request
{
Method = HttpMethod.Get,
BaseAddress = baseUri,
Endpoint = new Uri(repoUri.AbsolutePath + "/wiki", UriKind.Relative),
Timeout = TimeSpan.FromSeconds(3),
};
request.Headers.Add("User-Agent", productHeader.ToString());
var ret = await httpClient
.Send(request, CancellationToken.None)
.Catch();
if (ret == null)
return WikiProbeResult.Failed;
else if (ret.StatusCode == System.Net.HttpStatusCode.OK)
return WikiProbeResult.Ok;
return WikiProbeResult.NotFound;
}
public static string Get_Basic_Info(string app_name, int repo_id, string token)
{
string result;
try
{
var client = new GitHubClient(new ProductHeaderValue(app_name));
if (!String.IsNullOrEmpty(token))
{
var tokenAuth = new Octokit.Credentials(token);
client.Credentials = tokenAuth;
}
Octokit.Repository repository = client.Repository.Get(repo_id).Result;
result = JsonConvert.SerializeObject(repository);
}
catch (Exception ex)
{
Logger.Log_Error("AustinsFirstProject.Github_Api.Api.Rest_Api_V3.Repositories.Get_Basic_Info failed. Error Msg: " + ex.Message);
result = "";
}
return(result);
}
async Task<Repository> GetRepositoryInternal()
{
await sem.WaitAsync();
try
{
if (owner == null)
{
var ownerLogin = OriginalUrl.Owner;
var repositoryName = OriginalUrl.RepositoryName;
if (ownerLogin != null && repositoryName != null)
{
var repo = await client.Repository.Get(ownerLogin, repositoryName);
if (repo != null)
{
hasWiki = await HasWikiInternal(repo);
isEnterprise = await IsEnterpriseInternal();
repositoryCache = repo;
}
owner = ownerLogin;
}
}
}
// it'll throw if it's private or an enterprise instance requiring authentication
catch (ApiException)
{
if (!HostAddress.IsGitHubDotComUri(OriginalUrl.ToRepositoryUrl()))
isEnterprise = true;
}
catch {}
finally
{
sem.Release();
}
return repositoryCache;
}
private async Task <Octokit.Repository> GetRepositoryInternal()
{
try
{
if (owner == null)
{
var ownerLogin = OriginalUrl.Owner;
var repositoryName = OriginalUrl.RepositoryName;
if (ownerLogin != null && repositoryName != null)
{
var repo = await githubClient.Repository.Get(ownerLogin, repositoryName);
if (repo != null)
{
repositoryCache = repo;
}
owner = ownerLogin;
}
}
}
// it'll throw if it's private or an enterprise instance requiring authentication
catch (ApiException apiex)
{
if (!HostAddress.IsGitHubDotCom(OriginalUrl.ToRepositoryUri()))
{
isEnterprise = apiex.IsGitHubApiException();
}
}
catch {}
finally
{
sem.Release();
}
return(repositoryCache);
}
public Issue(Uri url, Uri htmlUrl, Uri commentsUrl, Uri eventsUrl, int number, ItemState state, string title, string body, User closedBy, User user, IReadOnlyList<Label> labels, User assignee, Milestone milestone, int comments, PullRequest pullRequest, DateTimeOffset? closedAt, DateTimeOffset createdAt, DateTimeOffset? updatedAt, int id, bool locked, Repository repository)
{
Id = id;
Url = url;
HtmlUrl = htmlUrl;
CommentsUrl = commentsUrl;
EventsUrl = eventsUrl;
Number = number;
State = state;
Title = title;
Body = body;
ClosedBy = closedBy;
User = user;
Labels = labels;
Assignee = assignee;
Milestone = milestone;
Comments = comments;
PullRequest = pullRequest;
ClosedAt = closedAt;
CreatedAt = createdAt;
UpdatedAt = updatedAt;
Locked = locked;
Repository = repository;
}
public override Task<IReadOnlyList<User>> GetAssignees(Repository repository)
{
IReadOnlyList<User> list = new List<User>
{
new User("https://avatars.githubusercontent.com/u/493828?v=1", null, null, 1, null, DateTimeOffset.Now,
1, "*****@*****.**", 1, 1, true, null, 1,
1, null, "user", "name", 1, null, 0, 0, 0, null, false)
};
return Task.FromResult(list);
}
public async Task GetLabel(string name, Octokit.Repository githubRepo)
{
await GitHubClient.Issue.Labels.Get(githubRepo.Id, name);
}
public override void UpdateIssue(Repository repository, int id, IssueUpdate update)
{
Issue = new Issue(null, null, id, ItemState.Open, update.Title, update.Body, null, null, null, null, 0, null, null, DateTimeOffset.Now, null );
}
public override void SaveIssue(Repository repository, NewIssue newIssue)
{
var issue = new Issue(null, null, 69, ItemState.Open, newIssue.Title, newIssue.Body, null, null, null, null, 0, null, null, DateTimeOffset.Now, null);
AllIssues.Add(issue);
Issue = issue;
}
public MoveStaleIARequirementsToBacklog(IGitHubClient client, Repository repository, TimeSpan maxStaleness)
{
this.client = client;
this.repository = repository;
this.maxStaleness = maxStaleness;
}
private async Task <IReadOnlyList <Milestone> > GetAllMilestones(Octokit.Repository githubRepo)
{
return(await GitHubClient.Issue.Milestone.GetAllForRepository(githubRepo.Id));
}
public RemindWhenMoreRequirementsNeedsToBeApproved(IGitHubClient client, Repository repository, BotCommand.IResponse response)
{
this.client = client;
this.repository = repository;
this.response = response;
}
public override async void UpdateIssue(Repository repository, int id, IssueUpdate update)
{
try
{
Issue issueUpdate = await _github.Issue.Update(repository.Owner.Login, repository.Name, id, update);
if (Repository != null && repository.Id == Repository.Repository.Id)
{
foreach (var issue in AllIssues)
{
if (issue.Number == issueUpdate.Number)
{
AllIssues.Remove(issue);
AllIssues.Insert(0, issueUpdate);
Issue = issueUpdate;
break;
}
}
}
}
catch ( Exception exception )
{
_log.Write(LogLevel.Error, "Failed to save issue.", exception);
}
}
public override async void SaveIssue(Repository repository, NewIssue newIssue)
{
try
{
Issue issue = await _github.Issue.Create(repository.Owner.Login, repository.Name, newIssue);
if (issue != null && Repository != null && repository.Id == Repository.Repository.Id)
{
AllIssues.Insert(0, issue);;
Issue = issue;
}
}
catch ( Exception exception )
{
_log.Write(LogLevel.Error, "Failed to save issue.", exception);
}
}
async Task<bool> HasWikiInternal(Repository repo)
{
if (repo == null)
return false;
if (!repo.HasWiki)
{
hasWiki = false;
return false;
}
var probe = wikiProbe.Value;
Debug.Assert(probe != null, "Lazy<Wiki> probe is not set, something is wrong.");
#if !DEBUG
if (probe == null)
return false;
#endif
var ret = await probe.ProbeAsync(repo);
return (ret == WikiProbeResult.Ok);
}
public Octokit.Repository Repository_GetById(long repositoryId)
{
lastCoreRequest = DateTime.Now;
Octokit.Repository repository = gitHubClient.Repository.Get(repositoryId).Result;
return(repository);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="client">Octokit object used for interacting with the GitHub REST API</param>
/// <param name="repo">Reference to the Octokit object describing the GitHub repo</param>
public Repository(GitHubClient client, Octokit.Repository repo)
{
_client = client;
_obj = repo;
}
