COA.EnterpriseServices/COA.EnterpriseServices.DataAccess/DataAccessManager.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;

namespace COA.EnterpriseServices.DataAccess
{
    /// <summary>
    /// Provides a wrapper around <see cref="IDataAccess{T}"/> as well as additional convenience CRUD methods
    /// </summary>
    public class DataAccessManager
    {
        private static readonly IDictionary<string, string[]> enabledDataAccess = new Dictionary<string, string[]>
        {
            #region Creditor

            ["COA.EnterpriseServices.DataAccess.Entities.Creditor"] = new[]
            {
                "COA.EnterpriseServices.DataAccess.QuickBase.QuickBaseDataAccess",
                "COA.EnterpriseServices.DataAccess.EntityFramework.EntityDataAccess"
            },

            #endregion

            #region Client

            ["COA.EnterpriseServices.DataAccess.Entities.Client"] = new[]
            {
                "COA.EnterpriseServices.DataAccess.QuickBase.QuickBaseDataAccess",
                "COA.EnterpriseServices.DataAccess.EntityFramework.EntityDataAccess"
            }

            #endregion
        };

        public ICollection<T> Get<T>(Expression<Func<T, bool>> query) where T : class, IRecord
        {
            return Invoke<T, ICollection<T>>(d => d.Get(query));
        }

        public T Get<T>(int id) where T : class, IRecord
        {
            var item = Get<T>(i => i.Id == id);

            if (item != null && item.Any())
            {
                return item.FirstOrDefault();
            }

            return default;
        }

        public bool Add<T>(T item) where T : class, IRecord
        {
            return Invoke<T, bool>(d => d.Add(item));
        }

        public bool Update<T>(T item) where T : class, IRecord
        {
            item.Modified = DateTime.Now;

            return Invoke<T, bool>(d => d.Update(item));
        }

        public bool Update<T>(int id, Action<T> update) where T : class, IRecord
        {
            var item = Get<T>(id);

            update(item);

            return Update(item);
        }

        public ICollection<T> Raw<T>(string command, params object[] parameters) where T : class, IRecord
        {
            return Invoke<T, ICollection<T>>(d => d.Raw(command, parameters));
        }

        private TResult Invoke<T, TResult>(Func<IDataAccess<T>, TResult> func) where T : class, IRecord
        {
            var results = new List<TResult>();
            var dataAccessInstances = GetEnabledDataAccess<T>();

            foreach (var dataAccessInstance in dataAccessInstances)
            {
                results.Add(func(dataAccessInstance));
            }

            // if the "EF" version invokes first, return that value
            return results.FirstOrDefault(r => r != null && !r.Equals(default(TResult)));
        }

        private ICollection<IDataAccess<T>> GetEnabledDataAccess<T>() where T : class, IRecord
        {
            var type = typeof(T);

            // load data access based on active configuration
            return Dependencies.Container
                .GetAllInstances<IDataAccess<T>>()
                .Select(i => new
                {
                    Instance = i,
                    Type = i.GetType()
                })
                .Where(i => enabledDataAccess.ContainsKey(type.FullName) && enabledDataAccess[type.FullName].Any(a => i.Type.FullName.StartsWith(a)))
                .OrderBy(i => i.Type.Name.StartsWith("QuickBase", StringComparison.OrdinalIgnoreCase))
                .Select(i => i.Instance)
                .ToList();
        }
    }
}