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