public void Enrich(string url, MetaOperation operation, IServiceProvider serviceProvider)
        {
            if (!Enabled)
            {
                return;
            }

            if (operation.url == null)
            {
                operation.url = MetaUrl.FromRaw(url);
            }

            var transforms = serviceProvider.GetServices <ITextTransform>();
            var cases      = transforms.Select(x => x.Name.ToLowerInvariant()).ToList();

            var multiCaseParameter = new MetaParameter
            {
                key         = MultiCaseOperator,
                value       = cases.FirstOrDefault() ?? string.Empty,
                description =
                    $"Transforms responses to alternative cases. Valid values are: {string.Join(", ", cases)}.",
                disabled = true
            };

            var envelopeParameter = new MetaParameter
            {
                key         = EnvelopeOperator,
                value       = "1",
                description =
                    "Transforms responses to include more information in the payload for constrained clients.",
                disabled = true
            };

            var prettyPrintParameter = new MetaParameter
            {
                key         = PrettyPrintOperator,
                value       = "1",
                description = "Enhances readability of responses by adding whitespace and nesting.",
                disabled    = true
            };

            var trimParameter = new MetaParameter
            {
                key         = TrimOperator,
                value       = "1",
                description = "Reduces response weight by omitting null and default values.",
                disabled    = true
            };

            operation.url.query ??= operation.url.query = new List <MetaParameter>();
            operation.url.query.AddRange(new[]
            {
                multiCaseParameter, envelopeParameter, trimParameter, prettyPrintParameter
            });
        }
        private MetaUrl Mapper(IDataReader reader)
        {
            MetaUrl singleItem    = new MetaUrl();
            int     startingIndex = 0;

            singleItem.Id       = reader.GetSafeInt32(startingIndex++);
            singleItem.Name     = reader.GetSafeString(startingIndex++);
            singleItem.Url      = reader.GetSafeString(startingIndex++);
            singleItem.IsLocked = reader.GetSafeBool(startingIndex++);
            return(singleItem);
        }
        public List <MetaUrl> Get()
        {
            List <MetaUrl> list = new List <MetaUrl>();

            DataProvider.ExecuteCmd("dbo.MetaOT_SelectAll"
                                    , inputParamMapper : null
                                    , singleRecordMapper : delegate(IDataReader reader, short set)
            {
                MetaUrl singleItem = Mapper(reader);
                list.Add(singleItem);
            });
            return(list);
        }
        public MetaUrl Get(int id)
        {
            MetaUrl singleItem = null;

            DataProvider.ExecuteCmd("dbo.MetaOT_SelectById"
                                    , inputParamMapper : delegate(SqlParameterCollection paramCollection)
            {
                paramCollection.AddWithValue("@Id", id);
            }
                                    , singleRecordMapper : delegate(IDataReader reader, short set)
            {
                singleItem = Mapper(reader);
            });
            return(singleItem);
        }
Exemple #5
0
        private MetaItem CreateOperationMetaItem(string baseUri, ApiDescription description,
                                                 IServiceProvider serviceProvider)
        {
            var relativePath = Uri.UnescapeDataString(description.RelativePath ?? string.Empty);
            var url          = $"{baseUri}/{relativePath}";
            var operation    = new MetaOperation
            {
                auth        = ResolveOperationAuth(description),
                proxy       = new { },
                certificate = new { },
                method      = description.HttpMethod,
                description = new MetaDescription {
                    content = "", type = MediaTypeNames.Text.Markdown, version = null
                },
                header = new List <MetaParameter>
                {
                    new MetaParameter
                    {
                        disabled    = false,
                        description = "",                         /* new MetaDescription
                                                                   * {
                                                                   * content = "",
                                                                   * type = MediaTypeNames.Markdown,
                                                                   * version = null
                                                                   * },*/
                        key         = HeaderNames.ContentType,
                        value       = MediaTypeNames.Application.Json
                    }
                },
                body = default
            };

            operation.url = MetaUrl.FromRaw(url);

            foreach (var provider in _parameterProviders)
            {
                provider.Enrich(url, operation, serviceProvider);
            }

            var item = new MetaItem
            {
                id          = Guid.NewGuid(),
                name        = relativePath,
                description =
                    new MetaDescription {
                    content = "", type = MediaTypeNames.Text.Markdown, version = null
                },
                variable = new List <dynamic>(),
                @event   = new List <dynamic>(),
                request  = operation,
                response = new List <dynamic>(),
                protocolProfileBehavior = new { }
            };

            if (description.SupportedRequestFormats.Count > 0)
            {
                var bodyParameter = description.ParameterDescriptions.SingleOrDefault(
                    x => x.Source.IsFromRequest && x.Source.Id == "Body");

                //
                // Token Capture:
                if (item.request.method == "POST" && bodyParameter?.Type?.Name == "BearerTokenRequest")
                {
                    [email protected](new
                    {
                        listen = "test",
                        script = new
                        {
                            id   = "66a87d23-bc0e-432c-acee-cb48d3704947",
                            exec = new List <string>
                            {
                                "var data = JSON.parse(responseBody);\r",
                                "postman.setGlobalVariable(\"accessToken\", data.accessToken);"
                            },
                            type = "text/javascript"
                        }
                    });
                    item.request.body = new
                    {
                        mode = "raw",
                        raw  =
                            "{\r\n\t\"IdentityType\": \"Username\",\r\n\t\"Identity\": \"\",\r\n\t\"Password\": \"\"\r\n}"
                    };
                }

                //
                // Body Definition (roots only):
                if (bodyParameter != null && bodyParameter.Type != null &&
                    !typeof(IEnumerable).IsAssignableFrom(bodyParameter.Type))
                {
                    item.request.body = new
                    {
                        mode = "raw",
                        raw  = JsonConvert.SerializeObject(
                            FormatterServices.GetUninitializedObject(bodyParameter.Type))
                    }
                }
                ;
            }

            //
            // Bearer:
            if (item.request?.auth != null &&
                (item.request.auth.Equals("bearer", StringComparison.OrdinalIgnoreCase) ||
                 item.request.auth.Equals("platformbearer", StringComparison.OrdinalIgnoreCase)))
            {
                item.request.header.Add(new MetaParameter
                {
                    key         = "Authorization",
                    value       = "Bearer {{accessToken}}",
                    description = "Access Token",
                    type        = "text"
                });
            }

            return(item);
        }