protected override async Task OnInitializedAsync()
{
_title = ModuleState.Title;
_containers = ThemeService.GetContainerControls(await ThemeService.GetThemesAsync(), PageState.Page.ThemeType);
_containerType = ModuleState.ContainerType;
if (!string.IsNullOrEmpty(PageState.Page.DefaultContainerType) && _containerType == PageState.Page.DefaultContainerType)
{
_containerType = "-";
}
if (_containerType == PageState.Site.DefaultContainerType)
{
_containerType = "-";
}
_allPages = ModuleState.AllPages.ToString();
_permissions = ModuleState.Permissions;
_permissionNames = ModuleState.ModuleDefinition.PermissionNames;
_pageId = ModuleState.PageId.ToString();
_settingsModuleType = Type.GetType(ModuleState.ModuleType);
if (_settingsModuleType != null)
{
var moduleobject = Activator.CreateInstance(_settingsModuleType) as IModuleControl;
_settingstitle = moduleobject.Title;
if (string.IsNullOrEmpty(_settingstitle))
{
_settingstitle = "Other Settings";
}
DynamicComponent = builder =>
{
builder.OpenComponent(0, _settingsModuleType);
builder.AddComponentReferenceCapture(1, inst => { _settings = Convert.ChangeType(inst, _settingsModuleType); });
builder.CloseComponent();
};
}
}
public override async Task SetParametersAsync(ParameterView parameters)
{
foreach (var p in parameters)
{
switch (p.Name)
{
case nameof(Toast):
{
if (Toast != null)
{
Toast.OnUpdate -= ToastUpdated;
}
Toast = (MatToast)p.Value;
Toast.OnUpdate += ToastUpdated;
EnsureInitialized();
Css = builder =>
{
var transitionClass = TransitionClass;
if (string.IsNullOrEmpty(transitionClass))
{
return;
}
builder.OpenElement(1, "style");
builder.AddContent(2, transitionClass);
builder.CloseElement();
};
break;
}
}
}
await base.SetParametersAsync(parameters);
}
private RenderFragment GenerateIl(bool isDisabled, RenderFragment innerHtml, bool isActive = false)
{
RenderFragment tempDynamicResult;
var classAtrr = "page-item";
if (isDisabled && !isActive)
{
classAtrr += " disabled";
}
if (isActive)
{
classAtrr += " active";
}
return(tempDynamicResult = builder =>
{
builder.OpenElement(1, "il");
builder.AddAttribute(2, "class", classAtrr);
builder.AddContent(3, innerHtml);
builder.CloseElement();
});
}
/// <inheritdoc />
public void SetParameters(ParameterCollection parameters)
{
attributes = parameters.ToDictionary() as Dictionary <string, object>;
// Capture the parameters we want to do special things with, plus all as a dictionary
childContent = GetAndRemove <RenderFragment>(attributes, RenderTreeBuilder.ChildContent);
tagName = GetAndRemove <string>(attributes, "TagName");
className = GetAndRemove <string>(attributes, "class");
Match = GetAndRemove <Match>(attributes, "Match");
//parameters.TryGetValue( RenderTreeBuilder.ChildContent, out childContent );
//parameters.TryGetValue( "TagName", out tagName );
//parameters.TryGetValue( "class", out className );
parameters.TryGetValue("href", out string href);
//Match = parameters.GetValueOrDefault( nameof( Match ), Match.Prefix );
// Update computed state and render
hrefAbsolute = href == null ? string.Empty : UriHelper.ToAbsoluteUri(href).AbsoluteUri;
isActive = ShouldMatch(UriHelper.GetAbsoluteUri());
renderHandle.Render(Render);
}
public void RenderIntoBatch(RenderBatchBuilder batchBuilder, RenderFragment renderFragment)
{
// A component might be in the render queue already before getting disposed by an
// earlier entry in the render queue. In that case, rendering is a no-op.
if (_componentWasDisposed)
{
return;
}
// Swap the old and new tree builders
(_renderTreeBuilderCurrent, _renderTreeBuilderPrevious) = (_renderTreeBuilderPrevious, _renderTreeBuilderCurrent);
_renderTreeBuilderCurrent.Clear();
renderFragment(_renderTreeBuilderCurrent);
var diff = RenderTreeDiffBuilder.ComputeDiff(
_renderer,
batchBuilder,
_componentId,
_renderTreeBuilderPrevious.GetFrames(),
_renderTreeBuilderCurrent.GetFrames());
batchBuilder.UpdatedComponentDiffs.Append(diff);
}
/// <summary>
/// Shows the modal with the component type using the specified <paramref name="title"/>,
/// passing the specified <paramref name="parameters"/> and setting a custom CSS style.
/// </summary>
/// <param name="contentComponent">Type of component to display.</param>
/// <param name="title">Modal title.</param>
/// <param name="parameters">Key/Value collection of parameters to pass to component being displayed.</param>
/// <param name="options">Options to configure the modal.</param>
public IModalReference Show(Type contentComponent, string title, ModalParameters parameters, ModalOptions options)
{
if (!typeof(IComponent).IsAssignableFrom(contentComponent))
{
throw new ArgumentException($"{contentComponent.FullName} must be a Blazor Component");
}
var modalInstanceId = Guid.NewGuid();
ModalReference modalReference = null;
var modalContent = new RenderFragment(builder =>
{
var i = 0;
builder.OpenComponent(i++, contentComponent);
foreach (var parameter in parameters._parameters)
{
builder.AddAttribute(i++, parameter.Key, parameter.Value);
}
builder.CloseComponent();
});
var modalInstance = new RenderFragment(builder =>
{
builder.OpenComponent <BlazoredModalInstance>(0);
builder.AddAttribute(1, "Options", options);
builder.AddAttribute(2, "Title", title);
builder.AddAttribute(3, "Content", modalContent);
builder.AddAttribute(4, "Id", modalInstanceId);
builder.AddComponentReferenceCapture(5, compRef => modalReference.ModalInstanceRef = (BlazoredModalInstance)compRef);
builder.CloseComponent();
});
modalReference = new ModalReference(modalInstanceId, modalInstance, this);
OnModalInstanceAdded?.Invoke(modalReference);
return(modalReference);
}
#pragma warning restore 0414
#pragma warning disable 1998
protected override void BuildRenderTree(Microsoft.AspNetCore.Components.RenderTree.RenderTreeBuilder builder)
{
base.BuildRenderTree(builder);
#line 2 "x:\dir\subdir\Test\TestComponent.cshtml"
RenderFragment <Test.Context> template = (context) =>
#line default
#line hidden
(builder2) => {
#line 2 "x:\dir\subdir\Test\TestComponent.cshtml"
__o = context.Index;
#line default
#line hidden
#line 2 "x:\dir\subdir\Test\TestComponent.cshtml"
__o = context.Item.ToLower();
#line default
#line hidden
}
#line 2 "x:\dir\subdir\Test\TestComponent.cshtml"
;
#line default
#line hidden
__o = new Microsoft.AspNetCore.Components.RenderFragment <Test.Context>(
#line 3 "x:\dir\subdir\Test\TestComponent.cshtml"
template
#line default
#line hidden
);
builder.AddAttribute(-1, "ChildContent", (Microsoft.AspNetCore.Components.RenderFragment)((builder2) => {
}
));
}
public void Show(Type contentComponent, string title, ModalParameters parameters, ModalOptions options)
{
if (!typeof(ComponentBase).IsAssignableFrom(contentComponent))
{
throw new ArgumentException("Must be a Blazor Component!");
}
var content = new RenderFragment(x =>
{
x.OpenComponent(1, contentComponent);
x.CloseComponent();
});
var onShowEventArgs = new OnShowEventArgs()
{
Title = title,
Content = content,
Parameters = parameters,
Options = options,
};
this.modalType = contentComponent;
this.OnShow?.Invoke(this, onShowEventArgs);
}
private static RenderFragment WrapInLayout([DynamicallyAccessedMembers(Component)] Type layoutType, RenderFragment bodyParam)
{
void Render(RenderTreeBuilder builder)
{
builder.OpenComponent(0, layoutType);
builder.AddAttribute(1, LayoutComponentBase.BodyPropertyName, bodyParam);
builder.CloseComponent();
};
return(Render);
}
public IRendererTreeBuilder AddContent(RenderFragment fragment)
{
renderTreeBuilder.AddContent(++sequence, fragment);
return(this);
}
/// <summary>
/// Shows a warning toast
/// </summary>
/// <param name="message">RenderFragment to display on the toast</param>
/// <param name="heading">The text to display as the toasts heading</param>
public void ShowWarning(RenderFragment message, string heading = "")
{
ShowToast(ToastLevel.Warning, message, heading);
}
/// <summary>
/// Shows a information toast
/// </summary>
/// <param name="message">RenderFragment to display on the toast</param>
/// <param name="heading">The text to display as the toasts heading</param>
public void ShowInfo(RenderFragment message, string heading = "")
{
ShowToast(ToastLevel.Info, message, heading);
}
public ISpecialColumnFragmentsCollection <TItem> AddColumnValueRenderFunction <TColumn>(Expression <Func <TItem, TColumn> > columnExpression, RenderFragment <TItem> renderFragment)
{
var entityType = gridConfigurationProvider.FindGridEntityConfigurationByType(typeof(TItem));
if (entityType is NullEntityType)
{
var entityTypeBuilder = internalModelBuilder
.Entity(typeof(TItem))
.Property(columnExpression.GetPropertyAccess())
.HasBlazorComponentValue(renderFragment);
return(this);
}
var columnName = columnExpression.GetPropertyAccess().Name;
var configurationProperty = entityType.FindProperty(columnName);
if (configurationProperty is Property property)
{
new InternalPropertyBuilder(property, internalModelBuilder)
.HasBlazorComponentValue(renderFragment);
}
return(this);
}
/// <inheritdoc />
protected override void BuildRenderTree(RenderTreeBuilder builder)
{
if (_refreshException != null)
{
Exception?oldRefreshException = _refreshException;
_refreshException = null;
throw oldRefreshException;
}
builder.OpenElement(0, "div");
if (UseGridFlexLayout)
{
builder.AddAttribute(1, "style", "display:flex;flex-flow: row wrap;");
}
builder.OpenElement(2, "div");
builder.AddAttribute(3, "style", GetSpacerStyle(_itemsBefore));
builder.AddElementReferenceCapture(4, elementReference => _spacerBefore = elementReference);
builder.CloseElement();
int lastItemIndex = Math.Min(_itemsBefore + _visibleItemCapacity, _itemCount);
int renderIndex = _itemsBefore;
int placeholdersBeforeCount = Math.Min(_loadedItemsStartIndex, lastItemIndex);
builder.OpenRegion(5);
// Render placeholders before the loaded items.
for (; renderIndex < placeholdersBeforeCount; renderIndex++)
{
// This is a rare case where it's valid for the sequence number to be programmatically incremented.
// This is only true because we know for certain that no other content will be alongside it.
builder.AddContent(renderIndex, _placeholder, new PlaceholderContext(renderIndex, _itemSize));
}
builder.CloseRegion();
_lastRenderedItemCount = 0;
// Render the loaded items.
if (_loadedItems != null && _itemTemplate != null)
{
IEnumerable <TItem>?itemsToShow = _loadedItems
.Skip(_itemsBefore - _loadedItemsStartIndex)
.Take(lastItemIndex - _loadedItemsStartIndex);
builder.OpenRegion(6);
foreach (TItem?item in itemsToShow)
{
builder.OpenElement(11, "div");
builder.SetKey(item);
//builder.AddAttribute(8, "data-selection-index", _lastRenderedItemCount + _itemsBefore - _loadedItemsStartIndex + StartIndex);
_itemTemplate(new IndexedItem <TItem> {
Item = item, Index = renderIndex + _lastRenderedItemCount + StartIndex
})(builder);
_lastRenderedItemCount++;
builder.CloseElement();
}
renderIndex += _lastRenderedItemCount;
builder.CloseRegion();
}
_lastRenderedPlaceholderCount = Math.Max(0, lastItemIndex - _itemsBefore - _lastRenderedItemCount);
builder.OpenRegion(12);
// Render the placeholders after the loaded items.
for (; renderIndex < lastItemIndex; renderIndex++)
{
builder.AddContent(renderIndex, _placeholder, new PlaceholderContext(renderIndex, _itemSize));
}
builder.CloseRegion();
int itemsAfter = Math.Max(0, _itemCount - _visibleItemCapacity - _itemsBefore);
builder.OpenElement(13, "div");
builder.AddAttribute(14, "style", GetSpacerStyle(itemsAfter));
builder.AddElementReferenceCapture(15, elementReference => _spacerAfter = elementReference);
builder.CloseElement();
//builder.AddElementReferenceCapture(13, elemRef => RootElementReference = elemRef);
builder.CloseElement();
}
protected override void OnInitialized()
{
base.OnInitialized();
// ReSharper disable once RedundantAssignment
Debugger = builder =>
{
var seq = 0;
builder.OpenElement(seq++, "style");
builder.AddContent(seq++,
@".redux-debugger {
display: flex;
flex-wrap: wrap;
}
.redux-debugger__historic-entry {
background-color: WhiteSmoke;
padding: .5em;
}
.redux-debugger__historic-entry:hover {
background-color: Gainsboro;
}
.redux-debugger__historic-entry--selected,
.redux-debugger__historic-entry--selected:hover {
background-color: #4189C7;
color: White;
}
.redux-debugger__historic-entry__action {
font-weight: bold;
}
.redux-debugger__action-details {
padding: .5em;
}");
builder.CloseElement();
builder.OpenElement(seq++, "div");
builder.AddAttribute(seq++, "class", "redux-debugger");
builder.OpenElement(seq++, "div");
builder.AddAttribute(seq++, "class", "redux-debugger__action-history");
foreach (var entry in Store.History)
{
Callback callback = () => SelectEntry(entry);
builder.OpenElement(seq++, "div");
builder.AddAttribute(seq++, "class", "redux-debugger__historic-entry " + (entry == _selectedEntry ? "redux-debugger__historic-entry--selected" : ""));
builder.AddAttribute(seq++, "onclick", callback);
builder.OpenElement(seq++, "div");
builder.AddAttribute(seq++, "class", "redux-debugger__historic-entry__action");
builder.AddContent(seq++, entry.Action?.ToString() ?? "Initial state");
builder.CloseElement();
builder.OpenElement(seq++, "div");
builder.AddAttribute(seq++, "class", "redux-debugger__historic-entry__time");
builder.AddContent(seq++, entry.Time.ToUniversalTime().ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fff'Z'"));
builder.CloseElement();
builder.CloseElement(); // historic-entry
}
builder.CloseElement(); // action-history
builder.OpenElement(seq++, "div");
builder.AddAttribute(seq++, "class", "redux-debugger__action-details");
seq = RenderActionDetails(builder, seq, _selectedEntry);
builder.CloseElement(); // action-details
builder.CloseElement(); // redux-debugger
};
}
private static RenderFragment RenderArray <T>(this IEnumerable <T> seq, RenderFragment <T> itemTemlpate) => sub => seq .Aggregate(sub, Render(itemTemlpate));
public static Func <RenderTreeBuilder, T, RenderTreeBuilder> Render <T>(this RenderFragment <T> itemTemlpate)
=> (b, t) =>
{
itemTemlpate(t).Invoke(b);
return(b);
};
public PropertyBuilder <TProperty, TEntity> HasBlazorComponentValueRender(RenderFragment <TEntity> fragment)
{
Builder.HasBlazorComponentValue(fragment);
return(this);
}
/// <summary>
/// Constructs an instance of <see cref="DynamicComponent"/>.
/// </summary>
public DynamicComponent()
{
_cachedRenderFragment = Render;
}
public async Task OnRenderCompletedAsync_DoesNotThrowWhenThereAreNoPendingBatchesToAck()
{
// Arrange
var serviceProvider = CreateServiceProvider();
var firstBatchTCS = new TaskCompletionSource <object>();
var secondBatchTCS = new TaskCompletionSource <object>();
var offlineClient = new CircuitClientProxy(new Mock <IClientProxy>(MockBehavior.Strict).Object, "offline-client");
offlineClient.SetDisconnected();
var renderer = GetRemoteRenderer(serviceProvider, offlineClient);
RenderFragment initialContent = (builder) =>
{
builder.OpenElement(0, "my element");
builder.AddContent(1, "some text");
builder.CloseElement();
};
var trigger = new Trigger();
var renderIds = new List <long>();
var onlineClient = new Mock <IClientProxy>();
onlineClient.Setup(c => c.SendCoreAsync(It.IsAny <string>(), It.IsAny <object[]>(), It.IsAny <CancellationToken>()))
.Callback((string name, object[] value, CancellationToken token) => renderIds.Add((long)value[1]))
.Returns <string, object[], CancellationToken>((n, v, t) => (long)v[1] == 2 ? firstBatchTCS.Task : secondBatchTCS.Task);
// This produces the initial batch (id = 2)
await renderer.Dispatcher.InvokeAsync(() => renderer.RenderComponentAsync <AutoParameterTestComponent>(
ParameterView.FromDictionary(new Dictionary <string, object>
{
[nameof(AutoParameterTestComponent.Content)] = initialContent,
[nameof(AutoParameterTestComponent.Trigger)] = trigger
})));
trigger.Component.Content = (builder) =>
{
builder.OpenElement(0, "offline element");
builder.AddContent(1, "offline text");
builder.CloseElement();
};
// This produces an additional batch (id = 3)
trigger.TriggerRender();
var originallyQueuedBatches = renderer._unacknowledgedRenderBatches.Count;
// Act
offlineClient.Transfer(onlineClient.Object, "new-connection");
var task = renderer.ProcessBufferedRenderBatches();
var exceptions = new List <Exception>();
renderer.UnhandledException += (sender, e) =>
{
exceptions.Add(e);
};
// Receive the ack for the initial batch
_ = renderer.OnRenderCompletedAsync(2, null);
// Receive the ack for the second batch
_ = renderer.OnRenderCompletedAsync(2, null);
firstBatchTCS.SetResult(null);
secondBatchTCS.SetResult(null);
// Repeat the ack for the third batch
_ = renderer.OnRenderCompletedAsync(3, null);
// Assert
Assert.Empty(exceptions);
}
/// <summary>
/// Shows a toast using the supplied settings
/// </summary>
/// <param name="level">Toast level to display</param>
/// <param name="message">RenderFragment to display on the toast</param>
/// <param name="heading">The text to display as the toasts heading</param>
public void ShowToast(ToastLevel level, RenderFragment message, string heading = "")
{
OnShow?.Invoke(level, message, heading);
}
public TestComponent(RenderFragment renderFragment)
{
_renderFragment = renderFragment;
}
/// <summary>
/// Shows a success toast
/// </summary>
/// <param name="message">RenderFragment to display on the toast</param>
/// <param name="heading">The text to display as the toasts heading</param>
public void ShowSuccess(RenderFragment message, string heading = "")
{
ShowToast(ToastLevel.Success, message, heading);
}
/// <summary>
/// Constructs an instance of <see cref="BlazorComponent"/>.
/// </summary>
public BlazorComponent()
{
_renderFragment = BuildRenderTree;
}
/// <summary>
/// Shows a error toast
/// </summary>
/// <param name="message">RenderFragment to display on the toast</param>
/// <param name="heading">The text to display as the toasts heading</param>
public void ShowError(RenderFragment message, string heading = "")
{
ShowToast(ToastLevel.Error, message, heading);
}
public async Task ShowAsync(string title, RenderFragment body)
{
await ShowAsync(title, body, ModalDialogSize.Default);
}
internal AntTimelineItem(RenderFragment childContent, RenderFragment dot, string @class)
{
this.ChildContent = childContent;
this.Dot = dot;
this.Class = @class;
}
public async Task ShowAsync(string title, RenderFragment body, ModalDialogSize size)
{
await OnShow?.Invoke(title, body, size);
}
/// <summary>
/// Constructs an instance of <see cref="ComponentBase"/>.
/// </summary>
public ComponentBase()
{
_renderFragment = BuildRenderTree;
}
public static RenderFragment ToRenderFrament <T>(
this IEnumerable <T> seq,
RenderFragment <T> itemTemplate)
=> seq.ToRenderFrament(0, itemTemplate);
