GetFirstValueByName() 공개 메소드

public GetFirstValueByName ( [ name ) : string
name [
리턴 string
        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);
            }
        }
        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();
            }
        }
예제 #3
0
        private string ExtractCode(string redirectedUrl)
        {
            var url = new Uri(redirectedUrl);
            var decoder = new WwwFormUrlDecoder(url.Query);

            return decoder.GetFirstValueByName("code");
        }
        /// <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());
            }
        }
예제 #5
0
        public static async Task<string> GetAccessToken(string username, string password)
        {
            try
            {
                var handler = new HttpClientHandler
                {
                    AutomaticDecompression = DecompressionMethods.GZip,
                    AllowAutoRedirect = false
                };

                using (var tempHttpClient = new HttpClient(handler))
                {
                    //Get session cookie
                    var sessionResp = await tempHttpClient.GetAsync(Resources.PtcLoginUrl);
                    var data = await sessionResp.Content.ReadAsStringAsync();
                    var lt = JsonHelper.GetValue(data, "lt");
                    var executionId = JsonHelper.GetValue(data, "execution");

                    //Login
                    var loginResp = await tempHttpClient.PostAsync(Resources.PtcLoginUrl,
                        new FormUrlEncodedContent(
                            new[]
                            {
                                new KeyValuePair<string, string>("lt", lt),
                                new KeyValuePair<string, string>("execution", executionId),
                                new KeyValuePair<string, string>("_eventId", "submit"),
                                new KeyValuePair<string, string>("username", username),
                                new KeyValuePair<string, string>("password", password)
                            }));

                    var decoder = new WwwFormUrlDecoder(loginResp.Headers.Location.Query);
                    var ticketId = decoder.GetFirstValueByName("ticket");
                    if (string.IsNullOrEmpty(ticketId))
                        throw new PtcOfflineException();

                    //Get tokenvar 
                    var tokenResp = await tempHttpClient.PostAsync(Resources.PtcLoginOauth,
                        new FormUrlEncodedContent(
                            new[]
                            {
                                new KeyValuePair<string, string>("client_id", "mobile-app_pokemon-go"),
                                new KeyValuePair<string, string>("redirect_uri",
                                    "https://www.nianticlabs.com/pokemongo/error"),
                                new KeyValuePair<string, string>("client_secret",
                                    "w8ScCUXJQc6kXKw8FiOhd8Fixzht18Dq3PEVkUCP5ZPxtgyWsbTvWHFLm2wNY0JR"),
                                new KeyValuePair<string, string>("grant_type", "refresh_token"),
                                new KeyValuePair<string, string>("code", ticketId)
                            }));

                    var tokenData = await tokenResp.Content.ReadAsStringAsync();
                    decoder = new WwwFormUrlDecoder(tokenData);
                    return decoder.GetFirstValueByName("access_token");
                }
            }
            catch (Exception)
            {
                return string.Empty;
            }
        }
예제 #6
0
        public async Task<bool> CompleteOAuthFlowAsync(string responseData)
        {
            // responseData value eg http://example.com/path?code=4cba03187d6cd6720217&state=6dfa60685ac94a29bdde2d9f3cbdce0e
            var responseUri = new Uri(responseData);
            var decoder = new WwwFormUrlDecoder(responseUri.Query);
            var code = decoder.GetFirstValueByName("code");
            var state = decoder.GetFirstValueByName("state");

            string storedState = VaultManager.GetPassword(VaultStateResourceKey, VaultDefaultUnusedUserName);
            if (storedState != state)
                return false;

            // We are storing the code to later be able to refresh the access token
            VaultManager.Save(VaultTokenCodeResourceKey, VaultDefaultUnusedUserName, code);

            bool ok = await AcquireAccessTokenAsync(code, state).ConfigureAwait(false); ;
            return ok;
        }
예제 #7
0
 public static string GetQueryParameter(this Uri uri, string parameterName)
 {
     string query = uri.Query;
     if (query.Length <= 1)
     {
         return null;
     }
     WwwFormUrlDecoder decoder = new WwwFormUrlDecoder(query);
     return decoder.GetFirstValueByName(parameterName);
 }
예제 #8
0
파일: Login.xaml.cs 프로젝트: olegkalyta/VK
        private void webView_LoadCompleted(object sender, NavigationEventArgs e)
        {
            if (e.Uri.AbsoluteUri.Contains("access_token")) {
                WwwFormUrlDecoder decoder = new WwwFormUrlDecoder(e.Uri.AbsoluteUri);

                long uID = 0;
                long.TryParse(decoder.GetFirstValueByName("user_id"), out uID);

                storage.SetToken(
                    decoder.GetFirstValueByName(Constants.TokenMarker));

                storage.SetCurrUserID(uID);

                this.Frame.Navigate(typeof(MyProfile));
            }
            else {
                progressRing.IsActive = false;
                webView.Visibility = Windows.UI.Xaml.Visibility.Visible;
            }
        }
예제 #9
0
        private async Task<string> GetTokenFromCode(string code)
        {
            var uri = $"{TokenUri}?client_id={Credentials.AppId}&client_secret={Credentials.AppSecret}&code={code}";
            using (var client = new HttpClient())
            {
                var response = await client.PostAsync(uri, null);
                var query = await response.Content.ReadAsStringAsync();

                var decoder = new WwwFormUrlDecoder(query);
                return decoder.GetFirstValueByName("access_token");
            }
        }
 private static IEnumerable<VideoInfo> GetVideoInfos(string source)
 {
     var t = new WwwFormUrlDecoder(source);
     var videoTitle = t.GetFirstValueByName("title");
     var splitByUrls = t.GetFirstValueByName("url_encoded_fmt_stream_map").Split(',');
     var videoInfos = new List<VideoInfo>();
     foreach (var s in splitByUrls) {
         var queries = new WwwFormUrlDecoder(s);
         var url = queries.GetFirstValueByName("url");
         var decoder = new WwwFormUrlDecoder(url.Substring(url.IndexOf('?')));
         byte formatCode;
         if (!Byte.TryParse(decoder.GetFirstValueByName("itag"), out formatCode)) continue;
         var fallbackHost = WebUtility.UrlDecode(queries.GetFirstValueByName("fallback_host"));
         var sig = WebUtility.UrlDecode(queries.GetFirstValueByName("sig"));
         var item = VideoInfo.Defaults.SingleOrDefault(videoInfo => videoInfo.FormatCode == formatCode);
         var info = item != null ? item.Clone() : new VideoInfo(formatCode);
         info.DownloadUri = new Uri(url + "&fallback_host=" + fallbackHost + "&signature=" + sig);
         info.Title = videoTitle;
         videoInfos.Add(info);
     }
     return videoInfos;
 }
