/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public Task <string> RenderAsync(DateTime?model)
{
YTagBuilder tag = new YTagBuilder("div");
FieldSetup(tag, FieldType.Anonymous);
if (model != null && (DateTime)model > DateTime.MinValue && (DateTime)model < DateTime.MaxValue)
{
DateTime last = (DateTime)model;
TimeSpan diff = last - DateTime.UtcNow;
string words = HE(Formatting.FormatTimeSpanInWords(diff));
string wordsTT = Formatting.FormatLongDateTime(last);
tag.Attributes.Add(Basics.CssTooltip, wordsTT);
tag.SetInnerText(words);
}
else
{
string text;
if (!TryGetSiblingProperty($"{PropertyName}_EmptyHTML", out text))
{
return(Task.FromResult <string>(null));
}
tag.InnerHtml = text;
}
return(Task.FromResult(tag.ToString(YTagRenderMode.Normal)));
}
internal async Task<string> RenderPropertyListAsync(object model, bool ReadOnly) {
HtmlBuilder hb = new HtmlBuilder();
Type modelType = model.GetType();
ClassData classData = ObjectSupport.GetClassData(modelType);
RenderHeader(hb, classData);
bool showVariables = YetaWF.Core.Localize.UserSettings.GetProperty<bool>("ShowVariables");
// property table
HtmlBuilder hbProps = new HtmlBuilder();
string divId = Manager.UniqueId();
hbProps.Append($@"
<div id='{divId}' class='yt_propertylist {(ReadOnly ? "t_display" : "t_edit")}'>
{await RenderHiddenAsync(model)}
{await RenderListAsync(model, null, showVariables, ReadOnly)}
</div>");
if (!string.IsNullOrWhiteSpace(classData.Legend)) {
YTagBuilder tagFieldSet = new YTagBuilder("fieldset");
YTagBuilder tagLegend = new YTagBuilder("legend");
tagLegend.SetInnerText(classData.Legend);
tagFieldSet.InnerHtml = tagLegend.ToString(YTagRenderMode.Normal) + hbProps.ToString();
hb.Append(tagFieldSet.ToString(YTagRenderMode.Normal));
} else {
hb.Append(hbProps.ToString());
}
RenderFooter(hb, classData);
ControlData cd = GetControlSets(model, divId);
Manager.ScriptManager.AddLast($@"new YetaWF_ComponentsHTML.PropertyListComponent('{divId}', {Utility.JsonSerialize(new PropertyList.PropertyListSetup())}, {Utility.JsonSerialize(cd)});");
return hb.ToString();
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public Task <string> RenderAsync(Decimal?model)
{
HtmlBuilder hb = new HtmlBuilder();
YTagBuilder tag = new YTagBuilder("input");
tag.AddCssClass("yt_decimal");
tag.AddCssClass("t_edit");
FieldSetup(tag, Validation ? FieldType.Validated : FieldType.Normal);
string id = MakeId(tag);
// handle min/max
float min = 0, max = 99999999.99F;
RangeAttribute rangeAttr = PropData.TryGetAttribute <RangeAttribute>();
if (rangeAttr != null)
{
min = Convert.ToSingle(rangeAttr.Minimum);
max = Convert.ToSingle(rangeAttr.Maximum);
}
string format = PropData.GetAdditionalAttributeValue("Format", "0.00");
if (model != null)
{
tag.MergeAttribute("value", ((decimal)model).ToString(format));
}
hb.Append($@"
{tag.ToString(YTagRenderMode.StartTag)}");
Manager.ScriptManager.AddLast($@"new YetaWF_ComponentsHTML.DecimalEditComponent('{id}', {{ Min: {min}, Max: {max} }});");
return(Task.FromResult(hb.ToString()));
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public Task <string> RenderAsync(DayTimeRange model)
{
HtmlBuilder hb = new HtmlBuilder();
if (model != null)
{
YTagBuilder tag = new YTagBuilder("div");
tag.AddCssClass("yt_daytimerange");
tag.AddCssClass("t_display");
FieldSetup(tag, FieldType.Anonymous);
string s = null;
if (model.Start != null && model.End != null)
{
if (model.Start2 != null && model.End2 != null)
{
s = __ResStr("time2", "{0} - {1}, {2} - {3} ", Formatting.FormatTime(model.GetStart()), Formatting.FormatTime(model.GetEnd()), Formatting.FormatTime(model.GetStart2()), Formatting.FormatTime(model.GetEnd2()));
}
else
{
s = __ResStr("time1", "{0} - {1}", Formatting.FormatTime(model.GetStart()), Formatting.FormatTime(model.GetEnd()));
}
}
else
{
s = __ResStr("time0", "");
}
tag.SetInnerText(s);
hb.Append(tag.ToString(YTagRenderMode.Normal));
}
return(Task.FromResult(hb.ToString()));
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public Task <string> RenderAsync(string model)
{
HtmlBuilder sb = new HtmlBuilder();
YTagBuilder tagLabel = new YTagBuilder("label");
FieldSetup(tagLabel, FieldType.Anonymous);
if (string.IsNullOrEmpty(model)) // we're distinguishing between "" and " "
{
tagLabel.InnerHtml = " ";
}
else
{
tagLabel.SetInnerText(model);
}
sb.Append(tagLabel.ToString(YTagRenderMode.Normal));
string helpLink;
if (TryGetSiblingProperty <string>($"{PropertyName}_HelpLink", out helpLink) && !string.IsNullOrWhiteSpace(helpLink))
{
YTagBuilder tagA = new YTagBuilder("a");
tagA.Attributes.Add("href", Utility.UrlEncodePath(helpLink));
tagA.Attributes.Add("target", "_blank");
tagA.MergeAttribute("rel", "noopener noreferrer");
tagA.AddCssClass(Manager.AddOnManager.CheckInvokedCssModule("yt_extlabel_img"));
tagA.InnerHtml = ImageHTML.BuildKnownIcon("#Help");
sb.Append(tagA.ToString(YTagRenderMode.Normal));
}
return(Task.FromResult(sb.ToString()));
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public Task <string> RenderAsync(bool?model)
{
YTagBuilder tag = new YTagBuilder("input");
tag.AddCssClass("yt_booleantext");
tag.AddCssClass("t_display");
FieldSetup(tag, FieldType.Anonymous);
tag.Attributes.Add("type", "checkbox");
tag.Attributes.Add("disabled", "disabled");
if (model != null && (bool)model)
{
tag.Attributes.Add("checked", "checked");
}
string text;
if (TryGetSiblingProperty($"{PropertyName}_Text", out text))
{
return(Task.FromResult(tag.ToString(YTagRenderMode.StartTag) + HE(text)));
}
else
{
return(Task.FromResult(tag.ToString(YTagRenderMode.StartTag)));
}
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public async Task <string> RenderAsync(string model)
{
UseSuppliedIdAsControlId();
HtmlBuilder hb = new HtmlBuilder();
hb.Append($"<div id='{ControlId}' class='yt_ssn t_edit'>");
Dictionary <string, object> hiddenAttributes = new Dictionary <string, object>(HtmlAttributes)
{
{ "__NoTemplate", true }
};
hb.Append(await HtmlHelper.ForEditComponentAsync(Container, PropertyName, null, "Hidden", HtmlAttributes: hiddenAttributes, Validation: Validation));
YTagBuilder tag = new YTagBuilder("input");
FieldSetup(tag, FieldType.Anonymous);
tag.Attributes.Add("name", "ssninput");
if (model != null)
{
tag.MergeAttribute("value", model);
}
hb.Append(tag.ToString(YTagRenderMode.StartTag));
hb.Append($"</div>");
Manager.ScriptManager.AddLast($@"new YetaWF_ComponentsHTML.SSNEditComponent('{ControlId}');");
return(hb.ToString());
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public Task <string> RenderAsync(bool?model)
{
YTagBuilder tag = new YTagBuilder("input");
tag.AddCssClass("yt_boolean");
tag.AddCssClass("t_edit");
FieldSetup(tag, Validation ? FieldType.Validated : FieldType.Anonymous);
tag.Attributes.Add("id", ControlId);
tag.Attributes.Add("type", "checkbox");
tag.Attributes.Add("value", "true");
if (model != null && (bool)model)
{
tag.Attributes.Add("checked", "checked");
}
// add a hidden field so we always get "something" for check boxes (that means we have to deal with duplicates names)
YTagBuilder tagHidden = new YTagBuilder("input");
FieldSetup(tagHidden, FieldType.Normal);
tagHidden.Attributes.Add("type", "hidden");
tagHidden.Attributes.Add("value", "false");
tagHidden.AddCssClass("yform-novalidate");
//Manager.ScriptManager.AddLast($@"new YetaWF_ComponentsHTML.BooleanEditComponent('{ControlId}');");
return(Task.FromResult(tag.ToString(YTagRenderMode.StartTag) + tagHidden.ToString(YTagRenderMode.StartTag)));
}
/// <summary>
/// Renders module links.
/// </summary>
/// <param name="mod">The module for which the module links are rendered.</param>
/// <param name="renderMode">The module links' rendering mode.</param>
/// <param name="cssClass">The optional CSS classes to use for the module links.</param>
/// <returns>Returns the module links as HTML.</returns>
public async Task <string> RenderModuleLinksAsync(ModuleDefinition mod, ModuleAction.RenderModeEnum renderMode, string cssClass)
{
HtmlBuilder hb = new HtmlBuilder();
MenuList moduleMenu = await mod.GetModuleMenuListAsync(renderMode, ModuleAction.ActionLocationEnum.ModuleLinks);
string menuContents = (await RenderMenuAsync(moduleMenu, null, Globals.CssModuleLinks));
if (!string.IsNullOrWhiteSpace(menuContents))
{
await Manager.AddOnManager.AddTemplateFromUIHintAsync("ActionIcons"); // action icons
// <div>
YTagBuilder div2Tag = new YTagBuilder("div");
div2Tag.AddCssClass(Manager.AddOnManager.CheckInvokedCssModule(cssClass));
hb.Append(div2Tag.ToString(YTagRenderMode.StartTag));
// <ul><li> menu
hb.Append(menuContents);
// </div>
hb.Append(div2Tag.ToString(YTagRenderMode.EndTag));
}
return(hb.ToString());
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public async Task <string> RenderAsync(TimeOfDay model)
{
// we're reusing Time component
await Manager.AddOnManager.AddTemplateFromUIHintAsync("Time");
HtmlBuilder hb = new HtmlBuilder();
hb.Append($"<div id='{ControlId}' class='yt_time t_edit'>");
Dictionary <string, object> hiddenAttributes = new Dictionary <string, object>(HtmlAttributes)
{
{ "__NoTemplate", true }
};
hb.Append(await HtmlHelper.ForEditComponentAsync(Container, PropertyName, null, "Hidden", HtmlAttributes: hiddenAttributes, Validation: Validation));
YTagBuilder tag = new YTagBuilder("input");
FieldSetup(tag, FieldType.Anonymous);
tag.Attributes.Add("name", "dtpicker");
if (model != null)
{
DateTime dt = model.AsDateTime();
tag.MergeAttribute("value", Formatting.FormatTime(dt));
}
hb.Append(tag.ToString(YTagRenderMode.StartTag));
hb.Append($"</div>");
Manager.ScriptManager.AddLast($@"new YetaWF_ComponentsHTML.TimeEditComponent('{ControlId}');");
return(hb.ToString());
}
private void AddErrorClass(YTagBuilder tagBuilder)
{
string cls = GetErrorClass();
if (!string.IsNullOrWhiteSpace(cls))
{
tagBuilder.AddCssClass(Manager.AddOnManager.CheckInvokedCssModule(cls));
}
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public Task <string> RenderAsync(object model)
{
YTagBuilder tag = new YTagBuilder("span");
FieldSetup(tag, FieldType.Anonymous);
tag.InnerHtml = ImageHTML.BuildKnownIcon("#RemoveLight", title: __ResStr("altRemove", "Remove"), name: "DeleteAction");
return(Task.FromResult(tag.ToString(YTagRenderMode.Normal)));
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public Task <string> RenderAsync(object model)
{
string text;
if (model is MultiString)
{
text = (MultiString)model;
}
else
{
text = (string)model;
}
int emHeight = PropData.GetAdditionalAttributeValue("EmHeight", 10);
HtmlBuilder hb = new HtmlBuilder();
YTagBuilder tag = new YTagBuilder("textarea");
tag.AddCssClass("yt_textareasourceonly");
tag.AddCssClass("t_edit");
tag.AddCssClass("k-textbox"); // USE KENDO style
FieldSetup(tag, Validation ? FieldType.Validated : FieldType.Normal);
tag.Attributes.Add("id", ControlId);
tag.Attributes.Add("rows", emHeight.ToString());
// handle StringLengthAttribute as maxlength
StringLengthAttribute lenAttr = PropData.TryGetAttribute <StringLengthAttribute>();
if (lenAttr != null)
{
#if DEBUG
if (tag.Attributes.ContainsKey("maxlength"))
{
throw new InternalError($"Both StringLengthAttribute and maxlength specified - {FieldName}");
}
#endif
int maxLength = lenAttr.MaximumLength;
if (maxLength > 0 && maxLength <= 8000)
{
tag.MergeAttribute("maxlength", maxLength.ToString());
}
}
#if DEBUG
if (lenAttr == null && !tag.Attributes.ContainsKey("maxlength"))
{
throw new InternalError($"No max string length given using StringLengthAttribute or maxlength - {FieldName}");
}
#endif
tag.SetInnerText(text);
hb.Append(tag.ToString(YTagRenderMode.Normal));
Manager.ScriptManager.AddLast($@"new YetaWF_ComponentsHTML.TextAreaSourceOnlyEditComponent('{ControlId}');");
return(Task.FromResult(hb.ToString()));
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public Task <string> RenderAsync(object model)
{
YTagBuilder tag = new YTagBuilder("input");
FieldSetup(tag, FieldType.Normal);
tag.MergeAttribute("name", FieldNamePrefix, true);
tag.MergeAttribute("type", "hidden");
tag.MergeAttribute("value", model == null ? "" : model.ToString());
return(Task.FromResult(tag.ToString(YTagRenderMode.StartTag)));
}
/// <summary>
/// Adds a unique ID to the specified tag.
/// </summary>
/// <param name="tag">The tag to which the ID is added</param>
/// <returns>Returns the ID.</returns>
public string MakeId(YTagBuilder tag)
{
string id = (from a in tag.Attributes where string.Compare(a.Key, "id", true) == 0 select a.Value).FirstOrDefault();
if (string.IsNullOrWhiteSpace(id))
{
id = Manager.UniqueId();
tag.Attributes.Add("id", id);
}
return(id);
}
/// <summary>
/// Renders an image <img> tag with specified attributes and returns HTML.
/// </summary>
/// <param name="imageType">The image type which must match a registered image handler. The YetaWF.Core.Image.ImageSupport.AddHandler method is used to register an image handler.</param>
/// <param name="width">The width of the image. Both <paramref name="width"/> and <paramref name="height"/> may be 0, in which case no size attributes are rendered.</param>
/// <param name="height">The height of the image. Both <paramref name="width"/> and <paramref name="height"/> may be 0, in which case no size attributes are rendered.</param>
/// <param name="model">The model representing the image.</param>
/// <param name="CacheBuster">A value that becomes part of the image URL, which can be used to defeat client-side caching. May be null.</param>
/// <param name="Alt">The text that is rendered as part of the <img> tag's Alt attribute. May be null in which case the text "Image" is used.</param>
/// <param name="ExternalUrl">Defines whether a full URL including domain is rendered (true) or whether just the path is used (false).</param>
/// <param name="SecurityType">The security type of the rendered image URL.</param>
/// <returns></returns>
public static string RenderImage(string imageType, int width, int height, string model,
string CacheBuster = null, string Alt = null, bool ExternalUrl = false, PageDefinition.PageSecurityType SecurityType = PageDefinition.PageSecurityType.Any)
{
string url = ImageHTML.FormatUrl(imageType, null, model, width, height, CacheBuster: CacheBuster, ExternalUrl: ExternalUrl, SecurityType: SecurityType);
YTagBuilder img = new YTagBuilder("img");
img.AddCssClass("t_preview");
img.Attributes.Add("src", url);
img.Attributes.Add("alt", Alt ?? __ResStr("altImg", "Image"));
return(img.ToString(YTagRenderMode.StartTag));
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public async Task <string> RenderAsync(Guid?model)
{
HtmlBuilder hb = new HtmlBuilder();
// dropdown
List <SelectionItem <string> > list;
list = (
from p in await PageDefinition.GetDesignedPagesAsync() orderby p.Url select
new SelectionItem <string> {
Text = p.Url,
Value = p.PageGuid.ToString(),
}).ToList <SelectionItem <string> >();
list.Insert(0, new SelectionItem <string> {
Text = __ResStr("select", "(select)"), Value = null
});
string ddList = await DropDownListComponent.RenderDropDownListAsync(this, (model ?? Guid.Empty).ToString(), list, null);
// link
YTagBuilder tag = new YTagBuilder("a");
PageDefinition page = null;
if (model != null)
{
page = await PageDefinition.LoadAsync((Guid)model);
}
tag.MergeAttribute("href", (page != null ? page.EvaluatedCanonicalUrl : ""));
tag.MergeAttribute("target", "_blank");
tag.MergeAttribute("rel", "nofollow noopener noreferrer");
tag.Attributes.Add(Basics.CssTooltip, __ResStr("linkTT", "Click to preview the page in a new window - not all pages can be displayed correctly and may require additional parameters"));
tag.InnerHtml = tag.InnerHtml + ImageHTML.BuildKnownIcon("#PagePreview", sprites: Info.PredefSpriteIcons);
string linkTag = tag.ToString(YTagRenderMode.Normal);
hb.Append($@"
<div id='{DivId}' class='yt_pageselection t_edit'>
<div class='t_select'>
{ddList.ToString()}
</div>
<div class='t_link'>
{linkTag}
</div>
<div class='t_description'>
</div>
</div>");
Manager.ScriptManager.AddLast($@"new YetaWF_ComponentsHTML.PageSelectionEditComponent('{DivId}');");
return(hb.ToString());
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public async Task <string> RenderAsync(object model)
{
HtmlBuilder hb = new HtmlBuilder();
string text;
if (model is MultiString)
{
text = (MultiString)model;
}
else
{
text = (string)model;
}
bool copy = PropData.GetAdditionalAttributeValue <bool>("Copy", true);
if (!string.IsNullOrWhiteSpace(text))
{
int emHeight = PropData.GetAdditionalAttributeValue("EmHeight", 10);
YTagBuilder tag = new YTagBuilder("textarea");
tag.AddCssClass("yt_textareasourceonly");
tag.AddCssClass("t_display");
tag.AddCssClass("k-textbox"); // USE KENDO style
//tag.AddCssClass("k-state-disabled"); // USE KENDO style
FieldSetup(tag, FieldType.Anonymous);
tag.Attributes.Add("id", ControlId);
tag.Attributes.Add("rows", emHeight.ToString());
if (copy)
{
tag.Attributes.Add("readonly", "readonly");
}
else
{
tag.Attributes.Add("disabled", "disabled");
}
tag.SetInnerText(text);
hb.Append(tag.ToString(YTagRenderMode.Normal));
if (copy)
{
hb.Append(ImageHTML.BuildKnownIcon("#TextAreaSourceOnlyCopy", sprites: Info.PredefSpriteIcons, title: __ResStr("ttCopy", "Copy to Clipboard"), cssClass: "yt_textareasourceonly_copy"));
}
}
if (copy)
{
await Manager.AddOnManager.AddAddOnNamedAsync(Package.AreaName, "clipboardjs.com.clipboard");// add clipboard support
}
return(hb.ToString());
}
/// <summary>
/// Render a StringTT display component given a HtmlHelper instance.
/// </summary>
/// <param name="htmlHelper">The HtmlHelper instance.</param>
/// <param name="text">The text displayed.</param>
/// <param name="tooltip">The tooltip.</param>
/// <returns></returns>
public static string ForStringTTDisplay(this YHtmlHelper htmlHelper, string text, string tooltip)
{
YTagBuilder tag = new YTagBuilder("span");
if (!string.IsNullOrWhiteSpace(tooltip))
{
tag.Attributes.Add(Basics.CssTooltipSpan, tooltip);
}
if (!string.IsNullOrWhiteSpace(text))
{
tag.SetInnerText(text);
}
return(tag.ToString(YTagRenderMode.Normal));
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public async Task <string> RenderAsync(DateTime?model)
{
UseSuppliedIdAsControlId();
HtmlBuilder hb = new HtmlBuilder();
hb.Append($"<div id='{ControlId}' class='yt_datetime t_edit'>");
Dictionary <string, object> hiddenAttributes = new Dictionary <string, object>(HtmlAttributes)
{
{ "__NoTemplate", true }
};
hb.Append(await HtmlHelper.ForEditComponentAsync(Container, PropertyName, null, "Hidden", HtmlAttributes: hiddenAttributes, Validation: Validation));
YTagBuilder tag = new YTagBuilder("input");
FieldSetup(tag, FieldType.Anonymous);
tag.Attributes.Add("name", "dtpicker");
// handle min/max date
DateTimeSetup setup = new DateTimeSetup {
Min = new DateTime(1900, 1, 1),
Max = new DateTime(2199, 12, 31),
};
MinimumDateAttribute minAttr = PropData.TryGetAttribute <MinimumDateAttribute>();
if (minAttr != null)
{
setup.Min = minAttr.MinDate;
}
MaximumDateAttribute maxAttr = PropData.TryGetAttribute <MaximumDateAttribute>();
if (maxAttr != null)
{
setup.Max = maxAttr.MaxDate;
}
if (model != null)
{
tag.MergeAttribute("value", Formatting.FormatDateTime((DateTime)model));// shows date using user's timezone
}
hb.Append(tag.ToString(YTagRenderMode.StartTag));
hb.Append($"</div>");
Manager.ScriptManager.AddLast($@"new YetaWF_ComponentsHTML.DateTimeEditComponent('{ControlId}', {Utility.JsonSerialize(setup)});");
return(hb.ToString());
}
public Task <string> RenderAsync(int model)
{
YTagBuilder tag = new YTagBuilder("span");
FieldSetup(tag, FieldType.Anonymous);
using (RoleDefinitionDataProvider dataProvider = new RoleDefinitionDataProvider()) {
RoleDefinition role = dataProvider.GetRoleById(model);
tag.SetInnerText(role.Name);
tag.Attributes.Add(Basics.CssTooltipSpan, role.Description);
}
return(Task.FromResult(tag.ToString(YTagRenderMode.Normal)));
}
private void AddValidation(YTagBuilder tagBuilder)
{
//$$$ // add some default validations
//if (!PropData.ReadOnly) {
// if (PropData.PropInfo.PropertyType == typeof(DateTime) || PropData.PropInfo.PropertyType == typeof(DateTime?)) {
// tagBuilder.Attributes["data-val-date"] = __ResStr("valDate", "Please enter a valid value for field '{0}'", PropData.GetCaption(Container));
// tagBuilder.MergeAttribute("data-val", "true");
// } else if (PropData.PropInfo.PropertyType == typeof(int) || PropData.PropInfo.PropertyType == typeof(int?) ||
// PropData.PropInfo.PropertyType == typeof(long) || PropData.PropInfo.PropertyType == typeof(long?)) {
// tagBuilder.Attributes["data-val-number"] = __ResStr("valNumber", "Please enter a valid number for field '{0}'", PropData.GetCaption(Container));
// tagBuilder.MergeAttribute("data-val", "true");
// }
//}
// Build validation attribute
List <object> objs = new List <object>();
foreach (YIClientValidation val in PropData.ClientValidationAttributes)
{
// TODO: GetCaption can fail for redirects (ModuleDefinition) so we can't call it when there are no validation attributes
// GridAllowedRole and GridAllowedUser use a ResourceRedirectList with a property OUTSIDE of the model. This only works in grids (where it is used)
// but breaks when used elsewhere (like here) so we only call GetCaption if there is a validation attribute (FOR NOW).
// That whole resource redirect business needs to be fixed (old and ugly, and fragile).
string caption = PropData.GetCaption(Container);
ValidationBase valBase = val.AddValidation(Container, PropData, caption, tagBuilder);
if (valBase != null)
{
string method = valBase.Method;
if (string.IsNullOrWhiteSpace(method))
{
throw new InternalError($"No method given ({nameof(ValidationBase)}.{nameof(ValidationBase.Method)})");
}
if (string.IsNullOrWhiteSpace(valBase.Message))
{
throw new InternalError($"No message given ({nameof(ValidationBase)}.{nameof(ValidationBase.Message)})");
}
objs.Add(valBase);
method = method.TrimEnd("Attribute"); // remove ending ..Attribute
method = method.TrimEnd("Validation"); // remove ending ..Validation
valBase.Method = method.ToLower();
if (string.IsNullOrWhiteSpace(method))
{
throw new InternalError($"No method name found after removing Attribute and Validation suffixes");
}
}
}
if (objs.Count > 0)
{
tagBuilder.Attributes.Add("data-v", Utility.JsonSerialize(objs));
}
}
public async Task <string> RenderAsync(string model)
{
HtmlBuilder hb = new HtmlBuilder();
YTagBuilder tag = new YTagBuilder("span");
FieldSetup(tag, FieldType.Anonymous);
ModuleAction actionDisplay = null;
ModuleAction actionLoginAs = null;
using (UserDefinitionDataProvider userDefDP = new UserDefinitionDataProvider()) {
UserDefinition user = null;
string userName = "";
if (!string.IsNullOrWhiteSpace(model))
{
user = await userDefDP.GetItemByEmailAsync(model);
if (user == null)
{
userName = model;
}
else
{
userName = user.Email;
UsersDisplayModule modDisp = new UsersDisplayModule();
actionDisplay = modDisp.GetAction_Display(null, user.UserName);
LoginModule modLogin = (LoginModule)await ModuleDefinition.CreateUniqueModuleAsync(typeof(LoginModule));
actionLoginAs = await modLogin.GetAction_LoginAsAsync(user.UserId, user.UserName);
}
}
else
{
userName = __ResStr("noEmail", "(not specified)");
}
tag.SetInnerText(userName);
}
hb.Append(tag.ToString(YTagRenderMode.Normal));
if (actionDisplay != null)
{
hb.Append(await actionDisplay.RenderAsync(ModuleAction.RenderModeEnum.IconsOnly));
}
if (actionLoginAs != null)
{
hb.Append(await actionLoginAs.RenderAsync(ModuleAction.RenderModeEnum.IconsOnly));
}
return(hb.ToString());
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public Task <string> RenderAsync(bool?model)
{
YTagBuilder tag = new YTagBuilder("input");
tag.AddCssClass("yt_boolean");
tag.AddCssClass("t_display");
FieldSetup(tag, FieldType.Anonymous);
tag.Attributes.Add("type", "checkbox");
tag.Attributes.Add("disabled", "disabled");
if (model != null && (bool)model)
{
tag.Attributes.Add("checked", "checked");
}
return(Task.FromResult(tag.ToString(YTagRenderMode.StartTag)));
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public Task <string> RenderAsync(TimeSpan?model)
{
HtmlBuilder hb = new HtmlBuilder();
if (model != null)
{
YTagBuilder tag = new YTagBuilder("div");
tag.AddCssClass("yt_timespan");
tag.AddCssClass("t_display");
FieldSetup(tag, FieldType.Anonymous);
tag.SetInnerText(Formatting.FormatTimeSpan(model));
hb.Append(tag.ToString(YTagRenderMode.Normal));
}
return(Task.FromResult(hb.ToString()));
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public Task <string> RenderAsync(DateTime?model)
{
HtmlBuilder hb = new HtmlBuilder();
if (model != null && (DateTime)model > DateTime.MinValue && (DateTime)model < DateTime.MaxValue)
{
YTagBuilder tag = new YTagBuilder("div");
tag.AddCssClass("yt_time");
tag.AddCssClass("t_display");
FieldSetup(tag, FieldType.Anonymous);
tag.SetInnerText(YetaWF.Core.Localize.Formatting.FormatTime(model));
hb.Append(tag.ToString(YTagRenderMode.Normal));
}
return(Task.FromResult(hb.ToString()));
}
public async Task <string> RenderAsync(int model)
{
HtmlBuilder hb = new HtmlBuilder();
YTagBuilder tag = new YTagBuilder("span");
tag.AddCssClass("yt_yetawf_identity_userid");
tag.AddCssClass("t_display");
FieldSetup(tag, FieldType.Anonymous);
ModuleAction actionDisplay = null;
ModuleAction actionLoginAs = null;
using (UserDefinitionDataProvider dataProvider = new UserDefinitionDataProvider()) {
UserDefinition user = await dataProvider.GetItemByUserIdAsync(model);
string userName = "";
if (user == null)
{
if (model != 0)
{
userName = string.Format("({0})", model);
}
}
else
{
userName = user.UserName;
Modules.UsersDisplayModule modDisp = new Modules.UsersDisplayModule();
actionDisplay = modDisp.GetAction_Display(null, userName);
Modules.LoginModule modLogin = (Modules.LoginModule) await ModuleDefinition.CreateUniqueModuleAsync(typeof(Modules.LoginModule));
actionLoginAs = await modLogin.GetAction_LoginAsAsync(model, userName);
}
tag.SetInnerText(userName);
}
hb.Append(tag.ToString(YTagRenderMode.Normal));
if (actionDisplay != null)
{
hb.Append(await actionDisplay.RenderAsync(ModuleAction.RenderModeEnum.IconsOnly));
}
if (actionLoginAs != null)
{
hb.Append(await actionLoginAs.RenderAsync(ModuleAction.RenderModeEnum.IconsOnly));
}
return(hb.ToString());
}
internal static async Task <string> RenderMenuAsync(MenuList menu, string id = null, string cssClass = null,
ModuleAction.RenderEngineEnum RenderEngine = ModuleAction.RenderEngineEnum.KendoMenu, bool Hidden = false, YHtmlHelper HtmlHelper = null)
{
HtmlBuilder hb = new HtmlBuilder();
int level = 0;
if (menu.Count == 0)
{
return(null);
}
string menuContents = await RenderLIAsync(HtmlHelper, menu, null, menu.RenderMode, RenderEngine, menu.LICssClass, level);
if (string.IsNullOrWhiteSpace(menuContents))
{
return(null);
}
// <ul class= style= >
YTagBuilder ulTag = new YTagBuilder("ul");
if (Hidden)
{
ulTag.Attributes.Add("style", "display:none");
}
if (!string.IsNullOrWhiteSpace(cssClass))
{
ulTag.AddCssClass(Manager.AddOnManager.CheckInvokedCssModule(cssClass));
}
ulTag.AddCssClass(string.Format("t_lvl{0}", level));
if (RenderEngine == ModuleAction.RenderEngineEnum.BootstrapSmartMenu)
{
ulTag.AddCssClass("nav");
ulTag.AddCssClass("navbar-nav");
}
if (!string.IsNullOrWhiteSpace(id))
{
ulTag.Attributes.Add("id", id);
}
hb.Append(ulTag.ToString(YTagRenderMode.StartTag));
// <li>....</li>
hb.Append(menuContents);
// </ul>
hb.Append(ulTag.ToString(YTagRenderMode.EndTag));
return(hb.ToString());
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public Task <string> RenderAsync(Decimal?model)
{
HtmlBuilder hb = new HtmlBuilder();
if (model != null && (Decimal)model > Decimal.MinValue && (Decimal)model < Decimal.MaxValue)
{
YTagBuilder tag = new YTagBuilder("div");
tag.AddCssClass("yt_decimal");
tag.AddCssClass("t_display");
FieldSetup(tag, FieldType.Anonymous);
string format = PropData.GetAdditionalAttributeValue("Format", "0.00");
if (model != null)
{
tag.SetInnerText(((decimal)model).ToString(format));
}
hb.Append(tag.ToString(YTagRenderMode.Normal));
}
return(Task.FromResult(hb.ToString()));
}
internal string GetModuleLink(Guid?model, bool force = false)
{
if (!force)
{
if (model == null || model == Guid.Empty)
{
return("");
}
}
YTagBuilder tag = new YTagBuilder("a");
tag.MergeAttribute("href", ModuleDefinition.GetModulePermanentUrl(model ?? Guid.Empty));
tag.MergeAttribute("target", "_blank");
tag.MergeAttribute("rel", "nofollow noopener noreferrer");
tag.Attributes.Add(Basics.CssTooltip, __ResStr("linkTT", "Click to preview the module in a new window - not all modules can be displayed correctly and may require additional parameters"));
tag.InnerHtml = tag.InnerHtml + ImageHTML.BuildKnownIcon("#ModulePreview", sprites: Info.PredefSpriteIcons);
return(tag.ToString(YTagRenderMode.Normal));
}
