// Action Name: RouteStopSchedule
// This action takes the routeStopId as the parameter
// Based on the routeStopId, the schedule records are retrieved for the selected route
// Offset minutes are added to the schedule's start times and thus the schedule for each stop is retrieved and displayed in the view
public IActionResult RouteStopSchedule(int routeStopId = 0)
{
if (routeStopId == 0)
{
TempData["message"] = "Please select a stop to see the schedule";
return(RedirectToAction("Index", "BPRouteStop"));
}
//var routeStops = _context.RouteStop.Where(x => x.RouteStopId == routeStopId).Include(x => x.BusRouteCode).Include(x => x.BusStopNumber);
RouteStop routeStop = _context.RouteStop.ToList().Find(x => x.RouteStopId == routeStopId);
if (routeStop == null)
{
TempData["message"] = "Sorry, no Route Stop with that id";
return(RedirectToAction("Index", "BPRouteStop"));
}
Response.Cookies.Append("busStopNumber", routeStop.BusStopNumber.ToString());
Response.Cookies.Append("busRouteCode", routeStop.BusRouteCode);
// Response.Cookies.Append("routeName", routeStop.BusRouteCodeNavigation.RouteName);
var routeSchedules = _context.RouteSchedule.Where(x => x.BusRouteCode == (routeStop.BusRouteCode)).OrderBy(x => x.StartTime).ToList();
if (routeSchedules.Count() == 0)
{
TempData["message"] = "There is no schedule for the selected route.";
return(RedirectToAction("Index", "GRBusStop"));
}
foreach (var item in routeSchedules)
{
item.StartTime += new TimeSpan(0, (int)routeStop.OffsetMinutes, 0);
}
return(View(routeSchedules));
}
private (List <Service> services, List <Stop> stops, List <RouteStop> routeStops) CombineStopsAndServices(List <Service> services, List <Stop> stops)
{
List <RouteStop> routeStops = new List <RouteStop>();
foreach (var service in services)
{
foreach (var route in service.Routes)
{
route.RouteStops = new List <RouteStop>();
foreach (var stop in route.Points)
{
var detailedStop = stops.FirstOrDefault(x => x.StopId == stop.StopId);
if (detailedStop != default(Stop))
{
var routeStop = new RouteStop
{
Order = route.RouteStops.Count(),
Route = route,
Stop = detailedStop,
};
route.RouteStops.Add(routeStop);
}
}
}
}
return(services, stops, routeStops);
}
private RouteStop CreateJobRouteStop(Job job, int sortOrder, int?locationId, int?minutes, int?stopActionId, long windowStart, long windowEnd, bool bSave = false)
{
if (job == null || job.Id == 0)
{
throw new Exception("Job is invalid");
}
var result = new RouteStop()
{
SubscriberId = job.SubscriberId,
JobId = job.Id,
LocationId = locationId,
StopDelay = minutes,
StopActionId = stopActionId,
SortOrder = sortOrder,
WindowStart = windowStart,
WindowEnd = windowEnd,
};
if (bSave)
{
_routeStopService.Insert(result);
job.RouteStops.Add(result);
Update(job);
job = GetByIdWithAll(job.Id);
}
return(result);
}
private static void ExtractTimetableTimes(XmlNodeList mainNodes, List <KeyValuePair <int, int> > timetableLineOrder, List <RouteStop> timetableStops)
{
foreach (XmlElement vehicleTypeNode in mainNodes)
{
int vehicleTypeID = int.Parse(vehicleTypeNode.Attributes["id"].Value);
foreach (XmlElement stopRef in vehicleTypeNode)
{
RouteStop currentRouteStop = new RouteStop();
int currentStopID = int.Parse(stopRef.Attributes["id"].Value);
currentRouteStop.PublicID = currentStopID;
foreach (XmlElement lineRef in stopRef)
{
int lineID = int.Parse(lineRef.Attributes["id"].Value);
string lineSchedule = lineRef.InnerText;
var currentLineSchedule = SplitTimeNode(lineSchedule, lineID);
currentRouteStop.LineToStopSchedule.Add(currentLineSchedule);
var lineIDAndVehicleType = new KeyValuePair <int, int>(lineID, vehicleTypeID);
if (!timetableLineOrder.Contains(lineIDAndVehicleType))
{
timetableLineOrder.Add(lineIDAndVehicleType);
}
}
timetableStops.Add(currentRouteStop);
}
}
}
public StopConnection Create(
RouteStop routeStop,
Departure departure,
StopVertex currentVertex,
RouteStop nextRouteStop,
StopVertex nextVertex,
DateTime connectionStartDay,
bool betweenTwoDays)
{
var endDay = connectionStartDay;
if (betweenTwoDays)
{
endDay = endDay.AddDays(1);
}
return(new StopConnection()
{
Line = routeStop.Line,
StartDateTime = connectionStartDay + departure.DepartureTime,
SourceStop = currentVertex,
EndDateTime = endDay + nextRouteStop
.Departures
.Where(p => p.RunIndex == departure.RunIndex)
.First()
.DepartureTime,
DestinationStop = nextVertex,
});
}
/// <summary>
/// Gets the queue time for the given <see cref="RouteStop"/>
/// </summary>
/// <param name="routeStop"></param>
/// <param name="timeOfDay"></param>
/// <returns></returns>
public TimeSpan GetQueueTime(RouteStop startStop, RouteStop endStop, TimeSpan timeOfDay)
{
if (endStop == null)
{
throw new ArgumentNullException("endStop");
}
if (LocationQueueDelays != null)
{
bool shouldGetQueueTime = !(startStop != null && startStop.Location.Id == endStop.Location.Id);
if (shouldGetQueueTime)
{
var queueDelays = LocationQueueDelays.Where(p => p.LocationId == endStop.Location.Id);
var match = queueDelays.FirstOrDefault(
p => p.DelayStartTime <= timeOfDay.Ticks && p.DelayEndTime >= timeOfDay.Ticks);
if (match != null)
{
endStop.QueueTime = new TimeSpan(0, match.QueueDelay, 0);
return(endStop.QueueTime.Value);
}
}
}
return(TimeSpan.Zero);
}
public async Task <IActionResult> Edit(int id, [Bind("RouteStopId,BusRouteCode,BusStopNumber,OffsetMinutes")] RouteStop routeStop)
{
if (id != routeStop.RouteStopId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(routeStop);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RouteStopExists(routeStop.RouteStopId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index"));
}
ViewData["BusRouteCode"] = new SelectList(_context.BusRoute, "BusRouteCode", "BusRouteCode", routeStop.BusRouteCode);
ViewData["BusStopNumber"] = new SelectList(_context.BusStop, "BusStopNumber", "BusStopNumber", routeStop.BusStopNumber);
return(View(routeStop));
}
public async Task <IActionResult> Edit(int id, [Bind("RouteStopID")] RouteStop routeStop, string RouteID, string StopID)
{
if (id != routeStop.RouteStopID)
{
return(NotFound());
}
routeStop.RouteID = _context.Routes.Where(n => n.Name == RouteID).SingleOrDefault().RouteID;
routeStop.StopID = _context.Stops.Where(n => n.Name == StopID).SingleOrDefault().StopID;
if (ModelState.IsValid)
{
try
{
_context.Update(routeStop);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RouteStopExists(routeStop.RouteStopID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["RouteID"] = new SelectList(_context.Routes, "Name", "Name", RouteID);
ViewData["StopID"] = new SelectList(_context.Stops, "Name", "Name", StopID);
return(View(routeStop));
}
private RouteStop[] GenerateRouteStop()
{
if (Addresses.Count > 0 || Addresses != null)
{
var routes = new RouteStop[Addresses.Count];
int i = 0;
foreach (var address in Addresses)
{
var RoutePoint = new RouteService.Point
{
x = address.Point.x,
y = address.Point.y
};
routes[i++] = new RouteStop
{
description = address.ToString(),
point = RoutePoint
};
}
return routes;
}
else
throw new ArgumentNullException("Adresses");
}
public async Task <RouteStopForecast> GetRouteStopForecastAsync(RouteStop routeStop)
{
var bus13RouteStop = routeStop.VendorInfo as Bus13RouteStop;
if (bus13RouteStop == null)
{
int id = 0;
int.TryParse(routeStop.Id, out id);
bus13RouteStop = new Bus13RouteStop {
Id = id, Type = "0"
};
}
var request = this.GetRequestBase(RouteStopForecastResource);
request.AddParameter("sid", bus13RouteStop.Id, ParameterType.QueryString);
request.AddParameter("type", bus13RouteStop.Type, ParameterType.QueryString);
request.AddParameter(InfoParam, _infoParamValue, ParameterType.QueryString);
var client = this.GetRestClient();
var forecast = await this.ExecuteAsync <List <Bus13RouteStopForecastItem> >(client, request)
.ConfigureAwait(false);
if (forecast != null && forecast.Any())
{
return(new RouteStopForecast(routeStop.Id, forecast.Select(this.ParseRouteStopForecast).ToList()));
}
return(new RouteStopForecast(routeStop.Id, new List <RouteStopForecastItem>()));
}
private RouteStop[] GenerateRouteStop()
{
if (Addresses.Count > 0 || Addresses != null)
{
var routes = new RouteStop[Addresses.Count];
int i = 0;
foreach (var address in Addresses)
{
var RoutePoint = new RouteService.Point
{
x = address.Point.x,
y = address.Point.y
};
routes[i++] = new RouteStop
{
description = address.ToString(),
point = RoutePoint
};
}
return(routes);
}
else
{
throw new ArgumentNullException("Adresses");
}
}
private void AddButton_Click(object sender, EventArgs e)
{
try
{
RouteStop res;
if (Edit)
{
res = Selected;
}
else
{
res = new RouteStop();
}
Set(res);
if (!Edit)
{
Context.RouteStops.Add(res);
}
Context.SaveChanges();
Close();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
internal bool RepresentsSame(RouteStop routePoint)
{
if (routePoint == null || (double)this.Longitude != (double)routePoint.Longitude || (double)this.Latitude != (double)routePoint.Latitude)
{
return(false);
}
if ((routePoint.Tags != null || routePoint.Tags.Length == 0) && (this.Tags != null || this.Tags.Length == 0))
{
if (this.Tags.Length != routePoint.Tags.Length)
{
return(false);
}
for (int index = 0; index < this.Tags.Length; ++index)
{
if (this.Tags[index].Key != routePoint.Tags[index].Key || this.Tags[index].Value != routePoint.Tags[index].Value)
{
return(false);
}
}
return(true);
}
if (this.Tags == null)
{
return(this.Tags.Length == 0);
}
return(true);
}
public RouteInfo GetRoute(Point origem, Point destino, TipoRota tp)
{
RouteStop[] a = new RouteStop[2] {
new RouteStop {
description = "origem", point = origem
},
new RouteStop {
description = "destino", point = destino
}
};
RouteOptions ro = new RouteOptions();
ro.language = Language;
//TODO: Criar enum com as possíveis opções: http://dev.maplink.com.br/webservices/rotas/#StructureVehicle
ro.vehicle = new Vehicle();
ro.vehicle.tollFeeCat = 2;
ro.vehicle.averageConsumption = 10;
ro.vehicle.averageSpeed = 60;
ro.vehicle.tankCapacity = 50;
ro.vehicle.fuelPrice = 2.60;
//TODO: Criar as opções: http://dev.maplink.com.br/webservices/rotas/#StructureVehicle
ro.routeDetails = new RouteDetails();
ro.routeDetails.routeType = (int)tp;
ro.routeDetails.descriptionType = 0;
return(_route.getRoute(a, ro, _token));
}
private static void EnsureEntityIsRoutable(RouteStop entity)
{
if (!entity.GeoLat.HasValue || !entity.GeoLon.HasValue)
{
throw new RoutingEntityException("Stop missing geocoding coordinates.", entity.ID);
}
}
public async Task <IActionResult> Create([Bind("RouteStopId,BusRouteCode,BusStopNumber,OffsetMinutes")] RouteStop routeStop)
{
RouteStop newroute = routeStop;
//************************************************************IMPORTANT*************************************************************
//************************************************************IMPORTANT*************************************************************
//************************************************************IMPORTANT*************************************************************
//You have to control the route number and and stop number in the database to ensure you select specific one for that typical route
//************************************************************IMPORTANT*************************************************************
//************************************************************IMPORTANT*************************************************************
//************************************************************IMPORTANT*************************************************************
if (_context.RouteStop.Where(r => r.BusRouteCode == newroute.BusRouteCode).Any(r => r.BusStopNumber == newroute.BusStopNumber) || (_context.RouteStop.Where(r => r.BusStopNumber == newroute.BusStopNumber).Any(r => r.OffsetMinutes == newroute.OffsetMinutes)))
{
if (_context.RouteStop.Where(r => r.BusRouteCode == newroute.BusRouteCode).Any(r => r.BusStopNumber == newroute.BusStopNumber))
{
TempData["Routemessage"] = "This route already exists, please select new one ";
}
if (_context.RouteStop.Where(r => r.BusStopNumber == newroute.BusStopNumber && r.BusRouteCode == newroute.BusRouteCode).Any(r => r.OffsetMinutes == newroute.OffsetMinutes))
{
if (newroute.OffsetMinutes == 0)
{
TempData["Stopmessage"] = "there is already a Zero offset";
}
else
{
TempData["Stopmessage"] = "This offset already exists, please select new one";
}
}
return(RedirectToAction("Create", "RouteStop"));
}
//This allows user to specify the offsetminutes for the typical busstopnumber
//if(_context.RouteStop.Where(r=>r.BusStopNumber==newroute.BusStopNumber).Any(r => r.OffsetMinutes==newroute.OffsetMinutes))
//{
// TempData["message"] = "This offset already exists, please select new one";
// return RedirectToAction("Create", "RouteStop");
//}
if (ModelState.IsValid)
{
_context.Add(routeStop);
TempData["message"] = "Stop sucessfully created";
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
//**********************************************Special Atention******************************************************************
//****************if you want the record to be insert into correct bus route, you need to speciify the code you have selected*****
//********************************************************************************************************************************
ViewData["BusRouteCode"] = new SelectList(_context.BusRoute.Where(r => r.BusRouteCode == HttpContext.Session.GetString("busRouteCode")), "BusRouteCode", "BusRouteCode", routeStop.BusRouteCode);
//ViewData["BusStopNumber"] = new SelectList(_context.BusStop, "BusStopNumber", "BusStopNumber", routeStop.BusStopNumber);
ViewData["BusStopNumber"] = new SelectList(_context.BusStop.OrderBy(b => b.Location), "BusStopNumber", "Location", routeStop.BusStopNumber);
ViewData["OffsetMinutes"] = new SelectList(_context.RouteStop, "OffsetMinutes", "OffsetMinutes", routeStop.OffsetMinutes);
return(View(routeStop));
}
public async Task <IActionResult> AddStop(int id)
{
ViewData["City"] = new SelectList(_context.Cities, "CityId", "City1");
var obj = new RouteStop();
obj.RouteId = id;
return(View(obj));
}
public RouteStop GetNextRouteStop(RouteStop routeStop)
{
var lineRouteStops = routeStop.Line.RouteStops;
return(lineRouteStops
.Where(p => p.StopIndex == routeStop.StopIndex + 1)
.FirstOrNull());
}
public ActionResult DeleteConfirmed(int id)
{
RouteStop routeStop = db.RouteStops.Find(id);
db.RouteStops.Remove(routeStop);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// Gets the approximate delay (minutes) for the given <see cref="RouteStop"/>
/// </summary>
/// <param name="routeStop"></param>
/// <param name="timeOfDay"></param>
/// <returns></returns>
public TimeSpan GetExecutionTime(RouteStop routeStop, TimeSpan timeOfDay)
{
if (routeStop.ExecutionTime.HasValue)
{
return(routeStop.ExecutionTime.Value);
}
return(GetExecutionTime(routeStop.StopAction, routeStop.Location, timeOfDay));
}
public async Task ChangeRouteStopOrdinal(RouteStop stop)
{
var rec = new RouteRecord {
Id = stop.RecordId,
Ord = stop.Ordinal
};
await RouteTable.UpdateRecord(rec, RouteRecord.ORD);
}
public async Task <IActionResult> Create([Bind("RouteStopId,BusRouteCode,BusStopNumber,OffsetMinutes")] RouteStop routeStop)
{
if (routeStop.OffsetMinutes < 0)
{
ModelState.AddModelError("", "OffsetMinutes must be 0 or greater than 0");
}
string busRCode = String.Empty;
if (Request.Cookies["BusRouteCode"] != null)
{
busRCode = Request.Cookies["BusRouteCode"];
}
else if (HttpContext.Session.GetString("BusRouteCode") != null)
{
}
var busRoute = _context.BusRoute.Where(a => a.BusRouteCode == busRCode).FirstOrDefault();
ViewData["BusRCode"] = busRoute.BusRouteCode;
ViewData["BusRName"] = busRoute.RouteName;
routeStop.BusRouteCode = busRCode;
//Check for offset 0
if (routeStop.OffsetMinutes == 0)
{
var isZeroExists = _context.RouteStop.Where(a => a.OffsetMinutes == 0 && a.BusRouteCode == routeStop.BusRouteCode);
if (isZeroExists.Any())
{
ModelState.AddModelError("", "There is already record for offset minute 0");
}
}
var isDuplicate = _context.RouteStop.Where(a => a.BusRouteCode == routeStop.BusRouteCode && a.BusStopNumber == routeStop.BusStopNumber);
if (isDuplicate.Any())
{
ModelState.AddModelError("", "Duplicate Record");
}
if (ModelState.IsValid)
{
try
{
_context.Add(routeStop);
await _context.SaveChangesAsync();
TempData["message"] = "New Route Stop Added";
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.GetBaseException().Message);
}
}
ViewData["BusRouteCode"] = new SelectList(_context.BusRoute, "BusRouteCode", "BusRouteCode", routeStop.BusRouteCode);
ViewData["BusStopNumber"] = new SelectList(_context.BusStop.OrderBy(a => a.Location), "BusStopNumber", "Location", routeStop.BusStopNumber);
return(View(routeStop));
}
/// <summary>
/// Gets the approximate delay (minutes) for the given <see cref="RouteStop"/>
/// </summary>
/// <param name="routeStop"></param>
/// <returns></returns>
public TimeSpan GetDelay(RouteStop routeStop)
{
if (routeStop.StopDelay.HasValue)
{
return(routeStop.StopDelay.Value);
}
return(GetDelay(routeStop.StopAction, routeStop.Location));
}
public void PrepareJob(Job job)
{
RouteStop previousStop = null;
foreach (var routeStop in job.RouteStops)
{
PrepareRouteStop(routeStop, previousStop, job.EquipmentConfiguration, job);
previousStop = routeStop;
}
}
public ActionResult DeleteConfirmed(int id)
{
using (var db = new TrolleyTrackerContext())
{
RouteStop routeStop = db.RouteStops.Find(id);
db.RouteStops.Remove(routeStop);
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
public JsonResult GetInfoMapLink(MapLinkConsulta dados)
{
try
{
const string token = "c13iyCvmcC9mzwkLd0LCbmYC5mUF5m2jNGNtNGt6NmK6NJK=";
var originRoute = new RouteStop
{
description = "",
point = new Point { x = Convert.ToDouble(dados.origem.longitude,cult) , y = Convert.ToDouble(dados.origem.latitude, cult) }
};
var destinationRoute = new RouteStop
{
description = "",
point = new Point { x = Convert.ToDouble(dados.destino.longitude,cult), y = Convert.ToDouble(dados.destino.latitude,cult) }
};
var routes = new[] { originRoute, destinationRoute };
var routeOptions = new RouteOptions
{
language = "portugues",
routeDetails = new RouteDetails { descriptionType = 0, routeType = 1, optimizeRoute = true },
vehicle = new Vehicle
{
tankCapacity = 20,
averageConsumption = 9,
fuelPrice = 3,
averageSpeed = 60,
tollFeeCat = 2
}
};
using (var routeSoapClient = new RouteSoapClient())
{
var getRouteTotalsResponse = routeSoapClient.getRouteTotals(routes, routeOptions, token);
var resultado = new
{
consumo = getRouteTotalsResponse.totalFuelUsed.ToString(cult),
distancia = getRouteTotalsResponse.totalDistance.ToString(cult),
tempototal = getRouteTotalsResponse.totalTime.ToString(cult)
};
return Json(resultado, JsonRequestBehavior.AllowGet);
}
return null;
}
catch (Exception ex)
{
return null;
}
}
public async Task <IActionResult> Create([Bind("RouteStopId,BusRouteCode,BusStopNumber,OffsetMinutes")] RouteStop routeStop)
{
if (ModelState.IsValid)
{
_context.Add(routeStop);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(await Create(Request.Cookies[cookieBusRouteCode]));
}
private static RouteStop ReadStopStartLine(string line)
{
CheckNullLine(line, "route start line");
LoggedException.RaiseIf(line[0] != '>' || line[8] != ',' || line.Length != 13, nameof(PASReader), "Invalid route start format");
RouteStop result = new RouteStop {
Id = line.Substring(1, 6)
};
result.SetLeaveFromString(line.Substring(9, 4));
return(result);
}
public static string GetFullName(RouteStop routeStop)
{
var res = routeStop.Stop.Name;
var cur = routeStop.Prev;
while (cur != null)
{
res = cur.Stop.Name + Separator + res;
cur = cur.Prev;
}
return(res);
}
public ActionResult Edit([Bind(Include = "ID,RouteID,StopID,StopSequence")] RouteStop routeStop)
{
if (ModelState.IsValid)
{
db.Entry(routeStop).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.RouteID = new SelectList(db.Routes, "ID", "ShortName", routeStop.RouteID);
ViewBag.StopID = new SelectList(db.Stops, "ID", "Name", routeStop.StopID);
return(View(routeStop));
}
public IList <RouteStop> GetByBusStop(int busStopId, int numberOfTimes)
{
if (busStopId > 0 && busStopId <= 10)
{
var stop = new BusStopData
{
Id = busStopId,
Name = $"Bus Stop {busStopId}",
RouteStops = new List <RouteStop>()
};
for (var routeId = 1; routeId <= 3; routeId++)
{
var routeStop = new RouteStop
{
BusStopId = busStopId,
BusStop = stop,
RouteId = routeId,
Route = new Route
{
Id = routeId,
Name = $"Route {routeId}",
RouteStops = stop.RouteStops
},
ArrivalTimes = new List <DateTime>()
};
// Each route starts running 2 minutes after the previous one
var timeOffset = (routeStop.RouteId - 1) * 2;
// Each stop is 2 minutes away from the previous one
timeOffset += (routeStop.BusStopId - 1) * 2;
// Each stop is serviced every 15 minutes per route
timeOffset = timeOffset % 15;
var nearestMultiple = this.FindNearestMultipleOfFifteen();
var nextStop = this.FindNearestTimeWithOffset(nearestMultiple, timeOffset);
for (var num = 0; num < numberOfTimes; num++)
{
routeStop.ArrivalTimes.Add(nextStop);
nextStop = nextStop.AddMinutes(15);
}
stop.RouteStops.Add(routeStop);
}
return(stop.RouteStops);
}
else
{
return(new List <RouteStop>());
}
}
public async Task <IActionResult> Create([Bind("RouteStopId,BusRouteCode,BusStopNumber,OffsetMinutes")] RouteStop routeStop)
{
if (ModelState.IsValid)
{
_context.Add(routeStop);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["BusRouteCode"] = new SelectList(_context.BusRoute, "BusRouteCode", "BusRouteCode", routeStop.BusRouteCode);
ViewData["BusStopNumber"] = new SelectList(_context.BusStop, "BusStopNumber", "BusStopNumber", routeStop.BusStopNumber);
return(View(routeStop));
}
public RouteTotals Calculate(RouteStop[] routes, int routeType)
{
this.ErrorMessage = String.Empty;
try
{
using (var routeSoapClient = new RouteSoapClient())
{
var getRouteTotalsResponse = routeSoapClient
.getRouteTotals(routes, this.DefaultRouteOptions(routeType), this.Token);
return getRouteTotalsResponse;
}
}
catch (System.ServiceModel.FaultException e)
{
this.ErrorMessage = e.Message;
return null;
}
}
public ActionResult Index(HttpPostedFileBase file)
{
MapLinkArquivoOutput resultado = new MapLinkArquivoOutput();
// Verify that the user selected a file
if (file != null && file.ContentLength > 0)
{
resultado.itens = new List<MapLinkOutputItem>();
StreamReader stream = new StreamReader(file.InputStream);
string conteudo = stream.ReadToEnd();
List<MapLinkFileInput> input = DecodeMapLinkInputFile(conteudo);
const string token = "c13iyCvmcC9mzwkLd0LCbmYC5mUF5m2jNGNtNGt6NmK6NJK=";
foreach(var item in input){
var originRoute = new RouteStop
{
description = "",
point = new Point { x = Convert.ToDouble(item.originCoordinate.longitude,cult) , y = Convert.ToDouble(item.originCoordinate.latitude, cult) }
};
var destinationRoute = new RouteStop
{
description = "",
point = new Point { x = Convert.ToDouble(item.destinationCoordinate.longitude,cult), y = Convert.ToDouble(item.destinationCoordinate.latitude,cult) }
};
var routes = new[] { originRoute, destinationRoute };
var routeOptions = new RouteOptions
{
language = "portugues",
routeDetails = new RouteDetails { descriptionType = 0, routeType = 1, optimizeRoute = true },
vehicle = new Vehicle
{
tankCapacity = 20,
averageConsumption = 9,
fuelPrice = 3,
averageSpeed = 60,
tollFeeCat = 2
}
};
using (var routeSoapClient = new RouteSoapClient())
{
var getRouteTotalsResponse = routeSoapClient.getRouteTotals(routes, routeOptions, token);
resultado.itens.Add(new MapLinkOutputItem(){
id=item.id,
consumo=getRouteTotalsResponse.totalFuelUsed.ToString(cult),
distancia=getRouteTotalsResponse.totalDistance.ToString(cult),
tempototal=getRouteTotalsResponse.totalTime.ToString(cult)
});
}
}
}
// redirect back to the index action to show the form once again
return View("Index",resultado);
}
