protected virtual IEnumerable <string> ResolveAssetPaths(IControlOutputContext context)
{
IAssetProvider assetProvider = (context.Control as IAssetProvider) ?? (context.Children.FirstOrDefault()?.Control as IAssetProvider);
if (null == assetProvider)
{
yield break;
}
var extensions = assetProvider.GetAssetFileExtensions();
if (null == extensions)
{
yield break;
}
extensions = extensions.Distinct();
foreach (var extension in extensions)
{
var paths = assetProvider.GetAssetPaths(extension);
if (null == paths)
{
yield break;
}
foreach (var path in paths)
{
yield return(path);
}
}
}
protected override async Task ProcessAsync(IControlOutputContext context)
{
GridColumn parentColumn = (GridColumn)context.Parent.Control;
context.Output.SuppressOutput();
var innerContent = await context.Output.GetChildContentAsync(true);
parentColumn.Template = innerContent.GetContent()?.Trim();
}
protected override async Task ProcessAsync(IControlOutputContext context)
{
GridColumn column = (GridColumn)context.Parent.Control;
var childContent = await context.Output.GetChildContentAsync();
if (!childContent.IsEmptyOrWhiteSpace)
{
column.Formatter = childContent.GetContent()?.Trim();
}
}
private bool EnsureRenderer(IControlOutputContext context)
{
if (this.RequiresRenderer && !(context.Parent?.Control is RendererTagHelper))
{
context.Output.Content.Clear();
context.Output.SuppressOutput();
context.Output.Content.SetHtmlContent($"<div>'{this.GetType().FullName}' requires a parent <renderer> since it doesn't have any default rendering logic.</div>");
return(false);
}
return(true);
}
protected override async Task ProcessAsync(IControlOutputContext context)
{
if (string.IsNullOrWhiteSpace(this.Name))
{
this.Name = Options.DefaultName;
}
RendererTagAttributes rendererAttributes = new RendererTagAttributes(
this.TagHelperContext.AllAttributes.Where(attr => 0 != string.Compare(attr.Name, nameof(this.Name), StringComparison.OrdinalIgnoreCase))
);
var controlRenderer = this.RendererFactory.GetRenderer(this.Name);
await controlRenderer.RenderAsync(context, rendererAttributes);
}
protected override IEnumerable <string> ResolveAssetPaths(IControlOutputContext context)
{
var viewContext = context.Control.ViewContext;
return(new[] {
viewContext.Asset("jquery.js"),
viewContext.Asset("bootstrap.bundle.js"),
viewContext.Asset("bootstrap.table.js"),
viewContext.Asset("bootstrap.min.css"),
viewContext.Asset("bootstrap.table.css"),
viewContext.Asset("font-awesome.css")
});
}
private void RenderAssets(IControlOutputContext context, RendererTagAttributes attributes)
{
var assetPaths = this.ResolveAssetPaths(context);
var currentHttpContext = context.GetHttpContext();
var optimizationScope = currentHttpContext.RequestServices.GetRequiredService <IOptimizationScope>();
var optimizationContext = optimizationScope.AddOrGetContext(this.OptimizationContextName);
foreach (var assetPath in assetPaths)
{
optimizationContext.AddAsset(assetPath);
}
}
private async Task RenderAssetsAsync(IControlOutputContext context)
{
var assetPaths = this.ResolveAssetPaths(context);
assetPaths = await this.Events.OnAssetPathsResolved(assetPaths);
var currentHttpContext = context.GetHttpContext();
var optimizationScope = currentHttpContext.RequestServices.GetRequiredService <IOptimizationScope>();
var optimizationContext = optimizationScope.AddOrGetContext(this.OptimizationContextName);
foreach (var assetPath in assetPaths)
{
optimizationContext.AddAsset(assetPath);
}
}
public virtual void Render(IControlOutputContext context, RendererTagAttributes attributes)
{
this.RendererControl = context.Control as RendererTagHelper;
if (null == context.Parent)
{
if (1 != context.Children.Count)
{
throw new Exception();
}
context.Output.TagName = string.Empty;
this.RenderRootControl(context.Children[0]);
context.Children[0].Output.Content.MoveTo(context.Output.Content);
this.RenderAssets(context, attributes);
}
}
protected virtual IEnumerable <string> ResolveAssetPaths(IControlOutputContext context)
{
IAssetProvider assetProvider = (context.Control as IAssetProvider) ?? (context.Children.FirstOrDefault()?.Control as IAssetProvider);
if (null == assetProvider)
{
yield break;
}
var extensions = assetProvider.GetAssetFileExtensions();
if (null == extensions)
{
yield break;
}
extensions = extensions.Distinct();
foreach (var extension in extensions)
{
var paths = assetProvider.GetAssetPaths(extension);
if (null == paths)
{
yield break;
}
foreach (var path in paths)
{
if (null == path)
{
throw new ArgumentNullException($"Null resource path specified in web control '{context.Control?.GetType().FullName}'.");
}
if (Uri.TryCreate(path, UriKind.Absolute, out Uri tempUri))
{
yield return(path);
}
else
{
yield return($"{this.WebControlsOptions.AssetsRootPath.Value.TrimEnd('/')}/{path.TrimStart('/')}");
}
}
}
}
public virtual async Task RenderAsync(IControlOutputContext context, RendererTagAttributes attributes)
{
this.RendererControl = context.Control as RendererTagHelper;
if (null == context.Parent)
{
if (1 != context.Children.Count)
{
throw new Exception();
}
context.Output.TagName = string.Empty;
this.RenderRootControl((TControl)context.Children[0].Control, context.Children[0]);
context.Children[0].Output.PreContent.MoveTo(context.Output.PreContent);
context.Children[0].Output.Content.MoveTo(context.Output.Content);
context.Children[0].Output.PostContent.MoveTo(context.Output.PostContent);
await this.RenderAssetsAsync(context);
}
}
public static string GenerateInitializerScript(IControlOutputContext context, string optimizationContextName, string startupScript, string postStartupScript = null)
{
if (null != startupScript && !startupScript.EndsWith(';'))
{
startupScript = startupScript + ";";
}
string initializerScript = $"function initialize{context.Id}(){{ {startupScript}{postStartupScript} }};";
string loaderScript = "if (adriva && adriva.optimization && adriva.optimization.loader && adriva.optimization.loader.hasAssets){"
+ $"if (adriva.optimization.loader.isReady('{optimizationContextName}')) {{ initialize{context.Id}(); }}"
+ $"else {{ document.addEventListener('contextReady', function(e){{ if('{optimizationContextName}'===e.detail){{ initialize{context.Id}(); }}; }}); }}"
+ "}"
+ "else {"
+ $"if('complete'===document.readyState) {{ initialize{context.Id}(); }}"
+ $"else {{ window.addEventListener('load', initialize{context.Id}); }}"
+ "} ";
return($"<script>{initializerScript}{Environment.NewLine}{loaderScript}</script>");
}
protected override void Process(IControlOutputContext context)
{
var grid = (Grid)context.Parent.Control;
grid.Pager = this;
}
protected virtual void RenderRootControl(TControl control, IControlOutputContext context)
{
}
public virtual void Render(IControlOutputContext context, RendererTagAttributes attributes)
{
Task renderTask = this.RenderAsync(context, attributes);
renderTask.GetAwaiter().GetResult();
}
protected override void RenderRootControl(Grid grid, IControlOutputContext context)
{
foreach (var column in grid.Columns)
{
if (!string.IsNullOrWhiteSpace(column.Formatter))
{
var formatterScript = RendererUtilities.GenerateWrappedScriptCall(column.Formatter, 2, out string formatterFunctionName);
column.Formatter = formatterFunctionName;
context.Output.PostContent.AppendHtml($"<script>{formatterScript}</script>");
}
}
TagBuilder tagBuilder = new TagBuilder("table");
tagBuilder.TagRenderMode = TagRenderMode.Normal;
tagBuilder.GenerateId(context.Id, "_");
foreach (var attribute in context.Attributes)
{
tagBuilder.Attributes.TryAdd(attribute.Name, Convert.ToString(attribute.Value));
}
context.Output.Content.SetHtmlContent(tagBuilder);
var contractResolver = new BootstrapGridRenderer.GridContractResolver();
var mappingBuilder = contractResolver.AddTypeMapping <Grid>()
.MapProperty(x => x.Columns, "columns")
.MapProperty(x => x.Height, "height")
.MapProperty(x => x.ShowDetails, "detailView")
.MapProperty(x => x.ResponseFormatter, "responseHandler")
.MapProperty(x => x.DataFieldName, "dataField", false)
.MapProperty(x => x.TotalFieldName, "totalField", false)
;
contractResolver.AddTypeMapping <GridColumn>()
.MapProperty(x => x.Field, "field")
.MapProperty(x => x.Title, "title")
.MapProperty(x => x.Width, "width")
.MapProperty(x => x.Formatter, "formatter")
.MapProperty(x => x.Alignment, "align")
.MapProperty(x => x.IsHidden, "visible", shouldNegate: true)
;
if (grid.DataSource is string)
{
mappingBuilder.MapProperty(x => x.DataSource, "url");
}
else
{
mappingBuilder.MapProperty(x => x.DataSource, "data", new DataSourceConverter());
}
JsonSerializerSettings jsonSerializerSettings = new JsonSerializerSettings()
{
ContractResolver = contractResolver
};
var json = Utilities.SafeSerialize(grid, jsonSerializerSettings);
var postStartupFunction = RendererUtilities.GenerateWrappedScriptCall(grid.OnInitialized, new[] { "grid" }, out string postStartupFunctionName);
context.Output.PostContent.AppendHtml(
RendererUtilities.GenerateInitializerScript(
context,
this.OptimizationContextName,
$"var grid = $('#{context.Id}').bootstrapTable({json});",
string.IsNullOrWhiteSpace(grid.OnInitialized) ? null : $"{postStartupFunctionName}(grid);"
)
);
if (!string.IsNullOrWhiteSpace(grid.OnInitialized))
{
context.Output.PreContent.AppendHtml($"<script>{postStartupFunction}</script>");
}
}
protected virtual Task ProcessAsync(IControlOutputContext context)
{
this.Process(context);
return(Task.CompletedTask);
}
protected virtual void Process(IControlOutputContext context)
{
}
protected override void Process(IControlOutputContext context)
{
Grid grid = (Grid)context.Parent.Control;
grid.Columns.Add(this);
}
public virtual async Task RenderAsync(IControlOutputContext context, RendererTagAttributes attributes)
{
await Task.CompletedTask;
this.Render(context, attributes);
}
public void Render(IControlOutputContext context, RendererTagAttributes attributes)
{
context.Output.SuppressOutput();
}
public Task RenderAsync(IControlOutputContext context, RendererTagAttributes attributes)
{
this.Render(context, attributes);
return(Task.CompletedTask);
}
protected override void RenderRootControl(IControlOutputContext context)
{
}
protected virtual Task ProcessAsync(IControlOutputContext context) => Task.CompletedTask;
protected override async Task ProcessAsync(IControlOutputContext context)
{
await Task.CompletedTask;
}
public static HttpContext GetHttpContext(this IControlOutputContext context)
{
return(context?.Control?.ViewContext?.HttpContext);
}
