public ExtensionEntry Load(ExtensionDescriptor descriptor)
{
if (!ExtensionsVirtualPathPrefixes.Contains(descriptor.Location)) {
return null;
}
var plocation = _hostEnvironment.MapPath(descriptor.Location);
using (_loaderContainer.AddLoader(_extensionAssemblyLoader.WithPath(plocation))) {
try {
var assembly = Assembly.Load(new AssemblyName(descriptor.Id));
_logger.LogInformation("Loaded referenced extension \"{0}\": assembly name=\"{1}\"", descriptor.Name, assembly.FullName);
return new ExtensionEntry {
Descriptor = descriptor,
Assembly = assembly,
ExportedTypes = assembly.ExportedTypes
};
}
catch (System.Exception ex) {
_logger.LogError(string.Format("Error trying to load extension {0}", descriptor.Id), ex);
throw;
}
}
}
public ExtensionEntry Load(ExtensionDescriptor descriptor)
{
if (!descriptor.Location.StartsWith("~/Core/")) {
return null;
}
var plocation = _hostEnvironment.MapPath("~/Core");
using (_loaderContainer.AddLoader(_extensionAssemblyLoader.WithPath(plocation))) {
var assembly = Assembly.Load(new AssemblyName(CoreAssemblyName));
_logger.LogInformation("Loaded referenced extension \"{0}\": assembly name=\"{1}\"", descriptor.Name, assembly.FullName);
return new ExtensionEntry {
Descriptor = descriptor,
Assembly = assembly,
ExportedTypes = assembly.ExportedTypes.Where(x => IsTypeFromModule(x, descriptor))
};
}
}
public static string ThemePath(this HtmlHelper helper, ExtensionDescriptor theme, string path)
{
return(theme.Location + "/" + theme.Id + path);
}
public bool IsCompatibleWithModuleReferences(ExtensionDescriptor extension, IEnumerable <ExtensionProbeEntry> references)
{
return(true);
}
private static bool IsTypeFromModule(Type type, ExtensionDescriptor descriptor)
{
return((type.Namespace + ".").StartsWith(CoreAssemblyName + "." + descriptor.Id + "."));
}
public void CreateDataMigration(string featureName)
{
Context.Output.WriteLine(T("Creating Data Migration for {0}", featureName));
ExtensionDescriptor extensionDescriptor = _extensionManager.AvailableExtensions().FirstOrDefault(extension => DefaultExtensionTypes.IsModule(extension.ExtensionType) &&
extension.Features.Any(feature => String.Equals(feature.Id, featureName, StringComparison.OrdinalIgnoreCase)));
if (extensionDescriptor == null)
{
Context.Output.WriteLine(T("Creating data migration failed: target Feature {0} could not be found.", featureName));
return;
}
string dataMigrationFolderPath = HostingEnvironment.MapPath("~/Modules/" + extensionDescriptor.Id + "/");
string dataMigrationFilePath = dataMigrationFolderPath + "Migrations.cs";
string templatesPath = HostingEnvironment.MapPath("~/Modules/Orchard." + ModuleName + "/CodeGenerationTemplates/");
string moduleCsProjPath = HostingEnvironment.MapPath(string.Format("~/Modules/{0}/{0}.csproj", extensionDescriptor.Id));
if (!Directory.Exists(dataMigrationFolderPath))
{
Directory.CreateDirectory(dataMigrationFolderPath);
}
if (File.Exists(dataMigrationFilePath))
{
Context.Output.WriteLine(T("Data migration already exists in target Module {0}.", extensionDescriptor.Id));
return;
}
List <SchemaCommand> commands = _schemaCommandGenerator.GetCreateFeatureCommands(featureName, false).ToList();
string dataMigrationText;
using (var stringWriter = new StringWriter()) {
var interpreter = new CodeGenerationCommandInterpreter(stringWriter);
foreach (var command in commands)
{
interpreter.Visit(command);
stringWriter.WriteLine();
}
dataMigrationText = File.ReadAllText(templatesPath + "DataMigration.txt");
dataMigrationText = dataMigrationText.Replace("$$FeatureName$$", featureName);
dataMigrationText = dataMigrationText.Replace("$$Commands$$", stringWriter.ToString());
}
File.WriteAllText(dataMigrationFilePath, dataMigrationText);
string projectFileText = File.ReadAllText(moduleCsProjPath);
// The string searches in solution/project files can be made aware of comment lines.
if (projectFileText.Contains("<Compile Include"))
{
string compileReference = string.Format("<Compile Include=\"{0}\" />\r\n ", "Migrations.cs");
projectFileText = projectFileText.Insert(projectFileText.LastIndexOf("<Compile Include"), compileReference);
}
else
{
string itemGroupReference = string.Format("</ItemGroup>\r\n <ItemGroup>\r\n <Compile Include=\"{0}\" />\r\n ", "Migrations.cs");
projectFileText = projectFileText.Insert(projectFileText.LastIndexOf("</ItemGroup>"), itemGroupReference);
}
File.WriteAllText(moduleCsProjPath, projectFileText);
TouchSolution(Context.Output);
Context.Output.WriteLine(T("Data migration created successfully in Module {0}", extensionDescriptor.Id));
}
/// <summary>
/// Checks whether the module is allowed for the current tenant
/// </summary>
private bool ExtensionIsAllowed(ExtensionDescriptor extensionDescriptor)
{
return(true); //_shellSettings.Modules.Length == 0 || _shellSettings.Modules.Contains(extensionDescriptor.Id);
}
private static bool IsTypeFromModule(Type type, ExtensionDescriptor descriptor)
{
return (type.Namespace + ".").StartsWith(CoreAssemblyName + "." + descriptor.Id + ".");
}
public void Monitor(ExtensionDescriptor extension, Action <IVolatileToken> monitor)
{
}
public bool IsCompatibleWithModuleReferences(ExtensionDescriptor extension, IEnumerable<ExtensionProbeEntry> references)
{
return true;
}
public void ExtensionDeactivated(ExtensionLoadingContext ctx, ExtensionDescriptor extension)
{
}
public static ExtensionDescriptor GetDescriptorForExtension(string locationPath, string extensionId, string extensionType, string manifestText)
{
Dictionary<string, string> manifest = ParseManifest(manifestText);
var extensionDescriptor = new ExtensionDescriptor {
Location = locationPath,
Id = extensionId,
ExtensionType = extensionType,
Name = GetValue(manifest, NameSection) ?? extensionId,
Path = GetValue(manifest, PathSection),
Description = GetValue(manifest, DescriptionSection),
Version = GetValue(manifest, VersionSection),
OrchardVersion = GetValue(manifest, OrchardVersionSection),
Author = GetValue(manifest, AuthorSection),
WebSite = GetValue(manifest, WebsiteSection),
Tags = GetValue(manifest, TagsSection),
AntiForgery = GetValue(manifest, AntiForgerySection),
Zones = GetValue(manifest, ZonesSection),
BaseTheme = GetValue(manifest, BaseThemeSection),
SessionState = GetValue(manifest, SessionStateSection)
};
extensionDescriptor.Features = GetFeaturesForExtension(manifest, extensionDescriptor);
return extensionDescriptor;
}
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 ExtensionEntry BuildEntry(ExtensionDescriptor descriptor)
{
foreach (var loader in _loaders) {
ExtensionEntry entry = loader.Load(descriptor);
if (entry != null)
return entry;
}
_logger.LogWarning("No suitable loader found for extension \"{0}\"", descriptor.Id);
return null;
}
public override void ExtensionDeactivated(ExtensionLoadingContext ctx, ExtensionDescriptor extension)
{
}
public ExtensionEntry Load(ExtensionDescriptor descriptor)
{
return(new ExtensionEntry {
Descriptor = descriptor, ExportedTypes = new[] { typeof(Alpha), typeof(Beta), typeof(Phi) }
});
}
public ExtensionProbeEntry Probe(ExtensionDescriptor descriptor)
{
return null;
}
public ExtensionProbeEntry Probe(ExtensionDescriptor descriptor)
{
return(new ExtensionProbeEntry {
Descriptor = descriptor, Loader = this
});
}
internal void LoadPrecompiledModule(ExtensionDescriptor descriptor)
{
var fileInfo = _hostingEnvironment.GetExtensionFileInfo(descriptor);
var assemblyFolderPath = Path.Combine(fileInfo.PhysicalPath, Constants.BinDirectoryName);
var assemblyPath = Path.Combine(assemblyFolderPath, CompilerUtility.GetAssemblyFileName(descriptor.Id));
// default runtime assemblies: "bin/{assembly}.dll"
var runtimeAssemblies = Directory.GetFiles(assemblyFolderPath,
"*" + FileNameSuffixes.DotNet.DynamicLib, SearchOption.TopDirectoryOnly);
foreach (var asset in runtimeAssemblies)
{
var assetName = Path.GetFileNameWithoutExtension(asset);
if (!IsAmbientAssembly(assetName))
{
var assetFileName = Path.GetFileName(asset);
var assetResolvedPath = ResolveAssemblyPath(assemblyFolderPath, assetFileName);
LoadFromAssemblyPath(assetResolvedPath);
PopulateBinaryFolder(assemblyFolderPath, assetResolvedPath);
PopulateProbingFolder(assetResolvedPath);
}
}
// compile only assemblies: "bin/refs/{assembly}.dll"
if (Directory.Exists(Path.Combine(assemblyFolderPath, CompilerUtility.RefsDirectoryName)))
{
var compilationAssemblies = Directory.GetFiles(
Path.Combine(assemblyFolderPath, CompilerUtility.RefsDirectoryName),
"*" + FileNameSuffixes.DotNet.DynamicLib, SearchOption.TopDirectoryOnly);
foreach (var asset in compilationAssemblies)
{
var assetFileName = Path.GetFileName(asset);
var assetResolvedPath = ResolveAssemblyPath(assemblyFolderPath, assetFileName, CompilerUtility.RefsDirectoryName);
_compileOnlyAssemblies[assetFileName] = assetResolvedPath;
PopulateBinaryFolder(assemblyFolderPath, assetResolvedPath, CompilerUtility.RefsDirectoryName);
PopulateProbingFolder(assetResolvedPath, CompilerUtility.RefsDirectoryName);
}
}
// specific runtime assemblies: "bin/runtimes/{rid}/lib/{tfm}/{assembly}.dll"
if (Directory.Exists(Path.Combine(assemblyFolderPath, PackagingConstants.Folders.Runtimes)))
{
var runtimeIds = GetRuntimeIdentifiers();
var runtimeTargets = Directory.GetFiles(
Path.Combine(assemblyFolderPath, PackagingConstants.Folders.Runtimes),
"*" + FileNameSuffixes.DotNet.DynamicLib, SearchOption.AllDirectories);
foreach (var asset in runtimeTargets)
{
var assetName = Path.GetFileNameWithoutExtension(asset);
if (!IsAmbientAssembly(assetName))
{
var tfmPath = Paths.GetParentFolderPath(asset);
var libPath = Paths.GetParentFolderPath(tfmPath);
var lib = Paths.GetFolderName(libPath);
if (String.Equals(lib, PackagingConstants.Folders.Lib, StringComparison.OrdinalIgnoreCase))
{
var tfm = Paths.GetFolderName(tfmPath);
var runtime = Paths.GetParentFolderName(libPath);
var relativeFolderPath = Path.Combine(PackagingConstants.Folders.Runtimes, runtime, lib, tfm);
if (runtimeIds.Contains(runtime))
{
LoadFromAssemblyPath(asset);
}
PopulateProbingFolder(asset, relativeFolderPath);
}
}
}
}
// resource assemblies: "bin/{locale?}/{assembly}.resources.dll"
var resourceAssemblies = Directory.GetFiles(assemblyFolderPath, "*.resources"
+ FileNameSuffixes.DotNet.DynamicLib, SearchOption.AllDirectories);
var assemblyFolderName = Paths.GetFolderName(assemblyFolderPath);
foreach (var asset in resourceAssemblies)
{
var assetFileName = Path.GetFileName(asset);
var locale = Paths.GetParentFolderName(asset).Replace(assemblyFolderName, String.Empty);
var assetResolvedPath = ResolveAssemblyPath(assemblyFolderPath, assetFileName, locale);
PopulateBinaryFolder(assemblyFolderPath, assetResolvedPath, locale);
PopulateProbingFolder(assetResolvedPath, locale);
PopulateRuntimeFolder(assetResolvedPath, locale);
}
}
public abstract bool LoaderIsSuitable(ExtensionDescriptor descriptor);
private bool IsAmbientExtension(ExtensionDescriptor descriptor)
{
return(IsAmbientAssembly(descriptor.Id));
}
public override void ExtensionDeactivated(ExtensionLoadingContext ctx, ExtensionDescriptor extension)
{
DeleteAssembly(ctx, extension.Id);
}
protected override ExtensionEntry LoadWorker(ExtensionDescriptor descriptor)
{
return(null);
}
private IViewEngine ShallowEngines(ExtensionDescriptor theme)
{
//return _configuredEnginesCache.BindShallowEngines(theme.ThemeName, () => new ViewEngineCollectionWrapper(_viewEngineProviders.Select(vep => vep.CreateBareViewEngine())));
return(DeepEngines(theme));
}
public ActionResult Index(int?layerId, string culture)
{
ExtensionDescriptor currentTheme = _siteThemeService.GetSiteTheme();
if (currentTheme == null)
{
Services.Notifier.Error(T("To manage widgets you must have a theme enabled."));
return(RedirectToAction("Index", "Admin", new { area = "Dashboard" }));
}
IEnumerable <LayerPart> layers = _widgetsService.GetLayers().OrderBy(x => x.Name).ToList();
if (!layers.Any())
{
Services.Notifier.Error(T("There are no widget layers defined. A layer will need to be added in order to add widgets to any part of the site."));
return(RedirectToAction("AddLayer"));
}
LayerPart currentLayer = layerId == null
? layers.FirstOrDefault(layer => layer.Name == "Default") ?? layers.FirstOrDefault()
: layers.FirstOrDefault(layer => layer.Id == layerId);
if (currentLayer == null && layerId != null) // Incorrect layer id passed
{
Services.Notifier.Error(T("Layer not found: {0}", layerId));
return(RedirectToAction("Index"));
}
IEnumerable <string> allZones = _widgetsService.GetZones();
IEnumerable <string> currentThemesZones = _widgetsService.GetZones(currentTheme);
string zonePreviewImagePath = string.Format("{0}/{1}/ThemeZonePreview.png", currentTheme.Location, currentTheme.Id);
string zonePreviewImage = _virtualPathProvider.FileExists(zonePreviewImagePath) ? zonePreviewImagePath : null;
var widgets = _widgetsService.GetWidgets();
if (!String.IsNullOrWhiteSpace(culture))
{
widgets = widgets.Where(x => {
if (x.Has <ILocalizableAspect>())
{
return(String.Equals(x.As <ILocalizableAspect>().Culture, culture, StringComparison.InvariantCultureIgnoreCase));
}
return(false);
}).ToList();
}
var viewModel = Shape.ViewModel()
.CurrentTheme(currentTheme)
.CurrentLayer(currentLayer)
.CurrentCulture(culture)
.Layers(layers)
.Widgets(widgets)
.Zones(currentThemesZones)
.Cultures(_cultureManager.ListCultures())
.OrphanZones(allZones.Except(currentThemesZones))
.OrphanWidgets(_widgetsService.GetOrphanedWidgets())
.ZonePreviewImage(zonePreviewImage);
return(View(viewModel));
}
public void ExtensionActivated(ExtensionLoadingContext ctx, ExtensionDescriptor extension)
{
}
private void ProcessExtension(ExtensionLoadingContext context, ExtensionDescriptor extension)
{
var extensionProbes = context.AvailableExtensionsProbes.ContainsKey(extension.Id) ?
context.AvailableExtensionsProbes[extension.Id] :
Enumerable.Empty <ExtensionProbeEntry>();
// materializes the list
extensionProbes = extensionProbes.ToArray();
if (Logger.IsEnabled(LogLevel.Debug))
{
Logger.Debug("Loaders for extension \"{0}\": ", extension.Id);
foreach (var probe in extensionProbes)
{
Logger.Debug(" Loader: {0}", probe.Loader.Name);
Logger.Debug(" VirtualPath: {0}", probe.VirtualPath);
Logger.Debug(" VirtualPathDependencies: {0}", string.Join(", ", probe.VirtualPathDependencies));
}
}
var moduleReferences =
context.AvailableExtensions
.Where(e =>
context.ReferencesByModule.ContainsKey(extension.Id) &&
context.ReferencesByModule[extension.Id].Any(r => StringComparer.OrdinalIgnoreCase.Equals(e.Id, r.Name)))
.ToList();
var processedModuleReferences =
moduleReferences
.Where(e => context.ProcessedExtensions.ContainsKey(e.Id))
.Select(e => context.ProcessedExtensions[e.Id])
.ToList();
var activatedExtension = extensionProbes.FirstOrDefault(
e => e.Loader.IsCompatibleWithModuleReferences(extension, processedModuleReferences)
);
var previousDependency = context.PreviousDependencies.FirstOrDefault(
d => StringComparer.OrdinalIgnoreCase.Equals(d.Name, extension.Id)
);
if (activatedExtension == null)
{
Logger.Warning("No loader found for extension \"{0}\"!", extension.Id);
}
var references = ProcessExtensionReferences(context, activatedExtension);
foreach (var loader in _loaders)
{
if (activatedExtension != null && activatedExtension.Loader.Name == loader.Name)
{
Logger.Information("Activating extension \"{0}\" with loader \"{1}\"", activatedExtension.Descriptor.Id, loader.Name);
loader.ExtensionActivated(context, extension);
}
else if (previousDependency != null && previousDependency.LoaderName == loader.Name)
{
Logger.Information("Deactivating extension \"{0}\" from loader \"{1}\"", previousDependency.Name, loader.Name);
loader.ExtensionDeactivated(context, extension);
}
}
if (activatedExtension != null)
{
context.NewDependencies.Add(new DependencyDescriptor
{
Name = extension.Id,
LoaderName = activatedExtension.Loader.Name,
VirtualPath = activatedExtension.VirtualPath,
References = references
});
}
// Keep track of which loader we use for every extension
// This will be needed for processing references from other dependent extensions
context.ProcessedExtensions.Add(extension.Id, activatedExtension);
}
public ExtensionProbeEntry Probe(ExtensionDescriptor descriptor)
{
return(null);
}
public MockThemeManager(ExtensionDescriptor des)
{
_dec = des;
}
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);
}
/// <summary>
/// Instantiates a theme based on an extension descriptor.
/// </summary>
/// <param name="extensionDescriptor">The extension descriptor.</param>
public ThemeEntry(ExtensionDescriptor extensionDescriptor)
{
Descriptor = extensionDescriptor;
}
public IEnumerable <ExtensionReferenceProbeEntry> ProbeReferences(ExtensionDescriptor extensionDescriptor)
{
throw new NotImplementedException();
}
public ExtensionEntry Load(ExtensionDescriptor descriptor)
{
return(new ExtensionEntry {
Descriptor = descriptor, ExportedTypes = new[] { typeof(BlogRecord), typeof(BodyRecord), typeof(BlogArchiveRecord) }
});
}
public void ExtensionDeactivated(ExtensionLoadingContext ctx, ExtensionDescriptor extension)
{
throw new NotImplementedException();
}
public virtual IEnumerable <ExtensionReferenceProbeEntry> ProbeReferences(ExtensionDescriptor descriptor)
{
return(Enumerable.Empty <ExtensionReferenceProbeEntry>());
}
public bool IsCompatibleWithModuleReferences(ExtensionDescriptor extension, IEnumerable <ExtensionProbeEntry> references)
{
throw new NotImplementedException();
}
public abstract ExtensionProbeEntry Probe(ExtensionDescriptor descriptor);
public ActionResult Index()
{
bool installThemes =
_featureManager.GetEnabledFeatures().FirstOrDefault(f => f.Id == "PackagingServices") != null &&
Services.Authorizer.Authorize(StandardPermissions.SiteOwner) && // only site owners
_shellSettings.Name == ShellSettings.DefaultName; // of the default tenant
var featuresThatNeedUpdate = _dataMigrationManager.GetFeaturesThatNeedUpdate();
ThemeEntry currentTheme = null;
ExtensionDescriptor currentThemeDescriptor = _siteThemeService.GetSiteTheme();
if (currentThemeDescriptor != null)
{
currentTheme = new ThemeEntry(currentThemeDescriptor);
}
IEnumerable <ThemeEntry> themes = _extensionManager.AvailableExtensions()
.Where(extensionDescriptor => {
bool hidden = false;
string tags = extensionDescriptor.Tags;
if (tags != null)
{
hidden = tags.Split(',').Any(t => t.Trim().Equals("hidden", StringComparison.OrdinalIgnoreCase));
}
// is the theme allowed for this tenant ?
bool allowed = _shellSettings.Themes.Length == 0 || _shellSettings.Themes.Contains(extensionDescriptor.Id);
return(!hidden && allowed &&
DefaultExtensionTypes.IsTheme(extensionDescriptor.ExtensionType) &&
(currentTheme == null ||
!currentTheme.Descriptor.Id.Equals(extensionDescriptor.Id)));
})
.Select(extensionDescriptor => {
ThemeEntry themeEntry = new ThemeEntry(extensionDescriptor)
{
NeedsUpdate = featuresThatNeedUpdate.Contains(extensionDescriptor.Id),
IsRecentlyInstalled = _themeService.IsRecentlyInstalled(extensionDescriptor),
Enabled = _shellDescriptor.Features.Any(sf => sf.Name == extensionDescriptor.Id),
CanUninstall = installThemes
};
if (_extensionDisplayEventHandler != null)
{
foreach (string notification in _extensionDisplayEventHandler.Displaying(themeEntry.Descriptor, ControllerContext.RequestContext))
{
themeEntry.Notifications.Add(notification);
}
}
return(themeEntry);
})
.ToArray();
return(View(new ThemesIndexViewModel {
CurrentTheme = currentTheme,
InstallThemes = installThemes,
Themes = themes
}));
}
protected abstract ExtensionEntry LoadWorker(ExtensionDescriptor descriptor);
