public async Task <List <Flight> > GetAsync(FlightFilter filter)
{
try
{
List <DbFlight> dbItems = null;
DbFlightFilter dbFilter = new DbFlightFilter();
dbFilter.Pkid = filter.FlightId;
await ExecuteAsync(async (connection) =>
{
var dbFlights = await connection.QueryAsync <DbFlight>(
sql: "usp_SelectFlights",
param: dbFilter,
commandType: CommandType.StoredProcedure
);
dbItems = dbFlights.ToList();
});
if (dbItems == null || false == dbItems.Any())
{
return(new List <Flight>());
}
return(dbItems.Select(dbItem => toFlight(dbItem)).ToList());
}
catch (Exception ex)
{
//TODO: log error
return(await Task.FromResult <List <Flight> >(new List <Flight>()));
}
}
public async Task <IActionResult> FindFlights([FromQuery] FlightFilter flightFilter, [FromQuery] SearchOption searchOption = SearchOption.Default)
{
var query = new GetFilteredFlightsQuery(flightFilter, searchOption);
var result = await _mediator.Send(query);
return(Ok(result));
}
public void Test1_DepartAfter_AddOneValidFlight()
{
// generate a date time to work with
var departureDateToTest = new System.DateTime(2030, 01, 01);
var flight = new Flight();
// create our segment with it's departure set to be the target data
var segment1 = new Segment();
segment1.Departure = departureDateToTest;
flight.Segments.Add(segment1);
var flights = new List <Flight>();
flights.Add(flight);
// call our function to test
var filterToTest = new FlightFilter();
var results = filterToTest.SetModelCollection(flights).DepartAfter(departureDateToTest.AddDays(-1)).Evaluate();
Assert.AreEqual(results.Count, 1);
}
public async Task <ItemsPage <Flight> > SearchFlightsAsync(FlightFilter filter)
{
FlightFilterEntity filterDal = _mapper.Map <FlightFilterEntity>(filter);
if (filter.SearchFlightsBack)
{
filterDal.PageLimit = (int)Math.Floor(Convert.ToDecimal(filter.PageLimit / 2));
}
ItemsPageEntity <FlightEntity> flightsDal =
await _flightRepository.SearchFlightsAsync(filterDal);
if (filter.SearchFlightsBack)
{
int?fromCityIdBuff = filterDal.FromCityId;
filterDal.FromCityId = filterDal.ToCityId;
filterDal.ToCityId = fromCityIdBuff;
int?fromAirportIdBuff = filterDal.FromAirportId;
filterDal.FromAirportId = filterDal.ToAirportId;
filterDal.ToAirportId = fromAirportIdBuff;
filterDal.DepartureDate = filter.DepartureBackDate;
filterDal.ArrivalDate = filter.ArrivalBackDate;
ItemsPageEntity <FlightEntity> flightsBackDal =
await _flightRepository.SearchFlightsAsync(filterDal);
flightsDal.Content = flightsDal.Content.Concat(flightsBackDal.Content).ToList();
}
return(_mapper.Map <ItemsPage <Flight> >(flightsDal));
}
public void Test2_DepartAfter_AddTwoFlightsWhereOneIsInvalid()
{
// generate a date time to work with
var departureDateToTest = new System.DateTime(2030, 01, 01);
var flight1 = new Flight();
var flight2 = new Flight();
// create one flight departing after the date
var segment1 = new Segment();
segment1.Departure = departureDateToTest.AddDays(1);
flight1.Segments.Add(segment1);
// and one before
var segment2 = new Segment();
segment2.Departure = departureDateToTest.AddDays(-1);
flight2.Segments.Add(segment2);
var flights = new List <Flight>();
flights.Add(flight1);
flights.Add(flight2);
// call our function to test
var filterToTest = new FlightFilter();
var results = filterToTest.SetModelCollection(flights).DepartAfter(departureDateToTest).Evaluate();
Assert.AreEqual(results.Count, 1);
}
public void ShouldReturnAValidFilterOnDateStartLessThanDateEnd()
{
var filter = new FlightFilter {
FilterType = FilterType.Date, DateStart = DateTime.Now, DateEnd = DateTime.Now.AddDays(1)
};
filter.IsValid().Should().BeTrue();
}
public void ShouldReturnAnInvalidFilterOnDateStartGreaterThanDateEnd()
{
var filter = new FlightFilter {
FilterType = FilterType.Date, DateStart = DateTime.Now.AddDays(1), DateEnd = DateTime.Now
};
filter.IsValid().Should().BeFalse();
}
public void ShouldReturnAnInvalidFilterOnInvalidDateEndMissing()
{
var filter = new FlightFilter {
FilterType = FilterType.Date, DateStart = DateTime.Now
};
filter.IsValid().Should().BeFalse();
}
public void ShouldReturnAValidFilterOnSuppliedLaunchType(string launchType)
{
var filter = new FlightFilter {
FilterType = FilterType.Launch, Launch = launchType
};
filter.IsValid().Should().BeTrue();
}
public void ShouldReturnAnInvalidFilterOnMissingLaunchType()
{
var filter = new FlightFilter {
FilterType = FilterType.Launch
};
filter.IsValid().Should().BeFalse();
}
public void ShouldReturnValidFilterOnValidCrewPosition(int position)
{
var filter = new FlightFilter {
FilterType = FilterType.Crew, Crew = position
};
filter.IsValid().Should().BeTrue();
}
public void ShouldReturnAnInvalidFilterOnAirfieldMissing()
{
var filter = new FlightFilter {
FilterType = FilterType.Airfield
};
filter.IsValid().Should().BeFalse();
}
public void ShouldReturnAValidFilterOnFlightStartLessThanFlightEnd()
{
var filter = new FlightFilter {
FilterType = FilterType.Number, FlightStart = 1, FlightEnd = 2
};
filter.IsValid().Should().BeTrue();
}
public void ShouldReturnAnInvalidFilterOnInvalidFlightStartMissing()
{
var filter = new FlightFilter {
FilterType = FilterType.Number, FlightEnd = 0
};
filter.IsValid().Should().BeFalse();
}
public void ShouldReturnAnInvalidFilterOnNumberAndDateCombined()
{
var filter = new FlightFilter {
FilterType = FilterType.Date | FilterType.Number
};
filter.IsValid().Should().BeFalse();
}
public void SetUp()
{
//arrange
fakeDataFormatter = Substitute.For <IDataFormatter>();
fakeFlightCollection = Substitute.For <IFlightCollection>();
uut = new FlightFilter(fakeDataFormatter);
}
public bool IsEmptyFilter(FlightFilter filter)
{
if (string.IsNullOrEmpty(filter.StartingPoint) && string.IsNullOrEmpty(filter.TermitationPoint) && filter.Date == new DateTime())
{
return(true);
}
return(false);
}
public void ShouldReturnAValidFilterOnDateStartEqualDateEnd()
{
var date = DateTime.Now;
var filter = new FlightFilter {
FilterType = FilterType.Date, DateStart = date, DateEnd = date
};
filter.IsValid().Should().BeTrue();
}
public async Task <List <Flight> > GetAsync(FlightFilter filter)
{
try
{
return(await repository.GetAsync(filter));
}
catch (Exception ex)
{
//TODO: log error
return(new List <Flight>());
}
}
public void TestNullFlights()
{
filter = new FlightFilter(5);
if (filter.FFiltreOut(null) == null)
{
Assert.Pass();
}
else
{
Assert.Fail();
}
}
public void TestNotAllowedFilterType()
{
filter = new FlightFilter(5);
if (filter.FFiltreOut(flights) == null)
{
Assert.Pass();
}
else
{
Assert.Fail();
}
}
public void TestEmptyFlights()
{
filter = new FlightFilter(5);
if (filter.FFiltreOut(new List <Flight>()) == null)
{
Assert.Pass();
}
else
{
Assert.Fail();
}
}
public void Test3Quest()
{
filter = new FlightFilter(2);
if (filter.FFiltreOut(flights).Count != 0)
{
Assert.Pass();
}
else
{
Assert.Fail();
}
}
private async Task <FilteredFlightResponse> GetFilteredFlightResponseDefault(FlightFilter filter)
{
FilteredFlightResponse result;
var locations = (await _locationsRepository.GetAsync(location =>
location.Id == filter.OriginLocationId ||
location.Id == filter.DestinationLocationId)).ToList();
var generatedDepartureEntities = (await _entityGenerator.GenerateRandomEntities(locations, filter.OriginDateTime, 10))
.Where(f => f.StartLocationId == filter.OriginLocationId)
.OrderBy(f => f.StartDateTime);
var filteredDepartureFlights = generatedDepartureEntities.Where(e => e.StartLocationId == filter.OriginLocationId)
.Select(f =>
{
f.StartLocation = locations.Where(l => l.Id == f.StartLocationId).FirstOrDefault();
f.EndLocation = locations.Where(l => l.Id == f.EndLocationId).FirstOrDefault();
return(f);
});
if (filter.ReturnDateTime != null)
{
var generatedArrivalEntities = (await _entityGenerator.GenerateRandomEntities(locations, ((DateTime)filter.ReturnDateTime), 10))
.Where(f => f.StartLocationId == filter.OriginLocationId)
.OrderBy(f => f.StartDateTime);
var filteredArrivalFlights = generatedArrivalEntities.Where(e => e.EndLocationId == filter.DestinationLocationId)
.Select(f =>
{
f.StartLocation = locations.Where(l => l.Id == f.EndLocationId).FirstOrDefault();
f.EndLocation = locations.Where(l => l.Id == f.StartLocationId).FirstOrDefault();
return(f);
});
result = new FilteredFlightResponse()
{
Departure = FilteredFlightsMapper.Mapper.Map <List <FlightResponse> >(filteredDepartureFlights),
Arrival = FilteredFlightsMapper.Mapper.Map <List <FlightResponse> >(filteredArrivalFlights)
};
}
else
{
result = new FilteredFlightResponse()
{
Departure = FilteredFlightsMapper.Mapper.Map <List <FlightResponse> >(filteredDepartureFlights),
Arrival = null
};
}
return(result);
}
public List <FlightByFilter> GetFlightsByFilter(FlightFilter filter = null)
{
try
{
var result = (from f in db.Flights
join a in db.Aircrafts on f.AircraftId equals a.Id
join am in db.AircraftModels on a.ModelId equals am.Id
join airl in db.Airlines on f.AirlineId equals airl.Id
join wp1 in db.Waypoints on f.StartingPointId equals wp1.Id
join wp2 in db.Waypoints on f.TermitationPointId equals wp2.Id
select new FlightByFilter
{
FlightId = f.Id,
Aircraft = a,
AircraftModel = am.Model,
AirlineId = airl.Id,
AirlineName = airl.Name,
StartingPoint = wp1,
TermitationPoint = wp2
});
if (filter != null)
{
if (!new FilterHandler().IsEmptyFilter(filter))
{
if (!String.IsNullOrEmpty(filter.StartingPoint))
{
result = result.Where(f => f.StartingPoint.City.Contains(filter.StartingPoint));
}
if (!String.IsNullOrEmpty(filter.TermitationPoint))
{
result = result.Where(f => f.TermitationPoint.City.Contains(filter.TermitationPoint));
}
if (!(filter.Date == new DateTime()))
{
result = result.Where(f => f.StartingPoint.DateTime.Date == filter.Date);
}
}
}
return(result.OrderBy(r => r.StartingPoint.DateTime).ToList());
}
catch (Exception ex)
{
return(null);
}
}
public IHttpActionResult Post([FromBody] FlightFilter filter)
{
if (filter == null)
{
return(BadRequest("Invalid Filter"));
}
if (!filter.IsValid())
{
return(BadRequest("Invalid Filter"));
}
dynamic flights = _flightProvider.GetFilteredFlights(filter);
return(((List <Flight>)flights).Any() ? Ok(flights) : NotFound());
}
public static List <Flight> GetByHour(FlightFilter filter)
{
try
{
using (var db = Configuration.Instance().ContextDB())
{
return(db.Flights.Include(x => x.ArrivalCity).Include(x => x.DepartureCity)
.Where(x => x.ArrivalStationId == filter.ArrivalStationId &&
x.DepartureStationId == filter.DepartureStationId &&
x.DepartureDate == filter.DepartureDate).ToList());
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <List <Flight> > GetAsync(FlightFilter filter)
{
try
{
List <Flight> flights = new List <Flight>();
var collection = Database.GetCollection <MongoFlight>("Flights");
var asyncCursor = await collection.FindAsync <MongoFlight>(new BsonDocument());
var dbFlights = await asyncCursor.ToListAsync();
if (dbFlights == null || false == dbFlights.Any())
{
return(flights);
}
dbFlights.ForEach(dbFlight =>
{
try
{
var flight = toFlight(dbFlight);
if (flight != null)
{
flights.Add(flight);
}
}
catch (Exception ex)
{
//TODO: log error
}
});
return(flights);
}
catch (Exception ex)
{
//TODO: handle exception
return(new List <Flight>());
}
}
public IHttpActionResult GetByHourFilter(FlightFilter filter)
{
try
{
var result = DaoFlight.GetByHour(filter);
var respuesta = new
{
errorCode = 0,
messageError = "Consulta correcta.",
flights = result
};
return(Ok(respuesta));
}
catch (Exception ex)
{
CatchError.Log4Net("ERROR", ex);
return(BadRequest(ex.Message));
}
}
public List <Flight> GetFilteredFlights(FlightFilter filter)
{
if (!filter.IsValid())
{
throw new InvalidFilterException("");
}
var flights = GetAllFlights();
if (((int)filter.FilterType & (int)FilterType.Number) == (int)FilterType.Number)
{
flights = GetFlightsByNumber(flights, filter);
}
if (((int)filter.FilterType & (int)FilterType.Date) == (int)FilterType.Date)
{
flights = GetFlightsByDate(flights, filter);
}
if (((int)filter.FilterType & (int)FilterType.Aircraft) == (int)FilterType.Aircraft)
{
flights = GetFlightByAircraft(flights, filter);
}
if (((int)filter.FilterType & (int)FilterType.Airfield) == (int)FilterType.Airfield)
{
flights = GetFlightByAirfield(flights, filter);
}
if (((int)filter.FilterType & (int)FilterType.Launch) == (int)FilterType.Launch)
{
flights = GetFlightByLaunch(flights, filter);
}
if (((int)filter.FilterType & (int)FilterType.Crew) == (int)FilterType.Crew)
{
flights = GetFlightByCrew(flights, filter);
}
if (((int)filter.FilterType & (int)FilterType.Trace) == (int)FilterType.Trace)
{
flights = GetFlightsWithTraceFiles(flights);
}
return(flights);
}
