ReadToEndAsync() public method

public ReadToEndAsync ( ) : Task
return Task
        private async Task<string> Create()
        {
            string sql;
            var assembly = typeof(TestDatabase).GetTypeInfo().Assembly;
            using (var reader = new StreamReader(assembly.GetManifestResourceStream(_sqlFile)))
            {
                sql = await reader.ReadToEndAsync();
            }

            var dbName = await CreateDatabase();
            var connectionString = $"Server=localhost;Port=5432;Database={_databaseName};User Id=postgres;Password=s1mpl3;";

            using (var connection = new NpgsqlConnection(connectionString))
            {
                await connection.OpenAsync();

                using (var command = connection.CreateCommand())
                {
                    foreach (
                        var statement in
                        Regex.Split(sql, @"^\s*GO\s*$", RegexOptions.Multiline)
                            .Where(s => !string.IsNullOrWhiteSpace(s)))
                    {
                        //_logger.LogDebug(sql);
                        command.CommandText = statement;
                        await command.ExecuteNonQueryAsync();
                    }
                }
            }
            return _connectionString = connectionString;
        }
Beispiel #2
0
        private async void btnRead_Click(object sender, EventArgs e)
        {
            tbData.Clear();

            try
            {
                //create dir if it does not exists
                if (!Directory.Exists(PathToFile))
                {
                    throw new IOException();
                }

                using (StreamReader sr = new StreamReader(Path.Combine(PathToFile, FileName)))
                {
                    var readText = "";
                    readText = await sr.ReadToEndAsync();
                    tbData.Text = readText;
                }
            }
            catch (IOException ex)
            {
                //catch error
                MessageBox.Show(ex.Message, @"Error!", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
        private async Task<string> GetPageText(string page)
        {
            string result = "";
            try
            {
                HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(page);
                using (WebResponse response = await request.GetResponseAsync().ConfigureAwait(false))
                {

                    using (StreamReader stream = new StreamReader(response.GetResponseStream()))
                    {
                        result = await stream.ReadToEndAsync().ConfigureAwait(false);
                        return result;
                    }
                }
            }
            catch (WebException)
            {
                return "";
            }
            catch (UriFormatException)
            {
                return "";
            }
        }
        /// <summary>
        /// Async method, return Response xmlDocument
        /// </summary>
        /// <param name="xmlRequest">xml request document</param>
        /// <returns></returns>
        public static async Task<XmlDocument> SendRequestXmlDocumentAsync(XmlDocument xmlRequest)
        {

            var httpWebRequest = (HttpWebRequest)WebRequest.Create("https://api.novaposhta.ua/v2.0/xml/");
            httpWebRequest.Method = "POST";
            httpWebRequest.KeepAlive = true;
            httpWebRequest.ContentType = @"application/x-www-form-urlencoded";
            ServicePointManager.DefaultConnectionLimit = 2000;
         
            var streamOut = new StreamWriter(await httpWebRequest.GetRequestStreamAsync());
            await streamOut.WriteAsync(xmlRequest.InnerXml);

            //streamOut.Flush();
            streamOut.Close();

            //In Stream
            var response = (await httpWebRequest.GetResponseAsync()).GetResponseStream();

            if (response == null)
                return null;

            var streamIn = new StreamReader(response);

            string strResponse = await streamIn.ReadToEndAsync();
            streamIn.Close();
            response.Close();

            //Load XML data to XmlDocument
            var xmlResponse = new XmlDocument();
            xmlResponse.LoadXml(strResponse);

            return xmlResponse;
        }
        public void With_WebSocket_CanReadTwoBufferedSmallFrames()
        {
            var handshake = GenerateSimpleHandshake();
            using (var ms = new MemoryStream())
            using (WebSocket ws = new WebSocketRfc6455(ms, new WebSocketListenerOptions() { PingTimeout = Timeout.InfiniteTimeSpan }, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1), new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2), handshake.Request, handshake.Response, handshake.NegotiatedMessageExtensions))
            {
                ms.Write(new Byte[] { 129, 130, 75, 91, 80, 26, 3, 50 }, 0, 8);
                ms.Write(new Byte[] { 129, 130, 75, 91, 80, 26, 3, 50 }, 0, 8);
                ms.Flush();
                ms.Seek(0, SeekOrigin.Begin);

                var reader = ws.ReadMessageAsync(CancellationToken.None).Result;
                Assert.IsNotNull(reader);
                using (var sr = new StreamReader(reader, Encoding.UTF8, true, 1024, true))
                {
                    String s = sr.ReadToEnd();
                    Assert.AreEqual("Hi", s);
                }

                reader = ws.ReadMessageAsync(CancellationToken.None).Result;
                Assert.IsNotNull(reader);
                using (var sr = new StreamReader(reader, Encoding.UTF8, true, 1024, true))
                {
                    String s = sr.ReadToEndAsync().Result;
                    Assert.AreEqual("Hi", s);
                }

                reader = ws.ReadMessageAsync(CancellationToken.None).Result;
                Assert.IsNull(reader);
            }
        }
 private async void FirstVariant_Click(object sender, RoutedEventArgs e)
 {
     _task.Visibility = Visibility.Hidden;
     next.Visibility = Visibility.Visible;
     UserText.Visibility = Visibility.Hidden;
     var1Task.Visibility = Visibility.Visible;
     try
     {
         using (StreamReader sr = new StreamReader("../../../Writing/var1Task2.txt"))
         {
             string line = await sr.ReadToEndAsync();
             var1Task.Text = line;
         }
     }
     catch (FileNotFoundException)
     {
         MessageBox.Show("File with writing rask not found");
     }
     Help.MouseLeave += Help_MouseLeave;
     next.Click += next_Click;
     UserText.TextChanged -= UserText_TextChanged1;
     UserText.TextChanged -= UserText_TextChanged2;
     UserText.TextChanged += UserText_TextChanged;
     FirstVariant.IsEnabled = false;
     SecondVariant.IsEnabled = true;
     ThirdVariant.IsEnabled = true;
 }
		public static async Task<List<TodoItem>> GetItemsAsync (Context context, int count = 0)
		{
			if (cache == null) {
				using (StreamReader sr = new StreamReader (context.Assets.Open ("tasks.json"))) {
					string data = await sr.ReadToEndAsync ();
					cache = await Task.Run (() => {
						var list = JsonConvert.DeserializeObject<List<TodoItem>> (data);
						List<TodoItem> items = new List<TodoItem> (list);
						while (items.Count < count)
							items.AddRange (list);
						return items;
					});
				}
			} else {
				Random rng = new Random ();  
				int n = cache.Count;  
				while (n > 1) {  
					n--;  
					int k = rng.Next (n + 1);  
					var value = cache [k];  
					cache [k] = cache [n];  
					cache [n] = value;  
				}  
			}
			return cache;
		}
        public async Task Invoke(HttpContext context)
        {
            using (var memoryStream = new MemoryStream())
            {
                var bodyStream = context.Response.Body;
                context.Response.Body = memoryStream;

                await _next(context);

                var isHtml = context.Response.ContentType?.ToLower().Contains("text/html");
                if (context.Response.StatusCode == 200 && isHtml.GetValueOrDefault())
                {
                    {
                        memoryStream.Seek(0, SeekOrigin.Begin);
                        using (var streamReader = new StreamReader(memoryStream))
                        {
                            string body = await streamReader.ReadToEndAsync();
                            body = MinifyHtml(body);
                            using (var minBodyStream = new MemoryStream())
                            using (var streamWriter = new StreamWriter(minBodyStream))
                            {
                                streamWriter.Write(body);
                                streamWriter.Flush();
                                minBodyStream.Seek(0, SeekOrigin.Begin);
                                await minBodyStream.CopyToAsync(bodyStream);
                            }
                        }
                    }
                }
            }
        }
        private async Task <string> GetJSONResponseAsync(string url)
        {
            var http = (HttpWebRequest)WebRequest.Create(new Uri(url));

            http.Accept      = "application/json";
            http.ContentType = "application/json";
            http.Method      = "POST";
            System.Net.WebResponse resp;
            try {
                if (YetaWFManager.IsSync())
                {
                    resp = http.GetResponse();
                }
                else
                {
                    resp = await http.GetResponseAsync();
                }
            } catch (Exception exc) {
                throw new InternalError("An error occurred retrieving exchange rates from openexchangerates.org - {0}", ErrorHandling.FormatExceptionMessage(exc));
            }
            using (System.IO.StreamReader sr = new System.IO.StreamReader(resp.GetResponseStream())) {
                if (YetaWFManager.IsSync())
                {
                    return(sr.ReadToEnd().Trim());
                }
                else
                {
                    return((await sr.ReadToEndAsync()).Trim());
                }
            }
        }
        internal static async Task<Character> LoadFromFileAsync (string filename, Rules rules) {
            Character character = null;
            Stopwatch timer = Stopwatch.StartNew();
            try {
                string xmlString;
                using (var file = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read, 0x1000, useAsync: true)) {
                    using (var reader = new StreamReader(file)) {
                        xmlString = await reader.ReadToEndAsync();
                    }
                }

                // cleanup campaign settings
                // CBuilder sometimes seems to insert invalid XML values?
                var endStr = "</D20CampaignSetting>";
                int start = xmlString.IndexOf("<D20CampaignSetting");
                int end = xmlString.IndexOf(endStr) + endStr.Length;
                if (start != -1 && end != -1 && start < end) {
                    xmlString = xmlString.Remove(start, end - start + 1);
                }

                ImportCharacter import = await xmlString.DeserializeXmlAsync<ImportCharacter>();
                character = import.ToCharacter(rules);
            }
            finally {
                timer.Stop();
                Trace.TraceInformation("Deserializing Character [{0}] from CB took {1}ms", Path.GetFileName(filename), timer.ElapsedMilliseconds);
            }

            return character;
        }
