private static List<RouteAssetsModel> LoadRouteAssetsFromBinFile(RouteModel route,
FileInfo fileInfo)
{
var doc = BinHandler.SerzToDoc(fileInfo.FullName);
List<RouteAssetsModel> output = GetBluePrintsFromXML(route, doc);
return output;
}
public void AddRoute(RouteModel route)
{
var entity = _routeMapper.MapToEntity(route);
_uof.Routes.Add(entity);
_uof.Complete();
}
public static List<FileInfo> LoadUnpackedRouteBinFilesToList(string routesBasePath,
RouteModel route)
{
if (route == null || string.IsNullOrEmpty(route.RouteGuid))
{
Log.Trace("Route object is not valid", null, LogEventType.Error);
return null;
}
if (string.IsNullOrEmpty(route.Pack) == false)
{
Log.Trace("Route object points to packed route. Please report this error.", null,
LogEventType.Error);
return null;
}
string path = @$"{routesBasePath}{route.RouteGuid}\";
try
{
DirectoryInfo dir = new DirectoryInfo(@$"{path}Scenery\");
var output = dir.GetFiles("*.bin", SearchOption.AllDirectories).ToList();
dir = new DirectoryInfo(@$"{path}Networks\Loft Tiles\");
output.AddRange(dir.GetFiles("*.bin", SearchOption.AllDirectories));
dir = new DirectoryInfo(@$"{path}Networks\Road Tiles\");
output.AddRange(dir.GetFiles("*.bin", SearchOption.AllDirectories));
dir = new DirectoryInfo(@$"{path}Networks\Track Tiles\");
output.AddRange(dir.GetFiles("*.bin", SearchOption.AllDirectories));
return output;
}
catch (Exception e)
{
Log.Trace($"Failed to route bin files from path {path} to list", e, LogEventType.Error);
throw;
}
}
private void btnDodajStanicu_Click(object sender, EventArgs e)
{
int poz;
if (int.TryParse(txtDodajStanicu.Text, out poz))
{
if (poz < 0 || poz > route.Stations.Count)
{
return;
}
}
else
{
return;
}
ChoseStation ss = new ChoseStation(route);
ss.ShowDialog();
if (ss.station != null)
{
route = RouteModel.Rout(route.Id, ss.station.Id, poz);
listBox1.Items.Clear();
listBox1.Items.AddRange(route.Stations.ToArray());
}
}
private string GetModuleClassName(RouteModel route)
{
return(GetTypeName(AngularModuleTemplate.AngularModuleTemplate.TemplateId, route.TypeReference.Element, new TemplateDiscoveryOptions()
{
TrackDependency = false
}));
}
public void EditRoute(RouteModel route)
{
var entity = _routeMapper.MapToEntity(route);
_uof.Routes.Update(entity);
_uof.Complete();
}
public RouteModel Create(Route route)
{
if (route == null)
{
return null;
}
var result = new RouteModel
{
Id = route.Id,
Name = route.Name,
Category = route.Category,
Gift = Create(route.Gift),
PlaceIcon = route.PlaceIcon,
Question = Create(route.OpenEndedQuestion),
Merchant = Create(route.Merchant)
};
var places = route.RoutePlaces.Select(x => x.Place).ToList();
var placeModels = new List<PlaceModel>();
foreach (var place in places)
{
placeModels.Add(Create(place));
}
result.Places = placeModels;
return result;
}
private void ContentListView_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (ContentListView.SelectedItem != null && ContentListView.SelectedItem is RouteModel)
{
RouteModel route = ContentListView.SelectedItem as RouteModel;
StopGroup stop = route.Stop.Group;
if (route.NextTripTime != null)
{
Frame.Navigate(typeof(TripPage), new TripParameter
{
Trip = route.NextTrip,
Stop = stop,
NextTrips = true,
DateTime = OriginalParameter.DateTime,
Location = OriginalParameter.Location
});
}
else
{
Frame.Navigate(typeof(TimetablePage), new TimetableParameter
{
Route = route.Route,
Stop = stop,
SelectedTime = OriginalParameter.DateTime
});
}
ContentListView.SelectedItem = null;
}
}
public string ExportRouteTable()
{
RouteModel route = RouteDataAccess.GetRouteById(RouteId);
var output = WriteRouteHeader() + WriteRouteData(route);
return(output);
}
RouteModel CreateRouteModelData(String name, RouteBase rr, int index)
{
RouteModel rm = CreateModel(rr, index);
rm.Name = name;
return(rm);
}
public void MakeEmptyMap(MapModel mapData, RouteModel route)
{
Clear();
Vector2Int mapSize = mapData.MapSize;
float nodeSize = mapData.NodeSize;
float offsetX = (nodeSize * 0.5f) * (mapData.MapSize.x - 1);
float offsetY = (nodeSize * 0.5f) * (mapData.MapSize.y - 1);
int nodeId = NumTable.TileIdOffset;
for (int y = 0; y < mapSize.y; y++)
{
for (int x = 0; x < mapSize.x; x++)
{
var newNode = Instantiate(nodePrefab, transform);
newNode.SetupNode(route, null);
newNode.transform.localPosition = new Vector3(x * nodeSize - offsetX, y * nodeSize - offsetY, 0);
newNode.transform.localScale = Vector3.one * nodeSize;
newNode.Position = new Vector2Int(x, y);
newNode.Id = nodeId++;
}
}
SetCamera(mapSize, nodeSize);
}
public IEnumerable <RouteModel> DropSelectedRoute([FromBody] RouteModel routeData)
{
client = new FireSharp.FirebaseClient(config);
FirebaseResponse setResponse = client.Update("Routes/" + routeData.Id.ToString(), routeData);
return(null);
}
public async Task PostRoutesToFirestore([FromBody] RouteViewModel routeData)
{
if (routeData != null)
{
CollectionReference collectionReference = db.Collection("RouteList");
string routeDataFromFrontEnd = routeData.RouteDescription;
string zone = "N/A";
client = new FireSharp.FirebaseClient(config);
StringReader reader = new StringReader(routeDataFromFrontEnd);
while ((routeDataFromFrontEnd = reader.ReadLine()) != null)
{
string[] cxLine = routeDataFromFrontEnd.Split("\t");
zone = cxLine[2] == null || cxLine[2] == "" ? zone : cxLine[2].ToString();
RouteModel routeModel = new RouteModel();
routeModel.Dsp = cxLine[0];
routeModel.Zone = zone;
routeModel.Status = "waiting".ToUpper();
routeModel.Cx = cxLine[3];
routeModel.Name = NameParser(cxLine[4]);
routeModel.Wave = Int32.Parse(routeData.Wave);
try
{
await collectionReference.AddAsync(routeModel);
}
catch (Exception e)
{
string s = e.ToString();
}
}
;
}
}
private void btnAdd_Click(object sender, EventArgs e)
{
newRout = new RoutView();
int br;
if (!int.TryParse(txtBroj.Text, out br))
{
return;
}
newRout.Line = br;
TransportView test = comboBox1.SelectedItem as TransportView;
if (test == null)
{
return;
}
newRout.Transport = new Transport {
Id = test.Id
};
newRout.Stations = listBox1.Items.Cast <Station>().ToList();
RouteModel.AddRoute(newRout);
this.Close();
}
/// <summary>
/// UpdateAsync unit to database
/// </summary>
/// <param name="id">The id of unit</param>
/// <param name="unit">The object of unit</param>
/// <returns>null</returns>
public async Task <RouteModel> UpdateAsync(RouteModel objData)
{
UnitOfWork.Context.Update(objData);
await SaveAsync();
return(objData);
}
public void SetProperties()
{
var defaults = new[] { new RouteDataItemModel {
PlaceHolder = "controller", DefaultValue = "Home"
} };
var constraints = new[] { new RouteConstraintModel {
IsMatch = true, ParameterName = "action", Constraint = ".+"
} };
var dataTokens = new RouteValueDictionary(new { area = "Test", name = "Hi" });
var url = "{controller}/{action}/{id}";
var test = new RouteModel();
test.Area = "Test";
test.Url = url;
test.RouteData = defaults;
test.Constraints = constraints;
test.DataTokens = dataTokens;
Assert.False(test.IsMatch);
Assert.Equal("Test", test.Area);
Assert.Equal(url, test.Url);
Assert.Same(defaults, test.RouteData);
Assert.Same(constraints, test.Constraints);
Assert.Same(dataTokens, test.DataTokens);
test.IsMatch = true;
Assert.True(test.IsMatch);
}
RouteModel CreateRouteModelData(String name, RestRoute rr, int index)
{
RouteModel rm = CreateRouteModelData(name, rr as RouteBase, index);
rm.Url = rr.Url;
return(rm);
}
public ActionResult EditRoute(RouteModel model)
{
if (!SessionManager.checkCurrentUserType(UserType.MAINTENANCE_PERSON))
{
return(new HttpStatusCodeResult(403));
}
if (ModelState.IsValid)
{
BL.Route r = MainClass.Instance.getRoutes().Find(v => v.id == model.id);
if (r != null)
{
r.driveTimeMinutes = model.driveTimeMinutes;
r.startPoint.name = model.startPointName;
r.startPoint.latitude = (decimal)System.Web.HttpContext.Current.Session["startPointLatitude"];
r.startPoint.longitude = (decimal)System.Web.HttpContext.Current.Session["startPointLongitude"];
r.startPoint.saveInDB();
r.endPoint.name = model.endPointName;
r.endPoint.latitude = (decimal)System.Web.HttpContext.Current.Session["endPointLatitude"];
r.endPoint.longitude = (decimal)System.Web.HttpContext.Current.Session["endPointLongitude"];
r.endPoint.saveInDB();
if (r.saveInDB() != null)
{
return(RedirectToAction("ViewRoute", "Trip"));
}
}
}
ViewBag.Status = false;
ViewBag.Message = "Could not edit route";
return(View());
}
public async Task <IActionResult> Edit(int id, [Bind("RouteID,LineID,BuggyID")] RouteModel routeModel)
{
if (id != routeModel.RouteID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(routeModel);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RouteModelExists(routeModel.RouteID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["BuggyID"] = new SelectList(_context.Buggies, "BuggyID", "BuggyID", routeModel.BuggyID);
ViewData["LineID"] = new SelectList(_context.Lines, "ID", "ID", routeModel.LineID);
return(View(routeModel));
}
public List <ComplexRouteModel> getRoutes(string fromAirport, string toAirport, int stops)
{
var firstPartRoutes = _db.Routes.Where(r => r.AirportFrom == fromAirport).ToList();
RouteModel secondPartRoute = null;
var oneStopRoutes = new List <ComplexRouteModel>();
foreach (var route in firstPartRoutes)
{
var directRoutes = new List <DirectRouteModel>();
secondPartRoute = _db.Routes.Where(r => r.AirportFrom == route.AirportTo && r.AirportTo == toAirport).FirstOrDefault();
if (secondPartRoute != null)
{
directRoutes.Add(ConvertToDirectRoute(route));
directRoutes.Add(ConvertToDirectRoute(secondPartRoute));
oneStopRoutes.Add(new ComplexRouteModel
{
AirportFrom = route.AirportFrom,
AirportTo = secondPartRoute.AirportTo,
AirportFromName = _db.Airports.Where(a => a.IataCode == route.AirportFrom).FirstOrDefault().Name,
AirportToName = _db.Airports.Where(a => a.IataCode == secondPartRoute.AirportTo).FirstOrDefault().Name,
RoutePart = directRoutes
});
}
}
return(oneStopRoutes);
}
public ActionResult AddRoute(RouteModel routeModel)
{
if (!SessionManager.checkCurrentUserType(UserType.MAINTENANCE_PERSON))
{
return(new HttpStatusCodeResult(403));
}
if (ModelState.IsValid)
{
decimal longitude = (decimal)System.Web.HttpContext.Current.Session["startPointLongitude"];
decimal latitude = (decimal)System.Web.HttpContext.Current.Session["startPointLongitude"];
BL.LatLongCoordinate startPoint = new BL.LatLongCoordinate(
(decimal)System.Web.HttpContext.Current.Session["startPointLatitude"],
(decimal)System.Web.HttpContext.Current.Session["startPointLongitude"],
routeModel.startPointName);
startPoint.saveInDB();
BL.LatLongCoordinate endPoint = new BL.LatLongCoordinate(
(decimal)System.Web.HttpContext.Current.Session["endPointLatitude"],
(decimal)System.Web.HttpContext.Current.Session["endPointLongitude"],
routeModel.endPointName);
endPoint.saveInDB();
if (MainClass.Instance.addRoute(new BL.Route(startPoint, endPoint, routeModel.driveTimeMinutes)))
{
ViewBag.Message = "Successfully added route";
ViewBag.Status = true;
return(initialRouteView());
}
}
ViewBag.Message = "Route could not be added";
ViewBag.Status = false;
return(initialRouteView());
}
private void setRouts()
{
List <RoutView> routs;
routs = RouteModel.GetAllRoutes();
dataGridView1.DataSource = routs;
}
private void updateMap()
{
TransportView test = Transports.SelectedItem as TransportView;
if (test != null)
{
routs = RouteModel.GetAllRoutes(test.Id.ToString());
}
else
{
routs = RouteModel.GetAllRoutes();
}
Random rand = new Random(Environment.TickCount);
// mapa.clearMap();
for (int i = 0; i < routs.Count; i++)
{
Color b;
byte[] color = new byte[3];
rand.NextBytes(color);
b = Color.FromArgb(150, color[0], color[1], color[2]);
mapa.drawLines(routs[i], b);
}
}
public void PickDestination_RoundRobin_Works()
{
var destinations = new[]
{
new DestinationState("d1"),
new DestinationState("d2"),
new DestinationState("d3")
};
destinations[0].ConcurrentRequestCount++;
var context = new DefaultHttpContext();
var cluster = new ClusterState("cluster1");
var routeConfig = new RouteModel(new RouteConfig(), cluster, HttpTransformer.Default);
var feature = new ReverseProxyFeature()
{
Route = routeConfig,
};
context.Features.Set <IReverseProxyFeature>(feature);
var loadBalancer = Create <RoundRobinLoadBalancingPolicy>();
for (var i = 0; i < 10; i++)
{
var result = loadBalancer.PickDestination(context, cluster, availableDestinations: destinations);
Assert.Same(destinations[i % destinations.Length], result);
result.ConcurrentRequestCount++;
}
}
public async Task <IEnumerable <RouteModel> > GetRoutesFromDb()
{
List <RouteModel> routeList = new List <RouteModel>();
try
{
Query routeQuery = db.Collection("RouteList");
QuerySnapshot routeQuerySnapshot = await routeQuery.GetSnapshotAsync();
foreach (DocumentSnapshot documentSnapshot in routeQuerySnapshot.Documents)
{
if (documentSnapshot.Exists)
{
Dictionary <string, object> dataObject = documentSnapshot.ToDictionary();
string json = JsonConvert.SerializeObject(dataObject);
RouteModel routeModel = JsonConvert.DeserializeObject <RouteModel>(json);
routeModel.Id = documentSnapshot.Id;
routeList.Add(routeModel);
}
}
}
catch (Exception e)
{
throw;
}
return(routeList);
}
public async Task GetRouteAssets(RouteModel route)
{
var routeAssetsVM = IoC.Get <RouteAssetsView>();
routeAssetsVM.Route = route;
await _windowManager.ShowWindowAsync(routeAssetsVM);
}
private bool EditRoute(RouteModel route)
{
var editWindow = new EditRouteWindow();
var ctx = (EditRouteViewModel)editWindow.DataContext;
var routeCopy = new RouteModel();
CopyFields(route, routeCopy);
ctx.Route = routeCopy;
ctx.Airports = _airportService.GetAllAirports();
ctx.Carriers = _carrierService.GetAllCarriers();
routeCopy.AirportDepart = ctx.Airports.Single(a => a.Id == routeCopy.AirportDepart.Id);
routeCopy.AirportArrive = ctx.Airports.Single(a => a.Id == routeCopy.AirportArrive.Id);
if (editWindow.ShowDialog() != true)
{
return(false);
}
var errs = GetModelErrors(routeCopy);
if (errs != string.Empty)
{
ShowError(errs, "Error! Saving cancelled. ");
return(false);
}
CopyFields(routeCopy, route);
_routeService.EditRoute(route);
return(true);
}
private async void AssignRouteToResponder(ResponderModel responder, RouteModel defaultRoute)
{
if (defaultRoute.RoutePoints.Any())
{
var routeInstance = new Route <ResponderModel>(defaultRoute.RoutePoints.ToArray());
routeInstance.Element = responder;
// calculate route from the actual point to the route start point
Geoposition responderPosition = PushpinManager.GetResponderPosition(responder);
IEnumerable <Geoposition> routeToStartPosition = await RouteManager.CalculateRoute(responderPosition, routeInstance.RoutePositions.First());
if (!routeToStartPosition.Any())
{
// if routes api dont return any points, route directly to the position.
routeToStartPosition = new [] { responderPosition, routeInstance.RoutePositions.First() };
}
routeInstance.AddRouteToStartPoint(routeToStartPosition);
_routeUpdater.AddRoute(routeInstance);
var routeIndex = _predefinedRoutes.IndexOf(defaultRoute);
_responderRoutes[responder.Id] = routeIndex;
}
else
{
System.Diagnostics.Debug.WriteLine("FullRoute has zero elements, route could not be started");
}
}
private void CalculateRoute()
{
try
{
var routeCalculator = new RouteCalculator(
CredentialsProvider,
To,
From,
Dispatcher,
result =>
{
// Clear the route collection to have only one route at a time.
Routes.Clear();
// Create a new route based on route calculator result,
// and add the new route to the route collection.
var routeModel = new RouteModel(result.Result.RoutePath.Points);
Routes.Add(routeModel);
// Set the map to center on the new route.
var viewRect = LocationRect.CreateLocationRect(routeModel.Locations);
Map.SetView(viewRect);
});
// Display an error message in case of fault.
routeCalculator.Error += r => MessageBox.Show(r.Reason);
// Start the route calculation asynchronously.
routeCalculator.CalculateAsync();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public IHttpActionResult CheckRoutes(ValidationModel model)
{
List <RouteModel> routeModel = new List <RouteModel>();
var response = Utility.FilteredRoutes(Utility.isRouteSimilar(model), model.Distance);
foreach (var item in response.Body)
{
RouteModel r = new RouteModel();
r.RouteID = item.ID_Route;
r.RouteName = item.RouteName;
foreach (var item2 in item.LocationList)
{
LocationModel loc = new LocationModel();
loc.lat = item2.Latitude;
loc.lng = item2.Longitude;
loc.isMilestone = item2.isMilestone;
r.Coordinates.Add(loc);
}
}
if (response.IsComplete())
{
return(Ok(routeModel));
}
else
{
return(BadRequest(response.Message));
}
}
public static RouteModel AsRouteModel(this Route route)
{
RouteModel routeModel = new RouteModel
{
Distance = route.Distance,
LastTimeRidden = route.LastTimeRidden,
Id = route.Id,
Location = route.Location,
Name = route.Name,
RouteCoordinates = route.RouteCoordinates
};
return routeModel;
}
public List<KJ128NModel.RouteModel> GetAllRoute()
{
try
{
List<KJ128NModel.RouteModel> list = new List<RouteModel>();
string selectstr = "select * from route";
DataTable dt = dba.GetDataSet(selectstr).Tables[0];
for (int i = 0; i < dt.Rows.Count; i++)
{
RouteModel r = new RouteModel();
r.From = dt.Rows[i][1].ToString();
r.To = dt.Rows[i][2].ToString();
r.RouteLength = Convert.ToInt32(dt.Rows[i][3]);
list.Add(r);
}
return list;
}
catch (Exception ex)
{
throw ex;
}
}
private bool FindConvert(RouteModel rm)
{
if (rm.From.Equals(fromTemp))
{
return true;
}
return false;
}
