Beispiel #1
0
 public void UrlParameters_Returns_ParametersDefinedOnTheAttribute()
 {
     var routeInfo = new RouteInfo(_testMethod);
     var urlParameters = routeInfo.QueryParameters;
     var parameters = string.Join(",", urlParameters.Select(a => a.Name));
     Assert.Equal("p1,p2,p3,gender,date,list,numbers", parameters);
 }
        public void RouteInfoComparisonTest()
        {
            // Create route infos and add them to a list out of order.
            RouteInfo r101Both = new RouteInfo {
                Name = "101",
                LrsTypes = LrsTypes.Both
            };
            RouteInfo r005Both = new RouteInfo
            {
                Name = "005",
                LrsTypes = LrsTypes.Both
            };
            RouteInfo r005Inc = new RouteInfo
            {
                Name = "005",
                LrsTypes = LrsTypes.Increase
            };

            List<RouteInfo> routeInfo = new List<RouteInfo>();
            routeInfo = new List<RouteInfo>(3);
            routeInfo.Add(r101Both);
            routeInfo.Add(r005Both);
            routeInfo.Add(r005Inc);

            // Sort the list and test for the expected order.
            routeInfo.Sort();

            Assert.AreEqual(routeInfo[0], r005Inc);
            Assert.AreEqual(routeInfo[1], r005Both);
            Assert.AreEqual(routeInfo[2], r101Both);
        }
Beispiel #3
0
        public ActionResult OEmbed(string url, int maxwidth = 570, int maxheight = 400, DataFormat format = DataFormat.Json)
        {
            if (string.IsNullOrEmpty(url))
                return HttpStatusCodeResult(HttpStatusCode.BadRequest, "URL not specified");

            var route = new RouteInfo(new Uri(url), AppConfig.HostAddress).RouteData;
            var controller = route.Values["controller"].ToString().ToLowerInvariant();

            if (controller != "song" && controller != "s") {
                return HttpStatusCodeResult(HttpStatusCode.BadRequest, "Only song embeds are supported");
            }

            int id;

            if (controller == "s") {
                var match = Regex.Match(route.Values["action"].ToString(), @"(\d+)");
                id = int.Parse(match.Groups[1].Value);
            }
            else {
                id = int.Parse(route.Values["id"].ToString());
            }

            var song = Services.Songs.GetSong(id);
            var html = string.Format("<iframe src=\"{0}\" width=\"{1}\" height=\"{2}\"></iframe>",
                VocaUriBuilder.CreateAbsolute(Url.Action("EmbedSong", new {songId = id})), maxwidth, maxheight);

            return Object(new SongOEmbedResponse(song, maxwidth, maxheight, html), format);
        }
 public RouteDetail(RouteInfo routeInfo, Func<Type, ModelDescription> modelDescriptionCreator)
 {
     _routeInfo = routeInfo;
     _modelDescriptionCreator = modelDescriptionCreator;
     LoadUrlParameters();
     LoadBodyParameter();
     LoadReturnParameter();
 }
Beispiel #5
0
        public void ReturnParameter_Returns_ReturnParameter()
        {
            var routeInfo = new RouteInfo(_testMethod);
            var returnParameter = routeInfo.ReturnParameter;

            Assert.NotNull(returnParameter);
            Assert.Equal(typeof(TestResult), returnParameter.ParameterType);
        }
		public void HandlesRoutesWithNoConstraints()
		{
			var constraints = new RouteValueDictionary();
			var routeInfo = new RouteInfo { Constraints = new RouteValueDictionary() };

			var processor = new ConstraintsProcessor();
			processor.ProcessConstraints(constraints, routeInfo);
			Assert.AreEqual(0, routeInfo.Constraints.Count);
		}
Beispiel #7
0
        public virtual void Begin(HttpRequest req, HttpResponse res, RouteInfo route, Application app)
        {
            this.Request = req;
            this.Response = res;
            this.RouteInfo = route;
            this.App = app;

            // Start the show
            this.PreHandle();
        }
		public void IncludesRegExpConstraints()
		{
			var constraints = new RouteValueDictionary {{"id", @"\d+"}};
			var routeInfo = new RouteInfo { Constraints = new RouteValueDictionary() };

			var processor = new ConstraintsProcessor();
			processor.ProcessConstraints(constraints, routeInfo);
			Assert.AreEqual(1, routeInfo.Constraints.Count);
			Assert.AreEqual(@"\d+", routeInfo.Constraints["id"]);
		}
Beispiel #9
0
        public static MvcHtmlString RouteLinkExists(this HtmlHelper helper, RouteInfo routeInfo)
        {
            bool isNotAuthType = true;

            if (routeInfo.AccessType == RouteAccessType.Auth)
            {
                foreach (string role in Roles.GetRolesForUser())
                {
                    var userType = (WFSUserTypeEnum)Enum.Parse(typeof(WFSUserTypeEnum), role);
                    if (isNotAuthType)
                        isNotAuthType = !((routeInfo.UserType == userType) && routeInfo.AccessType == RouteAccessType.Auth);
                }
            }
            else
            {
                isNotAuthType = false;
            }

            bool isNotAuth = HttpContext.Current.User.Identity.IsAuthenticated && routeInfo.AccessType == RouteAccessType.NonAuth;
            bool isAuth = HttpContext.Current.User.Identity.IsAuthenticated && routeInfo.AccessType == RouteAccessType.NonAuth;
            bool isActive = routeInfo.IsActive();

            // auth type filter
            if (isNotAuth || isNotAuthType || !isActive)
            {
                return new MvcHtmlString(string.Empty);
            }

            if (helper.RouteCollection[routeInfo.RouteName] == null)
            {
                throw new Exception(string.Format(EXC_ROUTE_NOTFOUND, routeInfo.RouteName));
            }

            string area = (((System.Web.Routing.Route)(helper.RouteCollection[routeInfo.RouteName])).DataTokens["area"] ?? "").ToString();

            string currentArea = (helper.ViewContext.RouteData.DataTokens["area"] ?? "").ToString();

            string url = String.Format("/{0}", ((System.Web.Routing.Route)(helper.RouteCollection[routeInfo.RouteName])).Url);

            if (routeInfo.IsDisabled())
            {
                return new MvcHtmlString(string.Format(TMP_URL, "disabledMenuItem", "", helper.RouteLink(routeInfo.LinkText, routeInfo.RouteName, routeInfo.RouteValues, routeInfo.HtmlAttributes).ToHtmlString()));
            }
            else if (url == HttpContext.Current.Request.Url.AbsolutePath)
            {
                return new MvcHtmlString(string.Format(TMP_URL, "active", routeInfo.RouteMatchClass, helper.RouteLink(routeInfo.LinkText, routeInfo.RouteName, routeInfo.RouteValues, routeInfo.HtmlAttributes).ToHtmlString()));
            }
            else if (area == currentArea && !routeInfo.ExactMatch)
            {
                return new MvcHtmlString(string.Format(TMP_URL, "", "", helper.RouteLink(routeInfo.LinkText, routeInfo.RouteName, routeInfo.RouteValues, routeInfo.HtmlAttributes).ToHtmlString()));
            }

            return new MvcHtmlString(string.Format(TMP_URL, "", "", helper.RouteLink(routeInfo.LinkText, routeInfo.RouteName, routeInfo.RouteValues, routeInfo.HtmlAttributes).ToHtmlString()));
        }
		private RouteInfo Parse(string template)
	    {
			var parser = new RouteTemplateParser();
		    var parsedTemplate = TemplateParser.Parse(template);
			var info = new RouteInfo
			{
				Defaults = new Dictionary<string, object>(),
				Optional = new List<string>(),
			};
			parser.Parse(parsedTemplate, info);
		    return info;
	    }