Beispiel #11
0
		/// <summary>
		/// Performs web request and gets the weather from the service.
		/// </summary>
		/// <returns>The weather.</returns>
		/// <param name="location">Location to get the weather</param>
		public static async Task<WeatherData> GetWeather(Location location)
		{
			WeatherData result = null;
			string weatherUrl = string.Format (WEATHER_URL, EnumHelper.GetDescription (Subscription.Subscript.free), location.city, NUMBER_OF_DAYS.ToString (), ApplicationSettingsHelper.API_KEY);
			HttpWebRequest request = (HttpWebRequest)WebRequest.Create(weatherUrl);

			using(WebResponse response = await request.GetResponseAsync())
			{
				using (Stream resStream = response.GetResponseStream ()) 
				{
					using (StreamReader reader = new StreamReader (resStream)) 
					{
						string jsonResult = await reader.ReadToEndAsync ();
						result = JsonConvert.DeserializeObject<WeatherData> (jsonResult);
					}
				}
			}
			 
			int  length1 = result.data.weather.Length;
			int  length2 = result.data.weather[0].hourly.Length;

			// TODO: investigate ho w to run this tasks in Parallel
			for( int i = 0; i < length1; i++){
				for(int j = 0; j < length2; j++) {
					//taskArray[i*length2 + j]  = Task.Factory.StartNew(async () => { await GetWeatherImageFile (result.data.weather[i].hourly[j].weatherIconUrl[0].value); });
					await GetWeatherImageFile (result.data.weather[i].hourly[j].weatherIconUrl[0].value);
				}
			}
			return result;
		}
        public async Task<AzureToken> LoadToken(string subscriptionId)
        {
            string path = Path.Combine(_root, "Subscriptions", subscriptionId + ".dat");
            if (!File.Exists(path))
            {
                return null;
            }

            string content = null;
            using (var reader = new StreamReader(path))
            {
                content = await reader.ReadToEndAsync();
            }
            if (content == null)
            {
                return null;
            }
            var unprotected =
                Encoding.UTF8.GetString(
                    ProtectedData.Unprotect(
                        Convert.FromBase64String(content),
                        null,
                        DataProtectionScope.CurrentUser));
            
            return JsonFormat.Deserialize<AzureToken>(unprotected);
        }
		public async Task Invoke(IDictionary<string, object> env)
		{
			IOwinContext context = new OwinContext(env);
			 
			// Buffer the request body
			var requestBuffer = new MemoryStream();
			await context.Request.Body.CopyToAsync(
				requestBuffer);
			requestBuffer.Seek(0, SeekOrigin.Begin);
			 
			context.Request.Body = requestBuffer;
			 
			// Read the body
			var reader = new StreamReader(context.Request.Body);
			string content = await reader.ReadToEndAsync();
			 
			// Seek to the beginning of the stream for the
			// other components to correctly read the request body.
			((MemoryStream)context.Request.Body)
				.Seek(0, SeekOrigin.Begin);
			 
			Console.WriteLine(content);
			 
			await this.next(env);
		}
Beispiel #14
0
        public async Task <ValidationResult> ProcessEquipmentSubmission(HttpContext context)
        {
            System.IO.StreamReader sr = new System.IO.StreamReader(context.Request.Body);
            //TODO: handle encoding (UTF etc) correctly
            string responseContent = await sr.ReadToEndAsync();

            string jsonString = responseContent.Trim();

            try
            {
                JObject o = JObject.Parse(jsonString);

                JsonSerializer serializer = new JsonSerializer();
                var            cp         = (Common.Model.ChargePoint)serializer.Deserialize(new JTokenReader(o), typeof(Common.Model.ChargePoint));

                //validate cp submission
                return(POIManager.IsValid(cp));
            }
            catch (Exception exp)
            {
                System.Diagnostics.Debug.WriteLine(exp);

                //submission failed
                return(new ValidationResult {
                    IsValid = false, Message = "Exception processing submission:" + exp.Message
                });
            }
        }
