Gremlin/Gremlin_BlazorServer/Services/GenericController.cs

using Gremlin_BlazorServer.Data.DBClasses;
using Gremlin_BlazorServer.Data.EntityClasses;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.ChangeTracking;

namespace Gremlin_BlazorServer.Services;

public class GenericController {
    private static readonly GremlinDb gremlinDb = new();

    public IList<TResult>? GetAll<TResult>() where TResult : class, IMetadata {
        try {
            return gremlinDb.Set<TResult>().ToList();
        }
        catch (Exception exception) {
            Console.WriteLine(exception.InnerException);
            return null;
        }
    }

    public IList<TResult>? GetAll<TResult>(string include) where TResult : class, IMetadata {
        try {
            return gremlinDb.Set<TResult>().Include(include).ToList();
        }
        catch (Exception exception) {
            Console.WriteLine(exception.InnerException);
            return null;
        }
    }

    public IList<TResult>? GetAll<TResult>(Predicate<TResult> search) where TResult : class, IMetadata {
        ArgumentNullException.ThrowIfNull(search);
        try {
            return gremlinDb.Set<TResult>().AsEnumerable().Where(t => search(t)).ToList();
        }
        catch (Exception exception) {
            Console.WriteLine(exception.InnerException);
            return null;
        }
    }

    public async Task<IList<TResult>?> GetAllAsync<TResult>() where TResult : class, IMetadata {
        try {
            return await gremlinDb.Set<TResult>().ToListAsync();
        }
        catch (DbUpdateConcurrencyException exception) {
            await HandleDbUpdateConcurrencyException<TResult>(exception);
            Console.WriteLine(exception.InnerException);
            return null;
        }
    }

    public async Task<IList<TResult>?> GetAllAsync<TResult>(string include) where TResult : class, IMetadata {
        try {
            return await gremlinDb.Set<TResult>().Include(include).ToListAsync();
        }
        catch (DbUpdateConcurrencyException exception) {
            await HandleDbUpdateConcurrencyException<TResult>(exception);
            Console.WriteLine(exception.InnerException);
            return null;
        }
    }

    public async Task<IList<TResult>?> GetAllAsync<TResult>(string include1, string include2) where TResult : class, IMetadata {
        try {
            return await gremlinDb.Set<TResult>().Include(include1).Include(include2).ToListAsync();
        }
        catch (DbUpdateConcurrencyException exception) {
            await HandleDbUpdateConcurrencyException<TResult>(exception);
            Console.WriteLine(exception.InnerException);
            return null;
        }
    }

    public async Task<IList<TResult>?> GetAllAsync<TResult>(Predicate<TResult> search) where TResult : class, IMetadata {
        ArgumentNullException.ThrowIfNull(search);
        try {
            return await Task.Run(() => gremlinDb.Set<TResult>().AsEnumerable().Where(t => search(t)).ToList());
        }
        catch (DbUpdateConcurrencyException exception) {
            await HandleDbUpdateConcurrencyException<TResult>(exception);
            Console.WriteLine(exception.InnerException);
            return null;
        }
    }

    public async Task<IList<TResult>?> GetAllAsync<TResult>(Predicate<TResult> search, string include) where TResult : class, IMetadata {
        ArgumentNullException.ThrowIfNull(search);
        try {
            return await Task.Run(() => gremlinDb.Set<TResult>().Include(include).AsEnumerable().Where(t => search(t)).ToList());
        }
        catch (DbUpdateConcurrencyException exception) {
            await HandleDbUpdateConcurrencyException<TResult>(exception);
            Console.WriteLine(exception.InnerException);
            return null;
        }
    }

    // public IList<TResult>? GetAll<TResult>(Predicate<TResult> search, string include) where TResult : class, IMetadata {
    //     ArgumentNullException.ThrowIfNull(search);
    //     try {
    //         return gremlinDb.Set<TResult>().Include(include).AsEnumerable().Where(t => search(t)).ToList();
    //     }
    //     catch (Exception exception) {
    //         Console.WriteLine(exception.InnerException);
    //         return null;
    //     }
    // }

