private void CreateCoreMappings(IMapperConfigurationExpression configuration)
        {
            var localizationContext = IocManager.Resolve<ILocalizationContext>();

            configuration.CreateMap<ILocalizableString, string>().ConvertUsing(ls => ls?.Localize(localizationContext));
            configuration.CreateMap<LocalizableString, string>().ConvertUsing(ls => ls == null ? null : localizationContext.LocalizationManager.GetString(ls));
        }
        public static void LoadStandardMappings(IMapperConfigurationExpression config, IList<Type> types)
        {
            var mapsFrom = (from t in types
                            from i in GetInterfaces(t)
                            where IsGenericType(i) && i.GetGenericTypeDefinition() == typeof(IMapFrom<>) &&
                                  !IsAbstract(t) &&
                                  !IsInterface(t)
                            select new
                            {
                                Source = GetGenericArguments(i).First(),
                                Destination = t
                            }).ToArray();

            foreach (var map in mapsFrom)
            {
                config.CreateMap(map.Source, map.Destination);
            }

            var mapsTo = (from t in types
                          from i in GetInterfaces(t)
                          where IsGenericType(i) && i.GetGenericTypeDefinition() == typeof(IMapTo<>) &&
                                !IsAbstract(t) &&
                                !IsInterface(t)
                          select new
                          {
                              Source = t,
                              Destination = GetGenericArguments(i).First()
                          }).ToArray();

            foreach (var map in mapsTo)
            {
                config.CreateMap(map.Source, map.Destination);
            }

        }
Exemplo n.º 3
0
 public static void CreateMaps(IMapperConfigurationExpression cfg)
 {
     cfg.CreateMap<Instance, Domain.Instance>()
         .ForMember(d=>d.InstanceType,o=>o.MapFrom(s=>(Domain.InstanceType)s.InstanceTypeId));
     cfg.CreateMap<InstanceUser, Domain.InstanceUser>()
         .ForMember(d=>d.Level, o=>o.MapFrom(s=>(Domain.InstanceUserLevel)s.InstanceUserLevelId));
     cfg.CreateMap<UserInstance, Domain.UserInstance>()
         .ForMember(d=>d.Type,o=>o.MapFrom(s=>(Domain.InstanceType)s.Type));
 }
 private static void MapperConfigure(IMapperConfigurationExpression cfd)
 {
     cfd.CreateMap<Person, PersonInfoDto>(MemberList.Destination).ForMember(t => t.EmployeeBrithDate, t => t.MapFrom(src => src.Employee.BirthDate));
     cfd.CreateMap<EmailAddress, EmailDto>(MemberList.Destination).ForMember(t => t.EmailAddress, t => t.MapFrom(src => src.EmailAddress1));
     cfd.CreateMap<ShipMethod, ShipMethodDto>(MemberList.Destination);
     cfd.CreateMap<ProductListPriceHistory, ProductListPriceHistoryDto>(MemberList.Destination);
     cfd.CreateMap<Product, ProductDto>(MemberList.Destination);
     cfd.CreateMap<ProductModel, ProductModelDto>(MemberList.Destination);
     cfd.CreateMap<Product, Product2Dto>(MemberList.Destination);
 }
Exemplo n.º 5
0
        public static void Configure(IMapperConfigurationExpression cfg)
        {
            cfg.CreateMap<OrderDto, Order>()
                .ForMember(d => d.Name, opt => opt.MapFrom(s => s.FullName));

            cfg.CreateMap<Order, OrderDto>()
                .ForMember(d => d.FullName, opt => opt.MapFrom(s => s.Name));

            cfg.CreateMap<Customer, CustomerDto>()
                .ForMember(c => c.Orders, opt => opt.Ignore())
                .ReverseMap();
        }
Exemplo n.º 6
0
        public static void Register(IMapperConfigurationExpression cfg)
        {
            //aphorism
            cfg.CreateMap<Aphorism, VMAphorism>();
            cfg.CreateMap<VMAphorism, Aphorism>();

            //article
            cfg.CreateMap<Article, VMArticle>();
            cfg.CreateMap<VMArticle, Article>();

            //author aphorism
            cfg.CreateMap<AuthorAphorism, VMAuthorAphorism>();
            cfg.CreateMap<VMAuthorAphorism, AuthorAphorism>();

            //game
            cfg.CreateMap<Game, VMGame>();
            cfg.CreateMap<VMGame, Game>();

            //humor
            cfg.CreateMap<Humor, VMHumor>();
            cfg.CreateMap<VMHumor, Humor>();

            //material category
            cfg.CreateMap<MaterialCategory, VMMaterialCategory>();
            cfg.CreateMap<VMMaterialCategory, MaterialCategory>()
                .ForMember(d => d.ParentId, d => d.MapFrom(s => (string)s.ParentId));

            //news
            cfg.CreateMap<News, VMNews>();
            cfg.CreateMap<VMNews, News>();

            //site test
            cfg.CreateMap<SiteTest, VMSiteTest>();
            cfg.CreateMap<VMSiteTest, SiteTest>();

            //site test answer
            cfg.CreateMap<SiteTestAnswer, VMSiteTestAnswer>();
            cfg.CreateMap<VMSiteTestAnswer, SiteTestAnswer>();

            //site test question
            cfg.CreateMap<SiteTestQuestion, VMSiteTestQuestion>();
            cfg.CreateMap<VMSiteTestQuestion, SiteTestQuestion>();

            //site test setting
            cfg.CreateMap<SiteTestSetting, VMSiteTestSetting>();
            cfg.CreateMap<VMSiteTestSetting, SiteTestSetting>();

            //site test subject
            cfg.CreateMap<SiteTestSubject, VMSiteTestSubject>();
            cfg.CreateMap<VMSiteTestSubject, SiteTestSubject>();
        }
        public static void LoadCustomMappings(IMapperConfigurationExpression config, IList<Type> types)
        {
            var instancesToMap = (from t in types
                                  from i in GetInterfaces(t)
                                  where IsAssignable(t, typeof(IHaveCustomMappings)) &&
                                        !IsAbstract(t) &&
                                        !IsInterface(t)
                                  select InitializeCustomMappingObject(t)).ToArray();

            foreach (var map in instancesToMap)
            {
                map.CreateMappings(config);
            }
        }
