/// <summary>
/// Deactivate all models that have been "resolved", i.e. date range adjusted, or inactivated.
/// Add new records for "resolved" rows. Add the new record that hit all the conflicts to begin with.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="models"></param>
/// <param name="useWriteDb"></param>
/// <param name="isUpdateOnly"></param>
/// <returns></returns>
public static IEnumerable <T> SaveConflictResolution <T>(IEnumerable <T> models, bool useWriteDb = false, bool isUpdateOnly = false) where T : BaseDateRangeModel
{
var modelsList = models.ToList();
// Can't premptive check here because some BO's have extended matching criteria that would get ignored.
// Do it in BO layer. See CopayRuleBO.GetConflicts for example.
//var hasPendingConflicts = GetConflicts<T>(modelsList).Any();
//if (hasPendingConflicts)
//{
// throw new Exception("Cannot save this resolution because some conflicts remain.");
//}
using (var db = new RxSenseDb(useWriteDb))
{
foreach (var model in modelsList)
{
if (!isUpdateOnly && model.IDateRangeId == 0) //add new model only if isUpdateOnly is false.
{
db.Set <T>().Add(model);
continue;
}
var dbModel = db.Set <T>().Find(model.IDateRangeId);
if (dbModel != null && //found a dbModel
(dbModel.StartDate != model.StartDate || //and there is some edit to this dbModel
dbModel.EndDate != model.EndDate ||
dbModel.IsActive != model.IsActive))
{
//deactivate, regardless of if this is a deactivation or a date adjustment
//inactives stay inactive and keep deactivated date as is
dbModel.IsActive = false;
dbModel.DeactivatedDate = dbModel.DeactivatedDate ?? DateTime.UtcNow;
if (model.IsActive && //not a deactivate; maybe a "reactivate", still yields new record
(dbModel.StartDate != model.StartDate || //or is an effDateRange adjustment
dbModel.EndDate != model.EndDate))
{
db.Set <T>().Add(model);
}
}
}
db.SaveChanges();
}
//Set DeactivatedDate and ModifiedDate for return
foreach (var mdl in modelsList.Where(x => x.IsActive == false))
{
mdl.DeactivatedDate = mdl.DeactivatedDate ?? DateTime.UtcNow;
mdl.ModifiedDate = DateTime.UtcNow;
}
return(modelsList);
}
public static bool Contains <T>(Func <T, string> property, string value) where T : BaseModel
{
using (var db = new RxSenseDb())
{
var items = db.Set <T>().Select(property);
return(items.Contains(value, StringComparer.OrdinalIgnoreCase));
}
}
public static List <T> GetAll <T>() where T : BaseModel
{
using (var db = new RxSenseDb())
{
var results = db.Set <T>().ToList();
return(results);
}
}
public static async Task <T> GetAsync <T>(int id) where T : BaseModel
{
using (var db = new RxSenseDb())
{
var item = await db.Set <T>().FindAsync(id);
return(item);
}
}
public static T Get <T>(int id) where T : BaseModel
{
using (var db = new RxSenseDb())
{
var item = db.Set <T>().Find(id);
return(item);
}
}
public static int Count <T>(
Expression <Func <T, bool> > predicate,
bool useWriteDb = false)
where T : BaseModel
{
using (var db = new RxSenseDb(useWriteDb))
{
var dbSet = db.Set <T>().AsQueryable();
return(dbSet.Where(predicate).Count());
}
}
public static async Task <T> AddOrUpdateAsync <T>(T model, bool useWritedb = true) where T : BaseModel
{
using (var db = new RxSenseDb(useWritedb))
{
db.Set <T>().AddOrUpdate(model);
await db.SaveChangesAsync();
return(model);
}
}
public static async Task <T> AddAsync <T>(
T model) where T : BaseModel
{
using (var db = new RxSenseDb())
{
db.Set <T>().Add(model);
await db.SaveChangesAsync();
return(model);
}
}
/// <summary>
/// Given an EffDated model, finds all DB records
/// that satisfy matching criteria, per EffectiveDateMatchingCriteria
/// (i.e. finda all "versions" of this record).
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="model"></param>
/// <param name="filter"></param>
/// <param name="useWriteDb"></param>
/// <returns></returns>
public static IEnumerable <T> GetEffectiveMatches <T>(T model,
bool useWriteDb = false,
Expression <Func <T, bool> > filter = null,
params Expression <Func <T, object> >[] includes)
where T : BaseDateRangeModel
{
var type = typeof(T); //model.GetType();
var tablettribute = (TableAttribute)Attribute.GetCustomAttribute(type, typeof(TableAttribute));
var matchingCriteria = EffectiveDateMatchingCriteria[tablettribute.Name];
var predicate = PredicateBuilder.True <T>();
foreach (var matchingCriterion in matchingCriteria)
{
var prop = type.GetProperty(matchingCriterion);
if (prop == null)
{
throw new Exception("EffectiveDateMatchingCriteria lookup failed.");
}
var propVal = prop.GetValue(model);
var param = Expression.Parameter(typeof(T), "x"); //"x =>"
var expr = Expression.Lambda <Func <T, bool> >( //x.param
Expression.Equal( // ==
Expression.Property(param, matchingCriterion), //propVal
Expression.Convert(Expression.Constant(propVal),
prop.PropertyType)),
param);
predicate = predicate.And(expr);
}
if (filter != null)
{
predicate = predicate.And(filter);
}
using (var db = new RxSenseDb(useWriteDb))
{
var query = db.Set <T>()
.AsQueryable();
foreach (var include in includes)
{
query.Include(include);
}
return(query
.Where(predicate)
.ToList()); //concrete the results since this db context will be disposed
}
}
public static async Task <T> UpdateAsync <T>(T model) where T : BaseModel
{
using (var db = new RxSenseDb())
{
db.Set <T>().Attach(model);
db.Entry(model).State = EntityState.Modified;
await db.SaveChangesAsync();
return(model);
}
}
public static List <T> AddRange <T>(List <T> models) where T : BaseModel
{
if (models?.Count > 0)
{
using (var db = new RxSenseDb())
{
db.Set <T>().AddRange(models);
db.SaveChanges();
}
}
return(models);
}
public static T AddOrUpdate <T>
(T model,
bool useWriteDb = false)
where T : BaseModel
{
using (var db = new RxSenseDb(useWriteDb))
{
db.Set <T>().AddOrUpdate(model);
db.SaveChanges();
return(model);
}
}
public static T Update <T>(
T model,
bool useWriteDb = false)
where T : BaseModel
{
using (var db = new RxSenseDb(useWriteDb))
{
db.Set <T>().Attach(model);
db.Entry(model).State = EntityState.Modified;
db.SaveChanges();
return(model);
}
}
public static async Task <T> GetAsync <T>(Expression <Func <T, bool> > predicate, params Expression <Func <T, object> >[] includes) where T : BaseModel
{
using (var db = new RxSenseDb())
{
var dbSet = db.Set <T>().AsQueryable();
foreach (var property in includes)
{
dbSet = dbSet.Include(property);
}
var result = await dbSet.SingleOrDefaultAsync(predicate);
return(result);
}
}
public static List <T> Query <T>(
Expression <Func <T, bool> > predicate,
bool useWriteDb = false,
params Expression <Func <T, object> >[] includes)
where T : BaseModel
{
using (var db = new RxSenseDb(useWriteDb))
{
var dbSet = db.Set <T>().AsQueryable();
foreach (var property in includes)
{
dbSet = dbSet.Include(property);
}
return(dbSet.Where(predicate).ToList());
}
}
/// <summary>
/// Given a T model, find Db record based on EffectiveDateMatchingCriteria
/// and IDateRangeId (PK Id), and set record to inactive if not already so.
/// Also record DeactivatedDate as UtcNow.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="model"></param>
/// <param name="useWriteDb"></param>
/// <returns></returns>
public static T Deactivate <T>(T model, bool useWriteDb = false) where T : BaseDateRangeModel
{
using (var db = new RxSenseDb(useWriteDb))
{
var matches = GetEffectiveMatches(model);
var dbModel = matches.FirstOrDefault(x => x.IDateRangeId == model.IDateRangeId);
if (dbModel != null)
{
db.Set <T>().Attach(dbModel); //because GetEffectiveMatches db context is out of scope
dbModel.IsActive = false;
dbModel.DeactivatedDate = DateTime.UtcNow;
db.SaveChanges();
}
return(dbModel);
}
}
