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);
}
