monorepo/LCU.API.Collections.RepoApi-old/LCU.API.Collections.RepoApi/Services/Reporting/AuctionReportingService.cs

using System;
using System.Threading.Tasks;
using LCU.API.Collections.RepoApi.Exceptions;
using LCU.API.Collections.RepoApi.Factories;
using LCU.Shared.Collections.RepoApiLib.Formatting;
using LCU.Shared.Collections.RepoApiLib.Models.Reporting.Responses;
using LCU.Shared.Collections.RepoApiLib.Repositories;
using Serilog;

namespace LCU.API.Collections.RepoApi.Services.Reporting
{
    public class AuctionReportingService : IAuctionReportingService
    {
        private readonly IReportingRepository _reportingRepository;

        public AuctionReportingService(IReportingRepository reportingRepository)
        {
            _reportingRepository = reportingRepository;
        }

        public async Task<ReportTableResponse> GetAssignedBalance(DateTime lowDateTime, DateTime highDateTime)
        {
            try
            {
                var reportData = await _reportingRepository.GetAccountsByDateRepoed(lowDateTime, highDateTime);

                return new ReportTableResponse()
                {
                    ReportTable = ReportTableFactory.CreateHistoricalSummationTable(
                        ReportSumType.Currency,
                        reportData,
                        "Auctions",
                        lowDateTime,
                        highDateTime,
                        (reportEntry) => reportEntry.Balance,
                        (reportEntry) => reportEntry.AuctionName,
                        (reportEntry) => reportEntry.DateRepoed,
                        (reportEntry) => reportEntry.RepoId),
                    DataTable = DataTableFormatting.CreateDataTable(
                        reportData,
                        (entry) => entry.RepoId,
                        StdReportEntryColumns.AccountNo(),
                        StdReportEntryColumns.Balance(),
                        StdReportEntryColumns.Auction(),
                        StdReportEntryColumns.Collateral(),
                        StdReportEntryColumns.RepoCompany(),
                        StdReportEntryColumns.DateRepoed(),
                        StdReportEntryColumns.DateEnteredAutoIMS(),
                        StdReportEntryColumns.ScheduledSaleDate())
                };
            }
            catch (Exception ex)
            {
                Log.Error(ex, "Failure retrieving Gross Active Balance Report");
                throw new ServerErrorException();
            }
        }

        public async Task<ReportTableResponse> GetAssignedCollateralCount(DateTime lowDateTime, DateTime highDateTime)
        {
            try
            {
                var reportData = await _reportingRepository.GetAccountsByDateRepoed(lowDateTime, highDateTime);

                return new ReportTableResponse()
                {
                    ReportTable = ReportTableFactory.CreateHistoricalSummationTable(
                        ReportSumType.WholeNumber,
                        reportData,
                        "Auctions",
                        lowDateTime,
                        highDateTime,
                        (reportEntry) => 1,
                        (reportEntry) => reportEntry.AuctionName,
                        (reportEntry) => reportEntry.DateRepoed,
                        (reportEntry) => reportEntry.RepoId),
                    DataTable = DataTableFormatting.CreateDataTable(
                        reportData,
                        (entry) => entry.RepoId,
                        StdReportEntryColumns.Member(),
                        StdReportEntryColumns.AccountNo(),
                        StdReportEntryColumns.Status(),
                        StdReportEntryColumns.DaysInStatus(),
                        StdReportEntryColumns.Balance(),
                        StdReportEntryColumns.AccountCode(),
                        StdReportEntryColumns.Bankruptcy(),
                        StdReportEntryColumns.Collateral(),
                        StdReportEntryColumns.DateRepoed(),
                        StdReportEntryColumns.Grade(),
                        StdReportEntryColumns.FloorPrice(),
                        StdReportEntryColumns.Auction())
                };
            }
            catch (Exception ex)
            {
                Log.Error(ex, "Failure retrieving Active Inventory Report");
                throw new ServerErrorException();
            }
        }

        public async Task<ReportTableResponse> GetSalePriceReport(DateTime lowDateTime, DateTime highDateTime)
        {
            try
            {
                var reportData = await _reportingRepository.GetAccountsByDateSoldInAutoIMS(lowDateTime, highDateTime);

                return new ReportTableResponse()
                {
                    ReportTable = ReportTableFactory.CreateHistoricalSummationTable(
                        ReportSumType.Currency,
                        reportData,
                        "Auctions",
                        lowDateTime,
                        highDateTime,
                        (reportEntry) => reportEntry.GrossSalePrice,
                        (reportEntry) => reportEntry.AuctionName,
                        (reportEntry) => reportEntry.SoldDate,
                        (reportEntry) => reportEntry.RepoId,
                        false),
                    DataTable = DataTableFormatting.CreateDataTable(
                        reportData,
                        (entry) => entry.RepoId,
                        StdReportEntryColumns.Member(),
                        StdReportEntryColumns.AccountNo(),
                        StdReportEntryColumns.Status(),
                        StdReportEntryColumns.DaysInStatus(),
                        StdReportEntryColumns.Balance(),
                        StdReportEntryColumns.AccountCode(),
                        StdReportEntryColumns.Bankruptcy(),
                        StdReportEntryColumns.Collateral(),
                        StdReportEntryColumns.Grade(),
                        StdReportEntryColumns.FloorPrice(),
                        StdReportEntryColumns.Auction(),
                        StdReportEntryColumns.DateSold(),
                        StdReportEntryColumns.GrossSalePrice(),
                        StdReportEntryColumns.GrossPercentFloor(),
                        StdReportEntryColumns.NetPercentFloor(),
                        StdReportEntryColumns.TotalCharges())
                };
            }
            catch (Exception ex)
            {
                Log.Error(ex, "Failture Retrieving Sold Price Report.");
                throw new ServerErrorException();
            }
        }

