private bool BackupPlugin(IPlugin plugin)
{
//Backup current version if installed and different from the one we are installing
try
{
IPlugin ip = InstalledPlugins.Find(plugin);
if (ip != null && ip.Version != plugin.Version)
{
if (!Directory.Exists(backupDir))
{
Directory.CreateDirectory(backupDir);
}
string oldPluginPath = Path.Combine(ApplicationPaths.AppPluginPath, plugin.Filename);
string bpPath = Path.Combine(backupDir, plugin.Filename);
File.Copy(oldPluginPath, bpPath, true);
IPlugin bp = backedUpPlugins.Find(plugin);
if (bp != null)
{
backedUpPlugins.Remove(bp);
}
backedUpPlugins.Add(Plugin.FromFile(bpPath, false));
return(true);
}
}
catch (Exception e)
{
Logger.ReportException("Error trying to backup current plugin", e);
}
return(false);
}
private void InstalledPluginsChanged(object sender, NotifyCollectionChangedEventArgs e)
{
//TODO re-sort
RemoveInstalledPluginsFromList();
InstalledPluginSerializer.Instance.StoreInstalledPlugins(InstalledPlugins.ToList(), EntityViewModel);
}
/// <summary>
/// Deserialize PluginInfo from json
/// </summary>
/// <param name="json">Json data of PluginInfo</param>
/// <returns>True if data are loaded, otherwise False</returns>
protected virtual bool DeserializePluginInfo(string json)
{
var pluginsInfo = JsonConvert.DeserializeObject <PluginsInfo>(json);
InstalledPluginNames = pluginsInfo.InstalledPluginNames;
InstalledPlugins = pluginsInfo.InstalledPlugins;
PluginNamesToUninstall = pluginsInfo.PluginNamesToUninstall;
PluginNamesToDelete = pluginsInfo.PluginNamesToDelete;
PluginNamesToInstall = pluginsInfo.PluginNamesToInstall;
return(InstalledPlugins.Any() || PluginNamesToUninstall.Any() || PluginNamesToDelete.Any() ||
PluginNamesToInstall.Any());
}
protected override void RenderPackages()
{
PluginsListBox.Clear();
PluginsListBox.Loading.ShowLoading(PluginsListBox.PackageListPane);
AppHost.DoEvents();
var searchText = PluginsListBox.Search.Text;
var packages = InstalledPlugins.OfType <PackagePluginDescriptor>().Select(p => p.Package).ToList();
var updatePackages = new List <Tuple <IPackageRepository, IPackage> >();
foreach (var gallery in AppHost.Plugins.GetPluginGalleries())
{
var repository = PackageRepositoryFactory.Default.CreateRepository(gallery.Location);
List <IPackage> updates;
try
{
updates = repository.GetUpdates(packages, PluginsListBox.IncludePrereleases, false).ToList();
}
catch (ArgumentException ex)
{
AppHost.Output.LogException(ex);
continue;
}
updatePackages.AddRange(updates.Select(package => new Tuple <IPackageRepository, IPackage>(repository, package)));
}
var listBoxItems = new List <PluginsListBoxItem>();
foreach (var tuple in updatePackages)
{
if (!tuple.Item2.Title.IsFilterMatch(searchText))
{
continue;
}
var plugin = new PackagePluginDescriptor(tuple.Item1, tuple.Item2);
listBoxItems.Add(new PluginsListBoxItem(this, plugin, false, false, true, false));
}
PluginsListBox.RenderPlugins(listBoxItems);
}
private async Task InternalRefresh()
{
// should be called from STA
var wasSelected = selectedPlugin?.InternalName;
selectedPlugin = null;
InstalledPlugins.Clear();
AvailablePlugins.Clear();
FreshPlugins.Clear();
MarkedForRemovalPlugins.Clear();
try
{
IsLoadingLocalPlugins = true;
// making sure that all packages are loaded
await PluginManager.PreloadTask.ConfigureAwait(false);
var installedPlugins = await Task.Run(() => PluginManager.GetAllPlugins().ToList()).ConfigureAwait(false);
// display installed plugins
Dispatch(() =>
{
foreach (var vm in installedPlugins.Select(plugin => new LoadedPluginViewModel(plugin, this)))
{
MovePluginToCorrectCollection(vm);
}
IsLoadingLocalPlugins = false;
RestorePluginSelection(wasSelected);
});
await LoadRegistryPlugins(installedPlugins);
// restore plugin selection if user didn't select other menu item while plugins were loading
RestorePluginSelection(wasSelected);
}
finally
{
// in case plugin loading failed, disable loading anyway
Dispatch(() => IsLoadingLocalPlugins = false);
}
}
protected override void RenderPackages()
{
PluginsListBox.Clear();
PluginsListBox.SupportPrereleases = true;
PluginsListBox.Loading.ShowLoading(PluginsListBox.PackageListPane);
AppHost.DoEvents();
var plugins = new List <BasePluginDescriptor>();
IPackageRepository repository;
try
{
repository = PackageRepositoryFactory.Default.CreateRepository(Url);
}
catch (Exception ex)
{
AppHost.Output.LogException(ex);
AppHost.MessageBox(string.Format("The URL of the repository \"{0}\" is invalid:\n\n{1}\n\n{2}", FeedName, Url, ex.Message), "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
var packages = new List <IPackage>();
try
{
var query = repository.Search(PluginsListBox.Search.Text, PluginsListBox.IncludePrereleases);
query = query.OrderByDescending(p => p.DownloadCount).ThenBy(p => p.Title).Skip(PageIndex * 10);
packages = query.ToList().GroupBy(p => p.Id).Select(y => y.OrderByDescending(p => p.Version).First()).ToList();
}
catch (WebException ex)
{
AppHost.MessageBox("Failed to communicated with the server: " + Url + "\n\nThe server responded with: " + ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
catch (UriFormatException)
{
AppHost.MessageBox("The URL is invalid: " + Url, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
var listBoxItems = new List <PluginsListBoxItem>();
var count = 0;
foreach (var package in packages)
{
var plugin = new PackagePluginDescriptor(repository, package);
plugins.Add(plugin);
count++;
if (count == 10)
{
break;
}
var isInstalled = InstalledPlugins.OfType <PackagePluginDescriptor>().Any(p => p.Package.Id == package.Id && p.Package.Version == package.Version);
listBoxItems.Add(new PluginsListBoxItem(this, plugin, true, false, false, isInstalled));
}
var total = PageIndex * 10 + packages.Count;
var currentPage = PageIndex;
var firstPage = currentPage - 2;
if (firstPage < 0)
{
firstPage = 0;
}
var lastPage = total % 10 == 0 ? total / 10 - 1 : total / 10;
if (lastPage > firstPage + 4)
{
lastPage = firstPage + 4;
}
PluginsListBox.RenderPlugins(listBoxItems);
PluginsListBox.RenderPager(currentPage, firstPage, lastPage);
}
public void EnablePlugin(InstalledPlugin installedPlugin)
{
installedPlugin.IsEnabled = true;
RaisePropertyChanged(this, new PropertyChangedEventArgs(nameof(installedPlugin.IsEnabled)));
InstalledPluginSerializer.Instance.StoreInstalledPlugins(InstalledPlugins.ToList(), EntityViewModel);
}
