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;
}