예제 #11
0
        private static string ExtracktTicketFromResponse(HttpResponseMessage loginResp)
        {
            var location = loginResp.Headers.Location;
            if (location == null)
                throw new LoginFailedException(loginResp);

            var decoder = new WwwFormUrlDecoder(loginResp.Headers.Location.Query);
            var ticketId = decoder.GetFirstValueByName("ticket");

            if (ticketId == null)
                throw new PtcOfflineException();

            return ticketId;
        }
 public static async Task<ExternalLoginResult> GetExternalAccessTokenAsync(string externalLoginUri, bool silentMode = false)
 {
     Uri authorizationRequestUri = new Uri(new Uri(ClientFactory.BaseAddress), externalLoginUri);
     WebAuthenticationOptions webAuthenticationOptions = silentMode ? WebAuthenticationOptions.SilentMode : WebAuthenticationOptions.None;
     WebAuthenticationResult authenticationResult = await WebAuthenticationBroker.AuthenticateAsync(webAuthenticationOptions, authorizationRequestUri);
     ExternalLoginResult loginExternalResult = new ExternalLoginResult() { WebAuthenticationResult = authenticationResult };
     if (authenticationResult.ResponseStatus == WebAuthenticationStatus.Success)
     {
         Uri responseDataUri = new Uri(authenticationResult.ResponseData);
         string fragment = responseDataUri.Fragment;
         if (fragment != null && fragment.Length > 0)
         {
             WwwFormUrlDecoder wwwFormUrlDecoder = new WwwFormUrlDecoder(fragment.Substring(1));
             loginExternalResult.AccessToken = wwwFormUrlDecoder.GetFirstValueByName("access_token");
         }
     }
     return loginExternalResult;
 }
예제 #13
0
        protected override void OnActivated(IActivatedEventArgs args)
        {
            if (args.Kind == ActivationKind.Protocol)
            {
                var commandArgs = args as ProtocolActivatedEventArgs;
                Windows.Foundation.WwwFormUrlDecoder decoder =
                    new Windows.Foundation.WwwFormUrlDecoder(commandArgs.Uri.Query);
                var destination = decoder.GetFirstValueByName("LaunchContext");

                string uriToLaunch = destination;
                var    uri         = new Uri(uriToLaunch);

                var success = Windows.System.Launcher.LaunchUriAsync(uri);

                Application.Current.Exit();

                // this.Suspending += OnSuspending;
            }

            //  base.OnActivated(args);
        }
예제 #14
0
		public async Task Can_Authenticate_With_OAuth()
		{
            WwwFormUrlDecoder decoder;

			const string consumerKey = "";
			const string consumerSecret = "";

			var baseUrl = "http://api.twitter.com";
			var client = new RestClient(baseUrl);
			client.Authenticator = OAuth1Authenticator.ForRequestToken(consumerKey, consumerSecret);
			var request = new RestRequest("oauth/request_token", Method.POST);
			var response = await client.ExecuteAsync(request);

			Assert.IsNotNull(response);
			Assert.AreEqual( (int)HttpStatusCode.OK, response.StatusCode);

            decoder = new WwwFormUrlDecoder(response.Content);
            var oauth_token = decoder.GetFirstValueByName("oauth_token");
            var oauth_token_secret = decoder.GetFirstValueByName("oauth_token_secret");
            
            //var qs = HttpUtility.ParseQueryString(response.Content);
            //var oauth_token = qs["oauth_token"];
            //var oauth_token_secret = qs["oauth_token_secret"];

            Assert.IsNotNull(oauth_token);
			Assert.IsNotNull(oauth_token_secret);

			request = new RestRequest("oauth/authorize");
			request.AddParameter("oauth_token", oauth_token);
			var url = client.BuildUri(request).ToString();
			//Process.Start(url);

			var verifier = "123456"; // <-- Breakpoint here (set verifier in debugger)
			request = new RestRequest("oauth/access_token", Method.POST);
			client.Authenticator = OAuth1Authenticator.ForAccessToken(
				consumerKey, consumerSecret, oauth_token, oauth_token_secret, verifier
			);
			response = await client.ExecuteAsync(request);

			Assert.IsNotNull(response);
			Assert.AreEqual( (int)HttpStatusCode.OK, response.StatusCode);

			//qs = HttpUtility.ParseQueryString(response.Content);
            decoder = new WwwFormUrlDecoder(response.Content);
            oauth_token = decoder.GetFirstValueByName("oauth_token");
            oauth_token_secret = decoder.GetFirstValueByName("oauth_token_secret");

            //oauth_token = qs["oauth_token"];
            //oauth_token_secret = qs["oauth_token_secret"];

			Assert.IsNotNull(oauth_token);
			Assert.IsNotNull(oauth_token_secret);

			request = new RestRequest("account/verify_credentials.xml");
			client.Authenticator = OAuth1Authenticator.ForProtectedResource(
				consumerKey, consumerSecret, oauth_token, oauth_token_secret
			);

			response = await client.ExecuteAsync(request);

			Assert.IsNotNull(response);
			Assert.AreEqual( (int)HttpStatusCode.OK, response.StatusCode);

			//request = new RestRequest("statuses/update.json", Method.POST);
			//request.AddParameter("status", "Hello world! " + DateTime.Now.Ticks.ToString());
			//client.Authenticator = OAuth1Authenticator.ForProtectedResource(
			//    consumerKey, consumerSecret, oauth_token, oauth_token_secret
			//);

			//response = client.Execute(request);

			//Assert.NotNull(response);
			//Assert.Equal(HttpStatusCode.OK, response.StatusCode);
		}
예제 #15
0
        public async Task<List<VideoItem>> ParseAsync(string url)
        {
            var id = GetVideoId(url);
            AssertUtil.HasText(id, "no id");

            var query = string.Format(Api, id);
            var result = await _httpClientService.GetStringAsync(query);
            AssertUtil.HasText(result, "no info from server");

            var form = new WwwFormUrlDecoder(result);
            var adaptiveFmts = form.GetFirstValueByName("adaptive_fmts");
            AssertUtil.HasText(result, "no videos");

            var adaptiveFmtsform = new WwwFormUrlDecoder(adaptiveFmts);

            //TODO    test only
            var dic = new Dictionary<string, string>();
            var quality = "";
            var type = "";
            foreach (var item in adaptiveFmtsform)
            {
                var key = item.Name;
                var value = item.Value;
                Debug.WriteLine(key + ":" + value);
                if ("url" == key)
                {
                    if (type.Contains("codecs=\"avc"))
                    {
                        dic.Add(quality, value);
                    }
                }
                else if ("quality_label" == key)
                {
                    quality = value;
                }
                else if ("type" == key)
                {
                    type = value;
                }
            }


            var videoUrl = "";
            if (dic.ContainsKey("1080p"))
            {
                videoUrl = dic["1080p"];
            }
            else if (dic.ContainsKey("1080p60"))
            {
                videoUrl = dic["1080p60"];
            }
            else if (dic.ContainsKey("720p60"))
            {
                videoUrl = dic["720p60"];
            }
            else if (dic.ContainsKey("720p"))
            {
                videoUrl = dic["720p"];
            }
            else if (dic.ContainsKey("480p"))
            {
                videoUrl = dic["480p"];
            }
            else if (dic.ContainsKey("240p"))
            {
                videoUrl = dic["240p"];
            }
            else if (dic.ContainsKey("144p"))
            {
                videoUrl = dic["144p"];
            }


            var videoItem = new VideoItem { Url = videoUrl };
            var items = new List<VideoItem>(1) { videoItem };
            return items;
        }
