Fixed Kafka integration issues. Fixed Liquid integration issues. Added test cases for string value. (#532)

Co-authored-by: Mittul Madaan <mittul.madaan@reedelsevier.com>

backend/extensions/Squidex.Extensions/Actions/Kafka/KafkaProducer.cs

@@ -15,9 +15,11 @@ using Confluent.Kafka;
 using Confluent.SchemaRegistry;
 using Confluent.SchemaRegistry.Serdes;
 using Microsoft.Extensions.Options;
+using Newtonsoft.Json;
 using Squidex.Infrastructure.Json;
 using Squidex.Infrastructure.Json.Objects;
 using Squidex.Infrastructure.Log;
+using Schema = Avro.Schema;
 
 namespace Squidex.Extensions.Actions.Kafka
 {
@@ -155,13 +157,20 @@ namespace Squidex.Extensions.Actions.Kafka
 
         private GenericRecord CreateAvroRecord(string json, string avroSchema)
         {
-            var schema = (RecordSchema)Avro.Schema.Parse(avroSchema);
+            try
+            {
+                var schema = (RecordSchema)Avro.Schema.Parse(avroSchema);
 
-            var jsonObject = jsonSerializer.Deserialize<JsonObject>(json);
+                var jsonObject = jsonSerializer.Deserialize<JsonObject>(json);
 
-            var result = (GenericRecord)GetValue(jsonObject, schema);
+                var result = (GenericRecord)GetValue(jsonObject, schema);
 
-            return result;
+                return result;
+            }
+            catch (JsonException ex)
+            {
+                throw new InvalidOperationException($"Failed to parse json: {json}, got {ex.Message}", ex);
+            }
         }
 
         public void Dispose()
@@ -170,12 +179,18 @@ namespace Squidex.Extensions.Actions.Kafka
             avroProducer?.Dispose();
         }
 
-        private object GetValue(IJsonValue value, Avro.Schema schema)
+        private object GetValue(IJsonValue value, Schema schema)
         {
             switch (value)
             {
                 case JsonString s:
                     return s.Value;
+                case JsonNumber n when schema.Tag == Schema.Type.Long:
+                    return (long)n.Value;
+                case JsonNumber n when schema.Tag == Schema.Type.Float:
+                    return (float)n.Value;
+                case JsonNumber n when schema.Tag == Schema.Type.Int:
+                    return (int)n.Value;
                 case JsonNumber n:
                     return n.Value;
                 case JsonBoolean b:

backend/src/Squidex.Domain.Apps.Core.Operations/Templates/Extensions/ContentFluidExtension.cs

@@ -19,6 +19,10 @@ namespace Squidex.Domain.Apps.Core.Templates.Extensions
         {
             FluidValue.SetTypeMapping<JsonObject>(x => new ObjectValue(x));
             FluidValue.SetTypeMapping<JsonArray>(x => new JsonArrayFluidValue(x));
+            FluidValue.SetTypeMapping<JsonString>(x => FluidValue.Create(x.Value));
+            FluidValue.SetTypeMapping<JsonBoolean>(x => FluidValue.Create(x.Value));
+            FluidValue.SetTypeMapping<JsonNumber>(x => FluidValue.Create(x.Value));
+            FluidValue.SetTypeMapping<JsonNull>(x => FluidValue.Create(null));
 
             memberAccessStrategy.Register<NamedContentData, object?>(
                 (value, name) => value.GetOrDefault(name));

backend/src/Squidex.Domain.Apps.Core.Operations/Templates/Extensions/DateTimeFluidExtension.cs

@@ -9,6 +9,8 @@ using System;
 using Fluid;
 using Fluid.Values;
 using NodaTime;
+using NodaTime.Text;
+using Squidex.Infrastructure.Json.Objects;
 
 namespace Squidex.Domain.Apps.Core.Templates.Extensions
 {
@@ -53,6 +55,20 @@ namespace Squidex.Domain.Apps.Core.Templates.Extensions
                         return formatter(value);
                     }
 
+                case StringValue stringValue:
+                    {
+                        var value = stringValue.ToStringValue();
+
+                        var instant = InstantPattern.General.Parse(value);
+
+                        if (instant.Success)
+                        {
+                            return formatter(instant.Value.ToDateTimeOffset());
+                        }
+
+                        break;
+                    }
+
                 case ObjectValue objectValue:
                     {
                         var value = objectValue.ToObjectValue();

backend/src/Squidex/Config/Domain/InfrastructureServices.cs

@@ -78,13 +78,13 @@ namespace Squidex.Config.Domain
                 .AsOptional<ITemplateEngine>();
 
             services.AddSingletonAs<ContentFluidExtension>()
-                .AsOptional<IFluidExtension>();
+                .As<IFluidExtension>();
 
             services.AddSingletonAs<DateTimeFluidExtension>()
-                .AsOptional<IFluidExtension>();
+                .As<IFluidExtension>();
 
             services.AddSingletonAs<UserFluidExtension>()
-                .AsOptional<IFluidExtension>();
+                .As<IFluidExtension>();
 
             services.AddSingleton<Func<IIncomingGrainCallContext, string>>(DomainObjectGrainFormatter.Format);
         }

backend/tests/Squidex.Domain.Apps.Core.Tests/Operations/HandleRules/RuleEventFormatterCompareTests.cs

@@ -660,6 +660,28 @@ namespace Squidex.Domain.Apps.Core.Operations.HandleRules
             Assert.Equal("1590769584000", result);
         }
 
+        [Theory]
+        [Expressions(
+            null,
+            "${CONTENT_DATA.time.iv | timestamp}",
+            null,
+            "{{event.data.time.iv | timestamp}}")]
+        public async Task Should_return_timestamp_when_string(string script)
+        {
+            var @event = new EnrichedContentEvent
+            {
+                Data =
+                    new NamedContentData()
+                        .AddField("time",
+                            new ContentFieldData()
+                                .AddValue(JsonValue.Create("2020-06-01T10:10:20Z")))
+            };
+
+            var result = await sut.FormatAsync(script, @event);
+
+            Assert.Equal("1591006220000", result);
+        }
+
         [Theory]
         [Expressions(
             null,