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