Initialize Microservice Project - Skills Guide¶

<Project>
    <PropertyGroup>
        <LangVersion>latest</LangVersion>
        <Version>1.0.0</Version>
        <NoWarn>$(NoWarn);CS1591</NoWarn>
        <NuGetAudit>false</NuGetAudit>
        <ImplicitUsings>enable</ImplicitUsings>
        <Nullable>enable</Nullable>
        <AbpProjectType>service-nolayer</AbpProjectType>
    </PropertyGroup>
</Project>

[*.csproj]
indent_size = 2

<Project Sdk="Microsoft.NET.Sdk.Web">
  <Import Project="..\common.props" />
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <GenerateDocumentationFile>true</GenerateDocumentationFile>
    <CopyLocalLockFileAssemblies>True</CopyLocalLockFileAssemblies>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.5">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>   
    <PackageReference Include="Serilog.AspNetCore" Version="9.0.0" />
    <PackageReference Include="Serilog.Extensions.Logging" Version="9.0.2" />
    <PackageReference Include="Serilog.Sinks.Async" Version="2.1.0" />
    <PackageReference Include="Serilog.Sinks.File" Version="7.0.0" />
    <PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />
    <PackageReference Include="Serilog.Sinks.ElasticSearch" Version="10.0.0" />
    <PackageReference Include="Serilog.Sinks.OpenTelemetry" Version="4.2.0" />
    <PackageReference Include="AspNetCore.HealthChecks.UI" Version="9.0.0" />
    <PackageReference Include="AspNetCore.HealthChecks.UI.Client" Version="9.0.0" />
    <PackageReference Include="AspNetCore.HealthChecks.UI.InMemory.Storage" Version="9.0.0" />
    <PackageReference Include="Microsoft.AspNetCore.DataProtection.StackExchangeRedis" Version="10.0.5" />
    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="10.0.5" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="10.0.5" />
    <PackageReference Include="prometheus-net.AspNetCore" Version="8.2.1" />
    <PackageReference Include="DistributedLock.Redis" Version="1.1.0" />
    <PackageReference Include="KubernetesClient" Version="18.0.5" />
    <PackageReference Include="IdentityModel" Version="7.0.0" />
  </ItemGroup>

  <!-- Service Dependencies -->

  <ItemGroup>
    <PackageReference Include="Volo.Abp.EntityFrameworkCore.PostgreSql" Version="10.1.1" />
    <PackageReference Include="Volo.Abp.AspNetCore.Mvc.UI.MultiTenancy" Version="10.1.1" />
    <PackageReference Include="Volo.Abp.AspNetCore.Authentication.JwtBearer" Version="10.1.1" />
    <PackageReference Include="Volo.Abp.Autofac" Version="10.1.1" />
    <PackageReference Include="Volo.Abp.AspNetCore.Serilog" Version="10.1.1" />
    <PackageReference Include="Volo.Abp.Swashbuckle" Version="10.1.1" />
    <PackageReference Include="Volo.Abp.EventBus.RabbitMQ" Version="10.1.1" />
    <PackageReference Include="Volo.Abp.My.RabbitMQ" Version="10.1.1" />
    <PackageReference Include="Volo.Abp.DistributedLocking" Version="10.1.1" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="Volo.Abp.FeatureManagement.EntityFrameworkCore" Version="10.1.1" />
    <PackageReference Include="Volo.Abp.PermissionManagement.EntityFrameworkCore" Version="10.1.1" />
    <PackageReference Include="Volo.Abp.SettingManagement.EntityFrameworkCore" Version="10.1.1" />
    <PackageReference Include="Volo.Abp.LanguageManagement.EntityFrameworkCore" Version="10.1.1" />
    <PackageReference Include="Volo.Abp.BlobStoring.Database.EntityFrameworkCore" Version="10.1.1" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="GridLab.Gmss.TenantManagement.EntityFrameworkCore" Version="10.1.1.*" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="GridLab.Gmss.AuditLogging.EntityFrameworkCore" Version="10.1.1.*" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="Volo.Abp.Studio.Client.AspNetCore" Version="2.2.4" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="../GridLab.Gmss.MyService.Contracts/GridLab.Gmss.MyService.Contracts.csproj" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\..\..\aspire\GridLab.Gmss.ServiceDefaults\GridLab.Gmss.ServiceDefaults.csproj" />
  </ItemGroup>

  <ItemGroup>
    <Compile Remove="Logs\**" />
    <Content Remove="Logs\**" />
    <EmbeddedResource Remove="Logs\**" />
    <None Remove="Logs\**" />
  </ItemGroup>

  <ItemGroup>
    <Content Remove="ClientProxies\**\*.json" />
    <EmbeddedResource Include="ClientProxies\**\*.json" />
  </ItemGroup>

