oqtane.framework/Oqtane.Client/Modules/Controls/RichTextEditor.razor

@using System.Text.RegularExpressions
@using Microsoft.AspNetCore.Components.Rendering
@using Microsoft.Extensions.DependencyInjection
@namespace Oqtane.Modules.Controls
@inherits ModuleControlBase
@inject IServiceProvider ServiceProvider
@inject IStringLocalizer<RichTextEditor> Localizer 

<div class="row" style="margin-bottom: 50px;">
    <div class="col">
        @_textEditorComponent
    </div>
</div>

@code {
    private string _textEditorProvider;
    private RenderFragment _textEditorComponent;
    private ITextEditor _textEditor;

    [Parameter]
    public string Content { get; set; }

    [Parameter]
    public bool ReadOnly { get; set; } = false;

    [Parameter]
    public string Placeholder { get; set; }

    [Parameter]
    public string Provider { get; set; }

    [Parameter(CaptureUnmatchedValues = true)]
    public Dictionary<string, object> AdditionalAttributes { get; set; } = new Dictionary<string, object>();

    protected override async Task OnInitializedAsync()
    {
        _textEditorProvider = await GetTextEditorType(ServiceProvider, PageState.Site.SiteId);
    }

    protected override void OnParametersSet()
    {
        _textEditorComponent = (builder) =>
        {
            CreateTextEditor(builder);
        };
    }

    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
        if(_textEditor != null)
        {
            _textEditor.Initialize(Content);
        }

        await base.OnAfterRenderAsync(firstRender);
    }

    public override async Task<List<Resource>> GetResources(IServiceProvider serviceProvider, Page page)
    {
        var type = await GetTextEditorType(serviceProvider, page.SiteId);
        if (!string.IsNullOrEmpty(type))
        {
            var editorType = Type.GetType(type);
            if (editorType != null && editorType.GetInterfaces().Contains(typeof(IModuleControl)))
            {
                var control = Activator.CreateInstance(editorType) as IModuleControl;
                return await control?.GetResources(serviceProvider, page);
            }
        }

        return await base.GetResources(serviceProvider, page);
    }

    public async Task<string> GetHtml()
    {
        return await _textEditor.GetContent();
    }

    private void CreateTextEditor(RenderTreeBuilder builder)
    {
        if(!string.IsNullOrEmpty(_textEditorProvider))
        {
            var editorType = Type.GetType(_textEditorProvider);
            if (editorType != null)
            {
                builder.OpenComponent(0, editorType);

                var attributes = new Dictionary<string, object>
                {
                    { "Placeholder", Placeholder },
                    { "ReadOnly", ReadOnly }
                };

                if (AdditionalAttributes != null)
                {
                    foreach(var key in AdditionalAttributes.Keys)
                    {
                        if(!attributes.ContainsKey(key))
                        {
                            attributes.Add(key, AdditionalAttributes[key]);
                        }
                        else
                        {
                            attributes[key] = AdditionalAttributes[key];
                        }
                    }
                }

                var index = 1;
                foreach(var name in attributes.Keys)
                {
                    if (editorType.GetProperty(name) != null)
                    {
                        builder.AddAttribute(index++, name, attributes[name]);
                    }
                }

                builder.AddComponentReferenceCapture(index, (c) =>
                {
                    _textEditor = (ITextEditor)c;
                });
                builder.CloseComponent();
            }
        }
    }

    private async Task<string> GetTextEditorType(IServiceProvider serviceProvider, int siteId)
    {
        const string EditorSettingName = "TextEditorProvider";

        if(!string.IsNullOrEmpty(Provider))
        {
            var provider = serviceProvider.GetServices<ITextEditorProvider>().FirstOrDefault(i => i.Name.Equals(Provider, StringComparison.OrdinalIgnoreCase));
            if(provider != null)
            {
                return provider.EditorType;
            }
        }

        var settingService = serviceProvider.GetService<ISettingService>();
        var settings = await settingService.GetSiteSettingsAsync(siteId);
        return settingService.GetSetting(settings, EditorSettingName, Constants.DefaultTextEditorProvider);
    }
}