/// <summary>
/// Determines whether the specified model type is structurally equal to this object.
/// </summary>
/// <param name="other">The object to compare with this object.</param>
/// <returns>true if the specified object is functionally equal to this object; otherwise, false.</returns>
public override bool StructurallyEquals(IModelType other)
{
if (ReferenceEquals(other as SequenceType, null))
{
return false;
}
return base.StructurallyEquals(other) &&
ElementType.StructurallyEquals((other as SequenceType).ElementType);
}
/// <summary>
/// Determines whether the specified model type is structurally equal to this object.
/// </summary>
/// <param name="other">The object to compare with this object.</param>
/// <returns>true if the specified object is functionally equal to this object; otherwise, false.</returns>
public override bool StructurallyEquals(IModelType other)
{
if (ReferenceEquals(other as DictionaryType, null))
{
return false;
}
return base.StructurallyEquals(other) &&
ValueType.StructurallyEquals((other as DictionaryType).ValueType) &&
SupportsAdditionalProperties == (other as DictionaryType).SupportsAdditionalProperties;
}
public override string EscapeDefaultValue(string defaultValue, IModelType type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
var primaryType = type as PrimaryType;
if (defaultValue != null)
{
if (type is CompositeType)
{
return "new " + type.Name + "()";
}
if (primaryType != null)
{
if (primaryType.KnownPrimaryType == KnownPrimaryType.String)
{
return Instance.QuoteValue(defaultValue);
}
if (primaryType.KnownPrimaryType == KnownPrimaryType.Boolean)
{
return defaultValue.ToLowerInvariant();
}
if ((primaryType.KnownPrimaryType == KnownPrimaryType.Date) ||
(primaryType.KnownPrimaryType == KnownPrimaryType.DateTime) ||
(primaryType.KnownPrimaryType == KnownPrimaryType.DateTimeRfc1123) ||
(primaryType.KnownPrimaryType == KnownPrimaryType.TimeSpan) ||
(primaryType.KnownPrimaryType == KnownPrimaryType.ByteArray) ||
(primaryType.KnownPrimaryType == KnownPrimaryType.Base64Url) ||
(primaryType.KnownPrimaryType == KnownPrimaryType.UnixTime))
{
return
$"Microsoft.Rest.Serialization.SafeJsonConvert.DeserializeObject<{primaryType.Name}>"+
$"({Instance.QuoteValue($"\"{defaultValue}\"")}, this.Client.SerializationSettings)";
}
}
}
return defaultValue;
}
/// <summary>
/// Returns language specific type reference name.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public virtual IModelType NormalizeTypeReference(IModelType type)
{
return type;
}
private bool TryBuildResponse(string methodName, HttpStatusCode responseStatusCode,
OperationResponse response, Method method, List<Stack<IModelType>> types, IModelType headerType)
{
bool handled = false;
IModelType serviceType;
if (SwaggerOperationProducesJson())
{
if (TryBuildResponseBody(methodName, response,
s => GenerateResponseObjectName(s, responseStatusCode), out serviceType))
{
method.Responses[responseStatusCode] = new Response(serviceType, headerType);
BuildMethodReturnTypeStack(serviceType, types);
handled = true;
}
}
return handled;
}
/// <summary>
/// Returns the ModelType name expressed as a nullable type (for classes, nothing different, for value types, append a '?'
/// </summary>
/// <param name="modelType">The ModelType to return as nullable</param>
/// <returns>The ModelType name expressed as a nullable type</returns>
public static string AsNullableType(this IModelType modelType) => modelType.IsValueType() ? $"{modelType.Name}?" : modelType.DeclarationName;
/// <summary> /// Returns true if the type is a PrimaryType with KnownPrimaryType matching typeToMatch. /// </summary> /// <param name="type"></param> /// <param name="typeToMatch"></param> /// <returns></returns> public static bool IsPrimaryType(this IModelType type, KnownPrimaryType typeToMatch) => typeToMatch == (type as PrimaryType)?.KnownPrimaryType;
/// <summary>
/// Initializes a new instance of Response.
/// </summary>
/// <param name="body">Body type.</param>
/// <param name="headers">Headers type.</param>
public Response(IModelType body, IModelType headers)
{
Body = body;
Headers = headers;
}
/// <summary>
/// Internal method for generating Yard-compatible representation of given type.
/// </summary>
/// <param name="type">The type doc needs to be generated for.</param>
/// <returns>Doc in form of string.</returns>
private static string PrepareTypeForDocRecursively(IModelType type)
{
var sequenceType = type as SequenceType;
var compositeType = type as CompositeType;
var enumType = type as EnumType;
var dictionaryType = type as DictionaryType;
var primaryType = type as PrimaryType;
if (primaryType != null)
{
if (primaryType.KnownPrimaryType == KnownPrimaryType.String)
{
return "String";
}
if (primaryType.KnownPrimaryType == KnownPrimaryType.Int || primaryType.KnownPrimaryType == KnownPrimaryType.Long)
{
return "Integer";
}
if (primaryType.KnownPrimaryType == KnownPrimaryType.Boolean)
{
return "Boolean";
}
if (primaryType.KnownPrimaryType == KnownPrimaryType.Double)
{
return "Float";
}
if (primaryType.KnownPrimaryType == KnownPrimaryType.Date)
{
return "Date";
}
if (primaryType.KnownPrimaryType == KnownPrimaryType.DateTime)
{
return "DateTime";
}
if (primaryType.KnownPrimaryType == KnownPrimaryType.DateTimeRfc1123)
{
return "DateTime";
}
if (primaryType.KnownPrimaryType == KnownPrimaryType.ByteArray)
{
return "Array<Integer>";
}
if (primaryType.KnownPrimaryType == KnownPrimaryType.TimeSpan)
{
return "Duration"; //TODO: Is this a real Ruby type...?
}
}
if (compositeType != null)
{
return compositeType.Name;
}
if (enumType != null)
{
return ((EnumTypeRb)enumType).ModuleName;
}
if (sequenceType != null)
{
string internalString = PrepareTypeForDocRecursively(sequenceType.ElementType);
if (!string.IsNullOrEmpty(internalString))
{
return $"Array<{internalString}>";
}
return string.Empty;
}
if (dictionaryType != null)
{
string internalString = PrepareTypeForDocRecursively(dictionaryType.ValueType);
if (!string.IsNullOrEmpty(internalString))
{
return $"Hash{{String => {internalString}}}";
}
return string.Empty;
}
return string.Empty;
}
public static bool ShouldBeSyntheticType(this IModelType type)
{
return(type is PrimaryType || type is SequenceType || type is DictionaryType || type is EnumType);
}
public string DeserializeResponse(IModelType type, string valueReference = "result", string responseVariable = "parsedResponse")
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
var builder = new IndentedStringBuilder(" ");
builder.AppendLine("var {0} = null;", responseVariable)
.AppendLine("try {")
.Indent()
.AppendLine("{0} = JSON.parse(responseBody);", responseVariable)
.AppendLine("{0} = JSON.parse(responseBody);", valueReference);
var deserializeBody = GetDeserializationString(type, valueReference, responseVariable);
if (!string.IsNullOrWhiteSpace(deserializeBody))
{
builder.AppendLine("if ({0} !== null && {0} !== undefined) {{", responseVariable)
.Indent()
.AppendLine(deserializeBody)
.Outdent()
.AppendLine("}");
}
builder.Outdent()
.AppendLine("} catch (error) {")
.Indent()
.AppendLine(DeserializationError)
.Outdent()
.AppendLine("}");
return builder.ToString();
}
public string GetDeserializationString(IModelType type, string valueReference = "result", string responseVariable = "parsedResponse")
{
var builder = new IndentedStringBuilder(" ");
if (type is CompositeType)
{
builder.AppendLine("var resultMapper = new client.models['{0}']().mapper();", type.Name);
}
else
{
builder.AppendLine("var resultMapper = {{{0}}};", type.ConstructMapper(responseVariable, null, false, false));
}
builder.AppendLine("{1} = client.deserialize(resultMapper, {0}, '{1}');", responseVariable, valueReference);
return builder.ToString();
}
/// <summary>
/// Determines whether the specified model type is structurally equal to this object.
/// </summary>
/// <param name="other">The object to compare with this object.</param>
/// <returns>true if the specified object is functionally equal to this object; otherwise, false.</returns>
public virtual bool StructurallyEquals(IModelType other)
{
if (ReferenceEquals(other, null))
{
return false;
}
return GetType() == other.GetType() && Name.Equals(other.Name);
}
/// <summary>
/// Returns deserialization settings reference.
/// </summary>
/// <param name="deserializationType"></param>
/// <returns></returns>
public string GetDeserializationSettingsReference(IModelType deserializationType)
{
if (deserializationType.IsOrContainsPrimaryType(KnownPrimaryType.Date))
{
return "new Microsoft.Rest.Serialization.DateJsonConverter()";
}
else if (deserializationType.IsOrContainsPrimaryType(KnownPrimaryType.Base64Url))
{
return "new Microsoft.Rest.Serialization.Base64UrlJsonConverter()";
}
else if (deserializationType.IsOrContainsPrimaryType(KnownPrimaryType.UnixTime))
{
return "new Microsoft.Rest.Serialization.UnixTimeJsonConverter()";
}
return ClientReference + ".DeserializationSettings";
}
/// <summary>
/// Returns language specific type declaration name.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public virtual IModelType NormalizeTypeDeclaration(IModelType type)
{
return type;
}
/// <summary>
/// Returns true if the specified type is user-defined.
/// </summary>
public static bool IsUserDefinedType(this IModelType type)
{
return((type is CompositeTypeGo) || (type is EnumTypeGo etg && etg.IsNamed));
}
public virtual string GetExceptionNameIfExist(IModelType type, bool needsQuote)
{
CompositeType compType = type as CompositeType;
if (compType != null)
{
if (ErrorTypes.Contains(compType))
{
if (needsQuote)
{
return ", '" + compType.GetExceptionDefineType() + "'";
}
return ", " + compType.GetExceptionDefineType();
}
}
return string.Empty;
}
/// <summary>
/// Determines whether the specified model type is structurally equal to this object.
/// </summary>
/// <param name="other">The object to compare with this object.</param>
/// <returns>true if the specified object is functionally equal to this object; otherwise, false.</returns>
public override bool StructurallyEquals(IModelType other)
{
if (ReferenceEquals(other as PrimaryType, null))
{
return false;
}
return base.StructurallyEquals(other) &&
KnownPrimaryType == (other as PrimaryType).KnownPrimaryType &&
Format == (other as PrimaryType).Format;
}
public string GetDocumentationType(IModelType type)
{
return (type as IExtendedModelTypePy)?.TypeDocumentation ?? PythonConstants.None;
}
public override string EscapeDefaultValue(string defaultValue, IModelType type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
PrimaryType primaryType = type as PrimaryType;
if (defaultValue != null && primaryType != null)
{
if (primaryType.KnownPrimaryType == KnownPrimaryType.String)
{
return QuoteValue(defaultValue, quoteChar: "'");
}
else if (primaryType.KnownPrimaryType == KnownPrimaryType.Boolean)
{
return defaultValue.ToLowerInvariant();
}
else
{
if (primaryType.KnownPrimaryType == KnownPrimaryType.Date ||
primaryType.KnownPrimaryType == KnownPrimaryType.DateTime ||
primaryType.KnownPrimaryType == KnownPrimaryType.DateTimeRfc1123 ||
primaryType.KnownPrimaryType == KnownPrimaryType.TimeSpan)
{
return "Date.parse('" + defaultValue + "')";
}
if (primaryType.KnownPrimaryType == KnownPrimaryType.ByteArray)
{
return "'" + defaultValue + "'.bytes.pack('C*')";
}
}
}
EnumType enumType = type as EnumType;
if (defaultValue != null && enumType != null)
{
return QuoteValue(defaultValue, quoteChar: "'");
}
return defaultValue;
}
private static void AppendConstraintValidations(string valueReference, Dictionary <Constraint, string> constraints, IndentedStringBuilder sb, IModelType type)
{
foreach (var constraint in constraints.Keys)
{
string constraintCheck;
var knownFormat = (type as PrimaryType)?.KnownFormat;
string constraintValue =
knownFormat == KnownFormat.@char ? $"'{constraints[constraint]}'" :
knownFormat == KnownFormat.@decimal ? $"{constraints[constraint]}m" :
constraints[constraint];
switch (constraint)
{
case Constraint.ExclusiveMaximum:
constraintCheck = $"{valueReference} >= {constraintValue}";
break;
case Constraint.ExclusiveMinimum:
constraintCheck = $"{valueReference} <= {constraintValue}";
break;
case Constraint.InclusiveMaximum:
constraintCheck = $"{valueReference} > {constraintValue}";
break;
case Constraint.InclusiveMinimum:
constraintCheck = $"{valueReference} < {constraintValue}";
break;
case Constraint.MaxItems:
constraintCheck = $"{valueReference}.Count > {constraintValue}";
break;
case Constraint.MaxLength:
constraintCheck = $"{valueReference}.Length > {constraintValue}";
break;
case Constraint.MinItems:
constraintCheck = $"{valueReference}.Count < {constraintValue}";
break;
case Constraint.MinLength:
constraintCheck = $"{valueReference}.Length < {constraintValue}";
break;
case Constraint.MultipleOf:
constraintCheck = $"{valueReference} % {constraintValue} != 0";
break;
case Constraint.Pattern:
constraintValue = ToLiteral(constraintValue);
if (type is DictionaryType)
{
constraintCheck = $"!System.Linq.Enumerable.All({valueReference}.Values, value => System.Text.RegularExpressions.Regex.IsMatch(value, {constraintValue}))";
}
else
{
constraintCheck = $"!System.Text.RegularExpressions.Regex.IsMatch({valueReference}, {constraintValue})";
}
break;
case Constraint.UniqueItems:
if ("true".EqualsIgnoreCase(constraints[constraint]))
{
constraintCheck = $"{valueReference}.Count != {valueReference}.Distinct().Count()";
}
else
{
constraintCheck = null;
}
break;
default:
throw new NotSupportedException("Constraint '" + constraint + "' is not supported.");
}
if (constraintCheck != null)
{
if (constraint != Constraint.UniqueItems)
{
sb.AppendLine("if ({0})", constraintCheck)
.AppendLine("{").Indent()
.AppendLine("throw new Microsoft.Rest.ValidationException(Microsoft.Rest.ValidationRules.{0}, \"{1}\", {2});",
constraint, valueReference.Replace("this.", ""), constraintValue).Outdent()
.AppendLine("}");
}
else
{
sb.AppendLine("if ({0})", constraintCheck)
.AppendLine("{").Indent()
.AppendLine("throw new Microsoft.Rest.ValidationException(Microsoft.Rest.ValidationRules.{0}, \"{1}\");",
constraint, valueReference.Replace("this.", "")).Outdent()
.AppendLine("}");
}
}
}
}
/// <summary>
/// Determines whether the specified model type is structurally equal to this object.
/// </summary>
/// <param name="other">The object to compare with this object.</param>
/// <returns>true if the specified object is functionally equal to this object; otherwise, false.</returns>
public override bool StructurallyEquals(IModelType other)
{
if (ReferenceEquals(other as EnumType, null))
{
return false;
}
return base.StructurallyEquals(other) &&
Values.OrderBy(t => t).SequenceEqual(Values.OrderBy(t => t)) &&
ModelAsString == (other as EnumType).ModelAsString;
}
public static IndentedStringBuilder AppendConstraintValidations(this IModelType type, string valueReference, Dictionary <Constraint, string> constraints,
IndentedStringBuilder builder)
{
if (valueReference == null)
{
throw new ArgumentNullException(nameof(valueReference));
}
if (constraints == null)
{
throw new ArgumentNullException(nameof(constraints));
}
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
foreach (var constraint in constraints.Keys)
{
string constraintCheck;
string constraintValue = constraints[constraint];
switch (constraint)
{
case Constraint.ExclusiveMaximum:
constraintCheck = $"{valueReference} >= {constraints[constraint]}";
break;
case Constraint.ExclusiveMinimum:
constraintCheck = $"{valueReference} <= {constraints[constraint]}";
break;
case Constraint.InclusiveMaximum:
constraintCheck = $"{valueReference} > {constraints[constraint]}";
break;
case Constraint.InclusiveMinimum:
constraintCheck = $"{valueReference} < {constraints[constraint]}";
break;
case Constraint.MaxItems:
constraintCheck = $"{valueReference}.length > {constraints[constraint]}";
break;
case Constraint.MaxLength:
constraintCheck = $"{valueReference}.length > {constraints[constraint]}";
break;
case Constraint.MinItems:
constraintCheck = $"{valueReference}.length < {constraints[constraint]}";
break;
case Constraint.MinLength:
constraintCheck = $"{valueReference}.length < {constraints[constraint]}";
break;
case Constraint.MultipleOf:
constraintCheck = $"{valueReference} % {constraints[constraint]} !== 0";
break;
case Constraint.Pattern:
constraintValue = "/" + constraintValue.Replace("/", "\\/") + "/";
constraintCheck = $"{valueReference}.match({constraintValue}) === null";
break;
case Constraint.UniqueItems:
if ("true".EqualsIgnoreCase(constraints[constraint]))
{
constraintCheck = string.Format(
"{0}.length !== {0}.filter(function(item, i, ar) {{ return ar.indexOf(item) === i; }}).length", valueReference);
}
else
{
constraintCheck = null;
}
break;
default:
throw new NotSupportedException("Constraint '" + constraint + "' is not supported.");
}
if (constraintCheck != null)
{
var escapedValueReference = valueReference.EscapeSingleQuotes();
if (constraint != Constraint.UniqueItems)
{
builder.AppendLine("if ({0})", constraintCheck)
.AppendLine("{").Indent()
.AppendLine("throw new Error('\"{0}\" should satisfy the constraint - \"{1}\": {2}');",
escapedValueReference, constraint, constraintValue).Outdent()
.AppendLine("}");
}
else
{
builder.AppendLine("if ({0})", constraintCheck)
.AppendLine("{").Indent()
.AppendLine("throw new Error('\"{0}\" should satisfy the constraint - \"{1}\"');",
escapedValueReference, constraint).Outdent()
.AppendLine("}");
}
}
}
return(builder);
}
private static JsonSchema ParseType(Property property, IModelType type, IDictionary<string, JsonSchema> definitions, IEnumerable<CompositeType> modelTypes)
{
JsonSchema result = null;
if (property == null || !property.IsReadOnly)
{
// A schema that matches a JSON object with specific properties, such as
// { "name": { "type": "string" }, "age": { "type": "number" } }
CompositeType compositeType = type as CompositeType;
if (compositeType != null)
{
result = ParseCompositeType(property, compositeType, definitions, modelTypes);
}
else
{
// A schema that matches a "dictionary" JSON object, such as
// { "additionalProperties": { "type": "string" } }
DictionaryType dictionaryType = type as DictionaryType;
if (dictionaryType != null)
{
result = ParseDictionaryType(property, dictionaryType, definitions, modelTypes);
}
else
{
// A schema that matches a single value from a given set of values, such as
// { "enum": [ "a", "b" ] }
EnumType enumType = type as EnumType;
if (enumType != null)
{
result = ParseEnumType(property, enumType);
}
else
{
// A schema that matches simple values, such as { "type": "number" }
PrimaryType primaryType = type as PrimaryType;
if (primaryType != null)
{
result = ParsePrimaryType(property, primaryType);
}
else
{
// A schema that matches an array of values, such as
// { "items": { "type": "number" } }
SequenceType sequenceType = type as SequenceType;
if (sequenceType != null)
{
result = ParseSequenceType(property, sequenceType, definitions, modelTypes);
}
else
{
Debug.Fail("Unrecognized property type: " + type.GetType());
}
}
}
}
}
}
return result;
}
/// <summary> /// Determines if the given IModelType is a value type in C# /// </summary> /// <param name="modelType">The type to check</param> /// <returns>True if the type maps to a C# value type, otherwise false</returns> public static bool IsValueType(this IModelType modelType) => true == (modelType as IExtendedModelType)?.IsValueType;
public string GetPropertyDocumentationType(IModelType type)
{
// todo: fix the glitch where some model types don't have their parent reference set correctly
if (type.Parent == null && (type is CompositeTypePy))
{
((CompositeTypePy)type).CodeModel = CodeModel;
}
if (type.Parent == null && (type is EnumTypePy))
{
((EnumTypePy)type).CodeModel = CodeModel;
}
return (type as IExtendedModelTypePy)?.TypeDocumentation ?? PythonConstants.None;
}
private Response BuildMethodReturnType(List<Stack<IModelType>> types, IModelType headerType)
{
IModelType baseType = New<PrimaryType>(KnownPrimaryType.Object);
// Return null if no response is specified
if (types.Count == 0)
{
return new Response(null, headerType);
}
// Return first if only one return type
if (types.Count == 1)
{
return new Response(types.First().Pop(), headerType);
}
// BuildParameter up type inheritance tree
types.ForEach(typeStack =>
{
IModelType type = typeStack.Peek();
while (!Equals(type, baseType))
{
if (type is CompositeType && _swaggerModeler.ExtendedTypes.ContainsKey(type.Name.RawValue))
{
type = _swaggerModeler.GeneratedTypes[_swaggerModeler.ExtendedTypes[type.Name.RawValue]];
}
else
{
type = baseType;
}
typeStack.Push(type);
}
});
// Eliminate commonly shared base classes
while (!types.First().IsNullOrEmpty())
{
IModelType currentType = types.First().Peek();
foreach (var typeStack in types)
{
IModelType t = typeStack.Pop();
if (!Equals(t, currentType))
{
return new Response(baseType, headerType);
}
}
baseType = currentType;
}
return new Response(baseType, headerType);
}
public static bool IsStream(this IModelType type)
{
return(type is PrimaryType primaryType && primaryType.KnownPrimaryType == KnownPrimaryType.Stream);
}
private void TryBuildDefaultResponse(string methodName, OperationResponse response, Method method, IModelType headerType)
{
IModelType errorModel = null;
if (SwaggerOperationProducesJson())
{
if (TryBuildResponseBody(methodName, response, s => GenerateErrorModelName(s), out errorModel))
{
method.DefaultResponse = new Response(errorModel, headerType);
}
}
}
/// <summary>
/// Return the TypeScript type (as a string) for specified type.
/// </summary>
/// <param name="type">IType to query</param>
/// <param name="inModelsModule">Pass true if generating the code for the models module, thus model types don't need a "models." prefix</param>
/// <returns>TypeScript type string for type</returns>
public static string TSType(this IModelType type, bool inModelsModule)
{
CompositeTypeTS composite = type as CompositeTypeTS;
SequenceType sequence = type as SequenceType;
DictionaryType dictionary = type as DictionaryType;
PrimaryType primary = type as PrimaryType;
EnumType enumType = type as EnumType;
string tsType;
if (primary != null)
{
tsType = primary.PrimaryTSType();
}
else if (enumType != null)
{
string enumName = enumType.DeclarationName;
if (inModelsModule || enumName.Contains('.') || enumName == "string")
{
tsType = enumName;
}
else
{
tsType = "Models." + enumName.ToPascalCase();
}
}
else if (composite != null)
{
// ServiceClientCredentials starts with the "msRest." prefix, so strip msRest./msRestAzure. as we import those
// types with no module prefix needed
var compositeName = composite.UnionTypeName;
if (compositeName.StartsWith("msRest.") || compositeName.StartsWith("msRestAzure."))
{
tsType = compositeName.Substring(compositeName.IndexOf('.') + 1);
}
else if (inModelsModule || compositeName.Contains('.'))
{
tsType = compositeName;
}
else
{
tsType = "Models." + compositeName;
}
}
else if (sequence != null)
{
if (sequence.IsSequenceContainingDateKind())
{
tsType = sequence.ElementType.TSType(inModelsModule) + "[]" + " | string[]";
}
else
{
tsType = sequence.ElementType.TSType(inModelsModule) + "[]";
}
}
else if (dictionary != null)
{
if (dictionary.IsDictionaryContainingDateKind()) //then provide a union of Date and string
{
tsType = "{ [propertyName: string]: " + dictionary.ValueType.TSType(inModelsModule) + " }" + " | { [propertyName: string]: string }";
}
else
{
tsType = "{ [propertyName: string]: " + dictionary.ValueType.TSType(inModelsModule) + " }";
}
}
else
{
throw new NotImplementedException($"Type '{type}' not implemented");
}
return(tsType);
}
/// <summary>
/// Casts the specified IModelType to the specified type paramater or throws an InvalidCastException.
/// </summary>
/// <typeparam name="T">The type to cast to.</typeparam>
/// <param name="type">The type to cast from.</param>
/// <returns>The type converted to T.</returns>
public static T Cast <T>(this IModelType type)
{
return((T)type);
}
public static void ConstructMapper(TSBuilder builder, IModelType type, string serializedName, IVariable parameter, bool isPageable, bool expandComposite, bool isXML, bool isCaseSensitive = true, string xmlName = null)
{
builder.Value(value => ConstructMapper(value, type, serializedName, parameter, isPageable, expandComposite, isXML, isCaseSensitive, xmlName));
}
//public bool IsComposed
//{ get; private set; }
#region .ctors and factories
private ModelViewProperty(IModelType parent, IModelProperty modelProperty)
{
Parent = parent;
ModelProperty = modelProperty;
}
public static void ConstructMapper(TSValue value, IModelType type, string serializedName, IVariable parameter, bool isPageable, bool expandComposite, bool isXML, bool isCaseSensitive = true, string xmlName = null)
{
value.Object(mapper => ConstructMapper(mapper, type, serializedName, parameter, isPageable, expandComposite, isXML, isCaseSensitive, xmlName));
}
/////////////////////////////////////////////////////////////////////////////////////////
//
// Type Extensions
//
/////////////////////////////////////////////////////////////////////////////////////////
public static bool IsStreamType(this IModelType body)
{
var r = body as CompositeTypeGo;
return(r != null && (r.BaseType.PrimaryType(KnownPrimaryType.Stream)));
}
public static void ConstructMapper(TSObject mapper, IModelType type, string serializedName, IVariable parameter, bool isPageable, bool expandComposite, bool isXML, bool isCaseSensitive = true, string xmlName = null)
{
string defaultValue = null;
bool isRequired = false;
bool isConstant = false;
bool isReadOnly = false;
Dictionary <Constraint, string> constraints = null;
var property = parameter as Property;
if (parameter != null)
{
defaultValue = parameter.DefaultValue;
isRequired = parameter.IsRequired;
isConstant = parameter.IsConstant;
constraints = parameter.Constraints;
}
string xmlPrefix = !isXML ? null : property?.XmlPrefix ?? type?.XmlPrefix;
bool addXmlNameFromParameterValue = isXML && !string.IsNullOrEmpty(xmlName) && xmlName != serializedName;
if (addXmlNameFromParameterValue)
{
if (!string.IsNullOrEmpty(xmlPrefix))
{
xmlName = $"{xmlPrefix}:{xmlName}";
}
mapper.QuotedStringProperty("xmlName", xmlName);
}
if (isXML && !string.IsNullOrEmpty(serializedName) && !string.IsNullOrEmpty(xmlPrefix))
{
serializedName = $"{xmlPrefix}:{serializedName}";
}
if (property != null)
{
isReadOnly = property.IsReadOnly;
if (isXML)
{
if (property.XmlIsAttribute)
{
mapper.BooleanProperty("xmlIsAttribute", true);
}
if (property.XmlIsWrapped)
{
mapper.BooleanProperty("xmlIsWrapped", true);
}
string propertyXmlName = property.ModelType.XmlProperties?.Name ?? property.XmlName;
if (!addXmlNameFromParameterValue && !string.IsNullOrEmpty(propertyXmlName))
{
if (!string.IsNullOrEmpty(xmlPrefix))
{
propertyXmlName = $"{xmlPrefix}:{propertyXmlName}";
}
// For some reason we can't omit xmlName in this scenario if it is equal to
// serializedName. It might have to do with whether or not xmlElementName
// is present, but I'm not sure at this time.
mapper.QuotedStringProperty("xmlName", propertyXmlName);
}
}
}
CompositeTypeTS composite = type as CompositeTypeTS;
if (composite != null && composite.ContainsConstantProperties && (parameter != null && parameter.IsRequired))
{
defaultValue = "{}";
}
SequenceType sequence = type as SequenceType;
if (sequence != null && isXML)
{
if (sequence.ElementXmlIsWrapped)
{
mapper.BooleanProperty("xmlElementIsWrapped", true);
}
string xmlElementName = sequence.ElementType.XmlProperties?.Name ?? sequence.ElementXmlName;
if (!string.IsNullOrEmpty(xmlElementName))
{
mapper.QuotedStringProperty("xmlElementName", xmlElementName);
}
}
if (isRequired)
{
mapper.BooleanProperty("required", true);
}
if (parameter?.IsXNullable != null)
{
if (parameter.IsXNullable.Value)
{
mapper.BooleanProperty("nullable", true);
}
else
{
mapper.BooleanProperty("nullable", false);
}
}
if (isReadOnly)
{
mapper.BooleanProperty("readOnly", true);
}
if (isConstant)
{
mapper.BooleanProperty("isConstant", true);
}
if (serializedName != null)
{
if (!isCaseSensitive)
{
serializedName = serializedName.ToLower();
}
mapper.QuotedStringProperty("serializedName", serializedName);
}
if (!string.IsNullOrEmpty(defaultValue))
{
mapper.TextProperty("defaultValue", defaultValue);
}
DictionaryType dictionary = type as DictionaryType;
PrimaryType primary = type as PrimaryType;
EnumType enumType = type as EnumType;
void applyConstraints(TSObject obj)
{
bool useClientSideValidation = (bool)(Settings.Instance?.CustomSettings[CodeModelTS.ClientSideValidationSettingName] ?? false);
if (useClientSideValidation && constraints != null && constraints.Any())
{
obj.ObjectProperty("constraints", constraintsObject =>
{
foreach (KeyValuePair <Constraint, string> constraintEntry in constraints)
{
Constraint constraint = constraintEntry.Key;
string constraintValue = constraintEntry.Value;
if (constraint == Constraint.Pattern)
{
constraintValue = CreateRegexPatternConstraintValue(constraintValue);
}
constraintsObject.TextProperty(constraint.ToString(), constraintValue);
}
});
}
}
// Apply header collection constraints only to dictionary values, not the dictionary itself
string prefix = parameter?.Extensions?.GetValue <string>(SwaggerExtensions.HeaderCollectionPrefix);
bool skipConstraints = !string.IsNullOrEmpty(prefix) && dictionary != null;
if (!skipConstraints)
{
applyConstraints(mapper);
}
if (primary != null)
{
switch (primary.KnownPrimaryType)
{
case KnownPrimaryType.Base64Url:
case KnownPrimaryType.Boolean:
case KnownPrimaryType.ByteArray:
case KnownPrimaryType.Date:
case KnownPrimaryType.DateTime:
case KnownPrimaryType.DateTimeRfc1123:
case KnownPrimaryType.Object:
case KnownPrimaryType.Stream:
case KnownPrimaryType.String:
case KnownPrimaryType.TimeSpan:
case KnownPrimaryType.UnixTime:
case KnownPrimaryType.Uuid:
AddTypeProperty(mapper, primary.KnownPrimaryType.ToString());
break;
case KnownPrimaryType.Int:
case KnownPrimaryType.Long:
case KnownPrimaryType.Decimal:
case KnownPrimaryType.Double:
AddTypeProperty(mapper, "Number");
break;
default:
throw new NotImplementedException($"{primary} is not a supported Type.");
}
}
else if (enumType != null)
{
if (enumType.ModelAsString)
{
AddTypeProperty(mapper, "String");
}
else
{
AddTypeProperty(mapper, "Enum", typeObject =>
{
typeObject.ArrayProperty("allowedValues", allowedValues =>
{
foreach (EnumValue enumValue in enumType.Values)
{
allowedValues.QuotedString(enumValue.SerializedName);
}
});
});
}
}
else if (sequence != null)
{
AddTypeProperty(mapper, "Sequence", typeObject =>
{
typeObject.Property("element", element =>
{
ConstructMapper(element, sequence.ElementType, null, null, false, false, isXML, isCaseSensitive);
});
});
}
else if (dictionary != null)
{
AddTypeProperty(mapper, "Dictionary", typeObject =>
{
typeObject.ObjectProperty("value", dictionaryValue =>
{
ConstructMapper(dictionaryValue, dictionary.ValueType, null, null, false, false, isXML, isCaseSensitive);
applyConstraints(dictionaryValue);
});
});
if (!string.IsNullOrEmpty(prefix))
{
mapper.QuotedStringProperty("headerCollectionPrefix", prefix);
}
}
else if (composite != null)
{
AddTypeProperty(mapper, "Composite", typeObject =>
{
if (expandComposite)
{
if (composite.IsPolymorphic)
{
// Note: If the polymorphicDiscriminator has a dot in it's name then do not escape that dot for
// it's serializedName, the way it is done for other properties. This makes it easy to find the
// discriminator property from the responseBody during deserialization. Please, do not get confused
// between the definition of the discriminator and the definition of the property that is
// marked as the discriminator.
typeObject.ObjectProperty("polymorphicDiscriminator", polymorphicDiscriminator =>
{
polymorphicDiscriminator.QuotedStringProperty("serializedName", composite.PolymorphicDiscriminator);
polymorphicDiscriminator.QuotedStringProperty("clientName", Singleton <CodeNamerTS> .Instance.GetPropertyName(composite.PolymorphicDiscriminator));
});
typeObject.QuotedStringProperty("uberParent", composite.Name);
}
else
{
CompositeType baseType = composite;
while (baseType.BaseModelType != null)
{
baseType = baseType.BaseModelType;
}
if (baseType.IsPolymorphic)
{
typeObject.TextProperty("polymorphicDiscriminator", baseType.Name + ".type.polymorphicDiscriminator");
typeObject.QuotedStringProperty("uberParent", baseType.Name);
}
}
}
typeObject.QuotedStringProperty("className", composite.Name);
if (expandComposite)
{
typeObject.ObjectProperty("modelProperties", modelProperties =>
{
if (composite.BaseModelType != null && composite.BaseModelType.ComposedProperties.Any())
{
modelProperties.Spread(composite.BaseModelType.Name + ".type.modelProperties");
}
foreach (Property prop in composite.Properties)
{
var serializedPropertyName = prop.SerializedName;
if (isPageable)
{
PropertyInfo itemName = composite.GetType().GetProperty("ItemName");
PropertyInfo nextLinkName = composite.GetType().GetProperty("NextLinkName");
string nextLinkNameValue = (string)nextLinkName.GetValue(composite);
if (itemName != null && ((string)itemName.GetValue(composite) == prop.Name))
{
serializedPropertyName = "";
}
if (prop.Name.Contains("nextLink") && nextLinkName != null && nextLinkNameValue == null)
{
continue;
}
}
if (modelProperties.ContainsProperty(prop.Name))
{
// throw new InvalidOperationException($"Mapper \"{serializedName}\" contains multiple modelProperties with the name \"{prop.Name}\".");
}
else
{
modelProperties.Property(prop.Name, propertyValue => ConstructMapper(propertyValue, prop.ModelType, serializedPropertyName, prop, false, false, isXML, isCaseSensitive));
}
}
});
}
if (composite.AdditionalProperties != null)
{
typeObject.ObjectProperty("additionalProperties", additionalProperties =>
{
ConstructMapper(additionalProperties, composite.AdditionalProperties, serializedName: null, parameter: null, isPageable: false, expandComposite: false, isXML: isXML);
});
}
else
{
CompositeTypeTS baseType = composite;
while (true)
{
baseType = (CompositeTypeTS)baseType.BaseModelType;
if (baseType == null)
{
break;
}
else if (baseType.AdditionalProperties != null)
{
typeObject.TextProperty("additionalProperties", $"{baseType.Name}.type.additionalProperties");
break;
}
}
}
});
}
else
{
throw new NotImplementedException($"{type} is not a supported Type.");
}
}
public ModelsModel Bind(CodeModelTs codeModel)
{
var models = new ModelsModel
{
Header = new HeaderModel
{
ApiVersion = codeModel.ApiVersion
},
RequestModels = new List <Model.Model>(),
ResponseModels = new List <Model.Model>(),
EnumModels = new List <EnumModel>()
};
var modelTypesFromDefinition = codeModel.ModelTypes.ToList();
var enumsInModels = new List <Tuple <string, IModelType> >();
Func <IVariable, ModelProperty> getPropertyModel =
variable =>
{
var propertyType = variable.ModelType;
string typeName = null;
//if (propertyType.IsEnumType())
//{
// var enumType = (EnumTypeTs) propertyType;
// typeName = enumType.GetImplementationName(variable);
// enumsInModels.Add(new Tuple<string, IModelType>(typeName, propertyType));
//}
return(new ModelProperty
{
Name = variable.Name.ToCamelCase(),
IsRequired = variable.IsRequired,
TypeName = typeName ?? GetTypeText(propertyType)
});
};
foreach (var method in codeModel.Methods)
{
string requestName = null;
string responseName = null;
IModelType modelType = null;
if (!TryGetResponseName(method, out modelType, out responseName, out requestName))
{
continue;
}
var requestModelType = new Model.Model
{
Name = requestName,
Properties = new List <ModelProperty>()
};
foreach (Parameter parameter in method.Parameters)
{
requestModelType.Properties.Add(getPropertyModel(parameter));
}
models.RequestModels.Add(requestModelType);
if (modelType.IsPrimaryType() || modelType.IsSequenceType() || modelType.IsEnumType())
{
continue;
}
var responseModelType = new Model.Model
{
Name = responseName,
Properties = new List <ModelProperty>()
};
var type = modelTypesFromDefinition.FirstOrDefault(m => m.ClassName == modelType.ClassName);
if (type == null)
{
continue;
}
modelTypesFromDefinition.Remove(type);
foreach (var property in type.Properties)
{
responseModelType.Properties.Add(getPropertyModel(property));
}
models.ResponseModels.Add(responseModelType);
}
foreach (var modelType in modelTypesFromDefinition)
{
if (modelType.IsPrimaryType() || modelType.IsSequenceType() && modelType.IsEnumType())
{
continue;
}
var model = new Model.Model
{
Name = GetTypeText(modelType),
Properties = new List <ModelProperty>()
};
models.ResponseModels.Add(model);
foreach (var property in modelType.Properties)
{
model.Properties.Add(getPropertyModel(property));
}
}
// disable enum generation for now #ranantawat.
// foreach (var pair in enumsInModels)
// {
// var enumType = (EnumTypeTs) pair.Item2;
// var enumModel = new EnumModel {Name = pair.Item1};
// if (enumType.ModelAsString)
// {
// for (var index = 0; index < enumType.EnumValues.Length; index++)
// {
// var value = enumType.Children.Cast<EnumValue>().ToArray()[index];
// enumModel.Values.Add(value.Name, index);
// }
// }
// models.EnumModels.Add(enumModel);
// }
models.EnumModels = models.EnumModels.Distinct().ToList();
foreach (EnumType enumType in codeModel.EnumTypes.ToArray())
{
models.EnumModels.Add(new EnumModel
{
Name = enumType.DeclarationName,
Values = new Dictionary <string, object>()
});
}
return(models);
}
public static string InitializePrimaryType(this IModelType paramType, string paramName, bool isBrowser = false)
{
var paramValue = "\"\"";
if (paramType.IsPrimaryType(KnownPrimaryType.String))
{
if (paramName.EqualsIgnoreCase("location"))
{
paramValue = "\"westus\"";
}
else
{
paramValue = $"\"test{paramName.ToCamelCase()}\"";
}
}
else if (paramType.IsPrimaryType(KnownPrimaryType.Date))
{
paramValue = "new Date().toISOString().substring(0, 10)";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.DateTime))
{
paramValue = "new Date().toISOString()";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.DateTimeRfc1123))
{
paramValue = "new Date().toUTCString()";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.UnixTime))
{
paramValue = "new Date()";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.TimeSpan))
{
paramValue = "\"P1Y2M3DT4H5M6S\"";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.Boolean))
{
paramValue = "true";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.Int) || paramType.IsPrimaryType(KnownPrimaryType.Long))
{
paramValue = "1";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.Decimal) || paramType.IsPrimaryType(KnownPrimaryType.Double))
{
paramValue = "1.01";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.Object))
{
paramValue = "{}";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.Uuid))
{
paramValue = "ec7b1657-199d-4d8a-bbb2-89a11a42e02a";
}
else if (paramType.IsPrimaryType(KnownPrimaryType.Stream))
{
paramValue = isBrowser ? "new ReadableStream()" : "new require(\"stream\").Readable()";
}
return(paramValue);
}
private string GetPagingSetting(CodeModelPya codeModel, CompositeType body, Dictionary <string, object> extensions, IModelType valueType,
IDictionary <int, string> typePageClasses, string methodName)
{
string valueTypeName = valueType.Name;
var ext = extensions[AzureExtensions.PageableExtension] as JContainer;
var ignoreNextLink = false;
if ((ext["nextLinkName"] != null) && (ext["nextLinkName"].Type == JTokenType.Null))
{
ignoreNextLink = true;
}
var nextLinkName = (string)ext["nextLinkName"] ?? "nextLink";
var itemName = (string)ext["itemName"] ?? "value";
// nextLinkName = nextLinkName.Replace(".", "\\\\.");
// itemName = itemName.Replace(".", "\\\\.");
var findNextLink = false;
var findItem = false;
foreach (var property in body.ComposedProperties)
{
var propName = property.SerializedName;
if (propName == nextLinkName)
{
findNextLink = true;
nextLinkName = property.SerializedName = property.SerializedName.Replace(".", "\\\\.")?.Replace("\\\\\\\\", "\\\\");
}
else if (propName == itemName)
{
findItem = true;
itemName = property.SerializedName = property.SerializedName.Replace(".", "\\\\.")?.Replace("\\\\\\\\", "\\\\");
}
if (propName == nextLinkName.Replace(".", "\\\\.")?.Replace("\\\\\\\\", "\\\\"))
{
nextLinkName = nextLinkName.Replace(".", "\\\\.")?.Replace("\\\\\\\\", "\\\\");
findNextLink = true;
}
else if (propName == itemName.Replace(".", "\\\\.")?.Replace("\\\\\\\\", "\\\\"))
{
itemName = itemName.Replace(".", "\\\\.")?.Replace("\\\\\\\\", "\\\\");
findItem = true;
}
}
if (!findItem)
{
throw new KeyNotFoundException("Couldn't find the item property specified by extension");
}
string className;
var hash = (nextLinkName + "#" + itemName).GetHashCode();
if (!typePageClasses.ContainsKey(hash))
{
className = (string)ext["className"];
if (string.IsNullOrEmpty(className))
{
if (typePageClasses.Count > 0)
{
className = valueTypeName +
string.Format(CultureInfo.InvariantCulture, "Paged{0}", typePageClasses.Count);
}
else
{
className = valueTypeName + "Paged";
}
}
typePageClasses.Add(hash, className);
}
className = typePageClasses[hash];
ext["className"] = className;
var pageModel = new PagePya(className, nextLinkName, itemName, valueType);
if (!codeModel.PageModels.Contains(pageModel))
{
codeModel.PageModels.Add(pageModel);
}
return(className);
}
public static string GetObsoleteAttribute(this IModelType x) => GetObsoleteAttribute(x.DeprecationMessage);
private bool ContainsCompositeType(IModelType type)
{
bool result = false;
//base condition
if (type is CompositeType ||
type is Core.Model.SequenceType && (type as Core.Model.SequenceType).ElementType is CompositeType ||
type is Core.Model.DictionaryType && (type as Core.Model.DictionaryType).ValueType is CompositeType)
{
result = true;
}
else if (type is Core.Model.SequenceType)
{
result = ContainsCompositeType((type as Core.Model.SequenceType).ElementType);
}
else if (type is Core.Model.DictionaryType)
{
result = ContainsCompositeType((type as Core.Model.DictionaryType).ValueType);
}
return result;
}
/// <summary> /// Returns true if the IModelType is a kind of string (ie, string PrimaryType or an Enum that is modeled as a string) /// </summary> /// <param name="t">ModelType to check</param> /// <returns>true if the IModelType is a kind of string</returns> public static bool IsKindOfString(this IModelType t) => t is PrimaryType pt &&
/// <summary>
/// Conditionally returns the ModelType name expressed as a nullable type (for classes, nothing different, for value types, append a '?'
/// </summary>
/// <param name="modelType">The ModelType to return as nullable</param>
/// <param name="predicate">An boolean indicating whether to make the type nullable</param>
/// <returns>The ModelType name expressed as a nullable type</returns>
public static string AsNullableType(this IModelType modelType, bool predicate) => predicate && modelType.IsValueType() ? $"{modelType.Name}?" : modelType.DeclarationName;
public static bool IsResource(this IModelType type)
{
CompositeTypeJva compositeType = type as CompositeTypeJva;
return(compositeType != null && compositeType.IsResource);
}
private bool IsFolder(IModelType type)
{
return(type.GetType() == typeof(Folder));
}
public override IModelType NormalizeTypeReference(IModelType type)
{
throw new System.NotImplementedException();
}
public static string ConstructMapper(this IModelType type, string serializedName, IVariable parameter, bool isPageable, bool expandComposite)
{
var builder = new IndentedStringBuilder(" ");
string defaultValue = null;
bool isRequired = false;
bool isConstant = false;
bool isReadOnly = false;
Dictionary <Constraint, string> constraints = null;
var property = parameter as Property;
if (parameter != null)
{
defaultValue = parameter.DefaultValue;
isRequired = parameter.IsRequired;
isConstant = parameter.IsConstant;
constraints = parameter.Constraints;
}
if (property != null)
{
isReadOnly = property.IsReadOnly;
}
CompositeType composite = type as CompositeType;
if (composite != null && composite.ContainsConstantProperties && (parameter != null && parameter.IsRequired))
{
defaultValue = "{}";
}
SequenceType sequence = type as SequenceType;
DictionaryType dictionary = type as DictionaryType;
PrimaryType primary = type as PrimaryType;
EnumType enumType = type as EnumType;
builder.AppendLine("").Indent();
if (isRequired)
{
builder.AppendLine("required: true,");
}
else
{
builder.AppendLine("required: false,");
}
if (isReadOnly)
{
builder.AppendLine("readOnly: true,");
}
if (isConstant)
{
builder.AppendLine("isConstant: true,");
}
if (serializedName != null)
{
builder.AppendLine("serializedName: '{0}',", serializedName);
}
if (defaultValue != null)
{
builder.AppendLine("defaultValue: {0},", defaultValue);
}
if (constraints != null && constraints.Count > 0)
{
builder.AppendLine("constraints: {").Indent();
var keys = constraints.Keys.ToList <Constraint>();
for (int j = 0; j < keys.Count; j++)
{
var constraintValue = constraints[keys[j]];
if (keys[j] == Constraint.Pattern)
{
constraintValue = $"'{constraintValue}'";
}
if (j != keys.Count - 1)
{
builder.AppendLine("{0}: {1},", keys[j], constraintValue);
}
else
{
builder.AppendLine("{0}: {1}", keys[j], constraintValue);
}
}
builder.Outdent().AppendLine("},");
}
// Add type information
if (primary != null)
{
switch (primary.KnownPrimaryType)
{
case KnownPrimaryType.Boolean:
builder.AppendLine("type: {").Indent().AppendLine("name: 'Boolean'").Outdent().AppendLine("}");
break;
case KnownPrimaryType.Int:
case KnownPrimaryType.Long:
case KnownPrimaryType.Decimal:
case KnownPrimaryType.Double:
builder.AppendLine("type: {").Indent().AppendLine("name: 'Number'").Outdent().AppendLine("}");
break;
case KnownPrimaryType.String:
builder.AppendLine("type: {").Indent().AppendLine("name: 'String'").Outdent().AppendLine("}");
break;
case KnownPrimaryType.Uuid:
builder.AppendLine("type: {").Indent().AppendLine("name: 'String'").Outdent().AppendLine("}");
break;
// case KnownPrimaryType.Uuid:
// builder.AppendLine("type: {").Indent().AppendLine("name: 'Uuid'").Outdent().AppendLine("}");
//break;
case KnownPrimaryType.ByteArray:
builder.AppendLine("type: {").Indent().AppendLine("name: 'ByteArray'").Outdent().AppendLine("}");
break;
case KnownPrimaryType.Base64Url:
builder.AppendLine("type: {").Indent().AppendLine("name: 'Base64Url'").Outdent().AppendLine("}");
break;
case KnownPrimaryType.Date:
builder.AppendLine("type: {").Indent().AppendLine("name: 'Date'").Outdent().AppendLine("}");
break;
case KnownPrimaryType.DateTime:
builder.AppendLine("type: {").Indent().AppendLine("name: 'DateTime'").Outdent().AppendLine("}");
break;
case KnownPrimaryType.DateTimeRfc1123:
builder.AppendLine("type: {").Indent().AppendLine("name: 'DateTimeRfc1123'").Outdent().AppendLine("}");
break;
case KnownPrimaryType.TimeSpan:
builder.AppendLine("type: {").Indent().AppendLine("name: 'TimeSpan'").Outdent().AppendLine("}");
break;
case KnownPrimaryType.UnixTime:
builder.AppendLine("type: {").Indent().AppendLine("name: 'UnixTime'").Outdent().AppendLine("}");
break;
case KnownPrimaryType.Object:
builder.AppendLine("type: {").Indent().AppendLine("name: 'Object'").Outdent().AppendLine("}");
break;
case KnownPrimaryType.Stream:
builder.AppendLine("type: {").Indent().AppendLine("name: 'Stream'").Outdent().AppendLine("}");
break;
default:
throw new NotImplementedException(string.Format(Resources.InvalidType, primary));
}
}
else if (enumType != null)
{
if (enumType.ModelAsString)
{
builder.AppendLine("type: {").Indent().AppendLine("name: 'String'").Outdent().AppendLine("}");
}
else
{
builder.AppendLine("type: {")
.Indent()
.AppendLine("name: 'Enum',")
.AppendLine("allowedValues: {0}", enumType.GetEnumValuesArray())
.Outdent()
.AppendLine("}");
}
}
else if (sequence != null)
{
builder.AppendLine("type: {")
.Indent()
.AppendLine("name: 'Sequence',")
.AppendLine("element: {")
.Indent()
.AppendLine("{0}", sequence.ElementType.ConstructMapper(sequence.ElementType.DeclarationName + "ElementType", null, false, false))
.Outdent().AppendLine("}").Outdent().AppendLine("}");
}
else if (dictionary != null)
{
builder.AppendLine("type: {")
.Indent()
.AppendLine("name: 'Dictionary',")
.AppendLine("value: {")
.Indent()
.AppendLine("{0}", dictionary.ValueType.ConstructMapper(dictionary.ValueType.DeclarationName + "ElementType", null, false, false))
.Outdent().AppendLine("}").Outdent().AppendLine("}");
}
else if (composite != null)
{
builder.AppendLine("type: {")
.Indent()
.AppendLine("name: 'Composite',");
if (composite.IsPolymorphic)
{
builder = ConstructPolymorphicDiscriminator(composite, builder);
}
if (!expandComposite)
{
builder.AppendLine("className: '{0}'", composite.Name).Outdent().AppendLine("}");
}
else
{
builder.AppendLine("className: '{0}',", composite.Name)
.AppendLine("modelProperties: {").Indent();
var composedPropertyList = new List <Property>(composite.ComposedProperties);
for (var i = 0; i < composedPropertyList.Count; i++)
{
var prop = composedPropertyList[i];
var serializedPropertyName = prop.SerializedName;
PropertyInfo nextLinkName = null;
string nextLinkNameValue = null;
if (isPageable)
{
var itemName = composite.GetType().GetProperty("ItemName");
nextLinkName = composite.GetType().GetProperty("NextLinkName");
nextLinkNameValue = (string)nextLinkName.GetValue(composite);
if (itemName != null && ((string)itemName.GetValue(composite) == prop.Name))
{
serializedPropertyName = "";
}
if (prop.Name.Contains("nextLink") && nextLinkName != null && nextLinkNameValue == null)
{
continue;
}
}
if (i != composedPropertyList.Count - 1)
{
if (!isPageable)
{
builder.AppendLine("{0}: {{{1}}},", prop.Name, prop.ModelType.ConstructMapper(serializedPropertyName, prop, false, false));
}
else
{
// if pageable and nextlink is also present then we need a comma as nextLink would be the next one to be added
if (nextLinkNameValue != null)
{
builder.AppendLine("{0}: {{{1}}},", prop.Name, prop.ModelType.ConstructMapper(serializedPropertyName, prop, false, false));
}
else
{
builder.AppendLine("{0}: {{{1}}}", prop.Name, prop.ModelType.ConstructMapper(serializedPropertyName, prop, false, false));
}
}
}
else
{
builder.AppendLine("{0}: {{{1}}}", prop.Name, prop.ModelType.ConstructMapper(serializedPropertyName, prop, false, false));
}
}
// end of modelProperties and type
builder.Outdent().AppendLine("}").Outdent().AppendLine("}");
}
}
else
{
throw new NotImplementedException(string.Format(Resources.InvalidType, type));
}
return(builder.ToString());
}
public override IModelType NormalizeTypeDeclaration(IModelType type)
{
throw new System.NotImplementedException();
}
/// <summary> /// Returns true if the IModelType is a kind of string (ie, string PrimaryType or an Enum that is modeled as a string) /// </summary> /// <param name="t">ModelType to check</param> /// <returns>true if the IModelType is a kind of string</returns> public static bool IsKindOfString(this IModelType t) => t is PrimaryType && ((PrimaryType)t).KnownPrimaryType == KnownPrimaryType.String && ((PrimaryType)t).KnownFormat != KnownFormat.@char || t is EnumType && ((EnumType)t).ModelAsString;
public override string EscapeDefaultValue(string value, IModelType type)
{
throw new NotImplementedException();
}
/// <summary>
/// Generate code to perform required validation on a type
/// </summary>
/// <param name="type">The type to validate</param>
/// <param name="scope">A scope provider for generating variable names as necessary</param>
/// <param name="valueReference">A reference to the value being validated</param>
/// <param name="constraints">Constraints</param>
/// <returns>The code to validate the reference of the given type</returns>
public static string ValidateType(this IModelType type, IChild scope, string valueReference,
Dictionary <Constraint, string> constraints)
{
if (scope == null)
{
throw new ArgumentNullException("scope");
}
var model = type as CompositeTypeCs;
var sequence = type as SequenceTypeCs;
var dictionary = type as DictionaryTypeCs;
var sb = new IndentedStringBuilder();
if (model != null && model.ShouldValidateChain())
{
sb.AppendLine("{0}.Validate();", valueReference);
}
if (constraints != null && constraints.Any())
{
AppendConstraintValidations(valueReference, constraints, sb, (type as PrimaryType)?.KnownFormat ?? KnownFormat.none);
}
if (sequence != null && sequence.ShouldValidateChain())
{
var elementVar = scope.GetUniqueName("element");
var innerValidation = sequence.ElementType.ValidateType(scope, elementVar, null);
if (!string.IsNullOrEmpty(innerValidation))
{
sb.AppendLine("foreach (var {0} in {1})", elementVar, valueReference)
.AppendLine("{").Indent()
.AppendLine(innerValidation).Outdent()
.AppendLine("}");
}
}
else if (dictionary != null && dictionary.ShouldValidateChain())
{
var valueVar = scope.GetUniqueName("valueElement");
var innerValidation = dictionary.ValueType.ValidateType(scope, valueVar, null);
if (!string.IsNullOrEmpty(innerValidation))
{
sb.AppendLine("foreach (var {0} in {1}.Values)", valueVar, valueReference)
.AppendLine("{").Indent()
.AppendLine(innerValidation).Outdent()
.AppendLine("}").Outdent();
}
}
if (sb.ToString().Trim().Length > 0)
{
if (type.IsValueType())
{
return(sb.ToString());
}
else
{
return(CheckNull(valueReference, sb.ToString()));
}
}
return(null);
}
/// <summary>
/// Initializes a new instance of Response.
/// </summary>
/// <param name="body">Body type.</param>
/// <param name="headers">Headers type.</param>
public Response(IModelType body, IModelType headers)
{
Body = body;
Headers = headers;
}
private static void BuildMethodReturnTypeStack(IModelType type, List<Stack<IModelType>> types)
{
var typeStack = new Stack<IModelType>();
typeStack.Push(type);
types.Add(typeStack);
}
/////////////////////////////////////////////////////////////////////////////////////////
//
// Type Extensions
//
/////////////////////////////////////////////////////////////////////////////////////////
public static bool IsStreamType(this IModelType body)
{
return(body is CompositeTypeGo r && (r.BaseType.PrimaryType(KnownPrimaryType.Stream)));
}
private bool TryBuildStreamResponse(HttpStatusCode responseStatusCode, OperationResponse response,
Method method, List<Stack<IModelType>> types, IModelType headerType)
{
bool handled = false;
if (SwaggerOperationProducesNotEmpty())
{
if (response.Schema != null)
{
IModelType serviceType = response.Schema.GetBuilder(_swaggerModeler)
.BuildServiceType(response.Schema.Reference.StripDefinitionPath());
Debug.Assert(serviceType != null);
BuildMethodReturnTypeStack(serviceType, types);
var compositeType = serviceType as CompositeType;
if (compositeType != null)
{
VerifyFirstPropertyIsByteArray(compositeType);
}
method.Responses[responseStatusCode] = new Response(serviceType, headerType);
handled = true;
}
}
return handled;
}
public static bool ShouldBeSyntheticType(this IModelType type)
{
return(type is PrimaryType || type is SequenceType || type is DictionaryType || type is EnumType ||
(type is CompositeType && (type as CompositeTypeGo).IsPolymorphicResponse()));
}
private bool TryBuildEmptyResponse(string methodName, HttpStatusCode responseStatusCode,
OperationResponse response, Method method, List<Stack<IModelType>> types, IModelType headerType)
{
bool handled = false;
if (response.Schema == null)
{
method.Responses[responseStatusCode] = new Response(null, headerType);
handled = true;
}
else
{
if (_operation.Produces.IsNullOrEmpty())
{
method.Responses[responseStatusCode] = new Response(New<PrimaryType>(KnownPrimaryType.Object), headerType);
BuildMethodReturnTypeStack(New<PrimaryType>(KnownPrimaryType.Object), types);
handled = true;
}
var unwrapedSchemaProperties =
_swaggerModeler.Resolver.Unwrap(response.Schema).Properties;
if (unwrapedSchemaProperties != null && unwrapedSchemaProperties.Any())
{
Logger.LogWarning(Resources.NoProduceOperationWithBody,
methodName);
}
}
return handled;
}
/// <summary>
/// Gets if the type has an interface.
/// </summary>
public static bool HasInterface(this IModelType type)
{
return((type is CompositeTypeGo compositeType) &&
(compositeType.IsRootType || compositeType.BaseIsPolymorphic && !compositeType.IsLeafType));
}
private bool TryBuildResponseBody(string methodName, OperationResponse response,
Func<string, string> typeNamer, out IModelType responseType)
{
bool handled = false;
responseType = null;
if (SwaggerOperationProducesJson())
{
if (response.Schema != null)
{
string referenceKey;
if (response.Schema.Reference != null)
{
referenceKey = response.Schema.Reference.StripDefinitionPath();
response.Schema.Reference = referenceKey;
}
else
{
referenceKey = typeNamer(methodName);
}
responseType = response.Schema.GetBuilder(_swaggerModeler).BuildServiceType(referenceKey);
handled = true;
}
}
return handled;
}
/// <summary>
/// Returns a quoted string for the given language if applicable.
/// </summary>
/// <param name="defaultValue">Value to quote.</param>
/// <param name="type">Data type.</param>
public virtual string EscapeDefaultValue(string defaultValue, IModelType type)
{
return defaultValue;
}