Exemplo n.º 8
0
        private static void LoadCustomMappings(IEnumerable<Type> types, IMapperConfigurationExpression mapperConfiguration)
        {
            var maps = (from t in types
                        from i in t.GetInterfaces()
                        where typeof(IHaveCustomMappings).IsAssignableFrom(t) &&
                              !t.GetTypeInfo().IsAbstract &&
                              !t.GetTypeInfo().IsInterface
                        select (IHaveCustomMappings)Activator.CreateInstance(t)).ToArray();

            foreach (var map in maps)
            {
                map.CreateMappings(mapperConfiguration);
            }
        }
        private void FindAndAutoMapTypes(IMapperConfigurationExpression configuration)
        {
            var types = _typeFinder.Find(type =>
                    type.IsDefined(typeof(AutoMapAttribute)) ||
                    type.IsDefined(typeof(AutoMapFromAttribute)) ||
                    type.IsDefined(typeof(AutoMapToAttribute))
            );

            Logger.DebugFormat("Found {0} classes defines auto mapping attributes", types.Length);
            foreach (var type in types)
            {
                Logger.Debug(type.FullName);
                configuration.CreateAbpAttributeMaps(type);
            }
        }
Exemplo n.º 10
0
        private static void LoadStandardMappings(IEnumerable<Type> types, IMapperConfigurationExpression mapperConfiguration)
        {
            var maps = (from t in types
                        from i in t.GetInterfaces()
                        where i.GetTypeInfo().IsGenericType && i.GetGenericTypeDefinition() == typeof(IMapFrom<>) &&
                              !t.GetTypeInfo().IsAbstract &&
                              !t.GetTypeInfo().IsInterface
                        select new
                        {
                            Source = i.GetGenericArguments()[0],
                            Destination = t
                        }).ToArray();

            foreach (var map in maps)
            {
                mapperConfiguration.CreateMap(map.Source, map.Destination);
            }
        }
        private void LoadReverseMappings(IEnumerable<Type> types, IMapperConfigurationExpression mapperConfiguration)
        {
            var maps = from t in types
                       from i in t.GetInterfaces()
                       where i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IMapTo<>) &&
                             !t.IsAbstract &&
                             !t.IsInterface
                       select new
                       {
                           Destination = i.GetGenericArguments()[0],
                           Source = t
                       };

            foreach (var map in maps)
            {
                mapperConfiguration.CreateMap(map.Source, map.Destination);
            }
        }
Exemplo n.º 12
0
    public void RegisterMappings(IMapperConfigurationExpression config) {

      #region DTOs

      config.CreateMap<UpkFile, DomainUpkFile>().ForMember(dest => dest.Filename,       opt => opt.Ignore())
                                                .ForMember(dest => dest.ModdedFiles,    opt => opt.Ignore())
                                                .ForMember(dest => dest.IsModded,       opt => opt.Ignore())
                                                .ForMember(dest => dest.Header,         opt => opt.Ignore())
                                                .ForMember(dest => dest.LastAccess,     opt => opt.Ignore())
                                                .ForMember(dest => dest.GameFilename,   opt => opt.Ignore())
                                                .ForMember(dest => dest.CurrentVersion, opt => opt.Ignore())
                                                .ReverseMap();

      config.CreateMap<ExportVersion, DomainExportVersion>().ReverseMap();

      config.CreateMap<ExportType, DomainExportType>().ReverseMap();

      config.CreateMap<DomainUpkManagerException, UpkManagerException>().ForMember(dest => dest.Message,    opt => opt.MapFrom(src => src.Exception.Message))
                                                                        .ForMember(dest => dest.StackTrace, opt => opt.MapFrom(src => src.Exception.StackTrace))
                                                                        .ForMember(dest => dest.Id,         opt => opt.Ignore());

      #endregion DTOs

    }
Exemplo n.º 13
0
 public void CreateMappings(IMapperConfigurationExpression configuration)
 {
     configuration.CreateMap <Person, PersonViewModel>()
     .ForMember(vm => vm.FullName, opt => opt.MapFrom(m => $"{m.FirstName} {m.LastName}"));
 }
Exemplo n.º 14
0
 public static void Map(IMapperConfigurationExpression cfg) =>
     cfg.CreateMap<Domain.PermissionScope, PermissionScope>();
