BLL
internal class Blc<TEntity> : IBlc<TEntity>
{
private readonly IDao<TEntity> _dao;
public Blc(IDao<TEntity> dao)
{
_dao = dao;
}
/// <summary>
/// <inheritdoc cref="IBlc{TEntity}.GetAsync()"/>
/// </summary>
public async Task<IEnumerable<TEntity>> GetAsync()
{
var cache = _dao.GetFromCache();
if (cache != null && cache.Any())
{
return cache;
}
return await _dao.GetAsync();
}
/// <summary>
/// <inheritdoc cref="IBlc{TEntity}.GetAsync(Expression{Func{TEntity, bool}})"/>
/// </summary>
public async Task<IEnumerable<TEntity>> GetAsync(Expression<Func<TEntity, bool>> expression)
{
var cache = _dao.GetFromCache();
if (cache != null && cache.Any())
{
return cache.Where(expression);
}
return await _dao.GetAsync(expression);
}
/// <summary>
/// <inheritdoc cref="IBlc{TEntity}.InitializeAsync()"/>
/// </summary>
public async Task InitializeAsync()
{
var results = await _dao.GetAsync();
if (!results.Any())
{
var fileData = _dao.GetFromFile();
if (fileData == null || !fileData.Any())
{
throw new KeyNotFoundException("Unable to get refdata from MongoDb nor from its backup file");
}
await _dao.InsertManyAsync(fileData);
}
_dao.InsertCache(results.ToList());
}
}
public interface IBlc<TEntity>
{
/// <summary>
/// Gets a list of TEntity from MongoDb
/// </summary>
Task<IEnumerable<TEntity>> GetAsync();
/// <summary>
/// Gets a filtered list of TEntity
/// </summary>
/// <param name="expression">filter expression</param>
/// <example>await _blc.GetAsync(x => x.Id == 1);</example>
Task<IEnumerable<TEntity>> GetAsync(Expression<Func<TEntity, bool>> expression);
/// <summary>
/// Called during application StartUp.
/// Checks if data already exists in database.
/// If not, pulls backup data from a json file and inserts that into database,
/// then inserts the data into the cache.
/// </summary>
/// <exception cref="KeyNotFoundException"></exception>
Task InitializeAsync();
}
DAL
/// <summary>
/// Ideally, this class will not be called directly, but instead via Blc
/// </summary>
internal class Dao<TEntity> : IDao<TEntity> where TEntity : class
{
private readonly IMemoryCache _cache;
private readonly string _cacheKey;
private readonly string _backupFile;
private readonly IMongoCollection<TEntity> _mongoCollection;
private readonly IJsonFileReader _fileReader;
public Dao(
MongoClient client,
IOptionsMonitor<Dictionary<string, MongoCollectionConfiguration>> collectionConfigs,
IOptionsMonitor<AppSettings> appSettings,
IMemoryCache cache,
IJsonFileReader fileReader)
{
BsonClassMap.RegisterClassMap<TEntity>(cm =>
{
cm.AutoMap();
cm.SetIgnoreExtraElementsIsInherited(true);
cm.SetIgnoreExtraElements(true);
});
var database = client.GetDatabase(appSettings.CurrentValue.DbName);
var collectionConfig = collectionConfigs.CurrentValue.FirstOrDefault(x =>
x.Key.ToLowerInvariant() == typeof(TEntity).Name.ToLowerInvariant()).Value;
_cacheKey = collectionConfig.CacheKey;
_backupFile = collectionConfig.BackupFileName;
_mongoCollection = database.GetCollection<TEntity>(collectionConfig.CollectionName);
_cache = cache;
_fileReader = fileReader;
}
/// <summary>
/// <inheritdoc cref="IDao{TEntity}.GetAsync()"/>
/// </summary>
public async Task<IEnumerable<TEntity>> GetAsync()
{
try
{
var cursorResult = await _mongoCollection.FindAsync(_ => true);
return await cursorResult.ToListAsync();
}
catch (MongoException ex)
{
throw new DatabaseException(ex.ToString());
}
}
/// <summary>
/// <inheritdoc cref="IDao{TEntity}.GetAsync(Expression{Func{TEntity, bool}})"/>
/// </summary>
public async Task<IEnumerable<TEntity>> GetAsync(Expression<Func<TEntity, bool>> expression)
{
try
{
var filter = Builders<TEntity>.Filter.Where(expression);
var cursorResult = await _mongoCollection.FindAsync(filter);
return await cursorResult.ToListAsync();
}
catch (MongoException ex)
{
throw new DatabaseException(ex.ToString());
}
}
/// <summary>
/// <inheritdoc cref="IDao{TEntity}.InsertManyAsync(List{TEntity})"/>
/// </summary>
public async Task InsertManyAsync(List<TEntity> data)
{
try
{
await _mongoCollection.InsertManyAsync(data);
}
catch (MongoException ex)
{
throw new DatabaseInsertException(ex.ToString());
}
}
/// <summary>
/// <inheritdoc cref="IDao{TEntity}.GetFromFile"/>
/// </summary>
public List<TEntity> GetFromFile()
{
var json = _fileReader.ReadAllText(_backupFile);
return JsonSerializer.Deserialize<List<TEntity>>(json);
}
/// <summary>
/// <inheritdoc cref="IDao{TEntity}.GetFromCache"/>
/// </summary>
public IQueryable<TEntity> GetFromCache()
{
_cache.TryGetValue(_cacheKey, out IQueryable<TEntity> cacheResults);
return cacheResults;
}
/// <summary>
/// <inheritdoc cref="IDao{TEntity}.InsertCache(List{TEntity})"/>
/// </summary>
public void InsertCache(List<TEntity> data)
{
var cacheEntryOptions = new MemoryCacheEntryOptions()
.SetSlidingExpiration(TimeSpan.FromHours(12));
_cache.Set(_cacheKey, data, cacheEntryOptions);
}
}
public interface IDao<TEntity>
{
/// <summary>
/// Pulls a list of TEntity from MongoDb.
/// </summary>
Task<IEnumerable<TEntity>> GetAsync();
/// <summary>
/// Pulls a filtered list of TEntity from MongoDb.
/// Converts the given Linq expression to a Mongo filter.
/// </summary>
Task<IEnumerable<TEntity>> GetAsync(Expression<Func<TEntity, bool>> expression);
/// <summary>
/// Inserts many TEntity into MongoDb.
/// </summary>
/// <param name="data">the list to be inserted into MongoDb</param>
Task InsertManyAsync(List<TEntity> data);
/// <summary>
/// Pulls a list of TEntity from its assigned backup json file.
/// </summary>
List<TEntity> GetFromFile();
/// <summary>
/// Pulls a list of TEntity from cache.
/// </summary>
IQueryable<TEntity> GetFromCache();
/// <summary>
/// Inserts a list of TEntity into cache
/// </summary>
void InsertCache(List<TEntity> data);
}
