private async Task <Commit> SetupCommitForRepository(IGitHubClient client) { var blob = new NewBlob { Content = "Hello World!", Encoding = EncodingType.Utf8 }; var blobResult = await client.Git.Blob.Create(_context.RepositoryOwner, _context.RepositoryName, blob); var newTree = new NewTree(); newTree.Tree.Add(new NewTreeItem { Type = TreeType.Blob, Mode = FileMode.File, Path = "README.md", Sha = blobResult.Sha }); var treeResult = await client.Git.Tree.Create(_context.RepositoryOwner, _context.RepositoryName, newTree); var newCommit = new NewCommit("test-commit", treeResult.Sha); return(await client.Git.Commit.Create(_context.RepositoryOwner, _context.RepositoryName, newCommit)); }
private async static Task <Commit> HelperCreateCommit(string owner, string repo) { var client = Helper.GetAuthenticatedClient(); var blob = new NewBlob { Content = "Hello World!", Encoding = EncodingType.Utf8 }; var blobResult = await client.Git.Blob.Create(owner, repo, blob); var newTree = new NewTree(); newTree.Tree.Add(new NewTreeItem { Type = TreeType.Blob, Mode = FileMode.File, Path = "README.md", Sha = blobResult.Sha }); var treeResult = await client.Git.Tree.Create(owner, repo, newTree); var newCommit = new NewCommit("test-commit", treeResult.Sha); return(await client.Git.Commit.Create(owner, repo, newCommit)); }
public async Task CreateCommit(long repoId, string directoryToAdd, string commitText) { var headMasterRef = "heads/master"; var github = GetClient(); var masterReference = await github.Git.Reference.Get(repoId, headMasterRef); var latestCommit = await GetLatestSHA(repoId, headMasterRef); var nt = new NewTree { BaseTree = latestCommit.Tree.Sha }; string[] filePaths = Directory.GetFiles(string.Format(@"{0}\", directoryToAdd)); foreach (var filePath in filePaths) { var linesOfCode = await File.ReadAllLinesAsync(filePath); var newTreeItem = new NewTreeItem { Mode = "100644", Type = TreeType.Blob, Content = linesOfCode.ToString(), Path = filePath }; nt.Tree.Add(newTreeItem); } var newTree = await github.Git.Tree.Create(repoId, nt); var newCommit = new NewCommit(commitText, newTree.Sha, masterReference.Object.Sha); var commit = await github.Git.Commit.Create(repoId, newCommit); await github.Git.Reference.Update(repoId, headMasterRef, new ReferenceUpdate(commit.Sha)); }
public static void MakeCommit(GitHubClient client, Configuration config, int commitNumber) { string yearString = Utils.GetTodaysDate().ToString("yyyy-MM-dd"); string headMasterRef = "refs/heads/master"; Reference masterReference = client.Git.Reference.Get(config.RepoOwner, config.RepoName, headMasterRef).Result; Commit latestCommit = client.Git.Commit.Get(config.RepoOwner, config.RepoName, masterReference.Object.Sha).Result; var nt = new NewTree { BaseTree = latestCommit.Tree.Sha }; var textBlob = new NewBlob { Encoding = EncodingType.Utf8, Content = $"Commit number {commitNumber} today" }; var textBlobRef = client.Git.Blob.Create(config.RepoOwner, config.RepoName, textBlob); nt.Tree.Add(new NewTreeItem { Path = yearString, Mode = "100644", Type = TreeType.Blob, Sha = textBlobRef.Result.Sha }); var newTree = client.Git.Tree.Create(config.RepoOwner, config.RepoName, nt).Result; var newCommit = new NewCommit($"commit {yearString} {commitNumber}", newTree.Sha, masterReference.Object.Sha); var commit = client.Git.Commit.Create(config.RepoOwner, config.RepoName, newCommit).Result; Reference reff = client.Git.Reference.Update(config.RepoOwner, config.RepoName, headMasterRef, new ReferenceUpdate(commit.Sha)).Result; }
private async Task <Reference> PushFix(IGitHubClient client, Repository repository, Commit latest, string jenkinsFile) { var oldTree = await client.Git.Tree.Get(repository.Owner.Login, repository.Name, latest.Sha).ConfigureAwait(false); var newTree = new NewTree { BaseTree = oldTree.Sha }; var blobReference = await CreateBlob(client, repository, jenkinsFile).ConfigureAwait(false); var treeItem = new NewTreeItem() { Path = JenkinsFileName, Mode = FileMode, Type = TreeType.Blob, Sha = blobReference.Sha }; newTree.Tree.Add(treeItem); var createdTree = await client.Git.Tree.Create(repository.Owner.Login, repository.Name, newTree).ConfigureAwait(false); var commit = new NewCommit($"Update {LibraryName} to latest version.", createdTree.Sha, new[] { latest.Sha }); var commitResponse = await client.Git.Commit.Create(repository.Owner.Login, repository.Name, commit).ConfigureAwait(false); var refUpdate = new ReferenceUpdate(commitResponse.Sha); return(await client.Git.Reference.Update(repository.Owner.Login, repository.Name, $"heads/{_branchName}", refUpdate).ConfigureAwait(false)); }
public async Task <string> CreateCommit(string message, string treeSha, string parentSha) { var newCommit = new NewCommit(message, treeSha, parentSha); var response = await CreateClient().Git.Commit.Create(Repository.Owner, Repository.Name, newCommit); return(response.Sha); }
public async Task Start() { using var workingRepo = new Repository(path2Repo); while (true) { var targetBranch = workingRepo.Branches .Where(b => b.FriendlyName == FrendlyBranchName).FirstOrDefault(); if (targetBranch.IsCurrentRepositoryHead) { var currentCommit = targetBranch.Commits.FirstOrDefault(); if (string.IsNullOrEmpty(CurrentSHA)) { CurrentSHA = currentCommit.Sha; } else { if (CurrentSHA != currentCommit.Sha) { CurrentSHA = currentCommit.Sha; NewCommit?.Invoke(this, workingRepo); } } await Task.Delay(10000); } await Task.Delay(10000); } }
public async Task CanCreateAndRetrieveCommit() { var blob = new NewBlob { Content = "Hello World!", Encoding = EncodingType.Utf8 }; var blobResult = await _client.GitDatabase.Blob.Create(_owner, _repository.Name, blob); var newTree = new NewTree(); newTree.Tree.Add(new NewTreeItem { Type = TreeType.Blob, Mode = FileMode.File, Path = "README.md", Sha = blobResult.Sha }); var treeResult = await _client.GitDatabase.Tree.Create(_owner, _repository.Name, newTree); var newCommit = new NewCommit("test-commit", treeResult.Sha); var commit = await _fixture.Create(_owner, _repository.Name, newCommit); Assert.NotNull(commit); var retrieved = await _fixture.Get(_owner, _repository.Name, commit.Sha); Assert.NotNull(retrieved); }
public async Task CanDeleteAReferenceWithRepositoryId() { var blob = new NewBlob { Content = "Hello World!", Encoding = EncodingType.Utf8 }; var blobResult = await _github.Git.Blob.Create(_context.RepositoryOwner, _context.RepositoryName, blob); var newTree = new NewTree(); newTree.Tree.Add(new NewTreeItem { Mode = FileMode.File, Type = TreeType.Blob, Path = "README.md", Sha = blobResult.Sha }); var treeResult = await _github.Git.Tree.Create(_context.RepositoryOwner, _context.RepositoryName, newTree); var newCommit = new NewCommit("This is a new commit", treeResult.Sha); var commitResult = await _github.Git.Commit.Create(_context.RepositoryOwner, _context.RepositoryName, newCommit); var newReference = new NewReference("heads/develop", commitResult.Sha); await _fixture.Create(_context.Repository.Id, newReference); await _fixture.Delete(_context.Repository.Id, "heads/develop"); var all = await _fixture.GetAll(_context.Repository.Id); Assert.Empty(all.Where(r => r.Ref == "heads/develop")); }
private async Task <Commit> CommitToRepository(RepositorySummary repositorySummary) { var owner = repositorySummary.Owner; var repository = repositorySummary.Name; var blob = new NewBlob { Content = "Hello World!", Encoding = EncodingType.Utf8 }; var blobResult = await _client.Git.Blob.Create(owner, repository, blob); var newTree = new NewTree(); newTree.Tree.Add(new NewTreeItem { Type = TreeType.Blob, Mode = FileMode.File, Path = "README.md", Sha = blobResult.Sha }); var treeResult = await _client.Git.Tree.Create(owner, repository, newTree); var newCommit = new NewCommit("test-commit", treeResult.Sha); var commit = await _fixture.Create(owner, repository, newCommit); return(commit); }
public async Task CanCreateAReference() { var blob = new NewBlob { Content = "Hello World!", Encoding = EncodingType.Utf8 }; var blobResult = await _client.GitDatabase.Blob.Create(_owner, _repository.Name, blob); var newTree = new NewTree(); newTree.Tree.Add(new NewTreeItem { Mode = FileMode.File, Type = TreeType.Blob, Path = "README.md", Sha = blobResult.Sha }); var treeResult = await _client.GitDatabase.Tree.Create(_owner, _repository.Name, newTree); var newCommit = new NewCommit("This is a new commit", treeResult.Sha); var commitResult = await _client.GitDatabase.Commit.Create(_owner, _repository.Name, newCommit); var newReference = new NewReference("heads/develop", commitResult.Sha); var result = await _fixture.Create(_owner, _repository.Name, newReference); Assert.Equal(commitResult.Sha, result.Object.Sha); }
public DeploymentsClientTests() { var github = Helper.GetAuthenticatedClient(); _deploymentsClient = github.Repository.Deployment; _context = github.CreateRepositoryContext("public-repo").Result; var blob = new NewBlob { Content = "Hello World!", Encoding = EncodingType.Utf8 }; var blobResult = github.Git.Blob.Create(_context.RepositoryOwner, _context.RepositoryName, blob).Result; var newTree = new NewTree(); newTree.Tree.Add(new NewTreeItem { Type = TreeType.Blob, Mode = FileMode.File, Path = "README.md", Sha = blobResult.Sha }); var treeResult = github.Git.Tree.Create(_context.RepositoryOwner, _context.RepositoryName, newTree).Result; var newCommit = new NewCommit("test-commit", treeResult.Sha); _commit = github.Git.Commit.Create(_context.RepositoryOwner, _context.RepositoryName, newCommit).Result; }
private IEnumerable <Commit> CreateCommits(int commitCount) { var github = Helper.GetAuthenticatedClient(); var list = new List <Commit>(); for (int i = 0; i < commitCount; i++) { var blob = new NewBlob { Content = string.Format("Hello World {0}!", i), Encoding = EncodingType.Utf8 }; var blobResult = github.Git.Blob.Create(_context.RepositoryOwner, _context.RepositoryName, blob).Result; var newTree = new NewTree(); newTree.Tree.Add(new NewTreeItem { Type = TreeType.Blob, Mode = FileMode.File, Path = "README.md", Sha = blobResult.Sha }); var treeResult = github.Git.Tree.Create(_context.RepositoryOwner, _context.RepositoryName, newTree).Result; var newCommit = new NewCommit("test-commit", treeResult.Sha); var commit = github.Git.Commit.Create(_context.RepositoryOwner, _context.RepositoryName, newCommit).Result; list.Add(commit); } return(list); }
public void Upload(Folder folderInfo) { var tree = this.ConstructTree(folderInfo); var createdTree = client.Git.Tree.Create(repo.Id, tree); createdTree.Wait(); // 4 - this commit should build on the current master branch var master = client.Git.Reference.Get(repo.Id, "heads/master"); master.Wait(); var newCommit = new NewCommit( "Hello World!", createdTree.Result.Sha, new[] { master.Result.Object.Sha }) { Author = new Committer("ram", "*****@*****.**", DateTime.UtcNow) }; var createdCommit = client.Git.Commit.Create(repo.Id, newCommit); createdCommit.Wait(); // 5 - create a reference for the master branch var updateReference = new ReferenceUpdate(createdCommit.Result.Sha); var updatedReference = client.Git.Reference.Update(repo.Id, "heads/master", updateReference); updatedReference.Wait(); }
/// <summary> /// Create a commit for a given repository /// </summary> /// <remarks> /// http://developer.github.com/v3/git/commits/#create-a-commit /// </remarks> /// <param name="owner">The owner of the repository</param> /// <param name="name">The name of the repository</param> /// <param name="commit">The commit to create</param> /// <returns></returns> public IObservable<Commit> Create(string owner, string name, NewCommit commit) { Ensure.ArgumentNotNullOrEmptyString(owner, "owner"); Ensure.ArgumentNotNullOrEmptyString(name, "name"); Ensure.ArgumentNotNull(commit, "commit"); return _client.Create(owner, name, commit).ToObservable(); }
public IObservable <Commit> Create(string owner, string name, NewCommit commit) { Ensure.ArgumentNotNullOrEmptyString(owner, "owner"); Ensure.ArgumentNotNullOrEmptyString(name, "name"); Ensure.ArgumentNotNull(commit, "commit"); return(_client.Create(owner, name, commit).ToObservable()); }
protected override async Task CommitTransactionAsync() { var newTreeResult = await github.Git.Tree.Create(owner, repo, newTree); var newCommit = new NewCommit("Commit test with several files", newTreeResult.Sha, masterReference.Object.Sha); var commit = await github.Git.Commit.Create(owner, repo, newCommit); await github.Git.Reference.Update(owner, repo, headMasterRef, new ReferenceUpdate(commit.Sha)); }
public async Task RequestsCorrectUrl() { var gitHubClient = Substitute.For <IGitHubClient>(); var client = new ObservableCommitsClient(gitHubClient); var newCommit = new NewCommit("message", "tree", new[] { "parent1", "parent2" }); client.Create("owner", "name", newCommit); gitHubClient.Git.Commit.Received().Create("owner", "name", newCommit); }
public async Task RequestsCorrectUrl() { var gitHubClient = Substitute.For<IGitHubClient>(); var client = new ObservableCommitsClient(gitHubClient); var newCommit = new NewCommit("message", "tree", new[] { "parent1", "parent2" }); client.Create("owner", "name", newCommit); gitHubClient.Git.Commit.Received().Create("owner", "name", newCommit); }
public async Task CanUpdateAReference() { var firstBlob = new NewBlob { Content = "Hello World!", Encoding = EncodingType.Utf8 }; var firstBlobResult = await _client.GitDatabase.Blob.Create(_owner, _repository.Name, firstBlob); var secondBlob = new NewBlob { Content = "This is a test!", Encoding = EncodingType.Utf8 }; var secondBlobResult = await _client.GitDatabase.Blob.Create(_owner, _repository.Name, secondBlob); var firstTree = new NewTree(); firstTree.Tree.Add(new NewTreeItem { Mode = FileMode.File, Type = TreeType.Blob, Path = "README.md", Sha = firstBlobResult.Sha }); var firstTreeResult = await _client.GitDatabase.Tree.Create(_owner, _repository.Name, firstTree); var firstCommit = new NewCommit("This is a new commit", firstTreeResult.Sha); var firstCommitResult = await _client.GitDatabase.Commit.Create(_owner, _repository.Name, firstCommit); var newReference = new NewReference("heads/develop", firstCommitResult.Sha); await _fixture.Create(_owner, _repository.Name, newReference); var secondTree = new NewTree(); secondTree.Tree.Add(new NewTreeItem { Mode = FileMode.File, Type = TreeType.Blob, Path = "README.md", Sha = secondBlobResult.Sha }); var secondTreeResult = await _client.GitDatabase.Tree.Create(_owner, _repository.Name, secondTree); var secondCommit = new NewCommit("This is a new commit", secondTreeResult.Sha, firstCommitResult.Sha); var secondCommitResult = await _client.GitDatabase.Commit.Create(_owner, _repository.Name, secondCommit); var referenceUpdate = new ReferenceUpdate(secondCommitResult.Sha); var result = await _fixture.Update(_owner, _repository.Name, "heads/develop", referenceUpdate); Assert.Equal(secondCommitResult.Sha, result.Object.Sha); }
static async Task <Commit> CreateCommit(GitHubClient client, string repoName, string message, string sha, string parent, string username) { var newCommit = new NewCommit(message, sha, parent); return(await client.Git.Commit.Create(username, repoName, newCommit)); }
public async Task <string> CreateCommit(string treeSha, string owner, string repo, string parentCommitSha) { var newCommit = new NewCommit("GitHubSync update", treeSha, new[] { parentCommitSha }); var createdCommit = await client.Git.Commit.Create(owner, repo, newCommit); log(string.Format("API Query - Create commit '{0}' in '{1}/{2}'. -> https://github.com/{1}/{2}/commit/{3}", createdCommit.Sha.Substring(0, 7), owner, repo, createdCommit.Sha)); return(createdCommit.Sha); }
public async Task PostsToTheCorrectUrlWithRepositoryId() { var gitHubClient = Substitute.For <IGitHubClient>(); var client = new ObservableCommitsClient(gitHubClient); var newCommit = new NewCommit("message", "tree", new[] { "parent1", "parent2" }); client.Create(1, newCommit); gitHubClient.Git.Commit.Received().Create(1, newCommit); }
public async Task EnsureNonNullArguments() { var client = new ObservableCommitsClient(Substitute.For<IGitHubClient>()); var newCommit = new NewCommit("message", "tree", new[] { "parent1", "parent2" }); await Assert.ThrowsAsync<ArgumentNullException>(() => client.Create(null, "name", newCommit).ToTask()); await Assert.ThrowsAsync<ArgumentNullException>(() => client.Create("owner", null, newCommit).ToTask()); await Assert.ThrowsAsync<ArgumentNullException>(() => client.Create("owner", "name", null).ToTask()); await Assert.ThrowsAsync<ArgumentException>(() => client.Create("", "name", newCommit).ToTask()); await Assert.ThrowsAsync<ArgumentException>(() => client.Create("owner", "", newCommit).ToTask()); }
public async Task PostsToTheCorrectUrlWithRepositoryId() { var gitHubClient = Substitute.For<IGitHubClient>(); var client = new ObservableCommitsClient(gitHubClient); var newCommit = new NewCommit("message", "tree", new[] { "parent1", "parent2" }); client.Create(1, newCommit); gitHubClient.Git.Commit.Received().Create(1, newCommit); }
public void Put([FromServices] Signature signature, [FromBody] NewCommit newCommit) { if (newCommit == null) //Keep empty messages working for now. { newCommit = new NewCommit() { Message = "" }; } this.commitRepository.Commit(signature, newCommit); }
public async Task CreateOrUpdateFiles(IEnumerable <CommitContent> commits, string commitMessage) { var headRef = $"heads/{_branch}"; // Get current head ref. var reference = await _octokitClient.Git.Reference.Get(_userName, _repoName, headRef); var latestCommit = await _octokitClient.Git.Commit.Get(_userName, _repoName, reference.Object.Sha); // Build new tree. var tree = new NewTree { BaseTree = latestCommit.Tree.Sha }; var tasks = commits.Select(c => { return(_octokitClient.Git.Blob.Create( _userName, _repoName, new NewBlob { Content = c.Content, Encoding = c.EncodingType }).ContinueWith( blob => { return new NewTreeItem { Path = c.FilePath, Mode = "100644", Type = TreeType.Blob, Sha = blob.Result.Sha }; })); }); var treeItem = await Task.WhenAll(tasks); foreach (var item in treeItem) { tree.Tree.Add(item); } var response = await _octokitClient.Git.Tree.Create(_userName, _repoName, tree); var newCommit = new NewCommit(commitMessage, response.Sha, reference.Object.Sha); var commit = await _octokitClient.Git.Commit.Create(_userName, _repoName, newCommit); // Update current head ref. await _octokitClient.Git.Reference.Update(_userName, _repoName, headRef, new ReferenceUpdate(commit.Sha)); }
private async Task <string> CommitNewTreeItem(List <NewTreeItem> list, StringBuilder sb, Action <string> updateLabel, Action <float, float> updateProgress) { float awaitCount = 0; float awaitMaxCount = 5 + list.Count; try { updateLabel?.Invoke("Get Master Reference.."); var masterReference = await Client.Git.Reference.Get(OwnerSpaceName, RepositoryName, ReferenceName); updateProgress?.Invoke(++awaitCount, awaitMaxCount); updateLabel?.Invoke("Get Latest Commit.."); var latestCommit = await Client.Git.Commit.Get(OwnerSpaceName, RepositoryName, masterReference.Object.Sha); updateProgress?.Invoke(++awaitCount, awaitMaxCount); var nt = new NewTree { BaseTree = latestCommit.Tree.Sha }; foreach (var item in list) { nt.Tree.Add(item); } updateLabel?.Invoke("Create New Tree.."); var newTree = await Client.Git.Tree.Create(OwnerSpaceName, RepositoryName, nt); updateProgress?.Invoke(++awaitCount, awaitMaxCount); var newCommit = new NewCommit(sb.ToString(), newTree.Sha, masterReference.Object.Sha); updateLabel?.Invoke("Create New Commit.."); var commit = await Client.Git.Commit.Create(OwnerSpaceName, RepositoryName, newCommit); updateProgress?.Invoke(++awaitCount, awaitMaxCount); updateLabel?.Invoke("Update Reference.."); await Client.Git.Reference.Update(OwnerSpaceName, RepositoryName, ReferenceName, new ReferenceUpdate(commit.Sha)); updateProgress?.Invoke(++awaitCount, awaitMaxCount); } catch (Exception e) { return(e.Message); } return(string.Empty); }
public async Task EnsureNonNullArguments() { var client = new ObservableCommitsClient(Substitute.For <IGitHubClient>()); var newCommit = new NewCommit("message", "tree", new[] { "parent1", "parent2" }); Assert.Throws <ArgumentNullException>(() => client.Create(null, "name", newCommit)); Assert.Throws <ArgumentNullException>(() => client.Create("owner", null, newCommit)); Assert.Throws <ArgumentNullException>(() => client.Create("owner", "name", null)); Assert.Throws <ArgumentNullException>(() => client.Create(1, null)); Assert.Throws <ArgumentException>(() => client.Create("", "name", newCommit)); Assert.Throws <ArgumentException>(() => client.Create("owner", "", newCommit)); }
public async Task EnsuresNonNullArguments() { var client = new CommitsClient(Substitute.For <IApiConnection>()); var newCommit = new NewCommit("message", "tree", new[] { "parent1", "parent2" }); await Assert.ThrowsAsync <ArgumentNullException>(() => client.Create(null, "name", newCommit)); await Assert.ThrowsAsync <ArgumentNullException>(() => client.Create("owner", null, newCommit)); await Assert.ThrowsAsync <ArgumentNullException>(() => client.Create("owner", "name", null)); await Assert.ThrowsAsync <ArgumentException>(() => client.Create("", "name", newCommit)); await Assert.ThrowsAsync <ArgumentException>(() => client.Create("owner", "", newCommit)); }
public DeploymentStatusClientTests() { _gitHubClient = new GitHubClient(new ProductHeaderValue("OctokitTests")) { Credentials = Helper.Credentials }; _deploymentsClient = _gitHubClient.Repository.Deployment; var newRepository = new NewRepository { Name = Helper.MakeNameWithTimestamp("public-repo"), AutoInit = true }; _repository = _gitHubClient.Repository.Create(newRepository).Result; _repositoryOwner = _repository.Owner.Login; var blob = new NewBlob { Content = "Hello World!", Encoding = EncodingType.Utf8 }; var blobResult = _gitHubClient.GitDatabase.Blob.Create(_repositoryOwner, _repository.Name, blob).Result; var newTree = new NewTree(); newTree.Tree.Add(new NewTreeItem { Type = TreeType.Blob, Mode = FileMode.File, Path = "README.md", Sha = blobResult.Sha }); var treeResult = _gitHubClient.GitDatabase.Tree.Create(_repositoryOwner, _repository.Name, newTree).Result; var newCommit = new NewCommit("test-commit", treeResult.Sha); _commit = _gitHubClient.GitDatabase.Commit.Create(_repositoryOwner, _repository.Name, newCommit).Result; var newDeployment = new NewDeployment { Ref = _commit.Sha }; _deployment = _deploymentsClient.Create(_repositoryOwner, _repository.Name, newDeployment).Result; }
private static async Task CommitTranscriptToGithub(TranscriptionResult transcriptionResult, ILogger log) { var gitHubPAT = Environment.GetEnvironmentVariable(nameof(AppSettings.GitHubToken), EnvironmentVariableTarget.Process); var gitHubUserName = Environment.GetEnvironmentVariable(nameof(AppSettings.GitHubUserName), EnvironmentVariableTarget.Process); var gitHubRepoName = Environment.GetEnvironmentVariable(nameof(AppSettings.GitHubRepoName), EnvironmentVariableTarget.Process); var headMasterRef = "heads/master"; var githubClient = new GitHubClient(new ProductHeaderValue($"{gitHubUserName}-{gitHubRepoName}")) { Credentials = new Credentials(gitHubPAT, AuthenticationType.Bearer) }; log.LogInformation("Get latest commit sha of master"); var masterReference = await githubClient.Git.Reference.Get(gitHubUserName, gitHubRepoName, headMasterRef); var latestCommit = await githubClient.Git.Commit.Get(gitHubUserName, gitHubRepoName, masterReference.Object.Sha); // New Tree var nt = new NewTree { BaseTree = latestCommit.Tree.Sha, }; var newTreeItem = new NewTreeItem { Mode = "100644", Type = TreeType.Blob, Content = JsonConvert.SerializeObject(transcriptionResult, Formatting.Indented), Path = $"transcripts/{transcriptionResult.PublishDate}_{transcriptionResult.Title}.json" }; nt.Tree.Add(newTreeItem); log.LogInformation("Add new tree"); var newTree = await githubClient.Git.Tree.Create(gitHubUserName, gitHubRepoName, nt); log.LogInformation("Add New Commit"); var newCommit = new NewCommit($"Add {transcriptionResult.Title}", newTree.Sha, masterReference.Object.Sha); var commit = await githubClient.Git.Commit.Create(gitHubUserName, gitHubRepoName, newCommit); log.LogInformation(" Update HEAD with the commit"); await githubClient.Git.Reference.Update(gitHubUserName, gitHubRepoName, headMasterRef, new ReferenceUpdate(commit.Sha)); }
public void PostsToTheCorrectUrlWithRepositoryId() { var connection = Substitute.For <IApiConnection>(); var client = new CommitsClient(connection); var parents = new List <string> { "sha-reference1", "sha-reference2" }; var newCommit = new NewCommit("message", "tree", parents); client.Create(1, newCommit); connection.Received().Post <Commit>(Arg.Is <Uri>(u => u.ToString() == "repositories/1/git/commits"), Arg.Is <NewCommit>(nc => nc.Message == "message" && nc.Tree == "tree" && nc.Parents.Count() == 2)); }
/// <summary> /// Commit the current working directory. /// </summary> /// <param name="signature">The user signature, from services.</param> /// <param name="newCommit">The new commit object.</param> public void Commit(Signature signature, NewCommit newCommit) { if (!repo.Index.IsFullyMerged) { throw new InvalidOperationException("Cannot commit while there are conflicts. Please resolve these first."); } var status = repo.RetrieveStatus(); if (status.IsDirty) { foreach (var path in QueryChanges(status).Select(s => s.FilePath)) { Commands.Stage(repo, path); } repo.Commit(newCommit.Message, signature, signature); } }
public async Task CanCreateAndRetrieveCommit() { string owner = this._repository.Owner.Login; var author = new Signature { Name = "author", Email = "*****@*****.**", Date = DateTime.UtcNow }; var commiter = new Signature { Name = "commiter", Email = "*****@*****.**", Date = DateTime.Today }; var newCommit = new NewCommit("test-commit", "[Change this to tree sha]", Enumerable.Empty<string>()) { Author = author, Committer = commiter }; var commit = await this._commitsClient.Create(owner, this._repository.Name, newCommit); Assert.NotNull(commit); var retrieved = await this._commitsClient.Get(owner, this._repository.Name, commit.Sha); Assert.NotNull(retrieved); }
public static async Task<Commit> CreateCommit(this IGitHubClient client, Repository repository, string message, string sha, string parent) { var newCommit = new NewCommit(message, sha, parent); return await client.GitDatabase.Commit.Create(repository.Owner.Login, repository.Name, newCommit); }
/// <summary> /// Create a commit for a given repository /// </summary> /// <remarks> /// http://developer.github.com/v3/git/commits/#create-a-commit /// </remarks> /// <param name="repositoryId">The Id of the repository</param> /// <param name="commit">The commit to create</param> public IObservable<Commit> Create(long repositoryId, NewCommit commit) { Ensure.ArgumentNotNull(commit, "commit"); return _client.Create(repositoryId, commit).ToObservable(); }
private async Task<Commit> CommitToRepository(RepositorySummary repositorySummary) { var owner = repositorySummary.Owner; var repository = repositorySummary.Name; var blob = new NewBlob { Content = "Hello World!", Encoding = EncodingType.Utf8 }; var blobResult = await _client.Git.Blob.Create(owner, repository, blob); var newTree = new NewTree(); newTree.Tree.Add(new NewTreeItem { Type = TreeType.Blob, Mode = FileMode.File, Path = "README.md", Sha = blobResult.Sha }); var treeResult = await _client.Git.Tree.Create(owner, repository, newTree); var newCommit = new NewCommit("test-commit", treeResult.Sha); var commit = await _fixture.Create(owner, repository, newCommit); return commit; }