Beispiel #15
0
        internal async Task<IPackageMetaData> GetPackageMetaData(string providerName)
        {
            string rootCacheDir = Environment.ExpandEnvironmentVariables(Defaults.CachePath);
            string metaPath = Path.Combine(rootCacheDir, providerName, Name, "metadata.json");
            try
            {
                if (!File.Exists(metaPath))
                {
                    string url = string.Format(_metaPackageUrlFormat, Name);
                    Directory.CreateDirectory(Path.GetDirectoryName(metaPath));

                    using (WebClient client = new WebClient())
                    {
                        // When this is async, it deadlocks when called from FileCompletionProvider.cs
                        await Task.Run(() => client.DownloadFile(url, metaPath)).ConfigureAwait(false);
                    }
                }

                using (StreamReader reader = new StreamReader(metaPath))
                {
                    string json = await reader.ReadToEndAsync().ConfigureAwait(false);

                    if (!string.IsNullOrEmpty(json))
                    {
                        return JsonConvert.DeserializeObject<CdnjsMetaData>(json);
                    }
                }
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.Write(ex);
            }

            return null;
        }
Beispiel #16
0
        private async Task<string> GetRequestToken()
        {
            try
            {
                const string requestTokenUrl = "http://api.moefou.org/oauth/request_token";
                const string httpMethod = "GET";
                Uri url = new Uri(requestTokenUrl);
                string timeStamp = this.OAuth.GenerateTimeStamp();
                string nonce = this.OAuth.GenerateNonce();
                string nUrl = null;
                string pa = null;
                string signature = this.OAuth.GenerateSignature(url, AppConst.MoeAppKey, AppConst.ConsumerSecret, string.Empty, string.Empty, httpMethod, timeStamp, nonce, string.Empty, out nUrl, out pa);
                List<QueryParameter> parameters = new List<QueryParameter>();


                string requestUrl = string.Format("{0}?{1}&{2}={3}", nUrl, pa, OAuthBase.OAuthSignatureKey, signature);
                WebRequest request = WebRequest.Create(requestUrl);
                WebResponse response = await request.GetResponseAsync();
                using (StreamReader sr = new StreamReader(response.GetResponseStream()))
                {
                    List<QueryParameter> reqPa = this.OAuth.GetQueryParameters(await sr.ReadToEndAsync());
                    var oauth_token = reqPa.Find(qp => qp.Name.Equals("oauth_token")).Value;
                    var oauth_token_secret = reqPa.Find(qp => qp.Name.Equals("oauth_token_secret")).Value;
                    //将为授权的token放入到
                    Windows.Storage.ApplicationData.Current.LocalSettings.Values["oauth_token"] = oauth_token;
                    Windows.Storage.ApplicationData.Current.LocalSettings.Values["oauth_token_secret"] = oauth_token_secret;
                }
                return string.Empty;
            }
            catch (Exception)
            {
                throw;
            }
        }
Beispiel #17
0
        private async Task LoadScriptPreview(string scriptPath)
        {
            this.ScriptTextBox.Text = string.Empty;
            this.lblScriptName.Text = string.Empty;

            if (string.IsNullOrEmpty(scriptPath)) { return; }

            if (System.IO.File.Exists(scriptPath))
            {
                lblScriptName.Text = System.IO.Path.GetFileName(scriptPath);

                try
                {
                    //this.ScriptTextBox.Text = System.IO.File.ReadAllText(scriptPath);
                    using (var sr = new System.IO.StreamReader(scriptPath))
                    {
                        this.ScriptTextBox.Text = await sr.ReadToEndAsync();
                    }
                }
                catch (Exception ex)
                {
                    this.ScriptTextBox.Text = "ERROR:" + Environment.NewLine + ex.Message;
                }
            }
        }
Beispiel #18
0
        public static async Task<bool> UpdateAvailable()
        {
            WebRequest request = WebRequest.Create(VersionLocation);
            WebResponse response = await request.GetResponseAsync();

            string answer = "";

            using(Stream responseStream = response.GetResponseStream())
                using(StreamReader sr = new StreamReader(responseStream))
                    answer = await sr.ReadToEndAsync();

            answer = answer.Replace("\n", "");
            answer = answer.Replace("\r", "");
            answer = answer.Trim();


            try
            {
                DateTime lastUpdate = DateTime.ParseExact(answer, "yyyy-MM-dd", CultureInfo.InvariantCulture);

                if (lastUpdate.CompareTo(BuildDate) > 0)
                    return true;
                else
                    return false;
            }
            catch
            {
                return false;
            }
        }
        public static async Task<string> GetAsync(string remoteAddr, bool supressErrors = false)
        {
            string remoteResponse = string.Empty;
            try
            {
                DateTime began = DateTime.UtcNow;

                // Request
                WebRequest request = WebRequest.Create(remoteAddr);
                request.Method = "GET";

                using (var response = (HttpWebResponse)await request.GetResponseAsync())
                using (Stream streamResponse = response.GetResponseStream())
                using (StreamReader streamReader = new StreamReader(streamResponse))
                    remoteResponse = await streamReader.ReadToEndAsync();

                var timeDiff = DateTime.Now - began;
            }
            catch (WebException ex)
            {
                if (!supressErrors)
                {
                    if (!supressErrors)
                        throw ex;
                    //throw new System.Exception("A required external service is not available!", ex);
                }
            }
            return remoteResponse;
        }
        private static async Task<TokenResponse> RedeemRefreshTokenInternalAsync(OAuthAccount account)
        {
            HttpWebRequest request = WebRequest.CreateHttp(account.TokenService);
            request.ContentType = "application/x-www-form-urlencoded";
            request.Method = "POST";

            var requestStream = await request.GetRequestStreamAsync();
            var writer = new StreamWriter(requestStream);

            StringBuilder sb = new StringBuilder();
            sb.AppendFormat("client_id={0}", Uri.EscapeDataString(account.ClientId));
            sb.AppendFormat("&redirect_uri={0}", Uri.EscapeDataString(account.RedirectUri));
            sb.AppendFormat("&client_secret={0}", Uri.EscapeDataString(account.ClientSecret));
            sb.AppendFormat("&refresh_token={0}", Uri.EscapeDataString(account.RefreshToken));
            sb.Append("&grant_type=refresh_token");
            if (null != account.Resource)
                sb.AppendFormat("&resource={0}", Uri.EscapeDataString(account.Resource));

            var content = sb.ToString();
            await writer.WriteAsync(content);
            await writer.FlushAsync();

            var response = await request.GetResponseAsync() as HttpWebResponse;
            if (null != response && response.StatusCode == HttpStatusCode.OK)
            {
                var responseStream = response.GetResponseStream();
                if (null != responseStream)
                {
                    var reader = new StreamReader(responseStream);
                    return JsonConvert.DeserializeObject<TokenResponse>(await reader.ReadToEndAsync());
                }
            }
            return null;
        }
    private async void SendRequest()
    {
      try
      {
        using (ISitecoreWebApiSession session = this.instanceSettings.GetSession())
        {
          var request = ItemWebApiRequestBuilder.RenderingHtmlRequestWithSourceAndRenderingId(sourceIdTextField.Text, renderingIdTextField.Text)
            .Build();

          this.ShowLoader();

          Stream response = await session.ReadRenderingHtmlAsync(request);

          response.Position = 0;
          string htmlText = "";
          using (StreamReader reader = new StreamReader(response))
          {
            htmlText = await reader.ReadToEndAsync();
          }

          this.resultWebView.LoadHtmlString(htmlText, null);
        }
      }
      catch(Exception e) 
      {
        AlertHelper.ShowLocalizedAlertWithOkOption("Error", e.Message);
      }
      finally
      {
        BeginInvokeOnMainThread(delegate
        {
          this.HideLoader();
        });
      }
    }
