public static QueryResponseDTO <List <UserAddressModel> > GetUserAddressInfo(UserAddressDTO dto)
{
QueryResponseDTO <List <UserAddressModel> > responseDTO = new QueryResponseDTO <List <UserAddressModel> >();
CustomDataCommand dataCommand = DataCommandManager.CreateCustomDataCommandFromConfig("GetUserAddressInfo");
using (DynamicQuerySqlBuilder sqlBuilder = new DynamicQuerySqlBuilder(
dataCommand.CommandText, dataCommand, dto.PagingInfo, "AddressID ASC"))
{
if (null != dto)
{
if (!string.IsNullOrEmpty(dto.AddressID))
{
sqlBuilder.ConditionConstructor
.AddCondition(QueryConditionRelationType.AND, "AddressID", DbType.Int32, "@AddressID", QueryConditionOperatorType.Equal, dto.AddressID);
}
if (!string.IsNullOrEmpty(dto.UserID))
{
sqlBuilder.ConditionConstructor
.AddCondition(QueryConditionRelationType.AND, "UserID", DbType.AnsiString, "@UserID", QueryConditionOperatorType.Equal, dto.UserID);
}
}
//QueryData
dataCommand.CommandText = sqlBuilder.BuildQuerySql();
var result = dataCommand.ExecuteEntityList <UserAddressModel>();
responseDTO.ResultEntity = result;
}
responseDTO.TotalCount = dto.PagingInfo.TotalCount;
responseDTO.Code = ResponseStaticModel.Code.OK;
responseDTO.Message = ResponseStaticModel.Message.OK;
return(responseDTO);
}
public IHttpActionResult PutUserAddress(int id, UserAddressDTO userAddress)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != userAddress.UserAddressID)
{
return(BadRequest());
}
try
{
db.Update(userAddress);
}
catch (DbUpdateConcurrencyException)
{
if (!UserAddressExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
/// <summary>
/// Invoked when <see cref="ToDTO"/> operation is about to return.
/// </summary>
/// <param name="dto"><see cref="UserAddressDTO"/> converted from <see cref="UserAddress"/>.</param>
static partial void OnDTO(this UserAddress entity, UserAddressDTO dto)
{
if (entity != null && entity.Address != null)
{
dto.Address = AddressAssembler.ToDTO(entity.Address);
}
}
public async Task <List <UserAddressDTO> > GetUserAddressesAsync(string userID)
{
var result = await _context.UserAdresses
.Where(c => userID == c.UserId.ToString())
.ToListAsync();
var resultDto = new List <UserAddressDTO>();
foreach (var item in result)
{
var entry = new UserAddressDTO()
{
Id = item.Id,
AppartmentNr = item.AppartmentNr,
City = item.City,
HomeNr = item.HomeNr,
Country = item.Country,
StreetName = item.StreetName,
Zipcode = item.Zipcode
};
resultDto.Add(entry);
}
return(resultDto);
}
public async Task SetAddress(int userId, UserAddressDTO userAddress)
{
var succeed = await _queries.SetAddress(userId, userAddress);
if (!succeed)
{
throw new Exception("Couldn't set user address!");
}
}
public UserAddressDTO Create(UserAddressDTO modelDTO)
{
if (modelDTO != null)
{
return(UserAddressAssembler.ToDTO(userAddressRepo.CreateUserAddress(UserAddressAssembler.ToEntity(modelDTO))));
}
return(null);
}
public async Task UpdateAdressAsync(UserAddressDTO address)
{
if (address == null)
{
throw new ArgumentNullException();
}
var user = new UserAddress(address.UserAddressId, address.Address1, address.Address2, address.City, address.ZipCode, address.State, address.Country);
await _userAddress.UpdateAsync(user);
}
public UserAddressDTO Get(int id)
{
UserAddressDTO oUserAddressDTO = null;
if (id > 0)
{
oUserAddressDTO = userAddressRepo.GetUserAddress(id).ToDTO();
}
return(oUserAddressDTO);
}
public UserAddressDTO Get(int UserAddressID)
{
UserAddressDTO oUserAddressDTO = null;
if (UserAddressID > 0)
{
UserAddress oUserAddress = oUserAddressRepo.GetUserAddress(UserAddressID);
}
return(oUserAddressDTO);
}
public IHttpActionResult PostUserAddress(UserAddressDTO userAddress)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Create(userAddress);
return(CreatedAtRoute("DefaultApi", new { id = userAddress.UserAddressID }, userAddress));
}
public async Task SetAddress_AddressIdNotNullDoesntExists_ShouldReturnFalse()
{
var userId = 1;
var userAddress = new UserAddressDTO()
{
Id = 9999
};
var result = await _accountQueries.SetAddress(userId, userAddress);
Assert.IsFalse(result);
}
public UserAddressDTO Update(UserAddressDTO oUserAddressDTO)
{
UserAddressDTO returnUserAddress = null;
if (oUserAddressDTO != null && oUserAddressDTO.UserAddressID > 0)
{
oUserAddressRepo.UpdateUserAddress(0, UserAddressAssembler.ToEntity(oUserAddressDTO));
returnUserAddress = oUserAddressDTO;
}
return(returnUserAddress);
}
public IHttpActionResult GetUserAddress(int id)
{
UserAddressDTO userAddress = new UserAddressDTO();
userAddress = db.Get(id);
if (userAddress == null)
{
return(NotFound());
}
return(Ok(userAddress));
}
public UserAddressDTO Update(UserAddressDTO modelDTO)
{
UserAddressDTO returnUserAddress = null;
if (modelDTO != null && modelDTO.UserAddressID > 0)
{
userAddressRepo.UpdateUserAddress(0, UserAddressAssembler.ToEntity(modelDTO));
returnUserAddress = modelDTO;
}
return(returnUserAddress);
}
/// <summary>
/// This function updates User's Data in the database on the basis of "edited" data provided by the user.
/// </summary>
/// <param name="UserAddressDTOobject"></param>
/// <returns></returns>
public Boolean UpdateUser(UserAddressDTO UserAddressDTOobject)
{
bool flag = false;
try
{
using (UnitOfWork uow = new UnitOfWork())
{
User userObj = new User();
Address addressObj = new Address();
userObj.UserId = UserAddressDTOobject.User.UserId;
userObj.FirstName = UserAddressDTOobject.User.FirstName;
userObj.LastName = UserAddressDTOobject.User.LastName;
userObj.MiddleName = UserAddressDTOobject.User.MiddleName;
userObj.DOB = UserAddressDTOobject.User.DOB;
userObj.HireDate = UserAddressDTOobject.User.HireDate;
userObj.ReleaseDate = UserAddressDTOobject.User.ReleaseDate;
userObj.FkRoleId = UserAddressDTOobject.User.FkRoleId;
userObj.Active = UserAddressDTOobject.User.Active;
userObj.RecordStatus = UserAddressDTOobject.User.RecordStatus;
userObj.CreatedBy = UserAddressDTOobject.User.CreatedBy;
userObj.CreatedDate = UserAddressDTOobject.User.CreatedDate;
userObj.LastModifiedBy = DateTime.Now;
userObj.LastModifiedDate = DateTime.Now.Date;
uow.UserRepo.Update(userObj);
//uow.Complete();
addressObj.AddressId = UserAddressDTOobject.Address.AddressId;
addressObj.AddressType = UserAddressDTOobject.Address.AddressType;
addressObj.Address1 = UserAddressDTOobject.Address.Address1;
addressObj.Address2 = UserAddressDTOobject.Address.Address2;
addressObj.City = UserAddressDTOobject.Address.City;
addressObj.FkStateId = UserAddressDTOobject.Address.FkStateId;
addressObj.CreatedBy = UserAddressDTOobject.Address.CreatedBy;
addressObj.CreatedDate = UserAddressDTOobject.Address.CreatedDate;
addressObj.LastModifiedBy = DateTime.Now;
addressObj.LastModifiedDate = DateTime.Now.Date;
uow.AddressRepo.Update(addressObj);
uow.Complete();
flag = true;
}
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
}
return(flag);
}
public async Task <JsonResult> UserAddressInfoByIdInJson(int UserAddressId)
{
UserAddressDTO UserAddressDTOobject = new UserAddressDTO();
using (var client = new HttpClient())
{
client.BaseAddress = new Uri("http://localhost:49750/");
HttpResponseMessage response = await client.GetAsync("api/User/UserDataById/?UserAddressId=" + UserAddressId);
if (response.IsSuccessStatusCode)
{
UserAddressDTOobject = response.Content.ReadAsAsync <UserAddressDTO>().Result;
}
return(Json(UserAddressDTOobject, JsonRequestBehavior.AllowGet));
}
}
public async Task SetAddress_AddressIdNull_ShouldReturnTrue()
{
var userId = 1;
var userAddress = new UserAddressDTO()
{
AppartmentNr = Faker.NumberFaker.Number().ToString(),
City = Faker.LocationFaker.City(),
Country = Faker.LocationFaker.Country(),
HomeNr = Faker.NumberFaker.Number().ToString(),
StreetName = Faker.LocationFaker.StreetName(),
Zipcode = Faker.LocationFaker.ZipCode()
};
var result = await _accountQueries.SetAddress(userId, userAddress);
Assert.IsTrue(result);
}
public async Task <bool> SetAddress(int userId, UserAddressDTO userAddress)
{
if (userAddress.Id != null)
{
var result = await _context.UserAdresses
.FirstOrDefaultAsync(
c =>
c.UserId == userId
&&
c.Id == userAddress.Id
);
if (result != null)
{
result.StreetName = userAddress.StreetName;
result.HomeNr = userAddress.HomeNr;
result.AppartmentNr = userAddress.AppartmentNr;
result.Zipcode = userAddress.Zipcode;
result.City = userAddress.City;
result.Country = userAddress.Country;
}
else
{
return(false);
}
}
else
{
var entry = new UserAdresses()
{
UserId = userId,
StreetName = userAddress.StreetName,
HomeNr = userAddress.HomeNr,
AppartmentNr = userAddress.AppartmentNr,
Zipcode = userAddress.Zipcode,
City = userAddress.City,
Country = userAddress.Country
};
await _context.UserAdresses.AddAsync(entry);
}
await _context.SaveChangesAsync();
return(true);
}
/// <summary>
/// Converts this instance of <see cref="UserAddressDTO"/> to an instance of <see cref="UserAddress"/>.
/// </summary>
/// <param name="dto"><see cref="UserAddressDTO"/> to convert.</param>
public static UserAddress ToEntity(this UserAddressDTO dto)
{
if (dto == null)
{
return(null);
}
var entity = new UserAddress();
entity.UserAddressID = dto.UserAddressID;
entity.UserID = dto.UserID;
entity.AddressID = dto.AddressID;
entity.IsPrimary = dto.IsPrimary;
dto.OnEntity(entity);
return(entity);
}
public async Task GetAddressAsync_AddressExists_ReturnsAddressDTO()
{
UserAddressService addressService = new UserAddressService(CreateUserAddressMockRepository().Object);
UserAddressDTO addressDTO = new UserAddressDTO
{
UserAddressId = "1",
Address1 = "Example Street",
Address2 = "Example House",
City = "Example City",
ZipCode = "11-111",
State = "Example State",
Country = "Example Country"
};
var result = await addressService.GetAddressAsync("1");
result.Should().BeEquivalentTo(addressDTO);
}
public async Task SetAddress_AddressIdNotNullDoesExists_ShouldReturnTrue()
{
var userId = 1;
var userAddress = new UserAddressDTO()
{
Id = (await _context.UserAdresses.FirstOrDefaultAsync(c => c.UserId == userId)).Id,
AppartmentNr = Faker.NumberFaker.Number().ToString(),
City = Faker.LocationFaker.City(),
Country = Faker.LocationFaker.Country(),
HomeNr = Faker.NumberFaker.Number().ToString(),
StreetName = Faker.LocationFaker.StreetName(),
Zipcode = Faker.LocationFaker.ZipCode()
};
var result = await _accountQueries.SetAddress(userId, userAddress);
Assert.IsTrue(result);
}
/// <summary>
/// Converts this instance of <see cref="UserAddress"/> to an instance of <see cref="UserAddressDTO"/>.
/// </summary>
/// <param name="entity"><see cref="UserAddress"/> to convert.</param>
public static UserAddressDTO ToDTO(this UserAddress entity)
{
if (entity == null)
{
return(null);
}
var dto = new UserAddressDTO();
dto.UserAddressID = entity.UserAddressID;
dto.UserID = entity.UserID;
dto.AddressID = entity.AddressID;
dto.IsPrimary = entity.IsPrimary;
entity.OnDTO(dto);
return(dto);
}
public static QueryResponseDTO <bool> DeleteUserAddressInfo(UserAddressDTO dto)
{
QueryResponseDTO <bool> response = new QueryResponseDTO <bool>();
response.ResultEntity = false;
CustomDataCommand dataCommand = DataCommandManager.CreateCustomDataCommandFromConfig("RemoveUserAddressInfo");
using (DynamicQuerySqlBuilder sqlBuilder = new DynamicQuerySqlBuilder(
dataCommand.CommandText, dataCommand, dto.PagingInfo, "UserID ASC"))
{
if (null != dto)
{
if (!string.IsNullOrEmpty(dto.AddressID))
{
sqlBuilder.ConditionConstructor
.AddCondition(QueryConditionRelationType.AND, "AddressID", DbType.Int32, "@AddressID", QueryConditionOperatorType.Equal, dto.AddressID);
}
if (!string.IsNullOrEmpty(dto.UserID))
{
sqlBuilder.ConditionConstructor
.AddCondition(QueryConditionRelationType.AND, "UserID", DbType.AnsiString, "@UserID", QueryConditionOperatorType.Equal, dto.UserID);
}
}
//QueryData
dataCommand.CommandText = sqlBuilder.BuildQuerySql();
var updateRows = dataCommand.ExecuteNonQuery();
if (updateRows > 0)
{
response.ResultEntity = true;
response.Code = ResponseStaticModel.Code.OK;
response.Message = ResponseStaticModel.Message.OK;
}
else
{
response.ResultEntity = false;
response.Code = ResponseStaticModel.Code.FAILED;
response.Message = ResponseStaticModel.Message.FAILED;
}
}
return(response);
}
public async Task UpdateAdressAsync_GivenAddress_InvokesRepositoryUpdateAsync()
{
var repositoryMock = CreateUserAddressMockRepository();
UserAddressService addressService = new UserAddressService(repositoryMock.Object);
UserAddressDTO addressDTO = new UserAddressDTO
{
UserAddressId = "1",
Address1 = "Example Street",
Address2 = "Example House",
City = "Example City",
ZipCode = "11-111",
State = "Example State",
Country = "Example Country"
};
await addressService.UpdateAdressAsync(addressDTO);
repositoryMock.Verify(p => p.UpdateAsync(It.Is <UserAddress>(s => s.UserAddressId == "1")), Times.Once);
}
public async Task <ActionResult> SetAddress([FromForm] UserAddressDTO collection)
{
if (ModelState.IsValid)
{
var session = HttpContext.Session.GetString("user");
if (session != null)
{
try
{
var uservm = JsonConvert.DeserializeObject <UserDTO>(session);
await _accountService.SetAddress(int.Parse(uservm.ID), collection);
}
catch (Exception) { }
}
}
return(Redirect("/"));
}
public async Task CreateAddressAsync_GivenAddress_InvokesRepositoryCreateAsync()
{
var mockRepository = CreateUserAddressMockRepository();
UserAddressService addressService = new UserAddressService(mockRepository.Object);
UserAddressDTO addressDTO = new UserAddressDTO
{
UserAddressId = "2",
Address1 = "Example Street",
Address2 = "Example House",
City = "Example City",
ZipCode = "11-111",
State = "Example State",
Country = "Example Country"
};
await addressService.CreateAddressAsync(addressDTO);
mockRepository.Verify(s => s.CreateAsync(It.Is <UserAddress>(x => x.UserAddressId == "2")), Times.Once);
}
public IHttpActionResult UserDataById([FromUri] int UserAddressId)
{
try
{
UserAddressDTO UserAddressDTOobject = UserBLobject.GetUserByUserAddressId(UserAddressId);
if (UserAddressDTOobject != null)
{
return(Ok(UserAddressDTOobject));
}
else
{
return(NotFound());
}
}
catch (Exception e)
{
return(InternalServerError(e));
}
}
public HttpResponseMessage DeleteUser([FromBody] UserAddressDTO UserAddressDTOobject)
{
try
{
bool flag = UserBLobject.DeleteUser(UserAddressDTOobject);
if (flag == true)
{
return(Request.CreateResponse(HttpStatusCode.OK));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
}
catch (Exception e)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, e.Message));
}
}
public async Task <ActionResult> EditUserAddress(UserAddressViewModel model)
{
if (ModelState.IsValid)
{
var userToEdit = new UserAddressDTO
{
UserAddressId = User.Identity.GetUserId(),
Address1 = model.Address1,
Address2 = model.Address2,
City = model.City,
ZipCode = model.ZipCode,
State = model.State,
Country = model.Country
};
await _userAddress.UpdateAdressAsync(userToEdit);
return(RedirectToAction("Index", "UserAddress"));
}
return(View());
}
public static QueryResponseDTO <bool> AddUserAddressInfo(UserAddressDTO dto)
{
QueryResponseDTO <bool> response = new QueryResponseDTO <bool>();
response.ResultEntity = false;
var dataCommand = DataCommandManager.GetDataCommand("AddUserAddressInfo");
var updateRows = dataCommand.ExecuteNonQuery(dto);
if (updateRows > 0)
{
response.ResultEntity = true;
response.Code = ResponseStaticModel.Code.OK;
response.Message = ResponseStaticModel.Message.OK;
}
else
{
response.ResultEntity = false;
response.Code = ResponseStaticModel.Code.FAILED;
response.Message = ResponseStaticModel.Message.FAILED;
}
return(response);
}
