public static async Task <String> Create(JsonSchema4 schema, Dictionary <String, JsonSchema4> others, String ns)
        {
            bool hasBase = false;

            var baseModelWriter = new BaseModelWriter("Input", CreatePropertyAttributes());
            var baseClass       = ModelTypeGenerator.Create(schema, schema.GetPluralName(), baseModelWriter, ns, ns + ".InputModels", allowPropertyCallback: p =>
            {
                if (p.CreateInputModel())
                {
                    hasBase = hasBase | p.IsAbstractOnInputModel();
                    return(p.IsAbstractOnInputModel());
                }
                return(false);
            });

            var modelWriter = new MainModelWriter(hasBase ? baseClass : null, "Input", CreatePropertyAttributes(), CreateClassAttributes(), false, false,
                                                  a =>
            {
                var interfaces = new String[] { a.BaseClassName, }
                .Concat(a.Writer.GetAdditionalInterfaces());

                a.Builder.AppendLine(
                    $@"    public partial class {a.Name}{a.ModelSuffix}{InterfaceListBuilder.Build(interfaces)}
    {{"
                    );
            })
            {
                AdditionalUsings = $@"using Threax.AspNetCore.Halcyon.Ext.ValueProviders;"
                                   + schema.GetExtraNamespaces(StrConstants.FileNewline)
            };

            return(ModelTypeGenerator.Create(schema, schema.GetPluralName(), modelWriter, ns, ns + ".InputModels",
                                             allowPropertyCallback: AllowProperty,
                                             additionalProperties: await AdditionalProperties(schema, others)));
        }
        public static String Get(JsonSchema4 schema, String ns, bool generated)
        {
            bool hasBase = false;

            var baseWriter = new QueryBaseModelWriter("Query", QueryPropertiesWriter.CreateAttributeBuilder())
            {
                InheritFrom = new String[] { "PagedCollectionQuery" }
            };
            var baseClass = ModelTypeGenerator.Create(schema, schema.GetPluralName(), baseWriter, ns, ns + ".Database", allowPropertyCallback: p =>
            {
                if (p.IsQueryable())
                {
                    hasBase = hasBase | p.IsAbstractOnQuery();
                    return(p.IsAbstractOnQuery());
                }
                return(false);
            });

            var baseClassName = "PagedCollectionQuery";

            if (hasBase)
            {
                baseClassName = $"{BaseModelWriter.CreateBaseClassName(schema.Title, "Query")}";
                baseClass     = $@"
{baseClass}
";
            }
            else
            {
                baseClass = "";
            }

            String Model, model;

            NameGenerator.CreatePascalAndCamel(schema.Title, out Model, out model);
            String Models, models;

            NameGenerator.CreatePascalAndCamel(schema.GetPluralName(), out Models, out models);
            String queryProps = ModelTypeGenerator.Create(schema, schema.GetPluralName(), new QueryPropertiesWriter(), schema, ns, ns, allowPropertyCallback: p =>
            {
                return(p.IsQueryable() && !p.IsAbstractOnQuery());
            });
            String queryCreate = ModelTypeGenerator.Create(schema, schema.GetPluralName(), new QueryCreateWriter(), schema, ns, ns, allowPropertyCallback: p =>
            {
                return(p.IsQueryable());
            });

            return(Create(ns, Model, model, Models, models, queryProps, queryCreate, schema.GetKeyType().GetTypeAsNullable(), baseClass, baseClassName, NameGenerator.CreatePascal(schema.GetKeyName()), schema.GetExtraNamespaces(StrConstants.FileNewline), generated));
        }
        public static async Task <String> Create(JsonSchema4 schema, Dictionary <String, JsonSchema4> others, String ns, bool generated)
        {
            bool hasBase = false;

            var baseWriter = new BaseModelWriter("", CreateAttributeBuilder());
            var baseClass  = ModelTypeGenerator.Create(schema, schema.GetPluralName(), baseWriter, ns, ns + ".ViewModels", allowPropertyCallback: p =>
            {
                if (p.CreateViewModel())
                {
                    hasBase = hasBase | p.IsAbstractOnViewModel();
                    return(p.IsAbstractOnViewModel());
                }
                return(false);
            });

            var mainWriter = new MainModelWriter(hasBase ? baseClass : null, "", CreateAttributeBuilder(), new NoAttributeBuilder(), schema.AllowCreated(), schema.AllowModified(),
                                                 a =>
            {
                var interfaces = new String[] { a.BaseClassName, }
                .Concat(a.Writer.GetAdditionalInterfaces());

                if (!generated)
                {
                    a.Builder.AppendLine(GetLinks(schema.GetPluralName()));
                }

                a.Builder.AppendLine(
                    $@"    public partial class {a.Name}{InterfaceListBuilder.Build(interfaces)}
    {{");

                a.Writer.CreateProperty(a.Builder, NameGenerator.CreatePascal(schema.GetKeyName()), new TypeWriterPropertyInfo(schema.GetKeyType()));
            }
                                                 )
            {
                AdditionalUsings =
                    $@"using {ns}.Controllers.Api;
using Threax.AspNetCore.Halcyon.Ext.ValueProviders;"
                    + schema.GetExtraNamespaces(StrConstants.FileNewline)
            };

            return(ModelTypeGenerator.Create(schema, schema.GetPluralName(), mainWriter, ns, ns + ".ViewModels",
                                             allowPropertyCallback: AllowProperty,
                                             additionalProperties: await AdditionalProperties(schema, others)));
        }
        public static String Create(JsonSchema4 schema, Dictionary <String, JsonSchema4> others, String ns)
        {
            bool hasBase = false;

            var baseWriter = new BaseModelWriter("Entity", CreateAttributeBuilder());
            var baseClass  = ModelTypeGenerator.Create(schema, schema.GetPluralName(), baseWriter, ns, ns + ".Database", allowPropertyCallback: p =>
            {
                if (p.CreateEntity())
                {
                    hasBase = hasBase | p.IsAbstractOnEntity();
                    return(p.IsAbstractOnEntity());
                }
                return(false);
            });

            var mainWriter = new MainModelWriter(hasBase ? baseClass : null, "Entity", CreateAttributeBuilder(), new NoAttributeBuilder(), schema.AllowCreated(), schema.AllowModified(),
                                                 a =>
            {
                var interfaces = new String[] { a.BaseClassName, }
                .Concat(a.Writer.GetAdditionalInterfaces());

                a.Builder.AppendLine(
                    $@"    public partial class {a.Name}Entity{InterfaceListBuilder.Build(interfaces)}
    {{
        [Key]"
                    );

                a.Writer.CreateProperty(a.Builder, NameGenerator.CreatePascal(schema.GetKeyName()), new TypeWriterPropertyInfo(schema.GetKeyType()));
            }
                                                 )
            {
                AdditionalUsings = schema.GetExtraNamespaces(StrConstants.FileNewline)
            };

            return(ModelTypeGenerator.Create(schema, schema.GetPluralName(), mainWriter, ns, ns + ".Database",
                                             allowPropertyCallback: AllowProperty,
                                             additionalProperties: AdditionalProperties(schema, others)));
        }
Esempio n. 5
0
        public static String Get(JsonSchema4 schema, String ns)
        {
            String Model, model;

            NameGenerator.CreatePascalAndCamel(schema.Title, out Model, out model);
            String Models, models;

            NameGenerator.CreatePascalAndCamel(schema.GetPluralName(), out Models, out models);
            String ModelId, modelId;

            NameGenerator.CreatePascalAndCamel(schema.GetKeyName(), out ModelId, out modelId);

            String queryProps = ModelTypeGenerator.Create(schema, schema.GetPluralName(), new QueryPropWriter(), schema, ns, ns, allowPropertyCallback: p =>
            {
                return(p.IsQueryable());
            });
            String customizer = ModelTypeGenerator.Create(schema, schema.GetPluralName(), new QueryCustomizerWriter(), schema, ns, ns, allowPropertyCallback: p =>
            {
                return(p.IsQueryable());
            });

            return(Create(ns, Model, model, Models, models, queryProps, customizer, schema.GetKeyType().GetTypeAsNullable(), ModelId, modelId, schema.GetExtraNamespaces(StrConstants.FileNewline)));
        }