public List <RouteDTO> GetAll()
{
var routes = _routeRepository.GetAll();
var routesDTO = routes.Select(RouteDTO.Convert).ToList();
return(routesDTO);
}
/// <summary>
/// Get the shortest possible distance between any two train platforms
/// </summary>
/// <param name="start">Starting Point</param>
/// <param name="end">Ending Point</param>
/// <param name="maxDistance">Depth parameter for graph algorithm</param>
/// <exception cref="RouteNotFoundException"
/// <returns>distance in integrer form or a RouteNotFoundException exception</returns>
public int GetShortestDistance(char start, char end, int maxDistance)
{
var routes = _routeRepository.GetAll();
var routeDomainItems = GetRouteDomainItemsForData(routes);
RouteScenarioContainer container = new RouteScenarioContainer(start, maxDistance);
TraverseRouteScenarios(routeDomainItems, ref container, true);
int distance = 0;
if (container.Passengers.Any())
{
distance = container.Passengers
.Where(m => m.RouteMap.First().CompareTo(start) == 0 && m.RouteMap.Last().CompareTo(end) == 0)
.Select(m => m.DistanceTraveled)
.OrderBy(m => m)
.FirstOrDefault();
}
if (distance == 0)
{
throw new RouteNotFoundException();
}
return(distance);
}
public void WhenExistsFromAndToDestinyThenFindByDijkstraImplementation()
{
var listRouteValue = new List <RouteValue>();
routeRepository.GetAll().Returns(listRouteValue);
var listNode = new List <Node>();
var nodeFrom = new Node(FROM);
var nodeTo = new Node(TO);
listNode.Add(nodeFrom);
listNode.Add(nodeTo);
graphCreator.CreateNodes(listRouteValue).Returns(listNode);
var bestRoute = new BestRoute();
dijkstraImplementation.FindBestRoute(nodeFrom, nodeTo).Returns(bestRoute);
var route = new Route(FROM, TO);
var result = dijkstraLowestPriceFinder.Find(route);
Assert.AreEqual(bestRoute, result);
routeRepository.Received().GetAll();
graphCreator.Received().CreateNodes(listRouteValue);
dijkstraImplementation.Received().FindBestRoute(nodeFrom, nodeTo);
}
public RedirectToActionResult AddToCart(int routeId, string returnUrl)
{
Route route = repository.GetAll().FirstOrDefault(repository => repository.Id == routeId);
if (route != null)
{
cart.AddItem(route, 1);
}
return(RedirectToAction("Index", new { returnUrl }));
}
public string AddToCart(int routeId, int userId)
{
RouteType route = _routeRepository.GetAll().FirstOrDefault(repository => repository.Id == routeId);
if (route != null)
{
carts[userId].AddItem(route, 1);
}
return("OK");
}
public void Init()
{
_routeRepository = Substitute.For <IRouteRepository>();
_routeRepository.GetAll().Returns(RoutePlaceMockHelper.CreateMockRoutes());
_routeRepository.GetById(Arg.Any <string>())
.Returns(new Route()
{
Id = "MockId",
DestinationId = "abc",
Destination = new Place
{
Id = "abc",
Name = "Traralgon"
},
OriginId = "efg",
Origin = new Place
{
Id = "efg",
Name = "Southern Cross"
},
DepartUtc = new DateTime(2018, 12, 1, 14, 15, 00).ToUniversalTime()
});
_queryHandler = new RouteQueryHandler(_routeRepository);
}
public async Task CleanUp()
{
var token = new System.Threading.CancellationToken();
var routes = await repository.GetAll(token);
foreach (var item in routes)
{
await repository.Delete(item.Id, token);
}
var points = await repositoryPoint.GetAll(token);
foreach (var item in points)
{
await repositoryPoint.Delete(item.Id, token);
}
}
public async Task <IEnumerable <RouteDTO> > GetAll()
{
var result = await _routeRepository.GetAll();
return(result
.Select(x => AutoMapper.Mapper.Map <Route, RouteDTO>(x))
.ToList());
}
public async Task GetAll_AllRoutes()
{
// Act
var routes = await _routeRepository.GetAll();
//Assert
Assert.AreEqual(routes.Count, 2);
}
// get all routes
public async Task <IEnumerable <DictionaryDTO> > GetRouteList()
{
var routeList = await _repository.GetAll().ConfigureAwait(false);
var routeDTOList = _mapper.Map <IEnumerable <Route>, List <DictionaryDTO> >(routeList);
return(routeDTOList);
}
private void AddConnections(Graph graph)
{
var routes = _routeRepository.GetAll();
foreach (var item in routes)
{
graph.AddConnection(item.SourceAirport, item.DestinationAirport, item.Price);
}
}
public IEnumerable <Router> GetAll(string keyword)
{
if (!string.IsNullOrEmpty(keyword))
{
return(_routeRepository.GetMulti(x => x.StartPoint.Contains(keyword) || x.EndPoint.Contains(keyword)));
}
else
{
return(_routeRepository.GetAll());
}
}
public async Task CleanUp()
{
var token = new System.Threading.CancellationToken();
IRouteRepository repository = Provider.GetService <IRouteRepository>();
var routes = await repository.GetAll(token);
foreach (var item in routes)
{
await repository.Delete(item.Id, token);
}
}
public async Task GetRoutesTest()
{
var token = new System.Threading.CancellationToken();
IRouteRepository repository = Provider.GetService <IRouteRepository>();
await repository.Add(
new Infrastructure.Persistence.DTO.Route()
{
OriginalPoint = new Infrastructure.Persistence.DTO.Point {
Name = "A"
},
DestinationPoint = new Infrastructure.Persistence.DTO.Point {
Name = "C"
},
Cost = 10, Time = 1
},
token);
await repository.Add(
new Infrastructure.Persistence.DTO.Route()
{
OriginalPoint = new Infrastructure.Persistence.DTO.Point {
Name = "A"
},
DestinationPoint = new Infrastructure.Persistence.DTO.Point {
Name = "B"
},
Cost = 10,
Time = 1
},
token);
await repository.Add(
new Infrastructure.Persistence.DTO.Route()
{
OriginalPoint = new Infrastructure.Persistence.DTO.Point {
Name = "A"
},
DestinationPoint = new Infrastructure.Persistence.DTO.Point {
Name = "D"
},
Cost = 10,
Time = 1
},
token);
var routes = await repository.GetAll(token);
Assert.AreEqual(3, routes.Count());
}
private List <Route> BuildRutes()
{
List <Route> routes = _routeRepository?.GetAll().ToList();
routes?.ForEach(route =>
{
Path path = _pathRepository.GetById(route.PathId);
path.Origin = _pointRepository.GetById(path.OriginId);
path.Destiny = _pointRepository.GetById(path.DestinyId);
route.Path = path;
});
return(routes);
}
public bool Remove(string id)
{
var orderToRemove = GetById(id);
var routes = routeRepository.GetAll();
foreach (var route in routes)
{
foreach (var entry in route.RouteEntries)
{
if (entry.Order.Id == orderToRemove.Id)
{
routeRepository.Remove(entry, route.Id);
break;
}
}
}
return(OrderRepository.RemoveOrder(orderToRemove.Id));
}
private async Task GetFutureRoutes_Works()
{
// Arrange
var route = DummyData.RouteFaker.Generate();
var pastRoute = DummyData.PastRouteFaker.Generate();
var routes = new List <Route>();
routes.Add(route);
routes.Add(pastRoute);
_routeRepository.GetAll().Returns(routes);
// Act
var result = _routeController.GetAll();
// Assert
routes.Remove(pastRoute);
result.Should().BeOfType <OkObjectResult>();
((OkObjectResult)result).Value.Should().BeSameAs(routes);
}
public BestRoute Find(Route route)
{
var routes = routeRepository.GetAll();
List <Node> nodes = graphCreator.CreateNodes(routes);
var nodeFrom = nodes.FirstOrDefault(node => node.Label == route.From);
var nodeTo = nodes.FirstOrDefault(node => node.Label == route.To);
if (nodeFrom == null)
{
throw new DestinyException(route.From);
}
if (nodeTo == null)
{
throw new DestinyException(route.To);
}
return(dijkstraImplementation.FindBestRoute(nodeFrom, nodeTo));
}
public ScheduleRepository(IRouteRepository routeRepository, IBusStopRepository busStopRepository)
{
_routeRepository = routeRepository;
_busStopRepository = busStopRepository;
//mocking bus stop list
_allScheduleItems = new List <ScheduleItem>();
var busStopList = _busStopRepository.GetAll();
var routeList = _routeRepository.GetAll();
foreach (var route in routeList.Result)
{
foreach (var busStop in busStopList.Result)
{
_allScheduleItems.Add(new ScheduleItem()
{
Route = route,
BusStop = busStop,
Departures = GetDepartureTimes(route, busStop)
});
}
}
}
public ViewResult List()
{
return(View(routesRepository.GetAll()));
}
public IEnumerable <Route> GetAllRoute(string lang)
{
return(databasePlaceholder.GetAll(lang));
}
public ViewResult List()
{
return(View(repo.GetAll()));
}
public IActionResult GetFutureRoutes()
{
//maybe refactor into repomethod
return(Ok(_routeRepository.GetAll().Where(r => r.Date > DateTime.Now)));
}
public ActionResult MainMenu()
{
var routen = _RouteRepository.GetAll().ToArray();
return(View(routen));
}
public IEnumerable <DriverInfo> GetAllDrivers()
{
return(repo.GetAll());
}
public async Task <IEnumerable <Route> > GetRoutes()
{
var routes = await _repository.GetAll();
return(routes.Select(c => (Route)c).ToList());
}
public IEnumerable <Route> GetAllRoutes()
{
return(routeRepository.GetAll());
}
public List <DriverInfo> GetAllDriverInfo()
{
return(repository.GetAll());
}
public IEnumerable <Route> GetAllRoute(string lang = "", string active = "")
{
return(databasePlaceholder.GetAll(lang, active));
}
public async Task <IList <Route> > Handle(RoutesQuery query, CancellationToken cancellationToken)
{
return(MapRoutesToViewModel(await _routeRepository.GetAll()));
}
