public static FlightRequestDto ToDto(this FlightRequest flightRequest)
{
var request = new FlightRequestDto()
{
Id = flightRequest.Id,
Message = flightRequest.Message,
SendTime = flightRequest.SendTime,
IsReaded = flightRequest.IsReaded,
Status = flightRequest.Status
};
request.From = new UserDto()
{
Id = flightRequest.From.Id,
FirstName = flightRequest.From.FirstName,
SecondName = flightRequest.From.SecondName,
Email = flightRequest.From.Email
};
request.To = new UserDto()
{
Id = flightRequest.To.Id,
FirstName = flightRequest.To.FirstName,
SecondName = flightRequest.To.SecondName,
Email = flightRequest.To.Email
};
return(request);
}
public IHttpActionResult GetAvailableFlights(FlightRequest flightRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest("Inavlid request"));
}
try
{
var flights = _service.GetFlights(flightRequest.StartDate, flightRequest.EndDate);
var helicopters = _service.GetAllHelicopter().ToDictionary(x => x.Id, x => x);
var cities = _service.GetAllCities().ToDictionary(x => x.Id, x => x);
var response = new List <FlightResponse>();
flights.ForEach(f =>
{
var temp = new FlightResponse
{
BookedSeats = f.BookedSeats,
Capacity = helicopters[f.HelicopterId].Capacity,
Destination = cities[f.DestinationId],
Source = cities[f.SourceId],
FlightNumber = f.FlightNumber
};
if (temp.Available >= flightRequest.Pax)
{
response.Add(temp);
}
});
return(Ok(response));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public IHttpActionResult Post(FlightRequest flight)
{
if (_flightService.Query().Any(f => f.To.AirportCode == flight.To.Airport &&
f.To.City == flight.To.City && f.To.Country == flight.To.Country &&
f.From.AirportCode == flight.From.Airport &&
f.From.City == flight.From.City &&
f.From.Country == flight.From.Country &&
f.ArrivalTime == flight.ArrivalTime &&
f.DepartureTime == flight.DepartureTime &&
f.Carrier == flight.Carrier))
{
Flight userFlight = _flightService.Query().FirstOrDefault(f => f.To.AirportCode == flight.To.Airport &&
f.To.City == flight.To.City && f.To.Country == flight.To.Country &&
f.From.AirportCode == flight.From.Airport &&
f.From.City == flight.From.City &&
f.From.Country == flight.From.Country &&
f.ArrivalTime == flight.ArrivalTime &&
f.DepartureTime == flight.DepartureTime &&
f.Carrier == flight.Carrier);
_flightService.Delete(userFlight);
}
return(Ok());
}
public IActionResult GetAvailableFlights([FromBody] FlightRequest flightRequest)
{
try
{
if (flightRequest == null)
{
throw new ArgumentException("Invalid Request");
}
if (flightRequest.startDate < DateTime.Now.Date || flightRequest.startDate == DateTime.MinValue)
{
throw new ArgumentException($"Invalid start date {flightRequest.startDate}", nameof(flightRequest.startDate));
}
if (flightRequest.endDate < DateTime.Now.Date || flightRequest.endDate == DateTime.MinValue)
{
throw new ArgumentException($"Invalid end date {flightRequest.endDate}", nameof(flightRequest.endDate));
}
if (flightRequest.numberOfPax < 1)
{
throw new ArgumentException($"Passenger count has to be atleast 1 { flightRequest.numberOfPax }", nameof(flightRequest.numberOfPax));
}
var Result = _flightService.GetAllAvailableFlights(flightRequest.startDate, flightRequest.endDate, flightRequest.numberOfPax);
return(Ok(new JsonResult(Result)));
}
catch (Exception ex)
{
return(BadRequest(new JsonResult(ex.Message)));
}
}
public ActionResult submitFlightRequest(string date1, string date2, string direction, string price, string foodPlanId, string entertainmentPlanId, string sportPlanId)
{
FlightRequest.insertFlightRequest(direction == "1", Convert.ToDateTime(date1), Convert.ToDateTime(date2), Convert.ToDouble(price),
Convert.ToInt32(entertainmentPlanId), Convert.ToInt32(foodPlanId), Convert.ToInt32(sportPlanId), Convert.ToInt32(Session["user"]));
return(RedirectToAction("MainPage", "Home"));
}
public Flight(FlightRequest request, string number)
{
Id = number;
DeparturePoint = request.PointOfDeparture;
DepartureTime = request.DepartureTime;
Destination = request.Destination;
DestinationArrivalTime = request.DestinationArrivalTime;
}
private static bool IsValid(FlightRequest flight)
{
return(!string.IsNullOrEmpty(flight.ArrivalTime) &&
!string.IsNullOrEmpty(flight.DepartureTime) &&
!string.IsNullOrEmpty(flight.Carrier) &&
IsValidAirport(flight.From) && IsValidAirport(flight.To) &&
ValidateDates(flight.DepartureTime, flight.ArrivalTime) &&
IsDifferentAirport(flight.From, flight.To));
}
public void SetDataCorrectly(bool isDeleted)
{
//Arrange
var flightRequest = new FlightRequest {
IsDeleted = isDeleted
};
//Act & Assert
Assert.AreEqual(flightRequest.IsDeleted, isDeleted);
}
public void SetDataCorrectly(int count)
{
//Arrange
var flightRequest = new FlightRequest {
PeopleCount = count
};
//Act & Assert
Assert.AreEqual(flightRequest.PeopleCount, count);
}
public void SetDataCorrectly(int flightRequestId)
{
//Arrange
var flightRequest = new FlightRequest {
Id = flightRequestId
};
//Act & Assert
Assert.AreEqual(flightRequest.Id, flightRequestId);
}
public void SetDataCorrectly(TravelClass travelClass)
{
//Arrange
var flightRequest = new FlightRequest {
TravelClass = travelClass
};
//Act & Assert
Assert.AreEqual(flightRequest.TravelClass, travelClass);
}
private void btnSearch_Click(object sender, EventArgs e)
{
FlightRequest fr = new FlightRequest();
fr = flightRequestList[lstResults.SelectedIndex];
reservationFactory.Search(fr.DateAndTime, fr.OrigAirport, fr.DestAirport, fileMatchPath);
BrowserForm frm = new BrowserForm();
frm.URL = "matchingFlights.xml";
frm.ShowDialog();
}
public void SetDataCorrectly(string toLocation)
{
//Arrange
var flightRequest = new FlightRequest {
ToLocation = toLocation
};
//Act & Assert
Assert.AreEqual(flightRequest.ToLocation, toLocation);
}
public void SetDataCorrectly(string fromLocation)
{
//Arrange
var flightRequest = new FlightRequest {
FromLocation = fromLocation
};
//Act & Assert
Assert.AreEqual(flightRequest.FromLocation, fromLocation);
}
public async Task InsertFlightRequest(FlightRequest flightRequest)
{
var flightRequests = await GetReliableDictionaryAsync("flightRequests");
using (var transaction = stateManager.CreateTransaction())
{
await flightRequests.AddOrUpdateAsync(
transaction, flightRequest.Id, flightRequest, (id, oldFlightRequest) => flightRequest);
await transaction.CommitAsync();
}
}
protected Flight ConvertFlightToDomain(FlightRequest flightRequest)
{
return(new Flight
{
Id = flightRequest.Id,
To = ConvertAirportToDomain(flightRequest.To),
From = ConvertAirportToDomain(flightRequest.From),
Carrier = flightRequest.Carrier,
ArrivalTime = flightRequest.ArrivalTime,
DepartureTime = flightRequest.DepartureTime
});
}
public void SetDataCorrectly(string userId)
{
//Arrange
var regularUser = new RegularUser {
Id = userId
};
var flightRequest = new FlightRequest {
UserId = regularUser.Id
};
//Act & Assert
Assert.AreEqual(flightRequest.UserId, userId);
}
public void SetDataCorrectly(int flightRequestId)
{
//Arrange
var flightRequest = new FlightRequest {
Id = flightRequestId
};
var flightRequestSet = new HashSet <FlightRequest> {
flightRequest
};
var admin = new Admin {
FlightRequests = flightRequestSet
};
//Act & Assert
Assert.AreEqual(admin.FlightRequests.First().Id, flightRequestId);
}
public async Task <IHttpActionResult> AddFlight(FlightRequest flight)
{
if (!IsValid(flight))
{
return(BadRequest());
}
var result = await _flightService.AddFlight(_mapper.Map <Flight>(flight));
if (!result.Succeeded)
{
return(Conflict());
}
flight.Id = result.Entity.Id;
return(Created(string.Empty, flight));
}
public void BrowseQuotes_WhenCall_ReturnExpected()
{
//Arrange
var expectedDepartDate = "2020-08-01";
var expectedInboundIataCode = "JFK";
var expectedOutboundIataCode = "SFO";
var expectedNumberOfStops = "1 stop";
var expectedAirlineName = "Alaska Airlines";
var expectedTripTotalPrice = "$139";
var expectedSource = "Skyscanner";
var expectedBookingBaseUrl = "https://www.kayak.com/flights";
var expectedBookingUrl = $"{expectedBookingBaseUrl}/{expectedOutboundIataCode}/{expectedInboundIataCode}/{expectedDepartDate}/";
IFlightRequest request = new FlightRequest()
{
DepartDate = expectedDepartDate, Destination = expectedInboundIataCode, Origin = expectedOutboundIataCode
};
SkyscannerBrowseQuoteResponse expectedResponse = GetAlaskaFlight();
MockISkyscannerLoader.Setup(_ => _.BrowseQuotesAsync(request)).Returns(Task.FromResult(expectedResponse));
MockISkyscannerLoader.Setup(_ => _.GetBaseBookingUrl()).Returns(expectedBookingBaseUrl);
// Act
var skyscannerQuoteReader = new SkyscannerResponseReader();
Task <List <IFlightResponse> > taskResponse = skyscannerQuoteReader.BrowseQuotesAsync(request);
taskResponse.Wait();
List <IFlightResponse> actualResponses = taskResponse.Result;
var expectedItineraries = 1; // 1 quote, and 1 Outbound, 0 Inbound
var actualItineraries = actualResponses[0].FlightItineraries;
var actualResponse = actualResponses[0];
//Assert
Assert.IsNotNull(actualResponse);
Assert.AreEqual(expectedResponse.Quotes.Length, actualResponses.Count);
Assert.AreEqual(expectedSource, actualResponse.QuoteSource);
Assert.AreEqual(expectedTripTotalPrice, actualResponse.TripTotalPrice);
Assert.AreEqual(expectedBookingUrl, actualResponse.BookingLink);
Assert.AreEqual(expectedItineraries, actualItineraries.Count);
Assert.AreEqual(expectedAirlineName, actualItineraries[0].AirlineName);
Assert.AreEqual(expectedInboundIataCode, actualItineraries[0].InboundIataCode);
Assert.AreEqual(expectedOutboundIataCode, actualItineraries[0].OutboundIataCode);
Assert.AreEqual(expectedNumberOfStops, actualItineraries[0].NumberOfStops);
}
public void GetQuotes_WhenCall_ReturnQuotes()
{
//arrange
IFlightRequest myFlightRequest = new FlightRequest();
IFlightResponse aKayakFlight = new FlightResponse();
var kayakFlights = new List <IFlightResponse>()
{
aKayakFlight
};
mockKayakServices.Setup(_ => _.BrowseQuotesAsync(myFlightRequest)).Returns(Task.FromResult(kayakFlights));
IFlightResponse aSkyscannerFlight = new FlightResponse();
var skyscannerFlights = new List <IFlightResponse>()
{
aSkyscannerFlight
};
mockSkyscannerServices.Setup(_ => _.BrowseQuotesAsync(myFlightRequest)).Returns(Task.FromResult(skyscannerFlights));
//act
var repository = new FlightRepository(new List <IFlightResponseReader>()
{
mockKayakServices.Object, mockSkyscannerServices.Object
});
IEnumerable <IFlightResponse> quoteResponses = repository.BrowseQuotes(myFlightRequest);
var expectedResponses = new List <IFlightResponse>()
{
aKayakFlight, aSkyscannerFlight
};
var expectedLogInfCount = 6;
//assert
Assert.IsNotNull(quoteResponses);
Assert.AreEqual(quoteResponses.Count(), expectedResponses.Count);
Assert.IsTrue(quoteResponses.Contains(expectedResponses[0]));
Assert.IsTrue(quoteResponses.Contains(expectedResponses[1]));
//assert log information
mockILog.Verify(_ => _.Info(It.IsAny <string>()), Times.Exactly(expectedLogInfCount));
//assert no log error
mockILog.Verify(_ => _.Error(It.IsAny <string>()), Times.Never);
}
public OkObjectResult FlightReport([FromBody] FlightRequest flightRequest)
{
_logger?.LogInformation("Entering HomeController FlightReport()");
if (flightRequest == null)
{
throw new ArgumentNullException(nameof(flightRequest));
}
var dataflight = DataService.FlightReport(flightRequest.DepartureAirport, flightRequest.ArrivalAirport, flightRequest.FlightStartDate, flightRequest.FlightEndDate);
// Publish Through RabbitMQ EventBus for Persistence of Flight Request
GenerateReport(dataflight);
_logger?.LogInformation("Leaving HomeController FlightReport()");
return(Ok($"Done : {true}"));
}
private void btnSearch_Click(object sender, EventArgs e)
{
if (version == "1.4")
{
FlightRequest chosen = temp.getRequest(lstbxSearchResults.SelectedIndex);
temp2 = new MatchFlightsFactory(chosen);
MatchingMultiCityFlights match = new MatchingMultiCityFlights(temp2.getMatches());
match.Show();
}
else
{
//send version to Reservation factory which will send to serialize to alter behaviour based on version
temp.findFlights(lstbxSearchResults.SelectedIndex, version);
BrowserForm frm = new BrowserForm();
frm.URL = temp.FileName;
frm.ShowDialog();
}
}
public IEnumerable <TuiNewFlight> GetFlights([FromBody] FlightRequest requestedFight)
{
this._logger?.LogInformation("Entering HomeController GetFlights()");
var flightRequest = requestedFight ?? throw new ArgumentNullException(nameof(requestedFight));
var flights = this.DataService.GetFlights(
flightRequest.DepartureAirport,
flightRequest.ArrivalAirport,
flightRequest.FlightStartDate,
flightRequest.FlightEndDate);
// Persist requested filghts through event bus
// Publish Through EventBus for Persistence of Flight Request
var tuiNewFlights = flights.ToList();
this.PersistRequestedFlights(tuiNewFlights);
return(tuiNewFlights);
}
public async Task <IHttpActionResult> Put(FlightRequest flightRequest)
{
var flight = Mapper.Map <Flight>(flightRequest);
if (await FlightService.Exists(flight))
{
return(Conflict());
}
var response = await FlightService.AddFlight(flight);
if (response.Succeeded)
{
var flightUrl = $"{Request.RequestUri}/{response.Entity.Id}";
var flightResponse = Mapper.Map <FlightResponse>(response.Entity);
return(Created(flightUrl, flightResponse));
}
return(new BadRequest(response.Errors, Request));
}
public static async Task <string> SearchFlight(FlightRequest request)
{
string data = string.Empty;
try
{
var str = $"source={request.Source}&destination={request.Destination}&dateofdeparture={request.DateOfDepa}&seatingclass={request.SeatingClass}&adults={request.Adult}&children={request.Childern}&infants={request.infants}&counter={request.Counter}";
var httpContent = new StringContent(str, Encoding.UTF8, "text/xml");
var response = await WebApiApplication.httpClientInstance.GetAsync(Settings.FlightUrl + str);
if (response.IsSuccessStatusCode)
{
data = await response.Content.ReadAsStringAsync();
}
}
catch (Exception ex)
{
}
return(data);
}
public async Task <IHttpActionResult> AddFlights(FlightRequest flight)
{
await semaphoreSlim.WaitAsync();
try
{
if (!_valid.FlightCheck(flight))
{
if (_flightService.Query().Any(f =>
f.To.AirportCode == flight.To.Airport && f.From.AirportCode == flight.From.Airport &&
f.DepartureTime == flight.DepartureTime && f.ArrivalTime == flight.ArrivalTime &&
f.Carrier == flight.Carrier))
{
return(Conflict());
}
else
{
Flight userFlight = _mapper.Map(flight, new Flight());
_airportService.Create(userFlight.From);
_airportService.Create(userFlight.To);
_flightService.Create(userFlight);
return(Created("", _mapper.Map(userFlight, new FlightResponse())));
}
}
else
{
return(BadRequest());
}
}
finally
{
semaphoreSlim.Release();
}
}
public void BrowseQuotes_WhenCallNotQuotesFound_ReturnEmptyList()
{
// Arrange
IFlightRequest request = new FlightRequest();
var response = new SkyscannerBrowseQuoteResponse()
{
Quotes = new Quote[] { }
};
MockISkyscannerLoader.Setup(_ => _.BrowseQuotesAsync(request)).Returns(Task.FromResult(response));
// Act
var skyscannerQuoteReader = new SkyscannerResponseReader();
Task <List <IFlightResponse> > taskResponse = skyscannerQuoteReader.BrowseQuotesAsync(request);
taskResponse.Wait();
var actualResponse = taskResponse.Result;
// Assert
Assert.IsNotNull(actualResponse);
Assert.AreEqual(actualResponse.Count, 0);
MockILog.Verify(_ => _.Error(It.IsAny <string>()), Times.Never);
}
protected override bool isValid(out string exceptionMessage)
{
if (!validTemplate (template, out exceptionMessage)) {
return false;
}
FlightTemplateRequest ftr = new FlightTemplateRequest ();
FlightTemplate flightTemplate = ftr.fetchFromID (template) [0];
string code = flightTemplate.code;
if (code == null) {
code = flightTemplate.generateCode();
}
FlightRequest fr = new FlightRequest ();
if (fr.fetchFlightFromCodeAndStartDate (code, start).Count() != 0) {
return makeExceptionMessage(out exceptionMessage, "There is already a flight with code " + code + " at " + start);
}
return validLocation(location, out exceptionMessage) && validAirplane(airplane, out exceptionMessage);
}
public FlightResponse GetAllFlightDataByNumber(FlightRequest flightRequest)
{
var response = _flight.GetFlightData(_mapper.Map <FlightDataRequest>(flightRequest)).Result;
return(_mapper.Map <FlightResponse>(response));
}
public async Task InsertFlightRequest(FlightRequest flightRequest)
{
flightRequest.Id = Guid.NewGuid();
await flightRequestRepository.InsertFlightRequest(flightRequest);
}
