public Task <PersonDetailCollectionResult> GetDetailByArgsAsync(PersonArgs?args, PagingArgs?paging)
{
return(ManagerInvoker.Default.InvokeAsync(this, async() =>
{
ExecutionContext.Current.OperationType = OperationType.Read;
EntityBase.CleanUp(args);
if (_getDetailByArgsOnPreValidateAsync != null)
{
await _getDetailByArgsOnPreValidateAsync(args, paging).ConfigureAwait(false);
}
MultiValidator.Create()
.Add(args.Validate(nameof(args)).Entity(PersonArgsValidator.Default))
.Additional((__mv) => _getDetailByArgsOnValidate?.Invoke(__mv, args, paging))
.Run().ThrowOnError();
if (_getDetailByArgsOnBeforeAsync != null)
{
await _getDetailByArgsOnBeforeAsync(args, paging).ConfigureAwait(false);
}
var __result = await PersonDataSvc.GetDetailByArgsAsync(args, paging).ConfigureAwait(false);
if (_getDetailByArgsOnAfterAsync != null)
{
await _getDetailByArgsOnAfterAsync(__result, args, paging).ConfigureAwait(false);
}
Cleaner.Clean(__result);
return __result;
}));
}
public Task <Person> MergeAsync(Guid fromId, Guid toId)
{
return(ManagerInvoker.Default.InvokeAsync(this, async() =>
{
ExecutionContext.Current.OperationType = OperationType.Update;
EntityBase.CleanUp(fromId, toId);
if (_mergeOnPreValidateAsync != null)
{
await _mergeOnPreValidateAsync(fromId, toId).ConfigureAwait(false);
}
MultiValidator.Create()
.Add(fromId.Validate(nameof(fromId)).Mandatory())
.Add(toId.Validate(nameof(toId)).Mandatory().CompareValue(CompareOperator.NotEqual, fromId, nameof(fromId).ToSentenceCase() !))
.Additional((__mv) => _mergeOnValidate?.Invoke(__mv, fromId, toId))
.Run().ThrowOnError();
if (_mergeOnBeforeAsync != null)
{
await _mergeOnBeforeAsync(fromId, toId).ConfigureAwait(false);
}
var __result = await PersonDataSvc.MergeAsync(fromId, toId).ConfigureAwait(false);
if (_mergeOnAfterAsync != null)
{
await _mergeOnAfterAsync(__result, fromId, toId).ConfigureAwait(false);
}
Cleaner.Clean(__result);
return __result;
}));
public Task <Person> UpdateAsync(Person value, Guid id)
{
value.Validate(nameof(value)).Mandatory().Run().ThrowOnError();
return(ManagerInvoker.Default.InvokeAsync(this, async() =>
{
ExecutionContext.Current.OperationType = OperationType.Update;
value.Id = id;
EntityBase.CleanUp(value, id);
if (_updateOnPreValidateAsync != null)
{
await _updateOnPreValidateAsync(value, id).ConfigureAwait(false);
}
MultiValidator.Create()
.Add(value.Validate(nameof(value)).Entity(PersonValidator.Default))
.Additional((__mv) => _updateOnValidate?.Invoke(__mv, value, id))
.Run().ThrowOnError();
if (_updateOnBeforeAsync != null)
{
await _updateOnBeforeAsync(value, id).ConfigureAwait(false);
}
var __result = await PersonDataSvc.UpdateAsync(value).ConfigureAwait(false);
if (_updateOnAfterAsync != null)
{
await _updateOnAfterAsync(__result, id).ConfigureAwait(false);
}
Cleaner.Clean(__result);
return __result;
}));
}
public Task <Person?> GetAsync(Guid id)
{
return(ManagerInvoker.Default.InvokeAsync(this, async() =>
{
ExecutionContext.Current.OperationType = OperationType.Read;
EntityBase.CleanUp(id);
if (_getOnPreValidateAsync != null)
{
await _getOnPreValidateAsync(id).ConfigureAwait(false);
}
MultiValidator.Create()
.Add(id.Validate(nameof(id)).Mandatory())
.Additional((__mv) => _getOnValidate?.Invoke(__mv, id))
.Run().ThrowOnError();
if (_getOnBeforeAsync != null)
{
await _getOnBeforeAsync(id).ConfigureAwait(false);
}
var __result = await PersonDataSvc.GetAsync(id).ConfigureAwait(false);
if (_getOnAfterAsync != null)
{
await _getOnAfterAsync(__result, id).ConfigureAwait(false);
}
Cleaner.Clean(__result);
return __result;
}));
}
public Task DeleteAsync(Guid id)
{
return(ManagerInvoker.Default.InvokeAsync(this, async() =>
{
ExecutionContext.Current.OperationType = OperationType.Delete;
EntityBase.CleanUp(id);
if (_deleteOnPreValidateAsync != null)
{
await _deleteOnPreValidateAsync(id).ConfigureAwait(false);
}
MultiValidator.Create()
.Add(id.Validate(nameof(id)).Mandatory())
.Additional((__mv) => _deleteOnValidate?.Invoke(__mv, id))
.Run().ThrowOnError();
if (_deleteOnBeforeAsync != null)
{
await _deleteOnBeforeAsync(id).ConfigureAwait(false);
}
await PersonDataSvc.DeleteAsync(id).ConfigureAwait(false);
if (_deleteOnAfterAsync != null)
{
await _deleteOnAfterAsync(id).ConfigureAwait(false);
}
}));
}
/// <summary>
/// Creates the <see cref="Person"/> object.
/// </summary>
/// <param name="value">The <see cref="Person"/> object.</param>
/// <returns>A refreshed <see cref="Person"/> object.</returns>
public Task <Person> CreateWithEfAsync(Person value)
{
return(ManagerInvoker.Default.InvokeAsync(this, async() =>
{
ExecutionContext.Current.OperationType = OperationType.Create;
EntityBase.CleanUp(value);
if (_createWithEfOnPreValidateAsync != null)
{
await _createWithEfOnPreValidateAsync(value);
}
MultiValidator.Create()
.Add(value.Validate(nameof(value)).Mandatory().Entity(PersonValidator.Default))
.Additional((__mv) => _createWithEfOnValidate?.Invoke(__mv, value))
.Run().ThrowOnError();
if (_createWithEfOnBeforeAsync != null)
{
await _createWithEfOnBeforeAsync(value);
}
var __result = await PersonDataSvc.CreateWithEfAsync(value);
if (_createWithEfOnAfterAsync != null)
{
await _createWithEfOnAfterAsync(__result);
}
Cleaner.Clean(__result);
return __result;
}));
}
/// <summary>
/// Mark <see cref="Person"/>.
/// </summary>
public Task MarkAsync()
{
return(ManagerInvoker.Default.InvokeAsync(this, async() =>
{
ExecutionContext.Current.OperationType = OperationType.Update;
if (_markOnBeforeAsync != null)
{
await _markOnBeforeAsync().ConfigureAwait(false);
}
await PersonDataSvc.MarkAsync().ConfigureAwait(false);
if (_markOnAfterAsync != null)
{
await _markOnAfterAsync().ConfigureAwait(false);
}
}));
}
public Task <PersonCollectionResult> GetAll2Async()
{
return(ManagerInvoker.Default.InvokeAsync(this, async() =>
{
ExecutionContext.Current.OperationType = OperationType.Read;
if (_getAll2OnBeforeAsync != null)
{
await _getAll2OnBeforeAsync().ConfigureAwait(false);
}
var __result = await PersonDataSvc.GetAll2Async().ConfigureAwait(false);
if (_getAll2OnAfterAsync != null)
{
await _getAll2OnAfterAsync(__result).ConfigureAwait(false);
}
Cleaner.Clean(__result);
return __result;
}));
}
/// <summary>
/// Validate a DataSvc Custom generation.
/// </summary>
/// <returns>A resultant <see cref="int"/>.</returns>
public Task <int> DataSvcCustomAsync()
{
return(ManagerInvoker.Default.InvokeAsync(this, async() =>
{
ExecutionContext.Current.OperationType = OperationType.Unspecified;
if (_dataSvcCustomOnBeforeAsync != null)
{
await _dataSvcCustomOnBeforeAsync().ConfigureAwait(false);
}
var __result = await PersonDataSvc.DataSvcCustomAsync().ConfigureAwait(false);
if (_dataSvcCustomOnAfterAsync != null)
{
await _dataSvcCustomOnAfterAsync(__result).ConfigureAwait(false);
}
Cleaner.Clean(__result);
return __result;
}));
}
