private EventCallback <MouseEventArgs> CreateOnClickCallback(DropDownMenuItem item)
{
var factory = new EventCallbackFactory();
return(item.OnClick != null?
factory.Create(this, item.OnClick) :
factory.Create(this, item.OnClickAsync));
}
public Action <IRendererTreeBuilder> BuildRendererTree <TItem>(IActualItemContext <TItem> actualItemContext, FormField field) where TItem : class
{
var localColumnName = actualItemContext.ActualColumnName;
var value = actualItemContext.GetActualItemColumnValue(localColumnName);
var valueExpression = GetValueExpression(actualItemContext.ActualItem, field);
var convertedValue = ConvertToDateTime(value);
actualItemContext.SetActualItemColumnValue(localColumnName, convertedValue);
return(builder =>
{
builder
.OpenElement(HtmlTagNames.Div, "form-field-wrapper")
.OpenComponent(typeof(InputDate <>).MakeGenericType(field.Type))
.AddAttribute("id", $"create-form-{localColumnName}")
.AddAttribute("class", "edit-text-field")
.AddAttribute("Value", convertedValue)
.AddAttribute("ValueExpression", valueExpression);
if (field.UnderlyneType == typeof(DateTime))
{
if (field.IsNullable)
{
builder
.AddAttribute("ValueChanged", eventCallbackFactory.Create <DateTime?>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <DateTime?>(valueExpression);
}
else
{
builder
.AddAttribute("ValueChanged", eventCallbackFactory.Create <DateTime>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <DateTime>(valueExpression);
}
}
else
{
if (field.IsNullable)
{
builder
.AddAttribute("ValueChanged", eventCallbackFactory.Create <DateTimeOffset?>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <DateTimeOffset?>(valueExpression);
}
else
{
builder
.AddAttribute("ValueChanged", eventCallbackFactory.Create <DateTimeOffset>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <DateTimeOffset>(valueExpression);
}
}
builder.CloseElement();
});
}
public Action <IRendererTreeBuilder> BuildRendererTree <TItem>(IActualItemContext <TItem> actualItemContext, PropertyInfo field) where TItem : class
{
var localColumnName = actualItemContext.ActualColumnName;
var value = actualItemContext.GetActualItemColumnValue(localColumnName);
var valueExpression = GetValueExpression(value, actualItemContext.ActualItem, field);
return(builder =>
{
builder
.OpenElement(HtmlTagNames.Div, "form-field-wrapper")
.OpenComponent(typeof(InputNumber <>).MakeGenericType(field.GetMemberType()))
.AddAttribute("Id", $"create-form-{localColumnName}")
.AddAttribute("Class", "edit-text-field")
.AddAttribute("Value", value)
.AddAttribute("ValueExpression", valueExpression);
if (value is int)
{
builder
.AddAttribute("ValueChanged", eventCallbackFactory.Create <int>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <int>(valueExpression);
}
else if (value is long)
{
builder
.AddAttribute("ValueChanged", eventCallbackFactory.Create <long>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <long>(valueExpression);
}
else if (value is decimal)
{
builder
.AddAttribute("ValueChanged", eventCallbackFactory.Create <decimal>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <decimal>(valueExpression);
}
else if (value is double)
{
builder
.AddAttribute("ValueChanged", eventCallbackFactory.Create <double>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <double>(valueExpression);
}
else if (value is float)
{
builder
.AddAttribute("ValueChanged", eventCallbackFactory.Create <float>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <float>(valueExpression);
}
builder.CloseElement();
});
}
private void ToggleClearBtn()
{
Suffix = (builder) =>
{
builder.OpenComponent <Icon>(31);
builder.AddAttribute(32, "Type", "close-circle");
builder.AddAttribute(33, "Class", GetClearIconCls());
if (string.IsNullOrEmpty(Value?.ToString()))
{
builder.AddAttribute(34, "Style", "visibility: hidden;");
}
else
{
builder.AddAttribute(34, "Style", "visibility: visible;");
}
builder.AddAttribute(35, "OnClick", CallbackFactory.Create <MouseEventArgs>(this, (args) =>
{
CurrentValue = default;
if (OnChange.HasDelegate)
{
OnChange.InvokeAsync(Value);
}
ToggleClearBtn();
}));
builder.CloseComponent();
};
}
public void BuildRendererTree(
IFormLayout <TModel> createFormLayout,
CreateItemRendererContext <TModel> createItemRendererContext,
IRendererTreeBuilder rendererTreeBuilder)
{
var bodyAction = createFormLayout.BuildBodyRendererTree(createItemRendererContext, formInputRendererTreeProvider);
var footerAction = createFormLayout.BuildFooterRendererTree(createItemRendererContext);
RenderFragment <EditContext> formBody = (EditContext context) => delegate(RenderTreeBuilder builder)
{
var internalBuilder = new BlazorRendererTreeBuilder(builder);
bodyAction?.Invoke(internalBuilder);
footerAction?.Invoke(internalBuilder);
internalBuilder
.OpenComponent(typeof(DataAnnotationsValidator))
.CloseComponent();
};
rendererTreeBuilder
.OpenComponent(typeof(EditForm))
.AddAttribute(nameof(EditContext), createItemRendererContext.ViewModel.EditContext)
.AddAttribute("OnValidSubmit", eventCallbackFactory.Create <EditContext>(this,
context => createItemRendererContext.ViewModel.SaveAction.Invoke(createItemRendererContext.ViewModel.Model)))
.AddAttribute(RenderTreeBuilder.ChildContent, formBody)
.CloseComponent();
createItemRendererContext.ViewModel.ValidateModel();
}
public Action <IRendererTreeBuilder> BuildRendererTree <TItem>(IActualItemContext <TItem> actualItemContext, FormField field) where TItem : class
{
var localColumnName = actualItemContext.ActualColumnName;
var value = actualItemContext.GetActualItemColumnValue(localColumnName);
var valueExpression = Expression.Lambda <Func <string> >(
Expression.Property(
Expression.Constant(actualItemContext.ActualItem),
field.Info));
return(builder =>
{
builder
.OpenElement(HtmlTagNames.Div, "form-field-wrapper")
.OpenComponent(typeof(InputText))
.AddAttribute("id", $"create-form-{localColumnName}")
.AddAttribute("class", "edit-text-field")
.AddAttribute("Value", value)
.AddAttribute("ValueExpression", valueExpression)
.AddAttribute("ValueChanged", eventCallbackFactory.Create <string>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <string>(valueExpression)
.CloseElement();
});
}
public Action <IRendererTreeBuilder> BuildRendererTree <TItem>(IActualItemContext <TItem> actualItemContext, PropertyInfo field) where TItem : class
{
var localColumnName = actualItemContext.ActualColumnName;
var value = actualItemContext.GetActualItemColumnValue(localColumnName);
var valueExpression = Expression.Lambda <Func <bool> >(
Expression.Property(
Expression.Constant(actualItemContext.ActualItem),
field));
return(builder =>
{
builder
.OpenElement(HtmlTagNames.Div, "checkbox")
.OpenElement(HtmlTagNames.Label)
.OpenComponent(typeof(InputCheckbox))
.AddAttribute("Id", $"create-form-{localColumnName}")
.AddAttribute("Class", string.Empty)
.AddAttribute("Value", value)
.AddAttribute("ValueExpression", valueExpression)
.AddAttribute("ValueChanged", eventCallbackFactory.Create <bool>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.OpenElement(HtmlTagNames.Span, "cr")
.OpenElement(HtmlTagNames.I, "cr-icon fa fa-check")
.CloseElement()
.CloseElement()
.CloseElement()
.CloseElement()
.AddValidationMessage <bool>(valueExpression);
});
}
public Action <IRendererTreeBuilder> BuildRendererTree <TItem>(IActualItemContext <TItem> actualItemContext, FormField field) where TItem : class
{
var localColumnName = actualItemContext.ActualColumnName;
var value = actualItemContext.GetActualItemColumnValue(localColumnName);
var valueExpression = GetValueExpression(actualItemContext.ActualItem, field);
return(builder =>
{
builder
.OpenElement(HtmlTagNames.Div, "checkbox")
.OpenElement(HtmlTagNames.Label)
.OpenComponent(typeof(InputCheckbox))
.AddAttribute("Id", $"create-form-{localColumnName}")
.AddAttribute("Class", string.Empty)
.AddAttribute("Value", value)
.AddAttribute("ValueExpression", valueExpression);
if (field.IsNullable)
{
builder.AddAttribute("ValueChanged", eventCallbackFactory.Create <bool?>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)));
}
else
{
builder.AddAttribute("ValueChanged", eventCallbackFactory.Create <bool>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)));
}
builder
.CloseComponent()
.OpenElement(HtmlTagNames.Span, "cr")
.OpenElement(HtmlTagNames.I, "cr-icon fa fa-check")
.CloseElement()
.CloseElement()
.CloseElement()
.CloseElement();
if (field.IsNullable)
{
builder.AddValidationMessage <bool?>(valueExpression);
}
else
{
builder.AddValidationMessage <bool>(valueExpression);
}
});
}
private EventCallback ConsoleSetHeight(int height)
{
return(EventCallbackFactory.Create(this, () =>
{
ConsoleHeight = height;
InvokeAsync(StateHasChanged);
}));
}
public static EventCallback <ErrorEventArgs> Create(this EventCallbackFactory factory, object receiver, Action <ErrorEventArgs> callback)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
return(factory.Create <ErrorEventArgs>(receiver, callback));
}
public static EventCallback <ClipboardEventArgs> Create(this EventCallbackFactory factory, object receiver, Func <ClipboardEventArgs, Task> callback)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
return(factory.Create <ClipboardEventArgs>(receiver, callback));
}
private void ToggleClearBtn()
{
suffix = new RenderFragment((builder) =>
{
builder.OpenComponent <AntIcon>(31);
builder.AddAttribute(32, "type", "close-circle");
if (string.IsNullOrEmpty(Value))
{
builder.AddAttribute(33, "style", "visibility: hidden;");
}
else
{
builder.AddAttribute(33, "style", "visibility: visible;");
}
builder.AddAttribute(34, "onclick", _callbackFactory.Create <MouseEventArgs>(this, (args) =>
{
Value = string.Empty;
ToggleClearBtn();
}));
builder.CloseComponent();
});
}
public async Task when_suppressing_item_if_the_pop_up_retrieve_no_the_item_should_not_be_suppressed()
{
ConfirmDisplayer.Setup(x => x.Confirm(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.Factory.StartNew(() => false));
bool hasCallRemoveCallback = false;
var removeItemEventCallBack = EventCallbackFactory.Create <StarpointsItem>(new object(), _ => hasCallRemoveCallback = true);
var starpointsItem = CreateStarpointsItem();
Authorize(starpointsItem, false);
var component = CreateComponent(ComponentParameter.CreateParameter("Item", starpointsItem)
, ComponentParameter.CreateParameter("PleaseRemoveItem", removeItemEventCallBack));
component.WaitForState(() => component.Nodes?.Length > 0);
await component.Instance.CancelItem();
await Task.Delay(30);
hasCallRemoveCallback.Should().BeFalse();
}
public async Task when_updating_status_the_update_status_api_method_should_be_called()
{
ConfirmDisplayer.Setup(x => x.Confirm(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.Factory.StartNew(() => true));
var removeItemEventCallBack = EventCallbackFactory.Create <StarpointsItem>(new object(), _ => { });
var starpointsItem = CreateStarpointsItem();
MockHttp.Expect($"http://localhost/StarpointsManager/CancelStarpoints/-1/{starpointsItem.Id}").Respond(HttpStatusCode.OK);
Authorize(starpointsItem, false);
var component = CreateComponent(ComponentParameter.CreateParameter("Item", starpointsItem)
, ComponentParameter.CreateParameter("PleaseRemoveItem", removeItemEventCallBack));
component.WaitForState(() => component.Nodes?.Length > 0);
await component.Instance.CancelItem();
await Task.Delay(30);
MockHttp.VerifyNoOutstandingExpectation();
}
public void Setup()
{
IActivityDefinitionService service = Substitute.For <IActivityDefinitionService>();
service.GetActivitySetNames().Returns(_activitySetNames);
_host.AddService(service);
EventCallbackFactory eventCallbackFactory = new EventCallbackFactory();
EventCallback <string> eventCallback = eventCallbackFactory.Create <string>(this, x =>
{
_callBackValue = x;
});
IDictionary <string, object> parameters = new Dictionary <string, object>
{
{ "CurrentActivitySetChanged", eventCallback }
};
_component = _host.AddComponent <ActivitySetSelector>(parameters);
}
public async Task when_suppressing_item_if_the_pop_up_retrieve_yes_the_item_should_be_suppressed()
{
ConfirmDisplayer.Setup(x => x.Confirm(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.Factory.StartNew(() => true));
bool hasCallRemoveCallback = false;
var removeItemEventCallBack = EventCallbackFactory.Create <StarpointsItem>(new object(), _ => hasCallRemoveCallback = true);
var starpointsItem = CreateStarpointsItem();
MockHttp.Expect($"http://localhost/StarpointsManager/CancelStarpoints/-1/{starpointsItem.Id}").Respond(HttpStatusCode.OK);
Authorize(starpointsItem, false);
var component = CreateComponent(ComponentParameter.CreateParameter("Item", starpointsItem)
, ComponentParameter.CreateParameter("PleaseRemoveItem", removeItemEventCallBack));
component.WaitForState(() => component.Nodes?.Length > 0);
await component.Instance.CancelItem();
await Task.Delay(30);
hasCallRemoveCallback.Should().BeTrue();
}
private void ToggleClearBtn()
{
Suffix = (builder) =>
{
builder.OpenComponent <Icon>(31);
builder.AddAttribute(32, "Type", "close-circle");
if (string.IsNullOrEmpty(Value?.ToString()))
{
builder.AddAttribute(33, "Style", "visibility: hidden;");
}
else
{
builder.AddAttribute(33, "Style", "visibility: visible;");
}
builder.AddAttribute(34, "onclick", CallbackFactory.Create <MouseEventArgs>(this, (args) =>
{
Value = default;//string.Empty;
ToggleClearBtn();
}));
builder.CloseComponent();
};
}
public Action <IRendererTreeBuilder> BuildRendererTree <TItem>(IActualItemContext <TItem> actualItemContext, FormField field, string localColumnName) where TItem : class
{
var value = actualItemContext.GetActualItemColumnValue(localColumnName);
var valueExpression = GetValueExpression(actualItemContext.ActualItem, field);
return(builder =>
{
builder
.OpenElement(HtmlTagNames.Div, "form-field-wrapper")
.OpenComponent(typeof(InputNumber <>).MakeGenericType(field.Type))
.AddAttribute("id", $"create-form-{localColumnName}")
.AddAttribute("class", "edit-text-field")
.AddAttribute("Value", value)
.AddAttribute("ValueExpression", valueExpression);
if (field.UnderlyingType == typeof(int))
{
if (field.IsNullable)
{
builder
.AddAttribute("ValueChanged", _eventCallbackFactory.Create <int?>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <int?>(valueExpression);
}
else
{
builder
.AddAttribute("ValueChanged", _eventCallbackFactory.Create <int>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <int>(valueExpression);
}
}
else if (field.UnderlyingType == typeof(long))
{
if (field.IsNullable)
{
builder
.AddAttribute("ValueChanged", _eventCallbackFactory.Create <long?>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <long?>(valueExpression);
}
else
{
builder
.AddAttribute("ValueChanged", _eventCallbackFactory.Create <long>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <long>(valueExpression);
}
}
else if (field.UnderlyingType == typeof(decimal))
{
if (field.IsNullable)
{
builder
.AddAttribute("ValueChanged", _eventCallbackFactory.Create <decimal?>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <decimal?>(valueExpression);
}
else
{
builder
.AddAttribute("ValueChanged", _eventCallbackFactory.Create <decimal>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <decimal>(valueExpression);
}
}
else if (field.UnderlyingType == typeof(double))
{
if (field.IsNullable)
{
builder
.AddAttribute("ValueChanged", _eventCallbackFactory.Create <double?>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <double?>(valueExpression);
}
else
{
builder
.AddAttribute("ValueChanged", _eventCallbackFactory.Create <double>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <double>(valueExpression);
}
}
else if (field.UnderlyingType == typeof(float))
{
if (field.IsNullable)
{
builder
.AddAttribute("ValueChanged", _eventCallbackFactory.Create <float?>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <float?>(valueExpression);
}
else
{
builder
.AddAttribute("ValueChanged", _eventCallbackFactory.Create <float>(this, v => actualItemContext.SetActualItemColumnValue(localColumnName, v)))
.CloseComponent()
.AddValidationMessage <float>(valueExpression);
}
}
builder.CloseElement();
});
}
public FileEditPlus()
{
EventFactory = new EventCallbackFactory();
Changed = EventFactory.Create <FileChangedEventArgs>(this, OnChanged);
Progressed = EventFactory.Create <FileProgressedEventArgs>(this, OnProgressed);
}
