private void RoutePoints_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (DataContext is IRouteEditorViewModel vm && vm.SelectedRoutePoint != null)
{
RoutePoints.ScrollIntoView(vm.SelectedRoutePoint);
}
}
public async Task <IActionResult> Edit(int id, [Bind("RouteId,Longitude,Lattitude")] RoutePoints routePoints)
{
if (id != routePoints.RouteId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(routePoints);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RoutePointsExists(routePoints.RouteId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(routePoints));
}
private void OnRoutePointRemoved(RoutePointRemovedEvent obj)
{
RoutePoint routePoint = RoutePoints.FirstOrDefault(x => x.Id == obj.RoutePointId);
if (routePoint != null)
{
RoutePoints.Remove(routePoint);
}
AircraftRouteViewModel routeViewModel = Routes.FirstOrDefault(x => x.AircraftId == obj.AircraftId);
if (routeViewModel != null)
{
Routes.Remove(routeViewModel);
}
Aircraft aircraft = Aircrafts.FirstOrDefault(x => x.Id == obj.AircraftId);
if (aircraft != null)
{
AircraftRouteViewModel route = _routeService.GetRouteLine(aircraft);
route.IsSelected = true;
Routes.Add(route);
}
}
public IActionResult SaveRide([FromBody] SaveRideViewModel vm)
{
var user = GetUser();
if (user == null)
{
return new UnauthorizedResult();
}
var route = new Routes();
route.DriverId = user.UserId;
route.DateOfRoute = vm.date;
route.TimeOfRoute = new TimeSpan(vm.time.Value.Hour, vm.time.Value.Minute, vm.time.Value.Second);
route.NumberOfSeats = vm.seats;
db.Routes.Add(route);
db.Entry(route).State = EntityState.Added;
db.SaveChanges();
var routePoints = new List<RoutePoints>();
var order = 0;
foreach(var routePoint in vm.points)
{
var newPoint = new RoutePoints();
newPoint.PointId = routePoint.point.pointId;
newPoint.RouteId = db.Entry(route).Entity.RouteId;
newPoint.Price = routePoint.price;
newPoint.PointOrder = order;
order++;
db.RoutePoints.Add(newPoint);
db.Entry(newPoint).State = EntityState.Added;
db.SaveChanges();
}
return Json(new { message = "Success" });
}
private bool RecordPoint()
{
if (paused || routePoint >= secretRoute.Count)
{
return(false);
}
Position curPos = secretRoute[routePoint]; routePoint++;
if (RoutePoints.Count > 0)
{
jDistance += PositionUtils.DistanceBetween(RoutePoints.Last(), curPos, Settings.UseMetric);
TimeSpan ts = DateTime.Now - lastStart;
jTime += ts.TotalSeconds;
lastStart = DateTime.Now;
}
RoutePoints.Add(curPos);
JourneyDistance = string.Format("{0:0.00} ", jDistance) + (Settings.UseMetric ? "km" : "mi");
JourneyTime = TimeUtils.FormatSecMultiple(jTime);
IsRecording = routePoint < secretRoute.Count;
return(IsRecording);
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
RoutePoints routePoints = await db.RoutePoints.FindAsync(id);
db.RoutePoints.Remove(routePoints);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public RouteDto GetRoute()
{
return(new RouteDto()
{
Points = RoutePoints.ToList(),
Distance = Distance,
Created = DateTime.Now
});
}
private void RefreshRoutePointsAndRoutes()
{
RoutePoints.Clear();
Routes.Clear();
foreach (Aircraft aircraft in Aircrafts)
{
RoutePoints.AddRange(aircraft.Route);
Routes.Add(_routeService.GetRouteLine(aircraft));
}
}
public async Task <IActionResult> Create([Bind("RouteId,Longitude,Lattitude")] RoutePoints routePoints)
{
if (ModelState.IsValid)
{
_context.Add(routePoints);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(routePoints));
}
public async Task <ActionResult> Edit([Bind(Include = "Id,RoutesId,PointsId,RLength,RTime,IsBack")] RoutePoints routePoints)
{
if (ModelState.IsValid)
{
db.Entry(routePoints).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewBag.PointsId = new SelectList(db.Points, "Id", "Name", routePoints.PointsId);
ViewBag.RoutesId = new SelectList(db.Routes, "Id", "Name", routePoints.RoutesId);
return(View(routePoints));
}
// GET: Guides/RoutePoints/Details/5
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
RoutePoints routePoints = await db.RoutePoints.FindAsync(id);
if (routePoints == null)
{
return(HttpNotFound());
}
return(View(routePoints));
}
public void SetRouteInfo(decimal longitude, decimal lattitude, int routeId)
{
using (var context = _context)
{
RoutePoints newPoint = new RoutePoints();
newPoint.RouteId = routeId;
newPoint.Longitude = longitude;
newPoint.Lattitude = lattitude;
context.Add(newPoint);
context.SaveChanges();
return;
}
}
// GET: Guides/RoutePoints/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
RoutePoints routePoints = await db.RoutePoints.FindAsync(id);
if (routePoints == null)
{
return(HttpNotFound());
}
ViewBag.PointsId = new SelectList(db.Points, "Id", "Name", routePoints.PointsId);
ViewBag.RoutesId = new SelectList(db.Routes, "Id", "Name", routePoints.RoutesId);
return(View(routePoints));
}
private void OnAircraftRemoved(AircraftRemovedEvent obj)
{
List <RoutePoint> routePointsToRemove = RoutePoints.Where(x => x.AircraftId == obj.AircraftId).ToList();
AircraftRouteViewModel routeToRemove = Routes.FirstOrDefault(x => x.AircraftId == obj.AircraftId);
if (routePointsToRemove.Any())
{
foreach (RoutePoint routePoint in routePointsToRemove)
{
RoutePoints.Remove(routePoint);
}
}
if (routeToRemove != null)
{
Routes.Remove(routeToRemove);
}
}
// Functions
// :IExerciseFactory
public Exercises CreateDBExercise(IExercise exercise)
{
// Setup
Exercises createdExercise = new Exercises();
// Convert
// :Exercise
createdExercise.RoutePoints = new ObservableCollection <RoutePoints>();
createdExercise.ExerciseStart = exercise.ExerciseStart;
createdExercise.ExerciseEnd = exercise.ExerciseEnd;
// :Points
foreach (var point in exercise.Points)
{
var createdPoint = new RoutePoints();
createdPoint.Latitude = point.Latitude;
createdPoint.Longitude = point.Longitude;
createdPoint.Time = point.Time;
createdExercise.RoutePoints.Add(createdPoint);
}
return(createdExercise);
}
// Functions
// :IExerciseFactory
public Exercises CreateDBExercise(IExercise exercise)
{
// Setup
Exercises createdExercise = new Exercises();
// Convert
// :Exercise
createdExercise.RoutePoints = new ObservableCollection<RoutePoints>();
createdExercise.ExerciseStart = exercise.ExerciseStart;
createdExercise.ExerciseEnd = exercise.ExerciseEnd;
// :Points
foreach (var point in exercise.Points)
{
var createdPoint = new RoutePoints();
createdPoint.Latitude = point.Latitude;
createdPoint.Longitude = point.Longitude;
createdPoint.Time = point.Time;
createdExercise.RoutePoints.Add(createdPoint);
}
return (createdExercise);
}
