public Data.PagedDataRequest Create(Uri requestUri) { int? pageNumber; int? pageSize; try { var valueCollection = requestUri.ParseQueryString(); pageNumber = PrimitiveTypeParser.Parse<int?>(valueCollection[Constants.CommonParameterNames.PageNumber]); pageSize = PrimitiveTypeParser.Parse<int?>(valueCollection[Constants.CommonParameterNames.PageSize]); } catch(Exception e) { _log.Error("Error Parsing input", e); throw new HttpException((int)HttpStatusCode.BadRequest, e.Message); } pageNumber = pageNumber.GetBoundedValue(Constants.Paging.DefaultPageNumber, Constants.Paging.MinPageNumber); pageSize = pageSize.GetBoundedValue(DefaultPageSize, Constants.Paging.MinPageSize, MaxPageSize); return new PagedDataRequest(pageNumber.Value, pageSize.Value); }
public static Response Execute(Uri url, Func<ISchedulerWrapper> getScheduler) { var scheduler = getScheduler(); var p = GetMethodParameters(url.ParseQueryString()); p.method.Invoke(scheduler, p.parameters.ToArray()); return new Response.RedirectResponse(p.redirect); }
public static Response Execute(Uri url) { var querystring = url.ParseQueryString(); var resource = querystring["r"]; resource = string.Format("{0}.Resources.{1}", assembly.FullName.Split(',')[0], resource); var content = ReadResource(resource); return new Response.ContentResponse(content: content, contentType: querystring["t"]); }
private void SelectedCurrencyLinkChanged(Uri link) { string currencyName; link.ParseQueryString().TryGetValue("Name", out currencyName); var selectedCurrency = _context.Currencies.FirstOrDefault(x => x.Name == currencyName); if (selectedCurrency != null) Messenger.Default.Send(selectedCurrency, "currencyChangedMsg"); }
public virtual MvxShowViewModelRequest GetRequestFromXamlUri(Uri viewUri) { var parsed = viewUri.ParseQueryString(); string queryString; if (!parsed.TryGetValue(QueryParameterKeyName, out queryString)) throw new MvxException("Unable to find incoming MvxShowViewModelRequest"); var text = Uri.UnescapeDataString(queryString); return JsonConvert.DeserializeObject<MvxShowViewModelRequest>(text); }
public virtual MvxViewModelRequest GetRequestFromXamlUri(Uri viewUri) { var parsed = viewUri.ParseQueryString(); string queryString; if (!parsed.TryGetValue(QueryParameterKeyName, out queryString)) throw new MvxException("Unable to find incoming MvxViewModelRequest"); var converter = Mvx.Resolve<IMvxNavigationSerializer>(); return converter.Serializer.DeserializeObject<MvxViewModelRequest>(queryString); }
public static Response Execute(Uri url, Func<ISchedulerWrapper> getScheduler) { var scheduler = getScheduler(); var qs = url.ParseQueryString(); var highlight = qs["highlight"]; var group = qs["group"]; var triggers = GetTriggers(scheduler, group); var paused = scheduler.IsTriggerGroupPaused(group); var v = Views.Views.TriggerGroup(group, paused, url.PathAndQuery, highlight, triggers); return new Response.XDocumentResponse(Helpers.XHTML(v)); }
public static Response Execute(Uri url, Func<ISchedulerWrapper> getScheduler) { var scheduler = getScheduler(); var querystring = url.ParseQueryString(); var highlight = querystring["highlight"]; var group = querystring["group"]; var job = querystring["job"]; var jobKey = new JobKey(job, group); var triggers = GetTriggers(scheduler, jobKey); var m = new TriggersByJobModel(triggers, url.PathAndQuery, group, job, highlight); return new Response.XDocumentResponse(Helpers.XHTML(Views.Views.TriggersByJob(m))); }
public static async Task<string> Authenticate() { var startURI = new Uri(START_URL); var endURI = new Uri(END_URL); string result; var webAuthResult = await WebAuthenticationBroker.AuthenticateAsync(WebAuthenticationOptions.None, startURI, endURI); switch (webAuthResult.ResponseStatus) { case WebAuthenticationStatus.Success: result = webAuthResult.ResponseData.ToString(); break; case WebAuthenticationStatus.ErrorHttp: result = webAuthResult.ResponseData.ToString(); throw new Exception(result); default: throw new Exception("Error :("); } var resultURI = new Uri(result); var query = resultURI.ParseQueryString(); var code = query["code"]; var tokenURL = "https://api.slack.com/api/oauth.access?code=" + Uri.EscapeUriString(code) + "&client_id=" + Uri.EscapeUriString(CLIENT_ID) + "&client_secret=" + Uri.EscapeUriString(CLIENT_SECRET); var tokenURI = new Uri(tokenURL); var httpClient = new HttpClient(); string tokenResponse; try { tokenResponse = await httpClient.GetStringAsync(tokenURI); } catch (Exception) { throw; } finally { httpClient.Dispose(); } JsonObject tokenObject; if (!JsonObject.TryParse(tokenResponse, out tokenObject)) { throw new Exception("Couldn't parse HTTP response. Try again later."); } if (!tokenObject.GetNamedBoolean("ok")) { throw new Exception("You are not authorized to access this team."); } return tokenObject.GetNamedString("access_token"); }
/// <summary> /// Parses the authentication response URI and creates the response object. /// </summary> /// <param name="uri">The URI where the user has been redirected to after authentication.</param> /// <returns></returns> public AuthenticationResponse ParseAuthenticationResponseUri(Uri uri) { Dictionary<string, string> queryParams = uri.ParseQueryString(); string code = null; string error = null; string state = null; queryParams.TryGetValue("code", out code); queryParams.TryGetValue("error", out error); queryParams.TryGetValue("state", out state); return new AuthenticationResponse() { Code = code, Error = error, State = state }; }
private static int GetOrderKey( IHttpRouteData routeData, Uri requestUri) { object orderKeyString; if (routeData.Values.TryGetValue("key", out orderKeyString)) { return int.Parse(orderKeyString.ToString()); } // It's now sure that query string has the shipmentKey value var quesryString = requestUri.ParseQueryString(); return int.Parse(quesryString["key"]); }
public static NameValueCollection FromForm(this IWebResponse response) { if (response == null) { throw new ArgumentNullException("response"); } using (var stream = response.Response.GetResponseStream()) using (var reader = new StreamReader(stream)) { string formData = reader.ReadToEnd(); Uri fakeUri = new Uri("http://localhost/?" + formData); return fakeUri.ParseQueryString(); } }
public static OAuthRequest Parse(Uri uri) { NameValueCollection queryString = uri.ParseQueryString(); string responseType = queryString.Get("response_type"); string clientId = queryString.Get("client_id"); string state = queryString.Get("state"); string scope = queryString.Get("scope"); string jwt = queryString.Get("jwt_token"); var redirectUri = new Uri(queryString.Get("redirect_uri"), UriKind.Absolute); var originalUri = uri.ToString().Replace("&jwt_token=" + jwt, ""); return new OAuthRequest(responseType, clientId, state, scope, redirectUri, jwt, originalUri); }
public static Response Execute(Uri url) { var thisUrl = url.PathAndQuery.Split('?')[0]; var qs = url.ParseQueryString(); var pageSize = GetPageSize(qs); var pagination = new PaginationInfo( firstItemIndex: GetStartIndex(qs), pageSize: pageSize, totalItemCount: logsQ.Count(), pageUrl: "log.ashx?start=!0&max=" + pageSize); var logs = logsQ.Skip(pagination.FirstItemIndex).Take(pagination.PageSize).ToList(); var v = GetView(qs.AllKeys); var view = v.Value(logs, pagination, thisUrl); return new Response.XDocumentResponse(view, v.Key); }
public ActionResult Callback() { string input; using (var reader = new StreamReader(Request.InputStream)) { input = reader.ReadToEnd(); } string locationBase = string.Format("{0}/auth/broker/end", Request.Url.GetComponents(UriComponents.SchemeAndServer, UriFormat.Unescaped)); var inputInQueryStringUri = new Uri(locationBase + "?" + input); NameValueCollection tokenValues = inputInQueryStringUri.ParseQueryString(); string tokenData = tokenValues["wresult"]; //Validate SWT token var tokenSerializer = new WSTrustFeb2005ResponseSerializer(); RequestSecurityTokenResponse requestSecrityTokenResponse = tokenSerializer.ReadXml(new XmlTextReader(new StringReader(tokenData)), new WSTrustSerializationContext()); var simpleWebTokenHandler = new SimpleWebTokenHandler("https://" + _registrationService.ServiceNamespace + ".accesscontrol.windows.net/", _swtSigningKey); var securityToken = simpleWebTokenHandler.ReadToken(requestSecrityTokenResponse.RequestedSecurityToken.SecurityTokenXml.InnerText) as SimpleWebToken; simpleWebTokenHandler.ValidateToken(securityToken, _acsRealm); //Create delegation in ACS var authServerIdentifier = securityToken.Claims.FirstOrDefault(c => c.ClaimType == ClaimTypes.NameIdentifier); var authServerIdentity = new AuthorizationServerIdentity { NameIdentifier = authServerIdentifier.Value, IdentityProvider = authServerIdentifier.Issuer }; //todo: Check if we can add some claims (role claims) to the scope string code = _registrationService.GetAuthorizationCode(_clientId, authServerIdentity, "scope"); //todo: use OAuth parameter names in the return URL //return the token string location = string.Format("{0}?acsToken={1}", locationBase, code); Response.StatusCode = (int)HttpStatusCode.Redirect; Response.Headers.Add("Location", location); Response.End(); return null; }
public static void HandleTryAppServiceResponse(HttpContextBase context) { if (context.Request.RawUrl.StartsWith("/try") && context.Request.Params["cookie"] != null) { var tryAppServiceToken = context.Request.Params["cookie"]; var state = context.Request.Params["state"]; var uri = new Uri(state); var querystring = uri.ParseQueryString(); context.Response.SetCookie(new HttpCookie("TryAppServiceToken", tryAppServiceToken)); context.Response.SetCookie(new HttpCookie("templateId", querystring["templateId"])); context.Response.SetCookie(new HttpCookie("provider", querystring["provider"])); context.Response.SetCookie(new HttpCookie("functionName", querystring["functionName"])); context.Response.RedirectLocation = "/try"; context.Response.StatusCode = 302; context.Response.End(); } }
public static Response Execute(Uri url, Func<ISchedulerWrapper> getScheduler) { var scheduler = getScheduler(); var querystring = url.ParseQueryString(); var group = querystring["group"]; var jobNames = scheduler.GetJobKeys(GroupMatcher<JobKey>.GroupEquals(group)); var runningJobs = scheduler.GetCurrentlyExecutingJobs(); var jobs = jobNames.Select(j => { var job = scheduler.GetJobDetail(j); var interruptible = typeof (IInterruptableJob).IsAssignableFrom(job.JobType); var jobContext = runningJobs.FirstOrDefault(r => r.JobDetail.Key.ToString() == job.Key.ToString()); return new JobWithContext(job, jobContext, interruptible); }); var paused = scheduler.IsJobGroupPaused(group); var highlight = querystring["highlight"]; var view = Views.Views.JobGroup(group, paused, highlight, url.PathAndQuery, jobs); return new Response.XDocumentResponse(Helpers.XHTML(view)); }
private static string CalculateCanonicalRequestHash(string httpMethod, string url, IDictionary<string, string> httpHeaders, out string signedHeaders) { var httpMethodToUpper = httpMethod.ToUpper(); var isGet = httpMethodToUpper == "GET"; var uri = new Uri(url); var queryStringCollection = uri.ParseQueryString(); var canonicalUri = uri.AbsolutePath; var queryString = ( from string parameter in queryStringCollection select new KeyValuePair<string, string>(parameter, queryStringCollection.Get(parameter)) ); var canonicalQueryString = queryString .OrderBy(x => x.Key) .Aggregate(string.Empty, (current, parameter) => current + string.Format("{0}={1}&", parameter.Key.ToLower(), parameter.Value.Trim())); if (canonicalQueryString.EndsWith("&")) canonicalQueryString = canonicalQueryString.Substring(0, canonicalQueryString.Length - 1); var headers = httpHeaders .Where(x => isGet == false || x.Key.StartsWith("Date", StringComparison.InvariantCultureIgnoreCase) == false) .OrderBy(x => x.Key); var canonicalHeaders = headers .Aggregate(string.Empty, (current, parameter) => current + string.Format("{0}:{1}\n", parameter.Key.ToLower(), parameter.Value.Trim())); signedHeaders = headers .Aggregate(string.Empty, (current, parameter) => current + parameter.Key.ToLower() + ";"); if (signedHeaders.EndsWith(";")) signedHeaders = signedHeaders.Substring(0, signedHeaders.Length - 1); using (var hash = SHA256.Create()) { var hashedPayload = httpHeaders["x-amz-content-sha256"]; var canonicalRequest = string.Format("{0}\n{1}\n{2}\n{3}\n{4}\n{5}", httpMethodToUpper, canonicalUri, canonicalQueryString, canonicalHeaders, signedHeaders, hashedPayload); return RavenAwsHelper.ConvertToHex(hash.ComputeHash(Encoding.UTF8.GetBytes(canonicalRequest))); } }
private string ComputeCanonicalizedResource(string url) { var uri = new Uri(url, UriKind.Absolute); var stringToHash = string.Format("/{0}{1}\n", accountName, uri.AbsolutePath); var queryStringCollection = uri.ParseQueryString(); var queryString = ( from string parameter in queryStringCollection select new KeyValuePair<string, string>(parameter, queryStringCollection.Get(parameter)) ); return queryString .OrderBy(x => x.Key) .Aggregate(stringToHash, (current, parameter) => current + string.Format("{0}:{1}\n", parameter.Key.ToLower(), parameter.Value)); }
public virtual ClaimsPrincipal AuthenticateQueryStrings(Uri uri) { return AuthenticateQueryStrings(uri.ParseQueryString()); }
private OfflineEntry GetCacheEntry(Uri uri, Guid requestId) { var filteredQueryParameters = uri.ParseQueryString() .Where(p => p.Key != "_") // Sanitize empty values (query string wo value) .Select(p => p.Key + (p.Value != null ? "=" : string.Empty) + (string.IsNullOrEmpty(p.Value) ? string.Empty : p.Value)); var mappedUri = new UriBuilder(uri); mappedUri.Query = string.Join("&", filteredQueryParameters); // TODO: review if trimming trailing slash is correct var flatString = mappedUri.Uri.ToString().TrimEnd('/'); OfflineEntry entry = null; lock (this.cacheIndex) { if (!this.cacheIndex.TryGetValue(flatString, out entry)) { entry = new OfflineEntry { RequestId = requestId, Key = flatString }; } } return entry; }
public Uri MakeUriFor(ReadOnlyCollection<Expression> arguments, UrlHelper urlHelper) { var argumentValues = ParameterHandlers.Any() ? ComputeRouteMap(ComputeArgumentValues(arguments)) : EmptyMap; var mapForUrlHelper = new Dictionary<string, object>(); var mapForQueryString = new Dictionary<string, IEnumerable>(); if (urlHelper.Request.GetRouteData() != null && urlHelper.Request.GetRouteData().GetSubRoutes() != null) { foreach (var p in urlHelper.Request.GetRouteData().GetSubRoutes().SelectMany(r => r.Values)) { mapForUrlHelper[p.Key] = p.Value; } } foreach (var p in argumentValues) { var arr = p.Value as IEnumerable; if (arr == null || p.Value is string) { mapForUrlHelper[p.Key] = p.Value; } else { mapForQueryString[p.Key] = arr; } } var routeEntry = _routeSelector(urlHelper.Request, RouteEntries); var uri = new Uri(urlHelper.Link(routeEntry.Name, mapForUrlHelper)); if(mapForQueryString.Count == 0) { return uri; } var uriBuilder = new UriBuilder(uri); var query = uri.ParseQueryString(); foreach(var pair in mapForQueryString) { var key = pair.Key; var arr = pair.Value; foreach(var value in arr) { query.Add(key, Convert.ToString(value, CultureInfo.InvariantCulture)); } } uriBuilder.Query = query.ToString(); return uriBuilder.Uri; }
public static void IsRedirectedToCookiesLogin(Uri requestUri, string protectedResourceUri, string message, string queryParameterName = "ReturnUrl") { Assert.True(requestUri.AbsolutePath.EndsWith("/Auth/CookiesLogin"), message); Assert.Equal<string>(new Uri(protectedResourceUri).AbsolutePath, requestUri.ParseQueryString()[queryParameterName]); }
public void Security_AuthorizeEndpointTests(HostType hostType) { using (ApplicationDeployer deployer = new ApplicationDeployer()) { var applicationUrl = deployer.Deploy(hostType, AuthServerHappyPathConfiguration); IDisposable clientEndpoint = null; try { clientEndpoint = WebApp.Start(Client_Redirect_Uri, app => app.Run(context => { return context.Response.WriteAsync(context.Request.QueryString.Value); })); string tokenEndpointUri = applicationUrl + "TokenEndpoint"; var basicClient = new HttpClient(); var headerValue = Convert.ToBase64String(Encoding.Default.GetBytes(string.Format("{0}:{1}", "123", "invalid"))); basicClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", headerValue); HttpClient httpClient = new HttpClient(); string requestUri = null; Uri landingUri = null; Uri applicationUri = new Uri(applicationUrl); HttpResponseMessage httpResponseMessage = null; //Happy path - response_type:code requestUri = AuthZ.CreateAuthZUri(applicationUrl, "code", "123", Client_Redirect_Uri, "scope1", "validstate"); landingUri = httpClient.GetAsync(requestUri).Result.RequestMessage.RequestUri; Assert.Equal<string>(Client_Redirect_Uri, landingUri.GetLeftPart(UriPartial.Path)); Assert.NotNull(landingUri.ParseQueryString()["code"]); Assert.Equal<string>("validstate", landingUri.ParseQueryString()["state"]); //Happy path - response_type:token requestUri = AuthZ.CreateAuthZUri(applicationUrl, "token", "123", Client_Redirect_Uri, "scope1", "validstate"); landingUri = httpClient.GetAsync(requestUri).Result.RequestMessage.RequestUri; landingUri = new Uri(landingUri.AbsoluteUri.Replace('#', '?')); Assert.Equal<string>(Client_Redirect_Uri, landingUri.GetLeftPart(UriPartial.Path)); Assert.NotNull(landingUri.ParseQueryString()["access_token"]); Assert.NotNull(landingUri.ParseQueryString()["expires_in"]); Assert.Equal<string>("bearer", landingUri.ParseQueryString()["token_type"]); Assert.Equal<string>("validstate", landingUri.ParseQueryString()["state"]); //Invalid redirect URI - pass error to application requestUri = AuthZ.CreateAuthZUri(applicationUrl, "code", "123", "invalid_uri_passonerror", "scope1", "validstate"); httpResponseMessage = httpClient.GetAsync(requestUri).Result; Assert.Equal<string>("error: invalid_request\r\n", httpResponseMessage.Content.ReadAsStringAsync().Result); Assert.True(httpResponseMessage.RequestMessage.RequestUri.GetLeftPart(UriPartial.Authority).StartsWith(applicationUri.GetLeftPart(UriPartial.Authority)), "Should not be redirected on invalid redirect_uri"); //Invalid redirect URI - Display error by middleware requestUri = AuthZ.CreateAuthZUri(applicationUrl, "code", "123", "invalid_uri_displayerror", "scope1", "validstate"); httpResponseMessage = httpClient.GetAsync(requestUri).Result; Assert.True(httpResponseMessage.RequestMessage.RequestUri.GetLeftPart(UriPartial.Authority).StartsWith(applicationUri.GetLeftPart(UriPartial.Authority)), "Should not be redirected on invalid redirect_uri"); Assert.True(httpResponseMessage.Content.ReadAsStringAsync().Result.StartsWith("error: invalid_request"), "Did not receive an error for an invalid redirect_uri"); //What happens if we don't set Validated explicitly. Send an invalid clientId => We don't set Validated for this case. requestUri = AuthZ.CreateAuthZUri(applicationUrl, "token", "invalidClient", Client_Redirect_Uri, "scope1", "validstate"); httpResponseMessage = httpClient.GetAsync(requestUri).Result; Assert.True(httpResponseMessage.RequestMessage.RequestUri.GetLeftPart(UriPartial.Authority).StartsWith(applicationUri.GetLeftPart(UriPartial.Authority)), "Should not be redirected on invalid redirect_uri"); Assert.True(httpResponseMessage.Content.ReadAsStringAsync().Result.StartsWith("error: invalid_request"), "Did not receive an error for an invalid redirect_uri"); //OnValidateAuthorizeRequest - Rejecting a request. Send an invalid state as we validate it there. Client should receive all the error code & description that we send requestUri = AuthZ.CreateAuthZUri(applicationUrl, "code", "123", Client_Redirect_Uri, "scope1", "invalidstate"); httpResponseMessage = httpClient.GetAsync(requestUri).Result; landingUri = httpResponseMessage.RequestMessage.RequestUri; Assert.Equal<string>(Client_Redirect_Uri, landingUri.GetLeftPart(UriPartial.Path)); Assert.Equal<string>("state.invalid", landingUri.ParseQueryString()["error"]); Assert.Equal<string>("state.invaliddescription", landingUri.ParseQueryString()["error_description"]); Assert.Equal<string>("state.invaliduri", landingUri.ParseQueryString()["error_uri"]); Assert.True(httpResponseMessage.Content.ReadAsStringAsync().Result.StartsWith("error=state.invalid&error_description=state.invaliddescription&error_uri=state.invaliduri"), "Did not receive an error when provider did not set Validated"); //Missing response_type requestUri = AuthZ.CreateAuthZUri(applicationUrl, null, "123", Client_Redirect_Uri, "scope1", "validstate"); httpResponseMessage = httpClient.GetAsync(requestUri).Result; Assert.Equal<string>(Client_Redirect_Uri, httpResponseMessage.RequestMessage.RequestUri.GetLeftPart(UriPartial.Path)); Assert.Equal<string>("invalid_request", httpResponseMessage.RequestMessage.RequestUri.ParseQueryString()["error"]); //Unsupported response_type requestUri = AuthZ.CreateAuthZUri(applicationUrl, "invalid_response_type", "123", Client_Redirect_Uri, "scope1", "validstate"); httpResponseMessage = httpClient.GetAsync(requestUri).Result; Assert.Equal<string>(Client_Redirect_Uri, httpResponseMessage.RequestMessage.RequestUri.GetLeftPart(UriPartial.Path)); Assert.Equal<string>("unsupported_response_type", httpResponseMessage.RequestMessage.RequestUri.ParseQueryString()["error"]); //Missing client_id requestUri = AuthZ.CreateAuthZUri(applicationUrl, "token", null, Client_Redirect_Uri, "scope1", "validstate"); httpResponseMessage = httpClient.GetAsync(requestUri).Result; Assert.True(httpResponseMessage.RequestMessage.RequestUri.GetLeftPart(UriPartial.Authority).StartsWith(applicationUri.GetLeftPart(UriPartial.Authority)), "Should not be redirected on invalid redirect_uri"); Assert.True(httpResponseMessage.Content.ReadAsStringAsync().Result.StartsWith("error: invalid_request"), "Did not receive an error for an invalid redirect_uri"); //Missing state - Should succeed requestUri = AuthZ.CreateAuthZUri(applicationUrl, "code", "123", Client_Redirect_Uri, "scope1", null); landingUri = httpClient.GetAsync(requestUri).Result.RequestMessage.RequestUri; Assert.Equal<string>(Client_Redirect_Uri, landingUri.GetLeftPart(UriPartial.Path)); Assert.NotNull(landingUri.ParseQueryString()["code"]); Assert.Equal<bool>(false, landingUri.ParseQueryString().ContainsKey("state")); //Token endpoint tests //Invalid client (client_id, client_secret) - As form parameters var formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "invalid") }); var responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result; var jToken = JToken.Parse(responseMessage); Assert.Equal<string>("invalid_client", jToken.SelectToken("error").Value<string>()); //Invalid client (client_id, client_secret) - As Basic auth headers responseMessage = basicClient.GetAsync(tokenEndpointUri).Result.Content.ReadAsStringAsync().Result; jToken = JToken.Parse(responseMessage); Assert.Equal<string>("invalid_client", jToken.SelectToken("error").Value<string>()); //grant_type=authorization_code - invalid code being sent formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "secret123"), new kvp("grant_type", "authorization_code"), new kvp("code", "InvalidCode"), new kvp("redirect_uri", Client_Redirect_Uri) }); responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result; jToken = JToken.Parse(responseMessage); Assert.Equal<string>("invalid_grant", jToken.SelectToken("error").Value<string>()); //grant_type=authorization_code - Full scenario requestUri = AuthZ.CreateAuthZUri(applicationUrl, "code", "123", Client_Redirect_Uri, "scope1", "validstate"); landingUri = httpClient.GetAsync(requestUri).Result.RequestMessage.RequestUri; Assert.Equal<string>(Client_Redirect_Uri, landingUri.GetLeftPart(UriPartial.Path)); Assert.NotNull(landingUri.ParseQueryString()["code"]); Assert.Equal<string>("validstate", landingUri.ParseQueryString()["state"]); formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "secret123"), new kvp("grant_type", "authorization_code"), new kvp("code", landingUri.ParseQueryString()["code"]), new kvp("redirect_uri", Client_Redirect_Uri) }); responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result; jToken = JToken.Parse(responseMessage); Assert.NotNull(jToken.SelectToken("access_token").Value<string>()); Assert.Equal<string>("bearer", jToken.SelectToken("token_type").Value<string>()); Assert.NotNull(jToken.SelectToken("expires_in").Value<string>()); Assert.Equal<string>("value1", jToken.SelectToken("param1").Value<string>()); Assert.Equal<string>("value2", jToken.SelectToken("param2").Value<string>()); Assert.NotNull(jToken.SelectToken("refresh_token").Value<string>()); //grant_type=password -- Resource owner credentials -- Invalid credentials formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "secret123"), new kvp("grant_type", "password"), new kvp("username", "user1"), new kvp("password", "invalid"), new kvp("scope", "scope1 scope2 scope3") }); responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result; jToken = JToken.Parse(responseMessage); Assert.Equal<string>("invalid_grant", jToken.SelectToken("error").Value<string>()); //grant_type=password -- Resource owner credentials formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "secret123"), new kvp("grant_type", "password"), new kvp("username", "user1"), new kvp("password", "password1"), new kvp("scope", "scope1 scope2 scope3") }); responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result; jToken = JToken.Parse(responseMessage); Assert.NotNull(jToken.SelectToken("access_token").Value<string>()); Assert.Equal<string>("bearer", jToken.SelectToken("token_type").Value<string>()); Assert.NotNull(jToken.SelectToken("expires_in").Value<string>()); Assert.Equal<string>("value1", jToken.SelectToken("param1").Value<string>()); Assert.Equal<string>("value2", jToken.SelectToken("param2").Value<string>()); Assert.NotNull(jToken.SelectToken("refresh_token").Value<string>()); //grant_type=refresh_token -- Use the refresh token issued on the previous call formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "secret123"), new kvp("grant_type", "refresh_token"), new kvp("refresh_token", jToken.SelectToken("refresh_token").Value<string>()), new kvp("scope", "scope1 scope2") }); responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result; jToken = JToken.Parse(responseMessage); Assert.NotNull(jToken.SelectToken("access_token").Value<string>()); Assert.Equal<string>("bearer", jToken.SelectToken("token_type").Value<string>()); Assert.NotNull(jToken.SelectToken("expires_in").Value<string>()); Assert.Equal<string>("value1", jToken.SelectToken("param1").Value<string>()); Assert.Equal<string>("value2", jToken.SelectToken("param2").Value<string>()); Assert.NotNull(jToken.SelectToken("refresh_token").Value<string>()); //grant_type=client_credentials - Bug# https://github.com/Katana/katana/issues/562 formContent = AuthZ.CreateTokenEndpointContent(new[] { new kvp("client_id", "123"), new kvp("client_secret", "secret123"), new kvp("grant_type", "client_credentials"), new kvp("scope", "scope1 scope2 scope3") }); responseMessage = httpClient.PostAsync(tokenEndpointUri, formContent).Result.Content.ReadAsStringAsync().Result; jToken = JToken.Parse(responseMessage); Assert.NotNull(jToken.SelectToken("access_token").Value<string>()); Assert.Equal<string>("bearer", jToken.SelectToken("token_type").Value<string>()); Assert.NotNull(jToken.SelectToken("expires_in").Value<string>()); Assert.Equal<string>("value1", jToken.SelectToken("param1").Value<string>()); Assert.Equal<string>("value2", jToken.SelectToken("param2").Value<string>()); } finally { //Finally close the client endpoint if (clientEndpoint != null) { clientEndpoint.Dispose(); } } } }
private static Guid GetShipmentKey(IHttpRouteData routeData, Uri requestUri) { // We are sure at this point that the shipmentKey value has been // supplied (either through route or quesry string) because it // wouldn't be possible for the request to arrive here if it wasn't. object shipmentKeyString; if (routeData.Values.TryGetValue("shipmentKey", out shipmentKeyString)) { return Guid.ParseExact(shipmentKeyString.ToString(), "D"); } // It's now sure that query string has the shipmentKey value var quesryString = requestUri.ParseQueryString(); return Guid.ParseExact(quesryString["shipmentKey"], "D"); }
public static bool IsYouTubeUri(Uri uri, out string videoId) { videoId = null; if (uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps) { /* * TODO: add support for all of the following * (or even more, see http://stackoverflow.com/questions/3392993/php-regex-to-get-youtube-video-id) * youtube.com/v/{vidid} * youtube.com/vi/{vidid} * youtube.com/?v={vidid} * youtube.com/?vi={vidid} * youtube.com/watch?v={vidid} * youtube.com/watch?vi={vidid} * youtu.be/{vidid} */ if ((uri.Host == "www.youtube.com" || uri.Host == "youtube.com") && uri.AbsolutePath == "/watch") { var nvc = uri.ParseQueryString(); videoId = nvc["v"]; return videoId != null; } else if (uri.Host == "youtu.be") { videoId = uri.AbsolutePath.Substring(1); return true; } } return false; }
public override void Load(Uri uri) { media = new LocationMedia(uri.AbsoluteUri); if (uri.Scheme == "dshow") { var nvc = uri.ParseQueryString(); foreach (var key in nvc.AllKeys) { media.AddOption(key + "=" + nvc[key]); } } media.StateChanged += OnMediaStateChange; bool doLoop = false; vlc.EncounteredError += (sender, args) => { OnMediaFailed(); }; vlc.EndReached += (sender, args) => { if (!loop) { Stop(); OnPlaybackEnded(); } else { doLoop = true; } }; vlc.Playing += (sender, args) => { if (loop && doLoop) { OnSeekStart(); } doLoop = false; }; vlc.Media = media; }
/// <summary> /// Login redirect are of the form https://host/?ec=30x&startURL=xyz /// </summary> /// <param name="uri"></param> /// <returns>null if this is not a login redirect and return the the value for startURL if this is a login redirect</returns> private string IsLoginRedirect(Uri uri) { if (uri != null && uri.IsAbsoluteUri && uri.AbsolutePath != null && uri.AbsolutePath == "/" && uri.Query != null) { Dictionary<string, string> qs = uri.ParseQueryString(); if ((qs["ec"] == "301" || qs["ec"] == "302") && qs["startURL"] != null) { return qs["startURL"]; } } return null; }
public void ParseUriTest() { var uri = new Uri("http://foo.com/bar?a=123"); var parameters = uri.ParseQueryString(); Assert.AreEqual(1, parameters.Count); Assert.AreEqual("123", parameters["a"]); }
public void ParseUri_EmptyQueryStringTest() { var uri = new Uri("http://foo.com/bar?"); var parameters = uri.ParseQueryString(); Assert.AreEqual(0, parameters.Count); }