9473957558

Committed 11 Jun 2024 11:07PM UTC coverage: 56.999% (-0.01%) from 57.012%

Build # 9473957558

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #461 from timmac-qmc/master

Allow mapping from entity to CreateModel

Run Details

563 of 1111 branches covered (50.68%)

Branch coverage included in aggregate %.

0 of 1 new or added line in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

1811 of 3054 relevant lines covered (59.3%)

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

loresoft / EntityFrameworkCore.Generator / 9473957558

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