Update: Use Generics for Compiled View

Also standardize inclusion of StyleSheets/Scripts for Plugin Resources

Disco.Services/Plugins/Features/UIExtension/Results/PluginResourceCssResult.cs

@@ -13,18 +13,18 @@ namespace Disco.Services.Plugins.Features.UIExtension.Results
     public class PluginResourceCssResult : UIExtensionResult
     {
         private string _resource;
-        private HtmlString _resourceUrl;
+        private string _resourceUrl;
 
         public PluginResourceCssResult(PluginFeatureManifest Source, string Resource)
             : base(Source)
         {
             this._resource = Resource;
-            this._resourceUrl = new HtmlString(Source.PluginManifest.WebResourceUrl(Resource));
+            this._resourceUrl = Source.PluginManifest.WebResourceUrl(Resource);
 
-            var deferredBundles = HttpContext.Current.Items[Bundle.UIExtensionCssKey] as List<HtmlString>;
+            var deferredBundles = HttpContext.Current.Items[Bundle.UIExtensionCssKey] as List<string>;
             if (deferredBundles == null)
             {
-                deferredBundles = new List<HtmlString>();
+                deferredBundles = new List<string>();
                 HttpContext.Current.Items[Bundle.UIExtensionCssKey] = deferredBundles;
             }
             if (!deferredBundles.Contains(this._resourceUrl))

Disco.Services/Plugins/Features/UIExtension/Results/PluginResourceScriptResult.cs

@@ -11,22 +11,22 @@ namespace Disco.Services.Plugins.Features.UIExtension.Results
     public class PluginResourceScriptResult : UIExtensionResult
     {
         private string _resource;
-        private HtmlString _resourceUrl;
+        private string _resourceUrl;
         private bool _placeInPageHead;
 
         public PluginResourceScriptResult(PluginFeatureManifest Source, string Resource, bool PlaceInPageHead)
             : base(Source)
         {
             this._resource = Resource;
-            this._resourceUrl = new HtmlString(Source.PluginManifest.WebResourceUrl(Resource));
+            this._resourceUrl = Source.PluginManifest.WebResourceUrl(Resource);
             this._placeInPageHead = PlaceInPageHead;
 
             if (this._placeInPageHead)
             {
-                var deferredBundles = HttpContext.Current.Items[Bundle.UIExtensionScriptsKey] as List<HtmlString>;
+                var deferredBundles = HttpContext.Current.Items[Bundle.UIExtensionScriptsKey] as List<string>;
                 if (deferredBundles == null)
                 {
-                    deferredBundles = new List<HtmlString>();
+                    deferredBundles = new List<string>();
                     HttpContext.Current.Items[Bundle.UIExtensionScriptsKey] = deferredBundles;
                 }
                 if (!deferredBundles.Contains(this._resourceUrl))

Disco.Services/Plugins/Features/UIExtension/UIExtensionFeature.cs

@@ -12,8 +12,27 @@ namespace Disco.Services.Plugins.Features.UIExtension
     [PluginFeatureCategory(DisplayName = "User Interface Extensions")]
     public abstract class UIExtensionFeature<UIModel> : PluginFeature where UIModel : BaseUIModel
     {
+        public ControllerContext Context { get; set; }
+
         public abstract UIExtensionResult ExecuteAction(ControllerContext context, UIModel model);
 
+        #region Bundles
+        public void IncludeStyleSheet(string Resource)
+        {
+            if (this.Context == null)
+                throw new NullReferenceException("This method can only be called when a Context is available");
+
+            this.Context.HttpContext.IncludeStyleSheetResource(Resource, this.Manifest.PluginManifest);
+        }
+        public void IncludeScript(string Resource)
+        {
+            if (this.Context == null)
+                throw new NullReferenceException("This method can only be called when a Context is available");
+
+            this.Context.HttpContext.IncludeScriptResource(Resource, this.Manifest.PluginManifest);
+        }
+        #endregion
+
         #region ActionResults
 
         protected LiteralResult Literal(string Content)
@@ -40,10 +59,15 @@ namespace Disco.Services.Plugins.Features.UIExtension
         {
             return new MultipleResult(this.Manifest, Results);
         }
+        [Obsolete("Use: PartialCompiled<ViewType>(dynamic Model)")]
         protected PrecompiledPartialViewResult Partial(Type PartialViewType, object Model = null)
         {
             return new PrecompiledPartialViewResult(this.Manifest, PartialViewType, Model);
         }
+        protected PrecompiledPartialViewResult PartialCompiled<ViewType>(dynamic Model = null) where ViewType : WebViewPage
+        {
+            return new PrecompiledPartialViewResult(this.Manifest, typeof(ViewType), Model);
+        }
 
         #endregion
 

Disco.Services/Plugins/Features/UIExtension/UIExtensions.cs

@@ -46,6 +46,7 @@ namespace Disco.Services.Plugins.Features.UIExtension
             {
                 using (var uiExtInstance = uiExt.CreateInstance<UIExtensionFeature<UIModel>>())
                 {
+                    uiExtInstance.Context = context;
                     uiExtResults.Enqueue(uiExtInstance.ExecuteAction(context, model));
                 }
             }

Disco.Services/Plugins/PluginConfigurationHandler.cs

@@ -20,17 +20,24 @@ namespace Disco.Services.Plugins
             // Nothing in Base Class
         }
 
+        [Obsolete("Use: Response<ViewType>(dynamic ViewModel)")]
         protected PluginConfigurationHandlerGetResponse GetResponse(Type ViewType, dynamic ViewModel = null)
         {
             return new PluginConfigurationHandlerGetResponse(this.Manifest, ViewType, ViewModel);
         }
+
+        protected PluginConfigurationHandlerGetResponse Response<ViewType>(dynamic Model = null) where ViewType : WebViewPage
+        {
+            return new PluginConfigurationHandlerGetResponse(this.Manifest, typeof(ViewType), Model);
+        }
+
         public class PluginConfigurationHandlerGetResponse
         {
             public PluginManifest Manifest { get; set; }
             public Type ViewType { get; set; }
-            public dynamic ViewModel { get; set; }
+            public dynamic Model { get; set; }
 
-            public PluginConfigurationHandlerGetResponse(PluginManifest Manifest, Type ViewType, dynamic ViewModel = null)
+            public PluginConfigurationHandlerGetResponse(PluginManifest Manifest, Type ViewType, dynamic Model = null)
             {
                 if (ViewType == null)
                     throw new ArgumentNullException("ViewType");
@@ -40,7 +47,7 @@ namespace Disco.Services.Plugins
                 this.Manifest = Manifest;
 
                 this.ViewType = ViewType;
-                this.ViewModel = ViewModel;
+                this.Model = Model;
             }
         }
     }

Disco.Services/Plugins/PluginExtensions.cs

@@ -93,6 +93,35 @@ namespace Disco.Services.Plugins
         }
         #endregion
 
+        #region Bundling
+        public static void IncludeStyleSheetResource(this HttpContextBase Context, string Resource, PluginManifest manifest)
+        {
+            var resourceUrl = manifest.WebResourceUrl(Resource);
+            
+            var deferredBundles = Context.Items[Bundle.UIExtensionCssKey] as List<string>;
+            if (deferredBundles == null)
+            {
+                deferredBundles = new List<string>();
+                HttpContext.Current.Items[Bundle.UIExtensionCssKey] = deferredBundles;
+            }
+            if (!deferredBundles.Contains(resourceUrl))
+                deferredBundles.Add(resourceUrl);
+        }
+        public static void IncludeScriptResource(this HttpContextBase Context, string Resource, PluginManifest manifest)
+        {
+            var resourcePath = manifest.WebResourceUrl(Resource);
+
+            var deferredBundles = Context.Items[Bundle.UIExtensionScriptsKey] as List<string>;
+            if (deferredBundles == null)
+            {
+                deferredBundles = new List<string>();
+                HttpContext.Current.Items[Bundle.UIExtensionScriptsKey] = deferredBundles;
+            }
+            if (!deferredBundles.Contains(resourcePath))
+                deferredBundles.Add(resourcePath);
+        }
+        #endregion
+
         #region Virtual Directories
 
         [Obsolete("Inherit ViewPages from 'Disco.Services.Plugins.WebViewPage' instead.")]

Disco.Services/Plugins/PluginWebHandler.cs

@@ -70,6 +70,19 @@ namespace Disco.Services.Plugins
 
         #endregion
 
+        #region Bundles
+
+        public void IncludeStyleSheet(string Resource)
+        {
+            this.HostController.HttpContext.IncludeStyleSheetResource(Resource, this.Manifest);
+        }
+        public void IncludeScript(string Resource)
+        {
+            this.HostController.HttpContext.IncludeScriptResource(Resource, this.Manifest);
+        }
+
+        #endregion
+
         #region Action Results
 
         #region Compiled View

Disco.Services/Plugins/WebHelper.cs

@@ -83,29 +83,11 @@ namespace Disco.Services.Plugins
 
         public void IncludeStyleSheet(string Resource)
         {
-            var url = ResourceUrl(Resource);
+            ViewPage.Context.IncludeStyleSheetResource(Resource, this.Manifest);
-
-            var deferredBundles = ViewPage.Context.Items[Bundle.UIExtensionCssKey] as List<HtmlString>;
-            if (deferredBundles == null)
-            {
-                deferredBundles = new List<HtmlString>();
-                ViewPage.Context.Items[Bundle.UIExtensionCssKey] = deferredBundles;
-            }
-            if (!deferredBundles.Contains(url))
-                deferredBundles.Add(url);
         }
         public void IncludeJavaScript(string Resource)
         {
-            var url = ResourceUrl(Resource);
+            ViewPage.Context.IncludeScriptResource(Resource, this.Manifest);
-
-            var deferredBundles = ViewPage.Context.Items[Bundle.UIExtensionScriptsKey] as List<HtmlString>;
-            if (deferredBundles == null)
-            {
-                deferredBundles = new List<HtmlString>();
-                ViewPage.Context.Items[Bundle.UIExtensionScriptsKey] = deferredBundles;
-            }
-            if (!deferredBundles.Contains(url))
-                deferredBundles.Add(url);
         }
 
         public HtmlString PartialCompiled<ViewType>(object Model) where ViewType : WebViewPage

Disco.Services/Web/Bundles/BundleExtensions.cs

@@ -29,8 +29,8 @@ namespace Disco.Services.Web
         {
             var deferredBundles = htmlHelper.ViewContext.HttpContext.Items[Bundle.DeferredKey] as List<string>;
 
-            var uiExtensionScripts = htmlHelper.ViewContext.HttpContext.Items[Bundle.UIExtensionScriptsKey] as List<HtmlString>;
+            var uiExtensionScripts = htmlHelper.ViewContext.HttpContext.Items[Bundle.UIExtensionScriptsKey] as List<string>;
-            var uiExtensionCss = htmlHelper.ViewContext.HttpContext.Items[Bundle.UIExtensionCssKey] as List<HtmlString>;
+            var uiExtensionCss = htmlHelper.ViewContext.HttpContext.Items[Bundle.UIExtensionCssKey] as List<string>;
 
             if (deferredBundles != null || uiExtensionScripts != null || uiExtensionCss != null)
             {
@@ -46,12 +46,12 @@ namespace Disco.Services.Web
                 }
                 if (uiExtensionCss != null)
                 {
-                    foreach (HtmlString extensionUrl in uiExtensionCss)
+                    foreach (string extensionUrl in uiExtensionCss)
                         bundleUrls.Append("<link href=\"").Append(extensionUrl).AppendLine("\" rel=\"stylesheet\" type=\"text/css\" />");
                 }
                 if (uiExtensionScripts != null)
                 {
-                    foreach (HtmlString extensionUrl in uiExtensionScripts)
+                    foreach (string extensionUrl in uiExtensionScripts)
                         bundleUrls.Append("<script src=\"").Append(extensionUrl).AppendLine("\" type=\"text/javascript\"></script>");
                 }
 

Disco.Web/Areas/Config/Models/Plugins/PluginConfigurationViewModel.cs

@@ -17,7 +17,7 @@ namespace Disco.Web.Areas.Config.Models.Plugins
             this.Manifest = response.Manifest;
 
             this.PluginViewType = response.ViewType;
-            this.PluginViewModel = response.ViewModel;
+            this.PluginViewModel = response.Model;
         }
     }
 }