Пример #1
0
        /// <summary>
        /// Package by ID
        /// </summary>
        /// <param name="id">Package ID</param>
        /// <returns>Package</returns>
        public Package FindById(string id)
        {
            if (!Security.IsAuthorizedTo(Rights.ManagePackages))
            {
                throw new UnauthorizedAccessException();
            }

            Package galPkg = CachedPackages.FirstOrDefault(p => p.Id == id);
            Package locPkg = Packaging.FileSystem.LoadThemes().FirstOrDefault(p => p.Id == id);

            if (locPkg == null)
            {
                locPkg = Packaging.FileSystem.LoadExtensions().FirstOrDefault(p => p.Id == id);
            }

            if (locPkg == null)
            {
                locPkg = Packaging.FileSystem.LoadWidgets().FirstOrDefault(p => p.Id == id);
            }

            if (locPkg != null && galPkg != null)
            {
                // package installed fro gallery
                galPkg.SettingsUrl = locPkg.SettingsUrl;
            }

            return(galPkg == null ? locPkg : galPkg);
        }
Пример #2
0
        public async Task GetDependencies(HashSet <int> dependecies, HashSet <int> returnDependencies)
        {
            foreach (int depPackageId in dependecies)
            {
                if (!returnDependencies.Contains(depPackageId) && !InstalledPackages.Any(x => x.PackageId == depPackageId))
                {
                    Package dependencyPackage = CachedPackages.FirstOrDefault(x => x.PackageId == depPackageId);
                    if (dependencyPackage == default)
                    {
                        dependencyPackage = await WebWrapper.GetPackage(depPackageId);

                        lock (CachedPackages)
                        {
                            CachedPackages.Add(dependencyPackage);
                        }
                    }

                    if (!dependencyPackage.IsPaid)
                    {
                        returnDependencies.Add(depPackageId);
                    }

                    await GetDependencies(dependencyPackage.Dependencies.ToHashSet(), returnDependencies);
                }
            }
        }
Пример #3
0
        /// <summary>
        /// Find packages
        /// </summary>
        /// <param name="take">Items to take</param>
        /// <param name="skip">Items to skip</param>
        /// <param name="filter">Filter expression</param>
        /// <param name="order">Sort order</param>
        /// <returns>List of packages</returns>
        public IEnumerable <Package> Find(int take = 10, int skip = 0, string filter = "", string order = "")
        {
            if (!Security.IsAuthorizedTo(BlogEngine.Core.Rights.AccessAdminPages))
            {
                throw new System.UnauthorizedAccessException();
            }

            if (take == 0)
            {
                take = CachedPackages.Count();
            }
            if (string.IsNullOrEmpty(filter))
            {
                filter = "1==1";
            }
            if (string.IsNullOrEmpty(order))
            {
                order = "LastUpdated desc";
            }

            var packages = new List <Package>();
            var query    = CachedPackages.AsQueryable().Where(filter);

            foreach (var item in query.OrderBy(order).Skip(skip).Take(take))
            {
                packages.Add(item);
            }
            return(packages);
        }
        /// <summary>
        /// Package by ID
        /// </summary>
        /// <param name="id">Package ID</param>
        /// <returns>Package</returns>
        public Package FindById(string id)
        {
            if (!Security.IsAuthorizedTo(BlogEngine.Core.Rights.ManagePackages))
            {
                throw new System.UnauthorizedAccessException();
            }

            return(CachedPackages.FirstOrDefault(pkg => pkg.Id == id));
        }
Пример #5
0
        public PackageManager(Uri apiUrl, MainWindow mw, string RWPath)
        {
            ApiUrl     = apiUrl;
            MainWindow = mw;

            SqLiteAdapter     = new SqLiteAdapter(Path.Combine(RWPath, "main.dls"));
            InstalledPackages = SqLiteAdapter.LoadInstalledPackages();
            CachedPackages    = CachedPackages.Union(InstalledPackages).ToList();
            WebWrapper        = new WebWrapper(ApiUrl);
        }
        public IQueryable <ServerPackage> GetPackages(ClientCompatibility compatibility)
        {
            var cache = CachedPackages.AsQueryable();

            if (!compatibility.AllowSemVer2)
            {
                cache = cache.Where(p => !p.Version.IsSemVer2());
            }

            return(cache);
        }
