public async Task Invoke(InvokeContext <TService> ctx)
{
IDataHelper <TService> dataHelper = ctx.ServiceContainer.GetDataHelper();
IServiceOperationsHelper <TService> serviceHelper = ctx.ServiceContainer.GetServiceHelper();
RunTimeMetadata metadata = ctx.Service.GetMetadata();
MethodDescription method = metadata.GetInvokeMethod(ctx.Request.methodName);
List <object> methParams = new List <object>();
for (int i = 0; i < method.parameters.Count; ++i)
{
methParams.Add(ctx.Request.paramInfo.GetValue(method.parameters[i].name, method, dataHelper));
}
RequestContext req = InvokeContext <TService> .CreateRequestContext(ctx.Service);
using (RequestCallContext callContext = new RequestCallContext(req))
{
MethodInfoData methodData = method.GetMethodData();
object instance = serviceHelper.GetMethodOwner(methodData);
object invokeRes = methodData.MethodInfo.Invoke(instance, methParams.ToArray());
object methodResult = await serviceHelper.GetMethodResult(invokeRes);
if (method.methodResult)
{
ctx.Response.result = methodResult;
}
}
await _next(ctx);
}
protected async Task <InvokeResponse> InvokeMethod(InvokeRequest invokeInfo)
{
var metadata = MetadataHelper.GetInitializedMetadata(this);
var method = metadata.GetInvokeMethod(invokeInfo.methodName);
var authorizer = ServiceContainer.Authorizer;
authorizer.CheckUserRightsToExecute(method.methodData);
var methParams = new List <object>();
for (var i = 0; i < method.parameters.Count; ++i)
{
methParams.Add(invokeInfo.paramInfo.GetValue(method.parameters[i].name, method, ServiceContainer));
}
var req = new RequestContext(this, operation: ServiceOperationType.InvokeMethod);
using (var callContext = new RequestCallContext(req))
{
var instance = _serviceHelper.GetMethodOwner(method.methodData);
var invokeRes = method.methodData.methodInfo.Invoke(instance, methParams.ToArray());
var meth_result = await ServiceOperationsHelper.GetMethodResult(invokeRes).ConfigureAwait(false);
var res = new InvokeResponse();
if (method.methodResult)
{
res.result = meth_result;
}
return(res);
}
}
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);
}
}
public async Task Invoke(QueryContext <TService> ctx)
{
DbSetInfo dbSetInfo = ctx.Request.GetDbSetInfo() ?? throw new InvalidOperationException($"Could not get the DbSet for {ctx.Request.dbSetName}");
IDataHelper <TService> dataHelper = ctx.ServiceContainer.GetDataHelper();
IServiceOperationsHelper <TService> serviceHelper = ctx.ServiceContainer.GetServiceHelper();
RunTimeMetadata metadata = ctx.Service.GetMetadata();
MethodDescription method = metadata.GetQueryMethod(ctx.Request.dbSetName, ctx.Request.queryName);
LinkedList <object> methParams = new LinkedList <object>();
for (int i = 0; i < method.parameters.Count; ++i)
{
methParams.AddLast(ctx.Request.paramInfo.GetValue(method.parameters[i].name, method, dataHelper));
}
RequestContext req = QueryContext <TService> .CreateRequestContext(ctx.Service, ctx.Request);
using (RequestCallContext callContext = new RequestCallContext(req))
{
MethodInfoData methodData = method.GetMethodData();
object instance = serviceHelper.GetMethodOwner(methodData);
object invokeRes = methodData.MethodInfo.Invoke(instance, methParams.ToArray());
QueryResult queryResult = (QueryResult)await serviceHelper.GetMethodResult(invokeRes);
IEnumerable <object> entities = queryResult.Result;
int? totalCount = queryResult.TotalCount;
RowGenerator rowGenerator = new RowGenerator(dbSetInfo, entities, dataHelper);
IEnumerable <Row> rows = rowGenerator.CreateRows();
SubsetsGenerator subsetsGenerator = new SubsetsGenerator(metadata, dataHelper);
SubsetList subResults = subsetsGenerator.CreateSubsets(queryResult.subResults);
ctx.Response.names = dbSetInfo.GetNames();
ctx.Response.totalCount = totalCount;
ctx.Response.rows = rows;
ctx.Response.subsets = subResults;
ctx.Response.extraInfo = queryResult.extraInfo;
}
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);
}
protected async Task <bool> ApplyChangeSet(ChangeSet changeSet)
{
AuthorizeChangeSet(changeSet);
var metadata = MetadataHelper.GetInitializedMetadata(this);
var graph = new ChangeSetGraph(changeSet, metadata);
graph.Prepare();
foreach (var rowInfo in graph.insertList)
{
var dbSet = changeSet.dbSets.Where(d => d.dbSetName == rowInfo.dbSetInfo.dbSetName).Single();
var req = new RequestContext(this, changeSet: changeSet, dbSet: dbSet, rowInfo: rowInfo,
operation: ServiceOperationType.SaveChanges);
using (var callContext = new RequestCallContext(req))
{
rowInfo.changeState = new EntityChangeState {
ParentRows = graph.GetParents(rowInfo)
};
ApplyChangesToEntity(rowInfo);
}
}
foreach (var rowInfo in graph.updateList)
{
var dbSet = changeSet.dbSets.Where(d => d.dbSetName == rowInfo.dbSetInfo.dbSetName).Single();
var req = new RequestContext(this, changeSet: changeSet, dbSet: dbSet, rowInfo: rowInfo,
operation: ServiceOperationType.SaveChanges);
using (var callContext = new RequestCallContext(req))
{
rowInfo.changeState = new EntityChangeState();
ApplyChangesToEntity(rowInfo);
}
}
foreach (var rowInfo in graph.deleteList)
{
var dbSet = changeSet.dbSets.Where(d => d.dbSetName == rowInfo.dbSetInfo.dbSetName).Single();
var req = new RequestContext(this, changeSet: changeSet, dbSet: dbSet, rowInfo: rowInfo,
operation: ServiceOperationType.SaveChanges);
using (var callContext = new RequestCallContext(req))
{
rowInfo.changeState = new EntityChangeState();
ApplyChangesToEntity(rowInfo);
}
}
var hasErrors = false;
//Validation step
foreach (var rowInfo in graph.insertList)
{
var dbSet = changeSet.dbSets.Where(d => d.dbSetName == rowInfo.dbSetInfo.dbSetName).Single();
var req = new RequestContext(this, changeSet: changeSet, dbSet: dbSet, rowInfo: rowInfo,
operation: ServiceOperationType.SaveChanges);
using (var callContext = new RequestCallContext(req))
{
if (!await _serviceHelper.ValidateEntity(metadata, req).ConfigureAwait(false))
{
rowInfo.invalid = rowInfo.changeState.ValidationErrors;
hasErrors = true;
}
}
}
//Validation step
foreach (var rowInfo in graph.updateList)
{
var dbSet = changeSet.dbSets.Where(d => d.dbSetName == rowInfo.dbSetInfo.dbSetName).Single();
var req = new RequestContext(this, changeSet: changeSet, dbSet: dbSet, rowInfo: rowInfo,
operation: ServiceOperationType.SaveChanges);
using (var callContext = new RequestCallContext(req))
{
if (!await _serviceHelper.ValidateEntity(metadata, req).ConfigureAwait(false))
{
rowInfo.invalid = rowInfo.changeState.ValidationErrors;
hasErrors = true;
}
}
}
if (hasErrors)
{
return(false);
}
var reqCntxt = new RequestContext(this, changeSet: changeSet, operation: ServiceOperationType.SaveChanges);
using (var callContext = new RequestCallContext(reqCntxt))
{
await ExecuteChangeSet().ConfigureAwait(false);
foreach (var rowInfo in graph.allList)
{
if (rowInfo.changeType != ChangeType.Deleted)
{
_serviceHelper.UpdateRowInfoAfterUpdates(rowInfo);
}
else
{
rowInfo.values = null;
}
}
//Track changes step
foreach (var rowInfo in graph.allList)
{
TrackChangesToEntity(rowInfo);
}
}
//OK, All updates are commited
return(true);
}
protected async Task <QueryResponse> ExecQuery(QueryRequest queryInfo)
{
var metadata = MetadataHelper.GetInitializedMetadata(this);
var method = metadata.GetQueryMethod(queryInfo.dbSetName, queryInfo.queryName);
var authorizer = ServiceContainer.Authorizer;
authorizer.CheckUserRightsToExecute(method.methodData);
queryInfo.dbSetInfo = metadata.dbSets[queryInfo.dbSetName];
var isMultyPageRequest = queryInfo.dbSetInfo.enablePaging && queryInfo.pageCount > 1;
QueryResult queryResult = null;
int? totalCount = null;
var methParams = new LinkedList <object>();
for (var i = 0; i < method.parameters.Count; ++i)
{
methParams.AddLast(queryInfo.paramInfo.GetValue(method.parameters[i].name, method, ServiceContainer));
}
var req = new RequestContext(this, queryInfo: queryInfo, operation: ServiceOperationType.Query);
using (var callContext = new RequestCallContext(req))
{
var instance = _serviceHelper.GetMethodOwner(method.methodData);
var invokeRes = method.methodData.methodInfo.Invoke(instance, methParams.ToArray());
queryResult = (QueryResult)await ServiceOperationsHelper.GetMethodResult(invokeRes).ConfigureAwait(false);
var entities = queryResult.Result;
totalCount = queryResult.TotalCount;
var rowGenerator = new RowGenerator(queryInfo.dbSetInfo, entities, ServiceContainer.DataHelper);
var rows = rowGenerator.CreateRows();
var subsetsGenerator = new SubsetsGenerator(this);
var subsets1 = subsetsGenerator.CreateSubsets(queryInfo.dbSetInfo, entities, queryResult.includeNavigations);
var subsets2 = subsetsGenerator.CreateSubsets(queryResult.subResults);
var subResults = subsets1.Aggregate(subsets2, (lst, subRes) =>
{
if (lst.Any(r => r.dbSetName == subRes.dbSetName))
{
throw new DomainServiceException(string.Format("The included results already have {0} entities", subRes.dbSetName));
}
lst.Add(subRes);
return(lst);
});
var res = new QueryResponse
{
pageIndex = queryInfo.pageIndex,
pageCount = queryInfo.pageCount,
dbSetName = queryInfo.dbSetName,
names = queryInfo.dbSetInfo.GetNames(),
totalCount = totalCount,
extraInfo = queryResult.extraInfo,
rows = rows,
subsets = subResults,
error = null
};
return(res);
}
}
