private static async Task CreateNextRelease(this IGitHubClient gitHubClient) { const string newReleaseBody = @" ### Changed ### New * Issue Title (#12345) ### Fixed ### Additional Items ### With special thanks for contributions to this release from: * Real Name - @githubhandle "; var newRelease = new NewRelease(NextReleaseName) { Draft = true, Name = NextReleaseName, Body = newReleaseBody.Trim() }; Console.WriteLine($"Creating new GitHub release '{newRelease.Name}'..."); var nextRelease = await gitHubClient.Repository.Release.Create(RepoOwner, RepoName, newRelease); Console.WriteLine($"Created new GitHub release '{nextRelease.Name}'"); }
public async Task CanEditAnAssetLabel() { var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true }; var release = await _releaseClient.Create(_repositoryOwner, _repositoryName, releaseWithNoUpdate); var stream = Helper.LoadFixture("hello-world.txt"); var newAsset = new ReleaseAssetUpload { ContentType = "text/plain", FileName = "hello-world.txt", RawData = stream }; var result = await _releaseClient.UploadAsset(release, newAsset); var asset = await _releaseClient.GetAsset(_repositoryOwner, _repositoryName, result.Id); var updateAsset = asset.ToUpdate(); updateAsset.Label = "some other thing"; var updatedAsset = await _releaseClient.EditAsset(_repositoryOwner, _repositoryName, result.Id, updateAsset); Assert.Equal("some other thing", updatedAsset.Label); }
public async Task CanDownloadAnAsset() { var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true }; var release = await _releaseClient.Create(_repositoryOwner, _repositoryName, releaseWithNoUpdate); var stream = Helper.LoadFixture("hello-world.txt"); var newAsset = new ReleaseAssetUpload { ContentType = "text/plain", FileName = "hello-world.txt", RawData = stream }; var result = await _releaseClient.UploadAsset(release, newAsset); Assert.True(result.Id > 0); var asset = await _releaseClient.GetAsset(_repositoryOwner, _repositoryName, result.Id); Assert.Equal(result.Id, asset.Id); var response = await _github.Connection.Get <object>(new Uri(asset.Url), new Dictionary <string, string>(), "application/octet-stream"); Assert.Equal("This is a plain text file.", response.Body); }
private NewRelease CreateNewRelease() { var name = Release.ItemSpec; var tag = Release.GetMetadata("TagName"); var newRelease = new NewRelease(tag) { Name = name }; var targetCommitSha = Release.GetMetadata("CommitSha"); if (!string.IsNullOrEmpty(targetCommitSha)) { newRelease.TargetCommitish = targetCommitSha; } var prerelease = Release.GetMetadata("Prerelease"); if (!string.IsNullOrEmpty(prerelease)) { newRelease.Prerelease = bool.Parse(prerelease); } var draft = Release.GetMetadata("Draft"); if (!string.IsNullOrEmpty(draft)) { newRelease.Draft = bool.Parse(draft); } return(newRelease); }
public async Task CanUploadAndRetrieveAnAsset() { var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true }; var release = await _releaseClient.Create(_context.RepositoryOwner, _context.RepositoryName, releaseWithNoUpdate); var stream = Helper.LoadFixture("hello-world.txt"); var newAsset = new ReleaseAssetUpload("hello-world.txt", "text/plain", stream, null); var result = await _releaseClient.UploadAsset(release, newAsset); Assert.True(result.Id > 0); var assets = await _releaseClient.GetAllAssets(_context.RepositoryOwner, _context.RepositoryName, release.Id); Assert.Equal(1, assets.Count); var asset = assets[0]; Assert.Equal(result.Id, asset.Id); Assert.NotNull(asset.Url); Assert.NotNull(asset.BrowserDownloadUrl); }
public async Task CreateRelease(string changelog) { try { await _client.Repository.Release.Get(_settings.RepositoryOwner, _settings.RepositoryName, _tag); Logger.WriteLine($"WARNING: Release already existing."); } catch (NotFoundException) { var newRelease = new NewRelease($"v{_stringVersion}{_beta}") { Name = $"v{_stringVersion}{_beta}", Body = changelog, Prerelease = false, TargetCommitish = string.IsNullOrEmpty(_beta) ? "master" : "beta" }; await Task.Run(() => _client.Repository.Release.Create(_settings.RepositoryOwner, _settings.RepositoryName, newRelease)); ExecuteWebhook(changelog); try { UpdateFirestoreVersion(); } catch (Exception e) { Logger.WriteLine($"Errors while updating Firestore version: {e}"); } Logger.WriteLine($"Release created"); } }
public static async Task <Release> CreateRelease(ModUpdateInfo info, Repository repo, string version, string name, string body) { //Get list of commits var latestCommits = Task.Run(async() => await info.Client.Repository.Commit.GetAll(repo.Owner.Login, repo.Name)); latestCommits.Wait(); var latestCommit = latestCommits.Result.First().Sha; //Check if release exists for the version # var curVersion = version; for (int newVersionAdditive = 0; newVersionAdditive < 999; newVersionAdditive++) { Console.WriteLine("Checking if release tag for version number already exists..."); var versCheck = Task.Run(async() => await info.Client.Repository.Release.GetAll(repo.Id)); versCheck.Wait(); if (versCheck.Result.Any(x => x.TagName == curVersion)) { curVersion = curVersion + newVersionAdditive; Console.WriteLine("Release tag exists. Setting new version to " + curVersion); } else { Console.WriteLine("Final release tag set as " + curVersion); break; } } //Set a tag for our release var tag = new NewTag { Message = name + " - " + body, Tag = curVersion, Object = latestCommit, // short SHA Type = TaggedType.Commit, // TODO: what are the defaults when nothing specified? Tagger = new Committer(info.GitHubAuthor, info.GitHubEmail, DateTimeOffset.UtcNow) }; var newTagProc = Task.Run(async() => await info.Client.Git.Tag.Create(repo.Owner.Login, repo.Name, tag)); newTagProc.Wait(); var newTag = newTagProc.Result; Console.WriteLine("Created a tag for {0} at {1}", newTag.Tag, newTag.Sha); var newRelease = new NewRelease(newTag.Tag) { Name = repo.Name + " " + name, Body = body, Draft = false, Prerelease = false }; var result = await info.Client.Repository.Release.Create(repo.Owner.Login, repo.Name, newRelease); return(result); }
/// <summary> /// Creates a new <see cref="Release"/> for the specified repository. /// </summary> /// <remarks> /// See the <a href="http://developer.github.com/v3/repos/releases/#create-a-release">API documentation</a> for more information. /// </remarks> /// <param name="owner">The repository's owner</param> /// <param name="name">The repository's name</param> /// <param name="data">A description of the release to create</param> /// <exception cref="ApiException">Thrown when a general API error occurs.</exception> public IObservable <Release> Create(string owner, string name, NewRelease data) { Ensure.ArgumentNotNullOrEmptyString(owner, "owner"); Ensure.ArgumentNotNullOrEmptyString(name, "name"); Ensure.ArgumentNotNull(data, "data"); return(_client.Create(owner, name, data).ToObservable()); }
public async Task SendsCreateToCorrectUrlWithRepositoryId() { var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true }; var release = await _releaseClient.Create(_context.Repository.Id, releaseWithNoUpdate); Assert.NotNull(release); }
/// <summary> /// Creates a new <see cref="Release"/> for the specified repository. /// </summary> /// <remarks> /// See the <a href="http://developer.github.com/v3/repos/releases/#create-a-release">API documentation</a> for more information. /// </remarks> /// <param name="owner">The repository's owner</param> /// <param name="name">The repository's name</param> /// <param name="data">A description of the release to create</param> /// <exception cref="ApiException">Thrown when a general API error occurs.</exception> /// <returns>The created <see cref="Release"/>.</returns> public IObservable<Release> Create(string owner, string name, NewRelease data) { Ensure.ArgumentNotNullOrEmptyString(owner, "owner"); Ensure.ArgumentNotNullOrEmptyString(name, "name"); Ensure.ArgumentNotNull(data, "data"); return _client.Create(owner, name, data).ToObservable(); }
internal static async Task CreateRelease() { try { string version = BuildConfig.GetAppVersionString(); var newRelease = new NewRelease(version); newRelease.Name = $"New Update {version}"; newRelease.Body = $"Update for version {version}"; newRelease.Draft = false; newRelease.Prerelease = false; var gitHub = new GitHubClient(new ProductHeaderValue(BuildConfig.GetGitAppName())); gitHub.Credentials = new Credentials(BuildConfig.GetGitToken()); bool success = false; int maxTries = 2; int current = 0; Release release = null; while (!success && current++ < maxTries) { release = await gitHub.Repository.Release.Create("clauderoy790", BuildConfig.GetGitAppName(), newRelease); success = release != null && !string.IsNullOrEmpty(release.UploadUrl); } if (!success) { throw new Exception($"Failed to create new releaes, tried {current} times."); } var files = Directory.GetFiles(BuildConfig.GetGitRepoLocalPath()); foreach (var file in files) { if (!BuildConfig.ShouldIncludeFileInReleaseAsset(file)) { continue; } using (var fs = File.OpenRead(file)) { FileInfo info = new FileInfo(file); var assetUpload = new ReleaseAssetUpload() { FileName = info.Name, ContentType = MimeMapping.GetMimeMapping(info.Name), RawData = fs }; var asset = await gitHub.Repository.Release.UploadAsset(release, assetUpload); Console.WriteLine($"Uploaded asset {info.Name} to release {version} successfully"); }; } } catch (Exception ex) { Console.WriteLine($"Failed to create release: {ex.Message}"); } Console.WriteLine("Release creation done"); }
public async Task <ReleaseInfo> MakeRelease(IGraph dataGraph, string releaseTag, string owner, string repositoryId, string datasetId, string repositoryDirectory, string authenticationToken) { var releaseInfo = new ReleaseInfo(releaseTag); var ntriplesDumpFileName = Path.Combine(repositoryDirectory, releaseTag + ".nt.gz"); ProgressLog.Info("Generating gzipped NTriples data dump"); var writer = new GZippedNTriplesWriter(); writer.Save(dataGraph, ntriplesDumpFileName); // Make a release try { ProgressLog.Info("Generating a new release of dataset {0}", datasetId); if (authenticationToken == null) { throw new WorkerException("No valid GitHub access token found for your account."); } var client = _gitHubClientFactory.CreateClient(authenticationToken); client.SetRequestTimeout(TimeSpan.FromSeconds(300)); var releaseClient = client.Repository.Release; var newRelease = new NewRelease(releaseTag) { TargetCommitish = "gh-pages" }; var release = await releaseClient.Create(owner, repositoryId, newRelease); // Attach data dump file(s) to release try { ProgressLog.Info("Uploading data dump files to GitHub release"); using (var zipFileStream = File.OpenRead(ntriplesDumpFileName)) { var upload = new ReleaseAssetUpload(Path.GetFileName(ntriplesDumpFileName), "application/gzip", zipFileStream, null); var releaseAsset = await releaseClient.UploadAsset(release, upload); releaseInfo.DownloadLinks.Add(releaseAsset.BrowserDownloadUrl); } } catch (Exception ex) { Log.Error(ex, "Failed to attach dump files to GitHub release"); throw new WorkerException(ex, "Failed to attach dump files to GitHub release"); } } catch (WorkerException) { throw; } catch (Exception ex) { Log.Error(ex, "Failed to create a new GitHub release"); throw new WorkerException(ex, "Failed to create a new GitHub release"); } return(releaseInfo); }
/// <summary> /// Creates a new draft release where we can deploy artifacts to /// Caller is responsible for finalizing the release and marking it as /// a release or pre-release once that setup is complete /// </summary> /// <returns>Reference to the newly created release</returns> public Release CreateRelease() { var data = new NewRelease("Draft") { Draft = true }; return(new Release(_client, _obj, _client.Repository.Release.Create(_obj.Id, data).Result)); }
public static async Task PublishRelease(Configure <GitHubReleaseSettings> configure) { var settings = configure.Invoke(new GitHubReleaseSettings()); settings.Validate(); var releaseTag = settings.Tag; var client = GetAuthenticatedClient(settings.Token, settings.Url); var existingReleases = await client.Repository.Release.GetAll(settings.RepositoryOwner, settings.RepositoryName); if (existingReleases.Any(r => r.TagName == releaseTag)) { // Release already present return; } var newRelease = new NewRelease(releaseTag) { TargetCommitish = settings.CommitSha, Name = settings.Name ?? releaseTag, Body = settings.ReleaseNotes, Draft = true, Prerelease = settings.Prerelease ?? false }; Logger.Info("Creating release draft..."); var releaseCreationResult = await client.Repository.Release.Create(settings.RepositoryOwner, settings.RepositoryName, newRelease); var createdRelease = await client.Repository.Release.Get(settings.RepositoryOwner, settings.RepositoryName, releaseCreationResult.Id); if (settings.ArtifactPaths != null) { foreach (var artifactPath in settings.ArtifactPaths) { using (var artifactStream = File.OpenRead(artifactPath)) { var fileName = Path.GetFileName(artifactPath); var assetUpload = new ReleaseAssetUpload { FileName = fileName, ContentType = "application/octet-stream", RawData = artifactStream, }; Logger.Info($"Uploading artifact {artifactPath}..."); await client.Repository.Release.UploadAsset(createdRelease, assetUpload); } } } var updatedRelease = createdRelease.ToUpdate(); updatedRelease.Draft = false; await client.Repository.Release.Edit(settings.RepositoryOwner, settings.RepositoryName, createdRelease.Id, updatedRelease); Logger.Info($"Release {settings.Name ?? releaseTag} was successfully created"); }
protected override void ProcessRecord() { try { var gitUri = GitHubClient.GitHubApiUrl; if (GitSourceOption == "external") { gitUri = new Uri(GitSourceUrl); } var client = new GitHubClient(new ProductHeaderValue(ApplicationName), gitUri); var tokenAuth = new Credentials(Token); client.Credentials = tokenAuth; var newRelease = new NewRelease(TagName) { Name = ReleaseName, Body = ReleaseBody, Draft = Draft, Prerelease = PreRelease, }; var release = client.Repository.Release.Create(Owner, Repo, newRelease).Result; WriteVerbose("Created release with id: " + release.Id + " at " + release.Url); if (Assets != null && Assets.Any()) { WriteVerbose("Uploading " + Assets.Count() + " assets"); foreach (var asset in Assets) { WriteVerbose("Uploading " + asset); using (var archiveContents = File.OpenRead(asset)) { var fileName = Path.GetFileName(asset); var assetUpload = new ReleaseAssetUpload() { FileName = fileName, ContentType = "application/zip", RawData = archiveContents }; var uploadedAsset = client.Repository.Release.UploadAsset(release, assetUpload).Result; WriteVerbose("Uploaded " + uploadedAsset.Name); } } } else { WriteVerbose("No assets specified"); } } catch (Exception e) { WriteVerbose("Error when publishing release: " + e); throw; } }
public void CallsIntoClient() { var gitHubClient = Substitute.For<IGitHubClient>(); var releasesClient = new ObservableReleasesClient(gitHubClient); var data = new NewRelease("fake-tag"); releasesClient.Create("fake", "repo", data); gitHubClient.Release.Received(1).Create("fake", "repo", data); }
public void EnsuresArgumentsNotNull() { var releasesClient = new ObservableReleasesClient(Substitute.For <IGitHubClient>()); var data = new NewRelease("fake-tag"); Assert.Throws <ArgumentNullException>(() => new NewRelease(null)); Assert.Throws <ArgumentNullException>(() => releasesClient.Create(null, "name", data)); Assert.Throws <ArgumentNullException>(() => releasesClient.Create("owner", null, data)); Assert.Throws <ArgumentNullException>(() => releasesClient.Create("owner", "name", null)); }
public void CallsIntoClient() { var gitHubClient = Substitute.For <IGitHubClient>(); var releasesClient = new ObservableReleasesClient(gitHubClient); var data = new NewRelease("fake-tag"); releasesClient.Create("fake", "repo", data); gitHubClient.Repository.Release.Received(1).Create("fake", "repo", data); }
public void RequestsTheCorrectUrlWithRepositoryId() { var gitHubClient = Substitute.For <IGitHubClient>(); var releasesClient = new ObservableReleasesClient(gitHubClient); var data = new NewRelease("fake-tag"); releasesClient.Create(1, data); gitHubClient.Repository.Release.Received(1).Create(1, data); }
public async Task EnsuresArgumentsNotNull() { var releasesClient = new ReleasesClient(Substitute.For<IApiConnection>()); var data = new NewRelease("fake-tag"); Assert.Throws<ArgumentNullException>(() => new NewRelease(null)); await Assert.ThrowsAsync<ArgumentNullException>(() => releasesClient.Create(null, "name", data)); await Assert.ThrowsAsync<ArgumentNullException>(() => releasesClient.Create("owner", null, data)); await Assert.ThrowsAsync<ArgumentNullException>(() => releasesClient.Create("owner", "name", null)); }
/// <summary> /// The AsyncRelease Method is an asyncronous method. /// It creates a plain GitHubClient that includes a User-Agent header. /// Authenticated access to the repo is used via personal access token. /// The repo is tagged and released with the new of the repo, a name for the release, and /// a markdown can be included. newRelease.Draft and newRelease.Prerelease are booleans and /// the defaults for both is false. /// </summary> public static async void AsyncReleaseMethod() { //A plain GitHubClient is created. You can use the default string for ProduceHeaderValue or enter your own. var client = new GitHubClient(new ProductHeaderValue("DevexGitRelease")); //Enter a personal access token for the repo you want to release. var tokenAuth = new Credentials(""); client.Credentials = tokenAuth; //Enter ("GitHub Account Name", "Repo Name", and "Tag Name or Version Number (v1.0.0)" for the release) string gitHubAccountName = "Jennyf19"; string repoName = "Calculator"; string tagName = "v1.2.0"; Repository result = await client.Repository.Get(gitHubAccountName, repoName); Console.WriteLine("The Repo Id is: " + result.Id); Console.WriteLine("The GitURL for the repo is: " + result.GitUrl); #region Create Tag //Enter the name of the repo to be released var newRelease = new NewRelease(tagName); //Enter the name of the release newRelease.Name = "Big Cat Adventure"; //Include any information you would like to share with the user in the markdown newRelease.Body = "This is the markdown"; //The Draft plag is used to indicate when a release should be published newRelease.Draft = false; //Indicates whether a release is unofficial or preview release newRelease.Prerelease = false; #endregion #region The Release ///To create a new release, you must have a corresponding tag for the repo var newReleaseResult = await client.Repository.Release.Create(result.Id, newRelease); Console.WriteLine("Created release tag: {0}", tagName); var tagsResult = await client.Repository.GetAllTags(result.Id); var tag = tagsResult.FirstOrDefault(); NewRelease data = newRelease; Console.WriteLine("Release of " + repoName + " complete"); Console.ReadLine(); }
public async Task Create(string name, string description, string assetDir) { int createdReleaseId = -1; var client = new GitHubClient(new ProductHeaderValue("kinv-release-app")); try { var tokenAuth = new Credentials(ghToken); // NOTE: not real token client.Credentials = tokenAuth; var newRelease = new NewRelease(name); newRelease.Name = "v" + name; newRelease.Body = description; newRelease.Draft = false; newRelease.Prerelease = false; var result = await client.Repository.Release.Create(ghUser, ghRepo, newRelease); Console.WriteLine("Created release id {0}", result.Id); createdReleaseId = result.Id; var release = await client.Repository.Release.Get(ghUser, ghRepo, result.Id); var files = Directory.GetFiles(assetDir); foreach (var file in files) { using (var contents = File.OpenRead(file)) { var assetUpload = new ReleaseAssetUpload() { FileName = Path.GetFileName(file), ContentType = file.EndsWith(".exe") ? "application/binary" : "application/zip", RawData = contents }; var asset = await client.Repository.Release.UploadAsset(release, assetUpload); } } } catch (Exception exc) { // if created and failed, delete it Console.Error.Write("Failed to create release: " + exc.Message); if (createdReleaseId != -1) { try { await client.Repository.Release.Delete(ghUser, ghRepo, createdReleaseId); } catch (Exception exc2) { Console.Error.Write("Failed to delete release: " + exc2.Message); } } } }
public Release CreateRelease(GitHubClient client, string releaseName, string body, bool draft = false, bool prerelease = false) { var newRelease = new NewRelease(releaseName); newRelease.Body = body; newRelease.Name = releaseName; newRelease.Draft = draft; newRelease.Prerelease = prerelease; return(client.Repository.Release.Create(userName, repositoryName, newRelease).Result); }
public async Task ReturnsReleasesWithNullPublishDate() { // create a release without a publish date var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true }; await _releaseClient.Create(_context.RepositoryOwner, _context.RepositoryName, releaseWithNoUpdate); var releases = await _releaseClient.GetAll(_context.RepositoryOwner, _context.RepositoryName); Assert.True(releases.Count == 1); Assert.False(releases.First().PublishedAt.HasValue); }
public void RequestsCorrectUrl() { var client = Substitute.For<IApiConnection>(); var releasesClient = new ReleasesClient(client); var data = new NewRelease("fake-tag"); releasesClient.Create("fake", "repo", data); client.Received().Post<Release>(Arg.Is<Uri>(u => u.ToString() == "repos/fake/repo/releases"), data, "application/vnd.github.v3"); }
public static ReleaseVersion Update(Repository repo, string outputPath) { NewRelease = GetNextReleaseNumber(repo); var nextReleaseTag = String.Format(ReleaseTagFormat, NewRelease.ToString()); repo.TagCurrent(nextReleaseTag); CreateMetaXml(outputPath); return(new ReleaseVersion(NewRelease)); }
public async Task RequestsCorrectUrl() { var client = Substitute.For <IApiConnection>(); var releasesClient = new ReleasesClient(client); var data = new NewRelease("fake-tag"); await releasesClient.Create("fake", "repo", data); client.Received().Post <Release>(Arg.Is <Uri>(u => u.ToString() == "repos/fake/repo/releases"), data, "application/vnd.github.v3"); }
public async Task EnsuresArgumentsNotNull() { var releasesClient = new ReleasesClient(Substitute.For <IApiConnection>()); var data = new NewRelease("fake-tag"); Assert.Throws <ArgumentNullException>(() => new NewRelease(null)); await Assert.ThrowsAsync <ArgumentNullException>(() => releasesClient.Create(null, "name", data)); await Assert.ThrowsAsync <ArgumentNullException>(() => releasesClient.Create("owner", null, data)); await Assert.ThrowsAsync <ArgumentNullException>(() => releasesClient.Create("owner", "name", null)); }
private async Task <Release> CreateRelease(GitHubClient client, string version) { var newRelease = new NewRelease(version) { Name = $"Version {version}", Body = "Please see [the official page](https://www.codemade.co.uk/clock) for release notes.", Draft = true, Prerelease = false }; Logger.Normal($"Creating release {version}"); return(await client.Repository.Release.Create(GIT_OWNER, GIT_REPO, newRelease)); }
public async Task ReturnsReleasesWithNullPublishDateWithRepositoryDate() { // create a release without a publish date var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true }; await _releaseClient.Create(_context.RepositoryOwner, _context.RepositoryName, releaseWithNoUpdate); var releases = await _releaseClient.GetAll(_context.Repository.Id); Assert.True(releases.Count == 1); Assert.False(releases.First().PublishedAt.HasValue); }
private static async Task ReleaseAsync() { var sha = Environment.GetEnvironmentVariable("sha"); var token = Environment.GetEnvironmentVariable("token"); var identity = Environment.GetEnvironmentVariable("repo")?.Split("/"); if (!string.IsNullOrEmpty(token)) { var owner = identity?[0]; var repoName = identity?[1]; var client = new GitHubClient(new ProductHeaderValue(owner)) { Credentials = new Credentials(token) }; var comment = string.Join("\n", (await client.Repository.Comment.GetAllForCommit(owner, repoName, sha)).Select(c => c.Body)); var tagName = $"汉化资源包-Snapshot-{DateTime.UtcNow:yyyyMMddhhmmss}"; var tag = new NewTag { Object = sha, Message = comment, Tag = tagName, Type = TaggedType.Commit, Tagger = new Committer("CFPABot", "*****@*****.**", DateTimeOffset.UtcNow) }; var tagResult = await client.Git.Tag.Create(owner, repoName, tag); Console.WriteLine($"Created a tag for {tagResult.Tag} at {tagResult.Sha}"); var newRelease = new NewRelease(tagName) { Name = tagName, Body = tag.Message, Draft = false, Prerelease = false }; var releaseResult = await client.Repository.Release.Create(owner, repoName, newRelease); Console.WriteLine($"Created release id {releaseResult.Id}"); await using var rawData = File.OpenRead(@"./Minecraft-Mod-Language-Modpack.zip"); var assetUpload = new ReleaseAssetUpload { FileName = "Minecraft-Mod-Language-Modpack.zip", ContentType = "application/zip", RawData = rawData }; var release = await client.Repository.Release.Get(owner, repoName, releaseResult.Id); await client.Repository.Release.UploadAsset(release, assetUpload); } }
public async Task CanChangeBodyOfRelease() { var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true }; var release = await _releaseClient.Create(_repositoryOwner, _repositoryName, releaseWithNoUpdate); var editRelease = release.ToUpdate(); editRelease.Body = "**This is an updated release"; editRelease.Draft = false; var updatedRelease = await _releaseClient.Edit(_repositoryOwner, _repositoryName, release.Id, editRelease); Assert.Equal(release.Id, updatedRelease.Id); Assert.False(updatedRelease.Draft); Assert.Equal("**This is an updated release", updatedRelease.Body); }
private static async Task <Release> CreateRelease(string owner, string repoName, string tagName, string releaseName, string description, bool isPrerelease, bool publish) { var newRelease = new NewRelease(tagName) { Name = releaseName, Body = description, Prerelease = isPrerelease, Draft = !publish }; var release = await client.Repository.Release.Create(owner, repoName, newRelease); Console.WriteLine($"Created {(publish ? "public" : "draft")} release {releaseName}: {release.HtmlUrl}"); return(release); }
public static async Task PublishRelease(GitHubReleaseSettings settings) { var releaseTag = settings.Tag; var client = GetAuthenticatedClient(settings.Token); var existingReleases = await client.Repository.Release.GetAll(settings.RepositoryOwner, settings.RepositoryName); if (existingReleases.Any(r => r.TagName == releaseTag)) { // Release already present return; } var newRelease = new NewRelease(releaseTag) { TargetCommitish = settings.CommitSha, Name = releaseTag, Body = settings.ReleaseNotes, Draft = true, Prerelease = settings.Prerelease ?? false }; var releaseCreationResult = await client.Repository.Release.Create(settings.RepositoryOwner, settings.RepositoryName, newRelease); var createdRelease = await client.Repository.Release.Get(settings.RepositoryOwner, settings.RepositoryName, releaseCreationResult.Id); if (settings.ArtifactPaths != null) { foreach (var artifactPath in settings.ArtifactPaths) { using (var artifactStream = File.OpenRead(artifactPath)) { var fileName = Path.GetFileName(artifactPath); var assetUpload = new ReleaseAssetUpload { FileName = fileName, ContentType = "application/octet-stream", RawData = artifactStream, }; await client.Repository.Release.UploadAsset(createdRelease, assetUpload); } } } var updatedRelease = createdRelease.ToUpdate(); updatedRelease.Draft = false; await client.Repository.Release.Edit(settings.RepositoryOwner, settings.RepositoryName, createdRelease.Id, updatedRelease); }
static async Task Release(string username, string token, string repo, string projectName, string buildNumber, bool promote, string target, string buildDir) { GitHubClient client = new GitHubClient(new ProductHeaderValue("GitHubReleaser")); var basicAuth = new Credentials(token); client.Credentials = basicAuth; var releases = client.Repository.Release.GetAll(username, repo); try { var latestRelease = await client.Repository.Release.GetLatest(username, repo); if (string.IsNullOrWhiteSpace(buildNumber)) { buildNumber = (int.Parse(latestRelease.TagName.Split('-')[1]) + 1).ToString(); } } catch (Exception) { buildNumber = "1"; } Zip(projectName, buildNumber, target, buildDir); var newRelease = new NewRelease("Build-" + buildNumber); newRelease.Name = "Build " + buildNumber + " @ " + DateTime.UtcNow.ToString("MM/dd/yyyy HH:mm:ss UTC"); newRelease.Body = promote ? "This was automatically uploaded by [GitHubReleaser](https://github.com/BadCodr/GitHubReleaser) @BadCodr" : ""; newRelease.Draft = false; newRelease.Prerelease = false; var result = await client.Repository.Release.Create(username, repo, newRelease); var archiveContents = File.OpenRead(Path.GetTempPath() + projectName + buildNumber + ".zip"); // TODO: better sample var assetUpload = new ReleaseAssetUpload() { FileName = projectName + buildNumber + ".zip", ContentType = "application/zip", RawData = archiveContents }; var asset = await client.Repository.Release.UploadAsset(result, assetUpload); Clean(projectName, buildNumber); Console.WriteLine("Created release id {0}", releases.Id); }
public async Task CanDeleteWithRepositoryId() { var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true }; var release = await _releaseClient.Create(_context.Repository.Id, releaseWithNoUpdate); var createdRelease = await _releaseClient.Get(_context.Repository.Id, release.Id); Assert.NotNull(createdRelease); await _releaseClient.Delete(_context.Repository.Id, createdRelease.Id); await Assert.ThrowsAsync <NotFoundException>(async() => await _releaseClient.Get(_context.Repository.Id, createdRelease.Id)); }
public void RequestsTheCorrectUrlWithRepositoryId() { var gitHubClient = Substitute.For<IGitHubClient>(); var releasesClient = new ObservableReleasesClient(gitHubClient); var data = new NewRelease("fake-tag"); releasesClient.Create(1, data); gitHubClient.Repository.Release.Received(1).Create(1, data); }
/// <summary> /// Creates a new <see cref="Release"/> for the specified repository. /// </summary> /// <remarks> /// See the <a href="http://developer.github.com/v3/repos/releases/#create-a-release">API documentation</a> for more information. /// </remarks> /// <param name="repositoryId">The repository's ID</param> /// <param name="data">A description of the release to create</param> /// <exception cref="ApiException">Thrown when a general API error occurs.</exception> public IObservable<Release> Create(int repositoryId, NewRelease data) { Ensure.ArgumentNotNull(data, "data"); return _client.Create(repositoryId, data).ToObservable(); }
public void EnsuresArgumentsNotNull() { var releasesClient = new ObservableReleasesClient(Substitute.For<IGitHubClient>()); var data = new NewRelease("fake-tag"); Assert.Throws<ArgumentNullException>(() => new NewRelease(null)); Assert.Throws<ArgumentNullException>(() => releasesClient.Create(null, "name", data)); Assert.Throws<ArgumentNullException>(() => releasesClient.Create("owner", null, data)); Assert.Throws<ArgumentNullException>(() => releasesClient.Create("owner", "name", null)); }
public async Task CanDownloadAnAsset() { var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true }; var release = await _releaseClient.Create(_repositoryOwner, _repositoryName, releaseWithNoUpdate); var stream = Helper.LoadFixture("hello-world.txt"); var newAsset = new ReleaseAssetUpload { ContentType = "text/plain", FileName = "hello-world.txt", RawData = stream }; var result = await _releaseClient.UploadAsset(release, newAsset); Assert.True(result.Id > 0); var asset = await _releaseClient.GetAsset(_repositoryOwner, _repositoryName, result.Id); Assert.Equal(result.Id, asset.Id); var response = await _github.Connection.Get<object>(new Uri(asset.Url), new Dictionary<string, string>(), "application/octet-stream"); Assert.Equal("This is a plain text file.", response.Body); }
public async Task CanDeleteAssetWithRepositoryId() { var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true }; var release = await _releaseClient.Create(_context.Repository.Id, releaseWithNoUpdate); var stream = Helper.LoadFixture("hello-world.txt"); var newAsset = new ReleaseAssetUpload("hello-world.txt", "text/plain", stream, null); var result = await _releaseClient.UploadAsset(release, newAsset); var asset = await _releaseClient.GetAsset(_context.Repository.Id, result.Id); Assert.NotNull(asset); Assert.ThrowsAsync<NotFoundException>(async () => await _releaseClient.DeleteAsset(_context.Repository.Id, result.Id)); }
public async Task RequestsCorrectUrlWithRepositoryId() { var client = Substitute.For<IApiConnection>(); var releasesClient = new ReleasesClient(client); var data = new NewRelease("fake-tag"); await releasesClient.Create(1, data); client.Received().Post<Release>(Arg.Is<Uri>(u => u.ToString() == "repositories/1/releases"), data, "application/vnd.github.v3"); }
public async Task CanDeleteWithRepositoryId() { var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true }; var release = await _releaseClient.Create(_context.Repository.Id, releaseWithNoUpdate); var createdRelease = await _releaseClient.Get(_context.Repository.Id, release.Id); Assert.NotNull(createdRelease); await _releaseClient.Delete(_context.Repository.Id, createdRelease.Id); Assert.ThrowsAsync<NotFoundException>(async () => await _releaseClient.Get(_context.Repository.Id, createdRelease.Id)); }
public async Task CanChangeCommitIshOfRelease() { var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true }; var release = await _releaseClient.Create(_context.RepositoryOwner, _context.RepositoryName, releaseWithNoUpdate); Assert.Equal("master", release.TargetCommitish); var newHead = await _github.CreateTheWorld(_context.Repository); var editRelease = release.ToUpdate(); editRelease.Draft = false; editRelease.TargetCommitish = newHead.Object.Sha; var updatedRelease = await _releaseClient.Edit(_context.RepositoryOwner, _context.RepositoryName, release.Id, editRelease); Assert.Equal(release.Id, updatedRelease.Id); Assert.False(updatedRelease.Draft); Assert.Equal(newHead.Object.Sha, updatedRelease.TargetCommitish); }
public async Task CanEditAnAssetLabel() { var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true }; var release = await _releaseClient.Create(_context.RepositoryOwner, _context.RepositoryName, releaseWithNoUpdate); var stream = Helper.LoadFixture("hello-world.txt"); var newAsset = new ReleaseAssetUpload("hello-world.txt", "text/plain", stream, null); var result = await _releaseClient.UploadAsset(release, newAsset); var asset = await _releaseClient.GetAsset(_context.RepositoryOwner, _context.RepositoryName, result.Id); var updateAsset = asset.ToUpdate(); updateAsset.Label = "some other thing"; var updatedAsset = await _releaseClient.EditAsset(_context.RepositoryOwner, _context.RepositoryName, result.Id, updateAsset); Assert.Equal("some other thing", updatedAsset.Label); }
public async Task CanDownloadAnAsset() { var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true }; var release = await _releaseClient.Create(_context.RepositoryOwner, _context.RepositoryName, releaseWithNoUpdate); var stream = Helper.LoadFixture("hello-world.txt"); var newAsset = new ReleaseAssetUpload("hello-world.txt", "text/plain", stream, null); var result = await _releaseClient.UploadAsset(release, newAsset); Assert.True(result.Id > 0); var asset = await _releaseClient.GetAsset(_context.RepositoryOwner, _context.RepositoryName, result.Id); Assert.Equal(result.Id, asset.Id); var response = await _github.Connection.Get<object>(new Uri(asset.Url), new Dictionary<string, string>(), "application/octet-stream"); Assert.Contains("This is a plain text file.", Encoding.ASCII.GetString((byte[])response.Body)); }
public async Task CanDownloadBinaryAsset() { var releaseWithNoUpdate = new NewRelease("0.1") { Draft = true }; var release = await _releaseClient.Create(_context.RepositoryOwner, _context.RepositoryName, releaseWithNoUpdate); var stream = Helper.LoadFixture("hello-world.zip"); var newAsset = new ReleaseAssetUpload("hello-world.zip" , "application/octet-stream" , stream , null); var result = await _releaseClient.UploadAsset(release, newAsset); Assert.True(result.Id > 0); var asset = await _releaseClient.GetAsset(_context.RepositoryOwner, _context.RepositoryName, result.Id); Assert.Equal(result.Id, asset.Id); var response = await _github.Connection.Get<object>(new Uri(asset.Url), new Dictionary<string, string>(), "application/octet-stream"); var textContent = string.Empty; using (var zipstream = new MemoryStream((byte[])response.Body)) using (var archive = new ZipArchive(zipstream)) { var enttry = archive.Entries[0]; var data = new byte[enttry.Length]; await enttry.Open().ReadAsync(data, 0, data.Length); textContent = Encoding.ASCII.GetString(data); } Assert.Contains("This is a plain text file.", textContent); }