Example #1
0
        void IModel.Write(IParseNodeWriter writer)
        {
            writer.WriteStartMap();

            writer.WritePropertyName("openapi");
            writer.WriteValue("3.0.0");

            writer.WriteObject("info", Info, ModelHelper.Write);
            writer.WriteList("servers", Servers, ModelHelper.Write);
            writer.WritePropertyName("paths");
            if (Paths.PathItems.Count() > 0)
            {
                ModelHelper.Write(writer, Paths);
            }
            else
            {
                writer.WriteValue("{}");
            }
            writer.WriteList("tags", Tags, ModelHelper.Write);
            if (!Components.IsEmpty())
            {
                writer.WriteObject("components", Components, ModelHelper.Write);
            }
            if (ExternalDocs.Url != null)
            {
                writer.WriteObject("externalDocs", ExternalDocs, ModelHelper.Write);
            }
            writer.WriteList("security", SecurityRequirements, ModelHelper.Write);

            writer.WriteEndMap();
        }
Example #2
0
        public override void Write(IParseNodeWriter writer)
        {
            if (node.Style == ScalarStyle.DoubleQuoted || node.Style == ScalarStyle.SingleQuoted)
            {
                writer.WriteValue(node.Value);
                return;
            }

            writer.WriteValue((object)node.Value);
        }
Example #3
0
        public static void WriteOpenApiDocument(IParseNodeWriter writer, OpenApiDocument doc)
        {
            writer.WriteStartMap();

            writer.WritePropertyName("openapi");
            writer.WriteValue("3.0.0");

            writer.WriteObject("info", doc.Info, WriteInfo);
            writer.WriteList("servers", doc.Servers, WriteServer);
            writer.WritePropertyName("paths");

            writer.WriteStartMap();
            WritePaths(writer, doc.Paths);
            writer.WriteEndMap();

            writer.WriteList("tags", doc.Tags, WriteTag);
            if (!doc.Components.IsEmpty())
            {
                writer.WriteObject("components", doc.Components, WriteComponents);
            }
            if (doc.ExternalDocs.Url != null)
            {
                writer.WriteObject("externalDocs", doc.ExternalDocs, WriteExternalDocs);
            }

            writer.WriteList("security", doc.SecurityRequirements, WriteSecurityRequirement);
            writer.WriteExtensions(doc.Extensions);

            writer.WriteEndMap();
        }
Example #4
0
 public static void WriteNumberProperty(this IParseNodeWriter writer, string name, decimal value, decimal?defaultValue = null)
 {
     if (defaultValue == null || value != defaultValue)
     {
         writer.WritePropertyName(name);
         writer.WriteValue(value);
     }
 }
Example #5
0
 public static void WriteStringProperty(this IParseNodeWriter writer, string name, string value)
 {
     if (!String.IsNullOrEmpty(value))
     {
         writer.WritePropertyName(name);
         writer.WriteValue(value);
     }
 }
Example #6
0
 public static void WriteNumberProperty(this IParseNodeWriter writer, string name, decimal?value)
 {
     if (value != null)
     {
         writer.WritePropertyName(name);
         writer.WriteValue((decimal)value);
     }
 }
Example #7
0
        private static void WriteSchemaProperties(IParseNodeWriter writer, Schema schema)
        {
            writer.WriteStringProperty("title", schema.Title);
            writer.WriteStringProperty("type", schema.Type);
            writer.WriteStringProperty("format", schema.Format);
            writer.WriteStringProperty("description", schema.Description);

            writer.WriteNumberProperty("maxLength", schema.MaxLength);
            writer.WriteNumberProperty("minLength", schema.MinLength);
            writer.WriteStringProperty("pattern", schema.Pattern);
            writer.WriteStringProperty("default", schema.Default);

            writer.WriteList("required", schema.Required, (nodeWriter, s) => nodeWriter.WriteValue(s));

            writer.WriteNumberProperty("maximum", schema.Maximum);
            writer.WriteBoolProperty("exclusiveMaximum", schema.ExclusiveMaximum, false);
            writer.WriteNumberProperty("minimum", schema.Minimum);
            writer.WriteBoolProperty("exclusiveMinimum", schema.ExclusiveMinimum, false);

            if (schema.AdditionalProperties != null)
            {
                writer.WritePropertyName("additionalProperties");
                WriteSchemaOrReference(writer, schema.AdditionalProperties);
            }

            if (schema.Items != null)
            {
                writer.WritePropertyName("items");
                WriteSchemaOrReference(writer, schema.Items);
            }
            writer.WriteNumberProperty("maxItems", schema.MaxItems);
            writer.WriteNumberProperty("minItems", schema.MinItems);

            if (schema.Properties != null)
            {
                writer.WritePropertyName("properties");
                writer.WriteStartMap();
                foreach (var prop in schema.Properties)
                {
                    writer.WritePropertyName(prop.Key);
                    if (prop.Value != null)
                    {
                        WriteSchemaOrReference(writer, prop.Value);
                    }
                    else
                    {
                        writer.WriteValue("null");
                    }
                }
                writer.WriteEndMap();
            }
            writer.WriteNumberProperty("maxProperties", schema.MaxProperties);
            writer.WriteNumberProperty("minProperties", schema.MinProperties);

            writer.WriteList("enum", schema.Enum, (nodeWriter, s) => nodeWriter.WriteValue(s));
            writer.WriteExtensions(schema.Extensions);
        }
