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)
}));
}
protected ActionResult ListExtensions(PackagingExtensionsOptions options, string packageType, Pager pager)
{
var selectedSource = _packagingSourceManager.GetSources().Where(s => s.Id == options.SourceId).FirstOrDefault();
var sources = selectedSource != null
? new[] { selectedSource }
: _packagingSourceManager.GetSources()
;
IEnumerable <PackagingEntry> extensions = null;
int totalCount = 0;
foreach (var source in sources)
{
try {
var sourceExtensions = _packagingSourceManager.GetExtensionList(true,
source,
packages => {
packages = packages.Where(p => p.PackageType == packageType &&
p.IsLatestVersion &&
(string.IsNullOrEmpty(options.SearchText) ||
p.Title.Contains(options.SearchText) ||
p.Description.Contains(options.SearchText) ||
p.Tags.Contains(options.SearchText)
));
switch (options.Order)
{
case PackagingExtensionsOrder.Downloads:
packages = packages.OrderByDescending(p => p.DownloadCount).ThenBy(p => p.Title);
break;
case PackagingExtensionsOrder.Ratings:
packages = packages.OrderByDescending(p => p.Rating).ThenBy(p => p.Title);
break;
case PackagingExtensionsOrder.Alphanumeric:
packages = packages.OrderBy(p => p.Title);
break;
}
if (pager.PageSize != 0)
{
packages = packages.Skip((pager.Page - 1) * pager.PageSize).Take(pager.PageSize);
}
return(packages);
}).ToArray();
// count packages separately to prevent loading everything just to count
totalCount += _packagingSourceManager.GetExtensionCount(
source,
packages => packages.Where(p => p.PackageType == packageType &&
p.IsLatestVersion &&
(string.IsNullOrEmpty(options.SearchText) || p.Title.Contains(options.SearchText)))
);
extensions = extensions == null ? sourceExtensions : extensions.Concat(sourceExtensions);
// apply another paging rule in case there were multiple sources
if (sources.Count() > 1)
{
switch (options.Order)
{
case PackagingExtensionsOrder.Downloads:
extensions = extensions.OrderByDescending(p => p.DownloadCount).ThenBy(p => p.Title);
break;
case PackagingExtensionsOrder.Ratings:
extensions = extensions.OrderByDescending(p => p.Rating).ThenBy(p => p.Title);
break;
case PackagingExtensionsOrder.Alphanumeric:
extensions = extensions.OrderBy(p => p.Title);
break;
}
if (pager.PageSize != 0)
{
extensions = extensions.Take(pager.PageSize);
}
}
} catch (Exception exception) {
this.Error(exception, T("Error loading extensions from gallery source '{0}'. {1}.", source.FeedTitle, exception.Message), Logger, Services.Notifier);
}
}
extensions = extensions ?? new PackagingEntry[0];
var pagerShape = Services.New.Pager(pager).TotalItemCount(totalCount);
// maintain previous route data when generating page links
var routeData = new RouteData();
routeData.Values.Add("Options.Order", options.Order);
routeData.Values.Add("Options.SearchText", options.SearchText);
routeData.Values.Add("Options.SourceId", options.SourceId);
pagerShape.RouteData(routeData);
extensions = extensions.ToList();
// Populate the notifications
IEnumerable <Tuple <ExtensionDescriptor, PackagingEntry> > extensionDescriptors = _extensionManager.AvailableExtensions()
.Join(extensions, extensionDescriptor => extensionDescriptor.Id, packaginEntry => packaginEntry.ExtensionId(),
(extensionDescriptor, packagingEntry) => new Tuple <ExtensionDescriptor, PackagingEntry>(extensionDescriptor, packagingEntry));
foreach (Tuple <ExtensionDescriptor, PackagingEntry> packagings in extensionDescriptors)
{
packagings.Item2.Installed = true;
if (_extensionDisplayEventHandler != null)
{
foreach (string notification in _extensionDisplayEventHandler.Displaying(packagings.Item1, ControllerContext.RequestContext))
{
packagings.Item2.Notifications.Add(notification);
}
}
}
return(View(packageType == DefaultExtensionTypes.Theme ? "Themes" : "Modules", new PackagingExtensionsViewModel {
Extensions = extensions,
Sources = _packagingSourceManager.GetSources().OrderBy(s => s.FeedTitle),
Pager = pagerShape,
Options = options
}));
}
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
}));
}
