15072048022

Committed 16 May 2025 03:31PM UTC coverage: 55.392% (-1.4%) from 56.772%

Build # 15072048022

Build Type

push

github

Committed by

pwelter34

Commit Message

enable nullable support

Run Details

616 of 1271 branches covered (48.47%)

Branch coverage included in aggregate %.

233 of 397 new or added lines in 61 files covered. (58.69%)

17 existing lines in 11 files now uncovered.

1824 of 3134 relevant lines covered (58.2%)

88.56 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/EntityFrameworkCore.Generator.Core/Templates/MapperClassTemplate.cs

using System.Collections.Generic;

using EntityFrameworkCore.Generator.Extensions;
using EntityFrameworkCore.Generator.Metadata.Generation;
using EntityFrameworkCore.Generator.Options;

namespace EntityFrameworkCore.Generator.Templates;

public class MapperClassTemplate : CodeTemplateBase
{
    private readonly Entity _entity;

    public MapperClassTemplate(Entity entity, GeneratorOptions options) : base(options)
    {
        _entity = entity;
    }

    public override string WriteCode()
    {
        CodeBuilder.Clear();

        CodeBuilder.AppendLine("using System;");
        CodeBuilder.AppendLine("using AutoMapper;");

        var imports = new SortedSet<string>
        {
            _entity.EntityNamespace
        };

        foreach (var model in _entity.Models)
            imports.Add(model.ModelNamespace);

        foreach (var import in imports)
        {
            if (_entity.MapperNamespace != import)
                CodeBuilder.AppendLine($"using {import};");
        }

        CodeBuilder.AppendLine();

        CodeBuilder.Append($"namespace {_entity.MapperNamespace}");

        if (Options.Project.FileScopedNamespace)
        {
            CodeBuilder.AppendLine(";");
            CodeBuilder.AppendLine();
            GenerateClass();
        }
        else
        {
            CodeBuilder.AppendLine();
            CodeBuilder.AppendLine("{");

            using (CodeBuilder.Indent())
            {
                GenerateClass();
            }

            CodeBuilder.AppendLine("}");
        }

        return CodeBuilder.ToString();
    }

    private void GenerateClass()
    {
        var entityClass = _entity.EntityClass.ToSafeName();
        var mapperClass = _entity.MapperClass.ToSafeName();

        if (Options.Model.Mapper.Document)
        {
            CodeBuilder.AppendLine("/// <summary>");
            CodeBuilder.AppendLine($"/// Mapper class for entity <see cref=\"{entityClass}\"/> .");
            CodeBuilder.AppendLine("/// </summary>");
        }
        if (Options.Model.Mapper.Attributes.HasValue())
        {
            CodeBuilder.AppendLine(Options.Model.Mapper.Attributes);
        }
        CodeBuilder.AppendLine($"public partial class {mapperClass}");

        if (_entity.MapperBaseClass.HasValue())
        {
            var mapperBaseClass = _entity.MapperBaseClass.ToSafeName();
            using (CodeBuilder.Indent())
                CodeBuilder.AppendLine($": {mapperBaseClass}");
        }

        CodeBuilder.AppendLine("{");

        using (CodeBuilder.Indent())
        {
            GenerateConstructor();
        }

        CodeBuilder.AppendLine("}");
    }

    private void GenerateConstructor()
    {
        var mapperClass = _entity.MapperClass.ToSafeName();

        var entityClass = _entity.EntityClass.ToSafeName();
        var entityFullName = $"{_entity.EntityNamespace}.{entityClass}";

        if (Options.Model.Mapper.Document)
        {
            CodeBuilder.AppendLine("/// <summary>");
            CodeBuilder.AppendLine($"/// Initializes a new instance of the <see cref=\"{mapperClass}\"/> class.");
            CodeBuilder.AppendLine("/// </summary>");
        }

        CodeBuilder.AppendLine($"public {mapperClass}()");
        CodeBuilder.AppendLine("{");

        string? readFullName = null;
        string? updateFullName = null;

        using (CodeBuilder.Indent())
        {
            foreach (var model in _entity.Models)
            {
                var modelClass = model.ModelClass.ToSafeName();
                var modelFullName = $"{model.ModelNamespace}.{modelClass}";

                switch (model.ModelType)
                {
                    case ModelType.Read:
                        readFullName = modelFullName;
                        CodeBuilder.AppendLine($"CreateMap<{entityFullName}, {modelFullName}>();").AppendLine();
                        break;
                    case ModelType.Create:
                        CodeBuilder.AppendLine($"CreateMap<{modelFullName}, {entityFullName}>();").AppendLine();
                        CodeBuilder.AppendLine($"CreateMap<{entityFullName}, {modelFullName}>();").AppendLine();
                        break;
                    case ModelType.Update:
                        updateFullName = modelFullName;
                        CodeBuilder.AppendLine($"CreateMap<{entityFullName}, {modelFullName}>();").AppendLine();
                        CodeBuilder.AppendLine($"CreateMap<{modelFullName}, {entityFullName}>();").AppendLine();
                        break;
                }
            }

            // include support for coping read model to update model
            if (readFullName.HasValue() && updateFullName.HasValue())
                CodeBuilder.AppendLine($"CreateMap<{readFullName}, {updateFullName}>();").AppendLine();

        }

        CodeBuilder.AppendLine("}");
        CodeBuilder.AppendLine();
    }

}

