public async Task CreateGuestAsync_CreatesGuest_IfGuestDtoCorrect() { // Arrange var mapperConfig = new MapperConfiguration(cfg => cfg.AddProfile <MappingProfile>()); var mapper = mapperConfig.CreateMapper(); var options = await SetupTestDatabaseAsync(_guests); var httpContextAccessor = new Mock <IHttpContextAccessor>(); var guestRepository = new GuestRepository(new WeddingPlannerDbContext(options, httpContextAccessor.Object)); var guestService = new GuestService(mapper, guestRepository); // Act var guestDto = new GuestDto { FirstName = "John", LastName = "Doe" }; await guestService.CreateAsync(guestDto); // Assert using var context = new WeddingPlannerDbContext(options, httpContextAccessor.Object); var guests = await context.Guests.ToListAsync(); var guest = await context.Guests.SingleAsync(x => x.Id == 4); guest.Should().NotBeNull(); guest.Id.Should().Be(4); guest.FirstName.Should().Be("John"); guest.LastName.Should().Be("Doe"); }
public async Task CreateGuestAsync_ReturnErrorResponse_IfExceptionThrown() { // Arrange var mockGuestDto = new GuestDto { FirstName = "John", LastName = "Doe", Age = 30 }; var mockGuest = new Guest { FirstName = "John", LastName = "Doe", Age = 30 }; var mockMapper = new Mock <IMapper>(); mockMapper.Setup(x => x.Map <Guest>(mockGuestDto)).Returns(mockGuest); var mockRepo = new Mock <IGuestRepository>(); mockRepo.Setup(x => x.CreateAsync(mockGuest)).Throws(new Exception("test message")); // Act var service = new GuestService(mockMapper.Object, mockRepo.Object); var result = await service.CreateAsync(mockGuestDto); // Assert result.Should().BeOfType <GuestResponse>(); result.Result.Should().BeFalse(); result.Status.Should().Be(ResponseStatus.Error); result.Item.Should().BeNull(); result.Message.Should().Contain("test message"); }
public async Task <IActionResult> PutGuest(int id, GuestDto guestDto) { if (id != guestDto.Id) { return(BadRequest()); } var guest = _mapper.Map <GuestDto, Guest>(guestDto); _context.Entry(guest).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!GuestExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task CreateGuestAsync_ReturnSuccessResponse_ForValidGuestDto() { // Arrange var mockGuestDto = new GuestDto { FirstName = "John", LastName = "Doe", Age = 30 }; var mockGuest = new Guest { FirstName = "John", LastName = "Doe", Age = 30 }; var mockMapper = new Mock <IMapper>(); mockMapper.Setup(x => x.Map <Guest>(mockGuestDto)).Returns(mockGuest); var mockRepo = new Mock <IGuestRepository>(); // Act var service = new GuestService(mockMapper.Object, mockRepo.Object); var result = await service.CreateAsync(mockGuestDto); // Assert result.Should().BeOfType <GuestResponse>(); result.Result.Should().BeTrue(); result.Status.Should().Be(ResponseStatus.Success); result.Item.Id.Should().Be(mockGuest.Id); result.Item.FirstName.Should().Be(mockGuest.FirstName); result.Item.LastName.Should().Be(mockGuest.LastName); }
public IHttpActionResult EditGuest(int id, [FromBody] GuestDto guestDto) { if (!ModelState.IsValid) { throw new HttpResponseException(HttpStatusCode.BadRequest); } var guestInDb = Context.Guests.SingleOrDefault(g => g.Id == id); if (guestInDb == null) { throw new HttpResponseException(HttpStatusCode.NotFound); } Mapper.Map(guestDto, guestInDb); try { Context.SaveChanges(); return(Ok(guestInDb)); } catch (Exception e) { Logger.Error(e, e.Message); return(BadRequest($"Error{e.Message}")); } }
public Domain.HotelAggregate.Hotel FindCheapest(GuestDto guest) { var _valuesPerHotel = new List <Tuple <Domain.HotelAggregate.Hotel, decimal> >(); var hotels = _hotelRepository.GetAll(); foreach (var hotel in hotels) { var reservationSum = 0m; foreach (var day in guest.DaysOfStaying) { var dayType = day.IsWeekend() ? ReservationDayType.Weekend : ReservationDayType.Weekday; var reservationTypeByDayAndGuestType = hotel.ReservationValues .FirstOrDefault(r => r.GuestType == guest.GuestType && r.DayType == dayType); if (reservationTypeByDayAndGuestType != null) { reservationSum += reservationTypeByDayAndGuestType.Value; } } _valuesPerHotel.Add(new Tuple <Domain.HotelAggregate.Hotel, decimal>(hotel, reservationSum)); } var cheapestHotelInTuple = _valuesPerHotel .OrderBy(t => t.Item2) .ThenByDescending(t => t.Item1.Rating) .FirstOrDefault(); return(cheapestHotelInTuple.Item1); }
public async Task Register_UserIsUnauthenticated_CreatesGuestUsingMediatorAndReturnsCreatedGuest() { var expectedGuestDto = new GuestDto() { Id = 5, Username = "******", Password = "******" }; this.mediatorMock.Setup(m => m.Send(It.IsAny <CreateGuestCommand>(), It.IsAny <CancellationToken>())) .ReturnsAsync(expectedGuestDto); var controller = this.GetUnauthenticatedController(); var command = new CreateGuestCommand() { Username = "******", Password = "******" }; var result = await controller.Register(command).ConfigureAwait(false); var okObjectResult = Assert.IsAssignableFrom <OkObjectResult>(result); var user = Assert.IsAssignableFrom <UserDto>(okObjectResult.Value); Assert.Equal(expectedGuestDto.Id, user.Id); this.mediatorMock.Verify(m => m.Send(command, CancellationToken.None), Times.Once); }
public async Task <IActionResult> UpdateGuest(int id, [FromBody] GuestDto guest) { try { if (id != guest.Id) { return(BadRequest("Id to update does not match entity Id")); } Entity.Guest entity = await _guestsRepository.Get(id); if (guest.ConfirmedGuests > entity.TotalGuestsAllowed) { return(BadRequest("Cannot have more guests than the maximum allowed for thie guest")); } entity.Name = guest.Name; entity.ConfirmedGuests = guest.ConfirmedGuests; entity.Partner = guest.Partner; await _guestsRepository.Update(entity); } catch (Exception e) { return(BadRequest(e.Message)); } return(Ok()); }
public void Validade(GuestDto guest) { if (guest == null) { throw new ArgumentException("Pessoa informada não encontrada"); } }
public async Task <IActionResult> CreateGuest([FromBody] GuestDto guest) { if (guest == null) { return(BadRequest()); } await _guestService.Add(guest); return(Created("Created new Guest", guest)); }
public async Task <IActionResult> UpdateGuest([FromBody] GuestDto guest) { if (guest == null) { return(BadRequest()); } await _guestService.Update(guest); return(Ok()); }
public static GuestDto ToDtoGuest(Guest g) { GuestDto gu = new GuestDto(); gu.guest_id = g.guest_id; gu.guest_first_name = g.guest_first_name; gu.guest_last_name = g.guest_last_name; gu.guest_email = g.guest_email; // gu.guest_tz = g.guest_tz; ///.... return(gu); }
public async Task <ActionResult <GuestDto> > PostGuest(GuestDto guestDto) { var guest = _mapper.Map <GuestDto, Guest>(guestDto); guest.FullName = getFullName(guest.FirstName, guest.MiddleName, guest.LastName); _context.Guests.Add(guest); await _context.SaveChangesAsync(); guestDto.Id = guest.Id; guestDto.FullName = guest.FullName; return(CreatedAtAction("GetGuest", new { id = guest.Id }, guestDto)); }
public async Task CreateGuest_WhenGuestDtoIsNull_ReturnsNullGuestDto() { var client = GetHttpClient(); GuestDto guestDto = null; var response = await client.PostAsJsonAsync("api/guests", Mapper.Map <Guest, GuestDto>(null)); if (response.IsSuccessStatusCode) { guestDto = await response.Content.ReadAsAsync <GuestDto>(); } Assert.IsNull(guestDto, "Trying to post empty Guest"); }
public static Guest ToDalGuestEdit(GuestDto g) { Guest gu = new Guest(); gu.guest_id = g.guest_id; gu.guest_first_name = g.guest_first_name; gu.guest_last_name = g.guest_last_name; gu.guest_email = g.guest_email; gu.gender = g.gender; //gu.guest_tz = g.guest_tz; gu.guest_message_befor = g.guest_message_befor; gu.guest_message_after = g.guest_message_after; return(gu); }
public async Task GetGuest_WhenIdNotValid_ReturnsGuestDto() { var id = -1; var client = GetHttpClient(); GuestDto guestDto = null; var response = await client.GetAsync("api/guests/" + id); if (response.IsSuccessStatusCode) { guestDto = await response.Content.ReadAsAsync <GuestDto>(); } Assert.IsNull(guestDto, "Failed request."); }
public async Task CreateGuest_WhenGuestDtoIsValid_ReturnsGuestDto() { var client = GetHttpClient(); GuestDto guestDto = null; var guestToCreate = MockGuest(); var response = await client.PostAsJsonAsync("api/guests", Mapper.Map <Guest, GuestDto>(guestToCreate)); if (response.IsSuccessStatusCode) { guestDto = await response.Content.ReadAsAsync <GuestDto>(); } Assert.IsNotNull(guestDto); Assert.IsInstanceOfType(guestDto, typeof(GuestDto), "Guest successfully added"); }
public async Task DeleteGuest_WhenCalledWithValidId_ReturnsDeletedObject() { var client = GetHttpClient(); GuestDto guestDto = null; var guestToDelete = GetGuestToDelete().GetAwaiter().GetResult(); var response = await client.DeleteAsync($"api/guests/{guestToDelete.Id}"); if (response.IsSuccessStatusCode) { guestDto = await response.Content.ReadAsAsync <GuestDto>(); } Assert.IsNotNull(guestDto); Assert.AreEqual(guestToDelete.Id, guestDto.Id, "Guest Id is valid"); Assert.IsInstanceOfType(guestDto, typeof(GuestDto), "Object Deleted successfully"); }
public async Task GetGuest_WhenIdIsValid_ReturnsGuestDto() { var id = 1; var client = GetHttpClient(); GuestDto guestDto = null; var response = await client.GetAsync("api/guests/" + id); if (response.IsSuccessStatusCode) { guestDto = await response.Content.ReadAsAsync <GuestDto>(); } Assert.IsNotNull(guestDto, "Request success."); Assert.AreEqual(guestDto.GetType(), typeof(GuestDto), "GuestDto returned."); }
public static Guest ToDalGuest(GuestDto g) { Guest gu = new Guest(); //Random rand = new Random(); //עשיתי מספרים גבוהים כי ךא עובד הבדיקה gu.guest_id = GuestDal.GetHID() + 1; gu.guest_first_name = g.guest_first_name; gu.guest_last_name = g.guest_last_name; gu.guest_email = g.guest_email; gu.gender = g.gender; //gu.guest_tz = g.guest_tz; gu.guest_message_befor = g.guest_message_befor; gu.guest_message_after = g.guest_message_after; return(gu); }
public GuestDto CreateGuest(GuestDto guestDto) { if (ModelState.IsValid) { throw new HttpResponseException(HttpStatusCode.BadRequest); } var guest = Mapper.Map <GuestDto, User_Guest_Detail>(guestDto); _db.User_Guest_Detail.Add(guest); _db.SaveChanges(); guestDto.gstID = guest.gstID; return(guestDto); }
public async Task EditGuest_WithVaildGuestId_ReturnsUpdatedGuestObject() { var client = GetHttpClient(); GuestDto guestDto = null; var guestToUpdate = MockGuestToDb(); guestToUpdate.FirstName = "UpdatedTestName"; var response = await client.PutAsJsonAsync("api/guests/" + guestToUpdate.Id, Mapper.Map <Guest, GuestDto>(guestToUpdate)); if (response.IsSuccessStatusCode) { guestDto = await response.Content.ReadAsAsync <GuestDto>(); } Assert.IsNotNull(guestDto); Assert.AreEqual("UpdatedTestName", guestDto.FirstName, "FirstName updated successfully"); Assert.IsInstanceOfType(guestDto, typeof(GuestDto), "Returned GuestDto object"); }
public void UpdateGuest(int id, GuestDto guestDto) { if (!ModelState.IsValid) { throw new HttpResponseException(HttpStatusCode.BadRequest); } var guestInDb = _db.User_Guest_Detail.SingleOrDefault(c => c.gstID == id); if (guestInDb == null) { throw new HttpResponseException(HttpStatusCode.NotFound); } Mapper.Map(guestDto, guestInDb); _db.SaveChanges(); }
public void UpdateGuest(int id, GuestDto guestDto) { if (!ModelState.IsValid) { throw new HttpResponseException(HttpStatusCode.BadRequest); } var guestInDataBase = _context.Guests.SingleOrDefault(g => g.ID == id); if (guestInDataBase == null) { throw new HttpResponseException(HttpStatusCode.NotFound); } Mapper.Map(guestDto, guestInDataBase); _context.SaveChanges(); }
private static Guest GuestMapper(GuestDto guest) { return(new Guest() { FirstName = guest.FirstName, LastName = guest.LastName, Email = guest.Email, CompanyName = guest.CompanyName, Nip = guest.Nip, Id = guest.Id, Reservation = new Reservation() { Price = guest.Price, ReservationNumber = guest.ReservationNumber, CheckIn = guest.CheckIn, CheckOut = guest.CheckOut } }); }
public async Task <IActionResult> Create([FromBody] GuestDto model) { if (!ModelState.IsValid) { _logger.LogWarning("Guest model is not valid."); return(BadRequest()); } var response = await _guestService.CreateAsync(model); if (!response.Result) { _logger.LogError($"An error occured during guest creation."); return(BadRequest(response)); } _logger.LogInformation($"Guest successfully created: {response.Item.Id}"); return(new OkObjectResult(response)); }
public async Task Create_ReturnsOkResult_WithGuest_ForGivenGuestDto() { // Arrange var mockLogger = new Mock <ILogger <GuestsController> >(); var mockService = new Mock <IGuestService>(); var mockGuest = new GuestDto { Id = 1, FirstName = "John", LastName = "Doe" }; var mockItem = new GuestDto { Id = 1, FirstName = "John", LastName = "Doe" }; var mockResponse = new GuestResponse( BaseApiResponse <GuestDto> .CreateSuccessResponse("test message", mockItem)); mockService.Setup(svc => svc.CreateAsync(mockGuest)).ReturnsAsync(mockResponse); var controller = new GuestsController(mockLogger.Object, mockService.Object); // Act var result = await controller.Create(mockGuest); // Assert result.Should().BeOfType <OkObjectResult>(); var okObjectResult = (OkObjectResult)result; okObjectResult.Value.Should().NotBeNull(); okObjectResult.Value.Should().BeOfType <GuestResponse>(); var response = (GuestResponse)okObjectResult.Value; response.Result.Should().BeTrue(); response.Status.Should().Be(ResponseStatus.Success); response.Item.Id.Should().Be(mockGuest.Id); response.Item.FirstName.Should().Be(mockGuest.FirstName); response.Item.LastName.Should().Be(mockGuest.LastName); }
public IActionResult AddGuest([FromBody] GuestForCreationDto guest) { if (guest.Name == null) { return(BadRequest()); } var newGuest = new GuestDto() { Name = guest.Name, }; GuestsDataStore.Current.Guests.Add(newGuest); var id = Guid.NewGuid(); // Return response return(CreatedAtRoute("GetGuest", new { guestId = id }, newGuest)); }
public async Task CreateGuestAsync_ReturnErrorResponse_ForNullParam() { // Arrange GuestDto mockGuestDto = null; Guest mockGuest = null; var mockMapper = new Mock <IMapper>(); mockMapper.Setup(x => x.Map <Guest>(mockGuestDto)).Returns(mockGuest); var mockRepo = new Mock <IGuestRepository>(); // Act var service = new GuestService(mockMapper.Object, mockRepo.Object); var result = await service.CreateAsync(mockGuestDto); // Assert result.Should().BeOfType <GuestResponse>(); result.Result.Should().BeFalse(); result.Status.Should().Be(ResponseStatus.Error); result.Item.Should().BeNull(); }
// GET: api/guests public IHttpActionResult Get([FromUri] string name = "Piotr", string city = "") { var guests = new List <Guest>(); if (String.IsNullOrEmpty(city)) { guests = _guestRepo.FindAllByFilter(x => x.FirstName == name).ToList(); } else { guests = _guestRepo.FindAllByFilter(x => x.FirstName == name && x.City == city).ToList(); } if (!guests.Any()) { return(NotFound()); } var guestsDto = GuestDto.CreateManyGuestDto(guests); return(Ok(guestsDto)); }