Merge pull request #17 from Adexandria/feature/add-ignore-configuration

Feature/add ignore configuration

Automapify.Client/MappingService.cs

@@ -18,7 +18,7 @@ public static MapifyConfiguration StudentConfig()
                 .Map(d => d.DOB, s => s.DateOfBirth)
                 .Map(d => d.IsDeleted, s => false)
                 .Map(d => d.Teachers.MapTo(s => s.Name), s => s.Teachers.MapFrom(p => $"{p.FirstName} {p.LastName}"))
-                .Map(d => d.TeacherNames, s => s.Teachers.MapFrom(p => $"{p.FirstName} {p.LastName}"))
+                .Ignore(d=>d.TeacherNames)
                 .Map(d => d.Classrooms, s => s.Classrooms)
                 .CreateConfig();
         }

Automapify.Client/Models/Dtos/StudentDto.cs

@@ -5,9 +5,11 @@ namespace Automapify.Client.Models.Dtos
 {
     public class StudentDto
     {
+        [Ignore]
         public int Id { get; set; }
         public string Name { get; set; }
         public int Age { get; set; }
+
         public DateTime DOB { get; set; }
         public bool IsDeleted { get; set; }
 

Automapify.Client/Models/Student.cs

@@ -1,4 +1,5 @@
 using Automapify.Client.Models.Dtos;
+using Automapify.Services.Attributes;
 using System;
 using System.Collections.Generic;
 using System.Linq;

Automapify.Client/Program.cs

@@ -68,8 +68,8 @@
 
     item.DisplayAge();
 }
-/*
-var config = DefaultConfig.Instance
+
+/*var config = DefaultConfig.Instance
     .AddJob(Job
          .MediumRun
          .WithLaunchCount(1)

Automapify.Test/MapperTests.cs

@@ -1,3 +1,4 @@
+using Automapify.Services;
 using Automapify.Test.Models;
 using Automappify.Services;
 
@@ -203,5 +204,44 @@ public void ShouldMapFromSourceObjectToExistingObjectUsingConfiguration()
                 Assert.That(TestClassroom.Courses.Select(s => s.LeadLecturer.Name).Single(), Is.EqualTo(classroomDto.LeadLecturers.Single()));
             });
         }
+
+        [Test]
+        public void ShouldMapFromSourceObjectToExistingObjectWithIgnoreAttributes()
+        {
+            var studentClassroomDto = new StudentClassroomDto();
+
+            studentClassroomDto.Map(TestClassroom);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(string.IsNullOrEmpty(studentClassroomDto.Name));
+                Assert.That(TestClassroom.NumberOfStudents, Is.EqualTo(studentClassroomDto.NoOfStudents));
+                Assert.That(TestClassroom.NumberOfTeachers, Is.EqualTo(studentClassroomDto.NoOfLecturers));
+                Assert.IsTrue(string.IsNullOrEmpty(studentClassroomDto.Code));
+            });
+        }
+
+        [Test]
+        public void ShouldMapFromSourceObjectToExistingObjectWithIgnoreConfiguration()
+        {
+            var studentClassroomDto = new StudentClassroomDto();
+
+            var testHelper = new TestHelper();
+
+            studentClassroomDto.Map(TestClassroom,testHelper.SetupIgnoreConfiguration());
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(string.IsNullOrEmpty(studentClassroomDto.Name));
+                Assert.That(TestClassroom.NumberOfStudents, Is.EqualTo(studentClassroomDto.NoOfStudents));
+                Assert.That(TestClassroom.NumberOfTeachers, Is.EqualTo(studentClassroomDto.NoOfLecturers));
+                Assert.IsTrue(string.IsNullOrEmpty(studentClassroomDto.Code));
+                Assert.That(studentClassroomDto.IsActive, Is.True);
+                Assert.That(TestClassroom.Courses.Select(s => s.LeadLecturer.Name).Single(), Is.EqualTo(studentClassroomDto.LeadLecturers.Single()));
+            });
+        }
+
+
+
     }
 }

Automapify.Test/Models/StudentClassroomDto.cs

@@ -0,0 +1,29 @@
+using Automapify.Services.Attributes;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using IgnoreAttribute = Automapify.Services.Attributes.IgnoreAttribute;
+
+namespace Automapify.Test.Models
+{
+    public class StudentClassroomDto
+    {
+        [Ignore]
+        public string Name { get; set; }
+
+        [MapProperty("NumberOfStudents")]
+        public int NoOfStudents { get; set; }
+
+        public bool IsActive { get; set; }
+
+        [MapProperty("NumberOfTeachers")]
+        public int NoOfLecturers { get; set; }
+
+        [Ignore]
+        public string Code { get; set; }
+
+        public List<string> LeadLecturers { get; set; }
+    }
+}

Automapify.Test/TestHelper.cs

@@ -41,6 +41,19 @@ private MapifyConfiguration SetupConfiguration()
                 .CreateConfig();
             return MapifyConfiguration;
         }
+
+        public MapifyConfiguration SetupIgnoreConfiguration()
+        {
+            MapifyConfiguration = new MapifyConfigurationBuilder<Classroom, ClassroomDto>()
+                .Ignore(d=>d.Name)
+                .Map(d => d.NoOfLecturers, s => s.NumberOfTeachers)
+                .Map(d => d.NoOfStudents, s => s.NumberOfStudents)
+                .Map(d => d.LeadLecturers, s => s.Courses.MapFrom(s => s.LeadLecturer.Name))
+                .Map(d => d.IsActive, s => s.NumberOfTeachers > 0 && s.NumberOfStudents > 0)
+                .Ignore(d=>d.Code)
+                .CreateConfig();
+            return MapifyConfiguration;
+        }
         protected MapifyConfiguration MapifyConfiguration { get; set; }
         protected Classroom TestClassroom { get; set; }
 

Automapify/Automapify.csproj

@@ -9,5 +9,6 @@
     <RepositoryUrl>https://github.com/Adeola-Aderibigbe/AutoMapify_Lib</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
     <PackageTags>.net 6.0, mapping</PackageTags>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
   </PropertyGroup>
 </Project>

Automapify/Models/MapifyTuple.cs

@@ -17,10 +17,22 @@ public MapifyTuple(string destinationMember, string sourceName, LambdaExpression
             SourceExpression = sourceExpression.Compile();
         }
 
+        public MapifyTuple(List<string> destinationMembers)
+        {
+            DestinationMemberNames = destinationMembers;
+
+            IsIgnored = true;
+        }
+
+        public void Ignore()
+        {
+            IsIgnored = true;
+        }
 
         public List<string> DestinationMemberNames { get; set; } = new List<string>();
 
-        public string SourceMemberName { get; set; }
+        public string SourceMemberName { get; set; } = string.Empty;
         public Delegate SourceExpression { get; set; }
+        public bool IsIgnored { get; set; } = false;
     }
 }

Automapify/Services/MapifyConfigurationBuilder.cs

@@ -23,6 +23,25 @@ public MapifyConfigurationBuilder<TSource, TDestination> Map<DestinationMember,
             return this;
         }
 
+
+
+        /// <summary>
+        /// Ignores property
+        /// </summary>
+        /// <typeparam name="DestinationMember"> destination member type</typeparam>
+        /// <param name="destinationPredicate">Destination expression</param>
+        /// <returns></returns>
+        public MapifyConfigurationBuilder<TSource,TDestination> Ignore<DestinationMember>
+            (Expression<Func<TDestination, DestinationMember>> destinationPredicate)
+        {
+            var members = GetMemberExpressionNames(destinationPredicate);
+
+            mapifyTuples.Add(new MapifyTuple(members));
+
+            return this;
+        }
+
+
         /// <summary>
         /// Get expression names from member
         /// </summary>
@@ -31,7 +50,7 @@ public MapifyConfigurationBuilder<TSource, TDestination> Map<DestinationMember,
         /// <param name="desExp">Expression</param>
         /// <returns>Names of the member</returns>
         private void CreateTuple<DestinationMember, SourceMember>
-            (Expression<Func<TDestination, DestinationMember>> destinationPredicate, Expression<Func<TSource, SourceMember>> sourcePredicate)
+            (Expression<Func<TDestination, DestinationMember>> destinationPredicate, Expression<Func<TSource, SourceMember>> sourcePredicate, bool isIgnored = false)
         {
             MemberExpression memberExpression = destinationPredicate.Body as MemberExpression;
 
@@ -41,24 +60,32 @@ private void CreateTuple<DestinationMember, SourceMember>
 
             var sourceName = GetSourceMemberExpressionName(sourcePredicate);
 
+            MapifyTuple mapifyTuple = null;
+
             if (currentMemberExpression != null)
             {
                 if (sourcePredicate.Body is MethodCallExpression sourceExpression)
                 {
                     newSourceExpression = sourcePredicate.Compile().Invoke(Activator.CreateInstance<TSource>()) as LambdaExpression;
                 }
-                mapifyTuples.Add(new MapifyTuple(currentMemberExpression?.Member?.Name, sourceName, newSourceExpression ?? sourcePredicate));
+                mapifyTuple = new MapifyTuple(currentMemberExpression?.Member?.Name, sourceName, newSourceExpression ?? sourcePredicate);
             }
             else
             {
                 var destinationName = GetMemberExpressionNames(destinationPredicate);
 
                 newSourceExpression = sourcePredicate.Compile().Invoke(Activator.CreateInstance<TSource>()) as LambdaExpression;
 
-                mapifyTuples.Add(new MapifyTuple(destinationName, sourceName, newSourceExpression));
+                mapifyTuple = new MapifyTuple(destinationName, sourceName, newSourceExpression);
             }
-        }
 
+            if (isIgnored)
+            {
+                mapifyTuple.Ignore();
+            }
+
+            mapifyTuples.Add(mapifyTuple);
+        }
 
         /// <summary>
         /// Get expression names from member

Automapify/Services/Mapper.cs

@@ -113,6 +113,15 @@ public static TDestination Map<TSource, TDestination>(this TSource sourceObj, Ma
             }
         }
 
+        /// <summary>
+        /// Handles mapping for collection
+        /// </summary>
+        /// <typeparam name="TSource">Type of the source</typeparam>
+        /// <param name="sourceObj">Source object</param>
+        /// <param name="destinationObj">Destination object</param>
+        /// <param name="destinationType">Destination type</param>
+        /// <param name="sourceType">Source Type</param>
+        /// <param name="mapifyConfiguration">Mapify configuration</param>
         private static void MapCollection<TSource>(TSource sourceObj, IList destinationObj ,Type destinationType,
             Type sourceType,
             MapifyConfiguration mapifyConfiguration = null)
@@ -156,17 +165,26 @@ private static void MapCollection<TSource>(TSource sourceObj, IList destinationO
             }
         }
 
+        /// <summary>
+        /// Maps system collection
+        /// </summary>
+        /// <param name="sourceObj">Source object</param>
+        /// <param name="destination">Destination object</param>
+        /// <param name="destinationName">Destination name</param>
+        /// <param name="mapifyConfiguration">Mapify configuration</param>
 
         private static void MapCollection(object? sourceObj, IList destination,string destinationName,
             MapifyConfiguration mapifyConfiguration = null)
         {
-             var propertyExpression = GetSourceExpression(mapifyConfiguration?.MapifyTuples, destinationName);
              if( sourceObj is ICollection sourceCollection)
              {
-                foreach(var source in sourceCollection)
+                var propertyExpression = GetSourceExpression(mapifyConfiguration?.MapifyTuples, destinationName);
+                foreach (var source in sourceCollection)
                 {
                     var result = propertyExpression?.DynamicInvoke(source);
-                    destination.Add(result);
+
+                    if (result != null)
+                        destination.Add(result);
                 }
              }
         }
@@ -179,6 +197,16 @@ private static void MapProperties<TSource,TDestination>(PropertyInfo[] destinati
             {
                 object propertyValue = null;
 
+                if (destinationProperty.GetCustomAttribute<IgnoreAttribute>() != null)
+                    continue;
+
+                var isIgnored = mapifyConfiguration?.MapifyTuples.Where(s => s.IsIgnored && s.DestinationMemberNames.Contains(destinationProperty.Name)).Select(s => s.IsIgnored).FirstOrDefault();
+                if (isIgnored.GetValueOrDefault())
+                {
+                    continue;
+                }
+
+
                 if (destinationProperty.PropertyType.GetGenericArguments().FirstOrDefault() is Type type && mapifyConfiguration != null)
                 {
                     Type openType = typeof(List<>);
@@ -212,7 +240,6 @@ private static void MapProperties<TSource,TDestination>(PropertyInfo[] destinati
                 else if (GetSourceExpression(mapifyConfiguration?.MapifyTuples, destinationProperty.Name) is Delegate propertyExpression)
                 {
                     propertyValue = propertyExpression?.DynamicInvoke(sourceObj);
-
                 }
                 else
                 {
@@ -254,8 +281,10 @@ private static PropertyInfo GetProperyInfo<TSource>(Dictionary<string, MapProper
         private static Delegate GetSourceExpression(IList<MapifyTuple> mapifyTuples, string propertyName)
         {
             if (mapifyTuples == null)
+            {
                 return default;
-
+            }
+
             MapifyTuple mapifyTuple = mapifyTuples.Where(s => s.DestinationMemberNames.Contains(propertyName)).FirstOrDefault();
             if(mapifyTuple != null)
             {
@@ -267,6 +296,7 @@ private static Delegate GetSourceExpression(IList<MapifyTuple> mapifyTuples, str
 
         private static MapifyConfiguration GetSourceConfiguration(IList<MapifyTuple> mapifyTuples,string sourcePropertyName, PropertyInfo[] properties)
         {
+
             if (mapifyTuples == null)
                 return default;
 
@@ -275,7 +305,6 @@ private static MapifyConfiguration GetSourceConfiguration(IList<MapifyTuple> map
             {
                 return new MapifyConfiguration(newMapifyTuples);
             }
-
             return default;
         }