Пример #7
0
        public void GetPackagesToDownload(IEnumerable <string> allMissing)
        {
            IEnumerable <string> depsToDownload = allMissing.Intersect(DownloadableDeps);

            while (depsToDownload.Count() > 0)
            {
                Package pkg = CachedPackages.First(x => x.PackageId == DownloadableDepsPackages[depsToDownload.First()]);
                PkgsToDownload.Add(pkg.PackageId);
                depsToDownload = depsToDownload.Except(pkg.FilesContained);
            }
        }
Пример #8
0
        /// <summary>
        /// Returns list of packages from online gallery for a single page
        /// </summary>
        /// <param name="pkgType">Theme, Widget or Extension</param>
        /// <param name="page">Current page</param>
        /// <param name="sortOrder">Order - newest, most downloaded etc.</param>
        /// <param name="searchVal">Search term if it is search request</param>
        /// <returns>List of packages</returns>
        public static List <JsonPackage> FromGallery(string pkgType, int page = 0, Gallery.OrderType sortOrder = Gallery.OrderType.Newest, string searchVal = "")
        {
            var packages = new List <JsonPackage>();
            var gallery  = CachedPackages.Where(p => p.Location == "G" || p.Location == "I");

            if (pkgType != "all")
            {
                gallery = gallery.Where(p => p.PackageType == pkgType).ToList();
            }

            foreach (var pkg in gallery)
            {
                if (string.IsNullOrEmpty(searchVal))
                {
                    packages.Add(pkg);
                }
                else
                {
                    if (pkg.Title.IndexOf(searchVal, StringComparison.OrdinalIgnoreCase) != -1 ||
                        pkg.Description.IndexOf(searchVal, StringComparison.OrdinalIgnoreCase) != -1
                        ||
                        (!string.IsNullOrWhiteSpace(pkg.Tags) &&
                         pkg.Tags.IndexOf(searchVal, StringComparison.OrdinalIgnoreCase) != -1))
                    {
                        packages.Add(pkg);
                    }
                }
            }

            Gallery.GalleryPager = new Pager(page, packages.Count, pkgType);

            if (packages.Count > 0)
            {
                switch (sortOrder)
                {
                case Gallery.OrderType.Downloads:
                    packages = packages.OrderByDescending(p => p.DownloadCount).ThenBy(p => p.Title).ToList();
                    break;

                case Gallery.OrderType.Rating:
                    packages = packages.OrderByDescending(p => p.Rating).ThenBy(p => p.Title).ToList();
                    break;

                case Gallery.OrderType.Newest:
                    packages = packages.OrderByDescending(p => Convert.ToDateTime(p.LastUpdated, Utils.GetDefaultCulture())).ThenBy(p => p.Title).ToList();
                    break;

                case Gallery.OrderType.Alphanumeric:
                    packages = packages.OrderBy(p => p.Title).ToList();
                    break;
                }
            }
            return(packages.Skip(page * Constants.PageSize).Take(Constants.PageSize).ToList());
        }
