public NewVersionWindow(GithubRelease release, MainWindow mainWindow)
{
_release = release;
_mainWindow = mainWindow;
InitializeComponent();
MainGrid.DataContext = _release;
}
/// <summary>
/// Downloads the latest release from github
/// </summary>
/// <returns></returns>
private async Task <string> DownloadRelease(GithubRelease release)
{
if (release == null)
{
return(null);
}
var downloadPath = SidekickPaths.GetDataFilePath("Sidekick-Update.exe");
if (File.Exists(downloadPath))
{
File.Delete(downloadPath);
}
var downloadUrl = release.Assets.FirstOrDefault(x => x.Name == "Sidekick-Setup.exe")?.DownloadUrl;
if (downloadUrl == null)
{
return(null);
}
var response = await githubClient.Client.GetAsync(downloadUrl);
using var downloadStream = await response.Content.ReadAsStreamAsync();
using var fileStream = new FileStream(downloadPath, FileMode.Create, FileAccess.Write, FileShare.None);
await downloadStream.CopyToAsync(fileStream);
return(downloadPath);
}
public UpdateViewModel(MainService main,
TrayService tray)
{
this.main = main;
this.tray = tray;
savePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory,
"Update",
"update.zip");
upexePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory,
"Update",
"ProjectEyeUp.exe");
string[] versionArray = Assembly.GetExecutingAssembly().GetName().Version.ToString().Split('.');
version = versionArray[0] + "." + versionArray[1] + "." + versionArray[2];
#if DEBUG
version = "1.0.3";
#endif
githubUrl = "https://api.github.com/repos/planshit/projecteye/releases/latest";
outPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory);
openurlCommand = new Command(new Action <object>(openurlCommand_action));
updateCommand = new Command(new Action <object>(updateCommand_action));
installCommand = new Command(new Action <object>(installCommand_action));
githubRelease = new GithubRelease(githubUrl, version);
githubRelease.RequestCompleteEvent += Updater_RequestCompleteEvent;
githubRelease.RequestErrorEvent += Updater_RequestErrorEvent;
githubRelease.GetRequest();
PlayProcess = true;
}
// Methods
// =======
public async Task <Asset> CheckForUpdateAsync()
{
RestRequest request = new RestRequest(Method.GET);
IRestResponse response = await Task.Run(() =>
{
return(restClient.Execute(request));
});
if (response == null)
{
return(null);
}
switch (response.ResponseStatus)
{
case ResponseStatus.TimedOut:
case ResponseStatus.Error:
case ResponseStatus.Aborted:
default:
return(null);
case ResponseStatus.Completed when response.StatusCode == HttpStatusCode.OK:
GithubRelease release = jsonConverter.FromJson <GithubRelease>(response.Content);
if (release == null)
{
return(null);
}
if (release.IsDraft)
{
return(null);
}
if (release.Tag == null)
{
return(null);
}
if (!Version.TryParse(release.Tag.Split('-')[0].Replace(vPrefix, string.Empty), out Version version))
{
return(null);
}
if (assemblyName.Version.CompareTo(version) >= 0)
{
return(null);
}
Asset asset = release.Assets.FirstOrDefault(r => r.URL.EndsWith(msiExtension));
if (asset == null)
{
return(null);
}
return(asset);
}
}
/// <summary>
/// Returns whether there is an update available for the core ModAPI DLLs.
/// </summary>
/// <returns></returns>
public static bool HasDllsUpdate(out GithubRelease release)
{
release = GetLatestGithubRelease("emd4600", "spore-modapi");
var updateVersion = ParseGithubVersion(release.tag_name);
return(updateVersion > Settings.CurrentDllsBuild);
}
public void SetUp()
{
var navigationServiceMock = new Mock <INavigationService>();
_dialogServiceMock = new Mock <IDialogService>();
var busStopRepositoryMock = new Mock <IBusStopRepository>();
_githubServiceMock = new Mock <IGithubService>();
_appUpdaterMock = new Mock <IAppUpdater>();
var geolocatorMock = new Mock <IGeolocator>();
_tabsPageVM = new TabsPageVM(navigationServiceMock.Object, _dialogServiceMock.Object,
_githubServiceMock.Object, busStopRepositoryMock.Object, _appUpdaterMock.Object, geolocatorMock.Object);
_githubRelease = new GithubRelease
{
Name = "Newer tRelease",
TagName = null,
Assets = new List <Asset>
{
new Asset
{
Id = 1,
Name = "TestAsset",
Size = 2,
Url = "www.update-download-test.com"
}
}
};
}
public GitHubUpdates(string componentUpdated, GithubRelease latestRelease)
{
InitializeComponent();
_componentUpdated = componentUpdated;
labelUpdated.Content = componentUpdated;
_latestRelease = latestRelease;
}
/// <summary>
/// Returns whether there is an update available for the program.
/// </summary>
/// <returns></returns>
public static bool HasProgramUpdate(out GithubRelease release)
{
release = GetLatestGithubRelease("Splitwirez", "Spore-Mod-Manager");
//release = GetLatestGithubRelease("emd4600", "sporemodder-fx");
var updateVersion = ParseGithubVersion(release.tag_name);
return(updateVersion > Settings.ModManagerVersion);
}
private GithubRelease[] GetReleasesFromVersions(List <MLAPIVersion> versions)
{
GithubRelease[] releases = new GithubRelease[versions.Count];
for (int i = 0; i < versions.Count; i++)
{
releases[i] = GetReleaseOfVersion(versions[i]);
}
return(releases);
}
public void Release()
{
GithubRelease ckan = GithubAPI.GetLatestRelease("KSP-CKAN/Test", false);
Assert.IsNotNull(ckan.author);
Assert.IsNotNull(ckan.download);
Assert.IsNotNull(ckan.size);
Assert.IsNotNull(ckan.version);
}
public GitHubUpdates(UpdaterComponent componentUpdated, GithubRelease latestRelease, string local, string online)
{
InitializeComponent();
_componentUpdated = componentUpdated;
labelUpdated.Content = componentUpdated.name;
labelVersion.Content = $"{(local != Properties.Resources.UpdaterNotInstalled ? $"{local} to " : "")}{online}";
_latestRelease = latestRelease;
onlineVersion = online;
}
public void TestSetup()
{
release = new GithubRelease()
{
Url = string.Empty,
Tag = "v0.2.0",
PreRelease = "False",
Published = string.Empty
};
}
IEnumerator CheckForUpdates()
{
using (UnityWebRequest webRequest = UnityWebRequest.Get("https://api.github.com/repos/japamala/armok-vision/releases"))
{
yield return(webRequest.SendWebRequest());
if (webRequest.result != UnityWebRequest.Result.Success)
{
Debug.LogError("Connection Error: " + webRequest.error);
}
else
{
var releases = JsonConvert.DeserializeObject <GithubRelease[]>(webRequest.downloadHandler.text);
foreach (var release in releases)
{
if (release.draft)
{
continue;
}
if (release.prerelease)
{
continue;
}
latestRelease = release;
break;
}
if (latestRelease == null)
{
Debug.Log("No valid release.");
yield break;
}
try
{
System.Version latestVersion = new System.Version(latestRelease.tag_name.TrimStart('v'));
System.Version currentVersion = new System.Version(BuildSettings.Instance.content_version);
if (latestVersion > currentVersion)
{
ModalPanel.Instance.Choice(string.Format("There is a new version of Armok Vision availabe for download.\r\n" +
"Current version: {0}\r\n" +
"Latest version: {1}\r\n" +
"Would you like to download it?", currentVersion, latestVersion), OpenRelease, NoEvent, DontAskAgain, "Yes", "No", "Don't ask again.");
}
else
{
Debug.Log("Armok Vision it up to date!");
}
}
catch (System.Exception e)
{
Debug.LogException(e);
yield break;
}
}
}
}
public void UpdateApp(GithubRelease latestRelease)
{
if (_updateSupport.CheckIfApkIsDownloaded())
{
_updateSupport.ApkInstall();
}
else
{
DownloadLatestVersion(latestRelease.Assets[0].Url);
}
}
public async Task <GithubRelease> GetRelease()
{
if (githubRelease == null || DateTime < DateTime.UtcNow.AddHours(-1))
{
DateTime = DateTime.UtcNow;
HttpClient.DefaultRequestHeaders.UserAgent.TryParseAdd("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.122 Safari/537.36 Edg/80.0.361.62");
githubRelease = await HttpClient.GetFromJsonAsync <GithubRelease>("https://api.github.com/repos/IvanJosipovic/KubeUI/releases/latest");
}
return(githubRelease);
}
protected override async Task Download(GithubRelease ghRelease)
{
var release = ghRelease.Release;
var asset = release.Assets.First(r => r.Name.Contains("win-x64"));
using (var client = new HttpClient())
using (var stream = await client.GetStreamAsync(asset.BrowserDownloadUrl))
using (var zipStream = new ZipArchive(stream))
{
zipStream.ExtractToDirectory(DownloadDirectory);
}
}
/// <summary>
/// Called after the loading, register the hook (for single-process) and check for new releases.
/// </summary>
private async void AppLoaded(object sender, RoutedEventArgs e)
{
_source = HwndSource.FromHwnd(new WindowInteropHelper(this).Handle);
_source.AddHook(new HwndSourceHook(SettingsHelper.WndProc));
GithubRelease githubRelease = await GithubHelper.GetLatestRelease();
if (githubRelease.IsLatest)
{
this.InformNewVersion(githubRelease.Url, githubRelease.Version, githubRelease.Current);
}
}
private async void MainForm_Load(object sender, EventArgs e)
{
Text += " v" + Shared.VERSION.ToString(CultureInfo.InvariantCulture);
ReadCurrentValues();
_newRelease = await UpdateChecker.CheckForUpdates().ConfigureAwait(true);
if (_newRelease != null)
{
btnUpdateAvailable.Visible = true;
btnUpdateAvailable.Text = "v" + _newRelease.tag_name + " is available!\r\nClick for changelog.";
}
}
protected override async Task Download(GithubRelease ghRelease)
{
var release = ghRelease.Release;
var asset = release.Assets.First(r => r.Name.Contains("osx-x64"));
// Download and extract tar gzip
using (var httpClient = new HttpClient())
using (var httpStream = await httpClient.GetStreamAsync(asset.BrowserDownloadUrl))
using (var decompressionStream = new GZipStream(httpStream, CompressionMode.Decompress))
using (var tar = TarArchive.CreateInputTarArchive(decompressionStream))
{
tar.ExtractContents(DownloadDirectory);
}
}
static void ParseGithub(WWW github)
{
release = JsonUtility.FromJson <GithubRelease>(github.text);
string current = EditorPrefs.GetString(prefs + Application.productName, nullDT);
if (DateTime.ParseExact(release.created_at, universalDT, CultureInfo.InvariantCulture) >
DateTime.ParseExact(current, universalDT, CultureInfo.InvariantCulture))
{
hasUpdate = true;
if (window != null)
{
window.Repaint();
}
}
}
/// <summary>
/// Downloads the update from the given Github release and applies it, extracting all the necessary files.
/// A progress handler can be passed to react when the operation progress (in the range [0, 100]) changes.
/// Throws an InvalidOperationException if the update is not valid.
/// </summary>
/// <param name="release"></param>
/// <param name="progressHandler"></param>
public static void UpdateDlls(GithubRelease release, ProgressChangedEventHandler progressHandler)
{
var asset = Array.Find(release.assets, a => a.name.ToLower() == "sporemodapidlls.zip");
if (asset == null)
{
throw new InvalidOperationException("Invalid update: no 'SporeModAPIdlls.zip' asset");
}
using (var client = new WebClient())
{
client.DownloadProgressChanged += (s, e) =>
{
var args = new ProgressChangedEventArgs((int)(e.ProgressPercentage * DOWNLOAD_PROGRESS), null);
if (progressHandler != null)
{
progressHandler.Invoke(null, args);
}
};
string zipName = Path.GetTempFileName();
client.DownloadFile(asset.browser_download_url, zipName);
using (var zip = new ZipFile(zipName))
{
int filesExtracted = 0;
foreach (string name in DLL_NAMES)
{
var entry = zip[name];
if (entry == null)
{
throw new InvalidOperationException("Invalid update: missing " + name + " in zip file");
}
entry.Extract(Settings.CoreLibsPath, ExtractExistingFileAction.OverwriteSilently);
Permissions.GrantAccessFile(Path.Combine(Settings.CoreLibsPath, entry.FileName));
++filesExtracted;
double progress = DOWNLOAD_PROGRESS + filesExtracted * (1.0f - DOWNLOAD_PROGRESS) / (float)(DLL_NAMES.Length);
var args = new ProgressChangedEventArgs((int)(progress * 100.0), null);
if (progressHandler != null)
{
progressHandler.Invoke(null, args);
}
}
}
File.Delete(zipName);
}
}
static async Task <string> GetUpdateUrl()
{
#if DEBUG
return(@"C:\Users\fritzen\Source\Repos\frznUpload\frznUploadClient\Releases");
#endif
bool pre = Config.AppSettings.AllKeys.Contains("Prerelease") && Config.AppSettings["Prerelease"].Value == "true";
List <GithubRelease> releases = await GetReleases();
GithubRelease latestRelease = releases
.Where(x => pre || !x.Prerelease)
.OrderByDescending(x => x.PublishedAt)
.First();
return(latestRelease.HtmlUrl.Replace("/tag/", "/download/"));
}
/// <summary>
/// Checks if there is a newer release available on github
/// </summary>
/// <returns></returns>
public async Task <bool> NewVersionAvailable()
{
initializer.ReportProgress(ProgressTypeEnum.Other, nameof(UpdateManager), "Checking for Updates...");
LatestRelease = await GetLatestRelease();
if (LatestRelease != null)
{
var latestVersion = new Version(Regex.Match(LatestRelease.Tag, @"(\d+\.){2}\d+").ToString());
// var currentVersion = new Version("0.2.0");
var currentVersion = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(x => x.FullName.Contains("Sidekick")).GetName().Version;
var result = currentVersion.CompareTo(latestVersion);
return(result < 0 ? true : false);
}
return(false);
}
public GitHubUpdates(UpdaterComponent componentUpdated, GithubRelease latestRelease, string local, string online)
{
InitializeComponent();
_componentUpdated = componentUpdated;
if (componentUpdated.name == "TeknoParrotUI")
{
labelUpdated.Content = componentUpdated.name + " (Requires App Restart)";
}
else
{
labelUpdated.Content = componentUpdated.name;
}
labelVersion.Content = $"{(local != Properties.Resources.UpdaterNotInstalled ? $"{local} to " : "")}{online}";
_latestRelease = latestRelease;
onlineVersion = online;
}
/// <summary>
/// Determines latest release on github. Pre-releases do not count as release, therefore we need to get the list of releases first, if no actual latest release can be found
/// </summary>
/// <returns></returns>
private async Task <GithubRelease> GetLatestRelease()
{
GithubRelease latestRelease = null;
try
{
var jsonOptions = new JsonSerializerOptions {
IgnoreNullValues = true, PropertyNameCaseInsensitive = true
};
var response = await _httpClient.GetAsync("/repos/domialex/Sidekick/releases/latest");
if (response.IsSuccessStatusCode)
{
latestRelease = await JsonSerializer.DeserializeAsync <GithubRelease>(await response.Content.ReadAsStreamAsync(), jsonOptions);
}
else
{
//Get List of releases if there is no latest release ( should only happen if there are only pre-releases)
var listResponse = await _httpClient.GetAsync("/repos/domialex/Sidekick/releases");
if (listResponse.IsSuccessStatusCode)
{
var githubReleaseList = await JsonSerializer.DeserializeAsync <GithubRelease[]>(await listResponse.Content.ReadAsStreamAsync(), jsonOptions);
// Iterate through version list to determine latest version
var highestVersionNo = new Version("0.0.0.0");
foreach (var release in githubReleaseList)
{
var releaseVersion = new Version(Regex.Match(release.Tag, @"(\d+\.){2}\d+").ToString());
if (highestVersionNo?.CompareTo(releaseVersion) < 0)
{
highestVersionNo = releaseVersion;
latestRelease = release;
}
}
}
}
}
catch (Exception)
{
throw;
}
return(latestRelease);
}
/// <summary>
/// Determines if there is a newer version available
/// </summary>
/// <returns></returns>
private bool IsUpdateAvailable(GithubRelease release)
{
if (release != null)
{
logger.LogInformation("[Updater] Found " + release.Tag + " as latest version on GitHub.");
var latestVersion = new Version(Regex.Match(release.Tag, @"(\d+\.){2}\d+").ToString());
var currentVersion = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(x => x.FullName.Contains("Sidekick")).GetName().Version;
var result = currentVersion.CompareTo(latestVersion);
return(result < 0);
}
else
{
logger.LogInformation("[Updater] No latest release found on GitHub.");
}
return(false);
}
// Start auto updater
public static async void AutoUpdate(GithubRelease release)
{
try
{
if (release.Assets.Count > 0)
{
string assemblylocation = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string updater = Path.Combine(assemblylocation, UpdaterFileName);
Process.Start(updater, string.Format("{0} {1}", Process.GetCurrentProcess().Id, release.Assets[0].Url));
Hearthstone_Deck_Tracker.API.Core.MainWindow.Close();
System.Windows.Application.Current.Shutdown();
}
}
catch (Exception e)
{
// Manual update
Log.Info("AutoUpdate error: " + e.Message);
Process.Start(releaseDownloadUrl);
}
}
// Start auto updater
public static async Task <bool> AutoUpdate(GithubRelease release)
{
bool status = true;
try
{
if (release.Assets.Count > 0)
{
// Update and install
status = await AutoUpdater.Update(release.Assets[0].Url);
}
}
catch (Exception e)
{
status = false;
Log.Info("AutoUpdate error: " + e.Message);
}
return(status);
}
public void PromptUpdate(IRestResponse response)
{
if (response.StatusCode != HttpStatusCode.OK)
{
return;
}
GithubRelease release = JsonConvert.DeserializeObject <GithubRelease>(response.Content);
if (release == null)
{
return;
}
if (release.IsDraft)
{
return;
}
Version.TryParse(release.Tag.Split('-')[0].Replace("v", ""), out Version version);
if (Assembly.GetExecutingAssembly().GetName().Version.CompareTo(version) >= 0)
{
return;
}
Asset asset = release.Assets.FirstOrDefault(r => r.URL.EndsWith(".msi"));
if (asset == null)
{
return;
}
UpdateWindow prompt = new UpdateWindow(release.URL, asset.URL)
{
Owner = this
};
prompt.ShowDialog();
}
public Updater(GithubRelease updateToVersion)
{
InitializeComponent();
backgroundWorker.DoWork += UpdateTool;
backgroundWorker.ProgressChanged += UpdateProgress;
backgroundWorker.RunWorkerCompleted += OnDone;
backgroundWorker.WorkerReportsProgress = true;
// bit of a hack to check if we're using the self-contained binary or not
var isSelfContained = File.Exists("System.dll");
foreach (var asset in updateToVersion.assets)
{
if ((isSelfContained && asset.name.Contains("sc")) ||
!(isSelfContained || asset.name.Contains("sc")))
{
releaseAsset = asset;
break;
}
}
}
