private XElement Convert(Base.Models.Entity.Entity entity, IClassAttribute attribute)
 {
     return(new XElement(HbmNamespace + "property",
                         new XAttribute("name", attribute.Name),
                         new XAttribute("column", _namingConvention.GetColumnName(attribute.Name))
                         ));
 }
        public void Test_entity_conversion_to_generated_class_output_model()
        {
            var ns             = new Namespace("MyApp.MyTest", null);
            var entity         = new Base.Models.Entity.Entity("MyClass", ns);
            var targetPlatform = new TargetPlatform("test");

            targetPlatform.RegisterClassNamingConvention(BasePluginConstants.Language_CSharp, new CSharpClassNamingConvention());

            entity.AddAttribute(new EntityAttribute("Id", TestDataTypes.Int, null, null));
            entity.AddAttribute(new EntityAttribute("Name", TestDataTypes.String, null, null));
            entity.OutputConfiguration.RegisterOutputFolder(new Filter(EntityPluginConstants.OutputModelType_Entity_GeneratedClass), new ProjectFolder(""));
            entity.OutputConfiguration.RegisterTargetPlatformForDesignModelType(entity.DesignModelType, targetPlatform);

            var templateCollection = new TemplateCollection();

            templateCollection.LoadTemplates(typeof(EntityPluginConstants).Assembly);

            var template = templateCollection.GetTemplate(EntityPluginConstants.OutputTemplateName_Entity_GeneratedClass);

            targetPlatform.RegisterOutputTemplate(EntityPluginConstants.OutputTemplateName_Entity_GeneratedClass, template);

            var converter      = new EntityConverter(templateCollection);
            var generatedClass = converter.CreateEntityGeneratedClass(entity, BasePluginConstants.Language_CSharp);

            generatedClass.Should().NotBeNull();
            generatedClass.ClassName.Should().Be("MyClass");
            generatedClass.ClassNamespace.Should().Be("MyApp.MyTest");

            var properties = generatedClass
                             .Properties
                             .Select(x => (name: x.Name, type: x.Type.TypeName));

            properties.Should().BeEquivalentTo(new[]
Exemple #3
0
        public ClassOutputModel CreateEntityGeneratedClass(Base.Models.Entity.Entity entity, string language)
        {
            var targetPlatform = entity.OutputConfiguration.GetTargetPlatformsForDesignModel(entity).FirstOrDefault();

            if (targetPlatform == null)
            {
                throw new ConfigurationException(
                          $"No target platforms defined for design model type '{entity.DesignModelType}'.");
            }

            var namingConvention = (IClassNamingConvention)targetPlatform.GetNamingConvention(language);
            var outputModelType  = NHibernatePluginConstants.OutputModelType_Entity_GeneratedClass;
            var builder          = new ClassOutputModelBuilder(outputModelType, entity, namingConvention);

            builder.CreatePartialClass(entity.Name, entity.Namespace);
            builder.SetOutputFile(entity.OutputConfiguration, namingConvention, fileExtension: ".gen.cs",
                                  mergeMode: OutputModelMergeMode.Replace);
            builder.SetOutputRenderer(targetPlatform.GetOutputTemplate(outputModelType));

            foreach (var entityAttribute in entity.Attributes)
            {
                builder.CreateProperty(entityAttribute.Name, namingConvention.GetTypeName(entityAttribute.Type));
            }

            return(builder.Build());
        }
        private XElement Convert(Base.Models.Entity.Entity entity)
        {
            var entityXmlElement = new XElement(HbmNamespace + "class",
                                                new XAttribute("name", entity.Name),
                                                new XAttribute("table", _namingConvention.GetTableName(entity.Name))
                                                );

            foreach (var attribute in entity.Attributes)
            {
                entityXmlElement.Add(Convert(entity, attribute));
            }

            return(entityXmlElement);
        }
Exemple #5
0
        public ClassOutputModel CreateEntityCustomClass(Base.Models.Entity.Entity entity, string language)
        {
            var targetPlatform = entity.OutputConfiguration.GetTargetPlatformsForDesignModel(entity).FirstOrDefault();

            if (targetPlatform == null)
            {
                throw new ConfigurationException($"No target platforms defined for design model type '{entity.DesignModelType}'.");
            }

            var namingConvention = targetPlatform.GetClassNamingConvention(language);
            var outputModelType  = EntityPluginConstants.OutputModelType_Entity_CustomClass;
            var builder          = new ClassOutputModelBuilder(outputModelType, entity, namingConvention);

            builder.CreatePartialClass(entity.Name, entity.Namespace);
            builder.SetOutputFile(entity.OutputConfiguration, namingConvention, fileExtension: ".cs");
            builder.SetOutputRenderer(targetPlatform.GetOutputTemplate(outputModelType));

            return(builder.Build());
        }
 public void Entity_mappings_should_be_preserved_when_copied_from_another_entity()
 {
     var entity = new Base.Models.Entity.Entity(null, null);
 }