Example #1
0
        public async Task <bool> DeployAsync(UpdateInfo info, NetworkCredential credentials)
        {
            try
            {
                var rsa = SignaturePrivateCertificate.GetRSAPrivateKey();

                // generate manifest bytes
                var serializer = new YamlDotNet.Serialization.Serializer();
                var yaml       = serializer.Serialize(info);
                var yamlBytes  = Encoding.UTF8.GetBytes(yaml);

                // generate signature for yaml manifest
                var signature = rsa.SignData(yamlBytes, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);

                try
                {
                    // upload manifest and signature
                    var webClient = new WebClient {
                        Credentials = credentials
                    };

                    await webClient.UploadDataTaskAsync(new Uri(UpdateUri, "update.yml"), "PUT", yamlBytes)
                    .ConfigureAwait(false);

                    await webClient.UploadDataTaskAsync(new Uri(UpdateUri, "update.sig"), "PUT", signature)
                    .ConfigureAwait(false);

                    Logger?.Info("Uploaded update manifest.");

                    // upload all application files
                    foreach (var infoFile in info.Files)
                    {
                        await webClient
                        .UploadFileTaskAsync(new Uri(UpdateUri, infoFile.RelativeUrl), "PUT", infoFile.RelativeUrl)
                        .ConfigureAwait(false);

                        Logger?.Info($"Uploaded {Path.GetFileName(infoFile.RelativeUrl)}.");
                    }

                    return(true);
                }
                catch (WebException e)
                {
                    Logger?.Error("Unable to upload file.", e);
                    return(false);
                }
            }
            catch (CryptographicException e)
            {
                Logger?.Error($"Failed to use private key: {e.Message}", e);
                return(false);
            }
        }
Example #2
0
        private async void loadPickers()
        {
            var getDepartments = await webClient.UploadDataTaskAsync($"{url}/api/getDepartments", "POST", Encoding.UTF8.GetBytes(""));

            listDepartment         = JsonConvert.DeserializeObject <List <Department> >(Encoding.Default.GetString(getDepartments));
            pickerDept.ItemsSource = listDepartment;


            var getAssetGroups = await webClient.UploadDataTaskAsync($"{url}/api/getAssetGroups", "POST", Encoding.UTF8.GetBytes(""));

            listAssetGroups = JsonConvert.DeserializeObject <List <assetgroups> >(Encoding.Default.GetString(getAssetGroups));
            pickerAssetGroup.ItemsSource = listAssetGroups;
        }
Example #3
0
        public static void UploadData_InvalidArguments_ThrowExceptions()
        {
            var wc = new WebClient();

            Assert.Throws <ArgumentNullException>("address", () => { wc.UploadData((string)null, null); });
            Assert.Throws <ArgumentNullException>("address", () => { wc.UploadData((string)null, null, null); });
            Assert.Throws <ArgumentNullException>("address", () => { wc.UploadData((Uri)null, null); });
            Assert.Throws <ArgumentNullException>("address", () => { wc.UploadData((Uri)null, null, null); });

            Assert.Throws <ArgumentNullException>("address", () => { wc.UploadDataAsync((Uri)null, null); });
            Assert.Throws <ArgumentNullException>("address", () => { wc.UploadDataAsync((Uri)null, null, null); });
            Assert.Throws <ArgumentNullException>("address", () => { wc.UploadDataAsync((Uri)null, null, null, null); });

            Assert.Throws <ArgumentNullException>("address", () => { wc.UploadDataTaskAsync((string)null, null); });
            Assert.Throws <ArgumentNullException>("address", () => { wc.UploadDataTaskAsync((string)null, null, null); });
            Assert.Throws <ArgumentNullException>("address", () => { wc.UploadDataTaskAsync((Uri)null, null); });
            Assert.Throws <ArgumentNullException>("address", () => { wc.UploadDataTaskAsync((Uri)null, null, null); });

            Assert.Throws <ArgumentNullException>("data", () => { wc.UploadData("http://localhost", null); });
            Assert.Throws <ArgumentNullException>("data", () => { wc.UploadData("http://localhost", null, null); });
            Assert.Throws <ArgumentNullException>("data", () => { wc.UploadData(new Uri("http://localhost"), null); });
            Assert.Throws <ArgumentNullException>("data", () => { wc.UploadData(new Uri("http://localhost"), null, null); });

            Assert.Throws <ArgumentNullException>("data", () => { wc.UploadDataAsync(new Uri("http://localhost"), null); });
            Assert.Throws <ArgumentNullException>("data", () => { wc.UploadDataAsync(new Uri("http://localhost"), null, null); });
            Assert.Throws <ArgumentNullException>("data", () => { wc.UploadDataAsync(new Uri("http://localhost"), null, null, null); });

            Assert.Throws <ArgumentNullException>("data", () => { wc.UploadDataTaskAsync("http://localhost", null); });
            Assert.Throws <ArgumentNullException>("data", () => { wc.UploadDataTaskAsync("http://localhost", null, null); });
            Assert.Throws <ArgumentNullException>("data", () => { wc.UploadDataTaskAsync(new Uri("http://localhost"), null); });
            Assert.Throws <ArgumentNullException>("data", () => { wc.UploadDataTaskAsync(new Uri("http://localhost"), null, null); });
        }