Beispiel #22
0
        public static async Task <string> ReadStringFromSelectedFile()
        {
            var picker = new Windows.Storage.Pickers.FileOpenPicker();

            picker.ViewMode = Windows.Storage.Pickers.PickerViewMode.List;
            picker.SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.DocumentsLibrary;
            picker.FileTypeFilter.Add(".txt");
            picker.FileTypeFilter.Add(".dat");
            picker.FileTypeFilter.Add(".");

            Windows.Storage.StorageFile file = await picker.PickSingleFileAsync();

            if (file != null)
            {
                await System.Threading.Tasks.Task.Run(async() =>
                {
                    var storedFile = await Windows.Storage.StorageFile.GetFileFromPathAsync(file.Path);
                    using (var readStream = await storedFile.OpenReadAsync())
                        using (var sr = new System.IO.StreamReader(readStream.AsStream()))
                        {
                            return(sr.ReadToEndAsync());
                        }
                });
            }
            return(null);
        }
Beispiel #23
0
            public static async Task <MetricsRow> ReadMetrics(string path)
            {
                string text;

                using (System.IO.StreamReader reader = new System.IO.StreamReader(path))
                {
                    text = await reader.ReadToEndAsync();
                }

                var root = XElement.Parse(text);

                var target = root.Element("Targets").Element("Target");

                var assemblyName = target.Attribute("Name").Value;

                var metricsElement = target.Element("Assembly").Element("Metrics");

                return(new MetricsRow()
                {
                    ProjectName = assemblyName,
                    ClassCoupling = ReadMetricsValue(metricsElement, "ClassCoupling"),
                    CyclomaticComplexity = ReadMetricsValue(metricsElement, "CyclomaticComplexity"),
                    MaintainabilityIndex = ReadMetricsValue(metricsElement, "MaintainabilityIndex"),
                    DepthOfInheritance = ReadMetricsValue(metricsElement, "DepthOfInheritance"),
                    SourceLines = ReadMetricsValue(metricsElement, "SourceLines")
                });
            }
        public async Task <IEnumerable <MonsterResume> > ListAllResumePerRegion(int regionId)
        {
            Pokedex pokedex = null;
            //var

            var    assembly = IntrospectionExtensions.GetTypeInfo(typeof(MonsterRepository)).Assembly;
            Stream stream   = assembly.GetManifestResourceStream($"{assembly.GetName().Name}.pokedex_{regionId}.json");
            string json     = "";

            using (var reader = new System.IO.StreamReader(stream))
            {
                json = await reader.ReadToEndAsync();
            }


            if (!string.IsNullOrEmpty(json))
            {
                pokedex = Newtonsoft.Json.JsonConvert.DeserializeObject <Pokedex>(json);
            }
            else
            {
                pokedex = await DataFetcher.GetApiObject <Pokedex>(regionId);
            }

            return(pokedex.Entries.Select(x => new MonsterResume
            {
                Id = x.EntryNumber,
                Name = x.Species.Name,
                ImagePath = $"{IMAGE_DEFAULT}{x.EntryNumber}{IMAGE_EXTENSION}"
            }));
        }
Beispiel #25
0
        public async Task ResponseLimit()
        {
            var client = CreateClient();
            var url = BaseUrl + "/000/" + Guid.NewGuid().ToString();

            var request = new HttpRequestMessage(HttpMethod.Post, url + "/xhr_streaming");
            var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);

            string msg = "\"" + new string('x', 128) + "\"";
            int nrOfMessages = 31;
            for (int i = 0; i < nrOfMessages; i++)
            {
                var sendResponse = await client.PostAsync(url + "/xhr_send", new StringContent("[" + msg + "]", Encoding.UTF8, "application/json"));
                Assert.Equal(HttpStatusCode.NoContent, sendResponse.StatusCode);
            }

            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            var contentStream = await response.Content.ReadAsStreamAsync();
            var reader = new StreamReader(contentStream);
            var prelude = await reader.ReadLineAsync();
            var open = await reader.ReadLineAsync();
            Assert.Equal(new string('h', 2048), prelude);
            Assert.Equal("o", open);
            var remaining = await reader.ReadToEndAsync();
            Assert.Equal(string.Concat(Enumerable.Repeat("a[" + msg + "]\n", nrOfMessages)), remaining);
        }
Beispiel #26
0
            public static async Task <CollectionConfiguration> LoadConfig(string path)
            {
                if (!File.Exists(path))
                {
                    return(null);
                }

                string text;

                using (System.IO.StreamReader reader = new System.IO.StreamReader(path))
                {
                    text = await reader.ReadToEndAsync();
                }

                var root = XElement.Parse(text);

                var config = new CollectionConfiguration();

                config.MsBuildPath   = root.Element(nameof(config.MsBuildPath)).Value;
                config.RootDirectory = root.Element(nameof(config.RootDirectory)).Value;

                string collectionStringValue = root.Element(nameof(config.CollectionMethod)).Value;

                config.CollectionMethod = (CollectionMethod)Enum.Parse(typeof(CollectionMethod), collectionStringValue);

                return(config);
            }
 public static async Task<string> ReadAllTextFromFileAsync(string path)
 {
     using (var streamReader = new StreamReader(File.OpenRead(path)))
     {
         return await streamReader.ReadToEndAsync();
     }
 }
Beispiel #28
0
        public async Task<string> LoadByKeyAsync(string key)
        {
            using (await _asyncLock.LockAsync())
            {
                var fileName = "cache_" + key;

                var existsFile = await ApplicationData.Current.LocalCacheFolder.TryGetItemAsync(fileName);

                //var existsFile = await FileSystem.Current.LocalStorage.CheckExistsAsync(fileName);

                if (existsFile != null)
                {
                    using (var stream = (await ((StorageFile)existsFile).OpenStreamForReadAsync()))
                    {
                        using (var dataReader = new StreamReader(stream, Encoding.UTF8))
                        {
                            var res = await dataReader.ReadToEndAsync();

                            return res;
                        }
                    }
                }

                return null;
            }
        }
Beispiel #29
0
        public async Task<string> GetJsonAsync(double lat, double lon)
        {
            Uri uri = new Uri(string.Format(
                "http://maps.google.com/maps/api/geocode/json?address=" + lat + "%2C" + lon + "&sensor=false&language=ja"));

            try
            {
                using (var client = new HttpClient())
                {
                    var response = await client.GetAsync(uri);
                    response.EnsureSuccessStatusCode(); // StatusCode が 200 以外なら Exception

                    using (var stream = await response.Content.ReadAsStreamAsync())
                    {
                        using (var streamReader = new StreamReader(stream))
                        {
                            var json = await streamReader.ReadToEndAsync();
                            var res = JsonConvert.DeserializeObject<RootObject>(json);

                            // Latitude, Longitude を投げると results の最初のフルアドレスが返ってくるようなので決め打ちですw
                            return res.results[0].formatted_address;
                        }
                    }
                }
            }
            catch (Exception e)
            {
#if DEBUG
                System.Diagnostics.Debug.WriteLine("***Error***: {0}\n{1}\n{2}", e.Source, e.Message, e.InnerException);
#endif
                return null;
                //res = null;
            }
        }
