#nullable enable

​

namespace Cnh.SysConsole.AuditLogging.MessageBroker

{

    using System;

    using System.Threading.Tasks;

    using MassTransit;

    using MassTransit.Testing;

    using Microsoft.Extensions.DependencyInjection;

    using CNH.Products.Lib.Model.Contracts;

    using Cnh.SysConsole.AuditLogging.MessageBroker.Consumers.ProductsDomain;

    using NSubstitute;

    using Serilog;

    using Serilog.Formatting.Compact;

​

    public class Program

    {

        public static async Task Main()

        {

            var provider = new ServiceCollection()

                .AddSerilog((services, cfg) =>

                    cfg

                        .WriteTo.Console(new RenderedCompactJsonFormatter()))

                .AddMassTransitTestHarness(cfg =>

                {

                    cfg.AddConsumer<ProductCreatedConsumer>();                 

                })

                .BuildServiceProvider(true);

​

            var harness = provider.GetRequiredService<ITestHarness>();

​

            await harness.Start();

            await harness.Bus.Publish<IActiveProductCreatedEvent>(new

            {

                Id = Guid.NewGuid()

            });

            await harness.Stop();

        }

    }

}

​

namespace CNH.Products.Lib.Model.Contracts

{

    using System;

    using System.ComponentModel;

    [Description("Active product created")]

    public interface IActiveProductCreatedEvent : IProductCreated

    {

        Guid Id { get; }

        string PartNumber { get; }

        string? Name { get; }

    }

    [Description("... Product created ...")]

    public interface IProductCreated

    {

    }

}

​

namespace Cnh.SysConsole.AuditLogging.MessageBroker.Consumers.ProductsDomain

{

    using System;

    using System.Threading.Tasks;

    using MassTransit;

    using CNH.Products.Lib.Model.Contracts;

    using Microsoft.Extensions.Logging;

    using Cnh.Psca.AuditLogger.Abstractions.Logging;

    public class ProductCreatedConsumer : IConsumer<IActiveProductCreatedEvent>

    {

        private readonly ILogger<ProductCreatedConsumer> _logger;

        public ProductCreatedConsumer(ILogger<ProductCreatedConsumer> logger)

        {

            _logger = logger;

        }

        public async Task Consume(ConsumeContext<IActiveProductCreatedEvent> context)

        {

            var @event = context.Message;

            _logger.LogInformation("Message received: {@IActiveProductCreatedEvent}", @event);

            var logEvent = new AuditLogEvent<IActiveProductCreatedEvent>(_logger, @event);

            _logger.LogInformation("Log event: {@LogEvent}", logEvent);

        }

    }

}

​

namespace Cnh.Psca.AuditLogger.Abstractions.Logging

{

    using System;

    using System.Text.Json;

    using Cnh.Psca.AuditLogger.Abstractions.Extensions;

    using Microsoft.Extensions.Logging;

    public class AuditLogEvent<TEvent>

    {

        /*

        public Type Type { get; }

        public bool IsInterface { get; }

        public Type[] InterfaceTypes { get; }

        */

        public string Name { get; }

        public string DisplayName { get; }

        public string Json { get; }

        public AuditLogEvent(ILogger logger, TEvent @event)

        {

            ArgumentNullException.ThrowIfNull(@event);

​

            /*

            Type = @event.GetType();

            IsInterface = @event.GetType().IsInterface;

            InterfaceTypes = @event.GetType().GetInterfaces();

            Name = @event.GetType().Name;

            DisplayName = @event.GetDescription() ?? Name;

            */

            var type = @event.GetType();

            Name = type.Name;

            DisplayName = type.GetDescription() ?? Name;

​

            Json = JsonSerializer.Serialize(@event);

        }

        public AuditLogEvent(ILogger logger, TEvent @event, string eventJson)

        {

            ArgumentNullException.ThrowIfNull(@event);

            ArgumentNullException.ThrowIfNull(eventJson);

​

            /*

            Type = @event.GetType();

            IsInterface = @event.GetType().IsInterface;

            InterfaceTypes = @event.GetType().GetInterfaces();

            Name = @event.GetType().Name;

            DisplayName = @event.GetDescription() ?? Name;

            */

            var type = @event.GetType();

            Name = type.Name;

            DisplayName = type.GetDescription() ?? Name;

​

            Json = eventJson;

        }

    }

}

​

namespace Cnh.Psca.AuditLogger.Abstractions.Extensions

{

    using System;

    using System.ComponentModel;

    using System.Reflection;

    /*

    public static class GenericExtensions

    {

        public static string? GetDescription<T>(this T source)

        {

            if (source == null)

            {

                return null;

            }

            var sourceType = source.GetType();

​

            var descriptionAttribute = sourceType

                .GetCustomAttribute<DescriptionAttribute>(false);

​

            string? description = descriptionAttribute?.Description;

            if (description != null)

            {

                return description;

            }

            foreach (var interfaceType in sourceType.GetInterfaces())

            {

                descriptionAttribute = interfaceType

                    .GetCustomAttribute<DescriptionAttribute>(false);

                description = descriptionAttribute?.Description;

                if (description != null)

                {

                    return description;

                }

            }

            return null;

        }

    }

    */

    public static class TypeExtensions

    {

        public static string? GetDescription(this Type sourceType)

        {

            var descriptionAttribute = sourceType

                .GetCustomAttribute<DescriptionAttribute>(false);

​

            var description = descriptionAttribute?.Description;

            if (!String.IsNullOrWhiteSpace(description))

            {

                return description;

            }

            foreach (var interfaceType in sourceType.GetInterfaces())

            {

                description = interfaceType.GetDescription();

                if (!String.IsNullOrWhiteSpace(description))

                {

                    return description;

                }

            }

​

            return null;

        }

    }

}