예제 #16
0
		public async void Can_Authenticate_LinkedIN_With_OAuth()
		{
            WwwFormUrlDecoder decoder;

			const string consumerKey = "TODO_CONSUMER_KEY_HERE";
			const string consumerSecret = "TODO_CONSUMER_SECRET_HERE";

			// request token
			var client = new RestClient {
				BaseUrl = "https://api.linkedin.com/uas/oauth",
				Authenticator = OAuth1Authenticator.ForRequestToken( consumerKey, consumerSecret, "http://localhost" )
			};
			var requestTokenRequest = new RestRequest( "requestToken" );
			var requestTokenResponse = await client.ExecuteAsync( requestTokenRequest );
			Assert.IsNotNull( requestTokenResponse );
			Assert.AreEqual( (int)HttpStatusCode.OK, requestTokenResponse.StatusCode );

            decoder = new WwwFormUrlDecoder(requestTokenResponse.Content);
            var requestToken = decoder.GetFirstValueByName("oauth_token");
            var requestSecret = decoder.GetFirstValueByName("oauth_token_secret");

            //var requestTokenResponseParameters = HttpUtility.ParseQueryString( requestTokenResponse.Content );
            //var requestToken = requestTokenResponseParameters[ "oauth_token" ];
            //var requestSecret = requestTokenResponseParameters[ "oauth_token_secret" ];
			
            Assert.IsNotNull( requestToken );
			Assert.IsNotNull( requestSecret );

			// redirect user
			requestTokenRequest = new RestRequest( "authenticate?oauth_token=" + requestToken );
			var redirectUri = client.BuildUri( requestTokenRequest );

            //Process.Start( redirectUri.ToString() );
			
            var requestUrl = "TODO: put browser URL here"; // replace this via the debugger with the return url from LinkedIN. Simply copy it from the opened browser
			if ( !Debugger.IsAttached )
			{
				Debugger.Launch();
			}
			Debugger.Break();

			// get the access token
            decoder = new WwwFormUrlDecoder(new Uri(requestUrl).Query);
            var requestVerifier = decoder.GetFirstValueByName("oauth_verifier");
            
			//var requestTokenQueryParameters = HttpUtility.ParseQueryString( new Uri( requestUrl ).Query );
			//var requestVerifier = requestTokenQueryParameters[ "oauth_verifier" ];

			client.Authenticator = OAuth1Authenticator.ForAccessToken( consumerKey, consumerSecret, requestToken, requestSecret, requestVerifier );
			var requestAccessTokenRequest = new RestRequest( "accessToken" );
			var requestActionTokenResponse = await client.ExecuteAsync( requestAccessTokenRequest );
			Assert.IsNotNull( requestActionTokenResponse );
			Assert.AreEqual( (int)HttpStatusCode.OK, requestActionTokenResponse.StatusCode );

            decoder = new WwwFormUrlDecoder(requestActionTokenResponse.Content);
            var accessToken = decoder.GetFirstValueByName("oauth_token");
            var accessSecret = decoder.GetFirstValueByName("oauth_token_secret");

            //var requestActionTokenResponseParameters = HttpUtility.ParseQueryString( requestActionTokenResponse.Content );
            //var accessToken = requestActionTokenResponseParameters[ "oauth_token" ];
            //var accessSecret = requestActionTokenResponseParameters[ "oauth_token_secret" ];
			
            Assert.IsNotNull( accessToken );
			Assert.IsNotNull( accessSecret );
		}
예제 #17
0
        public static string ExtractParamterFromQuery(this Uri uri, string parameterName)
        {
            var urlDecoder = new WwwFormUrlDecoder(uri.Query);

            return urlDecoder.GetFirstValueByName(parameterName);
        }
예제 #18
0
		//[Fact]
		public async void Can_Authenticate_Netflix_With_OAuth()
		{
            WwwFormUrlDecoder decoder;

            const string consumerKey = "";
			const string consumerSecret = "";

			var baseUrl = "http://api.netflix.com";
			var client = new RestClient(baseUrl);
			client.Authenticator = OAuth1Authenticator.ForRequestToken(consumerKey, consumerSecret);
			var request = new RestRequest("oauth/request_token");
			var response = await client.ExecuteAsync(request);

			Assert.IsNotNull(response);
			Assert.AreEqual( (int)HttpStatusCode.OK, response.StatusCode);

            decoder = new WwwFormUrlDecoder(response.Content);
            var oauth_token = decoder.GetFirstValueByName("oauth_token");
            var oauth_token_secret = decoder.GetFirstValueByName("oauth_token_secret");
            var applicationName = decoder.GetFirstValueByName("application_name");

            //var qs = HttpUtility.ParseQueryString(response.Content);
            //var oauth_token = qs["oauth_token"];
            //var oauth_token_secret = qs["oauth_token_secret"];
            //var applicationName = qs["application_name"];
			
            Assert.IsNotNull(oauth_token);
			Assert.IsNotNull(oauth_token_secret);
			Assert.IsNotNull(applicationName);

			var baseSslUrl = "https://api-user.netflix.com";
			var sslClient = new RestClient(baseSslUrl);
			request = new RestRequest("oauth/login");
			request.AddParameter("oauth_token", oauth_token);
			request.AddParameter("oauth_consumer_key", consumerKey);
			request.AddParameter("application_name", applicationName);
			var url = sslClient.BuildUri(request).ToString();
			
			//Process.Start(url);

			request = new RestRequest("oauth/access_token"); // <-- Breakpoint here, login to netflix
			client.Authenticator = OAuth1Authenticator.ForAccessToken(
				consumerKey, consumerSecret, oauth_token, oauth_token_secret
			);
			response = await client.ExecuteAsync(request);

			Assert.IsNotNull(response);
			Assert.AreEqual( (int)HttpStatusCode.OK, response.StatusCode);

            decoder = new WwwFormUrlDecoder(response.Content);
            oauth_token = decoder.GetFirstValueByName("oauth_token");
            oauth_token_secret = decoder.GetFirstValueByName("oauth_token_secret");
            var user_id = decoder.GetFirstValueByName("user_id");

            //qs = HttpUtility.ParseQueryString(response.Content);
            //oauth_token = qs["oauth_token"];
            //oauth_token_secret = qs["oauth_token_secret"];
            //var user_id = qs["user_id"];
			
            Assert.IsNotNull(oauth_token);
			Assert.IsNotNull(oauth_token_secret);
			Assert.IsNotNull(user_id);

			client.Authenticator = OAuth1Authenticator.ForProtectedResource(consumerKey, consumerSecret, oauth_token, oauth_token_secret);
			request = new RestRequest("users/{user_id}/queues/disc");
			request.AddUrlSegment("user_id", user_id);
			request.AddParameter("max_results", "2");

			var queueResponse = await client.ExecuteAsync(request); //
            var deserializer = new RestRT.Deserializers.JsonDeserializer();
            var result = (Queue)deserializer.Deserialize(response, typeof(Queue));


			Assert.IsNotNull(queueResponse);
			Assert.AreEqual( (int)HttpStatusCode.OK, queueResponse.StatusCode);

			Assert.IsNotNull(result);
			Assert.AreEqual(2, result.Items.Count);
		}
 // return series ID
 static string ParseIDFromBookLink(string link)
 {
     Uri uri = new Uri(SeverBaseUri, link);
     var decoder = new WwwFormUrlDecoder(uri.Query);
     return decoder.GetFirstValueByName("id");
 }