Example #8
0
 public static void WriteExtensions(this IParseNodeWriter writer, Dictionary <string, string> extensions)
 {
     if (extensions != null && extensions.Count > 0)
     {
         foreach (KeyValuePair <string, string> extension in extensions)
         {
             writer.WritePropertyName(extension.Key);
             writer.WriteValue(extension.Value);
         }
     }
 }
Example #9
0
        public static void WriteSecurityRequirement(IParseNodeWriter writer, SecurityRequirement securityRequirement)
        {
            writer.WriteStartMap();

            foreach (var scheme in securityRequirement.Schemes)
            {
                writer.WritePropertyName(scheme.Key.Pointer.TypeName);
                if (scheme.Value.Count > 0)
                {
                    writer.WriteStartList();
                    foreach (var scope in scheme.Value)
                    {
                        writer.WriteValue(scope);
                    }
                    writer.WriteEndList();
                }
                else
                {
                    writer.WriteValue("[]");
                }
            }

            writer.WriteEndMap();
        }
        void IModel.Write(IParseNodeWriter writer)
        {
            writer.WriteStartMap();

            foreach (var scheme in Schemes)
            {
                writer.WritePropertyName(scheme.Key.Pointer.TypeName);
                if (scheme.Value.Count > 0)
                {
                    writer.WriteStartList();
                    foreach (var scope in scheme.Value)
                    {
                        writer.WriteValue(scope);
                    }
                    writer.WriteEndList();
                }
                else
                {
                    writer.WriteValue("[]");
                }
            }

            writer.WriteEndMap();
        }
Example #11
0
        void IModel.Write(IParseNodeWriter writer)
        {
            writer.WriteStartMap();

            if (Enum.Count > 0)
            {
                writer.WritePropertyName("enum");
                writer.WriteStartList();
                foreach (var enumItem in Enum)
                {
                    writer.WriteValue(enumItem);
                }
                writer.WriteEndList();
            }
            writer.WriteStringProperty("default", Default);
            writer.WriteStringProperty("description", Description);

            writer.WriteEndMap();
        }
Example #12
0
 public virtual void Write(IParseNodeWriter writer)
 {
     writer.WriteValue(ToString());
 }
Example #13
0
 public void WriteRef(IParseNodeWriter writer)
 {
     writer.WriteValue(Name);
 }
Example #14
0
 public void Write(IParseNodeWriter writer)
 {
     writer.WriteValue(node.ToString());
 }
Example #15
0
        void IModel.Write(IParseNodeWriter writer)
        {
            writer.WriteStartMap();

            writer.WriteStringProperty("title", Title);
            writer.WriteStringProperty("type", Type);
            writer.WriteStringProperty("format", Format);
            writer.WriteStringProperty("description", Description);

            writer.WriteNumberProperty("maxLength", MaxLength);
            writer.WriteNumberProperty("minLength", MinLength);
            writer.WriteStringProperty("pattern", Pattern);
            writer.WriteStringProperty("default", Default);

            if (Required != null && Required.Length > 0)
            {
                writer.WritePropertyName("required");
                writer.WriteStartList();
                foreach (var name in Required)
                {
                    writer.WriteValue(name);
                }
                writer.WriteEndList();
            }

            writer.WriteNumberProperty("maximum", Maximum);
            writer.WriteBoolProperty("exclusiveMaximum", ExclusiveMaximum, false);
            writer.WriteNumberProperty("minimum", Minimum);
            writer.WriteBoolProperty("exclusiveMinimum", ExclusiveMinimum, false);

            if (Items != null)
            {
                writer.WritePropertyName("items");
                ModelHelper.Write(writer, Items);
            }
            writer.WriteNumberProperty("maxItems", MaxItems);
            writer.WriteNumberProperty("minItems", MinItems);

            if (Properties != null)
            {
                writer.WritePropertyName("properties");
                writer.WriteStartMap();
                foreach (var prop in Properties)
                {
                    writer.WritePropertyName(prop.Key);
                    if (prop.Value != null)
                    {
                        ModelHelper.Write(writer, prop.Value);
                    }
                    else
                    {
                        writer.WriteValue("null");
                    }
                }
                writer.WriteEndMap();
            }
            writer.WriteNumberProperty("maxProperties", MaxProperties);
            writer.WriteNumberProperty("minProperties", MinProperties);



            if (Enum.Count > 0)
            {
                writer.WritePropertyName("enum");
                writer.WriteStartList();
                foreach (var item in Enum)
                {
                    writer.WriteValue(item);
                }
                writer.WriteEndList();
            }
            writer.WriteEndMap();
        }