Revert "Revert "Aggiunti metodi statici""

This reverts commit 0c1e34c.

Author: AngeloDotNet

src/NET6CustomLibrary/DateTime/Converters/DateOnlyConverter.cs

@@ -0,0 +1,13 @@
+namespace NET6CustomLibrary.DateTime.Converters;
+
+public class DateOnlyConverter : JsonConverter<DateOnly>
+{
+    public override DateOnly Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        var value = reader.GetString();
+        return DateOnly.Parse(value);
+    }
+
+    public override void Write(Utf8JsonWriter writer, DateOnly value, JsonSerializerOptions options)
+        => writer.WriteStringValue(value.ToString("yyyy-MM-dd"));
+}

src/NET6CustomLibrary/DateTime/Converters/TimeOnlyConverter.cs

@@ -0,0 +1,13 @@
+namespace NET6CustomLibrary.DateTime.Converters;
+
+public class TimeOnlyConverter : JsonConverter<TimeOnly>
+{
+    public override TimeOnly Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        var value = reader.GetString();
+        return TimeOnly.Parse(value!);
+    }
+
+    public override void Write(Utf8JsonWriter writer, TimeOnly value, JsonSerializerOptions options)
+        => writer.WriteStringValue(value.ToString("HH:mm:ss.fff"));
+}

src/NET6CustomLibrary/DateTime/Converters/UtcDateTimeConverter.cs

@@ -0,0 +1,21 @@
+namespace NET6CustomLibrary.DateTime.Converters;
+
+public class UtcDateTimeConverter : JsonConverter<System.DateTime>
+{
+    private readonly string serializationFormat;
+
+    public UtcDateTimeConverter() : this(null)
+    {
+    }
+
+    public UtcDateTimeConverter(string serializationFormat)
+    {
+        this.serializationFormat = serializationFormat ?? "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffff'Z'";
+    }
+
+    public override System.DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        => reader.GetDateTime().ToUniversalTime();
+
+    public override void Write(Utf8JsonWriter writer, System.DateTime value, JsonSerializerOptions options)
+        => writer.WriteStringValue((value.Kind == DateTimeKind.Local ? value.ToUniversalTime() : value).ToString(serializationFormat));
+}

src/NET6CustomLibrary/DateTime/TypeConverters/DateOnlyTypeConverter.cs

@@ -0,0 +1,47 @@
+using System.ComponentModel;
+using System.Globalization;
+
+namespace NET6CustomLibrary.DateTime.TypeConverters;
+
+public class DateOnlyTypeConverter : TypeConverter
+{
+    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+    {
+        if (sourceType == typeof(string))
+        {
+            return true;
+        }
+
+        return base.CanConvertFrom(context, sourceType);
+    }
+
+    public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+    {
+        if (destinationType == typeof(string))
+        {
+            return true;
+        }
+
+        return base.CanConvertTo(context, destinationType);
+    }
+
+    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+    {
+        if (value is string input)
+        {
+            return DateOnly.Parse(input);
+        }
+
+        return base.ConvertFrom(context, culture, value);
+    }
+
+    public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+    {
+        if (destinationType == typeof(string) && value is DateOnly dateOnly)
+        {
+            return dateOnly.ToString();
+        }
+
+        return base.ConvertTo(context, culture, value, destinationType);
+    }
+}

src/NET6CustomLibrary/DateTime/TypeConverters/TimeOnlyTypeConverter.cs

@@ -0,0 +1,47 @@
+using System.ComponentModel;
+using System.Globalization;
+
+namespace NET6CustomLibrary.DateTime.TypeConverters;
+
+public class TimeOnlyTypeConverter : TypeConverter
+{
+    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+    {
+        if (sourceType == typeof(string))
+        {
+            return true;
+        }
+
+        return base.CanConvertFrom(context, sourceType);
+    }
+
+    public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+    {
+        if (destinationType == typeof(string))
+        {
+            return true;
+        }
+
+        return base.CanConvertTo(context, destinationType);
+    }
+
+    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+    {
+        if (value is string input)
+        {
+            return TimeOnly.Parse(input);
+        }
+
+        return base.ConvertFrom(context, culture, value);
+    }
+
+    public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+    {
+        if (destinationType == typeof(string) && value is TimeOnly timeOnly)
+        {
+            return timeOnly.ToString();
+        }
+
+        return base.ConvertTo(context, culture, value, destinationType);
+    }
+}

src/NET6CustomLibrary/Docs/README-DateTimeOnly.md