예제 #20
0
        public SaveParameters(string uri)
        {
            // Restor de recursos
            ResourceLoader labels = new Windows.ApplicationModel.Resources.ResourceLoader();

            // Analizador de parametros en URL
            WwwFormUrlDecoder decoder;
            try
            {
                decoder = new WwwFormUrlDecoder(uri.Substring(uri.IndexOf("?"), uri.Length - uri.IndexOf("?")));
            }
            catch (Exception)
            {
                throw new ParameterException(labels.GetString("Error_parametros") + " (ERR:W00)");
            }

            // Comprobamos los parámetros obligatorios uno a uno

            // Nombre del fichero (opcional)
            try
            {
                this.fileName = decoder.GetFirstValueByName(FILENAME);
            }
            catch (Exception)
            {
                fileName = null;
            }

            // Extensión del fichero (opcional)
            try
            {
                this.extension = decoder.GetFirstValueByName(EXTENSION);
                if (!this.extension.StartsWith("."))
                {
                    this.extension = "." + this.extension;
                }
            }
            catch (Exception)
            {
                this.extension = EXTENSION_DEFAULT;
            }

            // Descripción del fichero (opcional)
            try
            {
                this.description = decoder.GetFirstValueByName(DESCRIPTION);
            }
            catch (Exception)
            {
                this.description = null;
            }

            // Entorno GUI de origen (opcional, en caso de error o ausencia se toma el escritorio clásico como origen)
            try
            {
                Boolean.TryParse(decoder.GetFirstValueByName(FROM), out this.metro);
            }
            catch (Exception)
            {
                metro = false;
            }

            // ***********************
            // *** Datos a guardar ***
            // ***********************
            string dataBase64 = null;
            try
            {
                dataBase64 = decoder.GetFirstValueByName(DATA);
            }
            catch (Exception)
            {
                throw new ParameterException(labels.GetString("Error_parametros") + " (ERR:W02)");
            }

            // Deshacemos la codificación URL si existiese
            dataBase64 = dataBase64.Replace('_', '/').Replace('-', '+');
            try
            {
                // Guardamos los datos descodificados
                this.data = Convert.FromBase64String(dataBase64);
            }
            catch (Exception)
            {
                throw new ParameterException(labels.GetString("Error_parametros") + " (ERR:W10)");
            }
        }
예제 #21
0
        public SignParameters(string uri)
        {
            // Restor de recursos
            ResourceLoader labels = new Windows.ApplicationModel.Resources.ResourceLoader();

            // Analizador de parametros en URL
            WwwFormUrlDecoder decoder;
            try
            {
                decoder = new WwwFormUrlDecoder(uri.Substring(uri.IndexOf("?"), uri.Length - uri.IndexOf("?")));
            }
            catch (Exception)
            {
                throw new ParameterException(labels.GetString("Error_parametros") + " (ERR:W00)");
            }

            // Comprobamos los parámetros obligatorios uno a uno

            // Direccion del servlet de almacenamiento, comprobamos que exista y que sea una URI
            // valida con http o https
            string servlet;
            try
            {
                servlet = decoder.GetFirstValueByName(SERVLET_STORAGE);
            }
            catch (Exception)
            {
                throw new ParameterException(labels.GetString("Error_parametros") + " (ERR:W01)");
            }
            try
            {
                this.servletUri = new Uri(servlet);
            }
            catch (Exception)
            {
                throw new ParameterException(labels.GetString("Error_parametros") + " (ERR:W02)");
            }
            if (servletUri.Scheme != "http" && servletUri.Scheme != "https")
            {
                throw new ParameterException(labels.GetString("Error_parametros") + " (ERR:W03)");
            }

            // Id del fichero a firmar.
            try
            {
                this.id = decoder.GetFirstValueByName(ID);
            }
            catch (Exception)
            {
                throw new ParameterException(labels.GetString("Error_parametros") + " (ERR:W04)");
            }

            // Formato de firma (CAdES, XAdES, PAdES...)
            try
            {
                this.format = decoder.GetFirstValueByName(FORMAT);
            }
            catch (Exception)
            {
                throw new ParameterException(labels.GetString("Error_parametros") + " (ERR:W05)");
            }
            if (!supportedSignatureFormats.Contains(this.format.ToLower()))
            {
                throw new UnsupportedSignatureFormat(this.format);
            }

            // Algoritmo de firma (SHA1withRSA, SHA512withRSA, etc.)
            try
            {
                this.algorithm = decoder.GetFirstValueByName(ALGORITHM);
            }
            catch (Exception)
            {
                throw new ParameterException(labels.GetString("Error_parametros") + " (ERR:W06)");
            }
            if (!supportedSignatureAlgorithms.Contains(this.algorithm))
            {
                throw new UnsupportedSignatureAlgorithm(this.algorithm);
            }

            // Propiedades adicionales
            string base64Properties = null;
            try
            {
                base64Properties = decoder.GetFirstValueByName(PROPERTIES);
            }
            catch(Exception)
            {
                this.properties = new Dictionary<string,string>();
            }
            if (base64Properties != null)
            {
                // Deshacemos la codificacion URL si existiese
                base64Properties = base64Properties.Replace('_', '/').Replace('-', '+');
                // Deshacemos el Base64
                try
                {
                    byte[] binaryProperties = Convert.FromBase64String(base64Properties);
                    this.properties = Properties2Dictionary(System.Text.Encoding.UTF8.GetString(binaryProperties, 0, binaryProperties.Length));
                }
                catch (Exception)
                {
                    throw new ParameterException(labels.GetString("Error_parametros") + " (ERR:W07)");
                }
            }

            // Entorno GUI de origen (opcional, en caso de error o ausencia se toma el escritorio clásico como origen)
            try
            {
                Boolean.TryParse(decoder.GetFirstValueByName(FROM), out this.metro);
            }
            catch (Exception)
            {
                metro = false;
            }

            // Clave DES de cifrado
            string key;
            try
            {
                key = decoder.GetFirstValueByName(KEY);
            }
            catch (Exception)
            {
                throw new ParameterException(labels.GetString("Error_parametros") + " (ERR:W08)");
            }
            this.desKey = key;
            if (this.desKey.Length != 8)
            {
                throw new ParameterException(labels.GetString("Error_parametros") + " (ERR:W09)");
            }

            // Datos a firmar
            string dataBase64;
            try
            {
                dataBase64 = decoder.GetFirstValueByName(DATA);
            }
            catch (Exception)
            {
                dataBase64 = null;
            }
            // Nos pasan los datos en la URL
            if (dataBase64 != null)
            {
                // Deshacemos la codificación URL si existiese
                dataBase64 = dataBase64.Replace('_', '/').Replace('-', '+');
                try
                {
                    // Guardamos los datos descodificados
                    this.data = Convert.FromBase64String(dataBase64);
                }
                catch (Exception)
                {
                    throw new ParameterException(labels.GetString("Error_parametros") + " (ERR:W10)");
                }
            }
            //no tiene sentido esto aqui.
            //this.data = null;
        }