Пример #9
0
        public async Task <List <int> > FindFile(string file_name, bool withDeps = true)
        {
            Package package = InstalledPackages.FirstOrDefault(x => x.FilesContained.Contains(file_name));

            if (package != default)
            {
                return new List <int>()
                       {
                           package.PackageId
                       }
            }
            ;

            lock (CachedPackages)
                package = CachedPackages.FirstOrDefault(x => x.FilesContained.Contains(file_name));

            if (package != default)
            {
                return new List <int>()
                       {
                           package.PackageId
                       }
            }
            ;

            Package onlinePackage = await WebWrapper.SearchForFile(file_name);

            if (onlinePackage != null && onlinePackage.PackageId > 0)
            {
                lock (CachedPackages)
                {
                    if (!CachedPackages.Any(x => x.PackageId == onlinePackage.PackageId))
                    {
                        CachedPackages.Add(onlinePackage);
                    }
                }

                HashSet <int> dependencyPkgIds = new HashSet <int>();

                if (withDeps)
                {
                    await GetDependencies(new HashSet <int>() { onlinePackage.PackageId }, dependencyPkgIds);
                }

                return(new List <int>()
                {
                    onlinePackage.PackageId
                }.Union(dependencyPkgIds).ToList());
            }

            return(new List <int>());
        }
Пример #10
0
        public async Task ReceiveMSMQ()
        {
            string           queueFile  = Path.Combine(Path.GetTempPath(), "DLS.queue");
            HashSet <string> queuedPkgs = File.Exists(queueFile) ? File.ReadAllText(queueFile).Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToHashSet() : new HashSet <string>();

            if (queuedPkgs.Count > 0)
            {
                MainWindow.Dispatcher.Invoke(() => { MainWindow.Activate(); });
                if (await CheckLogin(1) < 0 || App.IsDownloading)
                {
                    File.WriteAllText(queueFile, string.Empty);
                    return;
                }

                int idToDownload = Convert.ToInt32(queuedPkgs.PopOne());

                if (!InstalledPackages.Exists(x => x.PackageId == idToDownload))
                {
                    Task.Run(async() =>
                    {
                        Package packageToDownload = await WebWrapper.GetPackage(idToDownload);
                        lock (CachedPackages)
                        {
                            if (!CachedPackages.Any(x => x.PackageId == packageToDownload.PackageId))
                            {
                                CachedPackages.Add(packageToDownload);
                            }
                        }

                        if (packageToDownload.IsPaid)
                        {
                            App.Window.Dispatcher.Invoke(() =>
                            {
                                MainWindow.ErrorDialog = new ContentDialog()
                                {
                                    Title               = "Cannot download package",
                                    Content             = "This is paid package. Paid packages cannot be downloaded through this app.",
                                    SecondaryButtonText = "OK",
                                    Owner               = App.Window
                                };

                                MainWindow.ErrorDialog.ShowAsync();
                            });

                            return;
                        }

                        HashSet <int> depsPkgs = new HashSet <int>();
                        await GetDependencies(new HashSet <int>()
                        {
                            packageToDownload.PackageId
                        }, depsPkgs);
                        HashSet <int> packageIds = new HashSet <int>()
                        {
                            packageToDownload.PackageId
                        }.Union(depsPkgs).ToHashSet();

                        if (packageIds.Count > 0)
                        {
                            App.IsDownloading = true;
                            MainWindow.Dispatcher.Invoke(() => { MainWindow.DownloadDialog.ShowAsync(); });
                            await MainWindow.DownloadDialog.DownloadPackages(packageIds, CachedPackages, InstalledPackages, WebWrapper, SqLiteAdapter);
                            App.IsDownloading = false;
                        }
                        else
                        {
                            new Task(() =>
                            {
                                App.Window.Dispatcher.Invoke(() =>
                                {
                                    MainWindow.ErrorDialog = new ContentDialog()
                                    {
                                        Title               = "Cannot download packages",
                                        Content             = "An error ocured when trying to install package.",
                                        SecondaryButtonText = "OK",
                                        Owner               = App.Window
                                    };

                                    MainWindow.ErrorDialog.ShowAsync();
                                });
                            }).Start();
                        }
                    }).Wait();
                }
                else
                {
                    App.Window.Dispatcher.Invoke(() =>
                    {
                        MainWindow.ErrorDialog = new ContentDialog()
                        {
                            Title               = "Cannot download package",
                            Content             = "This package is already downloaded.",
                            SecondaryButtonText = "OK",
                            Owner               = App.Window
                        };

                        MainWindow.ErrorDialog.ShowAsync();
                    });
                }

                File.WriteAllText(queueFile, string.Join(",", queuedPkgs));
                await ReceiveMSMQ();
            }
        }
