CaritasPWA/Shared/Services/Fundvelo/ReportRepositoryService.cs

using cwebplusApp.Shared.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using TG.Blazor.IndexedDB;

namespace cwebplusApp.Shared.Services {
    public sealed class ReportRepositoryService {

        private const string FoundReportRepository_Store_Name = "FoundReportRepositoryItems";
        private const string MissingReportRepository_Store_Name = "MissingReportRepositoryItems";

        private readonly IndexedDBManager dbManager;

        public ReportRepositoryService(IndexedDBManager _dbManager) {
            this.dbManager = _dbManager;
        }

        public async Task SaveReport(ReportRepositoryItem reportRepositoryItem) {
            if (reportRepositoryItem is FoundReportRepositoryItem fItem) {
                await SaveFoundReport(fItem);
            } else if (reportRepositoryItem is MissingReportRepositoryItem mItem) {
                await SaveMissingReport(mItem);
            }
        }

        public async ValueTask<List<FoundReportRepositoryItem>> GetFoundReports() {
            return await this.dbManager.GetRecords<FoundReportRepositoryItem>(FoundReportRepository_Store_Name);
        }

        public async ValueTask<List<FoundReportRepositoryItem>> GetPendingFoundReports() {
            var indexSearch = new StoreIndexQuery<ReportRepositoryItem.State> {
                Storename = FoundReportRepository_Store_Name,
                IndexName = "status",
                QueryValue = ReportRepositoryItem.State.PENDING
            };
            return new List<FoundReportRepositoryItem>(await this.dbManager.GetAllRecordsByIndex<ReportRepositoryItem.State, FoundReportRepositoryItem>(indexSearch));
        }

        public async ValueTask<List<FoundReportRepositoryItem>> GetTransmittedFoundReports() {
            var indexSearch = new StoreIndexQuery<ReportRepositoryItem.State> {
                Storename = FoundReportRepository_Store_Name,
                IndexName = "status",
                QueryValue = ReportRepositoryItem.State.TRANSMITTED
            };
            return new List<FoundReportRepositoryItem>(await this.dbManager.GetAllRecordsByIndex<ReportRepositoryItem.State, FoundReportRepositoryItem>(indexSearch));
        }

        public async ValueTask<List<MissingReportRepositoryItem>> GetMissingReports() {
            return await this.dbManager.GetRecords<MissingReportRepositoryItem>(MissingReportRepository_Store_Name);
        }

        public async ValueTask<List<MissingReportRepositoryItem>> GetPendingMissingReports() {
            var indexSearch = new StoreIndexQuery<ReportRepositoryItem.State> {
                Storename = MissingReportRepository_Store_Name,
                IndexName = "status",
                QueryValue = ReportRepositoryItem.State.PENDING
            };
            return new List<MissingReportRepositoryItem>(await this.dbManager.GetAllRecordsByIndex<ReportRepositoryItem.State, MissingReportRepositoryItem>(indexSearch));
        }

        public async ValueTask<List<MissingReportRepositoryItem>> GetTransmittedMissingReports() {
            var indexSearch = new StoreIndexQuery<ReportRepositoryItem.State> {
                Storename = MissingReportRepository_Store_Name,
                IndexName = "status",
                QueryValue = ReportRepositoryItem.State.TRANSMITTED
            };
            return new List<MissingReportRepositoryItem>(await this.dbManager.GetAllRecordsByIndex<ReportRepositoryItem.State, MissingReportRepositoryItem>(indexSearch));
        }

        public async ValueTask<int> GetNbrOfPendingReports() {
            IList<FoundReportRepositoryItem> foundReportRepositoryItems = await GetPendingFoundReports();
            List<MissingReportRepositoryItem> missingReportRepositoryItems = await GetPendingMissingReports();
            return foundReportRepositoryItems.Count + missingReportRepositoryItems.Count;
        }

        public async Task SaveFoundReport(FoundReportRepositoryItem foundReportRepositoryItem) {
            if (foundReportRepositoryItem.GetReport() is not null) {
                var newRecord = new StoreRecord<FoundReportRepositoryItem> {
                    Storename = FoundReportRepository_Store_Name,
                    Data = foundReportRepositoryItem
                };
                if (foundReportRepositoryItem.ID == 0) {
                    foundReportRepositoryItem.ID = GetCurrentTimeInMillis();
                    await this.dbManager.AddRecord(newRecord);
                } else {
                    await this.dbManager.UpdateRecord(newRecord);
                }
            } else {
                Console.WriteLine("b9a082d4: FoundReportRepositoryItem not saved to DB due to underlaying report is NULL!");
            }
        }

        public async Task SaveMissingReport(MissingReportRepositoryItem missingReportRepositoryItem) {
            if (missingReportRepositoryItem.GetReport() is not null) {
                var newRecord = new StoreRecord<MissingReportRepositoryItem> {
                    Storename = MissingReportRepository_Store_Name,
                    Data = missingReportRepositoryItem
                };
                if (missingReportRepositoryItem.ID == 0) {
                    missingReportRepositoryItem.ID = GetCurrentTimeInMillis();
                    await this.dbManager.AddRecord(newRecord);
                } else {
                    await this.dbManager.UpdateRecord(newRecord);
                }
            } else {
                Console.WriteLine("b7it83r1: MissingReportRepositoryItem not saved to DB due to underlaying report is NULL!");
            }
        }

        public async Task DeleteReport(ReportRepositoryItem reportRepositoryItem) {
            if (reportRepositoryItem is FoundReportRepositoryItem) {
                await this.dbManager.DeleteRecord(FoundReportRepository_Store_Name, reportRepositoryItem.ID);
            } else {
                await this.dbManager.DeleteRecord(MissingReportRepository_Store_Name, reportRepositoryItem.ID);
            }
        }

        public static long GetCurrentTimeInMillis() {
            return DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
        }

        public static string GetCurrentDateTimeFromMillis(long millis) {
            TimeSpan time = TimeSpan.FromMilliseconds(millis);
            DateTime date = new DateTime() + time;
            return date.ToString("dd.MM.yyyy HH:mm:ss");
        }
    }
}