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); }