DD.WellWorkover.Cloud/AsbCloudInfrastructure/DependencyInjection.cs

using AsbCloudApp.Data;
using AsbCloudApp.Data.SAUB;
using AsbCloudApp.Data.Subsystems;
using AsbCloudApp.Repositories;
using AsbCloudApp.Services;
using AsbCloudApp.Services.Subsystems;
using AsbCloudDb.Model;
using AsbCloudDb.Model.Subsystems;
using AsbCloudInfrastructure.Background;
using AsbCloudInfrastructure.Repository;
using AsbCloudInfrastructure.Services;
using AsbCloudInfrastructure.Services.DailyReport;
using AsbCloudInfrastructure.Services.DetectOperations;
using AsbCloudInfrastructure.Services.DrillingProgram;
using AsbCloudInfrastructure.Services.SAUB;
using AsbCloudInfrastructure.Services.Subsystems;
using AsbCloudInfrastructure.Services.WellOperationService;
using AsbCloudInfrastructure.Validators;
using FluentValidation.AspNetCore;
using Mapster;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using System;

namespace AsbCloudInfrastructure
{
    public static class DependencyInjection
    {
        public static IAsbCloudDbContext MakeContext(string connectionString)
        {
            var options = new DbContextOptionsBuilder<AsbCloudDbContext>()
                .UseNpgsql(connectionString)
                .Options;
            var context = new AsbCloudDbContext(options);
            return context;
        }

        public static void MapsterSetup()
        {
            TypeAdapterConfig.GlobalSettings.Default.Config
                .ForType<DateTimeOffset, DateTime>()
                .MapWith((source) => source.DateTime);

            TypeAdapterConfig.GlobalSettings.Default.Config
                .ForType<DateTime, DateTimeOffset>()
                .MapWith((source) => source == default ? new DateTime(0, DateTimeKind.Utc) : source);

            TypeAdapterConfig.GlobalSettings.Default.Config
                .ForType<TimeDto, TimeOnly>()
                .MapWith((source) => source == default ? default : source.MakeTimeOnly());

            TypeAdapterConfig.GlobalSettings.Default.Config
                .ForType<TimeOnly, TimeDto>()
                .MapWith((source) => new(source));

            TypeAdapterConfig.GlobalSettings.Default.Config
                .ForType<TimeOnly, TimeDto>()
                .MapWith((source) => new(source));

            TypeAdapterConfig.GlobalSettings.Default.Config
                .ForType<WellDto, Well>()
                .Ignore(dst => dst.Cluster,
                    dst => dst.RelationCompaniesWells,
                    dst => dst.Telemetry,
                    dst => dst.WellComposites,
                    dst => dst.WellCompositeSrcs,
                    dst => dst.WellOperations,
                    dst => dst.WellType);

            TypeAdapterConfig.GlobalSettings.Default.Config
                .ForType<ClusterDto, Cluster>()
                .Ignore(dst => dst.Deposit,
                    dst => dst.Wells);

            TypeAdapterConfig.GlobalSettings.Default.Config
                .ForType<FileCategoryDto, FileCategory>();

            TypeAdapterConfig.GlobalSettings.Default.Config
                .ForType<WellFinalDocumentDto, WellFinalDocument>();
        }

