예제 #1
0
        protected async Task <IList <IPullRequest> > GetPullRequestsAsync(IFolder repositoryFolder, string state, IErrorsAndInfos errorsAndInfos)
        {
            var pullRequests = new List <IPullRequest>();

            vGitUtilities.IdentifyOwnerAndName(repositoryFolder, out var owner, out var name, errorsAndInfos);
            if (errorsAndInfos.AnyErrors())
            {
                return(pullRequests);
            }


            var url    = $"https://api.github.com/repos/{owner}/{name}/pulls?state=" + state;
            var result = await RunJsonWebRequestAsync(url, owner, errorsAndInfos) as JArray;

            if (errorsAndInfos.AnyErrors())
            {
                return(pullRequests);
            }

            if (result == null)
            {
                errorsAndInfos.Errors.Add(Properties.Resources.CouldNotGetListOfPullRequests);
                return(pullRequests);
            }

            pullRequests.AddRange(result.Select(detailResult => CreatePullRequest(detailResult)));

            return(pullRequests);
        }
예제 #2
0
        public void CanIdentifyUrlOwnerAndName()
        {
            var errorsAndInfos = new ErrorsAndInfos();

            vSut.IdentifyOwnerAndName(MasterFolder, out var owner, out var name, errorsAndInfos);
            Assert.IsFalse(errorsAndInfos.AnyErrors(), errorsAndInfos.ErrorsPlusRelevantInfos());
            Assert.AreEqual("aspenlaub", owner);
            Assert.AreEqual("PakledCore", name);
        }
예제 #3
0
        private async Task AutoCommitAndPushAsync(string nugetFeedId, IFolder repositoryFolder, List <string> files, bool onlyIfNecessary, string commitMessage, bool noRebuildRequired, IErrorsAndInfos errorsAndInfos)
        {
            var branchName = GitUtilities.CheckedOutBranch(repositoryFolder);

            if (branchName != "master")
            {
                errorsAndInfos.Errors.Add(Properties.Resources.CheckedOutBranchIsNotMaster);
                return;
            }

            var headTipShaBeforePush = GitUtilities.HeadTipIdSha(repositoryFolder);

            GitUtilities.IdentifyOwnerAndName(repositoryFolder, out var owner, out _, errorsAndInfos);
            if (errorsAndInfos.AnyErrors())
            {
                errorsAndInfos.Errors.Add(Properties.Resources.OwnerAndNameNotFound);
                return;
            }

            var personalAccessTokensSecret = new PersonalAccessTokensSecret();
            var personalAccessTokens       = await SecretRepository.GetAsync(personalAccessTokensSecret, errorsAndInfos);

            var personalAccessToken = personalAccessTokens.FirstOrDefault(t => t.Owner == owner && t.Purpose == "AutoCommitPush");

            if (personalAccessToken == null)
            {
                errorsAndInfos.Errors.Add(Properties.Resources.AutoCommitPushAccessTokenNotFound);
                return;
            }

            using var repo = new Repository(repositoryFolder.FullName);

            var remotes = repo.Network.Remotes.ToList();

            if (remotes.Count != 1)
            {
                errorsAndInfos.Errors.Add(Properties.Resources.RemoteNotFoundOrNotUnique);
                return;
            }

            var remote = remotes[0];

            files.ForEach(f => {
                // ReSharper disable once AccessToDisposedClosure
                Commands.Stage(repo, f);
            });

            var checkFiles = GitUtilities.FilesWithUncommittedChanges(repositoryFolder);

            if (onlyIfNecessary && !checkFiles.Any())
            {
                return;
            }

            if (checkFiles.Count != files.Count)
            {
                errorsAndInfos.Errors.Add(string.Format(Properties.Resources.NumberOfFilesWithUncommittedChangesHasChanged,
                                                        string.Join(", ", files), string.Join(", ", checkFiles)));
                return;
            }

            var author    = new Signature(personalAccessToken.TokenName, personalAccessToken.Email, DateTime.Now);
            var committer = author;

            repo.Commit(commitMessage, author, committer);

            var options = new PushOptions {
                CredentialsProvider = (_, _, _) => new UsernamePasswordCredentials {
                    Username = owner,
                    Password = personalAccessToken.Token
                }
            };

            repo.Network.Push(remote, @"refs/heads/" + branchName, options);

            if (!noRebuildRequired)
            {
                return;
            }

            var pushedHeadTipShaRepository = PushedHeadTipShaRepository;

            if (!(await pushedHeadTipShaRepository.GetAsync(nugetFeedId, errorsAndInfos)).Contains(headTipShaBeforePush))
            {
                return;
            }

            var headTipSha = GitUtilities.HeadTipIdSha(repositoryFolder);
            await pushedHeadTipShaRepository.AddAsync(nugetFeedId, headTipSha, errorsAndInfos);
        }