/// <summary> /// Creates a GitHub release. /// </summary> /// <param name="repo">Identifies the target repo.</param> /// <param name="tagName">Specifies the tag to be referenced by the release.</param> /// <param name="releaseName">Optionally specifies the release name (defaults to <paramref name="tagName"/>).</param> /// <param name="body">Optionally specifies the markdown formatted release notes.</param> /// <param name="draft">Optionally indicates that the release won't be published immediately.</param> /// <param name="prerelease">Optionally indicates that the release is not production ready.</param> /// <param name="branch">Optionally identifies the branch to be tagged. This defaults to <b>master</b> or <b>main</b> when either of those branches are already present.</param> /// <returns>The newly created <see cref="Release"/>.</returns> /// <remarks> /// <para> /// If the <paramref name="tagName"/> doesn't already exist in the repo, this method will /// tag the latest commit on the specified <paramref name="branch"/> or else the defailt branch /// in the target repo and before creating the release. /// </para> /// </remarks> public Release Create(string repo, string tagName, string releaseName = null, string body = null, bool draft = false, bool prerelease = false, string branch = null) { Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(repo), nameof(repo)); Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(tagName), nameof(tagName)); releaseName = releaseName ?? tagName; var repoPath = GitHubRepoPath.Parse(repo); var client = GitHub.CreateGitHubClient(repo); var tags = client.Repository.GetAllTags(repoPath.Owner, repoPath.Repo).Result; var tag = tags.SingleOrDefault(tag => tag.Name == tagName); // Tag the specified or default branch when the tag doesn't already exist. // Note that we may need to if (tag == null) { if (string.IsNullOrEmpty(branch)) { // Identify the default branch. var branches = client.Repository.Branch.GetAll(repoPath.Owner, repoPath.Repo).Result; foreach (var branchDetails in branches) { if (branchDetails.Name == "master") { branch = "master"; break; } else if (branchDetails.Name == "main") { branch = "main"; break; } } var newTag = new NewTag() { Message = $"release-tag: {tagName}", Tag = tagName, Object = "", }; client.Git.Tag.Create(repoPath.Owner, repoPath.Repo, newTag); } } // Create the release. var release = new NewRelease(tagName) { Name = releaseName, Draft = draft, Prerelease = prerelease, Body = body }; return(client.Repository.Release.Create(repoPath.Owner, repoPath.Repo, release).Result); }
public void PerformsNewTagSerialization() { var tag = new NewTag { Message = "tag-message", Tag = "tag-name", Object = "tag-object", Type = TaggedType.Tree, Tagger = new SignatureResponse("tagger-name", "tagger-email", DateTimeOffset.Parse("2013-09-03T13:42:52Z")) }; var json = new SimpleJsonSerializer().Serialize(tag); const string expectedResult = "{\"tag\":\"tag-name\"," + "\"message\":\"tag-message\"," + "\"object\":\"tag-object\"," + "\"type\":\"tree\"," + "\"tagger\":{" + "\"name\":\"tagger-name\"," + "\"email\":\"tagger-email\"," + "\"date\":\"2013-09-03T13:42:52Z\"" + "}" + "}"; Assert.Equal(expectedResult, json); }
public async Task <bool> DeployProject() { await LoadProjectSettings(); var credentials = new Credentials(settings.GetString(OAuthTokenKey)); var client = new GitHubClient(new ProductHeaderValue("Kerbal Space Program for Visual Studio")) { Credentials = credentials }; var name = ""; var versionName = ""; await threadHandler.AsyncPump.RunAsync(async() => { using (var readLock = await projectLockService.ReadLockAsync()) { var msBuildProject = await readLock.GetProjectAsync(await project.GetSuggestedConfiguredProjectAsync()); name = msBuildProject.GetPropertyValue("Name"); versionName = msBuildProject.GetProperty(nameof(VersionNamePattern)).EvaluatedValue; } }); var tag = new NewTag { Message = $"Release {versionName} of {name}", Tag = versionName, Type = TaggedType.Commit, Tagger = new Committer(settings.GetString(UsernameKey), "", DateTimeOffset.UtcNow) }; return(false); }
/// <summary> /// The ButtonOk_Click method. /// </summary> /// <param name="sender">The <paramref name="sender"/> parameter.</param> /// <param name="args">The <paramref name="args"/> parameter.</param> private void ButtonOk_Click(object sender, EventArgs args) { try { var newTag = new NewTag { Name = txbxName.Text }; if (SelectedTag != null) { newTag.IsFolder = true; newTag.ParentId = SelectedTag.Id; } else { newTag.IsFolder = ckbxIsFolder.Checked; newTag.IsPublic = ckbxIsPublic.Checked; } MainForm.CurrentSystem.AddTag(newTag); } catch (Exception ex) { MainForm.Instance.WriteToLog($"Error creating tag: {ex.Message}"); throw; } }
public void PerformsNewTagSerialization() { var tag = new NewTag { Message = "tag-message", Tag = "tag-name", Object = "tag-object", Type = TaggedType.Tree, Tagger = new Signature { Name = "tagger-name", Email = "tagger-email", Date = new DateTime(2013, 09, 03, 13, 42, 52, DateTimeKind.Utc) } }; var json = new SimpleJsonSerializer().Serialize(tag); const string expectedResult = "{\"tag\":\"tag-name\"," + "\"message\":\"tag-message\"," + "\"object\":\"tag-object\"," + "\"type\":\"tree\"," + "\"tagger\":{" + "\"name\":\"tagger-name\"," + "\"email\":\"tagger-email\"," + "\"date\":\"2013-09-03T13:42:52Z\"" + "}" + "}"; Assert.Equal(expectedResult, json); }
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> /// Create a tag for a given repository /// </summary> /// <remarks> /// http://developer.github.com/v3/git/tags/#create-a-tag-object /// </remarks> /// <param name="owner">The owner of the repository</param> /// <param name="name">The name of the repository</param> /// <param name="tag">The tag to create</param> /// <returns></returns> public IObservable<GitTag> Create(string owner, string name, NewTag tag) { Ensure.ArgumentNotNullOrEmptyString(owner, "owner"); Ensure.ArgumentNotNullOrEmptyString(name, "name"); Ensure.ArgumentNotNull(tag, "tag"); return _client.Create(owner, name, tag).ToObservable(); }
/// <summary> /// Create a tag for a given repository /// </summary> /// <remarks> /// http://developer.github.com/v3/git/tags/#create-a-tag-object /// </remarks> /// <param name="owner">The owner of the repository</param> /// <param name="name">The name of the repository</param> /// <param name="tag">The tag to create</param> public IObservable <GitTag> Create(string owner, string name, NewTag tag) { Ensure.ArgumentNotNullOrEmptyString(owner, nameof(owner)); Ensure.ArgumentNotNullOrEmptyString(name, nameof(name)); Ensure.ArgumentNotNull(tag, nameof(tag)); return(_client.Create(owner, name, tag).ToObservable()); }
public async Task CreatesTagForRepositoryWithRepositoryId() { var newTag = new NewTag { Message = "Hello", Type = TaggedType.Tree, Object = sha, Tag = "tag" }; var tag = await fixture.Create(context.Repository.Id, newTag); Assert.Equal(tag.Object.Type, TaggedType.Blob); Assert.Equal(tag.Message, "Hello"); Assert.Equal(tag.Object.Sha, sha); }
public void PostsToTheCorrectUrlWithRepositoryId() { var gitHubClient = Substitute.For<IGitHubClient>(); var client = new ObservableTagsClient(gitHubClient); var newTag = new NewTag { Type = TaggedType.Tree }; client.Create(1, newTag); gitHubClient.Received().Git.Tag.Create(1, newTag); }
public async Task CreatesTagForRepositoryWithRepositoryId() { var newTag = new NewTag { Message = "Hello", Type = TaggedType.Tree, Object = sha, Tag = "tag" }; var tag = await fixture.Create(context.Repository.Id, newTag); Assert.Equal(TaggedType.Blob, tag.Object.Type); Assert.Equal("Hello", tag.Message); Assert.Equal(tag.Object.Sha, sha); }
public async Task CreatesTagForRepository() { var newTag = new NewTag { Message = "Hello", Type = TaggedType.Blob, Object = sha, Tag = "tag" }; var tag = await fixture.Create(context.RepositoryOwner, context.RepositoryName, newTag); var gitTag = await fixture.Get(context.RepositoryOwner, context.RepositoryName, tag.Sha); Assert.NotNull(gitTag); Assert.Equal(gitTag.Object.Type, TaggedType.Blob); Assert.Equal(gitTag.Message, "Hello"); Assert.Equal(gitTag.Object.Sha, sha); }
private void btnTag_Click(object sender, EventArgs e) { NewTag nt = new NewTag(); nt.ShowDialog(); if (nt.DialogResult == DialogResult.OK) { tags.Add(nt.GetTag()); lblTag.Text = tags.Count.ToString(); } }
public void PostsToTheCorrectUrlWithRepositoryId() { var gitHubClient = Substitute.For <IGitHubClient>(); var client = new ObservableTagsClient(gitHubClient); var newTag = new NewTag { Type = TaggedType.Tree }; client.Create(1, newTag); gitHubClient.Received().Git.Tag.Create(1, newTag); }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { NewTag tag = new NewTag(); tag.Left = Convert.ToDecimal(controllerContext.HttpContext.Request["left"]); tag.Top = Convert.ToDecimal(controllerContext.HttpContext.Request["top"]); tag.Height = Convert.ToDecimal(controllerContext.HttpContext.Request["height"]); tag.Width = Convert.ToDecimal(controllerContext.HttpContext.Request["width"]); tag.MomentoId = Convert.ToInt32(controllerContext.HttpContext.Request.QueryString["image_id"]); tag.Name = controllerContext.HttpContext.Request["name"]; return(tag); }
private async Task <GitTag> CreateTag(GitHubClient client) { var tag = $"v{GitVersion.AssemblySemVer}"; var sha = GitVersion.Sha; var newTag = new NewTag { Tag = tag, Tagger = new Committer("Loris Bognanni", "*****@*****.**", DateTimeOffset.Now) }; Logger.Normal($"Creating tag {tag} for commit {sha}"); return(await client.Git.Tag.Create(GIT_OWNER, GIT_REPO, newTag)); }
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); } }
/// <summary> /// The ButtonOk_Click method. /// </summary> /// <param name="sender">The <paramref name="sender"/> parameter.</param> /// <param name="args">The <paramref name="args"/> parameter.</param> private void ButtonOk_Click(object sender, EventArgs args) { try { var newTag = new NewTag { IsPublic = ckbxIsPublic.Checked, Name = txbxName.Text }; MainForm.CurrentSystem.CreateTag(newTag); } catch (Exception ex) { MainForm.Instance.WriteToLog(string.Format("Error creating tag: {0}", ex.Message)); throw; } }
public async Task CreatesTagForRepository() { var newTag = new NewTag { Message = "Hello", Type = TaggedType.Blob, Object = sha, Tag = "tag" }; var tag = await fixture.Create(context.RepositoryOwner, context.RepositoryName, newTag); var gitTag = await fixture.Get(context.RepositoryOwner, context.RepositoryName, tag.Sha); Assert.NotNull(gitTag); Assert.Equal(TaggedType.Blob, gitTag.Object.Type); Assert.Equal("Hello", gitTag.Message); Assert.Equal(gitTag.Object.Sha, sha); }
public async Task CreatesTagForRepositoryWithRepositoryId() { var github = Helper.GetAuthenticatedClient(); var newTag = new NewTag { Message = "Hello", Type = TaggedType.Blob, Object = sha, Tag = "tag" }; var tag = await github.Git.Tag.Create(context.Repository.Id, newTag); var gitTag = await github.Git.Tag.Get(context.Repository.Id, tag.Sha); Assert.NotNull(gitTag); Assert.Equal(TaggedType.Blob, gitTag.Object.Type); Assert.Equal("Hello", gitTag.Message); Assert.Equal(gitTag.Object.Sha, sha); }
public async Task DeserializeTagSignatureVerification() { var github = Helper.GetAuthenticatedClient(); var newTag = new NewTag { Message = "Hello", Type = TaggedType.Blob, Object = sha, Tag = "tag" }; var tag = await github.Git.Tag.Create(context.Repository.Id, newTag); var gitTag = await github.Git.Tag.Get(context.Repository.Id, tag.Sha); Assert.NotNull(gitTag); Assert.False(gitTag.Verification.Verified); Assert.Equal(VerificationReason.Unsigned, gitTag.Verification.Reason); Assert.Null(gitTag.Verification.Signature); Assert.Null(gitTag.Verification.Payload); }
/// <summary> /// Create a tag for a given repository /// </summary> /// <remarks> /// http://developer.github.com/v3/git/tags/#create-a-tag-object /// </remarks> /// <param name="repositoryId">The Id of the repository</param> /// <param name="tag">The tag to create</param> public IObservable<GitTag> Create(int repositoryId, NewTag tag) { Ensure.ArgumentNotNull(tag, "tag"); return _client.Create(repositoryId, tag).ToObservable(); }
public TagsViewModel(IDataClient client, IDialogCoordinator dialogCoordinator) { _client = client; _dialogCoordinator = dialogCoordinator; Tags = new ObservableCollection <TagViewModel>(); //Load all tags from db LoadTags = ReactiveCommand.CreateFromTask(async _ => await _client.GetTags().ConfigureAwait(true)); LoadTags.Subscribe(async result => { if (!result.WasSuccessful) { await _dialogCoordinator.ShowMessageAsync(this, "Error", string.Join("\n", result.Errors)).ConfigureAwait(true); return; } foreach (var tag in result.Result) { Tags.Add(new TagViewModel(tag)); } }); //Add new tag var addCanExecute = NewTag .WhenAnyValue(x => x.Name) .Select(newName => !string.IsNullOrEmpty(newName)); Add = ReactiveCommand.CreateFromTask(async _ => { var tag = await client.AddTag(NewTag.Model).ConfigureAwait(true); NewTag.Name = ""; return(tag); }, addCanExecute); Add.Subscribe(async result => { if (!result.WasSuccessful) { await _dialogCoordinator.ShowMessageAsync(this, "Error", string.Join("\n", result.Errors)).ConfigureAwait(true); return; } Tags.Add(new TagViewModel(result.Result)); }); //When changing the selected tag, reset the delete confirmation this.WhenAnyValue(x => x.SelectedTag) .Buffer(1, 1) .Subscribe(x => { var tagVm = x.FirstOrDefault(); if (tagVm != null) { tagVm.ConfirmDelete = false; } }); //Delete Tag Delete = ReactiveCommand.CreateFromTask(async _ => { if (SelectedTag.ConfirmDelete != true) { SelectedTag.ConfirmDelete = true; return(null); } return(await client.DeleteTag(SelectedTag?.Model).ConfigureAwait(true)); }, this.WhenAnyValue(x => x.SelectedTag).Select(x => x != null)); Delete.Subscribe(async result => { if (result == null) { return; } if (await result.DisplayErrors(this, _dialogCoordinator)) { return; } Tags.Remove(Tags.FirstOrDefault(x => x.Model.ID == result.Result.ID)); }); //Update Tag var saveCanExecute = this .WhenAnyValue(x => x.SelectedTag, x => x.SelectedTagHasErrors, (tag, hasError) => new { tag, hasError }) .Select(x => x.tag != null && x.hasError == false); Save = ReactiveCommand.CreateFromTask( async _ => await client.UpdateTag(SelectedTag?.Model).ConfigureAwait(true), saveCanExecute); Save.Subscribe(async result => await result.DisplayErrors(this, _dialogCoordinator)); }
private void Button_Click(object sender, RoutedEventArgs e) { AvailableTagsScroll.ScrollToBottom(); NewTag.Clear(); }
/// <summary> /// Create a tag for a given repository /// </summary> /// <remarks> /// http://developer.github.com/v3/git/tags/#create-a-tag-object /// </remarks> /// <param name="repositoryId">The Id of the repository</param> /// <param name="tag">The tag to create</param> public IObservable <GitTag> Create(long repositoryId, NewTag tag) { Ensure.ArgumentNotNull(tag, nameof(tag)); return(_client.Create(repositoryId, tag).ToObservable()); }
public void RaiseNewTag(string tag) { NewTag?.Invoke(this, tag); }
public async Task CreatesTagForRepositoryWithRepositoryId() { var github = Helper.GetAuthenticatedClient(); var newTag = new NewTag { Message = "Hello", Type = TaggedType.Blob, Object = sha, Tag = "tag" }; var tag = await github.Git.Tag.Create(context.Repository.Id, newTag); var gitTag = await github.Git.Tag.Get(context.Repository.Id, tag.Sha); Assert.NotNull(gitTag); Assert.Equal(gitTag.Object.Type, TaggedType.Blob); Assert.Equal(gitTag.Message, "Hello"); Assert.Equal(gitTag.Object.Sha, sha); }
public async Task DeserializeTagSignatureVerification() { var github = Helper.GetAuthenticatedClient(); var newTag = new NewTag { Message = "Hello", Type = TaggedType.Blob, Object = sha, Tag = "tag" }; var tag = await github.Git.Tag.Create(context.Repository.Id, newTag); var gitTag = await github.Git.Tag.Get(context.Repository.Id, tag.Sha); Assert.NotNull(gitTag); Assert.False(gitTag.Verification.Verified); Assert.Equal(gitTag.Verification.Reason, VerificationReason.Unsigned); Assert.Null(gitTag.Verification.Signature); Assert.Null(gitTag.Verification.Payload); }
public void Edit_WebPageTags(string PageIndexID, string NewTags, string OriginalTags) { string [] _newTags = NewTags.Replace(" ", "").Split(','); string [] _originalTags = OriginalTags.Replace(" ", "").Split(','); // Remove unused Tags List <PageTag> DeleteTags = new List <PageTag>(); foreach (string OriginalTag in _originalTags) { bool found = false; foreach (string NewTag in _newTags) { if (OriginalTag.Equals(NewTag, StringComparison.InvariantCultureIgnoreCase)) { found = true; break; } } if (!found) { DeleteTags.Add(Get_PageTag_ByTagName(OriginalTag)); } } foreach (PageTag DeleteTag in DeleteTags) { PageTag_Mapping myPageTag_Mapping = Get_PageTag_Mapping(PageIndexID, DeleteTag.PageTageID); Remove_PageTag_Mapping(myPageTag_Mapping.PageTag_MappingID); Delete_PageTags(DeleteTag, "07EB9C71-8751-4D42-AE97-CE4C8D213A12"); } // Add new Tags List <string> AddTags = new List <string>(); foreach (string NewTag in _newTags) { bool found = false; foreach (string OriginalTag in _originalTags) { if (NewTag.Equals(OriginalTag, StringComparison.InvariantCultureIgnoreCase)) { found = true; break; } } if (!found) { AddTags.Add(NewTag); } } foreach (string AddTag in AddTags) { string PageTagID = Add_PageTags(AddTag, "07EB9C71-8751-4D42-AE97-CE4C8D213A12"); if (PageTagID != null) { e2Data[] UpdateData = { new e2Data("PageIndexID", PageIndexID), new e2Data("PageTagID", PageTagID), new e2Data("IsFeatured", false.ToString()) }; Add_PageTag_Mapping(UpdateData); } } }