public static void EnumTemplate(HtmlHelper html, IXcstPackage package, ISequenceWriter <object> seqOutput)
{
XcstWriter output = DocumentWriter.CastElement(package, seqOutput);
string? className = GetEditorCssClass(new EditorInfo("Enum", "select"), null);
var htmlAttributes = CreateHtmlAttributes(html, className);
ViewDataDictionary viewData = html.ViewData;
Type modelType = viewData.ModelMetadata.ModelType;
Type enumType = Nullable.GetUnderlyingType(modelType) ?? modelType;
if (!enumType.IsEnum)
{
throw new InvalidOperationException("Enum template can only be used on Enum members.");
}
string?formatString = viewData.ModelMetadata.EditFormatString
?? viewData.ModelMetadata.DisplayFormatString;
bool applyFormatInEdit = viewData.ModelMetadata.EditFormatString != null;
IList <SelectListItem> options = EnumOptions(enumType, output, formatString, applyFormatInEdit);
string optionLabel = viewData.ModelMetadata.Watermark ?? String.Empty;
SelectInstructions.SelectHelper(html, output, viewData.ModelMetadata, String.Empty, options, optionLabel, multiple: false, htmlAttributes: htmlAttributes);
}
public static void BooleanTemplate(HtmlHelper html, IXcstPackage package, ISequenceWriter <object> seqOutput)
{
ViewDataDictionary viewData = html.ViewData;
bool?value = null;
if (viewData.Model != null)
{
value = Convert.ToBoolean(viewData.Model, CultureInfo.InvariantCulture);
}
if (viewData.ModelMetadata.IsNullableValueType)
{
XcstWriter output = DocumentWriter.CastElement(package, seqOutput);
string?className = GetEditorCssClass(new EditorInfo("Boolean", "select"), "list-box tri-state");
var htmlAttributes = CreateHtmlAttributes(html, className);
SelectInstructions.Select(html, output, String.Empty, TriStateValues(value), htmlAttributes: htmlAttributes);
}
else
{
string?className = GetEditorCssClass(new EditorInfo("Boolean", "input", InputType.CheckBox), "check-box");
var htmlAttributes = CreateHtmlAttributes(html, className);
InputInstructions.CheckBox(html, package, seqOutput, String.Empty, value.GetValueOrDefault(), htmlAttributes: htmlAttributes);
}
}
public static void CheckBoxForModel(
HtmlHelper htmlHelper, IXcstPackage package, ISequenceWriter <XElement> output, bool isChecked, HtmlAttribs?htmlAttributes = null)
{
ModelMetadata metadata = htmlHelper.ViewData.ModelMetadata;
CheckBoxForMetadata(htmlHelper, package, output, metadata, /*expression: */ String.Empty, isChecked, htmlAttributes);
}
public static void PasswordTemplate(HtmlHelper html, IXcstPackage package, ISequenceWriter <object> seqOutput)
{
XcstWriter output = DocumentWriter.CastElement(package, seqOutput);
string?className = GetEditorCssClass(new EditorInfo("Password", "input", InputType.Password), "text-box single-line password");
var htmlAttributes = CreateHtmlAttributes(html, className, addMetadataAttributes: true);
InputInstructions.Input(html, output, String.Empty, value: null, type: "password", htmlAttributes: htmlAttributes);
}
/// <summary>
/// Adds a singleton sequence writer with an instance specified in
/// <paramref name="implementationInstance" />
/// to the <see cref="Microsoft.Extensions.DependencyInjection.IServiceCollection" />.
/// </summary>
/// <param name="silverbackBuilder">
/// The <see cref="ISilverbackBuilder" /> that references the <see cref="IServiceCollection" /> to add
/// the services to.
/// </param>
/// <param name="implementationInstance">
/// The instance of the service.
/// </param>
/// <returns>
/// The <see cref="ISilverbackBuilder" /> so that additional calls can be chained.
/// </returns>
public static ISilverbackBuilder AddSingletonSequenceWriter(
this ISilverbackBuilder silverbackBuilder,
ISequenceWriter implementationInstance)
{
Check.NotNull(silverbackBuilder, nameof(silverbackBuilder));
silverbackBuilder.Services.AddSingleton(typeof(ISequenceWriter), implementationInstance);
return(silverbackBuilder);
}
static void HtmlInputTemplateHelper(HtmlHelper html, IXcstPackage package, ISequenceWriter <object> seqOutput, string templateName, string?inputType = null)
{
XcstWriter output = DocumentWriter.CastElement(package, seqOutput);
object value = html.ViewData.TemplateInfo.FormattedModelValue;
string?className = GetEditorCssClass(new EditorInfo(templateName, "input", InputType.Text), "text-box single-line");
var htmlAttributes = CreateHtmlAttributes(html, className, inputType: inputType, addMetadataAttributes: true);
InputInstructions.Input(html, output, name: String.Empty, value: value, htmlAttributes: htmlAttributes);
}
public static void UrlTemplate(HtmlHelper html, IXcstPackage package, ISequenceWriter <object> seqOutput)
{
XcstWriter output = DocumentWriter.CastElement(package, seqOutput);
ViewDataDictionary viewData = html.ViewData;
output.WriteStartElement("a");
output.WriteAttributeString("href", Convert.ToString(viewData.Model, CultureInfo.InvariantCulture));
output.WriteString(output.SimpleContent.Convert(viewData.TemplateInfo.FormattedModelValue));
output.WriteEndElement();
}
public static void ListBoxTemplate(HtmlHelper html, IXcstPackage package, ISequenceWriter <object> seqOutput)
{
XcstWriter output = DocumentWriter.CastElement(package, seqOutput);
string? className = GetEditorCssClass(new EditorInfo("ListBox", "select"), null);
var htmlAttributes = CreateHtmlAttributes(html, className);
ViewDataDictionary viewData = html.ViewData;
IEnumerable <SelectListItem>?options = Options(viewData);
SelectInstructions.SelectHelper(html, output, viewData.ModelMetadata, String.Empty, options, optionLabel: null, multiple: true, htmlAttributes: htmlAttributes);
}
public static void DecimalTemplate(HtmlHelper html, IXcstPackage package, ISequenceWriter <object> seqOutput)
{
ViewDataDictionary viewData = html.ViewData;
if (viewData.TemplateInfo.FormattedModelValue == viewData.ModelMetadata.Model)
{
viewData.TemplateInfo.FormattedModelValue =
String.Format(CultureInfo.CurrentCulture, "{0:0.00}", viewData.ModelMetadata.Model);
}
HtmlInputTemplateHelper(html, package, seqOutput, "Decimal");
}
public static void DecimalTemplate(HtmlHelper html, IXcstPackage package, ISequenceWriter <object> seqOutput)
{
ViewDataDictionary viewData = html.ViewData;
if (viewData.TemplateInfo.FormattedModelValue == viewData.ModelMetadata.Model)
{
viewData.TemplateInfo.FormattedModelValue =
package.Context.SimpleContent.Format("{0:0.00}", viewData.ModelMetadata.Model);
}
StringTemplate(html, package, seqOutput);
}
public static void ImageUrlTemplate(HtmlHelper html, IXcstPackage package, ISequenceWriter <object> seqOutput)
{
ViewDataDictionary viewData = html.ViewData;
if (viewData.Model != null)
{
XcstWriter output = DocumentWriter.CastElement(package, seqOutput);
output.WriteStartElement("img");
output.WriteAttributeString("src", Convert.ToString(viewData.Model, CultureInfo.InvariantCulture));
output.WriteEndElement();
}
}
internal static void DisplayTextHelper(HtmlHelper html, ISequenceWriter <string> output, ModelMetadata metadata)
{
string text = metadata.SimpleDisplayText;
if (metadata.HtmlEncode)
{
output.WriteString(text);
}
else
{
output.WriteRaw(text);
}
}
public static void CheckBoxFor <TModel>(
HtmlHelper <TModel> htmlHelper, IXcstPackage package, ISequenceWriter <XElement> output,
Expression <Func <TModel, bool> > expression, HtmlAttribs?htmlAttributes = null)
{
if (expression is null)
{
throw new ArgumentNullException(nameof(expression));
}
ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
string expressionString = ExpressionHelper.GetExpressionText(expression);
CheckBoxForMetadata(htmlHelper, package, output, metadata, expressionString, /*isChecked: */ null, htmlAttributes);
}
public static void DisplayFor <TModel, TValue>(
HtmlHelper <TModel> html, IXcstPackage package, ISequenceWriter <object> output, Expression <Func <TModel, TValue> > expression,
string?htmlFieldName = null, string?templateName = null, IList <string>?membersNames = null, object?additionalViewData = null) =>
TemplateHelpers.TemplateFor(
html,
package,
output,
expression: expression,
htmlFieldName: htmlFieldName,
templateName: templateName,
membersNames,
DataBoundControlMode.ReadOnly,
additionalViewData
);
public static void DisplayForModel(
HtmlHelper html, IXcstPackage package, ISequenceWriter <object> output,
string?htmlFieldName = null, string?templateName = null, IList <string>?membersNames = null, object?additionalViewData = null) =>
TemplateHelpers.TemplateHelper(
html,
package,
output,
html.ViewData.ModelMetadata,
htmlFieldName: htmlFieldName,
templateName: templateName,
membersNames,
DataBoundControlMode.ReadOnly,
additionalViewData
);
public static void Editor(
HtmlHelper html, IXcstPackage package, ISequenceWriter <object> output, string expression,
string?htmlFieldName = null, string?templateName = null, IList <string>?membersNames = null, object?additionalViewData = null) =>
TemplateHelpers.Template(
html,
package,
output,
expression: expression,
htmlFieldName: htmlFieldName,
templateName: templateName,
membersNames,
DataBoundControlMode.Edit,
additionalViewData
);
public static void ColorInputTemplate(HtmlHelper html, IXcstPackage package, ISequenceWriter <object> seqOutput)
{
ViewDataDictionary viewData = html.ViewData;
if (viewData.Model is Color color)
{
if (viewData.TemplateInfo.FormattedModelValue == viewData.ModelMetadata.Model)
{
viewData.TemplateInfo.FormattedModelValue =
String.Format(CultureInfo.InvariantCulture, "#{0:X2}{1:X2}{2:X2}", color.R, color.G, color.B);
}
}
HtmlInputTemplateHelper(html, package, seqOutput, "Color", "color");
}
static void CheckBoxForMetadata(
HtmlHelper htmlHelper, IXcstPackage package, ISequenceWriter <XElement> output, ModelMetadata?metadata, string expression,
bool?isChecked, HtmlAttribs?htmlAttributes)
{
object?model = metadata?.Model;
if (isChecked is null &&
model != null)
{
if (Boolean.TryParse(model.ToString(), out bool modelChecked))
{
isChecked = modelChecked;
}
}
CheckBoxHelper(htmlHelper, package, output, metadata, expression, isChecked, htmlAttributes);
}
internal void RenderXcstView(ViewContext viewContext, ISequenceWriter <object> writer)
{
object?instance = null;
Type type = BuildManager.GetCompiledType(this.ViewPath);
if (type != null)
{
instance = Activator.CreateInstance(type);
}
if (instance is null)
{
throw new InvalidOperationException($"The view found at '{this.ViewPath}' was not created.");
}
RenderViewImpl(viewContext, t => t.OutputToRaw(writer), instance);
}
static void CheckBoxHelper(
HtmlHelper htmlHelper, IXcstPackage package, ISequenceWriter <XElement> output, ModelMetadata?metadata, string name, bool?isChecked, HtmlAttribs?htmlAttributes)
{
XcstWriter inputWriter = DocumentWriter.CastElement(package, output);
XcstWriter hiddenWriter = DocumentWriter.CastElement(package, output);
bool explicitChecked = isChecked.HasValue;
if (explicitChecked &&
htmlAttributes != null &&
htmlAttributes.ContainsKey("checked"))
{
htmlAttributes = htmlAttributes.Clone();
htmlAttributes.Remove("checked"); // Explicit value must override dictionary
}
InputHelper(
htmlHelper,
inputWriter,
InputType.CheckBox,
metadata,
name,
value: "true",
useViewData: !explicitChecked,
isChecked: isChecked ?? false,
setId: true,
isExplicitValue: false,
format: null,
htmlAttributes: htmlAttributes);
string fullName = Name(htmlHelper, name);
// Render an additional <input type="hidden".../> for checkboxes. This
// addresses scenarios where unchecked checkboxes are not sent in the request.
// Sending a hidden input makes it possible to know that the checkbox was present
// on the page when the request was submitted.
hiddenWriter.WriteStartElement("input");
hiddenWriter.WriteAttributeString("type", HtmlHelper.GetInputTypeString(InputType.Hidden));
hiddenWriter.WriteAttributeString("name", fullName);
hiddenWriter.WriteAttributeString("value", "false");
hiddenWriter.WriteEndElement();
}
public static void BooleanTemplate(HtmlHelper html, IXcstPackage package, ISequenceWriter <object> seqOutput)
{
XcstWriter output = DocumentWriter.CastElement(package, seqOutput);
ViewDataDictionary viewData = html.ViewData;
bool?value = null;
if (viewData.Model != null)
{
value = Convert.ToBoolean(viewData.Model, CultureInfo.InvariantCulture);
}
if (viewData.ModelMetadata.IsNullableValueType)
{
output.WriteStartElement("select");
string?className = DefaultEditorTemplates.GetEditorCssClass(new EditorInfo("Boolean", "select"), "list-box tri-state");
HtmlAttributeHelper.WriteClass(className, null, output);
HtmlAttributeHelper.WriteBoolean("disabled", true, output);
foreach (SelectListItem item in DefaultEditorTemplates.TriStateValues(value))
{
SelectInstructions.WriteOption(item, output);
}
output.WriteEndElement();
}
else
{
output.WriteStartElement("input");
output.WriteAttributeString("type", "checkbox");
string?className = DefaultEditorTemplates.GetEditorCssClass(new EditorInfo("Boolean", "input", InputType.CheckBox), "check-box");
HtmlAttributeHelper.WriteClass(className, null, output);
HtmlAttributeHelper.WriteBoolean("disabled", true, output);
HtmlAttributeHelper.WriteBoolean("checked", value.GetValueOrDefault(), output);
output.WriteEndElement();
}
}
public static void EnumTemplate(HtmlHelper html, IXcstPackage package, ISequenceWriter <object> seqOutput)
{
ViewDataDictionary viewData = html.ViewData;
ModelMetadata modelMetadata = viewData.ModelMetadata;
if (modelMetadata.Model != null)
{
if (modelMetadata.EditFormatString != null)
{
// undo formatting if applicable to edit mode, for consistency with editor template
viewData.TemplateInfo.FormattedModelValue = modelMetadata.Model;
}
if (viewData.TemplateInfo.FormattedModelValue == modelMetadata.Model)
{
#if ASPNETMVC
Type modelType = modelMetadata.ModelType;
Type enumType = Nullable.GetUnderlyingType(modelType) ?? modelType;
if (enumType.IsEnum)
{
FieldInfo?enumField = enumType.GetField(modelMetadata.Model.ToString());
if (enumField != null)
{
viewData.TemplateInfo.FormattedModelValue =
DisplayNameUtil.GetFieldDisplayName(enumField);
}
}
#else
viewData.TemplateInfo.FormattedModelValue = modelMetadata.SimpleDisplayText;
#endif
}
}
StringTemplate(html, package, seqOutput);
}
internal static void CollectionTemplate(HtmlHelper html, IXcstPackage package, ISequenceWriter <object> seqOutput, TemplateHelpers.TemplateHelperDelegate templateHelper)
{
ViewDataDictionary viewData = html.ViewData;
object?model = viewData.ModelMetadata.Model;
if (model is null)
{
return;
}
IEnumerable collection = model as IEnumerable
?? throw new InvalidOperationException($"The Collection template was used with an object of type '{model.GetType().FullName}', which does not implement System.IEnumerable.");
Type typeInCollection = typeof(string);
Type?genericEnumerableType = TypeHelpers.ExtractGenericInterface(collection.GetType(), typeof(IEnumerable <>));
if (genericEnumerableType != null)
{
typeInCollection = genericEnumerableType.GetGenericArguments()[0];
}
bool typeInCollectionIsNullableValueType = TypeHelpers.IsNullableValueType(typeInCollection);
string oldPrefix = viewData.TemplateInfo.HtmlFieldPrefix;
try {
viewData.TemplateInfo.HtmlFieldPrefix = String.Empty;
string fieldNameBase = oldPrefix;
int index = 0;
foreach (object item in collection)
{
Type itemType = typeInCollection;
if (item != null &&
!typeInCollectionIsNullableValueType)
{
itemType = item.GetType();
}
ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => item, itemType);
string fieldName = String.Format(CultureInfo.InvariantCulture, "{0}[{1}]", fieldNameBase, index++);
templateHelper(
html,
package,
seqOutput,
metadata,
htmlFieldName: fieldName,
templateName: null,
membersNames: null,
DataBoundControlMode.ReadOnly,
additionalViewData: null
);
}
} finally {
viewData.TemplateInfo.HtmlFieldPrefix = oldPrefix;
}
}
public static void CollectionTemplate(HtmlHelper html, IXcstPackage package, ISequenceWriter <object> seqOutput) => CollectionTemplate(html, package, seqOutput, TemplateHelpers.TemplateHelper);
public static void CheckBox(
HtmlHelper htmlHelper, IXcstPackage package, ISequenceWriter <XElement> output, string name, bool isChecked, HtmlAttribs?htmlAttributes = null) =>
CheckBoxHelper(htmlHelper, package, output, default(ModelMetadata), name, isChecked, htmlAttributes);
public static void StringTemplate(HtmlHelper html, IXcstPackage package, ISequenceWriter <object> seqOutput) => seqOutput.WriteString(package.Context.SimpleContent.Convert(html.ViewData.TemplateInfo.FormattedModelValue));
internal static void ObjectTemplate(HtmlHelper html, IXcstPackage package, ISequenceWriter <object> seqOutput, TemplateHelpers.TemplateHelperDelegate templateHelper)
{
ViewDataDictionary viewData = html.ViewData;
ModelMetadata modelMetadata = viewData.ModelMetadata;
if (modelMetadata.Model is null ||
viewData.TemplateInfo.TemplateDepth > 1)
{
MetadataInstructions.DisplayTextHelper(html, seqOutput, modelMetadata);
return;
}
var filteredProperties = DisplayInstructions.DisplayProperties(html);
var groupedProperties = filteredProperties.GroupBy(p => p.GroupName());
bool createFieldset = groupedProperties.Any(g => g.Key != null);
foreach (var group in groupedProperties)
{
XcstWriter?fieldsetWriter = null;
if (createFieldset)
{
fieldsetWriter = DocumentWriter.CastElement(package, seqOutput);
fieldsetWriter.WriteStartElement("fieldset");
fieldsetWriter.WriteStartElement("legend");
fieldsetWriter.WriteString(group.Key);
fieldsetWriter.WriteEndElement();
}
foreach (ModelMetadata propertyMeta in group)
{
XcstWriter?fieldWriter = null;
if (!propertyMeta.HideSurroundingHtml)
{
XcstDelegate <object>?memberTemplate =
DisplayInstructions.MemberTemplate(html, propertyMeta);
if (memberTemplate != null)
{
memberTemplate(null !/* argument is not used */, fieldsetWriter ?? seqOutput);
continue;
}
XcstWriter labelWriter = fieldsetWriter
?? DocumentWriter.CastElement(package, seqOutput);
labelWriter.WriteStartElement("div");
labelWriter.WriteAttributeString("class", "display-label");
labelWriter.WriteString(propertyMeta.GetDisplayName() ?? String.Empty);
labelWriter.WriteEndElement();
fieldWriter = fieldsetWriter
?? DocumentWriter.CastElement(package, seqOutput);
fieldWriter.WriteStartElement("div");
fieldWriter.WriteAttributeString("class", "display-field");
}
templateHelper(
html,
package,
fieldWriter ?? fieldsetWriter ?? seqOutput,
propertyMeta,
htmlFieldName: propertyMeta.PropertyName,
templateName: null,
membersNames: null,
DataBoundControlMode.ReadOnly,
additionalViewData: null
);
if (!propertyMeta.HideSurroundingHtml)
{
fieldWriter !.WriteEndElement(); // </div>
}
}
if (createFieldset)
{
fieldsetWriter !.WriteEndElement(); // </fieldset>
}
}
}
public static void HiddenInputTemplate(HtmlHelper html, IXcstPackage package, ISequenceWriter <object> seqOutput)
{
if (!html.ViewData.ModelMetadata.HideSurroundingHtml)
{
StringTemplate(html, package, seqOutput);
}
}
public static void DisplayTextFor <TModel, TResult>(HtmlHelper <TModel> html, ISequenceWriter <string> output, Expression <Func <TModel, TResult> > expression) => DisplayTextHelper(html, output, ModelMetadata.FromLambdaExpression(expression, html.ViewData));
// display text
public static void DisplayText(HtmlHelper html, ISequenceWriter <string> output, string name) =>
DisplayTextHelper(html, output, ModelMetadata.FromStringExpression(name, html.ViewData));