Beispiel #11
0
 public static MvcHtmlString RouteLinkExists(this HtmlHelper helper, string linkText, string routeName, object routeValues, object htmlAttributes, string routeMatchesClass, bool exactMatch)
 {
     RouteInfo routeInfo = new RouteInfo();
     routeInfo.AccessType = RouteAccessType.All;
     routeInfo.ExactMatch = exactMatch;
     routeInfo.HtmlAttributes = htmlAttributes;
     routeInfo.LinkText = linkText;
     routeInfo.RouteMatchClass = routeMatchesClass;
     routeInfo.RouteName = routeName;
     routeInfo.RouteValues = routeValues;
     return helper.RouteLinkExists(routeInfo);
 }
		public void ExcludesCustomConstraints()
		{
			var customConstraint = new Mock<IRouteConstraint>();
			var constraints = new RouteValueDictionary {
				{ "id", @"\d+" },
				{ "awesome", customConstraint },
			};
			var routeInfo = new RouteInfo { Constraints = new RouteValueDictionary() };

			var processor = new ConstraintsProcessor();
			processor.ProcessConstraints(constraints, routeInfo);
			Assert.AreEqual(1, routeInfo.Constraints.Count);
		}
        public void BuildEndpoints_Header_Works()
        {
            var services = CreateServices();
            var factory  = services.GetRequiredService <ProxyEndpointFactory>();

            factory.SetProxyPipeline(context => Task.CompletedTask);

            var route = new ProxyRoute
            {
                RouteId = "route1",
                Match   = new ProxyMatch
                {
                    Path    = "/",
                    Headers = new[]
                    {
                        new RouteHeader()
                        {
                            Name            = "header1",
                            Values          = new[] { "value1" },
                            Mode            = HeaderMatchMode.HeaderPrefix,
                            IsCaseSensitive = true,
                        }
                    }
                },
            };
            var cluster   = new ClusterInfo("cluster1");
            var routeInfo = new RouteInfo("route1");

            var(routeEndpoint, routeConfig) = CreateEndpoint(factory, routeInfo, route, cluster);

            Assert.Same(cluster, routeConfig.Cluster);
            Assert.Equal("route1", routeEndpoint.DisplayName);
            var headerMetadata = routeEndpoint.Metadata.GetMetadata <IHeaderMetadata>();

            Assert.NotNull(headerMetadata);
            var matchers = headerMetadata.Matchers;

            Assert.Single(matchers);
            var matcher = matchers.Single();

            Assert.Equal("header1", matcher.Name);
            Assert.Equal(new[] { "value1" }, matcher.Values);
            Assert.Equal(HeaderMatchMode.HeaderPrefix, matcher.Mode);
            Assert.True(matcher.IsCaseSensitive);

            Assert.False(routeConfig.HasConfigChanged(route, cluster, routeInfo.ClusterRevision));
        }
Beispiel #14
0
        private void SpawnMonsters()
        {
            var topLeftLocation = new Point(CurrentLocation.X - Info.EventSize, CurrentLocation.Y - Info.EventSize);

            foreach (var eventRespawn in Info.Respawns)
            {
                var respawnInfo = new RespawnInfo();

                var monster = Envir.GetMonsterInfo(eventRespawn.MonsterName);
                if (monster == null)
                {
                    SMain.EnqueueDebugging(string.Format("{0} Activating Event:{1} FAILED COULDN'T FIND MONSTER {2}", Map.Info.FileName, Info.EventName, eventRespawn.MonsterName));
                    return;
                }
                respawnInfo.Spread          = eventRespawn.MonsterCount;
                respawnInfo.Count           = eventRespawn.MonsterCount;
                respawnInfo.MonsterIndex    = monster.Index;
                respawnInfo.Delay           = 10000;
                respawnInfo.SaveRespawnTime = false;
                respawnInfo.RespawnIndex    = 0;
                respawnInfo.RespawnTicks    = 0;


                if (eventRespawn.SpreadY == 0 && eventRespawn.SpreadX == 0 && eventRespawn.MonsterCount == 1)
                {
                    respawnInfo.Location = CurrentLocation;
                }
                else
                {
                    respawnInfo.Location = new Point(topLeftLocation.X + eventRespawn.SpreadX * 2, topLeftLocation.Y + eventRespawn.SpreadY * 2);
                }

                MapRespawn mapRespawn = new MapRespawn(respawnInfo);

                RouteInfo route = new RouteInfo();
                route.Location = respawnInfo.Location;
                route.Delay    = 1000;
                mapRespawn.Route.Add(route);

                mapRespawn.Map = Map;
                mapRespawn.IsEventObjective = eventRespawn.IsObjective;
                mapRespawn.Event            = this;
                MapRespawns.Add(mapRespawn);
            }

            Map.Respawns.AddRange(MapRespawns);
        }