1	using System.Collections.Generic;
2
3	using EntityFrameworkCore.Generator.Extensions;
4	using EntityFrameworkCore.Generator.Metadata.Generation;
5	using EntityFrameworkCore.Generator.Options;
6
7	namespace EntityFrameworkCore.Generator.Templates;
8
9	public class MapperClassTemplate : CodeTemplateBase
10	{
11	private readonly Entity _entity;
12
13	public MapperClassTemplate(Entity entity, GeneratorOptions options) : base(options)	×
14	{
15	_entity = entity;	×
16	}	×
17
18	public override string WriteCode()
19	{
20	CodeBuilder.Clear();	×
21
22	CodeBuilder.AppendLine("using System;");	×
23	CodeBuilder.AppendLine("using AutoMapper;");	×
24
NEW 25	var imports = new SortedSet<string>	×
NEW 26	{	×
NEW 27	_entity.EntityNamespace	×
NEW 28	};	×
29
30	foreach (var model in _entity.Models)	×
31	imports.Add(model.ModelNamespace);	×
32
33	foreach (var import in imports)	×
34	{
35	if (_entity.MapperNamespace != import)	×
36	CodeBuilder.AppendLine($"using {import};");	×
37	}
38
39	CodeBuilder.AppendLine();	×
40
41	CodeBuilder.Append($"namespace {_entity.MapperNamespace}");	×
42
43	if (Options.Project.FileScopedNamespace)	×
44	{
45	CodeBuilder.AppendLine(";");	×
46	CodeBuilder.AppendLine();	×
47	GenerateClass();	×
48	}
49	else
50	{
51	CodeBuilder.AppendLine();	×
52	CodeBuilder.AppendLine("{");	×
53
54	using (CodeBuilder.Indent())	×
55	{
56	GenerateClass();	×
57	}	×
58
59	CodeBuilder.AppendLine("}");	×
60	}
61
62	return CodeBuilder.ToString();	×
63	}
64
65	private void GenerateClass()
66	{
67	var entityClass = _entity.EntityClass.ToSafeName();	×
68	var mapperClass = _entity.MapperClass.ToSafeName();	×
69
70	if (Options.Model.Mapper.Document)	×
71	{
72	CodeBuilder.AppendLine("/// <summary>");	×
73	CodeBuilder.AppendLine($"/// Mapper class for entity <see cref=\"{entityClass}\"/> .");	×
74	CodeBuilder.AppendLine("/// </summary>");	×
75	}
76	if (Options.Model.Mapper.Attributes.HasValue())	×
77	{
78	CodeBuilder.AppendLine(Options.Model.Mapper.Attributes);	×
79	}
80	CodeBuilder.AppendLine($"public partial class {mapperClass}");	×
81
82	if (_entity.MapperBaseClass.HasValue())	×
83	{
84	var mapperBaseClass = _entity.MapperBaseClass.ToSafeName();	×
85	using (CodeBuilder.Indent())	×
86	CodeBuilder.AppendLine($": {mapperBaseClass}");	×
87	}
88
89	CodeBuilder.AppendLine("{");	×
90
91	using (CodeBuilder.Indent())	×
92	{
93	GenerateConstructor();	×
94	}	×
95
96	CodeBuilder.AppendLine("}");	×
97	}	×
98
99	private void GenerateConstructor()
100	{
101	var mapperClass = _entity.MapperClass.ToSafeName();	×
102
103	var entityClass = _entity.EntityClass.ToSafeName();	×
104	var entityFullName = $"{_entity.EntityNamespace}.{entityClass}";	×
105
106	if (Options.Model.Mapper.Document)	×
107	{
108	CodeBuilder.AppendLine("/// <summary>");	×
109	CodeBuilder.AppendLine($"/// Initializes a new instance of the <see cref=\"{mapperClass}\"/> class.");	×
110	CodeBuilder.AppendLine("/// </summary>");	×
111	}
112
113	CodeBuilder.AppendLine($"public {mapperClass}()");	×
114	CodeBuilder.AppendLine("{");	×
115
NEW 116	string? readFullName = null;	×
NEW 117	string? updateFullName = null;	×
118
119	using (CodeBuilder.Indent())	×
120	{
121	foreach (var model in _entity.Models)	×
122	{
123	var modelClass = model.ModelClass.ToSafeName();	×
124	var modelFullName = $"{model.ModelNamespace}.{modelClass}";	×
125
126	switch (model.ModelType)	×
127	{
128	case ModelType.Read:
129	readFullName = modelFullName;	×
130	CodeBuilder.AppendLine($"CreateMap<{entityFullName}, {modelFullName}>();").AppendLine();	×
131	break;	×
132	case ModelType.Create:
133	CodeBuilder.AppendLine($"CreateMap<{modelFullName}, {entityFullName}>();").AppendLine();	×
134	CodeBuilder.AppendLine($"CreateMap<{entityFullName}, {modelFullName}>();").AppendLine();	×
135	break;	×
136	case ModelType.Update:
137	updateFullName = modelFullName;	×
138	CodeBuilder.AppendLine($"CreateMap<{entityFullName}, {modelFullName}>();").AppendLine();	×
139	CodeBuilder.AppendLine($"CreateMap<{modelFullName}, {entityFullName}>();").AppendLine();	×
140	break;
141	}
142	}
143
144	// include support for coping read model to update model
145	if (readFullName.HasValue() && updateFullName.HasValue())	×
146	CodeBuilder.AppendLine($"CreateMap<{readFullName}, {updateFullName}>();").AppendLine();	×
147
148	}	×
149
150	CodeBuilder.AppendLine("}");	×
151	CodeBuilder.AppendLine();	×
152	}	×
153
154	}

loresoft / EntityFrameworkCore.Generator / 15072048022

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous