monorepo/LCU.API.Internal.FileOperations/LCU.Api.Internal.FileOperations/Program.cs

using System;
using System.IO;
using System.Reflection;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Serilog;
using MassTransit;
using LCU.Library.Internal.FileOperationsModels.Models;
using LCU.Library.Internal.LcuEvaluation;
using LCU.Library.Internal.LcuMassTransit;
using LCU.Library.Internal.LcuMassTransitModels;
using LCU.Library.Internal.Status;
using LCU.Library.Internal.Configuration;
using LCU.Library.Internal.FileOperationsModels.Models.Requests;
using LCU.Library.Internal.LCUServiceFactory;
using LCU.Library.Internal.LCUServiceFactory.Configurations;
using LCU.Library.Internal.Logging.Models;
using LCU.Library.Internal.Logging;
using LCU.Api.Internal.FileOperations.Configurations;
using LCU.Api.Internal.FileOperations.Consumers;
using LCU.Api.Internal.FileOperations.Services;
using LCU.Api.Internal.FileOperations.Services.ExcelServices;
using LCU.Api.Internal.FileOperations.Services.FileActionServices;
using LCU.Api.Internal.FileOperations.Services.PdfServices;
using LCU.Api.Internal.FileOperations.Services.QueueServices;

string MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

var builder = BuildBuilder(args);
BuildServicesAndConfigurations(builder);
BuildAppAndRun(builder);

WebApplicationBuilder BuildBuilder(string[] args)
{
	var builder = WebApplication.CreateBuilder(args);
    builder.Host.UseSerilog();
    return builder;
}

void BuildServicesAndConfigurations(WebApplicationBuilder builder)
{
	var services = builder.Services;
	var configuration = builder.Configuration;

	//Configurations
	var apiConfiguration = configuration.Bind<ApiConfiguration>(services, "Primary");
	var servicesFactoryConfiguration = configuration.Bind<ServicesFactoryConfiguration>(services);
	services.AddSingleton(apiConfiguration);
    var loggerConfiguration = new LoggingConfiguration(apiConfiguration.AppName,
                                                       apiConfiguration.SeqApiKey,
                                                       apiConfiguration.SeqUrl);
    var lcuLogging = new LcuLogging(loggerConfiguration);
    lcuLogging.UseLcuLogging();

    var connectionConfiguration = MassTransitConfigurationSetUp.AddConnectionConfiguration(ref services, configuration);
	var receiveEndpointConfiguration = MassTransitConfigurationSetUp.GetReceiveEndpointConfiguration(configuration, "FileOperationsReceiveEndpoint");
	services.AddSingleton(receiveEndpointConfiguration);
	AddMassTransitServices(ref services, connectionConfiguration, receiveEndpointConfiguration);

	//Services
	services.AddLCUStatusServicesWithApiHealthCheck(configuration);
	services.AddLcuEvaluationServices();
	AddFileOperationServices(services);
	AddFileActionServices(services);
	AddServiceFactoryServices(services);
	AddPdfServices(services);
	AddExcelServices(services);

	services.AddLCUServiceFactoryAndValidateServiceRegistration<IFileActionService>(servicesFactoryConfiguration);
	services.AddControllers();
	services.AddCors(options =>
	{
		options.AddPolicy(MyAllowSpecificOrigins,
			builder =>
			{
				builder.WithOrigins(
					apiConfiguration.CorsAllowedOrigins
					).AllowAnyHeader().AllowAnyMethod();
			});
	});

	// Register the Swagger generator, defining 1 or more Swagger documents
	services.AddSwaggerGen(c =>
	{
		c.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo { Title = "File Operations API", Version = "v1" });
		// For this to work, I also had to check the generate xml box in build options.
		var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.XML";
		var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
		c.IncludeXmlComments(xmlPath);
	});
}

void BuildAppAndRun(WebApplicationBuilder builder)
{
	var app = builder.Build();

	app.UseSwagger();

	// Enable middleware to serve swagger-ui (HTML, JS, CSS, etc.), 
	// specifying the Swagger JSON endpoint.
	app.UseSwaggerUI(c =>
	{
		c.SwaggerEndpoint("/swagger/v1/swagger.json", "File Operations API");
	});

	if (app.Environment.IsDevelopment())
	{
		app.UseDeveloperExceptionPage();
	}
	else
	{
		// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
		app.UseHsts();
	}

	app.UseAuthentication();
	app.UseCors(MyAllowSpecificOrigins);
	app.UseHttpsRedirection();
	app.UseRouting();
	app.UseEndpoints(endpoints =>
		{
			endpoints.MapControllers();
		}
	);

	app.Run();
}

void AddFileOperationServices(IServiceCollection services)
{
	services.AddScoped<IQueueFileOperationsService, QueueFileOperationsService>();
	services.AddScoped<IFileOperationsService, FileOperationsService>();
	services.AddScoped<IDirectFileOperationsService, DirectFileOperationsService>();
	services.AddScoped<IDirectFileService, DirectFileService>();
	services.AddScoped<IDynamicDirectoryService, DynamicDirectoryService>();
	services.AddScoped<IFileSizeService, FileSizeService>();
}

