Esempio n. 1
0
        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);
            }
        }
Esempio n. 2
0
        protected async Task <RefreshInfo> RefreshRowInfo(RefreshInfo info)
        {
            var metadata = MetadataHelper.GetInitializedMetadata(this);

            info.dbSetInfo = metadata.dbSets[info.dbSetName];
            var methodData = metadata.getOperationMethodInfo(info.dbSetName, MethodType.Refresh);

            if (methodData == null)
            {
                throw new InvalidOperationException(string.Format(ErrorStrings.ERR_REC_REFRESH_INVALID,
                                                                  info.dbSetInfo.EntityType.Name, GetType().Name));
            }
            info.rowInfo.dbSetInfo = info.dbSetInfo;
            var authorizer = ServiceContainer.Authorizer;

            authorizer.CheckUserRightsToExecute(methodData);
            var req = new RequestContext(this, rowInfo: info.rowInfo, operation: ServiceOperationType.RowRefresh);

            using (var callContext = new RequestCallContext(req))
            {
                var instance  = _serviceHelper.GetMethodOwner(methodData);
                var invokeRes = methodData.methodInfo.Invoke(instance, new object[] { info });
                var dbEntity  = await ServiceOperationsHelper.GetMethodResult(invokeRes).ConfigureAwait(false);

                var rri = new RefreshInfo {
                    rowInfo = info.rowInfo, dbSetName = info.dbSetName
                };
                if (dbEntity != null)
                {
                    _serviceHelper.UpdateRowInfoFromEntity(dbEntity, info.rowInfo);
                }
                else
                {
                    rri.rowInfo = null;
                }

                return(rri);
            }
        }
Esempio n. 3
0
        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);
            }
        }