/// <summary> /// Removes all keys but controller and action /// </summary> public static RouteValueDictionary PurgeQueryString(this RouteValueDictionary routeValueDict) { var copy = new RouteValueDictionary(routeValueDict); foreach (var item in routeValueDict) { if (item.Key != MvcConstants.ControllerRouteValueKey && item.Key != MvcConstants.ActionRouteValueKey) { copy.Remove(item.Key); } } return(copy); }
public string BuildUrl(Route route, RequestContext requestContext, RouteValueDictionary userValues, RouteValueDictionary constraints, out RouteValueDictionary usedValues) { usedValues = null; if (requestContext == null) { return(null); } RouteData routeData = requestContext.RouteData; var currentValues = routeData.Values ?? new RouteValueDictionary(); var values = userValues ?? new RouteValueDictionary(); var defaultValues = (route != null ? route.Defaults : null) ?? new RouteValueDictionary(); // The set of values we should be using when generating the URL in this route var acceptedValues = new RouteValueDictionary(); // Keep track of which new values have been used HashSet <string> unusedNewValues = new HashSet <string> (values.Keys, StringComparer.OrdinalIgnoreCase); // This route building logic is based on System.Web.Http's Routing code (which is Apache Licensed by MS) // and which can be found at mono's external/aspnetwebstack/src/System.Web.Http/Routing/HttpParsedRoute.cs // Hopefully this will ensure a much higher compatiblity with MS.NET's System.Web.Routing logic. (pruiz) #region Step 1: Get the list of values we're going to use to match and generate this URL // Find out which entries in the URL are valid for the URL we want to generate. // If the URL had ordered parameters a="1", b="2", c="3" and the new values // specified that b="9", then we need to invalidate everything after it. The new // values should then be a="1", b="9", c=<no value>. foreach (var item in parameterNames) { var parameterName = item.Key; object newParameterValue; bool hasNewParameterValue = values.TryGetValue(parameterName, out newParameterValue); if (hasNewParameterValue) { unusedNewValues.Remove(parameterName); } object currentParameterValue; bool hasCurrentParameterValue = currentValues.TryGetValue(parameterName, out currentParameterValue); if (hasNewParameterValue && hasCurrentParameterValue) { if (!ParametersAreEqual(currentParameterValue, newParameterValue)) { // Stop copying current values when we find one that doesn't match break; } } // If the parameter is a match, add it to the list of values we will use for URL generation if (hasNewParameterValue) { if (ParameterIsNonEmpty(newParameterValue)) { acceptedValues.Add(parameterName, newParameterValue); } } else { if (hasCurrentParameterValue) { acceptedValues.Add(parameterName, currentParameterValue); } } } // Add all remaining new values to the list of values we will use for URL generation foreach (var newValue in values) { if (ParameterIsNonEmpty(newValue.Value) && !acceptedValues.ContainsKey(newValue.Key)) { acceptedValues.Add(newValue.Key, newValue.Value); } } // Add all current values that aren't in the URL at all foreach (var currentValue in currentValues) { if (!acceptedValues.ContainsKey(currentValue.Key) && !parameterNames.ContainsKey(currentValue.Key)) { acceptedValues.Add(currentValue.Key, currentValue.Value); } } // Add all remaining default values from the route to the list of values we will use for URL generation foreach (var item in parameterNames) { object defaultValue; if (!acceptedValues.ContainsKey(item.Key) && !IsParameterRequired(item.Key, defaultValues, out defaultValue)) { // Add the default value only if there isn't already a new value for it and // only if it actually has a default value, which we determine based on whether // the parameter value is required. acceptedValues.Add(item.Key, defaultValue); } } // All required parameters in this URL must have values from somewhere (i.e. the accepted values) foreach (var item in parameterNames) { object defaultValue; if (IsParameterRequired(item.Key, defaultValues, out defaultValue) && !acceptedValues.ContainsKey(item.Key)) { // If the route parameter value is required that means there's // no default value, so if there wasn't a new value for it // either, this route won't match. return(null); } } // All other default values must match if they are explicitly defined in the new values var otherDefaultValues = new RouteValueDictionary(defaultValues); foreach (var item in parameterNames) { otherDefaultValues.Remove(item.Key); } foreach (var defaultValue in otherDefaultValues) { object value; if (values.TryGetValue(defaultValue.Key, out value)) { unusedNewValues.Remove(defaultValue.Key); if (!ParametersAreEqual(value, defaultValue.Value)) { // If there is a non-parameterized value in the route and there is a // new value for it and it doesn't match, this route won't match. return(null); } } } #endregion #region Step 2: If the route is a match generate the appropriate URL var uri = new StringBuilder(); var pendingParts = new StringBuilder(); var pendingPartsAreAllSafe = false; bool blockAllUriAppends = false; var allSegments = new List <PatternSegment?> (); // Build a list of segments plus separators we can use as template. foreach (var segment in segments) { if (allSegments.Count > 0) { allSegments.Add(null); // separator exposed as null. } allSegments.Add(segment); } // Finally loop thru al segment-templates building the actual uri. foreach (var item in allSegments) { var segment = item.GetValueOrDefault(); // If segment is a separator.. if (item == null) { if (pendingPartsAreAllSafe) { // Accept if (pendingParts.Length > 0) { if (blockAllUriAppends) { return(null); } // Append any pending literals to the URL uri.Append(pendingParts.ToString()); pendingParts.Length = 0; } } pendingPartsAreAllSafe = false; // Guard against appending multiple separators for empty segments if (pendingParts.Length > 0 && pendingParts[pendingParts.Length - 1] == '/') { // Dev10 676725: Route should not be matched if that causes mismatched tokens // Dev11 86819: We will allow empty matches if all subsequent segments are null if (blockAllUriAppends) { return(null); } // Append any pending literals to the URI (without the trailing slash) and prevent any future appends uri.Append(pendingParts.ToString(0, pendingParts.Length - 1)); pendingParts.Length = 0; } else { pendingParts.Append("/"); } #if false } else if (segment.AllLiteral) { // Spezial (optimized) case: all elements of segment are literals. pendingPartsAreAllSafe = true; foreach (var tk in segment.Tokens) { pendingParts.Append(tk.Name); } #endif } else { // Segments are treated as all-or-none. We should never output a partial segment. // If we add any subsegment of this segment to the generated URL, we have to add // the complete match. For example, if the subsegment is "{p1}-{p2}.xml" and we // used a value for {p1}, we have to output the entire segment up to the next "/". // Otherwise we could end up with the partial segment "v1" instead of the entire // segment "v1-v2.xml". bool addedAnySubsegments = false; foreach (var token in segment.Tokens) { if (token.Type == PatternTokenType.Literal) { // If it's a literal we hold on to it until we are sure we need to add it pendingPartsAreAllSafe = true; pendingParts.Append(token.Name); } else { if (token.Type == PatternTokenType.Standard || token.Type == PatternTokenType.CatchAll) { if (pendingPartsAreAllSafe) { // Accept if (pendingParts.Length > 0) { if (blockAllUriAppends) { return(null); } // Append any pending literals to the URL uri.Append(pendingParts.ToString()); pendingParts.Length = 0; addedAnySubsegments = true; } } pendingPartsAreAllSafe = false; // If it's a parameter, get its value object acceptedParameterValue; bool hasAcceptedParameterValue = acceptedValues.TryGetValue(token.Name, out acceptedParameterValue); if (hasAcceptedParameterValue) { unusedNewValues.Remove(token.Name); } object defaultParameterValue; defaultValues.TryGetValue(token.Name, out defaultParameterValue); if (ParametersAreEqual(acceptedParameterValue, defaultParameterValue)) { // If the accepted value is the same as the default value, mark it as pending since // we won't necessarily add it to the URL we generate. pendingParts.Append(Convert.ToString(acceptedParameterValue, CultureInfo.InvariantCulture)); } else { if (blockAllUriAppends) { return(null); } // Add the new part to the URL as well as any pending parts if (pendingParts.Length > 0) { // Append any pending literals to the URL uri.Append(pendingParts.ToString()); pendingParts.Length = 0; } uri.Append(Convert.ToString(acceptedParameterValue, CultureInfo.InvariantCulture)); addedAnySubsegments = true; } } else { Debug.Fail("Invalid path subsegment type"); } } } if (addedAnySubsegments) { // See comment above about why we add the pending parts if (pendingParts.Length > 0) { if (blockAllUriAppends) { return(null); } // Append any pending literals to the URL uri.Append(pendingParts.ToString()); pendingParts.Length = 0; } } } } if (pendingPartsAreAllSafe) { // Accept if (pendingParts.Length > 0) { if (blockAllUriAppends) { return(null); } // Append any pending literals to the URI uri.Append(pendingParts.ToString()); } } // Process constraints keys if (constraints != null) { // If there are any constraints, mark all the keys as being used so that we don't // generate query string items for custom constraints that don't appear as parameters // in the URI format. foreach (var constraintsItem in constraints) { unusedNewValues.Remove(constraintsItem.Key); } } // Encode the URI before we append the query string, otherwise we would double encode the query string var encodedUri = new StringBuilder(); encodedUri.Append(UriEncode(uri.ToString())); uri = encodedUri; // Add remaining new values as query string parameters to the URI if (unusedNewValues.Count > 0) { // Generate the query string bool firstParam = true; foreach (string unusedNewValue in unusedNewValues) { object value; if (acceptedValues.TryGetValue(unusedNewValue, out value)) { uri.Append(firstParam ? '?' : '&'); firstParam = false; uri.Append(Uri.EscapeDataString(unusedNewValue)); uri.Append('='); uri.Append(Uri.EscapeDataString(Convert.ToString(value, CultureInfo.InvariantCulture))); } } } #endregion usedValues = acceptedValues; return(uri.ToString()); }
public BoundUrl Bind(RouteValueDictionary currentValues, RouteValueDictionary values, RouteValueDictionary defaultValues, RouteValueDictionary constraints) { if (currentValues == null) { currentValues = new RouteValueDictionary(); } if (values == null) { values = new RouteValueDictionary(); } if (defaultValues == null) { defaultValues = new RouteValueDictionary(); } RouteValueDictionary acceptedValues = new RouteValueDictionary(); HashSet <string> unusedNewValues = new HashSet <string>(values.Keys, StringComparer.OrdinalIgnoreCase); ForEachParameter(this.PathSegments, delegate(ParameterSubsegment parameterSubsegment) { object obj2; object obj3; string key = parameterSubsegment.ParameterName; bool flag = values.TryGetValue(key, out obj2); if (flag) { unusedNewValues.Remove(key); } bool flag2 = currentValues.TryGetValue(key, out obj3); if ((flag && flag2) && !RoutePartsEqual(obj3, obj2)) { return(false); } if (flag) { if (IsRoutePartNonEmpty(obj2)) { acceptedValues.Add(key, obj2); } } else if (flag2) { acceptedValues.Add(key, obj3); } return(true); }); foreach (KeyValuePair <string, object> pair in values) { if (IsRoutePartNonEmpty(pair.Value) && !acceptedValues.ContainsKey(pair.Key)) { acceptedValues.Add(pair.Key, pair.Value); } } foreach (KeyValuePair <string, object> pair2 in currentValues) { string str = pair2.Key; if (!acceptedValues.ContainsKey(str) && (GetParameterSubsegment(this.PathSegments, str) == null)) { acceptedValues.Add(str, pair2.Value); } } ForEachParameter(this.PathSegments, delegate(ParameterSubsegment parameterSubsegment) { object obj2; if (!acceptedValues.ContainsKey(parameterSubsegment.ParameterName) && !IsParameterRequired(parameterSubsegment, defaultValues, out obj2)) { acceptedValues.Add(parameterSubsegment.ParameterName, obj2); } return(true); }); if (!ForEachParameter(this.PathSegments, delegate(ParameterSubsegment parameterSubsegment) { object obj2; if (IsParameterRequired(parameterSubsegment, defaultValues, out obj2) && !acceptedValues.ContainsKey(parameterSubsegment.ParameterName)) { return(false); } return(true); })) { return(null); } RouteValueDictionary otherDefaultValues = new RouteValueDictionary(defaultValues); ForEachParameter(this.PathSegments, delegate(ParameterSubsegment parameterSubsegment) { otherDefaultValues.Remove(parameterSubsegment.ParameterName); return(true); }); foreach (KeyValuePair <string, object> pair3 in otherDefaultValues) { object obj2; if (values.TryGetValue(pair3.Key, out obj2)) { unusedNewValues.Remove(pair3.Key); if (!RoutePartsEqual(obj2, pair3.Value)) { return(null); } } } StringBuilder builder = new StringBuilder(); StringBuilder builder2 = new StringBuilder(); bool flag2 = false; for (int i = 0; i < this.PathSegments.Count; i++) { PathSegment segment = this.PathSegments[i]; if (segment is SeparatorPathSegment) { if (flag2 && (builder2.Length > 0)) { builder.Append(builder2.ToString()); builder2.Length = 0; } flag2 = false; if ((builder2.Length > 0) && (builder2[builder2.Length - 1] == '/')) { return(null); } builder2.Append("/"); } else { ContentPathSegment segment2 = segment as ContentPathSegment; if (segment2 != null) { bool flag3 = false; foreach (PathSubsegment subsegment2 in segment2.Subsegments) { LiteralSubsegment subsegment3 = subsegment2 as LiteralSubsegment; if (subsegment3 != null) { flag2 = true; builder2.Append(UrlEncode(subsegment3.Literal)); } else { ParameterSubsegment subsegment4 = subsegment2 as ParameterSubsegment; if (subsegment4 != null) { object obj3; object obj4; if (flag2 && (builder2.Length > 0)) { builder.Append(builder2.ToString()); builder2.Length = 0; flag3 = true; } flag2 = false; if (acceptedValues.TryGetValue(subsegment4.ParameterName, out obj3)) { unusedNewValues.Remove(subsegment4.ParameterName); } defaultValues.TryGetValue(subsegment4.ParameterName, out obj4); if (RoutePartsEqual(obj3, obj4)) { builder2.Append(UrlEncode(Convert.ToString(obj3, CultureInfo.InvariantCulture))); } else { if (builder2.Length > 0) { builder.Append(builder2.ToString()); builder2.Length = 0; } builder.Append(UrlEncode(Convert.ToString(obj3, CultureInfo.InvariantCulture))); flag3 = true; } } } } if (flag3 && (builder2.Length > 0)) { builder.Append(builder2.ToString()); builder2.Length = 0; } } } } if (flag2 && (builder2.Length > 0)) { builder.Append(builder2.ToString()); } if (constraints != null) { foreach (KeyValuePair <string, object> pair4 in constraints) { unusedNewValues.Remove(pair4.Key); } } if (unusedNewValues.Count > 0) { bool flag5 = true; foreach (string str2 in unusedNewValues) { object obj5; if (acceptedValues.TryGetValue(str2, out obj5)) { builder.Append(flag5 ? '?' : '&'); flag5 = false; builder.Append(Uri.EscapeDataString(str2)); builder.Append('='); builder.Append(Uri.EscapeDataString(Convert.ToString(obj5, CultureInfo.InvariantCulture))); } } } return(new BoundUrl { Url = builder.ToString(), Values = acceptedValues }); }
public BoundUrl Bind(RouteValueDictionary currentValues, RouteValueDictionary values, RouteValueDictionary defaultValues, RouteValueDictionary constraints) { if (currentValues == null) { currentValues = new RouteValueDictionary(); } if (values == null) { values = new RouteValueDictionary(); } if (defaultValues == null) { defaultValues = new RouteValueDictionary(); } // The set of values we should be using when generating the URL in this route RouteValueDictionary acceptedValues = new RouteValueDictionary(); // Keep track of which new values have been used HashSet <string> unusedNewValues = new HashSet <string>(values.Keys, StringComparer.OrdinalIgnoreCase); // Step 1: Get the list of values we're going to try to use to match and generate this URL // Find out which entries in the URL are valid for the URL we want to generate. // If the URL had ordered parameters a="1", b="2", c="3" and the new values // specified that b="9", then we need to invalidate everything after it. The new // values should then be a="1", b="9", c=<no value>. ForEachParameter(PathSegments, delegate(ParameterSubsegment parameterSubsegment) { // If it's a parameter subsegment, examine the current value to see if it matches the new value string parameterName = parameterSubsegment.ParameterName; object newParameterValue; bool hasNewParameterValue = values.TryGetValue(parameterName, out newParameterValue); if (hasNewParameterValue) { unusedNewValues.Remove(parameterName); } object currentParameterValue; bool hasCurrentParameterValue = currentValues.TryGetValue(parameterName, out currentParameterValue); if (hasNewParameterValue && hasCurrentParameterValue) { if (!RoutePartsEqual(currentParameterValue, newParameterValue)) { // Stop copying current values when we find one that doesn't match return(false); } } // If the parameter is a match, add it to the list of values we will use for URL generation if (hasNewParameterValue) { if (IsRoutePartNonEmpty(newParameterValue)) { acceptedValues.Add(parameterName, newParameterValue); } } else { if (hasCurrentParameterValue) { acceptedValues.Add(parameterName, currentParameterValue); } } return(true); }); // Add all remaining new values to the list of values we will use for URL generation foreach (var newValue in values) { if (IsRoutePartNonEmpty(newValue.Value)) { if (!acceptedValues.ContainsKey(newValue.Key)) { acceptedValues.Add(newValue.Key, newValue.Value); } } } // Add all current values that aren't in the URL at all foreach (var currentValue in currentValues) { string parameterName = currentValue.Key; if (!acceptedValues.ContainsKey(parameterName)) { ParameterSubsegment parameterSubsegment = GetParameterSubsegment(PathSegments, parameterName); if (parameterSubsegment == null) { acceptedValues.Add(parameterName, currentValue.Value); } } } // Add all remaining default values from the route to the list of values we will use for URL generation ForEachParameter(PathSegments, delegate(ParameterSubsegment parameterSubsegment) { if (!acceptedValues.ContainsKey(parameterSubsegment.ParameterName)) { object defaultValue; if (!IsParameterRequired(parameterSubsegment, defaultValues, out defaultValue)) { // Add the default value only if there isn't already a new value for it and // only if it actually has a default value, which we determine based on whether // the parameter value is required. acceptedValues.Add(parameterSubsegment.ParameterName, defaultValue); } } return(true); }); // All required parameters in this URL must have values from somewhere (i.e. the accepted values) bool hasAllRequiredValues = ForEachParameter(PathSegments, delegate(ParameterSubsegment parameterSubsegment) { object defaultValue; if (IsParameterRequired(parameterSubsegment, defaultValues, out defaultValue)) { if (!acceptedValues.ContainsKey(parameterSubsegment.ParameterName)) { // If the route parameter value is required that means there's // no default value, so if there wasn't a new value for it // either, this route won't match. return(false); } } return(true); }); if (!hasAllRequiredValues) { return(null); } // All other default values must match if they are explicitly defined in the new values RouteValueDictionary otherDefaultValues = new RouteValueDictionary(defaultValues); ForEachParameter(PathSegments, delegate(ParameterSubsegment parameterSubsegment) { otherDefaultValues.Remove(parameterSubsegment.ParameterName); return(true); }); foreach (var defaultValue in otherDefaultValues) { object value; if (values.TryGetValue(defaultValue.Key, out value)) { unusedNewValues.Remove(defaultValue.Key); if (!RoutePartsEqual(value, defaultValue.Value)) { // If there is a non-parameterized value in the route and there is a // new value for it and it doesn't match, this route won't match. return(null); } } } // Step 2: If the route is a match generate the appropriate URL StringBuilder url = new StringBuilder(); StringBuilder pendingParts = new StringBuilder(); bool pendingPartsAreAllSafe = false; bool blockAllUrlAppends = false; for (int i = 0; i < PathSegments.Count; i++) { PathSegment pathSegment = PathSegments[i]; // parsedRouteUrlPart if (pathSegment is SeparatorPathSegment) { if (pendingPartsAreAllSafe) { // Accept if (pendingParts.Length > 0) { if (blockAllUrlAppends) { return(null); } // Append any pending literals to the URL url.Append(pendingParts.ToString()); pendingParts.Length = 0; } } pendingPartsAreAllSafe = false; // Guard against appending multiple separators for empty segements if (pendingParts.Length > 0 && pendingParts[pendingParts.Length - 1] == '/') { // Dev10 676725: Route should not be matched if that causes mismatched tokens // Dev11 86819: We will allow empty matches if all subsequent segments are null if (blockAllUrlAppends) { return(null); } // Append any pending literals to the URL(without the trailing slash) and prevent any future appends url.Append(pendingParts.ToString(0, pendingParts.Length - 1)); pendingParts.Length = 0; blockAllUrlAppends = true; } else { pendingParts.Append("/"); } } else { ContentPathSegment contentPathSegment = pathSegment as ContentPathSegment; if (contentPathSegment != null) { // Segments are treated as all-or-none. We should never output a partial segment. // If we add any subsegment of this segment to the generated URL, we have to add // the complete match. For example, if the subsegment is "{p1}-{p2}.xml" and we // used a value for {p1}, we have to output the entire segment up to the next "/". // Otherwise we could end up with the partial segment "v1" instead of the entire // segment "v1-v2.xml". bool addedAnySubsegments = false; foreach (PathSubsegment subsegment in contentPathSegment.Subsegments) { LiteralSubsegment literalSubsegment = subsegment as LiteralSubsegment; if (literalSubsegment != null) { // If it's a literal we hold on to it until we are sure we need to add it pendingPartsAreAllSafe = true; pendingParts.Append(UrlEncode(literalSubsegment.Literal)); } else { ParameterSubsegment parameterSubsegment = subsegment as ParameterSubsegment; if (parameterSubsegment != null) { if (pendingPartsAreAllSafe) { // Accept if (pendingParts.Length > 0) { if (blockAllUrlAppends) { return(null); } // Append any pending literals to the URL url.Append(pendingParts.ToString()); pendingParts.Length = 0; addedAnySubsegments = true; } } pendingPartsAreAllSafe = false; // If it's a parameter, get its value object acceptedParameterValue; bool hasAcceptedParameterValue = acceptedValues.TryGetValue(parameterSubsegment.ParameterName, out acceptedParameterValue); if (hasAcceptedParameterValue) { unusedNewValues.Remove(parameterSubsegment.ParameterName); } object defaultParameterValue; defaultValues.TryGetValue(parameterSubsegment.ParameterName, out defaultParameterValue); if (RoutePartsEqual(acceptedParameterValue, defaultParameterValue)) { // If the accepted value is the same as the default value, mark it as pending since // we won't necessarily add it to the URL we generate. pendingParts.Append(UrlEncode(Convert.ToString(acceptedParameterValue, CultureInfo.InvariantCulture))); } else { if (blockAllUrlAppends) { return(null); } // Add the new part to the URL as well as any pending parts if (pendingParts.Length > 0) { // Append any pending literals to the URL url.Append(pendingParts.ToString()); pendingParts.Length = 0; } url.Append(UrlEncode(Convert.ToString(acceptedParameterValue, CultureInfo.InvariantCulture))); addedAnySubsegments = true; } } else { Debug.Fail("Invalid path subsegment type"); } } } if (addedAnySubsegments) { // See comment above about why we add the pending parts if (pendingParts.Length > 0) { if (blockAllUrlAppends) { return(null); } // Append any pending literals to the URL url.Append(pendingParts.ToString()); pendingParts.Length = 0; } } } else { Debug.Fail("Invalid path segment type"); } } } if (pendingPartsAreAllSafe) { // Accept if (pendingParts.Length > 0) { if (blockAllUrlAppends) { return(null); } // Append any pending literals to the URL url.Append(pendingParts.ToString()); } } // Process constraints keys if (constraints != null) { // If there are any constraints, mark all the keys as being used so that we don't // generate query string items for custom constraints that don't appear as parameters // in the URL format. foreach (var constraintsItem in constraints) { unusedNewValues.Remove(constraintsItem.Key); } } // Add remaining new values as query string parameters to the URL if (unusedNewValues.Count > 0) { // Generate the query string bool firstParam = true; foreach (string unusedNewValue in unusedNewValues) { object value; if (acceptedValues.TryGetValue(unusedNewValue, out value)) { url.Append(firstParam ? '?' : '&'); firstParam = false; url.Append(Uri.EscapeDataString(unusedNewValue)); url.Append('='); url.Append(Uri.EscapeDataString(Convert.ToString(value, CultureInfo.InvariantCulture))); } } } return(new BoundUrl { Url = url.ToString(), Values = acceptedValues }); }