        public static IServiceCollection AddInfrastructure(this IServiceCollection services, IConfiguration configuration)
        {
            MapsterSetup();
            var connectionStringName = "DefaultConnection";
#if DEBUG
            connectionStringName = "DebugConnection";
#endif
            services.AddDbContext<AsbCloudDbContext>(options =>
                options.UseNpgsql(configuration.GetConnectionString(connectionStringName)));

            // TODO: переместить FluentValidation в описание моделей
            services.AddFluentValidationClientsideAdapters();

            services.AddMemoryCache();
            services.AddScoped<IAsbCloudDbContext>(provider => provider.GetService<AsbCloudDbContext>());
            services.AddScoped<IEmailService, EmailService>();

            services.AddSingleton(new WitsInfoService());
            services.AddSingleton(new InstantDataRepository());
            services.AddSingleton(provider=> TelemetryDataCache<TelemetryDataSaubDto>.GetInstance<TelemetryDataSaub>(configuration));
            services.AddSingleton(provider=> TelemetryDataCache<TelemetryDataSpinDto>.GetInstance<TelemetryDataSpin>(configuration));
            services.AddSingleton<ITelemetryTracker, TelemetryTracker>();
            services.AddSingleton<IRequerstTrackerService, RequestTrackerService>();
            services.AddSingleton<BackgroundWorker>();
            services.AddSingleton<IReduceSamplingService>(provider => ReduceSamplingService.GetInstance(configuration));

            services.AddTransient<IAuthService, AuthService>();
            services.AddTransient<IClusterService, ClusterService>();
            services.AddTransient<IProcessMapRepository, ProcessMapRepository>();
            services.AddTransient<IDrillingProgramService, DrillingProgramService>();
            services.AddTransient<IEventService, EventService>();
            services.AddTransient<FileService>();
            services.AddTransient<IMeasureService, MeasureService>();
            services.AddTransient<IMessageService, MessageService>();
            services.AddTransient<IOperationsStatService, OperationsStatService>();
            services.AddTransient<IReportService, ReportService>();
            services.AddTransient<ISetpointsService, SetpointsService>();
            services.AddTransient<ITelemetryService, TelemetryService>();
            services.AddTransient<ITelemetryUserService, TelemetryUserService>();
            services.AddTransient<ITimezoneService, TimezoneService>();
            services.AddTransient<IWellService, WellService>();
            services.AddTransient<IWellOperationImportService, WellOperationImportService>();
            services.AddTransient<IWellOperationService, WellOperationService>();
            services.AddTransient<IScheduleReportService, ScheduleReportService>();
            services.AddTransient<IDailyReportService, DailyReportService>();
            services.AddTransient<IDetectedOperationService, DetectedOperationService>();            
            services.AddTransient<ISubsystemOperationTimeService, SubsystemOperationTimeService>();
            services.AddTransient<IScheduleRepository, ScheduleRepository>();
            services.AddTransient<IRepositoryWellRelated<OperationValueDto>, CrudWellRelatedRepositoryBase<OperationValueDto, OperationValue>>();
            services.AddTransient<IUserSettingsRepository, UserSettingsRepository>();
            services.AddTransient<IWellFinalDocumentsService, WellFinalDocumentsService>();
            services.AddTransient<IFileCategoryService, FileCategoryService>();
            services.AddTransient<ILimitingParameterService, LimitingParameterService>();

            // admin crud services:
            services.AddTransient<ICrudRepository<TelemetryDto>, CrudCacheRepositoryBase<TelemetryDto, Telemetry>>(s =>
                new CrudCacheRepositoryBase<TelemetryDto, Telemetry>(
                    s.GetService<IAsbCloudDbContext>(),
                    s.GetService<IMemoryCache>(),
                    dbSet => dbSet.Include(t => t.Well))); // может быть включен в сервис TelemetryService
            services.AddTransient<ICrudRepository<DepositDto>, CrudCacheRepositoryBase<DepositDto, Deposit>>(s =>
                new CrudCacheRepositoryBase<DepositDto, Deposit>(
                    s.GetService<IAsbCloudDbContext>(),
                    s.GetService<IMemoryCache>(),
                    dbSet => dbSet.Include(d => d.Clusters)));
            services.AddTransient<ICrudRepository<CompanyDto>, CrudCacheRepositoryBase<CompanyDto, Company>>(s =>
                new CrudCacheRepositoryBase<CompanyDto, Company>(
                    s.GetService<IAsbCloudDbContext>(),
                    s.GetService<IMemoryCache>(),
                    dbSet => dbSet.Include(c => c.CompanyType)));

            services.AddTransient<ICrudRepository<CompanyTypeDto>, CrudCacheRepositoryBase<CompanyTypeDto, CompanyType>>();
            services.AddTransient<ICrudRepository<ClusterDto>, CrudCacheRepositoryBase<ClusterDto, Cluster>>(s =>
                new CrudCacheRepositoryBase<ClusterDto, Cluster>(
                    s.GetService<IAsbCloudDbContext>(),
                    s.GetService<IMemoryCache>(),
                    dbSet => dbSet
                        .Include(c => c.Wells)
                        .Include(c => c.Deposit))); // может быть включен в сервис ClusterService

            services.AddTransient<ICrudRepository<DrillerDto>, CrudCacheRepositoryBase<DrillerDto, Driller>>();

            services.AddTransient<IFileRepository, FileRepository>();
            services.AddTransient<IFileStorageRepository, FileStorageRepository>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository>();
            services.AddTransient<IUserRoleRepository, UserRoleRepository>();
            services.AddTransient<IUserRepository, UserRepository>();
            services.AddTransient<ILimitingParameterRepository, LimitingParameterRepository>();
            // Subsystem service
            services.AddTransient<ICrudRepository<SubsystemDto>, CrudCacheRepositoryBase<SubsystemDto, Subsystem>>();
            services.AddTransient<ISubsystemService, SubsystemService>();

            services.AddTransient<ICrudRepository<PermissionDto>, CrudCacheRepositoryBase<PermissionDto, Permission>>();

            // TelemetryData services
            services.AddTransient<ITelemetryDataService<TelemetryDataSaubDto>, TelemetryDataSaubService>();
            services.AddTransient<ITelemetryDataService<TelemetryDataSpinDto>, TelemetryDataSpinService>();

            // Wits
            services.AddTransient<IWitsRecordRepository<AsbCloudApp.Data.WITS.Record1Dto>, WitsRecordRepository<AsbCloudApp.Data.WITS.Record1Dto, AsbCloudDb.Model.WITS.Record1>>();
            services.AddTransient<IWitsRecordRepository<AsbCloudApp.Data.WITS.Record7Dto>, WitsRecordRepository<AsbCloudApp.Data.WITS.Record7Dto, AsbCloudDb.Model.WITS.Record7>>();
            services.AddTransient<IWitsRecordRepository<AsbCloudApp.Data.WITS.Record8Dto>, WitsRecordRepository<AsbCloudApp.Data.WITS.Record8Dto, AsbCloudDb.Model.WITS.Record8>>();
            services.AddTransient<IWitsRecordRepository<AsbCloudApp.Data.WITS.Record50Dto>, WitsRecordRepository<AsbCloudApp.Data.WITS.Record50Dto, AsbCloudDb.Model.WITS.Record50>>();
            services.AddTransient<IWitsRecordRepository<AsbCloudApp.Data.WITS.Record60Dto>, WitsRecordRepository<AsbCloudApp.Data.WITS.Record60Dto, AsbCloudDb.Model.WITS.Record60>>();
            services.AddTransient<IWitsRecordRepository<AsbCloudApp.Data.WITS.Record61Dto>, WitsRecordRepository<AsbCloudApp.Data.WITS.Record61Dto, AsbCloudDb.Model.WITS.Record61>>();

            services.AddValidators();

            return services;
        }

        public static IServiceCollection AddTransientLazy<TService, TImplementation>(this IServiceCollection services)
            where TService : class
            where TImplementation : class, TService
            => services.AddTransient<TService, TImplementation>()
            .AddTransient(provider => new Lazy<TService>(provider.GetService<TService>));

        public static IServiceCollection AddTransientLazy<TService, TImplementation>(this IServiceCollection services, Func<IServiceProvider, TImplementation> implementationFactory)
            where TService : class
            where TImplementation : class, TService
            => services.AddTransient<TService, TImplementation>(implementationFactory)
            .AddTransient(provider => new Lazy<TService>(() => implementationFactory(provider)));

    }
}