Exemplo n.º 15
0
        public static void ConfigureAppDataEntities(this IMapperConfigurationExpression mapperConfigurationExpression,
                                                    IContainerProvider containerProvider)
        {
            // Entities to view models
            mapperConfigurationExpression.CreateMap <ValidationSession, ViewModels.Main.ItemViewModel>()
            .ForMember(dest => dest.IsActive, opt => opt.Ignore())
            .ForMember(dest => dest.ItemTappedCommand, opt => opt.Ignore())
            .ForMember(dest => dest.IsChecked, opt => opt.Ignore())
            .ForMember(dest => dest.IsSelected, opt => opt.Ignore())
            .ForMember(dest => dest.ItemSelectedCommand, opt => opt.Ignore());

            mapperConfigurationExpression.CreateMap <ValidationSession, ViewModels.ValidationSessionOverview.ItemViewModel>()
            .ForMember(dest => dest.Pinned, opt => opt.Ignore())
            .ForMember(dest => dest.IsActive, opt => opt.Ignore())
            .ForMember(dest => dest.ItemTappedCommand, opt => opt.Ignore())
            .ForMember(dest => dest.IsSelected, opt => opt.Ignore())
            .ForMember(dest => dest.ItemSelectedCommand, opt => opt.Ignore());

            mapperConfigurationExpression.CreateMap <LegendItem, ItemViewModel>()
            .ForMember(dest => dest.Color, opt => opt.MapFrom(src => Color.FromArgb(src.Red, src.Green, src.Blue)))
            .ForMember(dest => dest.IsActive, opt => opt.Ignore())
            .ForMember(dest => dest.ItemTappedCommand, opt => opt.Ignore())
            .ForMember(dest => dest.IsSelected, opt => opt.Ignore())
            .ForMember(dest => dest.ItemSelectedCommand, opt => opt.Ignore())
            .EqualityComparison((source, dest) => dest.Id == source.Id);

            mapperConfigurationExpression.CreateMap <ValidationSession, SamplePointsViewModel>()
            .ForMember(dest => dest.Points, opt => opt.MapFrom(src => src.SampleItems));

            mapperConfigurationExpression.CreateMap <SampleItem, SamplePointViewModel>()
            .ForMember(dest => dest.Longitude, opt => opt.Ignore())
            .ForMember(dest => dest.Latitude, opt => opt.Ignore())
            .ForMember(dest => dest.Selected, opt => opt.Ignore())
            .ForMember(dest => dest.Radius, opt => opt.Ignore())
            .ForMember(dest => dest.FillColor, opt => opt.Ignore())
            .ForMember(dest => dest.StrokeColor, opt => opt.Ignore())
            .ForMember(dest => dest.StrokeWidth, opt => opt.Ignore())
            .ForMember(dest => dest.ValidationSessionId, opt => opt.Ignore())
            .ForMember(dest => dest.LegendItemId, opt => opt.Ignore())
            .AfterMap((src, dest) =>
            {
                Wkx.Point geometry = Geometry.Deserialize <WktSerializer>(src.Geometry) as Wkx.Point;

                if (geometry == null)
                {
                    throw new InvalidOperationException();
                }

                dest.Longitude = geometry.X.Value;
                dest.Latitude  = geometry.Y.Value;
            })
            .EqualityComparison((source, destination) => source.Id == destination.Id);

            mapperConfigurationExpression.CreateMap <LocalValidation, ViewModels.ValidationUpload.ItemViewModel>()
            .ForMember(dest => dest.LegendItemId, opt => opt.MapFrom(src => src.LegendItem == null ? null : (int?)src.LegendItem.Id))
            .ForMember(dest => dest.Uploaded, opt => opt.Ignore())
            .ForMember(dest => dest.IsActive, opt => opt.Ignore())
            .ForMember(dest => dest.ItemTappedCommand, opt => opt.Ignore())
            .ForMember(dest => dest.IsSelected, opt => opt.Ignore())
            .ForMember(dest => dest.ItemSelectedCommand, opt => opt.Ignore())
            .EqualityComparison((source, destination) => source.SampleItem.Id == destination.SampleItemId);

            // View models to entities
            mapperConfigurationExpression.CreateMap <ValidationSessionDetailViewModel, ValidationSession>()
            .ForMember(dest => dest.UserId, opt => opt.Ignore())
            .ForMember(dest => dest.User, opt => opt.Ignore())
            .ForMember(dest => dest.SampleItems, opt => opt.Ignore());

            mapperConfigurationExpression.CreateMap <ItemViewModel, LegendItem>()
            .ForMember(dest => dest.Red, opt => opt.MapFrom(src => src.Color.R * 255.0))
            .ForMember(dest => dest.Green, opt => opt.MapFrom(src => src.Color.G * 255.0))
            .ForMember(dest => dest.Blue, opt => opt.MapFrom(src => src.Color.B * 255.0))
            .ForMember(dest => dest.ValidationSession, opt => opt.Ignore())
            .ForMember(dest => dest.SampleItems, opt => opt.Ignore())
            .EqualityComparison((source, dest) => dest.Id == source.Id);

            mapperConfigurationExpression.CreateMap <SamplePointsViewModel, ValidationSession>(MemberList.Source)
            .ForMember(dest => dest.SampleItems, opt => opt.MapFrom(src => src.Points));

            mapperConfigurationExpression.CreateMap <SamplePointViewModel, SampleItem>()
            .ForMember(dest => dest.Geometry, configuration =>
            {
                configuration.ResolveUsing((source, destination) =>
                {
                    Wkx.Point point = new Wkx.Point(source.Longitude, source.Latitude);
                    return(point.SerializeString <WktSerializer>());
                });
            })
            .ForMember(dest => dest.ValidationSession, opt => opt.Ignore())
            .ForMember(dest => dest.LegendItem, opt => opt.Ignore())
            .ForMember(dest => dest.LocalValidation, opt => opt.Ignore())
            .AfterMap((src, dest, context) =>
            {
                ValidationSession validationSession       = (ValidationSession)context.Items[nameof(ValidationSession)];
                IDictionary <int, LegendItem> legendItems = (IDictionary <int, LegendItem>)context.Items[nameof(LegendItem)];

                dest.ValidationSession = validationSession;
                dest.LegendItem        = legendItems[src.LegendItemId];
            })
            .EqualityComparison((source, destination) => source.Id == destination.Id);

            mapperConfigurationExpression.CreateMap <ValidatePageViewModel, LocalValidation>()
            .ForMember(dest => dest.LegendItem, opt => opt.Ignore())
            .ForMember(dest => dest.SampleItem, opt => opt.Ignore())
            .ForMember(dest => dest.Uploaded, opt => opt.Ignore())
            .AfterMap(async(src, dest, context) =>
            {
                IAppDataService appDataService = containerProvider.Resolve <IAppDataService>();

                dest.SampleItem = await appDataService.GetSampleItemByIdAsync(src.SampleItemId, src.ValidationSessionId);
                dest.LegendItem = src.SelectedLegendItem != null
                                                ? await appDataService.GetLegendItemByIdAsync(src.SelectedLegendItem.Id, src.ValidationSessionId)
                                                : null;
            });
        }
Exemplo n.º 16
0
 public DomainProfile(IMapperConfigurationExpression mapperConfiguration)
 {
     _mapperConfiguration = mapperConfiguration;
 }