Example #4
0
        protected override async void OnAppearing()
        {
            base.OnAppearing();

            using (var webClient = new WebClient())
            {
                webClient.Headers.Add("Content-Type", "application/json");
                var getResponse = await webClient.UploadDataTaskAsync($"http://10.0.2.2:49450/Assets/Details?assetSN={_assetSN}", "POST", Encoding.UTF8.GetBytes(""));

                var selectedAsset = JsonConvert.DeserializeObject <CurrentAsset>(Encoding.Default.GetString(getResponse));
                entryAssetName.Text         = selectedAsset.AssetName;
                entryAssetSN.Text           = selectedAsset.AssetSN;
                entryCurrentDepartment.Text = selectedAsset.DepartmentName;
                var getAssetGroupID = _assetSN.Split('/')[1];
                entryNewAssetSN.Text = $"??/{getAssetGroupID}/????";
            }
            using (var webClient = new WebClient())
            {
                webClient.Headers.Add("Content-Type", "application/json");
                var getResponse = await webClient.UploadDataTaskAsync($"http://10.0.2.2:49450/Departments", "POST", Encoding.UTF8.GetBytes(""));

                _departments = JsonConvert.DeserializeObject <List <Department> >(Encoding.Default.GetString(getResponse));
                foreach (var item in _departments)
                {
                    pDestinationDepartment.Items.Add(item.Name);
                }

                pDestinationDepartment.Items.Remove(entryCurrentDepartment.Text);

                var getLocation = await webClient.UploadDataTaskAsync("http://10.0.2.2:49450/Locations", "POST", Encoding.UTF8.GetBytes(""));

                _locations = JsonConvert.DeserializeObject <List <Location> >(Encoding.Default.GetString(getLocation));
            }
            using (var webClient = new WebClient())
            {
                webClient.Headers.Add("Content-Type", "application/json");
                var getResponse = await webClient.UploadDataTaskAsync($"http://10.0.2.2:49450/Assets", "POST", Encoding.UTF8.GetBytes(""));

                _assets = JsonConvert.DeserializeObject <List <Asset> >(Encoding.Default.GetString(getResponse));

                var getDepartmentLocations = await webClient.UploadDataTaskAsync($"http://10.0.2.2:49450/Departments/DepartmentLocations", "POST", Encoding.UTF8.GetBytes(""));

                _departmentLocations = JsonConvert.DeserializeObject <List <DepartmentLocation> >(Encoding.Default.GetString(getDepartmentLocations));

                var getTransferLogs = await webClient.UploadDataTaskAsync($"http://10.0.2.2:49450/AssetTransferLogs", "POST", Encoding.UTF8.GetBytes(""));

                _assetTranferLogs = JsonConvert.DeserializeObject <List <AssetTranferLog> >(Encoding.Default.GetString(getTransferLogs));
            }
        }
Example #5
0
        public async Task <TResponse> PostAsync <TResponse, TData>(string resource, TData data) where TResponse : class
        {
            client = client ?? new WebClient();
            client.Headers.Add(HttpRequestHeader.ContentType, "application/json");
            client.Encoding = Encoding.UTF8;
            var authz = GetBasicAuthzValue();

            if (authz.HasValue())
            {
                client.Headers.Add(HttpRequestHeader.Authorization, authz);
            }

            var json = JSON.Serialize(data);

            byte[] dataBytes     = Encoding.UTF8.GetBytes(json);
            var    uri           = GetUriForResource(resource);
            var    responseBytes = new byte[0];
            await client.UploadDataTaskAsync(uri, "POST", dataBytes).ConfigureAwait(false);

            string response = Encoding.UTF8.GetString(responseBytes);

            if (typeof(TResponse) == typeof(string))
            {
                return(response as TResponse);
            }

            return(JSON.Deserialize <TResponse>(response));
        }
Example #6
0
        private async void btnDelete_Clicked(object sender, EventArgs e)
        {
            if (lvUpdate.SelectedItem == null)
            {
                await DisplayAlert("Delete", "Please select a booking to update!", "Ok");
            }
            else
            {
                var userResponse = await DisplayAlert("Delete", "Please select a booking to update!", "Yes", "Cancel");

                if (userResponse)
                {
                    var toDelete = (GetCustomBookings)lvUpdate.SelectedItem;
                    using (var webClient = new WebClient())
                    {
                        var response = await webClient.UploadDataTaskAsync($"http://10.0.2.2:60022/Bookings/Delete/{toDelete.BookingID}", "POST", Encoding.UTF8.GetBytes(""));

                        var responseString = Encoding.Default.GetString(response);
                        if (responseString != "\"Booking removed successfully!\"")
                        {
                            await DisplayAlert("Delete", "Unable to delete booking! PLease contact administrator!", "Ok");
                        }
                        else
                        {
                            await DisplayAlert("Delete", "Booking removed successfully!", "Ok");
                        }
                    }
                    await UpdateData();
                }
            }
        }
