public async Task <ChangeSetResponse> ServiceApplyChangeSet(ChangeSetRequest changeSet)
{
ICRUDOperationsUseCaseFactory factory = ServiceContainer.CRUDOperationsUseCaseFactory;
CRUDServiceMethods serviceMethods = new CRUDServiceMethods(
(err) => { _OnError(err); return(GetFriendlyErrorMessage(err)); },
(row) => TrackChangesToEntity(row),
async() =>
{
await ExecuteChangeSet();
},
async() =>
{
await AfterExecuteChangeSet(changeSet);
},
async(subResults) =>
{
await AfterChangeSetCommited(changeSet, subResults);
});
ICRUDOperationsUseCase uc = factory.Create(this, serviceMethods);
IResponsePresenter <ChangeSetResponse, ChangeSetResponse> output = ServiceContainer.GetRequiredService <IResponsePresenter <ChangeSetResponse, ChangeSetResponse> >();
bool res = await uc.Handle(changeSet, output);
return(output.Response);
}
public static RequestContext CreateRequestContext(TService service, ChangeSetRequest changeSet, RowInfo rowInfo = null)
{
DbSet dbSet = rowInfo == null ? null : changeSet.dbSets.Where(d => d.dbSetName == rowInfo.GetDbSetInfo().dbSetName).Single();
return(new RequestContext(service, changeSet: changeSet, dbSet: dbSet, rowInfo: rowInfo,
operation: ServiceOperationType.SaveChanges));
}
/// <summary>
/// Refresh Customer's custom ServerCalculated field 'AddressCount' on insert or delete
/// </summary>
/// <param name="changeSet"></param>
/// <param name="refreshResult"></param>
/// <returns></returns>
public override async Task AfterChangeSetCommited(ChangeSetRequest changeSet, SubResultList refreshResult)
{
DbSetInfo custAddrDbSet = this.GetSetInfosByEntityType(typeof(CustomerAddress)).Single();
DbSetInfo customerDbSet = this.GetSetInfosByEntityType(typeof(Customer)).Single();
DbSet dbCustAddr = changeSet.dbSets.FirstOrDefault(d => d.dbSetName == custAddrDbSet.dbSetName);
if (dbCustAddr != null)
{
int[] custIDs = dbCustAddr.rows.Where(r => r.changeType == ChangeType.Deleted || r.changeType == ChangeType.Added).Select(r => r.values.First(v => v.fieldName == "CustomerId").val).Select(id => int.Parse(id)).ToArray();
System.Collections.Generic.List <Customer> customersList = await DB.Customer.AsNoTracking().Where(c => custIDs.Contains(c.CustomerId)).ToListAsync();
System.Collections.Generic.List <int> customerAddress = await DB.CustomerAddress.AsNoTracking().Where(ca => custIDs.Contains(ca.CustomerId)).Select(ca => ca.CustomerId).ToListAsync();
customersList.ForEach(customer =>
{
customer.AddressCount = customerAddress.Count(id => id == customer.CustomerId);
});
SubResult subResult = new SubResult
{
dbSetName = customerDbSet.dbSetName,
Result = customersList
};
refreshResult.Add(subResult);
}
}
public async Task <bool> Handle(ChangeSetRequest message, IOutputPort <ChangeSetResponse> outputPort)
{
ChangeSetResponse response = new ChangeSetResponse(message);
try
{
CRUDContext <TService> context = new CRUDContext <TService>(message, response, (TService)_service, _serviceContainer);
context.Properties.Add(CRUDContext <TService> .CHANGE_METHODS_KEY, _serviceMethods);
await _pipeline(context);
}
catch (Exception ex)
{
if (ex is TargetInvocationException)
{
ex = ex.InnerException;
}
string err = _serviceMethods.OnError(ex);
response.error = new ErrorInfo(err, ex.GetType().Name);
}
outputPort.Handle(response);
return(response.error == null);
}
public async Task AfterChangeSetCommited(ChangeSetRequest changeSet, SubResultList refreshResult)
{
IEnumerable <IDataManager> dataManagers = _dataManagers.Values.Select(m => (IDataManager)m);
foreach (IDataManager dataManager in dataManagers)
{
await dataManager.AfterChangeSetCommited(changeSet, refreshResult);
}
}
public async Task AfterExecuteChangeSet(ChangeSetRequest changeSet)
{
IEnumerable <IDataManager> dataManagers = _dataManagers.Values.Select(m => (IDataManager)m);
foreach (IDataManager dataManager in dataManagers)
{
await dataManager.AfterExecuteChangeSet(changeSet);
}
}
public CRUDContext(
ChangeSetRequest request,
ChangeSetResponse response,
TService service,
IServiceContainer <TService> serviceContainer)
{
_ExceptionInfo = null;
Request = request;
Response = response;
Service = service;
ServiceContainer = serviceContainer;
Properties = new Dictionary <string, object>();
}
public RequestContext(BaseDomainService dataService,
DbSet dbSet = null,
ChangeSetRequest changeSet = null,
RowInfo rowInfo = null,
QueryRequest queryInfo = null,
ServiceOperationType operation = ServiceOperationType.None)
{
DataService = dataService ?? throw new ArgumentNullException(nameof(dataService));
CurrentDbSet = dbSet;
CurrentChangeSet = changeSet;
CurrentRowInfo = rowInfo;
CurrentQueryInfo = queryInfo;
CurrentOperation = operation;
_dataBag = null;
}
public async Task Invoke(CRUDContext <TService> ctx)
{
IServiceOperationsHelper <TService> serviceHelper = ctx.ServiceContainer.GetServiceHelper();
RunTimeMetadata metadata = ctx.Service.GetMetadata();
ChangeSetRequest changeSet = ctx.Request;
ChangeSetGraph graph = new ChangeSetGraph(ctx.Request, metadata);
graph.Prepare();
ctx.Properties.Add(CRUDContext <TService> .CHANGE_GRAPH_KEY, graph);
RowInfo currentRowInfo = null;
try
{
foreach (RowInfo rowInfo in graph.InsertList)
{
currentRowInfo = rowInfo;
await Insert(ctx, metadata, changeSet, graph, rowInfo);
}
foreach (RowInfo rowInfo in graph.UpdateList)
{
currentRowInfo = rowInfo;
await Update(ctx, metadata, changeSet, rowInfo);
}
foreach (RowInfo rowInfo in graph.DeleteList)
{
currentRowInfo = rowInfo;
await Delete(ctx, metadata, changeSet, rowInfo);
}
}
catch (Exception ex)
{
if (currentRowInfo != null)
{
object dbEntity = currentRowInfo.GetChangeState()?.Entity;
currentRowInfo.SetChangeState(new EntityChangeState {
Entity = dbEntity, Error = ex
});
}
throw;
}
await _next(ctx);
}
public async Task Invoke(CRUDContext <TService> ctx)
{
RunTimeMetadata metadata = ctx.Service.GetMetadata();
ChangeSetRequest changeSet = ctx.Request;
IChangeSetGraph graph = ctx.Properties.Get <IChangeSetGraph>(CRUDContext <TService> .CHANGE_GRAPH_KEY) ?? throw new InvalidOperationException("Could not get Graph changes from properties");
if (!await ValidateRows(ctx, changeSet, metadata, graph.InsertList))
{
throw new ValidationException(ErrorStrings.ERR_SVC_CHANGES_ARENOT_VALID);
}
if (!await ValidateRows(ctx, changeSet, metadata, graph.UpdateList))
{
throw new ValidationException(ErrorStrings.ERR_SVC_CHANGES_ARENOT_VALID);
}
await _next(ctx);
}
private async Task <bool> ValidateRows(CRUDContext <TService> ctx, ChangeSetRequest changeSet, RunTimeMetadata metadata, IEnumerable <RowInfo> rows)
{
TService service = ctx.Service;
IServiceOperationsHelper <TService> serviceHelper = ctx.ServiceContainer.GetServiceHelper();
foreach (RowInfo rowInfo in rows)
{
RequestContext req = CRUDContext <TService> .CreateRequestContext(service, changeSet, rowInfo);
using (RequestCallContext callContext = new RequestCallContext(req))
{
if (!await serviceHelper.ValidateEntity(metadata, req))
{
rowInfo.invalid = rowInfo.GetChangeState().ValidationErrors;
return(false);
}
}
}
return(true);
}
public async Task Invoke(CRUDContext <TService> ctx)
{
IServiceOperationsHelper <TService> serviceHelper = ctx.ServiceContainer.GetServiceHelper();
IDataHelper <TService> dataHelper = ctx.ServiceContainer.GetDataHelper();
Metadata.RunTimeMetadata metadata = ctx.Service.GetMetadata();
ChangeSetRequest changeSet = ctx.Request;
IChangeSetGraph graph = ctx.Properties.Get <IChangeSetGraph>(CRUDContext <TService> .CHANGE_GRAPH_KEY) ?? throw new InvalidOperationException("Could not get Graph changes from properties");
CRUDServiceMethods serviceMethods = ctx.Properties.Get <CRUDServiceMethods>(CRUDContext <TService> .CHANGE_METHODS_KEY) ?? throw new InvalidOperationException("Could not get CRUD Service methods from properties");
RequestContext req = CRUDContext <TService> .CreateRequestContext(ctx.Service, changeSet);
using (RequestCallContext callContext = new RequestCallContext(req))
{
await serviceMethods.ExecuteChangeSet();
await serviceHelper.AfterExecuteChangeSet(changeSet);
await serviceMethods.AfterChangeSetExecuted();
foreach (RowInfo rowInfo in graph.AllList)
{
if (rowInfo.changeType != ChangeType.Deleted)
{
serviceHelper.UpdateRowInfoAfterUpdates(rowInfo);
}
}
SubResultList subResults = new SubResultList();
await serviceHelper.AfterChangeSetCommited(changeSet, subResults);
await serviceMethods.AfterChangeSetCommited(subResults);
SubsetsGenerator subsetsGenerator = new SubsetsGenerator(metadata, dataHelper);
ctx.Response.subsets = subsetsGenerator.CreateSubsets(subResults);
}
await _next(ctx);
}
public virtual Task AfterChangeSetCommited(ChangeSetRequest changeSet, SubResultList refreshResult)
{
return(Task.CompletedTask);
}
public virtual Task AfterExecuteChangeSet(ChangeSetRequest changeSet)
{
return(Task.CompletedTask);
}
protected virtual Task AfterExecuteChangeSet(ChangeSetRequest message)
{
return(Task.CompletedTask);
}
public async Task <ActionResult> Save([ServiceParamsBinder] ChangeSetRequest changeSet)
{
ChangeSetResponse response = await DomainService.ServiceApplyChangeSet(changeSet);
return(new ChunkedResult <ChangeSetResponse>(response, Serializer));
}
private async Task Delete(CRUDContext <TService> ctx, RunTimeMetadata metadata, ChangeSetRequest changeSet, RowInfo rowInfo)
{
TService service = ctx.Service;
IServiceOperationsHelper <TService> serviceHelper = ctx.ServiceContainer.GetServiceHelper();
CheckRowInfo(rowInfo);
using (RequestCallContext callContext = new RequestCallContext(CRUDContext <TService> .CreateRequestContext(service, changeSet, rowInfo)))
{
rowInfo.SetChangeState(new EntityChangeState());
await serviceHelper.DeleteEntity(metadata, rowInfo);;
}
}
private async Task Insert(CRUDContext <TService> ctx, RunTimeMetadata metadata, ChangeSetRequest changeSet, IChangeSetGraph graph, RowInfo rowInfo)
{
TService service = ctx.Service;
IServiceOperationsHelper <TService> serviceHelper = ctx.ServiceContainer.GetServiceHelper();
CheckRowInfo(rowInfo);
using (RequestCallContext callContext = new RequestCallContext(CRUDContext <TService> .CreateRequestContext(service, changeSet, rowInfo)))
{
rowInfo.SetChangeState(new EntityChangeState {
ParentRows = graph.GetParents(rowInfo)
});
await serviceHelper.InsertEntity(metadata, rowInfo);
}
}
protected virtual Task AfterChangeSetCommited(ChangeSetRequest message, SubResultList refreshResult)
{
return(Task.CompletedTask);
}
public async Task <ActionResult> Save([FromBody] ChangeSetRequest changeSet)
{
ChangeSetResponse res = await DomainService.ServiceApplyChangeSet(changeSet);
return(new ChunkedResult <ChangeSetResponse>(res, DomainService.Serializer));
}
public ChangeSetGraph(ChangeSetRequest changeSet, RunTimeMetadata metadata)
{
ChangeSet = changeSet ?? throw new ArgumentNullException(nameof(changeSet));
_metadata = metadata ?? throw new ArgumentNullException(nameof(metadata));
}