void AddServiceFactoryServices(IServiceCollection services)
{
	services.AddScoped<IFileActionService, MoveFileService>();
	services.AddScoped<IFileActionService, CopyFileService>();
	services.AddScoped<IFileActionService, DeleteFileService>();
	services.AddScoped<IFileActionService, RenameFileService>();
	services.AddScoped<IFileActionService, ZipDirectoryService>();
	services.AddScoped<IFileActionService, CreateDirectoryService>();
	services.AddScoped<IFileActionService, RenameDirectoryService>();
	services.AddScoped<IFileActionService, BulkOperationService<MoveFileRequest>>();
	services.AddScoped<IFileActionService, UnzipFileService>();
	services.AddScoped<IFileActionService, EncryptFileDataService>();
	services.AddScoped<IFileActionService, DecryptFileDataService>();
	services.AddScoped<IFileActionService, ModifyFileService>();
	services.AddScoped<IFileActionService, UnzipPasswordProtectedFileService>();
	services.AddScoped<IFileActionService, BatchPdfParserService>();
	services.AddScoped<IFileActionService, WriteFileService>();
	services.AddScoped<IFileActionService, DeleteDirectoryService>();
	services.AddScoped<IFileActionService, ValidateFileService>();
	services.AddScoped<IFileActionService, AppendFileService>();
	services.AddScoped<IFileActionService, ExtractIndexFileDataService>();
	services.AddScoped<IFileActionService, DeleteEmptyDirectoryService>();
	services.AddScoped<IFileActionService, ValidateFileSizeInRangeService>();
    services.AddScoped<IFileActionService, WriteBinaryFileService>();
}

void AddFileActionServices(IServiceCollection services)
{
	services.AddScoped<IActionService<MoveFileRequest>, MoveFileService>();
	services.AddScoped<IActionService<ModifyFileRequest>, ModifyFileService>();
	services.AddScoped<IActionService<CopyFileRequest>, CopyFileService>();
	services.AddScoped<IActionService<DeleteFileRequest>, DeleteFileService>();
	services.AddScoped<IActionService<RenameFileRequest>, RenameFileService>();
	services.AddScoped<IActionService<ZipDirectoryRequest>, ZipDirectoryService>();
	services.AddScoped<IActionService<UnzipFileRequest>, UnzipFileService>();
	services.AddScoped<IActionService<UnzipPasswordProtectedFileRequest>, UnzipPasswordProtectedFileService>();
	services.AddScoped<IActionService<ValidateFileRequest>, ValidateFileService>();
	services.AddScoped<IActionService<CreateDirectoryRequest>, CreateDirectoryService>();
	services.AddScoped<IActionService<RenameDirectoryRequest>, RenameDirectoryService>();
	services.AddScoped<IActionService<BulkOperationRequest<MoveFileRequest>>, BulkOperationService<MoveFileRequest>>();
	services.AddScoped<IActionService<EncryptFileDataRequest>, EncryptFileDataService>();
	services.AddScoped<IActionService<DecryptFileDataRequest>, DecryptFileDataService>();
	services.AddScoped<IActionService<WriteFileRequest>, WriteFileService>();
	services.AddScoped<IActionService<DeleteDirectoryRequest>, DeleteDirectoryService>();
	services.AddScoped<IActionService<AppendFileRequest>, AppendFileService>();
	services.AddScoped<IActionService<ExtractIndexFileDataRequest>, ExtractIndexFileDataService>();
	services.AddScoped<IActionService<DeleteEmptyDirectoryRequest>, DeleteEmptyDirectoryService>();
	services.AddScoped<IActionService<ValidateFileSizeInRangeRequest>, ValidateFileSizeInRangeService>();
}

void AddPdfServices(IServiceCollection services)
{
	services.AddScoped<IBatchPdfParserService, BatchPdfParserService>();
	services.AddScoped<IPdfParserService, PdfParserService>();
	services.AddScoped<IHtmlToPdfService, HtmlToPdfService>();
}

void AddExcelServices(IServiceCollection services)
{
	services.AddScoped<IExcelService, ExcelService>();
}

void AddMassTransitServices(ref IServiceCollection services,
							ConnectionConfiguration connectionConfiguration,
							ReceiveEndpointConfiguration receiveEndpointConfiguration)
{
	services.AddMassTransit(x =>
	{
		x.AddConsumer<FileOperationsConsumer>();

		x.UsingRabbitMq((context, cfg) =>
		{
			cfg.Host(connectionConfiguration.HostUrl, "/", host =>
			{
				host.Username(connectionConfiguration.UserName);
				host.Password(connectionConfiguration.Password);
			});

			cfg.ReceiveEndpoint(receiveEndpointConfiguration.ReceiveEndpoint, e =>
			{
				e.ConfigureConsumer<FileOperationsConsumer>(context);
				e.SetQuorumQueue();
				e.PrefetchCount = receiveEndpointConfiguration.PrefetchLimit;
			});

		});
	});
	services.AddMassTransitHostedService();
}