public void ConversionToUtcTimeWorks() { var mapper = new MemberMapper(); MemberOptions func = new MemberOptions((ctx, options) => { if (ctx.Source.DeclaringType == typeof(SourceDate)) { options.Convert <DateTime, DateTime>(d => d.ToUniversalTime()); } else { options.Convert <DateTime, DateTime>(d => d.ToLocalTime()); } }); mapper.CreateMap <SourceDate, DestinationDate>(options: func); mapper.CreateMap <DestinationDate, SourceDate>(options: func); var result = mapper.Map(new SourceDate { Start = DateTime.Now }, new DestinationDate()); Assert.AreEqual(DateTimeKind.Utc, result.Start.Kind); var reverse = mapper.Map(new DestinationDate { Start = DateTime.Now }, new SourceDate()); Assert.AreEqual(DateTimeKind.Local, reverse.Start.Kind); }
public ProposedMap CreateMapProposal(TypePair pair, MemberOptions options = null, LambdaExpression customMappingExpression = null, params Type[] parameters) { var map = new ProposedMap(pair.SourceType, pair.DestinationType, this.mapper, this.options); foreach (var param in parameters) { map.ParameterTypes.Add(param); } CustomMapping customMapping = null; customMapping = GetCustomMappingFromExpression(pair, customMappingExpression, customMapping); TryGetCustomMapping(pair, out customMapping); var mapping = GetComplexTypeMapping(0, pair, options ?? mapper.DefaultMemberOptions, customMapping, true); if (mapping.CustomMapping == null) { mapping.CustomMapping = customMapping; } map.ProposedTypeMapping = mapping; return(map); }
/// <summary> /// Checks if the mapper repository contains a map and if so, returns it as an out parameter. /// </summary> /// <returns></returns> public bool TryGetMap(IMemberMapper mapper, MemberOptions options, TypePair pair, out ProposedMap map) { MapFuncWrapper action; if (cache.TryGetValue(pair, out action)) { lock (action) { if (action.InUse) { map = null; return(false); } try { action.InUse = true; map = action.CreateMapFunction(mapper, options); } finally { action.InUse = false; } return(true); } } map = null; return(false); }
/// <summary> /// Checks if the mapper repository contains a map and if so, returns it as an out parameter. /// </summary> /// <returns></returns> public bool TryGetMap <TSource, TDestination>(IMemberMapper mapper, MemberOptions options, out ProposedMap <TSource, TDestination> map) { MapFuncWrapper action; if (cache.TryGetValue(new TypePair(typeof(TSource), typeof(TDestination)), out action)) { lock (action) { if (action.InUse) { map = null; return(false); } try { action.InUse = true; map = (ProposedMap <TSource, TDestination>)action.CreateMapFunction(mapper, options); } finally { action.InUse = false; } return(true); } } map = null; return(false); }
/// <summary> /// Go one deeper into the type hierarchy to map between a source and destination member. /// </summary> private void GenerateComplexTypeMapping(int currentDepth, MemberOptions options, CustomMapping customMapping, ProposedTypeMapping typeMapping, PropertyOrFieldInfo destinationMember, PropertyOrFieldInfo sourceMember) { var complexPair = new TypePair(sourceMember.PropertyOrFieldType, destinationMember.PropertyOrFieldType); // Go one deeper var complexTypeMapping = GetComplexTypeMapping(currentDepth + 1, complexPair, options, customMapping); // If a mapping has been found if (complexTypeMapping != null) { complexTypeMapping = complexTypeMapping.Clone(); complexTypeMapping.DestinationMember = destinationMember; complexTypeMapping.SourceMember = sourceMember; CustomMapping customMappingForType; TryGetCustomMapping(complexPair, out customMappingForType); complexTypeMapping.CustomMapping = customMappingForType; typeMapping.ProposedTypeMappings.Add(complexTypeMapping); } else { // If no mapping has been found, don't cache the 'owning' typemapping as it will cause issues later typeMapping.DoNotCache = true; } }
/// <summary> /// Checks the application restriction to make sure that it /// follows the restriction that the user sets for the application. /// </summary> /// <param name="id">Member Manager Id</param> /// <param name="member">Member View</param> /// <param name="message">Message</param> /// <returns></returns> private (bool Allow, MemberVm Member, MemberOptionsVm Options) CheckUpdateRestrictions(int id, MemberVm member, out string message) { message = String.Empty; var memberOptions = new MemberOptions(); var managerSettings = DataAccess.MemberManagerSettings.GetById(id); #region Application Check // Check the the application even exists before doing the checks to the member table. if (managerSettings == null) { message = MemberManagerMessages.Error.MANAGER_DOES_NOT_EXISTS; return(false, member, new MemberOptionsVm(memberOptions)); } #endregion Application Check #region Username Check // Always check for username to make sure that the username only exists once per application. var dbUserNameCheck = DataAccess.MemberLogin.Find(f => f.MemberManagerId == managerSettings.Id && f.Member.Username.ToLower() == member.Username.ToLower()); if (dbUserNameCheck != null && dbUserNameCheck.MemberId != member.Id) { message = MemberManagerMessages.Error.USERNAME_EXISTS; return(false, member, new MemberOptionsVm(memberOptions)); } #endregion Username Check #region Email Restriction Check //check for email restrictions if (managerSettings.RestrictEmail) { var dbMember = DataAccess.MemberLogin.Find(f => f.MemberManagerId == managerSettings.Id && f.Member.Email == member.Email); if (dbMember != null && dbUserNameCheck.MemberId != member.Id) { message = MemberManagerMessages.Error.EMAIL_EXISTS; return(false, member, new MemberOptionsVm(memberOptions)); } } #endregion Email Restriction Check #region Display Name Check if (String.IsNullOrWhiteSpace(member.DisplayName)) { message = MemberManagerMessages.Error.MEMBER_DISPLAY_NAME_REQUIRED; return(false, member, new MemberOptionsVm(memberOptions)); } #endregion Display Name Check // automatically validate the new user based on the application settings. memberOptions.IsValidated = managerSettings.AutoValidateUser; return(true, member, new MemberOptionsVm(memberOptions)); }
public static string GetPaymentDescription(MemberOptions membershipOptions) { List <string> descriptionList = new List <string>() { membershipOptions.MembershipType.ToString() }; if (membershipOptions.SwimSubs1) { descriptionList.Add(GetSwimSub1Description(DateTime.Now)); } if (membershipOptions.SwimSubs2) { descriptionList.Add(GetSwimSub2Description(DateTime.Now)); } if (membershipOptions.EnglandAthleticsMembership) { descriptionList.Add("England Athletics Membership"); } if (membershipOptions.OpenWaterIndemnityAcceptance.HasValue && membershipOptions.OpenWaterIndemnityAcceptance.Value == true) { descriptionList.Add("Open Water Swimming"); } return(string.Join(", ", descriptionList)); }
private void SetMembershipOptions(IMember member, MemberOptions membershipOptions, DateTime membershipExpiry, bool zeroSwimCredits) { // Fix for swim subs renewal bug if (member.GetValue <string>(MemberProperty.swimSubs2)?.Length > 0) { member.SetValue(MemberProperty.swimSubs2ExpiryDate, member.GetValue <DateTime>(MemberProperty.MembershipExpiry)); } member.SetValue(MemberProperty.membershipType, (int)membershipOptions.MembershipType); member.SetValue(MemberProperty.OpenWaterIndemnityAcceptance, membershipOptions.OpenWaterIndemnityAcceptance); member.SetValue(MemberProperty.swimSubs1, membershipOptions.SwimSubs1 ? GetSwimSub1Description(DateTime.Now) : string.Empty); member.SetValue(MemberProperty.swimSubs2, membershipOptions.SwimSubs2 ? GetSwimSub2Description(DateTime.Now) : string.Empty); member.SetValue(MemberProperty.EnglandAthleticsMembership, membershipOptions.EnglandAthleticsMembership); member.SetValue(MemberProperty.Volunteering, membershipOptions.Volunteering); member.SetValue(MemberProperty.MembershipExpiry, membershipExpiry); if (zeroSwimCredits) { member.SetValue(MemberProperty.TrainingCredits, 0); } member.SetValue(MemberProperty.GuestCode, membershipOptions.GuestCode); member.SetValue(MemberProperty.ReferredByMember, membershipOptions.ReferredByMember); if (membershipOptions.OpenWaterIndemnityAcceptance.Value) { int swimAuthNumber = GetSwimAuthNumber(membershipOptions.MembershipType.Value); member.SetValue(MemberProperty.SwimAuthNumber, swimAuthNumber); } }
public ProposedMap CreateMapProposal(TypePair pair, MemberOptions options = null, LambdaExpression customMappingExpression = null, params Type[] parameters) { var mapperOptions = GetMapperOptions(mapper, pair.SourceType, pair.DestinationType); var processor = new StrategyProcessor(this, mapper, mappingCache, customMappingCache, mapperOptions); return(processor.CreateMapProposal(pair, options, customMappingExpression, parameters)); }
/// <summary> /// /// </summary> /// <param name="view">MemberOptions</param> /// <returns>MemberOptions</returns> internal virtual MemberOptions ToEntity(MemberOptions view = null) { if (view == null) { view = new MemberOptions(); } return(view); }
public ActionResult Register(PersonalDetails personalDetails, GuestOptions guestOptions) { if (!ModelState.IsValid) { return(CurrentUmbracoPage()); } var existingMember = Services.MemberService.GetByEmail(personalDetails.Email); if (existingMember != null) { ModelState.AddModelError("Email", "There is already a member registered with the supplied email address."); return(CurrentUmbracoPage()); } if (_guestRegistrationPage == null || !_guestRegistrationPage.GuestCodes.Contains(guestOptions.GuestCode, StringComparer.OrdinalIgnoreCase)) { ModelState.AddModelError("GuestCode", "The guest code does not match any available codes."); return(CurrentUmbracoPage()); } Logger.Info(typeof(RegistrationController), $"New guest registration request: {JsonConvert.SerializeObject(personalDetails)}"); string rootUrl = string.Format("{0}://{1}{2}", Request.Url.Scheme, Request.Url.Host, Request.Url.Port == 80 ? string.Empty : ":" + Request.Url.Port); string successUrl = string.Format("{0}/the-club/confirm-registration", rootUrl); //TODO - Register guest var member = _memberProvider.CreateMember(personalDetails, new string[] { MSTCRoles.Guest }); var memberOptions = new MemberOptions() { MembershipType = MembershipTypeEnum.Guest, OpenWaterIndemnityAcceptance = guestOptions.OpenWaterIndemnityAcceptance, GuestCode = guestOptions.GuestCode, }; _memberProvider.UpdateMemberDetails(member, personalDetails, memberOptions); //Login the member FormsAuthentication.SetAuthCookie(member.Username, true); string content = GetRegEmailContent(personalDetails, guestOptions); _emailProvider.SendEmail(EmailProvider.MembersEmail, EmailProvider.SupportEmail, "New MSTC guest registration", content); var model = new RegistrationCompleteModel() { PromptForConfirmation = false, IsRegistered = true }; TempData["Model"] = model; return(Redirect(successUrl)); }
internal MemberOptionsVm(MemberOptions view = null) { if (view == null) { return; } _emailToken = view.EmailToken; _resetToken = view.ResetToken; _isValidated = view.IsValidated; }
public AncestryBrowserWindowViewModel(TypeInfo typeInfo) { _typeInfo = typeInfo; ExpandCollapseAllCommand = new DelegateCommand(ExpandCollapseAllCommandHandler); _options = new MemberOptions { ShowProperties = true, ShowEvents = true, ShowMethods = true, ShowProtected = true, ShowProtectedInternal = true, ShowPublic = true }; _typeViewModel = new TypeViewModel(_typeInfo); _ancestry = _typeViewModel.Ancestry.ToList(); _ancestry.Last().IsLast = true; _assemblies = _ancestry .GroupBy(t => t.TypeInfo.Module.Assembly) .Select(g => new AssemblyViewModel(g.Key, g)) .ToList(); int currentIndex = 0; foreach (var assembly in _assemblies) { var brush = BrushProvider.BrushPairs[currentIndex].Background as SolidColorBrush; brush = new SolidColorBrush( new Color { A = 72, R = brush.Color.R, G = brush.Color.G, B = brush.Color.B}); assembly.BackgroundBrush = brush; assembly.CaptionBrush = BrushProvider.BrushPairs[currentIndex].Caption; currentIndex++; if (currentIndex == BrushProvider.BrushPairs.Count) { currentIndex = 0; } } KindGroup = new CommandsGroupViewModel( Resources.Members, new List<GroupedUserCommand> { new GroupedUserCommand(Resources.All, ShowAllMemberKinds, true), new GroupedUserCommand(Resources.Virtual, ShowVirtualMembers) }); UpdateMembers(); FillToolTips(); }
public ActionResult Register(MemberOptions memberOptions, PersonalDetails personalDetails) { if (!ModelState.IsValid) { return(CurrentUmbracoPage()); } var member = Services.MemberService.GetByEmail(personalDetails.Email); if (member != null) { ModelState.AddModelError("Email", "There is already a member registered with the supplied email address."); return(CurrentUmbracoPage()); } var model = new RegistrationDetails() { PersonalDetails = personalDetails, MemberOptions = memberOptions }; _sessionProvider.RegistrationDetails = model; Logger.Info(typeof(RegistrationController), $"New member registration request: {JsonConvert.SerializeObject(model)}"); var customerDto = new CustomerDto() { GivenName = model.PersonalDetails.FirstName, FamilyName = model.PersonalDetails.LastName, AddressLine1 = model.PersonalDetails.Address1, City = model.PersonalDetails.City, PostalCode = model.PersonalDetails.Postcode, Email = model.PersonalDetails.Email }; string scheme = _goCardlessProvider.Environment == GoCardlessClient.Environment.LIVE ? "Https" : Request.Url.Scheme; string rootUrl = string.Format("{0}://{1}{2}", scheme, Request.Url.Host, Request.Url.Port == 80 ? string.Empty : ":" + Request.Url.Port); string successUrl = string.Format("{0}/the-club/confirm-registration", rootUrl); var redirectResponse = _goCardlessProvider.CreateRedirectRequest(Logger, customerDto, "MSTC Member Registration", _sessionProvider.SessionId, successUrl); if (redirectResponse.HasError) { ModelState.AddModelError("", redirectResponse.Error); return(CurrentUmbracoPage()); } _sessionProvider.GoCardlessRedirectFlowId = redirectResponse.Id; return(Redirect(redirectResponse.RedirectUrl)); }
public void UpdateMemberOptions(IMember member, MemberOptions membershipOptions, bool isUpgrade) { var membershipExpiry = GetNewMemberExpiry(DateTime.Now); bool zeroSwimCredits = false; SetMembershipOptions(member, membershipOptions, membershipExpiry, zeroSwimCredits); if (isUpgrade) { string username = member.Email; Roles.RemoveUserFromRole(username, MSTCRoles.Guest); Roles.AddUserToRole(username, MSTCRoles.Member); } }
public PropertyMetaData( PropertyInfo propertyInfo, AoMemberAttribute memberAttribute, AoFlagsAttribute flagsAttribute, AoUsesFlagsAttribute[] usesFlagsAttributes) { this.propertyInfo = propertyInfo; this.flagsAttribute = flagsAttribute; this.usesFlagsAttributes = usesFlagsAttributes; this.options = new MemberOptions( this.propertyInfo.PropertyType, memberAttribute.IsFixedSize, memberAttribute.FixedSizeLength, memberAttribute.SerializeSize, memberAttribute.PadAfter, memberAttribute.PadBefore, usesFlagsAttributes); }
public static List <MemberEntry <T> > GenerateList <T>(MemberOptions options) { PropertyInfo[] properties = (options & MemberOptions.Properties) == 0 ? new PropertyInfo[0] : typeof(T).GetProperties(bf); FieldInfo[] fields = (options & MemberOptions.Fields) == 0 ? new FieldInfo[0] : typeof(T).GetFields(bf); var members = properties.Where(p => p.GetIndexParameters().Length == 0).Cast <MemberInfo>() .Concat(fields.Cast <MemberInfo>()).OrderBy(e => e.MetadataToken).ToArray(); var result = members.Select(m => new MemberEntry <T>( m.Name, m, options.IsSet(MemberOptions.Getter | MemberOptions.Typed) ? ReflectionTools.CreateGetter <T>(m) : null, options.IsSet(MemberOptions.Getter | MemberOptions.Untyped) ? ReflectionTools.CreateGetterUntyped(typeof(T), m) : null, options.IsSet(MemberOptions.Setters | MemberOptions.Typed) ? ReflectionTools.CreateSetter <T>(m) : null, options.IsSet(MemberOptions.Setters | MemberOptions.Untyped) ? ReflectionTools.CreateSetterUntyped(typeof(T), m) : null )).ToList(); return(result); }
private void GenerateEnumerableMapping(int currentDepth, MemberOptions options, CustomMapping customMapping, ProposedTypeMapping typeMapping, PropertyOrFieldInfo destinationMember, PropertyOrFieldInfo sourceMember) { var typeOfSourceEnumerable = CollectionTypeHelper.GetTypeInsideEnumerable(sourceMember.PropertyOrFieldType); var typeOfDestinationEnumerable = CollectionTypeHelper.GetTypeInsideEnumerable(destinationMember.PropertyOrFieldType); var canAssignSourceItemsToDestination = CanAssignSourceItemsToDestination(destinationMember, sourceMember, typeOfSourceEnumerable, typeOfDestinationEnumerable); if (canAssignSourceItemsToDestination) { typeMapping.ProposedTypeMappings.Add( new ProposedTypeMapping { DestinationMember = destinationMember, SourceMember = sourceMember, ProposedMappings = new List <ProposedMemberMapping>() }); } else { var complexPair = new TypePair(typeOfSourceEnumerable, typeOfDestinationEnumerable); var complexTypeMapping = GetComplexTypeMapping(currentDepth + 1, complexPair, options, customMapping); if (complexTypeMapping != null) { complexTypeMapping = complexTypeMapping.Clone(); complexTypeMapping.DestinationMember = destinationMember; complexTypeMapping.SourceMember = sourceMember; CustomMapping customMappingForType; TryGetCustomMapping(complexPair, out customMappingForType); complexTypeMapping.CustomMapping = customMappingForType; typeMapping.ProposedTypeMappings.Add(complexTypeMapping); } else { typeMapping.DoNotCache = true; } } }
public void ConversionIsCarriedOverToSubtypes() { var mapper = new MemberMapper(); MemberOptions func = new MemberOptions((ctx, options) => { if (typeof(IDataModel).IsAssignableFrom(ctx.Source.DeclaringType) && typeof(DtoBase).IsAssignableFrom(ctx.Destination.DeclaringType)) { options.Convert <DateTime, DateTime>(d => d.ToUniversalTime()); } }); mapper.CreateMap <Customer, CustomerDto>(options: func); var result = mapper.Map <Customer, CustomerDto>(new Customer { CreationTime = DateTime.Now }); Assert.AreEqual(DateTimeKind.Utc, result.CreationTime.Kind); }
public int Calculate(MemberOptions membershipOptions, DateTime currentDate) { var cost = GetTypeCostPence(membershipOptions.MembershipType.Value, currentDate); if (membershipOptions.SwimSubs1) { cost += SwimsSubsCostInPence(membershipOptions.MembershipType.Value); } if (membershipOptions.SwimSubs2) { cost += SwimsSubsCostInPence(membershipOptions.MembershipType.Value); } if (membershipOptions.EnglandAthleticsMembership) { cost += EnglandAthleticsCostInPence; } if (membershipOptions.OpenWaterIndemnityAcceptance.HasValue && membershipOptions.OpenWaterIndemnityAcceptance.Value == true) { cost += OwsSignupCostPence; } return(cost); }
public ActionResult Renew(MemberOptions model) { var member = _memberProvider.GetLoggedInMember(); if (!ModelState.IsValid || member == null) { return(CurrentUmbracoPage()); } _sessionProvider.RenewalOptions = model; var membershipType = member.GetValue <MembershipTypeEnum>(MemberProperty.membershipType); bool isRenewing = membershipType != MembershipTypeEnum.Guest; Logger.Info(typeof(RenewController), $"Member {(isRenewing ? "renewal" : "upgrade")} request: {member.Email}, {JsonConvert.SerializeObject(model)}"); PaymentStates state = isRenewing ? PaymentStates.MemberRenewal : PaymentStates.MemberUpgrade; _sessionProvider.CanProcessPaymentCompletion = true; var redirectUrl = $"/Payment?state={state}"; return(Redirect(redirectUrl)); }
public static List <MemberEntry <T> > GenerateList <T>(MemberOptions options, Type?type = null) { if (type != null && !typeof(T).IsAssignableFrom(type)) { throw new InvalidOperationException($"Type {type} is assignable {typeof(T)}"); } var finalType = type ?? typeof(T); PropertyInfo[] properties = (options & MemberOptions.Properties) == 0 ? new PropertyInfo[0] : typeof(T).GetProperties(bf); FieldInfo[] fields = (options & MemberOptions.Fields) == 0 ? new FieldInfo[0] : typeof(T).GetFields(bf); var members = properties.Where(p => p.GetIndexParameters().Length == 0).Cast <MemberInfo>() .Concat(fields.Cast <MemberInfo>()).OrderBy(e => e.MetadataToken).ToArray(); var result = members.Select(m => new MemberEntry <T>( m.Name, m, options.IsSet(MemberOptions.Getter) ? ReflectionTools.CreateGetter <T, object?>(m) : null, options.IsSet(MemberOptions.Setters) ? ReflectionTools.CreateSetter <T, object?>(m) : null )).ToList(); return(result); }
public FunctionPointCounter(MemberOptions memberOptions) : this() { this.MemberOption = memberOptions; }
/// <summary> /// Returns a type mapping of the TypePair you pass in. /// </summary> /// <returns></returns> private ProposedTypeMapping GetTypeMapping(int currentDepth, TypePair pair, MemberOptions options = null, CustomMapping customMapping = null) { if (!typeStack.Contains(pair)) { typeStack.Push(pair); } else if (this.options.Safety.IfRecursiveRelationshipIsDetected == RecursivePropertyOptions.ThrowIfRecursionIsDetected) { // Oh noes, recursion! throw new RecursiveRelationshipException(pair); } // if it's a recursive relationship, by default we return null which is handled after the method returns else { return(null); } var typeMapping = new ProposedTypeMapping(); typeMapping.SourceMember = null; typeMapping.DestinationMember = null; Type destinationType, sourceType; // If it's an enumerable type (List<>, IEnumerable<>, etc) then we're currently interested // in the type 'inside' the enumerable. if (CollectionTypeHelper.IsEnumerable(pair.DestinationType)) { destinationType = CollectionTypeHelper.GetTypeInsideEnumerable(pair.DestinationType); } else { destinationType = pair.DestinationType; } // Same here. if (CollectionTypeHelper.IsEnumerable(pair.SourceType)) { sourceType = CollectionTypeHelper.GetTypeInsideEnumerable(pair.SourceType); } else { sourceType = pair.SourceType; } // The memberprovider is responsible for linking a destination member with a source member var memberProvider = this.strategy.MemberProviderFactory.GetMemberProvider(sourceType, destinationType, mapper); // Loop through all members it could find foreach (var mapping in GetTypeMembers(memberProvider, options, currentDepth)) { var destinationMember = mapping.Destination; var sourceMember = mapping.Source; // Does the memberprovider see any reason to ignore this member? if (memberProvider.IsMemberIgnored(sourceType, destinationMember)) { continue; } Expression customExpression = null; // Try to extract an expression that was supplied for this destination member if (customMapping != null) { customExpression = customMapping.GetExpressionForMember(destinationMember); if (mapping.ConversionFunction == null) { var conversionFunction = customMapping.GetConversionFunction(sourceMember, destinationMember); mapping.ConversionFunction = conversionFunction; } } // Did the user supply a function to transform the source member's value? if (mapping.ConversionFunction != null) { // If no custom mapping yet, then we need to create one // as it's where we'll be storing the conversion function if (customMapping == null) { customMapping = new CustomMapping { DestinationType = destinationType }; customMappingCache.AddOrUpdate(pair, customMapping, (k, v) => customMapping); typeMapping.CustomMapping = customMapping; } // Let the custom mapping be the owner of the conversion function customMapping.AddConversionFunction(sourceMember, destinationMember, mapping.ConversionFunction); } else if (customMapping != null) { } ProposedHierarchicalMapping hierarchicalMapping = null; // No source member or can't write to the destination? if (HasNoSourceMember(customExpression, sourceMember) || !destinationMember.CanWrite) { if (this.options.Conventions.AutomaticallyFlattenHierarchies) { // Propose a mapping that flattens a hierarchy if possible. // For example, map type.CompanyName to otherType.Company.Name hierarchicalMapping = memberProvider.ProposeHierarchicalMapping(destinationMember); } // No way to map this thing? Add it to incompatible members if the option has been turned on. // Will cause an (intended) exception later on, allowing you to verify your mappings // for correctness and completeness. if (hierarchicalMapping == null && this.options.Strictness.ThrowWithoutCorrespondingSourceMember) { typeMapping.IncompatibleMappings.Add(destinationMember); } } // Nullable value types screw up everything! var nullableType = NullableTypeHelper.TryGetNullableType(sourceMember); // Can we do a simple right to left assignment between the members? // So, are they basically the same type or do we need to do further mapping? var canUseSimpleTypeMapping = CanUseDirectAssignment(pair, destinationMember, sourceMember, nullableType, hierarchicalMapping); if (canUseSimpleTypeMapping) { // If simple mapping is possible create a mapping between the members typeMapping.ProposedMappings.Add ( new ProposedMemberMapping { SourceMember = sourceMember, DestinationMember = destinationMember, HierarchicalMapping = hierarchicalMapping } ); } // No simple assignment, but a custom expression is supplied // and that's just as good as having a direct assignment mapping else if (customExpression != null || mapping.ConversionFunction != null) { typeMapping.ProposedMappings.Add ( new ProposedMemberMapping { SourceMember = sourceMember, DestinationMember = destinationMember, HierarchicalMapping = hierarchicalMapping } ); } // We have a source member but can't directly assign the source to the destination. // Further mapping is needed. else if (sourceMember != null) { // Is the member of an IEnumerable type? if (AreMembersIEnumerable(destinationMember, sourceMember)) { // Create a deeper mapping for IEnumerable members GenerateEnumerableMapping(currentDepth, options, customMapping, typeMapping, destinationMember, sourceMember); } else { // Create a deeper mapping for a 'regular' type. GenerateComplexTypeMapping(currentDepth, options, customMapping, typeMapping, destinationMember, sourceMember); } } // All we have is a destination member and a custom expression // that gives the destination member a value. Good enough! else if (customExpression != null) { typeMapping.ProposedMappings.Add ( new ProposedMemberMapping { SourceMember = null, DestinationMember = destinationMember } ); } } // Don't cache the typemapping when this flag has been set. // That happens when the maximum depth was reached during the mapping // for this particular type and we didn't explore the full depth // of the type. We don't wanna reuse this typemapping at a later time // because the mapping might be for something completely different // at a depth at which the full depth CAN be explored. if (!typeMapping.DoNotCache) { mappingCache[pair] = typeMapping; } typeStack.Pop(); return(typeMapping); }
private IEnumerable <SourceDestinationMapping> GetTypeMembers(IMemberProvider memberProvider, MemberOptions options, int currentDepth) { var destinationMembers = memberProvider.GetDestinationMembers(); foreach (var destinationMember in destinationMembers) { var destination = destinationMember; var sourceMember = memberProvider.GetMatchingSourceMember(destinationMember); LambdaExpression conversion = null; // User supplied a custom method that can influence the mapping if (options != null) { // A class that allows you to customize a few things about a mapping var option = new MemberOption(sourceMember, destinationMember); var ctx = new MappingContext(sourceMember, destinationMember, currentDepth, this.mapper); // Execute the user supplied function options(ctx, option); conversion = option.ConversionFunction; switch (option.State) { // User indicated in the `options` method that he wants to ignore the member case MemberOptionState.Ignored: continue; } // Source member is set if (option.Source != null) { // If the user supplied an invalid source member if (option.Source.DeclaringType != sourceMember.DeclaringType) { throw new InvalidOperationException("Cannot use member declared on another type."); } sourceMember = option.Source; } // Destination member is set if (option.Destination != null) { // If the user supplied an invalid destination member if (option.Destination.DeclaringType != destination.DeclaringType) { throw new InvalidOperationException("Cannot use member declared on another type."); } destination = option.Destination; } } // Simple container class var mapping = new SourceDestinationMapping { Source = sourceMember, Destination = destination, ConversionFunction = conversion }; yield return(mapping); } }
public AstCreationVisitor(ParsedContracts contracts) { _contracts = contracts; _currentMemberOptions = new MemberOptions(); }
public void UpdateMembers(MemberOptions options) { ResetMembers(_events); ResetMembers(_fields); ResetMembers(_methods); ResetMembers(_properties); IEnumerable<MemberViewModel> members = new MemberViewModel[0]; if (options.ShowFields) { members = members.Concat(_fields); } if (options.ShowProperties) { members = members.Concat(_properties); } if (options.ShowEvents) { members = members.Concat(_events); } if (options.ShowMethods) { members = members.Concat(_methods); } if (!options.ShowPrivate) { members = members.Where(m => !m.IsPrivate); } if (!options.ShowInternal) { members = members.Where(m => !m.IsInternal); } if (!options.ShowProtected) { members = members.Where(m => !m.IsProtected); } if (!options.ShowProtectedInternal) { members = members.Where(m => !m.IsProtectedInternal); } if (!options.ShowPublic) { members = members.Where(m => !m.IsPublic); } if (!string.IsNullOrWhiteSpace(options.SearchTerm)) { members = members.Where(m => m.MemberInfo.Name.IndexOf(options.SearchTerm.Trim(), StringComparison.InvariantCultureIgnoreCase) >= 0); } if (options.MemberKind == MemberKind.Virtual) { members = members.OfType<ICanBeVirtual>().Where(m => m.IsVirtual).OfType<MemberViewModel>(); foreach (var member in members) { var maybeVirtualMember = member as ICanBeVirtual; if (maybeVirtualMember.IsOverride) { member.IsMarked = true; } } } Members = members.ToArray(); }
static bool IsSet(this MemberOptions options, MemberOptions flags) { return((options & flags) == flags); }
public ProposedMap <TSource, TDestination, TParam> CreateMapProposal <TSource, TDestination, TParam>(MemberOptions options = null, Expression <Func <TSource, TParam, object> > customMappingExpression = null) { var map = new ProposedMap <TSource, TDestination, TParam>(this.mapper, this.options); map.ParameterTypes.Add(typeof(TParam)); var pair = new TypePair(typeof(TSource), typeof(TDestination)); CustomMapping customMapping = null; //if (customMappingExpression != null) //{ // customMapping = CustomMapping.GetCustomMapping(typeof(TDestination), customMappingExpression); // customMappingCache[pair] = customMapping; //} customMapping = GetCustomMappingFromExpression(pair, customMappingExpression, customMapping); TryGetCustomMapping(pair, out customMapping); var mapping = GetComplexTypeMapping(0, pair, options ?? mapper.DefaultMemberOptions, customMapping, true); if (mapping.CustomMapping == null) { mapping.CustomMapping = customMapping; } map.ProposedTypeMapping = mapping; return(map); }
public void ConversionToUtcTimeWorks() { var mapper = new MemberMapper(); MemberOptions func = new MemberOptions((ctx, options) => { if (ctx.Source.DeclaringType == typeof(SourceDate)) { options.Convert<DateTime, DateTime>(d => d.ToUniversalTime()); } else { options.Convert<DateTime, DateTime>(d => d.ToLocalTime()); } }); mapper.CreateMap<SourceDate, DestinationDate>(options: func); mapper.CreateMap<DestinationDate, SourceDate>(options: func); var result = mapper.Map(new SourceDate { Start = DateTime.Now }, new DestinationDate()); Assert.AreEqual(DateTimeKind.Utc, result.Start.Kind); var reverse = mapper.Map(new DestinationDate { Start = DateTime.Now }, new SourceDate()); Assert.AreEqual(DateTimeKind.Local, reverse.Start.Kind); }
public void ConversionIsCarriedOverToSubtypes() { var mapper = new MemberMapper(); MemberOptions func = new MemberOptions((ctx, options) => { if (typeof(IDataModel).IsAssignableFrom(ctx.Source.DeclaringType) && typeof(DtoBase).IsAssignableFrom(ctx.Destination.DeclaringType)) { options.Convert<DateTime, DateTime>(d => d.ToUniversalTime()); } }); mapper.CreateMap<Customer, CustomerDto>(options: func); var result = mapper.Map<Customer, CustomerDto>(new Customer { CreationTime = DateTime.Now }); Assert.AreEqual(DateTimeKind.Utc, result.CreationTime.Kind); }
private ProposedTypeMapping GetComplexTypeMapping(int currentDepth, TypePair complexPair, MemberOptions options, CustomMapping customMapping, bool skipCache = false) { if (complexPair.SourceType == complexPair.DestinationType) { var maxDepth = this.options.Cloning.MaxCloneDepth; if (maxDepth.HasValue && currentDepth > maxDepth) { return(null); } } else { var maxDepth = this.options.Conventions.MaxDepth; if (maxDepth.HasValue && currentDepth > maxDepth) { return(null); } } ProposedTypeMapping complexTypeMapping; if (skipCache || !mappingCache.TryGetValue(complexPair, out complexTypeMapping)) { ProposedMap proposedMap; if (mapper.MapRepository != null && mapper.MapRepository.TryGetMap(mapper, options, complexPair, out proposedMap)) { complexTypeMapping = proposedMap.ProposedTypeMapping; } else { complexTypeMapping = GetTypeMapping(currentDepth, complexPair, options, customMapping); } } return(complexTypeMapping); }
public ProposedMap <TSource, TDestination, TParam> CreateMapProposal <TSource, TDestination, TParam>(MemberOptions options = null, Expression <Func <TSource, TParam, object> > customMappingExpression = null) { var mapperOptions = GetMapperOptions(mapper, typeof(TSource), typeof(TDestination)); var processor = new StrategyProcessor(this, mapper, mappingCache, customMappingCache, mapperOptions); return(processor.CreateMapProposal <TSource, TDestination, TParam>(options, customMappingExpression)); }
//Each element in the IList is a MemberEntry<T> with typeof(T) == type. //You can acces them in a untyped fashion using IMemberEntry public static IList GenerateIList(Type type, MemberOptions options) { return(mi1.GetInvoker(type).Invoke(options)); }
public override AstNode?VisitPragmaDefinition(PragmaDefinitionContext context) { var pragmaName = context.name?.token?.Text; if (string.IsNullOrEmpty(pragmaName)) { _contracts.AddError(context, "Missing pragma name"); return(null); } var optionDescriptor = _contracts.Options.GetOptionDescriptor(pragmaName); if (optionDescriptor != null) { if (!_definedContractOptions.Add(pragmaName)) { _contracts.AddError(context.name, "Duplicate file-level pragma: {0}", pragmaName); return(null); } if (_hasDefinitions) { _contracts.AddError(context, "File-level pragma {0} should be set at the top of the file", pragmaName); } } else { _currentMemberOptions = _currentMemberOptions.Clone(); optionDescriptor = _currentMemberOptions.GetOptionDescriptor(pragmaName); if (optionDescriptor == null) { _contracts.AddError(context.name, "Unknown pragma: '{0}'", pragmaName); return(null); } } pragmaName = optionDescriptor.Name; var value = context._valueTokens.Count > 0 ? context._valueTokens.First().token.GetFullTextUntil(context._valueTokens.Last().token) : null; if (value == null) { if (optionDescriptor.IsBoolean) { value = context.not == null ? "true" : "false"; } else { _contracts.AddError(context, "Pragma {0} expects a value", pragmaName); return(null); } } if (!optionDescriptor.SetValue(value)) { _contracts.AddError(context, "Invalid option value: '{0}' for {1}", value, pragmaName); } return(null); }