feat: Refactor mapping interfaces and classes for improved consistency and functionality

framework/src/Volo.Abp.Mapperly/Volo/Abp/Mapperly/AbpMapperlyConventionalRegistrar.cs

@@ -9,7 +9,7 @@ public class AbpMapperlyConventionalRegistrar : DefaultConventionalRegistrar
 {
     protected override bool IsConventionalRegistrationDisabled(Type type)
     {
-        return !type.GetInterfaces().Any(x => x.IsGenericType && typeof(IAbpMapperly<,>) == x.GetGenericTypeDefinition()) ||
+        return !type.GetInterfaces().Any(x => x.IsGenericType && typeof(IAbpMapperlyMapper<,>) == x.GetGenericTypeDefinition()) ||
                base.IsConventionalRegistrationDisabled(type);
     }
 
@@ -17,8 +17,8 @@ public class AbpMapperlyConventionalRegistrar : DefaultConventionalRegistrar
     {
         var exposedServiceTypes = base.GetExposedServiceTypes(type);
         var mapperlyInterfaces = type.GetInterfaces().Where(x =>
-            x.IsGenericType && (typeof(IAbpMapperly<,>) == x.GetGenericTypeDefinition() ||
-                                typeof(IAbpReverseMapperly<,>) == x.GetGenericTypeDefinition()));
+            x.IsGenericType && (typeof(IAbpMapperlyMapper<,>) == x.GetGenericTypeDefinition() ||
+                                typeof(IAbpReverseMapperlyMapper<,>) == x.GetGenericTypeDefinition()));
         return exposedServiceTypes
             .Union(mapperlyInterfaces)
             .Distinct()

framework/src/Volo.Abp.Mapperly/Volo/Abp/Mapperly/AbpMapperlyBase.cs → framework/src/Volo.Abp.Mapperly/Volo/Abp/Mapperly/AbpMapperlyMapperBase.cs

@@ -2,7 +2,7 @@ using Volo.Abp.DependencyInjection;
 
 namespace Volo.Abp.Mapperly;
 
-public abstract class AbpMapperlyBase<TSource, TDestination> : IAbpMapperly<TSource, TDestination>, ITransientDependency
+public abstract class AbpMapperlyMapperBase<TSource, TDestination> : IAbpMapperlyMapper<TSource, TDestination>, ITransientDependency
 {
     public abstract TDestination Map(TSource source);
 
@@ -16,7 +16,7 @@ public abstract class AbpMapperlyBase<TSource, TDestination> : IAbpMapperly<TSou
     }
 }
 
