protected override void Resolve(ILifetimeScope container) { _compositionStrategy = container.Resolve<CompositionStrategy>(); _compositionStrategy.Logger = container.Resolve<ILogger>(); var alphaExtension = new ExtensionDescriptor { Id = "Alpha", Name = "Alpha", ExtensionType = "Module" }; var alphaFeatureDescriptor = new FeatureDescriptor { Id = "Alpha", Name = "Alpha", Extension = alphaExtension }; var betaFeatureDescriptor = new FeatureDescriptor { Id = "Beta", Name = "Beta", Extension = alphaExtension, Dependencies = new List<string> { "Alpha" } }; alphaExtension.Features = new List<FeatureDescriptor> { alphaFeatureDescriptor, betaFeatureDescriptor }; _availableExtensions = new[] { alphaExtension }; _installedFeatures = new List<Feature> { new Feature { Descriptor = alphaFeatureDescriptor, ExportedTypes = new List<Type> { typeof(AlphaDependency) } }, new Feature { Descriptor = betaFeatureDescriptor, ExportedTypes = new List<Type> { typeof(BetaDependency) } } }; _loggerMock.Setup(x => x.IsEnabled(It.IsAny<LogLevel>())).Returns(true); _extensionManager.Setup(x => x.AvailableExtensions()).Returns(() => _availableExtensions); _extensionManager.Setup(x => x.AvailableFeatures()).Returns(() => _extensionManager.Object.AvailableExtensions() .SelectMany(ext => ext.Features) .ToReadOnlyCollection()); _extensionManager.Setup(x => x.LoadFeatures(It.IsAny<IEnumerable<FeatureDescriptor>>())).Returns(() => _installedFeatures); }
private void ProcessPlacementFile(ShapeTableBuilder builder, FeatureDescriptor featureDescriptor, PlacementFile placementFile) { var feature = new Feature { Descriptor = featureDescriptor }; // invert the tree into a list of leaves and the stack var entries = DrillDownShapeLocations(placementFile.Nodes, Enumerable.Empty<PlacementMatch>()); foreach (var entry in entries) { var shapeLocation = entry.Item1; var matches = entry.Item2; string shapeType; string differentiator; GetShapeType(shapeLocation, out shapeType, out differentiator); Func<ShapePlacementContext, bool> predicate = ctx => true; if (differentiator != "") { predicate = ctx => (ctx.Differentiator ?? "") == differentiator; } if (matches.Any()) { predicate = matches.SelectMany(match => match.Terms).Aggregate(predicate, BuildPredicate); } var placement = new PlacementInfo(); var segments = shapeLocation.Location.Split(';').Select(s => s.Trim()); foreach (var segment in segments) { if (!segment.Contains('=')) { placement.Location = segment; } else { var index = segment.IndexOf('='); var property = segment.Substring(0, index).ToLower(); var value = segment.Substring(index + 1); switch (property) { case "shape": placement.ShapeType = value; break; case "alternate": placement.Alternates = new[] { value }; break; case "wrapper": placement.Wrappers = new[] { value }; break; } } } builder.Describe(shapeType) .From(feature) .Placement(ctx => { var hit = predicate(ctx); // generate 'debugging' information to trace which file originated the actual location if (hit) { var virtualPath = featureDescriptor.Extension.Location + "/" + featureDescriptor.Extension.Id + "/Placement.info"; ctx.Source = virtualPath; } return hit; }, placement); } }
private void ProcessFeatureDescriptor(ShapeTableBuilder builder, FeatureDescriptor featureDescriptor) { var virtualPath = featureDescriptor.Extension.Location + "/" + featureDescriptor.Extension.Id + "/Placement.info"; var placementFile = _placementFileParser.Parse(virtualPath); if (placementFile != null) { ProcessPlacementFile(builder, featureDescriptor, placementFile); } }
public override void Register(ContainerBuilder builder) { var mockFeatureManager = new Mock<IFeatureManager>(); var theme1 = new FeatureDescriptor {Extension = new ExtensionDescriptor { Zones = ThemeZoneName1, ExtensionType = "Theme" }}; var theme2 = new FeatureDescriptor { Extension = new ExtensionDescriptor { Zones = ThemeZoneName2, ExtensionType = "Theme" } }; var theme3 = new FeatureDescriptor { Extension = new ExtensionDescriptor { Zones = DuplicateZoneNames, ExtensionType = "Theme" } }; var module1 = new FeatureDescriptor { Extension = new ExtensionDescriptor { Zones = "DontSeeMeBecauseIAmNotATheme", ExtensionType = "Module" } }; mockFeatureManager.Setup(x => x.GetEnabledFeatures()) .Returns(new[] { theme1, theme2, theme3, module1 }); builder.RegisterType<DefaultContentManager>().As<IContentManager>(); builder.RegisterType<StubCacheManager>().As<ICacheManager>(); builder.RegisterType<Signals>().As<ISignals>(); builder.RegisterType<DefaultContentManagerSession>().As<IContentManagerSession>(); builder.RegisterInstance(new Mock<IContentDefinitionManager>().Object); builder.RegisterInstance(new Mock<ITransactionManager>().Object); builder.RegisterInstance(new Mock<IAuthorizer>().Object); builder.RegisterInstance(new Mock<INotifier>().Object); builder.RegisterInstance(mockFeatureManager.Object); builder.RegisterType<OrchardServices>().As<IOrchardServices>(); builder.RegisterType<DefaultShapeTableManager>().As<IShapeTableManager>(); builder.RegisterType<DefaultShapeFactory>().As<IShapeFactory>(); builder.RegisterType<WidgetsService>().As<IWidgetsService>(); builder.RegisterType<StubExtensionManager>().As<IExtensionManager>(); builder.RegisterType<StubWidgetPartHandler>().As<IContentHandler>(); builder.RegisterType<StubLayerPartHandler>().As<IContentHandler>(); builder.RegisterType<DefaultContentQuery>().As<IContentQuery>(); builder.RegisterInstance(new Mock<IPageClassBuilder>().Object); builder.RegisterType<DefaultContentDisplay>().As<IContentDisplay>(); }
private void ProcessFeatureDescriptor(ShapeTableBuilder builder, FeatureDescriptor featureDescriptor) { var virtualPath = _fileSystem .GetExtensionFileProvider(featureDescriptor.Extension, _logger) .GetFileInfo("Placement.info"); var placementFile = _placementFileParser.Parse(virtualPath); if (placementFile != null) { ProcessPlacementFile(builder, featureDescriptor, placementFile); } }
/// <summary> /// Returns true if the item has an explicit or implicit dependency on the subject /// </summary> /// <param name="item"></param> /// <param name="subject"></param> /// <returns></returns> internal static bool HasDependency(FeatureDescriptor item, FeatureDescriptor subject) { if (DefaultExtensionTypes.IsTheme(item.Extension.ExtensionType)) { if (DefaultExtensionTypes.IsModule(subject.Extension.ExtensionType)) { // Themes implicitly depend on modules to ensure build and override ordering return true; } if (DefaultExtensionTypes.IsTheme(subject.Extension.ExtensionType)) { // Theme depends on another if it is its base theme return item.Extension.BaseTheme == subject.Id; } } // Return based on explicit dependencies return item.Dependencies != null && item.Dependencies.Any(x => StringComparer.OrdinalIgnoreCase.Equals(x, subject.Id)); }
private void ProcessFeatureDescriptor(ShapeTableBuilder builder, FeatureDescriptor featureDescriptor) { var virtualPath = _fileSystem .GetExtensionFileProvider(featureDescriptor.Extension, _logger) .GetFileInfo("placement.json"); if (virtualPath.Exists) { using (var stream = virtualPath.CreateReadStream()) { using (var reader = new StreamReader(stream)) { using (var jtr = new JsonTextReader(reader)) { JsonSerializer serializer = new JsonSerializer(); var placementFile = serializer.Deserialize<PlacementFile>(jtr); ProcessPlacementFile(builder, featureDescriptor, placementFile); } } } } }
private void ProcessPlacementFile(ShapeTableBuilder builder, FeatureDescriptor featureDescriptor, PlacementFile placementFile) { var feature = new Feature { Descriptor = featureDescriptor }; foreach (var entry in placementFile) { var shapeType = entry.Key; var matches = entry.Value; foreach (var filter in entry.Value) { var placement = new PlacementInfo(); placement.Location = filter.Location; placement.Alternates = filter.Alternates; placement.Wrappers = filter.Wrappers; placement.ShapeType = filter.ShapeType; builder.Describe(shapeType) .From(feature) .Placement(ctx => CheckFilter(ctx, filter), placement); } } }
private Feature LoadFeature(FeatureDescriptor featureDescriptor) { var extensionDescriptor = featureDescriptor.Extension; var featureId = featureDescriptor.Id; var extensionId = extensionDescriptor.Id; ExtensionEntry extensionEntry; try { extensionEntry = BuildEntry(extensionDescriptor); } catch (Exception ex) { _logger.LogError(string.Format("Error loading extension '{0}'", extensionId), ex); throw new OrchardException(T("Error while loading extension '{0}'.", extensionId), ex); } if (extensionEntry == null) { // If the feature could not be compiled for some reason, // return a "null" feature, i.e. a feature with no exported types. return new Feature { Descriptor = featureDescriptor, ExportedTypes = Enumerable.Empty<Type>() }; } var extensionTypes = extensionEntry.ExportedTypes.Where(t => t.GetTypeInfo().IsClass && !t.GetTypeInfo().IsAbstract); var featureTypes = new List<Type>(); foreach (var type in extensionTypes) { string sourceFeature = GetSourceFeatureNameForType(type, extensionId); if (String.Equals(sourceFeature, featureId, StringComparison.OrdinalIgnoreCase)) { featureTypes.Add(type); } } return new Feature { Descriptor = featureDescriptor, ExportedTypes = featureTypes }; }
internal static int GetPriority(FeatureDescriptor featureDescriptor) { return featureDescriptor.Priority; }
private static Feature FrameworkFeature(FeatureDescriptor descriptor) { return new Feature { Descriptor = descriptor }; }
public void ExtensionManagerShouldReturnEmptyFeatureIfFeatureDoesNotExist() { var featureDescriptor = new FeatureDescriptor { Id = "NoSuchFeature", Extension = new ExtensionDescriptor { Id = "NoSuchFeature" } }; var manager = new ExtensionManager(new StubExtensionLocator(), new StubLoaders[] { }, new TypeFeatureProvider(), new NullLogger<ExtensionManager>()); Feature feature = manager.LoadFeatures(new[] { featureDescriptor }).First(); Assert.Equal(featureDescriptor, feature.Descriptor); Assert.Equal(0, feature.ExportedTypes.Count()); }
/// <summary> /// Returns true if the item has an explicit or implicit dependency on the subject /// </summary> /// <param name="item"></param> /// <param name="subject"></param> /// <returns></returns> internal static bool HasDependency(FeatureDescriptor item, FeatureDescriptor subject) { // Return based on explicit dependencies return item.Dependencies != null && item.Dependencies.Any(x => StringComparer.OrdinalIgnoreCase.Equals(x, subject.Id)); }
public void ApplyChanges() { if (Logger.IsEnabled(LogLevel.Information)) { Logger.LogInformation("Applying changes for for shell '{0}'", _settings.Name); } var shellState = _stateManager.GetShellStateAsync().Result; // start with description of all declared features in order - order preserved with all merging var orderedFeatureDescriptors = _extensionManager.AvailableFeatures(); // merge feature state into ordered list var orderedFeatureDescriptorsAndStates = orderedFeatureDescriptors .Select(featureDescriptor => new { FeatureDescriptor = featureDescriptor, FeatureState = shellState.Features.FirstOrDefault(s => s.Name == featureDescriptor.Id), }) .Where(entry => entry.FeatureState != null) .ToArray(); // get loaded feature information var loadedFeatures = _extensionManager.LoadFeatures(orderedFeatureDescriptorsAndStates.Select(entry => entry.FeatureDescriptor)).ToArray(); // merge loaded feature information into ordered list var loadedEntries = orderedFeatureDescriptorsAndStates.Select( entry => new { Feature = loadedFeatures.SingleOrDefault(f => f.Descriptor == entry.FeatureDescriptor) ?? new Feature { Descriptor = entry.FeatureDescriptor, ExportedTypes = Enumerable.Empty<Type>() }, entry.FeatureDescriptor, entry.FeatureState, }).ToList(); // find feature state that is beyond what's currently available from modules var additionalState = shellState.Features.Except(loadedEntries.Select(entry => entry.FeatureState)); // create additional stub entries for the sake of firing state change events on missing features var allEntries = loadedEntries.Concat(additionalState.Select(featureState => { var featureDescriptor = new FeatureDescriptor { Id = featureState.Name, Extension = new ExtensionDescriptor { Id = featureState.Name } }; return new { Feature = new Feature { Descriptor = featureDescriptor, ExportedTypes = Enumerable.Empty<Type>(), }, FeatureDescriptor = featureDescriptor, FeatureState = featureState }; })).ToArray(); // lower enabled states in reverse order foreach (var entry in allEntries.Reverse().Where(entry => entry.FeatureState.EnableState == ShellFeatureState.State.Falling)) { if (Logger.IsEnabled(LogLevel.Information)) { Logger.LogInformation("Disabling feature '{0}'", entry.Feature.Descriptor.Id); } _eventBus.Notify<IFeatureEventHandler>(x => x.Disabling(entry.Feature)); _stateManager.UpdateEnabledState(entry.FeatureState, ShellFeatureState.State.Down); _eventBus.Notify<IFeatureEventHandler>(x => x.Disabled(entry.Feature)); } // lower installed states in reverse order foreach (var entry in allEntries.Reverse().Where(entry => entry.FeatureState.InstallState == ShellFeatureState.State.Falling)) { if (Logger.IsEnabled(LogLevel.Information)) { Logger.LogInformation("Uninstalling feature '{0}'", entry.Feature.Descriptor.Id); } _eventBus.Notify<IFeatureEventHandler>(x => x.Uninstalling(entry.Feature)); _stateManager.UpdateInstalledState(entry.FeatureState, ShellFeatureState.State.Down); _eventBus.Notify<IFeatureEventHandler>(x => x.Uninstalled(entry.Feature)); } // raise install and enabled states in order foreach (var entry in allEntries.Where(entry => IsRising(entry.FeatureState))) { if (entry.FeatureState.InstallState == ShellFeatureState.State.Rising) { if (Logger.IsEnabled(LogLevel.Information)) { Logger.LogInformation("Installing feature '{0}'", entry.Feature.Descriptor.Id); } _eventBus.Notify<IFeatureEventHandler>(x => x.Installing(entry.Feature)); _stateManager.UpdateInstalledState(entry.FeatureState, ShellFeatureState.State.Up); _eventBus.Notify<IFeatureEventHandler>(x => x.Installed(entry.Feature)); } if (entry.FeatureState.EnableState == ShellFeatureState.State.Rising) { if (Logger.IsEnabled(LogLevel.Information)) { Logger.LogInformation("Enabling feature '{0}'", entry.Feature.Descriptor.Id); } _eventBus.Notify<IFeatureEventHandler>(x => x.Enabling(entry.Feature)); _stateManager.UpdateEnabledState(entry.FeatureState, ShellFeatureState.State.Up); _eventBus.Notify<IFeatureEventHandler>(x => x.Enabled(entry.Feature)); } } }
private Feature LoadFeature(FeatureDescriptor featureDescriptor) { var extensionDescriptor = featureDescriptor.Extension; var featureId = featureDescriptor.Id; var extensionId = extensionDescriptor.Id; ExtensionEntry extensionEntry; try { extensionEntry = _cacheManager.Get(extensionId, ctx => { var entry = BuildEntry(extensionDescriptor); if (entry != null) { ctx.Monitor(_asyncTokenProvider.GetToken(monitor => { foreach (var loader in _loaders) { loader.Monitor(entry.Descriptor, token => monitor(token)); } })); } return entry; }); } catch (Exception ex) { Logger.Error(ex, "Error loading extension '{0}'", extensionId); throw new CoreException(string.Format("Error while loading extension '{0}'.", extensionId), ex); } if (extensionEntry == null) { // If the feature could not be compiled for some reason, // return a "null" feature, i.e. a feature with no exported types. return new Feature { Descriptor = featureDescriptor, ExportedTypes = Enumerable.Empty<Type>() }; } var extensionTypes = extensionEntry.ExportedTypes.Where(t => t.IsClass && !t.IsAbstract); var featureTypes = new List<Type>(); foreach (var type in extensionTypes) { string sourceFeature = GetSourceFeatureNameForType(type, extensionId); if (String.Equals(sourceFeature, featureId, StringComparison.OrdinalIgnoreCase)) { featureTypes.Add(type); } } return new Feature { Descriptor = featureDescriptor, ExportedTypes = featureTypes }; }
private bool FeatureIsTheme(FeatureDescriptor fd) { return DefaultExtensionTypes.IsTheme(fd.Extension.ExtensionType); }
private Feature FrameworkFeature(FeatureDescriptor descriptor) { return new Feature { Descriptor = descriptor, ExportedTypes = new[] { typeof (TestDependency), typeof (TestSingletonDependency), typeof (TestTransientDependency), } }; }
private Feature LoadFeature(FeatureDescriptor featureDescriptor) { var featureName = featureDescriptor.Name; string extensionName = GetExtensionForFeature(featureName); if (extensionName == null) throw new ArgumentException(T("Feature ") + featureName + T(" was not found in any of the installed extensions")); var extension = BuildActiveExtensions().Where(x => x.Descriptor.Name == extensionName).FirstOrDefault(); if (extension == null) throw new InvalidOperationException(T("Extension ") + extensionName + T(" is not active")); var extensionTypes = extension.ExportedTypes.Where(t => t.IsClass && !t.IsAbstract); var featureTypes = new List<Type>(); foreach (var type in extensionTypes) { string sourceFeature = GetSourceFeatureNameForType(type, extensionName); if (String.Equals(sourceFeature, featureName, StringComparison.OrdinalIgnoreCase)) { featureTypes.Add(type); } } return new Feature { Descriptor = featureDescriptor, ExportedTypes = featureTypes }; }
public void ExtensionManagerShouldReturnEmptyFeatureIfFeatureDoesNotExist() { var featureDescriptor = new FeatureDescriptor { Id = "NoSuchFeature", Extension = new ExtensionDescriptor { Id = "NoSuchFeature" } }; Feature feature = _manager.LoadFeatures(new[] { featureDescriptor }).First(); Assert.AreEqual(featureDescriptor, feature.Descriptor); Assert.AreEqual(0, feature.ExportedTypes.Count()); }
private static IEnumerable<FeatureDescriptor> GetFeaturesForExtension(IDictionary<string, string> manifest, ExtensionDescriptor extensionDescriptor) { var featureDescriptors = new List<FeatureDescriptor>(); // Default feature FeatureDescriptor defaultFeature = new FeatureDescriptor { Id = extensionDescriptor.Id, Name = GetValue(manifest, FeatureNameSection) ?? extensionDescriptor.Name, Priority = GetValue(manifest, PrioritySection) != null ? int.Parse(GetValue(manifest, PrioritySection)) : 0, Description = GetValue(manifest, FeatureDescriptionSection) ?? GetValue(manifest, DescriptionSection) ?? string.Empty, Dependencies = ParseFeatureDependenciesEntry(GetValue(manifest, DependenciesSection)), Extension = extensionDescriptor, Category = GetValue(manifest, CategorySection) }; featureDescriptors.Add(defaultFeature); // Remaining features string featuresText = GetValue(manifest, FeaturesSection); if (featuresText != null) { FeatureDescriptor featureDescriptor = null; using (StringReader reader = new StringReader(featuresText)) { string line; while ((line = reader.ReadLine()) != null) { if (IsFeatureDeclaration(line)) { if (featureDescriptor != null) { if (!featureDescriptor.Equals(defaultFeature)) { featureDescriptors.Add(featureDescriptor); } featureDescriptor = null; } string[] featureDeclaration = line.Split(new[] { ":" }, StringSplitOptions.RemoveEmptyEntries); string featureDescriptorId = featureDeclaration[0].Trim(); if (string.Equals(featureDescriptorId, extensionDescriptor.Id, StringComparison.OrdinalIgnoreCase)) { featureDescriptor = defaultFeature; featureDescriptor.Name = extensionDescriptor.Name; } else { featureDescriptor = new FeatureDescriptor { Id = featureDescriptorId, Extension = extensionDescriptor }; } } else if (IsFeatureFieldDeclaration(line)) { if (featureDescriptor != null) { string[] featureField = line.Split(new[] { ":" }, 2, StringSplitOptions.None); int featureFieldLength = featureField.Length; if (featureFieldLength != 2) continue; for (int i = 0; i < featureFieldLength; i++) { featureField[i] = featureField[i].Trim(); } switch (featureField[0].ToLowerInvariant()) { case NameSection: featureDescriptor.Name = featureField[1]; break; case DescriptionSection: featureDescriptor.Description = featureField[1]; break; case CategorySection: featureDescriptor.Category = featureField[1]; break; case PrioritySection: featureDescriptor.Priority = int.Parse(featureField[1]); break; case DependenciesSection: featureDescriptor.Dependencies = ParseFeatureDependenciesEntry(featureField[1]); break; } } else { string message = string.Format("The line {0} in manifest for extension {1} was ignored", line, extensionDescriptor.Id); throw new ArgumentException(message); } } else { string message = string.Format("The line {0} in manifest for extension {1} was ignored", line, extensionDescriptor.Id); throw new ArgumentException(message); } } if (featureDescriptor != null && !featureDescriptor.Equals(defaultFeature)) featureDescriptors.Add(featureDescriptor); } } return featureDescriptors; }
private Feature LoadFeature(FeatureDescriptor featureDescriptor) { lock(_features) { if (_logger.IsEnabled(LogLevel.Information)) { _logger.LogInformation("Loading feature {0}", featureDescriptor.Name); } if(_features.ContainsKey(featureDescriptor.Id)) { if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug("Feature {0} loaded from cache", featureDescriptor.Name); } return _features[featureDescriptor.Id]; } var extensionDescriptor = featureDescriptor.Extension; var featureId = featureDescriptor.Id; var extensionId = extensionDescriptor.Id; var extensionEntry = LoadExtension(extensionDescriptor); Feature feature; if (extensionEntry == null) { // If the feature could not be compiled for some reason, // return a "null" feature, i.e. a feature with no exported types. feature = new Feature { Descriptor = featureDescriptor, ExportedTypes = Enumerable.Empty<Type>() }; _features.Add(featureDescriptor.Id, feature); return feature; } var extensionTypes = extensionEntry.ExportedTypes.Where(t => t.GetTypeInfo().IsClass && !t.GetTypeInfo().IsAbstract); var featureTypes = new List<Type>(); foreach (var type in extensionTypes) { string sourceFeature = GetSourceFeatureNameForType(type, extensionId); if (String.Equals(sourceFeature, featureId, StringComparison.OrdinalIgnoreCase)) { featureTypes.Add(type); } } feature = new Feature { Descriptor = featureDescriptor, ExportedTypes = featureTypes }; foreach (var type in feature.ExportedTypes) { _typeFeatureProvider.TryAdd(type, feature); } _features.Add(featureDescriptor.Id, feature); return feature; } }
private bool FeatureIsEnabled(FeatureDescriptor fd) { return _shellDescriptor.Features.Any(sf => sf.Name == fd.Id); }
static Feature Feature(FeatureDescriptor descriptor) { return new Feature { Descriptor = descriptor }; }
/// <summary> /// Maps an orchard module descriptor to a new <see cref="OrchardFeature"/> object. /// </summary> /// <param name="descriptor">The descriptor to map.</param> /// <returns>The created object.</returns> private static OrchardFeature MapDescriptorToOrchardFeature(FeatureDescriptor descriptor) { return new OrchardFeature { Id = descriptor.Id, Name = descriptor.Name, Description = descriptor.Description, Category = descriptor.Category, Priority = descriptor.Priority, Dependencies = descriptor.Dependencies != null ? descriptor.Dependencies.ToArray() : null }; }
private static IEnumerable<FeatureDescriptor> GetFeaturesForExtension(Mapping features, ExtensionDescriptor extensionDescriptor) { var featureDescriptors = new List<FeatureDescriptor>(); if (features != null) { foreach (var entity in features.Entities) { var featureDescriptor = new FeatureDescriptor { Extension = extensionDescriptor, Name = entity.Key.ToString(), }; var featureMapping = (Mapping)entity.Value; foreach (var featureEntity in featureMapping.Entities) { if (String.Equals(featureEntity.Key.ToString(), "description", StringComparison.OrdinalIgnoreCase)) { featureDescriptor.Description = featureEntity.Value.ToString(); } else if (String.Equals(featureEntity.Key.ToString(), "category", StringComparison.OrdinalIgnoreCase)) { featureDescriptor.Category = featureEntity.Value.ToString(); } else if (String.Equals(featureEntity.Key.ToString(), "dependencies", StringComparison.OrdinalIgnoreCase)) { featureDescriptor.Dependencies = ParseFeatureDependenciesEntry(featureEntity.Value.ToString()); } } featureDescriptors.Add(featureDescriptor); } } if (!featureDescriptors.Any(fd => fd.Name == extensionDescriptor.Name)) { featureDescriptors.Add(new FeatureDescriptor { Name = extensionDescriptor.Name, Dependencies = new string[0], Extension = extensionDescriptor, }); } return featureDescriptors; }
private bool FeatureIsEnabled(FeatureDescriptor fd) { return (DefaultExtensionTypes.IsTheme(fd.Extension.ExtensionType) && (fd.Id == "TheAdmin" || fd.Id == "SafeMode")) || _shellDescriptor.Features.Any(sf => sf.Name == fd.Id); }
public void ExtensionManagerShouldThrowIfFeatureDoesNotExist() { var featureDescriptor = new FeatureDescriptor { Name = "NoSuchFeature" }; Assert.Throws<ArgumentException>(() => _manager.LoadFeatures(new [] { featureDescriptor })); }