    // public TResult? Get<TResult>(Predicate<TResult> search) where TResult : class, IMetadata {
    // 	ArgumentNullException.ThrowIfNull(search);
    // 	try {
    // 		using GremlinDb gremlinDb = new();
    // 		return gremlinDb.Set<TResult>().AsEnumerable().FirstOrDefault(t => search(t));
    // 	}
    // 	catch (Exception exception) {
    // 		Console.WriteLine(exception.InnerException);
    // 		return null;
    // 	}
    // }

    public static async Task<TResult> GetAsync<TResult>(Predicate<TResult> search) where TResult : class, IMetadata, new() {
        try {
            return await Task.Run(() => gremlinDb.Set<TResult>().AsEnumerable().First(t => search(t)));
        }
        catch (Exception e) {
            Console.WriteLine(e.InnerException);
            return new();
        }
    }

    // public TResult? Get<TResult>(Predicate<TResult> search, string include) where TResult : class, IMetadata {
    // 	ArgumentNullException.ThrowIfNull(search);
    // 	try {
    // 		using GremlinDb gremlinDb = new();
    // 		return gremlinDb.Set<TResult>().AsNoTracking().Include(include).AsEnumerable().FirstOrDefault(t => search(t));
    // 	}
    // 	catch (Exception exception) {
    // 		Console.WriteLine(exception.InnerException);
    // 		return null;
    // 	}
    // }

    public async Task<TResult> GetAsync<TResult>(Predicate<TResult> search, string include1) where TResult : class, IMetadata, new() {
        ArgumentNullException.ThrowIfNull(search);
        try {
            return await Task.Run(() => gremlinDb.Set<TResult>().Include(include1).AsEnumerable().First(t => search(t)));
        }
        catch (DbUpdateConcurrencyException exception) {
            await HandleDbUpdateConcurrencyException<TResult>(exception);
            Console.WriteLine(exception.InnerException);
            return new();
        }
    }

    public async Task<TResult> GetAsync<TResult>(Predicate<TResult> search, string include1, string include2) where TResult : class, IMetadata, new() {
        ArgumentNullException.ThrowIfNull(search);
        try {
            return await Task.Run(() => gremlinDb.Set<TResult>().Include(include1).Include(include2).AsEnumerable().First(t => search(t)));
        }
        catch (DbUpdateConcurrencyException exception) {
            await HandleDbUpdateConcurrencyException<TResult>(exception);
            Console.WriteLine(exception.InnerException);
            return new();
        }
    }

    public static async Task<TResult> GetLastAsync<TResult>() where TResult : class, IMetadata, new() {
        try {
            return await Task.Run(() => gremlinDb.Set<TResult>().AsEnumerable().Last());
        }
        catch (Exception exception) {
            Console.WriteLine(exception.InnerException);
            return new();
        }
    }

    // public int Insert<T>(T entity) where T : class, IMetadata {
    // 	try {
    // 		using GremlinDb gremlinDb = new();
    // 		gremlinDb.Set<T>().Add(entity);
    // 		return gremlinDb.SaveChanges();
    // 	}
    // 	catch (Exception exception) {
    // 		Console.WriteLine(exception.InnerException);
    // 		return 0;
    // 	}
    // }

    // public int Insert<T>(IEnumerable<T> entities) where T : class, IMetadata {
    // 	try {
    // 		using GremlinDb gremlinDb = new();
    // 		gremlinDb.Set<T>().AddRange(entities);
    // 		return gremlinDb.SaveChanges();
    // 	}
    // 	catch (Exception exception) {
    // 		Console.WriteLine(exception.InnerException);
    // 		return 0;
    // 	}
    // }

    public async Task<int> InsertAsync<T>(T entity) where T : class, IMetadata {
        try {
            gremlinDb.Set<T>().Add(entity);
            return await gremlinDb.SaveChangesAsync();
        }
        catch (DbUpdateConcurrencyException exception) {
            await HandleDbUpdateConcurrencyException<T>(exception);
            Console.WriteLine(exception.InnerException);
            return 0;
        }
    }