Beispiel #30
0
        private async Task OutputProfileSignInResult(IOutputProvider outputProvider, HttpContext context, APIRequestParams filter)
        {
            var    sr          = new System.IO.StreamReader(context.Request.Body);
            string jsonContent = await sr.ReadToEndAsync();

            var loginModel = JsonConvert.DeserializeObject <LoginModel>(jsonContent);

            User   user             = new OCM.API.Common.UserManager().GetUser(loginModel);
            string access_token     = null;
            var    responseEnvelope = new APIResponseEnvelope();

            if (user == null)
            {
                context.Response.StatusCode = 401;
                return;
            }
            else
            {
                access_token = Security.JWTAuth.GenerateEncodedJWT(user);

                /*
                 * var validatedToken = Security.JWTAuthTicket.ValidateJWTForUser(testTicket, user);
                 */
            }

            responseEnvelope.Data = new { UserProfile = user, access_token = access_token };

            await outputProvider.GetOutput(context, context.Response.Body, responseEnvelope, filter);
        }
 public async Task<string> ReadContentAsStringAsync()
 {
     using (var sr = new StreamReader(this.Content))
     {
         return await sr.ReadToEndAsync();
     }
 }
Beispiel #32
0
        /// <summary>
        /// Loads data from csv file into List of PodatakViewModels to show in grid.
        /// </summary>
        /// <param name="filePath">Csv file path (directory + "podaci.csv")</param>
        /// <returns>List</returns>
        private async Task <List <PodatakViewModel> > LoadCsvDataFrom(string filePath)
        {
            List <PodatakViewModel> pom = new List <PodatakViewModel>();

            if (System.IO.File.Exists(filePath))
            {
                using (System.IO.StreamReader objReader = new System.IO.StreamReader(filePath, System.Text.Encoding.UTF8))
                {
                    var contents = await objReader.ReadToEndAsync();

                    using (System.IO.StringReader strReader = new System.IO.StringReader(contents))
                    {
                        do
                        {
                            var textLine = await strReader.ReadLineAsync();

                            if (textLine != string.Empty)
                            {
                                pom.Add(new PodatakViewModel(
                                            textLine.Split(';')
                                            ));
                            }
                        } while (strReader.Peek() != -1);
                    }
                }
            }

            return(pom);
        }
Beispiel #33
0
        private async void TimerCallback(object state)
        {
            try
            {
                using (var stream = await _httpClient.Get(new HttpRequestOptions
                {
                    Url = "http://bot.whatismyipaddress.com/"

                }).ConfigureAwait(false))
                {
                    using (var reader = new StreamReader(stream))
                    {
                        var address = await reader.ReadToEndAsync().ConfigureAwait(false);

                        if (IsValid(address))
                        {
                            ((ConnectManager) _connectManager).OnWanAddressResolved(address);
                            CacheAddress(address);
                        }
                    }
                }
            }
            catch
            {
            }
        }
Beispiel #34
0
        /// <summary>
        /// 根据手机号码获取号码属地
        /// </summary>
        /// <param name="_PhoneNum"></param>
        /// <returns></returns>
        public async Task<PhoneSearchGetBak> GetProvByPhoneNum(string _PhoneNum)
        {
            if (string.IsNullOrWhiteSpace(_PhoneNum))
                return null;
            string _url = "http://shop.10086.cn/i/v1/res/numarea/" + _PhoneNum;

            try
            {
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(_url);
                request.Method = "GET";
                request.KeepAlive = true;

                request.CookieContainer = new CookieContainer();

                using (HttpWebResponse mResponse = (HttpWebResponse)request.GetResponse())
                {
                    cookie = request.CookieContainer;//如果用不到Cookie,删去即可  

                    using (Stream mStream = mResponse.GetResponseStream())
                    {
                        using (StreamReader myStreamReader =
                            new StreamReader(mStream, Encoding.GetEncoding("utf-8")))
                        {
                            string retString = await myStreamReader.ReadToEndAsync();
                            return JsonConvert.DeserializeObject<PhoneSearchGetBak>(retString);
                        }
                    }
                }
            }
            catch (Exception)
            {

            }
            return null;
        }
        public async Task Invoke(HttpContext context)
        {
            var sw = new Stopwatch();
            sw.Start();

            using (var memoryStream = new MemoryStream())
            {
                var bodyStream = context.Response.Body;
                context.Response.Body = memoryStream;

                await _next(context);

                var isHtml = context.Response.ContentType?.ToLower().Contains("text/html");
                if (context.Response.StatusCode == 200 && isHtml.GetValueOrDefault())
                {
                    memoryStream.Seek(0, SeekOrigin.Begin);
                    using (var streamReader = new StreamReader(memoryStream))
                    {
                        var responseBody = await streamReader.ReadToEndAsync();
                        //C# 6 DEMO
                        var newFooter = string.Format($"<footer><div id='process'>Page processed in {sw.ElapsedMilliseconds} milliseconds.</div>");
                        responseBody = responseBody.Replace("<footer>", newFooter);
                        context.Response.Headers.Add("X-ElapsedTime", new[] { sw.ElapsedMilliseconds.ToString() });
                        using (var amendedBody = new MemoryStream())
                        using (var streamWriter = new StreamWriter(amendedBody))
                        {
                            streamWriter.Write(responseBody);
                            amendedBody.Seek(0, SeekOrigin.Begin);
                            await amendedBody.CopyToAsync(bodyStream);
                        }
                    }
                }
            }
        }
