private static JsonSchemaProperty AddDiscriminatedSubSchema(
JsonSchema parentSchema,
string discriminatingPropertyName,
string discriminatingPropertyValue,
string discriminatedPropertyName,
JsonSchema subSchema = null)
{
if (null == subSchema)
{
subSchema = new JsonSchema();
}
JsonSchemaProperty discriminatingProperty = new JsonSchemaProperty();
discriminatingProperty.ExtensionData = new Dictionary <string, object>();
discriminatingProperty.ExtensionData.Add("const", discriminatingPropertyValue);
subSchema.Properties.Add(discriminatingPropertyName, discriminatingProperty);
JsonSchemaProperty discriminatedProperty = new JsonSchemaProperty();
subSchema.Properties.Add(discriminatedPropertyName, discriminatedProperty);
parentSchema.OneOf.Add(subSchema);
return(discriminatedProperty);
}
public string Generate(JsonSchemaProperty property)
{
string textToChange = property.Name;
string result = NewMethod(textToChange);
return(result);
}
public string Generate(JsonSchemaProperty property)
{
string f = string.Join("", property.Name.Split(new char[] { '_', '-' }).ToList().Select((a) => a.First().ToString().ToUpperInvariant() + a.Substring(1)));
//C# do not support property names with the same name of the parent class, change nswag behavior with this replace
return(f.Replace("Calldata", "CallData").Replace("Tx", "TX").Replace("CommitmentId", "CommitmentID").Replace("PubKey", "PublicKey").Replace("Peers", "PeersCollection").Replace("OracleQueries", "OracleQueriesCollection").Replace("FateAssembler", "Assembler"));
}
private string GetDotNetType(JsonSchema schema, JsonSchemaProperty parent)
{
if (schema != null)
{
if (schema.IsArray)
{
return($"IList<{GetDotNetType(schema.Item, parent)}>");
}
if (schema.IsDictionary && schema.AdditionalPropertiesSchema != null)
{
return($"IDictionary<string, {GetDotNetType(schema.AdditionalPropertiesSchema, parent)}>");
}
if (schema?.Reference != null)
{
return(classNameHelper.GetClassNameForSchemaDefinition(schema.Reference));
}
if (schema != null)
{
return(GetDotNetType(schema.Type, parent.Name, parent.IsRequired, schema.Format));
}
}
return(GetDotNetType(parent.Type, parent.Name, parent.IsRequired, parent.Format));
}
public async Task When_yaml_OpenAPI_spec_has__relative_external_schema_refs_in_subdirs__they_are_resolved(string relativePath)
{
var path = GetTestDirectory() + relativePath;
OpenApiDocument doc = await OpenApiYamlDocument.FromFileAsync(path);
IDictionary <string, OpenApiPathItem> docPaths = doc.Paths;
OpenApiPathItem pathItem = docPaths["/life-cycles"];
OpenApiOperation operation = pathItem["get"];
IDictionary <string, OpenApiResponse> responses = operation.Responses;
OpenApiResponse OK = responses["200"].ActualResponse;
var schema = OK.Content["application/json"];
JsonSchemaProperty items = schema.Schema.ActualSchema.ActualProperties["items"];
var innerProperties = items.Item.ActualSchema.ActualProperties;
string[] expectedProperties = new string[] { "id", "systemName", "name", "smallImageID", "helpText" };
foreach (string property in expectedProperties)
{
Assert.True(innerProperties.ContainsKey(property));
}
pathItem = docPaths["/ad-hoc-tasks/{adhocTaskId}/execute"];
operation = pathItem["post"];
responses = operation.Responses;
OK = responses["200"].ActualResponse;
schema = OK.Content["application/json"];
Assert.Equal("status", schema.Schema.ActualDiscriminator);
Assert.Equal("Completed", schema.Schema.ActualDiscriminatorObject.Mapping.Keys.First());
Assert.Equal(2, schema.Schema.ActualSchema.ActualProperties["status"].ActualSchema.Enumeration.Count);
}
public static JsonSchemaProperty SetRequired(this JsonSchemaProperty property, bool isRequired)
{
property.IsRequired = isRequired;
property.IsNullableRaw = !isRequired;
return(property);
}
private static JsonSchema BuildJsonSchema()
{
var schema = new JsonSchema {
Title = "Asset", Type = JsonObjectType.Object
};
void AddProperty(string name, JsonObjectType type, string?format = null)
{
var property = new JsonSchemaProperty {
Type = type, Format = format
};
schema.Properties[name.ToCamelCase()] = property;
}
AddProperty("id", JsonObjectType.String);
AddProperty("version", JsonObjectType.Integer);
AddProperty("created", JsonObjectType.String, JsonFormatStrings.DateTime);
AddProperty("createdBy", JsonObjectType.String);
AddProperty("fileHash", JsonObjectType.String);
AddProperty("fileName", JsonObjectType.String);
AddProperty("fileSize", JsonObjectType.Integer);
AddProperty("fileVersion", JsonObjectType.Integer);
AddProperty("isProtected", JsonObjectType.Boolean);
AddProperty("lastModified", JsonObjectType.String, JsonFormatStrings.DateTime);
AddProperty("lastModifiedBy", JsonObjectType.String);
AddProperty("metadata", JsonObjectType.None);
AddProperty("mimeType", JsonObjectType.String);
AddProperty("slug", JsonObjectType.String);
AddProperty("tags", JsonObjectType.String);
AddProperty("type", JsonObjectType.String);
return(schema);
}
private static JsonSchemaProperty Enrich(JsonSchemaProperty property, string?description = null, bool isRequired = false)
{
property.Description = description;
property.SetRequired(isRequired);
return(property);
}
private static JsonSchema BuildJsonSchema()
{
var schema = new JsonSchema {
Title = "Asset", Type = JsonObjectType.Object
};
void AddProperty(string name, JsonObjectType type, string?format = null)
{
var property = new JsonSchemaProperty {
Type = type, Format = format
};
schema.Properties[name.ToCamelCase()] = property;
}
AddProperty(nameof(IAssetEntity.Id), JsonObjectType.String, JsonFormatStrings.Guid);
AddProperty(nameof(IAssetEntity.Created), JsonObjectType.String, JsonFormatStrings.DateTime);
AddProperty(nameof(IAssetEntity.CreatedBy), JsonObjectType.String);
AddProperty(nameof(IAssetEntity.FileHash), JsonObjectType.String);
AddProperty(nameof(IAssetEntity.FileName), JsonObjectType.String);
AddProperty(nameof(IAssetEntity.FileSize), JsonObjectType.Integer);
AddProperty(nameof(IAssetEntity.FileVersion), JsonObjectType.Integer);
AddProperty(nameof(IAssetEntity.LastModified), JsonObjectType.String, JsonFormatStrings.DateTime);
AddProperty(nameof(IAssetEntity.LastModifiedBy), JsonObjectType.String);
AddProperty(nameof(IAssetEntity.Metadata), JsonObjectType.None);
AddProperty(nameof(IAssetEntity.MimeType), JsonObjectType.String);
AddProperty(nameof(IAssetEntity.Slug), JsonObjectType.String);
AddProperty(nameof(IAssetEntity.Tags), JsonObjectType.String);
AddProperty(nameof(IAssetEntity.Type), JsonObjectType.String);
AddProperty(nameof(IAssetEntity.Version), JsonObjectType.Integer);
return(schema);
}
/// <summary>Initializes a new instance of the <see cref="JsonPropertyModel"/> class. </summary>
/// <param name="name">The name of the property. </param>
/// <param name="parent">The parent object. </param>
/// <param name="schema">The property type as schema object. </param>
public JsonPropertyModel(string name, JsonObjectModel parent, JsonSchemaProperty schema)
{
Name = name;
Parent = parent;
Schema = schema;
Parent.PropertyChanged += (sender, args) => RaisePropertyChanged(() => Value);
}
public QueryJsonConversionTests()
{
var nested = new JsonSchemaProperty {
Title = "nested"
};
nested.Properties["property"] = new JsonSchemaProperty
{
Type = JsonObjectType.String
};
schema.Properties["boolean"] = new JsonSchemaProperty
{
Type = JsonObjectType.Boolean
};
schema.Properties["datetime"] = new JsonSchemaProperty
{
Type = JsonObjectType.String, Format = JsonFormatStrings.DateTime
};
schema.Properties["guid"] = new JsonSchemaProperty
{
Type = JsonObjectType.String, Format = JsonFormatStrings.Guid
};
schema.Properties["integer"] = new JsonSchemaProperty
{
Type = JsonObjectType.Integer
};
schema.Properties["number"] = new JsonSchemaProperty
{
Type = JsonObjectType.Number
};
schema.Properties["string"] = new JsonSchemaProperty
{
Type = JsonObjectType.String
};
schema.Properties["stringArray"] = new JsonSchemaProperty
{
Item = new JsonSchema
{
Type = JsonObjectType.String
},
Type = JsonObjectType.Array
};
schema.Properties["object"] = nested;
schema.Properties["reference"] = new JsonSchemaProperty
{
Reference = nested
};
}
public static JsonSchema AddProperty(this JsonSchema schema, string name, JsonSchemaProperty property, bool required)
{
schema.Properties.Add(name, property);
if (required)
{
schema.RequiredProperties.Add(name);
}
return(schema);
}
private JsonSchemaProperty GetProperty(PropertyDefinition prop)
{
var value = new JsonSchemaProperty()
{
IsRequired = prop.Required
};
if (!string.IsNullOrEmpty(prop.Description))
{
value.Description = prop.Description;
}
switch (prop.Type)
{
case PropertyDefinitionEnum.Integer:
case PropertyDefinitionEnum.Double:
GetTypeNumeric(prop, value);
break;
case PropertyDefinitionEnum.DateTime:
case PropertyDefinitionEnum.Time:
case PropertyDefinitionEnum.Date:
case PropertyDefinitionEnum.Email:
case PropertyDefinitionEnum.IdnEmail:
case PropertyDefinitionEnum.Hostname:
case PropertyDefinitionEnum.IdnHostname:
case PropertyDefinitionEnum.Ipv4:
case PropertyDefinitionEnum.Ipv6:
case PropertyDefinitionEnum.Uri:
case PropertyDefinitionEnum.UriReference:
case PropertyDefinitionEnum.Iri:
case PropertyDefinitionEnum.IriReference:
case PropertyDefinitionEnum.UriTemplate:
case PropertyDefinitionEnum.JsonPointer:
case PropertyDefinitionEnum.Regex:
case PropertyDefinitionEnum.Text:
GetTypeString(prop, value);
break;
case PropertyDefinitionEnum.Bool:
value.Type = JsonObjectType.Boolean;
break;
default:
break;
}
if (!prop.Required && prop.Enums.Count() == 0)
{
value.Type = value.Type & JsonObjectType.None;
}
return(value);
}
/// <summary>Initializes a new instance of the <see cref="PropertyModel"/> class.</summary>
/// <param name="classTemplateModel">The class template model.</param>
/// <param name="property">The property.</param>
/// <param name="typeResolver">The type resolver.</param>
/// <param name="settings">The settings.</param>
public PropertyModel(
ClassTemplateModel classTemplateModel,
JsonSchemaProperty property,
CSharpTypeResolver typeResolver,
CSharpGeneratorSettings settings)
: base(property, classTemplateModel, typeResolver, settings)
{
_property = property;
_settings = settings;
_resolver = typeResolver;
}
public static void SetRequired(this JsonSchemaProperty property, bool isRequired)
{
if (isRequired)
{
property.IsRequired = true;
}
else
{
property.IsNullableRaw = true;
}
}
/// <summary>Initializes a new instance of the <see cref="PropertyModel"/> class.</summary>
/// <param name="classTemplateModel">The class template model.</param>
/// <param name="property">The property.</param>
/// <param name="parentTypeName">Name of the parent type.</param>
/// <param name="typeResolver">The resolver.</param>
/// <param name="settings">The settings.</param>
public PropertyModel(
ClassTemplateModel classTemplateModel,
JsonSchemaProperty property, string parentTypeName,
TypeScriptTypeResolver typeResolver,
TypeScriptGeneratorSettings settings)
: base(property, classTemplateModel, typeResolver, settings)
{
_property = property;
_resolver = typeResolver;
_parentTypeName = parentTypeName;
_settings = settings;
}
private static void AddCollectionRuleTriggerSchema(GenerationContext context, JsonSchema triggerTypeSchema, string triggerType)
{
JsonSchemaProperty settingsProperty = AddDiscriminatedSubSchema(
context.Schema.Definitions[nameof(CollectionRuleTriggerOptions)],
nameof(CollectionRuleTriggerOptions.Type),
triggerType,
nameof(CollectionRuleTriggerOptions.Settings));
settingsProperty.Type = JsonObjectType.Null;
triggerTypeSchema.Enumeration.Add(triggerType);
}
private static JsonSchemaProperty SetDescription(this JsonSchemaProperty jsonProperty, IField field)
{
if (!string.IsNullOrWhiteSpace(field.RawProperties.Hints))
{
jsonProperty.Description = $"{field.Name} ({field.RawProperties.Hints})";
}
else
{
jsonProperty.Description = field.Name;
}
return(jsonProperty);
}
/// <summary>Initializes a new instance of the <see cref="PropertyModelBase"/> class.</summary>
/// <param name="property">The property.</param>
/// <param name="classTemplateModel">The class template model.</param>
/// <param name="typeResolver">The type resolver.</param>
/// <param name="settings">The settings.</param>
protected PropertyModelBase(
JsonSchemaProperty property,
ClassTemplateModelBase classTemplateModel,
TypeResolverBase typeResolver,
CodeGeneratorSettingsBase settings)
{
_classTemplateModel = classTemplateModel;
_property = property;
_settings = settings;
_typeResolver = typeResolver;
PropertyName = _settings.PropertyNameGenerator.Generate(_property);
}
private void GenerateObject(JToken token, JsonSchema schema, JsonSchema rootSchema)
{
schema.Type = JsonObjectType.Object;
foreach (var property in ((JObject)token).Properties())
{
var propertySchema = new JsonSchemaProperty();
var propertyName = property.Value.Type == JTokenType.Array ? ConversionUtilities.Singularize(property.Name) : property.Name;
var typeNameHint = ConversionUtilities.ConvertToUpperCamelCase(propertyName, true);
Generate(property.Value, propertySchema, rootSchema, typeNameHint);
schema.Properties[property.Name] = propertySchema;
}
}
static void FixProperty(JsonSchema item, string name)
{
if (item.Properties.Keys.Contains(name))
{
item.Properties.Remove(name);
var jsonProperty = new JsonSchemaProperty();
jsonProperty.Type = JsonObjectType.String;
jsonProperty.IsNullableRaw = true;
KeyValuePair <string, JsonSchemaProperty> keyValuePair = new KeyValuePair <string, JsonSchemaProperty>(name, jsonProperty);
item.Properties.Add(keyValuePair);
}
}
public static JsonSchema AddAnyOfProperty(this JsonSchema schema, string name, bool required, params JsonSchema[] values)
{
var enumProperty = new JsonSchemaProperty();
foreach (var value in values)
{
enumProperty.AnyOf.Add(value);
}
schema.Properties.Add(name, enumProperty);
if (required)
{
schema.RequiredProperties.Add(name);
}
return(schema);
}
public override string Generate(JsonSchemaProperty property)
{
// Makes array type properties initialized with empty collections
if (property.IsArray)
{
property.IsRequired = true;
}
// Cases CSharp properly
if (property.Name == "csharp")
{
return("CSharp");
}
return(base.Generate(property));
}
private static void AddConsoleLoggerOptionsSubSchema <TOptions>(GenerationContext context, ConsoleLoggerFormat consoleLoggerFormat)
{
JsonSchema consoleLoggerOptionsSchema = new JsonSchema();
consoleLoggerOptionsSchema.RequiredProperties.Add(nameof(ConsoleLoggerOptions.FormatterName));
JsonSchemaProperty formatterOptionsProperty = AddDiscriminatedSubSchema(
context.Schema.Definitions[nameof(ConsoleLoggerOptions)],
nameof(ConsoleLoggerOptions.FormatterName),
consoleLoggerFormat.ToString(),
nameof(ConsoleLoggerOptions.FormatterOptions),
consoleLoggerOptionsSchema);
formatterOptionsProperty.Reference = context.AddTypeIfNotExist <TOptions>();
}
/// <summary>Generates the property name.</summary>
/// <param name="property">The property.</param>
/// <returns>The new name.</returns>
public virtual string Generate(JsonSchemaProperty property)
{
return(ConversionUtilities.ConvertToUpperCamelCase(property.Name
.Replace("\"", string.Empty)
.Replace("@", string.Empty)
.Replace("$", string.Empty)
.Replace("[", string.Empty)
.Replace("]", string.Empty)
.Replace(".", "-")
.Replace("=", "-")
.Replace("+", "plus"), true)
.Replace("*", "Star")
.Replace(":", "_")
.Replace("-", "_"));
}
private void SetLinkProperties(RelationshipDefinition item, Dictionary <string, JsonSchemaProperty> dic)
{
var p = new JsonSchemaProperty()
{
Type = JsonObjectType.Object,
IsRequired = true,
};
dic.Add("OriginLink", p);
Dictionary <string, JsonSchemaProperty> dic2 = new Dictionary <string, JsonSchemaProperty>();
foreach (var property in item.Origin.Properties)
{
dic2.Add(property.Name, GetProperty(property));
}
p.Properties[nameof(ReferentialBase.Name)] = dic2[nameof(ReferentialBase.Name)];
foreach (var item2 in dic2.Keys.OrderBy(c => c))
{
if (!p.Properties.ContainsKey(item2))
{
p.Properties[item2] = dic2[item2];
}
}
p = new JsonSchemaProperty()
{
Type = JsonObjectType.Object,
IsRequired = true,
};
dic.Add("TargetLink", p);
dic2 = new Dictionary <string, JsonSchemaProperty>();
foreach (var property in item.Target.Properties)
{
dic2.Add(property.Name, GetProperty(property));
}
p.Properties[nameof(ReferentialBase.Name)] = dic2[nameof(ReferentialBase.Name)];
foreach (var item2 in dic2.Keys.OrderBy(c => c))
{
if (!p.Properties.ContainsKey(item2))
{
p.Properties[item2] = dic2[item2];
}
}
}
private static void AddDefaultConsoleLoggerOptionsSubSchema(GenerationContext context)
{
JsonSchema consoleLoggerOptionsSchema = new JsonSchema();
JsonSchemaProperty formatterNameProperty = new JsonSchemaProperty();
JsonSchemaProperty formatterOptionsProperty = new JsonSchemaProperty();
formatterOptionsProperty.Reference = context.AddTypeIfNotExist <SimpleConsoleFormatterOptions>();
formatterNameProperty.Type = JsonObjectType.Null;
formatterNameProperty.Default = "Simple";
consoleLoggerOptionsSchema.Properties.Add(nameof(ConsoleLoggerOptions.FormatterName), formatterNameProperty);
consoleLoggerOptionsSchema.Properties.Add(nameof(ConsoleLoggerOptions.FormatterOptions), formatterOptionsProperty);
context.Schema.Definitions[nameof(ConsoleLoggerOptions)].OneOf.Add(consoleLoggerOptionsSchema);
}
private static void AddCollectionRuleTriggerSchema <TOptions>(GenerationContext context, JsonSchema triggerTypeSchema, string triggerType)
{
JsonSchema subSchema = new JsonSchema();
subSchema.RequiredProperties.Add(nameof(CollectionRuleTriggerOptions.Settings));
JsonSchemaProperty settingsProperty = AddDiscriminatedSubSchema(
context.Schema.Definitions[nameof(CollectionRuleTriggerOptions)],
nameof(CollectionRuleTriggerOptions.Type),
triggerType,
nameof(CollectionRuleTriggerOptions.Settings),
subSchema);
settingsProperty.Reference = context.AddTypeIfNotExist <TOptions>();
triggerTypeSchema.Enumeration.Add(triggerType);
}
/// <summary>Initializes a new instance of the <see cref="PropertyModel"/> class.</summary>
/// <param name="classTemplateModel">The class template model.</param>
/// <param name="property">The property.</param>
/// <param name="typeResolver">The type resolver.</param>
/// <param name="settings">The settings.</param>
public PropertyModel(
ClassTemplateModel classTemplateModel,
JsonSchemaProperty property,
CSharpTypeResolver typeResolver,
CSharpGeneratorSettings settings)
: base(property, classTemplateModel, typeResolver, settings)
{
_property = property;
_settings = settings;
_resolver = typeResolver;
Id = property.Id;
if (property.Reference != null && string.IsNullOrEmpty(Id))
{
Id = property.Reference.Id;
}
}
private JToken HandleStringType(JsonSchema schema, JsonSchemaProperty property)
{
if (schema.Format == JsonFormatStrings.Date)
{
return(JToken.FromObject(DateTimeOffset.UtcNow.ToString("yyyy-MM-dd")));
}
else if (schema.Format == JsonFormatStrings.DateTime)
{
return(JToken.FromObject(DateTimeOffset.UtcNow.ToString("o")));
}
else if (property != null)
{
return(JToken.FromObject(property.Name));
}
else
{
return(JToken.FromObject(""));
}
}
