public static void MapToExisting(this Domain.Address source, Person target)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
if (source == null)
{
target.Address1 = null;
target.Address2 = null;
target.City = null;
target.State = null;
target.Zip = null;
target.Country = null;
}
else
{
target.Address1 = source.AddressLine1;
target.Address2 = source.AddressLine2;
target.City = source.City;
target.State = source.State;
target.Zip = source.PostalCode;
// don't map Country this because it's not mapping... it's a defaulting decision
}
}
public int SaveAddress(Domain.Address address)
{
Address efAddress = new Address();
if (address.AddressId == 0)
{
demoDBContext.Address.Add(efAddress);
}
else
{
efAddress = demoDBContext.Address.Where(x => x.AddressId == address.AddressId).FirstOrDefault();
}
efAddress.CountryId = address.CountryId;
efAddress.StateId = address.StateId;
efAddress.CityId = address.CityId;
efAddress.HouseOfficeNo = address.HouseOfficeNo;
efAddress.Street1 = address.Street1;
efAddress.Street2 = address.Street2;
efAddress.ZipCode = address.ZipCode;
demoDBContext.SaveChanges();
return(efAddress.AddressId);
}
public async Task Retrieve_Address_ReturnAddressDto()
{
var address = new Domain.Address
{
City = "昆明市",
County = "五华区",
Province = "云南省"
};
var stubAddressRepository = new Mock <IRepository <Domain.Address> >();
stubAddressRepository.Setup(q => q.RetrieveAsync(address.ID)).ReturnsAsync(address);
var stubProvinceRepository = new Mock <IRepository <Province> >();
var stubAddressUnitOfWork = new Mock <IAddressUnitOfWork>();
var addressServiceMock = new AddressServiceImpl.AddressServiceImpl(stubAddressRepository.Object, stubProvinceRepository.Object, stubAddressUnitOfWork.Object);
AddressDto.AddressDto addressDto = await addressServiceMock.RetrieveAsync(address.ID);
Assert.Equal(address.ID, addressDto.ID);
Assert.Equal(address.City, addressDto.City);
Assert.Equal(address.County, addressDto.County);
Assert.Equal(address.Province, addressDto.Province);
}
private Address MapAddress(Domain.Address dAddr)
{
var address = new Address();
address.AddressId = dAddr.AddressId;
address.City = dAddr.City;
address.PostalCode = dAddr.PostalCode;
address.State = dAddr.State;
address.StreetAddress = dAddr.StreetAddress;
address.StreetNumber = dAddr.StreetNumber;
address.ZipCode = dAddr.ZipCode;
return(address);
}
private Domain.Address MapAddress(Address address)
{
var dAddr = new Domain.Address();
dAddr.AddressId = address.AddressId;
dAddr.City = address.City;
dAddr.PostalCode = address.PostalCode;
dAddr.State = address.State;
dAddr.StreetAddress = address.StreetAddress;
dAddr.StreetNumber = address.StreetNumber;
dAddr.ZipCode = address.ZipCode;
return(dAddr);
}
public static DAL.App.DTO.Address MapFromDomain(Domain.Address address)
{
var res = address == null ? null : new DAL.App.DTO.Address
{
Id = address.Id,
Country = address.Country,
City = address.City,
Street = address.Street,
HouseNumber = address.HouseNumber,
UnitNumber = address.UnitNumber,
PostalCode = address.PostalCode,
};
return(res);
}
public Domain.Company MockCompany(string companyName, Domain.Address address)
{
var company = new Domain.Company(new Domain.Errors());
company.CompanySize = new Domain.CompanySize {
CompanySizeId = 1
};
company.CompanyId = Guid.NewGuid();
company.Name = "FDHSMV";
var office = new Domain.Office();
office.OfficeId = Guid.NewGuid();
office.Address = address;
company.Offices = new List <Domain.Office> {
office
};
return(company);
}
public static Domain.Address MapToAddress(this Person source)
{
if (source == null)
{
return(null);
}
var target = new Domain.Address
{
AddressLine1 = source.Address1,
AddressLine2 = source.Address2,
City = source.City,
State = source.State,
PostalCode = source.Zip,
};
return(target);
}
public Domain.Address GetAddressById(int?addressId)
{
Domain.Address address = new Domain.Address();
if (addressId == null || addressId == 0)
{
return(address);
}
address = demoDBContext.Address.Where(x => x.AddressId == addressId).Select(x => new Domain.Address()
{
AddressId = x.AddressId,
CountryId = x.CountryId,
StateId = x.StateId,
CityId = x.CityId,
HouseOfficeNo = x.HouseOfficeNo,
Street1 = x.Street1,
Street2 = x.Street2,
ZipCode = x.ZipCode
}).FirstOrDefault();
return(address);
}
public async Task <List <Domain.Company> > SearchForCompaniesByAddress(Domain.Address dAddr)
{
// Func<string, string, bool> equals = (left, right) => string.Equals(left, right, StringComparison.CurrentCultureIgnoreCase);
var query = from company in store.Companies
from office in company.Offices
where string.Equals(office.Address.StreetNumber, dAddr.StreetNumber, StringComparison.CurrentCultureIgnoreCase) &&
string.Equals(office.Address.StreetAddress, dAddr.StreetAddress, StringComparison.CurrentCultureIgnoreCase) &&
string.Equals(office.Address.City, dAddr.City, StringComparison.CurrentCultureIgnoreCase) &&
string.Equals(office.Address.State, dAddr.State, StringComparison.CurrentCultureIgnoreCase) &&
string.Equals(office.Address.ZipCode, dAddr.ZipCode, StringComparison.CurrentCultureIgnoreCase)
select company;
query = IncludeAll(query);
var companies = await query.ToListAsync();
if (companies == null || companies.Count() == 0)
{
return(null);
}
return(companies.ConvertAll(c => mapper.MapFromEntity(c)));
}
public async Task GivenACompanyShouldFindCompanyByAddress()
{
var options = new DbContextOptionsBuilder <CompanyContext>()
.UseInMemoryDatabase(databaseName: "ShouldFindCompanyByAddress")
.Options;
using (var context = new CompanyContext(options))
{
await context.Database.EnsureCreatedAsync();
var repository = new CompanyRepository(context);
var address = new Domain.Address {
AddressId = Guid.NewGuid(), StreetNumber = "1112", StreetAddress = "Carissa Dr.", City = "TTown", State = "FL", ZipCode = "32308"
};
var objectUnderTest = mock.MockCompany("FDHSMV", address);
await repository.Add(objectUnderTest);
var actualValue = await repository.SearchForCompaniesByAddress(address);
Assert.NotNull(actualValue);
Assert.Equal(objectUnderTest.Name, actualValue[0].Name);
}
}
public Response()
{
Address = new Domain.Address();
}
public Response()
{
Address = new Domain.Address();
}
public bool UpdateAddress(Domain.Address address)
{
return(addressGateway.Update(mapDomainToDtoObject(address)) > 0);
}
