public static void MaybeEnvelope(this HttpResponse response, HttpRequest request, PublicApiOptions apiOptions,
                                         QueryOptions queryOptions, object data, IList <Error> errors, out object body)
        {
            if (FeatureRequested(request, apiOptions.JsonConversion.EnvelopeOperator,
                                 apiOptions.JsonConversion.EnvelopeEnabled))
            {
                body = new EnvelopeBody
                {
                    Data      = data,
                    Status    = response.StatusCode,
                    Headers   = response.Headers,
                    Errors    = errors,
                    HasErrors = errors?.Count > 0
                };
            }
            else
            {
                body = new NestedBody
                {
                    Data      = data,
                    Errors    = errors,
                    HasErrors = errors?.Count > 0
                };
            }

            response.StatusCode = (int)HttpStatusCode.OK;
        }
Exemple #2
0
 /// <summary>
 /// This method is used to create request envelope message body, but not include the RequestCollection.
 /// </summary>
 /// <param name="versionTypeNumber">Specify the version type number.</param>
 /// <param name="minorVersionTypeNumber">Specify the minor version type number.</param>
 private void CreateEnvelopeBody(ushort?versionTypeNumber, ushort?minorVersionTypeNumber)
 {
     this.requestEnvelope = new EnvelopeBody();
     this.requestEnvelope.RequestVersion    = this.CreateRequestVersion(versionTypeNumber, minorVersionTypeNumber);
     this.requestEnvelope.RequestCollection = new RequestCollection();
     this.requestEnvelope.RequestCollection.CorrelationId = Guid.NewGuid().ToString();
 }
        public static void MaybeEnvelope <T>(this HttpResponse response, HttpRequest request,
                                             JsonConversionOptions options,
                                             T data, IList <Error> errors, out object body)
        {
            if (FeatureRequested(request, options.EnvelopeOperator))
            {
                body = new EnvelopeBody <T>
                {
                    Data      = data,
                    Status    = response.StatusCode,
                    Headers   = response.Headers,
                    Errors    = errors,
                    HasErrors = errors?.Count > 0
                };
            }
            else
            {
                body = new NestedBody <T> {
                    Data = data, Errors = errors, HasErrors = errors?.Count > 0
                };
            }

            response.StatusCode = (int)HttpStatusCode.OK;
        }
        public static void MaybeEnvelope(this HttpResponse response, HttpRequest request, PublicApiOptions apiOptions,
                                         QueryOptions queryOptions,
                                         IPageHeader data, IList <Error> errors, out object body)
        {
            if (FeatureRequested(request, apiOptions.JsonConversion.EnvelopeOperator,
                                 apiOptions.JsonConversion.EnvelopeEnabled))
            {
                body = new EnvelopeBody
                {
                    Data    = data,
                    Status  = response.StatusCode,
                    Headers = response.Headers,
                    Paging  = new PagingInfo
                    {
                        TotalCount   = data.TotalCount,
                        TotalPages   = data.TotalPages,
                        NextPage     = GetNextPage(request, data, queryOptions),
                        PreviousPage = GetPreviousPage(request, data, queryOptions),
                        LastPage     = GetLastPage(request, data, queryOptions)
                    },
                    Errors    = errors,
                    HasErrors = errors?.Count > 0
                };

                response.StatusCode = (int)HttpStatusCode.OK;
                return;
            }

            var link = StringBuilderPool.Scoped(sb =>
            {
                if (data.TotalPages > 1)
                {
                    var firstPage = $"<{GetFirstPage(request, data, queryOptions)}>; rel=\"first\"";
                    sb.Append(firstPage);
                }

                if (data.HasNextPage)
                {
                    var nextPage = $"<{GetNextPage(request, data, queryOptions)}>; rel=\"next\"";
                    if (sb.Length > 0)
                    {
                        sb.Append(", ");
                    }

                    sb.Append(nextPage);
                }

                if (data.HasPreviousPage)
                {
                    var previousPage = $"<{GetPreviousPage(request, data, queryOptions)}>; rel=\"previous\"";
                    if (sb.Length > 0)
                    {
                        sb.Append(", ");
                    }

                    sb.Append(previousPage);
                }

                if (data.TotalPages > 1)
                {
                    var lastPage = $"<{GetLastPage(request, data, queryOptions)}>; rel=\"last\"";
                    if (sb.Length > 0)
                    {
                        sb.Append(", ");
                    }

                    sb.Append(lastPage);
                }
            });

            if (link.Length > 0)
            {
                response.Headers.Add(Constants.HttpHeaders.Link, link);
            }

            response.Headers.Add(queryOptions.TotalCountHeader, data.TotalCount.ToString());
            response.Headers.Add(queryOptions.TotalPagesHeader, data.TotalPages.ToString());
            body = new NestedBody
            {
                Data      = data,
                Errors    = errors,
                HasErrors = errors?.Count > 0
            };
        }