</Project>
````

### Step 2: Add `Program.cs`

Configure application startup with Serilog, Elasticsearch logging, and OpenTelemetry:

```cs
public class Program
{
    public static async Task<int> Main(string[] args)
    {
        Log.Logger = new LoggerConfiguration()
            .WriteTo.Async(c => c.File("Logs/logs.txt"))
            .WriteTo.Async(c => c.Console())
            .CreateBootstrapLogger();

        try
        {
            Log.Information($"Starting {GetCurrentAssemblyName()}");

            AbpStudioEnvironmentVariableLoader.Load();

            var builder = WebApplication.CreateBuilder(args);

            builder.AddServiceDefaults();

            builder.Host
                .AddAppSettingsSecretsJson()
                .UseAutofac()
                .UseSerilog((context, services, loggerConfiguration) =>
                {
                    var applicationName = services.GetRequiredService<IApplicationInfoAccessor>().ApplicationName;

                    loggerConfiguration
                        .ReadFrom.Configuration(context.Configuration)
                        .ReadFrom.Services(services)
                        .Enrich.WithProperty("Application", applicationName)
                        .If(context.Configuration.GetValue<bool>("ElasticSearch:IsLoggingEnabled"), c =>
                            c.WriteTo.Elasticsearch(
                                new ElasticsearchSinkOptions(new Uri(context.Configuration["ElasticSearch:Url"]!))
                                {
                                    AutoRegisterTemplate = true,
                                    AutoRegisterTemplateVersion = AutoRegisterTemplateVersion.ESv6,
                                    IndexFormat = "Gmss-log-{0:yyyy.MM}" 
                                })
                        )
                        .WriteTo.Async(c => c.OpenTelemetry())
                        .WriteTo.Async(c => c.AbpStudio(services));
                });

            await builder.AddApplicationAsync<GmssMyServiceModule>();

            var app = builder.Build();

            await app.InitializeApplicationAsync();
            await app.RunAsync();

            Log.Information($"Stopped {GetCurrentAssemblyName()}");

            return 0;
        }
        catch (HostAbortedException)
        {
            /* Ignoring this exception because: https://github.com/dotnet/efcore/issues/29809#issuecomment-1345132260 */
            return 2;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"{GetCurrentAssemblyName()} terminated unexpectedly!");
            Console.WriteLine(ex.ToString());
            Console.WriteLine(ex.StackTrace ?? "");

            Log.Fatal(ex, $"{GetCurrentAssemblyName()} terminated unexpectedly!");
            Log.Fatal(ex.Message);
            Log.Fatal(ex.StackTrace ?? "");
            return 1;
        }
        finally
        {
            await Log.CloseAndFlushAsync();
        }
    }

    private static string GetCurrentAssemblyName()
    {
        return typeof(Program).Assembly.GetName().Name!;
    }
}

{
  "App": {
    "EnablePII": true
  }
}

{
  "ConnectionStrings": {
    "AdministrationService": "Host=localhost;Port=5432;Database=Gmss_Administration;User ID=postgres;Password=myPassword;Timeout=240;",
    "AbpBlobStoring": "Host=localhost;Port=5432;Database=Gmss_BlobStoring;User ID=postgres;Password=myPassword;Timeout=240;",
    "AuditLoggingService": "Host=localhost;Port=5432;Database=Gmss_AuditLogging;User ID=postgres;Password=myPassword;Timeout=240;",
    "TenantManagementService": "Host=localhost;Port=5432;Database=Gmss_TenantManagement;User ID=postgres;Password=myPassword;Timeout=240;",
    "MyService": "Host=localhost;Port=5432;Database=Gmss_My;User ID=postgres;Password=myPassword;Timeout=240;"
  },
  "App": {
    "CorsOrigins": "http://localhost:44310",
    "EnablePII": false,
    "HealthCheckUrl": "/health-status"
  },
  "Swagger": {
    "IsEnabled": true
  },
  "AuthServer": {
    "Authority": "http://localhost:44346",
    "MetaAddress": "http://localhost:44346",
    "RequireHttpsMetadata": false,
    "SwaggerClientId": "SwaggerTestUI",
    "Audience": "MyService"
  },
  "Redis": {
    "Configuration": "localhost:6379"
  },
  "RabbitMQ": {
    "Connections": {
      "Default": {
        "HostName": "localhost"
      }
    },
    "EventBus": {
      "ClientName": "Gmss_MyService",
      "ExchangeName": "Gmss"
    }
  },
  "RemoteServices": {},
  "AbpDistributedCache": {
    "KeyPrefix": "Gmss:"
  },
  "DataProtection": {
    "ApplicationName": "Gmss",
    "Keys": "Gmss-Protection-Keys"
  },
  "ElasticSearch": {
    "IsLoggingEnabled": true,
    "Url": "http://localhost:9200"
  },
  "StringEncryption": {
    "DefaultPassPhrase": "ENaTKK5o6BglpUjM"
  }
}

[ConnectionStringName(DatabaseName)]
public class MyServiceDbContext :
    AbpDbContext<MyServiceDbContext>,
    IHasEventInbox,
    IHasEventOutbox
{
    public const string DbTablePrefix = "";
    public const string DbSchema = null;

    public const string DatabaseName = "MyService";

    public DbSet<IncomingEventRecord> IncomingEvents { get; set; }

    public DbSet<OutgoingEventRecord> OutgoingEvents { get; set; }

    public MyServiceDbContext(DbContextOptions<MyServiceDbContext> options) 
        : base(options)
    {
    }

    protected override void OnModelCreating(ModelBuilder builder)
    {
        base.OnModelCreating(builder);

        builder.ConfigureEventInbox();
        builder.ConfigureEventOutbox();
    }
}

public class MyServiceDatabaseMigrationEventHandler : EfCoreDatabaseMigrationEventHandlerBase<MyServiceDbContext>
{
    private readonly MyServiceDataSeeder _dataSeeder;

    public MyServiceDatabaseMigrationEventHandler(
        ILoggerFactory loggerFactory,
        ICurrentTenant currentTenant,
        IUnitOfWorkManager unitOfWorkManager,
        ITenantStore tenantStore,
        IAbpDistributedLock abpDistributedLock,
        IDistributedEventBus distributedEventBus,
        MyServiceDataSeeder dataSeeder
    ) : base(
        MyServiceDbContext.DatabaseName,
        currentTenant,
        unitOfWorkManager,
        tenantStore,
        abpDistributedLock,
        distributedEventBus,
        loggerFactory)
    {
        _dataSeeder = dataSeeder;
    }

    protected override async Task SeedAsync(Guid? tenantId)
    {
        await _dataSeeder.SeedAsync(tenantId);
    }
}

    public class BackgroundJobsServiceDataSeeder : ITransientDependency
    {
        private readonly ILogger<BackgroundJobsServiceDataSeeder> _logger;

        public BackgroundJobsServiceDataSeeder(
            ILogger<BackgroundJobsServiceDataSeeder> logger)
        {
            _logger = logger;
        }

        public async Task SeedAsync(Guid? tenantId = null)
        {
            _logger.LogInformation("Seeding data...");

            //...
        }
    }

namespace GridLab.Gmss.MyService.Data;

/* This class is needed for EF Core console commands
 * (like Add-Migration and Update-Database commands)
 * */
public class MyServiceDbContextFactory : IDesignTimeDbContextFactory<MyServiceDbContext>
{
    [ModuleInitializer]
    public static void Initialize()
    {
        // https://www.npgsql.org/efcore/release-notes/6.0.html#opting-out-of-the-new-timestamp-mapping-logic
        AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);
    }

    public MyServiceDbContext CreateDbContext(string[] args)
    {
        var builder = new DbContextOptionsBuilder<MyServiceDbContext>()
            .UseNpgsql(GetConnectionStringFromConfiguration(), b =>
            {
                b.MigrationsHistoryTable("__MyService_Migrations");
            });

        return new MyServiceDbContext(builder.Options);
    }

    private static string GetConnectionStringFromConfiguration()
    {
        return BuildConfiguration().GetConnectionString(MyServiceDbContext.DatabaseName)
               ?? throw new ApplicationException($"Could not find a connection string named '{MyServiceDbContext.DatabaseName}'.");
    }

    private static IConfigurationRoot BuildConfiguration()
    {
        var builder = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json", optional: false)
            .AddEnvironmentVariables();

        return builder.Build();
    }
}

public class MyServiceRuntimeDatabaseMigrator : EfCoreRuntimeDatabaseMigratorBase<MyServiceDbContext>
{
    private readonly MyServiceDataSeeder _dataSeeder;

    public MyServiceRuntimeDatabaseMigrator(
        ILoggerFactory loggerFactory,
        IUnitOfWorkManager unitOfWorkManager,
        IServiceProvider serviceProvider,
        ICurrentTenant currentTenant,
        IAbpDistributedLock abpDistributedLock,
        IDistributedEventBus distributedEventBus,
        MyServiceDataSeeder dataSeeder
    ) : base(
        MyServiceDbContext.DatabaseName,
        unitOfWorkManager,
        serviceProvider,
        currentTenant,
        abpDistributedLock,
        distributedEventBus,
        loggerFactory)
    {
        _dataSeeder = dataSeeder;
    }

    protected override async Task SeedAsync()
    {
        await _dataSeeder.SeedAsync();
    }
}

public static class HealthChecksBuilderExtensions
{
    public static void AddBackgroundJobsServiceHealthChecks(this IServiceCollection services)
    {
        // Add your health checks here
        var healthChecksBuilder = services.AddHealthChecks();
        healthChecksBuilder.AddCheck<BackgroundJobsCheck>("Background Jobs Service Check", tags: ["background-jobs"]);

        var configuration = services.GetConfiguration();
        var healthCheckUrl = configuration["App:HealthCheckUrl"];

        if (string.IsNullOrEmpty(healthCheckUrl))
        {
            healthCheckUrl = "/health-status";
        }

        services.ConfigureHealthCheckEndpoint(healthCheckUrl);

        var healthChecksUiBuilder = services.AddHealthChecksUI(settings =>
        {
            settings.AddHealthCheckEndpoint("Background Jobs Service Health Status", configuration["App:HealthUiCheckUrl"] ?? healthCheckUrl);
        });

        // Set your HealthCheck UI Storage here
        healthChecksUiBuilder.AddInMemoryStorage();

        services.MapHealthChecksUiEndpoints(options =>
        {
            options.UIPath = "/health-ui";
            options.ApiPath = "/health-api";
        });
    }

    private static IServiceCollection ConfigureHealthCheckEndpoint(this IServiceCollection services, string path)
    {
        services.Configure<AbpEndpointRouterOptions>(options =>
        {
            options.EndpointConfigureActions.Add(endpointContext =>
            {
                endpointContext.Endpoints.MapHealthChecks(
                    new PathString(path.EnsureStartsWith('/')),
                    new HealthCheckOptions
                    {
                        Predicate = _ => true,
                        ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse,
                        AllowCachingResponses = false,
                    });
            });
        });

        return services;
    }

    private static IServiceCollection MapHealthChecksUiEndpoints(this IServiceCollection services, Action<global::HealthChecks.UI.Configuration.Options>? setupOption = null)
    {
        services.Configure<AbpEndpointRouterOptions>(routerOptions =>
        {
            routerOptions.EndpointConfigureActions.Add(endpointContext =>
            {
                endpointContext.Endpoints.MapHealthChecksUI(setupOption);
            });
        });

        return services;
    }
}

public class GmssMetrics : ISingletonDependency
{
    public const string MeterName = "Gmss.Api";

    private readonly Counter<long> _helloRequestCounter;

    public GmssMetrics(IMeterFactory meterFactory)
    {
        var meter = meterFactory.Create(MeterName);
        _helloRequestCounter = meter.CreateCounter<long>("hello_requests.count");
    }

    public void IncrementHelloCounter()
    {
        _helloRequestCounter.Add(1);
    }
}

[Route("api/my/demo")]
[Area("my")]
[RemoteService(Name = "MyService")]
public class DemoController : AbpController
{
    private readonly GmssMetrics _gmssMetrics;

    public DemoController(GmssMetrics gmssMetrics)
    {
        _gmssMetrics = gmssMetrics;
    }

    [HttpGet]
    [Route("hello")]
    public async Task<string> HelloWorld()
    {
        _gmssMetrics.IncrementHelloCounter();
        return await Task.FromResult("Hello World!");
    }

    [HttpGet]
    [Route("hello-authorized")]
    [Authorize]
    public async Task<string> HelloWorldAuthorized()
    {
        return await Task.FromResult("Hello World (Authorized)!");
    }
}

[RemoteService(false)]
public class HomeController : AbpController
{
    public ActionResult Index()
    {
        return Redirect("~/swagger");
    }
}

{
  "$schema": "https://json.schemastore.org/launchsettings.json",
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:443XY"
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "GridLab.Gmss.CimService": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "http://localhost:443XY",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

dotnet ef migrations add Initial --context BackgroundJobsServiceDbContext --output-dir Migrations

  <Import Project="..\common.props" />

  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <RootNamespace>GridLab.Gmss.MyService</RootNamespace>
    <GenerateEmbeddedFilesManifest>true</GenerateEmbeddedFilesManifest>
    <CopyLocalLockFileAssemblies>True</CopyLocalLockFileAssemblies>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.Extensions.FileProviders.Embedded" Version="10.0.5" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="Volo.Abp.UI" Version="10.1.1" />
    <PackageReference Include="Volo.Abp.Validation" Version="10.1.1" />
    <PackageReference Include="Volo.Abp.Authorization.Abstractions" Version="10.1.1" />
    <PackageReference Include="Volo.Abp.Ddd.Application.Contracts" Version="10.1.1" />
    <PackageReference Include="Volo.Abp.Ddd.Domain.Shared" Version="10.1.1" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="GridLab.Gmss.My.Application.Contracts" Version="10.1.1.*" />
  </ItemGroup>

  <ItemGroup>
    <EmbeddedResource Include="Localization\MyService\*.json" />
    <Content Remove="Localization\MyService\*.json" />
  </ItemGroup>

using Localization.Resources.AbpUi;
using GridLab.Gmss.MyService.Localization;
using Volo.Abp.Application;
using Volo.Abp.Authorization;
using Volo.Abp.Domain;
using Volo.Abp.Localization;
using Volo.Abp.Localization.ExceptionHandling;
using Volo.Abp.Modularity;
using Volo.Abp.UI;
using Volo.Abp.Validation;
using Volo.Abp.Validation.Localization;
using Volo.Abp.VirtualFileSystem;
using GridLab.Gmss.My;

namespace GridLab.Gmss.MyService;

[DependsOn(
    typeof(AbpValidationModule),
    typeof(AbpUiModule),
    typeof(AbpAuthorizationAbstractionsModule),
    typeof(AbpDddApplicationContractsModule),
    typeof(MyApplicationContractsModule),
    typeof(AbpDddDomainSharedModule)
)]
public class GmssMyServiceContractsModule : AbpModule
{
    public override void ConfigureServices(ServiceConfigurationContext context)
    {
        Configure<AbpVirtualFileSystemOptions>(options =>
        {
            options.FileSets.AddEmbedded<GmssMyServiceContractsModule>();
        });

        Configure<AbpLocalizationOptions>(options =>
        {
            options.Resources
                .Add<MyServiceResource>("en")
                .AddBaseTypes(typeof(AbpValidationResource), typeof(AbpUiResource))
                .AddVirtualJson("/Localization/MyService");
        });

        Configure<AbpExceptionLocalizationOptions>(options =>
        {
            options.MapCodeNamespace("MyService", typeof(MyServiceResource));
        });
    }
}

GridLab.Gmss.MyService.Contracts/
└── Localization/
    └── MyService/
        ├── en.json
        └── ... (other languages)

{
  "culture": "en",
  "texts": {
    "MyService": "My Service"
  }
}

  <Import Project="..\common.props" />
  <PropertyGroup>
    <Version>1.0.0</Version>
    <TargetFramework>net10.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
    <PackageReference Include="NSubstitute" Version="5.3.0" />
    <PackageReference Include="NSubstitute.Analyzers.CSharp" Version="1.0.17">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
    </PackageReference>
    <PackageReference Include="Shouldly" Version="4.3.0" />
    <PackageReference Include="xunit" Version="2.9.3" />
    <PackageReference Include="xunit.extensibility.execution" Version="2.9.3" />
    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.4" />
    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="10.0.5" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="Volo.Abp.AspNetCore.TestBase" Version="10.1.1" />
    <PackageReference Include="Volo.Abp.EntityFrameworkCore.Sqlite" Version="10.1.1" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\GridLab.Gmss.MyService\GridLab.Gmss.MyService.csproj" />
  </ItemGroup>

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using GridLab.Gmss.MyService.Data;
using Volo.Abp;
using Volo.Abp.AspNetCore.TestBase;
using Volo.Abp.My;
using Volo.Abp.BackgroundWorkers;
using Volo.Abp.Caching;
using Volo.Abp.DistributedLocking;
using Volo.Abp.EventBus;
using Volo.Abp.FeatureManagement;
using Volo.Abp.Modularity;
using Volo.Abp.PermissionManagement;
using Volo.Abp.SettingManagement;
using Volo.Abp.Uow;
using Microsoft.Data.Sqlite;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Storage;
using Volo.Abp.EntityFrameworkCore;
using Volo.Abp.EntityFrameworkCore.Sqlite;
using Volo.Abp.SettingManagement.EntityFrameworkCore;
using Volo.Abp.PermissionManagement.EntityFrameworkCore;
using Volo.Abp.FeatureManagement.EntityFrameworkCore;
using Volo.Abp.BlobStoring.Database.EntityFrameworkCore;

namespace GridLab.Gmss.MyService.Tests;

/* This project has a dotnet project reference to the GridLab.Gmss.MyService project,
 * but it does not have a module dependency to the GmssMyServiceModule module class.
 * Because, GmssMyServiceModule has configurations proper for development and production
 * environments, but not proper or necessary for tests.
 *
 * In this test project, we are carefully depending on the modules that we need in tests.
 *
 * For example, GmssMyServiceModule depends on AbpEventBusRabbitMqModule,
 * but this module depends on AbpEventBusModule since we don't want to use RabbitMQ in tests.
 * AbpEventBusModule has an in-process event bus instead of a real distributed event bus, and it is fine for tests.
 *
 * WARNING: If you change GmssMyServiceModule class, you may need to properly change this class to keep
 *          test code compatible with the application code.
 */
[DependsOn(
    typeof(AbpAspNetCoreTestBaseModule),
    typeof(AbpEntityFrameworkCoreSqliteModule),
    typeof(BlobStoringDatabaseEntityFrameworkCoreModule),
    typeof(AbpSettingManagementEntityFrameworkCoreModule),
    typeof(AbpPermissionManagementEntityFrameworkCoreModule),
    typeof(AbpFeatureManagementEntityFrameworkCoreModule),
    typeof(AbpEventBusModule),
    typeof(AbpCachingModule),
    typeof(AbpDistributedLockingAbstractionsModule)
)]
[AdditionalAssembly(typeof(GmssMyServiceModule))]
public class MyServiceTestsModule : AbpModule
{
    private SqliteConnection? _sqliteConnection;

    public override void PreConfigureServices(ServiceConfigurationContext context)
    {
        PreConfigure<AbpSqliteOptions>(x => x.BusyTimeout = null);
    }

    public override void ConfigureServices(ServiceConfigurationContext context)
    {
        var configuration = context.Services.GetConfiguration();

        ConfigureAuthorization(context);
        ConfigureDatabase(context);
        ConfigureDatabaseTransactions(context);
        ConfigureDynamicStores();
        ConfigureMy();
    }

    public override void OnApplicationInitialization(ApplicationInitializationContext context)
    {
        var app = context.GetApplicationBuilder();

        app.UseCorrelationId();
        app.UseAbpRequestLocalization();
        app.UseStaticFiles();
        app.UseRouting();
        app.UseUnitOfWork();
        app.UseConfiguredEndpoints();
    }

    public override async Task OnPostApplicationInitializationAsync(ApplicationInitializationContext context)
    {
        using var scope = context.ServiceProvider.CreateScope();
        await scope.ServiceProvider
            .GetRequiredService<MyServiceDataSeeder>()
            .SeedAsync();
    }

    public override void OnApplicationShutdown(ApplicationShutdownContext context)
    {
        _sqliteConnection?.Dispose();
    }

    private static void ConfigureAuthorization(ServiceConfigurationContext context)
    {
        /* We don't need to authorization in tests */
        context.Services.AddAlwaysAllowAuthorization();
    }

    private void ConfigureDatabase(ServiceConfigurationContext context)
    {
        _sqliteConnection = CreateDatabaseAndGetConnection();

        context.Services.AddAbpDbContext<MyServiceDbContext>(options =>
        {
            options.AddDefaultRepositories();
        });

        Configure<AbpDbContextOptions>(options =>
        {
            options.Configure(opts =>
            {
                /* Use SQLite for all EF Core DbContexts in tests */
                opts.UseSqlite(_sqliteConnection);
            });
        });
    }

    private void ConfigureDatabaseTransactions(ServiceConfigurationContext context)
    {
        context.Services.AddAlwaysDisableUnitOfWorkTransaction();

        Configure<AbpUnitOfWorkDefaultOptions>(options =>
        {
            options.TransactionBehavior = UnitOfWorkTransactionBehavior.Disabled;
        });
    }

    private void ConfigureDynamicStores()
    {
        Configure<FeatureManagementOptions>(options =>
        {
            options.SaveStaticFeaturesToDatabase = false;
            options.IsDynamicFeatureStoreEnabled = false;
        });

        Configure<PermissionManagementOptions>(options =>
        {
            options.SaveStaticPermissionsToDatabase = false;
            options.IsDynamicPermissionStoreEnabled = false;
        });

        Configure<SettingManagementOptions>(options =>
        {
            options.SaveStaticSettingsToDatabase = false;
            options.IsDynamicSettingStoreEnabled = false;
        });
    }

    private void ConfigureMy()
    {
        Configure<AbpBackgroundWorkerOptions>(options =>
        {
            options.IsEnabled = false;
        });

        Configure<AbpBackgroundJobOptions>(options =>
        {
            options.IsJobExecutionEnabled = false;
        });
    }

    private static SqliteConnection CreateDatabaseAndGetConnection()
    {
        var connection = new SqliteConnection("Data Source=:memory:");
        connection.Open();

        // MyServiceDbContext ()
        new MyServiceDbContext(
            new DbContextOptionsBuilder<MyServiceDbContext>().UseSqlite(connection).Options
        ).GetService<IRelationalDatabaseCreator>().CreateTables();

        // PermissionManagementDbContext
        new PermissionManagementDbContext(
            new DbContextOptionsBuilder<PermissionManagementDbContext>().UseSqlite(connection).Options
        ).GetService<IRelationalDatabaseCreator>().CreateTables();

        // FeatureManagementDbContext
        new FeatureManagementDbContext(
            new DbContextOptionsBuilder<FeatureManagementDbContext>().UseSqlite(connection).Options
        ).GetService<IRelationalDatabaseCreator>().CreateTables();

        // SettingManagementDbContext
        new SettingManagementDbContext(
            new DbContextOptionsBuilder<SettingManagementDbContext>().UseSqlite(connection).Options
        ).GetService<IRelationalDatabaseCreator>().CreateTables();

        // BlobStoringDbContext
        new BlobStoringDbContext(
            new DbContextOptionsBuilder<BlobStoringDbContext>().UseSqlite(connection).Options
        ).GetService<IRelationalDatabaseCreator>().CreateTables();

        return connection;
    }
}

protected virtual async Task<string> GetResponseAsStringAsync(
    string url,
    HttpStatusCode expectedStatusCode = HttpStatusCode.OK)
{
    var response = await GetResponseAsync(url, expectedStatusCode);
    return await response.Content.ReadAsStringAsync();
}

protected virtual async Task<HttpResponseMessage> GetResponseAsync(
    string url,
    HttpStatusCode expectedStatusCode = HttpStatusCode.OK)
{
    var response = await Client.GetAsync(url);
    response.StatusCode.ShouldBe(expectedStatusCode);
    return response;
}

protected virtual Task WithUnitOfWorkAsync(Func<Task> func)
{
    return WithUnitOfWorkAsync(new AbpUnitOfWorkOptions(), func);
}

protected virtual async Task WithUnitOfWorkAsync(AbpUnitOfWorkOptions options, Func<Task> action)
{
    using (var scope = ServiceProvider.CreateScope())
    {
        var uowManager = scope.ServiceProvider.GetRequiredService<IUnitOfWorkManager>();

        using (var uow = uowManager.Begin(options))
        {
            await action();
            await uow.CompleteAsync();
        }
    }
}

protected virtual Task<TResult> WithUnitOfWorkAsync<TResult>(Func<Task<TResult>> func)
{
    return WithUnitOfWorkAsync(new AbpUnitOfWorkOptions(), func);
}

protected virtual async Task<TResult> WithUnitOfWorkAsync<TResult>(AbpUnitOfWorkOptions options, Func<Task<TResult>> func)
{
    using (var scope = ServiceProvider.CreateScope())
    {
        var uowManager = scope.ServiceProvider.GetRequiredService<IUnitOfWorkManager>();

        using (var uow = uowManager.Begin(options))
        {
            var result = await func();
            await uow.CompleteAsync();
            return result;
        }
    }
}

private static string GetContentRootFolder()
{
    var assemblyDirectoryPath = Path.GetDirectoryName(typeof(GmssMyServiceModule).Assembly.Location);
    if (assemblyDirectoryPath == null)
    {
        throw new Exception($"Could not find location of {typeof(GmssMyServiceModule).Assembly.FullName} assembly!");
    }

    return assemblyDirectoryPath;
}