erp-platform/api/src/Kurs.Platform.HttpApi.Host/Program.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Kurs.Platform.Classrooms;
using Kurs.Platform.Enums;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.SignalR;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Serilog;
using Serilog.Sinks.PostgreSQL;
using static Kurs.Settings.SettingsConsts;

namespace Kurs.Platform;

public class Program
{
    public async static Task<int> Main(string[] args)
    {
        var configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json")
            .AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? ""}.json", true)
            .Build();


        var columnWriters = new Dictionary<string, ColumnWriterBase>
        {
            { "Message", new RenderedMessageColumnWriter() },
            { "Message_Template", new MessageTemplateColumnWriter() },
            { "Level", new LevelColumnWriter() },
            { "Timestamp", new TimestampColumnWriter() },
            { "Exception", new ExceptionColumnWriter() },
            { "Properties", new LogEventSerializedColumnWriter() }
        };

        var loggerConfig = new LoggerConfiguration()
            .MinimumLevel.Error()
            .WriteTo.Console(); // Konsola da log yaz

        switch (DefaultDatabaseProvider)
        {
            case DatabaseProvider.PostgreSql:
                loggerConfig = loggerConfig.WriteTo.PostgreSQL(
                    connectionString: configuration.GetConnectionString(DefaultDatabaseProvider),
                    tableName: TableNameResolver.GetFullTableName(nameof(TableNameEnum.LogEntry)),
                    columnOptions: columnWriters,
                    needAutoCreateTable: false,
                    respectCase: true
                );
                break;

            case DatabaseProvider.SqlServer:
                loggerConfig = loggerConfig.WriteTo.MSSqlServer(
                    connectionString: configuration.GetConnectionString(DefaultDatabaseProvider),
                    tableName: TableNameResolver.GetFullTableName(nameof(TableNameEnum.LogEntry)),
                    autoCreateSqlTable: false,
                    columnOptions: new Serilog.Sinks.MSSqlServer.ColumnOptions()
                );
                break;

            default:
                throw new InvalidOperationException("Unsupported database provider for logging.");
        }

        Log.Logger = loggerConfig.CreateLogger();


        try
        {
            Log.Information("Starting Kurs.Platform.HttpApi.Host.");
            var builder = WebApplication.CreateBuilder(args);
            builder.Host.AddAppSettingsSecretsJson()
                .UseAutofac()
                .UseSerilog();
            await builder.AddApplicationAsync<PlatformHttpApiHostModule>();

            var baseDomain = builder.Configuration["App:BaseDomain"]?.Trim();
            var extraOrigins = (builder.Configuration["App:CorsOrigins"] ?? "")
                .Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);

            builder.Services.AddCors(options =>
            {
                options.AddPolicy("Dynamic", policy =>
                {
                    policy
                        .AllowAnyHeader()
                        .AllowAnyMethod()
                        .AllowCredentials()
                        .SetIsOriginAllowed(origin =>
                        {
                            if (!Uri.TryCreate(origin, UriKind.Absolute, out var uri))
                                return false;

                            var scheme = uri.Scheme.ToLowerInvariant();
                            var host = uri.Host.ToLowerInvariant();

                            if (builder.Environment.IsProduction()) //IsProduction
                            {
                                if (scheme != "https") return false;

                                if (!string.IsNullOrWhiteSpace(baseDomain))
                                {
                                    var bd = baseDomain.ToLowerInvariant();
                                    if (host == bd || host.EndsWith("." + bd))
                                        return true;
                                }

                                foreach (var o in extraOrigins)
                                {
                                    if (Uri.TryCreate(o, UriKind.Absolute, out var eo)
                                        && eo.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase)
                                        && eo.Host.Equals(host, StringComparison.OrdinalIgnoreCase))
                                    {
                                        return true;
                                    }
                                }

                                return false;
                            }
                            else //IsDevelopment
                            {
                                if (scheme == "https" && (host == "localhost" || host == "127.0.0.1" || host == "[::1]")
                                    || (scheme == "http" && (host == "localhost" || host == "127.0.0.1" || host == "[::1]"))
                                    || (!string.IsNullOrWhiteSpace(baseDomain) && (host == $"dev.{baseDomain.ToLowerInvariant()}")))
                                    return true;

                                foreach (var o in extraOrigins)
                                {
                                    if (Uri.TryCreate(o, UriKind.Absolute, out var eo)
                                        && eo.Host.Equals(host, StringComparison.OrdinalIgnoreCase))
                                    {
                                        return true;
                                    }
                                }

                                return false;
                            }
                        });
                });
            });

            builder.Services.AddSingleton<IUserIdProvider, CustomUserIdProvider>();

            var app = builder.Build();
            app.UseCors("Dynamic");
            await app.InitializeApplicationAsync();
            await app.RunAsync();
            return 0;
        }
        catch (Exception ex)
        {
            if (ex is HostAbortedException)
            {
                throw;
            }

            Log.Fatal(ex, "Host terminated unexpectedly!");
            return 1;
        }
        finally
        {
            Log.CloseAndFlush();
        }
    }
}