CreateWorkflowInstanceDialog.razor

@*
    Copyright © 2024-Present The Synapse Authors

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*@

@using Json.Schema
@using Neuroglia.Data.Infrastructure.ResourceOriented.Properties
@using ServerlessWorkflow.Sdk
@using ServerlessWorkflow.Sdk.Models
@using System.Xml.Schema
@using Synapse.Core.Infrastructure.Services
@using System.Text.Json.Nodes
@namespace Synapse.Dashboard.Components
@inject MonacoInterop MonacoInterop
@inject IExternalResourceProvider ExternalResourceProvider
@inject IJsonSerializer JsonSerializer
@inject IXmlSerializer XmlSerializer

<Tabs>
    @if(schema != null)
    {
        <Tab Title="Form" Active="true">
            <Content>
                <div class="pt-3">
                    <DynamicForm Schema="schema" OnValueChanged="value => OnValueChanged(value)" />
                </div>
            </Content>
        </Tab>
    }
    <Tab Title="Text">
        <Content>
            <div class="pt-3">
                <MonacoEditor OnTextChanged="OnTextChanged" ModelName="@modelName" Document="input" />
            </div>
        </Content>
    </Tab>
</Tabs>

<div class="py-3">
    @if (Operators != null && Operators.Count() > 0)
    {
        <select class="form-select m-2" @onchange="OnSelectOperatorChanged">
            <option value="">Any Operator</option>
            @foreach (var op in Operators)
            {
                var name = op.GetName() + "." + op.GetNamespace();
                <option value="@name" selected="@(name == operatorName)">@name</option>
            }
        </select>
    }
</div>

<div class="text-center">
    <Button Outline="true" Color="ButtonColor.Primary" class="m-auto mt-3 w-100" @onclick="async _ => await OnStartAsync()">
        <Icon Name="IconName.Play" />
        Start
    </Button>
</div>

@code {

    WorkflowDefinition? workflowDefinition;
    JsonSchema? schema;
    string payload = string.Empty;
    string modelName = string.Empty;
    EquatableDictionary<string, object>? input;
    string? operatorName;

    [Parameter] public WorkflowDefinition? WorkflowDefinition { get; set; }
    [Parameter] public EquatableList<Operator> Operators { get; set; } = [];
    [Parameter] public string? OperatorName { get; set; } = null;
    [Parameter] public EquatableDictionary<string, object>? Input { get; set; }
    [Parameter] public EventCallback<CreateWorkflowInstanceParameters> OnCreate { get; set; }
    [Parameter] public EventCallback<ProblemDetails> OnProblem { get; set; }

    void OnValueChanged(object? value)
    {
        payload = value == null ? string.Empty : JsonSerializer.SerializeToText(value);
    }

    void OnTextChanged(string value)
    {
        payload = value;
    }

    protected override async Task OnParametersSetAsync()
    {
        await base.OnParametersSetAsync();
        if (input != Input) input = Input;
        if (operatorName != OperatorName) operatorName = OperatorName;
        if (workflowDefinition != WorkflowDefinition) 
        {
            workflowDefinition = WorkflowDefinition;
            await LoadSchemaAsync();
        }
        if (WorkflowDefinition?.Input?.Schema?.Document != null)
        {
            modelName = WorkflowDefinition.Document.Name + "-" + WorkflowDefinition.Document.Version;
            await MonacoInterop.AddValidationSchemaAsync(JsonSerializer.SerializeToText(WorkflowDefinition.Input.Schema.Document), $"https://synapse.io/schemas/{modelName}.json", $"{modelName}*").ConfigureAwait(false);
        }
    }

    protected void OnSelectOperatorChanged(ChangeEventArgs e)
    {
        operatorName = e.Value?.ToString();
    }

    async Task OnStartAsync()
    {
        if (schema != null)
        {
            var node = string.IsNullOrWhiteSpace(payload) ? null : JsonSerializer.Deserialize<JsonNode>(payload);
            var evaluationOptions = new EvaluationOptions()
            {
                OutputFormat = OutputFormat.List
            };
            var evaluationResult = schema.Evaluate(node, evaluationOptions);
            if (!evaluationResult.IsValid)
            {
                var errors = evaluationResult.Details.Where(d => d.Errors != null).SelectMany(d => d.Errors!).GroupBy(e => e.Key).Select(e => new KeyValuePair<string, string[]>(e.Key, e.Select(e => e.Value).ToArray())).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
                var problemDetails = new ProblemDetails(ErrorTypes.Invalid, ProblemTitles.ValidationFailed, ErrorStatus.Validation, "Workflow instance input validation failed", errors: errors);
                if (OnProblem.HasDelegate) await OnProblem.InvokeAsync(problemDetails);
                return;
            }
        }
        if (OnCreate.HasDelegate)
        {
            await OnCreate.InvokeAsync(new CreateWorkflowInstanceParameters() { 
                Input = payload,
                Operator = operatorName
            });
        }
    }

    async Task LoadSchemaAsync()
    {
        var schemaDefinition = WorkflowDefinition?.Input?.Schema;
        if (schemaDefinition == null) return;
        if (schemaDefinition.Resource == null)
        {
            switch (schemaDefinition.Format)
            {
                case SchemaFormat.Avro:
                    schema = Avro.Schema.Parse(JsonSerializer.SerializeToText(schemaDefinition.Document)).ToJsonSchema();
                    break;
                case SchemaFormat.Json:
                    schema = JsonSchema.FromText(JsonSerializer.SerializeToText(schemaDefinition.Document));
                    break;
                case SchemaFormat.Xml:
                    var xml = XmlSerializer.SerializeToText(schemaDefinition.Document);
                    var stringReader = new StringReader(xml);
                    schema = XmlSchema.Read(stringReader, null)!.ToJsonSchema();
                    break;
                default:
                    throw new NotSupportedException($"The specified schema format '{schemaDefinition.Format}' is not supported");
            }
        }
        else
        {
            using var stream = await ExternalResourceProvider.ReadAsync(schemaDefinition.Resource).ConfigureAwait(false);
            using var streamReader = new StreamReader(stream);
            schema = schemaDefinition.Format switch
            {
                SchemaFormat.Avro => Avro.Schema.Parse(await streamReader.ReadToEndAsync()).ToJsonSchema(),
                SchemaFormat.Json => await JsonSchema.FromStream(stream).ConfigureAwait(false),
                SchemaFormat.Xml => XmlSchema.Read(stream, null)!.ToJsonSchema(),
                _ => throw new NotSupportedException($"The specified schema format '{schemaDefinition.Format}' is not supported"),
            };
        }
    }

}