public override async Task <I> UpdateAsync(I entity)
{
entity.CheckArgument(nameof(entity));
entity.OneItem.CheckArgument(nameof(entity.OneItem));
entity.AnotherItem.CheckArgument(nameof(entity.AnotherItem));
var result = new E();
var updOne = await OneEntityController.UpdateAsync(entity.OneItem).ConfigureAwait(false);
result.OneEntity.CopyProperties(updOne);
if (entity.AnotherItem.Id == 0)
{
var pi = GetForeignKeyToOne();
if (pi != null)
{
pi.SetValue(entity.AnotherItem, result.OneEntity.Id);
}
var insAnother = await AnotherEntityController.InsertAsync(entity.AnotherItem).ConfigureAwait(false);
result.AnotherEntity.CopyProperties(insAnother);
}
else
{
var updAnother = await AnotherEntityController.UpdateAsync(entity.AnotherItem).ConfigureAwait(false);
result.AnotherEntity.CopyProperties(updAnother);
}
return(await BeforeReturnAsync(result).ConfigureAwait(false));
}
public virtual async Task <I> InsertAsync(I entity)
{
entity.CheckArgument(nameof(entity));
entity.FirstItem.CheckArgument(nameof(entity.FirstItem));
entity.SecondItems.CheckArgument(nameof(entity.SecondItems));
var result = new E();
result.FirstEntity.CopyProperties(entity.FirstItem);
await OneEntityController.InsertAsync(result.FirstEntity).ConfigureAwait(false);
foreach (var item in entity.SecondItems)
{
var secondEntity = new TSecondEntity();
secondEntity.CopyProperties(item);
var pi = GetNavigationToOne();
if (pi != null)
{
pi.SetValue(secondEntity, result.FirstEntity);
}
await ManyEntityController.InsertAsync(secondEntity).ConfigureAwait(false);
result.AddSecondItem(secondEntity);
}
return(result);
}
protected virtual async Task LoadChildsAsync(E entity)
{
var piOneFK = GetForeignKeyToOne();
var piAnotherFK = GetForeignKeyToAnother();
if (piOneFK != null)
{
var value = piOneFK.GetValue(entity.ConnectorEntity);
if (value != null)
{
var child = await OneEntityController.GetByIdAsync((int)Convert.ChangeType(value, piOneFK.PropertyType)).ConfigureAwait(false);
if (child != null)
{
entity.OneEntity.CopyProperties(child);
}
}
}
if (piAnotherFK != null)
{
var value = piAnotherFK.GetValue(entity.ConnectorEntity);
if (value != null)
{
var child = await AnotherEntityController.GetByIdAsync((int)Convert.ChangeType(value, piAnotherFK.PropertyType)).ConfigureAwait(false);
if (child != null)
{
entity.AnotherEntity.CopyProperties(child);
}
}
}
}
public override async Task DeleteAsync(int id)
{
//Delete all costs that are no longer included in the list.
var identXRoles = await IdentityXRoleController.ExecuteQueryAllAsync(e => e.IdentityId == id);
foreach (var item in identXRoles)
{
await IdentityXRoleController.DeleteAsync(item.Id).ConfigureAwait(false);
}
await OneEntityController.DeleteAsync(id).ConfigureAwait(false);
}
public override async Task <I> InsertAsync(I entity)
{
entity.CheckArgument(nameof(entity));
entity.ConnectorItem.CheckArgument(nameof(entity.ConnectorItem));
entity.OneItem.CheckArgument(nameof(entity.OneItem));
entity.AnotherItem.CheckArgument(nameof(entity.AnotherItem));
var result = new E();
result.OneEntity.CopyProperties(entity.OneItem);
if (entity.OneItemIncludeSave)
{
if (result.OneEntity.Id == 0)
{
await OneEntityController.InsertAsync(result.OneEntity).ConfigureAwait(false);
var piNav = GetNavigationToOne();
if (piNav != null)
{
piNav.SetValue(result.ConnectorEntity, result.OneEntity);
}
}
else
{
await OneEntityController.UpdateAsync(result.OneEntity).ConfigureAwait(false);
}
}
result.AnotherEntity.CopyProperties(entity.AnotherItem);
if (entity.AnotherItemIncludeSave)
{
if (result.AnotherItem.Id == 0)
{
await AnotherEntityController.InsertAsync(result.AnotherEntity).ConfigureAwait(false);
var piNav = GetNavigationToAnother();
if (piNav != null)
{
piNav.SetValue(result.ConnectorEntity, result.AnotherEntity);
}
}
else
{
await AnotherEntityController.UpdateAsync(result.AnotherEntity).ConfigureAwait(false);
}
}
result.ConnectorEntity.CopyProperties(entity.ConnectorItem);
await ConnectorEntityController.InsertAsync(result.ConnectorEntity).ConfigureAwait(false);
return(await BeforeReturnAsync(result).ConfigureAwait(false));
}
public override async Task <IAppAccess> InsertAsync(IAppAccess entity)
{
entity.CheckArgument(nameof(entity));
entity.FirstItem.CheckArgument(nameof(entity.FirstItem));
entity.SecondItems.CheckArgument(nameof(entity.SecondItems));
var result = new AppAccess();
result.FirstEntity.CopyProperties(entity.FirstItem);
await OneEntityController.InsertAsync(result.FirstEntity).ConfigureAwait(false);
foreach (var item in entity.SecondItems)
{
var role = new Role();
var joinRole = new IdentityXRole();
joinRole.Identity = result.FirstEntity;
if (item.Id == 0)
{
item.Designation = RoleController.ClearRoleDesignation(item.Designation);
var qryItem = ManyEntityController.ExecuteQuery(e => e.Designation.Equals(item.Designation)).FirstOrDefault();
if (qryItem != null)
{
role.CopyProperties(qryItem);
joinRole.RoleId = role.Id;
}
else
{
role.CopyProperties(item);
await ManyEntityController.InsertAsync(role).ConfigureAwait(false);
joinRole.Role = role;
}
}
else
{
var qryItem = await ManyEntityController.GetByIdAsync(item.Id).ConfigureAwait(false);
if (qryItem != null)
{
role.CopyProperties(qryItem);
}
joinRole.RoleId = role.Id;
}
await IdentityXRoleController.InsertAsync(joinRole).ConfigureAwait(false);
result.AddSecondItem(role);
}
return(result);
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (disposing)
{
OneEntityController.Dispose();
ManyEntityController.Dispose();
OneEntityController = null;
ManyEntityController = null;
}
}
internal override async Task <E> InsertAsync(E entity)
{
entity.CheckArgument(nameof(entity));
entity.OneEntity.CheckArgument(nameof(entity.OneEntity));
entity.ManyEntities.CheckArgument(nameof(entity.ManyEntities));
await OneEntityController.InsertAsync(entity.OneEntity).ConfigureAwait(false);
foreach (var item in entity.ManyEntities)
{
SetNavigationToParent(item, entity.OneEntity);
await ManyEntityController.InsertAsync(item).ConfigureAwait(false);
}
return(await BeforeReturnAsync(entity).ConfigureAwait(false));
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (disposing)
{
ChangedSessionToken -= HandleChangedSessionToken;
OneEntityController.Dispose();
ManyEntityController.Dispose();
OneEntityController = null;
ManyEntityController = null;
}
}
public override async Task <IEnumerable <I> > QueryAllAsync(string predicate)
{
var result = new List <E>();
var query = await OneEntityController.QueryAllAsync(predicate).ConfigureAwait(false);
foreach (var item in query)
{
E entity = new E();
entity.OneItem.CopyProperties(item);
await LoadDetailsAsync(entity, item.Id).ConfigureAwait(false);
result.Add(entity);
}
return(await BeforeReturnAsync(result).ConfigureAwait(false));
}
public override async Task <IEnumerable <I> > GetPageListAsync(int pageIndex, int pageSize)
{
var result = new List <E>();
var query = await OneEntityController.GetPageListAsync(pageIndex, pageSize).ConfigureAwait(false);
foreach (var item in query)
{
E entity = new E();
entity.OneItem.CopyProperties(item);
await LoadDetailsAsync(entity, item.Id).ConfigureAwait(false);
result.Add(entity);
}
return(await BeforeReturnAsync(result).ConfigureAwait(false));
}
public override async Task DeleteAsync(int id)
{
var entity = await GetByIdAsync(id).ConfigureAwait(false);
if (entity != null)
{
if (entity.AnotherItem.Id > 0)
{
await AnotherEntityController.DeleteAsync(entity.AnotherItem.Id).ConfigureAwait(false);
}
await OneEntityController.DeleteAsync(entity.Id).ConfigureAwait(false);
}
else
{
throw new LogicException(ErrorType.InvalidId);
}
}
public virtual async Task DeleteAsync(int id)
{
var entity = await GetByIdAsync(id).ConfigureAwait(false);
if (entity != null)
{
foreach (var item in entity.SecondItems)
{
await ManyEntityController.DeleteAsync(item.Id).ConfigureAwait(false);
}
await OneEntityController.DeleteAsync(entity.Id).ConfigureAwait(false);
}
else
{
throw new LogicException(ErrorType.InvalidId);
}
}
public override async Task <I> GetByIdAsync(int id)
{
E result;
var oneEntity = await OneEntityController.GetByIdAsync(id).ConfigureAwait(false);
if (oneEntity != null)
{
result = new E();
result.OneItem.CopyProperties(oneEntity);
await LoadAnotherAsync(result, oneEntity.Id).ConfigureAwait(false);
}
else
{
throw new LogicException(ErrorType.InvalidId);
}
return(await BeforeReturnAsync(result).ConfigureAwait(false));
}
public virtual async Task <I> GetByIdAsync(int id)
{
var result = default(E);
var firstEntity = await OneEntityController.GetByIdAsync(id).ConfigureAwait(false);
if (firstEntity != null)
{
result = new E();
result.FirstItem.CopyProperties(firstEntity);
await LoadDetailsAsync(result, firstEntity.Id).ConfigureAwait(false);
}
else
{
throw new LogicException(ErrorType.InvalidId);
}
return(result);
}
public override async Task <I> UpdateAsync(I entity)
{
entity.CheckArgument(nameof(entity));
entity.OneItem.CheckArgument(nameof(entity.OneItem));
entity.ManyItems.CheckArgument(nameof(entity.ManyItems));
var query = (await QueryDetailsAsync(entity.Id).ConfigureAwait(false)).ToList();
//Delete all costs that are no longer included in the list.
foreach (var item in query)
{
var exitsItem = entity.ManyItems.SingleOrDefault(i => i.Id == item.Id);
if (exitsItem == null)
{
await ManyEntityController.DeleteAsync(item.Id).ConfigureAwait(false);
}
}
var result = new E();
var oneEntity = await OneEntityController.UpdateAsync(entity.OneItem).ConfigureAwait(false);
result.OneItem.CopyProperties(oneEntity);
foreach (var item in entity.ManyItems)
{
if (item.Id == 0)
{
var pi = GetForeignKeyToOne();
if (pi != null)
{
pi.SetValue(item, oneEntity.Id);
}
var insDetail = await ManyEntityController.InsertAsync(item).ConfigureAwait(false);
item.CopyProperties(insDetail);
}
else
{
var updDetail = await ManyEntityController.UpdateAsync(item).ConfigureAwait(false);
item.CopyProperties(updDetail);
}
}
return(await BeforeReturnAsync(result).ConfigureAwait(false));
}
public virtual Task <IQueryable <I> > QueryAllAsync(string predicate)
{
return(Task.Run(async() =>
{
List <I> result = new List <I>();
foreach (var item in (await OneEntityController.QueryAllAsync(predicate).ConfigureAwait(false)).ToList())
{
E entity = new E();
entity.FirstItem.CopyProperties(item);
await LoadDetailsAsync(entity, item.Id).ConfigureAwait(false);
result.Add(entity);
}
return result.AsQueryable();
}));
}
public virtual Task <IQueryable <I> > GetPageListAsync(int pageIndex, int pageSize)
{
return(Task.Run(async() =>
{
List <I> result = new List <I>();
foreach (var item in (await OneEntityController.GetPageListAsync(pageIndex, pageSize).ConfigureAwait(false)).ToList())
{
E entity = new E();
entity.FirstItem.CopyProperties(item);
await LoadDetailsAsync(entity, item.Id).ConfigureAwait(false);
result.Add(entity);
}
return result.AsQueryable();
}));
}
internal override async Task <E> UpdateAsync(E entity)
{
entity.CheckArgument(nameof(entity));
entity.OneItem.CheckArgument(nameof(entity.OneItem));
entity.ManyItems.CheckArgument(nameof(entity.ManyItems));
var query = (await QueryDetailsAsync(entity.Id).ConfigureAwait(false)).ToList();
//Delete all costs that are no longer included in the list.
foreach (var item in query)
{
var exitsItem = entity.ManyItems.SingleOrDefault(i => i.Id == item.Id);
if (exitsItem == null)
{
await ManyEntityController.DeleteAsync(item.Id).ConfigureAwait(false);
}
}
await OneEntityController.UpdateAsync(entity.OneItem).ConfigureAwait(false);
foreach (var item in entity.ManyItems)
{
if (item.Id == 0)
{
var pi = GetForeignKeyToOne();
if (pi != null)
{
pi.SetValue(item, entity.OneEntity.Id);
}
await ManyEntityController.InsertAsync(item).ConfigureAwait(false);
}
else
{
await ManyEntityController.UpdateAsync(item).ConfigureAwait(false);
}
}
return(await BeforeReturnAsync(entity).ConfigureAwait(false));
}
public override async Task <I> InsertAsync(I entity)
{
entity.CheckArgument(nameof(entity));
entity.OneItem.CheckArgument(nameof(entity.OneItem));
entity.AnotherItem.CheckArgument(nameof(entity.AnotherItem));
var result = new E();
result.OneEntity.CopyProperties(entity.OneItem);
await OneEntityController.InsertAsync(result.OneEntity).ConfigureAwait(false);
result.AnotherEntity.CopyProperties(entity.AnotherItem);
var pi = GetNavigationToOne();
if (pi != null)
{
pi.SetValue(result.AnotherEntity, result.OneEntity);
}
await AnotherEntityController.InsertAsync(result.AnotherEntity).ConfigureAwait(false);
return(await BeforeReturnAsync(result).ConfigureAwait(false));
}
public override async Task <I> InsertAsync(I entity)
{
entity.CheckArgument(nameof(entity));
entity.OneItem.CheckArgument(nameof(entity.OneItem));
entity.ManyItems.CheckArgument(nameof(entity.ManyItems));
var result = new E();
result.OneEntity.CopyProperties(entity.OneItem);
await OneEntityController.InsertAsync(result.OneEntity).ConfigureAwait(false);
foreach (var item in entity.ManyItems)
{
var manyEntity = new TManyEntity();
manyEntity.CopyProperties(item);
SetNavigationToParent(manyEntity, result.OneEntity);
await ManyEntityController.InsertAsync(manyEntity).ConfigureAwait(false);
result.AddManyItem(manyEntity);
}
return(await BeforeReturnAsync(result).ConfigureAwait(false));
}
public override async Task <IAppAccess> UpdateAsync(IAppAccess entity)
{
entity.CheckArgument(nameof(entity));
entity.FirstItem.CheckArgument(nameof(entity.FirstItem));
entity.SecondItems.CheckArgument(nameof(entity.SecondItems));
var accessRoles = entity.SecondItems.Select(i =>
{
var entity = new Role();
i.Designation = RoleController.ClearRoleDesignation(i.Designation);
if (entity.Id == 0)
{
var role = ManyEntityController.ExecuteQuery(e => e.Designation.Equals(i.Designation))
.FirstOrDefault();
if (role != null)
{
entity.CopyProperties(role);
}
}
return(entity);
});
//Delete all costs that are no longer included in the list.
var identityXRoles = await IdentityXRoleController.ExecuteQueryAllAsync(e => e.IdentityId == entity.Id).ConfigureAwait(false);
foreach (var item in identityXRoles)
{
var stillHasTheRole = accessRoles.Any(i => i.Id == item.RoleId);
if (stillHasTheRole == false)
{
await IdentityXRoleController.DeleteAsync(item.Id).ConfigureAwait(false);
}
}
var result = new AppAccess();
var firstEntity = await OneEntityController.UpdateAsync(entity.FirstItem).ConfigureAwait(false);
result.FirstItem.CopyProperties(firstEntity);
foreach (var accessRole in accessRoles)
{
var role = new Role();
var joinRole = new IdentityXRole();
role.Id = accessRole.Id;
joinRole.IdentityId = firstEntity.Id;
if (accessRole.Id == 0)
{
role.CopyProperties(accessRole);
await ManyEntityController.InsertAsync(role).ConfigureAwait(false);
joinRole.Role = role;
}
else
{
var qryRole = await ManyEntityController.GetByIdAsync(role.Id).ConfigureAwait(false);
if (qryRole != null)
{
role.CopyProperties(qryRole);
joinRole.RoleId = role.Id;
}
}
var identityXRole = identityXRoles.SingleOrDefault(e => e.IdentityId == joinRole.IdentityId && e.RoleId == joinRole.RoleId);
if (identityXRole == null)
{
await IdentityXRoleController.InsertAsync(joinRole).ConfigureAwait(false);
}
result.AddSecondItem(role);
}
return(result);
}
public override Task <int> CountByAsync(string predicate)
{
return(OneEntityController.CountByAsync(predicate));
}
public virtual Task <int> CountAsync()
{
return(OneEntityController.CountAsync());
}
public virtual Task <int> CountByAsync(string predicate)
{
return(OneEntityController.CountByAsync(predicate));
}
public override Task <int> CountAsync()
{
return(OneEntityController.CountAsync());
}
