DD.WellWorkover.Cloud/AsbCloudInfrastructure/DependencyInjection.cs

using AsbCloudApp.Data;
using AsbCloudApp.Data.DailyReport.Blocks.TimeBalance;
using AsbCloudApp.Data.DetectedOperation;
using AsbCloudApp.Data.DrillTestReport;
using AsbCloudApp.Data.Manuals;
using AsbCloudApp.Data.ProcessMaps;
using AsbCloudApp.Data.SAUB;
using AsbCloudApp.Data.Subsystems;
using AsbCloudApp.Data.Trajectory;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudApp.Services.DailyReport;
using AsbCloudApp.Services.Notifications;
using AsbCloudApp.Services.ProcessMaps.WellDrilling;
using AsbCloudDb.Model;
using AsbCloudDb.Model.DailyReports.Blocks.TimeBalance;
using AsbCloudDb.Model.Manuals;
using AsbCloudDb.Model.ProcessMapPlan;
using AsbCloudDb.Model.ProcessMaps;
using AsbCloudDb.Model.Trajectory;
using AsbCloudDb.Model.WellSections;
using AsbCloudInfrastructure.Background;
using AsbCloudInfrastructure.Repository;
using AsbCloudInfrastructure.Services;
using AsbCloudInfrastructure.Services.DailyReport;
using AsbCloudInfrastructure.Services.DetectOperations;
using AsbCloudInfrastructure.Services.DrillingProgram;
using AsbCloudInfrastructure.Services.DrillTestReport;
using AsbCloudInfrastructure.Services.ProcessMapPlan.Export;
using AsbCloudInfrastructure.Services.ProcessMapPlan.Parser;
using AsbCloudInfrastructure.Services.ProcessMaps.Report;
using AsbCloudInfrastructure.Services.SAUB;
using AsbCloudInfrastructure.Services.Subsystems;
using AsbCloudInfrastructure.Services.Trajectory;
using AsbCloudInfrastructure.Services.Trajectory.Export;
using AsbCloudInfrastructure.Services.Trajectory.Parser;
using AsbCloudInfrastructure.Services.WellOperations.Factories;
using AsbCloudInfrastructure.Services.WellOperationService;
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 void MapsterSetup()
        {
            TypeAdapterConfig.GlobalSettings.Default.Config
               .ForType<SetpointsRequestDto, SetpointsRequest>()
               .Ignore(source => source.Author)
               .Ignore(source => source.Well);

            TypeAdapterConfig.GlobalSettings.Default.Config
               .ForType<DetectedOperationDto, DetectedOperation>()
               .Ignore(source => source.OperationCategory);

            TypeAdapterConfig.GlobalSettings.Default.Config
               .ForType<ScheduleDto, Schedule>()
               .Ignore(source => source.Driller);

#pragma warning disable CS8603 // Possible null reference return.
            TypeAdapterConfig.GlobalSettings.Default.Config
               .ForType<ProcessMapPlanBaseDto, ProcessMapPlanBase>()
               .Ignore(dst => dst.Author, dst => dst.Editor);
#pragma warning restore CS8603 // Possible null reference return.

            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.MakeTimeOnly());

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

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

#pragma warning disable CS8603 // Possible null reference return.
            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);
