Ejemplo n.º 1
0
        private async Task GenerateInheritanceAsync(Type type, JsonSchema4 schema, JsonSchemaResolver schemaResolver)
        {
            GenerateInheritanceDiscriminator(type, schema);

            var baseType = type.GetTypeInfo().BaseType;

            if (baseType != null && baseType != typeof(object))
            {
                if (Settings.FlattenInheritanceHierarchy)
                {
                    await GeneratePropertiesAndInheritanceAsync(baseType, (JsonObjectContract)ResolveContract(baseType), schema, schemaResolver).ConfigureAwait(false);
                }
                else
                {
                    var baseSchema = await GenerateAsync(baseType, schemaResolver).ConfigureAwait(false);

                    if (RequiresSchemaReference(baseType, null))
                    {
                        if (schemaResolver.RootObject != baseSchema.ActualSchema)
                        {
                            schemaResolver.AppendSchema(baseSchema.ActualSchema, Settings.SchemaNameGenerator.Generate(baseType));
                        }

                        schema.AllOf.Add(new JsonSchema4
                        {
                            SchemaReference = baseSchema.ActualSchema
                        });
                    }
                    else
                    {
                        schema.AllOf.Add(baseSchema);
                    }
                }
            }
        }
        private async Task GenerateInheritanceAsync(Type type, JsonSchema4 schema, JsonSchemaResolver schemaResolver)
        {
            GenerateInheritanceDiscriminator(type, schema);

            var baseType = type.GetTypeInfo().BaseType;

            if (baseType != null && baseType != typeof(object))
            {
                if (Settings.FlattenInheritanceHierarchy)
                {
                    var typeDescription = Settings.ReflectionService.GetDescription(baseType, null, Settings);
                    if (!typeDescription.IsDictionary && !type.IsArray)
                    {
                        await GeneratePropertiesAndInheritanceAsync(baseType, schema, schemaResolver).ConfigureAwait(false);
                    }
                }
                else
                {
                    var baseSchema = await GenerateAsync(baseType, schemaResolver).ConfigureAwait(false);

                    var baseTypeInfo = Settings.ReflectionService.GetDescription(baseType, null, Settings);
                    if (baseTypeInfo.RequiresSchemaReference(Settings.TypeMappers))
                    {
                        if (schemaResolver.RootObject != baseSchema.ActualSchema)
                        {
                            schemaResolver.AppendSchema(baseSchema.ActualSchema, Settings.SchemaNameGenerator.Generate(baseType));
                        }

                        schema.AllOf.Add(new JsonSchema4
                        {
                            Reference = baseSchema.ActualSchema
                        });
                    }
                    else
                    {
                        schema.AllOf.Add(baseSchema);
                    }
                }
            }

            if (Settings.FlattenInheritanceHierarchy && Settings.GenerateAbstractProperties)
            {
#if !LEGACY
                foreach (var i in type.GetTypeInfo().ImplementedInterfaces)
#else
                foreach (var i in type.GetTypeInfo().GetInterfaces())
#endif
                {
                    var typeDescription = Settings.ReflectionService.GetDescription(i, null, Settings);
                    if (!typeDescription.IsDictionary && !type.IsArray && !typeof(IEnumerable).GetTypeInfo().IsAssignableFrom(i.GetTypeInfo()))
                    {
                        await GeneratePropertiesAndInheritanceAsync(i, schema, schemaResolver).ConfigureAwait(false);
                    }
                }
            }
        }