private static IEnumerable <Uri> ExtractDownloadUrls(string source) { #if NETFX_CORE string urlMap = new WwwFormUrlDecoder(source).GetFirstValueByName("url_encoded_fmt_stream_map"); #else string urlMap = HttpUtility.ParseQueryString(source).Get("url_encoded_fmt_stream_map"); #endif string[] splitByUrls = urlMap.Split(','); foreach (string s in splitByUrls) { #if NETFX_CORE var decoder = new WwwFormUrlDecoder(s); string url = string.Format("{0}&fallback_host={1}&signature={2}", decoder.GetFirstValueByName("url"), decoder.GetFirstValueByName("fallback_host"), decoder.GetFirstValueByName("sig")); url = WebUtility.UrlDecode(url); url = WebUtility.UrlDecode(url); #else var queries = HttpUtility.ParseQueryString(s); string url = string.Format("{0}&fallback_host={1}&signature={2}", queries["url"], queries["fallback_host"], queries["sig"]); url = HttpUtility.UrlDecode(url); url = HttpUtility.UrlDecode(url); #endif yield return(new Uri(url)); } }
private async void WebViewer_NavigationCompleted(WebView sender, WebViewNavigationCompletedEventArgs args) { // Check if new location is redirect uri if (args.Uri.AbsoluteUri.IndexOf(App.RedirectUri) == 0) { // Get parameters var encoder = new WwwFormUrlDecoder(args.Uri.AbsoluteUri.Replace('#', '&')); // Replacing # with ? to make GetFirstValueByName() work var accessToken = encoder.GetFirstValueByName("access_token"); var expires = encoder.GetFirstValueByName("expires"); if (!String.IsNullOrEmpty(accessToken)) { // Success App.AccessToken = accessToken; App.Expires = expires; Frame.GoBack(); var successDialog = new MessageDialog("Successfully logged in.", "Success!"); await successDialog.ShowAsync(); return; } // Show error message, if something went wrong var errorDialog = new MessageDialog("Whoops, we could not log you in successfully. Sorry for that!", "Something went wrong..."); await errorDialog.ShowAsync(); Frame.GoBack(); } }
/// <summary> /// Method to receive protocal invocation and process the arguments. /// </summary> /// <param name="e"></param> protected override void OnNavigatedTo(NavigationEventArgs e) { base.OnNavigatedTo(e); WwwFormUrlDecoder decoder = new WwwFormUrlDecoder(e.Parameter.ToString()); try { bool IsJson = false; var content = decoder.GetFirstValueByName("content"); var isjson = decoder.GetFirstValueByName("isjson"); if (!string.IsNullOrEmpty(isjson)) { IsJson = Convert.ToBoolean(isjson); } if (!string.IsNullOrEmpty(content)) { if (IsJson) { dynamic data = JObject.Parse(content); txtContent.Text = data.Name; } else { txtContent.Text = content; } } } catch (Exception ex) { txtContent.Text = ex.Message; } }
private async Task ProcessToastNotificationActivation(string arguments, ValueSet userInput) { // Perform tasks if (arguments == ACTIVATION_WITH_ERROR) { await ShowErrorLog().ConfigureAwait(false); } else if (arguments == ACTIVATION_WITH_ERROR_COPY_LOG) { var error = await GetMostRecentErrorText(); Services.Helpers.ClipboardHelper.CopyToClipboard(error); } else if (arguments == ACTIVATION_WITH_ERROR_OPEN_LOG) { await ShowErrorLogFolder(); } else if (arguments.StartsWith("cache_cancel")) { var cacheManager = Container.Resolve <Models.Cache.VideoCacheManager>(); var query = arguments.Split('?')[1]; var decode = new WwwFormUrlDecoder(query); var videoId = decode.GetFirstValueByName("id"); var quality = (NicoVideoQuality)Enum.Parse(typeof(NicoVideoQuality), decode.GetFirstValueByName("quality")); await cacheManager.CancelCacheRequest(videoId, quality); } }
private async Task <Token> GetAccessToken() { var token = new Token(); var startUrl = Common.FormatAuthUrl(AuthorizationEndpointUrl, ResponseTypes.Token, ConsumerKey, WebUtility.UrlEncode(CallbackUrl), DisplayTypes.Popup); var startUri = new Uri(startUrl); var endUri = new Uri(CallbackUrl); var webAuthenticationResult = await Windows.Security.Authentication.Web.WebAuthenticationBroker.AuthenticateAsync( Windows.Security.Authentication.Web.WebAuthenticationOptions.None, startUri, endUri); switch (webAuthenticationResult.ResponseStatus) { case Windows.Security.Authentication.Web.WebAuthenticationStatus.Success: var responseData = webAuthenticationResult.ResponseData; var responseUri = new Uri(responseData); var decoder = new WwwFormUrlDecoder(responseUri.Fragment.Replace("#", "?")); token.AccessToken = decoder.GetFirstValueByName("access_token"); token.RefreshToken = decoder.GetFirstValueByName("refresh_token"); token.InstanceUrl = WebUtility.UrlDecode(decoder.GetFirstValueByName("instance_url")); return(token); case Windows.Security.Authentication.Web.WebAuthenticationStatus.ErrorHttp: throw new Exception(webAuthenticationResult.ResponseErrorDetail.ToString()); default: throw new Exception(webAuthenticationResult.ResponseData); } }
/// <summary> /// Retrieves an OAuth 2.0 token for a given Authentication ticket. /// </summary> /// <param name="httpClient">The <see cref="HttpClient"/> instance to use for this request.</param> /// <param name="authTicket">The Authentication Ticket to use for this request. Obtained by calling <see cref="GetAuthenticationTicket(HttpClient, PtcLoginParameters)"/>.</param> /// <returns></returns> private async Task <AccessToken> GetOAuthToken(string authTicket) { var requestData = new Dictionary <string, string> { { "client_id", "mobile-app_pokemon-go" }, { "redirect_uri", "https://www.nianticlabs.com/pokemongo/error" }, { "client_secret", "w8ScCUXJQc6kXKw8FiOhd8Fixzht18Dq3PEVkUCP5ZPxtgyWsbTvWHFLm2wNY0JR" }, { "grant_type", "refresh_token" }, { "code", authTicket } }; var responseMessage = await HttpClient.PostAsync(Constants.LoginOauthUrl, new FormUrlEncodedContent(requestData)).ConfigureAwait(false); var responseContent = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false); if (string.IsNullOrWhiteSpace(responseContent)) { throw new Exception("Your login was OK, but we could not get an API Token."); } var decoder = new WwwFormUrlDecoder(responseContent); if (decoder.Count == 0) { throw new Exception("Your login was OK, but we could not get an API Token."); } return(new AccessToken { Username = this.Username, Token = decoder.GetFirstValueByName("access_token"), ExpiresUtc = DateTime.UtcNow.AddSeconds(int.Parse(decoder.GetFirstValueByName("expires"))), AuthType = AuthType.Ptc }); }
private async Task ProcessCommand(WwwFormUrlDecoder querybag, IOutputStream outstream) { try { string botCmd = querybag.GetFirstValueByName("cmd").ToLowerInvariant(); // Throws System.ArgumentException if not found switch (botCmd) { case "arm": { fc.Arm(); await WriteResponseAsync("200 OK", successMsg, outstream); break; } case "disarm": { fc.Disarm(); await WriteResponseAsync("200 OK", successMsg, outstream); break; } case "takeoff": { await fc.takeoff(); await WriteResponseAsync("200 OK", successMsg, outstream); break; } case "flyheight": { UInt32 height = UInt32.Parse(querybag.GetFirstValueByName("height")); // in cm! fc.flyToHeight(height); await WriteResponseAsync("200 OK", successMsg, outstream); break; } default: { await WriteResponseAsync("400 Bad Request", string.Format("UNSUPPORTED COMMAND: {0}", botCmd), outstream); break; } } lastCommand = botCmd; } catch (ArgumentException) { await WriteResponseAsync("400 Bad Request", "INVALID QUERY STRING", outstream); } catch (Exception e) { await WriteResponseAsync("500 Internal Server Error", e.Message + e.StackTrace, outstream); } }
private async void Authenticate() { var SpotifyUrl = $"https://accounts.google.com/o/oauth2/auth?client_id={this.clientId}&redirect_uri={Uri.EscapeDataString(this.redirectURI)}&response_type=code&scope={Uri.EscapeDataString(this.scope)}"; var StartUri = new Uri(SpotifyUrl); var EndUri = new Uri(redirectURI); WebAuthenticationResult WebAuthenticationResult = await WebAuthenticationBroker.AuthenticateAsync(WebAuthenticationOptions.None, StartUri, EndUri); if (WebAuthenticationResult.ResponseStatus == WebAuthenticationStatus.Success) { var decoder = new WwwFormUrlDecoder(new Uri(WebAuthenticationResult.ResponseData).Query); if (decoder[0].Name != "code") { System.Diagnostics.Debug.WriteLine($"OAuth authorization error: {decoder.GetFirstValueByName("error")}."); return; } var autorizationCode = decoder.GetFirstValueByName("code"); var pairs = new Dictionary <string, string>(); pairs.Add("code", autorizationCode); pairs.Add("client_id", this.clientId); pairs.Add("client_secret", this.clientSecret); pairs.Add("redirect_uri", this.redirectURI); pairs.Add("grant_type", "authorization_code"); var formContent = new Windows.Web.Http.HttpFormUrlEncodedContent(pairs); var client = new Windows.Web.Http.HttpClient(); var httpResponseMessage = await client.PostAsync(new Uri("https://www.googleapis.com/oauth2/v4/token"), formContent); if (!httpResponseMessage.IsSuccessStatusCode) { System.Diagnostics.Debug.WriteLine($"OAuth authorization error: {httpResponseMessage.StatusCode}."); return; } string jsonString = await httpResponseMessage.Content.ReadAsStringAsync(); var jsonObject = Windows.Data.Json.JsonObject.Parse(jsonString); var accessToken = jsonObject["access_token"].GetString(); this.accessToken = accessToken; this.gotAccessToken = true; this.GMailServices = new GmailServices(this.accessToken); this.GMailServices.LatestEmailsEvent += (sender, status) => { this.LatestEmailsEvent?.Invoke(this, status); }; this.CalendarServices = new CalendarServices(this.accessToken); this.CalendarServices.LatestCalendarEvent += (sender, status) => { this.LatestCalendarEvent?.Invoke(this, status); }; } }
// launch by protocol protected override void OnActivated(IActivatedEventArgs args) { base.OnActivated(args); if (args.Kind == ActivationKind.Protocol) { ProtocolActivatedEventArgs protocolArgs = (ProtocolActivatedEventArgs)args; WwwFormUrlDecoder decoder = new WwwFormUrlDecoder(protocolArgs.Uri.Query); string s_port = decoder.GetFirstValueByName("port"); int.TryParse(s_port, out int port); Controller.Connect(port); Frame rootFrame = Window.Current.Content as Frame; if (rootFrame == null) { rootFrame = new Frame(); rootFrame.NavigationFailed += OnNavigationFailed; Window.Current.Content = rootFrame; } if (rootFrame.Content == null) { rootFrame.Navigate(typeof(MainPage)); } } Window.Current.Activate(); }
public override async Task OnStartAsync(StartKind startKind, IActivatedEventArgs args) { if (args is ProtocolActivatedEventArgs pArgs) { if (!string.IsNullOrWhiteSpace(pArgs.Uri.Query)) { try { var parsedQuery = new WwwFormUrlDecoder(pArgs.Uri.Query); if (parsedQuery.Count > 0) { var chatUrl = parsedQuery.GetFirstValueByName("chatflow"); Utils.APISettings.Values["API"] = chatUrl; MainPageViewModel.CurrentInstance?.StartChatting(); } } catch { } } } if (args is FileActivatedEventArgs fArgs && fArgs.Files.Count > 0) { var file = fArgs.Files[0] as StorageFile; Utils.APISettings.Values["JSON"] = await FileIO.ReadTextAsync(file); MainPageViewModel.CurrentInstance?.StartChatting(); } // long-running startup tasks go here await Utils.LoadConfig(); NavigationService.Navigate(typeof(Views.MainPage)); await Task.CompletedTask; }
/// <summary> /// Performs the first step in the OAuth2 workflow and retreives the auth code /// </summary> /// <param name="authCodeUri">The box api uri to retrieve the auth code. BoxConfig.AuthCodeUri should be used for this field</param> /// <param name="redirectUri">The redirect uri that the page will navigate to after granting the auth code</param> /// <returns></returns> public static async Task <string> GetAuthCode(Uri authCodeUri, Uri redirectUri = null) { Uri callbackUri = redirectUri == null? WebAuthenticationBroker.GetCurrentApplicationCallbackUri() : redirectUri; WebAuthenticationResult war = await WebAuthenticationBroker.AuthenticateAsync( WebAuthenticationOptions.None, authCodeUri, callbackUri); switch (war.ResponseStatus) { case WebAuthenticationStatus.Success: // grab auth code var response = war.ResponseData; WwwFormUrlDecoder decoder = new WwwFormUrlDecoder(new Uri(response).Query); return(decoder.GetFirstValueByName("code")); case WebAuthenticationStatus.UserCancel: throw new Exception("User Canceled Login"); case WebAuthenticationStatus.ErrorHttp: default: throw new Exception("Error returned by GetAuthCode() : " + war.ResponseStatus.ToString()); } }
public async Task AuthenticateAsync() { var clientId = "MTcpOsELm-U8sw"; var authenticationResult = await WebAuthenticationBroker.AuthenticateAsync(WebAuthenticationOptions.None, new Uri("https://www.reddit.com/api/v1/authorize?client_id=" + clientId + "&response_type=code&state=RANDOM_STRING2&redirect_uri=http://localhost&duration=permanent&scope=identity,edit,flair,history,modconfig,modflair,modlog,modposts,modwiki,mysubreddits,privatemessages,read,report,save,submit,subscribe,vote,wikiedit,wikiread"), new Uri("http://localhost")); if (authenticationResult.ResponseStatus == WebAuthenticationStatus.Success) { WwwFormUrlDecoder urlDecoder = new WwwFormUrlDecoder(new Uri(authenticationResult.ResponseData).Query); var codeString = urlDecoder.GetFirstValueByName("code"); var postClient = new HttpClient(); postClient.DefaultRequestHeaders.Authorization = CreateBasicHeader(clientId, ""); HttpContent httpContent = new StringContent("grant_type=authorization_code&code=" + codeString + "&redirect_uri=http://localhost"); httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded"); var responseMessage = await postClient.PostAsync(new Uri("https://ssl.reddit.com/api/v1/access_token"), httpContent); var responseContent = await responseMessage.Content.ReadAsStringAsync(); var jsonResponse = JObject.Parse(responseContent); accessToken = jsonResponse["access_token"].ToString(); httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", accessToken); } }
private async void BingTranslationReady(IAsyncResult ar) { // STEP 4: Process the translation // Get the request details HttpWebRequest request = (HttpWebRequest)ar.AsyncState; // Get the response details HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(ar); // Read the contents of the response into a string System.IO.Stream streamResponse = response.GetResponseStream(); System.IO.StreamReader streamRead = new System.IO.StreamReader(streamResponse); string responseString = streamRead.ReadToEnd(); // Translator returns XML, so load it into an XDocument System.Xml.Linq.XDocument xTranslation = System.Xml.Linq.XDocument.Parse(responseString); string strTest = xTranslation.Root.FirstNode.ToString(); // We're not on the UI thread, so use the dispatcher to update the UI await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { translationResult.Text = strTest; WwwFormUrlDecoder decoder = new WwwFormUrlDecoder(request.RequestUri.Query); Word w = new Word(); w.Text = decoder.GetFirstValueByName("text"); w.Learning = true; Description d = new Description() { Text = strTest }; w.addDescription(d); App.ViewModel.addWord(w); }); }
private async void FinalizeAuthorization(string url) { try { var urlDecoder = new WwwFormUrlDecoder(url.Substring(url.IndexOf('?') + 1)); await Authorization.RetrieveAndSaveTokensFromAuthCode(urlDecoder.GetFirstValueByName("code")); WebViewHelper.Navigate(new Uri(urlDecoder.GetFirstValueByName("state"))); } catch (Exception ex) { logger.Info("Authorization failed. " + ex.ToString()); Authorize("https://open.spotify.com/", clearExisting: false); } }
private void OnNavigationStarting(WebView sender, WebViewNavigationStartingEventArgs args) { this.ResetErrorView(); this.LoadingState = true; var isSignOutWorkflow = GoogleDomainsHelper.IsSignOutWorkflow(args.Uri); if (_customHttpHeaderSet && !isSignOutWorkflow) { _customHttpHeaderSet = false; return; } args.Cancel = true; if (isSignOutWorkflow) { var queryParams = new WwwFormUrlDecoder(args.Uri.Query); var uri = new Uri(queryParams.GetFirstValueByName("continue")); UriHelper.ClearCookiesFor(uri); this.ManageUri(uri); } else { this.ManageUri(args.Uri); } }
/// <summary> /// This function extracts access_token from the response returned from web authentication broker /// and uses that token to get user information using facebook graph api. /// </summary> /// <param name="responseData">responseData returned from AuthenticateAsync result.</param> private async Task GetFacebookUserNameAsync(string responseData) { var decoder = new WwwFormUrlDecoder(responseData); var error = decoder.TryGetValue("error"); if (error != null) { FacebookUserName.Text = $"Error: {error}"; return; } // You can store access token locally for further use. string access_token = decoder.GetFirstValueByName("access_token"); string expires_in = decoder.TryGetValue("expires_in"); // expires_in is optional HttpClient httpClient = new HttpClient(); Uri uri = new Uri($"https://graph.facebook.com/me?access_token={Uri.EscapeDataString(access_token)}"); try { string response = await httpClient.GetStringAsync(uri); JsonObject userInfo = JsonObject.Parse(response).GetObject(); FacebookUserName.Text = userInfo.GetNamedString("name"); } catch (Exception) { FacebookUserName.Text = "Error contacting Facebook"; } }
/// <summary> /// Обработчик перехода на страницу авторизации /// </summary> /// <param name="sender"></param> /// <param name="args"></param> private void WvAuthorization_LoginNavigationCompleted(WebView sender, WebViewNavigationCompletedEventArgs args) { wvAuthorization.Visibility = Visibility.Visible; if (string.IsNullOrEmpty(args.Uri.Fragment)) { return; } var decoder = new WwwFormUrlDecoder(args.Uri.Fragment.Substring(1)); App.VkSettings.AccessToken = decoder.GetFirstValueByName("access_token"); App.VkSettings.UserId = decoder.GetFirstValueByName("user_id"); App.NavigationService.Navigate(typeof(MainView)); wvAuthorization.NavigationCompleted -= WvAuthorization_LoginNavigationCompleted; }
public async Task ProcessRedirect(Uri url) { if (url.Host == "golf1052.com" && !url.Query.Contains("error=access_denied")) { var decoded = new WwwFormUrlDecoder(url.Query); string code = decoded.GetFirstValueByName("code"); FormUrlEncodedContent tokenRequestContent = new FormUrlEncodedContent(new Dictionary <string, string>() { { "grant_type", "authorization_code" }, { "code", code }, { "redirect_uri", Secrets.SpotifyRedirectUrl } }); httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", GetEncodedAuth()); HttpResponseMessage tokenResponseMessage = await httpClient.PostAsync("https://accounts.spotify.com/api/token", tokenRequestContent); try { await SetupSpotifyToken(tokenResponseMessage); } catch { Available = false; throw; } } else { Available = false; } }
public async void NavigateWithConfig(string parameter) { try { var urlDecoder = new WwwFormUrlDecoder(parameter); var pageUrl = urlDecoder.GetFirstValueByName("pageUrl"); await WebViewHelper.NavigateToSpotifyUrl(pageUrl); var autoplayEntry = urlDecoder.FirstOrDefault(x => x.Name == "autoplay"); AutoPlayAction action = AutoPlayAction.None; if (autoplayEntry != null) { action = autoplayEntry.Value == "track" ? AutoPlayAction.Track : AutoPlayAction.Playlist; } if (action != AutoPlayAction.None) { await WebViewHelper.AutoPlay(action); } return; } catch (Exception ex) { logger.Info($"Parsing input parameter {parameter} failed. {ex}"); } }
private async void OauthBrowser_NavigationCompleted(WebView sender, WebViewNavigationCompletedEventArgs args) { if (OauthViewer.Visibility == Visibility.Collapsed) { return; } OauthProgress.Visibility = Visibility.Collapsed; if (!args.IsSuccess) { MessageDialog dlg = new MessageDialog(args.WebErrorStatus.ToString() + ": " + args.Uri.AbsoluteUri); await dlg.ShowAsync(); ShowOauthPanel(false); return; } if (string.IsNullOrWhiteSpace(args.Uri.Query)) { return; } string code = string.Empty; try { WwwFormUrlDecoder decoder = new WwwFormUrlDecoder(args.Uri.Query); if (ListProviders.SelectedIndex == OauthProvider.GoogleProvider) { code = decoder.GetFirstValueByName("approvalCode"); } else { code = decoder.GetFirstValueByName("code"); } } catch { } if (string.IsNullOrWhiteSpace(code)) { return; } _oauthWrapper.AuthorizationCode = code; ShowOauthPanel(false); }
public Login() { this.InitializeComponent(); Window.Current.SetTitleBar(TitleBarElement); Window.Current.Activated += OnWindowFocusChange; Window.Current.SizeChanged += OnWindowSizeChanged; LoginWebview.Height = Window.Current.Bounds.Height * 0.8; WebviewPopup.VerticalOffset = -(LoginWebview.Height / 2); LoginWebview.NavigationStarting += async(view, args) => { // Clearing challenge if (args.Uri.PathAndQuery == "/" || string.IsNullOrEmpty(args.Uri.PathAndQuery)) { WebviewPopup.IsOpen = false; } // Facebook OAuth Login if (args.Uri.PathAndQuery.Contains("accounts/signup", StringComparison.OrdinalIgnoreCase)) { // Uri looks like this: https://www.instagram.com/accounts/signup/?#access_token=... WebviewPopup.IsOpen = false; FbLoginButton.IsEnabled = false; try { var query = args.Uri.Fragment.Substring(1); // turn fragment into query (remove the '#') var urlParams = new WwwFormUrlDecoder(query); var fbToken = urlParams.GetFirstValueByName("access_token"); if (string.IsNullOrEmpty(fbToken)) { await ShowLoginErrorDialog("Failed to acquire access token"); FbLoginButton.IsEnabled = true; return; } var result = await _viewModel.LoginWithFacebook(fbToken).ConfigureAwait(true); if (!result.IsSucceeded) { await ShowLoginErrorDialog(result.Message); FbLoginButton.IsEnabled = true; return; } Frame.Navigate(typeof(MainPage)); } catch (Exception e) { await ShowLoginErrorDialog( "Unexpected error occured while logging in with Facebook. Please try again later or log in with Instagram account instead."); #if !DEBUG Crashes.TrackError(e); #endif } } }; }
public void Test_BuildUri_1() { Dictionary <string, string> queryPairs = new Dictionary <string, string> { { "type", "CHAT" }, { "msgId", "[email protected]_SOME_MESSAGE_ID" }, }; Uri result = UriUtils.buildUri("*****@*****.**", queryPairs); Assert.IsTrue(result.Scheme.Equals(UriUtils.URI_SCHEME)); Assert.IsTrue(UriUtils.getBareJidFromUri(result).Equals("*****@*****.**")); WwwFormUrlDecoder decoder = UriUtils.parseUriQuery(result); Assert.AreEqual(decoder.GetFirstValueByName("type"), "CHAT"); Assert.AreEqual(decoder.GetFirstValueByName("msgId"), "[email protected]_SOME_MESSAGE_ID"); }
protected override async void OnActivated(IActivatedEventArgs e) { if (e.Kind == ActivationKind.Protocol) { //#pragma warning disable UWP003 // UWP-only // await FullTrustProcessLauncher.LaunchFullTrustProcessForCurrentAppAsync(); //#pragma warning restore UWP003 // UWP-only ProtocolActivatedEventArgs protocolArgs = (ProtocolActivatedEventArgs)e; Uri uri = protocolArgs.Uri; if (uri.Scheme == "live.wallpaper.store") { if (!string.IsNullOrEmpty(uri.Query)) { WwwFormUrlDecoder decoder = new WwwFormUrlDecoder(uri.Query); if (decoder.Count > 0) { string host = null, wallpaperDir = null; try { host = decoder.GetFirstValueByName("host"); wallpaperDir = decoder.GetFirstValueByName("wallpaper"); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex); } //var setting = new SettingObject //{ // //Server = new ServerSetting // //{ // // ServerUrl = host // //}, // //General = new GeneralSetting() // //{ // // WallpaperSaveDir = wallpaperDir // //} //}; //await ApplicationData.Current.LocalSettings.SaveAsync("config", setting); } } await ActivationService.ActivateAsync(e); } } }
private async Task LoadReportAsync() { if (Uri.TryCreate(EmbedUrl, UriKind.Absolute, out Uri embedUri)) { string token = await GetUserTokenAsync(); if (!string.IsNullOrEmpty(token) && embedUri.Query.IndexOf("reportid", StringComparison.OrdinalIgnoreCase) != -1 && embedUri.Query.IndexOf("groupid", StringComparison.OrdinalIgnoreCase) != -1) { var tokenCredentials = new TokenCredentials(token, "Bearer"); using (var client = new PowerBIClient(new Uri(ApiUrl), tokenCredentials)) { var decoder = new WwwFormUrlDecoder(embedUri.Query.ToLower()); string groupId = decoder.GetFirstValueByName("groupid"); string reportId = decoder.GetFirstValueByName("reportid"); Report report = await client.Reports.GetReportAsync(groupId, reportId); if (report != null) { InvokeScriptAsync($"loadGroups(" + $"'{token}', " + $"{JsonConvert.SerializeObject(new Report[] { report })}, " + $"{JsonConvert.SerializeObject(report)}, " + (IsWindowsPhone ? $"'{DisplayInformation.CurrentOrientation.ToString()}'," : "'', ") + $"{ShowFilter.ToString().ToLower()}" + ")"); return; } } } ClearReport(); } else { throw new ArgumentException(nameof(EmbedUrl)); } }
public static int GetInt32(this WwwFormUrlDecoder query, string key) { try { return(query.GetFirstValueByName(key).QueryValueAsInt32()); } catch (ArgumentException) { return(0); } }
private async void ShowPopup(string parameter) { WwwFormUrlDecoder decoder = new WwwFormUrlDecoder(parameter); Debug.WriteLine(decoder.GetFirstValueByName("num")); Debug.WriteLine(decoder.GetFirstValueByName("offset")); var menu = new PopupMenu(); menu.Commands.Add(new UICommand("Citer", (command) => { Debug.WriteLine("VM Open param=" + parameter); })); var chosenCommand = await menu.ShowAsync(new Point(100, Convert.ToDouble(decoder.GetFirstValueByName("offset")) + 44.0)); if (chosenCommand == null) { Debug.WriteLine("VM Dismiss param=" + parameter); } }
public static string GetString(this WwwFormUrlDecoder query, string key) { try { return(query.GetFirstValueByName(key)); } catch (ArgumentException) { return(null); } }
static string GetDecoderField(WwwFormUrlDecoder decoder, string key) { try { return(decoder.GetFirstValueByName(key)); } catch (Exception) { return(String.Empty); } }
private string GetValue(WwwFormUrlDecoder decoder, string key, string defaultValue = null) { try { return(decoder.GetFirstValueByName(key)); } catch (ArgumentException) { return(defaultValue); } }
public static bool GetBoolean(this WwwFormUrlDecoder query, string key) { try { return(query.GetFirstValueByName(key).QueryValueAsBoolean()); } catch (ArgumentException) { return(false); } }