Esempio n. 1
0
        private async Task OpenPackageFromRepository(string searchTerm)
        {
            var canceled = AskToSaveCurrentFile();

            if (canceled)
            {
                return;
            }

            var selectedPackageInfo = PackageChooser.SelectPackage(searchTerm);

            if (selectedPackageInfo == null)
            {
                return;
            }

            if (selectedPackageInfo.IsLocalPackage)
            {
                await OpenLocalPackage(selectedPackageInfo.DownloadUrl.LocalPath);
            }
            else
            {
                var packageVersion = new NuGetVersion(selectedPackageInfo.Version);
                var cachePackage   = MachineCache.Default.FindPackage(selectedPackageInfo.Id, packageVersion);

                DispatcherOperation processPackageAction(ISignaturePackage package)
                {
                    var servicePackage = selectedPackageInfo.AsDataServicePackage();

                    servicePackage.CorePackage = package;
                    LoadPackage(servicePackage,
                                selectedPackageInfo.DownloadUrl.ToString(),
                                PackageType.DataServicePackage);

                    // adding package to the cache, but with low priority
                    return(Dispatcher.BeginInvoke(
                               (Action <IPackage>)MachineCache.Default.AddPackage,
                               DispatcherPriority.ApplicationIdle,
                               package));
                }

                if (cachePackage == null || cachePackage.GetHash() != selectedPackageInfo.PackageHash)
                {
                    var downloadedPackage = await PackageDownloader.Download(
                        selectedPackageInfo.DownloadUrl,
                        selectedPackageInfo.Id,
                        packageVersion.ToString());

                    if (downloadedPackage != null)
                    {
                        await processPackageAction(downloadedPackage);
                    }
                }
                else
                {
                    await processPackageAction(cachePackage);
                }
            }
        }
Esempio n. 2
0
        private void SelectDependencyButtonClicked(object sender, RoutedEventArgs e)
        {
            var selectedPackage = PackageChooser.SelectPackage(null);

            if (selectedPackage != null)
            {
                _newPackageDependency.Id          = selectedPackage.Id;
                _newPackageDependency.VersionSpec = VersionRange.Parse(selectedPackage.Version);
            }
        }
        private void SelectDependencyButtonClicked(object sender, RoutedEventArgs e)
        {
            PackageInfo selectedPackage = PackageChooser.SelectPackage(null);

            if (selectedPackage != null)
            {
                _newPackageDependency.Id          = selectedPackage.Id;
                _newPackageDependency.VersionSpec = NuGet.VersionUtility.ParseVersionSpec(selectedPackage.Version);
            }
        }
        private async Task OpenPackageFromRepository(string searchTerm)
        {
            var canceled = AskToSaveCurrentFile();

            if (canceled)
            {
                return;
            }

            var selectedPackageInfo = PackageChooser.SelectPackage(searchTerm);

            if (selectedPackageInfo == null)
            {
                return;
            }

            var repository = PackageChooser.Repository;

            if (repository == null)
            {
                return;
            }

            var cachePackage = MachineCache.Default.FindPackage(selectedPackageInfo.Id, selectedPackageInfo.SemanticVersion);

            DispatcherOperation processPackageAction(ISignaturePackage package)
            {
                LoadPackage(package,
                            package.Source,
                            repository.PackageSource.Source,
                            PackageType.RemotePackage);

                // adding package to the cache, but with low priority
                return(Dispatcher.BeginInvoke(
                           (Action <IPackage>)MachineCache.Default.AddPackage,
                           DispatcherPriority.ApplicationIdle,
                           package));
            }

            if (cachePackage == null)
            {
                var downloadedPackage = await PackageDownloader.Download(
                    repository,
                    selectedPackageInfo.Identity);

                if (downloadedPackage != null)
                {
                    await processPackageAction(downloadedPackage);
                }
            }
            else
            {
                await processPackageAction(cachePackage);
            }
        }
Esempio n. 5
0
        private void SelectDependencyButtonClicked(object sender, RoutedEventArgs e)
        {
            DiagnosticsClient.TrackEvent("PackageDependencyEditor_SelectDependencyButtonClicked");

            var selectedPackage = PackageChooser.SelectPackage(null);

            if (selectedPackage != null)
            {
                _newPackageDependency.Id          = selectedPackage.Id;
                _newPackageDependency.VersionSpec = VersionRange.Parse(selectedPackage.Version);
            }
        }