public decimal CalculateFinalPrice(TourSearchRequest request, List <TourRecord> records)
{
decimal FinalPrice = 0;
for (int i = 0; i < records.Count(); i++)
{
if (records[i].Country == request.ToCountry)
{
for (int j = 0; j < records[i].StartTimes.Length; j++)
{
if (records[i].StartTimes[j] == request.DepartureDate)
{
FinalPrice += records[i].BasePriceForPerson * request.PersonCount;
DateTime date1 = records[i].StartTimes[j];
DateTime date2 = DateTime.Now;
TimeSpan span = date1 - date2;
double days = span.TotalDays;
if (days < 10)
{
FinalPrice += FinalPrice * 10 / 100;
}
if (records[i].PlacesLeft[j] < 3)
{
FinalPrice += FinalPrice * 15 / 100;
}
}
}
}
}
return(FinalPrice);
}
public async Task <TourSearchResponse> SearchAsync(TourSearchRequest tourSearchRequest)
{
var cts = new CancellationTokenSource();
var standartProviderSearchTask = _standartProvider.SearchAsync(tourSearchRequest, cts.Token);
var otherProviderSearchTask = _otherProvider.SearchAsync(tourSearchRequest, cts.Token);
var searchTasks = new[] { standartProviderSearchTask, otherProviderSearchTask };
await Task.WhenAny(Task.WhenAll(searchTasks), Task.Delay(_settings.MaxWaitTime));
cts.Cancel();
var completedResults =
searchTasks
.Where(t => t.Status == TaskStatus.RanToCompletion)
.Select(t => t.Result)
.ToList();
var tours = completedResults
.SelectMany(x => x)
.GroupBy(x => x, Tour.TourComparer)
.Select(tourGroup =>
{
if (tourGroup.Count() == 1)
{
return(tourGroup.First());
}
var minPriceTour = tourGroup.OrderBy(x => x.TotalPrice).First();
var preferedTour = tourGroup.FirstOrDefault(x => x.Provider.Equals(_settings.PreferedProviderName));
if (preferedTour != null && preferedTour.TotalPrice < minPriceTour.TotalPrice * _settings.MaxPreferedProviderPriceFactor)
{
return(preferedTour);
}
else
{
return(minPriceTour);
}
})
.AsQueryable()
.ApplySorting(tourSearchRequest)
.ToList();
var result = new TourSearchResponse
{
Status = "xz",
Tours = tours
};
return(result);
}
public List <TourSearchResponse> GetTourSearchResponse(TourSearchRequest request)
{
List <TourRecord> filteredTourRecords = FilterByCriteria(request);
decimal FinalPrice = CalculateFinalPrice(request, filteredTourRecords);
List <TourSearchResponse> responses = new List <TourSearchResponse>();
for (int i = 0; i < filteredTourRecords.Count; i++)
{
responses.Add(new TourSearchResponse(filteredTourRecords[i].Name, filteredTourRecords[i].City, CalculateTourPopularity(filteredTourRecords[i]), FinalPrice));
}
return(responses);
}
public void Should_Find_ByCriteria()
{
// Arrange
TourStorage storage = new TourStorage();
storage.AddTour(new TourRecord
(
1,
"Tour to Japan, Kyoto",
"Japan",
"Kyoto",
new DateTime[] { new DateTime(2018, 08, 11) },
new int[] { 7 },
new int[] { 4 },
4,
800000
));
storage.AddTour(new TourRecord
(
2,
"Tour to USA, Virginia",
"USA",
"Virginia",
new DateTime[] { new DateTime(2018, 07, 11) },
new int[] { 11 },
new int[] { 5 },
8,
300000
));
storage.AddTour(new TourRecord
(
3,
"Tour to USA, Virginia",
"USA",
"Virginia",
new DateTime[] { new DateTime(2018, 07, 25) },
new int[] { 12 },
new int[] { 7 },
8,
350000
));
TourService service = new TourService(storage);
TourSearchRequest request = new TourSearchRequest("Japan", new DateTime(2018, 08, 10), 2, 3);
// Act
List <TourRecord> filtered = service.FilterByCriteria(request);
// Assert
Assert.IsTrue(filtered[0].City == "Kyoto");
}
public async Task <List <Tour> > SearchAsync(TourSearchRequest tourSearchRequest, CancellationToken cancellationToken)
{
var tours = _tourRepository.Tours
.Where(tourSearchRequest.Criteria)
.ApplySorting(tourSearchRequest)
.Take(_settings.ToursPackSize)
.ToList();
var personCount = tourSearchRequest.PersonCount.GetValueOrDefault(_settings.DefaultPersonCount);
await tours.ForEachAsync(Environment.ProcessorCount, x => _priceCalculator.CalculatePrice(x, personCount));
var random = new Random((int)DateTime.Now.Ticks);
await Task.Delay(random.Next(3000, 17000), cancellationToken);
return(tours);
}
public void BuyTicket(TourSearchRequest request)
{
List <TourRecord> allTours = _tourStorage.ReadAllTours();
for (int i = 0; i < allTours.Count; i++)
{
if (allTours[i].Country == request.ToCountry)
{
for (int j = 0; j < allTours[i].StartTimes.Length; j++)
{
if (allTours[i].StartTimes[j] == request.DepartureDate)
{
allTours[i].PlacesLeft[j] -= request.PersonCount;
}
}
}
}
}
public List <TourRecord> FilterByCriteria(TourSearchRequest request)
{
var allTours = _tourStorage.ReadAll()
.Where(x => x.Country == request.ToCountry &&
x.MaxPersonsAllowed >= request.PersonCount);
List <TourRecord> filteredTourRecords = new List <TourRecord>();
foreach (var item in allTours)
{
foreach (var date in item.StartTimes)
{
for (int i = -request.DepartureDateOffset; i <= request.DepartureDateOffset; i++)
{
if (request.DepartureDate.AddDays(i) == date)
{
filteredTourRecords.Add(item);
}
}
}
}
return(filteredTourRecords);
}
public async Task <IActionResult> SearchAsync([FromBody] TourSearchRequest tourSearchRequest)
{
var tourSearchResponse = await _searchService.SearchAsync(tourSearchRequest);
return(Ok(tourSearchResponse));
}