예제 #22
0
        private static async Task<string> GetToken(System.Net.Http.HttpClient tempHttpClient, string ticketId)
        {
            HttpResponseMessage tokenResp;
            var tokenRequest = GenerateTokenVarRequest(ticketId);
            using (var formUrlEncodedContent = new FormUrlEncodedContent(tokenRequest))
            {
                tokenResp = await tempHttpClient.PostAsync(Resources.PtcLoginOauth, formUrlEncodedContent).ConfigureAwait(false);
            }

            var tokenData = await tokenResp.Content.ReadAsStringAsync().ConfigureAwait(false);
            var decoder = new WwwFormUrlDecoder(tokenData);
            return decoder.GetFirstValueByName("access_token");
        }
예제 #23
0
        /**
         * Launch the oAuth User Agent login dialog
         **/
        public async Task<String> oAuthUserAgentFlow()
        {
            //if we already have an Access Token, just return that
            if (AccessToken != "")
            {
                return AccessToken;
            }

            //If we have a refresh token available, use the Refresh Token flow to get a new Access Token
            if (RefreshToken != "" && RefreshToken != null)
            {
                AccessToken = await RefreshTokenFlow();
                return AccessToken;
            }

            //prepare the request uri and the callback uri
            Uri requestUri = new Uri("https://login.salesforce.com/services/oauth2/authorize?response_type=token&display=touch&client_id="+ConsumerKey+"&redirect_uri="+WebUtility.UrlEncode(RedirectUri));
            Uri callbackUri = new Uri(RedirectUri);

            //launch the authentication process using WebAuthenticationBroker
            WebAuthenticationResult webAuthenticationResult = await WebAuthenticationBroker.AuthenticateAsync(WebAuthenticationOptions.None, requestUri, callbackUri);
            if (webAuthenticationResult.ResponseStatus == WebAuthenticationStatus.Success)
            {
                //parse the response Uri to get access token, etc.
                Uri responseUri = new Uri(webAuthenticationResult.ResponseData.ToString());
                //just treat it as a query string so we can use WwwFormUrlDecoder to parse it
                WwwFormUrlDecoder decoder = new WwwFormUrlDecoder(responseUri.Fragment.Replace("#", "?"));
                AccessToken = decoder.GetFirstValueByName("access_token");
                RefreshToken = decoder.GetFirstValueByName("refresh_token");
                InstanceUrl = WebUtility.UrlDecode(decoder.GetFirstValueByName("instance_url"));
                PersistData.SetSerializedValue("instance_url", InstanceUrl);
                Debug.WriteLine("Access Token: "+AccessToken);
                return AccessToken;
            }
            else
            {
                return "";
            }
        }
