Program.cs

using CommandLine;
using Coscine.KpiGenerator.Logging;
using Coscine.KpiGenerator.Reportings.ApplicationProfile;
using Coscine.KpiGenerator.Reportings.Complete;
using Coscine.KpiGenerator.Reportings.Project;
using Coscine.KpiGenerator.Reportings.Resource;
using Coscine.KpiGenerator.Reportings.System;
using Coscine.KpiGenerator.Reportings.User;
using Microsoft.Extensions.Logging;
using NLog.Config;
using NLog.Extensions.Logging;
using static KPIGenerator.Utils.CommandLineOptions;

namespace Coscine.KpiGenerator;

public class Program
{
    private static ILogger _logger = null!;

    public static int Main(string[] args)
    {
        ConfigurationItemFactory.Default.LayoutRenderers.RegisterDefinition("assembly-name", typeof(AssemblyNameLayoutRenderer));
        ConfigurationItemFactory.Default.LayoutRenderers.RegisterDefinition("assembly-version", typeof(AssemblyVersionLayoutRenderer));
        _logger = LoggerFactory.Create(builder => builder.AddNLog()).CreateLogger<Program>();

        try
        {
            bool result = Parser.Default.ParseArguments<
                CompleteReportingOptions,
                ProjectReportingOptions,
                ResourceReportingOptions,
                UserReportingOptions,
                ApplicationProfileReportingOptions,
                SystemReportingOptions
                >(args)
            .MapResult(
              (CompleteReportingOptions options) => new CompleteReporting(SanitizeOptions(options), _logger).Run(),
              (ProjectReportingOptions options) => new ProjectReporting(SanitizeOptions(options), _logger).Run(),
              (ResourceReportingOptions options) => new ResourceReporting(SanitizeOptions(options), _logger).Run(),
              (UserReportingOptions options) => new UserReporting(SanitizeOptions(options), _logger).Run(),
              (ApplicationProfileReportingOptions options) => new ApplicationProfileReporting(SanitizeOptions(options), _logger).Run(),
              (SystemReportingOptions options) => new SystemReporting(SanitizeOptions(options), _logger).Run(),
              _ => false);
            if (result)
            {
                Console.WriteLine("\nFinished.\n");
                _logger.LogInformation("Finished.");
                return 0; // Exit Code 0 for Success
            }
            else
            {
                Console.WriteLine("Program execution was interrupted.\n");
                _logger.LogInformation("Program execution was interrupted.");
                return -1; // Exit Code -1 for Failure
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
            _logger.LogWarning(e, e.Message);
            return -1; // Exit Code -1 for Failure
        }
    }

    public static TResult SanitizeOptions<TResult>(TResult unsanitizedOptions)
    {
        // Sanitize all input that accepts an array or is a list of inputs.
        if (unsanitizedOptions is not null)
        {
            var type = unsanitizedOptions.GetType();
            if (type == typeof(CompleteReportingOptions))
            {
                var options = unsanitizedOptions as CompleteReportingOptions;
                if (options is not null)
                {
                    // Sanitize options here
                    return (TResult)(object)options;
                }
            }
            else if (type == typeof(ProjectReportingOptions))
            {
                var options = unsanitizedOptions as ProjectReportingOptions;
                if (options is not null)
                {
                    // Sanitize options here
                    return (TResult)(object)options;
                }
            }
            else if (type == typeof(ResourceReportingOptions))
            {
                var options = unsanitizedOptions as ResourceReportingOptions;
                if (options is not null)
                {
                    // Sanitize options here
                    return (TResult)(object)options;
                }
            }
            else if (type == typeof(UserReportingOptions))
            {
                var options = unsanitizedOptions as UserReportingOptions;
                if (options is not null)
                {
                    // Sanitize options here
                    return (TResult)(object)options;
                }
            }
            else if (type == typeof(ApplicationProfileReportingOptions))
            {
                var options = unsanitizedOptions as ApplicationProfileReportingOptions;
                if (options is not null)
                {
                    // Sanitize options here
                    return (TResult)(object)options;
                }
            }
            else if (type == typeof(SystemReportingOptions))
            {
                var options = unsanitizedOptions as SystemReportingOptions;
                if (options is not null)
                {
                    // Sanitize options here
                    return (TResult)(object)options;
                }
            }
        }
        return unsanitizedOptions;
    }
    private static void LogInnerException(Exception ex)
    {
        if (ex.InnerException is not null)
        {
            _logger.LogWarning(ex.InnerException, "InnerException: {innerException}", ex.InnerException.Message);
            LogInnerException(ex.InnerException);
        }
    }
}