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);
}
}
/// <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 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 IEnumerable <T> Deactivate <T>(IEnumerable <T> models, bool useWriteDb = false) where T : BaseDateRangeModel
{
using (var db = new RxSenseDb(useWriteDb))
{
foreach (var model in models)
{
model.IsActive = false;
model.ModifiedDate = DateTime.UtcNow;
model.DeactivatedDate = model.ModifiedDate;
db.Entry(model).State = EntityState.Modified;
}
db.SaveChanges();
}
return(models);
}
/// <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);
}
}
