コード例 #1
0
#pragma warning disable 1591 // Xml Comments
        public QueryResult Execute(IQuery query, PagingInfo paging)
        {
            ThrowIfNoQueryPropertyOnQuery(query);

            var result = QueryResult.For(query);

            try
            {
                var authorizationResult = _fetchingSecurityManager.Authorize(query);
                if (!authorizationResult.IsAuthorized)
                {
                    result.SecurityMessages = authorizationResult.BuildFailedAuthorizationMessages();
                    result.Items            = new object[0];
                    return(result);
                }
                result.Validation = _validator.Validate(query);
                if (!result.Validation.Success)
                {
                    result.Items = new object[0];
                    return(result);
                }

                var property       = GetQueryPropertyFromQuery(query);
                var actualQuery    = property.GetValue(query, null);
                var provider       = GetQueryProvider(query, property, actualQuery);
                var providerResult = ExecuteOnProvider(provider, actualQuery, paging);
                result.TotalItems = providerResult.TotalItems;
                var readModels = providerResult.Items as IEnumerable <IReadModel>;
                result.Items = readModels != null?_filters.Filter(readModels) : providerResult.Items;
            }
            catch (TargetInvocationException ex)
            {
                _exceptionPublisher.Publish(ex.InnerException);
                result.Exception = ex.InnerException;
            }
            catch (Exception ex)
            {
                _exceptionPublisher.Publish(ex);
                result.Exception = ex;
            }

            return(result);
        }
コード例 #2
0
        /// <inheritdoc/>
        public Task <QueryResult> Execute(IQuery query, PagingInfo paging)
        {
            var queryType = query.GetType();

            _logger.Debug("Executing query of type '{QueryName}'", queryType.AssemblyQualifiedName);

            var taskCompletionSource = new TaskCompletionSource <QueryResult>();
            var result = QueryResult.For(query);

            try
            {
                ThrowIfNoQueryPropertyOnQuery(queryType);

                var authorizationResult = _fetchingSecurityManager.Authorize(query);
                if (!authorizationResult.IsAuthorized)
                {
                    result.SecurityMessages = authorizationResult.BuildFailedAuthorizationMessages();
                    result.Items            = Array.Empty <object>();
                    taskCompletionSource.SetResult(result);
                    return(taskCompletionSource.Task);
                }

                var validation = _validator.Validate(query);
                result.BrokenRules = validation.BrokenRules;
                if (!validation.Success)
                {
                    result.Items = Array.Empty <object>();
                    taskCompletionSource.SetResult(result);
                    return(taskCompletionSource.Task);
                }

                var property        = GetQueryPropertyFromQuery(queryType);
                var actualQuery     = property.GetValue(query, null);
                var queryReturnType = actualQuery.GetType();
                if (actualQuery is Task && queryReturnType.IsGenericType)
                {
                    var task = actualQuery as Task;
#pragma warning disable CA2008
                    task.ContinueWith(tr =>
                    {
                        var resultProperty = tr.GetType().GetProperty("Result");
                        queryReturnType    = queryReturnType.GetGenericArguments()[0];
                        actualQuery        = resultProperty.GetValue(tr);
                        HandleActualQuery(queryType, actualQuery, queryReturnType, result, paging);

                        taskCompletionSource.SetResult(result);
                    });
#pragma warning restore CA2008
                }
                else
                {
                    HandleActualQuery(queryType, actualQuery, queryReturnType, result, paging);
                    taskCompletionSource.SetResult(result);
                }
            }
            catch (TargetInvocationException ex)
            {
                result.Exception = ex.InnerException;
                taskCompletionSource.SetResult(result);
            }
            catch (Exception ex)
            {
                result.Exception = ex;

                switch (ex)
                {
                case MissingQueryProperty missingQueryProperty:
                {
                    taskCompletionSource.SetException(ex);
                    throw;
                }

                default:
                {
                    taskCompletionSource.SetResult(result);
                }

                break;
                }
            }

            return(taskCompletionSource.Task);
        }