@@ -0,0 +1,41 @@
+# Date and Time only configuration
+
+
+## Registering services at Startup
+
+```csharp
+public Startup(IConfiguration configuration)
+{
+  Configuration = configuration;
+}
+
+public IConfiguration Configuration { get; }
+	
+public void ConfigureServices(IServiceCollection services)
+{
+  TypeDescriptor.AddAttributes(typeof(DateOnly), new TypeConverterAttribute(typeof(DateOnlyTypeConverter)));
+  TypeDescriptor.AddAttributes(typeof(TimeOnly), new TypeConverterAttribute(typeof(TimeOnlyTypeConverter)));
+
+  services.AddControllers()
+    .AddDateTimeJsonOptions();
+}
+```
+
+
+## Added options in swagger configuration
+```csharp
+public void ConfigureServices(IServiceCollection services)
+{
+  services.AddSwaggerGen(options =>
+    {
+      options.SwaggerDoc("v1", new OpenApiInfo
+      {
+          //OMISSIS
+      });
+
+      options.AddDateTimeSwaggerGenOptions();
+
+      //OMISSIS
+    });
+}
+```

src/NET6CustomLibrary/Extensions/DependencyInjection.cs

@@ -0,0 +1,101 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.OpenApi.Any;
+using Microsoft.OpenApi.Models;
+using NET6CustomLibrary.DateTime.Converters;
+using NET6CustomLibrary.Serilog.Services;
+using Serilog;
+using Swashbuckle.AspNetCore.SwaggerGen;
+
+namespace NET6CustomLibrary.Extensions;
+
+public static class DependencyInjection
+{
+    #region "SERILOG"
+    public static IServiceCollection AddSerilogServices(this IServiceCollection services)
+    {
+        services.AddTransient<ILoggerService, LoggerService>();
+
+        return services;
+    }
+
+    public static WebApplication AddSerilogConfigureServices(this WebApplication application)
+    {
+        application.UseSerilogRequestLogging(options =>
+        {
+            options.IncludeQueryInRequestPath = true;
+        });
+
+        return application;
+    }
+
+    public static WebApplicationBuilder AddSerilogOptionsBuilder(this WebApplicationBuilder builder)
+    {
+        builder.Host.UseSerilog((hostingContext, loggerConfiguration) =>
+        {
+            loggerConfiguration.ReadFrom.Configuration(hostingContext.Configuration);
+        });
+
+        return builder;
+    }
+    #endregion
+
+    #region "MULTI LANGUAGE"
+    public static IServiceCollection AddSupportedCultures(this IServiceCollection services, string[] cultures)
+    {
+        var supportedCultures = cultures;
+        var localizationOptions = new RequestLocalizationOptions()
+            .AddSupportedCultures(supportedCultures)
+            .AddSupportedUICultures(supportedCultures)
+            .SetDefaultCulture(supportedCultures[0]);
+
+        services.Configure<RequestLocalizationOptions>(options =>
+        {
+            options.SupportedCultures = localizationOptions.SupportedCultures;
+            options.SupportedUICultures = localizationOptions.SupportedUICultures;
+            options.DefaultRequestCulture = localizationOptions.DefaultRequestCulture;
+        });
+
+        return services;
+    }
+
+    public static WebApplication UseLocalizationConfiguration(this WebApplication app)
+    {
+        app.UseRequestLocalization();
+
+        return app;
+    }
+    #endregion
+
+    #region "DATE and TIME ONLY"
+    public static IMvcBuilder AddDateTimeJsonOptions(this IMvcBuilder builder)
+    {
+        builder.AddJsonOptions(options =>
+        {
+            options.JsonSerializerOptions.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull;
+            options.JsonSerializerOptions.Converters.Add(new DateOnlyConverter());
+            options.JsonSerializerOptions.Converters.Add(new TimeOnlyConverter());
+            options.JsonSerializerOptions.Converters.Add(new UtcDateTimeConverter());
+        });
+
+        return builder;
+    }
+
+    public static SwaggerGenOptions AddDateTimeSwaggerGenOptions(this SwaggerGenOptions options)
+    {
+        options.MapType<DateOnly>(() => new OpenApiSchema
+        {
+            Type = "string",
+            Format = "date"
+        });
+
+        options.MapType<TimeOnly>(() => new OpenApiSchema
+        {
+            Type = "string",
+            Format = "time",
+            Example = new OpenApiString(TimeOnly.FromDateTime(System.DateTime.Now).ToString("HH:mm:ss"))
+        });
+
+        return options;
+    }
+    #endregion
+}