Beispiel #15
0
        private void SpawnMonstersForInvasion(List <EventRespawn> respawns)
        {
            var topLeftLocation = new Point(CurrentLocation.X - Info.EventSize, CurrentLocation.Y - Info.EventSize);

            foreach (var eventRespawn in respawns)
            {
                var monster = Envir.GetMonsterInfo(eventRespawn.MonsterName);
                if (monster == null)
                {
                    SMain.EnqueueDebugging(string.Format("{0} Event:{1} FAILED COULDN'T FIND MONSTER {2}", Map.Info.FileName, Info.EventName, eventRespawn.MonsterName));
                    continue;
                }

                var respawnInfo = new RespawnInfo()
                {
                    Spread       = eventRespawn.MonsterCount,
                    Count        = eventRespawn.MonsterCount,
                    MonsterIndex = monster.Index,
                    Delay        = ushort.MaxValue
                };

                if (eventRespawn.SpreadY == 0 && eventRespawn.SpreadX == 0)
                {
                    respawnInfo.Location = CurrentLocation;
                }
                else
                {
                    respawnInfo.Location = new Point(topLeftLocation.X + eventRespawn.SpreadX * 2, topLeftLocation.Y + eventRespawn.SpreadY * 2);
                }

                MapRespawn mapRespawn = new MapRespawn(respawnInfo);

                RouteInfo route = new RouteInfo()
                {
                    Location = respawnInfo.Location,
                    Delay    = 1000,
                };
                mapRespawn.Route.Add(route);

                mapRespawn.Map = Map;
                mapRespawn.IsEventObjective = eventRespawn.IsObjective;
                mapRespawn.Event            = this;
                MapRespawns.Add(mapRespawn);
            }

            Map.Respawns.AddRange(MapRespawns);
        }
Beispiel #16
0
        public void Get_WithId_ReturnOne()
        {
            //arrange
            var controller = new AutoAPI.RESTAPIController(SetupHelper.BuildTestContext(), null, null);
            var routeInfo  = new RouteInfo()
            {
                Entity = entityList.Where(x => x.Route == "/api/authors").First(), Id = "1"
            };

            //act
            var result = (OkObjectResult)controller.Get(routeInfo);

            //assert
            Assert.Equal(200, result.StatusCode.Value);
            Assert.Equal(1, ((Author)result.Value).Id);
            Assert.Equal("Ernest Hemingway", ((Author)result.Value).Name);
        }
        public static async Task <T> Patch_ModelAsync <T>(Api.Models.PointModel point)
        {
            var routeInfo = new RouteInfo
            {
                HttpMethods = "PATCH",
                Path        = Patch_Model,
                Parameters  = new List <ParameterInfo>
                {
                    new ParameterInfo()
                    {
                        Name = "point", Type = "Api.Models.PointModel"
                    },
                }
            };

            return(await HttpClientAsync.Async <T>(routeInfo, point));
        }
Beispiel #18
0
 void SetRouteInfo(string Code, string Segment, EndPoint point)
 {
     if (RouteList.ContainsKey(Code))
     {
         RouteList[Code].RemotePoint = point;
         RouteList[Code].IsOnline    = true;
         RouteList[Code].Segment     = Segment;
     }
     else
     {
         RouteInfo info = new RouteInfo();
         info.RemotePoint = point;
         info.Segment     = Segment;
         info.IsOnline    = true;
         RouteList.Add(Code, info);
     }
 }
Beispiel #19
0
        public void HandlesOptionalParameters()
        {
            var routes = new RouteCollection();

            routes.MapRoute(
                name: "Hello",
                url: "hello/world/{id}",
                defaults: new { controller = "Hello", action = "HelloWorld", id = UrlParameter.Optional }
                );

            var routeInfo         = new RouteInfo();
            var defaultsProcessor = new DefaultsProcessor();

            defaultsProcessor.ProcessDefaults((Route)routes["Hello"], routeInfo);

            Assert.IsTrue(routeInfo.Optional.Contains("id"));
        }
        public static async Task <T> Patch_1_FromBodyAsync <T>(string key)
        {
            var routeInfo = new RouteInfo
            {
                HttpMethods = "PATCH",
                Path        = Patch_1_FromBody,
                Parameters  = new List <ParameterInfo>
                {
                    new ParameterInfo()
                    {
                        Name = "key", Type = "string"
                    },
                }
            };

            return(await HttpClientAsync.Async <T>(routeInfo, key));
        }
        private static IEnumerable<RouteInfo> GetRouteInfo()
        {
            var items = new List<RouteInfo>();

            foreach (var route in RouteTable.Routes.Cast<Route>())
            {
                var item = new RouteInfo { Url = route.Url };

                if (route.Defaults != null)
                {
                    foreach (var @default in route.Defaults)
                        item.Defaults.Add(@default.Key, @default.Value.ToString());
                }

                if (route.Constraints != null)
                {
                    foreach (var constraint in route.Constraints)
                    {
                        if (constraint.Value == null)
                            continue;

                        if (constraint.Value.GetType() == typeof(RestfulHttpMethodConstraint))
                            item.HttpMethod = String.Join(", ", ((RestfulHttpMethodConstraint)constraint.Value).AllowedMethods);
                        else if (constraint.Value.GetType() == typeof(RegexRouteConstraint))
                            item.Constraints.Add(constraint.Key, ((RegexRouteConstraint)constraint.Value).Pattern);
                        else
                            item.Constraints.Add(constraint.Key, constraint.Value.ToString());
                    }
                }

                if (route.DataTokens != null)
                {
                    foreach (var token in route.DataTokens)
                    {
                        if (token.Key.ValueEquals("namespaces"))
                            item.DataTokens.Add(token.Key, ((string[])token.Value).Aggregate((n1, n2) => n1 + ", " + n2));
                        else
                            item.DataTokens.Add(token.Key, token.Value.ToString());
                    }
                }

                items.Add(item);
            }

            return items;
        }
        private void BindRouteName()
        {
            RouteController  routeController = new RouteController();
            RouteCollections routeCollection = routeController.SelectList();

            RouteInfo info = new RouteInfo();

            info.RouteName = " - Select One - ";
            info.RouteID   = null;
            routeCollection.Insert(0, info);

            cboRoute.DisplayMember = "RouteName";
            cboRoute.ValueMember   = "RouteID";
            cboRoute.DataSource    = routeCollection;

            cboRoute.SelectedIndex = 0;
        }
