public NugetPackagePluginCatalog(string packageName, string packageVersion = null, bool includePrerelease                     = false, NuGetFeed packageFeed = null,
                                         string packagesFolder             = null, Action <TypeFinderCriteriaBuilder> configureFinder = null, Dictionary <string, TypeFinderCriteria> criterias = null,
                                         NugetPluginCatalogOptions options = null)
        {
            _packageName       = packageName;
            _packageVersion    = packageVersion;
            _includePrerelease = includePrerelease;
            _packageFeed       = packageFeed;

            PackagesFolder = packagesFolder ?? Path.Combine(Path.GetTempPath(), "NugetPackagePluginCatalog", Path.GetRandomFileName());

            if (!Directory.Exists(PackagesFolder))
            {
                Directory.CreateDirectory(PackagesFolder);
            }

            if (criterias == null)
            {
                criterias = new Dictionary <string, TypeFinderCriteria>();
            }

            _typeFinderCriterias = criterias;
            _options             = options ?? new NugetPluginCatalogOptions();

            if (configureFinder != null)
            {
                var builder = new TypeFinderCriteriaBuilder();
                configureFinder(builder);

                var criteria = builder.Build();

                _typeFinderCriterias.Add("", criteria);
            }
        }
        public FolderPluginCatalog(string folderPath, Action <TypeFinderCriteriaBuilder> configureFinder, TypeFinderCriteria finderCriteria,
                                   FolderPluginCatalogOptions options)
        {
            if (string.IsNullOrWhiteSpace(folderPath))
            {
                throw new ArgumentNullException(nameof(folderPath));
            }

            _folderPath = folderPath;
            _options    = options ?? new FolderPluginCatalogOptions();

            if (configureFinder != null)
            {
                var builder = new TypeFinderCriteriaBuilder();
                configureFinder(builder);

                var criteria = builder.Build();

                _options.TypeFinderCriterias.Add("", criteria);
            }

            if (finderCriteria != null)
            {
                _options.TypeFinderCriterias.Add("", finderCriteria);
            }

            if (_options.TypeFinderCriteria != null)
            {
                _options.TypeFinderCriterias.Add("", _options.TypeFinderCriteria);
            }
        }
        public FolderPluginCatalog(string folderPath, Action <TypeFinderCriteriaBuilder> configureFinder, TypeFinderCriteria finderCriteria,
                                   FolderPluginCatalogOptions options)
        {
            if (string.IsNullOrWhiteSpace(folderPath))
            {
                throw new ArgumentNullException(nameof(folderPath));
            }

            _folderPath = folderPath;
            _options    = options ?? new FolderPluginCatalogOptions();

            if (_options.TypeFinderOptions == null)
            {
                _options.TypeFinderOptions = new TypeFinderOptions();
            }

            if (_options.TypeFinderOptions.TypeFinderCriterias == null)
            {
                _options.TypeFinderOptions.TypeFinderCriterias = new List <TypeFinderCriteria>();
            }

            if (configureFinder != null)
            {
                var builder = new TypeFinderCriteriaBuilder();
                configureFinder(builder);

                var criteria = builder.Build();

                _options.TypeFinderOptions.TypeFinderCriterias.Add(criteria);
            }

            if (finderCriteria != null)
            {
                _options.TypeFinderOptions.TypeFinderCriterias.Add(finderCriteria);
            }

            if (_options.TypeFinderCriteria != null)
            {
                _options.TypeFinderOptions.TypeFinderCriterias.Add(_options.TypeFinderCriteria);
            }

            if (_options.TypeFinderCriterias?.Any() == true)
            {
                foreach (var typeFinderCriteria in _options.TypeFinderCriterias)
                {
                    var crit = typeFinderCriteria.Value;
                    crit.Tags = new List <string>()
                    {
                        typeFinderCriteria.Key
                    };

                    _options.TypeFinderOptions.TypeFinderCriterias.Add(crit);
                }
            }
        }
        private void SetFilters(Predicate <Type> filter, Dictionary <string, Predicate <Type> > taggedFilters, TypeFinderCriteria criteria,
                                Action <TypeFinderCriteriaBuilder> configureFinder)
        {
            if (_options.TypeFinderCriterias == null)
            {
                _options.TypeFinderCriterias = new Dictionary <string, TypeFinderCriteria>();
            }

            if (filter != null)
            {
                var filterCriteria = new TypeFinderCriteria {
                    Query = (context, type) => filter(type)
                };

                _options.TypeFinderCriterias.Add(string.Empty, filterCriteria);
            }

            if (taggedFilters?.Any() == true)
            {
                foreach (var taggedFilter in taggedFilters)
                {
                    var taggedCriteria = new TypeFinderCriteria {
                        Query = (context, type) => taggedFilter.Value(type)
                    };

                    _options.TypeFinderCriterias.Add(taggedFilter.Key, taggedCriteria);
                }
            }

            if (configureFinder != null)
            {
                var builder = new TypeFinderCriteriaBuilder();
                configureFinder(builder);

                var configuredCriteria = builder.Build();

                _options.TypeFinderCriterias.Add("", configuredCriteria);
            }

            if (criteria != null)
            {
                _options.TypeFinderCriterias.Add("", criteria);
            }

            if (_options.TypeFinderCriterias?.Any() != true)
            {
                var findAll = TypeFinderCriteriaBuilder
                              .Create()
                              .Build();

                _options.TypeFinderCriterias.Add(string.Empty, findAll);
            }
        }
Esempio n. 5
0
        public NugetFeedPluginCatalog(NuGetFeed packageFeed, string searchTerm = null,
                                      bool includePrereleases = false, int maxPackages = 128,
                                      string packagesFolder   = null, Action <TypeFinderCriteriaBuilder> configureFinder = null, Dictionary <string, TypeFinderCriteria> criterias = null,
                                      NugetFeedPluginCatalogOptions options = null)
        {
            _packageFeed        = packageFeed;
            _searchTerm         = searchTerm;
            _includePrereleases = includePrereleases;
            _maxPackages        = maxPackages;

            PackagesFolder = packagesFolder ?? Path.Combine(Path.GetTempPath(), "NugetFeedPluginCatalog", Path.GetRandomFileName());

            if (!Directory.Exists(PackagesFolder))
            {
                Directory.CreateDirectory(PackagesFolder);
            }

            if (criterias == null)
            {
                criterias = new Dictionary <string, TypeFinderCriteria>();
            }

            _options = options ?? new NugetFeedPluginCatalogOptions();

            if (configureFinder != null)
            {
                var builder = new TypeFinderCriteriaBuilder();
                configureFinder(builder);

                var criteria = builder.Build();

                _options.TypeFinderOptions.TypeFinderCriterias.Add(criteria);
            }

            foreach (var finderCriteria in criterias)
            {
                finderCriteria.Value.Tags = new List <string>()
                {
                    finderCriteria.Key
                };

                _options.TypeFinderOptions.TypeFinderCriterias.Add(finderCriteria.Value);
            }
        }