Exemplo n.º 17
0
        public static void CreateMappings(IMapperConfigurationExpression configuration)
        {
            //Inputs
            configuration.CreateMap <CheckboxInputType, FeatureInputTypeDto>();
            configuration.CreateMap <SingleLineStringInputType, FeatureInputTypeDto>();
            configuration.CreateMap <ComboboxInputType, FeatureInputTypeDto>();
            configuration.CreateMap <IInputType, FeatureInputTypeDto>()
            .Include <CheckboxInputType, FeatureInputTypeDto>()
            .Include <SingleLineStringInputType, FeatureInputTypeDto>()
            .Include <ComboboxInputType, FeatureInputTypeDto>();
            configuration.CreateMap <StaticLocalizableComboboxItemSource, LocalizableComboboxItemSourceDto>();
            configuration.CreateMap <ILocalizableComboboxItemSource, LocalizableComboboxItemSourceDto>()
            .Include <StaticLocalizableComboboxItemSource, LocalizableComboboxItemSourceDto>();
            configuration.CreateMap <LocalizableComboboxItem, LocalizableComboboxItemDto>();
            configuration.CreateMap <ILocalizableComboboxItem, LocalizableComboboxItemDto>()
            .Include <LocalizableComboboxItem, LocalizableComboboxItemDto>();

            //Chat
            configuration.CreateMap <ChatMessage, ChatMessageDto>();
            configuration.CreateMap <ChatMessage, ChatMessageExportDto>();

            //Feature
            configuration.CreateMap <FlatFeatureSelectDto, Feature>().ReverseMap();
            configuration.CreateMap <Feature, FlatFeatureDto>();

            //Role
            configuration.CreateMap <RoleEditDto, Role>().ReverseMap();
            configuration.CreateMap <Role, RoleListDto>();
            configuration.CreateMap <UserRole, UserListRoleDto>();

            //Edition
            configuration.CreateMap <EditionEditDto, SubscribableEdition>().ReverseMap();
            configuration.CreateMap <EditionCreateDto, SubscribableEdition>();
            configuration.CreateMap <EditionSelectDto, SubscribableEdition>().ReverseMap();
            configuration.CreateMap <SubscribableEdition, EditionInfoDto>();

            configuration.CreateMap <Edition, EditionInfoDto>().Include <SubscribableEdition, EditionInfoDto>();

            configuration.CreateMap <SubscribableEdition, EditionListDto>();
            configuration.CreateMap <Edition, EditionEditDto>();
            configuration.CreateMap <Edition, SubscribableEdition>();
            configuration.CreateMap <Edition, EditionSelectDto>();


            //Payment
            configuration.CreateMap <SubscriptionPaymentDto, SubscriptionPayment>().ReverseMap();
            configuration.CreateMap <SubscriptionPaymentListDto, SubscriptionPayment>().ReverseMap();
            configuration.CreateMap <SubscriptionPayment, SubscriptionPaymentInfoDto>();

            //Permission
            configuration.CreateMap <Permission, FlatPermissionDto>();
            configuration.CreateMap <Permission, FlatPermissionWithLevelDto>();

            //Language
            configuration.CreateMap <ApplicationLanguage, ApplicationLanguageEditDto>();
            configuration.CreateMap <ApplicationLanguage, ApplicationLanguageListDto>();
            configuration.CreateMap <NotificationDefinition, NotificationSubscriptionWithDisplayNameDto>();
            configuration.CreateMap <ApplicationLanguage, ApplicationLanguageEditDto>()
            .ForMember(ldto => ldto.IsEnabled, options => options.MapFrom(l => !l.IsDisabled));

            //Tenant
            configuration.CreateMap <Tenant, RecentTenant>();
            configuration.CreateMap <Tenant, TenantLoginInfoDto>();
            configuration.CreateMap <Tenant, TenantListDto>();
            configuration.CreateMap <TenantEditDto, Tenant>().ReverseMap();
            configuration.CreateMap <CurrentTenantInfoDto, Tenant>().ReverseMap();

            //User
            configuration.CreateMap <User, UserEditDto>()
            .ForMember(dto => dto.Password, options => options.Ignore())
            .ReverseMap()
            .ForMember(user => user.Password, options => options.Ignore());
            configuration.CreateMap <User, UserLoginInfoDto>();
            configuration.CreateMap <User, UserListDto>();
            configuration.CreateMap <User, ChatUserDto>();
            configuration.CreateMap <User, OrganizationUnitUserListDto>();
            configuration.CreateMap <Role, OrganizationUnitRoleListDto>();
            configuration.CreateMap <CurrentUserProfileEditDto, User>().ReverseMap();
            configuration.CreateMap <UserLoginAttemptDto, UserLoginAttempt>().ReverseMap();
            configuration.CreateMap <ImportUserDto, User>();

            //AuditLog
            configuration.CreateMap <AuditLog, AuditLogListDto>();
            configuration.CreateMap <EntityChange, EntityChangeListDto>();
            configuration.CreateMap <EntityPropertyChange, EntityPropertyChangeDto>();

            //Friendship
            configuration.CreateMap <Friendship, FriendDto>();
            configuration.CreateMap <FriendCacheItem, FriendDto>();

            //OrganizationUnit
            configuration.CreateMap <OrganizationUnit, OrganizationUnitDto>();

            //Webhooks
            configuration.CreateMap <WebhookSubscription, GetAllSubscriptionsOutput>();
            configuration.CreateMap <WebhookSendAttempt, GetAllSendAttemptsOutput>()
            .ForMember(webhookSendAttemptListDto => webhookSendAttemptListDto.WebhookName,
                       options => options.MapFrom(l => l.WebhookEvent.WebhookName))
            .ForMember(webhookSendAttemptListDto => webhookSendAttemptListDto.Data,
                       options => options.MapFrom(l => l.WebhookEvent.Data));

            configuration.CreateMap <WebhookSendAttempt, GetAllSendAttemptsOfWebhookEventOutput>();

            configuration.CreateMap <DynamicProperty, DynamicPropertyDto>().ReverseMap();
            configuration.CreateMap <DynamicPropertyValue, DynamicPropertyValueDto>().ReverseMap();
            configuration.CreateMap <DynamicEntityProperty, DynamicEntityPropertyDto>()
            .ForMember(dto => dto.DynamicPropertyName,
                       options => options.MapFrom(entity => entity.DynamicProperty.PropertyName));
            configuration.CreateMap <DynamicEntityPropertyDto, DynamicEntityProperty>();

            configuration.CreateMap <DynamicEntityPropertyValue, DynamicEntityPropertyValueDto>().ReverseMap();
            //User Delegations
            configuration.CreateMap <CreateUserDelegationDto, UserDelegation>();

            /* ADD YOUR OWN CUSTOM AUTOMAPPER MAPPINGS HERE */

            // PhoneBook (we will comment out other lines when the new DTOs are added)
            configuration.CreateMap <Person, PersonListDto>();
            //configuration.CreateMap<AddPhoneInput, Phone>();
            //configuration.CreateMap<CreatePersonInput, Person>();
            //configuration.CreateMap<Person, GetPersonForEditOutput>();
            //configuration.CreateMap<Phone, PhoneInPersonListDto>();

            configuration.CreateMap <CreatePersonInput, Person>();
        }
Exemplo n.º 18
0
 public void CreateMappings(IMapperConfigurationExpression configuration)
 {
     configuration.CreateMap <Request, RequestModel>()
     .ForMember(p => p.Role,
                mapping => mapping.MapFrom(c => c.Role.Name));
 }
Exemplo n.º 19
0
 protected override void Configure(IMapperConfigurationExpression expression)
 {
     expression.CreateMap <CoreResponseGetChairs, ResponseGetChairs>();
     expression.CreateMap <CoreResponseGetChairsItem, ResponseGetChairsItem>();
 }
 public abstract void CreateMap(IMapperConfigurationExpression configuration, Type type);
Exemplo n.º 21
0
 /// <summary>
 /// 添加映射映射关系
 /// </summary>
 /// <param name="config"></param>
 private static void AddMapper(IMapperConfigurationExpression config)
 {
     //config.CreateMap<GroupUserModel, GroupInfoDto>();
     //config.CreateMap<GroupInfoDto, GroupUserModel>();
 }
Exemplo n.º 22
0
 public void CreateMappings(IMapperConfigurationExpression configuration)
 {
     configuration.CreateMap <GameDetailsViewModel, GameBll>()
     .ForMember(r => r.Genres, opts => opts.Ignore())
     .ForMember(r => r.PlatformTypes, opts => opts.Ignore());
 }