Beispiel #23
0
        public void Delete_WithIdID_Deletes()
        {
            //arrange
            var testContext = SetupHelper.BuildTestContext();
            var controller  = new AutoAPI.RESTAPIController(testContext, null, null);
            var routeInfo   = new RouteInfo()
            {
                Entity = entityList.Where(x => x.Route == "/api/authors").First(), Id = "1"
            };

            //act
            var result = (OkObjectResult)controller.Delete(routeInfo);

            //assert
            Assert.Equal(200, result.StatusCode);
            Assert.Null(testContext.Authors.Find(1));
        }
        public static async Task <T> GetByIdAsync <T>(int id)
        {
            var routeInfo = new RouteInfo
            {
                HttpMethods = "GET",
                Path        = GetById,
                Parameters  = new List <ParameterInfo>
                {
                    new ParameterInfo()
                    {
                        Name = "id", Type = "int"
                    },
                }
            };

            return(await HttpClientAsync.Async <T>(routeInfo, id));
        }
        public ModelEndpointDataSourceReport(EndpointDataSource endpointDataSource) : base(endpointDataSource)
        {
            foreach (var endpoint in endpointDataSource.Endpoints.OrderBy(ep => (ep as RouteEndpoint)?.Order ?? -1))
            {
                var meta      = ExtractMetadata(endpoint.Metadata);
                var routeInfo = new RouteInfo()
                {
                    DisplayName  = endpoint.DisplayName,
                    Meta         = meta,
                    RoutePattern = (endpoint as RouteEndpoint)?.RoutePattern.RawText.ToString(),
                    HttpMethods  = string.Join(",", endpoint.Metadata.OfType <HttpMethodMetadata>().SelectMany(h => h.HttpMethods).Distinct())
                };

                var values = typeof(RouteInfo).GetProperties().Select(p => p.GetValue(routeInfo)?.ToString() ?? string.Empty).ToArray();
                _rows.Add(values);
            }
        }
Beispiel #26
0
        public async Task <Result <RouteInfo> > GetRouteInfoAsync(string carTagId)
        {
            FormUrlEncodedContent content = new FormUrlEncodedContentBuilder()
                                            .Add("CarTagId", carTagId)
                                            .Build();
            HttpClient          client  = NetUtils.Instance();
            HttpResponseMessage respone = await client.PostAsync(NetURL.URL_ROUTE_INFO, content);

            RouteInfo      routeInfo = null;
            ResponseResult result    = NetUtils.ExplainHttpResponce(respone);

            if (result.StateCode == 200)
            {
                routeInfo = RouteInfo.InstanceFormJson(result.Data);
            }
            return(Result <RouteInfo> .FromResponseResult(result, routeInfo));
        }
        public static async Task <T> Get_1_Nullable_ConstraintAsync <T>(int?id)
        {
            var routeInfo = new RouteInfo
            {
                HttpMethods = "GET",
                Path        = Get_1_Nullable_Constraint,
                Parameters  = new List <ParameterInfo>
                {
                    new ParameterInfo()
                    {
                        Name = "id", Type = "int?"
                    },
                }
            };

            return(await HttpClientAsync.Async <T>(routeInfo, id));
        }
Beispiel #28
0
        public void Get_WithCount_ReturnCount()
        {
            //arrange
            var controller = new AutoAPI.RESTAPIController(SetupHelper.BuildTestContext(), null, null);
            var routeInfo  = new RouteInfo()
            {
                Entity  = entityList.Where(x => x.Route == "/api/authors").First(),
                IsCount = true
            };

            //act
            var result = (OkObjectResult)controller.Get(routeInfo);

            //assert
            Assert.Equal(200, result.StatusCode.Value);
            Assert.Equal(2, (int)result.Value);
        }
        public static async Task <T> EditAsync <T>(Api.Models.PointModel model)
        {
            var routeInfo = new RouteInfo
            {
                HttpMethods = "POST",
                Path        = Edit,
                Parameters  = new List <ParameterInfo>
                {
                    new ParameterInfo()
                    {
                        Name = "model", Type = "Api.Models.PointModel"
                    },
                }
            };

            return(await HttpClientAsync.Async <T>(routeInfo, model));
        }
        public static async Task <T> Delete_1_Nullable_ParameterAsync <T>(int?id)
        {
            var routeInfo = new RouteInfo
            {
                HttpMethods = "DELETE",
                Path        = Delete_1_Nullable_Parameter,
                Parameters  = new List <ParameterInfo>
                {
                    new ParameterInfo()
                    {
                        Name = "id", Type = "int?"
                    },
                }
            };

            return(await HttpClientAsync.Async <T>(routeInfo, id));
        }
Beispiel #31
0
        private RouteInfo Create()
        {
            var route = new RouteInfo()
            {
                Name      = Guid.NewGuid().ToString("N"),
                Hosts     = new string[] { "www.konghq.com" },
                Methods   = new string[] { "GET" },
                Protocols = new string[] { "http" },
                Https_redirect_status_code = 301,
                Service = new RouteInfo.ServiceId()
                {
                    Id = TestCases.SERVICE_ID
                }
            };

            return(route);
        }
        public static async Task <T> DeleteAsync <T>(string id)
        {
            var routeInfo = new RouteInfo
            {
                HttpMethods = "DELETE",
                Path        = Delete,
                Parameters  = new List <ParameterInfo>
                {
                    new ParameterInfo()
                    {
                        Name = "id", Type = "string"
                    },
                }
            };

            return(await HttpClientAsync.Async <T>(routeInfo, id));
        }
        public static async Task <T> GetPostByEmailAsync <T>(string email)
        {
            var routeInfo = new RouteInfo
            {
                HttpMethods = "GET",
                Path        = GetPostByEmail,
                Parameters  = new List <ParameterInfo>
                {
                    new ParameterInfo()
                    {
                        Name = "email", Type = "string"
                    },
                }
            };

            return(await HttpClientAsync.Async <T>(routeInfo, email));
        }
        /// <summary>
        /// Builds a tool tip text containing the overall information generated out of all routes.
        /// </summary>
        /// <returns>Tool tip text. Returns an empty string if there is any route with an error.</returns>
        public string GetToolTip()
        {
            if (routes.Count(r => r.HasRoutePolyline) != routes.Count)
            {
                return("");
            }

            var info = new RouteInfo();

            foreach (var r in routes)
            {
                info.time     += r.RouteInfo.time;
                info.distance += r.RouteInfo.distance;
            }

            return(Route.FormatRouteToolTip(First.Label, Last.Label, info));
        }
