public async Task TestGetByCompleteAddressAsyncModelInvalid()
{
// Arrange
var patients = GenerateAddressEntityList();
var mockDbSet = patients.AsQueryable().BuildMockDbSet();
var mockContext = new Mock <DemographicsDbContext>();
mockContext
.Setup(x => x.Set <Address>())
.Returns(mockDbSet.Object)
.Verifiable();
var testModel = new AddressInputModel
{
StreetName = "Test Street",
HouseNumber = "666",
Town = "Test Town",
State = "Test State",
ZipCode = "12345"
};
var repository = new AddressRepository(mockContext.Object);
// Act
var result = await repository.GetByCompleteAddressAsync(testModel);
// Assert
Assert.Null(result);
}
public OrderViewModel AddAddressesToOrder(AddressInputModel address, OrderViewModel order)
{
if (address.CountryId != null)
{
order.ShippingAdress = new AddressViewModel
{
City = address.City,
Street = address.Street,
Zipcode = address.Zipcode,
Country = _countryRepo.GetCountryById((int)address.CountryId).Name
};
}
if (address.BillingCountryId != null)
{
order.BillingAddress = new AddressViewModel
{
City = address.BillingCity,
Street = address.BillingStreet,
Zipcode = address.Zipcode,
Country = _countryRepo.GetCountryById((int)address.BillingCountryId).Name
};
}
return(order);
}
/// <summary>
/// Handle an incoming <see cref="AddressInputModel"/> DTO.
/// </summary>
/// <param name="entity"></param>
/// <param name="model"></param>
/// <returns></returns>
private async Task HandleIncomingAddress(Patient entity, AddressInputModel model)
{
if (entity == null || model == null || AddressInputModelPropertiesNullOrWhitespace(model))
{
throw new ArgumentNullException();
}
// Does a functionally identical entity already exist?
var result = await _unitOfWork.AddressRepository.GetByCompleteAddressAsync(model);
// No--create a new entity and link it up
if (result == null)
{
var address = _mapper.Map <Address>(model);
_unitOfWork.AddressRepository.Create(address);
entity.PatientAddresses.Add(new PatientAddress
{
Patient = entity,
Address = address
});
}
// Yes--link it up if it isn't already linked (if it is already linked, no need to do anything)
else if (!entity.PatientAddresses.Any(pa => pa.PatientId == entity.Id && pa.AddressId == result.Id))
{
entity.PatientAddresses.Add(new PatientAddress
{
Patient = entity,
Address = result
});
}
}
public IActionResult AddAddress(AddressInputModel address)
{
var currentUser = _userManager.GetUserId(HttpContext.User);
_addressService.AddAddress(address, currentUser);
return(RedirectToAction("Address"));
}
public void CreateOrderShouldAddNewOrderToDb()
{
var shipment = new Shipment()
{
FromCity = new City {
Name = "Plovdiv"
},
ToCity = new City {
Name = "Sofia"
},
Length = 2,
Width = 3,
Height = 1.2,
Weight = 333,
IsExpressDelivery = true,
IsFragile = false,
Price = 114.60M
};
var input = new AddressInputModel
{
ShipmentId = shipment.Id,
LoadingName = "Fenix",
UnloadingName = "Fazan",
LoadingDate = DateTime.UtcNow.AddMinutes(12),
UnloadingDate = DateTime.UtcNow.AddDays(2),
LoadingPhone = "0877-223-225",
UnloadingPhone = "0877-774-225",
Description = "descr",
LoadingStreet = "бул. Христо Ботев",
UnloadingStreet = "Александровска",
LoadingNumber = "12",
UnloadingNumber = "23A",
LoadingEmail = "*****@*****.**",
UnloadingEmail = "*****@*****.**",
};
var user = new ApplicationUser
{
UserName = "******"
};
var optionsBuilder = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var db = new ApplicationDbContext(optionsBuilder.Options);
db.Shipments.Add(shipment);
db.Users.Add(user);
db.SaveChanges();
var ordersService = new OrdersService(db);
ordersService.CreateOrder(input, user.Id);
var result = db.Orders.Count();
Assert.Equal(1, result);
}
public void AddAddress(string doctorId, AddressInputModel addressInputModel)
{
Doctor doctor = this.GetDoctor(doctorId);
string addressId = this.addressesService.Add(addressInputModel);
doctor.Addresses.Add(this.addressesService.GetAddress(addressId));
this.db.SaveChanges();
}
public IActionResult AddAddress([FromBody] AddressInputModel address)
// Adds a new address associated with an authenticated user
{
if (!ModelState.IsValid)
{
return(StatusCode(412, address));
}
_addressService.AddAddress(User.Identity.Name, address);
return(StatusCode(201, "Address has been created."));
}
public void AddAddress(string personId, AddressInputModel addressInputModel)
{
Person person = this.GetPerson(personId);
string addressId = this.addressesService.Add(addressInputModel);
person.Addresses.Add(this.addressesService.GetAddress(addressId));
this.db.SaveChanges();
}
public void AddAddress(string relativeId, AddressInputModel addressInputModel)
{
Relative relative = this.GetRelative(relativeId);
string addressId = this.addressesService.Add(addressInputModel);
relative.Addresses.Add(this.addressesService.GetAddress(addressId));
this.db.SaveChanges();
}
public IActionResult AddAddress([FromBody] AddressInputModel address)
{
if (!ModelState.IsValid)
{
return(BadRequest("Address is not properly constructed!"));
}
_addressService.AddAddress(User.Identity.Name, address);
return(StatusCode(201, address));
}
public IActionResult Address(AddressInputModel newAddress)
{
if (ModelState.IsValid)
{
var userId = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
_accountService.AddNewAddress(newAddress, userId);
return(RedirectToAction("Information"));
}
return(View());
}
public IActionResult AddAddress([FromBody] AddressInputModel address)
{
if (!ModelState.IsValid)
{
ErrorHandler.GetModelErrors(ModelState);
}
var email = ClaimsHelper.GetClaim(User, "name");
var newAddress = _addressService.AddAddress(email, address);
return(CreatedAtRoute("AddAddress", new { id = newAddress.Id }, null));
}
public IActionResult Add(AddressInputModel model)
{
if (!ModelState.IsValid)
{
return(this.RedirectToAction("Checkout", "Orders"));
}
var adress = this.addressesService.CreateAddress(model.Country, model.Town, model.Street, model.OtherDetails);
this.addressesService.AddAddressToUser(this.User.Identity.Name, adress);
return(this.RedirectToAction("Checkout", "Orders"));
}
public async Task <string> CreateAsync(AddressInputModel inputModel)
{
var address = inputModel.Map <AddressInputModel, Address>();
var townId = await _townsService.GetIdByNameAsync(inputModel.TownName);
address.TownId = townId;
var createdAddress = _context.Addresses.Add(address).Entity;
await _context.SaveChangesAsync();
return(createdAddress.Id);
}
/// <summary>
/// Finds a <see cref="Address"/> entity by its minimally complete set of properties.
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <Address> GetByCompleteAddressAsync(AddressInputModel model)
{
var result =
await base.GetByCondition(a =>
a.StreetName.Contains(model.StreetName) &&
a.HouseNumber.Contains(model.HouseNumber) &&
a.Town.Contains(model.Town) &&
a.State.Contains(model.State) &&
a.ZipCode.Contains(model.ZipCode))
.FirstOrDefaultAsync();
return(result);
}
public AddressDto AddAddress(string email, AddressInputModel address)
{
var user = _dbContext.Users.FirstOrDefault(u => u.Email == email)
?? throw new ResourceNotFoundException($"User with email {email} not found");
var addressEntity = _mapper.Map <Address>(address);
addressEntity.UserId = user.Id;
_dbContext.Addresses.Add(addressEntity);
_dbContext.SaveChanges();
return(_mapper.Map <AddressDto>(addressEntity));
}
public async Task <ActionResult> Create(AddressInputModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View());
}
var user = await this.userManager.GetUserAsync(this.User);
await this.addresesService.CreateAddressAsync(user, model);
return(this.Redirect("/Orders/Create"));
}
public IActionResult Address(AddressInputModel address)
{
if (!ModelState.IsValid)
{
return(View());
}
var userId = _signInManager.IsSignedIn(User) ? int.Parse(User.FindFirst("CustomerId").Value) : 10;
var order = _orderService.GetActiveOrder(userId);
order = _orderService.AddAddressesToOrder(address, order);
TempData["order"] = JsonConvert.SerializeObject(order);
return(RedirectToAction("ReviewPage"));
}
public void AddAddressToCustomer(int customerId, AddressInputModel model)
{
var address = new Address
{
City = model.City,
Street = model.Street,
CountryId = model.CountryId,
ZipCode = model.Zipcode
};
_addressRepo.AddAddress(address);
_addressRepo.AddAddressToCustomer(customerId, address.Id);
}
public IActionResult AddAddress([FromBody] AddressInputModel inputModel)
{
// Check if inputModel is correct
if (!ModelState.IsValid)
{
throw new ModelFormatException("Address not properly formatted.");
}
// Get user email from claims
var email = User.Claims.FirstOrDefault(c => c.Type == "name").Value;
_addressService.AddAddress(email, inputModel);
return(StatusCode(201));
}
public async Task <IActionResult> Create([FromBody] AddressInputModel model)
{
var entity = mapper.Map <Address>(model);
entity.CustomerId = UserId;
this.ctx.Add(entity);
if (await this.ctx.SaveChangesAsync() > 0)
{
var url = Url.Link("AddressGet", new { id = entity.Id });
return(Created(url, mapper.Map <AddressModel>(entity)));
}
return(BadRequest());
}
public string Add(AddressInputModel addressIinputModel)
{
Address address = new Address()
{
Town = addressIinputModel.Town,
Street = addressIinputModel.Street,
AdditionalDescription = addressIinputModel.AdditionalDescription
};
this.db.Addresses.Add(address);
this.db.SaveChanges();
return(address.Id);
}
/// <summary>
/// Indicates whether the properties of an <see cref="PatientInputModel"/> DTO are null or whitespace.
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
private static bool AddressInputModelPropertiesNullOrWhitespace(AddressInputModel model)
{
if (model == null)
{
throw new ArgumentNullException();
}
return
(string.IsNullOrWhiteSpace(model.StreetName) ||
string.IsNullOrWhiteSpace(model.HouseNumber) ||
string.IsNullOrWhiteSpace(model.Town) ||
string.IsNullOrWhiteSpace(model.State) ||
string.IsNullOrWhiteSpace(model.ZipCode));
}
public void AddAddress(AddressInputModel address, string currentUser)
{
var addressToAdd = new Address
{
UserId = currentUser,
StreetName = address.StreetName,
HouseNumber = address.HouseNumber,
City = address.City,
Country = address.Country,
ZipCode = address.ZipCode,
Name = address.Name
};
_addressRepo.AddAddress(addressToAdd);
}
/****************************ADDRESS FUNCTIONS******************************\
|***************************************************************************|
\***************************************************************************/
public void AddNewAddress(AddressInputModel newAddress, string userId)
{
var addressEntityModel = new Address()
{
UserId = userId,
Street = newAddress.Street,
HouseNum = newAddress.HouseNum,
City = newAddress.City,
Country = newAddress.Country,
ZipCode = newAddress.ZipCode
};
_db.Addresses.Add(addressEntityModel);
_db.SaveChanges();
}
public async Task UpdateAsync(string id, AddressInputModel inputModel)
{
this.ThrowIfIncorrectId(_context.Addresses, id);
var address = await _context.Addresses
.FirstOrDefaultAsync(x => x.Id == id);
_context.Entry(address).State = EntityState.Detached;
address = inputModel.Map <AddressInputModel, Address>();
address.Id = id;
_context.Addresses.Update(address);
await _context.SaveChangesAsync();
}
public void AddAddress(string email, AddressInputModel address)
{
var user = _dbContext.Users.FirstOrDefault(u => u.Email == email);
var newAddress = new Address
{
UserId = user.Id,
StreetName = address.StreetName,
HouseNumber = address.HouseNumber,
ZipCode = address.ZipCode,
Country = address.Country,
City = address.City
};
_dbContext.Addresses.Add(newAddress);
_dbContext.SaveChanges();
}
public async Task UpdateAsync_ShouldThrowWhenIncorrectId()
{
var incorrectId = Guid.NewGuid().ToString();
var address = new AddressInputModel
{
TownName = _townName,
Street = "Test street",
AddressType = AddressType.Billing.ToString(),
BuildingNumber = "10A"
};
var exception = await Assert.ThrowsAsync <ArgumentException>(
async() => await _addressesService.UpdateAsync(incorrectId, address));
var expectedMessage = ErrorMessage.GetIncorrectIdMessage(_addressesService.GetType().Name);
Assert.Equal(expectedMessage, exception.Message);
}
public async Task UpdateAsync_ShouldWorkCorrectly()
{
var address = new AddressInputModel
{
TownName = _townName,
Street = "Updates street",
AddressType = AddressType.Other.ToString(),
BuildingNumber = "Initial number"
};
await _addressesService.UpdateAsync(_addressId, address);
var addressFromDb = await _context.Addresses
.FirstOrDefaultAsync(x => x.Id == _addressId);
Assert.Equal(address.Street, addressFromDb.Street);
Assert.Equal(address.BuildingNumber, addressFromDb.BuildingNumber);
Assert.Equal(address.AddressType, addressFromDb.AddresType.ToString());
}
public IActionResult Create(AddressInputModel input)
{
if (!ModelState.IsValid)
{
this.ViewBag.ShipmentId = input.ShipmentId;
return(this.View());
}
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
string orderId = this.ordersService.CreateOrder(input, userId);
return(this.RedirectToAction("OrderAdded", "Orders", new ChangesApplied
{
Message = "Вие успешно добавихте поръчка с номер:",
OrderId = orderId
}));
}
