[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!