Beispiel #35
0
    /// <summary>
    /// 時間、金額、乗り換え回数取得
    /// </summary>
    /// <param name="Info"></param>
    private RouteInfo GetElement(IEnumerable <XElement> Info)
    {
        int i  = 0;
        var rI = new RouteInfo();

        foreach (XElement el in Info)
        {
            switch (i)
            {
            case 0:
                rI.Time = el.Value;
                //Debug.Log(rI.Time);
                rI.LeftTime   = rI.Time.Remove(5);
                rI.ArriveTime = rI.Time.Remove(13).Remove(0, 8);
                if (IsDebug)
                {
                    Debug.Log("出発: " + rI.LeftTime);
                    Debug.Log("到着: " + rI.ArriveTime);
                }
                break;

            case 1:
                rI.TCount = int.Parse(el.Value.Remove(el.Value.Length - 1).Remove(0, 3));
                if (IsDebug)
                {
                    Debug.Log("乗り換え回数: " + (rI.TCount + 1));
                }
                Array.Resize(ref rI.TransTime, 2 + 2 * rI.TCount);
                break;

            case 2:
                rI.Money = int.Parse(el.Value.Remove(el.Value.Length - 1).Remove(0, 3));
                if (IsDebug)
                {
                    Debug.Log("料金: " + rI.Money);
                }
                break;

            default:
                break;
            }
            i++;
        }
        return(rI);
    }
Beispiel #36
0
        /// <summary>
        /// Function to Update values in Route Table
        /// </summary>
        /// <param name="routeinfo"></param>
        /// <returns></returns>
        public bool RouteEditing(RouteInfo routeinfo)
        {
            bool isEdit = false;

            try
            {
                if (sqlcon.State == ConnectionState.Closed)
                {
                    sqlcon.Open();
                }
                SqlCommand sccmd = new SqlCommand("RouteEditing", sqlcon);
                sccmd.CommandType = CommandType.StoredProcedure;
                SqlParameter sprmparam = new SqlParameter();
                sprmparam       = sccmd.Parameters.Add("@routeId", SqlDbType.Decimal);
                sprmparam.Value = routeinfo.RouteId;
                sprmparam       = sccmd.Parameters.Add("@routeName", SqlDbType.VarChar);
                sprmparam.Value = routeinfo.RouteName;
                sprmparam       = sccmd.Parameters.Add("@areaId", SqlDbType.Decimal);
                sprmparam.Value = routeinfo.AreaId;
                sprmparam       = sccmd.Parameters.Add("@narration", SqlDbType.VarChar);
                sprmparam.Value = routeinfo.Narration;
                sprmparam       = sccmd.Parameters.Add("@extra1", SqlDbType.VarChar);
                sprmparam.Value = routeinfo.Extra1;
                sprmparam       = sccmd.Parameters.Add("@extra2", SqlDbType.VarChar);
                sprmparam.Value = routeinfo.Extra2;
                int ina = sccmd.ExecuteNonQuery();
                if (ina > 0)
                {
                    isEdit = true;
                }
                else
                {
                    isEdit = false;
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());
            }
            finally
            {
                sqlcon.Close();
            }
            return(isEdit);
        }
Beispiel #37
0
        public void HandlesMvcControllerAndAction()
        {
            var routes = new RouteCollection();

            routes.MapRoute(
                name: "Hello",
                url: "hello/world",
                defaults: new { controller = "Hello", action = "HelloWorld" }
                );

            var routeInfo         = new RouteInfo();
            var defaultsProcessor = new DefaultsProcessor();

            defaultsProcessor.ProcessDefaults((Route)routes["Hello"], routeInfo);

            Assert.AreEqual("Hello", routeInfo.Defaults["controller"]);
            Assert.AreEqual("HelloWorld", routeInfo.Defaults["action"]);
        }
Beispiel #38
0
 bool ContainsEqualRouteInfo(ICollection <RouteInfo> routeInfoCollection, RouteInfo routeInfo, bool ignoreSelf)
 {
     foreach (var item in routeInfoCollection)
     {
         bool valuesEqual      = item.Name == routeInfo.Name && item.Order == routeInfo.Order && item.Template == routeInfo.Template;
         bool updateTypesEqual = UpdateTypeCollectionsEqual(item.UpdateTypes, routeInfo.UpdateTypes);
         bool isEqual          = valuesEqual && updateTypesEqual;
         if (isEqual)
         {
             bool isSelf = item == routeInfo;
             if (!(ignoreSelf && isSelf))
             {
                 return(true);
             }
         }
     }
     return(false);
 }
Beispiel #39
0
        public void HandlesAreas()
        {
            var routes  = new RouteCollection();
            var areaReg = new AreaRegistrationContext("Foobar", routes);

            areaReg.MapRoute(
                name: "Hello",
                url: "hello/world",
                defaults: new { controller = "Hello", action = "HelloWorld" }
                );

            var routeInfo         = new RouteInfo();
            var defaultsProcessor = new DefaultsProcessor();

            defaultsProcessor.ProcessDefaults((Route)routes["Hello"], routeInfo);

            Assert.AreEqual("Foobar", routeInfo.Defaults["area"]);
        }
