///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Repository.GenericRepository`1.UpdateOne(`0,System.String,System.Object)"]/*'/>
public void UpdateOne(T t, string propertyName, object newValue)
{
using (DbContext newContext = (DbContext)Activator.CreateInstance(DataContext.GetType()))
{
T tToChange = FindByIdIncludesInNewContext(newContext, GenericToolsTypeAnalysis.GetKeysValues(t));
PropertyInfo propToChange = typeof(T).GetProperty(propertyName);
if (propToChange == null)
{
throw new PropertyNameNotFoundException(typeof(T), propertyName);
}
if (!propToChange.CanWrite)
{
throw new CannotWriteReadOnlyPropertyException(typeof(T), propertyName);
}
if (newValue != null && !propToChange.PropertyType.IsAssignableFrom(newValue.GetType()))
{
throw new InvalidArgumentsForClassException(typeof(T));
}
typeof(T).GetProperty(propertyName).SetValue(tToChange, newValue);
foreach (var entry in newContext.ChangeTracker.Entries())
{
entry.State = EntityState.Detached;
}
newContext.SaveChanges();
}
}
///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Repository.GenericRepository`1.SetNewParamFromContextList(System.Data.Entity.DbContext,GenericRepositoryAndService.Repository.GenericRepository{`0}.CustomParam)"]/*'/>
private CustomParam SetNewParamFromContextList(DbContext newContext, CustomParam customParam)
{
var newvalue = Convert.ChangeType(
Activator.CreateInstance(typeof(List <>).MakeGenericType(customParam.TypeofElement)),
typeof(List <>).MakeGenericType(customParam.TypeofElement)
);
if (customParam.Value != null)
{
foreach (object item in customParam.Value as IList)
{
object newitem;
if (item is BaseEntity entity)
{
newitem = newContext.Set(customParam.TypeofElement).Find(entity.Id);
}
else
{
object[] objs = GenericToolsTypeAnalysis.GetKeysValuesForType(item, customParam.TypeofElement);
newitem = GenericToolsCRUD.FindByKeysInNewContextForType(customParam.TypeofElement, newContext, objs);
}
((IList)newvalue).Add(newitem);
}
}
return(new CustomParam(
newvalue,
customParam.TypeofElement,
customParam.PropertyName,
customParam.Prop,
true
));
}
///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Service.GenericService`1.UpdateOneCrypted(`0,System.String,System.Object)"]/*'/>
public void UpdateOneCrypted(T t, string propertyName, object newValue)
{
T told = FindByIdExcludes(GenericToolsTypeAnalysis.GetKeysValues(t));
t = GenericToolsCRUDCrypt.CryptIfUpdatedOne(told, t, propertyName, newValue);
UpdateOne(t, propertyName, newValue);
}
///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Service.GenericService`1.UpdateCrypted(`0)"]/*'/>
public void UpdateCrypted(T t)
{
T told = FindByIdExcludes(GenericToolsTypeAnalysis.GetKeysValues(t));
t = GenericToolsCRUDCrypt.CryptIfUpdated(told, t);
Update(t);
}
///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Service.GenericService`1.Delete(`0)"]/*'/>
public void Delete(T t)
{
dynamic temprep = _repository;
GenericToolsCRUD.PrepareDelete <T>(temprep.DataContext, GenericToolsTypeAnalysis.GetKeysValues(t));
_repository.Delete(t);
}
public GenericRepository(DbContext dataContext)
{
DataContext = dataContext;
dbSet = DataContext.Set <T>();
_DynamicDBListTypes = GenericToolsTypeAnalysis.DynamicDBListTypes <T>();
_DynamicDBTypes = GenericToolsTypeAnalysis.DynamicDBTypes <T>();
}
///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Service.GenericService`1.FindByManyId(System.Boolean,System.Boolean,System.Object[])"]/*'/>
public List <T> FindByManyId(bool isIncludes, bool isTracked, params object[] objs)
{
GenericToolsTypeAnalysis.CheckIfObjsIsManyKeysOrIds <T>(objs);
List <T> lst = new List <T>();
if (typeof(BaseEntity).IsAssignableFrom(typeof(T)))
{
int?[] ids = GenericToolsTypeAnalysis.GetManyIds(objs);
foreach (int?id in ids)
{
if (!id.HasValue)
{
throw new IdNullForClassException(typeof(T));
}
lst.Add(_repository.FindById(isIncludes, isTracked, id.Value));
}
return(lst);
}
else
{
object[][] objectskeys = GenericToolsTypeAnalysis.GetManyKeys <T>(objs);
foreach (object[] keys in objectskeys)
{
lst.Add(_repository.FindById(isIncludes, isTracked, keys));
}
return(lst);
}
}
///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Repository.GenericRepository`1.FindById(System.Boolean,System.Boolean,System.Object[])"]/*'/>
public T FindById(bool isIncludes, bool isTracked, params object[] objs)
{
GenericToolsTypeAnalysis.CheckIfObjectIsKey <T>(objs);
return(GenericToolsQueriesAndLists.QueryWhereKeysAre(
Collection(isIncludes, isTracked),
objs
).SingleOrDefault());
}
///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Repository.GenericRepository`1.Add(`0)"]/*'/>
public void Add(T t)
{
if (GenericToolsTypeAnalysis.HasDynamicDBTypeOrListType <T>())
{
throw new CascadeCreationInDBException(typeof(T));
}
dbSet.Add(t);
}
///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Repository.GenericRepository`1.FindByIdIncludesInNewContext(System.Data.Entity.DbContext,System.Object[])"]/*'/>
private T FindByIdIncludesInNewContext(DbContext dbContext, params object[] objs)
{
GenericToolsTypeAnalysis.CheckIfObjectIsKey <T>(objs);
return(GenericToolsQueriesAndLists.QueryWhereKeysAre(
GenericToolsQueriesAndLists.QueryTInclude <T>(dbContext),
objs
).SingleOrDefault());
}
///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Service.GenericService`1.Delete(System.Object[])"]/*'/>
public void Delete(params object[] objs)
{
GenericToolsTypeAnalysis.CheckIfObjectIsKey <T>(objs);
dynamic temprep = _repository;
GenericToolsCRUD.PrepareDelete <T>(temprep.DataContext, objs);
_repository.Delete(objs);
}
///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Repository.GenericRepository`1.Modify(`0)"]/*'/>
public void Modify(T t)
{
if (GenericToolsTypeAnalysis.HasDynamicDBTypeOrListType <T>())
{
throw new CascadeCreationInDBException(typeof(T));
}
if (DataContext.Entry(t).State == EntityState.Detached)
{
dbSet.Attach(t);
}
DataContext.Entry(t).State = EntityState.Modified;
}
///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Repository.GenericRepository`1.Update(`0,System.Object[])"]/*'/>
public void Update(T t, params object[] objs)
{
if (GenericToolsTypeAnalysis.HasDynamicDBTypeOrListType <T>())
{
CustomParam[] props = SetCustom(objs);
UpdateGeneric(DataContext, t, props);
}
else
{
Modify(t);
Commit();
}
}
///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Repository.GenericRepository`1.Save(`0,System.Object[])"]/*'/>
public void Save(T t, params object[] objs)
{
if (GenericToolsTypeAnalysis.HasDynamicDBTypeOrListType <T>())
{
CustomParam[] props = SetCustom(objs);
SaveGeneric(t, props);
}
else
{
Add(t);
Commit();
}
}
///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Repository.GenericRepository`1.UpdateGeneric(System.Data.Entity.DbContext,`0,GenericRepositoryAndService.Repository.GenericRepository{`0}.CustomParam[])"]/*'/>
private void UpdateGeneric(DbContext context, T t, params CustomParam[] propss)
{
using (DbContext newContext = (DbContext)Activator.CreateInstance(context.GetType()))
{
T tToChange = FindByIdIncludesTrackedInNewContext(newContext, GenericToolsTypeAnalysis.GetKeysValues(t));
tToChange = ModifyOtherProperties(tToChange, t, propss);
List <CustomParam> newparams = SetNewParamsFromContext(newContext, propss);
foreach (CustomParam newparam in newparams)
{
typeof(T).GetProperty(newparam.PropertyName).SetValue(tToChange, newparam.Value);
}
newContext.Entry(tToChange).State = EntityState.Modified;
newContext.SaveChanges();
}
}
///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Repository.GenericRepository`1.SetNewParamFromContextNotList(System.Data.Entity.DbContext,GenericRepositoryAndService.Repository.GenericRepository{`0}.CustomParam)"]/*'/>
private CustomParam SetNewParamFromContextNotList(DbContext newContext, CustomParam customParam)
{
object newvalue = null;
if (customParam.Value != null)
{
if (customParam.Value is BaseEntity entity)
{
newvalue = newContext.Set(customParam.TypeofElement).Find(entity.Id);
}
else
{
object[] objs = GenericToolsTypeAnalysis.GetKeysValuesForType(customParam.Value, customParam.TypeofElement);
newvalue = GenericToolsCRUD.FindByKeysInNewContextForType(customParam.TypeofElement, newContext, objs);
}
}
return(new CustomParam(
newvalue,
customParam.TypeofElement,
customParam.PropertyName,
customParam.Prop,
false
));
}
///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Repository.GenericRepository`1.Remove(System.Object[])"]/*'/>
public void Remove(params object[] objs)
{
GenericToolsTypeAnalysis.CheckIfObjectIsKey <T>(objs);
Remove(FindByIdIncludes(objs));
}
///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Service.GenericService`1.FindById(System.Boolean,System.Boolean,System.Object[])"]/*'/>
public T FindById(bool isIncludes, bool isTracked, params object[] objs)
{
GenericToolsTypeAnalysis.CheckIfObjectIsKey <T>(objs);
return(_repository.FindById(isIncludes, isTracked, objs));
}
///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Repository.GenericRepository`1.Delete(System.Object[])"]/*'/>
public void Delete(params object[] objs)
{
GenericToolsTypeAnalysis.CheckIfObjectIsKey <T>(objs);
Remove(objs);
Commit();
}
///<include file='docs.xml' path='doc/members/member[@name="M:GenericRepositoryAndService.Repository.GenericRepository`1.SetCustom(System.Object[])"]/*'/>
private CustomParam[] SetCustom(params object[] objs)
{
CustomParam[] res = new CustomParam[_DynamicDBListTypes.Count() + _DynamicDBTypes.Count()];
int resindex = 0;
List <string> lkeysforlisttypes = _DynamicDBListTypes.Keys.ToList();
List <Type> ltypesforlisttpes = _DynamicDBListTypes.Values.ToList();
List <Type> lTlisttype = _DynamicDBListTypes.Values.Select(typ =>
typeof(List <>).MakeGenericType(typ)
).ToList();
List <string> lkeysfortypes = _DynamicDBTypes.Keys.ToList();
List <Type> lTtypes = _DynamicDBTypes.Values.ToList();
foreach (object obj in objs.Where(o => o != null))
{
bool isFound = false;
int i = 0;
if (obj is PropToNull proptonull)
{
isFound = true;
Type typeofprop = typeof(T).GetProperty(proptonull.PropertyName).PropertyType;
if (GenericToolsTypeAnalysis.TryListOfWhat(typeofprop, out Type innertype))
{
res[resindex] = CreateDefaultListCustomParamFromKey(proptonull.PropertyName);
lkeysforlisttypes.Remove(proptonull.PropertyName);
ltypesforlisttpes.Remove(innertype);
lTlisttype.Remove(typeof(List <>).MakeGenericType(innertype));
}
else
{
res[resindex] = CreateDefaultCustomParamFromKey(proptonull.PropertyName);
lkeysfortypes.Remove(proptonull.PropertyName);
lTtypes.Remove(typeofprop);
}
resindex++;
}
else
{
foreach (Type typ in lTlisttype)
{
try
{
var test = Convert.ChangeType(obj, typ);
isFound = true;
res[resindex] = CreateListCustomParamFromKey(lkeysforlisttypes[i], obj);
resindex++;
lkeysforlisttypes.RemoveAt(i);
ltypesforlisttpes.RemoveAt(i);
lTlisttype.RemoveAt(i);
break;
}
catch { }
i++;
}
i = 0;
if (!isFound)
{
foreach (Type typ in lTtypes)
{
try
{
var test = Convert.ChangeType(obj, typ);
isFound = true;
res[resindex] = CreateCustomParamFromKey(lkeysfortypes[i], obj);
resindex++;
lkeysfortypes.RemoveAt(i);
lTtypes.RemoveAt(i);
break;
}
catch { }
i++;
}
}
}
if (!isFound)
{
throw new InvalidArgumentsForClassException(typeof(T));
}
}
foreach (string key in lkeysforlisttypes)
{
res[resindex] = CreateDefaultListCustomParamFromKey(key);
resindex++;
}
foreach (string key in lkeysfortypes)
{
res[resindex] = CreateDefaultCustomParamFromKey(key);
resindex++;
}
return(res);
}
