/// <summary>
/// Verify that mutability values are valid in context of Read Only property.
/// </summary>
/// <param name="mutable">mutability extension object.</param>
/// <param name="context">Rule context.</param>
/// <param name="formatParameters">array of invalid parameters to be returned.</param>
/// <returns><c>true</c> if all values for x-ms-mutability are valid in context of Read Only property, otherwise <c>false</c>.</returns>
private bool ValidateMutabilityValuesWithReadOnlyProperty(object mutable, RuleContext context, out object[] formatParameters)
{
string[] values = ((Newtonsoft.Json.Linq.JArray)mutable).ToObject <string[]>();
string[] invalidValues = null;
var resolver = new SchemaResolver(context?.GetServiceDefinition());
Schema schema = resolver.Unwrap(context?.GetFirstAncestor <Schema>());
if (schema.ReadOnly)
{
// Property with "readOnly": true must only have "read" value in x-ms-mutability extension.
invalidValues = values.Except(ValidValuesForReadOnlyProperty, StringComparer.OrdinalIgnoreCase).ToArray();
}
else
{
// Property with "readOnly": false must have more than "read" value in x-ms-mutability extension.
if (values.Length == 1)
{
invalidValues = values.Contains(ValidValuesForReadOnlyProperty[0], StringComparer.OrdinalIgnoreCase) ?
ValidValuesForReadOnlyProperty : new string[0];
}
}
bool isValid = invalidValues == null || invalidValues.Length == 0;
formatParameters = isValid ? new object[0] : new string[] { String.Join(",", invalidValues) };
return(isValid);
}
public SwaggerService Generate(Type type, InterfaceMapping map, string excludedMethodName = "Swagger", string controllernameused = null)
{
_service = new SwaggerService();
_serviceType = type;
_exceptionType = new JsonSchema4();
_exceptionType.TypeName = "SwaggerException";
_exceptionType.Properties.Add("ExceptionType", new JsonProperty {
Type = JsonObjectType.String
});
_exceptionType.Properties.Add("Message", new JsonProperty {
Type = JsonObjectType.String
});
_exceptionType.Properties.Add("StackTrace", new JsonProperty {
Type = JsonObjectType.String
});
_service.Definitions[_exceptionType.TypeName] = _exceptionType;
var schemaResolver = new SchemaResolver();
var methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
foreach (var method in methods.Where(m => m.Name != excludedMethodName))
{
if (Array.IndexOf(map.TargetMethods, method) == -1)
{
continue;
}
var parameters = method.GetParameters().ToList();
var methodName = method.Name;
var operation = new SwaggerOperation();
operation.OperationId = methodName;
var httpPath = GetHttpPath(operation, method, parameters, schemaResolver, controllernameused);
LoadParameters(operation, parameters, schemaResolver);
LoadReturnType(operation, method, schemaResolver);
LoadMetaData(operation, method);
var httpMethod = GetMethod(method);
if (!_service.Paths.ContainsKey(httpPath))
{
var path = new SwaggerOperations();
_service.Paths[httpPath] = path;
}
_service.Paths[httpPath][httpMethod] = operation;
}
foreach (var schema in schemaResolver.Schemes)
{
_service.Definitions[schema.TypeName] = schema;
}
_service.GenerateOperationIds();
return(_service);
}
/// <summary>Generates a Swagger specification for the given controller types.</summary>
/// <param name="controllerTypes">The types of the controller.</param>
/// <returns>The <see cref="SwaggerDocument" />.</returns>
/// <exception cref="InvalidOperationException">The operation has more than one body parameter.</exception>
public SwaggerDocument GenerateForControllers(IEnumerable <Type> controllerTypes)
{
var document = CreateDocument(Settings);
var schemaResolver = new SchemaResolver();
var schemaDefinitionAppender = new SwaggerDocumentSchemaDefinitionAppender(document,
Settings.TypeNameGenerator);
foreach (var controllerType in controllerTypes)
{
GenerateForController(document, controllerType,
new SwaggerGenerator(_schemaGenerator, Settings, schemaResolver, schemaDefinitionAppender));
}
AppendRequiredSchemasToDefinitions(document, schemaResolver);
document.GenerateOperationIds();
foreach (var processor in Settings.DocumentProcessors)
{
processor.Process(new DocumentProcessorContext(document, controllerTypes));
}
return(document);
}
public void TypeLookupAdvancedTest(Type expectedType, AvroSchema schema)
{
var assembly = Assembly.GetExecutingAssembly();
var actualType = SchemaResolver.GetTypeFromSchema(schema, assembly);
Assert.AreEqual(expectedType, actualType);
}
public void TypeLookupExceptionTest()
{
var assembly = Assembly.GetExecutingAssembly();
var schema = new TypeLookupSchema();
Assert.Throws <ArgumentException>(() => SchemaResolver.GetTypeFromSchema(schema, assembly));
}
/// <summary>
/// Builds the schema. Main list of activities to perform.
/// </summary>
private void BuildSchemaImpl(IEnumerable <Entity> entities, IEnumerable <SchemaFile> schemas)
{
_namespaceToSchema = schemas.ToDictionary(schema => schema.Namespace);
_entities = entities;
_aliasResolver = new EntityStreamAliasResolver(entities);
_schemaManager = new SchemaResolver(entities, _aliasResolver);
_schemaManager.Initialize();
_namesUsed = new HashSet <XmlQualifiedName>();
_namesDeclared = new HashSet <XmlQualifiedName>();
AddRootElement();
AddRootChildren();
FindFieldTypes();
AddFields();
AddTypes();
AddRelationships();
var errors = _namesUsed.Except(_namesDeclared).ToList( );
if (errors.Count > 0)
{
throw new Exception("Names were used but not declared: " + string.Join(", ", errors.Select(qn => string.Format("{0}:{1}", qn.Namespace, qn.Name))));
}
}
internal string FromAssemblyType(string[] classNames, string settingsData)
{
var settings = JsonConvert.DeserializeObject <AssemblyTypeToSwaggerGeneratorSettings>(settingsData);
RegisterReferencePaths(GetAllReferencePaths(settings));
var document = new SwaggerDocument();
var generator = new JsonSchemaGenerator(settings);
var schemaResolver = new SchemaResolver();
var schemaDefinitionAppender = new SwaggerDocumentSchemaDefinitionAppender(document, settings.TypeNameGenerator);
#if FullNet
var assembly = Assembly.LoadFrom(settings.AssemblyPath);
#else
var assembly = Context.LoadFromAssemblyPath(settings.AssemblyPath);
#endif
foreach (var className in classNames)
{
var type = assembly.GetType(className);
var schema = generator.Generate(type, schemaResolver, schemaDefinitionAppender);
document.Definitions[type.Name] = schema;
}
return(document.ToJson());
}
public void Should_build_json_schema_with_resolver()
{
var schemaResolver = new SchemaResolver((name, action) => action());
var jsonSchema = schema.BuildDynamicJsonSchema(schemaResolver);
CheckFields(jsonSchema);
}
public void TypeLookupTest(Type expectedType, Type schema)
{
var assembly = Assembly.GetExecutingAssembly();
var schemaInstance = Activator.CreateInstance(schema) as AvroSchema;
var actualType = SchemaResolver.GetTypeFromSchema(schemaInstance, assembly);
Assert.AreEqual(expectedType, actualType);
}
public DatumReader(AvroSchema readerSchema, AvroSchema writerSchema)
{
var methods = SchemaResolver.ResolveReader <T>(readerSchema, writerSchema);
_reader = methods.Item1;
_skipper = methods.Item2;
ReaderSchema = readerSchema;
WriterSchema = writerSchema;
}
/// <summary>Generates a Swagger specification for the given controller type.</summary>
/// <param name="controllerType">The type of the controller.</param>
/// <param name="excludedMethodName">The name of the excluded method name.</param>
/// <returns>The <see cref="SwaggerService" />.</returns>
/// <exception cref="InvalidOperationException">The operation has more than one body parameter.</exception>
public SwaggerService GenerateForController(Type controllerType, string excludedMethodName = "Swagger")
{
var service = new SwaggerService();
var schemaResolver = new SchemaResolver();
GenerateForController(service, controllerType, excludedMethodName, schemaResolver);
service.GenerateOperationIds();
return(service);
}
protected static Schema Get200ResponseSchema(RuleContext context)
{
OperationResponse response = context?.GetFirstAncestor <Operation>()?.Responses?.GetValueOrNull("200");
if (response == null)
{
return(null);
}
var resolver = new SchemaResolver(context?.GetServiceDefinition());
return(resolver.Unwrap(response.Schema));
}
/// <summary>Generates a Swagger specification for the given controller types.</summary>
/// <param name="controllerTypes">The types of the controller.</param>
/// <param name="excludedMethodName">The name of the excluded method name.</param>
/// <returns>The <see cref="SwaggerService" />.</returns>
/// <exception cref="InvalidOperationException">The operation has more than one body parameter.</exception>
public SwaggerService GenerateForControllers(Type[] controllerTypes, string excludedMethodName = "Swagger")
{
var service = new SwaggerService();
var schemaResolver = new SchemaResolver();
foreach (var controllerType in controllerTypes)
{
GenerateForController(service, controllerType, excludedMethodName, schemaResolver);
}
service.GenerateOperationIds();
return(service);
}
public void Should_build_flat_json_schema()
{
var languagesConfig = LanguagesConfig.English.Set(Language.DE);
var schemaResolver = new SchemaResolver((name, action) =>
{
return(action());
});
var jsonSchema = schema.BuildFlatJsonSchema(schemaResolver);
CheckFields(jsonSchema);
}
public static CMapperSchemaTree CreateSchemaTree(TransformBase map)
{
var schemaLoader = new BizTalkMapSchemaArtifactLoader(map);
var schemaResolveHandler = new SchemaResolver();
schemaResolveHandler.CustomResolution(schemaLoader);
var schemaTree = new CMapperSchemaTree();
schemaTree.SetSchemaResolveHandler(schemaResolveHandler);
return(schemaTree);
}
/// <summary>Generates a Swagger specification for the given controller types.</summary>
/// <param name="controllerTypes">The types of the controller.</param>
/// <param name="excludedMethodName">The name of the excluded method name.</param>
/// <returns>The <see cref="SwaggerService" />.</returns>
/// <exception cref="InvalidOperationException">The operation has more than one body parameter.</exception>
public SwaggerService GenerateForControllers(IEnumerable <Type> controllerTypes, string excludedMethodName = "Swagger")
{
var service = CreateService(Settings);
var schemaResolver = new SchemaResolver();
var schemaDefinitionAppender = new SwaggerServiceSchemaDefinitionAppender(service, Settings.TypeNameGenerator);
foreach (var controllerType in controllerTypes)
{
GenerateForController(service, controllerType, excludedMethodName, schemaResolver, schemaDefinitionAppender);
}
service.GenerateOperationIds();
return(service);
}
/// <summary>
/// Finds a property by name in the given
/// </summary>
/// <param name="schema">The schema to serve as a starting point</param>
/// <param name="definition">The service definition that contains all definitions</param>
/// <param name="propertyName">The name of the property to find</param>
/// <returns>The schema for the found property or null</returns>
public static Schema FindPropertyInChain(this Schema schema, ServiceDefinition definition, string propertyName)
{
Schema propertyDefinition = null;
var resolver = new SchemaResolver(definition);
// Try to find the property in this schema or its ancestors
try
{
propertyDefinition = resolver.FindProperty(schema, propertyName);
}
catch (InvalidOperationException)
{
// There was a problem finding the property (e.g. a circular reference). Return null
}
return(propertyDefinition);
}
/// <summary>
/// Load field data.
/// </summary>
/// <param name="dataTable"></param>
/// <param name="context"></param>
/// <returns></returns>
/// <remarks>
/// Data sources MUST:
/// - ensure that bits are represented as Booleans
/// - ensure that XML is transformed so that entityRefs contain Upgrade ids
/// - or where XML contains an alias, translate it to uprgadeId|alias (as the alias may be changed in the target)
/// - ensure that aliases export their namespace and direction marker.
/// </remarks>
public IEnumerable <DataEntry> GetFieldData(string dataTable, IProcessingContext context)
{
if (!FieldData.ContainsKey(dataTable))
{
return(Enumerable.Empty <DataEntry>( ));
}
Dictionary <Entity, List <FieldData> > typedValues = FieldData[dataTable];
if (dataTable == "Alias")
{
Alias aliasMarkerIdField = Aliases.CoreAlias("aliasMarkerId");
return(from pair in typedValues
from field in pair.Value
let alias = SchemaResolver.GetAliasFieldValue(pair.Key, field.Field.Alias)
let intFieldValue = SchemaResolver.GetIntFieldValue(field.Field, aliasMarkerIdField)
where intFieldValue != null
where pair.Key.Members != null && pair.Key.Members.Any(m => m.MemberDefinition.Alias.Namespace == "core" && m.MemberDefinition.Alias.Value == "inSolution" && m.Value == ActiveSolution)
let markerId = intFieldValue.Value
select new DataEntry
{
AliasMarkerId = markerId,
Data = alias.Value,
EntityId = pair.Key.Guid,
FieldId = field.Field.Guid,
Namespace = alias.Namespace,
State = DataState.Added
});
}
/////
// Non-Alias
/////
return(from pair in typedValues
from field in pair.Value
where pair.Key.Members != null && pair.Key.Members.Any(m => m.MemberDefinition.Alias.Namespace == "core" && m.MemberDefinition.Alias.Value == "inSolution" && m.Value == ActiveSolution)
select new DataEntry
{
Data = FormatData(field),
EntityId = pair.Key.Guid,
FieldId = field.Field.Guid,
State = DataState.Added
});
}
/// <summary>Generates a Swagger specification for the given controller type.</summary>
/// <param name="controllerType">The type of the controller.</param>
/// <param name="excludedMethodName">The name of the excluded method name.</param>
/// <returns>The <see cref="SwaggerService" />.</returns>
/// <exception cref="InvalidOperationException">The operation has more than one body parameter.</exception>
public SwaggerService GenerateForController(Type controllerType, string excludedMethodName = "Swagger")
{
var service = new SwaggerService
{
Consumes = new List <string> {
"application/json"
},
Produces = new List <string> {
"application/json"
}
};
var schemaResolver = new SchemaResolver();
GenerateForController(service, controllerType, excludedMethodName, schemaResolver);
service.GenerateOperationIds();
return(service);
}
internal string FromAssemblyType(string[] classNames, string settingsData)
{
var settings = JsonConvert.DeserializeObject <AssemblyTypeToSwaggerGeneratorSettings>(settingsData);
var generator = new JsonSchemaGenerator(settings);
var resolver = new SchemaResolver();
var service = new SwaggerService();
var assembly = Assembly.LoadFrom(settings.AssemblyPath);
foreach (var className in classNames)
{
var type = assembly.GetType(className);
var schema = generator.Generate <JsonSchema4>(type, resolver);
service.Definitions[type.Name] = schema;
}
return(service.ToJson());
}
private void AppendRequiredSchemasToDefinitions(SwaggerService service, SchemaResolver schemaResolver)
{
foreach (var schema in schemaResolver.Schemes)
{
if (!service.Definitions.Values.Contains(schema))
{
var typeName = schema.GetTypeName(Settings.TypeNameGenerator);
if (!service.Definitions.ContainsKey(typeName))
{
service.Definitions[typeName] = schema;
}
else
{
service.Definitions["ref_" + Guid.NewGuid().ToString().Replace("-", "_")] = schema;
}
}
}
}
public SchemaSwaggerGenerator(
SwaggerDocument document,
string appName,
string appPath,
Schema schema,
SchemaResolver schemaResolver,
PartitionResolver partitionResolver)
{
this.document = document;
this.appName = appName;
this.appPath = appPath;
schemaPath = schema.Name;
schemaName = schema.DisplayName();
schemaType = schema.TypeName();
dataSchema = schemaResolver($"{schemaType}Dto", schema.BuildJsonSchema(partitionResolver, schemaResolver));
contentSchema = schemaResolver($"{schemaType}ContentDto", schemaBuilder.CreateContentSchema(schema, dataSchema));
}
/// <summary>Generates a Swagger specification for the given controller types.</summary>
/// <param name="controllerTypes">The types of the controller.</param>
/// <param name="excludedMethodName">The name of the excluded method name.</param>
/// <returns>The <see cref="SwaggerService" />.</returns>
/// <exception cref="InvalidOperationException">The operation has more than one body parameter.</exception>
public SwaggerService GenerateForControllers(IEnumerable <Type> controllerTypes, string excludedMethodName = "Swagger")
{
var service = new SwaggerService
{
Consumes = new List <string> {
"application/json"
},
Produces = new List <string> {
"application/json"
}
};
var schemaResolver = new SchemaResolver();
foreach (var controllerType in controllerTypes)
{
GenerateForController(service, controllerType, excludedMethodName, schemaResolver);
}
service.GenerateOperationIds();
return(service);
}
/// <summary>Generates a Swagger specification for the given controller types.</summary>
/// <param name="controllerTypes">The types of the controller.</param>
/// <returns>The <see cref="SwaggerService" />.</returns>
/// <exception cref="InvalidOperationException">The operation has more than one body parameter.</exception>
public SwaggerService GenerateForControllers(IEnumerable <Type> controllerTypes)
{
var service = CreateDocument(Settings);
var schemaResolver = new SchemaResolver();
var schemaDefinitionAppender = new SwaggerServiceSchemaDefinitionAppender(service, Settings.TypeNameGenerator);
foreach (var controllerType in controllerTypes)
{
GenerateForController(service, controllerType, schemaResolver, new SwaggerGenerator(_schemaGenerator, Settings, schemaResolver, schemaDefinitionAppender));
}
service.GenerateOperationIds();
foreach (var processor in Settings.DocumentProcessors)
{
processor.Process(service);
}
return(service);
}
public static JsonSchema BuildFlatJsonSchema(this Schema schema, SchemaResolver schemaResolver)
{
Guard.NotNull(schemaResolver, nameof(schemaResolver));
var schemaName = schema.TypeName();
var jsonSchema = SchemaBuilder.Object();
foreach (var field in schema.Fields.ForApi())
{
var property = JsonTypeVisitor.BuildProperty(field, null, false);
if (property != null)
{
var propertyReference = schemaResolver($"{schemaName}{field.Name.ToPascalCase()}FlatPropertyDto", () => property);
jsonSchema.Properties.Add(field.Name, CreateProperty(field, propertyReference));
}
}
return(jsonSchema);
}
/// <summary>
/// Load entities.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public IEnumerable <EntityEntry> GetEntities(IProcessingContext context)
{
if (string.IsNullOrEmpty(ActiveSolution))
{
throw new InvalidOperationException("No 'ActiveSolution' has been specified.");
}
/////
// Get all entities.
/////
IEnumerable <Entity> allEntities = Entities.Concat(SchemaResolver.GetImpliedRelationshipEntites( ));
/////
// Get the entities that belong to the active solution.
/////
IEnumerable <Entity> activeSolutionEntities = allEntities.Where(e => e.Members.Any(m => m.MemberDefinition.Alias.Namespace == "core" && m.MemberDefinition.Alias.Value == "inSolution" && m.Value == ActiveSolution));
return(activeSolutionEntities.Select(e => new EntityEntry
{
EntityId = e.Guid,
State = DataState.Added
}));
}
/// <summary>
/// Gets the fields with defaults.
/// </summary>
/// <param name="type">The type.</param>
/// <returns></returns>
private IEnumerable <FieldData> GetFieldsWithDefaults(Entity type)
{
List <FieldData> result;
if (!_defaultsOnType.TryGetValue(type, out result))
{
Alias defaultValueAlias = Aliases.CoreAlias("defaultValue");
result =
(from ancType in SchemaResolver.GetAncestors(type)
from field in SchemaResolver.GetDeclaredFields(ancType)
let defaultValue = SchemaResolver.GetStringFieldValue(field, defaultValueAlias)
where defaultValue != null
select new FieldData
{
Field = field,
Value = defaultValue
}).ToList( );
_defaultsOnType[type] = result;
}
return(result);
}
public static JsonSchema BuildDynamicJsonSchema(this Schema schema, SchemaResolver schemaResolver, bool withHidden = false)
{
Guard.NotNull(schemaResolver, nameof(schemaResolver));
var jsonSchema = SchemaBuilder.Object();
foreach (var field in schema.Fields.ForApi(withHidden))
{
var propertyItem = JsonTypeVisitor.BuildProperty(field, null, withHidden);
if (propertyItem != null)
{
var property =
SchemaBuilder.ObjectProperty(propertyItem)
.SetDescription(field)
.SetRequired(field.RawProperties.IsRequired);
jsonSchema.Properties.Add(field.Name, property);
}
}
return(jsonSchema);
}
public void Should_build_flat_json_schema()
{
var languagesConfig = LanguagesConfig.English.Set(Language.DE);
var schemaResolver = new SchemaResolver((name, action) =>
{
return(action());
});
var jsonSchema = schema.BuildFlatJsonSchema(schemaResolver);
var jsonProperties = AllPropertyNames(jsonSchema);
void CheckField(IField field)
{
if (!field.IsForApi())
{
Assert.DoesNotContain(field.Name, jsonProperties);
}
else
{
Assert.Contains(field.Name, jsonProperties);
}
if (field is IArrayField array)
{
foreach (var nested in array.Fields)
{
CheckField(nested);
}
}
}
foreach (var field in schema.Fields)
{
CheckField(field);
}
}
public DotNetSchemaURIResolver(SchemaResolver resolver)
{
this.resolver = resolver;
}
public DotNetSchemaURIResolver(SchemaResolver resolver)
{
this.resolver = resolver;
}