Beispiel #40
0
        public ActionResult EntryToolTip(string url, string callback)
        {
            var route = new RouteInfo(new Uri(url), AppConfig.HostAddress).RouteData;
            var controller = route.Values["controller"].ToString();
            var id = int.Parse(route.Values["id"].ToString());
            string data = string.Empty;

            switch (controller) {
                case "Album":
                    data = RenderPartialViewToString("AlbumWithCoverPopupContent", Services.Albums.GetAlbum(id));
                    break;
                case "Artist":
                    data = RenderPartialViewToString("ArtistPopupContent", Services.Artists.GetArtist(id));
                    break;
            }

            return Json(data, callback);
        }
Beispiel #41
0
        public static string ExtractEndpoint(ResolvedServicePartition resolved, RouteInfo validRoute)
        {
            var resolvedEndpoints = resolved.Endpoints.First().Address;
            var rawAddress        = JsonObject.Parse(resolvedEndpoints);

            var endpoints = rawAddress["Endpoints"] as JsonObject;

            if (endpoints == null)
            {
                return(string.Empty);
            }

            var endpoint = endpoints.Count == 1
                ? endpoints.First().Value.ToString()
                : endpoints[validRoute.ListenerName] as string ?? "";

            return(endpoint);
        }
Beispiel #42
0
    /// <summary>
    /// 乗り換え番線を取得したい人生だった
    /// 現状2回以上の乗り換えに対応してません。
    /// </summary>
    /// <param name="Info"></param>
    /// <param name="rI"></param>
    /// <returns></returns>
    private void GetTLine(IEnumerable <XElement> Info, RouteInfo rI)
    {
        int i = 0;

        foreach (XElement el in Info)
        {
            if (i < 2)
            {
                //Debug.Log(el.Value.Replace(" ", "").Replace(" ", "").Replace("\n", ""));
                rI.TLine[i] = el.Value.Replace(" ", "").Replace(" ", "").Replace("\n", "");
                i++;
            }
            else
            {
                break;
            }
        }
    }
        private TreeNodeViewModel CreateRouteNode(TreeNodeViewModel parentNode, RouteInfo route)
        {
            TreeNodeViewModel node = new TreeNodeViewModel()
            {
                Parent      = parentNode,
                IsExpanded  = false,
                NodeIcon    = ROUTE_ICON,
                NodeText    = route.Name,
                NodeToolTip = route.ToString(),
                NodePayload = route
            };

            node.ContextMenuItems.Add(new MenuItemViewModel()
            {
                MenuItemHeader  = "Edit route settings",
                MenuItemIcon    = EDIT_QUEUE_ICON,
                MenuItemCommand = new RelayCommand(EditRouteCommand),
                MenuItemPayload = node
            });
            node.ContextMenuItems.Add(new MenuItemViewModel()
            {
                IsSeparator = true
            });
            node.ContextMenuItems.Add(new MenuItemViewModel()
            {
                MenuItemHeader  = "Send test message to remote queue",
                MenuItemIcon    = SEND_MESSAGE_ICON,
                MenuItemCommand = new RelayCommand(SendTestMessageCommand),
                MenuItemPayload = node
            });
            node.ContextMenuItems.Add(new MenuItemViewModel()
            {
                IsSeparator = true
            });
            node.ContextMenuItems.Add(new MenuItemViewModel()
            {
                MenuItemHeader  = "Delete route",
                MenuItemIcon    = ROUTE_ERROR_ICON,
                MenuItemCommand = new RelayCommand(DeleteRouteCommand),
                MenuItemPayload = node
            });

            return(node);
        }
        public void BuildEndpoints_InvalidPath_BubblesOutException()
        {
            // Arrange
            var builder     = Create <RuntimeRouteBuilder>();
            var parsedRoute = new ParsedRoute
            {
                RouteId  = "route1",
                Path     = "/{invalid",
                Priority = 12,
            };
            var cluster   = new ClusterInfo("cluster1", new DestinationManager(), new Mock <IProxyHttpClientFactory>().Object);
            var routeInfo = new RouteInfo("route1");

            // Act
            Action action = () => builder.Build(parsedRoute, cluster, routeInfo);

            // Assert
            Assert.Throws <AspNetCore.Routing.Patterns.RoutePatternException>(action);
        }
        protected void OnTableListingRequest(TableListingRequest listingRequest, RouteInfo routeInfo)
        {
            TableListingResponse listingResponse = new TableListingResponse();
            listingResponse.ResponseId = listingRequest.RequestId;
            listingResponse.TableSummaries = Manager.Tables.GetTableSummaries();

            ClientBoundSeverEnvelopeObject envelope = new ClientBoundSeverEnvelopeObject();
            envelope.InnerData = Manager.Serializer.GetBytes(listingResponse);
            envelope.InnerOperationCode = (int)GameMessageType.Client_ReceiveTableListingResponse;
            envelope.SenderServerId = Manager.ServerInfo.ServerId;
            envelope.PlayerNames = listingRequest.PlayerName.ToList();

            OutgoingMessage outgoingMessage = ServerMessageFormatter.CreateOutgoingMessage(
                     (int)ServerMessageType.ReceiveForwardMessageToClientRequest,
                     Manager.Serializer.GetBytes(envelope),
                     Manager.ResolveServers(routeInfo.GatewayServerId.ToList()));

            Manager.InternalOutgoingMessageQueue.Add(outgoingMessage);
        }
Beispiel #46
0
        public GisDataPump()
        {
            Task.Factory.StartNew(() =>
            {
                ril = new List<RouteInfo>();
                //read all route-files into RouteInfoObjects.
                foreach (var routeFile in Directory.GetFiles(routeDictionary, "*.json"))
                {
                    var file = new FileInfo(routeFile);
                    //Send data to client when movement is detected (or faked in this case)
                    var ri = new RouteInfo(file, (id, geodata) =>
                    {
                        this.InvokeToAll<GeoCars>(new { id, geodata },"pos");
                    });
                    ril.Add(ri);
                    var r = new Random(42);
                    ri.Start(r.Next(1000,5000));
                }

            });
        }