Exemplo n.º 23
0
        public static void ConfigureApiModels(this IMapperConfigurationExpression mapperConfigurationExpression,
                                              IContainerProvider containerProvider)
        {
            // Api models to view models
            mapperConfigurationExpression.CreateMap <ValidationSessionModel, ViewModels.ValidationSessionOverview.ItemViewModel>()
            .ForMember(dest => dest.Id, opt => opt.MapFrom(src => src.ValidationSessionID))
            .ForMember(dest => dest.Name, opt => opt.MapFrom(src => src.ValidationSessionName))
            .ForMember(dest => dest.Pinned, opt => opt.Ignore())
            .ForMember(dest => dest.IsActive, opt => opt.Ignore())
            .ForMember(dest => dest.ItemTappedCommand, opt => opt.Ignore())
            .ForMember(dest => dest.IsSelected, opt => opt.Ignore())
            .ForMember(dest => dest.ItemSelectedCommand, opt => opt.Ignore())
            .AfterMap(async(src, dest) =>
            {
                IAppDataService appDataService = containerProvider.Resolve <IAppDataService>();
                dest.Pinned = await appDataService.TryGetValidationSessionByIdAsync(src.ValidationSessionID) != null;
            });

            mapperConfigurationExpression.CreateMap <ValidationSessionDetailModel, ValidationSessionDetailViewModel>()
            .ForMember(dest => dest.Id, opt => opt.MapFrom(src => src.ValidationSessionID))
            .ForMember(dest => dest.Name, opt => opt.MapFrom(src => src.ValidationSessionName))
            .ForMember(dest => dest.ValidationMethod, opt => opt.MapFrom(src => src.ValidationMethodEnum));

            mapperConfigurationExpression.CreateMap <LegendItemModel, ItemViewModel>()
            .ForMember(dest => dest.Id, opt => opt.MapFrom(src => src.LegendItemID))
            .ForMember(dest => dest.Color, opt => opt.MapFrom(src => Color.FromArgb(src.Red, src.Green, src.Blue)))
            .ForMember(dest => dest.Name, opt => opt.MapFrom(src => src.ClassName))
            .ForMember(dest => dest.IsActive, opt => opt.Ignore())
            .ForMember(dest => dest.ItemTappedCommand, opt => opt.Ignore())
            .ForMember(dest => dest.IsSelected, opt => opt.Ignore())
            .ForMember(dest => dest.ItemSelectedCommand, opt => opt.Ignore())
            .EqualityComparison((source, dest) => dest.Id == source.LegendItemID);

            mapperConfigurationExpression.CreateMap <IEnumerable <SampleItemModel>, SamplePointsViewModel>()
            .ForMember(dest => dest.Points, opt => opt.MapFrom(src => src));

            mapperConfigurationExpression.CreateMap <SampleItemModel, SamplePointViewModel>()
            .ForMember(dest => dest.Id, opt => opt.MapFrom(src => src.SampleItemID))
            .ForMember(dest => dest.ValidationSessionId,
                       configuration =>
            {
                configuration.ResolveUsing(
                    (source, destination, model, context) => (int)context.Items[nameof(ValidationSession.Id)]);
            })
            .ForMember(dest => dest.IsValidated, opt => opt.MapFrom(src => src.Validated))
            .ForMember(dest => dest.Longitude, opt => opt.Ignore())
            .ForMember(dest => dest.Latitude, opt => opt.Ignore())
            .ForMember(dest => dest.Selected, opt => opt.Ignore())
            .ForMember(dest => dest.Radius, opt => opt.Ignore())
            .ForMember(dest => dest.FillColor, opt => opt.Ignore())
            .ForMember(dest => dest.StrokeColor, opt => opt.Ignore())
            .ForMember(dest => dest.StrokeWidth, opt => opt.Ignore())
            .AfterMap((source, dest) =>
            {
                Wkx.Point geometry = Geometry.Deserialize <WktSerializer>(source.GeometryString) as Wkx.Point;

                if (geometry == null)
                {
                    throw new InvalidOperationException();
                }

                dest.Longitude = geometry.X.Value;
                dest.Latitude  = geometry.Y.Value;
            })
            .EqualityComparison((source, destination) => source.SampleItemID == destination.Id);

            // View models to api models
            mapperConfigurationExpression.CreateMap <ViewModels.ValidationUpload.ItemViewModel, ValidationCreateModel>();
        }
Exemplo n.º 24
0
 public static void Configure(this IMapperConfigurationExpression mapperConfigurationExpression,
                              IContainerProvider containerProvider)
 {
     mapperConfigurationExpression.ConfigureAppDataEntities(containerProvider);
     mapperConfigurationExpression.ConfigureApiModels(containerProvider);
 }
 public void CreateMappings(IMapperConfigurationExpression cfg)
 {
     cfg.CreateMap <Exam, AllExamsViewModel>()
     .ForMember(dest => dest.CustomerFullName, opt => opt.MapFrom(src => src.Customer.User.FirstName + " " + src.Customer.User.LastName))
     .ForMember(dest => dest.CourseInfo, opt => opt.MapFrom(src => src.Course.Trainer.User.Nickname + " as trainer" + src.Course.School.TradeMark + " school" + src.Course.Car.CarModel + " " + src.Course.Car.Make + " " + src.Course.Car.Transmission));
 }
Exemplo n.º 26
0
 protected abstract void Configure(IMapperConfigurationExpression expression);
Exemplo n.º 27
0
 public void CreateMappings(IMapperConfigurationExpression configuration)
 {
     configuration.CreateMap<Source, TestConfig>().ForMember(dest => dest.Number, opt => opt.MapFrom(src => src.Nr));
     configuration.CreateMap<TestConfig, Source>().ForMember(dest => dest.Nr, opt => opt.MapFrom(src => src.Number)); ;
 }
Exemplo n.º 28
0
 public void CreateMappings(IMapperConfigurationExpression configuration)
 {
     configuration.CreateMap <Category, CategoryIdAndNameViewModel>()
     .ForMember(x => x.CountOfAllSayings,
                m => m.MapFrom(c => c.Sayings.Count()));
 }
 /// <summary>
 /// Set custom AutoMapper configuration settings.
 /// </summary>
 /// <param name="configuration">AutoMapper configuration.</param>
 protected virtual void AddCustomConfiguration(IMapperConfigurationExpression configuration)
 {
     // Map properties with public or internal getters
     configuration.ShouldMapProperty = p => (p.GetMethod != null && (p.GetMethod.IsPublic || p.GetMethod.IsAssembly));
 }
