More work around the feature management UI and hooked a little force enable/disable

--HG--
branch : dev

src/Orchard.Web/Modules/Orchard.Modules/Controllers/AdminController.cs

@@ -1,11 +1,8 @@
 using System.Linq;
-using System.Reflection;
 using System.Web.Mvc;
 using Orchard.Localization;
 using Orchard.Modules.ViewModels;
-using Orchard.Mvc.AntiForgery;
 using Orchard.Mvc.Results;
-using Orchard.UI.Notify;
 
 namespace Orchard.Modules.Controllers {
     public class AdminController : Controller {
@@ -37,9 +34,7 @@ namespace Orchard.Modules.Controllers {
             if (module == null)
                 return new NotFoundResult();
 
-            return View(new ModuleEditViewModel {
+            return View(new ModuleEditViewModel {Name = module.DisplayName});
-                                               Name = module.DisplayName
-                                           });
         }
 
         public ActionResult Features() {
@@ -50,43 +45,30 @@ namespace Orchard.Modules.Controllers {
             return View(new FeaturesViewModel {Features = features});
         }
 
-        [ValidateAntiForgeryTokenOrchard]
+        [HttpPost]
-        public ActionResult Enable(string id) {
+        public ActionResult Enable(string id, bool? force) {
             if (!Services.Authorizer.Authorize(Permissions.ManageFeatures, T("Not allowed to manage features")))
                 return new HttpUnauthorizedResult();
 
             if (string.IsNullOrEmpty(id))
                 return new NotFoundResult();
 
-            _moduleService.EnableFeatures(new [] {id});
+            _moduleService.EnableFeatures(new[] {id}, force != null && (bool) force);
 
             return RedirectToAction("Features");
         }
 
-        [ValidateAntiForgeryTokenOrchard]
+        [HttpPost]
-        public ActionResult Disable(string id) {
+        public ActionResult Disable(string id, bool? force) {
             if (!Services.Authorizer.Authorize(Permissions.ManageFeatures, T("Not allowed to manage features")))
                 return new HttpUnauthorizedResult();
 
             if (string.IsNullOrEmpty(id))
                 return new NotFoundResult();
 
-            _moduleService.DisableFeatures(new[] { id });
+            _moduleService.DisableFeatures(new[] {id}, force != null && (bool) force);
 
             return RedirectToAction("Features");
         }
-
-        private class FormValueRequiredAttribute : ActionMethodSelectorAttribute {
-            private readonly string _submitButtonName;
-
-            public FormValueRequiredAttribute(string submitButtonName) {
-                _submitButtonName = submitButtonName;
-            }
-
-            public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo) {
-                var value = controllerContext.HttpContext.Request.Form[_submitButtonName];
-                return !string.IsNullOrEmpty(value);
-            }
-        }
     }
 }

src/Orchard.Web/Modules/Orchard.Modules/Services/ModuleService.cs

@@ -16,7 +16,8 @@ namespace Orchard.Modules.Services {
         private readonly IExtensionManager _extensionManager;
         private readonly IShellDescriptorManager _shellDescriptorManager;
 
-        public ModuleService(IOrchardServices orchardServices,IExtensionManager extensionManager, IShellDescriptorManager shellDescriptorManager) {
+        public ModuleService(IOrchardServices orchardServices, IExtensionManager extensionManager,
+                             IShellDescriptorManager shellDescriptorManager) {
             Services = orchardServices;
             _extensionManager = extensionManager;
             _shellDescriptorManager = shellDescriptorManager;
@@ -27,15 +28,20 @@ namespace Orchard.Modules.Services {
         public IOrchardServices Services { get; set; }
 
         public IModule GetModuleByName(string moduleName) {
-            return _extensionManager.AvailableExtensions().Where(e => string.Equals(e.Name, moduleName, StringComparison.OrdinalIgnoreCase) && string.Equals(e.ExtensionType, ModuleExtensionType, StringComparison.OrdinalIgnoreCase)).Select(
+            return
-                descriptor => AssembleModuleFromDescriptor(descriptor)).FirstOrDefault();
+                _extensionManager.AvailableExtensions().Where(
+                    e =>
+                    string.Equals(e.Name, moduleName, StringComparison.OrdinalIgnoreCase) &&
+                    string.Equals(e.ExtensionType, ModuleExtensionType, StringComparison.OrdinalIgnoreCase)).Select(
+                        descriptor => AssembleModuleFromDescriptor(descriptor)).FirstOrDefault();
         }
 
         public IEnumerable<IModule> GetInstalledModules() {
             return
                 _extensionManager.AvailableExtensions().Where(
-                    e => String.Equals(e.ExtensionType, ModuleExtensionType, StringComparison.OrdinalIgnoreCase)).Select(
+                    e => String.Equals(e.ExtensionType, ModuleExtensionType, StringComparison.OrdinalIgnoreCase)).Select
-                    descriptor => AssembleModuleFromDescriptor(descriptor));
+                    (
+                        descriptor => AssembleModuleFromDescriptor(descriptor));
         }
 
         public void InstallModule(HttpPostedFileBase file) {
@@ -46,86 +52,145 @@ namespace Orchard.Modules.Services {
             _extensionManager.UninstallExtension(ModuleExtensionType, moduleName);
         }
 
-        public IModule GetModuleByFeatureName(string featureName) {
-            return GetInstalledModules()
-                .Where(
-                m =>
-                m.Features.FirstOrDefault(f => string.Equals(f.Name, featureName, StringComparison.OrdinalIgnoreCase)) !=
-                null).FirstOrDefault();
-        }
-
         public IEnumerable<IModuleFeature> GetAvailableFeatures() {
             var enabledFeatures = _shellDescriptorManager.GetShellDescriptor().EnabledFeatures;
             return GetInstalledModules()
                 .SelectMany(m => _extensionManager.LoadFeatures(m.Features))
-                .Select(f => AssembleModuleFromDescriptor(f, enabledFeatures.FirstOrDefault(sf => string.Equals(sf.Name, f.Descriptor.Name, StringComparison.OrdinalIgnoreCase)) != null));
+                .Select(
-        }
+                    f =>
-
+                    AssembleModuleFromDescriptor(f,
-        public IEnumerable<Feature> GetAvailableFeaturesByModule(string moduleName) {
+                                                 enabledFeatures.FirstOrDefault(
-            throw new NotImplementedException();
+                                                     sf =>
+                                                     string.Equals(sf.Name, f.Descriptor.Name,
+                                                                   StringComparison.OrdinalIgnoreCase)) != null));
         }
 
         public void EnableFeatures(IEnumerable<string> featureNames) {
+            EnableFeatures(featureNames, false);
+        }
+
+        public void EnableFeatures(IEnumerable<string> features, bool force) {
             var shellDescriptor = _shellDescriptorManager.GetShellDescriptor();
             var enabledFeatures = shellDescriptor.EnabledFeatures.ToList();
-            var features = GetAvailableFeatures().ToList();
 
-            foreach (var name in featureNames) {
+            var featuresToEnable =
-                var featureName = name;
+                features.Select(s => EnableFeature(s, GetAvailableFeatures(), force)).
-                var feature = features.Single(f => f.Descriptor.Name == featureName);
+                    SelectMany(ies => ies.Select(s => s));
-                var sleepingDependencies =
-                    feature.Descriptor.Dependencies.Where(s => enabledFeatures.FirstOrDefault(sf => sf.Name == s) == null);
 
-                if (sleepingDependencies.Count() != 0) {
+            if (featuresToEnable.Count() == 0)
-                    Services.Notifier.Warning(T(
+                return;
-                        "If you want to enable {0}, then you'll also need {1} (and I won't let you flip everything on in one go yet).",
+
-                        featureName,
+            foreach (var featureToEnable in featuresToEnable) {
-                        sleepingDependencies.Count() > 1
+                enabledFeatures.Add(new ShellFeature {Name = featureToEnable});
-                            ? string.Join("",
+                Services.Notifier.Information(T("{0} was enabled", featureToEnable));
-                                          sleepingDependencies.Select(
-                                              (s, i) =>
-                                              i == sleepingDependencies.Count() - 2
-                                                  ? T("{0} and ", s).ToString()
-                                                  : T("{0}, ", s).ToString()).ToArray())
-                            : sleepingDependencies.First()));
-                } else if (enabledFeatures.FirstOrDefault(f => f.Name == featureName) == null) {
-                    enabledFeatures.Add(new ShellFeature {Name = featureName});
-                    Services.Notifier.Information(T("{0} was enabled", featureName));
-                }
             }
 
-            _shellDescriptorManager.UpdateShellDescriptor(shellDescriptor.SerialNumber, enabledFeatures, shellDescriptor.Parameters);
+            _shellDescriptorManager.UpdateShellDescriptor(shellDescriptor.SerialNumber, enabledFeatures,
+                                                          shellDescriptor.Parameters);
         }
 
         public void DisableFeatures(IEnumerable<string> featureNames) {
+            DisableFeatures(featureNames, false);
+        }
+
+        public void DisableFeatures(IEnumerable<string> features, bool force) {
             var shellDescriptor = _shellDescriptorManager.GetShellDescriptor();
             var enabledFeatures = shellDescriptor.EnabledFeatures.ToList();
-            var features = GetAvailableFeatures().ToList();
 
-            foreach (var name in featureNames) {
+            var featuresToDisable =
-                var featureName = name;
+                features.Select(s => DisableFeature(s, GetAvailableFeatures(), force)).SelectMany(
-                var dependants = features.Where(f => f.IsEnabled && f.Descriptor.Dependencies != null && f.Descriptor.Dependencies.Contains(featureName));
+                    ies => ies.Select(s => s));
 
-                if (dependants.Count() != 0) {
+            if (featuresToDisable.Count() == 0)
-                    Services.Notifier.Warning(T(
+                return;
-                        "If you want to disable {0}, then you'll also lose {1} (and I won't let you do that yet).",
+
-                        featureName,
+            foreach (var featureToDisable in featuresToDisable) {
-                        dependants.Count() > 0
+                var feature = featureToDisable;
-                            ? string.Join("",
+                enabledFeatures.RemoveAll(f => f.Name == feature);
-                                          dependants.Select(
+                Services.Notifier.Information(T("{0} was disabled", feature));
-                                              (f, i) =>
-                                              i == dependants.Count() - 2
-                                                  ? T("{0} and ", f.Descriptor.Name).ToString()
-                                                  : T("{0}, ", f.Descriptor.Name).ToString()).ToArray())
-                            : dependants.First().Descriptor.Name));
-                }
-                else {
-                    enabledFeatures.RemoveAll(f => f.Name == featureName);
-                    Services.Notifier.Information(T("{0} was disabled", featureName));
-                }
             }
 
-            _shellDescriptorManager.UpdateShellDescriptor(shellDescriptor.SerialNumber, enabledFeatures, shellDescriptor.Parameters);
+            _shellDescriptorManager.UpdateShellDescriptor(shellDescriptor.SerialNumber, enabledFeatures,
+                                                          shellDescriptor.Parameters);
+        }
+
+        public IModule GetModuleByFeatureName(string featureName) {
+            return GetInstalledModules()
+                .Where(
+                    m =>
+                    m.Features.FirstOrDefault(
+                        f => string.Equals(f.Name, featureName, StringComparison.OrdinalIgnoreCase)) !=
+                    null).FirstOrDefault();
+        }
+
+        private IEnumerable<string> EnableFeature(string featureName, IEnumerable<IModuleFeature> features, bool force) {
+            var featuresList = features.ToList();
+            var getDisabledDependencies =
+                new Func<string, IEnumerable<IModuleFeature>, IEnumerable<IModuleFeature>>(
+                    (n, fs) => {
+                        var feature = fs.Single(f => f.Descriptor.Name == n);
+                        return feature.Descriptor.Dependencies != null
+                                   ? feature.Descriptor.Dependencies.Select(
+                                       fn => fs.Single(f => f.Descriptor.Name == fn)).Where(f => !f.IsEnabled)
+                                   : Enumerable.Empty<IModuleFeature>();
+                    });
+
+            var featuresToEnable = GetAffectedFeatures(featureName, featuresList, getDisabledDependencies);
+
+            if (featuresToEnable.Count() > 1 && !force) {
+                GenerateWarning("If you want {0} enabled, then you'll also need to enable {1}.",
+                                featureName,
+                                featuresToEnable.Where(fn => fn != featureName));
+                return Enumerable.Empty<string>();
+            }
+
+            return featuresToEnable;
+        }
+
+        private IEnumerable<string> DisableFeature(string featureName, IEnumerable<IModuleFeature> features, bool force) {
+            var featuresList = features.ToList();
+            var getEnabledDependants =
+                new Func<string, IEnumerable<IModuleFeature>, IEnumerable<IModuleFeature>>(
+                    (n, fs) => fs.Where(f => f.IsEnabled && f.Descriptor.Dependencies != null && f.Descriptor.Dependencies.Contains(n)));
+
+            var featuresToDisable = GetAffectedFeatures(featureName, featuresList, getEnabledDependants);
+
+            if (featuresToDisable.Count() > 1 && !force) {
+                GenerateWarning("If {0} is disabled, then you'll also lose {1}.",
+                                featureName,
+                                featuresToDisable.Where(fn => fn != featureName));
+                return Enumerable.Empty<string>();
+            }
+
+            return featuresToDisable;
+        }
+
+        private static IEnumerable<string> GetAffectedFeatures(string featureName, IEnumerable<IModuleFeature> features, Func<string, IEnumerable<IModuleFeature>, IEnumerable<IModuleFeature>> getAffectedDependencies) {
+            var dependencies = new List<string> {featureName};
+
+            foreach (var dependency in getAffectedDependencies(featureName, features))
+                dependencies.AddRange(GetAffectedFeatures(dependency.Descriptor.Name, features, getAffectedDependencies));
+
+            return dependencies;
+        }
+
+        private void GenerateWarning(string messageFormat, string featureName, IEnumerable<string> featuresInQuestion) {
+            if (featuresInQuestion.Count() < 1)
+                return;
+
+            Services.Notifier.Warning(T(
+                messageFormat,
+                featureName,
+                featuresInQuestion.Count() > 1
+                    ? string.Join("",
+                                  featuresInQuestion.Select(
+                                      (fn, i) =>
+                                      T(i == featuresInQuestion.Count() - 1
+                                            ? "{0}"
+                                            : (i == featuresInQuestion.Count() - 2
+                                                   ? "{0} and "
+                                                   : "{0}, "), fn).ToString()).ToArray())
+                    : featuresInQuestion.First()));
         }
 
         private static IModule AssembleModuleFromDescriptor(ExtensionDescriptor extensionDescriptor) {

src/Orchard.Web/Modules/Orchard.Modules/Views/Admin/Features.ascx

@@ -56,6 +56,22 @@
                         }
                         } %>
                     </div>
+                    <div class="cathedral"><%
+                        //temporary forceful feature actions
+                        if (feature.IsEnabled) {
+                        using (Html.BeginFormAntiForgeryPost(string.Format("{0}", Url.Action("Disable", new { area = "Orchard.Modules" })), FormMethod.Post, new {@class = "inline link"})) { %>
+                            <%=Html.Hidden("id", feature.Descriptor.Name, new { id = "" })%>
+                            <%=Html.Hidden("force", true)%>
+                            <button type="submit"><%=_Encoded("π")%></button><%
+                        }
+                        } else {
+                        using (Html.BeginFormAntiForgeryPost(string.Format("{0}", Url.Action("Enable", new { area = "Orchard.Modules" })), FormMethod.Post, new {@class = "inline link"})) { %>
+                            <%=Html.Hidden("id", feature.Descriptor.Name, new { id = "" })%>
+                            <%=Html.Hidden("force", true)%>
+                            <button type="submit"><%=_Encoded("π")%></button><%
+                        }
+                        } %>
+                    </div>
                 </div>
             </li><%
             } %>

src/Orchard.Web/Modules/Orchard.Modules/styles/admin.css

@@ -1,4 +1,9 @@
-.features .category {
+.orchard-modules #main h2 {
+    border:0;
+    margin-bottom:.2em;
+}
+
+.features .category {
     overflow:hidden;
 }
 .features .feature {
@@ -28,8 +33,8 @@
 }
 
 .features .enabled.feature {
-    background:#D1F2A5;
+    background:#FFF;
-    border-color:#BCD994;
+    border-color:#CFE493;cfe493
 }
 .features .disabled.feature {
     background:#EAEAEA;
@@ -40,7 +45,7 @@
     padding:.4em .5em;
 }
 .features .dependencies li,
-.features .actions a {
+.features .actions {
     font-size:1.4em;
 }
 .features .dependencies {
@@ -65,3 +70,16 @@
     right:.8em;
     top:.6em;
 }
+
+.cathedral {
+    bottom:0;
+    font-size:.8em;
+    position:absolute;
+    right:3px;
+}
+.cathedral a,
+.cathedral a:link,
+.cathedral a:visited,
+.cathedral form.inline.link button {
+    color:#aeaeae;
+}

src/Orchard.Web/Themes/TheAdmin/Styles/site.css

@@ -337,8 +337,8 @@ span.message {
 	color:#fff;
 }
 .info.message {
-    background:#D1F2A5; /* green*/
+    background:#e6f1c9; /* green */
-	border:1px solid #BCD994;
+	border:1px solid #cfe493;
 	color:#062232;
 }
 .debug.message {

src/Orchard/Modules/IModuleService.cs

@@ -1,6 +1,5 @@
 using System.Collections.Generic;
 using System.Web;
-using Orchard.Environment.Extensions.Models;
 
 namespace Orchard.Modules {
     public interface IModuleService : IDependency {
@@ -8,9 +7,10 @@ namespace Orchard.Modules {
         IEnumerable<IModule> GetInstalledModules();
         void InstallModule(HttpPostedFileBase file);
         void UninstallModule(string moduleName);
-        IModule GetModuleByFeatureName(string featureName);
         IEnumerable<IModuleFeature> GetAvailableFeatures();
         void EnableFeatures(IEnumerable<string> featureNames);
+        void EnableFeatures(IEnumerable<string> featureNames, bool force);
         void DisableFeatures(IEnumerable<string> featureNames);
+        void DisableFeatures(IEnumerable<string> featureNames, bool force);
     }
 }