Beispiel #47
0
        public ActionResult EntryToolTip(string url, string callback)
        {
            if (string.IsNullOrWhiteSpace(url))
                return HttpStatusCodeResult(HttpStatusCode.BadRequest, "URL must be specified");

            var route = new RouteInfo(new Uri(url), AppConfig.HostAddress, HttpContext).RouteData;
            var controller = route.Values["controller"].ToString();
            var id = int.Parse(route.Values["id"].ToString());
            string data = string.Empty;

            switch (controller) {
                case "Album":
                    data = RenderPartialViewToString("AlbumWithCoverPopupContent", Services.Albums.GetAlbum(id));
                    break;
                case "Artist":
                    data = RenderPartialViewToString("ArtistPopupContent", Services.Artists.GetArtist(id));
                    break;
                case "Song":
                    data = RenderPartialViewToString("SongPopupContent", Services.Songs.GetSongWithPVAndVote(id));
                    break;
            }

            return Json(data, callback);
        }
        public virtual void SendEnvelopeObjectToServer(GameMessageType messageType, byte[] innerData, List<IPEndPoint> receivers, RouteInfo routeInfo)
        {
            ServerEnvelopeObject envelope = new ServerEnvelopeObject();
            envelope.InnerOperationCode = (int)messageType;
            envelope.InnerData = innerData;
            envelope.SenderServerId = ServerId;
            envelope.RouteInfo = routeInfo;

            OutgoingMessage com = ServerMessageFormatter.CreateOutgoingMessage(
                (int)ServerMessageType.ReceiveForwardedMessageFromClient,
                Serializer.GetBytes(envelope),
                receivers);

            InternalOutgoingMessageQueue.Add(com);
        }
 /// <summary>
 /// creating a default route under the creating area
 /// </summary>
 public void RouteNACreateUnderTheArea()
 {
     try
     {
         RouteBll BllRoute = new RouteBll();
         RouteInfo infoRoute = new RouteInfo();
         infoRoute.RouteName = "NA";
         infoRoute.AreaId = decAreaId;
         infoRoute.Narration = txtNarration.Text.Trim();
         infoRoute.Extra1 = string.Empty;
         infoRoute.Extra2 = string.Empty;
         infoRoute.ExtraDate = DateTime.Today;
         BllRoute.RouteAdd(infoRoute);
     }
     catch (Exception ex)
     {
         MessageBox.Show("AR2" + ex.Message, "OpenMiracle", MessageBoxButtons.OK, MessageBoxIcon.Information);
     }
 }
        public void RouteInfoEqualityTest()
        {
            RouteInfo r1, r2;
            // Test two values that should be equal.
            r1 = new RouteInfo
            {
                Name = "005",
                LrsTypes = LrsTypes.Both
            };

            r2 = new RouteInfo
            {
                Name = "005",
                LrsTypes = LrsTypes.Both
            };

            Assert.AreEqual<RouteInfo>(r1, r2, "{0} should equal {1}.", r1, r2);

            r2.LrsTypes = LrsTypes.Decrease;

            Assert.AreNotEqual<RouteInfo>(r1, r2, "{0} should not equal {1}", r1, r2);
        }
 /// <summary>
 /// Function to save the new route
 /// </summary>
 public void SaveFunction()
 {
     try
     {
         RouteBll BllRoute = new RouteBll();
         RouteInfo infoRoute = new RouteInfo();
         infoRoute.RouteName = txtRouteName.Text.Trim();
         infoRoute.AreaId = Convert.ToDecimal(cmbArea.SelectedValue.ToString());
         infoRoute.Narration = txtNarration.Text.Trim();
         infoRoute.Extra1 = String.Empty;
         infoRoute.Extra2 = String.Empty;
         if (BllRoute.RouteCheckExistence(txtRouteName.Text.Trim(), 0, Convert.ToDecimal(cmbArea.SelectedValue.ToString())) == false)
         {
             decRoute = BllRoute.RouteAddParticularFields(infoRoute);
             {
                 Messages.SavedMessage();
                 Clear();
                 GridFill();
                 if (frmCustomerobj != null)
                 {
                     this.Close();
                 }
             }
         }
         else
         {
             Messages.InformationMessage(" Route name already exist");
             txtRouteName.Focus();
         }
     }
     catch (Exception ex)
     {
         MessageBox.Show("RT4" + ex.Message, "OpenMiracle", MessageBoxButtons.OK, MessageBoxIcon.Information);
     }
 }
 public RouteSummary(RouteInfo routeInfo, string helpModulePath)
 {
     _helpModulePath = RouteInfo.CleanPath(helpModulePath);
     Name = RouteInfo.CleanPath(routeInfo.Name);
     HttpMethod = routeInfo.HttpMethod;
 }
Beispiel #53
0
        private static RouteInfo GetRouteInfo(
            IInlineConstraintResolver constraintResolver,
            Dictionary<string, RouteTemplate> templateCache,
            ActionDescriptor action)
        {
            var constraint = action.RouteConstraints
                .Where(c => c.RouteKey == AttributeRouting.RouteGroupKey)
                .FirstOrDefault();
            if (constraint == null ||
                constraint.KeyHandling != RouteKeyHandling.RequireKey ||
                constraint.RouteValue == null)
            {
                // This can happen if an ActionDescriptor has a route template, but doesn't have one of our
                // special route group constraints. This is a good indication that the user is using a 3rd party
                // routing system, or has customized their ADs in a way that we can no longer understand them.
                //
                // We just treat this case as an 'opt-out' of our attribute routing system.
                return null;
            }

            var routeInfo = new RouteInfo()
            {
                ActionDescriptor = action,
                RouteGroup = constraint.RouteValue,
                RouteTemplate = action.AttributeRouteInfo.Template,
            };

            try
            {
                RouteTemplate parsedTemplate;
                if (!templateCache.TryGetValue(action.AttributeRouteInfo.Template, out parsedTemplate))
                {
                    // Parsing with throw if the template is invalid.
                    parsedTemplate = TemplateParser.Parse(action.AttributeRouteInfo.Template);
                    templateCache.Add(action.AttributeRouteInfo.Template, parsedTemplate);
                }

                routeInfo.ParsedTemplate = parsedTemplate;
            }
            catch (Exception ex)
            {
                routeInfo.ErrorMessage = ex.Message;
                return routeInfo;
            }

            foreach (var kvp in action.RouteValueDefaults)
            {
                foreach (var parameter in routeInfo.ParsedTemplate.Parameters)
                {
                    if (string.Equals(kvp.Key, parameter.Name, StringComparison.OrdinalIgnoreCase))
                    {
                        routeInfo.ErrorMessage = Resources.FormatAttributeRoute_CannotContainParameter(
                            routeInfo.RouteTemplate,
                            kvp.Key,
                            kvp.Value);

                        return routeInfo;
                    }
                }
            }

            routeInfo.Order = action.AttributeRouteInfo.Order;

            routeInfo.Precedence = AttributeRoutePrecedence.Compute(routeInfo.ParsedTemplate);

            routeInfo.Name = action.AttributeRouteInfo.Name;

            var constraintBuilder = new RouteConstraintBuilder(constraintResolver, routeInfo.RouteTemplate);

            foreach (var parameter in routeInfo.ParsedTemplate.Parameters)
            {
                if (parameter.InlineConstraints != null)
                {
                    if (parameter.IsOptional)
                    {
                        constraintBuilder.SetOptional(parameter.Name);
                    }

                    foreach (var inlineConstraint in parameter.InlineConstraints)
                    {
                        constraintBuilder.AddResolvedConstraint(parameter.Name, inlineConstraint.Constraint);
                    }
                }
            }

            routeInfo.Constraints = constraintBuilder.Build();

            routeInfo.Defaults = routeInfo.ParsedTemplate.Parameters
                .Where(p => p.DefaultValue != null)
                .ToDictionary(p => p.Name, p => p.DefaultValue, StringComparer.OrdinalIgnoreCase);

            return routeInfo;
        }