Exemplo n.º 30
0
 public void Bind(IMapperConfigurationExpression cfg)
 {
     cfg.CreateMap <JobClassAddModel, JobClassEntity>();
     cfg.CreateMap <JobClassEntity, JobClassUpdateModel>();
     cfg.CreateMap <JobClassUpdateModel, JobClassEntity>();
 }
Exemplo n.º 31
0
        private static void RegisterCustomMaps(IMapperConfigurationExpression configuration, IEnumerable <Type> types)
        {
            var maps = GetCustomMappings(types);

            CreateMappings(configuration, maps);
        }
        ///// <summary>
        ///// 添加AutoMapper服务,自动加载所有继承Profile配置
        ///// </summary>
        ///// <param name="services"><see cref="IServiceCollection"/></param>
        ///// <param name="configAction">配置函数</param>
        ///// <returns></returns>
        //public static IServiceCollection AddAutoMapper(this IServiceCollection services, Action<IMapperConfigurationExpression> configAction)
        //{
        //    lock (lockObj)
        //    {
        //        //AutoMapper 配置服务
        //        Mapper.Reset();
        //        Mapper.Initialize(config =>
        //        {
        //            configAction?.Invoke(config);
        //        });
        //        return services;
        //    }
        //}


        /// <summary>
        /// 注入程序集Mappings
        /// </summary>
        /// <param name="config"><see cref="IMapperConfigurationExpression"/></param>
        /// <returns></returns>
        public static void RegisterAllMappings(this IMapperConfigurationExpression config)
        {
            //获取所有的程序集
            config.RegisterAllMappings(Assembly.GetEntryAssembly());
        }
 public ReverseMappingsProfile(List<Type> types, IMapperConfigurationExpression mapperConfiguration)
 {
     this.LoadReverseMappings(types, mapperConfiguration);
 }
Exemplo n.º 34
0
 public static void CreateMappings(IMapperConfigurationExpression configuration)
 {
     configuration.CreateMap <ExhibitionShop, ExhibitionShopListDto>();
     configuration.CreateMap <ExhibitionShopEditDto, ExhibitionShop>();
 }
 public StandardMappingsProfile(List<Type> types, IMapperConfigurationExpression mapperConfiguration)
 {
     this.LoadStandardMappings(types, mapperConfiguration);
 }
Exemplo n.º 36
0
 public static void Config(IServiceCollection services, IMapperConfigurationExpression mapper)
 {
     ConfigServices(services);
     Errors.Init();
 }
 public CustomMappingsProfile(List<Type> types, IMapperConfigurationExpression mapperConfiguration)
 {
     this.LoadCustomMappings(types, mapperConfiguration);
 }
        public void Configure(IMapperConfigurationExpression configuration)
        {
            var map = configuration.CreateMap <OrderLineEntity, OrderLineModel>();

            map.ForMember(x => x.OrderEntityId, x => x.MapFrom(o => o.Order.Id));
        }
 public static void LoadAllMappings(IMapperConfigurationExpression config, IList<Type> types)
 {
     LoadStandardMappings(config, types);
     LoadCustomMappings(config, types);
 }
Exemplo n.º 40
0
 public static void ConfigureApplicationProfiles(this IMapperConfigurationExpression mapperConfiguration)
 {
     mapperConfiguration.AddProfile(new DomainToViewModelProfile());
     mapperConfiguration.AddProfile(new ViewModelToDomainProfile());
 }
