public override void Process(TagHelperContext context, TagHelperOutput output)
{
output.TagName = "div";
var pre = string.Format(
"<ul class=\"pagination\" search-form-target=\"{0}\" update-link=\"{1}\" update-target=\"{2}\">",
SearchFormTarget,
UpdateLink,
UpdateTarget);
output.PreContent.SetContent(pre);
var items = new StringBuilder();
for (var i = 1; i <= TotalPages; i++)
{
var li = string.Format(
@"<li" + ((i == CurrentPage)?" class=\"active\"":"") + @">
<a href='{0}' title='{1}'>{2}</a>
</li>", i, "Click to go to page {i}", i);
items.AppendLine(li);
}
output.Content.SetContent(items.ToString());
output.PostContent.SetContent("</ul>");
output.Attributes.Clear();
output.Attributes.Add("class", "paged-list");
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
var bytes = await _redisCache.GetAsync(context.UniqueId);
string content;
if (bytes == null)
{
var childContent = await output.GetChildContentAsync();
content = childContent.GetContent();
bytes = Encoding.UTF8.GetBytes(content);
await _redisCache.SetAsync(context.UniqueId, bytes, new DistributedCacheEntryOptions
{
AbsoluteExpiration = AbsoluteExpiration,
AbsoluteExpirationRelativeToNow = RelativeAbsoluteExpiration,
SlidingExpiration = SlidingExpiration
});
}
else
{
content = Encoding.UTF8.GetString(bytes);
}
output.SuppressOutput();
// Unsupress by setting the content again.
output.Content.SetHtmlContent(content);
}
/// <summary>
/// Calls the <see cref="ITagHelper.ProcessAsync"/> method on <see cref="ITagHelper"/>s.
/// </summary>
/// <param name="executionContext">Contains information associated with running <see cref="ITagHelper"/>s.
/// </param>
/// <returns>Resulting <see cref="TagHelperOutput"/> from processing all of the
/// <paramref name="executionContext"/>'s <see cref="ITagHelper"/>s.</returns>
public async Task<TagHelperOutput> RunAsync(TagHelperExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException(nameof(executionContext));
}
var tagHelperContext = new TagHelperContext(
executionContext.AllAttributes,
executionContext.Items,
executionContext.UniqueId);
OrderTagHelpers(executionContext.TagHelpers);
for (var i = 0; i < executionContext.TagHelpers.Count; i++)
{
executionContext.TagHelpers[i].Init(tagHelperContext);
}
var tagHelperOutput = new TagHelperOutput(
executionContext.TagName,
executionContext.HTMLAttributes,
executionContext.GetChildContentAsync)
{
TagMode = executionContext.TagMode,
};
for (var i = 0; i < executionContext.TagHelpers.Count; i++)
{
await executionContext.TagHelpers[i].ProcessAsync(tagHelperContext, tagHelperOutput);
}
return tagHelperOutput;
}
/// <summary>
/// Calls the <see cref="ITagHelper.ProcessAsync"/> method on <see cref="ITagHelper"/>s.
/// </summary>
/// <param name="executionContext">Contains information associated with running <see cref="ITagHelper"/>s.
/// </param>
/// <returns>Resulting <see cref="TagHelperOutput"/> from processing all of the
/// <paramref name="executionContext"/>'s <see cref="ITagHelper"/>s.</returns>
public async Task<TagHelperOutput> RunAsync(TagHelperExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException(nameof(executionContext));
}
var tagHelperContext = new TagHelperContext(
executionContext.AllAttributes,
executionContext.Items,
executionContext.UniqueId);
var orderedTagHelpers = executionContext.TagHelpers.OrderBy(tagHelper => tagHelper.Order);
foreach (var tagHelper in orderedTagHelpers)
{
tagHelper.Init(tagHelperContext);
}
var tagHelperOutput = new TagHelperOutput(
executionContext.TagName,
executionContext.HTMLAttributes,
executionContext.GetChildContentAsync)
{
TagMode = executionContext.TagMode,
};
foreach (var tagHelper in orderedTagHelpers)
{
await tagHelper.ProcessAsync(tagHelperContext, tagHelperOutput);
}
return tagHelperOutput;
}
public override async void Process(TagHelperContext context, TagHelperOutput output)
{
output.TagName = "div";
output.AppendClass("widget-box");
output.AppendClass(Class);
var originalContent = await output.GetChildContentAsync();
var innerHtml = originalContent.GetContent();
output.Content.Clear();
if (!innerHtml.Contains(WidgetBoxHeaderHelper.HeaderCss))
{
// user is taking easy/lazy way of declaring the widget box
output.Content.Append(WidgetBoxHeaderHelper.GetFullHeader(Title, IsCollapsible));
var widgetBodyDiv = WidgetBoxBodyHelper.GetFullBodyInternals(Padding, innerHtml);
output.Content.Append(widgetBodyDiv);
}
else
{
// user is doing the hardwork themselves
output.Content.AppendHtml(innerHtml);
}
base.Process(context, output);
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
string menuUrl = _UrlHelper.Action(ActionName, ControllerName);
output.TagName = "";
var a = new TagBuilder("a");
a.MergeAttribute("href", $"{menuUrl}");
a.MergeAttribute("class", "item");
a.InnerHtml.Append(MenuText);
var routeData = ViewContext.RouteData.Values;
var currentController = routeData["controller"];
var currentAction = routeData["action"];
if (String.Equals(ActionName, currentAction as string, StringComparison.OrdinalIgnoreCase)
&& String.Equals(ControllerName, currentController as string, StringComparison.OrdinalIgnoreCase))
{
a.AddCssClass("active");
a.AddCssClass("blue");
}
output.Content.SetContent(a);
}
public override Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
if (!string.IsNullOrEmpty(DatatablesEdit))
output.Attributes.Add("data-edit", DatatablesEdit);
if (!string.IsNullOrEmpty(DatatablesDelete))
output.Attributes.Add("data-delete", DatatablesDelete);
if (!string.IsNullOrEmpty(DatatablesCreate))
output.Attributes.Add("data-create", DatatablesCreate);
if (!string.IsNullOrEmpty(DatatablesEditRowSelect))
output.Attributes.Add("data-edit-row-select", DatatablesEditRowSelect);
if (!string.IsNullOrEmpty(DatatablesEditButton))
output.Attributes.Add("data-edit-button", DatatablesEditButton);
if (!string.IsNullOrEmpty(DatatablesDeleteButton))
output.Attributes.Add("data-delete-button", DatatablesDeleteButton);
if (!string.IsNullOrEmpty(DatatablesCreateButton))
output.Attributes.Add("data-create-button", DatatablesCreateButton);
if (!string.IsNullOrEmpty(DatatablesLang))
output.Attributes.Add("data-language", DatatablesLang);
if (!string.IsNullOrEmpty(Lengthmenu))
output.Attributes.Add("data-lengthmenu", Lengthmenu);
if (!Savestate != null)
output.Attributes.Add("data-savestate", Savestate);
if (!string.IsNullOrEmpty(Url))
output.Attributes.Add("data-url", Url);
return Task.FromResult(0);
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
if (_bundleManager.Exists(Source))
{
var result = (await _smidgeHelper.GenerateJsUrlsAsync(Source, Debug)).ToArray();
var currAttr = output.Attributes.ToDictionary(x => x.Name, x => x.Value);
using (var writer = new StringWriter())
{
foreach (var s in result)
{
var builder = new TagBuilder(output.TagName)
{
TagRenderMode = TagRenderMode.Normal
};
builder.MergeAttributes(currAttr);
builder.Attributes["src"] = s;
builder.WriteTo(writer, _encoder);
}
writer.Flush();
output.PostElement.SetContent(new HtmlString(writer.ToString()));
}
//This ensures the original tag is not written.
output.TagName = null;
}
else
{
//use what is there
output.Attributes["src"] = Source;
}
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
var builder = new TagBuilder("h2", HtmlHelper.HtmlEncoder);
var title = ViewContext.ViewBag.Title;
builder.InnerHtml = HtmlHelper.Encode(title);
output.PreContent.SetContent(builder.ToString());
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
// If a condition is set and evaluates to false, don't render the tag.
if (Condition.HasValue && !Condition.Value)
{
output.SuppressOutput();
}
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
output.TagName = null;
for (int i = 0; i < Count; i++)
{
output.Content.Append(await output.GetChildContentAsync());
}
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
output.Content.AppendHtml("<ul>");
if (Credentials != null)
{
foreach(KeyValuePair<string, Credential> pair in Credentials)
{
GenerateCredentialHtml(pair.Key, pair.Value, output);
}
}
output.Content.AppendHtml("</ul>");
base.Process(context, output);
}
public override async void Process(TagHelperContext context, TagHelperOutput output)
{
output.SuppressOutput();
var originalContent = await output.GetChildContentAsync();
var headerDiv = GetHeader();
headerDiv.InnerHtml.AppendHtml(originalContent.GetContent());
output.Content.Clear();
output.Content.Append(headerDiv);
base.Process(context, output);
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
if (Emoji == "smile")
{
output.Attributes.Add("title", "smile");
output.Content.SetContent(" :) ");
output.TagMode = TagMode.StartTagAndEndTag;
}
else if (Emoji == "sad")
{
var childContent = await context.GetChildContentAsync();
output.Attributes.Add("title", "sad");
output.Content.Append(childContent.GetContent() + ":'(");
}
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
output.TagName = null;
var partialResult = _viewEngine.FindPartialView(ViewContext, Name);
if (partialResult != null && partialResult.Success)
{
var partialViewData = new ViewDataDictionary(ViewContext.ViewData, Model);
var partialWriter = new TagHelperContentWrapperTextWriter(ViewContext.Writer.Encoding, output.Content);
var partialViewContext = new ViewContext(ViewContext, partialResult.View, partialViewData, partialWriter);
await partialResult.View.RenderAsync(partialViewContext);
}
}
public override async void Process(TagHelperContext context, TagHelperOutput output)
{
output.SuppressOutput();
var originalContent = await output.GetChildContentAsync();
var bodyContainer = GetBodyContainer(Padding);
bodyContainer.WidgetMain.InnerHtml.AppendHtml(originalContent.GetContent());
output.Content.Clear();
output.Content.Append(bodyContainer.WidgetBody);
base.Process(context, output);
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
if (Controller != null && Action != null)
{
var methodParameters = output.Attributes.ToDictionary(attribute => attribute.Key,
attribute => (object)attribute.Value);
// We remove all attributes from the resulting HTML element because they're supposed to
// be parameters to our final href value.
output.Attributes.Clear();
output.Attributes["href"] = UrlHelper.Action(Action, Controller, methodParameters);
output.PreContent.SetContent("My ");
}
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
output.TagName = "div";
output.Attributes["class"] = "profile-info-row";
var sb = new StringBuilder();
sb.AppendFormat(@"
<div class=""profile-info-name"">{0}</div>
<div class=""profile-info-value"">
<span>{1}</span>
</div>", Name, Value);
output.Content.Clear();
output.Content.AppendHtml(sb.ToString());
base.Process(context, output);
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
var br = new TagBuilder("br");
br.TagRenderMode = TagRenderMode.SelfClosing;
output.TagName = "div";
output.Attributes.Add("itemscope", null);
output.Attributes.Add("itemtype", "http://schema.org/Organization");
var name = new TagBuilder("span");
name.MergeAttribute("itemprop", "name");
name.InnerHtml.Append(Organisation.Name);
var address = new TagBuilder("address");
address.MergeAttribute("itemprop", "address");
address.MergeAttribute("itemscope", null);
address.MergeAttribute("itemtype", "http://schema.org/PostalAddress");
var span = new TagBuilder("span");
span.MergeAttribute("itemprop", "streetAddress");
span.InnerHtml.Append(Organisation.StreetAddress);
address.InnerHtml.Append(br);
span = new TagBuilder("span");
span.MergeAttribute("itemprop", "addressLocality");
span.InnerHtml.Append(Organisation.AddressLocality);
address.InnerHtml.Append(span);
address.InnerHtml.Append(br);
span = new TagBuilder("span");
span.MergeAttribute("itemprop", "addressRegion");
span.InnerHtml.Append(Organisation.AddressRegion);
address.InnerHtml.Append(span);
span = new TagBuilder("span");
span.MergeAttribute("itemprop", "postalCode");
span.InnerHtml.Append(Organisation.PostalCode);
address.InnerHtml.Append(span);
output.Content.Clear();
output.Content.Append(address);
}
/// <inheritdoc />
/// <remarks>Does nothing if <see cref="For"/> is <c>null</c>.</remarks>
public override void Process(TagHelperContext context, TagHelperOutput output)
{
var tagBuilder = Generator.GenerateTextArea(
ViewContext,
For.ModelExplorer,
For.Name,
rows: 0,
columns: 0,
htmlAttributes: null);
if (tagBuilder != null)
{
// Overwrite current Content to ensure expression result round-trips correctly.
output.Content.SetContent(tagBuilder.InnerHtml);
output.MergeAttributes(tagBuilder);
}
}
public void Constructor_SetsProperties_AsExpected()
{
// Arrange
var expectedItems = new Dictionary<object, object>
{
{ "test-entry", 1234 }
};
// Act
var context = new TagHelperContext(
allAttributes: Enumerable.Empty<IReadOnlyTagHelperAttribute>(),
items: expectedItems,
uniqueId: string.Empty);
// Assert
Assert.NotNull(context.Items);
Assert.Same(expectedItems, context.Items);
var item = Assert.Single(context.Items);
Assert.Equal("test-entry", (string)item.Key, StringComparer.Ordinal);
Assert.Equal(1234, item.Value);
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
StringBuilder sb = new StringBuilder();
// Build ClientSide Model
sb.AppendLine("var Model = {");
sb.AppendLine("debug : " + JsonConvert.SerializeObject(Debugger.IsAttached) + ",");
sb.AppendLine("controller : " + JsonConvert.SerializeObject(ViewContext.RouteData.Values["controller"]) + ",");
sb.AppendLine("action : " + JsonConvert.SerializeObject(ViewContext.RouteData.Values["action"]) + ",");
sb.AppendLine("httpMethod : " + JsonConvert.SerializeObject(_httpContextAccessor.HttpContext.Request.Method) + ",");
sb.AppendLine("userAgent : " + JsonConvert.SerializeObject(_httpContextAccessor.HttpContext.Request.Headers["user-agent"]));
//sb.AppendLine(" 'currentCulture' : " + JsonConvert.SerializeObject(Thread.CurrentThread.CurrentCulture.Name) + ",");
//sb.AppendLine(" 'currentUiCulture' : " + JsonConvert.SerializeObject(Thread.CurrentThread.CurrentUICulture.Name));
sb.AppendLine("};");
// End script tag
sb.AppendLine("</script>");
output.Content.Append(sb.ToString());
}
public async Task Process_AddsHiddenInputTag_FromEndOfFormContent(
List<TagBuilder> tagBuilderList,
string expectedOutput)
{
// Arrange
var viewContext = new ViewContext();
var tagHelperOutput = new TagHelperOutput(
tagName: "form",
attributes: new TagHelperAttributeList(),
getChildContentAsync: (useCachedResult) =>
{
Assert.True(viewContext.FormContext.CanRenderAtEndOfForm);
foreach (var item in tagBuilderList)
{
viewContext.FormContext.EndOfFormContent.Add(item);
}
return Task.FromResult<TagHelperContent>(new DefaultTagHelperContent());
});
var tagHelperContext = new TagHelperContext(
Enumerable.Empty<IReadOnlyTagHelperAttribute>(),
new Dictionary<object, object>(),
"someId");
var tagHelper = new RenderAtEndOfFormTagHelper
{
ViewContext = viewContext
};
tagHelper.Init(tagHelperContext);
// Act
await tagHelper.ProcessAsync(context: tagHelperContext, output: tagHelperOutput);
// Assert
Assert.Equal(expectedOutput, tagHelperOutput.PostContent.GetContent());
}
/// <inheritdoc />
/// <remarks>Does nothing if user provides an <c>FormAction</c> attribute.</remarks>
/// <exception cref="InvalidOperationException">
/// Thrown if <c>FormAction</c> attribute is provided and <see cref="Action"/>, <see cref="Controller"/>,
/// <see cref="Fragment"/> or <see cref="Route"/> are non-<c>null</c> or if the user provided <c>asp-route-*</c> attributes.
/// Also thrown if <see cref="Route"/> and one or both of <see cref="Action"/> and <see cref="Controller"/>
/// are non-<c>null</c>
/// </exception>
public override void Process(TagHelperContext context, TagHelperOutput output)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
// If "FormAction" is already set, it means the user is attempting to use a normal button or input element.
if (output.Attributes.ContainsName(FormAction))
{
if (Action != null ||
Controller != null ||
Area != null ||
Page != null ||
PageHandler != null ||
Fragment != null ||
Route != null ||
(_routeValues != null && _routeValues.Count > 0))
{
// User specified a FormAction and one of the bound attributes; can't override that FormAction
// attribute.
throw new InvalidOperationException(
Resources.FormatFormActionTagHelper_CannotOverrideFormAction(
FormAction,
output.TagName,
RouteValuesPrefix,
ActionAttributeName,
ControllerAttributeName,
AreaAttributeName,
FragmentAttributeName,
RouteAttributeName,
PageAttributeName,
PageHandlerAttributeName));
}
return;
}
var routeLink = Route != null;
var actionLink = Controller != null || Action != null;
var pageLink = Page != null || PageHandler != null;
if ((routeLink && actionLink) || (routeLink && pageLink) || (actionLink && pageLink))
{
var message = string.Join(
Environment.NewLine,
Resources.FormatCannotDetermineAttributeFor(FormAction, '<' + output.TagName + '>'),
RouteAttributeName,
ControllerAttributeName + ", " + ActionAttributeName,
PageAttributeName + ", " + PageHandlerAttributeName);
throw new InvalidOperationException(message);
}
RouteValueDictionary routeValues = null;
if (_routeValues != null && _routeValues.Count > 0)
{
routeValues = new RouteValueDictionary(_routeValues);
}
if (Area != null)
{
if (routeValues == null)
{
routeValues = new RouteValueDictionary();
}
// Unconditionally replace any value from asp-route-area.
routeValues["area"] = Area;
}
var urlHelper = UrlHelperFactory.GetUrlHelper(ViewContext);
string url;
if (pageLink)
{
url = urlHelper.Page(Page, PageHandler, routeValues, protocol: null, host: null, fragment: Fragment);
}
else if (routeLink)
{
url = urlHelper.RouteUrl(Route, routeValues, protocol: null, host: null, fragment: Fragment);
}
else
{
url = urlHelper.Action(Action, Controller, routeValues, protocol: null, host: null, fragment: Fragment);
}
output.Attributes.SetAttribute(FormAction, url);
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
output.Content.AppendEncoded("root-content");
}
public async Task ProcessAsync_DoesNotOverrideOutputContent(
string childContent,
string outputContent,
string expectedOutputContent)
{
// Arrange
var tagBuilder = new TagBuilder("span2");
tagBuilder.InnerHtml.SetHtmlContent("New HTML");
tagBuilder.Attributes.Add("data-foo", "bar");
tagBuilder.Attributes.Add("data-hello", "world");
var generator = new Mock <IHtmlGenerator>(MockBehavior.Strict);
var setup = generator
.Setup(mock => mock.GenerateValidationMessage(
It.IsAny <ViewContext>(),
It.IsAny <ModelExplorer>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <object>()))
.Returns(tagBuilder);
var validationMessageTagHelper = new ValidationMessageTagHelper(generator.Object)
{
For = CreateModelExpression("Hello")
};
var output = new TagHelperOutput(
"span",
attributes: new TagHelperAttributeList(),
getChildContentAsync: (useCachedResult, encoder) =>
{
var tagHelperContent = new DefaultTagHelperContent();
tagHelperContent.AppendHtml(childContent);
return(Task.FromResult <TagHelperContent>(tagHelperContent));
});
output.Content.AppendHtml(outputContent);
var context = new TagHelperContext(
tagName: "span",
allAttributes: new TagHelperAttributeList(
Enumerable.Empty <TagHelperAttribute>()),
items: new Dictionary <object, object>(),
uniqueId: "test");
var viewContext = CreateViewContext();
validationMessageTagHelper.ViewContext = viewContext;
// Act
await validationMessageTagHelper.ProcessAsync(context, output);
// Assert
Assert.Equal("span", output.TagName);
Assert.Equal(2, output.Attributes.Count);
var attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("data-foo"));
Assert.Equal("bar", attribute.Value);
attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("data-hello"));
Assert.Equal("world", attribute.Value);
Assert.Equal(expectedOutputContent, output.Content.GetContent());
}
/// <summary>
/// Asynchronously removes the script from the render pipeline and stores it into the HTML context to be rendered later.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="output">The output.</param>
/// <returns></returns>
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
//Validate inputs
var hasName = null != Name && _namePatern.IsMatch(Name);
var hasSrc = !string.IsNullOrWhiteSpace(Src);
if (!hasName && !hasSrc)
throw new ArgumentException("Name is required. It must be a single string without whitespace, commas, pipes or semi-colons.", nameof(Name));
var namedScript = new NamedScriptInfo { Name = Name ?? Src, Src = Src, Dependencies = _dependsOn, Aliases = _aliases };
if (hasSrc)
{
if (!Src.EndsWith(".min.js"))
{
//TODO: Consider automatically looking at a minified source cache
}
}
else
{
//Get the script contents
var contents = await output.GetChildContentAsync(true);
var scriptContent = contents.GetContent();
namedScript.Script = scriptContent;
}
//Save them into the http Context
if (_httpContextAccessor.HttpContext.Items.ContainsKey(ViewDataKey))
{
var scripts = (IDictionary<string, NamedScriptInfo>)_httpContextAccessor.HttpContext.Items[ViewDataKey];
if (scripts.ContainsKey(namedScript.Name))
Debug.WriteLine("Duplicate script ignored");
else
scripts.Add(namedScript.Name, namedScript);
}
else
_httpContextAccessor.HttpContext.Items[ViewDataKey] = new Dictionary<string, NamedScriptInfo> { { namedScript.Name, namedScript } };
//suppress any output
output.SuppressOutput();
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
output.TagName = "button";
output.Attributes.Add("id", Id + "button");
output.Attributes.Add("name", Id + "button");
output.Attributes.Add("class", "layui-btn layui-btn-sm");
output.Attributes.Add("type", "button");
output.TagMode = TagMode.StartTagAndEndTag;
output.Content.SetHtmlContent("选择文件");
string ext = "";
if (string.IsNullOrEmpty(CustomType))
{
switch (UploadType)
{
case UploadTypeEnum.AllFiles:
ext = "";
break;
case UploadTypeEnum.ImageFile:
ext = "jpg|jpeg|gif|bmp|png|tif";
break;
case UploadTypeEnum.ZipFile:
ext = "zip";
break;
case UploadTypeEnum.ExcelFile:
ext = "xls|xlsx";
break;
case UploadTypeEnum.PDFFile:
ext = "pdf";
break;
case UploadTypeEnum.WordFile:
ext = "doc|docx";
break;
case UploadTypeEnum.TextFile:
ext = "txt";
break;
}
}
else
{
ext = CustomType;
}
var vm = context.Items["model"] as BaseVM;
var url = "/_Framework/Upload";
if (vm != null)
{
url += $"?_DONOT_USE_CS={vm.CurrentCS}";
}
output.PreElement.SetHtmlContent($@"
<label id='{Id}label'></label>
");
output.PostElement.SetHtmlContent($@"
<input type='hidden' id='{Id}' name='{Field.Name}' value='{Field.Model}' {(Field.Metadata.IsRequired ? " lay-verify=required" : string.Empty)} />
<script>
function {Id}DoDelete(fileid){{
$('#{Id}').parents('form').append(""<input type='hidden' id='DeletedFileIds' name='DeletedFileIds' value='""+fileid+""' />"");
$('#{Id}label').html('');
$('#{Id}').val('');
}}
var index = 0;
//普通图片上传
var uploadInst = layui.upload.render({{
elem: '#{Id}button'
,url: '{url}'
,size: {FileSize}
,accept: 'file'
,exts: '{ext}'
,before: function(obj){{
index = layui.layer.load(2);
}}
,done: function(res){{
layui.layer.close(index);
if(res.data.id == ''){{
layui.layer.msg('上传失败');
}}
else{{
$('#{Id}').val(res.data.id);
var del = ""<button class='layui-btn layui-btn-sm layui-btn-danger' type='button' id='{Id}del' style='color:white'>""+res.data.name+"" 删除</button>"";
$('#{Id}label').html(del);
$('#{Id}del').on('click',function(){{
{Id}DoDelete(res.data.id);
}});
}}
}}
,error: function(){{
layui.layer.close(index);
}}
}});
</script>
");
if (Field.Model != null && Field.Model.ToString() != Guid.Empty.ToString())
{
var geturl = $"/_Framework/GetFileName/{Field.Model}";
if (vm != null)
{
geturl += $"?_DONOT_USE_CS={vm.CurrentCS}";
}
output.PostElement.AppendHtml($@"
<script>
$.ajax({{
cache: false,
type: 'GET',
url: '{geturl}',
async: false,
success: function(data) {{
var del = ""<button class='layui-btn layui-btn-sm layui-btn-danger' type='button' id='{Id}del' style='color:white'>""+data+"" 删除</button>"";
$('#{Id}label').html(del);
$('#{Id}del').on('click',function(){{
{Id}DoDelete('{Field.Model}');
}});
}}
}});
</script>
");
}
base.Process(context, output);
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
output.SuppressOutput();
if (String.IsNullOrEmpty(Name) && !String.IsNullOrEmpty(Src))
{
RequireSettings setting;
if (String.IsNullOrEmpty(DependsOn))
{
// Include custom script url
setting = _resourceManager.Include("script", Src, DebugSrc);
}
else
{
// Anonymous declaration with dependencies, then display
var name = Guid.NewGuid().ToString();
var definition = _resourceManager.InlineManifest.DefineScript(name);
definition.SetUrl(Src, DebugSrc);
if (!String.IsNullOrEmpty(Version))
{
definition.SetVersion(Version);
}
if (!String.IsNullOrEmpty(CdnSrc))
{
definition.SetCdn(CdnSrc, DebugCdnSrc);
}
if (!String.IsNullOrEmpty(Culture))
{
definition.SetCultures(Culture.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries));
}
if (!String.IsNullOrEmpty(DependsOn))
{
definition.SetDependencies(DependsOn.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries));
}
if (!String.IsNullOrEmpty(Version))
{
definition.SetVersion(Version);
}
setting = _resourceManager.RegisterResource("script", name);
}
if (At != ResourceLocation.Unspecified)
{
setting.AtLocation(At);
}
if (!String.IsNullOrEmpty(Condition))
{
setting.UseCondition(Condition);
}
setting.UseDebugMode(Debug);
if (!String.IsNullOrEmpty(Culture))
{
setting.UseCulture(Culture);
}
foreach (var attribute in output.Attributes)
{
setting.SetAttribute(attribute.Name, attribute.Value.ToString());
}
}
else if (!String.IsNullOrEmpty(Name) && String.IsNullOrEmpty(Src))
{
// Resource required
var setting = _resourceManager.RegisterResource("script", Name);
if (At != ResourceLocation.Unspecified)
{
setting.AtLocation(At);
}
setting.UseCdn(UseCdn);
if (!String.IsNullOrEmpty(Condition))
{
setting.UseCondition(Condition);
}
setting.UseDebugMode(Debug);
if (!String.IsNullOrEmpty(Culture))
{
setting.UseCulture(Culture);
}
if (!String.IsNullOrEmpty(Version))
{
setting.UseVersion(Version);
}
}
else if (!String.IsNullOrEmpty(Name) && !String.IsNullOrEmpty(Src))
{
// Inline declaration
var definition = _resourceManager.InlineManifest.DefineScript(Name);
definition.SetUrl(Src, DebugSrc);
if (!String.IsNullOrEmpty(Version))
{
definition.SetVersion(Version);
}
if (!String.IsNullOrEmpty(CdnSrc))
{
definition.SetCdn(CdnSrc, DebugCdnSrc);
}
if (!String.IsNullOrEmpty(Culture))
{
definition.SetCultures(Culture.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries));
}
if (!String.IsNullOrEmpty(DependsOn))
{
definition.SetDependencies(DependsOn.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries));
}
if (!String.IsNullOrEmpty(Version))
{
definition.SetVersion(Version);
}
// If At is specified then we also render it
if (At != ResourceLocation.Unspecified)
{
var setting = _resourceManager.RegisterResource("script", Name);
setting.AtLocation(At);
if (!String.IsNullOrEmpty(Condition))
{
setting.UseCondition(Condition);
}
setting.UseDebugMode(Debug);
if (!String.IsNullOrEmpty(Culture))
{
setting.UseCulture(Culture);
}
foreach (var attribute in output.Attributes)
{
setting.SetAttribute(attribute.Name, attribute.Value.ToString());
}
}
}
else if (String.IsNullOrEmpty(Name) && String.IsNullOrEmpty(Src))
{
// Custom script content
var childContent = output.GetChildContentAsync().Result;
var builder = new TagBuilder("script");
builder.InnerHtml.AppendHtml(childContent);
builder.TagRenderMode = TagRenderMode.Normal;
foreach (var attribute in output.Attributes)
{
builder.Attributes.Add(attribute.Name, attribute.Value.ToString());
}
// If no type was specified, define a default one
if (!builder.Attributes.ContainsKey("type"))
{
builder.Attributes.Add("type", "text/javascript");
}
if (At == ResourceLocation.Head)
{
_resourceManager.RegisterHeadScript(builder);
}
else
{
_resourceManager.RegisterFootScript(builder);
}
}
}
public async Task ProcessAsync_GeneratesExpectedOutput_WithModelError(ValidationSummary validationSummary)
{
// Arrange
var expectedError = "I am an error.";
var expectedTagName = "not-div";
var metadataProvider = new TestModelMetadataProvider();
var htmlGenerator = new TestableHtmlGenerator(metadataProvider);
var validationSummaryTagHelper = new ValidationSummaryTagHelper(htmlGenerator)
{
ValidationSummary = validationSummary,
};
var expectedPreContent = "original pre-content";
var expectedContent = "original content";
var tagHelperContext = new TagHelperContext(
tagName: "not-div",
allAttributes: new TagHelperAttributeList(),
items: new Dictionary <object, object>(),
uniqueId: "test");
var output = new TagHelperOutput(
expectedTagName,
attributes: new TagHelperAttributeList
{
{ "class", "form-control" }
},
getChildContentAsync: (useCachedResult, encoder) =>
{
var tagHelperContent = new DefaultTagHelperContent();
tagHelperContent.SetContent("Something");
return(Task.FromResult <TagHelperContent>(tagHelperContent));
});
output.PreContent.SetContent(expectedPreContent);
output.Content.SetContent(expectedContent);
output.PostContent.SetContent("Custom Content");
var model = new Model();
var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider);
validationSummaryTagHelper.ViewContext = viewContext;
var modelState = viewContext.ModelState;
SetValidModelState(modelState);
modelState.AddModelError(string.Empty, expectedError);
// Act
await validationSummaryTagHelper.ProcessAsync(tagHelperContext, output);
// Assert
Assert.InRange(output.Attributes.Count, low: 1, high: 2);
var attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("class"));
Assert.Equal(
new TagHelperAttribute("class", "form-control validation-summary-errors"),
attribute,
CaseSensitiveTagHelperAttributeComparer.Default);
Assert.Equal(expectedPreContent, output.PreContent.GetContent());
Assert.Equal(expectedContent, output.Content.GetContent());
Assert.Equal(
$"Custom Content<ul><li>{expectedError}</li>{Environment.NewLine}</ul>",
output.PostContent.GetContent());
Assert.Equal(expectedTagName, output.TagName);
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
await output.GetChildContentAsync();
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
output.TagName = "a";
output.Attributes.SetAttribute("href", "mailto:" + Address);
output.Content.SetContent(Content);
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
output.Attributes.AddClass("alert-link");
output.Attributes.RemoveAll("abp-alert-link");
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
if (output.TagMode == TagMode.SelfClosing && AspFor == null)
{
throw new InvalidOperationException(
$"Content is required when the '{AspForAttributeName}' attribute is not specified.");
}
var errorSummaryContext = context.GetContextItem <ErrorSummaryContext>();
var childContent = await output.GetChildContentAsync();
IHtmlContent itemContent;
if (output.TagMode == TagMode.StartTagAndEndTag)
{
itemContent = childContent.Snapshot();
}
else
{
Debug.Assert(AspFor != null);
var validationMessage = _modelHelper.GetValidationMessage(
ViewContext,
AspFor !.ModelExplorer,
AspFor.Name);
if (validationMessage == null)
{
return;
}
itemContent = new HtmlString(validationMessage);
}
string?resolvedHref = null;
if (output.Attributes.TryGetAttribute("href", out var hrefAttribute))
{
resolvedHref = hrefAttribute.Value.ToString();
output.Attributes.Remove(hrefAttribute);
}
else if (AspFor != null)
{
var errorFieldId = TagBuilder.CreateSanitizedId(
_modelHelper.GetFullHtmlFieldName(ViewContext, AspFor !.Name),
Constants.IdAttributeDotReplacement);
// Date inputs are special; they don't have an element with ID which exactly corresponds to the name derived above;
// the IDs are suffixed with .Day .Month and .Year for each of the components.
// We don't have a perfect way to know whether this error is for a date input.
// The best we can do is look at the type for the ModelExpression and see if it looks like a date type.
// If it does look like a date type we also consult DateInputParseErrorsProvider to know which input to link to
// (e.g. if .Day is valid but .Month and .Year are not, we link to .Month as the first input with errors.)
// (Note we cannot rely on DateInputParseErrorsProvider for identifying date inputs since we could have errors
// that didn't come from model binding so TryGetErrorsForModel will return false.)
if (IsModelExpressionForDate())
{
var dateInputErrorComponents = DateInputErrorComponents.All;
if (_dateInputParseErrorsProvider.TryGetErrorsForModel(AspFor.Name, out var dateInputParseErrors))
{
dateInputErrorComponents = dateInputParseErrors.GetErrorComponents();
}
Debug.Assert(dateInputErrorComponents != DateInputErrorComponents.None);
if (dateInputErrorComponents.HasFlag(DateInputErrorComponents.Day))
{
errorFieldId += ".Day";
}
else if (dateInputErrorComponents.HasFlag(DateInputErrorComponents.Month))
{
errorFieldId += ".Month";
}
else
{
errorFieldId += ".Year";
}
}
resolvedHref = $"#{errorFieldId}";
}
errorSummaryContext.AddItem(new ErrorSummaryItem()
{
Content = itemContent,
Attributes = output.Attributes.ToAttributeDictionary(),
Href = resolvedHref,
LinkAttributes = LinkAttributes.ToAttributeDictionary()
});
output.SuppressOutput();
bool IsModelExpressionForDate()
{
Debug.Assert(AspFor != null);
var modelType = AspFor !.Metadata.ModelType;
return(_options.DateInputModelConverters.Any(c => c.CanConvertModelType(modelType)));
}
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
IUrlHelper urlHelper = urlHelperFactory.GetUrlHelper(ViewContext);
TagBuilder result = new TagBuilder("div");
// Create html tags for back and forward arrow in navigation
TagBuilder backTag = new TagBuilder("a");
TagBuilder forwardTag = new TagBuilder("a");
int prevPage;
int nextPage;
if (PageModel.CurrentPage == 1)
{
prevPage = 1;
}
else
{
prevPage = PageModel.CurrentPage - 1;
}
if (PageModel.CurrentPage == PageModel.TotalPages)
{
nextPage = PageModel.TotalPages;
}
else
{
nextPage = PageModel.CurrentPage + 1;
}
backTag.Attributes["href"] = urlHelper.Action(PageAction, new { pageNum = prevPage });
backTag.AddCssClass("btn-secondary btn ml-1 mr-1 pl-2 pr-2 mb-5");
backTag.InnerHtml.AppendHtml("<<");
result.InnerHtml.AppendHtml(backTag);
// Create page link for every page in navigation
for (int i = 1; i <= PageModel.TotalPages; i++)
{
TagBuilder tag = new TagBuilder("a");
PageUrlValues["pageNum"] = i;
tag.Attributes["href"] = urlHelper.Action(PageAction,
PageUrlValues);
if (PageClassesEnabled)
{
tag.AddCssClass(PageClass);
tag.AddCssClass(i == PageModel.CurrentPage ? PageClassSelected : PageClassNormal);
}
tag.InnerHtml.Append(i.ToString());
result.InnerHtml.AppendHtml(tag);
}
forwardTag.Attributes["href"] = urlHelper.Action(PageAction, new { pageNum = nextPage });
forwardTag.AddCssClass("btn-secondary btn ml-1 mr-1 pl-2 pr-2 mb-5");
forwardTag.InnerHtml.AppendHtml(">>");
result.InnerHtml.AppendHtml(forwardTag);
result.AddCssClass("pagination justify-content-center");
output.Content.AppendHtml(result.InnerHtml);
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
this.InnerProcess(ref context, ref output);
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
output.TagName = "ul";
output.Attributes["class"] = "pagination pagination-sm";
if (CurrentPage == 0)
CurrentPage = 1;
var writer = new StringWriter();
var encoder = new HtmlEncoder();
var li = new TagBuilder("li");
var a = new TagBuilder("a");
if (CurrentPage > 10)
{
a.MergeAttribute("href", $"{Url}?Page={((CurrentPage - 1) / 10) * 10}{(SearchMode ? $"&SearchField={SearchField}&SearchQuery={SearchQuery}" : "")}");
a.InnerHtml.AppendHtml("◄");
}
else
{
a.MergeAttribute("class", "disabled");
a.InnerHtml.AppendHtml("◁");
}
li.InnerHtml.Append(a);
li.WriteTo(writer, encoder);
int firstPage = (CurrentPage - 1) / 10 * 10 + 1;
int i;
for (i = firstPage; i < firstPage + 10; i++)
{
if (i > TotalPages)
break;
li = new TagBuilder("li");
a = new TagBuilder("a");
if (i == CurrentPage)
{
li.MergeAttribute("class", "active");
a.MergeAttribute("href", "#");
}
else
{
a.MergeAttribute("href", $"{Url}?Page={i}{(SearchMode ? $"&SearchField={SearchField}&SearchQuery={SearchQuery}" : "")}");
}
a.InnerHtml.AppendHtml(i.ToString());
li.InnerHtml.Append(a);
li.WriteTo(writer, encoder);
}
li = new TagBuilder("li");
a = new TagBuilder("a");
if (i < TotalPages)
{
a.MergeAttribute("href", $"{Url}?Page={i}{(SearchMode ? $"&SearchField={SearchField}&SearchQuery={SearchQuery}" : "")}");
a.InnerHtml.AppendHtml("►");
}
else
{
a.MergeAttribute("class", "disabled");
a.InnerHtml.AppendHtml("▷");
}
li.InnerHtml.Append(a);
li.WriteTo(writer, encoder);
output.Content.AppendHtml(writer.ToString());
}
public static String MergeClasses(this TagHelperContext context, String value)
{
return(context.MergeAttribute("class", value));
}
public async Task ProcessAsync_MergesTagBuilderFromGenerateValidationSummary()
{
// Arrange
var tagBuilder = new TagBuilder("span2");
tagBuilder.InnerHtml.SetHtmlContent("New HTML");
tagBuilder.Attributes.Add("anything", "something");
tagBuilder.Attributes.Add("data-foo", "bar");
tagBuilder.Attributes.Add("data-hello", "world");
var generator = new Mock <IHtmlGenerator>(MockBehavior.Strict);
generator
.Setup(mock => mock.GenerateValidationSummary(
It.IsAny <ViewContext>(),
It.IsAny <bool>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <object>()))
.Returns(tagBuilder);
var validationSummaryTagHelper = new ValidationSummaryTagHelper(generator.Object)
{
ValidationSummary = ValidationSummary.ModelOnly,
};
var expectedPreContent = "original pre-content";
var expectedContent = "original content";
var output = new TagHelperOutput(
tagName: "div",
attributes: new TagHelperAttributeList(),
getChildContentAsync: (useCachedResult, encoder) => Task.FromResult <TagHelperContent>(
new DefaultTagHelperContent()));
output.PreContent.SetContent(expectedPreContent);
output.Content.SetContent(expectedContent);
output.PostContent.SetContent("Content of validation summary");
var viewContext = CreateViewContext();
validationSummaryTagHelper.ViewContext = viewContext;
var context = new TagHelperContext(
tagName: "div",
allAttributes: new TagHelperAttributeList(),
items: new Dictionary <object, object>(),
uniqueId: "test");
// Act
await validationSummaryTagHelper.ProcessAsync(context, output);
// Assert
Assert.Equal("div", output.TagName);
Assert.Collection(
output.Attributes,
attribute =>
{
Assert.Equal("anything", attribute.Name);
Assert.Equal("something", attribute.Value);
},
attribute =>
{
Assert.Equal("data-foo", attribute.Name);
Assert.Equal("bar", attribute.Value);
},
attribute =>
{
Assert.Equal("data-hello", attribute.Name);
Assert.Equal("world", attribute.Value);
});
Assert.Equal(expectedPreContent, output.PreContent.GetContent());
Assert.Equal(expectedContent, output.Content.GetContent());
Assert.Equal("Content of validation summaryNew HTML", output.PostContent.GetContent());
}
public static String MergeAttribute(this TagHelperContext context, String attrName, String value, String separator = " ")
{
var currentValue = context.AllAttributes[attrName]?.Value;
return($"{value}{separator}{currentValue}");
}
public override Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
this.InnerProcess(ref context, ref output);
return(base.ProcessAsync(context, output));
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
output.TagName = "script";
output.Attributes.Add("src", "Resources/Scripts/mvc.input.js");
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
string textClass = "form-control"; //TextBoxClass;
var propertyName = For.Name.Camelize();
var labelName = ((DefaultModelMetadata)For.Metadata).Placeholder ?? ((DefaultModelMetadata)For.Metadata).DisplayName ?? For.Name.Humanize();
var dataType = ((DefaultModelMetadata)For.Metadata).DataTypeName;
var inputType = dataType == "Password" ? "Password" : "Text";
// HTML5 input type="" to be supported
//color
//date
//datetime
//datetime-local
//email
//month
//number
//range
//search
//tel
//time
//url
//week
output.TagName = "div";
output.Attributes.Add("class", "form-group");
var label = new TagBuilder("label");
label.MergeAttribute("for", propertyName);
label.InnerHtml.AppendHtml(labelName);
output.PostContent.SetHtmlContent(label);
var input = new TagBuilder("input");
input.MergeAttribute("id", propertyName);
input.MergeAttribute("type", dataType);
if (!string.IsNullOrEmpty(textClass))
{
input.AddCssClass(textClass);
}
if (!string.IsNullOrEmpty(Hidden))
{
output.Attributes.Add("hidden", "hidden");
input.Attributes.Add("hidden", "hidden");
}
if (!string.IsNullOrEmpty(Readonly) || For.Metadata.IsReadOnly)
{
input.Attributes.Add("readonly", "readonly");
}
input.Attributes.Add("#" + propertyName, "dummyvalue");
if (((DefaultModelMetadata)For.Metadata).HasMinLengthValidation())
{
input.Attributes.Add("minLength", ((DefaultModelMetadata)For.Metadata).MinLength().ToString());
}
if (((DefaultModelMetadata)For.Metadata).HasMaxLengthValidation())
{
input.Attributes.Add("maxLength", ((DefaultModelMetadata)For.Metadata).MaxLength().ToString());
}
if (((DefaultModelMetadata)For.Metadata).IsRequired)
{
input.Attributes.Add("required", "required");
}
if (For.Metadata.HasRegexValidation())
{
input.Attributes.Add("pattern", For.Metadata.RegexExpression());
}
input.Attributes.Add("placeholder", labelName);
input.TagRenderMode = TagRenderMode.StartTag;
if (dataType == "Currency")
{
//<div class="input-group">
var divInputGroup = new TagBuilder("div");
divInputGroup.MergeAttribute("class", "input-group");
// <span class="input-group-addon">$</span>
var spanInputGroupAddon = new TagBuilder("span");
spanInputGroupAddon.MergeAttribute("class", "input-group-addon");
spanInputGroupAddon.InnerHtml.Append("$");
divInputGroup.InnerHtml.AppendHtml(spanInputGroupAddon);
divInputGroup.InnerHtml.AppendHtml(input);
output.PostContent.SetHtmlContent(divInputGroup);
}
else
{
output.PostContent.SetHtmlContent(input);
}
var childContent = output.PostContent.GetContent();
output.PostContent.SetHtmlContent(Regex.Replace(childContent, @"=""dummyvalue""", string.Empty));
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
var preHtml = string.Empty;
var postHtml = string.Empty;
if (output.Attributes.ContainsName("id") == false && string.IsNullOrEmpty(Id) == false)
{
output.Attributes.SetAttribute("id", Id);
}
if (output.Attributes.ContainsName("lay-filter") == false && output.Attributes.ContainsName("id") == true)
{
output.Attributes.SetAttribute("lay-filter", $"{output.Attributes["id"].Value}filter");
}
if (string.IsNullOrEmpty(Class) == false)
{
output.Attributes.SetAttribute("class", Class);
}
if (Style == null)
{
Style = "";
}
if (Width.HasValue)
{
Style += $" width:{Width}px;";
}
if (Height.HasValue)
{
Style += $" height:{Height}px;";
}
if (string.IsNullOrEmpty(Style) == false)
{
if (this is TreeTagHelper)
{
Style += " overflow:auto;";
}
output.Attributes.SetAttribute("style", Style);
}
if (context.Items.ContainsKey("ipr"))
{
int?ipr = (int?)context.Items["ipr"];
if (ipr > 0)
{
int col = 12 / ipr.Value;
if (Colspan != null)
{
col *= Colspan.Value;
}
preHtml = $@"
<div class=""layui-col-md{col}"">
" + preHtml;
postHtml += @"
</div>
";
output.PreElement.SetHtmlContent(preHtml + output.PreElement.GetContent());
output.PostElement.AppendHtml(postHtml);
}
}
//输出事件
switch (this)
{
case ComboBoxTagHelper item:
if (item.LinkField != null)
{
if (!string.IsNullOrEmpty(item.TriggerUrl))
{
output.PostElement.AppendHtml($@"
<script>
layui.use(['form'],function(){{
var form = layui.form;
form.on('select({output.Attributes["lay-filter"].Value})', function(data){{
{FormatFuncName(item.ChangeFunc)};
ff.LinkedChange('{item.TriggerUrl}/'+data.value,'{Core.Utils.GetIdByName(item.LinkField.ModelExplorer.Container.ModelType.Name + "." + item.LinkField.Name)}','{item.LinkField.Name}');
ff.changeComboIcon(data);
}});
}})
</script>
");
}
}
else
{
output.PostElement.AppendHtml($@"
<script>
layui.use(['form'],function(){{
var form = layui.form;
form.on('select({output.Attributes["lay-filter"].Value})', function(data){{
{FormatFuncName(item.ChangeFunc)};
ff.changeComboIcon(data);
}});
}})
</script>
");
}
break;
case CheckBoxTagHelper item:
if (string.IsNullOrEmpty(item.ChangeFunc) == false)
{
output.PostContent.SetHtmlContent(output.PostContent.GetContent().Replace("type=\"checkbox\" ", $"type=\"checkbox\" lay-filter=\"{output.Attributes["lay-filter"].Value}\""));
output.PostElement.AppendHtml($@"
<script>
layui.use(['form'],function(){{
var form = layui.form;
form.on('checkbox({output.Attributes["lay-filter"].Value})', function(data){{
{FormatFuncName(item.ChangeFunc)};
}});
}})
</script>
");
}
break;
case SwitchTagHelper item:
if (string.IsNullOrEmpty(item.ChangeFunc) == false)
{
output.PostElement.AppendHtml($@"
<script>
layui.use(['form'],function(){{
var form = layui.form;
form.on('switch({output.Attributes["lay-filter"].Value})', function(data){{
{FormatFuncName(item.ChangeFunc)};
}});
}})
</script>
");
}
break;
case RadioTagHelper item:
if (string.IsNullOrEmpty(item.ChangeFunc) == false)
{
output.PostContent.SetHtmlContent(output.PostContent.GetContent().Replace("type=\"radio\" ", $"type=\"radio\" lay-filter=\"{output.Attributes["lay-filter"].Value}\""));
output.PostElement.AppendHtml($@"
<script>
layui.use(['form'],function(){{
var form = layui.form;
form.on('radio({output.Attributes["lay-filter"].Value})', function(data){{
{FormatFuncName(item.ChangeFunc)};
}});
}})
</script>
");
}
break;
case TextBoxTagHelper item:
if (string.IsNullOrEmpty(item.SearchUrl) == false)
{
if (!string.IsNullOrEmpty(item.TriggerUrl))
{
output.PostElement.AppendHtml($@"
<script>
layui.use(['autocomplete'],function(){{
layui.autocomplete.render({{
elem: $('#{item.Id}')[0],
url: '{item.SearchUrl}',
cache: false,
template_val: '{{{{d.Value}}}}',
template_txt: '{{{{d.Text}}}}',
onselect: function (data) {{
$('#{item.Id}').val(data.Value);
{FormatFuncName(item.ChangeFunc)};
ff.LinkedChange('{item.TriggerUrl}/'+data.Value,'{Core.Utils.GetIdByName(item.LinkField.ModelExplorer.Container.ModelType.Name + "." + item.LinkField.Name)}','{item.LinkField.Name}');
}}
}});
}})
</script>
");
}
else
{
output.PostElement.AppendHtml($@"
<script>
layui.use(['autocomplete'],function(){{
layui.autocomplete.render({{
elem: $('#{item.Id}')[0],
url: '{item.SearchUrl}',
cache: false,
template_val: '{{{{d.Value}}}}',
template_txt: '{{{{d.Text}}}}',
onselect: function (data) {{
$('#{item.Id}').val(data.Value);
{FormatFuncName(item.ChangeFunc)};
}}
}});
}})
</script>
");
}
}
break;
}
//如果是submitbutton，则在button前面加入一个区域用来定位输出后台返回的错误
if (output.TagName == "button" && output.Attributes.TryGetAttribute("lay-submit", out TagHelperAttribute ta) == true)
{
output.PreElement.SetHtmlContent($"<p id='{Id}errorholder'></p>" + output.PreElement.GetContent());
}
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
TagBuilder anchor = new TagBuilder("a");
anchor.Attributes.Add("href", "https://twitter.com/share");
anchor.Attributes.Add("class", "twitter-share-button");
anchor.Attributes.Add("data-url", TwitterShareUrl);
anchor.Attributes.Add("data-text", "Check out this site");
anchor.InnerHtml = "Tweet";
TagBuilder script = new TagBuilder("script");
script.InnerHtml = @"
!function (d, s, id) { var js, fjs = d.getElementsByTagName(s)[0];
if (!d.getElementById(id)) { js = d.createElement(s); js.id = id;
js.src = '//platform.twitter.com/widgets.js'; fjs.parentNode.insertBefore(js, fjs);
} }(document, 'script', 'twitter-wjs');
";
string twitterShare = anchor + script.ToString();
output.Content.Append(twitterShare);
}
public override void Init(TagHelperContext context)
{
base.Init(context);
context.Items[nameof(TabStripTagHelper)] = this;
}
public async Task ProcessAsync_GeneratesExpectedOutput()
{
// Arrange
var expectedTagName = "not-span";
var metadataProvider = new TestModelMetadataProvider();
var modelExpression = CreateModelExpression("Name");
var htmlGenerator = new TestableHtmlGenerator(metadataProvider);
var validationMessageTagHelper = new ValidationMessageTagHelper(htmlGenerator)
{
For = modelExpression
};
var expectedPreContent = "original pre-content";
var expectedContent = "original content";
var expectedPostContent = "original post-content";
var tagHelperContext = new TagHelperContext(
tagName: "not-span",
allAttributes: new TagHelperAttributeList
{
{ "id", "myvalidationmessage" },
{ "for", modelExpression },
},
items: new Dictionary <object, object>(),
uniqueId: "test");
var output = new TagHelperOutput(
expectedTagName,
attributes: new TagHelperAttributeList
{
{ "id", "myvalidationmessage" }
},
getChildContentAsync: (useCachedResult, encoder) =>
{
var tagHelperContent = new DefaultTagHelperContent();
tagHelperContent.SetContent("Something");
return(Task.FromResult <TagHelperContent>(tagHelperContent));
});
output.PreContent.SetContent(expectedPreContent);
output.Content.SetContent(expectedContent);
output.PostContent.SetContent(expectedPostContent);
var viewContext = TestableHtmlGenerator.GetViewContext(
model: null,
htmlGenerator: htmlGenerator,
metadataProvider: metadataProvider);
validationMessageTagHelper.ViewContext = viewContext;
// Act
await validationMessageTagHelper.ProcessAsync(tagHelperContext, output);
// Assert
Assert.Equal(4, output.Attributes.Count);
var attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("id"));
Assert.Equal("myvalidationmessage", attribute.Value);
attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("class"));
Assert.Equal("field-validation-valid", attribute.Value);
attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("data-valmsg-for"));
Assert.Equal("Name", attribute.Value);
attribute = Assert.Single(output.Attributes, attr => attr.Name.Equals("data-valmsg-replace"));
Assert.Equal("true", attribute.Value);
Assert.Equal(expectedPreContent, output.PreContent.GetContent());
Assert.Equal(expectedContent, output.Content.GetContent());
Assert.Equal(expectedPostContent, output.PostContent.GetContent());
Assert.Equal(expectedTagName, output.TagName);
}
public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
if (String.IsNullOrEmpty(Message) && Errors.Count == 0)
{
output.SuppressOutput();
return;
}
output.TagName = "div";
output.AddCssClass($"alert alert-danger wv-alert {(ShowIcon ? " alert-icon " : "")} {Class}");
//>> Icon
if (ShowIcon)
{
var iconEl = new TagBuilder("div");
iconEl.AddCssClass("icon");
iconEl.InnerHtml.AppendHtml($"<i class='fas fa-fw fa-exclamation-circle'></i>");
output.Content.AppendHtml(iconEl);
}
//>> content
var contentEl = new TagBuilder("div");
contentEl.AddCssClass("content");
//>> content >> message
if (!String.IsNullOrWhiteSpace(Message))
{
var titleEl = new TagBuilder("div");
if (Errors.Count > 0)
{
titleEl.AddCssClass("title");
}
titleEl.InnerHtml.AppendHtml(Message);
contentEl.InnerHtml.AppendHtml(titleEl);
}
//>> content >> errors
if (Errors.Count > 0)
{
var ulEl = new TagBuilder("ul");
ulEl.AddCssClass($"list");
foreach (var error in Errors)
{
var liEl = new TagBuilder("li");
if (!ShowKey)
{
liEl.InnerHtml.AppendHtml(error.Value);
}
else
{
var keyEl = new TagBuilder("strong");
keyEl.InnerHtml.AppendHtml(error.Key);
liEl.InnerHtml.AppendHtml(keyEl);
liEl.InnerHtml.AppendHtml($" - {error.Value}");
}
ulEl.InnerHtml.AppendHtml(liEl);
}
contentEl.InnerHtml.AppendHtml(ulEl);
}
output.Content.AppendHtml(contentEl);
}
public async Task ProcessAsync_GeneratesExpectedOutput_WithEmptyNameFor_WithValidationFor()
{
// Arrange
var expectedAttributeValue = "-expression-";
var expectedTagName = "span";
var metadataProvider = new EmptyModelMetadataProvider();
var modelExpression = CreateModelExpression(string.Empty);
var htmlGenerator = new TestableHtmlGenerator(metadataProvider);
var viewContext = TestableHtmlGenerator.GetViewContext(
model: null,
htmlGenerator: htmlGenerator,
metadataProvider: metadataProvider);
var validationMessageTagHelper = new ValidationMessageTagHelper(htmlGenerator)
{
For = modelExpression,
ViewContext = viewContext,
};
var tagHelperContext = new TagHelperContext(
expectedTagName,
new TagHelperAttributeList
{
{ "for", modelExpression },
},
new Dictionary <object, object>(),
"test");
var output = new TagHelperOutput(
expectedTagName,
new TagHelperAttributeList
{
{ "data-valmsg-for", expectedAttributeValue },
},
(_, __) => Task.FromResult <TagHelperContent>(new DefaultTagHelperContent()));
validationMessageTagHelper.ViewContext = viewContext;
// Act
await validationMessageTagHelper.ProcessAsync(tagHelperContext, output);
// Assert
Assert.Equal(expectedTagName, output.TagName);
Assert.Collection(output.Attributes,
attribute =>
{
Assert.Equal("data-valmsg-for", attribute.Name);
Assert.Equal(expectedAttributeValue, attribute.Value);
},
attribute =>
{
Assert.Equal("class", attribute.Name);
Assert.Equal("field-validation-valid", attribute.Value);
},
attribute =>
{
Assert.Equal("data-valmsg-replace", attribute.Name);
Assert.Equal("true", attribute.Value);
});
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
output.TagName = "div";
output.TagMode = TagMode.StartTagAndEndTag;
output.Attributes.Add("id", $"{_idPrefix}{Id}");
#region 添加下拉数据 并 设置默认选中
var modeltype = Field.Metadata.ModelType;
var listItems = Items?.Model as List <ComboSelectListItem>;
if (listItems == null)
{
listItems = new List <ComboSelectListItem>();
if (Items.Metadata.ModelType.IsList())
{
var exports = (Items.Model as IList);
foreach (var item in exports)
{
listItems.Add(new ComboSelectListItem
{
Text = item?.ToString(),
Value = item?.ToString()
});
}
}
}
var data = listItems.Select(x => new
{
x.Value,
Title = x.Text,
x.Disabled,
Checked = x.Selected
}).ToArray();
#endregion
// 赋默认值
if (string.IsNullOrEmpty(DefaultValue) && Field.Model != null)
{
var selectVal = new List <string>();
if (modeltype.IsArray || (modeltype.IsGenericType && typeof(List <>).IsAssignableFrom(modeltype.GetGenericTypeDefinition())))
{
foreach (var item in Field.Model as dynamic)
{
selectVal.Add($"'{item.ToString().ToLower()}'");
}
}
else
{
selectVal.Add(Field.Model.ToString().ToLower());
}
DefaultValue = $"[{string.Join(",", selectVal)}]";
}
var title = $"['{(string.IsNullOrEmpty(LeftTitle) ? "待选择" : LeftTitle)}','{(string.IsNullOrEmpty(RightTitle) ? "选择的" : RightTitle)}']";
var content = $@"
<script>
layui.use(['transfer'],function(){{
var $ = layui.$;
var transfer = layui.transfer;
var name = '{Field.Name}';
var _id = '{_idPrefix}{Id}';
var container = $('#'+_id);
function defaultFunc(data,index,transferIns) {{
var selectVals = transfer.getData('{Id}');
/* remove old values */
var inputs = $('#'+_id+' input[name='+name+']')
if(inputs!=null && inputs.length>0){{
for (var i = 0; i < inputs.length; i++) {{
inputs[i].remove();
}}
}}
/* add new values */
for (var i = 0; i < selectVals.length; i++) {{
container.append('<input type=""hidden"" name=""'+name+'"" value=""'+selectVals[i].value+'""/>');
}}
}}
var defaultVal = {(string.IsNullOrEmpty(DefaultValue) ? "[]" : DefaultValue)};
var transferIns = transfer.render({{
elem: '#'+_id
,title:{title}
,data:{JsonConvert.SerializeObject(data, _jsonSerializerSettings)}
{(string.IsNullOrEmpty(DefaultValue) ? string.Empty : $",value:defaultVal")}
,id:'{Id}'
,text:{{none:'{NonePlaceholder}',searchNone:'{SearchNonePlaceholder}'}}
{(!EnableSearch ? string.Empty : ",showSearch:true")}
{(!Width.HasValue ? string.Empty : $",width:{Width}")}
{(!Height.HasValue ? string.Empty : $",height:{Height}")}
,onchange: function(data,index){{defaultFunc(data,index,transferIns);
{(string.IsNullOrEmpty(ChangeFunc) ? string.Empty : $"{ChangeFunc}(data, index,transferIns);")}
protected override void AddHtmlTag(ViewContext viewContext, TagHelperContext context, TagHelperOutput output, string file)
{
output.Content.AppendHtml($"<script src=\"{viewContext.GetUrlHelper().Content(file.EnsureStartsWith('~'))}\"></script>{Environment.NewLine}");
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
var modelState = _accessor.ActionContext.ModelState;
}
public override void Init(TagHelperContext context)
{
base.Init(context);
this.ListGroupContext.IsLinkGroup = true;
}
public override void Process(TagHelperContext context, TagHelperOutput output)
{
output.Content.SetContent("root-content");
}
public override Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
output.Attributes.AddOrUpdate("type", "number");
return(base.ProcessAsync(context, output));
}
public async Task ProcessAsync_GeneratesExpectedOutput_WithPropertyErrors()
{
// Arrange
var expectedError0 = "I am an error.";
var expectedError2 = "I am also an error.";
var expectedTagName = "not-div";
var expectedAttributes = new TagHelperAttributeList
{
new TagHelperAttribute("class", "form-control validation-summary-errors"),
new TagHelperAttribute("data-valmsg-summary", "true"),
};
var metadataProvider = new TestModelMetadataProvider();
var htmlGenerator = new TestableHtmlGenerator(metadataProvider);
var validationSummaryTagHelper = new ValidationSummaryTagHelper(htmlGenerator)
{
ValidationSummary = ValidationSummary.All,
};
var expectedPreContent = "original pre-content";
var expectedContent = "original content";
var tagHelperContext = new TagHelperContext(
tagName: "not-div",
allAttributes: new TagHelperAttributeList(),
items: new Dictionary <object, object>(),
uniqueId: "test");
var output = new TagHelperOutput(
expectedTagName,
attributes: new TagHelperAttributeList
{
{ "class", "form-control" }
},
getChildContentAsync: (useCachedResult, encoder) =>
{
var tagHelperContent = new DefaultTagHelperContent();
tagHelperContent.SetContent("Something");
return(Task.FromResult <TagHelperContent>(tagHelperContent));
});
output.PreContent.SetContent(expectedPreContent);
output.Content.SetContent(expectedContent);
output.PostContent.SetContent("Custom Content");
var model = new Model();
var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator, metadataProvider);
validationSummaryTagHelper.ViewContext = viewContext;
var modelState = viewContext.ModelState;
SetValidModelState(modelState);
modelState.AddModelError(key: $"{nameof(Model.Strings)}[0]", errorMessage: expectedError0);
modelState.AddModelError(key: $"{nameof(Model.Strings)}[2]", errorMessage: expectedError2);
// Act
await validationSummaryTagHelper.ProcessAsync(tagHelperContext, output);
// Assert
Assert.Equal(expectedAttributes, output.Attributes, CaseSensitiveTagHelperAttributeComparer.Default);
Assert.Equal(expectedPreContent, output.PreContent.GetContent());
Assert.Equal(expectedContent, output.Content.GetContent());
Assert.Equal(
$"Custom Content<ul><li>{expectedError0}</li>{Environment.NewLine}" +
$"<li>{expectedError2}</li>{Environment.NewLine}</ul>",
output.PostContent.GetContent());
Assert.Equal(expectedTagName, output.TagName);
}
public override Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
return(Task.Run(() => Process(context, output)));
}
public override void Process(TagHelperContext context,
TagHelperOutput output)
{
output.PreContent.SetHtmlContent("<b><i>");
output.PostContent.SetHtmlContent("</i></b>");
}
public override void Init(TagHelperContext context)
{
base.Init(context);
context.Items.Add("tr-url", this);
}
