private string GetIconAnchor(string cssClass, string iconCssClass, int pageNumber, string title)
{
StringBuilder anchor = new StringBuilder();
TagBuilder.Begin(anchor, "a");
TagBuilder.AddClass(anchor, cssClass);
if (!string.IsNullOrWhiteSpace(title))
{
TagBuilder.AddTitle(anchor, title);
}
if (pageNumber > 0)
{
TagBuilder.AddAttribute(anchor, "href",
string.Format(CultureInfo.InvariantCulture, "{0}?page={1}", this._currentPageUrl, pageNumber));
}
TagBuilder.Close(anchor);
if (!string.IsNullOrWhiteSpace(iconCssClass))
{
TagBuilder.AddIcon(anchor, iconCssClass);
}
TagBuilder.EndTag(anchor, "a");
return(anchor.ToString());
}
public override string Get()
{
StringBuilder grid = new StringBuilder();
using (DataTable table = this.GetTable())
{
if (table.Rows.Count.Equals(0))
{
return("<div class='ui message'>No record found</div>");
}
TagBuilder.Begin(grid, "table");
TagBuilder.AddId(grid, "FormGridView");
TagBuilder.AddClass(grid, ConfigBuilder.GetGridViewCssClass(this.Config));
TagBuilder.AddStyle(grid, ConfigBuilder.GetGridViewWidth(this.Config) + ";white-space: nowrap;");
TagBuilder.Close(grid);
List <Column> columns = GetColumns(table).ToList();
HeaderRow header = new HeaderRow(this.Config, columns);
grid.Append(header.Get());
using (Body body = new Body(this.Config, table, columns))
{
grid.Append(body.Get());
}
TagBuilder.EndTag(grid, "table");
}
return(grid.ToString());
}
internal static void AddScrudFormRow(StringBuilder builder, string targetControlId, string label, string control)
{
TagBuilder.Begin(builder, "tr", true);
TagBuilder.Begin(builder, "td");
TagBuilder.AddClass(builder, "label-cell");
TagBuilder.Close(builder);
TagBuilder.Begin(builder, "label");
TagBuilder.AddAttribute(builder, "for", targetControlId);
TagBuilder.Close(builder);
builder.Append(label);
TagBuilder.EndTag(builder, "label");
TagBuilder.EndTag(builder, "td");
TagBuilder.Begin(builder, "td");
TagBuilder.AddClass(builder, "control-cell");
TagBuilder.Close(builder);
builder.Append(control);
TagBuilder.EndTag(builder, "td");
TagBuilder.EndTag(builder, "tr");
}
public static TagBuilder GridEditDeleteLink(this IHtmlHelper html, string controller, string editAction, string deleteAction, Dictionary <string, object> data, string objectTypeName, string objectName, bool editInGrid = false, string deleteController = null, bool renderDeleteLink = true)
{
object htmlAttr = null;
TagBuilder div = new TagBuilder(Constants.DOM.DIV);
div.AddClass("actIconsContainer");
if (editInGrid)
{
foreach (var key in data.Keys)
{
div.Attributes["data-" + key] = data[key].ToString();
}
}
if (editAction.ToLower().Contains("edit"))
{
htmlAttr = new { title = "edit" };
}
div.InnerHtml.Append(html.GriEditLink(controller, editAction, data, objectTypeName, htmlAttr: htmlAttr).ToString());
if (renderDeleteLink)
{
if (deleteAction.ToLower().Contains("delete"))
{
htmlAttr = new { title = "delete" };
}
div.InnerHtml.Append(html.GridDeleteLink(deleteController.Nz(controller), deleteAction, data, objectTypeName, objectName, htmlAttr).ToString());
}
return(div);
}
public static IHtmlContent TickBox(this IHtmlHelper htmlHelper, string name, object value, bool isChecked, string extraClasses = null, string extraAttr = null)
{
TagBuilder tb = new TagBuilder(Constants.DOM.LABEL);
tb.AddClass("checkbox-inline i-checks " + extraClasses);
tb.InnerHtml.Append(addValidationErrorMarker(htmlHelper, new HtmlString(@"<input type = 'checkbox' value='{0}' name='{1}' id='{1}' {2} {3}/>".Frmt(value, name, isChecked ? "checked='checked'" : null, extraAttr)), name).ToString());
return(tb);
}
public static IHtmlContent TickBoxFor <TModel>(this IHtmlHelper <TModel> htmlHelper, Expression <Func <TModel, bool> > expression, object attributes = null, string extraClasses = null)
{
var tb = new TagBuilder(Constants.DOM.LABEL);
tb.AddClass("checkbox-inline i-checks " + extraClasses);
tb.InnerHtml.Append(addValidationErrorMarker(htmlHelper, htmlHelper.CheckBoxFor(expression, attributes), htmlHelper.IdFor(expression)).ToString());
return(tb);
}
public static IHtmlContent TimePicker <TModel, TResult>(this IHtmlHelper <TModel> helper, Expression <Func <TModel, TResult> > expression, bool isRequired = false)
{
TagBuilder divContainer = new TagBuilder(Constants.DOM.DIV);
divContainer.AddClass("input-group bootstrap-timepicker");
divContainer.InnerHtml.AppendHtml("<span class='input-group-addon'><i class='fa fa-clock-o'></i></span>");
divContainer.InnerHtml.Append(BBTextBoxFor(helper, expression, new { required = isRequired, @class = "bs-timepicker form-control" }, "{0:t}").ToString());
return(divContainer);
}
public static IHtmlContent DatePicker <TModel, TResult>(this IHtmlHelper <TModel> helper, Expression <Func <TModel, TResult> > expression, string extraClass = "", bool isRequired = false)
{
TagBuilder divContainer = new TagBuilder(Constants.DOM.DIV);
divContainer.AddClass("input-group date");
divContainer.InnerHtml.AppendHtml("<span class='input-group-addon'><i class='fa fa-calendar'></i></span>");
divContainer.InnerHtml.Append(BBTextBoxFor(helper, expression, new { required = isRequired, @class = "form-control " + extraClass }, "{0:dd/MM/yyyy}").ToString());
return(divContainer);
}
public static TagBuilder FALink(this IHtmlHelper html, string controller, string action, string iconClass, object routeValues = null, object htmlAttributes = null)
{
TagBuilder a = (TagBuilder)html.ActionLink(string.Empty, action, controller, routeValues, htmlAttributes);
TagBuilder i = new TagBuilder(Constants.DOM.I);
i.AddCssClass(Constants.Css.FONT_AWESOME);
i.AddClass(iconClass);
a.InnerHtml.Append(i.ToString());
return(a);
}
public static IHtmlContent Save(this IHtmlHelper html, string name = "submit", string value = "save", string innerText = "Save", string additionalClasses = null)
{
TagBuilder tg = new TagBuilder(Constants.DOM.SPAN);
tg.AddClass("redirectContainer");
tg.InnerHtml.Append(html.Hidden(Constants.Route.PARENT_PAGE_URL, GetRefUrl(html)).ToString());
tg.InnerHtml.Append(html.SubmitButton(
name, value, innerText, additionalClasses,
btn => btn.AddCssClass("btn-primary save-btn")
).ToString());
return(tg);
}
private static IHtmlContent addValidationErrorMarker(this IHtmlHelper htmlHelper, IHtmlContent html, string elName)
{
var containerTag = new TagBuilder(Constants.DOM.DIV);
containerTag.AddClass("validContainer");
containerTag.InnerHtml.Append(html.ToString());
var validationKeys = new string[] { "number", "required", "min", "max" };
//if (Constants.HtmlAttribute.VALIDATION_ATTRS.Any(a => html.ToString().Contains(a)))
{
containerTag.InnerHtml.Append(ValidationErrorMarker(htmlHelper, elName).ToString());
}
return(containerTag);
}
public static IHtmlContent HiddenEnumerableFor <TModel, TResult>(this IHtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TResult> > expression, object[] values, object attributes = null)
{
string name = htmlHelper.IdFor(expression);
TagBuilder divContainer = new TagBuilder(Constants.DOM.DIV);
divContainer.AddClass("{0}Container".Frmt(name));
if (values != null)
{
foreach (var value in values)
{
divContainer.InnerHtml.Append(htmlHelper.Hidden(name, value, attributes).ToString());
}
}
return(divContainer);
}
//public static IHtmlContent DropZone(this IHtmlHelper html, IModelWithImage model, string dropZoneId)
//{
// return html.Partial("_EditImages", new EditImages()
// {
// DropZoneId = dropZoneId,
// ImagesModel = model
// });
//}
public static IHtmlContent SubmitButton(this IHtmlHelper html, string name, string value, string innerText, string additionalClasses = null, Action <TagBuilder> setProperties = null)
{
TagBuilder result = new TagBuilder("button");
result.Attributes[Constants.HtmlAttribute.NAME] = name;
result.Attributes[Constants.HtmlAttribute.VALUE] = value;
result.Attributes[Constants.HtmlAttribute.TYPE] = "submit";
result.AddCssClass("btn");
result.AddClass(additionalClasses);
if (setProperties != null)
{
setProperties(result);
}
result.InnerHtml.SetHtmlContent(innerText);
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="output"></param>
public override void Process(TagHelperContext context, TagHelperOutput output)
{
switch (TagHelper.DropdownButtonType)
{
case DropdownButtonType.Single:
output.AddClass("dropdown-toggle");
output.AddAttribute("data-toggle", "dropdown");
break;
default:
var tagbuilder = new TagBuilder(output.TagName);
tagbuilder.MergeAttributes(output.Attributes.ToDictionary(a => a.Name, a => a.Value));
tagbuilder.AddClass("dropdown-toggle").AddClass("dropdown-toggle-split").AddAttribute("data-toggle", "dropdown");
output.PostElement.AppendHtml(tagbuilder);
break;
}
}
public override string Get()
{
StringBuilder form = new StringBuilder();
TagBuilder.Begin(form, "form");
TagBuilder.AddId(form, "FormPanel");
TagBuilder.AddStyle(form, "display:none;");
TagBuilder.AddClass(form, ConfigBuilder.GetFormPanelCssClass(this.Config));
TagBuilder.Close(form);
TagBuilder.Begin(form, "div");
TagBuilder.AddClass(form, ConfigBuilder.GetFormCssClass(this.Config));
TagBuilder.Close(form);
TagBuilder.Begin(form, "div");
TagBuilder.AddClass(form, ConfigBuilder.GetFormDescriptionCssClass(this.Config));
TagBuilder.Close(form);
form.Append(Resources.Titles.RequiredFieldDetails);
TagBuilder.EndTag(form, "div");
TagBuilder.Begin(form, "table");
TagBuilder.AddAttribute(form, "role", "scrud");
TagBuilder.Close(form);
IEnumerable <FieldConfig> fields = FieldConfigHelper.GetFields(this.Values, this.Config, this.Editing);
foreach (Field field in fields.Select(fieldConfig => new Field(this.Config, fieldConfig)))
{
form.Append(field.Get());
}
FormFooter footer = new FormFooter(this.Config);
form.Append(footer.Get());
TagBuilder.EndTag(form, "table");
TagBuilder.EndTag(form, "div");
TagBuilder.EndTag(form, "form");
return(form.ToString());
}
private void BuildButton(StringBuilder builder, string type, string id, string click, string value)
{
TagBuilder.Begin(builder, "input");
TagBuilder.AddType(builder, type);
TagBuilder.AddId(builder, id);
if (!string.IsNullOrWhiteSpace(click))
{
TagBuilder.AddAttribute(builder, "onclick", click);
}
if (!string.IsNullOrWhiteSpace(this.ButtonCssClass))
{
TagBuilder.AddClass(builder, this.ButtonCssClass);
}
TagBuilder.AddValue(builder, value);
TagBuilder.Close(builder, true);
}
public override string Get()
{
StringBuilder list = new StringBuilder();
TagBuilder.Begin(list, "div");
TagBuilder.AddId(list, this.FieldConfig.ColumnName);
TagBuilder.AddClass(list, "grouped inline fields");
TagBuilder.AddAttribute(list, "data-scrud", "radio");
TagBuilder.Close(list);
TagBuilder.AddRadioField(list, this.FieldConfig.ColumnName, "yes", Resources.Titles.Yes,
this.FieldConfig.DefaultValue.ToUpperInvariant().Equals("TRUE"), this.FieldConfig.IsDisabled);
TagBuilder.AddRadioField(list, this.FieldConfig.ColumnName, "no", Resources.Titles.No,
this.FieldConfig.DefaultValue.ToUpperInvariant().Equals("FALSE"), this.FieldConfig.IsDisabled);
TagBuilder.EndTag(list, "div");
return(list.ToString());
}
private string GetCommandPanel()
{
StringBuilder panel = new StringBuilder();
TagBuilder.Begin(panel, "div");
TagBuilder.AddClass(panel, ConfigBuilder.GetCommandPanelCssClass(this.Config));
TagBuilder.Close(panel);
this.AddSelectButton(panel);
this.AddShowCompactButton(panel);
this.AddShowAllButton(panel);
this.AddAddButton(panel);
this.AddEditButton(panel);
this.AddDeleteButton(panel);
this.AddPrintButton(panel);
TagBuilder.EndTag(panel, "div");
return(panel.ToString());
}
public static IHtmlContent DatePicker <TModel>(this IHtmlHelper <TModel> htmlHelper, string id, string value = "", string extraClass = "", string extraAttr = "")
{
var tg = new TagBuilder(Constants.DOM.DIV);
tg.AddClass("input-group date");
tg.Attributes.Add("id", id + "_dateContainer");
var disabledAttr = "disabled";
if (extraAttr.IsNotEmpty() && extraAttr.Contains(disabledAttr))
{
tg.Attributes.Add(disabledAttr, disabledAttr);
}
tg.InnerHtml.AppendHtml(@"
<span class='input-group-addon'>
<i class='fa fa-calendar'></i>
</span>" );
tg.InnerHtml.Append(addValidationErrorMarker(htmlHelper, new HtmlString("<input type = 'text' id='{0}' name='{0}' asp-for='{0}' value='{1}' class='form-control {2}' {3} />".Frmt(id, value, extraClass, extraAttr)), id).ToString());
return(tg);
}
public override string Get()
{
GridView grid = new GridView(this.Config);
StringBuilder gridPanel = new StringBuilder();
TagBuilder.Begin(gridPanel, "div");
TagBuilder.AddId(gridPanel, "GridPanel");
TagBuilder.AddClass(gridPanel, ConfigBuilder.GetGridPanelCssClass(this.Config));
TagBuilder.AddStyle(gridPanel, ConfigBuilder.GetGridPanelStyle(this.Config));
TagBuilder.Close(gridPanel);
gridPanel.Append(grid.Get());
Pager pager = new Pager(this.Config);
gridPanel.Append(pager.Get());
TagBuilder.EndTag(gridPanel, "div");
return(gridPanel.ToString());
}
private string GetAnchor(int pageNumber)
{
StringBuilder anchor = new StringBuilder();
TagBuilder.Begin(anchor, "a");
TagBuilder.AddClass(anchor, pageNumber.Equals(this._currentPage) ? "active item" : "item");
TagBuilder.AddAttribute(anchor, "href",
string.Format(CultureInfo.InvariantCulture, "{0}?page={1}", this._currentPageUrl, pageNumber));
TagBuilder.AddTitle(anchor, string.Format(Thread.CurrentThread.CurrentCulture, Titles.PageN, pageNumber));
TagBuilder.Close(anchor);
anchor.Append(pageNumber.ToString(Thread.CurrentThread.CurrentCulture));
TagBuilder.EndTag(anchor, "a");
return(anchor.ToString());
}
public override string Get()
{
StringBuilder selector = new StringBuilder();
TagBuilder.Begin(selector, "a");
TagBuilder.AddClass(selector, this.CssClass);
TagBuilder.AddAttribute(selector, "role", this.HtmlRole);
TagBuilder.AddAttribute(selector, "tabindex", this.TabIndex);
TagBuilder.AddAttribute(selector, "data-title", this.FieldConfig.ColumnNameLocalized);
TagBuilder.AddAttribute(selector, "href", this.HRef);
if (this.FieldConfig.IsDisabled)
{
TagBuilder.AddStyle(selector, "pointer-events:none;");
}
TagBuilder.Close(selector);
TagBuilder.EndTag(selector, "a");
return(selector.ToString());
}
private string GetPager()
{
if (this._pageSize.Equals(0))
{
this._pageSize = this._blockCount;
}
this._totalPages = (int)Decimal.Ceiling(Decimal.Divide(this._totalRecords, this._pageSize));
int start = 1 +
(int)Decimal.Ceiling(Decimal.Divide(this._currentPage, this._blockCount) - 1) * this._blockCount;
int end = start + this._blockCount - 1;
if (end > this._totalPages)
{
end = this._totalPages;
}
StringBuilder pager = new StringBuilder();
TagBuilder.Begin(pager, "div");
TagBuilder.AddClass(pager, this._cssClass);
TagBuilder.Close(pager);
pager.Append(this.FirstItem());
pager.Append(this.PreviousItem());
pager.Append(this.GetAnchor(1));
//The previous page block
string title;
if (start - this._blockCount > 0)
{
title = string.Format(Thread.CurrentThread.CurrentCulture, Titles.PageN, start - 1);
pager.Append(this.GetIconAnchor("icon item", "arrow left icon", start - 1, title));
}
//Paged items
for (int i = start; i <= end; i++)
{
//Do not create the first and last page
//because we will create them explicitly
//which will be followed/led
//by next/previous page blocks
if (i.Equals(1) || i.Equals(this._totalPages))
{
continue;
}
pager.Append(this.GetAnchor(i));
}
//The next page block
if (start + this._blockCount < this._totalPages)
{
title = string.Format(Thread.CurrentThread.CurrentCulture, Titles.PageN, end + 1);
pager.Append(this.GetIconAnchor("icon item", "arrow right icon", end + 1, title));
}
pager.Append(this.GetAnchor(this._totalPages));
pager.Append(this.NextItem());
pager.Append(this.LastItem());
TagBuilder.EndTag(pager, "div");
return(pager.ToString());
}
public override string Get()
{
StringBuilder rows = new StringBuilder();
TagBuilder.Begin(rows, "tbody", true);
for (int i = 0; i < this.Table.Rows.Count; i++)
{
DataRow row = this.Table.Rows[i];
string keyValue = row[this.Config.KeyColumn].ToString();
TagBuilder.Begin(rows, "tr", true);
TagBuilder.Begin(rows, "td", true);
TagBuilder.Begin(rows, "input");
TagBuilder.AddType(rows, "radio");
TagBuilder.AddId(rows, "SelectRadio" + keyValue);
TagBuilder.AddValue(rows, keyValue);
TagBuilder.Close(rows, true);
TagBuilder.EndTag(rows, "td");
foreach (Column column in this.Columns)
{
TagBuilder.Begin(rows, "td");
switch (column.Type.FullName)
{
case "System.Decimal":
case "System.Double":
case "System.Single":
TagBuilder.AddClass(rows, "text right");
TagBuilder.Close(rows);
decimal value = Conversion.TryCastDecimal(row[column.ColumnName]);
if (!value.Equals(0))
{
rows.Append(value.ToString("N", CultureInfo.CurrentCulture));
}
break;
case "System.DateTime":
TagBuilder.AddClass(rows, "text right");
TagBuilder.Close(rows);
DateTime date = Conversion.TryCastDate(row[column.ColumnName]);
rows.Append(date.Date == date
? Conversion.TryCastDate(date).ToString("D", CultureInfo.CurrentCulture)
: Conversion.TryCastDate(date).ToString("F", CultureInfo.CurrentCulture));
break;
default:
TagBuilder.Close(rows);
rows.Append(HttpUtility.HtmlEncode(row[column.ColumnName]));
break;
}
TagBuilder.EndTag(rows, "td");
}
TagBuilder.EndTag(rows, "tr");
}
TagBuilder.EndTag(rows, "tbody");
return(rows.ToString());
}
public override string Get()
{
if (string.IsNullOrWhiteSpace(this.FieldConfig.ColumnName))
{
return(string.Empty);
}
StringBuilder textBox = new StringBuilder();
string type = "text";
bool isPasswordField = this.FieldConfig.ColumnName.ToUpperInvariant().Equals("PASSWORD");
TagBuilder.Begin(textBox, "input");
TagBuilder.AddId(textBox, this.FieldConfig.ColumnName);
TagBuilder.AddAttribute(textBox, "data-scrud", "text");
if (isPasswordField && this.FieldConfig.IsDisabled)
{
type = "password";
this.FieldConfig.DefaultValue = "fake-password";
}
if (this.FieldConfig.IsDisabled)
{
textBox.Append(" readonly='readonly'");
}
if (!string.IsNullOrWhiteSpace(this.ValidationType))
{
TagBuilder.AddAttribute(textBox, "data-vtype", this.ValidationType);
}
TagBuilder.AddType(textBox, type);
if (this.FieldConfig.DataType.ToUpperInvariant().Equals("COLOR"))
{
TagBuilder.AddClass(textBox, "color");
}
if (!this.FieldConfig.DefaultValue.StartsWith("nextVal", StringComparison.OrdinalIgnoreCase))
{
if (this.ValidationType == "date")
{
DateTime date = Conversion.TryCastDate(this.FieldConfig.DefaultValue);
if (date != DateTime.MinValue)
{
TagBuilder.AddValue(textBox, date.Date == date ? date.ToString("d") : date.ToString("f"));
}
TagBuilder.AddClass(textBox, "date");
}
else
{
TagBuilder.AddValue(textBox, this.FieldConfig.DefaultValue);
}
}
if (!this.FieldConfig.IsNullable)
{
TagBuilder.AddRequired(textBox);
}
if (this.FieldConfig.MaxLength > 0)
{
TagBuilder.AddAttribute(textBox, "maxlength", this.FieldConfig.MaxLength);
}
TagBuilder.Close(textBox, true);
return(textBox.ToString());
}
public static IHtmlContent Grid <T>(this IHtmlHelper htmlHelper, string actionUrl, GridModel <T> model)
{
TagBuilder formTag = new TagBuilder(Constants.DOM.FORM);
formTag.MergeAttributes(new
{
method = "POST",
action = actionUrl
});
TagBuilder tableTag = new TagBuilder(Constants.DOM.TABLE);
tableTag.AddCssClass("table table-striped");
tableTag.AddClass(model.Class);
TagBuilder tHead = new TagBuilder("thead");
TagBuilder headerRow = new TagBuilder(Constants.DOM.TR);
foreach (GridModelColumn <T> col in model.Columns)
{
TagBuilder cell = new TagBuilder(Constants.DOM.TH);
cell.AddClass(col.Class);
cell.InnerHtml.SetContent(col.HeaderTextFunc().ToString());
headerRow.InnerHtml.Append(cell.ToString());
}
tHead.InnerHtml.SetContent(headerRow.ToString());
tableTag.InnerHtml.Append(tHead.ToString());
TagBuilder tBody = new TagBuilder("tbody");
foreach (T item in model.Data)
{
TagBuilder row = new TagBuilder(Constants.DOM.TR);
foreach (GridModelColumn <T> col in model.Columns)
{
TagBuilder cell = new TagBuilder(Constants.DOM.TD);
cell.Attributes["data-name"] = col.Name;
if (col.ValueFunc != null)
{
cell.Attributes["data-value"] = col.ValueFunc(item);
}
cell.InnerHtml.SetContent(col.ItemTemplateFunc(item).ToString());
row.InnerHtml.Append(cell.ToString());
}
tBody.InnerHtml.Append(row.ToString());
}
tableTag.InnerHtml.Append(tBody.ToString());
formTag.InnerHtml.SetContent(tableTag.ToString());
TagBuilder scriptTag = new TagBuilder(Constants.DOM.SCRIPT);
scriptTag.Attributes.Add("type", "text/x-handlebars-template");
TagBuilder editRow = new TagBuilder(Constants.DOM.TR);
editRow.AddCssClass("edit-row");
foreach (GridModelColumn <T> col in model.Columns)
{
TagBuilder cell = new TagBuilder(Constants.DOM.TD);
cell.InnerHtml.SetContent(col.EditorTemplateFunc("{{" + col.Name + "}}").ToString());
editRow.InnerHtml.Append(cell.ToString());
}
scriptTag.InnerHtml.SetContent(editRow.ToString());
TagBuilder gridDiv = new TagBuilder(Constants.DOM.DIV);
gridDiv.AddCssClass("grid-view table-responsive");
gridDiv.InnerHtml.Append(formTag.ToString());
gridDiv.InnerHtml.Append(scriptTag.ToString());
return(gridDiv);
}