-public abstract class AbpReverseMapperlyBase<TDestination, TSource> : AbpMapperlyBase<TSource, TDestination>, IAbpReverseMapperly<TDestination, TSource>
+public abstract class AbpReverseMapperlyMapperBase<TDestination, TSource> : AbpMapperlyMapperBase<TSource, TDestination>, IAbpReverseMapperlyMapper<TDestination, TSource>
 {
     public abstract TSource ReverseMap(TDestination destination);
 

framework/src/Volo.Abp.Mapperly/Volo/Abp/Mapperly/IAbpMapperly.cs → framework/src/Volo.Abp.Mapperly/Volo/Abp/Mapperly/IAbpMapperlyMapper.cs

@@ -1,6 +1,6 @@
 namespace Volo.Abp.Mapperly;
 
-public interface IAbpMapperly<in TSource, TDestination>
+public interface IAbpMapperlyMapper<in TSource, TDestination>
 {
     TDestination Map(TSource source);
 
@@ -11,7 +11,7 @@ public interface IAbpMapperly<in TSource, TDestination>
     void AfterMap(TSource source, TDestination destination);
 }
 
-public interface IAbpReverseMapperly<TDestination, TSource> : IAbpMapperly<TSource, TDestination>
+public interface IAbpReverseMapperlyMapper<TDestination, TSource> : IAbpMapperlyMapper<TSource, TDestination>
 {
     TSource ReverseMap(TDestination destination);
 

framework/src/Volo.Abp.Mapperly/Volo/Abp/Mapperly/MapperlyAutoObjectMappingProvider.cs

@@ -28,7 +28,7 @@ public class MapperlyAutoObjectMappingProvider : IAutoObjectMappingProvider
 
     public virtual TDestination Map<TSource, TDestination>(object source)
     {
-        var mapper = ServiceProvider.GetService<IAbpMapperly<TSource, TDestination>>();
+        var mapper = ServiceProvider.GetService<IAbpMapperlyMapper<TSource, TDestination>>();
         if (mapper != null)
         {
             mapper.BeforeMap((TSource)source);
@@ -38,23 +38,23 @@ public class MapperlyAutoObjectMappingProvider : IAutoObjectMappingProvider
             return destination;
         }
 
-        var reverseMapper = ServiceProvider.GetService<IAbpReverseMapperly<TSource, TDestination>>();
+        var reverseMapper = ServiceProvider.GetService<IAbpReverseMapperlyMapper<TSource, TDestination>>();
         if (reverseMapper != null)
         {
             reverseMapper.BeforeReverseMap((TSource)source);
             var destination = reverseMapper.ReverseMap((TSource)source);
-            TryMapExtraProperties(reverseMapper.As<IAbpMapperly<TDestination, TSource>>(),  destination, (TSource)source, GetExtraProperties(destination));
+            TryMapExtraProperties(reverseMapper.As<IAbpMapperlyMapper<TDestination, TSource>>(),  destination, (TSource)source, GetExtraProperties(destination));
             reverseMapper.AfterReverseMap((TSource)source, destination);
             return destination;
         }
 
-        throw new AbpException($"No {TypeHelper.GetFullNameHandlingNullableAndGenerics(typeof(IAbpMapperly<TSource, TDestination>))} or" +
-                               $" {TypeHelper.GetFullNameHandlingNullableAndGenerics(typeof(IAbpReverseMapperly<TSource, TDestination>))} was found");
+        throw new AbpException($"No {TypeHelper.GetFullNameHandlingNullableAndGenerics(typeof(IAbpMapperlyMapper<TSource, TDestination>))} or" +
+                               $" {TypeHelper.GetFullNameHandlingNullableAndGenerics(typeof(IAbpReverseMapperlyMapper<TSource, TDestination>))} was found");
     }
 
     public virtual TDestination Map<TSource, TDestination>(TSource source, TDestination destination)
     {
-        var mapper = ServiceProvider.GetService<IAbpMapperly<TSource, TDestination>>();
+        var mapper = ServiceProvider.GetService<IAbpMapperlyMapper<TSource, TDestination>>();
         if (mapper != null)
         {
             mapper.BeforeMap(source);
@@ -65,19 +65,19 @@ public class MapperlyAutoObjectMappingProvider : IAutoObjectMappingProvider
             return destination;
         }
 
-        var reverseMapper = ServiceProvider.GetService<IAbpReverseMapperly<TSource, TDestination>>();
+        var reverseMapper = ServiceProvider.GetService<IAbpReverseMapperlyMapper<TSource, TDestination>>();
         if (reverseMapper != null)
         {
             reverseMapper.BeforeReverseMap(source);
             var destinationExtraProperties = GetExtraProperties(destination);
             reverseMapper.ReverseMap(source, destination);
-            TryMapExtraProperties(reverseMapper.As<IAbpReverseMapperly<TDestination, TSource>>(), source, destination, destinationExtraProperties);
+            TryMapExtraProperties(reverseMapper.As<IAbpReverseMapperlyMapper<TDestination, TSource>>(), source, destination, destinationExtraProperties);
             reverseMapper.AfterReverseMap(source, destination);
             return destination;
         }
 
-        throw new AbpException($"No {TypeHelper.GetFullNameHandlingNullableAndGenerics(typeof(IAbpMapperly<TSource, TDestination>))} or" +
-                               $" {TypeHelper.GetFullNameHandlingNullableAndGenerics(typeof(IAbpReverseMapperly<TSource, TDestination>))} was found");
+        throw new AbpException($"No {TypeHelper.GetFullNameHandlingNullableAndGenerics(typeof(IAbpMapperlyMapper<TSource, TDestination>))} or" +
+                               $" {TypeHelper.GetFullNameHandlingNullableAndGenerics(typeof(IAbpReverseMapperlyMapper<TSource, TDestination>))} was found");
     }
 
     protected virtual ExtraPropertyDictionary GetExtraProperties<TDestination>(TDestination destination)
@@ -95,7 +95,7 @@ public class MapperlyAutoObjectMappingProvider : IAutoObjectMappingProvider
         return extraProperties;
     }
 
-    protected virtual void TryMapExtraProperties<TSource, TDestination>(IAbpMapperly<TSource, TDestination> mapper, TSource source, TDestination destination, ExtraPropertyDictionary destinationExtraProperty)
+    protected virtual void TryMapExtraProperties<TSource, TDestination>(IAbpMapperlyMapper<TSource, TDestination> mapper, TSource source, TDestination destination, ExtraPropertyDictionary destinationExtraProperty)
     {
         var mapToRegularPropertiesAttribute = mapper.GetType().GetSingleAttributeOrNull<MapExtraPropertiesAttribute>();
         if (mapToRegularPropertiesAttribute != null &&

framework/test/Volo.Abp.Mapperly.Tests/Volo/Abp/Mapperly/AbpMapperlyBeforeAndAfterMethod_Tests.cs

@@ -22,7 +22,7 @@ public class MyClassDto
 }
 
 [Mapper]
-public partial class MyClassMapper : AbpMapperlyBase<MyClass, MyClassDto>
+public partial class MyClassMapper : AbpMapperlyMapperBase<MyClass, MyClassDto>
 {
     public override partial MyClassDto Map(MyClass source);
 

framework/test/Volo.Abp.Mapperly.Tests/Volo/Abp/Mapperly/AbpMapperlyModule_Basic_Tests.cs

@@ -53,8 +53,8 @@ public class AbpMapperlyModule_Basic_Tests : AbpIntegratedTest<MapperlyTestModul
     {
         var exception = Assert.Throws<AbpException>(() =>_objectMapper.Map<MyEntity, MyClassDto>(new MyEntity()));
         exception.Message.ShouldBe("No " +
-                                   "Volo.Abp.Mapperly.IAbpMapperly<Volo.Abp.Mapperly.SampleClasses.MyEntity,Volo.Abp.Mapperly.MyClassDto> or " +
-                                   "Volo.Abp.Mapperly.IAbpReverseMapperly<Volo.Abp.Mapperly.SampleClasses.MyEntity,Volo.Abp.Mapperly.MyClassDto>" +
+                                   "Volo.Abp.Mapperly.IAbpMapperlyMapper<Volo.Abp.Mapperly.SampleClasses.MyEntity,Volo.Abp.Mapperly.MyClassDto> or " +
+                                   "Volo.Abp.Mapperly.IAbpReverseMapperlyMapper<Volo.Abp.Mapperly.SampleClasses.MyEntity,Volo.Abp.Mapperly.MyClassDto>" +
                                    " was found");
     }
 }

framework/test/Volo.Abp.Mapperly.Tests/Volo/Abp/Mapperly/AbpMapperly_Dependency_Injection_Tests.cs

@@ -28,7 +28,7 @@ public class BirthdayCalculatorService : ITransientDependency
 }
 
 [Mapper]
-public partial class MyDIClassMapper : AbpMapperlyBase<MyDIClass, MyDIClassDto>
+public partial class MyDIClassMapper : AbpMapperlyMapperBase<MyDIClass, MyDIClassDto>
 {
     private readonly BirthdayCalculatorService _birthdayCalculatorService;
 

framework/test/Volo.Abp.Mapperly.Tests/Volo/Abp/Mapperly/AbpReverseMapperly_Tests.cs

@@ -22,7 +22,7 @@ public class MyReverseClassDto
 }
 
 [Mapper]
-public partial class MyReverseClassMapper : AbpReverseMapperlyBase<MyReverseClassDto, MyReverseClass>
+public partial class MyReverseClassMapper : AbpReverseMapperlyMapperBase<MyReverseClassDto, MyReverseClass>
 {
     public override partial MyReverseClassDto Map(MyReverseClass source);
 

framework/test/Volo.Abp.Mapperly.Tests/Volo/Abp/Mapperly/SampleClasses/MapperlyMappers.cs

@@ -4,7 +4,7 @@ using Volo.Abp.Mapperly.SampleClasses;
 using Volo.Abp.ObjectExtending.TestObjects;
 
 [Mapper]
-public partial class MyEntityMapper : AbpMapperlyBase<MyEntity, MyEntityDto>
+public partial class MyEntityMapper : AbpMapperlyMapperBase<MyEntity, MyEntityDto>
 {
     public override partial MyEntityDto Map(MyEntity source);
 
@@ -12,7 +12,7 @@ public partial class MyEntityMapper : AbpMapperlyBase<MyEntity, MyEntityDto>
 }
 
 [Mapper]
-public partial class MyEnumMapper : AbpMapperlyBase<MyEnum, MyEnumDto>
+public partial class MyEnumMapper : AbpMapperlyMapperBase<MyEnum, MyEnumDto>
 {
     public override partial MyEnumDto Map(MyEnum source);
 
@@ -24,7 +24,7 @@ public partial class MyEnumMapper : AbpMapperlyBase<MyEnum, MyEnumDto>
 
 [Mapper]
 [MapExtraProperties(IgnoredProperties = ["CityName"])]
-public partial class ExtensibleTestPersonMapper : AbpMapperlyBase<ExtensibleTestPerson, ExtensibleTestPersonDto>
+public partial class ExtensibleTestPersonMapper : AbpMapperlyMapperBase<ExtensibleTestPerson, ExtensibleTestPersonDto>
 {
     public override partial ExtensibleTestPersonDto Map(ExtensibleTestPerson source);
 
@@ -33,7 +33,7 @@ public partial class ExtensibleTestPersonMapper : AbpMapperlyBase<ExtensibleTest
 
 [Mapper]
 [MapExtraProperties(MapToRegularProperties = true)]
-public partial class ExtensibleTestPersonWithRegularPropertiesDtoMapper : AbpMapperlyBase<ExtensibleTestPerson, ExtensibleTestPersonWithRegularPropertiesDto>
+public partial class ExtensibleTestPersonWithRegularPropertiesDtoMapper : AbpMapperlyMapperBase<ExtensibleTestPerson, ExtensibleTestPersonWithRegularPropertiesDto>
 {
     [MapperIgnoreTarget(nameof(ExtensibleTestPersonWithRegularPropertiesDto.Name))]
     [MapperIgnoreTarget(nameof(ExtensibleTestPersonWithRegularPropertiesDto.Age))]