Exemplo n.º 41
0
 public static void AddDataReaderMapping(this IMapperConfigurationExpression configuration)
 => configuration.AddDataReaderMapping(false);
    public void RegisterMappings(IMapperConfigurationExpression config) {

      #region Settings

      config.CreateMap<DomainSettings, SettingsDialogViewEntity>().ReverseMap();

      config.CreateMap<DomainSettings, SettingsWindowViewEntity>().ForMember(dest => dest.AreSettingsChanged, opt => opt.Ignore())
                                                                  .ForMember(dest => dest.MainWindowState,    opt => opt.ResolveUsing(src => src.Maximized ? WindowState.Maximized : WindowState.Normal));

      config.CreateMap<SettingsWindowViewEntity, DomainSettings>().ForMember(dest => dest.Maximized,  opt => opt.ResolveUsing(src => src.MainWindowState == WindowState.Maximized))
                                                                  .ForMember(dest => dest.PathToGame, opt => opt.Ignore())
                                                                  .ForMember(dest => dest.ExportPath, opt => opt.Ignore());

      #endregion Settings

      #region Messages

      config.CreateMap<DomainLoadProgress, LoadProgressMessage>().ForMember(dest => dest.CanAsync,         opt => opt.Ignore())
                                                                 .ForMember(dest => dest.IsLocalMode, opt => opt.Ignore());

      #endregion Messages

      #region Header

      config.CreateMap<DomainHeader, HeaderViewEntity>().ForMember(dest => dest.Group, opt => opt.MapFrom(src => src.Group.String))
                                                        .ForMember(dest => dest.Guid,  opt => opt.ResolveUsing(src => new Guid(src.Guid)));

      #endregion Header

      #region Tables

      config.CreateMap<DomainExportTableEntry, ExportTableEntryViewEntity>().ForMember(dest => dest.Guid,          opt => opt.ResolveUsing(src => new Guid(src.Guid)))
                                                                            .ForMember(dest => dest.ArchetypeName, opt => opt.MapFrom(src => src.ArchetypeReferenceNameIndex.Name))
                                                                            .ForMember(dest => dest.OwnerName,     opt => opt.MapFrom(src => src.OwnerReferenceNameIndex.Name))
                                                                            .ForMember(dest => dest.TypeName,      opt => opt.MapFrom(src => src.TypeReferenceNameIndex.Name))
                                                                            .ForMember(dest => dest.Name,          opt => opt.MapFrom(src => src.NameTableIndex.Name))
                                                                            .ForMember(dest => dest.IsSelected,    opt => opt.Ignore())
                                                                            .ForMember(dest => dest.IsErrored,     opt => opt.Ignore());

      config.CreateMap<DomainExportTableEntry, ObjectTreeViewEntity>().ForMember(dest => dest.Name,       opt => opt.MapFrom(src => src.NameTableIndex.Name))
                                                                      .ForMember(dest => dest.IsExport,   opt => opt.UseValue(true))
                                                                      .ForMember(dest => dest.IsImport,   opt => opt.UseValue(false))
                                                                      .ForMember(dest => dest.IsExpanded, opt => opt.Ignore())
                                                                      .ForMember(dest => dest.IsSelected, opt => opt.Ignore())
                                                                      .ForMember(dest => dest.Parent,     opt => opt.Ignore())
                                                                      .ForMember(dest => dest.Children,   opt => opt.UseValue(new ObservableCollection<ObjectTreeViewEntity>()));

      config.CreateMap<DomainImportTableEntry, ImportTableEntryViewEntity>().ForMember(dest => dest.PackageName,        opt => opt.MapFrom(src => src.PackageNameIndex.Name))
                                                                            .ForMember(dest => dest.TypeName,           opt => opt.MapFrom(src => src.TypeNameIndex.Name))
                                                                            .ForMember(dest => dest.Name,               opt => opt.MapFrom(src => src.NameTableIndex.Name))
                                                                            .ForMember(dest => dest.OwnerReferenceName, opt => opt.MapFrom(src => src.OwnerReferenceNameIndex.Name))
                                                                            .ForMember(dest => dest.IsErrored,          opt => opt.Ignore())
                                                                            .ForMember(dest => dest.IsSelected,         opt => opt.Ignore());

      config.CreateMap<DomainImportTableEntry, ObjectTreeViewEntity>().ForMember(dest => dest.Name,       opt => opt.MapFrom(src => src.NameTableIndex.Name))
                                                                      .ForMember(dest => dest.IsExport,   opt => opt.UseValue(false))
                                                                      .ForMember(dest => dest.IsImport,   opt => opt.UseValue(true))
                                                                      .ForMember(dest => dest.IsExpanded, opt => opt.Ignore())
                                                                      .ForMember(dest => dest.IsSelected, opt => opt.Ignore())
                                                                      .ForMember(dest => dest.Parent,     opt => opt.Ignore())
                                                                      .ForMember(dest => dest.Children,   opt => opt.UseValue(new ObservableCollection<ObjectTreeViewEntity>()));

      config.CreateMap<DomainNameTableEntry, NameTableEntryViewEntity>().ForMember(dest => dest.Name,       opt => opt.MapFrom(src => src.Name.String))
                                                                        .ForMember(dest => dest.IsErrored,  opt => opt.Ignore())
                                                                        .ForMember(dest => dest.IsSelected, opt => opt.Ignore());

      config.CreateMap<DomainGenerationTableEntry, GenerationsTableEntryViewEntity>().ForMember(dest => dest.IsErrored,  opt => opt.Ignore())
                                                                                     .ForMember(dest => dest.IsSelected, opt => opt.Ignore());

      config.CreateMap<DomainCompressedChunk, CompressionTableEntryViewEntity>().ForMember(dest => dest.BlockSize,         opt => opt.MapFrom(src => src.Header.BlockSize))
                                                                                .ForMember(dest => dest.CompressionBlocks, opt => opt.MapFrom(src => src.Header.Blocks))
                                                                                .ForMember(dest => dest.IsErrored,         opt => opt.Ignore())
                                                                                .ForMember(dest => dest.IsSelected,        opt => opt.Ignore());

      config.CreateMap<DomainCompressedChunkBlock, CompressionBlockViewEntity>().ForMember(dest => dest.IsSelected, opt => opt.Ignore());

      #endregion Tables

      #region Properties

      config.CreateMap<DomainProperty, PropertyViewEntity>().ForMember(dest => dest.Name,          opt => opt.MapFrom(src => src.NameIndex.Name))
                                                            .ForMember(dest => dest.TypeName,      opt => opt.MapFrom(src => src.TypeNameIndex.Name))
                                                            .ForMember(dest => dest.PropertyValue, opt => opt.MapFrom(src => src.Value.PropertyString))
                                                            .ForMember(dest => dest.IsErrored,     opt => opt.Ignore())
                                                            .ForMember(dest => dest.IsSelected,    opt => opt.Ignore());

      #endregion Properties

      #region Objects

      config.CreateMap<DomainMipMap, MipMapViewEntity>().ForMember(dest => dest.IsEnabled, opt => opt.ResolveUsing(src => src.ImageData != null))
                                                        .ForMember(dest => dest.IsChecked, opt => opt.Ignore())
                                                        .ForMember(dest => dest.Level,     opt => opt.Ignore());

      config.CreateMap<DomainExportedObject, ExportedObjectViewEntity>().ForMember(dest => dest.IsChecked,  opt => opt.Ignore())
                                                                        .ForMember(dest => dest.IsSelected, opt => opt.Ignore())
                                                                        .PreserveReferences();

      #endregion Objects

      #region DTOs

      config.CreateMap<DomainUpkFile, FileViewEntity>().ForMember(dest => dest.GameVersion,          opt => opt.ResolveUsing(src => src.GetMaxVersion()))
                                                       .ForMember(dest => dest.ExportTypes,          opt => opt.ResolveUsing(src => src.GetBestExports()?.Select(e => e.Name) ?? new List<string>()))
                                                       .ForMember(dest => dest.IsChecked,            opt => opt.Ignore())
                                                       .ForMember(dest => dest.IsSelected,           opt => opt.Ignore())
                                                       .ForMember(dest => dest.IsErrored,            opt => opt.Ignore())
                                                       .ForMember(dest => dest.ContainsTargetObject, opt => opt.Ignore());

      #endregion DTOs

    }
Exemplo n.º 43
0
 public static void Map(IMapperConfigurationExpression cfg) =>
     cfg.CreateMap<Domain.Client, Client>();
Exemplo n.º 44
0
 internal static void InitMap(IMapperConfigurationExpression cfg)
 {
     cfg.CreateMap <StampedEntity, StampViewModel>().ReverseMap();
 }
Exemplo n.º 45
0
 public static void CreateMaps(IMapperConfigurationExpression cfg)
 {
     cfg.CreateMap<Domain.Instance, Instance>()
         .ForMember(d => d.InstanceTypeId, o => o.MapFrom(s => (int)s.InstanceType))
         .ForMember(d => d.InstanceUsers, o => o.Ignore());
 }
 private static void ExtendMappingConfiguration(IMapperConfigurationExpression cfg)
 {
     AutoMapperConfiguration.Extend(cfg);
 }
Exemplo n.º 47
0
 internal static void CreateMaps(IMapperConfigurationExpression cfg)
 {
 }
Exemplo n.º 48
0
 internal static void CreateMaps(IMapperConfigurationExpression cfg)
 {
     cfg.CreateMap<Domain.UserInstance, Models.UserInstanceModel>()
         .ForMember(d=>d.InstanceType,o=>o.MapFrom(s=>s.Type));
 }
Exemplo n.º 49
0
 internal static void Map(IMapperConfigurationExpression cfg)
 {
     cfg.CreateMap <AuthorizationServerDeploymentDefinition, AuthorizationServerProperties>();
 }
