MireaBackend/SqlData/Persistence/DependencyInjection.cs

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Mirea.Api.DataAccess.Application.Interfaces.DbContexts.Schedule;
using Mirea.Api.DataAccess.Domain.Schedule;
using Mirea.Api.DataAccess.Persistence.Common;
using Mirea.Api.DataAccess.Persistence.Contexts.Schedule;
using Mirea.Api.DataAccess.Persistence.EntityTypeConfigurations;
using System;
using System.Linq;
using System.Reflection;

namespace Mirea.Api.DataAccess.Persistence;

public static class DependencyInjection
{
    public static IServiceCollection AddPersistence(this IServiceCollection services, DatabaseProvider dbProvider, string connection)
    {
        services.AddDbContext<CampusDbContext>(options =>
            UseDatabase(options).CreateDbContext<CampusDbContext, Campus>(dbProvider));
        services.AddDbContext<DisciplineDbContext>(options =>
            UseDatabase(options).CreateDbContext<DisciplineDbContext, Discipline>(dbProvider));
        services.AddDbContext<FacultyDbContext>(options =>
            UseDatabase(options).CreateDbContext<FacultyDbContext, Faculty>(dbProvider));
        services.AddDbContext<GroupDbContext>(options =>
            UseDatabase(options).CreateDbContext<GroupDbContext, Group>(dbProvider));
        services.AddDbContext<LectureHallDbContext>(options =>
            UseDatabase(options).CreateDbContext<LectureHallDbContext, LectureHall>(dbProvider));
        services.AddDbContext<LessonAssociationDbContext>(options =>
            UseDatabase(options).CreateDbContext<LessonAssociationDbContext, LessonAssociation>(dbProvider));
        services.AddDbContext<ProfessorDbContext>(options =>
            UseDatabase(options).CreateDbContext<ProfessorDbContext, Professor>(dbProvider));
        services.AddDbContext<LessonDbContext>(options =>
            UseDatabase(options).CreateDbContext<LessonDbContext, Lesson>(dbProvider));
        services.AddDbContext<TypeOfOccupationDbContext>(options =>
            UseDatabase(options).CreateDbContext<TypeOfOccupationDbContext, TypeOfOccupation>(dbProvider));
        services.AddDbContext<SpecificWeekDbContext>(options =>
            UseDatabase(options).CreateDbContext<SpecificWeekDbContext, SpecificWeek>(dbProvider));

        services.AddDbContext<UberDbContext>(options =>
        {
            var providerNamespace = typeof(Mark).Namespace + "." + Enum.GetName(dbProvider);

            var assembly = Assembly.GetExecutingAssembly();
            var configurationTypes = assembly.GetTypes()
                .Where(t =>
                    t is { IsNested: false, IsAbstract: false, Namespace: not null } &&
                    t.Namespace.StartsWith(providerNamespace) &&
                    t.GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEntityTypeConfiguration<>)));

            var modelBuilder = new ModelBuilder();

            foreach (var configurationType in configurationTypes)
            {
                var configurationInstance = Activator.CreateInstance(configurationType)!;
                modelBuilder.ApplyConfiguration(configurationInstance);
            }

            var dbContext = (UberDbContext)Activator.CreateInstance(typeof(UberDbContext), (DbContextOptions<UberDbContext>)UseDatabase(options).Options)!;
            dbContext.ApplyConfigurations(modelBuilder);
        });

        services.AddScoped<ICampusDbContext>(provider => provider.GetRequiredService<CampusDbContext>());
        services.AddScoped<IDisciplineDbContext>(provider => provider.GetRequiredService<DisciplineDbContext>());
        services.AddScoped<IFacultyDbContext>(provider => provider.GetRequiredService<FacultyDbContext>());
        services.AddScoped<IGroupDbContext>(provider => provider.GetRequiredService<GroupDbContext>());
        services.AddScoped<ILectureHallDbContext>(provider => provider.GetRequiredService<LectureHallDbContext>());
        services.AddScoped<ILessonAssociationDbContext>(provider => provider.GetRequiredService<LessonAssociationDbContext>());
        services.AddScoped<IProfessorDbContext>(provider => provider.GetRequiredService<ProfessorDbContext>());
        services.AddScoped<ILessonDbContext>(provider => provider.GetRequiredService<LessonDbContext>());
        services.AddScoped<ITypeOfOccupationDbContext>(provider => provider.GetRequiredService<TypeOfOccupationDbContext>());
        services.AddScoped<ISpecificWeekDbContext>(provider => provider.GetRequiredService<SpecificWeekDbContext>());

        return services;

        DbContextOptionsBuilder UseDatabase(DbContextOptionsBuilder options)
        {
            return dbProvider switch
            {
                DatabaseProvider.Mysql => options.UseMySql(connection, ServerVersion.AutoDetect(connection),
                    x => x.MigrationsAssembly("MysqlMigrations")),
                DatabaseProvider.Sqlite => options.UseSqlite(connection,
                    x => x.MigrationsAssembly("SqliteMigrations")),
                DatabaseProvider.Postgresql => options.UseNpgsql(connection,
                    x => x.MigrationsAssembly("PsqlMigrations")),
                _ => throw new ArgumentException("Unsupported database provider", Enum.GetName(dbProvider))
            };
        }
    }

    public static IHealthChecksBuilder AddDatabaseHealthCheck(this IHealthChecksBuilder healthChecksBuilder, DatabaseProvider dbProvider, string connection)
    {
        return dbProvider switch
        {
            DatabaseProvider.Mysql => healthChecksBuilder.AddMySql(connection, name: "MySql"),
            DatabaseProvider.Sqlite => healthChecksBuilder.AddSqlite(connection, name: "Sqlite"),
            DatabaseProvider.Postgresql => healthChecksBuilder.AddNpgSql(connection, name: "PostgreSQL"),
            _ => throw new ArgumentException("Unsupported database provider", Enum.GetName(dbProvider))
        };
    }
}