/// <summary> /// Default Constructor of Route /// </summary> /// <param name="rt">Route Type</param> /// <param name="end">destination block given PointRoute</param> /// <param name="ID">DB ID of route given DefinedRoute</param> /// <param name="blocks">List of blocks contained by that route</param> public Route(RouteTypes rt, IBlock end, int ID, List <IBlock> blocks) { _routeType = rt; _endBlock = end; _routeID = ID; _routeBlocks = blocks; }
/// <summary> /// Default Constructor of Route /// </summary> /// <param name="rt">Route Type</param> /// <param name="end">destination block given PointRoute</param> /// <param name="ID">DB ID of route given DefinedRoute</param> /// <param name="blocks">List of blocks contained by that route</param> public Route(RouteTypes rt, IBlock end, int ID, List<IBlock> blocks) { _routeType = rt; _endBlock = end; _routeID = ID; _routeBlocks = blocks; }
internal void Initialize(Chapter chapter) { if (NodeCategory.Count == 0) { foreach (string str in Enum.GetNames(typeof(NodeTypes))) { NodeTypes type = (NodeTypes)Enum.Parse(typeof(NodeTypes), str); NodeCategory.Add(type, new List <int>()); } } if (RouteCategory.Count == 0) { foreach (string str in Enum.GetNames(typeof(RouteTypes))) { RouteTypes type = (RouteTypes)Enum.Parse(typeof(RouteTypes), str); RouteCategory.Add(type, new List <int>()); } } Reset(); Cur_Chapter = chapter; DrawMap(chapter.ChapterMapRoundCount); SetPicForNodes(); SetLevels(Cur_Chapter.Levels); }
/// <summary>View departures for all routes from a stop</summary> /// <param name="routeType">Number identifying transport mode; values returned via RouteTypes API</param> /// <param name="stopId">Identifier of stop; values returned by Stops API</param> /// <param name="platformNumbers">Filter by platform number at stop</param> /// <param name="directionId"> /// Filter by identifier of direction of travel; values returned by Directions API - /// /v3/directions/route/{route_id} /// </param> /// <param name="dateUtc">Filter by the date and time of the request (ISO 8601 UTC format)</param> /// <param name="maxResults">Maximum number of results returned</param> /// <param name="gtfs">Indicates that stop_id parameter will accept "GTFS stop_id" data</param> /// <param name="includeCancelled"> /// Indicates if cancelled services (if they exist) are returned (default = false) - /// metropolitan train only /// </param> /// <param name="expand"> /// List objects to be returned in full (i.e. expanded) - options include: all, stop, route, run, /// direction, disruption /// </param> /// <returns> /// Service departures from the specified stop for all routes of the specified route type; departures are /// timetabled and real-time (if applicable). /// </returns> /// <exception cref="SwaggerException">A server side error occurred.</exception> public DeparturesResponse GetForStop(RouteTypes routeType, int stopId, IEnumerable <int> platformNumbers, int?directionId, DateTime?dateUtc, int?maxResults, bool?gtfs, bool?includeCancelled, IEnumerable <ExpandableParameter> expand) { return(Task.Run(async() => await GetForStopAsync(routeType, stopId, platformNumbers, directionId, dateUtc, maxResults, gtfs, includeCancelled, expand, CancellationToken.None)).GetAwaiter().GetResult()); }
public async Task <ActionResult> DeleteConfirmed(int id) { RouteTypes routeTypes = await db.RouteTypes.FindAsync(id); db.RouteTypes.Remove(routeTypes); await db.SaveChangesAsync(); return(RedirectToAction("Index")); }
/// <summary> /// Initializes a new instance of the <see cref="WebRouteAttribute"/> class. /// </summary> /// <param name="routeTypes">The route type.</param> /// <param name="controllerRoute">The controller route.</param> /// <param name="actionRoute">The action route.</param> public WebRouteAttribute(RouteTypes routeTypes, string controllerRoute, string actionRoute) { if (routeTypes != RouteTypes.ControllerAndAction) { throw new ArgumentException("Too many route parameters"); } this.ControllerRoute = controllerRoute; this.ActionRoute = actionRoute; }
public async Task <ActionResult> Edit([Bind(Include = "Id,Name")] RouteTypes routeTypes) { if (ModelState.IsValid) { db.Entry(routeTypes).State = EntityState.Modified; await db.SaveChangesAsync(); return(RedirectToAction("Index")); } return(View(routeTypes)); }
/// <summary> /// Returns a route depending on its type /// </summary> /// <param name="session">Data access object</param> /// <param name="type">The route type of interest</param> /// <returns>route object</returns> public static IRoute GetRouteByType(IDalSession session, RouteTypes type) { IRoute route = null; List<ICriterion> expressions = new List<ICriterion>(); expressions.Add(Expression.Eq("Type", type)); IList list = session.GetList(typeof(Route), expressions); if (list != null && list.Count > 0) { route = (IRoute)list[0]; } return route; }
public async Task <ActionResult> Create([Bind(Include = "Id,Name")] RouteTypes routeTypes) { if (ModelState.IsValid) { db.RouteTypes.Add(routeTypes); await db.SaveChangesAsync(); return(RedirectToAction("Index")); } return(View(routeTypes)); }
private int GetIndexOf(RouteTypes routeType) { string Route = routeType.ToString().ToLower(); //convert the enum type to string and go with lower case to match with the entries for (int i = 0; i < RouteTemplate.Length; i++) //loop thru the list { if (RouteTemplate[i] == Route) { return(i); // if the enum matches with the route url return the position of it } } return(-1);//otherwise return -1 }
public static List <RouteID> GetRoutesOfType(RouteTypes routeType) { List <RouteID> routesIDList = new List <RouteID>(); foreach (RouteID id in Routes.Keys) { if (Routes[id].RouteType == routeType) { routesIDList.Add(id); } } return(routesIDList); }
// GET: Guides/RouteTypes/Delete/5 public async Task <ActionResult> Delete(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } RouteTypes routeTypes = await db.RouteTypes.FindAsync(id); if (routeTypes == null) { return(HttpNotFound()); } return(View(routeTypes)); }
public string GetUrlFor(RouteTypes routeType, string value) { List <string> CopiedRouteValues = new List <string>(RouteValues); //copy the default route parameters to make sure that those don't change string UrlToReturn = string.Empty; //empty the url to make sure those don't stack int index = GetIndexOf(routeType); //get the index of the route type if (index != -1) { CopiedRouteValues[index] = value; //make sure it's a valid number } foreach (var routeValue in CopiedRouteValues) //loop thru the copied route { UrlToReturn += $"/{routeValue}"; //add every value to the route } return(UrlToReturn); //and then return it }
public WebRouteAttribute(RouteTypes routeTypes, string route) { if (routeTypes == RouteTypes.ControllerAndAction) { throw new ArgumentException("Can't set up a route with route type 'ControllerAndAction' without two route parameters"); } if (routeTypes.HasFlag(RouteTypes.Controller)) { this.ControllerRoute = route; } if (routeTypes.HasFlag(RouteTypes.Action)) { this.ActionRoute = route; } }
/// <summary>View facilities at a specific stop (Metro and V/Line stations only)</summary> /// <param name="stopId">Identifier of stop; values returned by Stops API</param> /// <param name="routeType">Number identifying transport mode; values returned via RouteTypes API</param> /// <param name="stopLocation">Indicates if stop location information will be returned (default = false)</param> /// <param name="stopAmenities">Indicates if stop amenity information will be returned (default = false)</param> /// <param name="stopAccessibility">Indicates if stop accessibility information will be returned (default = false)</param> /// <returns> /// Stop location, amenity and accessibility facility information for the specified stop (metropolitan and V/Line /// stations only). /// </returns> /// <exception cref="SwaggerException">A server side error occurred.</exception> public Task <StopResponse> StopDetailsAsync(int stopId, RouteTypes routeType, bool?stopLocation, bool?stopAmenities, bool?stopAccessibility) { return(StopDetailsAsync(stopId, routeType, stopLocation, stopAmenities, stopAccessibility, CancellationToken.None)); }
/// <summary>View facilities at a specific stop (Metro and V/Line stations only)</summary> /// <param name="stopId">Identifier of stop; values returned by Stops API</param> /// <param name="routeType">Number identifying transport mode; values returned via RouteTypes API</param> /// <param name="stopLocation">Indicates if stop location information will be returned (default = false)</param> /// <param name="stopAmenities">Indicates if stop amenity information will be returned (default = false)</param> /// <param name="stopAccessibility">Indicates if stop accessibility information will be returned (default = false)</param> /// <returns> /// Stop location, amenity and accessibility facility information for the specified stop (metropolitan and V/Line /// stations only). /// </returns> /// <exception cref="SwaggerException">A server side error occurred.</exception> public StopResponse StopDetails(int stopId, RouteTypes routeType, bool?stopLocation, bool?stopAmenities, bool?stopAccessibility) { return(Task.Run(async() => await StopDetailsAsync(stopId, routeType, stopLocation, stopAmenities, stopAccessibility, CancellationToken.None)).GetAwaiter().GetResult()); }
/// <summary>View departures for a specific route from a stop</summary> /// <param name="routeType">Number identifying transport mode; values returned via RouteTypes API</param> /// <param name="stopId">Identifier of stop; values returned by Stops API</param> /// <param name="routeId">Identifier of route; values returned by Routes API - v3/routes</param> /// <param name="directionId"> /// Filter by identifier of direction of travel; values returned by Directions API - /// /v3/directions/route/{route_id} /// </param> /// <param name="dateUtc">Filter by the date and time of the request (ISO 8601 UTC format)</param> /// <param name="maxResults">Maximum number of results returned</param> /// <param name="gtfs">Indicates that stop_id parameter will accept "GTFS stop_id" data</param> /// <param name="includeCancelled"> /// Indicates if cancelled services (if they exist) are returned (default = false) - /// metropolitan train only /// </param> /// <param name="expand"> /// List objects to be returned in full (i.e. expanded) - options include: all, stop, route, run, /// direction, disruption /// </param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of /// cancellation. /// </param> /// <returns> /// Service departures from the specified stop for the specified route (and route type); departures are timetabled /// and real-time (if applicable). /// </returns> /// <exception cref="SwaggerException">A server side error occurred.</exception> public async Task <DeparturesResponse> GetForStopAndRouteAsync(RouteTypes routeType, int stopId, string routeId, int?directionId, DateTime?dateUtc, int?maxResults, bool?gtfs, bool?includeCancelled, IEnumerable <ExpandableParameter> expand, CancellationToken cancellationToken) { var urlBuilder = new StringBuilder(); urlBuilder .Append("/v3/departures/route_type/{route_type}/stop/{stop_id}/route/{route_id}?"); urlBuilder.Replace("{route_type}", Uri.EscapeDataString(((int)routeType).ToString())); urlBuilder.Replace("{stop_id}", Uri.EscapeDataString(stopId.ToString())); urlBuilder.Replace("{route_id}", Uri.EscapeDataString(routeId)); if (directionId != null) { urlBuilder.Append("direction_id=").Append(Uri.EscapeDataString(directionId.Value.ToString())).Append("&"); } if (dateUtc != null) { urlBuilder.Append("date_utc=").Append(Uri.EscapeDataString(dateUtc.Value.ToString("s", CultureInfo.InvariantCulture))).Append("&"); } if (maxResults != null) { urlBuilder.Append("max_results=").Append(Uri.EscapeDataString(maxResults.Value.ToString())).Append("&"); } if (gtfs != null) { urlBuilder.Append("gtfs=").Append(Uri.EscapeDataString(gtfs.Value.ToString())).Append("&"); } if (includeCancelled != null) { urlBuilder.Append("include_cancelled=").Append(Uri.EscapeDataString(includeCancelled.Value.ToString())).Append("&"); } if (expand != null) { urlBuilder.Append("expand=").Append(Uri.EscapeDataString(string.Join(",", expand))).Append("&"); } var client = new HttpClient(); try { using (var request = new HttpRequestMessage()) { request.Method = new HttpMethod("GET"); request.Headers.Accept.Add( new MediaTypeWithQualityHeaderValue("application/json")); PrepareRequest(client, request, urlBuilder); var url = urlBuilder.ToString(); request.RequestUri = new Uri(BaseUrl + url, UriKind.RelativeOrAbsolute); PrepareRequest(client, request, url); var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken) .ConfigureAwait(false); try { var headers = response.Headers.ToDictionary(h => h.Key, h => h.Value); foreach (var item in response.Content.Headers) { headers[item.Key] = item.Value; } ProcessResponse(client, response); var status = ((int)response.StatusCode).ToString(); if (status == "200") { var responseData = await response.Content.ReadAsStringAsync().ConfigureAwait(false); var result = default(DeparturesResponse); try { result = JsonConvert.DeserializeObject <DeparturesResponse>(responseData); return(result); } catch (Exception exception) { throw new SwaggerException("Could not deserialize the response body.", status, responseData, headers, exception); } } else if (status == "400") { var responseData = await response.Content.ReadAsStringAsync().ConfigureAwait(false); var result = default(ErrorResponse); try { result = JsonConvert.DeserializeObject <ErrorResponse>(responseData); } catch (Exception exception) { throw new SwaggerException("Could not deserialize the response body.", status, responseData, headers, exception); } throw new SwaggerException <ErrorResponse>("Invalid Request", status, responseData, headers, result, null); } else if (status == "403") { var responseData = await response.Content.ReadAsStringAsync().ConfigureAwait(false); var result = default(ErrorResponse); try { result = JsonConvert.DeserializeObject <ErrorResponse>(responseData); } catch (Exception exception) { throw new SwaggerException("Could not deserialize the response body.", status, responseData, headers, exception); } throw new SwaggerException <ErrorResponse>("Access Denied", status, responseData, headers, result, null); } else if (status != "200" && status != "204") { var responseData = await response.Content.ReadAsStringAsync().ConfigureAwait(false); throw new SwaggerException( "The HTTP status code of the response was not expected (" + (int)response.StatusCode + ").", status, responseData, headers, null); } return(default(DeparturesResponse)); } finally { response?.Dispose(); } } } finally { client?.Dispose(); } }
/// <summary>View departures for a specific route from a stop</summary> /// <param name="routeType">Number identifying transport mode; values returned via RouteTypes API</param> /// <param name="stopId">Identifier of stop; values returned by Stops API</param> /// <param name="routeId">Identifier of route; values returned by Routes API - v3/routes</param> /// <param name="directionId"> /// Filter by identifier of direction of travel; values returned by Directions API - /// /v3/directions/route/{route_id} /// </param> /// <param name="dateUtc">Filter by the date and time of the request (ISO 8601 UTC format)</param> /// <param name="maxResults">Maximum number of results returned</param> /// <param name="gtfs">Indicates that stop_id parameter will accept "GTFS stop_id" data</param> /// <param name="includeCancelled"> /// Indicates if cancelled services (if they exist) are returned (default = false) - /// metropolitan train only /// </param> /// <param name="expand"> /// List objects to be returned in full (i.e. expanded) - options include: all, stop, route, run, /// direction, disruption /// </param> /// <returns> /// Service departures from the specified stop for the specified route (and route type); departures are timetabled /// and real-time (if applicable). /// </returns> /// <exception cref="SwaggerException">A server side error occurred.</exception> public Task <DeparturesResponse> GetForStopAndRouteAsync(RouteTypes routeType, int stopId, string routeId, int?directionId, DateTime?dateUtc, int?maxResults, bool?gtfs, bool?includeCancelled, IEnumerable <ExpandableParameter> expand) { return(GetForStopAndRouteAsync(routeType, stopId, routeId, directionId, dateUtc, maxResults, gtfs, includeCancelled, expand, CancellationToken.None)); }
private IRoute getSpecificRoute(RouteTypes type) { foreach (IRoute route in routes) { if (route.Type == type) { return route; } } throw new ApplicationException(string.Format("Could not find the route of type {0}", type.ToString())); }
/// <summary>View the stopping pattern for a specific trip/service run</summary> /// <param name="runId"> /// Identifier of a trip/service run; values returned by Runs API - /v3/route/{route_id} and Departures /// API /// </param> /// <param name="routeType">Number identifying transport mode; values returned via RouteTypes API</param> /// <param name="stopId">Filter by stop_id; values returned by Stops API</param> /// <param name="dateUtc">Filter by the date and time of the request (ISO 8601 UTC format)</param> /// <returns>The stopping pattern of the specified trip/service run and route type.</returns> /// <exception cref="SwaggerException">A server side error occurred.</exception> public Task <StoppingPattern> GetPatternByRunAsync(int runId, RouteTypes routeType, int?stopId, DateTime?dateUtc) { return(GetPatternByRunAsync(runId, routeType, stopId, dateUtc, CancellationToken.None)); }
/// <summary>View the trip/service run for a specific run ID and route type</summary> /// <param name="runId"> /// Identifier of a trip/service run; values returned by Runs API - /v3/route/{route_id} and Departures /// API /// </param> /// <param name="routeType">Number identifying transport mode; values returned via RouteTypes API</param> /// <returns>The trip/service run details for the run ID and route type specified.</returns> /// <exception cref="SwaggerException">A server side error occurred.</exception> public RunResponse ForRunAndRouteType(int runId, RouteTypes routeType) { return(Task.Run(async() => await ForRunAndRouteTypeAsync(runId, routeType, CancellationToken.None)).GetAwaiter().GetResult()); }
/// <summary>View the trip/service run for a specific run ID and route type</summary> /// <param name="runId"> /// Identifier of a trip/service run; values returned by Runs API - /v3/route/{route_id} and Departures /// API /// </param> /// <param name="routeType">Number identifying transport mode; values returned via RouteTypes API</param> /// <returns>The trip/service run details for the run ID and route type specified.</returns> /// <exception cref="SwaggerException">A server side error occurred.</exception> public Task <RunResponse> ForRunAndRouteTypeAsync(int runId, RouteTypes routeType) { return(ForRunAndRouteTypeAsync(runId, routeType, CancellationToken.None)); }
/// <summary>View all routes of a particular type for a direction of travel</summary> /// <param name="directionId"> /// Identifier of direction of travel; values returned by Directions API - /// /v3/directions/route/{route_id} /// </param> /// <param name="routeType">Number identifying transport mode; values returned via RouteTypes API</param> /// <returns>All routes of the specified route type that travel in the specified direction.</returns> /// <exception cref="SwaggerException">A server side error occurred.</exception> public Task <DirectionsResponse> ForDirectionAndTypeAsync(int directionId, RouteTypes routeType) { return(ForDirectionAndTypeAsync(directionId, routeType, CancellationToken.None)); }
/// <summary>View all stops on a specific route</summary> /// <param name="routeId">Identifier of route; values returned by Routes API - v3/routes</param> /// <param name="routeType">Number identifying transport mode; values returned via RouteTypes API</param> /// <returns>All stops on the specified route.</returns> /// <exception cref="SwaggerException">A server side error occurred.</exception> public StopsOnRouteResponse StopsForRoute(int routeId, RouteTypes routeType) { return(Task.Run(async() => await StopsForRouteAsync(routeId, routeType, CancellationToken.None)).GetAwaiter().GetResult()); }
/// <summary>View all routes of a particular type for a direction of travel</summary> /// <param name="directionId"> /// Identifier of direction of travel; values returned by Directions API - /// /v3/directions/route/{route_id} /// </param> /// <param name="routeType">Number identifying transport mode; values returned via RouteTypes API</param> /// <returns>All routes of the specified route type that travel in the specified direction.</returns> /// <exception cref="SwaggerException">A server side error occurred.</exception> public DirectionsResponse ForDirectionAndType(int directionId, RouteTypes routeType) { return(Task.Run(async() => await ForDirectionAndTypeAsync(directionId, routeType, CancellationToken.None)).GetAwaiter().GetResult()); }
public ChangeRouteTypeTravelEvent(double _distance,RouteTypes _type) : base(_distance) { System.Diagnostics.Debug.WriteLine("Added ChangeRouteTypeEvent"); this._type = _type; }
/// <summary>View the trip/service run for a specific run ID and route type</summary> /// <param name="runId"> /// Identifier of a trip/service run; values returned by Runs API - /v3/route/{route_id} and Departures /// API /// </param> /// <param name="routeType">Number identifying transport mode; values returned via RouteTypes API</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of /// cancellation. /// </param> /// <returns>The trip/service run details for the run ID and route type specified.</returns> /// <exception cref="SwaggerException">A server side error occurred.</exception> public async Task <RunResponse> ForRunAndRouteTypeAsync(int runId, RouteTypes routeType, CancellationToken cancellationToken) { var urlBuilder = new StringBuilder(); urlBuilder.Append("/v3/runs/{run_id}/route_type/{route_type}?"); urlBuilder.Replace("{run_id}", Uri.EscapeDataString(runId.ToString())); urlBuilder.Replace("{route_type}", Uri.EscapeDataString(((int)routeType).ToString())); var client = new HttpClient(); try { using (var request = new HttpRequestMessage()) { request.Method = new HttpMethod("GET"); request.Headers.Accept.Add( new MediaTypeWithQualityHeaderValue("application/json")); PrepareRequest(client, request, urlBuilder); var url = urlBuilder.ToString(); request.RequestUri = new Uri(BaseUrl + url, UriKind.RelativeOrAbsolute); PrepareRequest(client, request, url); var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken) .ConfigureAwait(false); try { var headers = response.Headers.ToDictionary(h => h.Key, h => h.Value); foreach (var item in response.Content.Headers) { headers[item.Key] = item.Value; } ProcessResponse(client, response); var status = ((int)response.StatusCode).ToString(); if (status == "200") { var responseData = await response.Content.ReadAsStringAsync().ConfigureAwait(false); var result = default(RunResponse); try { result = JsonConvert.DeserializeObject <RunResponse>(responseData); return(result); } catch (Exception exception) { throw new SwaggerException("Could not deserialize the response body.", status, responseData, headers, exception); } } else if (status == "400") { var responseData = await response.Content.ReadAsStringAsync().ConfigureAwait(false); var result = default(ErrorResponse); try { result = JsonConvert.DeserializeObject <ErrorResponse>(responseData); } catch (Exception exception) { throw new SwaggerException("Could not deserialize the response body.", status, responseData, headers, exception); } throw new SwaggerException <ErrorResponse>("Invalid Request", status, responseData, headers, result, null); } else if (status == "403") { var responseData = await response.Content.ReadAsStringAsync().ConfigureAwait(false); var result = default(ErrorResponse); try { result = JsonConvert.DeserializeObject <ErrorResponse>(responseData); } catch (Exception exception) { throw new SwaggerException("Could not deserialize the response body.", status, responseData, headers, exception); } throw new SwaggerException <ErrorResponse>("Access Denied", status, responseData, headers, result, null); } else if (status != "200" && status != "204") { var responseData = await response.Content.ReadAsStringAsync().ConfigureAwait(false); throw new SwaggerException( "The HTTP status code of the response was not expected (" + (int)response.StatusCode + ").", status, responseData, headers, null); } return(default(RunResponse)); } finally { response?.Dispose(); } } } finally { client?.Dispose(); } }
/// <summary>View all stops on a specific route</summary> /// <param name="routeId">Identifier of route; values returned by Routes API - v3/routes</param> /// <param name="routeType">Number identifying transport mode; values returned via RouteTypes API</param> /// <returns>All stops on the specified route.</returns> /// <exception cref="SwaggerException">A server side error occurred.</exception> public Task <StopsOnRouteResponse> StopsForRouteAsync(int routeId, RouteTypes routeType) { return(StopsForRouteAsync(routeId, routeType, CancellationToken.None)); }
/// <summary>View the stopping pattern for a specific trip/service run</summary> /// <param name="runId"> /// Identifier of a trip/service run; values returned by Runs API - /v3/route/{route_id} and Departures /// API /// </param> /// <param name="routeType">Number identifying transport mode; values returned via RouteTypes API</param> /// <param name="stopId">Filter by stop_id; values returned by Stops API</param> /// <param name="dateUtc">Filter by the date and time of the request (ISO 8601 UTC format)</param> /// <returns>The stopping pattern of the specified trip/service run and route type.</returns> /// <exception cref="SwaggerException">A server side error occurred.</exception> public StoppingPattern GetPatternByRun(int runId, RouteTypes routeType, int?stopId, DateTime?dateUtc) { return(Task.Run(async() => await GetPatternByRunAsync(runId, routeType, stopId, dateUtc, CancellationToken.None)).GetAwaiter().GetResult()); }