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)); }