protected override string CreateMessage(Type dtoType) { var requestObj = AutoMappingUtils.PopulateWith(Activator.CreateInstance(dtoType)); var xml = DataContractSerializer.Instance.Parse(requestObj, true); var soapEnvelope = $@"<?xml version=""1.0"" encoding=""utf-8""?> <soap:Envelope xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns:soap=""http://schemas.xmlsoap.org/soap/envelope/""> <soap:Body> {xml} </soap:Body> </soap:Envelope>"; return(soapEnvelope); }
public void Populate_From_Properties_With_Attribute() { var originalToObj = ModelWithOnlyStringFields.Create("id-1"); var toObj = ModelWithOnlyStringFields.Create("id-1"); var fromObj = ModelWithOnlyStringFields.Create("id-2"); AutoMappingUtils.PopulateFromPropertiesWithAttribute(toObj, fromObj, typeof(IndexAttribute)); Assert.That(toObj.Id, Is.EqualTo(originalToObj.Id)); Assert.That(toObj.AlbumId, Is.EqualTo(originalToObj.AlbumId)); //Properties with IndexAttribute Assert.That(toObj.Name, Is.EqualTo(fromObj.Name)); Assert.That(toObj.AlbumName, Is.EqualTo(fromObj.AlbumName)); }
public void Populate_Same_Objects() { var toObj = ModelWithFieldsOfDifferentTypes.Create(1); var fromObj = ModelWithFieldsOfDifferentTypes.Create(2); var obj3 = AutoMappingUtils.PopulateWith(toObj, fromObj); Assert.IsTrue(obj3 == toObj); Assert.That(obj3.Bool, Is.EqualTo(fromObj.Bool)); Assert.That(obj3.DateTime, Is.EqualTo(fromObj.DateTime)); Assert.That(obj3.Double, Is.EqualTo(fromObj.Double)); Assert.That(obj3.Guid, Is.EqualTo(fromObj.Guid)); Assert.That(obj3.Id, Is.EqualTo(fromObj.Id)); Assert.That(obj3.LongId, Is.EqualTo(fromObj.LongId)); Assert.That(obj3.Name, Is.EqualTo(fromObj.Name)); }
public void Should_Convert_LocalDate_To_DateTime() { MapperConfig.RegisterLocalDateToDateTimeConverter(); var map = new Dictionary <string, object> { { nameof(EntityWithClrTypes.DateValue), new LocalDate(2019, 1, 12) } }; var entity = ValueMapper.MapValue <EntityWithClrTypes>(map); entity.DateValue.Year.Should().Be(2019); entity.DateValue.Month.Should().Be(1); entity.DateValue.Day.Should().Be(12); AutoMappingUtils.Reset(); }
public void Should_Convert_LocalDate_To_DateTime() { Neo4jMapperConfig.RegisterLocalDateToDateTimeConverter(); var map = new Dictionary <string, object> { { nameof(EntityWithClrTypes.DateValue), new LocalDate(2019, 1, 12) } }; var entity = ValueMapper.MapValue <EntityWithClrTypes>(map); Assert.AreEqual(2019, entity.DateValue.Year); Assert.AreEqual(1, entity.DateValue.Month); Assert.AreEqual(12, entity.DateValue.Day); AutoMappingUtils.Reset(); }
private void AssertLocalTimeConvertersAreRegistered() { var localTimeToTimeSpanConverter = AutoMappingUtils.GetConverter(typeof(LocalTime), typeof(TimeSpan)); localTimeToTimeSpanConverter.Should().NotBeNull(); var localTimeToNullableTimeSpanConverter = AutoMappingUtils.GetConverter(typeof(LocalTime), typeof(TimeSpan?)); localTimeToNullableTimeSpanConverter.Should().NotBeNull(); var timeSpanToLocalTimeConverter = AutoMappingUtils.GetConverter(typeof(TimeSpan), typeof(LocalTime)); timeSpanToLocalTimeConverter.Should().NotBeNull(); var nullableTimeSpanToLocalTimeConverter = AutoMappingUtils.GetConverter(typeof(TimeSpan?), typeof(LocalTime)); nullableTimeSpanToLocalTimeConverter.Should().NotBeNull(); }
private void AssertLocalDateConvertersAreRegistered() { var localDateToDateTimeConverter = AutoMappingUtils.GetConverter(typeof(LocalDate), typeof(DateTime)); localDateToDateTimeConverter.Should().NotBeNull(); var localDateToNullableDateTimeConverter = AutoMappingUtils.GetConverter(typeof(LocalDate), typeof(DateTime?)); localDateToNullableDateTimeConverter.Should().NotBeNull(); var dateTimeToLocalDateTimeConverter = AutoMappingUtils.GetConverter(typeof(DateTime), typeof(LocalDate)); dateTimeToLocalDateTimeConverter.Should().NotBeNull(); var nullableDateTimeToLocalDateTimeConverter = AutoMappingUtils.GetConverter(typeof(DateTime?), typeof(LocalDate)); nullableDateTimeToLocalDateTimeConverter.Should().NotBeNull(); }
private void AssertZonedDateTimeConvertersAreRegistered() { var zonedDateTimeToDateTimeOffsetConverter = AutoMappingUtils.GetConverter(typeof(ZonedDateTime), typeof(DateTimeOffset)); zonedDateTimeToDateTimeOffsetConverter.Should().NotBeNull(); var zonedDateTimeToNullableDateTimeOffsetConverter = AutoMappingUtils.GetConverter(typeof(ZonedDateTime), typeof(DateTimeOffset?)); zonedDateTimeToNullableDateTimeOffsetConverter.Should().NotBeNull(); var dateTimeOffsetToZonedDateTimeConverter = AutoMappingUtils.GetConverter(typeof(DateTimeOffset), typeof(ZonedDateTime)); dateTimeOffsetToZonedDateTimeConverter.Should().NotBeNull(); var nullableDateTimeOffsetToZonedDateTimeConverter = AutoMappingUtils.GetConverter(typeof(DateTimeOffset?), typeof(ZonedDateTime)); nullableDateTimeOffsetToZonedDateTimeConverter.Should().NotBeNull(); }
public void Should_Convert_Enum_Type_To_String() { var entity = new MovieWithType { Title = "Top Gun", Released = 1986, Tagline = "As students at the United States Navy's elite fighter weapons school compete to be best in the class, one daring young pilot learns a few things from a civilian instructor that are not taught in the classroom.", MovieType = MovieType.Action }; try { AutoMapping.RegisterConverter <MovieWithType, Dictionary <string, object> >(movieWithType => { var dictionary = movieWithType.ConvertTo <Dictionary <string, object> >(true); dictionary[nameof(movieWithType.MovieType)] = movieWithType.MovieType.ToString(); return(dictionary); }); var parameter = entity.ToParameterMap("entity"); Assert.AreEqual("entity", parameter.Key); Assert.AreEqual(4, parameter.Value.Count); Assert.IsTrue(parameter.Value.ContainsKey("Title")); var titleValue = parameter.Value["Title"]; Assert.IsInstanceOf <string>(titleValue); Assert.AreEqual("Top Gun", titleValue); Assert.IsTrue(parameter.Value.ContainsKey("Released")); var releasedValue = parameter.Value["Released"]; Assert.IsInstanceOf <int>(releasedValue); Assert.AreEqual(1986, releasedValue); Assert.IsTrue(parameter.Value.ContainsKey("MovieType")); var movieTypeValue = parameter.Value["MovieType"]; Assert.IsInstanceOf <string>(movieTypeValue); Assert.AreEqual("Action", movieTypeValue); } finally { AutoMappingUtils.Reset(); } }
public void Should_Not_Throw_Exception_When_Multiple_Same_Type_CustomTypeConverters_Found() { AutoMappingUtils.RegisterConverter((DateTimeOffset from) => new WrappedDateTimeOffset(from)); var personWithWrappedDateOfBirth = new PersonWithWrappedDateOfBirth { DateOfBirth = new WrappedDateTimeOffset( new DateTimeOffset(1971, 3, 23, 4, 30, 0, TimeSpan.Zero)) }; var personWithDoB = personWithWrappedDateOfBirth.ConvertTo <PersonWithDateOfBirth>(); // Object returned but mapping failed Assert.That(personWithDoB.FirstName, Is.Null); Assert.That(personWithDoB.LastName, Is.Null); Assert.That(personWithDoB.DateOfBirth, Is.EqualTo(DateTimeOffset.MinValue)); AutoMappingUtils.Reset(); }
public void Can_Convert_POCO_collections_with_custom_Converter() { AutoMapping.RegisterConverter((User from) => { var to = from.ConvertTo <UserDto>(skipConverters: true); // avoid infinite recursion to.FirstName += "!"; to.LastName += "!"; return(to); }); AutoMapping.RegisterConverter((Car from) => $"{from.Name} ({from.Age})"); var user = new User { FirstName = "John", LastName = "Doe", Car = new Car { Name = "BMW X6", Age = 3 } }; var users = new UsersData { Id = 1, User = user, UsersList = { user }, UsersMap = { { 1, user } } }; var dtoUsers = users.ConvertTo <UsersDto>(); Assert.That(dtoUsers.Id, Is.EqualTo(users.Id)); void AssertUser(UserDto userDto) { Assert.That(userDto.FirstName, Is.EqualTo(user.FirstName + "!")); Assert.That(userDto.LastName, Is.EqualTo(user.LastName + "!")); Assert.That(userDto.Car, Is.EqualTo($"{user.Car.Name} ({user.Car.Age})")); } AssertUser(user.ConvertTo <UserDto>()); AssertUser(dtoUsers.User); AssertUser(dtoUsers.UsersList[0]); AssertUser(dtoUsers.UsersMap[1]); AutoMappingUtils.Reset(); }
public void AddMatch(string name, AssignmentMember readMember, AssignmentMember writeMember) { if (AutoMappingUtils.ShouldIgnoreMapping(readMember.Type, writeMember.Type)) { return; } // Ignore mapping collections if Element Types are ignored if (typeof(IEnumerable).IsAssignableFrom(readMember.Type) && typeof(IEnumerable).IsAssignableFrom(writeMember.Type)) { var fromGenericDef = readMember.Type.GetTypeWithGenericTypeDefinitionOf(typeof(IDictionary <,>)); var toGenericDef = writeMember.Type.GetTypeWithGenericTypeDefinitionOf(typeof(IDictionary <,>)); if (fromGenericDef != null && toGenericDef != null) { // Check if to/from Key or Value Types are ignored var fromArgs = fromGenericDef.GetGenericArguments(); var toArgs = toGenericDef.GetGenericArguments(); if (AutoMappingUtils.ShouldIgnoreMapping(fromArgs[0], toArgs[0])) { return; } if (AutoMappingUtils.ShouldIgnoreMapping(fromArgs[1], toArgs[1])) { return; } } else if (readMember.Type != typeof(string) && writeMember.Type != typeof(string)) { var elFromType = readMember.Type.GetCollectionType(); var elToType = writeMember.Type.GetCollectionType(); if (AutoMappingUtils.ShouldIgnoreMapping(elFromType, elToType)) { return; } } } this.AssignmentMemberMap[name] = new AssignmentEntry(name, readMember, writeMember); }
protected override string CreateMessage(Type dtoType) { try { var requestObj = AutoMappingUtils.PopulateWith(Activator.CreateInstance(dtoType)); using var ms = MemoryStreamFactory.GetStream(); HostContext.ContentTypes.SerializeToStreamAsync( new BasicRequest { ContentType = this.ContentType }, requestObj, ms).Wait(); return(ms.ReadToEnd()); } catch (Exception ex) { var error = $"Error serializing type '{dtoType.GetOperationName()}' with custom format '{this.ContentFormat}'"; Log.Error(error, ex); return($"{{Unable to show example output for type '{dtoType.GetOperationName()}' using the custom '{this.ContentFormat}' filter}}{ex.Message}"); } }
public static void PopulateSession(this IAuthSession session, IUserAuth userAuth, List <IAuthTokens> authTokens = null) { if (userAuth == null) { return; } var holdSessionId = session.Id; session.PopulateWith(userAuth); session.Id = holdSessionId; session.UserAuthId = session.UserAuthId ?? userAuth.Id.ToString(CultureInfo.InvariantCulture); session.IsAuthenticated = true; if (authTokens != null) { session.ProviderOAuthAccess = authTokens; } var existingPopulator = AutoMappingUtils.GetPopulator(typeof(IAuthSession), typeof(IUserAuth)); existingPopulator?.Invoke(session, userAuth); }
public void OneTimeTearDown() { AutoMappingUtils.Reset(); }
public void Can_create_Dictionary_default_value() { var obj = (Dictionary <string, ClassWithEnum>)AutoMappingUtils.CreateDefaultValue(typeof(Dictionary <string, ClassWithEnum>), new Dictionary <Type, int>()); Assert.That(obj, Is.Not.Null); }
public static GetMemberDelegate CreateTypeConverter(Type fromType, Type toType) { if (fromType == toType) { return(null); } var converter = AutoMappingUtils.GetConverter(fromType, toType); if (converter != null) { return(converter); } if (fromType == typeof(string)) { return(fromValue => TypeSerializer.DeserializeFromString((string)fromValue, toType)); } if (toType == typeof(string)) { return(o => TypeSerializer.SerializeToString(o).StripQuotes()); } var underlyingToType = Nullable.GetUnderlyingType(toType) ?? toType; var underlyingFromType = Nullable.GetUnderlyingType(fromType) ?? fromType; if (underlyingToType.IsEnum) { if (underlyingFromType.IsEnum || fromType == typeof(string)) { return(fromValue => Enum.Parse(underlyingToType, fromValue.ToString(), ignoreCase: true)); } if (underlyingFromType.IsIntegerType()) { return(fromValue => Enum.ToObject(underlyingToType, fromValue)); } } else if (underlyingFromType.IsEnum) { if (underlyingToType.IsIntegerType()) { return(fromValue => Convert.ChangeType(fromValue, underlyingToType, null)); } } else if (typeof(IEnumerable).IsAssignableFrom(fromType) && underlyingToType != typeof(string)) { return(fromValue => AutoMappingUtils.TryConvertCollections(fromType, underlyingToType, fromValue)); } else if (underlyingToType.IsValueType) { return(fromValue => AutoMappingUtils.ChangeValueType(fromValue, underlyingToType)); } else { return(fromValue => { if (fromValue == null) { return fromValue; } if (toType == typeof(string)) { return fromValue.ToJsv(); } var toValue = toType.CreateInstance(); toValue.PopulateWith(fromValue); return toValue; }); } return(null); }
protected override string CreateMessage(Type dtoType) { var requestObj = AutoMappingUtils.PopulateWith(Activator.CreateInstance(dtoType)); return(requestObj.SerializeAndFormat()); }
protected override string CreateMessage(Type dtoType) { var requestObj = AutoMappingUtils.PopulateWith(dtoType.CreateInstance()); return(JsonDataContractSerializer.Instance.SerializeToString(requestObj)); }
public void Can_create_DTO_with_Stream() { var o = typeof(RawRequest).CreateInstance(); var requestObj = AutoMappingUtils.PopulateWith(o); }
public void PopulateObject_UsesDefinedEnum_OnNestedTypes() { var requestObj = (Dictionary <string, TestClass2>)AutoMappingUtils.CreateDefaultValue(typeof(Dictionary <string, TestClass2>), new Dictionary <Type, int>()); Assert.True(Enum.IsDefined(typeof(TestClassType), requestObj.First().Value.Type)); }
public void PopulateObject_UsesDefinedEnum() { var requestObj = (TestClass2)AutoMappingUtils.PopulateWith(Activator.CreateInstance(typeof(TestClass2))); Assert.True(Enum.IsDefined(typeof(TestClassType), requestObj.Type)); }
public string Parse(Type type) { return(Parse(AutoMappingUtils.PopulateWith(type.CreateInstance()), true)); }