public async Task <IEnumerable <IFeatureInfo> > EnableFeaturesAsync(ShellDescriptor shellDescriptor, IEnumerable <IFeatureInfo> features, bool force)
{
var extensions = _extensionManager.GetExtensions();
var enabledFeatures = _extensionManager.GetEnabledFeatures(shellDescriptor).ToList();
IDictionary <IFeatureInfo, bool> availableFeatures = extensions
.Features
.ToDictionary(featureDescriptor => featureDescriptor,
featureDescriptor => enabledFeatures.Any(shellFeature => shellFeature.Id == featureDescriptor.Id));
var featuresToEnable = features
.Select(feature => EnableFeature(feature, availableFeatures, false))
.SelectMany(ies => ies)
.Distinct()
.ToList();
if (featuresToEnable.Count > 0)
{
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("Enabling features {0}", string.Join(",", featuresToEnable.Select(x => x.Id)));
}
shellDescriptor.Features = enabledFeatures.Concat(featuresToEnable).Select(x => new ShellFeature(x.Id)).ToList();
await _shellDescriptorManager.UpdateShellDescriptorAsync(
shellDescriptor.SerialNumber,
shellDescriptor.Features,
shellDescriptor.Parameters);
}
return(featuresToEnable);
}
public async Task <ActionResult> Index()
{
IEnumerable <ModuleEntry> modules = _extensionManager.GetExtensions()
.Where(extensionDescriptor => extensionDescriptor.Manifest.IsModule())
.OrderBy(extensionDescriptor => extensionDescriptor.Manifest.Name)
.Select(extensionDescriptor => new ModuleEntry {
Descriptor = extensionDescriptor
});
var features = await _shellFeaturesManager.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));
}
/// <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 async Task <IEnumerable <ModuleFeature> > GetAvailableFeaturesAsync()
{
var enabledFeatures =
await _shellFeaturesManager.GetEnabledFeaturesAsync();
var availableFeatures = _extensionManager.GetExtensions().Features;
return(availableFeatures
.Select(f => AssembleModuleFromDescriptor(f, enabledFeatures
.Any(sf => sf.Id == f.Id))));
}
public void ShouldReturnExtension()
{
var extensions = ModuleThemeScopedExtensionManager.GetExtensions()
.Where(e => e.Manifest.ModuleInfo.Category == "Test");
Assert.Equal(5, extensions.Count());
}
public DefaultEntityTypeProvider(IExtensionManager extensionManager)
{
_extensionManager = extensionManager;
foreach (var item in _extensionManager.GetExtensions())
{
var extension = _extensionManager.LoadExtensionAsync(item).Result.Assembly;
Types.AddRange(extension.GetTypes().Where(predicate));
foreach (var assemblie in extension.GetReferencedAssemblies())
{
var assembly = Assembly.Load(assemblie);
if (assembly != null)
{
//extensionAccemblys.Add(assembly);
Types.AddRange(assembly.GetTypes().Where(predicate));
}
}
}
//var extensionAssemblys = GetAssemblysOfExtension();
//foreach (var extension in extensionAssemblys)
//{
// Types.AddRange(过滤(extension.GetTypes()));
// LoadReferencedAssemblys(extension.GetReferencedAssemblies());
//}
}
/// <inheritdocs />
public IEnumerable <IFileInfo> GetLocations(string cultureName)
{
var poFileName = cultureName + PoFileExtension;
var extensions = _extensionsManager.GetExtensions();
// Load .po files in each extension folder first, based on the extensions order
foreach (var extension in extensions)
{
// From [Extension]/Localization
yield return(_fileProvider.GetFileInfo(PathExtensions.Combine(extension.SubPath, _resourcesContainer, poFileName)));
}
// Load global .po files from /Localization
yield return(_fileProvider.GetFileInfo(PathExtensions.Combine(_resourcesContainer, poFileName)));
// Load tenant-specific .po file from /App_Data/Sites/[Tenant]/Localization
yield return(new PhysicalFileInfo(new FileInfo(PathExtensions.Combine(_shellDataContainer, _resourcesContainer, poFileName))));
// Load each modules .po file for extending localization when using Orchard Core as a NuGet package
foreach (var extension in extensions)
{
// \src\OrchardCore.Cms.Web\Localization\OrchardCore.Cms.Web\fr-CA.po
yield return(_fileProvider.GetFileInfo(PathExtensions.Combine(_resourcesContainer, extension.Id, poFileName)));
// \src\OrchardCore.Cms.Web\Localization\OrchardCore.Cms.Web-fr-CA.po
yield return(_fileProvider.GetFileInfo(PathExtensions.Combine(_resourcesContainer, extension.Id + CultureDelimiter + poFileName)));
}
// Load all .po files from a culture specific folder
// e.g, \src\OrchardCore.Cms.Web\Localization\fr-CA\*.po
foreach (var file in _fileProvider.GetDirectoryContents(PathExtensions.Combine(_resourcesContainer, cultureName)))
{
yield return(file);
}
}
public static IEnumerable <IFeatureInfo> GetDisabledFeatures(this IExtensionManager extensionManager, ShellDescriptor shellDescriptor)
{
var extensions = extensionManager.GetExtensions();
var features = extensions.Features;
return(features.Where(fd => shellDescriptor.Features.All(sf => sf.Id != fd.Id)));
}
public IEnumerable <IFileInfo> GetLocations(string cultureName)
{
var poFileName = cultureName + PoFileExtension;
var extensions = _extensionsManager.GetExtensions();
// Load .po files in each extension folder first, based on the extensions order
foreach (var extension in extensions)
{
yield return(_fileProvider.GetFileInfo(PathExtensions.Combine(extension.SubPath, ExtensionDataFolder, _resourcesContainer, poFileName)));
}
// Then load global .po file for the applications
yield return(new PhysicalFileInfo(new FileInfo(PathExtensions.Combine(_applicationDataContainer, _resourcesContainer, poFileName))));
// Load tenant-specific .po file
yield return(new PhysicalFileInfo(new FileInfo(PathExtensions.Combine(_shellDataContainer, _resourcesContainer, poFileName))));
// Load each modules .po file for extending localization when using Orchard Core as a Nuget package
foreach (var extension in extensions)
{
// \src\OrchardCore.Cms.Web\App_Data/Localization/OrchardCore.Cms.Web/fr-CA.po
yield return(new PhysicalFileInfo(new FileInfo(PathExtensions.Combine(_applicationDataContainer, _resourcesContainer, extension.Id, poFileName))));
// \src\OrchardCore.Cms.Web\App_Data/Localization/OrchardCore.Cms.Web-fr-CA.po
yield return(new PhysicalFileInfo(new FileInfo(PathExtensions.Combine(_applicationDataContainer, _resourcesContainer, extension.Id + CultureDelimiter + poFileName))));
// \src\OrchardCore.Cms.Web\App_Data/Localization/fr-CA/OrchardCore.Cms.Web.po
yield return(new PhysicalFileInfo(new FileInfo(PathExtensions.Combine(_applicationDataContainer, _resourcesContainer, cultureName, extension.Id + PoFileExtension))));
}
}
Task <IEnumerable <IFeatureInfo> > IShellFeaturesManager.GetEnabledFeaturesAsync()
{
var extensions = _extensionManager.GetExtensions();
var features = extensions.Features;
return(Task.FromResult(features.AsEnumerable()));
}
public Task <IEnumerable <IExtensionInfo> > GetEnabledExtensionsAsync()
{
// enabled extensions are those which have at least one enabled feature.
var enabledIds = _extensionManager.GetFeatures().Where(f => _shellDescriptor
.Features.Any(sf => sf.Id == f.Id)).Select(f => f.Extension.Id).Distinct().ToArray();
// Extensions are still ordered according to the weight of their first features.
return(Task.FromResult(_extensionManager.GetExtensions().Where(e => enabledIds.Contains(e.Id))));
}
/// <inheritdoc />
public virtual IEnumerable<string> ExpandViewLocations(ViewLocationExpanderContext context,
IEnumerable<string> viewLocations)
{
if (context.AreaName == null)
{
return viewLocations;
}
HashSet<string> enabledExtensionIds = null;
var result = new List<string>();
if (context.PageName != null)
{
if (!_memoryCache.TryGetValue(PageCacheKey, out IEnumerable<string> modulePageSharedViewLocations))
{
modulePageSharedViewLocations = _modulesWithPageSharedViews
.Where(m => GetEnabledExtensionIds().Contains(m.Id))
.Select(m => '/' + m.SubPath + PageSharedViewsPath);
_memoryCache.Set(PageCacheKey, modulePageSharedViewLocations);
}
result.AddRange(modulePageSharedViewLocations);
}
if (!_memoryCache.TryGetValue(CacheKey, out IEnumerable<string> moduleSharedViewLocations))
{
moduleSharedViewLocations = _modulesWithSharedViews
.Where(m => GetEnabledExtensionIds().Contains(m.Id))
.Select(m => '/' + m.SubPath + SharedViewsPath);
_memoryCache.Set(CacheKey, moduleSharedViewLocations);
}
result.AddRange(moduleSharedViewLocations);
result.AddRange(viewLocations);
return result;
HashSet<string> GetEnabledExtensionIds()
{
if (enabledExtensionIds != null)
{
return enabledExtensionIds;
}
var enabledIds = _extensionManager.GetFeatures().Where(f => _shellDescriptor
.Features.Any(sf => sf.Id == f.Id)).Select(f => f.Extension.Id).ToHashSet();
return enabledExtensionIds = _extensionManager.GetExtensions()
.Where(e => enabledIds.Contains(e.Id)).Select(x => x.Id).ToHashSet();
}
}
async Task CreateAndRegisterShellsAsync()
{
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("Start creation of shells");
}
// Load all extensions and features so that the controllers are
// registered in ITypeFeatureProvider and their areas defined in the application
// conventions.
_extensionManager
.GetExtensions()
.Features
.InvokeAsync(
f => _extensionManager.LoadFeatureAsync(f), _logger)
.Wait();
// Is there any tenant right now?
var allSettings = _shellSettingsManager.LoadSettings().Where(CanCreateShell).ToArray();
// Load all tenants, and activate their shell.
if (allSettings.Any())
{
Parallel.ForEach(allSettings, settings =>
{
try
{
GetOrCreateShellContext(settings);
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
_logger.LogError(string.Format("A tenant could not be started: {0}", settings.Name), ex);
}
});
}
// No settings, run the Setup.
else
{
var setupContext = await CreateSetupContextAsync();
RegisterShell(setupContext);
}
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("Done creating shells");
}
}
public ComponentViewLocationExpanderProvider(
RazorCompilationFileProviderAccessor fileProviderAccessor,
IExtensionManager extensionManager,
ShellDescriptor shellDescriptor,
IMemoryCache memoryCache)
{
_extensionManager = extensionManager;
_shellDescriptor = shellDescriptor;
_memoryCache = memoryCache;
if (_initialized)
{
return;
}
lock (_synLock)
{
if (!_initialized)
{
var modulesWithComponentViews = new List <IExtensionInfo>();
var modulesWithPagesComponentViews = new List <IExtensionInfo>();
var orderedModules = _extensionManager.GetExtensions()
.Where(e => e.Manifest.Type.Equals("module", StringComparison.OrdinalIgnoreCase))
.Reverse();
foreach (var module in orderedModules)
{
var moduleComponentsViewFilePaths = fileProviderAccessor.FileProvider.GetViewFilePaths(
module.SubPath + "/Views/Shared/Components", RazorExtensions,
viewsFolder: null, inViewsFolder: true, inDepth: true);
if (moduleComponentsViewFilePaths.Any())
{
modulesWithComponentViews.Add(module);
}
var modulePagesComponentsViewFilePaths = fileProviderAccessor.FileProvider.GetViewFilePaths(
module.SubPath + "/Pages/Shared/Components", RazorExtensions,
viewsFolder: null, inViewsFolder: true, inDepth: true);
if (modulePagesComponentsViewFilePaths.Any())
{
modulesWithPagesComponentViews.Add(module);
}
}
_modulesWithComponentViews = modulesWithComponentViews;
_modulesWithPagesComponentViews = modulesWithPagesComponentViews;
_initialized = true;
}
}
}
public IEnumerable <string> GetLocations(string cultureName)
{
// Load .po files in each extension folder first, based on the extensions order
foreach (var extension in _extensionsManager.GetExtensions())
{
yield return(Path.Combine(_root, extension.SubPath, _rootContainer, _resourcesContainer, cultureName, PoFileName));
}
// Then load global .po file for the applications
yield return(Path.Combine(_root, _rootContainer, _resourcesContainer, cultureName, PoFileName));
// Finally load tenant-specific .po file
yield return(Path.Combine(_root, _rootContainer, _shellContainer, _shellName, _resourcesContainer, cultureName, PoFileName));
}
public Task <ShellDescriptor> GetShellDescriptorAsync()
{
if (_shellDescriptor == null)
{
_shellDescriptor = new ShellDescriptor
{
Features = _extensionManager.GetExtensions().Features.Select(x => new ShellFeature {
Id = x.Id
}).ToList()
};
}
return(Task.FromResult(_shellDescriptor));
}
public async Task <ActionResult> Features()
{
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageFeatures)) // , T["Not allowed to manage features."]
{
return(Unauthorized());
}
var enabledFeatures = await _shellFeaturesManager.GetEnabledFeaturesAsync();
var moduleFeatures = new List <ModuleFeature>();
foreach (var moduleFeatureInfo in _extensionManager
.GetExtensions()
.Features
.Where(f => !f.Extension.Manifest.IsTheme()))
{
var dependentFeatures = _extensionManager.GetDependentFeatures(moduleFeatureInfo.Id, enabledFeatures.ToArray());
var moduleFeature = new ModuleFeature
{
Descriptor = moduleFeatureInfo,
IsEnabled = enabledFeatures.Contains(moduleFeatureInfo),
//IsRecentlyInstalled = _moduleService.IsRecentlyInstalled(f.Extension),
//NeedsUpdate = featuresThatNeedUpdate.Contains(f.Id),
DependentFeatures = dependentFeatures.Where(x => x.Id != moduleFeatureInfo.Id).ToList()
};
moduleFeatures.Add(moduleFeature);
}
return(View(new FeaturesViewModel
{
Features = moduleFeatures,
IsAllowed = ExtensionIsAllowed
}));
}
public IEnumerable <IFileInfo> GetLocations(string cultureName)
{
var poFileName = cultureName + PoFileExtension;
// Load .po files in each extension folder first, based on the extensions order
foreach (var extension in _extensionsManager.GetExtensions())
{
yield return(_fileProvider.GetFileInfo(PathExtensions.Combine(extension.SubPath, ExtensionDataFolder, _resourcesContainer, poFileName)));
}
// Then load global .po file for the applications
yield return(new PhysicalFileInfo(new FileInfo(PathExtensions.Combine(_applicationDataContainer, _resourcesContainer, poFileName))));
// Finally load tenant-specific .po file
yield return(new PhysicalFileInfo(new FileInfo(PathExtensions.Combine(_shellDataContainer, _resourcesContainer, poFileName))));
}
private bool IsBaseTheme(string featureId, string themeId)
{
// determine if the given feature is a base theme of the given theme
var availableFeatures = _extensionManager.GetExtensions().Features;
var themeFeature = availableFeatures.SingleOrDefault(fd => fd.Id == themeId);
while (themeFeature != null && themeFeature.Extension.Manifest.IsTheme())
{
var themeExtensionInfo = new ThemeExtensionInfo(themeFeature.Extension);
if (!themeExtensionInfo.HasBaseTheme())
{
return(false);
}
if (themeExtensionInfo.IsBaseThemeFeature(featureId))
{
return(true);
}
themeFeature = availableFeatures.SingleOrDefault(fd => fd.Id == themeExtensionInfo.BaseTheme);
}
return(false);
}
/// <summary>
/// Handle extension information from bundle
/// </summary>
void HandleExtension()
{
IExtensionManager extensionManager = bundleRuntime.Framework.ServiceContainer.GetFirstOrDefaultService <IExtensionManager>();
// 处理UIShell.OSGi.MainShell扩展点。
List <Extension> extensions = extensionManager.GetExtensions("QTP.OSGI");
if (extensions != null && extensions.Count > 0)
{
foreach (Extension extension in extensions)
{
Extension ex = extension;
List <XmlNode> data = ex.Data;
if (data != null && data.Count > 0)
{
foreach (XmlNode topNode in data)
{
if (topNode.Attributes["Page"] != null)
{
// 从扩展点获取扩展插件定义的用户控件，然后添加到MainForm中。
string mainShellClassName = topNode.Attributes["Page"].Value;
Type type = ex.Owner.LoadClass(mainShellClassName);
Control control = (Control)System.Activator.CreateInstance(type);
TabPage tabPage = new TabPage(mainShellClassName = topNode.Attributes["Title"].Value);
tabPage.Controls.Add(control);
tabControl1.TabPages.Add(tabPage);
control.Dock = DockStyle.Fill;
control.Visible = true;
//UserControl uc = (UserControl)System.Activator.CreateInstance(type);
//this.Controls.Add(control);
}
}
//XmlNode topNode = data[0];
}
}
}
}
/// <inheritdoc />
public virtual IEnumerable <string> ExpandViewLocations(ViewLocationExpanderContext context,
IEnumerable <string> viewLocations)
{
if (context.AreaName == null)
{
return(viewLocations);
}
var result = new List <string>();
if (context.ViewName.StartsWith("Components/", StringComparison.Ordinal))
{
if (!_memoryCache.TryGetValue(CacheKey, out IEnumerable <string> moduleComponentViewLocations))
{
var enabledIds = _extensionManager.GetFeatures().Where(f => _shellDescriptor
.Features.Any(sf => sf.Id == f.Id)).Select(f => f.Extension.Id).Distinct().ToArray();
var enabledExtensions = _extensionManager.GetExtensions()
.Where(e => enabledIds.Contains(e.Id)).ToArray();
var sharedViewsPath = "/Views/Shared/{0}" + RazorViewEngine.ViewExtension;
moduleComponentViewLocations = _modulesWithComponentViews
.Where(m => enabledExtensions.Any(e => e.Id == m.Id))
.Select(m => '/' + m.SubPath + sharedViewsPath);
_memoryCache.Set(CacheKey, moduleComponentViewLocations);
}
result.AddRange(moduleComponentViewLocations);
}
result.AddRange(viewLocations);
return(result);
}
public Task <IEnumerable <RecipeDescriptor> > HarvestRecipesAsync()
{
return(_extensionManager.GetExtensions().InvokeAsync(descriptor => HarvestRecipes(descriptor), Logger));
}
public async Task ApplyChanges()
{
if (Logger.IsEnabled(LogLevel.Information))
{
Logger.LogInformation("Applying changes for for shell '{0}'", _settings.Name);
}
var shellState = await _stateManager.GetShellStateAsync();
// start with description of all declared features in order - order preserved with all merging
var orderedFeatureDescriptors = _extensionManager.GetExtensions().Features;
// merge feature state into ordered list
var orderedFeatureDescriptorsAndStates = orderedFeatureDescriptors
.Select(featureInfo => new
{
FeatureDescriptor = featureInfo,
FeatureState = shellState.Features.FirstOrDefault(s => s.Id == featureInfo.Id),
})
.Where(entry => entry.FeatureState != null)
.ToArray();
// get loaded feature information
var loadedFeatures = await Task.WhenAll(orderedFeatureDescriptorsAndStates
.Select(x => _extensionManager.LoadFeatureAsync(x.FeatureDescriptor))
.ToArray());
// merge loaded feature information into ordered list
var loadedEntries = orderedFeatureDescriptorsAndStates.Select(
entry => new
{
Feature = loadedFeatures.SingleOrDefault(f => f.FeatureInfo == entry.FeatureDescriptor)
?? new NonCompiledFeatureEntry(entry.FeatureDescriptor),
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 InternalFeatureInfo(
featureState.Id,
new InternalExtensionInfo(featureState.Id)
);
return(new
{
Feature = (FeatureEntry) new NonCompiledFeatureEntry(featureDescriptor),
FeatureDescriptor = (IFeatureInfo)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.FeatureInfo.Id);
}
_eventBus.Notify <IFeatureEventHandler>(x => x.Disabling(entry.Feature.FeatureInfo));
await _stateManager.UpdateEnabledStateAsync(entry.FeatureState, ShellFeatureState.State.Down);
_eventBus.Notify <IFeatureEventHandler>(x => x.Disabled(entry.Feature.FeatureInfo));
}
// 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.FeatureInfo.Id);
}
_eventBus.Notify <IFeatureEventHandler>(x => x.Uninstalling(entry.Feature.FeatureInfo));
await _stateManager.UpdateInstalledStateAsync(entry.FeatureState, ShellFeatureState.State.Down);
_eventBus.Notify <IFeatureEventHandler>(x => x.Uninstalled(entry.Feature.FeatureInfo));
}
// 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.FeatureInfo.Id);
}
_eventBus.Notify <IFeatureEventHandler>(x => x.Installing(entry.Feature.FeatureInfo));
await _stateManager.UpdateInstalledStateAsync(entry.FeatureState, ShellFeatureState.State.Up);
_eventBus.Notify <IFeatureEventHandler>(x => x.Installed(entry.Feature.FeatureInfo));
}
if (entry.FeatureState.EnableState == ShellFeatureState.State.Rising)
{
if (Logger.IsEnabled(LogLevel.Information))
{
Logger.LogInformation("Enabling feature '{0}'", entry.Feature.FeatureInfo.Id);
}
_eventBus.Notify <IFeatureEventHandler>(x => x.Enabling(entry.Feature.FeatureInfo));
await _stateManager.UpdateEnabledStateAsync(entry.FeatureState, ShellFeatureState.State.Up);
_eventBus.Notify <IFeatureEventHandler>(x => x.Enabled(entry.Feature.FeatureInfo));
}
}
}
public virtual Task <IEnumerable <RecipeDescriptor> > HarvestRecipesAsync()
{
return(_extensionManager.GetExtensions().InvokeAsync(HarvestRecipes, _logger));
}
private void LoadExistingExtensions(string extensionPoint, ExtensionChangeHandler extensionChangeBuilder)
{
_extensionManager.GetExtensions(extensionPoint).ForEach(
extension => extensionChangeBuilder.Builder.Build(extension.Data, extension.Owner));
}
public async Task <ActionResult> Index()
{
var installThemes = await _authorizationService.AuthorizeAsync(User, StandardPermissions.SiteOwner); // only site owners
if (!installThemes)
{
return(Forbid());
}
//&& _shellSettings.Name == ShellSettings.; // of the default tenant
//&& _featureManager.GetEnabledFeatures().FirstOrDefault(f => f.Id == "PackagingServices") != null
//var featuresThatNeedUpdate = _dataMigrationManager.GetFeaturesThatNeedUpdate();
var currentSiteThemeExtensionInfo = await _siteThemeService.GetSiteThemeAsync();
var currentAdminThemeExtensionInfo = await _adminThemeService.GetAdminThemeAsync();
var currentAdminTheme = currentAdminThemeExtensionInfo != null ? new ThemeEntry(currentAdminThemeExtensionInfo) : default(ThemeEntry);
var currentSiteTheme = currentSiteThemeExtensionInfo != null ? new ThemeEntry(currentSiteThemeExtensionInfo) : default(ThemeEntry);
var enabledFeatures = await _shellFeaturesManager.GetEnabledFeaturesAsync();
var themes = _extensionManager.GetExtensions().OfType <IThemeExtensionInfo>().Where(extensionDescriptor =>
{
var tags = extensionDescriptor.Manifest.Tags.ToArray();
var isHidden = tags.Any(x => string.Equals(x, "hidden", StringComparison.OrdinalIgnoreCase));
// Is the theme allowed for this tenant?
// allowed = _shellSettings.Themes.Length == 0 || _shellSettings.Themes.Contains(extensionDescriptor.Id);
return(!isHidden);
})
.Select(extensionDescriptor =>
{
var isAdmin = IsAdminTheme(extensionDescriptor.Manifest);
var themeId = isAdmin ? currentAdminTheme?.Extension.Id : currentSiteTheme?.Extension.Id;
var isCurrent = extensionDescriptor.Id == themeId;
var isEnabled = enabledFeatures.Any(x => x.Extension.Id == extensionDescriptor.Id);
var themeEntry = new ThemeEntry(extensionDescriptor)
{
//NeedsUpdate = featuresThatNeedUpdate.Contains(extensionDescriptor.Id),
//IsRecentlyInstalled = _themeService.IsRecentlyInstalled(extensionDescriptor),
Enabled = isEnabled,
CanUninstall = installThemes,
IsAdmin = isAdmin,
IsCurrent = isCurrent
};
//if (_extensionDisplayEventHandler != null)
//{
// foreach (string notification in _extensionDisplayEventHandler.Displaying(themeEntry.Descriptor, ControllerContext.RequestContext))
// {
// themeEntry.Notifications.Add(notification);
// }
//}
return(themeEntry);
})
.OrderByDescending(x => x.IsCurrent);
var model = new SelectThemesViewModel
{
CurrentSiteTheme = currentSiteTheme,
CurrentAdminTheme = currentAdminTheme,
Themes = themes
};
return(View(model));
}
public Task <IEnumerable <IExtensionInfo> > GetEnabledExtensionsAsync()
{
return(Task.FromResult(_extensionManager.GetExtensions()));
}
/// <inheritdoc />
public virtual IEnumerable <string> ExpandViewLocations(ViewLocationExpanderContext context,
IEnumerable <string> viewLocations)
{
if (context.ActionContext.ActionDescriptor is PageActionDescriptor page)
{
var pageViewLocations = PageViewLocations().ToList();
pageViewLocations.AddRange(viewLocations);
return(pageViewLocations);
IEnumerable <string> PageViewLocations()
{
if (page.RelativePath.Contains("/Pages/") && !page.RelativePath.StartsWith("/Pages/", StringComparison.Ordinal))
{
yield return(page.RelativePath.Substring(0, page.RelativePath.IndexOf("/Pages/", StringComparison.Ordinal))
+ "/Views/Shared/{0}" + RazorViewEngine.ViewExtension);
}
}
}
// Get Extension, and then add in the relevant views.
var extension = _extensionManager.GetExtension(context.AreaName);
if (!extension.Exists)
{
return(viewLocations);
}
var result = new List <string>();
var extensionViewsPath = '/' + extension.SubPath + "/Views";
result.Add(extensionViewsPath + "/{1}/{0}" + RazorViewEngine.ViewExtension);
if (!context.ViewName.StartsWith("Components/", StringComparison.Ordinal))
{
result.Add(extensionViewsPath + "/Shared/{0}" + RazorViewEngine.ViewExtension);
}
else
{
if (!_memoryCache.TryGetValue(CacheKey, out IEnumerable <string> moduleComponentViewLocations))
{
var enabledIds = _extensionManager.GetFeatures().Where(f => _shellDescriptor
.Features.Any(sf => sf.Id == f.Id)).Select(f => f.Extension.Id).Distinct().ToArray();
var enabledExtensions = _extensionManager.GetExtensions()
.Where(e => enabledIds.Contains(e.Id)).ToArray();
var sharedViewsPath = "/Views/Shared/{0}" + RazorViewEngine.ViewExtension;
moduleComponentViewLocations = _modulesWithComponentViews
.Where(m => enabledExtensions.Any(e => e.Id == m.Id))
.Select(m => '/' + m.SubPath + sharedViewsPath);
_memoryCache.Set(CacheKey, moduleComponentViewLocations);
}
result.AddRange(moduleComponentViewLocations);
}
result.AddRange(viewLocations);
return(result);
}
public void ShouldReturnExtension()
{
var extensions = ModuleScopedExtensionManager.GetExtensions();
Assert.Equal(4, extensions.Count());
}
public async Task <IEnumerable <RecipeDescriptor> > HarvestRecipesAsync()
{
return(await _extensionManager.GetExtensions().InvokeAsync(async descriptor => {
return await HarvestRecipesAsync(descriptor);
}, Logger));
}
public async Task UpdateAsync(string featureId)
{
if (_processedFeatures.Contains(featureId))
{
return;
}
_processedFeatures.Add(featureId);
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("Updating feature: {0}", featureId);
}
// proceed with dependent features first, whatever the module it's in
var dependencies = _extensionManager.GetExtensions().Features
.Where(f => f.Id == featureId)
.Where(f => f.Dependencies.Any())
.SelectMany(f => f.Dependencies)
.ToList();
await UpdateAsync(dependencies);
var migrations = GetDataMigrations(featureId);
// apply update methods to each migration class for the module
foreach (var migration in migrations)
{
_session.ExecuteMigration(schemaBuilder =>
{
migration.SchemaBuilder = schemaBuilder;
// copy the object for the Linq query
var tempMigration = migration;
// get current version for this migration
var dataMigrationRecord = GetDataMigrationRecordAsync(tempMigration).Result;
var current = 0;
if (dataMigrationRecord != null)
{
current = dataMigrationRecord.Version.Value;
}
else
{
dataMigrationRecord = new Records.DataMigration {
DataMigrationClass = migration.GetType().FullName
};
_dataMigrationRecord.DataMigrations.Add(dataMigrationRecord);
}
try
{
// do we need to call Create() ?
if (current == 0)
{
// try to resolve a Create method
var createMethod = GetCreateMethod(migration);
if (createMethod != null)
{
current = (int)createMethod.Invoke(migration, new object[0]);
}
}
var lookupTable = CreateUpgradeLookupTable(migration);
while (lookupTable.ContainsKey(current))
{
try
{
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("Applying migration for {0} from version {1}.", featureId, current);
}
current = (int)lookupTable[current].Invoke(migration, new object[0]);
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
_logger.LogError(0, "An unexpected error occurred while applying migration on {0} from version {1}.", featureId, current);
throw;
}
}
// if current is 0, it means no upgrade/create method was found or succeeded
if (current == 0)
{
return;
}
dataMigrationRecord.Version = current;
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
_logger.LogError(0, "Error while running migration version {0} for {1}.", current, featureId);
_session.Cancel();
throw new OrchardException(T("Error while running migration version {0} for {1}.", current, featureId), ex);
}
finally
{
// Persist data migrations
_session.Save(_dataMigrationRecord);
}
});
}
}