#pragma warning restore CS8603 // Possible null reference return.

            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>();

            TypeAdapterConfig.GlobalSettings.Default.Config
               .ForType<NotificationDto, Notification>()
               .Ignore(dst => dst.NotificationCategory,
                  dst => dst.User);

            TypeAdapterConfig.GlobalSettings.Default.Config
               .ForType<TimeBalanceRecord, TimeBalanceRecordDto>()
               .Map(dest => dest.DurationHours, src => new PlanFactDto<double?>()
               {
                   Plan = src.DurationHoursPlan,
                   Fact = src.DurationHoursFact
               });

            TypeAdapterConfig.GlobalSettings.Default.Config
               .ForType<TimeBalanceBlock, TimeBalanceBlockDto>()
               .Map(dest => dest.WellDepth, src => new PlanFactDto<double?>()
               {
                   Plan = src.WellDepthPlan
               });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanRotorDto>>.NewConfig()
                .Include<ProcessMapPlanRotor, ChangeLogDto<ProcessMapPlanRotorDto>>()
                .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanRotorDto>()
                {
                    Item = src.Adapt<ProcessMapPlanRotorDto>()
                });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanSlideDto>>.NewConfig()
                .Include<ProcessMapPlanSlide, ChangeLogDto<ProcessMapPlanSlideDto>>()
                .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanSlideDto>()
                {
                    Item = src.Adapt<ProcessMapPlanSlideDto>()
                });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanOperationReamingRotorDto>>.NewConfig()
                .Include<ProcessMapPlanOperationReamingRotor, ChangeLogDto<ProcessMapPlanOperationReamingRotorDto>>()
                .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanOperationReamingRotorDto>()
                {
                    Item = src.Adapt<ProcessMapPlanOperationReamingRotorDto>()
                });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanOperationReamingSlideDto>>.NewConfig()
                .Include<ProcessMapPlanOperationReamingSlide, ChangeLogDto<ProcessMapPlanOperationReamingSlideDto>>()
                .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanOperationReamingSlideDto>()
                {
                    Item = src.Adapt<ProcessMapPlanOperationReamingSlideDto>()
                });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanOperationLoadCapacityDto>>.NewConfig()
                .Include<ProcessMapPlanOperationLoadCapacity, ChangeLogDto<ProcessMapPlanOperationLoadCapacityDto>>()
                .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanOperationLoadCapacityDto>()
                {
                    Item = src.Adapt<ProcessMapPlanOperationLoadCapacityDto>()
                });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanSurveyDto>>.NewConfig()
                .Include<ProcessMapPlanSurvey, ChangeLogDto<ProcessMapPlanSurveyDto>>()
                .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanSurveyDto>()
                {
                    Item = src.Adapt<ProcessMapPlanSurveyDto>()
                });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanOperationPositioningOffTheBottomDto>>.NewConfig()
                .Include<ProcessMapPlanOperationPositioningOffTheBottom, ChangeLogDto<ProcessMapPlanOperationPositioningOffTheBottomDto>>()
                .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanOperationPositioningOffTheBottomDto>()
                {
                    Item = src.Adapt<ProcessMapPlanOperationPositioningOffTheBottomDto>()
                });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanOscillationAnglesDto>>.NewConfig()
                .Include<ProcessMapPlanOscillationAngles, ChangeLogDto<ProcessMapPlanOscillationAnglesDto>>()
                .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanOscillationAnglesDto>()
                {
                    Item = src.Adapt<ProcessMapPlanOscillationAnglesDto>()
                });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanOperationTFOrientationDto>>.NewConfig()
                .Include<ProcessMapPlanOperationTFOrientation, ChangeLogDto<ProcessMapPlanOperationTFOrientationDto>>()
                .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanOperationTFOrientationDto>()
                {
                    Item = src.Adapt<ProcessMapPlanOperationTFOrientationDto>()
                });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanOperationSwitchPumpDto>>.NewConfig()
               .Include<ProcessMapPlanOperationSwitchPump, ChangeLogDto<ProcessMapPlanOperationSwitchPumpDto>>()
               .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanOperationSwitchPumpDto>()
               {
                   Item = src.Adapt<ProcessMapPlanOperationSwitchPumpDto>()
               });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanOperationSwitchingToTheModeDto>>.NewConfig()
               .Include<ProcessMapPlanOperationSwitchingToTheMode, ChangeLogDto<ProcessMapPlanOperationSwitchingToTheModeDto>>()
               .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanOperationSwitchingToTheModeDto>()
               {
                   Item = src.Adapt<ProcessMapPlanOperationSwitchingToTheModeDto>()
               });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanDrillTestDto>>.NewConfig()
               .Include<ProcessMapPlanOperationSwitchingToTheMode, ChangeLogDto<ProcessMapPlanDrillTestDto>>()
               .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanDrillTestDto>()
               {
                   Item = src.Adapt<ProcessMapPlanDrillTestDto>()
               });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanShockTestDto>>.NewConfig()
               .Include<ProcessMapPlanOperationSwitchingToTheMode, ChangeLogDto<ProcessMapPlanShockTestDto>>()
               .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanShockTestDto>()
               {
                   Item = src.Adapt<ProcessMapPlanShockTestDto>()
               });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanFunctionsDamperDto>>.NewConfig()
               .Include<ProcessMapPlanFunctionsDamper, ChangeLogDto<ProcessMapPlanFunctionsDamperDto>>()
               .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanFunctionsDamperDto>()
               {
                   Item = src.Adapt<ProcessMapPlanFunctionsDamperDto>()
               });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanAutoHoldTFDto>>.NewConfig()
               .Include<ProcessMapPlanAutoHoldTF, ChangeLogDto<ProcessMapPlanAutoHoldTFDto>>()
               .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanAutoHoldTFDto>()
               {
                   Item = src.Adapt<ProcessMapPlanAutoHoldTFDto>()
               });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanFunctionsJarrDrillToolDto>>.NewConfig()
               .Include<ProcessMapPlanFunctionsJarrDrillTool, ChangeLogDto<ProcessMapPlanFunctionsJarrDrillToolDto>>()
               .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanFunctionsJarrDrillToolDto>()
               {
                   Item = src.Adapt<ProcessMapPlanFunctionsJarrDrillToolDto>()
               });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanUpdatingNoloadParametersDto>>.NewConfig()
               .Include<ProcessMapPlanUpdatingNoloadParameters, ChangeLogDto<ProcessMapPlanUpdatingNoloadParametersDto>>()
               .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanUpdatingNoloadParametersDto>()
               {
                   Item = src.Adapt<ProcessMapPlanUpdatingNoloadParametersDto>()
               });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanOscillationDto>>.NewConfig()
               .Include<ProcessMapPlanOscillation, ChangeLogDto<ProcessMapPlanOscillationDto>>()
               .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanOscillationDto>()
               {
                   Item = src.Adapt<ProcessMapPlanOscillationDto>()
               });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanAntiCrashRotationDto>>.NewConfig()
              .Include<ProcessMapPlanAntiCrashRotation, ChangeLogDto<ProcessMapPlanAntiCrashRotationDto>>()
              .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanAntiCrashRotationDto>()
              {
                  Item = src.Adapt<ProcessMapPlanAntiCrashRotationDto>()
              });

            TypeAdapterConfig<ChangeLogAbstract, ChangeLogDto<ProcessMapPlanStaticMeasurementOutputDto>>.NewConfig()
              .Include<ProcessMapPlanStaticMeasurementOutput, ChangeLogDto<ProcessMapPlanStaticMeasurementOutputDto>>()
              .Map(dest => dest, src => new ChangeLogDto<ProcessMapPlanStaticMeasurementOutputDto>()
              {
                  Item = src.Adapt<ProcessMapPlanStaticMeasurementOutputDto>()
              });
        }

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


            services.AddMemoryCache();
            services.AddScoped<IAsbCloudDbContext>(provider => provider.GetRequiredService<AsbCloudDbContext>());

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

            services.AddTransient<IAuthService, AuthService>();
            services.AddTransient<IDepositRepository, DepositRepository>();
            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.AddScoped<ITelemetryService, TelemetryService>();
            services.AddTransient<ITelemetryUserService, TelemetryUserService>();
            services.AddTransient<ITimezoneService, TimezoneService>();
            services.AddScoped<IWellService, WellService>();
            services.AddTransient<IProcessMapReportDrillingExportService, ProcessMapReportDataSaubStatExportService>();
            services.AddTransient<IWellOperationRepository, WellOperationRepository>();
            services.AddTransient<IDailyReportService, DailyReportService>();
            services.AddTransient<IDetectedOperationService, DetectedOperationService>();
            services.AddTransient<ISubsystemService, SubsystemService>();
            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>();
            services.AddTransient<WellInfoService>();
            services.AddTransient<IHelpPageService, HelpPageService>();
            services.AddTransient<IScheduleReportService, ScheduleReportService>();
            services.AddTransient<IDataSaubStatRepository, DataSaubStatRepository>();

            services.AddTransient<IProcessMapReportDrillingService, ProcessMapReportDrillingService>();

            services.AddTransient<TrajectoryService>();

            services.AddTransient<IGtrRepository, GtrWitsRepository>();

            services.AddTransient<NotificationService>();
            services.AddTransient<INotificationRepository, NotificationRepository>();
            services.AddTransient<ICrudRepository<NotificationCategoryDto>, CrudCacheRepositoryBase<NotificationCategoryDto,
                NotificationCategory>>();
            services.AddTransient<IDrillTestRepository, DrillTestRepository>();
            services.AddTransient<IWellCompositeOperationService, WellCompositeOperationService>();

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

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

            services.AddTransient<IHelpPageRepository, HelpPageRepository>();
            services.AddTransient<IFileRepository, FileRepository>();
            services.AddTransient<IFileStorageRepository, FileStorageRepository>();           
            services.AddTransient<IUserRoleRepository, UserRoleRepository>();
            services.AddTransient<IUserRepository, UserRepository>();
            services.AddTransient<ILimitingParameterRepository, LimitingParameterRepository>();
            services.AddTransient<ITelemetryWirelineRunOutRepository, TelemetryWirelineRunOutRepository>();
            services.AddTransient<IWellFinalDocumentsRepository, WellFinalDocumentsRepository>();
            services.AddTransient<ITrajectoryEditableRepository<TrajectoryGeoPlanDto>, TrajectoryEditableRepository<TrajectoryPlan, TrajectoryGeoPlanDto>>();
            services.AddTransient<ITrajectoryEditableRepository<TrajectoryGeoFactDto>, TrajectoryEditableRepository<TrajectoryFact, TrajectoryGeoFactDto>>();
            services.AddTransient<ITrajectoryNnbRepository, TrajectoryNnbRepository>();
            services.AddTransient<IFaqRepository, FaqRepository>();
            services.AddTransient<ISlipsStatService, SlipsStatService>();
            services.AddTransient<IWellContactService, WellContactService>();
            services.AddTransient<ICrudRepository<WellSectionTypeDto>, CrudCacheRepositoryBase<WellSectionTypeDto,
               WellSectionType>>();

            services.AddTransient<ICrudRepository<SubsystemDto>, CrudCacheRepositoryBase<SubsystemDto, Subsystem>>();

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

            // TelemetryData services
            services.AddTransient<ITelemetryDataSaubService, 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.AddTransient<IDrillTestReportService, DrillTestReportService>();
            services.AddTransient<IReportMakerService<DrillTestReportDataDto>, DrillTestReportMakerService>();

            services.AddTransient<IManualDirectoryRepository, ManualDirectoryRepository>();
            services.AddTransient<IManualCatalogService, ManualCatalogService>();
            services.AddTransient<ICrudRepository<ManualDto>, CrudRepositoryBase<ManualDto, Manual>>();

            services.AddTransient<IWellboreService, WellboreService>();

            services.AddTransient<DetectedOperationExportService>();

            services.AddTransient<IDailyReportService, DailyReportService>();
            services.AddTransient<IDailyReportRepository, DailyReportRepository>();
            services.AddTransient<IDailyReportExportService, DailyReportExportService>();

            services.AddTransient<IRepositoryWellRelated<WellSectionPlanDto>, CrudWellRelatedRepositoryBase<WellSectionPlanDto, WellSectionPlan>>();

            services.AddTransient<IWellSectionPlanRepository, WellSectionPlanRepository>();
            services.AddTransient<IWellOperationCategoryRepository, WellOperationCategoryRepository>();
            services.AddTransient<IDetectedOperationRepository, DetectedOperationRepository>();

            services.AddTransient<TrajectoryPlanParser>();
            services.AddTransient<TrajectoryFactManualParser>();
            services.AddTransient<ProcessMapPlanRotorParser>();
            services.AddTransient<ProcessMapPlanSlideParser>();
            services.AddTransient<ProcessMapPlanReamParser>();
            services.AddTransient<ProcessMapPlanOperationReamingRotorParser>();
            services.AddTransient<ProcessMapPlanOperationReamingSlideParser>();
            services.AddTransient<ProcessMapPlanOperationLoadCapacityParser>();
            services.AddTransient<ProcessMapPlanSurveyParser>();
            services.AddTransient<ProcessMapPlanOperationPositioningOffTheBottomParser>();
            services.AddTransient<ProcessMapPlanOscillationAnglesParser>();
            services.AddTransient<ProcessMapPlanOperationTFOrientationParser>();
            services.AddTransient<ProcessMapPlanOperationSwitchPumpParser>();
            services.AddTransient<ProcessMapPlanOperationSwitchingToTheModeParser>();
            services.AddTransient<ProcessMapPlanDrillTestParser>();
            services.AddTransient<ProcessMapPlanShockTestParser>();
            services.AddTransient<ProcessMapPlanFunctionsDamperParser>();
            services.AddTransient<ProcessMapPlanAutoHoldTFParser>();
            services.AddTransient<ProcessMapPlanFunctionsJarrDrillToolParser>();
            services.AddTransient<ProcessMapPlanUpdatingNoloadParametersParser>();
            services.AddTransient<ProcessMapPlanOscillationParser>();
            services.AddTransient<ProcessMapPlanAntiCrashRotationParser>();
            services.AddTransient<ProcessMapPlanStaticMeasurementOutputParser>();

            services.AddTransient<TrajectoryPlanExportService>();
            services.AddTransient<TrajectoryFactManualExportService>();
            services.AddTransient<TrajectoryFactNnbExportService>();

            services.AddTransient<ProcessMapPlanRotorExportService>();
            services.AddTransient<ProcessMapPlanSlideExportService>();
            services.AddTransient<ProcessMapPlanReamExportService>();
            services.AddTransient<ProcessMapPlanOperationReamingRotorExportService>();
            services.AddTransient<ProcessMapPlanOperationReamingSlideExportService>();
            services.AddTransient<ProcessMapPlanOperationLoadCapacityExportService>();
            services.AddTransient<ProcessMapPlanSurveyExportService>();
            services.AddTransient<ProcessMapPlanOperationPositioningOffTheBottomExportService>();
            services.AddTransient<ProcessMapPlanOscillationAnglesExportService>();
            services.AddTransient<ProcessMapPlanOperationTFOrientationExportService>();
            services.AddTransient<ProcessMapPlanOperationSwitchPumpExportService>();
            services.AddTransient<ProcessMapPlanOperationSwitchingToTheModeExportService>();
            services.AddTransient<ProcessMapPlanDrillTestExportService>();
            services.AddTransient<ProcessMapPlanShockTestExportService>();
            services.AddTransient<ProcessMapPlanFunctionsDamperExportService>();
            services.AddTransient<ProcessMapPlanAutoHoldTFExportService>();
            services.AddTransient<ProcessMapPlanFunctionsJarrDrillToolExportService>();
            services.AddTransient<ProcessMapPlanUpdatingNoloadParametersExportService>();
            services.AddTransient<ProcessMapPlanOscillationExportService>();
            services.AddTransient<ProcessMapPlanAntiCrashRotationExportService>();
            services.AddTransient<ProcessMapPlanStaticMeasurementOutputExportService>();

            services.AddTransient<WellOperationParserFactory>();
            services.AddTransient<WellOperationExportServiceFactory>();

            return services;
        }
        
        public static IServiceCollection AddProcessMaps(this IServiceCollection services, IConfiguration configuration)
        {
            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanRotorDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanRotor, ProcessMapPlanRotorDto>>();

            services.AddTransient<
               IChangeLogRepository<ProcessMapPlanSlideDto, ProcessMapPlanBaseRequestWithWell>,
               ProcessMapPlanBaseRepository<ProcessMapPlanSlide, ProcessMapPlanSlideDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanReamDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanReam, ProcessMapPlanReamDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanOperationReamingRotorDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanOperationReamingRotor, ProcessMapPlanOperationReamingRotorDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanOperationReamingSlideDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanOperationReamingSlide, ProcessMapPlanOperationReamingSlideDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanOperationLoadCapacityDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanOperationLoadCapacity, ProcessMapPlanOperationLoadCapacityDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanSurveyDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanSurvey, ProcessMapPlanSurveyDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanOperationPositioningOffTheBottomDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanOperationPositioningOffTheBottom, ProcessMapPlanOperationPositioningOffTheBottomDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanOscillationAnglesDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanOscillationAngles, ProcessMapPlanOscillationAnglesDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanOperationTFOrientationDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanOperationTFOrientation, ProcessMapPlanOperationTFOrientationDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanOperationSwitchPumpDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanOperationSwitchPump, ProcessMapPlanOperationSwitchPumpDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanOperationSwitchingToTheModeDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanOperationSwitchingToTheMode, ProcessMapPlanOperationSwitchingToTheModeDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanDrillTestDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanDrillTest, ProcessMapPlanDrillTestDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanShockTestDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanShockTest, ProcessMapPlanShockTestDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanFunctionsDamperDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanFunctionsDamper, ProcessMapPlanFunctionsDamperDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanAutoHoldTFDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanAutoHoldTF, ProcessMapPlanAutoHoldTFDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanFunctionsJarrDrillToolDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanFunctionsJarrDrillTool, ProcessMapPlanFunctionsJarrDrillToolDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanUpdatingNoloadParametersDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanUpdatingNoloadParameters, ProcessMapPlanUpdatingNoloadParametersDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanOscillationDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanOscillation, ProcessMapPlanOscillationDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanAntiCrashRotationDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanAntiCrashRotation, ProcessMapPlanAntiCrashRotationDto>>();

            services.AddTransient<
                IChangeLogRepository<ProcessMapPlanStaticMeasurementOutputDto, ProcessMapPlanBaseRequestWithWell>,
                ProcessMapPlanBaseRepository<ProcessMapPlanStaticMeasurementOutput, ProcessMapPlanStaticMeasurementOutputDto>>();

            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanRotorDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanSlideDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanOperationReamingRotorDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanOperationReamingSlideDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanOperationLoadCapacityDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanSurveyDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanOperationPositioningOffTheBottomDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanOscillationAnglesDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanOperationTFOrientationDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanOperationSwitchPumpDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanOperationSwitchingToTheModeDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanDrillTestDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanShockTestDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanFunctionsDamperDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanAutoHoldTFDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanFunctionsJarrDrillToolDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanUpdatingNoloadParametersDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanOscillationDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanAntiCrashRotationDto>>();
            services.AddTransient<IWellCompositeRepository, WellCompositeRepository<ProcessMapPlanStaticMeasurementOutputDto>>();

            return services;
        }
    }
}