public XenkoStoreAlternateVersionViewModel([NotNull] XenkoStoreVersionViewModel xenkoVersion)
: base(xenkoVersion.ServiceProvider)
{
this.xenkoVersion = xenkoVersion;
SetAsActiveCommand = new AnonymousCommand(ServiceProvider, () =>
{
xenkoVersion.UpdateLocalPackage(LocalPackage, null);
if (LocalPackage == null)
{
// If it's a non installed version, offer same version for serverPackage so that it offers to install this specific version
xenkoVersion.UpdateServerPackage(ServerPackage, null);
}
else
{
// Otherwise, offer latest version for update
xenkoVersion.UpdateServerPackage(xenkoVersion.LatestServerPackage, null);
}
xenkoVersion.Launcher.ActiveVersion = xenkoVersion;
});
}
private async Task RetrieveServerXenkoVersions()
{
try
{
#if SIMULATE_OFFLINE
var serverPackages = new List <IPackage>();
#else
var serverPackages = await RunLockTask(() => store.FindSourcePackages(store.MainPackageIds, CancellationToken.None).Result.OrderByDescending(p => p.Version).ToList());
#endif
// Check if we could connect to the server
var wasOffline = IsOffline;
IsOffline = serverPackages.Count == 0;
// Inform the user if we just switched offline
if (IsOffline && !wasOffline)
{
var message = Strings.ErrorOfflineMode;
if (!string.IsNullOrEmpty(LastErrorOrWarning))
{
message += Environment.NewLine + Environment.NewLine + Strings.Details + Environment.NewLine + LastErrorOrWarning;
}
await ServiceProvider.Get <IDialogService>().MessageBox(message, MessageBoxButton.OK, MessageBoxImage.Information);
}
// We are offline, let's stop here
if (IsOffline)
{
return;
}
lock (objectLock)
{
// Retrieve all server packages (ignoring dev ones)
var packages = serverPackages
.Where(x => !string.Equals(x.Source, Environment.ExpandEnvironmentVariables(store.DevSource), StringComparison.OrdinalIgnoreCase))
.GroupBy(p => $"{p.Version.Version.Major}.{p.Version.Version.Minor}", p => p);
foreach (var package in packages)
{
var serverPackage = package.FirstOrDefault();
if (serverPackage != null)
{
// Find if we already have this package in our list
int index = xenkoVersions.BinarySearch(Tuple.Create(serverPackage.Version.Version.Major, serverPackage.Version.Version.Minor));
XenkoStoreVersionViewModel version;
if (index < 0)
{
// If not, add it
version = new XenkoStoreVersionViewModel(this, store, null, serverPackage.Version.Version.Major, serverPackage.Version.Version.Minor);
Dispatcher.Invoke(() => xenkoVersions.Add(version));
}
else
{
// If yes, update it and remove it from the list of old version
version = (XenkoStoreVersionViewModel)xenkoVersions[index];
}
version.UpdateServerPackage(serverPackage);
}
}
}
}
catch (Exception e)
{
// TODO: error
e.Ignore();
}
finally
{
Dispatcher.Invoke(() =>
{
// Allow to install the latest version if any version is found
var latestVersion = xenkoVersions.FirstOrDefault();
if (latestVersion != null)
{
// Latest version not installed and can be downloaded
if (latestVersion.CanBeDownloaded)
{
InstallLatestVersionCommand.IsEnabled = !latestVersion.CanDelete && latestVersion.CanBeDownloaded;
}
}
OnPropertyChanging(nameof(ActiveDocumentationPages));
OnPropertyChanged(nameof(ActiveDocumentationPages));
});
}
}
public async Task RetrieveLocalXenkoVersions()
{
List <RecentProjectViewModel> currentRecentProjects;
lock (RecentProjects)
{
currentRecentProjects = new List <RecentProjectViewModel>(RecentProjects);
}
try
{
var localPackages = await RunLockTask(() => store.GetPackagesInstalled(store.MainPackageIds).OrderByDescending(p => p.Version).ToList());
lock (objectLock)
{
// Retrieve all local packages
var packages = localPackages.Where(p => !store.IsDevRedirectPackage(p)).GroupBy(p => $"{p.Version.Version.Major}.{p.Version.Version.Minor}", p => p);
var updatedLocalPackages = new HashSet <XenkoStoreVersionViewModel>();
foreach (var package in packages)
{
var localPackage = package.FirstOrDefault();
if (localPackage != null)
{
// Find if we already have this package in our list
int index = xenkoVersions.BinarySearch(Tuple.Create(localPackage.Version.Version.Major, localPackage.Version.Version.Minor));
XenkoStoreVersionViewModel version;
if (index < 0)
{
// If not, add it
version = new XenkoStoreVersionViewModel(this, store, localPackage, localPackage.Version.Version.Major, localPackage.Version.Version.Minor);
Dispatcher.Invoke(() => xenkoVersions.Add(version));
}
else
{
version = (XenkoStoreVersionViewModel)xenkoVersions[index];
}
version.UpdateLocalPackage(localPackage);
updatedLocalPackages.Add(version);
}
}
// Update versions that are not installed locally anymore
Dispatcher.Invoke(() =>
{
foreach (var xenkoUninstalledVersion in xenkoVersions.OfType <XenkoStoreVersionViewModel>().Where(x => !updatedLocalPackages.Contains(x)))
{
xenkoUninstalledVersion.UpdateLocalPackage(null);
}
});
// Update the active version if it is now invalid.
if (ActiveVersion == null || !xenkoVersions.Contains(ActiveVersion) || !ActiveVersion.CanDelete)
{
ActiveVersion = XenkoVersions.FirstOrDefault(x => x.CanDelete);
}
if (!lastActiveVersionRestored)
{
var restoredVersion = XenkoVersions.FirstOrDefault(x => x.CanDelete && x.Name == LauncherSettings.ActiveVersion);
if (restoredVersion != null)
{
ActiveVersion = restoredVersion;
lastActiveVersionRestored = true;
}
}
}
var devPackages = localPackages.Where(store.IsDevRedirectPackage);
Dispatcher.Invoke(() => xenkoVersions.RemoveWhere(x => x is XenkoDevVersionViewModel));
foreach (var package in devPackages)
{
try
{
var realPath = File.ReadAllText(store.GetRedirectFile(package));
if (!Directory.Exists(realPath))
{
throw new DirectoryNotFoundException();
}
var version = new XenkoDevVersionViewModel(this, store, package, realPath, true);
Dispatcher.Invoke(() => xenkoVersions.Add(version));
}
catch (Exception e)
{
await ServiceProvider.Get <IDialogService>().MessageBox(string.Format(Strings.ErrorDevRedirect, e), MessageBoxButton.OK, MessageBoxImage.Information);
}
}
}
catch (Exception e)
{
// TODO: error
e.Ignore();
}
finally
{
Dispatcher.Invoke(() =>
{
foreach (var project in currentRecentProjects)
{
// Manually discarding the possibility to upgrade from 1.0
if (project.XenkoVersionName == "1.0")
{
continue;
}
project.CompatibleVersions.Clear();
foreach (var version in XenkoVersions)
{
// We suppose all dev versions are compatible with any project.
if (version is XenkoDevVersionViewModel)
{
project.CompatibleVersions.Add(version);
}
var storeVersion = version as XenkoStoreVersionViewModel;
if (storeVersion != null && storeVersion.CanDelete)
{
// Discard the version that matches the recent project version
if (project.XenkoVersion == new Version(storeVersion.Version.Version.Major, storeVersion.Version.Version.Minor))
{
continue;
}
// Discard the versions that are anterior to the recent project version
if (project.XenkoVersion > storeVersion.Version.Version)
{
continue;
}
project.CompatibleVersions.Add(version);
}
}
}
});
}
}
