public string[] GetInstalledThemes() { return(extensionManager.AvailableExtensions() .Where(x => DefaultExtensionTypes.IsTheme(x.ExtensionType) && shellDescriptor.Features.Any(y => y.Name == x.Name)) .Select(x => x.Name) .ToArray()); }
public void AvailableExtensionsShouldFollowCatalogLocations() { _folders.Manifests.Add("foo", "Name: Foo"); _folders.Manifests.Add("bar", "Name: Bar"); _folders.Manifests.Add("frap", "Name: Frap"); _folders.Manifests.Add("quad", "Name: Quad"); var available = _manager.AvailableExtensions(); Assert.That(available.Count(), Is.EqualTo(4)); Assert.That(available, Has.Some.Property("Id").EqualTo("foo")); }
public void AvailableExtensionsShouldFollowCatalogLocations() { _folders.Manifests.Add("foo", "Name: Foo"); _folders.Manifests.Add("bar", "Name: Bar"); _folders.Manifests.Add("frap", "Name: Frap"); _folders.Manifests.Add("quad", "Name: Quad"); var available = _manager.AvailableExtensions(); Assert.Equal(available.Count(), 4); Assert.Contains(available, t => t.Id == "foo"); }
public ActionResult Index(ModulesIndexOptions options, PagerParameters pagerParameters) { if (!Services.Authorizer.Authorize(StandardPermissions.SiteOwner, T("Not allowed to manage modules"))) { return(new HttpUnauthorizedResult()); } Pager pager = new Pager(Services.WorkContext.CurrentSite, pagerParameters); IEnumerable <ModuleEntry> modules = _extensionManager.AvailableExtensions() .Where(extensionDescriptor => DefaultExtensionTypes.IsModule(extensionDescriptor.ExtensionType) && (string.IsNullOrEmpty(options.SearchText) || extensionDescriptor.Name.ToLowerInvariant().Contains(options.SearchText.ToLowerInvariant()))) .OrderBy(extensionDescriptor => extensionDescriptor.Name) .Select(extensionDescriptor => new ModuleEntry { Descriptor = extensionDescriptor }); int totalItemCount = modules.Count(); if (pager.PageSize != 0) { modules = modules.Skip((pager.Page - 1) * pager.PageSize).Take(pager.PageSize); } // This way we can more or less reliably handle this implicit dependency. var installModules = _featureManager.GetEnabledFeatures().FirstOrDefault(f => f.Id == "PackagingServices") != null; modules = modules.ToList(); foreach (ModuleEntry moduleEntry in modules) { moduleEntry.IsRecentlyInstalled = _moduleService.IsRecentlyInstalled(moduleEntry.Descriptor); moduleEntry.CanUninstall = installModules; if (_extensionDisplayEventHandler != null) { foreach (string notification in _extensionDisplayEventHandler.Displaying(moduleEntry.Descriptor, ControllerContext.RequestContext)) { moduleEntry.Notifications.Add(notification); } } } return(View(new ModulesIndexViewModel { Modules = modules, InstallModules = installModules, Options = options, Pager = Shape.Pager(pager).TotalItemCount(totalItemCount) })); }
public PackageData Harvest(string extensionName) { ExtensionDescriptor extensionDescriptor = _extensionManager.AvailableExtensions().FirstOrDefault(x => x.Id == extensionName); if (extensionDescriptor == null) { return(null); } return(new PackageData { ExtensionType = extensionDescriptor.ExtensionType, ExtensionName = extensionDescriptor.Id, ExtensionVersion = extensionDescriptor.Version, PackageStream = _packageBuilder.BuildPackage(extensionDescriptor), }); }
public async Task <ActionResult> Index() { IEnumerable <ModuleEntry> modules = _extensionManager.AvailableExtensions() .Where(extensionDescriptor => DefaultExtensionTypes.IsModule(extensionDescriptor.ExtensionType)) .OrderBy(extensionDescriptor => extensionDescriptor.Name) .Select(extensionDescriptor => new ModuleEntry { Descriptor = extensionDescriptor }); var features = await _featureManager.GetEnabledFeaturesAsync(); var installModules = features.FirstOrDefault(f => f.Id == "PackagingServices") != null; modules = modules.ToList(); foreach (ModuleEntry moduleEntry in modules) { moduleEntry.IsRecentlyInstalled = false; //_moduleService.IsRecentlyInstalled(moduleEntry.Descriptor); moduleEntry.CanUninstall = installModules; //if (_extensionDisplayEventHandler != null) //{ // foreach (string notification in _extensionDisplayEventHandler.Displaying(moduleEntry.Descriptor, ControllerContext.RequestContext)) // { // moduleEntry.Notifications.Add(notification); // } //} } var model = new ModulesIndexViewModel { Modules = modules, InstallModules = installModules }; return(View(model)); }
private IEnumerable <UpdatePackageEntry> GetPackagesWorker(PackagingSource packagingSource) { var list = new Dictionary <string, UpdatePackageEntry>(StringComparer.OrdinalIgnoreCase); var extensions = _extensionManager.AvailableExtensions(); foreach (var extension in extensions) { var packageId = PackageBuilder.BuildPackageId(extension.Id, extension.ExtensionType); GetOrAddEntry(list, packageId).ExtensionsDescriptor = extension; } var packages = _packagingSourceManager.GetExtensionList(false, packagingSource) .ToList() .GroupBy(p => p.PackageId, StringComparer.OrdinalIgnoreCase); foreach (var package in packages) { var entry = GetOrAddEntry(list, package.Key); entry.PackageVersions = entry.PackageVersions.Concat(package).ToList(); } return(list.Values.Where(e => e.ExtensionsDescriptor != null && e.PackageVersions.Any())); }
public void ExtensionManagerShouldLoadFeatures() { var extensionLoader = new StubLoaders(); var folders = new StubExtensionLocator(); folders.Manifests.Add("TestModule", @" Name: TestModule Version: 1.0.3 OrchardVersion: 1 Features: TestModule: Description: My test module for Orchard. TestFeature: Description: Contains the Phi type. "); IExtensionManager extensionManager = CreateExtensionManager(folders, extensionLoader); var testFeature = extensionManager.AvailableExtensions() .SelectMany(x => x.Features); var features = extensionManager.LoadFeatures(testFeature); var types = features.SelectMany(x => x.ExportedTypes); Assert.NotEqual(0, types.Count()); }
public void ExtensionManagerLoadFeatureReturnsTypesFromSpecificFeaturesWithFeatureAttribute() { var extensionLoader = new StubLoaders(); var extensionFolder = new StubFolders(); extensionFolder.Manifests.Add("TestModule", @" Name: TestModule Version: 1.0.3 OrchardVersion: 1 Features: TestModule: Description: My test module for Orchard. TestFeature: Description: Contains the Phi type. "); IExtensionManager extensionManager = CreateExtensionManager(extensionFolder, extensionLoader); var testFeature = extensionManager.AvailableExtensions() .SelectMany(x => x.Features) .Single(x => x.Id == "TestFeature"); foreach (var feature in extensionManager.LoadFeatures(new[] { testFeature })) { foreach (var type in feature.ExportedTypes) { Assert.That(type == typeof(Phi)); } } }
public void ExtensionManagerFeaturesContainNonAbstractClasses() { var extensionLoader = new StubLoaders(); var folders = new StubExtensionLocator(); folders.Manifests.Add("TestModule", @" Name: TestModule Version: 1.0.3 OrchardVersion: 1 Features: TestModule: Description: My test module for Orchard. TestFeature: Description: Contains the Phi type. "); IExtensionManager extensionManager = CreateExtensionManager(folders, extensionLoader); var testFeature = extensionManager.AvailableExtensions() .SelectMany(x => x.Features); var features = extensionManager.LoadFeatures(testFeature); var types = features.SelectMany(x => x.ExportedTypes); foreach (var type in types) { Assert.True(type.GetTypeInfo().IsClass); Assert.True(!type.GetTypeInfo().IsAbstract); } }
public void ExtensionManagerLoadFeatureDoesNotReturnTypesFromNonMatchingFeatures() { var extensionLoader = new StubLoaders(); var extensionFolder = new StubFolders(DefaultExtensionTypes.Module); extensionFolder.Manifests.Add("TestModule", @" Name: TestModule Version: 1.0.3 SystemVersion: 1 Features: TestModule: Description: My test module for System. TestFeature: Description: Contains the Phi type. "); IExtensionManager extensionManager = CreateExtensionManager(extensionFolder, extensionLoader); var testModule = extensionManager.AvailableExtensions() .SelectMany(x => x.Features) .Single(x => x.Id == "TestModule"); foreach (var feature in extensionManager.LoadFeatures(new[] { testModule })) { foreach (var type in feature.ExportedTypes) { Assert.True(type != typeof(Phi)); Assert.True((type == typeof(Alpha) || (type == typeof(Beta)))); } } }
public void ExtensionManagerFeaturesContainNonAbstractClasses() { var extensionLoader = new StubLoaders(); var extensionFolder = new StubFolders(DefaultExtensionTypes.Module); extensionFolder.Manifests.Add("TestModule", @" Name: TestModule Version: 1.0.3 SystemVersion: 1 Features: TestModule: Description: My test module for System. TestFeature: Description: Contains the Phi type. "); IExtensionManager extensionManager = CreateExtensionManager(extensionFolder, extensionLoader); var testFeature = extensionManager.AvailableExtensions() .SelectMany(x => x.Features); var features = extensionManager.LoadFeatures(testFeature); var types = features.SelectMany(x => x.ExportedTypes); foreach (var type in types) { Assert.True(type.IsClass); Assert.True(!type.IsAbstract); } }
public void ExtensionManagerTestFeatureAttribute() { var extensionLoader = new StubLoaders(); var extensionFolder = new StubFolders(DefaultExtensionTypes.Module); extensionFolder.Manifests.Add("TestModule", @" Name: TestModule Version: 1.0.3 SystemVersion: 1 Features: TestModule: Description: My test module for System. TestFeature: Description: Contains the Phi type. "); IExtensionManager extensionManager = CreateExtensionManager(extensionFolder, extensionLoader); var testFeature = extensionManager.AvailableExtensions() .SelectMany(x => x.Features) .Single(x => x.Id == "TestFeature"); foreach (var feature in extensionManager.LoadFeatures(new[] { testFeature })) { foreach (var type in feature.ExportedTypes) { foreach (SystemFeatureAttribute featureAttribute in type.GetCustomAttributes(typeof(SystemFeatureAttribute), false)) { Assert.Equal(featureAttribute.FeatureName, "TestFeature"); } } } }
private bool ModuleAlreadyInstalled(string packageId) { return(_extensionManager.AvailableExtensions().Where(m => DefaultExtensionTypes.IsModule(m.ExtensionType)) .Any(module => module.Id.Equals( packageId.Substring(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Module).Length), StringComparison.OrdinalIgnoreCase))); }
public void ExtensionManagerShouldLoadFeatures() { var extensionLoader = new StubLoaders(); var extensionFolder = new StubFolders(DefaultExtensionTypes.Module); extensionFolder.Manifests.Add("TestModule", @" Name: TestModule Version: 1.0.3 SystemVersion: 1 Features: TestModule: Description: My test module for System. TestFeature: Description: Contains the Phi type. "); IExtensionManager extensionManager = CreateExtensionManager(extensionFolder, extensionLoader); var testFeature = extensionManager.AvailableExtensions() .SelectMany(x => x.Features); var features = extensionManager.LoadFeatures(testFeature); var types = features.SelectMany(x => x.ExportedTypes); Assert.NotEqual(types.Count(), 0); }
public IEnumerable <ExtensionInfo> AvailableExtensions() { return(_extensionManager.AvailableExtensions().Select(t => new ExtensionInfo() { Name = t.Name })); }
/// <summary> /// Retrieves an enumeration of the available features together with its state (enabled / disabled). /// </summary> /// <returns>An enumeration of the available features together with its state (enabled / disabled).</returns> public IEnumerable <ModuleFeature> GetAvailableFeatures() { var enabledFeatures = _shellDescriptorManager.GetShellDescriptor().Features; return(_extensionManager.AvailableExtensions() .SelectMany(m => _extensionManager.LoadFeatures(m.Features)) .Select(f => AssembleModuleFromDescriptor(f, enabledFeatures .FirstOrDefault(sf => string.Equals(sf.Name, f.Descriptor.Id, StringComparison.OrdinalIgnoreCase)) != null))); }
public ActionResult Create() { if (!CheckPermission(PagesPermissions.ManagePages)) { return(new HttpUnauthorizedResult()); } WorkContext.Breadcrumbs.Add(T("Pages"), Url.Action("Index", new { area = Constants.Areas.Pages })); WorkContext.Breadcrumbs.Add(T("Create")); var model = new PageModel { IsEnabled = true, Title = "" }; var result = new ControlFormResult <PageModel>(model) { Title = T("Create Page").Text, UpdateActionName = "Update", CssClass = "form-edit-page", ShowBoxHeader = false, FormWrapperStartHtml = Constants.Form.FormWrapperStartHtml, FormWrapperEndHtml = Constants.Form.FormWrapperEndHtml }; //result.AddAction(true, false, false).HasText(T("Preview")).HasUrl(Url.Action("Preview")).HasButtonStyle(ButtonStyle.Default); var themes = extensionManager.AvailableExtensions().Where(x => DefaultExtensionTypes.IsTheme(x.ExtensionType) && descriptor.Features.Any(f => f.Name == x.Id)).ToDictionary(k => k.Id, v => v.Name); result.RegisterExternalDataSource(x => x.Theme, themes); result.RegisterExternalDataSource(x => x.ShowOnMenuId, menuService.GetRecords().ToDictionary(k => k.Id, v => v.Name)); // Page tags var tags = pageTagService.GetRecords(); if (tags.Count > 0) { result.AddHiddenValue("RichtextCustomTags", JsonConvert.SerializeObject(tags.Select(x => new[] { x.Name, "[%" + x.Name + "%]" }))); } return(result); }
public override IQueryable <IPackage> GetPackages() { IEnumerable <IPackage> repositoryPackages = SourceRepository.GetPackages().ToList(); IEnumerable <IPackage> packages = from extension in _extensionManager.AvailableExtensions() let id = PackageBuilder.BuildPackageId(extension.Id, extension.ExtensionType) let version = extension.Version != null?Version.Parse(extension.Version) : null let package = repositoryPackages.FirstOrDefault(p => p.Id == id && (version == null || p.Version == version)) where package != null select package; return(packages.AsQueryable()); }
public void List() { var currentTheme = _siteThemeService.GetSiteTheme(); var featuresThatNeedUpdate = _dataMigrationManager.GetFeaturesThatNeedUpdate(); var themes = _extensionManager.AvailableExtensions() .Where(d => DefaultExtensionTypes.IsTheme(d.ExtensionType)) .Where(d => d.Tags != null && d.Tags.Split(',').Any(t => t.Trim().Equals("hidden", StringComparison.OrdinalIgnoreCase)) == false) .Select(d => new ThemeEntry { Descriptor = d, NeedsUpdate = featuresThatNeedUpdate.Contains(d.Id), Enabled = _shellDescriptor.Features.Any(sf => sf.Name == d.Id) }) .ToArray(); if (Summary) { foreach (var theme in themes) { Context.Output.WriteLine(T("{0}", theme.Name)); } } else { Context.Output.WriteLine(T("Current theme")); Context.Output.WriteLine(T("--------------------------")); WriteThemeLines(new ThemeEntry { Descriptor = currentTheme, NeedsUpdate = featuresThatNeedUpdate.Contains(currentTheme.Id), Enabled = _shellDescriptor.Features.Any(sf => sf.Name == currentTheme.Id) }); Context.Output.WriteLine(T("List of available themes")); Context.Output.WriteLine(T("--------------------------")); themes.Where(t => t.Name.Trim().Equals(currentTheme.Name.Trim(), StringComparison.OrdinalIgnoreCase) == false) .ToList() .ForEach(WriteThemeLines); } }
public ActionResult Index(ModulesIndexOptions options, PagerParameters pagerParameters) { if (!Services.Authorizer.Authorize(StandardPermissions.SiteOwner, T("Not allowed to manage modules"))) { return(new HttpUnauthorizedResult()); } Pager pager = new Pager(Services.WorkContext.CurrentSite, pagerParameters); IEnumerable <ModuleEntry> modules = _extensionManager.AvailableExtensions() .Where(extensionDescriptor => DefaultExtensionTypes.IsModule(extensionDescriptor.ExtensionType) && (string.IsNullOrEmpty(options.SearchText) || extensionDescriptor.Name.ToLowerInvariant().Contains(options.SearchText.ToLowerInvariant()))) .OrderBy(extensionDescriptor => extensionDescriptor.Name) .Select(extensionDescriptor => new ModuleEntry { Descriptor = extensionDescriptor }); int totalItemCount = modules.Count(); if (pager.PageSize != 0) { modules = modules.Skip((pager.Page - 1) * pager.PageSize).Take(pager.PageSize); } modules = modules.ToList(); foreach (ModuleEntry moduleEntry in modules) { moduleEntry.IsRecentlyInstalled = _moduleService.IsRecentlyInstalled(moduleEntry.Descriptor); } return(View(new ModulesIndexViewModel { Modules = modules, InstallModules = _featureManager.GetEnabledFeatures().FirstOrDefault(f => f.Id == "PackagingServices") != null, Options = options, Pager = Shape.Pager(pager).TotalItemCount(totalItemCount) })); }
public void MonitorExtensionsWork(Action <IVolatileToken> monitor) { var locations = _extensionManager.AvailableExtensions().Select(e => e.Location).Distinct(StringComparer.InvariantCultureIgnoreCase); Logger.Information("Start monitoring extension files..."); // Monitor add/remove of any module/theme foreach (string location in locations) { Logger.Debug("Monitoring virtual path \"{0}\"", location); monitor(_virtualPathMonitor.WhenPathChanges(location)); } // Give loaders a chance to monitor any additional changes var extensions = _extensionManager.AvailableExtensions().Where(d => DefaultExtensionTypes.IsModule(d.ExtensionType) || DefaultExtensionTypes.IsTheme(d.ExtensionType)).ToList(); foreach (var extension in extensions) { foreach (var loader in _loaders) { loader.Monitor(extension, monitor); } } Logger.Information("Done monitoring extension files..."); }
public ActionResult Index() { if (!Services.Authorizer.Authorize(Orchard.Themes.Permissions.ApplyTheme, T("Cannot manage themes"))) return new HttpUnauthorizedResult(); var viewModel = new ThemePickerIndexViewModel { ThemeSelectionSettings = _settingsService.Get(), ThemeSelectionRules = _rules.Select(r => r.GetType().Name), Themes = _extensionManager.AvailableExtensions() .Where(d => DefaultExtensionTypes.IsTheme(d.ExtensionType) && _shellDescriptor.Features.Any(sf => sf.Name == d.Id)) .Select(d => d.Id) .OrderBy(n => n) }; return View(viewModel); }
public IEnumerable <Recipe> Recipes() { if (_recipes == null) { var recipes = new List <Recipe>(); foreach (var extension in _extensionManager.AvailableExtensions()) { recipes.AddRange(_recipeHarvester.HarvestRecipes(extension.Id).Where(recipe => recipe.IsSetupRecipe)); } _recipes = recipes; } return(_recipes); }
public void ThemeNameIsIntroducedAsFeatureImplicitly() { var extensionLoader = new StubLoaders(); var extensionFolder = new StubFolders(DefaultExtensionTypes.Theme); extensionFolder.Manifests.Add("Minimalistic", @" Name: Minimalistic Version: 1.0.3 SystemVersion: 1 "); IExtensionManager extensionManager = CreateExtensionManager(extensionFolder, extensionLoader); var minimalisticModule = extensionManager.AvailableExtensions().Single(x => x.Id == "Minimalistic"); Assert.Equal(minimalisticModule.Features.Count(), 1); Assert.Equal(minimalisticModule.Features.Single().Id, "Minimalistic"); }
public async Task <IEnumerable <INavigationDefinition> > Filter(IEnumerable <INavigationDefinition> navigationDefinitions) { foreach (var navDef in navigationDefinitions) { var areaName = extensionManager.AvailableExtensions() .FirstOrDefault(e => e.Id == navDef.GetType().Assembly.FullName).Name; foreach (var navItem in navDef.Items) { if (!navItem.RouteValues.ContainsKey(RouteConst.area)) { navItem.RouteValues[RouteConst.area] = areaName; } } } return(navigationDefinitions); }
public void ModuleNameIsIntroducedAsFeatureImplicitly() { var extensionLoader = new StubLoaders(); var extensionFolder = new StubFolders(); extensionFolder.Manifests.Add("Minimalistic", @" Name: Minimalistic Version: 1.0.3 OrchardVersion: 1 "); IExtensionManager extensionManager = CreateExtensionManager(extensionFolder, extensionLoader); var minimalisticModule = extensionManager.AvailableExtensions().Single(x => x.Id == "Minimalistic"); Assert.That(minimalisticModule.Features.Count(), Is.EqualTo(1)); Assert.That(minimalisticModule.Features.Single().Id, Is.EqualTo("Minimalistic")); }
public bool HasLoader(string featureId) { var descriptor = _extensionManager .AvailableExtensions() .Where(d => DefaultExtensionTypes.IsModule(d.ExtensionType) || DefaultExtensionTypes.IsTheme(d.ExtensionType)) .OrderBy(d => d.Id) .FirstOrDefault(e => e.Id == featureId || e.Features.Select(f => f.Id).Contains(featureId)); foreach (var loader in _loaders) { if (loader.LoaderIsSuitable(descriptor)) { return(true); } } return(false); }
public ActionResult Import() { if (!Services.Authorizer.Authorize(Permissions.UploadTranslation)) { return(RedirectToAction("Index")); } var model = _localizationService.GetCultures(); var extensions = _extensionManager.AvailableExtensions(); ViewBag.Modules = extensions .Where(e => DefaultExtensionTypes.IsModule(e.ExtensionType)) .OrderBy(e => e.Name); ViewBag.Themes = extensions .Where(extensionDescriptor => DefaultExtensionTypes.IsTheme(extensionDescriptor.ExtensionType)) .OrderBy(e => e.Name); return(View(model)); }
public void MonitorExtensionsWork(Action <IVolatileToken> monitor) { Logger.Information("Start monitoring extension files..."); // Monitor add/remove of any module/theme monitor(_virtualPathMonitor.WhenPathChanges("~/Modules")); monitor(_virtualPathMonitor.WhenPathChanges("~/Themes")); // Give loaders a chance to monitor any additional changes var extensions = _extensionManager.AvailableExtensions().Where(d => DefaultExtensionTypes.IsModule(d.ExtensionType) || DefaultExtensionTypes.IsTheme(d.ExtensionType)).ToList(); foreach (var extension in extensions) { foreach (var loader in _loaders) { loader.Monitor(extension, monitor); } } Logger.Information("Done monitoring extension files..."); }