| public Map ( object source, Type, sourceType, Type, destinationType ) : object | ||
| source | object | |
| sourceType | Type, | |
| destinationType | Type, | |
| return | object | |
public async Task <IActionResult> GetMessagesByCustomer(Guid customerId)
{
try
{
var result = _mappingService.Map <DutyMessage, DutyMessageDto>(await _repository.GetByCustomerId(customerId));
return(Ok(result));
}
catch (Exception)
{
return(BadRequest());
}
}
public void WhenMappingLevelAggregation()
{
MappingService mappingService = new MappingService(null);
var searchResultItem1 = new ApprenticeshipSearchResultsItem
{
StandardId = "101",
Title = "Standard 1"
};
var resultList = new List <ApprenticeshipSearchResultsItem> {
searchResultItem1
};
var levels = new Dictionary <int, long?> {
{ 2, 3L }, { 3, 38L }, { 4, 380L }
};
var model = new ApprenticeshipSearchResponse {
TotalResults = 1234L, SearchTerm = "apprenticeship", Results = resultList, AggregationLevel = levels, SelectedLevels = new List <int> {
2
}
};
var mappedResult = mappingService.Map <ApprenticeshipSearchResponse, ApprenticeshipSearchResultViewModel>(model);
mappedResult.AggregationLevel.Count().Should().Be(3);
mappedResult.AggregationLevel.FirstOrDefault(m => m.Value == "2")?.Checked.Should().BeTrue();
mappedResult.AggregationLevel.FirstOrDefault(m => m.Value == "3")?.Checked.Should().BeFalse();
mappedResult.AggregationLevel.FirstOrDefault(m => m.Value == "4")?.Count.Should().Be(380);
}
public UserDto GetUser(Guid userKey, string userProfileOriginator)
{
UserDto userDto = null;
Execute(uow =>
{
var cacheKey = CacheKeyHelper.GetCacheKey <UserDto>(userKey);
userDto = uow.Cache.GetCachedItem <UserDto>(cacheKey);
if (userDto != null)
{
userDto.UserProfile = GetUserProfile(uow, userDto.Key, userProfileOriginator);
return;
}
var user = uow.Store.FirstOrDefault <User>(x => x.Key == userKey);
if (user == null)
{
return;
}
userDto = MappingService.Map <UserDto>(user);
userDto.UserProfile = GetUserProfile(uow, userDto.Key, userProfileOriginator);
CacheUserDto(uow, userDto);
});
return(userDto);
}
public void ServiceLoadsFromFile()
{
var loader = new Mock<ILoader>();
var subject = new MappingService(loader.Object, "tracks");
var result = subject.Map(new Mapping());
loader.Verify( l => l.Load(It.IsAny<string>()));
}
private Response MapUsing(MappingService mappingService)
{
var result = mappingService.Map(Mapping.From(this.Bind<SerializableMapping>()));
var viewmodel = new SerializableMapping();
return Response.AsJson(result.To(viewmodel));
}
CreateUser(UserUpdateDto userUpdateDto, ICollection <UserProfileDto> userProfiles)
{
var updateResultType = UserUpdateResultType.Unknown;
UserDto userDto = null;
var result = ExecuteWithProcessResult(uow =>
{
userDto = GetUser(uow, null, userUpdateDto.Email.Address);
if (userDto != null)
{
updateResultType = UserUpdateResultType.EmailExists;
return;
}
var user = uow.Store.Add(MappingService.Map <User>(userUpdateDto));
if (user == null)
{
updateResultType = UserUpdateResultType.GeneralFailure;
throw new Exception("Failed to create User.");
}
userDto = MappingService.Map <UserDto>(user);
CacheUserDto(uow, userDto);
foreach (var userProfileDto in userProfiles)
{
userProfileDto.UserKey = user.Key;
var userProfile = MappingService.Map <UserProfile>(userProfileDto);
uow.Store.Add(userProfile);
var cacheKey = GetUserProfileCacheKey(userProfileDto.UserKey, userProfileDto.UserProfileOriginator);
uow.Cache.SetCachedItemAsync(cacheKey, userProfileDto).Wait();
}
});
return(result, userDto, updateResultType);
}
public void TestMapper_Enumerable_Found()
{
var services = new ServiceCollection();
services.AddScoped <IMapper <SourceModel, DestinationModel>, TestMapper>();
var serviceProvider = services.BuildServiceProvider();
var mappingService = new MappingService(serviceProvider);
var sources = new List <SourceModel>
{
new SourceModel
{
Value = "value",
},
new SourceModel
{
Value = "other",
},
};
var destinations = mappingService.Map <SourceModel, DestinationModel>(sources)
.ToList();
Assert.NotNull(destinations);
Assert.Equal(2, destinations.Count);
Assert.IsType <DestinationModel>(destinations[0]);
Assert.IsType <DestinationModel>(destinations[1]);
Assert.Equal("value", destinations[0].Value);
Assert.Equal("other", destinations[1].Value);
}
protected UserDto UpdateUser(IdentityUow uow, Guid userKey, Action <User> updateAction)
{
var user = uow.Store.UpdatePropertiesOnly(x => x.Key == userKey, updateAction);
var userDto = MappingService.Map <UserDto>(user);
CacheUserDto(uow, userDto);
return(userDto);
}
public void ThrowArgumentNullException_WhenObjectFromIsNull()
{
// Arrange
var postService = new MappingService();
// Act & Assert
Assert.Throws <ArgumentNullException>(() => postService.Map <Type>(null));
}
private void CollectScopeAssociatedInfo(IdentityUow uow, ScopeDto scopeDto)
{
scopeDto.ScopeClaims = uow.Store.List <ScopeClaim>(set => set.Where(x => x.ScopeKey == scopeDto.Key))
.Select(x => MappingService.Map <ScopeClaimDto>(x))
.ToList();
scopeDto.ScopeSecrets = uow.Store.List <ScopeSecret>(set => set.Where(x => x.ScopeKey == scopeDto.Key))
.Select(x => MappingService.Map <ScopeSecretDto>(x))
.ToList();
}
public async Task <Seller> CreateSeller(Seller seller)
{
return(await Task.Run(() =>
{
var temp = MappingService.Map <Domain.Seller>(seller);
var result = MappingService.Map <Seller>(SellerService.Create(temp));
return result;
}));
}
public async Task <Customer> CreateCustomer([FromBody] Customer customer)
{
return(await Task.Run(() =>
{
var temp = MappingService.Map <Domain.Customer>(customer);
var result = MappingService.Map <Customer>(CustomerService.Create(temp));
return result;
}));
}
public async Task <Order> CreateCustomer([FromBody] Order order,
[FromBody] int customerId, [FromBody] int sellerId)
{
return(await Task.Run(() =>
{
var temp = MappingService.Map <Domain.Order>(order);
var result = MappingService.Map <Order>(OrderService.Create(temp, customerId, sellerId));
return result;
}));
}
public async Task <CargoAM> GetCargo(int cargoId)
{
var domainCargo = await DomainCargoService.Get(cargoId);
if (domainCargo == null)
{
return(null);
}
var result = MappingService.Map(domainCargo, new CargoAM());
return(result);
}
public MappingModule()
{
var mappingService = new MappingService(new LastFmLoader(), "tracks");
Get["/mbid/{Mbid}"] = req =>
{
var result = mappingService.Map(new Mapping { MusicBrainz = new MusicBrainzId(req.Mbid) });
return((Mapping) result).SevenDigital.ToString();
};
Get["/7did/{Id}"] = req =>
{
var result = mappingService.Map(new Mapping { SevenDigital = new SevenDigitalId(req.Id) });
return
Response.AsRedirect(
"http://www.last.fm/mbid/"
+
((Mapping)result).MusicBrainz.ToString
());
};
Get["/status"] = _ => DateTime.Now.ToString();
}
public void TestMapper_NotFound()
{
var services = new ServiceCollection();
var serviceProvider = services.BuildServiceProvider();
var mappingService = new MappingService(serviceProvider);
var source = new SourceModel
{
Value = "value",
};
Assert.Throws <MapperNotFoundException>(() => mappingService.Map <SourceModel, DestinationModel>(source));
}
public void TestMapper_Enumerable_Null()
{
var services = new ServiceCollection();
services.AddScoped <IMapper <SourceModel, DestinationModel>, TestMapper>();
var serviceProvider = services.BuildServiceProvider();
var mappingService = new MappingService(serviceProvider);
List <SourceModel> sources = null;
var destinations = mappingService.Map <SourceModel, DestinationModel>(sources);
Assert.Null(destinations);
}
public async Task <Order> Update(int id, [FromBody] Order order)
{
return(await Task.Run(() =>
{
if (id == order.Id)
{
var temp = MappingService.Map <Domain.Order>(order);
var result = MappingService.Map <Order>(OrderService.Update(temp));
return result;
}
return order;
}));
}
public async Task <Seller> Update(int id, [FromBody] Seller seller)
{
return(await Task.Run(() =>
{
if (id == seller.Id)
{
var temp = MappingService.Map <Domain.Seller>(seller);
var result = MappingService.Map <Seller>(SellerService.Update(temp));
return result;
}
return seller;
}));
}
public async Task <Customer> Update(int id, [FromBody] Customer customer)
{
return(await Task.Run(() =>
{
if (id == customer.Id)
{
var temp = MappingService.Map <Domain.Customer>(customer);
var result = MappingService.Map <Customer>(CustomerService.Update(temp));
return result;
}
return customer;
}));
}
private void CollectClientAssociatedInfo(IdentityUow uow, ClientDto clientDto)
{
clientDto.AllowedScopes = uow.Store
.List <ClientScope>(set => set.Where(x => x.ClientKey == clientDto.Key))
.Select(x => MappingService.Map <ClientScopeDto>(x))
.ToList();
clientDto.ClientSecrets = uow.Store
.List <ClientSecret>(set => set.Where(x => x.ClientKey == clientDto.Key))
.Select(x => MappingService.Map <ClientSecretDto>(x))
.ToList();
clientDto.RedirectUris = uow.Store
.List <ClientRedirectUri>(set => set.Where(x => x.ClientKey == clientDto.Key))
.Select(x => MappingService.Map <ClientRedirectUriDto>(x))
.ToList();
}
public UserDto SetVerificationCode(string email, VerificationPurpose verificationPurpose,
string hashedVerificationCode, DateTimeOffset timeVerificationCodeExpires)
{
UserDto userDto = null;
Execute(uow =>
{
var user = uow.Store.UpdatePropertiesOnly <User>(x => x.Email.Address == email,
x => x.WithVerificationCode(verificationPurpose, hashedVerificationCode,
timeVerificationCodeExpires));
userDto = MappingService.Map <UserDto>(user);
CacheUserDto(uow, userDto);
});
return(userDto);
}
public void ShouldMappFromFrameworkFrameworkViewModelWhenFrameworkIsEmpty()
{
var service = new MappingService(Mock.Of <ILog>());
var framework = new GetFrameworkResponse
{
Framework = new Framework
{
Title = "title1",
}
};
var viewModel = service.Map <GetFrameworkResponse, FrameworkViewModel>(framework);
viewModel.ExpiryDateString.Should().BeNull();
viewModel.Should().NotBeNull();
}
public ActionResult Search()
{
var countries = this.countryService.GetAllCountries()
.Select(x => MappingService.Map <CountryViewModel>(x))
.Select(c => new SelectListItem()
{
Text = c.Name, Value = c.Id.ToString()
})
.ToList();
var viewModel = new SearchViewModel()
{
Countries = countries
};
return(View(viewModel));
}
private ClientDto AddOrUpdateClient(IdentityUow uow, ClientDto clientDto)
{
var client = MappingService.Map <Client>(clientDto).AsNewEntity();
client = uow.Store.AddOrUpdate(client, x => x.ClientId == clientDto.ClientId);
if (clientDto.AllowedScopes != null)
{
foreach (var allowedScopeDto in clientDto.AllowedScopes)
{
var allowedScope = MappingService.Map <ClientScope>(allowedScopeDto).WithClient(client);
uow.Store.AddOrUpdate(allowedScope,
x => x.ClientKey == client.Key && x.Scope == allowedScopeDto.Scope);
}
}
if (clientDto.ClientSecrets != null)
{
foreach (var clientSecretDto in clientDto.ClientSecrets)
{
var clientSecret = MappingService.Map <ClientSecret>(clientSecretDto).WithClient(client);
uow.Store.AddOrUpdate(clientSecret,
x => x.ClientKey == client.Key && x.Value == clientSecretDto.Value);
}
}
if (clientDto.RedirectUris != null)
{
foreach (var redirectUriDto in clientDto.RedirectUris)
{
var redirectUri = MappingService.Map <ClientRedirectUri>(redirectUriDto).WithClient(client);
uow.Store.AddOrUpdate(redirectUri,
x => x.ClientKey == client.Key && x.Uri == redirectUriDto.Uri);
}
}
var updatedClientDto = MappingService.Map <ClientDto>(client);
CollectClientAssociatedInfo(uow, updatedClientDto);
var cacheKey = CacheKeyHelper.GetCacheKey <ClientDto>(client.ClientId);
uow.Cache.SetCachedItemAsync(cacheKey, updatedClientDto).Wait();
return(updatedClientDto);
}
public ActionResult AddCity()
{
var countries = this.countryServices.GetAllCountries()
.AsQueryable()
.Select(x => MappingService.Map <CountryViewModel>(x))
.Select(c => new SelectListItem()
{
Text = c.Name, Value = c.Id.ToString()
})
.ToList();
var viewModel = new AddCityViewModel()
{
Countries = countries
};
return(PartialView("_AddCity", viewModel));
}
public MemberUpdatedEvent CreateOrUpdateMember(IBasicRequestKey request, MemberUpdateDto dto,
Func <MemberUpdateDto, UserProfileDto> createUserProfileDto)
{
var member = MappingService.Map <Member>(dto).AsNewEntity();
if (dto.Roles == null)
{
dto.Roles = new List <RoleDto>();
}
if (!dto.Roles.Any())
{
dto.Roles.Add(new RoleDto {
RoleType = RoleTypeName.BasicMember
});
}
foreach (var roleDto in dto.Roles)
{
roleDto.UserKey = member.Key;
}
var roles = dto.Roles.Select(x => MappingService.Map <Role>(x).AsNewEntity()).ToList();
var updatedEvent = new MemberUpdatedEvent().LinkTo(request);
updatedEvent.WithProcessResult(ExecuteWithProcessResult(uow =>
{
var updatedMember = uow.Store.AddOrUpdate(member,
x => x.Email.Address == member.Email.Address ||
x.Mobile.LocalNumberWithAreaCodeInDigits == member.Mobile.LocalNumberWithAreaCodeInDigits ||
x.Username == member.Username
);
var updatedMemberDto = MappingService.Map <MemberUpdateDto>(updatedMember);
updatedMemberDto.Roles = new List <RoleDto>();
uow.Store.Delete <Role>(x => x.UserKey == updatedMember.Key);
foreach (var role in roles)
{
var updatedRole = uow.Store.Add(role);
updatedMemberDto.Roles.Add(MappingService.Map <RoleDto>(updatedRole));
}
updatedEvent.WithMember(updatedMemberDto)
.WithUserProfile(createUserProfileDto?.Invoke(updatedMemberDto));
}));
return(updatedEvent);
}
public void TestMapper_Found()
{
var services = new ServiceCollection();
services.AddScoped <IMapper <SourceModel, DestinationModel>, TestMapper>();
var serviceProvider = services.BuildServiceProvider();
var mappingService = new MappingService(serviceProvider);
var source = new SourceModel
{
Value = "value",
};
var destination = mappingService.Map <SourceModel, DestinationModel>(source);
Assert.NotNull(destination);
Assert.IsType <DestinationModel>(destination);
Assert.Equal("value", destination.Value);
}
public void ShouldMapStandardProvidersItemToViewModel()
{
var service = new MappingService(Mock.Of <ILog>());
var response = new ProviderSearchResultItem
{
Address = new Address {
Address1 = "Address 1", Address2 = "Address 2"
},
LocationName = "Location Name",
LocationId = 12345
};
var viewModel = service.Map <ProviderSearchResultItem, StandardProviderResultItemViewModel>(response);
viewModel.Should().NotBeNull();
viewModel.LocationAddressLine.Should().Be("Location Name, Address 1, Address 2");
viewModel.DeliveryModes.Count.Should().Be(0);
}
public void Handle(CreateMemberRequest message)
{
if (string.IsNullOrWhiteSpace(message.Member.Email?.Address))
{
Bus.Publish(new MemberUpdatedEvent().LinkTo(message)
.WithProcessResult(new ArgumentException("Email address is required"),
"Email address is required."));
MarkAsComplete();
}
Data.Email = message.Member.Email?.Address;
DataCache.SetItem(message, Data.Email);
var createUserRequest = new CreateUserRequest
{
UserUpdate = MappingService.Map <UserUpdateDto>(message.Member)
}.LinkTo(message);
Bus.Send(_commonBusEndpointSettings.Identity, createUserRequest);
}
public ActionResult Search(int AirportDepartureId, int AirportArrivalId, DateTime DateOfDeparture, int AvailableSeats)
{
var flights = this.flightService.GetFlights(AirportDepartureId, AirportArrivalId, DateOfDeparture, AvailableSeats);
var flightsViewModel = flights
.Select(f => MappingService.Map <DetailsFlightViewModel>(f))
.ToList();
if (flightsViewModel.Count == 0)
{
this.TempData["Ticket"] = null;
}
else
{
this.TempData["Ticket"] = flightsViewModel;
}
return(PartialView("_FlightSearchResult", flightsViewModel));
}
private ClientDto GetClient(IdentityUow uow, string clientId)
{
var cacheKey = CacheKeyHelper.GetCacheKey <ClientDto>(clientId);
var clientDto = uow.Cache.GetCachedItem <ClientDto>(cacheKey);
if (clientDto != null)
{
return(clientDto);
}
clientDto = MappingService.Map <ClientDto>(uow.Store.FirstOrDefault <Client>(x => x.ClientId == clientId));
if (clientDto == null)
{
return(null);
}
CollectClientAssociatedInfo(uow, clientDto);
uow.Cache.SetCachedItemAsync(cacheKey, clientDto).Wait();
return(clientDto);
}
private UserDto GetUser(IdentityUow uow, string userProfileOriginator, string usernameOrEmailOrMobileNumber)
{
var cacheKey = GetUserCacheKey(usernameOrEmailOrMobileNumber);
var userDto = uow.Cache.GetCachedItem <UserDto>(cacheKey);
if (userDto != null)
{
userDto.UserProfile = GetUserProfile(uow, userDto.Key, userProfileOriginator);
return(userDto);
}
var localNumberInDigits = usernameOrEmailOrMobileNumber.GetNumberInDigits();
if (!string.IsNullOrWhiteSpace(localNumberInDigits))
{
cacheKey = CacheKeyHelper.GetCacheKey <UserDto>(localNumberInDigits);
userDto = uow.Cache.GetCachedItem <UserDto>(cacheKey);
}
if (userDto != null)
{
userDto.UserProfile = GetUserProfile(uow, userDto.Key, userProfileOriginator);
return(userDto);
}
var user = uow.Store.FirstOrDefault <User>(
x => x.Email.Address == usernameOrEmailOrMobileNumber ||
x.Username == usernameOrEmailOrMobileNumber ||
x.Mobile.LocalNumberWithAreaCode == usernameOrEmailOrMobileNumber ||
x.Mobile.LocalNumberWithAreaCodeInDigits == localNumberInDigits
);
if (user == null)
{
return(null);
}
userDto = MappingService.Map <UserDto>(user);
userDto.UserProfile = GetUserProfile(uow, userDto.Key, userProfileOriginator);
CacheUserDto(uow, userDto);
return(userDto);
}
