[ENH] Test All UI Component Modes

[thabaum]

We will need to be sure to test all the render modes such as prerender/static/interactive/hybrid/etc...

[ADefWebserver]

Perhaps get a release out with interactive mode because I would not want static mode to be a blocker?

[thabaum]

I think once we move things to the right places this should be good to go.

We got some work to do here

🚀

7 is our current showstopper.

[ADefWebserver]

Ok I see your point now.

[thabaum]

@ADefWebserver Notice the line public override string RenderMode => RenderModes.Static; in the code block below is the current HTML Index.razor code behind:

@code {
    private string content = "";

    public override string RenderMode => RenderModes.Static;

    protected override async Task OnParametersSetAsync()
    {
        try
        {
            if (ShouldRender())
            {
                var htmltext = await HtmlTextService.GetHtmlTextAsync(ModuleState.ModuleId);
                if (htmltext != null)
                {
                    content = htmltext.Content;
                    content = Utilities.FormatContent(content, PageState.Alias, "render");
                }
                else
                {
                    content = "";
                }
            }
        }
        catch (Exception ex)
        {
            await logger.LogError(ex, "Error Loading Content {Error}", ex.Message);
            AddModuleMessage(Localizer["Error.Content.Load"], MessageType.Error);
        }
    }
}

Now I believe all modules are ran interactively natively except when this has been declared, or should be.

The current "Edit.razor" file does not have this override:

@code {
    public override SecurityAccessLevel SecurityAccessLevel => SecurityAccessLevel.Edit;

    public override string Title => "Edit Html/Text";

    public override List<Resource> Resources => new List<Resource>()
    {
        new Resource { ResourceType = ResourceType.Stylesheet, Url = "css/quill/quill.bubble.css" },
        new Resource { ResourceType = ResourceType.Stylesheet, Url = "css/quill/quill.snow.css" }
    };

    private RichTextEditor RichTextEditorHtml;
    private bool _allowfilemanagement;
    private bool _allowrawhtml;
    private string _content = null;
    private string _createdby;
    private DateTime _createdon;
    private string _modifiedby;
    private DateTime _modifiedon;
    private List<Models.HtmlText> _htmltexts;
    private string _view = "";

    protected override async Task OnInitializedAsync()
    {
        try
        {
            _allowfilemanagement = bool.Parse(SettingService.GetSetting(ModuleState.Settings, "AllowFileManagement", "true"));
            _allowrawhtml = bool.Parse(SettingService.GetSetting(ModuleState.Settings, "AllowRawHtml", "true"));
            await LoadContent();
        }
        catch (Exception ex)
        {
            await logger.LogError(ex, "Error Loading Content {Error}", ex.Message);
            AddModuleMessage(Localizer["Error.Content.Load"], MessageType.Error);
        }
    }

    private async Task LoadContent()
    {
        var htmltext = await HtmlTextService.GetHtmlTextAsync(ModuleState.ModuleId);
        if (htmltext != null)
        {
            _content = htmltext.Content;
            _content = Utilities.FormatContent(_content, PageState.Alias, "render");
            _createdby = htmltext.CreatedBy;
            _createdon = htmltext.CreatedOn;
            _modifiedby = htmltext.ModifiedBy;
            _modifiedon = htmltext.ModifiedOn;
        }
        else
        {
            _content = string.Empty;
        }

        _htmltexts = await HtmlTextService.GetHtmlTextsAsync(ModuleState.ModuleId);
        _htmltexts = _htmltexts.OrderByDescending(item => item.CreatedOn).ToList();

        _view = "";
    }

    private async Task SaveContent()
    {
        string content = await RichTextEditorHtml.GetHtml();
        content = Utilities.FormatContent(content, PageState.Alias, "save");

        try
        {
            var htmltext = new HtmlText();
            htmltext.ModuleId = ModuleState.ModuleId;
            htmltext.Content = content;
            await HtmlTextService.AddHtmlTextAsync(htmltext);

            await logger.LogInformation("Content Saved {HtmlText}", htmltext);
            NavigationManager.NavigateTo(NavigateUrl());
        }
        catch (Exception ex)
        {
            await logger.LogError(ex, "Error Saving Content {Error}", ex.Message);
            AddModuleMessage(Localizer["Error.Content.Save"], MessageType.Error);
        }
    }

    private async Task View(Models.HtmlText htmltext)
    {
        try
        {
            htmltext = await HtmlTextService.GetHtmlTextAsync(htmltext.HtmlTextId, htmltext.ModuleId);
            if (htmltext != null)
            {
                _view = htmltext.Content;
                _view = Utilities.FormatContent(_view, PageState.Alias, "render");
                StateHasChanged();
            }       
        }
        catch (Exception ex)
        {
            await logger.LogError(ex, "Error Viewing Content {Error}", ex.Message);
            AddModuleMessage(Localizer["Error.Content.View"], MessageType.Error);
        }
    }

    private async Task Restore(Models.HtmlText htmltext)
    {
        try
        {
            htmltext = await HtmlTextService.GetHtmlTextAsync(htmltext.HtmlTextId, ModuleState.ModuleId);
            if (htmltext != null)
            {
                var content = htmltext.Content;
                htmltext = new HtmlText();
                htmltext.ModuleId = ModuleState.ModuleId;
                htmltext.Content = content;
                await HtmlTextService.AddHtmlTextAsync(htmltext);
                await logger.LogInformation("Content Restored {HtmlText}", htmltext);
                AddModuleMessage(Localizer["Message.Content.Restored"], MessageType.Success);
                await LoadContent();
                StateHasChanged();
            }               
        }
        catch (Exception ex)
        {
            await logger.LogError(ex, "Error Restoring Content {Error}", ex.Message);
            AddModuleMessage(Localizer["Error.Content.Restore"], MessageType.Error);
        }
    }

    private async Task Delete(Models.HtmlText htmltext)
    {
        try
        {
            htmltext = await HtmlTextService.GetHtmlTextAsync(htmltext.HtmlTextId, ModuleState.ModuleId);
            if (htmltext != null)
            {
                await HtmlTextService.DeleteHtmlTextAsync(htmltext.HtmlTextId, htmltext.ModuleId);
                await logger.LogInformation("Content Deleted {HtmlText}", htmltext);
                AddModuleMessage(Localizer["Message.Content.Deleted"], MessageType.Success);
                await LoadContent();
                StateHasChanged();
            }       
        }
        catch (Exception ex)
        {
            await logger.LogError(ex, "Error Deleting Content {Error}", ex.Message);
            AddModuleMessage(Localizer["Error.Content.Delete"], MessageType.Error);
        }
    }
}

For reference. We should be able to tap into all this logic first with the new editor and leave the other Index.razor file as is I am guessing.

And correct me if I am wrong anywhere please as I know we may need to fix a few things in the project to allow static rendering to work properly. For now focusing on interactive server settings with prerendering enabled.

[ADefWebserver]

This is Perfect!