private void ReadClass(Type type, ModelTransferObject model, IOptions caller) { // Logger.Trace($"Reflection read type {type.Name} ({type.Namespace})"); if (type.BaseType != typeof(object) && type.BaseType != typeof(ValueType) && type.BaseType != null) { IOptions baseOptions = this.options.Get(type.BaseType); if (!baseOptions.Ignore) { model.BasedOn = this.Read(type.BaseType, caller); } } if (model.IsGeneric) { this.ReadGenericArguments(type, model); } model.IsInterface = type.IsInterface; model.IsAbstract = type.IsAbstract; foreach (Type interFace in type.GetInterfaces(false)) { IOptions interfaceOptions = this.options.Get(interFace); if (interfaceOptions.Ignore) { continue; } ModelTransferObject interfaceTransferObject = this.Read(interFace, caller); if (this.transferObjects.Contains(interfaceTransferObject)) { model.Interfaces.Add(interfaceTransferObject); } } if (model is GenericModelTransferObject genericModel) { Type genericType = type.GetGenericTypeDefinition(); this.ReadConstants(genericType, genericModel.Template); this.ReadFields(genericType, genericModel.Template); this.ReadProperties(genericType, genericModel.Template); this.ApplyGenericTemplate(type, genericModel); } else { this.ReadConstants(type, model); this.ReadFields(type, model); this.ReadProperties(type, model); } }
protected virtual EnumTemplate WriteEnum(IModelConfiguration configuration, ModelTransferObject model, string nameSpace, List <FileTemplate> files) { if (model.EnumValues == null) { throw new InvalidOperationException("Can not write enum without values"); } EnumTemplate enumTemplate = files.AddFile(configuration.RelativePath, configuration.AddHeader) .AddNamespace(nameSpace) .AddEnum(model.Name); foreach (KeyValuePair <string, int> pair in model.EnumValues) { string formattedName = Formatter.FormatProperty(pair.Key, configuration); enumTemplate.Values.Add(new EnumValueTemplate(pair.Key, Code.Number(pair.Value), formattedName)); } return(enumTemplate); }
protected virtual FieldTemplate AddField(ModelTransferObject model, MemberTransferObject member, ClassTemplate classTemplate) { IOptions fieldOptions = this.Options.Get(member); if (model.Language != null && fieldOptions.Language != null) { this.MapType(model.Language, fieldOptions.Language, member.Type); } this.AddUsing(member.Type, classTemplate, fieldOptions); FieldTemplate fieldTemplate = classTemplate.AddField(member.Name, member.Type.ToTemplate()).Public().FormatName(fieldOptions) .WithComment(member.Comment); if (fieldOptions.WithOptionalProperties) { fieldTemplate.Optional(); } return(fieldTemplate); }
protected override ClassTemplate WriteClass(ModelTransferObject model, string relativePath) { IOptions modelOptions = this.Options.Get(model); ClassTemplate classTemplate = base.WriteClass(model, relativePath); if (!model.IsAbstract && !classTemplate.IsInterface && modelOptions.Language.IsTypeScript()) { ConstructorTemplate constructor = classTemplate.AddConstructor(); constructor.AddParameter(Code.Generic("Partial", classTemplate.ToType()), "init").Optional(); constructor.WithCode(Code.Static(Code.Type("Object")).Method("assign", Code.This(), Code.Local("init")).Close()); if (classTemplate.BasedOn.Any(x => !x.ToType().IsInterface)) { // TODO: Add super parameters constructor.WithSuper(); } } return(classTemplate); }
public void Read(DemoReadConfiguration configuration, List <ITransferObject> transferObjects) { Logger.Trace($"Read {configuration.HelloWorld.Name}..."); // Read something here and create your transfer objects ModelTransferObject model = new ModelTransferObject { Name = configuration.HelloWorld.Name, Namespace = "Test" }; if (configuration.HelloWorld.Test1) { model.Properties.Add(new PropertyTransferObject { Name = "Test1", Type = new TypeTransferObject { Name = "string" } }); } transferObjects.Add(model); }
private void ReadFields(Type type, ModelTransferObject model) { FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); foreach (FieldInfo field in fields) { IOptions fieldOptions = this.options.Get(field); if (fieldOptions.Ignore) { continue; } FieldTransferObject fieldTransferObject = new() { Name = field.Name, Type = this.Read(field.FieldType, fieldOptions) }; model.Fields.Add(fieldTransferObject); this.options.Set(fieldTransferObject, fieldOptions); } }
protected virtual EnumTemplate WriteEnum(ModelTransferObject model, string relativePath) { if (model.EnumValues == null) { throw new InvalidOperationException("Can not write enum without values"); } IOptions modelOptions = this.Options.Get(model); EnumTemplate enumTemplate = this.files.AddFile(relativePath, modelOptions) .WithName(model.FileName) .AddNamespace(modelOptions.SkipNamespace ? string.Empty : model.Namespace) .AddEnum(model.Name); foreach (KeyValuePair <string, int> pair in model.EnumValues) { string formattedName = Formatter.FormatProperty(pair.Key, modelOptions); enumTemplate.Values.Add(new EnumValueTemplate(pair.Key, Code.Number(pair.Value), formattedName)); } return(enumTemplate); }
private void ReadProperties(Type type, ModelTransferObject model) { PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); foreach (PropertyInfo property in properties) { IOptions propertyOptions = this.options.Get(property); if (propertyOptions.Ignore) { continue; } PropertyTransferObject propertyTransferObject = new() { Name = property.Name, Type = this.Read(property.PropertyType, propertyOptions), Attributes = property.GetCustomAttributes().ToTransferObjects().ToList() }; model.Properties.Add(propertyTransferObject); this.options.Set(propertyTransferObject, propertyOptions); } }
private void ReadConstants(Type type, ModelTransferObject model) { FieldInfo[] constants = type.GetFields(BindingFlags.Public | BindingFlags.Static); foreach (FieldInfo field in constants) { IOptions fieldOptions = this.options.Get(field); if (fieldOptions.Ignore) { continue; } FieldTransferObject fieldTransferObject = new() { Name = field.Name, Type = this.Read(field.FieldType, fieldOptions), Default = field.GetValue(null) }; model.Constants.Add(fieldTransferObject); this.options.Set(fieldTransferObject, fieldOptions); } }
protected virtual void WriteModel(IModelConfiguration configuration, ModelTransferObject model, string nameSpace, List <FileTemplate> files) { if (model == null) { return; } this.MapType(model.Language, configuration.Language, model); if (model.FromSystem) { return; } if (model.IsEnum) { this.WriteEnum(configuration, model, nameSpace, files); } else { this.WriteClass(configuration, model, nameSpace, files); } }
public ModelTransferObject Read(Type type, List <ITransferObject> transferObjects) { bool isFromSystem = type.Namespace != null && type.Namespace.StartsWith("System"); ModelTransferObject model = new ModelTransferObject { Language = ReflectionLanguage.Instance }; model.FromType(type); ModelTransferObject existingModel = transferObjects.OfType <ModelTransferObject>().FirstOrDefault(entry => entry.Equals(model)); if (existingModel != null) { return(existingModel); } if (type.GetCustomAttributes <GenerateIgnoreAttribute>().Any()) { Logger.Trace($"{type.Name} ({type.Namespace}) ignored (decorated with {nameof(GenerateIgnoreAttribute)})"); return(model); } if (type.IsArray) { this.ReadArray(type, model, transferObjects); } else if (type.IsGenericType && isFromSystem) { this.ReadGenericFromSystem(type, model, transferObjects); } else if (type.IsEnum) { transferObjects.Add(model); this.ReadEnum(type, model); } else if (!isFromSystem) { transferObjects.Add(model); this.ReadClass(type, model, transferObjects); } return(model); }
private void ReadEnum(Type type, ModelTransferObject model) { // Logger.Trace($"Reflection read enum {type.Name} ({type.Namespace})"); model.IsEnum = true; model.EnumValues = new Dictionary <string, int>(); Array values = Enum.GetValues(type); foreach (object value in values) { if (!(value is int)) { //throw new InvalidOperationException($"Can not convert {value.GetType().Name} enums. Only int enums are currently implemented"); } } foreach (int value in values.Cast <int>()) { string name = Enum.GetName(type, value); if (name != null) { model.EnumValues.Add(name, value); } } }
public IEnumerable <FileTemplate> Write(JsonWriteConfiguration configuration, List <ITransferObject> transferObjects) { ModelTransferObject model = transferObjects.OfType <ModelTransferObject>().FirstOrDefault(); if (model == null) { throw new InvalidOperationException("Can not create JsonObjectReader without object. Add in settings a read configuration"); } if (!configuration.Language.IsCsharp()) { throw new InvalidOperationException($"Can not generate JsonReader ({configuration.Reader.Name}) for language {configuration.Language}"); } Logger.Trace("Write JsonReader..."); string className = configuration.Reader.Name ?? model.Name + "Reader"; FileTemplate fileTemplate = new FileTemplate(configuration.Reader.RelativePath, configuration.AddHeader); ClassTemplate classTemplate = fileTemplate.AddNamespace(configuration.Reader.Namespace ?? model.Namespace ?? configuration.Object.Namespace) .AddClass(className) .FormatName(configuration); WriteReader(classTemplate, model, configuration.FormatNames); yield return(fileTemplate); }
internal static void WriteReader(ClassTemplate classTemplate, ModelTransferObject model, bool formatNames) { TypeTemplate objectType = Code.Type(model.Name, model.Namespace); if (model.Namespace != classTemplate.Namespace.Name && model.Namespace != null) { classTemplate.AddUsing(model.Namespace); } classTemplate.WithUsing("Newtonsoft.Json") //.WithUsing("Newtonsoft.Json.Linq") .WithUsing("System.IO"); classTemplate.AddMethod("Load", objectType) .FormatName(model.Language, formatNames) .WithParameter(Code.Type("string"), "fileName") .Static() .Code.AddLine(Code.Return(Code.Method("Parse", Code.Local("File").Method("ReadAllText", Code.Local("fileName"))))); classTemplate.AddMethod("Parse", objectType) .FormatName(model.Language, formatNames) .WithParameter(Code.Type("string"), "json") .Static() .Code.AddLine(Code.Return(Code.Local("JsonConvert").GenericMethod("DeserializeObject", objectType, Code.Local("json")))); }
protected override ClassTemplate WriteClass(IModelConfiguration configuration, ModelTransferObject model, string nameSpace, List <FileTemplate> files) { ClassTemplate classTemplate = base.WriteClass(configuration, model, nameSpace, files); if (!model.IsAbstract && !model.IsInterface && configuration.Language.IsTypeScript()) { ConstructorTemplate constructor = classTemplate.AddConstructor(); constructor.WithParameter(Code.Generic("Partial", classTemplate.ToType()), "init", Code.Null()) .WithCode(Code.Static(Code.Type("Object")).Method("assign", Code.This(), Code.Local("init")).Close()); if (classTemplate.BasedOn.Any(x => !x.ToType().IsInterface)) { // TODO: Add super parameters constructor.WithSuper(); } } return(classTemplate); }
public void Read(ConfigurationBase configurationBase, List <ITransferObject> transferObjects) { TsqlReadConfiguration configuration = (TsqlReadConfiguration)configurationBase; this.Validate(configuration); TsqlTypeReader typeReader = new TsqlTypeReader(configuration.Connection); foreach (TsqlReadEntity readEntity in configuration.Entities) { ModelTransferObject model; if (!string.IsNullOrEmpty(readEntity.Table)) { List <TsqlColumn> columns = typeReader.GetColumns(readEntity.Schema ?? configuration.Schema, readEntity.Table); model = new ModelTransferObject { Name = readEntity.Name ?? readEntity.Table, Namespace = readEntity.Namespace ?? configuration.Namespace, Language = TsqlLanguage.Instance }; foreach (TsqlColumn column in columns) { model.Properties.Add(new PropertyTransferObject { Name = column.Name, Type = new TypeTransferObject { Name = column.Type, IsNullable = column.IsNullable } }); } transferObjects.Add(model); } else { //TODO: Implement for StoredProcedure model = new ModelTransferObject { Name = readEntity.Name ?? readEntity.StoredProcedure, Namespace = readEntity.Namespace ?? configuration.Namespace, Language = TsqlLanguage.Instance }; } EntityTransferObject entity = new EntityTransferObject { Name = model.Name, Model = model, Table = readEntity.Table, Schema = readEntity.Schema ?? configuration.Schema }; if (!string.IsNullOrEmpty(readEntity.Table)) { typeReader.GetPrimaryKeys(readEntity.Schema ?? configuration.Schema, readEntity.Table) .Select(x => new EntityKeyTransferObject { Name = x.Name }) .ForEach(entity.Keys.Add); List <TsqlNavigationProperty> navigationProperties = typeReader.GetNavigationProperties(readEntity.Schema ?? configuration.Schema, readEntity.Table); } foreach (TsqlReadEntityKeyAction action in readEntity.KeyActions) { switch (action.Action.ToLowerInvariant()) { case "remove": case "delete": if (action.All) { entity.Keys.Clear(); } else { entity.Keys.Remove(entity.Keys.FirstOrDefault(x => x.Name.Equals(action.Name, StringComparison.InvariantCultureIgnoreCase))); } break; case "add": case "insert": entity.Keys.Add(new EntityKeyTransferObject { Name = action.Name }); break; default: throw new InvalidOperationException($"Unknown entity key action {action.Action} found"); } } foreach (EntityKeyTransferObject key in entity.Keys) { key.Property = entity.Model.Properties.FirstOrDefault(x => x.Name == key.Name).AssertIsNotNull(key.Name, $"Key {key.Name} has no matching property"); key.Type = key.Property.Type; } transferObjects.Add(entity); } foreach (TsqlReadStoredProcedure readStoredProcedure in configuration.StoredProcedures) { string schema = readStoredProcedure.Schema ?? configuration.Schema; //List<TsqlColumn> columns = typeReader.GetColumnsFromStoredProcedure(schema, readStoredProcedure.Name); StoredProcedureTransferObject storedProcedure = new StoredProcedureTransferObject { Schema = schema, Name = readStoredProcedure.Name }; storedProcedure.ReturnType = new TypeTransferObject { Name = "void", FromSystem = true }; transferObjects.Add(storedProcedure); } }
private ModelTransferObject ReadModel(string name, JObject source, List <ITransferObject> list) { ModelTransferObject model = name == null ? new JsonModelTransferObject { Name = "Unknown", Language = JsonLanguage.Instance } : new ModelTransferObject { Name = name, Language = JsonLanguage.Instance }; list.Add(model); foreach (JProperty property in source.Properties()) { if (property.Value.Type == JTokenType.Object) { ModelTransferObject propertyModel = this.ReadModel(property.Name, (JObject)property.Value, list); model.Properties.Add(new PropertyTransferObject { Name = propertyModel.Name, Type = propertyModel }); } else if (property.Value.Type == JTokenType.Array) { TypeTransferObject listType = new TypeTransferObject { Name = JTokenType.Array.ToString() }; model.Properties.Add(new PropertyTransferObject { Name = property.Name, Type = listType }); List <JToken> children = property.Value.Children().ToList(); if (children.Count == 0 || children.Any(x => x.Type != children.First().Type)) { listType.Generics.Add(new GenericAliasTransferObject { Type = new TypeTransferObject { Name = JTokenType.Object.ToString() } }); } else if (children.First().Type == JTokenType.Object) { ModelTransferObject entryModel = this.ReadModel(property.Name, (JObject)children.First(), list); listType.Generics.Add(new GenericAliasTransferObject { Type = entryModel }); } else { listType.Generics.Add(new GenericAliasTransferObject { Type = new TypeTransferObject { Name = children.First().Type.ToString() } }); } } else { model.Properties.Add(new PropertyTransferObject { Name = property.Name, Type = new TypeTransferObject { Name = property.Value.Type.ToString() } }); } } return(model); }
private TypeTransferObject Read(OpenApiReadConfiguration configuration, OpenApiSchema schema) { if (schema.Reference == null) { return(new TypeTransferObject { Name = schema.Type }); } ModelTransferObject model = transferObjects.OfType <ModelTransferObject>().FirstOrDefault(x => x.Name == schema.Reference.Id); if (model != null) { return(model); } if (schema.Type == "array") { return(new TypeTransferObject { Name = schema.Type, Generics = { new GenericAliasTransferObject { Type = this.Read(configuration, schema.Items) } } }); } if (schema.Type == "object") { model = new ModelTransferObject { Name = schema.Reference.Id, Namespace = configuration.Namespace, Language = OpenApiLanguage.Instance }; foreach (KeyValuePair <string, OpenApiSchema> propertyPair in schema.Properties) { PropertyTransferObject property = new PropertyTransferObject { Name = propertyPair.Key, Type = this.Read(configuration, propertyPair.Value) }; if (configuration.DataAnnotations && propertyPair.Value.MaxLength.HasValue) { property.Attributes.Add(new AttributeTransferObject { Name = "MaxLength", Namespace = "System.ComponentModel.DataAnnotations", Value = propertyPair.Value.MaxLength.Value }); } model.Properties.Add(property); } transferObjects.Add(model); return(model); } throw new InvalidOperationException($"Unknown schema type {schema.Type}"); }
protected override ClassTemplate WriteClass(IModelConfiguration configuration, ModelTransferObject model, string nameSpace, List <FileTemplate> files) { ClassTemplate classTemplate = base.WriteClass(configuration, model, nameSpace, files); if (model is JsonModelTransferObject && this.jsonConfiguration.Object.WithReader) { ObjectReaderWriter.WriteReader(classTemplate, model, configuration.FormatNames); } return(classTemplate); }
private void ReadGenericFromSystem(Type type, ModelTransferObject model) { // Logger.Trace($"Reflection read generic system type {type.Name}<{string.Join(",", type.GetGenericArguments().Select(x => x.Name))}> ({type.Namespace})"); this.ReadGenericArguments(type, model); this.ApplyGenericTemplate(type, (GenericModelTransferObject)model); }
protected virtual FieldTemplate AddField(ModelTransferObject model, string name, TypeTransferObject type, ClassTemplate classTemplate, IConfiguration configuration) { this.MapType(model.Language, configuration.Language, type); this.AddUsing(type, classTemplate, configuration); return(classTemplate.AddField(name, type.ToTemplate()).Public().FormatName(configuration)); }
protected virtual ClassTemplate WriteClass(IModelConfiguration configuration, ModelTransferObject model, string nameSpace, List <FileTemplate> files) { if (model.BasedOn != null) { this.MapType(model.Language, configuration.Language, model.BasedOn); } ClassTemplate classTemplate = files.AddFile(configuration.RelativePath, configuration.AddHeader) .AddNamespace(nameSpace) .AddClass(model.Name, model.BasedOn?.ToTemplate()) .FormatName(configuration); if (model.BasedOn != null) { this.AddUsing(model.BasedOn, classTemplate, configuration); } configuration.Usings?.ForEach(x => classTemplate.AddUsing(x, null, null)); classTemplate.IsInterface = model.IsInterface; classTemplate.IsAbstract = model.IsAbstract; if (model.IsGeneric) { classTemplate.Generics.AddRange(model.Generics.Where(x => x.Alias != null).Select(x => new ClassGenericTemplate(x.Alias))); } foreach (TypeTransferObject interFace in model.Interfaces) { this.MapType(model.Language, configuration.Language, interFace); classTemplate.BasedOn.Add(new BaseTypeTemplate(classTemplate, Code.Interface(interFace.Name, interFace.Namespace))); this.AddUsing(interFace, classTemplate, configuration); } this.AddFields(model, classTemplate, configuration); this.AddProperties(model, classTemplate, configuration); return(classTemplate); }
private void ReadClass(Type type, ModelTransferObject model, List <ITransferObject> transferObjects) { Logger.Trace($"Reflection read type {type.Name} ({type.Namespace})"); if (type.BaseType != typeof(object) && type.BaseType != null) { model.BasedOn = this.Read(type.BaseType, transferObjects); } Dictionary <Type, string> genericMapping = new Dictionary <Type, string>(); if (type.IsGenericType) { model.IsGeneric = true; model.Generics.Clear(); foreach (Type argument in type.GenericTypeArguments) { string alias = genericMapping.Count > 1 ? $"T{genericMapping.Count}" : "T"; genericMapping.Add(argument, alias); model.Generics.Add(new GenericAliasTransferObject { Alias = alias, Type = this.Read(argument, transferObjects) }); } } model.IsInterface = type.IsInterface; model.IsAbstract = type.IsAbstract; foreach (Type interFace in type.GetInterfaces(false)) { model.Interfaces.Add(this.Read(interFace, transferObjects)); } FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); foreach (FieldInfo field in fields) { FieldTransferObject fieldTransferObject = new FieldTransferObject { Name = field.Name, Type = genericMapping.ContainsKey(field.FieldType) ? new TypeTransferObject { Name = genericMapping[field.FieldType] } : this.Read(field.FieldType, transferObjects) }; model.Fields.Add(fieldTransferObject); } PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); foreach (PropertyInfo property in properties) { PropertyTransferObject propertyTransferObject = new PropertyTransferObject { Name = property.Name, Type = genericMapping.ContainsKey(property.PropertyType) ? new TypeTransferObject { Name = genericMapping[property.PropertyType] } : this.Read(property.PropertyType, transferObjects), CanRead = property.CanRead, CanWrite = property.CanWrite }; model.Properties.Add(propertyTransferObject); } }
private Dictionary <IEdmType, TypeTransferObject> ReadModels(IEdmModel edmModel, List <ITransferObject> list) { Dictionary <IEdmType, TypeTransferObject> modelMapping = new Dictionary <IEdmType, TypeTransferObject>(); Dictionary <IEdmType, EntityTransferObject> entityMapping = new Dictionary <IEdmType, EntityTransferObject>(); foreach (IEdmSchemaType schemaType in edmModel.SchemaElements.Select(element => edmModel.FindDeclaredType(element.FullName())).Where(x => x != null)) { if (schemaType.TypeKind == EdmTypeKind.Entity && schemaType is IEdmEntityType entityType) { ModelTransferObject model = new ModelTransferObject { Name = schemaType.Name, Namespace = schemaType.Namespace, Language = ODataLanguage.Instance }; modelMapping[entityType.AsActualType()] = model; EntityTransferObject entity = new EntityTransferObject { Name = schemaType.Name, Model = model }; entityMapping[entityType.AsActualType()] = entity; foreach (IEdmProperty edmProperty in entityType.DeclaredProperties) { model.Properties.Add(new PropertyTransferObject { Name = edmProperty.Name, Type = this.ToTransferObject(edmProperty.Type.Definition, modelMapping) }); } if (entityType.DeclaredKey != null) { foreach (IEdmStructuralProperty key in entityType.DeclaredKey) { PropertyTransferObject property = model.Properties.FirstOrDefault(x => x.Name == key.Name); entity.Keys.Add(new EntityKeyTransferObject { Name = key.Name, Type = this.ToTransferObject(key.Type.Definition, modelMapping).Clone(), Property = property }); } } // TODO: Add Navigation Properties list.Add(model); list.Add(entity); } } foreach (IEdmAction action in edmModel.SchemaElements.OfType <IEdmAction>()) { IEdmType boundTo = action.FindParameter(BindingParameterName)?.Type.Definition; if (boundTo != null && modelMapping.ContainsKey(boundTo)) { EntityTransferObject entity = entityMapping[boundTo]; EntityActionTransferObject entityAction = new EntityActionTransferObject { Name = action.Name, Namespace = action.Namespace }; if (action.ReturnType != null) { entityAction.ReturnType = modelMapping[action.ReturnType.Definition]; } entity.Actions.Add(entityAction); foreach (IEdmOperationParameter actionParameter in action.Parameters.Where(parameter => parameter.Name != BindingParameterName)) { entityAction.Parameters.Add(new EntityActionParameterTransferObject { Name = actionParameter.Name, Type = modelMapping[actionParameter.Type.Definition] }); } } else { // TODO: Unbound actions } } return(modelMapping); }
protected virtual ClassTemplate WriteClass(ModelTransferObject model, string relativePath) { IOptions modelOptions = this.Options.Get(model); if (model.BasedOn != null && model.Language != null && modelOptions.Language != null) { this.MapType(model.Language, modelOptions.Language, model.BasedOn); } bool isInterface = model.IsInterface || modelOptions.PreferInterfaces; string modelNamespace = modelOptions.SkipNamespace ? string.Empty : model.Namespace; ClassTemplate otherClassTemplate = this.files.Where(file => file.RelativePath == relativePath && file.Options.Language == modelOptions.Language) .SelectMany(file => file.Namespaces) .SelectMany(ns => ns.Children).OfType <ClassTemplate>() .FirstOrDefault(x => x.Namespace.Name == modelNamespace && x.Name == model.Name); NamespaceTemplate namespaceTemplate = otherClassTemplate?.Namespace ?? this.files.AddFile(relativePath, modelOptions) .WithName(model.FileName) // .WithType(isInterface ? "interface" : null) .AddNamespace(modelNamespace); ClassTemplate classTemplate = namespaceTemplate.AddClass(model.Name, model.BasedOn?.ToTemplate()) .FormatName(modelOptions); if (model.BasedOn != null) { this.AddUsing(model.BasedOn, classTemplate, modelOptions); } classTemplate.IsInterface = isInterface; classTemplate.IsAbstract = model.IsAbstract; if (model is GenericModelTransferObject generic) { generic.Template.Generics.Select(x => new ClassGenericTemplate(x.Alias.Name)).ForEach(classTemplate.Generics.Add); } foreach (TypeTransferObject interFace in model.Interfaces) { if (model.Language != null && modelOptions.Language != null) { this.MapType(model.Language, modelOptions.Language, interFace); } if (interFace.Name == model.Name) { continue; } classTemplate.BasedOn.Add(new BaseTypeTemplate(classTemplate, interFace.ToTemplate())); this.AddUsing(interFace, classTemplate, modelOptions); } if (model is GenericModelTransferObject genericModel) { this.AddConstants(genericModel.Template, classTemplate); this.AddFields(genericModel.Template, classTemplate); this.AddProperties(genericModel.Template, classTemplate); } else { this.AddConstants(model, classTemplate); this.AddFields(model, classTemplate); this.AddProperties(model, classTemplate); } return(classTemplate); }
public ModelTransferObject Read(Type type, IOptions caller = null) { ModelTransferObject model = new() { Language = ReflectionLanguage.Instance, Type = type }; model.Name = model.OriginalName = type.Name; model.Namespace = type.Namespace; model.IsNullable = !type.IsValueType; model.IsGeneric = type.IsGenericType; model.IsGenericParameter = type.IsGenericParameter; model.FromSystem = type.Namespace != null && type.Namespace.StartsWith("System"); IOptions typeOptions = this.options.Get(type, caller); if (model.IsGeneric) { model.Name = model.OriginalName = type.Name.Split('`').First(); model = new GenericModelTransferObject(model); } ModelTransferObject existingModel = this.transferObjects.OfType <ModelTransferObject>().FirstOrDefault(entry => entry.Equals(model)); if (existingModel != null) { // TODO: Replace complete if with cached model reading after cloning of TransferModels is fixed if (model.IsGeneric) { GenericModelTransferObject genericModel = new(existingModel); existingModel = genericModel; this.options.Set(existingModel, typeOptions); this.ApplyGenericTemplate(type, genericModel); this.transferObjects.Add(existingModel); } return(existingModel); } // TODO: Uncomment cached model reading after cloning of TransferModels is fixed // existingModel = this.environment.TransferObjects.OfType<ModelTransferObject>().FirstOrDefault(entry => entry.Equals(model)); // if (existingModel != null) // { // return this.ReadExisting(existingModel, caller); // } this.options.Set(model, typeOptions); if (typeOptions.Ignore) { Logger.Trace($"{type.Name} ({type.Namespace}) ignored (decorated with {nameof(GenerateIgnoreAttribute)})"); return(model); } if (type.IsGenericParameter) { return(model); } if (type.IsArray) { this.ReadArray(type, model); } else if (model.IsGeneric && model.FromSystem) { this.ReadGenericFromSystem(type, model); } else if (type.IsEnum) { this.transferObjects.Add(model); this.ReadEnum(type, model); } else if (!model.FromSystem) { this.transferObjects.Add(model); this.ReadClass(type, model, caller); } if (model.Name == nameof(Nullable)) { model.IsNullable = true; } return(model); }