    public async Task<int> InsertAsync<T>(IEnumerable<T> entities) where T : class, IMetadata {
        try {
            gremlinDb.Set<T>().AddRange(entities);
            return await gremlinDb.SaveChangesAsync();
        }
        catch (DbUpdateConcurrencyException exception) {
            await HandleDbUpdateConcurrencyException<T>(exception);
            Console.WriteLine(exception.InnerException);
            return 0;
        }
    }

    public static async Task<bool> IsExistingAsync<T>(Predicate<T> search) where T : class, IMetadata {
        try {
            return await Task.Run(() => gremlinDb.Set<T>().AsEnumerable().Any(t => search(t)));
        }
        catch (Exception exception) {
            Console.WriteLine(exception.InnerException);
            return false;
        }
    }

    // public int Update<T>(T entity) where T : class, IMetadata {
    // 	try {
    // 		using GremlinDb gremlinDb = new();
    // 		gremlinDb.Set<T>().Update(entity);
    // 		return gremlinDb.SaveChanges();
    // 	}
    // 	catch (Exception exception) {
    // 		Console.WriteLine(exception.InnerException);
    // 		return 0;
    // 	}
    // }

    public async Task<int> UpdateAsync<T>(T entity) where T : class, IMetadata {
        try {
            gremlinDb.Set<T>().Update(entity);
            return await gremlinDb.SaveChangesAsync(false);
        }
        catch (DbUpdateConcurrencyException exception) {
            await HandleDbUpdateConcurrencyException<T>(exception);
            Console.WriteLine(exception.InnerException);
            return 0;
        }
    }

    private static async Task HandleDbUpdateConcurrencyException<T>(DbUpdateConcurrencyException exception) where T : class, IMetadata {
        // Loop through the entities that caused the concurrency conflict
        foreach (EntityEntry? entry in exception.Entries) {
            if (entry.Entity is not T clientValues) throw new NotSupportedException($"Concurrency conflicts for entities of type {entry.Entity.GetType().Name} are not supported.");
            PropertyValues? databaseEntry = await entry.GetDatabaseValuesAsync();
            if (databaseEntry is null)
                // The record has been deleted from the database
                // Notify the user or handle the error in some other way
                throw new("The record has been deleted from the database.");
            T databaseValues = (T)databaseEntry.ToObject();
            // Compare the database values with the client values
            if (databaseValues.DataVersionNumber != clientValues.DataVersionNumber)
                // The name has been changed by another user
                // Notify the user or handle the error in some other way
                throw new("The record has been modified by another user.");
            // The conflict is caused by a property other than the name
            // Notify the user or handle the error in some other way
            throw new("A concurrency conflict occurred.");

            // Handle concurrency conflicts for other entity types, if necessary
        }
    }

    // public int Update<T>(IEnumerable<T> entities) where T : class, IMetadata {
    // 	try {
    // 		using GremlinDb gremlinDb = new();
    // 		gremlinDb.Set<T>().UpdateRange(entities);
    // 		return gremlinDb.SaveChanges();
    // 	}
    // 	catch (Exception exception) {
    // 		Console.WriteLine(exception.InnerException);
    // 		return 0;
    // 	}
    // }

    public static async Task<int> UpdateAsync<T>(IEnumerable<T> entities) where T : class, IMetadata {
        try {
            await Task.Run(() => gremlinDb.Set<T>().UpdateRange(entities));
            return await gremlinDb.SaveChangesAsync();
        }
        catch (Exception exception) {
            Console.WriteLine(exception.InnerException);
            return 0;
        }
    }

    public static async Task<int> RemoveAsync<T>(T entity) where T : class, IMetadata {
        try {
            await Task.Run(() => gremlinDb.Set<T>().Remove(entity));
            return await gremlinDb.SaveChangesAsync();
        }
        catch (Exception exception) {
            Console.WriteLine(exception.InnerException);
            return 0;
        }
    }

    // public async Task<Account?> ResolveAccountById(uint accountId){
    // 	try {
    // 		
    // 		if (gremlinDb.Accounts != null) 
    // 			return gremlinDb.Accounts.First(a => a.AccountId.Equals(accountId));
    // 		else {
    // 			return null;
    // 		}
    // 	}
    // 	catch (Exception exception){
    // 		Console.WriteLine(exception.InnerException);
    // 		return null;
    // 	}
    // }
}