public virtual async Task <I> UpdateAsync(I entity)
{
entity.CheckArgument(nameof(entity));
entity.FirstItem.CheckArgument(nameof(entity.FirstItem));
entity.SecondItem.CheckArgument(nameof(entity.SecondItem));
var result = new E();
var updFirst = await FirstEntityController.UpdateAsync(entity.FirstItem).ConfigureAwait(false);
result.FirstEntity.CopyProperties(updFirst);
if (entity.SecondItem.Id == 0)
{
var pi = GetForeignKeyToOne();
if (pi != null)
{
pi.SetValue(entity.SecondItem, result.FirstEntity.Id);
}
var insSecond = await SecondEntityController.InsertAsync(entity.SecondItem).ConfigureAwait(false);
result.SecondEntity.CopyProperties(insSecond);
}
else
{
var updSecond = await SecondEntityController.UpdateAsync(entity.SecondItem).ConfigureAwait(false);
result.SecondEntity.CopyProperties(updSecond);
}
return(result);
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (disposing)
{
FirstEntityController.Dispose();
SecondEntityController.Dispose();
FirstEntityController = null;
SecondEntityController = null;
}
}
public virtual async Task DeleteAsync(int id)
{
var entity = await GetByIdAsync(id).ConfigureAwait(false);
if (entity != null)
{
if (entity.SecondItem.Id > 0)
{
await SecondEntityController.DeleteAsync(entity.SecondItem.Id).ConfigureAwait(false);
}
await FirstEntityController.DeleteAsync(entity.Id).ConfigureAwait(false);
}
else
{
throw new LogicException(ErrorType.InvalidId);
}
}
public virtual Task <IQueryable <I> > QueryAllAsync(string predicate)
{
return(Task.Run(async() =>
{
List <I> result = new List <I>();
foreach (var item in (await FirstEntityController.QueryAllAsync(predicate).ConfigureAwait(false)).ToList())
{
E entity = new E();
entity.FirstItem.CopyProperties(item);
await LoadSecondAsync(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 FirstEntityController.GetPageListAsync(pageIndex, pageSize).ConfigureAwait(false)).ToList())
{
E entity = new E();
entity.FirstItem.CopyProperties(item);
await LoadSecondAsync(entity, item.Id).ConfigureAwait(false);
result.Add(entity);
}
return result.AsQueryable();
}));
}
public virtual async Task <I> GetByIdAsync(int id)
{
var result = default(E);
var firstEntity = await FirstEntityController.GetByIdAsync(id).ConfigureAwait(false);
if (firstEntity != null)
{
var predicate = $"{typeof(TFirstEntity).Name}Id == {firstEntity.Id}";
result = new E();
result.FirstItem.CopyProperties(firstEntity);
await LoadSecondAsync(result, firstEntity.Id).ConfigureAwait(false);
}
else
{
throw new LogicException(ErrorType.InvalidId);
}
return(result);
}
public virtual async Task <I> InsertAsync(I entity)
{
entity.CheckArgument(nameof(entity));
entity.FirstItem.CheckArgument(nameof(entity.FirstItem));
entity.SecondItem.CheckArgument(nameof(entity.SecondItem));
var result = new E();
result.FirstEntity.CopyProperties(entity.FirstItem);
await FirstEntityController.InsertAsync(result.FirstEntity).ConfigureAwait(false);
result.SecondEntity.CopyProperties(entity.SecondItem);
var pi = GetNavigationToOne();
if (pi != null)
{
pi.SetValue(result.SecondEntity, result.FirstEntity);
}
await SecondEntityController.InsertAsync(result.SecondEntity).ConfigureAwait(false);
return(result);
}
public virtual Task <int> CountByAsync(string predicate)
{
return(FirstEntityController.CountByAsync(predicate));
}
public virtual Task <int> CountAsync()
{
return(FirstEntityController.CountAsync());
}