Пример #11
0
        public async Task <HashSet <string> > GetDownloadableDependencies(HashSet <string> globalDependencies, HashSet <string> existing, MainWindow mw)
        {
            InstalledPackages = SqLiteAdapter.LoadInstalledPackages();

            HashSet <string> allDownloadableDeps = await WebWrapper.QueryArray("listFiles");

            HashSet <string> conflictDeps = existing.Intersect(allDownloadableDeps).Except(InstalledPackages.SelectMany(x => x.FilesContained)).ToHashSet();

            HashSet <int> conflictPackages = new HashSet <int>();

            int maxThreads = Math.Min(Environment.ProcessorCount, conflictDeps.Count);

            Parallel.For(0, maxThreads, workerId =>
            {
                Task.Run(async() =>
                {
                    int max = conflictDeps.Count * (workerId + 1) / maxThreads;
                    for (int i = conflictDeps.Count * workerId / maxThreads; i < max; i++)
                    {
                        List <int> packages = await FindFile(conflictDeps.ElementAt(i), false);

                        Trace.Assert(packages.Count > 0, $"FindFile for {conflictDeps.ElementAt(i)} returned no packages!");

                        if (packages.Count > 0)
                        {
                            int id = packages.First();
                            lock (conflictPackages)
                            {
                                if (conflictPackages.Contains(id))
                                {
                                    continue;
                                }

                                conflictPackages.Add(id);
                            }
                        }
                    }
                }).Wait();
            });

            bool rewriteAll = false;
            bool keepAll    = false;

            for (int i = 0; i < conflictPackages.Count; i++)
            {
                int id = conflictPackages.ElementAt(i);

                if (Settings.Default.IgnoredPackages?.Contains(id) == true)
                {
                    continue;
                }

                Package p = CachedPackages.FirstOrDefault(x => x.PackageId == id);

                bool rewrite = false;
                if (!rewriteAll && !keepAll)
                {
                    Task <ContentDialogResult> t = null;
                    mw.Dispatcher.Invoke(() =>
                    {
                        MainWindow.ContentDialog = new ConflictPackageDialog(p.DisplayName);
                        t = MainWindow.ContentDialog.ShowAsync();
                    });

                    ContentDialogResult result = await t;

                    ConflictPackageDialog dlg = (ConflictPackageDialog)MainWindow.ContentDialog;

                    rewrite    = dlg.RewriteLocal;
                    rewriteAll = dlg.RewriteAll;
                    keepAll    = dlg.KeepAll;
                }

                if (rewrite || rewriteAll)
                {
                    PkgsToDownload.Add(id);
                    HashSet <int> depsPkgs = new HashSet <int>();
                    await GetDependencies(new HashSet <int>() { id }, depsPkgs);

                    PkgsToDownload.UnionWith(depsPkgs);
                }
                else
                {
                    if (Settings.Default.IgnoredPackages == null)
                    {
                        Settings.Default.IgnoredPackages = new List <int>();
                    }

                    Settings.Default.IgnoredPackages.Add(id);
                    Settings.Default.Save();
                }
            }

            CheckUpdates();

            DownloadableDeps = allDownloadableDeps.Intersect(globalDependencies).ToHashSet();
            return(DownloadableDeps);
        }
Пример #12
0
 public override IQueryable <IPackage> GetPackages()
 {
     return(CachedPackages.AsQueryable());
 }