        public async Task<ReportTableResponse> GetAuctionFeeReport(DateTime lowDateTime, DateTime highDateTime)
        {
            try
            {
                var reportData = await _reportingRepository.GetAccountsByDateSoldInAutoIMS(lowDateTime, highDateTime);

                return new ReportTableResponse()
                {
                    ReportTable = ReportTableFactory.CreateHistoricalSummationTable(
                        ReportSumType.Currency,
                        reportData,
                        "Auctions",
                        lowDateTime,
                        highDateTime,
                        (reportEntry) => reportEntry.TotalCharges,
                        (reportEntry) => reportEntry.AuctionName,
                        (reportEntry) => reportEntry.SoldDate,
                        (reportEntry) => reportEntry.RepoId,
                        false),
                    DataTable = DataTableFormatting.CreateDataTable(
                        reportData,
                        (entry) => entry.RepoId,
                        StdReportEntryColumns.Member(),
                        StdReportEntryColumns.AccountNo(),
                        StdReportEntryColumns.Status(),
                        StdReportEntryColumns.DaysInStatus(),
                        StdReportEntryColumns.Balance(),
                        StdReportEntryColumns.AccountCode(),
                        StdReportEntryColumns.Bankruptcy(),
                        StdReportEntryColumns.Collateral(),
                        StdReportEntryColumns.Auction(),
                        StdReportEntryColumns.DateSold(),
                        StdReportEntryColumns.TotalCharges())
                };
            }
            catch (Exception ex)
            {
                Log.Error(ex, "Failture Retrieving Auction Fee Report.");
                throw new ServerErrorException();
            }
        }

        public async Task<ReportTableResponse> GetAvgDaysAssignedToSold(DateTime lowDateTime, DateTime highDateTime)
        {
            try
            {
                var reportData = await _reportingRepository.GetAccountsByDateSoldInAutoIMS(lowDateTime, highDateTime);

                return new ReportTableResponse()
                {
                    ReportTable = ReportTableFactory.CreateHistoricalSummationTable(
                        ReportSumType.WholeNumberAvg,
                        reportData,
                        "Auctions",
                        lowDateTime,
                        highDateTime,
                        (reportEntry) =>
                        {
                            if (reportEntry.SoldDate != null && reportEntry.DateEnteredAutoIMS != null)
                            {
                                return (decimal) (reportEntry.SoldDate.Value - reportEntry.DateEnteredAutoIMS.Value).TotalDays;
                            }
                            return null;
                        },
                        (reportEntry) => reportEntry.AuctionName,
                        (reportEntry) => reportEntry.SoldDate,
                        (reportEntry) => reportEntry.RepoId,
                        false),
                    DataTable = DataTableFormatting.CreateDataTable(
                        reportData,
                        (entry) => entry.RepoId,
                        StdReportEntryColumns.Member(),
                        StdReportEntryColumns.AccountNo(),
                        StdReportEntryColumns.Status(),
                        StdReportEntryColumns.DaysInStatus(),
                        StdReportEntryColumns.Balance(),
                        StdReportEntryColumns.AccountCode(),
                        StdReportEntryColumns.Bankruptcy(),
                        StdReportEntryColumns.Collateral(),
                        StdReportEntryColumns.Auction(),
                        StdReportEntryColumns.DateEnteredAutoIMS("Date Assigned"),
                        StdReportEntryColumns.DateSold(),
                        StdReportEntryColumns.AutoIMSAssignmentToSold("Days Assigned to Sold"))
                };
            }
            catch (Exception ex)
            {
                Log.Error(ex, "Failture Retrieving Avg. Days Assigned to Sold Report.");
                throw new ServerErrorException();
            }
        }

        public async Task<ReportTableResponse> GetAvgNetOfFloor(DateTime lowDateTime, DateTime highDateTime)
        {
            try
            {
                var reportData = await _reportingRepository.GetAccountsByDateSoldInAutoIMS(lowDateTime, highDateTime);

                return new ReportTableResponse()
                {
                    ReportTable = ReportTableFactory.CreateHistoricalSummationTable(
                        ReportSumType.PercentageAvg,
                        reportData,
                        "Auctions",
                        lowDateTime,
                        highDateTime,
                        (reportEntry) => reportEntry.NetPercentFloor,
                        (reportEntry) => reportEntry.AuctionName,
                        (reportEntry) => reportEntry.SoldDate,
                        (reportEntry) => reportEntry.RepoId,
                        false),
                    DataTable = DataTableFormatting.CreateDataTable(
                        reportData,
                        (entry) => entry.RepoId,
                        StdReportEntryColumns.Member(),
                        StdReportEntryColumns.AccountNo(),
                        StdReportEntryColumns.Status(),
                        StdReportEntryColumns.DaysInStatus(),
                        StdReportEntryColumns.Balance(),
                        StdReportEntryColumns.AccountCode(),
                        StdReportEntryColumns.Bankruptcy(),
                        StdReportEntryColumns.Collateral(),
                        StdReportEntryColumns.Auction(),
                        StdReportEntryColumns.NetPercentFloor(),
                        StdReportEntryColumns.DateSold())
                };
            }
            catch (Exception ex)
            {
                Log.Error(ex, "Failture Retrieving Avg. Days Assigned to Sold Report.");
                throw new ServerErrorException();
            }
        }
    }
}