예제 #24
0
        private async Task ProcessCommand(WwwFormUrlDecoder querybag, IOutputStream outstream)
        {
            try
            {
                if (!bot.HasArduino)
                {
                    throw new IOException("No Arduino Device Connected");
                }

                string botCmd = querybag.GetFirstValueByName("cmd").ToLowerInvariant(); // Throws System.ArgumentException if not found
                switch (botCmd)
                {
                    case "stop":
                        {
                            await bot.Stop();
                            await WriteResponseAsync("200 OK", successMsg, outstream);
                            break;
                        }
                    case "status":
                        {
                            if (bot.IsMoving)
                            {
                                float moveProgress = bot.MoveProgress;
                                var moveProg = Math.Floor(moveProgress * 100.0f);

                                string s = "{command=\"" + lastCommand + "\", percent=\"" + moveProg.ToString() + "\"}";
                                await WriteResponseAsync("200 OK", s, outstream);
                            }
                            else
                            {
                                string s = "{command=\"" + lastCommand + "\"}";
                                await WriteResponseAsync("200 OK", s, outstream);
                            }

                            break;
                        }
                    case "move":
                        {
                            float dst = float.Parse(querybag.GetFirstValueByName("dst"));
                            await bot.Move(dst);
                            await WriteResponseAsync("200 OK", successMsg, outstream);
                            break;
                        }
                    case "movelr":
                        {
                            float dstl = float.Parse(querybag.GetFirstValueByName("dstl"));
                            float dstr = float.Parse(querybag.GetFirstValueByName("dstr"));
                            await bot.Move(dstl, dstr);
                            await WriteResponseAsync("200 OK", successMsg, outstream);
                            break;
                        }
                    case "setcolor":
                        {
                            byte r = 0;
                            byte g = 0;
                            byte b = 0;

                            // queryBag will throw an exception if it doesn't find it. 
                            // And you can't query if it is there.
                            try
                            {
                                r = byte.Parse(querybag.GetFirstValueByName("r"));
                            }
                            catch
                            { }

                            try
                            {
                                g = byte.Parse(querybag.GetFirstValueByName("g"));
                            }
                            catch
                            { }

                            try
                            {
                                b = byte.Parse(querybag.GetFirstValueByName("b"));
                            }
                            catch
                            { }

                            await bot.SetLedColor(r, g, b);
                            await WriteResponseAsync("200 OK", successMsg, outstream);
                            break;
                        }
                    case "rotate":
                        {
                            float deg = float.Parse(querybag.GetFirstValueByName("deg"));
                            await bot.Rotate(deg);
                            await WriteResponseAsync("200 OK", successMsg, outstream);
                            break;
                        }
                    case "neckextend":
                        {
                            await bot.RaiseNeck();
                            await WriteResponseAsync("200 OK", botCmd, outstream);
                            break;
                        }
                    case "neckretract":
                        {
                            await bot.LowerNeck();
                            await WriteResponseAsync("200 OK", successMsg, outstream);
                            break;
                        }
                    case "armextend":
                        {
                            await bot.RaiseArm();
                            await WriteResponseAsync("200 OK", successMsg, outstream);
                            break;
                        }

                    case "armretract":
                        {
                            await bot.LowerArm();
                            await WriteResponseAsync("200 OK", successMsg, outstream);
                            break;
                        }
                    case "neckextendtime":
                        {
                            int time = int.Parse(querybag.GetFirstValueByName("ms"));
                            await bot.RaiseNeck(time);

                            await WriteResponseAsync("200 OK", botCmd, outstream);
                            break;
                        }
                    case "neckretracttime":
                        {
                            int time = int.Parse(querybag.GetFirstValueByName("ms"));
                            await bot.LowerNeck(time);

                            await WriteResponseAsync("200 OK", successMsg, outstream);
                            break;
                        }
                    case "armextendtime":
                        {
                            int time = int.Parse(querybag.GetFirstValueByName("ms"));
                            await bot.RaiseArm(time);

                            await WriteResponseAsync("200 OK", successMsg, outstream);
                            break;
                        }
                    case "armretracttime":
                        {
                            int time = int.Parse(querybag.GetFirstValueByName("ms"));
                            await bot.LowerArm(time);

                            await WriteResponseAsync("200 OK", successMsg, outstream);
                            break;
                        }
                    case "camcapture":
                        {
                            await WriteResponseAsync("400 OK", successMsg, outstream);
                            break;
                        }
                    case "getbattery":
                        {
                            string s = "{success=\"ok\", \"percent\"=\"50\"}";
                            await WriteResponseAsync("200 OK", s, outstream);
                            break;
                        }
                    case "getwifi":
                        {
                            string s = "{success=\"ok\", \"percent\"=\"90\"}";
                            await WriteResponseAsync("200 OK", s, outstream);
                            break;
                        }
                    case "getcompass":
                        {
                            string s = "{success=\"ok\", \"heading\"=\"90\"}";
                            await WriteResponseAsync("200 OK", s, outstream);
                            break;
                        }
                    case "getaltitude":
                        {
                            string s = "{success=\"ok\", \"altitude\"=\"2400m\"}";
                            await WriteResponseAsync("200 OK", s, outstream);
                            break;
                        }
                    case "gettemp":
                        {
                            string s = "{success=\"ok\", \"temp\"=\"72f\"}";
                            await WriteResponseAsync("200 OK", s, outstream);
                            break;
                        }
                    case "shutdown":
                        {
                            await WriteResponseAsync("200 OK", successMsg, outstream);
                            // how do I initiate shutdown?
                            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);
            }
        }
예제 #25
0
        public static bool ParseResponseData(string responseData)
        {
            try
            {
                Uri uri = new Uri(responseData);

                if (!String.IsNullOrEmpty(uri.Query))
                {
                    // Error example:
                    // http://kiewic.com/?error_code=1349126&error_message=App%20Not%20Setup%3A%20The%20developers%20of%20this%20app%20have%20not%20set%20up%20this%20app%20properly%20for%20Facebook%20Login.#_=_
                    WwwFormUrlDecoder queryString = new WwwFormUrlDecoder(uri.Query);

                    string errorCode = queryString.GetFirstValueByName("error_code");
                    if (!String.IsNullOrEmpty(errorCode))
                    {
                        string errorMessage = queryString.GetFirstValueByName("error_message");
                        ShowError(errorMessage, String.Format("Error {0}", errorCode));
                        return false;
                    }
                }

                if (!String.IsNullOrEmpty(uri.Fragment))
                {
                    // Token example:
                    // http://kiewic.com/#access_token=CAAUVp1iaXIoBADZA6TV0BPB7hUGkqF7I6ZAcvWWlabBznOWzdicE4ZBeF1c2G3IOsHbaKiSedCr7PpQxAZAqmhPiIGV6dYndtqGBIaIXwcWc3Rj6lLfYQlGDdtRwt0ZBEu4KuZCYIel1S4FVeND5q2lfH0gYMFpU2ncmdTN6BTLDA0HVmKvKWLKH71YzmrFP3mdB7CR5TcHAZDZD&expires_in=4774
                    WwwFormUrlDecoder queryString = new WwwFormUrlDecoder(uri.Fragment.Substring(1));

                    string accessToken = queryString.GetFirstValueByName("access_token");
                    AccessToken = accessToken;
                    Debug.WriteLine(AccessToken);
                    return true;
                }
            }
            catch (Exception ex)
            {
                ShowError(ex.Message, String.Format("Error 0x{0:X}", ex.HResult));
            }

            return false;
        }
예제 #26
0
        protected override void OnActivated(IActivatedEventArgs args) {
            base.OnActivated(args);

            InitMangers();
            InitWindow();
            switch (args.Kind) {
                case ActivationKind.VoiceCommand:
                    CortanaManager.OnActivated(args as VoiceCommandActivatedEventArgs);
                    Window.Current.Activate();
                    break;
                case ActivationKind.Protocol:
                    var a = args as ProtocolActivatedEventArgs;
                    WwwFormUrlDecoder decoder = new WwwFormUrlDecoder(a.Uri.Query);
                    var wheelmapParams = WheelmapParams.FromString(decoder.GetFirstValueByName("LaunchContext"));
                    ShowMainPage(args, wheelmapParams);
                    break;
                default:
                    ShowMainPage(args);
                    break;
            }
            
        }
예제 #27
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);
            }
        }
 static NovelPositionIdentifier ParseIDFromReadLink(string link)
 {
     var pos = new NovelPositionIdentifier();
     Uri uri = new Uri(SeverBaseUri, link);
     var decoder = new WwwFormUrlDecoder(uri.Query);
     pos.ChapterId = decoder.GetFirstValueByName("chapterId");
     pos.VolumeId = decoder.GetFirstValueByName("volId");
     pos.SeriesId = decoder.GetFirstValueByName("bookId");
     return pos;
 }