Пример #13
0
        public async Task ReceiveMSMQ()
        {
            string           queueFile  = Path.Combine(Path.GetTempPath(), "DLS.queue");
            HashSet <string> queuedPkgs = File.Exists(queueFile) ? File.ReadAllText(queueFile).Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToHashSet() : new HashSet <string>();

            if (queuedPkgs.Count > 0)
            {
                MainWindow.Dispatcher.Invoke(() => { MainWindow.Activate(); });
                if (!await Utils.CheckLogin(async delegate
                {
                    await ReceiveMSMQ();
                    MSMQRunning = false;
                }, MainWindow, ApiUrl) || App.IsDownloading)
                {
                    //File.WriteAllText(queueFile, string.Empty);
                    return;
                }

                int idToDownload = Convert.ToInt32(queuedPkgs.PopOne());

                if (!InstalledPackages.Exists(x => x.PackageId == idToDownload))
                {
                    Task.Run(async() =>
                    {
                        Package packageToDownload = await WebWrapper.GetPackage(idToDownload);
                        lock (CachedPackages)
                        {
                            if (!CachedPackages.Any(x => x.PackageId == packageToDownload.PackageId))
                            {
                                CachedPackages.Add(packageToDownload);
                            }
                        }

                        if (packageToDownload.IsPaid)
                        {
                            App.Window.Dispatcher.Invoke(() =>
                            {
                                MainWindow.ErrorDialog = new ContentDialog()
                                {
                                    Title               = Localization.Strings.CantDownload,
                                    Content             = Localization.Strings.PaidPackageFail,
                                    SecondaryButtonText = Localization.Strings.Ok,
                                    Owner               = App.Window
                                };

                                MainWindow.ErrorDialog.ShowAsync();
                            });

                            return;
                        }

                        HashSet <int> depsPkgs = new HashSet <int>();
                        await GetDependencies(new HashSet <int>()
                        {
                            packageToDownload.PackageId
                        }, depsPkgs);
                        HashSet <int> packageIds = new HashSet <int>()
                        {
                            packageToDownload.PackageId
                        }.Union(depsPkgs).ToHashSet();

                        if (packageIds.Count > 0)
                        {
                            App.IsDownloading = true;
                            MainWindow.Dispatcher.Invoke(() => { MainWindow.DownloadDialog.ShowAsync(); });
                            await MainWindow.DownloadDialog.DownloadPackages(packageIds, CachedPackages, InstalledPackages, WebWrapper, SqLiteAdapter);
                            App.IsDownloading = false;
                        }
                        else
                        {
                            new Task(() =>
                            {
                                App.Window.Dispatcher.Invoke(() =>
                                {
                                    MainWindow.ErrorDialog = new ContentDialog()
                                    {
                                        Title               = Localization.Strings.CantDownload,
                                        Content             = Localization.Strings.InstalFail,
                                        SecondaryButtonText = Localization.Strings.Ok,
                                        Owner               = App.Window
                                    };

                                    MainWindow.ErrorDialog.ShowAsync();
                                });
                            }).Start();
                        }
                    }).Wait();
                }
                else
                {
                    App.Window.Dispatcher.Invoke(() =>
                    {
                        MainWindow.ErrorDialog = new ContentDialog()
                        {
                            Title               = Localization.Strings.CantDownload,
                            Content             = Localization.Strings.AlreadyInstalFail,
                            SecondaryButtonText = Localization.Strings.Ok,
                            Owner               = App.Window
                        };

                        MainWindow.ErrorDialog.ShowAsync();
                    });
                }

                File.WriteAllText(queueFile, string.Join(",", queuedPkgs));
                await ReceiveMSMQ();
            }
        }
