public void Populate(Octokit.Release latestRelease)
{
string currentVersion = Application.version;
bool hasNewerVersion = latestRelease != null;
downloadLatestButton.gameObject.SetActive(hasNewerVersion);
if (hasNewerVersion && latestRelease.Assets.Count > 0)
{
textInfo.text = string.Format("A new version of Moonscraper Chart Editor is available.\n\nCurrent version- v{0}\nLatest version- v{1}", currentVersion, latestRelease.TagName);
var downloadAsset = latestRelease.Assets[0];
downloadLatestButton.onClick.RemoveAllListeners();
downloadLatestButton.onClick.AddListener(() =>
{
Application.OpenURL(downloadAsset.BrowserDownloadUrl);
});
}
else
{
textInfo.text = string.Format("Moonscraper Chart Editor is up to date. The current version is v{0}", currentVersion);
}
}
public AvailableUpdate(Release releaseInfo)
{
this.Date = (releaseInfo.PublishedAt ?? releaseInfo.CreatedAt).LocalDateTime;
this.Details = releaseInfo.Body;
this.IsBeta = releaseInfo.Prerelease;
this.Name = releaseInfo.Name;
}
public UpdateWindow(Release release)
{
InitializeComponent();
_release = release;
TextReleaseTitle.Text = _release.Name;
TextReleaseNotes.Text = _release.Body;
}
private async Task <bool> ProcessRelease(Octokit.Release release, string branch, string version)
{
var isNewRelease = false;
// Get an updateEntity
var updateEntity = await _updateService.Find(version, branch).ConfigureAwait(false);
if (updateEntity != null)
{
return(isNewRelease);
}
var parsedVersion = Version.Parse(version);
// Create update object
updateEntity = new UpdateEntity
{
Version = version,
IntVersion = parsedVersion.ToIntVersion(),
ReleaseDate = release.PublishedAt.Value.UtcDateTime,
Branch = branch
};
// Set new release to true.
isNewRelease = true;
// Parse changes
var releaseBody = release.Body;
var features = ReleaseFeaturesGroup.Matches(releaseBody);
if (features.Any())
{
updateEntity.New.Clear();
foreach (Match match in features)
{
updateEntity.New.Add(match.Groups["text"].Value);
}
}
var fixes = ReleaseFixesGroup.Matches(releaseBody);
if (fixes.Any())
{
updateEntity.Fixed.Clear();
foreach (Match match in fixes)
{
updateEntity.Fixed.Add(match.Groups["text"].Value);
}
}
await _updateService.Insert(updateEntity).ConfigureAwait(false);
// Process release files.
await Task.WhenAll(release.Assets.Select(x => ProcessAsset(x, branch, updateEntity.Id)));
return(isNewRelease);
}
public async Task <Release> GetLatestGitHubRelease()
{
Release _release = new Release();
try
{
if (NetworkInterface.GetIsNetworkAvailable())
{
GitHubClient githubClient = new GitHubClient(new ProductHeaderValue("Vulnerator"));
Octokit.Release release = await githubClient.Repository.Release.GetLatest("Vulnerator", "Vulnerator");
_release.TagName = release.TagName;
_release.HtmlUrl = release.HtmlUrl;
}
else
{
_release.TagName = "Unavailable";
}
return(_release);
}
catch (Exception exception)
{
string error = "Unable to retrieve GitHub Vulnerator release listing.";
LogWriter.LogErrorWithDebug(error, exception);
_release.TagName = "Unavailable";
return(_release);
}
}
private void AppendVersionReleaseNotes(StringBuilder stringBuilder, Release release)
{
if (this.configuration.Export.IncludeCreatedDateInTitle)
{
stringBuilder.AppendLine(string.Format(CultureInfo.InvariantCulture, "## {0} ({1})", release.TagName, release.CreatedAt.ToString(this.configuration.Export.CreatedDateStringFormat, CultureInfo.InvariantCulture)));
}
else
{
stringBuilder.AppendLine(string.Format(CultureInfo.InvariantCulture, "## {0}", release.TagName));
}
stringBuilder.AppendLine(Environment.NewLine);
if (this.configuration.Export.PerformRegexRemoval)
{
var regexPattern = new Regex(this.configuration.Export.RegexText, this.configuration.Export.IsMultilineRegex ? RegexOptions.Multiline : RegexOptions.Singleline);
var replacement = string.Empty;
var replacedBody = regexPattern.Replace(release.Body, replacement);
stringBuilder.AppendLine(replacedBody);
}
else
{
stringBuilder.AppendLine(release.Body);
}
}
private string[] UploadAll(IReleasesClient client, Release release, IEnumerable<UploadFile> items)
{
return items.Select(item =>
{
//BuildHelper.DisplayAndLog(string.Format("Uploading {0}...", item));
return Upload(client, release, item);
}).ToArray();
}
public ReleaseResponse(Release release)
{
Id = release.Id;
TagName = release.TagName;
Title = release.Name;
Body = release.Body;
Url = release.HtmlUrl;
}
async Task UpdateFromReleaseAsync(Release pendingUpdateRelease)
{
var assets =
await client.Release.GetAllAssets(
RepositoryOwner,
RepositoryName,
pendingUpdateRelease.Id);
await UpdateFromAssetsAsync(assets);
}
void OnUserCheckForUpdatesComplete(Octokit.Release release)
{
// Queue up the action to open the menu in a safe spot, editor or playing. Don't want to try to open this up if the user already has a menu open
QueueInterruptTask(() =>
{
UpdatesMenu updatesMenu = uiServices.gameObject.GetComponentInChildren <UpdatesMenu>(true);
updatesMenu.Populate(release);
EnableMenu(updatesMenu.gameObject.GetComponent <DisplayMenu>());
});
}
/// <summary>
/// Uploads a <see cref="ReleaseAsset"/> for the specified release.
/// </summary>
/// <remarks>
/// See the <a href="http://developer.github.com/v3/repos/releases/#upload-a-release-asset">API documentation</a> for more information.
/// </remarks>
/// <param name="release">The <see cref="Release"/> to attach the uploaded asset to.</param>
/// <param name="data">Description of the asset with its data.</param>
/// <exception cref="ApiException">Thrown when a general API error occurs.</exception>
/// <returns>The created <see cref="ReleaseAsset"/>.</returns>
public Task<ReleaseAsset> UploadAsset(Release release, ReleaseAssetUpload data)
{
Ensure.ArgumentNotNull(release, "release");
Ensure.ArgumentNotNull(data, "data");
var endpoint = release.UploadUrl.ExpandUriTemplate(new {name = data.FileName});
return ApiConnection.Post<ReleaseAsset>(
endpoint,
data.RawData,
"application/vnd.github.manifold-preview",
data.ContentType);
}
private void GetCommitInformation(Octokit.Release release, Release rel, Repository repository, string sha)
{
var commit = repository.Client.Repository.Commit.Get(repository.Owner, repository.Name, sha).Result;
rel.NumberOfAdditions += commit.Stats.Additions;
rel.NumberOfDeletions += commit.Stats.Deletions;
rel.NumberOfFilesModified += commit.Files.Count;
if (commit.Author != null)
{
rel.Contributers.Add(commit.Author.Id);
}
}
private static LatestVersionRetrievedEventArgs GrabVersions(IEnumerable<ReleaseAsset> latest, Release release)
{
var windowsLatest = latest.Where(asset => asset.Name.Contains("windows"));
var windowsIntel386 = windowsLatest.FirstOrDefault(asset => asset.Name.Contains("386"));
var windowsAmd64 = windowsLatest.FirstOrDefault(asset => asset.Name.Contains("amd64"));
return new LatestVersionRetrievedEventArgs()
{
LatestIntel386 = windowsIntel386,
LatestAmd64 = windowsAmd64,
LatestVersion = release
};
}
public static async Task<Release> GetLastUpdate()
{
try
{
IReadOnlyList<Release> lastReleases = await Rep.Release.GetAll("imthe666st", "NTRClient");
LastRelease = lastReleases[0];
return LastRelease;
}
catch (Exception e)
{
MessageBox.Show(@"An error occured trying to look for updates!");
BugReporter br = new BugReporter(e, "Updater exception", false);
return null;
}
}
public async Task<UpdateType> CheckUpdate(UpdateType locked = UpdateType.None)
{
var releases = await _releaseClient.GetAll(RepositoryOwner, RepostoryName);
SemVersion lockedVersion;
switch (locked)
{
case UpdateType.Major:
lockedVersion = new SemVersion(CurrentVersion.Major + 1);
LatestRelease = releases.FirstOrDefault(
release => !release.Prerelease &&
Helper.StripInitialV(release.TagName) > CurrentVersion &&
Helper.StripInitialV(release.TagName) < lockedVersion
);
break;
case UpdateType.Minor:
lockedVersion = new SemVersion(CurrentVersion.Major, CurrentVersion.Minor + 1);
LatestRelease = releases.FirstOrDefault(
release => !release.Prerelease &&
Helper.StripInitialV(release.TagName) > CurrentVersion &&
Helper.StripInitialV(release.TagName) < lockedVersion
);
break;
default:
LatestRelease = releases.FirstOrDefault(
release => !release.Prerelease &&
Helper.StripInitialV(release.TagName) > CurrentVersion
);
break;
}
if (LatestRelease == null) return UpdateType.None;
var tagName = LatestRelease.TagName;
var latestVersion = Helper.StripInitialV(tagName);
if (latestVersion.Major != CurrentVersion.Major)
return UpdateType.Major;
if (latestVersion.Minor != CurrentVersion.Minor)
return UpdateType.Minor;
if (latestVersion.Patch != CurrentVersion.Patch)
return UpdateType.Patch;
return UpdateType.None;
}
public List <Release> GetAllReleasesUsingReleaseTags(Repository repository,
string patternUrl, string testPattern)
{
var index = 0;
var allReleases = new List <Release>();
var allUsers = repository.Client.Repository.Statistics.GetContributors(repository.Owner, repository.Name).Result;
var tags = repository.Client.Repository.GetAllTags(repository.Owner, repository.Name).Result;
// Go through all the release tags and extract commits and pull requests data
foreach (var tag in tags)
{
try
{
Octokit.Release release = null;
release = repository.Client.Repository.Release.Get(repository.Owner, repository.Name, tag.Name).Result;
var rel = new Release();
rel.ProjectName = repository.Owner + "-" + repository.Name;
rel.Contributers = new List <int>();
GetCommitInformation(release, rel, repository, tag.Commit.Sha);
if (index > 0 && index < tags.Count - 2)
{
rel = ExtractCommits(repository, tags[index - 1].Name, tag.Name, rel,
testPattern, allUsers.ToList());
}
rel.Id = release.Id;
rel.PullRequests = new List <PullRequest>();
(DateTime created, int pullRequests) = new HtmlParser().
ParseReleaseHtmlToCountPullRequests(patternUrl, release);
rel.Created = created;
rel.NumberofPullRequests = pullRequests;
rel.Version = release.TagName;
allReleases.Add(rel);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
index++;
}
return(allReleases);
}
private void AddLatestReleaseCandidate()
{
Octokit.Release release = null;
try
{
var client = new GitHubClient(new ProductHeaderValue("nvQuickSite"));
var releases = client.Repository.Release.GetAll("dnnsoftware", "Dnn.Platform").Result;
if (releases.Count > 0)
{
release = releases[0];
if (release.Name.IndexOf("rc", StringComparison.OrdinalIgnoreCase) >= 0) //is it a release candidate?
{
var asset = release.Assets.Where(a => a.BrowserDownloadUrl.IndexOf("install", StringComparison.OrdinalIgnoreCase) > -1).FirstOrDefault();
if (asset != null)
{
string nameForCBO = "DNN Platform ";
if (release.TagName != null && release.TagName[0] == 'v')
{
nameForCBO += release.TagName.Remove(0, 1);
}
else
{
nameForCBO += release.TagName;
}
cboLatestReleases.Items.Add(new ComboItem(asset.BrowserDownloadUrl, nameForCBO));
}
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
/// <summary>
/// Uploads a <see cref="ReleaseAsset"/> for the specified release.
/// </summary>
/// <remarks>
/// See the <a href="http://developer.github.com/v3/repos/releases/#upload-a-release-asset">API documentation</a> for more information.
/// </remarks>
/// <param name="release">The <see cref="Release"/> to attach the uploaded asset to</param>
/// <param name="data">Description of the asset with its data</param>
/// <exception cref="ApiException">Thrown when a general API error occurs.</exception>
/// <returns>The created <see cref="ReleaseAsset"/>.</returns>
public Task<ReleaseAsset> UploadAsset(Release release, ReleaseAssetUpload data)
{
Ensure.ArgumentNotNull(release, "release");
Ensure.ArgumentNotNull(data, "data");
var endpoint = release.UploadUrl.ExpandUriTemplate(new { name = data.FileName });
if (data.Timeout.HasValue)
{
return ApiConnection.Post<ReleaseAsset>(
endpoint,
data.RawData,
"application/vnd.github.v3",
data.ContentType,
data.Timeout.GetValueOrDefault());
}
return ApiConnection.Post<ReleaseAsset>(
endpoint,
data.RawData,
"application/vnd.github.v3",
data.ContentType);
}
DateTime GetUpdatedAt(Release release)
{
//we try to parse our footer
var temp = release.Body.Split(new[] { " at " }, StringSplitOptions.RemoveEmptyEntries);
if (!temp.Any())
{
return DateTime.MinValue;
}
DateTime result;
if (!DateTime.TryParse(temp.Last().Split(' ').First(), out result))
{
return DateTime.MinValue;
}
return result;
}
private ITaskItem TaskItemFor(Release release, ReleaseAsset asset)
{
var item = new TaskItem();
// I don't think there's a way, via the API, to get something like this:
// https://github.com/git-tfs/msbuild-tasks/releases/download/v0.0.9/GitTfsTasks-0.0.9.zip
item.ItemSpec = "https://github.com/" + Repository + "/releases/download/" + TagName + "/" + asset.Name;
item.MaybeSetMetadata("ContentType", asset.ContentType);
item.MaybeSetMetadata("Id", asset.Id.ToString());
item.MaybeSetMetadata("Label", asset.Label);
item.MaybeSetMetadata("Name", asset.Name);
item.MaybeSetMetadata("State", asset.State);
return item;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="client">Octokit object used for interacting with the GitHub REST API</param>
/// <param name="parentRepo">Reference to the repository this release is associated with</param>
/// <param name="repo">Reference to the Octokit object describing the GitHub release</param>
public Release(GitHubClient client, Octokit.Repository parentRepo, Octokit.Release release)
{
_client = client;
_release = release;
_parent = parentRepo;
}
public AvailableUpdate(Release releaseInfo, IEnumerable<ReleaseAsset> assets)
: this(releaseInfo)
{
this.assets = assets.ToArray();
}
private ITaskItem[] UploadAll(IReleasesClient client, Release release, IEnumerable<ITaskItem> items)
{
return items.Select(item => { Log.LogMessage("Uploading {0}...", item.ItemSpec); return Upload(client, release, item).Result; }).ToArray();
}
private string Upload(IReleasesClient client, Release release, UploadFile sourceItem)
{
var uploadedAsset = client.UploadAsset(release, BuildAssetUpload(sourceItem));
return TaskItemFor(release, uploadedAsset);
}
private string TaskItemFor(Release release, Task<ReleaseAsset> asset)
{
return "https://github.com/" + _repository + "/releases/download/" + _tagName + "/" + asset.Result.Name;
//item.MaybeSetMetadata("ContentType", asset.ContentType);
//item.MaybeSetMetadata("Id", asset.Id.ToString());
//item.MaybeSetMetadata("Label", asset.Label);
//item.MaybeSetMetadata("Name", asset.Name);
//item.MaybeSetMetadata("State", asset.State);
}
static Task UploadFileToGithub(Release githubRelease, string filePath, string filePublishName, string contentType)
{
var buildZipAssetWindows = new ReleaseAssetUpload()
{
FileName = filePublishName,
ContentType = contentType,
RawData = File.OpenRead(filePath)
};
return github.Release.UploadAsset(githubRelease, buildZipAssetWindows);
}
private static async Task AddAssets(GitHubClient github, IList<string> assets, Release release)
{
if (assets != null)
{
foreach (var asset in assets)
{
if (!File.Exists(asset))
{
continue;
}
var upload = new ReleaseAssetUpload
{
FileName = Path.GetFileName(asset),
ContentType = "application/octet-stream",
RawData = File.Open(asset, FileMode.Open)
};
await github.Release.UploadAsset(release, upload);
}
}
}
bool IsUpdateToReleaseNeeded(Release release)
{
if (release.Prerelease)
{
return false;
}
var releaseVersion = GetReleaseVersion(release);
return IsUpdateToVersionNeeded(releaseVersion);
}
static Version GetReleaseVersion(Release release)
{
var versionMatch = Regex.Match(release.Name, "shapeshifter-v(.+)");
var versionGroup = versionMatch.Groups[1];
var version = new Version(versionGroup.Value);
return version;
}
private async System.Threading.Tasks.Task<ITaskItem> Upload(IReleasesClient client, Release release, ITaskItem sourceItem)
{
var uploadedAsset = await client.UploadAsset(release, BuildAssetUpload(sourceItem));
return TaskItemFor(release, uploadedAsset);
}
