DD.WellWorkover.Cloud/AsbCloudInfrastructure/Services/ReportService.cs

using AsbCloudApp.Services;
using AsbCloudApp.Data;
using AsbCloudDb.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using AsbSaubReport;

namespace AsbCloudInfrastructure.Services
{
    public class ReportService : IReportService
    {
        private readonly IAsbCloudDbContext db;
        private readonly IConfiguration configuration;
        private readonly ITelemetryService telemetryService;
        private readonly IBackgroundQueue queue;

        public ReportService(IAsbCloudDbContext db, IConfiguration configuration, ITelemetryService telemetryService, IBackgroundQueue queue)
        {
            this.db = db;
            this.configuration = configuration;
            this.telemetryService = telemetryService;
            this.queue = queue;
            RootPath = "reports";
        }

        public string RootPath { get ; private set; }

        public int CreateReport(int wellId, int stepSeconds, int format, DateTime begin, 
            DateTime end, Action<float , string , int> progressHandler, Action<string, int> reportNameHandler)
        {
            var newReportId = queue.EnqueueTask((id) =>
            {
                var optionsBuilder = new DbContextOptionsBuilder<AsbCloudDbContext>();
                optionsBuilder.UseNpgsql(configuration.GetConnectionString("DefaultConnection"));

                using (var context = new AsbCloudDbContext(optionsBuilder.Options))
                {
                    var generator = GetReportGenerator(wellId, begin, end, stepSeconds, format, context);
                    generator.OnProgress += (s,e) => progressHandler.Invoke(e.progress, e.operation, id);
                    var newReportName = generator.Make();
                    if(newReportName is not null)
                    {
                        var shorReportName = newReportName.Split(Path.DirectorySeparatorChar).Last();
                        reportNameHandler.Invoke(shorReportName, id);

                        var newReportProperties = new Report
                        {
                            Name = newReportName,
                            WellId = wellId,
                            Date = DateTime.Now,
                            Begin = begin,
                            End = end,
                            Step = stepSeconds,
                            Format = format
                        };
                        context.Reports.Add(newReportProperties);
                        context.SaveChanges();
                    }
                }
            });
            return newReportId;
        }

        public int GetReportPagesCount(int wellId, DateTime begin, DateTime end, int stepSeconds, int format)
        {
            var generator = GetReportGenerator(wellId, begin, end, stepSeconds, format, (AsbCloudDbContext)db);

            return generator.GetPagesCount();
        }

        public IEnumerable<ReportPropertiesDto> GetSuitableReports(int wellId, DateTime begin, DateTime end, int stepSeconds, int format)
        {
            var suitableReportsFromDb = GetSuitableReportsFromDb(wellId, begin, end, stepSeconds, format);

            var suitableReportsProperties = suitableReportsFromDb.Select(r => new ReportPropertiesDto 
            {
                Id = r.Id,
                Name = Path.GetFileName(r.Name),
                FullName = r.Name,
                WellId = r.WellId,
                Date = r.Date,
                Begin = r.Begin,
                End = r.End,
                Step = r.Step,
                Format = r.Format == 0 ? ".pdf" : ".las"
            });

            return suitableReportsProperties;
        }

        public DatesRangeDto GetReportsDatesRange(int wellId)
        {
            var telemetry = telemetryService.GetTelemetryByWellId(wellId);

            if (telemetry is null)
                return null;

            try
            {
                var datesRange = (from d in db.DataSaubBases
                                  where d.IdTelemetry == telemetry.Id
                                  select d.Date).Union(
                                  from m in db.Messages
                                  where m.IdTelemetry == telemetry.Id
                                  select m.Date).GroupBy(g => true)
                                  .Select(g => new
                                  {
                                      From = g.Min(),
                                      To = g.Max()
                                  }).FirstOrDefault(); 
                return new DatesRangeDto { From = datesRange.From, To = datesRange.To };
            }
            catch(InvalidOperationException)
            {
                return new DatesRangeDto { From = DateTime.MinValue, To = DateTime.MaxValue };
            }
        }

        private IEnumerable<Report> GetSuitableReportsFromDb(int wellId, DateTime begin, DateTime end, int stepSeconds, int format)
        {
            var suitableReportsNames = (from r in db.Reports
                                        where r.WellId == wellId
                                        && r.Begin >= begin
                                        && r.End <= end
                                        && r.Step <= stepSeconds
                                        && r.Format == format
                                        select r).OrderBy(o => o.Date).Take(512).ToList();

            return suitableReportsNames;
        }

        private IReportGenerator GetReportGenerator(int wellId, DateTime begin, DateTime end, int stepSeconds, int format, AsbCloudDbContext context)
        {
            var dataSource = new ReportDataSourcePgCloud(context, wellId);
            var generator = new PdfGenerator(dataSource)
            {
                ReportDirectory = Path.Combine(RootPath, $"{wellId}"),
                Begin = begin,
                End = end,
                Step = TimeSpan.FromSeconds(stepSeconds),
                WithCharts = true,
                WithEvents = true
            };

            switch(format)
            {
                case 0:
                    return generator;
                case 1:
                    return generator;
                default:
                    return generator;
            }
        }
    }
}