Пример #14
0
        public async Task ResolveConflicts()
        {
            HashSet <string> conflictDeps = MainWindow.RW.AllInstalledDeps.Intersect(DownloadableDeps).Except(InstalledPackages.SelectMany(x => x.FilesContained)).ToHashSet();

            HashSet <int> conflictPackages = new HashSet <int>();

            while (conflictDeps.Count > 0)
            {
                Package pkg = CachedPackages.First(x => x.FilesContained.Contains(conflictDeps.First()));
                conflictPackages.Add(pkg.PackageId);
                conflictDeps.ExceptWith(pkg.FilesContained);
            }

            //HashSet<int> conflictPackages = conflictPkgs.Select(x => x.PackageId).ToHashSet();

            bool rewriteAll = false;
            bool keepAll    = false;

            for (int i = 0; i < conflictPackages.Count; i++)
            {
                int id = conflictPackages.ElementAt(i);

                if (Settings.Default.IgnoredPackages?.Contains(id) == true)
                {
                    continue;
                }

                Package p = CachedPackages.FirstOrDefault(x => x.PackageId == id);

                bool rewrite = false;
                if (!rewriteAll && !keepAll)
                {
                    Task <ContentDialogResult> t = null;
                    MainWindow.Dispatcher.Invoke(() =>
                    {
                        MainWindow.ContentDialog = new ConflictPackageDialog(p.DisplayName);
                        t = MainWindow.ContentDialog.ShowAsync();
                    });

                    ContentDialogResult result = await t;

                    ConflictPackageDialog dlg = (ConflictPackageDialog)MainWindow.ContentDialog;

                    rewrite    = dlg.RewriteLocal;
                    rewriteAll = dlg.RewriteAll;
                    keepAll    = dlg.KeepAll;
                }

                if (rewrite || rewriteAll)
                {
                    PkgsToDownload.Add(id);
                    HashSet <int> depsPkgs = new HashSet <int>();
                    await GetDependencies(new HashSet <int>() { id }, depsPkgs);

                    PkgsToDownload.UnionWith(depsPkgs);
                }
                else
                {
                    if (Settings.Default.IgnoredPackages == null)
                    {
                        Settings.Default.IgnoredPackages = new List <int>();
                    }

                    Settings.Default.IgnoredPackages.Add(id);
                    Settings.Default.Save();
                }
            }
        }
Пример #15
0
        public async Task VerifyCache()
        {
            List <Package> localCache = SqLiteAdapter.LoadPackages(true);

            ServerVersions = new Dictionary <int, int>();
            localCache.ForEach(x => ServerVersions[x.PackageId] = x.Version);
            Tuple <IEnumerable <Package>, HashSet <int> > tRemoteCache = await WebWrapper.ValidateCache(ServerVersions);

            IEnumerable <Package> remoteCache    = tRemoteCache.Item1;
            HashSet <int>         remoteVersions = tRemoteCache.Item2;

            lock (CachedPackages)
            {
                CachedPackages = remoteCache.ToList();
                localCache.ForEach(x =>
                {
                    if (!remoteVersions.Contains(x.PackageId))
                    {
                        CachedPackages.Add(x);
                    }
                    else
                    {
                        ServerVersions[x.PackageId] = CachedPackages.First(y => y.PackageId == x.PackageId).Version;
                    }
                });
                foreach (Package pkg in remoteCache)
                {
                    ServerVersions[pkg.PackageId] = pkg.Version;
                }
            }
            if (remoteVersions.Count > 0)
            {
                new Task(() =>
                {
                    foreach (Package pkg in CachedPackages)
                    {
                        SqLiteAdapter.SavePackage(pkg, true);
                    }
                    SqLiteAdapter.FlushToFile(true);
                }).Start();
            }
            CachedPackages.ForEach(x =>
            {
                if (x.IsPaid)
                {
                    x.FilesContained.ForEach(y =>
                    {
                        DownloadablePaidDepsPackages[y] = x.PackageId;
                        DownloadablePaidDeps.Add(y);
                    });
                }
                else
                {
                    x.FilesContained.ForEach(y =>
                    {
                        DownloadableDepsPackages[y] = x.PackageId;
                        DownloadableDeps.Add(y);
                    });
                }
            });
        }
Пример #16
0
 /// <summary>
 /// Package by ID
 /// </summary>
 /// <param name="pkgId">Package ID</param>
 /// <returns>Package</returns>
 public static JsonPackage GetPackage(string pkgId)
 {
     return(CachedPackages.FirstOrDefault(pkg => pkg.Id == pkgId));
 }