Beispiel #36
0
        private async Task GoGoGo()
        {
            var webRequest = WebRequest.Create(GetUrl());
            //获取或设置用于对 Internet 资源请求进行身份验证的网络凭据
            webRequest.Credentials = CredentialCache.DefaultNetworkCredentials;
            StringBuilder sb = new StringBuilder();
            sb.AppendFormat("该请求的协议方法:{0}\n", webRequest.Method);
            sb.AppendFormat("访问Internet的网络代理:{0}\n", webRequest.Proxy);
            sb.AppendFormat("请求数据的内容长度:{0}\n", webRequest.ContentLength);
            sb.AppendFormat("与该请求关联的URI:{0}\n", webRequest.RequestUri);
            sb.AppendFormat("获取或设置请求超时之前的时间(毫秒):{0}\n", webRequest.Timeout);

            //客户端不应该创建Response,而是通过WebRequest的GetResponse方法进行创建
            var webResponse = await webRequest.GetResponseAsync();

            sb.AppendFormat("响应请求的URI:{0}\n", webResponse.ResponseUri);

            //获取返回数据流
            using (var stream = webResponse.GetResponseStream())
            {
                using (var reader = new StreamReader(stream))
                {
                    sb.AppendLine(await reader.ReadToEndAsync());
                }
            }
            rtxt1.Text = sb.ToString();
        }
        public async Task PackageFeedCountParameterTest()
        {
            var request = WebRequest.Create(UrlHelper.V2FeedRootUrl + @"stats/downloads/last6weeks/");
            var response = await request.GetResponseAsync();

            string responseText;
            using (var sr = new StreamReader(response.GetResponseStream()))
            {
                responseText = await sr.ReadToEndAsync();
            }

            string[] separators = { "}," };
            int packageCount = responseText.Split(separators, StringSplitOptions.RemoveEmptyEntries).Length;
            // Only verify the stats feed contains 500 packages for production
            if (UrlHelper.BaseUrl.ToLowerInvariant() == Constants.NuGetOrgUrl)
            {
                Assert.True(packageCount == 500, "Expected feed to contain 500 packages. Actual count: " + packageCount);
            }

            request = WebRequest.Create(UrlHelper.V2FeedRootUrl + @"stats/downloads/last6weeks?count=5");
            // Get the response.
            response = await request.GetResponseAsync();
            using (var sr = new StreamReader(response.GetResponseStream()))
            {
                responseText = await sr.ReadToEndAsync();
            }

            packageCount = responseText.Split(separators, StringSplitOptions.RemoveEmptyEntries).Length;
            Assert.True(packageCount == 5, "Expected feed to contain 5 packages. Actual count: " + packageCount);
        }
		private async void OnTSBOpenFileClick(object sender, EventArgs e)
		{
			OpenFileDialog ofd = new OpenFileDialog();
			ofd.Filter = "Текстовые файлы (*.txt)|*.txt;*.dat;*.ini;*.cpp;*.h;*.cs";
			if(ofd.ShowDialog() == DialogResult.OK)
			{
				ACTBMainInput.Enabled = false;
				if(sender == TSBOpenFile)
				{
					ACTBMainInput.Clear();
				}
				try
				{
					using (StreamReader reader = new StreamReader(ofd.FileName))
					{
						ACTBMainInput.Text += await reader.ReadToEndAsync();
					}
				} catch (Exception)
				{
					MessageBox.Show("При чтении файлп произошла ошибка!","Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
				} finally
				{
					ACTBMainInput.Enabled = true;
				}
			}
		}
Beispiel #39
0
        /// <summary>
        ///post 提交数据到服务器
        /// </summary>
        /// <param name="postUrl">post地址</param>
        /// <param name="json">Json数据</param>
        /// <returns></returns>
        private async Task <string> HttpGet(string postUrl, int timeout = 10 * 1000)
        {
            string result_msg = "";

            try
            {
                string formUrl = postUrl;

                // 设置提交的相关参数
                HttpWebRequest request    = WebRequest.Create(formUrl) as HttpWebRequest;
                Encoding       myEncoding = Encoding.UTF8;
                request.Method            = "GET";
                request.KeepAlive         = false;
                request.Timeout           = timeout;
                request.AllowAutoRedirect = true;
                request.ContentType       = "text/html;charset=UTF-8";
                request.UserAgent         = "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727; .NET CLR  3.0.04506.648; .NET CLR 3.5.21022; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)";

                using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
                {
                    using (Stream responseStream = response.GetResponseStream())
                    {
                        using (StreamReader reader = new System.IO.StreamReader(responseStream, Encoding.GetEncoding("UTF-8")))
                        {
                            result_msg = await reader.ReadToEndAsync();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                result_msg = ex.ToString();
            }
            return(result_msg);
        }
        private static async Task WriteWebRequestSizeAsync(
            string url)
        {
            try
            {
                WebRequest webRequest =
                    WebRequest.Create(url);

                WebResponse response =
                    await webRequest.GetResponseAsync();
                using(StreamReader reader =
                    new StreamReader(
                        response.GetResponseStream()))
                {
                    string text =
                        await reader.ReadToEndAsync();
                    Console.WriteLine(
                        FormatBytes(text.Length));
                }
            }
            catch(WebException)
            {
                // ...
            }
            catch(IOException)
            {
                // ...
            }
            catch(NotSupportedException)
            {
                // ...
            }
        }
Beispiel #41
0
        public static async Task <string> getRawBodyAsync(Stream bodyStream)
        {
            using (System.IO.StreamReader reader = new System.IO.StreamReader(bodyStream, System.Text.Encoding.UTF8))
            {
                var result = await reader.ReadToEndAsync();

                return(result);
            }
        }
Beispiel #42
0
        public async Task <bool> ProcessMediaItemSubmission(string uploadPath, HttpContext context, MediaItem mediaItem, int userId)
        {
            try
            {
                var    sr          = new System.IO.StreamReader(context.Request.Body);
                string jsonContent = await sr.ReadToEndAsync();

                var submission = JsonConvert.DeserializeObject <Common.Model.Submissions.MediaItemSubmission>(jsonContent);
                if (submission.ImageDataBase64 == null)
                {
                    return(false);
                }
                string filePrefix = DateTime.UtcNow.Millisecond.ToString() + "_";

                var tempFiles = new List <string>();

                string tempFolder = uploadPath + "\\";

                string tmpFileName = tempFolder + filePrefix + submission.ChargePointID;
                if (submission.ImageDataBase64.StartsWith("data:image/jpeg"))
                {
                    tmpFileName += ".jpg";
                }
                if (submission.ImageDataBase64.StartsWith("data:image/png"))
                {
                    tmpFileName += ".png";
                }
                if (submission.ImageDataBase64.StartsWith("data:image/tiff"))
                {
                    tmpFileName += ".tiff";
                }

                if (submission.ImageDataBase64.StartsWith("data:"))
                {
                    submission.ImageDataBase64 = submission.ImageDataBase64.Substring(submission.ImageDataBase64.IndexOf(',') + 1, submission.ImageDataBase64.Length - (submission.ImageDataBase64.IndexOf(',') + 1));
                }
                File.WriteAllBytes(tmpFileName, Convert.FromBase64String(submission.ImageDataBase64));

                tempFiles.Add(tmpFileName);

                var task = Task.Factory.StartNew(() =>
                {
                    var mediaManager = new MediaItemManager();

                    foreach (var tmpFile in tempFiles)
                    {
                        var photoAdded = mediaManager.AddPOIMediaItem(tempFolder, tmpFile, submission.ChargePointID, submission.Comment, false, userId);
                    }
                }, TaskCreationOptions.LongRunning);

                return(true);
            }
            catch
            {
                return(false);
            }
        }
Beispiel #43
0
        static async Task <string> WGet(string url, System.Text.Encoding encoding)
        {
            HttpClient http = new HttpClient();
            var        st   = await http.GetStreamAsync(url);

            var    sr  = new System.IO.StreamReader(st, encoding);
            string ans = await sr.ReadToEndAsync();

            return(ans);
        }
Beispiel #44
0
        public async static Task <ResponseObject> GetWebApiAsync(string uri, int timeOut = 3000)
        {
            string    result = string.Empty;
            WebClient client = new WebClientto(timeOut);

            System.IO.Stream       stream = client.OpenRead(uri);
            System.IO.StreamReader reader = new System.IO.StreamReader(stream, System.Text.Encoding.UTF8);
            result = await reader.ReadToEndAsync();

            reader.Close();
            return(new ResponseObject(true, JsonConvert.DeserializeObject(result)));
        }
Beispiel #45
0
        public async Task <List <FtpListRecord> > ListAsync(string path)
        {
            var clientFtp = _ClientFtpCreate(path);

            clientFtp.Method = System.Net.WebRequestMethods.Ftp.ListDirectoryDetails;
            var ftpList1 = await clientFtp.GetResponseAsync() as System.Net.FtpWebResponse;

            var regexLineTyped = new System.Text.RegularExpressions.Regex(@"(?<date>.+((?i)am|pm))\s*?(<(?<type>\w+)>)\s*(?<name>.+)");
            var regexLineFile  = new System.Text.RegularExpressions.Regex(@"(?<date>.+((?i)am|pm))\s*(?<size>\d+)\s*(?<name>.+)");
            var r = new List <FtpListRecord>();

            using (var ftpList1Sr = new System.IO.StreamReader(ftpList1.GetResponseStream()))
            {
                var ftpList1Response = await ftpList1Sr.ReadToEndAsync();

                using (var stringReader = new System.IO.StringReader(ftpList1Response))
                {
                    while (true)
                    {
                        var line = stringReader.ReadLine();
                        if (line == null)
                        {
                            break;
                        }
                        var match1 = regexLineTyped.Match(line);
                        if (match1.Success)
                        {
                            r.Add(new FtpListRecord
                            {
                                Date  = DateTime.Parse(match1.Groups["date"].Value.Trim()),
                                Name  = match1.Groups["name"].Value.Trim(),
                                IsDir = match1.Groups["type"].Value.Trim().ToLower() == "dir",
                            });
                        }
                        else
                        {
                            var match2 = regexLineFile.Match(line);
                            if (match2.Success)
                            {
                                r.Add(new FtpListRecord
                                {
                                    Date  = DateTime.Parse(match2.Groups["date"].Value.Trim()),
                                    Name  = match2.Groups["name"].Value.Trim(),
                                    Size  = long.Parse(match2.Groups["size"].Value.Trim()),
                                    IsDir = false,
                                });
                            }
                        }
                    }
                }
            }
            return(r);
        }
        internal virtual async Task <string> GetFileAsync(string basePath, string name, string extension)
        {
            var area = Area;

            if (!string.IsNullOrEmpty(area))
            {
                area = area + "/";
            }
            var lang = "";

            if (WebConstants.SeparateClientSideDynamicFilesByLanguage && (WebConstants.MultiLanguageClientAwareController == MultiLanguageRoutingOptions.Both || WebConstants.MultiLanguageClientAwareController == MultiLanguageRoutingOptions.OnlyLanguageBased) &&
                !string.IsNullOrEmpty(Lang))
            {
                lang = Lang + "/";
            }

            var path = "";

            if (StaticsAreExternal)
            {
                path = Path.Combine(HttpContext.Server.MapPath("\\"), ".." + MasterDynamicPath + basePath + "/" + lang + area + Controller + "/" + name + extension);
            }
            else
            {
                if (basePath.Length > 0 && basePath[0] == '/')
                {
                    basePath = basePath.Substring(1);
                }

                path = Path.Combine(HttpContext.Server.MapPath("\\"), basePath + "/" + lang + area + Controller + "/" + name + extension);
            }
            var result = "";

            Logger?.Log($"GetFileAsync: \"{path}\"");

            if (System.IO.File.Exists(path))
            {
                using (System.IO.TextReader reader = new System.IO.StreamReader(path))
                {
                    result = await reader.ReadToEndAsync();
                }

                Logger?.Log($"   result length: {result.Length}");

                return(result);
            }
            else
            {
                Logger?.Log($"   NOT FOUND");

                throw new HttpNotFoundException("File not found: " + path);
            }
        }
        /// <summary>
        /// A class containing all relevant information from the HttpWebResponse.
        /// </summary>
        /// <typeparam name="T">The type of the content property in result.</typeparam>
        /// <param name="value">The HttpWebResponse to evaluate.</param>
        /// <returns></returns>
        /// <exception cref="ArgumentNullException">Thrown when the given argument is null.</exception>
        /// <exception cref="IOException">Thrown when the response stream is null.</exception>
        /// <exception cref="NotSupportedException">Thrown when the type is not supported.</exception>
        public static async Task <HttpResponse <T> > CreateFromWebResponseAsync <T>(HttpWebResponse value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }

            var responseStream = value.GetResponseStream();

            if (responseStream == null)
            {
                throw new IOException("response stream was null!");
            }

            var result = new HttpResponse <T>();

            switch (typeof(T))
            {
            case Type byteArrayType when byteArrayType == typeof(byte[]):
                var ms = new MemoryStream();
                await responseStream.CopyToAsync(ms);

                var byteArrayContent = ms.ToArray();

                result.Content = (T)(object)byteArrayContent;
                break;

            case Type stringType when stringType == typeof(string):
                using (var streamReader = new StreamReader(responseStream))
                {
                    var stringContent = await streamReader.ReadToEndAsync();

                    result.Content = (T)(object)stringContent;
                }
                break;

            default:
                throw new NotSupportedException("cannot create HttpResponse of the given type");
            }

            if (int.TryParse(value.GetResponseHeader(HeaderNames.LimitRemaining), out var lrem))
            {
                result.LimitRemaining = lrem;
            }

            if (int.TryParse(value.GetResponseHeader(HeaderNames.LimitReset), out var lres))
            {
                result.LimitReset = DateTime.SpecifyKind(DateTimeOffset.FromUnixTimeSeconds(lres).DateTime, DateTimeKind.Utc);
            }

            return(result);
        }
        public static async System.Threading.Tasks.Task <Dictionary <String, String> > GetLicenses()
        {
            var result = new Dictionary <String, String>();
            var files  = await(await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFolderAsync("LICENSE")).GetFilesAsync();

            foreach (var f in files)
            {
                using (var st = (await f.OpenReadAsync()).AsStream())
                    using (var rd = new System.IO.StreamReader(st))
                    {
                        if (f.Name == "LICENSE")
                        {
                            _CurrentLicense = await rd.ReadToEndAsync();
                        }
                        else
                        {
                            result.Add(f.Name, await rd.ReadToEndAsync());
                        }
                    }
            }
            return(result);
        }
        public static async Task <IActionResult> WebhookTriggerTest([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "test")] HttpRequest request, ILogger log)
        {
            string jobId = request.Query["jobId"];

            if (string.IsNullOrEmpty(jobId))
            {
                if (request.Method.ToLowerInvariant() == "post")
                {
                    var s    = new System.IO.StreamReader(request.Body);
                    var text = await s.ReadToEndAsync();

                    log.LogInformation($"Body: {text}");
                    //https://docs.microsoft.com/en-us/azure/event-grid/webhook-event-delivery

                    var r = await TestInfraLogic.WebhooksTest.validation(log, text);

                    if (r.Item1)
                    {
                        log.LogInformation($"Returning validation code {r.Item2}");
                        return(new OkObjectResult(r.Item2));
                    }
                    else
                    {
                        await TestInfraLogic.WebhooksTest.post(log, StorageTableConnectionString, text);

                        return(new OkResult());
                    }
                }
                else
                {
                    log.LogWarning($"Unhandled request method {request.Method} when job id is not set");
                    return(new BadRequestResult());
                }
            }
            else
            {
                if (request.Method.ToLowerInvariant() == "get")
                {
                    log.LogInformation($"Getting webhook messages for job ${jobId}");
                    var results = await TestInfraLogic.WebhooksTest.get(log, StorageTableConnectionString, jobId);

                    return(new OkObjectResult(results));
                }
                else
                {
                    log.LogWarning($"Unhandled request method {request.Method} when job id is ${jobId}");
                    return(new BadRequestResult());
                }
            }
        }
Beispiel #50
0
        // read file
        // check if there is a new DTO detected via timestamp
        // parse DTO and store in DB
        // store new data in DB as an episode
        public static List <string> ReadLogData()
        {
            string currentUserAppData = System.Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
            string playerLogDataPath  = currentUserAppData + "Low\\Mediatonic\\FallGuys_client\\Player.log";

            System.IO.FileStream fs = new System.IO.FileStream(playerLogDataPath, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite);
            using (System.IO.StreamReader sr = new System.IO.StreamReader(fs))
            {
                List <string> playerLogData = new List <string>();
                playerLogData = sr.ReadToEndAsync().Result.Split("\r\n").ToList();
                return(playerLogData);
            }
            // List<string> playerLogData = System.IO.File.ReadLines(playerLogDataPath).ToList();
        }
Beispiel #51
0
    public string Update(HttpContext context, int id)
    {
        System.IO.StreamReader reader = new System.IO.StreamReader(System.Web.HttpContext.Current.Request.InputStream);

        var requestFromPost = reader.ReadToEndAsync();

        string response = requestFromPost.Result;

        BookModel books = JsonConvert.DeserializeObject <BookModel>(response);

        books.Update(books, id);

        return(response);
    }
Beispiel #52
0
    public string Post(HttpContext context)
    {
        System.IO.StreamReader reader = new System.IO.StreamReader(System.Web.HttpContext.Current.Request.InputStream);

        var requestFromPost = reader.ReadToEndAsync();

        string teste = requestFromPost.Result;

        BookModel books = JsonConvert.DeserializeObject <BookModel>(teste);

        books.Insert(books);

        return(teste);
    }
Beispiel #53
0
        public async Task <IActionResult> Post()
        {
            string body = string.Empty;

            using (var reader = new System.IO.StreamReader(Request.Body))
                body = await reader.ReadToEndAsync();

            if (string.IsNullOrWhiteSpace(body))
            {
                return(BadRequest());
            }

            return(new FileStreamResult(new MemoryStream(GenerateDocument(body)), "application/octet-stream"));
        }
Beispiel #54
0
        public async Task <IActionResult> PostBase64()
        {
            string body = string.Empty;

            using (var reader = new System.IO.StreamReader(Request.Body))
                body = await reader.ReadToEndAsync();

            if (string.IsNullOrWhiteSpace(body))
            {
                return(BadRequest());
            }

            return(Ok(Convert.ToBase64String(GenerateDocument(body))));
        }
Beispiel #55
0
        public async static Task LoadCitiesList()
        {
            if (AllCities == null || AllCities.Count == 0)
            {
                var    assembly     = typeof(MainPage).GetTypeInfo().Assembly;
                var    jsonFileName = "city.list.json";
                Stream stream       = assembly.GetManifestResourceStream($"{assembly.GetName().Name}.{jsonFileName}");
                using (var reader = new System.IO.StreamReader(stream))
                {
                    var jsonString = await reader.ReadToEndAsync();

                    AllCities = JsonConvert.DeserializeObject <List <City> >(jsonString);
                }
            }
        }
        /// <summary>
        /// Get the list of characters from an embedded JSON file, including their child entities.
        /// </summary>
        /// <returns>Array of Character objects</returns>
        private async Task <Character[]> ReadCharactersFromFile()
        {
            var    assembly = typeof(CharacterService).GetTypeInfo().Assembly;
            Stream stream   = assembly.GetManifestResourceStream(Constants.CharactersFilename);
            string text;

            using (var reader = new System.IO.StreamReader(stream))
            {
                text = await reader.ReadToEndAsync();
            }

            var characters = JsonConvert.DeserializeObject <Character[]>(text);

            return(characters);
        }
        public async Task <T> ReadFromJsonEmbededFile <T>(string JsonFileEmbeded)
        {
            try
            {
                var    assembly = IntrospectionExtensions.GetTypeInfo(typeof(JsonLocalHandler)).Assembly;
                Stream stream   = assembly.GetManifestResourceStream(JsonFileEmbeded);

                using (var reader = new System.IO.StreamReader(stream))
                {
                    return(Newtonsoft.Json.JsonConvert.DeserializeObject <T>(await reader.ReadToEndAsync()));
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
                return(default(T));
            }
        }
        private async Task _callPush()
        {
            try
            {
                //App Service Publish Profile Credentials
                //string userName = "******"; //userName
                //string userPassword = "******"; //userPWD

                ////change webJobName to your WebJob name
                //string webJobName = "WEBJOBNAME";

                //var unEncodedString = String.Format($"{userName}:{userPassword}");
                //var encodedString = Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes(unEncodedString));

                //Change this URL to your WebApp hosting the
                string URL = "https://skagry-net-core.azurewebsites.net/api/job/push";


                System.Net.WebRequest request = System.Net.WebRequest.Create(URL);
                request.Method = "GET";
                //request.ContentLength = 0;
                //request.Headers["Authorization"] = "Basic " + encodedString;
                System.Net.WebResponse response = await request.GetResponseAsync();

                var responseFromServer = "no responce";
                using (System.IO.Stream dataStream = response.GetResponseStream()) {
                    using (System.IO.StreamReader reader = new System.IO.StreamReader(dataStream)) {
                        responseFromServer = await reader.ReadToEndAsync();
                    }
                }

                Console.WriteLine(responseFromServer);  //no response
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message.ToString());
            }
            finally {
                await Task.Delay(30000);

                Console.WriteLine("run Next trigger:" + DateTime.UtcNow);
            }
        }
        private async static Task <string> FetchTextFileContents(string inPath)
        {
            if (System.IO.File.Exists(inPath) == false)
            {
                return("");
            }

            try
            {
                using (System.IO.StreamReader streamReader = System.IO.File.OpenText(inPath))
                {
                    return(await streamReader.ReadToEndAsync());
                }
            }
            catch (Exception)
            {
                return("");
            }
        }
Beispiel #60
0
        /// <summary>
        /// Reads a travel log input file.
        /// </summary>
        /// <param name="fileName">The file name.</param>
        /// <returns>A string containing all text from the file.</returns>
        private async Task <string> ReadTravelLog(string fileName)
        {
            var    assembly = typeof(TravelLogStore).GetTypeInfo().Assembly;
            Stream stream   = assembly.GetManifestResourceStream(string.Format("CodeKata.Files.{0}", fileName));

            if (stream == null)
            {
                return("");
            }

            string text = "";

            using (var reader = new System.IO.StreamReader(stream))
            {
                text = await reader.ReadToEndAsync();
            }

            return(text);
        }