Example #7
0
        public static async Task <string> FileUploadAsync(string filePath)
        {
            try
            {
                if (!File.Exists(filePath))
                {
                    MessageBox.Show("Given file does not exist! Please try again.", "Error!");
                    return(null);
                }
                using (var webClient = new WebClient())
                {
                    string boundary = "------------------------" + DateTime.Now.Ticks.ToString("x");
                    webClient.Headers.Add("Content-Type", "multipart/form-data; boundary=" + boundary);
                    using (var fileStream = File.OpenRead(filePath))
                    {
                        var fileBytes = new byte[fileStream.Length];
                        fileStream.Read(fileBytes, 0, fileBytes.Length);
                        var    fileData = webClient.Encoding.GetString(fileBytes);
                        var    package  = string.Format("--{0}\r\nContent-Disposition: form-data; name=\"file\"; filename=\"{1}\"\r\nContent-Type: {2}\r\n\r\n{3}\r\n--{0}--\r\n", boundary, Path.GetFileName(filePath), "application/octet-stream", fileData);
                        var    nfile    = webClient.Encoding.GetBytes(package);
                        byte[] resp     = await webClient.UploadDataTaskAsync(Settings.UpdateDetails.FileUploadUrl, "POST", nfile);

                        var respDetails = JsonConvert.DeserializeObject <UploadFileResponse>(Encoding.UTF8.GetString(resp));
                        return(respDetails.links[0].href);
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("Make sure FileUploadUrl is set in File>Settings>FileUploadUrl field and it's working.", "Unable to upload file!");
            }
            return(null);
        }
Example #8
0
        private async void uploadFile(string filename, byte[] imgBytes)
        {
            using (var webClient = new WebClient())
            {
                var mConnectivity = (ConnectivityManager)GetSystemService(Context.ConnectivityService);
                var info          = mConnectivity.ActiveNetworkInfo;
                if (info != null && info.IsConnected)
                {
                    if (info.GetState() == NetworkInfo.State.Connected)
                    {
                        progress = new ProgressDialog(this);
                        progress.SetProgressStyle(ProgressDialogStyle.Horizontal);
                        progress.Progress = 0;
                        progress.Show();
                        webClient.UploadProgressChanged += new UploadProgressChangedEventHandler(UploadProgress);
                        webClient.UploadDataCompleted   += new UploadDataCompletedEventHandler(UploadComplete);
                        webClient.Headers.Add("Content-Type", "application/x-www-form-urlencoded");
                        string postData = "FileName=" + filename + ".jpg&UploadFile=" + WebUtility.UrlEncode(System.Convert.ToBase64String(imgBytes));
                        //string postData = "FileName=test.jpg&UploadFile=test";
                        byte[] byteArray = Encoding.UTF8.GetBytes(postData);
                        byte[] response  = await webClient.UploadDataTaskAsync("http://192.168.5.100:8008/getImage.ashx", byteArray);

                        string s = webClient.Encoding.GetString(response);
                        Toast.MakeText(this, s, ToastLength.Short).Show();
                    }
                }
                else
                {
                    Toast.MakeText(this, "网络不可用", ToastLength.Short).Show();
                }
            }
        }
        public async Task <bool> Login(string login, string password)
        {
            var tokenUri = $"{_networkConfiguration.Api}/token";
            var body     = $"login={login}&password={password}";
            var jsonBody = JsonSerializer.Serialize(new Credentials {
                Login = login, Password = password
            });
            var requestBody = Encoding.UTF8.GetBytes(jsonBody);

            using (var client = new WebClient())
            {
                try
                {
                    client.Headers.Add(HttpRequestHeader.ContentType, "application/json");
                    client.Headers.Add(HttpRequestHeader.ContentLength, requestBody.Length.ToString());
                    var res = await client.UploadDataTaskAsync(tokenUri, "POST", requestBody);

                    var res1 = Encoding.UTF8.GetString(res);
                    return(true);
                }
                catch (WebException ex)
                {
                    var res = ex.Message;
                    return(false);
                }
            }
        }
Example #10
0
        private async Task <ApiResult <T> > DoRequestAsync <T>(string url, HttpMethod httpMethod = HttpMethod.Get, object body = null)
        {
            try
            {
                using (var webClient = new WebClient())
                {
                    var authInfo = await yandexCredentials.GetAuthorizationInfoAsync().ConfigureAwait(false);

                    webClient.Headers.Set("Authorization", $"OAuth {authInfo.Token}");

                    var fullUrl       = $"{urlPrefix}/{url}";
                    var firstResponse = httpMethod == HttpMethod.Post
                        ? await webClient.UploadDataTaskAsync(fullUrl, body.ToFormData()).ConfigureAwait(false)
                        : await webClient.DownloadDataTaskAsync(fullUrl).ConfigureAwait(false);

                    var f = Encoding.UTF8.GetString(firstResponse);

                    return(serializer.Deserialize <ApiResult <T> >(firstResponse));
                }
            }
            catch (WebException e)
            {
                var responseStream = e.Response?.GetResponseStream();
                if (responseStream == null)
                {
                    throw new YandexApiException($"YandexApi Error {e.Status} {e.Message}");
                }

                using (var reader = new StreamReader(responseStream))
                {
                    throw new YandexApiException($"YandexApi Error {await reader.ReadToEndAsync().ConfigureAwait(false)}");
                }
            }
        }
Example #11
0
        internal async Task <string> sendCardStats()
        {
            try
            {
                MetaLog.Info("Uploading Game to MetaStats.net ...", "sendRequest");

                string url = "http://metastats.net/metadetector/stats.php?a=Stats&v=0.0.2";


                string postData = GetCardStats();

                if (postData != "")
                {
                    WebClient client = new WebClient();
                    byte[]    data   = Encoding.UTF8.GetBytes(postData);
                    //byte[] data = Compress.Zip(postData);
                    Uri uri      = new Uri(url);
                    var response = Encoding.UTF8.GetString(await client.UploadDataTaskAsync(uri, "POST", data));

                    MetaLog.Info("Game Upload Done", "sendRequest");

                    return(response);
                }

                return(null);
            }
            catch (Exception ex)
            {
                MetaLog.Error(ex);
                return(null);
            }
        }
Example #12
0
        public async Task <byte[]> PostAsync(Uri url, string parameters)
        {
#if DEBUG
            var cached = TestingEnvCore.GetUrlBytes(url, parameters);
            if (cached != null)
            {
                return(cached);
            }
#endif
            try
            {
                using (var webClient = new WebClient())
                {
                    webClient.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded";
                    var data = Encoding.Default.GetBytes(parameters);

                    var result = await webClient.UploadDataTaskAsync(url, data);

#if DEBUG
                    TestingEnvCore.StoreUrlBytes(url, parameters, result);
#endif

                    return(result);
                }
            }
            catch (Exception e)
            {
                _logger.Exception(e);
                return(null);
            }
        }
Example #13
0
        public static async Task <string> Execute(string text)
        {
            try
            {
                string url     = "https://westus.api.cognitive.microsoft.com/text/analytics/v2.0/languages";
                string data    = "{\"documents\": [ {\"id\": \"" + new Guid().ToString() + "\",\"text\": \"" + text + "\"	} ]}";
                byte[] payload = Encoding.ASCII.GetBytes(data);

                s_httpClient.Headers.Add(HttpRequestHeader.ContentType, "application/json");
                s_httpClient.Headers.Add("Ocp-Apim-Subscription-Key", BotConfiguration.TEXTANALYTICS_KEY);
                byte[] response = await s_httpClient.UploadDataTaskAsync(url, payload);

                ResponseBody body = null;
                using (var stream = new MemoryStream(response))
                    body = Utils.Deserialize <ResponseBody>(stream);

                string returnedLanguage = body.documents[0].detectedLanguages[0].name.ToLower();
                if (s_allowedLanguages.Contains(returnedLanguage))
                {
                    return(returnedLanguage);
                }
                return(LanguageManager.DEFAULT_LANG);
            }
            catch (Exception)
            {
                return(LanguageManager.DEFAULT_LANG);
            }
        }
        private async void btnReject_Clicked(object sender, EventArgs e)
        {
            if (lvBookings.SelectedItem == null)
            {
                await DisplayAlert("Reject", "Please select a booking to reject!", "Ok");
            }
            else
            {
                var rejectValue = "Rejected";
                var toReject    = (BookingManagerView)lvBookings.SelectedItem;
                using (var webClient = new WebClient())
                {
                    var response = await webClient.UploadDataTaskAsync($"http://10.0.2.2:60022/Bookings/ApproveBookings/{toReject.BookingID}?value={rejectValue}",
                                                                       "POST", Encoding.UTF8.GetBytes(""));

                    var responseString = Encoding.Default.GetString(response);
                    if (responseString == "\"Booking rejected successfully!\"")
                    {
                        await DisplayAlert("Reject", "Booking rejected successfully!", "Ok");
                    }
                    else
                    {
                        await DisplayAlert("Reject", "Unable to reject booking!", "Ok");
                    }
                }
                await LoadData();
            }
        }
        private async void btnApprove_Clicked(object sender, EventArgs e)
        {
            if (lvBookings.SelectedItem == null)
            {
                await DisplayAlert("Approve", "Please select a booking to approve!", "Ok");
            }
            else
            {
                var approveValue = "Approved";
                var toApprove    = (BookingManagerView)lvBookings.SelectedItem;
                using (var webClient = new WebClient())
                {
                    var response = await webClient.UploadDataTaskAsync($"http://10.0.2.2:60022/Bookings/ApproveBookings/{toApprove.BookingID}?value={approveValue}",
                                                                       "POST", Encoding.UTF8.GetBytes(""));

                    var responseString = Encoding.Default.GetString(response);
                    if (responseString == "\"Unable to approve booking! Package quantity is not enough!\"")
                    {
                        await DisplayAlert("Approve", "Unable to approve booking! Package quantity is not enough!", "Ok");
                    }
                    else
                    {
                        await DisplayAlert("Approve", "Booking approved successfully!", "Ok");
                    }
                }
                await LoadData();
            }
        }
Example #16
0
        public static async Task UploadPackagedInis(IEnumerable <IndexedArchive> archives)
        {
            archives = archives.ToArray(); // defensive copy
            Utils.Log($"Packaging {archives.Count()} inis");
            try
            {
                await using var ms = new MemoryStream();
                using (var z = new ZipArchive(ms, ZipArchiveMode.Create, true))
                {
                    foreach (var archive in archives)
                    {
                        var state = (AbstractDownloadState)(await DownloadDispatcher.ResolveArchive(archive.IniData));
                        var entry = z.CreateEntry(Path.GetFileName(archive.Name));
                        await using var os = entry.Open();
                        await os.WriteAsync(Encoding.UTF8.GetBytes(string.Join("\n", state.GetMetaIni())));
                    }
                }

                var webClient = new WebClient();
                await webClient.UploadDataTaskAsync($"https://{Consts.WabbajackCacheHostname}/indexed_files/notify",
                                                    "POST", ms.ToArray());
            }
            catch (Exception ex)
            {
                Utils.Log(ex.ToString());
            }
        }
Example #17
0
        private async void btnLogin_Clicked(object sender, EventArgs e)
        {
            var username  = Convert.FromBase64String(entryUsername.Text);
            var password  = Convert.FromBase64String(entryPassword.Text);
            var LoginUser = new LoginDetails();

            using (var rsa = new RSACryptoServiceProvider(2048))
            {
                rsa.PersistKeyInCsp = false;
                rsa.ImportParameters(publicKey);
                LoginUser.encrytedUsername = rsa.Encrypt(username, true);
                LoginUser.encrytedPassword = rsa.Encrypt(password, true);
                using (var webClient = new WebClient())
                {
                    webClient.Headers.Add("Content-Type", "application/json");
                    var jsonData = JsonConvert.SerializeObject(LoginUser);
                    var response = await webClient.UploadDataTaskAsync($"http://10.0.2.2:51908/LoginUsers/Login", "POST", Encoding.UTF8.GetBytes(jsonData));

                    if (Encoding.Default.GetString(response) != "\"User not found or credentials are incorrect!\"")
                    {
                        await DisplayAlert("Login", "Login successful", "Ok");
                    }
                    else
                    {
                        await DisplayAlert("Login", "Login unsuccessful! Please check your credentials", "Ok");
                    }
                }
            }
        }
Example #18
0
 private static async Task <CloudConvertResponseResult> PostUploadJsonAsync(string url, byte[] data)
 {
     try
     {
         using (var wc = new WebClient())
         {
             wc.Headers[HttpRequestHeader.ContentType] = "binary/octet-stream";
             var result = wc.UploadDataTaskAsync(url, "PUT", data)
                          .ContinueWith(task => new CloudConvertResponseResult()
             {
                 IsError = false,
                 Result  = Encoding.UTF8.GetString(task.Result, 0, task.Result.Length)
             });
             return(await result);
         }
     }
     catch (WebException webEx)
     {
         return(await new Task <CloudConvertResponseResult>(() => new CloudConvertResponseResult()
         {
             IsError = true,
             Result = webEx.Message
         }));
     }
 }
Example #19
0
        /// <summary>
        /// 使用Post方法上传数据并下载文件或结果
        /// </summary>
        /// <param name="url"></param>
        /// <param name="data"></param>
        /// <param name="stream"></param>
        public static async Task DownloadAsync(string url, string data, Stream stream)
        {
            var wc        = new WebClient();
            var fileBytes = await wc.UploadDataTaskAsync(url, "POST", Encoding.UTF8.GetBytes(string.IsNullOrEmpty(data) ? "" : data));

            await stream.WriteAsync(fileBytes, 0, fileBytes.Length);//也可以分段写入
        }
Example #20
0
        /// <summary>
        /// Get 请求
        /// </summary>
        /// <param name="url">地址</param>
        /// <param name="paramString">参数字符串</param>
        /// <param name="encoding">字符编码类型(默认 UTF8)</param>
        /// <returns></returns>
        public static async Task <string> GetAsync(string url, string paramString, Encoding encoding = null)
        {
            if (string.IsNullOrEmpty(url))
            {
                throw new Exception("url 为空!");
            }

            if (string.IsNullOrEmpty(paramString))
            {
                return(await GetAsync(url));
            }

            try
            {
                encoding = encoding ?? DefaultEncoding;

                using (var webClient = new WebClient())
                {
                    var data         = encoding.GetBytes(paramString);                        //编码,尤其是汉字,事先要看下抓取网页的编码方式
                    var responseData = await webClient.UploadDataTaskAsync(url, "GET", data); //得到返回字符流

                    return(encoding.GetString(responseData));                                 //解码
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
Example #21
0
        /// <summary>
        /// 1 生成预支付订单,获得预支付Id以便于发起微信支付
        /// </summary>
        /// <param name="proTitle"></param>
        /// <param name="total_fee"></param>
        /// <returns></returns>
        public async Task <string> GoPrePayId(string proTitle, decimal total_fee)
        {
            //1 生成预支付订单
            var prePayId  = "";
            var prePayErr = "";

            WebClient client = new WebClient();
            string    entity = GenProductArgs(proTitle, total_fee);

            client.Headers.Add("Accept", "application/json");
            client.Headers.Add("Content-Type", "application/json");
            byte[] responseByte = null;
            try {
                responseByte = await client.UploadDataTaskAsync(url, "POST", Encoding.UTF8.GetBytes(entity));

                string content = Encoding.UTF8.GetString(responseByte);
                Dictionary <string, string> responseXml = DecodeXml(content);
                prePayId  = responseXml["prepay_id"];
                prePayErr = responseXml.ContainsKey("err_code_des") ? responseXml["err_code_des"] : "";
                if (string.IsNullOrEmpty(prePayErr))
                {
                    prePayErr = responseXml.ContainsKey("return_msg") ? responseXml["return_msg"] : "";
                }

                Toast.MakeText(this.Context, "prePayId:" + prePayId, ToastLength.Short).Show();
            }
            catch (Exception ex) {
                Toast.MakeText(this.Context, "请求标识出错:" + prePayId + "_" + prePayErr + "_" + ex.GetAllMsg(), ToastLength.Short).Show();
            }
            finally {
            }

            return(prePayId);
        }
Example #22
0
        /// <summary>
        /// POST 请求
        /// </summary>
        /// <param name="url">地址</param>
        /// <param name="paramString">参数字符串</param>
        /// <param name="encoding">字符编码类型(默认 UTF8)</param>
        /// <returns></returns>
        public static async Task <string> PostAsync(string url, string paramString = "", Encoding encoding = null)
        {
            if (string.IsNullOrEmpty(url))
            {
                throw new Exception("url 为空!");
            }

            try
            {
                paramString = paramString ?? "";
                encoding    = encoding ?? DefaultEncoding;
                var data = encoding.GetBytes(paramString);

                using (var webClient = new WebClient())
                {
                    //采取POST方式必须加的header,如果改为GET方式的话就去掉这句话即可
                    webClient.Headers.Add("Content-Type", "application/x-www-form-urlencoded");
                    var responseData = await webClient.UploadDataTaskAsync(url, "POST", data); //得到返回字符流

                    return(encoding.GetString(responseData));                                  //解码
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
Example #23
0
        /// <summary>
        /// 上传
        /// </summary>
        /// <param name="requestUrl">请求url</param>
        /// <param name="responseText">响应</param>
        /// <returns></returns>
        async public Task <byte[]> Upload(String url)
        {
            WebClient webClient = new WebClient();

            webClient.Headers.Add("Content-Type", "multipart/form-data; boundary=" + boundary);
            return(await webClient.UploadDataTaskAsync(url, MergeContent()));
        }
Example #24
0
        private static async Task <string> UploadStringAsync(string url, string paramString = null,
                                                             Encoding encoding = null)
        {
            if (string.IsNullOrEmpty(url))
            {
                throw new ArgumentException("url 为空");
            }

            try
            {
                using (var webClient = new WebClient())
                {
                    byte[] responseData;
                    encoding = encoding ?? DefaultEncoding;

                    if (string.IsNullOrEmpty(paramString))
                    {
                        responseData = await webClient.DownloadDataTaskAsync(url);
                    }
                    else
                    {
                        var data = encoding.GetBytes(paramString);                            //编码,尤其是汉字,事先要看下抓取网页的编码方式
                        responseData = await webClient.UploadDataTaskAsync(url, "GET", data); //得到返回字符流
                    }

                    return(encoding.GetString(responseData)); //解码
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
Example #25
0
 public static async Task ConcurrentOperations_Throw()
 {
     await LoopbackServer.CreateServerAsync((server, url) =>
     {
         var wc       = new WebClient();
         Task ignored = wc.DownloadDataTaskAsync(url); // won't complete
         Assert.Throws <NotSupportedException>(() => { wc.DownloadData(url); });
         Assert.Throws <NotSupportedException>(() => { wc.DownloadDataAsync(url); });
         Assert.Throws <NotSupportedException>(() => { wc.DownloadDataTaskAsync(url); });
         Assert.Throws <NotSupportedException>(() => { wc.DownloadString(url); });
         Assert.Throws <NotSupportedException>(() => { wc.DownloadStringAsync(url); });
         Assert.Throws <NotSupportedException>(() => { wc.DownloadStringTaskAsync(url); });
         Assert.Throws <NotSupportedException>(() => { wc.DownloadFile(url, "path"); });
         Assert.Throws <NotSupportedException>(() => { wc.DownloadFileAsync(url, "path"); });
         Assert.Throws <NotSupportedException>(() => { wc.DownloadFileTaskAsync(url, "path"); });
         Assert.Throws <NotSupportedException>(() => { wc.UploadData(url, new byte[42]); });
         Assert.Throws <NotSupportedException>(() => { wc.UploadDataAsync(url, new byte[42]); });
         Assert.Throws <NotSupportedException>(() => { wc.UploadDataTaskAsync(url, new byte[42]); });
         Assert.Throws <NotSupportedException>(() => { wc.UploadString(url, "42"); });
         Assert.Throws <NotSupportedException>(() => { wc.UploadStringAsync(url, "42"); });
         Assert.Throws <NotSupportedException>(() => { wc.UploadStringTaskAsync(url, "42"); });
         Assert.Throws <NotSupportedException>(() => { wc.UploadFile(url, "path"); });
         Assert.Throws <NotSupportedException>(() => { wc.UploadFileAsync(url, "path"); });
         Assert.Throws <NotSupportedException>(() => { wc.UploadFileTaskAsync(url, "path"); });
         Assert.Throws <NotSupportedException>(() => { wc.UploadValues(url, new NameValueCollection()); });
         Assert.Throws <NotSupportedException>(() => { wc.UploadValuesAsync(url, new NameValueCollection()); });
         Assert.Throws <NotSupportedException>(() => { wc.UploadValuesTaskAsync(url, new NameValueCollection()); });
         return(Task.CompletedTask);
     });
 }
Example #26
0
        private async void btnUnlock_Clicked(object sender, EventArgs e)
        {
            var password = await DisplayPromptAsync("Master Login", "Please key in master password");

            using (var webClient = new WebClient())
            {
                webClient.Headers.Add("Content-Type", "application/json");
                var response = await webClient.UploadDataTaskAsync($"http://10.0.2.2:51908/LoginUsers/GetPublicKey?password={password}", "POST", Encoding.UTF8.GetBytes(""));

                if (Encoding.Default.GetString(response) == "\"Password incorrect! Application will now close!\"")
                {
                    await DisplayAlert("Master Login", "Password incorrect! Application will now close!", "Ok");

                    System.Diagnostics.Process.GetCurrentProcess().Kill();
                }
                else
                {
                    publicKey = JsonConvert.DeserializeObject <RSAParameters>(Encoding.Default.GetString(response));
                    await DisplayAlert("Master Login", "Login successful", "Ok");

                    StackField.IsVisible = true;
                    btnUnlock.IsVisible  = false;
                }
            }
        }
Example #27
0
        public static async Task SendSlackMessageAsync(Configure <SlackMessage> configurator, string webhook)
        {
            var message = configurator(new SlackMessage());
            var payload = JsonConvert.SerializeObject(message);
            var data    = new NameValueCollection {
                ["payload"] = payload
            };

            using (var client = new WebClient())
            {
                client.Headers["Content-Type"] = "application/x-www-form-urlencoded";

                var stringBuilder = new StringBuilder();
                var str           = string.Empty;
                foreach (var key in data.AllKeys)
                {
                    stringBuilder
                    .Append(str)
                    .Append(HttpUtility.UrlEncode(key))
                    .Append(value: '=')
                    .Append(HttpUtility.UrlEncode(data[key]));

                    str = "&";
                }

                var bytes = Encoding.ASCII.GetBytes(stringBuilder.ToString());

                var response = await client.UploadDataTaskAsync(webhook, "POST", bytes);

                var responseText = Encoding.UTF8.GetString(response);
                ControlFlow.Assert(responseText == "ok", $"'{responseText}' == 'ok'");
            }
        }
Example #28
0
        private static async Task MigrateMissionv2()
        {
            using StreamReader reader = new StreamReader(Path.Combine(Directory.GetCurrentDirectory(), "Migrate", "missionv2.json"));
            var json = await reader.ReadToEndAsync();

            var data = JsonConvert.DeserializeObject <MissionModel[]>(json, new JsonSerializerSettings
            {
                TypeNameHandling = TypeNameHandling.All
            });

            foreach (var m in data)
            {
                try
                {
                    using (WebClient webClient = new WebClient())
                    {
                        string missionJson = JsonConvert.SerializeObject(m, new JsonSerializerSettings
                        {
                            TypeNameHandling = TypeNameHandling.All
                        });
                        webClient.Headers.Add("Accept", "text/json");
                        webClient.Headers.Add("Content-Type", "text/json");
                        await webClient.UploadDataTaskAsync(new Uri($"{URL}/api/missions/createMissionFromApi"), Encoding.UTF8.GetBytes(missionJson));
                    }
                }
                catch (Exception e)
                {
                }
            }

            //Console.WriteLine(json);
        }
Example #29
0
        public void TestSignup()
        {
            StringBuilder json = new StringBuilder();

            json.Append("{");
            json.Append("\"pwd\":\"testPwd\",");
            json.Append("\"name\":\"testName\",");
            json.Append("\"email\":\"[email protected]\"");
            json.Append("}");
            byte[] requestData = Encoding.GetEncoding("UTF-8").GetBytes(json.ToString());

            WebClient client = new WebClient();

            client.Headers.Add("Content-Type", "application/json");
            client.Headers.Add("ContentLength", requestData.Length.ToString());

            client.UploadDataTaskAsync("http://localhost:49938/SignService.svc/sign/zsp123456,,,1/", "POST", requestData)
            .ContinueWith(
                (task) =>
            {
                if (task.Exception == null)
                {
                    string result = Encoding.GetEncoding("UTF-8").GetString(task.Result);
                    Console.WriteLine("result is:");
                    Console.WriteLine(result);
                }
                else
                {
                    Console.WriteLine((task.Exception.InnerException as WebException).Message);
                    Console.WriteLine("-------------------------");
                    Console.WriteLine(task.Exception);
                }
            });
        }
Example #30
0
        protected override async void OnAppearing()
        {
            base.OnAppearing();
            using (var webClient = new WebClient())
            {
                var response = await webClient.UploadDataTaskAsync("http://10.0.2.2:49450/Assets", "POST", Encoding.UTF8.GetBytes(""));

                _assets = JsonConvert.DeserializeObject <List <Asset> >(Encoding.Default.GetString(response));
            }
            var getAssetID = (from x in _assets
                              where x.AssetSN == _assetSN
                              select x.ID).First();

            using (var webClient = new WebClient())
            {
                var response = await webClient.UploadDataTaskAsync($"http://10.0.2.2:49450/AssetTransferLogs/GetAssetLogs?assetID={getAssetID}", "POST", Encoding.UTF8.GetBytes(""));

                var getString = Encoding.Default.GetString(response);
                if (getString == "\"No details available\"")
                {
                    lvTransfer.IsVisible = false;
                    lblNull.IsVisible    = true;
                }
                else
                {
                    var listSource = JsonConvert.DeserializeObject <List <History> >(getString);
                    lvTransfer.ItemsSource = listSource;
                }
            }
        }
Example #31
0
        public static void UploadData_InvalidArguments_ThrowExceptions()
        {
            var wc = new WebClient();

            Assert.Throws<ArgumentNullException>("address", () => { wc.UploadData((string)null, null); });
            Assert.Throws<ArgumentNullException>("address", () => { wc.UploadData((string)null, null, null); });
            Assert.Throws<ArgumentNullException>("address", () => { wc.UploadData((Uri)null, null); });
            Assert.Throws<ArgumentNullException>("address", () => { wc.UploadData((Uri)null, null, null); });

            Assert.Throws<ArgumentNullException>("address", () => { wc.UploadDataAsync((Uri)null, null); });
            Assert.Throws<ArgumentNullException>("address", () => { wc.UploadDataAsync((Uri)null, null, null); });
            Assert.Throws<ArgumentNullException>("address", () => { wc.UploadDataAsync((Uri)null, null, null, null); });

            Assert.Throws<ArgumentNullException>("address", () => { wc.UploadDataTaskAsync((string)null, null); });
            Assert.Throws<ArgumentNullException>("address", () => { wc.UploadDataTaskAsync((string)null, null, null); });
            Assert.Throws<ArgumentNullException>("address", () => { wc.UploadDataTaskAsync((Uri)null, null); });
            Assert.Throws<ArgumentNullException>("address", () => { wc.UploadDataTaskAsync((Uri)null, null, null); });

            Assert.Throws<ArgumentNullException>("data", () => { wc.UploadData("http://localhost", null); });
            Assert.Throws<ArgumentNullException>("data", () => { wc.UploadData("http://localhost", null, null); });
            Assert.Throws<ArgumentNullException>("data", () => { wc.UploadData(new Uri("http://localhost"), null); });
            Assert.Throws<ArgumentNullException>("data", () => { wc.UploadData(new Uri("http://localhost"), null, null); });

            Assert.Throws<ArgumentNullException>("data", () => { wc.UploadDataAsync(new Uri("http://localhost"), null); });
            Assert.Throws<ArgumentNullException>("data", () => { wc.UploadDataAsync(new Uri("http://localhost"), null, null); });
            Assert.Throws<ArgumentNullException>("data", () => { wc.UploadDataAsync(new Uri("http://localhost"), null, null, null); });

            Assert.Throws<ArgumentNullException>("data", () => { wc.UploadDataTaskAsync("http://localhost", null); });
            Assert.Throws<ArgumentNullException>("data", () => { wc.UploadDataTaskAsync("http://localhost", null, null); });
            Assert.Throws<ArgumentNullException>("data", () => { wc.UploadDataTaskAsync(new Uri("http://localhost"), null); });
            Assert.Throws<ArgumentNullException>("data", () => { wc.UploadDataTaskAsync(new Uri("http://localhost"), null, null); });
        }
Example #32
0
 protected override Task<byte[]> UploadDataAsync(WebClient wc, string address, byte[] data) => wc.UploadDataTaskAsync(address, data);
Example #33
0
 public static async Task ConcurrentOperations_Throw()
 {
     await LoopbackServer.CreateServerAsync((server, url) =>
     {
         var wc = new WebClient();
         Task ignored = wc.DownloadDataTaskAsync(url); // won't complete
         Assert.Throws<NotSupportedException>(() => { wc.DownloadData(url); });
         Assert.Throws<NotSupportedException>(() => { wc.DownloadDataAsync(url); });
         Assert.Throws<NotSupportedException>(() => { wc.DownloadDataTaskAsync(url); });
         Assert.Throws<NotSupportedException>(() => { wc.DownloadString(url); });
         Assert.Throws<NotSupportedException>(() => { wc.DownloadStringAsync(url); });
         Assert.Throws<NotSupportedException>(() => { wc.DownloadStringTaskAsync(url); });
         Assert.Throws<NotSupportedException>(() => { wc.DownloadFile(url, "path"); });
         Assert.Throws<NotSupportedException>(() => { wc.DownloadFileAsync(url, "path"); });
         Assert.Throws<NotSupportedException>(() => { wc.DownloadFileTaskAsync(url, "path"); });
         Assert.Throws<NotSupportedException>(() => { wc.UploadData(url, new byte[42]); });
         Assert.Throws<NotSupportedException>(() => { wc.UploadDataAsync(url, new byte[42]); });
         Assert.Throws<NotSupportedException>(() => { wc.UploadDataTaskAsync(url, new byte[42]); });
         Assert.Throws<NotSupportedException>(() => { wc.UploadString(url, "42"); });
         Assert.Throws<NotSupportedException>(() => { wc.UploadStringAsync(url, "42"); });
         Assert.Throws<NotSupportedException>(() => { wc.UploadStringTaskAsync(url, "42"); });
         Assert.Throws<NotSupportedException>(() => { wc.UploadFile(url, "path"); });
         Assert.Throws<NotSupportedException>(() => { wc.UploadFileAsync(url, "path"); });
         Assert.Throws<NotSupportedException>(() => { wc.UploadFileTaskAsync(url, "path"); });
         Assert.Throws<NotSupportedException>(() => { wc.UploadValues(url, new NameValueCollection()); });
         Assert.Throws<NotSupportedException>(() => { wc.UploadValuesAsync(url, new NameValueCollection()); });
         Assert.Throws<NotSupportedException>(() => { wc.UploadValuesTaskAsync(url, new NameValueCollection()); });
         return Task.CompletedTask;
     });
 }