/// <summary> /// 执行http请求 /// </summary> /// <returns>请求结果</returns> private async Task <TResponse> SendAsync <TResponse>() { TResponse result; using (var cancellation = this.CreateLinkedTokenSource()) { var completionOption = HttpCompletionOption.ResponseContentRead; var response = await this.HttpApiConfig.HttpClient.SendAsync(this.RequestMessage, completionOption, cancellation.Token).ConfigureAwait(false); string responseString = await response.Content.ReadAsStringAsync(); if (!response.IsSuccessStatusCode) { throw GetFaildException(response); } try { result = JsonExtensions.Deserialize <TResponse>(responseString); } catch (Exception ex) { throw ex; } } return(result); }
public async void GetAuthorizedHubs() { var message = await Configuration.Post("/api/Account/GetAuthorizedHubs", null); var user = JsonExtensions.Deserialize <ReturnValue <DexihHub[]> >(message); Assert.True(user.Success); }
public async Task <CepDTO.Retorno> ObterCep(CepDTO.Envio dto) { var response = await _httpClient.GetAsync(string.Format(_uri, dto.Cep)); var retornoJson = response.Content.ReadAsStringAsync().Result; var endereco = JsonExtensions.Deserialize <CepDTO.Retorno>(retornoJson); return(endereco); }
public async void GetHub() { var hubKey = new { HubKey = 2 }; var message = await Configuration.Post("/api/Hub/GetHubCache", hubKey); var hubResult = JsonExtensions.Deserialize <ReturnValue <DexihHub> >(message); Assert.True(hubResult.Success); }
public void DeserializeTest2() { string userStr = "{\"Id\":11, \"Name\":\"Xiaoming\"}"; var jsonDo = JsonExtensions.Deserialize(userStr, typeof(UserDo)); Assert.True(jsonDo is UserDo); var userDo = jsonDo as UserDo; Assert.NotNull(userDo); Assert.Equal(11, userDo.Id); Assert.Equal("Xiaoming", userDo.Name); }
protected async Task <T> Put <T>(string url, string putData) where T : BaseResponse { var response = await Client.PutAsync(url, new StringContent(putData)); T output = JsonExtensions.Deserialize <T>(await response.Content.ReadAsStringAsync()); if (output.Errcode != 0) { throw new TencentHttpException(url, putData, output); } return(output); }
public async void SaveHub() { var hub = new DexihHub() { Name = HubName, Description = "The description", EncryptionKey = "123" }; var message = await Configuration.Post("/api/Account/SaveHub", hub); var user = JsonExtensions.Deserialize <ReturnValue <DexihHub> >(message); Assert.True(user.Success); }
public void DeserializeTest() { string userStr = "{\"Id\":11, \"Name\":\"Xiaoming\"}"; var userDo = JsonExtensions.Deserialize <UserDo>(userStr); Assert.NotNull(userDo); Assert.Equal(11, userDo.Id); Assert.Equal("Xiaoming", userDo.Name); string otherStr = "\"Key\":11, \"Index\":\"Xiaoming\"}"; Assert.Throws <Newtonsoft.Json.JsonSerializationException>(() => JsonExtensions.Deserialize <UserDo>(otherStr)); string otherStr2 = "{\"Key\":11, \"Index\":\"Xiaoming\"}"; var userDo2 = JsonExtensions.Deserialize <UserDo>(otherStr2); Assert.NotNull(userDo2); Assert.Equal(0, userDo2.Id); Assert.Null(userDo2.Name); }
public static async Task Login() { var user = new { Email = AppSettings["DexihEmail"], Password = AppSettings["DexihPassword"], RememberMe = true }; CookieContainer = new CookieContainer(); var handler = new HttpClientHandler() { CookieContainer = CookieContainer }; if (HttpClient == null) { HttpClient = new HttpClient(handler) { Timeout = TimeSpan.FromSeconds(600) }; } var result = await Post("/api/Account/Login", user); var message = JsonExtensions.Deserialize <ReturnValue>(result); Assert.True(message.Success); // Get user required to refresh the antiforgerytoken result = await Post("/api/Account/GetUser", null); var user2 = JsonExtensions.Deserialize <ReturnValue <ApplicationUser> >(result); Assert.True(user2.Success); Assert.Equal(user.Email, user2.Value.Email); }
//public async Task<StatusEnum> SyncAsync<TSource, TModel>(ICollection<TSource> currentListEntities, // List<TModel> newList, Func<TModel, CurrentUserViewModel, TSource> newEntity, Expression<Func<TSource, TModel, bool>> indentifier, Role[] allowedRoles, bool save) where TSource : BaseEntity //{ // var currentUser = CurrentUser(); // if (currentUser == null) // return StatusEnum.UserIsNull; // if (currentListEntities?.Any() == true) // { // var mustBeLeft = currentListEntities.Where(source => newList.Any(model => indentifier.Compile().Invoke(source, model))).ToList(); // var mustBeRemoved = currentListEntities.Where(x => !mustBeLeft.Contains(x)).ToList(); // if (mustBeRemoved.Count > 0) // foreach (var redundant in mustBeRemoved) // await RemoveAsync(redundant, null, DeleteEnum.Delete, false); // } // if (newList?.Any() != true) // return await SaveChangesAsync(); // foreach (var model in newList) // { // var source = currentListEntities?.FirstOrDefault(entity => indentifier.Compile().Invoke(entity, model)); // if (source == null) // { // var newItem = newEntity.Invoke(model, currentUser); // await AddAsync(newItem, allowedRoles, false); // } // else // { // if (!source.IsDeleted) // continue; // _unitOfWork.UnDelete(source, currentUser); // } // } // return await SaveChangesAsync(); //} public CurrentUserViewModel CurrentUser(List <Claim> claims) { if (claims.Count == 0) { return(null); } var result = new CurrentUserViewModel { Username = claims.Find(x => x.Type == ClaimTypes.Name)?.Value, Mobile = claims.Find(x => x.Type == ClaimTypes.MobilePhone)?.Value, Role = claims.Find(x => x.Type == ClaimTypes.Role)?.Value.To <Role>() ?? Role.User, EncryptedPassword = claims.Find(x => x.Type == ClaimTypes.Hash)?.Value, Id = claims.Find(x => x.Type == ClaimTypes.NameIdentifier)?.Value, FirstName = claims.Find(x => x.Type == "FirstName")?.Value, LastName = claims.Find(x => x.Type == "LastName")?.Value, EmployeeId = claims.Find(x => x.Type == "EmployeeId")?.Value, UserPropertyCategories = JsonExtensions.Deserialize <List <CategoryJsonViewModel> >(claims.Find(x => x.Type == "PropertyCategories")?.Value), UserItemCategories = JsonExtensions.Deserialize <List <CategoryJsonViewModel> >(claims.Find(x => x.Type == "ItemCategories")?.Value), EmployeeDivisions = JsonExtensions.Deserialize <List <DivisionJsonViewModel> >(claims.Find(x => x.Type == "EmployeeDivisions")?.Value), }; return(result); }
public async Task WebSocketEchoTests() { var cookies = new CookieContainer(); var handler = new HttpClientHandler { CookieContainer = cookies }; //Login to the web server to receive an authenicated cookie. using (var httpClient = new HttpClient(handler)) { httpClient.DefaultRequestHeaders.Add("Accept", "application/json"); var content = new StringContent("{\"Email\":\"[email protected]\",\"Password\":\"dexIH-1\"}", Encoding.UTF8, "application/json"); var response = await httpClient.PostAsync(Url + "Account/Login", content); var result = await response.Content.ReadAsStringAsync(); Assert.False(string.IsNullOrEmpty(result), "Error Account/Login"); var loginResult = JsonExtensions.Deserialize <ReturnValue <object> >(result); Assert.True(loginResult.Success, "login failed: " + loginResult.Message); } }
private TempCredentialResult GenTempCredential(Dictionary <string, object> values) { try { Dictionary <string, object> credential = STSClient.genCredential(values); TempCredentialResult output = new TempCredentialResult { Bucket = values["bucket"].ToString(), Region = values["region"].ToString() }; IList <string> errs = new List <string>(); foreach (KeyValuePair <string, object> kvp in credential) { switch (kvp.Key) { case "Credentials": output.Credential = JsonExtensions.Deserialize <TempCredential>(kvp.Value.ToString()); break; case "ExpiredTime": if (long.TryParse(kvp.Value.ToString(), out long et)) { output.ExpiredTime = et; } else { errs.Add("ExpiredTime"); errs.Add("kvp.Value.ToString()"); // logger.LogError($"ExpiredTime:{kvp.Value}"); } output.Expiration = new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero).AddSeconds(output.ExpiredTime); break; case "StartTime": if (long.TryParse(kvp.Value.ToString(), out long st)) { output.StartTime = st; } else { errs.Add("StartTime"); errs.Add("kvp.Value.ToString()"); } break; case "RequestId": output.RequestId = kvp.Value.ToString(); break; //case "Expiration": output.Expiration = JsonConvert.DeserializeObject<DateTimeOffset>(kvp.Value.ToString()); break; } } return(output); } catch (Exception ex) { string[] p = new string[] { "bucket", values["bucket"].ToString(), "region", values["region"].ToString(), "allowPrefix", values["allowPrefix"].ToString(), "allowActions", string.Join(",", values["allowActions"] as string[]), "ex", ex.Message }; throw new WFwException(Results.OperationResultType.TencentCloudSdkStsErr, "", p); } }
private async Task RenewSslCertificate(string certificatePath, CancellationToken cancellationToken) { try { var details = new RenewSslCertificateModel() { Domain = _remoteSettings.Network.DynamicDomain, Password = _remoteSettings.Network.CertificatePassword }; _logger.LogInformation("Attempting to generate a new ssl certificate..."); var response = await _sharedSettings.PostAsync("Remote/GenerateCertificate", details, cancellationToken); if (response != null) { if (response.Content.Headers.ContentType.MediaType == "application/json") { var jsonContent = await response.Content.ReadAsStringAsync(); var message = JsonExtensions.Deserialize <ReturnValue>(jsonContent); _logger.LogError("Ssl request generated the following error: " + message.ExceptionDetails); throw new RemoteSecurityException(message.Message, message.Exception); } var certificate = await response.Content.ReadAsByteArrayAsync(); try { using (var cert = new X509Certificate2(certificate, _remoteSettings.Network.CertificatePassword)) { var effectiveDate = DateTime.Parse(cert.GetEffectiveDateString()); var expiresDate = DateTime.Parse(cert.GetExpirationDateString()); // if cert expires in next 14 days, then renew. if (DateTime.Now > effectiveDate && DateTime.Now < expiresDate) { await File.WriteAllBytesAsync(certificatePath, certificate, cancellationToken); _logger.LogInformation( $"A new Ssl certificate has been successfully created at {certificatePath}."); } else { var reason = $"A new Ssl certificate was download but has effective dates between {effectiveDate} and {expiresDate}. This certificate has not been saved."; _logger.LogCritical(reason); throw new RemoteSecurityException(reason); } } } catch (Exception ex) { var reason = $"There was an error with the downloaded SSL certificate. {ex.Message}"; _logger.LogCritical(reason, ex); throw new RemoteSecurityException(reason, ex); } } else { var reason = $"The ssl certificate renewal failed. {response.ReasonPhrase}."; _logger.LogCritical(reason); throw new RemoteSecurityException(reason); } } catch (Exception ex) { _logger.LogCritical("There was an issue generating a new SSL certificate. The existing certificate will be used, or if there is not a current certificate, then HTTP connections will not be available.", ex); } }
public async void GetHubPerformance(int concurrent, int delay) { await Configuration.Login(); var timer = Stopwatch.StartNew(); var bestTime = long.MaxValue; var worstTime = 0L; var totalTime = 0L; var data = new long[concurrent]; var errors = new string[concurrent]; var tasks = Enumerable.Range(0, concurrent).Select(i => Task.Run(async() => { await Task.Delay(delay * i); var loopTimer = Stopwatch.StartNew(); try { var hubKey = new { HubKey = 2 }; var response = await Configuration.Post("/api/Hub/GetHubCache", hubKey); var hubCache = JsonExtensions.Deserialize <ReturnValue <DexihHub> >(response); if (!hubCache.Success) { errors[i] = hubCache.Message; } } catch (Exception e) { errors[i] = e.Message; } finally { loopTimer.Stop(); var elapsed = loopTimer.ElapsedMilliseconds; data[i] = elapsed; if (elapsed < bestTime) { bestTime = elapsed; } if (elapsed > worstTime) { worstTime = elapsed; } Interlocked.Add(ref totalTime, elapsed); } })); await Task.WhenAll(tasks); for (var i = 0; i < concurrent; i++) { _output.WriteLine($"{data[i]}\t{errors[i]}"); } timer.Stop(); _output.WriteLine($"Best Time - {bestTime}."); _output.WriteLine($"Worst Time - {worstTime}."); _output.WriteLine($"Total Time - {timer.ElapsedMilliseconds}."); _output.WriteLine($"Average Time - {totalTime / concurrent}"); }
/// <summary> /// Gets any libraries which are contained on the remote server, but not in the global server cache. /// </summary> /// <param name="cancellationToken"></param> /// <returns></returns> /// <exception cref="Exception"></exception> public async Task <RemoteLibraries> GetRemoteLibraries(CancellationToken cancellationToken) { if (_remoteLibraries != null) { return(_remoteLibraries); } HttpResponseMessage response; try { response = await _httpClient.GetAsync(_apiUri + "Account/GetGlobalCache", cancellationToken); } catch (Exception ex) { _logger.LogCritical(10, ex, "Internal error connecting to the server at location: {0}", "Account/GetGlobalCache"); throw; } if (!response.IsSuccessStatusCode) { var message = $"Could not connect with server. Status = {response.StatusCode.ToString()}, {response.ReasonPhrase}"; _logger.LogCritical(4, message); throw new Exception(message); } try { // get the global cache from the server, and return remote libraries which are missing. var serverResponse = await response.Content.ReadAsStringAsync(); var globalCache = JsonExtensions.Deserialize <CacheManager>(serverResponse); var globalFunctions = globalCache.DefaultRemoteLibraries.Functions .ToDictionary(c => (c.FunctionAssemblyName, c.FunctionClassName, c.FunctionMethodName)); var functions = Functions.GetAllFunctions().Where(c => !globalFunctions.ContainsKey(( c.FunctionAssemblyName, c.FunctionClassName, c.FunctionMethodName))).ToList(); var globalConnections = globalCache.DefaultRemoteLibraries.Connections .ToDictionary(c => (c.ConnectionAssemblyName, c.ConnectionClassName)); var connections = Connections.GetAllConnections().Where(c => !globalConnections.ContainsKey(( c.ConnectionAssemblyName, c.ConnectionClassName))).ToList(); var globalTransforms = globalCache.DefaultRemoteLibraries.Transforms .ToDictionary(c => (c.TransformAssemblyName, c.TransformClassName)); var transforms = Transforms.GetAllTransforms().Where(c => !globalTransforms.ContainsKey(( c.TransformAssemblyName, c.TransformClassName))).ToList(); var remoteLibraries = new RemoteLibraries() { Functions = functions, Connections = connections, Transforms = transforms }; _remoteLibraries = remoteLibraries; return(remoteLibraries); } catch (Exception ex) { _logger.LogCritical(4, $"An invalid response was returned connecting with server. Response was: \"{ex.Message}\"."); throw; } }
public async Task <ActionResult> GenerateCertificate([FromBody] GenerateCertificateModel data, CancellationToken cancellationToken) { var appUser = await _operations.RepositoryManager.GetUserAsync(User, cancellationToken); _logger.LogInformation($"Generating ssl certificate for user {appUser.Email}, stored certificate expires: {appUser.CertificateExpiry}."); CertificateChain cert; IKey privateKey; // if the certificate expires in more than 30 days, use the stored one, otherwise create a new one. if (appUser.CertificateExpiry != null && appUser.CertificateExpiry >= DateTime.Now.AddDays(30)) { cert = new CertificateChain(appUser.CertificateChain); privateKey = KeyFactory.FromPem(appUser.PrivateKey); _logger.LogDebug($"Used stored certificate chain for user {appUser.Email}."); } else { _logger.LogDebug($"Generating new certificate for user {appUser.Email}."); // the domain for the certificate is a hash of the userid.domain. var hash = appUser.Id.CreateSHA1(); var domain = $"{hash}.{data.domain}"; var txtName = $"_acme-challenge.{domain}"; AcmeContext acme; var server = _webHostEnvironment.IsDevelopment() ? WellKnownServers.LetsEncryptStagingV2 : WellKnownServers.LetsEncryptV2; // Load the saved account key if (System.IO.File.Exists("letsencrypt.pem")) { _logger.LogDebug($"Using existing letsencrypt account."); var pemKey = await System.IO.File.ReadAllTextAsync("letsencrypt.pem", cancellationToken); var accountKey = KeyFactory.FromPem(pemKey); acme = new AcmeContext(server, accountKey); } else { _logger.LogDebug($"Creating new letsencrypt account."); acme = new AcmeContext(server); if (string.IsNullOrEmpty(_operations.Config.LetsEncryptAccount)) { throw new RemoteAgentException("There was no LetsEncryptAccount specific in the appsettings.json file on the web server."); } await acme.NewAccount(_operations.Config.LetsEncryptAccount, true); // Save the account key for later use var pemKey = acme.AccountKey.ToPem(); await System.IO.File.WriteAllTextAsync("letsencrypt.pem", pemKey, cancellationToken); } _logger.LogDebug($"Placing order for new certificate on domain *.{domain}."); // place order for new certificate var order = await acme.NewOrder(new[] { $"*.{domain}" }); // update the distributed cache with the new record. var txtItemsJson = await _distributedCache.GetStringAsync("txtRecords", token : cancellationToken); List <KeyValuePair <string, string> > txtItems; if (txtItemsJson == null) { txtItems = new List <KeyValuePair <string, string> >(); } else { txtItems = JsonExtensions.Deserialize <List <KeyValuePair <string, string> > >(txtItemsJson); } // generate the dns challenge foreach (var authz in await order.Authorizations()) { var dnsChallenge = await authz.Dns(); var dnxText = acme.AccountKey.DnsTxt(dnsChallenge.Token); var pair = new KeyValuePair <string, string>(txtName, dnxText); txtItems.Add(pair); } txtItemsJson = JsonExtensions.Serialize(txtItems); _logger.LogTrace($"Updating txt records: ${txtItemsJson}"); var txtItemsByte = Encoding.ASCII.GetBytes(txtItemsJson); var options = new DistributedCacheEntryOptions() { SlidingExpiration = TimeSpan.FromSeconds(60) }; await _distributedCache.SetAsync("txtRecords", txtItemsByte, options, cancellationToken); try { foreach (var authz in await order.Authorizations()) { var dnsChallenge = await authz.Dns(); // validate certificate var challenge = await dnsChallenge.Validate(); if (challenge.Error != null) { var message = $"Error running letsEncrypt challenge. {challenge.Error.Detail}"; _errorLogger.LogEvent(message); throw new RemoteAgentException(message); } while (true) { await Task.Delay(100, cancellationToken); var a = await authz.Resource(); if (AuthorizationStatus.Invalid == a.Status) { if (a.Challenges != null) { foreach (var c in a.Challenges) { var message = $"Error running letsEncrypt challenge. The authorization status is invalid. Details:{c.Error?.Detail ?? "none"}"; _errorLogger.LogEvent(message); throw new RemoteAgentException(message); } } else { var message = $"Error running letsEncrypt challenge. Details:{challenge.Error?.Detail ?? "none"}"; _errorLogger.LogEvent(message); throw new RemoteAgentException(message); } } var status = a.Status ?? AuthorizationStatus.Pending; if (status == AuthorizationStatus.Valid) { break; } } } } finally { await _distributedCache.RemoveAsync(txtName, cancellationToken); } // download certificate once validation is complete privateKey = KeyFactory.NewKey(KeyAlgorithm.ES256); cert = await order.Generate(new CsrInfo { CountryName = "AU", State = "Victoria", Locality = "Melbourne", Organization = "Data Experts Group", OrganizationUnit = "Integration Hub", CommonName = $"*.{domain}", }, privateKey); // save the certificate for future usage appUser.PrivateKey = privateKey.ToPem(); appUser.CertificateChain = cert.ToPem(); appUser.CertificateExpiry = DateTime.Now.AddDays(90); // let's encrypt default expiry date. await _operations.RepositoryManager.UpdateUserAsync(appUser, cancellationToken); } // build the pfx file var pfxBuilder = cert.ToPfx(privateKey); var pfx = pfxBuilder.Build("Data Experts Integration Hub Certificate", data.password); return(File(pfx, "application/octet-stream", "dexih.pfx")); }