Beispiel #54
0
        public static RouteInfo ToRouteInfo(this ConnectionRecord record, string gatewayServerId)
        {
            RouteInfo routeInfo = new RouteInfo();
            routeInfo.GatewayServerId = gatewayServerId;
            routeInfo.GameServerId = record.GameServerId;
            routeInfo.TableId = record.TableId;

            return routeInfo;
        }
        protected void OnJoinTableRequestReceived(JoinTableRequest jtr, RouteInfo routeInfo)
        {
            var myEvent = JoinTableRequestReceived;

            if (myEvent != null)
            {
                myEvent(this, new JoinTableEventArgs(jtr, routeInfo));
            }
        }
        /// <summary>
        /// On double clicking on the datagridview, It displays the details of the rack to edit or delete
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void dgvRoute_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
        {
            try
            {
                if (e.RowIndex != -1)
                {
                    if (dgvRoute.Rows[e.RowIndex].Cells["dgvtxtRouteName"].Value.ToString() != "NA")
                    {
                        RouteBll BllRoute = new RouteBll();
                        RouteInfo infoRoute = new RouteInfo();
                        infoRoute = BllRoute.RouteView(Convert.ToDecimal(dgvRoute.CurrentRow.Cells["dgvtxtRouteId"].Value.ToString()));
                        decRouteId = Convert.ToDecimal(dgvRoute.CurrentRow.Cells["dgvtxtRouteId"].Value.ToString());
                        txtRouteName.Text = infoRoute.RouteName;
                        cmbArea.SelectedValue = infoRoute.AreaId.ToString();
                        txtNarration.Text = infoRoute.Narration;
                        btnSave.Text = "Update";
                        btnDelete.Enabled = true;
                        txtRouteName.Focus();

                    }
                    else
                    {
                        Messages.InformationMessage("Default Route cannot update or delete");
                        Clear();
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("RT19" + ex.Message, "OpenMiracle", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
 public static void Map(this RouteCollection collection, RouteInfo rootRoute)
 {
     foreach (RouteInfo ri in rootRoute.TreeStructureToList())
         collection.MapPageRoute(ri.GetRouteName(), ri.GetRouteUrl(), string.Empty);
 }
        public JoinTableEventArgs(JoinTableRequest request, RouteInfo routeInfo)
        {
            Request = request;

            RouteInfo = routeInfo;
        }
        private RouteCost RequestRouteCost(RouteType routeType)
        {
            _routeDetails = new RouteDetails();
            _routeDetails.descriptionType = Config.DesciptionType;
            _routeDetails.optimizeRoute = true;
            _routeDetails.routeType = Convert.ToInt32(routeType);

            _routeOptions.routeDetails = _routeDetails;

            using (var routeSoapClient = new RouteSoapClient())
            {
                _routeInfo = routeSoapClient.getRoute(GenerateRouteStop(), _routeOptions, _token);
            }

            return new RouteCost
            {
                TotalDistance = _routeInfo.routeTotals.totalDistance,
                TotalFuelCost = _routeInfo.routeTotals.totalfuelCost,
                TotalCostWithToll = _routeInfo.routeTotals.totalCost,
                TotalTimeRote = _routeInfo.routeTotals.totalTime
            };
        }
 /// <summary>
 /// Function to edit already existing route
 /// </summary>
 public void EditFunction()
 {
     try
     {
         RouteBll BllRoute = new RouteBll();
         RouteInfo infoRoute = new RouteInfo();
         infoRoute.RouteName = txtRouteName.Text.Trim();
         infoRoute.AreaId = Convert.ToDecimal(cmbArea.SelectedValue.ToString());
         infoRoute.Narration = txtNarration.Text.Trim();
         infoRoute.Extra1 = String.Empty;
         infoRoute.Extra2 = String.Empty;
         infoRoute.RouteId = decRouteId;
         if (BllRoute.RouteCheckExistence(txtRouteName.Text.Trim(), decRouteId, Convert.ToDecimal(cmbArea.SelectedValue.ToString())) == false)
         {
             if (BllRoute.RouteEditing(infoRoute))
             {
                 Messages.UpdatedMessage();
                 GridFill();
                 Clear();
             }
             else if (infoRoute.RouteId == 1)
             {
                 Messages.InformationMessage("Cannot update");
                 Clear();
                 txtRouteName.Focus();
             }
         }
         else
         {
             Messages.InformationMessage(" Route name already exist");
             txtRouteName.Focus();
         }
     }
     catch (Exception ex)
     {
         MessageBox.Show("RT5" + ex.Message, "OpenMiracle", MessageBoxButtons.OK, MessageBoxIcon.Information);
     }
 }