예제 #29
0
        async protected override void OnActivated(IActivatedEventArgs args)
        {
            Frame rootFrame = Window.Current.Content as Frame;

            if (rootFrame == null)
            {
                CreateRootFrame();

                if (!RootFrame.Navigate(typeof(MainPage)))
                {
                    throw new Exception("Failed to create initial page");
                }

                Window.Current.Activate();
            }

            if (args.Kind == ActivationKind.Launch)
            {
                var toastArgs = args as LaunchActivatedEventArgs;
                if (toastArgs == null)
                {
                    return;
                }
                var arguments = JsonConvert.DeserializeObject <ToastNotificationArgs>(toastArgs.Arguments);
                if (arguments.openBookmarks)
                {
                    var bookmarkCommand = new NavigateToBookmarksCommand();
                    bookmarkCommand.Execute(null);
                    return;
                }

                if (arguments != null && arguments.openPrivateMessages)
                {
                    var openPms = new NavigateToPrivateMessageListPageCommand();
                    openPms.Execute(null);
                    return;
                }
            }

            //Find out if this is activated from a toast;
            if (args.Kind == ActivationKind.ToastNotification)
            {
                //Get the pre-defined arguments and user inputs from the eventargs;
                var toastArgs = args as ToastNotificationActivatedEventArgs;
                if (toastArgs == null)
                {
                    return;
                }
                var arguments = JsonConvert.DeserializeObject <ToastNotificationArgs>(toastArgs.Argument);
                if (arguments != null && arguments.threadId > 0)
                {
                    var bookmarkCommand = new NavigateToBookmarksCommand();
                    bookmarkCommand.Execute(arguments.threadId);
                    return;
                }

                var forumEntity = JsonConvert.DeserializeObject <ForumEntity>(toastArgs.Argument);
                if (forumEntity != null)
                {
                    var navigateCommand = new NavigateToThreadListPageCommandViaTile();
                    navigateCommand.Execute(forumEntity);
                }
            }

            // Cortana
            if (args.Kind == ActivationKind.VoiceCommand)
            {
                var commandArgs = args as VoiceCommandActivatedEventArgs;
                HandleVoiceRequest(commandArgs);
            }

            if (args.Kind == ActivationKind.Protocol)
            {
                var commandArgs = args as ProtocolActivatedEventArgs;
                Windows.Foundation.WwwFormUrlDecoder decoder =
                    new Windows.Foundation.WwwFormUrlDecoder(commandArgs.Uri.Query);
                var destination = decoder.GetFirstValueByName("LaunchContext");
                var jsonTest    = WebUtility.UrlDecode(destination);

                var arguments = JsonConvert.DeserializeObject <ToastNotificationArgs>(jsonTest);
                if (arguments != null && arguments.threadId > 0)
                {
                    var bookmarkCommand = new NavigateToBookmarksCommand();
                    bookmarkCommand.Execute(arguments.threadId);
                    return;
                }

                if (arguments != null && arguments.openPrivateMessages)
                {
                    var openPms = new NavigateToPrivateMessageListPageCommand();
                    openPms.Execute(null);
                    return;
                }

                var forumEntity = JsonConvert.DeserializeObject <ForumEntity>(jsonTest);
                if (forumEntity != null)
                {
                    var navigateCommand = new NavigateToThreadListPageCommandViaTile();
                    navigateCommand.Execute(forumEntity);
                }
            }

            //...
        }
예제 #30
0
        /// <summary>
        /// Invoked when the application is activated by some other means other than launching
        /// </summary>
        /// <param name="e">Event data for the event.</param>
        protected override async void OnActivated(IActivatedEventArgs args)
        {
#if DEBUG
            if (System.Diagnostics.Debugger.IsAttached)
            {
                this.DebugSettings.EnableFrameRateCounter = true;
            }
#endif
            Frame rootFrame = Window.Current.Content as Frame;

            // Do not repeat app initialization when the Window already has content,
            // just ensure that the window is active
            if (rootFrame == null)
            {
                // Create a Frame to act as the navigation context and navigate to the first page
                rootFrame = new Frame();

                rootFrame.NavigationFailed += OnNavigationFailed;

                // Place the frame in the current Window
                Window.Current.Content = rootFrame;
            }
            if (args.Kind == ActivationKind.VoiceCommand)
            {
                try
                {
                    // now get the parameters pased in
                    VoiceCommandActivatedEventArgs commandArgs             = args as VoiceCommandActivatedEventArgs;
                    SpeechRecognitionResult        speechRecognitionResult = commandArgs.Result;
                    string voiceCommandName = speechRecognitionResult.RulePath[0];
                    string textSpoken       = speechRecognitionResult.Text;
                    IReadOnlyList <string> recognisedVoiceCommandPhrases;
                    System.Diagnostics.Debug.WriteLine("Voice CommandName: " + voiceCommandName);
                    System.Diagnostics.Debug.WriteLine("text Spoken: " + textSpoken);

                    switch (voiceCommandName)
                    {
                    case "readBook":
                    {
                        string bookName  = this.SemanticInterpretation("bookName", speechRecognitionResult);
                        var    folder    = ApplicationData.Current.LocalFolder;
                        var    subFolder = await folder.GetFolderAsync("books");

                        var files = await subFolder.GetFilesAsync();

                        foreach (StorageFile sf in files)
                        {
                            if (sf.DisplayName.Equals(bookName))
                            {
                                book = sf.Name;
                                break;
                            }
                        }
                        break;
                    }

                    default:
                    {
                        break;
                    }
                    }   // end Switch(voiceCommandName)

                    System.Diagnostics.Debug.WriteLine("go to main page Now ");
                }
                catch (Exception)
                {
                    MessageDialog msgDialog = new MessageDialog("Crashed");
                    await msgDialog.ShowAsync();
                }
            }
            else if (args.Kind == ActivationKind.Protocol)
            {
                var commandArgs = args as ProtocolActivatedEventArgs;
                Windows.Foundation.WwwFormUrlDecoder decoder = new Windows.Foundation.WwwFormUrlDecoder(commandArgs.Uri.Query);
                var destination = decoder.GetFirstValueByName("LaunchContext");
            }

            if (rootFrame.Content == null)
            {
                // When the navigation stack isn't restored navigate to the first page,
                // configuring the new page by passing required information as a navigation
                // parameter
                rootFrame.Navigate(typeof(EnterByVoice), args.PreviousExecutionState);
            }
            // Ensure the current window is active
            Window.Current.Activate();
        }