Exemplo n.º 50
0
 public static void Configure(IMapperConfigurationExpression expression)
 {
     expression.CreateMap <CQ.GetProductById.Product, Dtos.Apis.Product.Get.Product>();
 }
Exemplo n.º 51
0
 private ObjectMapper(IMapperConfigurationExpression configuration)
 {
     Configuration = configuration;
     Configuration.AddConditionalObjectMapper().Conventions.Add(pair => true);
 }
Exemplo n.º 52
0
 public static IMapperConfigurationExpression AddAccomodatieFaciliteitMapper(this IMapperConfigurationExpression configExpression)
 {
     configExpression.CreateMap <Data.AccomodatieFaciliteit, Model.AccomodatieFaciliteitModel>().ReverseMap();
     return(configExpression);
 }
Exemplo n.º 53
0
 private void RegisterMappers(IMapperConfigurationExpression configurationExpression)
 {
     configurationExpression.AddMaps(_assembliesToScan);
 }
 protected override void AddProfile(IMapperConfigurationExpression cfg)
 {
     cfg.AddProfile <DataLockProfile>();
 }
Exemplo n.º 55
0
        public static void CreateMappings(IMapperConfigurationExpression configuration)
        {
            //Inputs
            configuration.CreateMap <CheckboxInputType, FeatureInputTypeDto>();
            configuration.CreateMap <SingleLineStringInputType, FeatureInputTypeDto>();
            configuration.CreateMap <ComboboxInputType, FeatureInputTypeDto>();
            configuration.CreateMap <IInputType, FeatureInputTypeDto>()
            .Include <CheckboxInputType, FeatureInputTypeDto>()
            .Include <SingleLineStringInputType, FeatureInputTypeDto>()
            .Include <ComboboxInputType, FeatureInputTypeDto>();
            configuration.CreateMap <StaticLocalizableComboboxItemSource, LocalizableComboboxItemSourceDto>();
            configuration.CreateMap <ILocalizableComboboxItemSource, LocalizableComboboxItemSourceDto>()
            .Include <StaticLocalizableComboboxItemSource, LocalizableComboboxItemSourceDto>();
            configuration.CreateMap <LocalizableComboboxItem, LocalizableComboboxItemDto>();
            configuration.CreateMap <ILocalizableComboboxItem, LocalizableComboboxItemDto>()
            .Include <LocalizableComboboxItem, LocalizableComboboxItemDto>();

            //Chat
            configuration.CreateMap <ChatMessage, ChatMessageDto>();

            //Feature
            configuration.CreateMap <FlatFeatureSelectDto, Feature>().ReverseMap();
            configuration.CreateMap <Feature, FlatFeatureDto>();

            //Role
            configuration.CreateMap <RoleEditDto, Role>().ReverseMap();
            configuration.CreateMap <Role, RoleListDto>();
            configuration.CreateMap <UserRole, UserListRoleDto>();

            //Edition
            configuration.CreateMap <EditionEditDto, SubscribableEdition>().ReverseMap();
            configuration.CreateMap <EditionSelectDto, SubscribableEdition>().ReverseMap();
            configuration.CreateMap <SubscribableEdition, EditionInfoDto>();

            configuration.CreateMap <Edition, EditionInfoDto>().Include <SubscribableEdition, EditionInfoDto>();

            configuration.CreateMap <Edition, EditionListDto>();
            configuration.CreateMap <Edition, EditionEditDto>();
            configuration.CreateMap <Edition, SubscribableEdition>();
            configuration.CreateMap <Edition, EditionSelectDto>();


            //Payment
            configuration.CreateMap <SubscriptionPaymentDto, SubscriptionPayment>().ReverseMap();
            configuration.CreateMap <SubscriptionPaymentListDto, SubscriptionPayment>().ReverseMap();
            configuration.CreateMap <SubscriptionPayment, SubscriptionPaymentInfoDto>();

            //Permission
            configuration.CreateMap <Permission, FlatPermissionDto>();
            configuration.CreateMap <Permission, FlatPermissionWithLevelDto>();

            //Language
            configuration.CreateMap <ApplicationLanguage, ApplicationLanguageEditDto>();
            configuration.CreateMap <ApplicationLanguage, ApplicationLanguageListDto>();
            configuration.CreateMap <NotificationDefinition, NotificationSubscriptionWithDisplayNameDto>();
            configuration.CreateMap <ApplicationLanguage, ApplicationLanguageEditDto>()
            .ForMember(ldto => ldto.IsEnabled, options => options.MapFrom(l => !l.IsDisabled));

            //Tenant
            configuration.CreateMap <Tenant, RecentTenant>();
            configuration.CreateMap <Tenant, TenantLoginInfoDto>();
            configuration.CreateMap <Tenant, TenantListDto>();
            configuration.CreateMap <TenantEditDto, Tenant>().ReverseMap();
            configuration.CreateMap <CurrentTenantInfoDto, Tenant>().ReverseMap();

            //User
            configuration.CreateMap <User, UserEditDto>()
            .ForMember(dto => dto.Password, options => options.Ignore())
            .ReverseMap()
            .ForMember(user => user.Password, options => options.Ignore());
            configuration.CreateMap <User, UserLoginInfoDto>();
            configuration.CreateMap <User, UserListDto>();
            configuration.CreateMap <User, ChatUserDto>();
            configuration.CreateMap <User, OrganizationUnitUserListDto>();
            configuration.CreateMap <CurrentUserProfileEditDto, User>().ReverseMap();
            configuration.CreateMap <UserLoginAttemptDto, UserLoginAttempt>().ReverseMap();

            //AuditLog
            configuration.CreateMap <AuditLog, AuditLogListDto>();
            configuration.CreateMap <EntityChange, EntityChangeListDto>();

            //Friendship
            configuration.CreateMap <Friendship, FriendDto>();
            configuration.CreateMap <FriendCacheItem, FriendDto>();

            //OrganizationUnit
            configuration.CreateMap <OrganizationUnit, OrganizationUnitDto>();

            /* ADD YOUR OWN CUSTOM AUTOMAPPER MAPPINGS HERE */
        }
Exemplo n.º 56
0
 public void  Map(IMapperConfigurationExpression cfg)
 {
     cfg.CreateMap <IBDeposit, Deposit>();
 }
Exemplo n.º 57
-6
        private void RegisterMaps(IMapperConfigurationExpression config)
        {
            config.CreateMap<Rma,RmaViewModel>()
                .ForMember(x => x.HardwareTypeName, m => m.MapFrom(x => x.HardwareType.Name));

            config.CreateMap<RmaViewModel,Rma>().ConvertUsing<RmaVmToEntity>();
        }