public static void PopulateProperty(Property property, SwaggerObject swaggerObject) { if (swaggerObject == null) { throw new ArgumentNullException("swaggerObject"); } if (property == null) { throw new ArgumentNullException("property"); } property.DefaultValue = swaggerObject.Default; if (IsSwaggerObjectConstant(swaggerObject, property.IsRequired)) { property.DefaultValue = swaggerObject.Enum.TokensToStrings().First(); property.IsConstant = true; } property.Documentation = swaggerObject.Description; // tag the paramter with all the extensions from the swagger object property.Extensions.AddRange(swaggerObject.Extensions); SetConstraints(property.Constraints, swaggerObject); }
/// <summary> /// Determines if a constraint is supported for the SwaggerObject Type /// </summary> /// <param name="constraintName"></param> /// <returns></returns> public static bool IsConstraintSupported(this SwaggerObject swaggerObject, string constraintName) { switch (swaggerObject.Type) { case DataType.Array: return(constraintName.EqualsIgnoreCase(Constraint.MinItems.ToString()) || constraintName.EqualsIgnoreCase(Constraint.MaxItems.ToString()) || constraintName.EqualsIgnoreCase(Constraint.UniqueItems.ToString())); case DataType.Integer: case DataType.Number: return(constraintName.EqualsIgnoreCase(Constraint.ExclusiveMaximum.ToString()) || constraintName.EqualsIgnoreCase(Constraint.ExclusiveMinimum.ToString()) || constraintName.EqualsIgnoreCase(Constraint.MultipleOf.ToString()) || constraintName.EqualsIgnoreCase("minimum") || constraintName.EqualsIgnoreCase("maximum")); case DataType.String: return(constraintName.EqualsIgnoreCase(Constraint.MinLength.ToString()) || constraintName.EqualsIgnoreCase(Constraint.MaxLength.ToString()) || constraintName.EqualsIgnoreCase(Constraint.Pattern.ToString())); default: return(false); } }
public static void PopulateParameter(IVariable parameter, SwaggerObject swaggerObject) { if (swaggerObject == null) { throw new ArgumentNullException("swaggerObject"); } if (parameter == null) { throw new ArgumentNullException("parameter"); } parameter.IsRequired = swaggerObject.IsRequired; parameter.DefaultValue = swaggerObject.Default; if (IsSwaggerObjectConstant(swaggerObject)) { parameter.DefaultValue = swaggerObject.Enum[0]; parameter.IsConstant = true; } parameter.Documentation = swaggerObject.Description; parameter.CollectionFormat = swaggerObject.CollectionFormat; // tag the paramter with all the extensions from the swagger object parameter.Extensions.AddRange(swaggerObject.Extensions); SetConstraints(parameter.Constraints, swaggerObject); }
public static void PopulateParameter(IParameter parameter, SwaggerObject swaggerObject) { if (swaggerObject == null) { throw new ArgumentNullException("swaggerObject"); } if (parameter == null) { throw new ArgumentNullException("parameter"); } parameter.IsRequired = swaggerObject.IsRequired; parameter.DefaultValue = swaggerObject.Default; if (IsSwaggerObjectConstant(swaggerObject)) { parameter.DefaultValue = swaggerObject.Enum[0]; parameter.IsConstant = true; } var compositeType = parameter.Type as CompositeType; if (compositeType != null && compositeType.ComposedProperties.Any()) { if (compositeType.ComposedProperties.All(p => p.IsConstant)) { parameter.DefaultValue = "{}"; parameter.IsConstant = true; } } parameter.Documentation = swaggerObject.Description; parameter.CollectionFormat = swaggerObject.CollectionFormat; var enumType = parameter.Type as EnumType; if (enumType != null) { if (parameter.Documentation == null) { parameter.Documentation = string.Empty; } else { parameter.Documentation = parameter.Documentation.TrimEnd('.') + ". "; } parameter.Documentation += "Possible values include: " + string.Join(", ", enumType.Values.Select(v => string.Format(CultureInfo.InvariantCulture, "'{0}'", v.Name))); } swaggerObject.Extensions.ForEach(e => parameter.Extensions[e.Key] = e.Value); SetConstraints(parameter.Constraints, swaggerObject); }
public static List <string> ReadAdditionalHeaders(SwaggerObject swaggerObject) { List <string> list = new List <string>(); foreach (var secutiryDefinitions in swaggerObject.securityDefinitions) { list.Add(secutiryDefinitions.Value.name); } return(list); }
private static bool IsExpandableEnum(SwaggerObject swaggerObject) { if (swaggerObject.Extensions.ContainsKey(CodeGenerator.EnumObject)) { var enumObject = swaggerObject.Extensions[CodeGenerator.EnumObject] as Newtonsoft.Json.Linq.JContainer; if (enumObject != null) { if (enumObject["modelAsString"] != null) { return(bool.Parse(enumObject["modelAsString"].ToString())); } } } return(false); }
public override async Task Generate(CodeModel codeModel) { var @namespace = Class.CreateName(codeModel.Namespace); var phpGroups = codeModel.Operations .Where(o => o.Name.RawValue != string.Empty) .Select(o => new PhpFunctionGroup(@namespace, o)); var phpFunctions = codeModel.Operations .Where(o => o.Name.RawValue == string.Empty) .SelectMany(o => o.Methods.Select(m => new PhpOperation(m))); var swaggerObjectData = PHP.Const( SwaggerObjectData, PHP.FromJson(SwaggerObject.Create(codeModel))); var client = PHP.Class( name: Class.CreateName(@namespace, codeModel.Name), constructor: PHP.Constructor( parameters: ClientConstructorParameters, body: PHP .Statements(CreateClient) .Concat(phpGroups.Select(g => g.Create)) .Concat(phpFunctions.SelectMany(f => f.ConstructorStatements))), functions: phpGroups .Select(o => o.Function) .Concat(phpFunctions.Select(f => f.Function)), properties: phpGroups .Select(o => o.Property) .Concat(phpFunctions.Select(f => f.Property)), consts: PHP.Consts(swaggerObjectData)); foreach (var class_ in phpGroups .Select(o => o.Class) .Concat(ImmutableArray.Create(client))) { await Write( string.Join("\n", class_.ToCodeText(Indent)), class_.Name.FileName, false); } }
/// <summary> /// The visitor method for building service types. This is called when an instance of this class is /// visiting a _swaggerModeler to build a service type. /// </summary> /// <param name="serviceTypeName">name for the service type</param> /// <returns>built service type</returns> public virtual IModelType BuildServiceType(string serviceTypeName) { PrimaryType type = SwaggerObject.ToType(); Debug.Assert(type != null); if (type.KnownPrimaryType == KnownPrimaryType.Object && SwaggerObject.KnownFormat == KnownFormat.file) { type = New <PrimaryType>(KnownPrimaryType.Stream); } type.XmlProperties = (SwaggerObject as Schema)?.Xml; type.Format = SwaggerObject.Format; var xMsEnum = SwaggerObject.Extensions.GetValue <JToken>(Core.Model.XmsExtensions.Enum.Name); if ((SwaggerObject.Enum != null || xMsEnum != null) && type.KnownPrimaryType == KnownPrimaryType.String && !(IsSwaggerObjectConstant(SwaggerObject))) { var enumType = New <EnumType>(); if (SwaggerObject.Enum != null) { SwaggerObject.Enum.ForEach(v => enumType.Values.Add(new EnumValue { Name = v, SerializedName = v })); } if (xMsEnum != null) { var enumObject = xMsEnum as JContainer; if (enumObject != null) { enumType.SetName(enumObject["name"].ToString()); if (enumObject["modelAsString"] != null) { enumType.ModelAsString = bool.Parse(enumObject["modelAsString"].ToString()); } var valueOverrides = enumObject["values"] as JArray; if (valueOverrides != null) { enumType.Values.Clear(); foreach (var valueOverride in valueOverrides) { var value = valueOverride["value"]; var description = valueOverride["description"]; var name = valueOverride["name"] ?? value; enumType.Values.Add(new EnumValue { Name = (string)name, SerializedName = (string)value, Description = (string)description }); } } } if (string.IsNullOrEmpty(enumType.Name)) { throw new InvalidOperationException( string.Format(CultureInfo.InvariantCulture, "{0} extension needs to specify an enum name.", Core.Model.XmsExtensions.Enum.Name)); } var existingEnum = Modeler.CodeModel.EnumTypes.FirstOrDefault( e => e.Name.RawValue.EqualsIgnoreCase(enumType.Name.RawValue)); if (existingEnum != null) { if (!existingEnum.StructurallyEquals(enumType)) { throw new InvalidOperationException( string.Format(CultureInfo.InvariantCulture, "Swagger document contains two or more {0} extensions with the same name '{1}' and different values: {2} vs. {3}", Core.Model.XmsExtensions.Enum.Name, enumType.Name, string.Join(",", existingEnum.Values.Select(x => x.SerializedName)), string.Join(",", enumType.Values.Select(x => x.SerializedName)))); } // Use the existing one! enumType = existingEnum; } else { Modeler.CodeModel.Add(enumType); } } else { enumType.ModelAsString = true; enumType.SetName(string.Empty); } enumType.XmlProperties = (SwaggerObject as Schema)?.Xml; return(enumType); } if (SwaggerObject.Type == DataType.Array) { if (SwaggerObject.Items == null) { throw new Exception($"Invalid Swagger: Missing 'items' definition of an 'array' type."); } string itemServiceTypeName; if (SwaggerObject.Items.Reference != null) { itemServiceTypeName = SwaggerObject.Items.Reference.StripDefinitionPath(); } else { itemServiceTypeName = serviceTypeName + "Item"; } var elementType = SwaggerObject.Items.GetBuilder(Modeler).BuildServiceType(itemServiceTypeName); return(New <SequenceType>(new { ElementType = elementType, Extensions = SwaggerObject.Items.Extensions, XmlProperties = (SwaggerObject as Schema)?.Xml, ElementXmlProperties = SwaggerObject.Items?.Xml })); } if (SwaggerObject.AdditionalProperties != null) { string dictionaryValueServiceTypeName; if (SwaggerObject.AdditionalProperties.Reference != null) { dictionaryValueServiceTypeName = SwaggerObject.AdditionalProperties.Reference.StripDefinitionPath(); } else { dictionaryValueServiceTypeName = serviceTypeName + "Value"; } return(New <DictionaryType>(new { ValueType = SwaggerObject.AdditionalProperties.GetBuilder(Modeler) .BuildServiceType((dictionaryValueServiceTypeName)), Extensions = SwaggerObject.AdditionalProperties.Extensions, XmlProperties = (SwaggerObject as Schema)?.Xml })); } return(type); }
private SwaggerObjectBase Build(JToken token) { // Fetch from cache first var location = GetLocation(token); SwaggerObjectBase existingObject; if (_documentObjectCache.TryGetValue(location, out existingObject)) { return existingObject; } var jObject = token as JObject; if (jObject != null) { // Only one $ref is allowed inside a swagger JObject JToken referenceToken; if (jObject.TryGetValue("$ref", out referenceToken)) { if (referenceToken.Type != JTokenType.String && referenceToken.Type != JTokenType.Null) { throw new JsonException($"JSON reference $ref property must have a string or null value, instead of {referenceToken.Type}, location: {referenceToken.Path}."); } var formatted = RestApiHelper.FormatReferenceFullPath((string)referenceToken); var deferredObject = new SwaggerReferenceObject { DeferredReference = formatted.Item1, ReferenceName = formatted.Item2, Location = location }; // For swagger, other properties are still allowed besides $ref, e.g. // "schema": { // "$ref": "#/definitions/foo" // "example": { } // } // Use Token property to keep other properties // These properties cannot be referenced jObject.Remove("$ref"); deferredObject.Token = jObject; _documentObjectCache.Add(location, deferredObject); return deferredObject; } var swaggerObject = new SwaggerObject { Location = location }; foreach (KeyValuePair<string, JToken> property in jObject) { swaggerObject.Dictionary.Add(property.Key, Build(property.Value)); } _documentObjectCache.Add(location, swaggerObject); return swaggerObject; } var jArray = token as JArray; if (jArray != null) { var swaggerArray = new SwaggerArray { Location = location }; foreach (var property in jArray) { swaggerArray.Array.Add(Build(property)); } return swaggerArray; } return new SwaggerValue { Location = location, Token = token }; }
/// <summary> /// The visitor method for building service types. This is called when an instance of this class is /// visiting a _swaggerModeler to build a service type. /// </summary> /// <param name="serviceTypeName">name for the service type</param> /// <returns>built service type</returns> public virtual IType BuildServiceType(string serviceTypeName) { PrimaryType type = SwaggerObject.ToType(); if (type == PrimaryType.Object && "file".Equals(SwaggerObject.Format, StringComparison.OrdinalIgnoreCase)) { type = PrimaryType.Stream; } if (SwaggerObject.Enum != null && type == PrimaryType.String && (SwaggerObject.Enum.Count > 1 || IsExpandableEnum(SwaggerObject))) { var enumType = new EnumType(); SwaggerObject.Enum.ForEach(v => enumType.Values.Add(new EnumValue { Name = v, SerializedName = v })); if (SwaggerObject.Extensions.ContainsKey(CodeGenerator.EnumObject)) { var enumObject = SwaggerObject.Extensions[CodeGenerator.EnumObject] as Newtonsoft.Json.Linq.JContainer; if (enumObject != null) { enumType.Name = enumObject["name"].ToString(); if (enumObject["modelAsString"] != null) { enumType.ModelAsString = bool.Parse(enumObject["modelAsString"].ToString()); } } enumType.SerializedName = enumType.Name; if (string.IsNullOrEmpty(enumType.Name)) { throw new InvalidOperationException( string.Format(CultureInfo.InvariantCulture, "{0} extension needs to specify an enum name.", CodeGenerator.EnumObject)); } var existingEnum = Modeler.ServiceClient.EnumTypes.FirstOrDefault( e => e.Name.Equals(enumType.Name, StringComparison.OrdinalIgnoreCase)); if (existingEnum != null) { if (!existingEnum.Equals(enumType)) { throw new InvalidOperationException( string.Format(CultureInfo.InvariantCulture, "Swagger document contains two or more {0} extensions with the same name '{1}' and different values.", CodeGenerator.EnumObject, enumType.Name)); } } else { Modeler.ServiceClient.EnumTypes.Add(enumType); } } else { enumType.ModelAsString = true; enumType.Name = string.Empty; enumType.SerializedName = string.Empty; } return(enumType); } if (SwaggerObject.Type == DataType.Array) { string itemServiceTypeName; if (SwaggerObject.Items.Reference != null) { itemServiceTypeName = SwaggerObject.Items.Reference.StripDefinitionPath(); } else { itemServiceTypeName = serviceTypeName + "Item"; } var elementType = SwaggerObject.Items.GetBuilder(Modeler).BuildServiceType(itemServiceTypeName); return(new SequenceType { ElementType = elementType }); } if (SwaggerObject.AdditionalProperties != null) { string dictionaryValueServiceTypeName; if (SwaggerObject.AdditionalProperties.Reference != null) { dictionaryValueServiceTypeName = SwaggerObject.AdditionalProperties.Reference.StripDefinitionPath(); } else { dictionaryValueServiceTypeName = serviceTypeName + "Value"; } return(new DictionaryType { ValueType = SwaggerObject.AdditionalProperties.GetBuilder(Modeler) .BuildServiceType((dictionaryValueServiceTypeName)) }); } return(type); }
internal static bool DefinesInlineProperties(this SwaggerObject entity) { return(entity.Description != null || entity.Items != null || entity.Type != null); }
/// <summary> /// Determines if the default value appears in the enum /// </summary> internal static bool EnumContainsDefault(this SwaggerObject entity) { return(entity.Enum.Contains(entity.Default)); }
private static void RemoveReferenceDefinitions(SwaggerObject root) { // Remove definitions and parameters which has been added into _documentObjectCache if (root.Dictionary.ContainsKey(DefinitionsKey)) { root.Dictionary.Remove(DefinitionsKey); } if (root.Dictionary.ContainsKey(ParametersKey)) { root.Dictionary.Remove(ParametersKey); } }
public ObjectBuilder(SwaggerObject swaggerObject, SwaggerModeler modeler) { SwaggerObject = swaggerObject; Modeler = modeler; }
private static bool IsSwaggerObjectConstant(SwaggerObject swaggerObject) { return(swaggerObject.Enum != null && swaggerObject.Enum.Count == 1 && swaggerObject.IsRequired); }
public static List <ViewModelClass> ReadViewModels(SwaggerObject swaggerObject, string apiNameSpace, string clientNameSpace) { List <ViewModelClass> viewModelList = new List <ViewModelClass>(); foreach (var definition in swaggerObject.definitions) { ViewModelClass viewModelClass = new ViewModelClass(); viewModelClass.NameOfClass = TranslateNameSpace(definition.Key, apiNameSpace, clientNameSpace); foreach (var property in definition.Value.properties) { if (!string.IsNullOrEmpty(property.Value.type) && property.Value.type.Equals("object")) { // INNER VIEW MODEL CLASS DETECTED ViewModelClass innerViewModelClass = new ViewModelClass(); string nameOfClassAdjusted = definition.Key + char.ToUpper(property.Key[0]) + property.Key.Substring(1); innerViewModelClass.NameOfClass = TranslateNameSpace(nameOfClassAdjusted, apiNameSpace, clientNameSpace); foreach (var innerProperty in property.Value.properties) { string CSharpType = TranslateCSharpType(innerProperty.Value.type, innerProperty.Value.format, innerProperty.Value._ref, innerProperty.Value.items, apiNameSpace, clientNameSpace); innerViewModelClass.Properties.Add(new ViewModelProperty { Name = innerProperty.Key, Type = CSharpType }); } viewModelList.Add(innerViewModelClass); viewModelClass.Properties.Add(new ViewModelProperty { Name = property.Key, Type = innerViewModelClass.NameOfClass }); } else { string CSharpType = TranslateCSharpType(property.Value.type, property.Value.format, property.Value._ref, property.Value.items, apiNameSpace, clientNameSpace); viewModelClass.Properties.Add(new ViewModelProperty { Name = property.Key, Type = CSharpType }); } } viewModelList.Add(viewModelClass); } return(viewModelList); }
public static List <ServiceClass> ReadServices(SwaggerObject swaggerObject, string apiNameSpace, string clientNameSpace) { List <ServiceClass> serviceList = new List <ServiceClass>(); foreach (var path in swaggerObject.paths) { if (path.Value.parameters != null) { // TODO: Check what value comes } if (path.Value.get != null) { var serviceClass = GetOrGenerateServiceClass(ref serviceList, path.Value.get); AddServiceMethod(ref serviceClass, HttpVerb.GET, path.Key, path.Value.get, apiNameSpace, clientNameSpace); } if (path.Value.post != null) { var serviceClass = GetOrGenerateServiceClass(ref serviceList, path.Value.post); AddServiceMethod(ref serviceClass, HttpVerb.POST, path.Key, path.Value.post, apiNameSpace, clientNameSpace); } if (path.Value.put != null) { var serviceClass = GetOrGenerateServiceClass(ref serviceList, path.Value.put); AddServiceMethod(ref serviceClass, HttpVerb.PUT, path.Key, path.Value.put, apiNameSpace, clientNameSpace); } if (path.Value.delete != null) { var serviceClass = GetOrGenerateServiceClass(ref serviceList, path.Value.delete); AddServiceMethod(ref serviceClass, HttpVerb.DELETE, path.Key, path.Value.delete, apiNameSpace, clientNameSpace); } if (path.Value.patch != null) { var serviceClass = GetOrGenerateServiceClass(ref serviceList, path.Value.patch); AddServiceMethod(ref serviceClass, HttpVerb.PATCH, path.Key, path.Value.patch, apiNameSpace, clientNameSpace); } if (path.Value.options != null) { var serviceClass = GetOrGenerateServiceClass(ref serviceList, path.Value.options); AddServiceMethod(ref serviceClass, HttpVerb.OPTIONS, path.Key, path.Value.options, apiNameSpace, clientNameSpace); } if (path.Value.head != null) { var serviceClass = GetOrGenerateServiceClass(ref serviceList, path.Value.head); AddServiceMethod(ref serviceClass, HttpVerb.HEAD, path.Key, path.Value.head, apiNameSpace, clientNameSpace); } } return(serviceList); }
/// <summary> /// The visitor method for building service types. This is called when an instance of this class is /// visiting a _swaggerModeler to build a service type. /// </summary> /// <param name="serviceTypeName">name for the service type</param> /// <returns>built service type</returns> public virtual IModelType BuildServiceType(string serviceTypeName, bool required) { PrimaryType type = SwaggerObject.ToType(); Debug.Assert(type != null); if (type.KnownPrimaryType == KnownPrimaryType.Object && SwaggerObject.KnownFormat == KnownFormat.file) { type = New <PrimaryType>(KnownPrimaryType.Stream); } type.XmlProperties = (SwaggerObject as Schema)?.Xml; type.Format = SwaggerObject.Format; var xMsEnum = SwaggerObject.Extensions.GetValue <JToken>(Core.Model.XmsExtensions.Enum.Name); if (xMsEnum != null && SwaggerObject.Enum == null) { throw new InvalidOperationException($"Found 'x-ms-enum' without 'enum' on the same level. Please either add an 'enum' restriction or remove 'x-ms-enum'."); } if (SwaggerObject.Enum != null && type.KnownPrimaryType == KnownPrimaryType.String && !(IsSwaggerObjectConstant(SwaggerObject, required))) { if (SwaggerObject.Enum.Count == 0) { throw new InvalidOperationException($"Found an 'enum' with no values. Please remove this (unsatisfiable) restriction or add values."); } var enumType = New <EnumType>(); // Set the underlying type. This helps to determine whether the values in EnumValue are of type string, number, etc. enumType.UnderlyingType = type; SwaggerObject.Enum.OfType <JValue>().Select(x => (string)x).ForEach(v => enumType.Values.Add(new EnumValue { Name = v, SerializedName = v })); if (xMsEnum is JContainer enumObject) { var enumName = "" + enumObject["name"]; if (string.IsNullOrEmpty(enumName)) { throw new InvalidOperationException($"{Core.Model.XmsExtensions.Enum.Name} extension needs to specify an enum name."); } enumType.SetName(enumName); if (enumObject["modelAsString"] != null) { enumType.ModelAsString = bool.Parse(enumObject["modelAsString"].ToString()); } enumType.OldModelAsString = (enumObject["oldModelAsString"] != null)? bool.Parse(enumObject["oldModelAsString"].ToString()) : false; if (enumType.OldModelAsString) { enumType.ModelAsString = true; } var valueOverrides = enumObject["values"] as JArray; if (valueOverrides != null) { var valuesBefore = new HashSet <string>(enumType.Values.Select(x => x.SerializedName)); enumType.Values.Clear(); foreach (var valueOverride in valueOverrides) { var value = valueOverride["value"]; var description = valueOverride["description"]; var name = valueOverride["name"] ?? value; var enumVal = new EnumValue { Name = (string)name, SerializedName = (string)value, Description = (string)description }; if (valueOverride["allowedValues"] is JArray allowedValues) { // set the allowedValues if any foreach (var allowedValue in allowedValues) { enumVal.AllowedValues.Add(allowedValue.ToString()); } } enumType.Values.Add(enumVal); } var valuesAfter = new HashSet <string>(enumType.Values.Select(x => x.SerializedName)); // compare values if (!valuesBefore.SetEquals(valuesAfter)) { throw new InvalidOperationException($"Values specified by 'enum' mismatch those specified by 'x-ms-enum' (name: '{enumName}'): " + string.Join(", ", valuesBefore.Select(x => $"'{x}'")) + " vs " + string.Join(", ", valuesAfter.Select(x => $"'{x}'"))); } } var existingEnum = Modeler.CodeModel.EnumTypes.FirstOrDefault( e => e.Name.RawValue.EqualsIgnoreCase(enumType.Name.RawValue)); if (existingEnum != null) { if (!existingEnum.StructurallyEquals(enumType)) { throw new InvalidOperationException( string.Format(CultureInfo.InvariantCulture, "Swagger document contains two or more {0} extensions with the same name '{1}' and different values: {2} vs. {3}", Core.Model.XmsExtensions.Enum.Name, enumType.Name, string.Join(",", existingEnum.Values.Select(x => x.SerializedName)), string.Join(",", enumType.Values.Select(x => x.SerializedName)))); } // Use the existing one! enumType = existingEnum; } else { Modeler.CodeModel.Add(enumType); } } else { enumType.ModelAsString = true; enumType.SetName(string.Empty); } enumType.XmlProperties = (SwaggerObject as Schema)?.Xml; return(enumType); } if (SwaggerObject.Type == DataType.Array) { if (SwaggerObject.Items == null) { throw new Exception($"Invalid Swagger: Missing 'items' definition of an 'array' type."); } string itemServiceTypeName; if (SwaggerObject.Items.Reference != null) { itemServiceTypeName = SwaggerObject.Items.Reference.StripComponentsSchemaPath(); } else { itemServiceTypeName = serviceTypeName + "Item"; } var elementType = SwaggerObject.Items.GetBuilder(Modeler).BuildServiceType(itemServiceTypeName, false); return(New <SequenceType>(new { ElementType = elementType, Extensions = SwaggerObject.Items.Extensions, XmlProperties = (SwaggerObject as Schema)?.Xml, ElementXmlProperties = SwaggerObject.Items?.Xml })); } if (SwaggerObject.AdditionalProperties != null) { string dictionaryValueServiceTypeName; if (SwaggerObject.AdditionalProperties.Reference != null) { dictionaryValueServiceTypeName = SwaggerObject.AdditionalProperties.Reference.StripComponentsSchemaPath(); } else { dictionaryValueServiceTypeName = serviceTypeName + "Value"; } return(New <DictionaryType>(new { ValueType = SwaggerObject.AdditionalProperties.GetBuilder(Modeler) .BuildServiceType(dictionaryValueServiceTypeName, false), Extensions = SwaggerObject.AdditionalProperties.Extensions, XmlProperties = (SwaggerObject as Schema)?.Xml })); } return(type); }
private static bool IsSwaggerObjectConstant(SwaggerObject swaggerObject, bool isRequired) => swaggerObject.Enum != null && swaggerObject.Enum.Count == 1 && isRequired;
/// <summary> /// The visitor method for building service types. This is called when an instance of this class is /// visiting a _swaggerModeler to build a service type. /// </summary> /// <param name="serviceTypeName">name for the service type</param> /// <returns>built service type</returns> public virtual IType BuildServiceType(string serviceTypeName) { PrimaryType type = SwaggerObject.ToType(); if (SwaggerObject.Enum != null && SwaggerObject.Enum.Any() && type == PrimaryType.String) { var enumType = new EnumType(); SwaggerObject.Enum.ForEach(v => enumType.Values.Add(new EnumValue { Name = v, SerializedName = v })); if (SwaggerObject.Extensions.ContainsKey("x-ms-enum")) { enumType.IsExpandable = false; enumType.Name = SwaggerObject.Extensions["x-ms-enum"] as string; enumType.SerializedName = enumType.Name; if (string.IsNullOrEmpty(enumType.Name)) { throw new InvalidOperationException("x-ms-enum extension needs to specify an enum name."); } var existingEnum = Modeler.ServiceClient.EnumTypes.FirstOrDefault( e => e.Name.Equals(enumType.Name, StringComparison.OrdinalIgnoreCase)); if (existingEnum != null) { if (!existingEnum.Equals(enumType)) { throw new InvalidOperationException( string.Format(CultureInfo.InvariantCulture, "Swagger document contains two or more x-ms-enum extensions with the same name '{0}' and different values.", enumType.Name)); } } else { Modeler.ServiceClient.EnumTypes.Add(enumType); } } else { enumType.IsExpandable = true; enumType.Name = string.Empty; enumType.SerializedName = string.Empty; } return(enumType); } if (SwaggerObject.Type == DataType.Array) { string itemServiceTypeName; if (SwaggerObject.Items.Reference != null) { itemServiceTypeName = SwaggerObject.Items.Reference.StripDefinitionPath(); } else { itemServiceTypeName = serviceTypeName + "Item"; } var elementType = SwaggerObject.Items.GetBuilder(Modeler).BuildServiceType(itemServiceTypeName); return(new SequenceType { ElementType = elementType }); } if (SwaggerObject.AdditionalProperties != null) { string dictionaryValueServiceTypeName; if (SwaggerObject.AdditionalProperties.Reference != null) { dictionaryValueServiceTypeName = SwaggerObject.AdditionalProperties.Reference.StripDefinitionPath(); } else { dictionaryValueServiceTypeName = serviceTypeName + "Value"; } return(new DictionaryType { ValueType = SwaggerObject.AdditionalProperties.GetBuilder(Modeler) .BuildServiceType((dictionaryValueServiceTypeName)) }); } return(type); }
public static void SetConstraints(Dictionary <Constraint, string> constraints, SwaggerObject swaggerObject) { if (constraints == null) { throw new ArgumentNullException("constraints"); } if (swaggerObject == null) { throw new ArgumentNullException("swaggerObject"); } if (!string.IsNullOrEmpty(swaggerObject.Maximum) && swaggerObject.IsConstraintSupported(nameof(swaggerObject.Maximum)) && !swaggerObject.ExclusiveMaximum) { constraints[Constraint.InclusiveMaximum] = swaggerObject.Maximum; } if (!string.IsNullOrEmpty(swaggerObject.Maximum) && swaggerObject.IsConstraintSupported(nameof(swaggerObject.Maximum)) && swaggerObject.ExclusiveMaximum && swaggerObject.IsConstraintSupported(nameof(swaggerObject.ExclusiveMaximum))) { constraints[Constraint.ExclusiveMaximum] = swaggerObject.Maximum; } if (!string.IsNullOrEmpty(swaggerObject.Minimum) && swaggerObject.IsConstraintSupported(nameof(swaggerObject.Minimum)) && !swaggerObject.ExclusiveMinimum) { constraints[Constraint.InclusiveMinimum] = swaggerObject.Minimum; } if (!string.IsNullOrEmpty(swaggerObject.Minimum) && swaggerObject.IsConstraintSupported(nameof(swaggerObject.Minimum)) && swaggerObject.ExclusiveMinimum && swaggerObject.IsConstraintSupported(nameof(swaggerObject.ExclusiveMinimum))) { constraints[Constraint.ExclusiveMinimum] = swaggerObject.Minimum; } if (!string.IsNullOrEmpty(swaggerObject.MaxLength) && swaggerObject.IsConstraintSupported(nameof(swaggerObject.MaxLength))) { constraints[Constraint.MaxLength] = swaggerObject.MaxLength; } if (!string.IsNullOrEmpty(swaggerObject.MinLength) && swaggerObject.IsConstraintSupported(nameof(swaggerObject.MinLength))) { constraints[Constraint.MinLength] = swaggerObject.MinLength; } if (!string.IsNullOrEmpty(swaggerObject.Pattern) && swaggerObject.IsConstraintSupported(nameof(swaggerObject.Pattern))) { constraints[Constraint.Pattern] = swaggerObject.Pattern; } if (!string.IsNullOrEmpty(swaggerObject.MaxItems) && swaggerObject.IsConstraintSupported(nameof(swaggerObject.MaxItems))) { constraints[Constraint.MaxItems] = swaggerObject.MaxItems; } if (!string.IsNullOrEmpty(swaggerObject.MinItems) && swaggerObject.IsConstraintSupported(nameof(swaggerObject.MinItems))) { constraints[Constraint.MinItems] = swaggerObject.MinItems; } if (!string.IsNullOrEmpty(swaggerObject.MultipleOf) && swaggerObject.IsConstraintSupported(nameof(swaggerObject.MultipleOf))) { constraints[Constraint.MultipleOf] = swaggerObject.MultipleOf; } if (swaggerObject.UniqueItems && swaggerObject.IsConstraintSupported(nameof(swaggerObject.UniqueItems))) { constraints[Constraint.UniqueItems] = "true"; } }
/// <summary> /// Determines if the SwaggerObject has both a default and an enum defined /// </summary> /// <param name="entity"></param> /// <returns></returns> internal static bool HasDefaultAndEnum(this SwaggerObject entity) { return(!string.IsNullOrEmpty(entity.Default) && entity.Enum != null); }
/// <summary> /// The visitor method for building service types. This is called when an instance of this class is /// visiting a _swaggerModeler to build a service type. /// </summary> /// <param name="serviceTypeName">name for the service type</param> /// <returns>built service type</returns> public virtual IModelType BuildServiceType(string serviceTypeName) { PrimaryType type = SwaggerObject.ToType(); Debug.Assert(type != null); if (type.KnownPrimaryType == KnownPrimaryType.Object && SwaggerObject.KnownFormat == KnownFormat.file) { type = New <PrimaryType>(KnownPrimaryType.Stream); } type.XmlProperties = (SwaggerObject as Schema)?.Xml; type.Format = SwaggerObject.Format; if (SwaggerObject.Enum != null && type.KnownPrimaryType == KnownPrimaryType.String && !(IsSwaggerObjectConstant(SwaggerObject))) { var enumType = New <EnumType>(); SwaggerObject.Enum.ForEach(v => enumType.Values.Add(new EnumValue { Name = v, SerializedName = v })); if (SwaggerObject.Extensions.ContainsKey(Core.Model.XmsExtensions.Enum.Name)) { var enumObject = SwaggerObject.Extensions[Core.Model.XmsExtensions.Enum.Name] as Newtonsoft.Json.Linq.JContainer; if (enumObject != null) { enumType.SetName(enumObject["name"].ToString()); if (enumObject["modelAsString"] != null) { enumType.ModelAsString = bool.Parse(enumObject["modelAsString"].ToString()); } } enumType.SerializedName = enumType.Name; if (string.IsNullOrEmpty(enumType.Name)) { throw new InvalidOperationException( string.Format(CultureInfo.InvariantCulture, "{0} extension needs to specify an enum name.", Core.Model.XmsExtensions.Enum.Name)); } var existingEnum = Modeler.CodeModel.EnumTypes.FirstOrDefault( e => e.Name.RawValue.EqualsIgnoreCase(enumType.Name.RawValue)); if (existingEnum != null) { if (!existingEnum.StructurallyEquals(enumType)) { throw new InvalidOperationException( string.Format(CultureInfo.InvariantCulture, "Swagger document contains two or more {0} extensions with the same name '{1}' and different values.", Core.Model.XmsExtensions.Enum.Name, enumType.Name)); } // Use the existing one! enumType = existingEnum; } else { Modeler.CodeModel.Add(enumType); } } else { enumType.ModelAsString = true; enumType.SetName(string.Empty); enumType.SerializedName = string.Empty; } enumType.XmlProperties = (SwaggerObject as Schema)?.Xml; return(enumType); } if (SwaggerObject.Type == DataType.Array) { string itemServiceTypeName; if (SwaggerObject.Items.Reference != null) { itemServiceTypeName = SwaggerObject.Items.Reference.StripDefinitionPath(); } else { itemServiceTypeName = serviceTypeName + "Item"; } var elementType = SwaggerObject.Items.GetBuilder(Modeler).BuildServiceType(itemServiceTypeName); return(New <SequenceType>(new { ElementType = elementType, Extensions = SwaggerObject.Items.Extensions, XmlProperties = (SwaggerObject as Schema)?.Xml, ElementXmlProperties = SwaggerObject.Items?.Xml })); } if (SwaggerObject.AdditionalProperties != null) { string dictionaryValueServiceTypeName; if (SwaggerObject.AdditionalProperties.Reference != null) { dictionaryValueServiceTypeName = SwaggerObject.AdditionalProperties.Reference.StripDefinitionPath(); } else { dictionaryValueServiceTypeName = serviceTypeName + "Value"; } return(New <DictionaryType>(new { ValueType = SwaggerObject.AdditionalProperties.GetBuilder(Modeler) .BuildServiceType((dictionaryValueServiceTypeName)), Extensions = SwaggerObject.AdditionalProperties.Extensions, XmlProperties = (SwaggerObject as Schema)?.Xml })); } return(type); }
static void Main(string[] args) { string configFileName = "config.json"; if (!File.Exists(configFileName)) { var streamWriter = File.CreateText(configFileName); // Unload the file streamWriter.Dispose(); } var configFile = File.OpenText(configFileName); ConfigurationData config = JsonConvert.DeserializeObject <ConfigurationData>(configFile.ReadToEnd()); // Unload the file configFile.Dispose(); if (config == null) { config = new ConfigurationData() { APIUrl = "", APISwaggerUrl = "", APINameSpace = "", ClientNameSpace = "", FolderPath = "" }; } else { Console.WriteLine("--- DETECTED A CONFIGURATION FILE IN THE SYSTEM"); Console.WriteLine("> API URL: " + config.APIUrl); Console.WriteLine("> API URL FROM SWAGGER FILE: " + config.APISwaggerUrl); Console.WriteLine("> API NAMESPACE: " + config.APINameSpace); Console.WriteLine("> CLIENT NAMESPACE: " + config.ClientNameSpace); Console.WriteLine("> FOLDER: " + config.FolderPath); Console.WriteLine(); } Console.WriteLine("--- GETTING THE CONFIGURATION FROM THE USER"); string inputFromUser = ""; Console.WriteLine("> ENTER THE API URL: (EXAMPLE: \"http://api.yourwebsite.com/\")"); inputFromUser = Console.ReadLine(); if (!string.IsNullOrWhiteSpace(inputFromUser)) { config.APIUrl = inputFromUser; } Console.WriteLine("> ENTER THE API URL FROM SWAGGER FILE: (EXAMPLE: \"http://api.yourwebsite.com/swagger/docs/v1\")"); inputFromUser = Console.ReadLine(); if (!string.IsNullOrWhiteSpace(inputFromUser)) { config.APISwaggerUrl = inputFromUser; } Console.WriteLine("> ENTER THE API NAMESPACE: (EXAMPLE: \"ExampleNameSpace\")"); inputFromUser = Console.ReadLine(); if (!string.IsNullOrWhiteSpace(inputFromUser)) { config.APINameSpace = inputFromUser; } Console.WriteLine("> ENTER THE CLIENT NAMESPACE: (EXAMPLE: \"ExampleNameSpace.Web.MyClientAPI\")"); inputFromUser = Console.ReadLine(); if (!string.IsNullOrWhiteSpace(inputFromUser)) { config.ClientNameSpace = inputFromUser; } Console.WriteLine("> ENTER THE FOLDER: (EXAMPLE: \"C:\\TEMP_SWAGGER\\\")"); inputFromUser = Console.ReadLine(); if (!string.IsNullOrWhiteSpace(inputFromUser)) { config.FolderPath = inputFromUser; } if (!config.FolderPath.EndsWith("\\")) { config.FolderPath = config.FolderPath + "\\"; } File.WriteAllText(configFileName, JsonConvert.SerializeObject(config)); Console.WriteLine("--- CONFIGURATION INSERTED"); Console.WriteLine("--- GETTING THE JSON FILE FROM SWAGGER"); SwaggerObject swaggerObject = GetSwaggerObject(config.APISwaggerUrl); Console.WriteLine("- JSON File Loaded"); Console.WriteLine("--- GROUPING THE DATA FROM THE JSON FILE"); DateTime executionDateTime = DateTime.Now; var services = SwaggerReader.ReadServices(swaggerObject, config.APINameSpace, config.ClientNameSpace); Console.WriteLine("> SERVICES (Quantity: " + services.Count + ")"); Console.WriteLine(""); foreach (var serviceClass in services) { Console.WriteLine(serviceClass.ToString()); } Console.WriteLine("> EXECUTION TIME: " + (DateTime.Now - executionDateTime).TotalSeconds + " SECONDS"); Console.WriteLine(""); Console.WriteLine("> PRESS ANY KEY TO GENERATE THE FILES..."); Console.ReadLine(); executionDateTime = DateTime.Now; var viewModels = SwaggerReader.ReadViewModels(swaggerObject, config.APINameSpace, config.ClientNameSpace); Console.WriteLine("> VIEW MODELS (Quantity: " + viewModels.Count + ")"); Console.WriteLine(""); foreach (var viewModelClass in viewModels) { Console.WriteLine(viewModelClass.ToString()); } Console.WriteLine("> EXECUTION TIME: " + (DateTime.Now - executionDateTime).TotalSeconds + " SECONDS"); Console.WriteLine(""); Console.WriteLine("> PRESS ANY KEY TO GENERATE THE FILES..."); Console.ReadLine(); Infrastructure infrastructure = new Infrastructure(); infrastructure.AdditionalHeaderParameters = SwaggerReader.ReadAdditionalHeaders(swaggerObject); executionDateTime = DateTime.Now; ConfigureFolder(config.FolderPath); Console.WriteLine("> CREATING THE SERVICES FILES"); Console.WriteLine(""); SwaggerWriter.WriteServices(services, infrastructure, config.APIUrl, config.APINameSpace, config.ClientNameSpace, config.FolderPath); Console.WriteLine(""); Console.WriteLine("> CREATING THE VIEW MODELS FILES"); Console.WriteLine(""); SwaggerWriter.WriteViewModels(viewModels, config.APINameSpace, config.ClientNameSpace, config.FolderPath); Console.WriteLine(""); Console.WriteLine("> EXECUTION TIME: " + (DateTime.Now - executionDateTime).TotalSeconds + " SECONDS"); Console.WriteLine(""); Console.WriteLine("> PROCCESS EXECUTED WITH SUCCESS"); Console.ReadLine(); }