예제 #31
0
        /// <summary>
        /// Finishes the login process asynchronously.
        /// </summary>
        /// <param name="webAuthenticationResult">The web authentication result.</param>
        private async Task FinishLoginAsync(WebAuthenticationResult webAuthenticationResult)
        {
            if (webAuthenticationResult.ResponseStatus == WebAuthenticationStatus.ErrorHttp)
            {
                this._exceptionHandler.Handle(new Exception(webAuthenticationResult.ResponseData));
            }
            else if (webAuthenticationResult.ResponseStatus == WebAuthenticationStatus.UserCancel)
            {
                LogTo.Debug("User cancelled the login.");
            }
            else if (webAuthenticationResult.ResponseStatus == WebAuthenticationStatus.Success)
            {
                var responseUri = new Uri(webAuthenticationResult.ResponseData);
                var decoder = new WwwFormUrlDecoder(responseUri.Query);

                string accessToken = decoder.GetFirstValueByName("code");

                var client = this.GetClient();

                await client.Core.OAuth2.TokenAsync(accessToken);

                AccountInfo dropboxUserInfo = await client.Core.Accounts.AccountInfoAsync();
                this._sessionService.UserLoggedIn(client.UserAccessToken, dropboxUserInfo.uid);

                await this._eventAggregator.PublishOnUIThreadAsync(new UserLoggedInEvent());
            }
        }
        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);
            }
        }
예제 #33
0
        protected override async void OnNavigatedTo(NavigationEventArgs e)
        {


            Uri StartUri = new Uri(String.Format(
                "https://login.live.com/oauth20_authorize.srf?client_id={0}&scope={1}&response_type=token&redirect_uri={2}",
                "000000004812E450",
                "wl.signin onedrive.readwrite",
                WebUtility.UrlEncode("http://kiewic.com/")));

            Uri EndUri = new Uri("http://kiewic.com/");

            WebAuthenticationResult result = await WebAuthenticationBroker.AuthenticateAsync(
                WebAuthenticationOptions.None,
                StartUri,
                EndUri);

            string testData = "http://kiewic.com/#access_token=EwCQAq1DBAAUGCCXc8wU/zFu9QnLdZXy%2bYnElFkAASu2H0Plv73qlsNgaAsNtK931pWT/wMdIa4zJzNKDNz9Er%2b97p7qo0XGR4%2bkfr%2bTCh4EV5wQ5NTYHufWeIdlvlm9lkdt3S6SotwygCJtUJqoVBI4fGJxXdTz6tCiqsC2NbZNxGR9od4osWN33ZuNIHp2f3%2b0KiX0fs%2bLJK8wIHW22LtUsj%2bCZY/K9qA%2bEbxAfgIpZDsAzV2U1NdjUobSKkvA3SEaARx/exIm0jZTRvM0XRoNHn/ZhlcMrd1nehEpOM3SFp3%2bkIfKiFiHXVm0P/vRS/VJFHXyNyCDFqGuw63vOklnqT4w2LhQyGu3G/%2bUIJBpBfuSHNwikthHPm3xjYoDZgAACO1iT9UawnDVYAFVZk/mv7wwb58vrJc1l0v7UClfth7j5bm/%2b7yYB0Rr9WHdquSqrotvovjR//V2Kmtgn3rzLQYg8ma5/2t6VgtyPIwbQm6kRP382CYpS3n5ZdvyX7nNWHwM9RlsKkZdS9zT7kkwxVsbW7MJaqSlcnbnkWaad84KzfrjSyxr9ceUb/eajRu3ltRy9Tbtkt2A8QjXtKw2Th82WjIrZjDg10JoeRqvFtfu1IeEBlofUgAPUK7VkbDdKVbgDIl97TZD5qW9m8JTQkhlbq6%2btZhiqFN/JZLOPum6a4sEOAf46v1sw70UDv0raxewMA6y2j6gGMGFojFse6vWHXTLQRpqnBwpc3iOnaaqcMGGCRimdMhtCmKITW9%2bJ/NbKo8DbTk65ancQYmBgNpNHNVStZTGex3MwcxEY9mQ1p69aXN0fXhWY7GL%2bB0wEuwJn50H04s4WtlepIv2Ww0QhfZ1vxkd1HIRdwE%3d&authentication_token=eyJhbGciOiJIUzI1NiIsImtpZCI6IjEiLCJ0eXAiOiJKV1QifQ.eyJ2ZXIiOjEsImlzcyI6InVybjp3aW5kb3dzOmxpdmVpZCIsImV4cCI6MTQyNTYxMjU0NCwidWlkIjoiNmM0NzY5YjcxMmZlNDBjYTY0MDAyYTg4MDI1NjBkMjgiLCJhdWQiOiJraWV3aWMuY29tIiwidXJuOm1pY3Jvc29mdDphcHB1cmkiOiJhcHBpZDovLzAwMDAwMDAwNDgxMkU0NTAiLCJ1cm46bWljcm9zb2Z0OmFwcGlkIjoiMDAwMDAwMDA0ODEyRTQ1MCJ9.Xzw94LXFH3wIwwSWpQmxPH9HAB9H-qyLLW4WZfcSY9o&token_type=bearer&expires_in=3600&scope=wl.signin%20onedrive.readwrite%20wl.basic%20wl.contacts_skydrive%20wl.skydrive%20wl.skydrive_update&user_id=6c4769b712fe40ca64002a8802560d28";

            testData = result.ResponseData;

            var urlDecoder = new WwwFormUrlDecoder(testData);
            foreach (var decoderEntry in urlDecoder)
            {
                Debug.WriteLine(decoderEntry.Name + " " + decoderEntry.Value);
            }

            string token = urlDecoder.GetFirstValueByName("http://kiewic.com/#access_token");

            HttpClient client = new HttpClient();
            client.DefaultRequestHeaders.Add("Authorization", String.Format("bearer {0}", token));

            HttpStringContent createSessionContent = new HttpStringContent(
                "{ \"@name.conflictBehavior\": \"rename\" }",
                UnicodeEncoding.Utf8,
                "application/json");

            Uri createSessionUri = new Uri("https://api.onedrive.com/v1.0/drive/root:/Foo/bar2.txt:/upload.createSession");
            var response = await client.PostAsync(createSessionUri, createSessionContent);
            var responseString = await response.Content.ReadAsStringAsync();

            Debug.WriteLine(responseString);

            JsonObject jsonObject = JsonObject.Parse(responseString);
            Uri uploadUrl = new Uri(jsonObject.GetNamedString("uploadUrl"));

            HttpStringContent putContent1 = new HttpStringContent(
                "hello ",
                UnicodeEncoding.Utf8,
                "text/plain");
            putContent1.Headers.Add("Content-Range", "bytes 0-5/11");

            HttpStringContent putContent2 = new HttpStringContent(
                "world",
                UnicodeEncoding.Utf8,
                "text/plain");
            putContent2.Headers.Add("Content-Range", "bytes 6-10/11");

            response = await client.PutAsync(uploadUrl, putContent2);
            responseString = await response.Content.ReadAsStringAsync();

            Debug.WriteLine(responseString);

            response = await client.PutAsync(uploadUrl, putContent1);
            responseString = await response.Content.ReadAsStringAsync();

            Debug.WriteLine(responseString);
        }