/// <summary>
/// Retrieves the genre list from the Shoutcast server
/// </summary>
/// <returns>A List of ShoutcastGenre objects</returns>
public List<ShoutcastGenre> GetGenres()
{
WebRequestHandler wrh = new WebRequestHandler();
string response = wrh.MakeWebRequest(m_GenresUrl + "?rss=1");
m_Genres = ParseGenres(response);
return m_Genres;
}
/// <summary>
///
/// </summary>
/// <param name="url"></param>
/// <param name="data"></param>
/// <param name="authentication"></param>
/// <param name="contentType"></param>
/// <param name="method"></param>
/// <param name="jsonBody"></param>
/// <returns></returns>
protected string SendWebRequest(string url, Dictionary <string, string> data, AuthenticationHeaderValue authentication = null, string contentType = "application/x-www-form-urlencoded", string method = "POST", string jsonBody = "")
{
string responseString = null;
FormUrlEncodedContent content = null;
System.Net.Http.HttpResponseMessage response = null;
string certpath = (HttpContext.Current == null) ? connectionConfiguration.sslCertPath : HttpContext.Current.Server.MapPath(connectionConfiguration.sslCertPath);
var encodedCredentials = Convert.ToBase64String(Encoding.ASCII.GetBytes(String.Format("{0}:{1}", connectionConfiguration.clientID, connectionConfiguration.clientSecret)));
WebRequestHandler handler = new WebRequestHandler();
X509Certificate2 certificate = LoadCertificateFile(certpath, connectionConfiguration.sslKeyPath, connectionConfiguration.sslKeyPass);
handler.ClientCertificates.Add(certificate);
using (var client = new HttpClient(handler))
{
// iat needs to support Basic Authentication
// uncomment this when it does.
if (authentication != null)
{
client.DefaultRequestHeaders.Authorization = authentication;
}
client.DefaultRequestHeaders.Add("User-Agent", "adp-connection-net/1.0.1");
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(contentType));
if (method.ToUpper().Equals("POST"))
{
if (jsonBody != String.Empty)
{
var jsonContent = new StringContent(jsonBody, Encoding.UTF8, "application/json");
response = client.PostAsync(url, jsonContent).Result;
}
else if (data != null)
{
content = new FormUrlEncodedContent(data);
response = client.PostAsync(url, content).Result;
}
}
else
{
response = client.GetAsync(url).Result;
}
if (response.IsSuccessStatusCode)
{
// by calling .Result you are performing a synchronous call
var responseContent = response.Content;
// by calling .Result you are synchronously reading the result
responseString = responseContent.ReadAsStringAsync().Result;
}
else
{
// by calling .Result you are performing a synchronous call
var responseContent = response.Content;
// by calling .Result you are synchronously reading the result
responseString = responseContent.ReadAsStringAsync().Result;
throw new ADPConnectionException(String.Format("Connection Exception: {0}: {1}", response.StatusCode, responseString), new JavaScriptSerializer().Serialize(response));
}
}
return(responseString);
}
async Task CheckForUpdates()
{
try
{
// Remove any old ClickOnce installs
try
{
var uninstallInfo = UninstallInfo.Find("IPFilter Updater");
if (uninstallInfo != null)
{
Trace.TraceWarning("Old ClickOnce app installed! Trying to remove...");
var uninstaller = new Uninstaller();
uninstaller.Uninstall(uninstallInfo);
Trace.TraceInformation("Successfully removed ClickOnce app");
}
}
catch (Exception ex)
{
Trace.TraceError("Failed to remove old ClickOnce app: " + ex);
telemetryClient?.TrackException(ex);
}
Trace.TraceInformation("Checking for software updates...");
progress.Report(new ProgressModel(UpdateState.Downloading, "Checking for software updates...", -1));
var updater = new Updater();
var result = await updater.CheckForUpdateAsync();
var currentVersion = new Version(Process.GetCurrentProcess().MainModule.FileVersionInfo.FileVersion);
var latestVersion = new Version(result.Version);
Update.IsUpdateAvailable = latestVersion > currentVersion;
if (Update.IsUpdateAvailable)
{
Update.AvailableVersion = latestVersion;
Update.IsUpdateRequired = true;
Update.MinimumRequiredVersion = latestVersion;
Update.UpdateSizeBytes = 2000000;
}
Trace.TraceInformation("Current version: {0}", Update.CurrentVersion);
Trace.TraceInformation("Available version: {0}", Update.AvailableVersion?.ToString() ?? "<no updates>");
if (!Update.IsUpdateAvailable)
{
return;
}
if (MessageBoxHelper.Show(dispatcher, "Update Available", MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.Yes,
"An update to version {0} is available. Would you like to update now?", Update.AvailableVersion) != MessageBoxResult.Yes)
{
return;
}
Trace.TraceInformation("Starting application update...");
// If we're not "installed", then don't check for updates. This is so the
// executable can be stand-alone. Stand-alone self-update to come later.
using (var key = Registry.CurrentUser.OpenSubKey("SOFTWARE\\IPFilter"))
{
var installPath = (string)key?.GetValue("InstallPath");
if (installPath == null)
{
using (var process = new Process())
{
process.StartInfo = new ProcessStartInfo("https://davidmoore.github.io/ipfilter/")
{
UseShellExecute = true
};
process.Start();
return;
}
}
}
var msiPath = Path.Combine(Path.GetTempPath(), "IPFilter.msi");
// Download the installer
using (var handler = new WebRequestHandler())
{
handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
var uri = new Uri($"{result.Uri}?{DateTime.Now.ToString("yyyyMMddHHmmss")}");
using (var httpClient = new HttpClient(handler))
using (var response = await httpClient.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead, cancellationToken.Token))
{
if (cancellationToken.IsCancellationRequested)
{
progress.Report(new ProgressModel(UpdateState.Ready, "Update cancelled. Ready.", 100));
Update.IsUpdating = false;
return;
}
var length = response.Content.Headers.ContentLength;
double lengthInMb = !length.HasValue ? -1 : (double)length.Value / 1024 / 1024;
double bytesDownloaded = 0;
using (var stream = await response.Content.ReadAsStreamAsync())
using (var msi = File.Open(msiPath, FileMode.Create, FileAccess.Write, FileShare.Read))
{
var buffer = new byte[65535 * 4];
int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken.Token);
while (bytesRead != 0)
{
await msi.WriteAsync(buffer, 0, bytesRead, cancellationToken.Token);
bytesDownloaded += bytesRead;
if (length.HasValue)
{
double downloadedMegs = bytesDownloaded / 1024 / 1024;
var percent = (int)Math.Floor((bytesDownloaded / length.Value) * 100);
var status = string.Format(CultureInfo.CurrentUICulture, "Downloaded {0:F2} MB of {1:F2} MB", downloadedMegs, lengthInMb);
Update.IsUpdating = true;
Update.DownloadPercentage = percent;
progress.Report(new ProgressModel(UpdateState.Downloading, status, percent));
}
if (cancellationToken.IsCancellationRequested)
{
progress.Report(new ProgressModel(UpdateState.Ready, "Update cancelled. Ready.", 100));
Update.IsUpdating = false;
return;
}
bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken.Token);
}
}
}
}
progress.Report(new ProgressModel(UpdateState.Ready, "Launching update...", 100));
Update.IsUpdating = false;
// Now run the installer
var sb = new StringBuilder("msiexec.exe ");
// Enable logging for the installer
sb.AppendFormat(" /l*v \"{0}\"", Path.Combine(Path.GetTempPath(), "IPFilter.log"));
sb.AppendFormat(" /i \"{0}\"", msiPath);
//sb.Append(" /passive");
ProcessInformation processInformation = new ProcessInformation();
StartupInfo startupInfo = new StartupInfo();
SecurityAttributes processSecurity = new SecurityAttributes();
SecurityAttributes threadSecurity = new SecurityAttributes();
processSecurity.nLength = Marshal.SizeOf(processSecurity);
threadSecurity.nLength = Marshal.SizeOf(threadSecurity);
const int NormalPriorityClass = 0x0020;
if (!ProcessManager.CreateProcess(null, sb, processSecurity,
threadSecurity, false, NormalPriorityClass,
IntPtr.Zero, null, startupInfo, processInformation))
{
throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());
}
try
{
//dispatcher.Invoke(DispatcherPriority.Normal, new Action(Application.Current.Shutdown));
Application.Current.Shutdown();
}
catch (Exception ex)
{
Trace.TraceError("Exception when shutting down app for update: " + ex);
Update.ErrorMessage = "Couldn't shutdown the app to apply update.";
telemetryClient?.TrackException(ex);
}
}
catch (Exception ex)
{
Trace.TraceWarning("Application update check failed: " + ex);
telemetryClient?.TrackException(ex);
telemetryClient?.Flush();
}
finally
{
progress.Report(new ProgressModel(UpdateState.Ready, "Ready", 0));
}
}
internal CouchbaseHttpClient(WebRequestHandler handler)
public Polymath(VaultClientSettings vaultClientSettings)
{
VaultClientSettings = vaultClientSettings;
#if NET45
var handler = new WebRequestHandler();
// if auth method is kerberos, then set the credentials in the handler.
if (vaultClientSettings.AuthMethodInfo?.AuthMethodType == AuthMethodType.Kerberos)
{
var kerberosAuthMethodInfo = vaultClientSettings.AuthMethodInfo as KerberosAuthMethodInfo;
handler.PreAuthenticate = kerberosAuthMethodInfo.PreAuthenticate;
handler.Credentials = kerberosAuthMethodInfo.Credentials;
}
#elif NET46 || NET461 || NET462 || NET47 || NET471 || NET472 || NET48
var handler = new WinHttpHandler();
// if auth method is kerberos, then set the credentials in the handler.
if (vaultClientSettings.AuthMethodInfo?.AuthMethodType == AuthMethodType.Kerberos)
{
var kerberosAuthMethodInfo = vaultClientSettings.AuthMethodInfo as KerberosAuthMethodInfo;
handler.PreAuthenticate = kerberosAuthMethodInfo.PreAuthenticate;
handler.ServerCredentials = kerberosAuthMethodInfo.Credentials;
}
#else
var handler = new HttpClientHandler();
// if auth method is kerberos, then set the credentials in the handler.
if (vaultClientSettings.AuthMethodInfo?.AuthMethodType == AuthMethodType.Kerberos)
{
var kerberosAuthMethodInfo = vaultClientSettings.AuthMethodInfo as KerberosAuthMethodInfo;
handler.PreAuthenticate = kerberosAuthMethodInfo.PreAuthenticate;
handler.Credentials = kerberosAuthMethodInfo.Credentials;
}
#endif
// not the best place, but a very convenient place to add cert of certauthmethod.
if (vaultClientSettings.AuthMethodInfo?.AuthMethodType == AuthMethodType.Cert)
{
var certAuthMethodInfo = vaultClientSettings.AuthMethodInfo as CertAuthMethodInfo;
if (certAuthMethodInfo.ClientCertificate != null)
{
handler.ClientCertificates.Add(certAuthMethodInfo.ClientCertificate);
}
else
{
if (certAuthMethodInfo.ClientCertificateCollection != null)
{
handler.ClientCertificates.AddRange(certAuthMethodInfo.ClientCertificateCollection);
}
}
}
vaultClientSettings.PostProcessHttpClientHandlerAction?.Invoke(handler);
_httpClient = VaultClientSettings.MyHttpClientProviderFunc == null ? new HttpClient(handler) : VaultClientSettings.MyHttpClientProviderFunc(handler);
_httpClient.BaseAddress = new Uri(VaultClientSettings.VaultServerUriWithPort);
if (VaultClientSettings.VaultServiceTimeout != null)
{
_httpClient.Timeout = VaultClientSettings.VaultServiceTimeout.Value;
}
if (VaultClientSettings.AuthMethodInfo != null)
{
_authMethodLoginProvider = AuthProviderFactory.CreateAuthenticationProvider(VaultClientSettings.AuthMethodInfo, this);
SetVaultTokenDelegate();
}
}
static void Main(string[] args)
{
try
{
var certificatePath = args[0];
var password = args[1];
var uriStr = args[2];
var agentId = args[3];
var command = args[4];
var tablePath = args[5];
string requestId = "";
if (args.Length > 6)
{
requestId = args[6];
}
var xmlSerializer = new GenericXmlSerializer();
var pemPacker = new PemPacker();
var certificate = new X509Certificate2(certificatePath, password);
var pkcs7Coder = new PKCS7Coder(certificate);
var uri = new Uri(uriStr);
var handler = new WebRequestHandler();
handler.ClientCertificates.Add(certificate);
using (var client = new YandexMoneyClient(xmlSerializer, pkcs7Coder, pemPacker, uri, handler))
{
//var response = client.TestDepositionRequest(new TestDepositionRequest()
//{
// AgentId = 203598,
// DstAccount = "410019806982007",
// Amount = "10.00",
// ClientOrderId = Guid.NewGuid().ToString(),
// DepositionPointId = "29",
// Currency = "643",
// Contract = "Зачисление на кошелек",
// RequestDT = DateTime.Now
//});
//Console.WriteLine(response.Error);
//Console.WriteLine(response.Identification);
//Console.WriteLine(response.Status);
//Console.WriteLine(response.TechMessage);
//Console.ReadLine();
if (command == "check")
{
var checkDepositionPointRequest = new CheckDepositionPointsRequest()
{
AgentId = long.Parse(agentId),
RequestId = requestId
};
var result = client.CheckDepositionPointsRequest(checkDepositionPointRequest);
Console.WriteLine(result.Status);
Console.WriteLine(result.RequestId);
if (result.Error != null)
{
Console.WriteLine(result.Error.Code);
Console.WriteLine(result.Error.PointId);
}
Console.WriteLine();
foreach (var item in result.Items)
{
Console.WriteLine($"{item.Id} {item.Reason} {item.Status}");
}
}
else if (command == "add")
{
var parser = new AddressParser();
var wb = new XSSFWorkbook(tablePath);
var sheet = wb.GetSheetAt(0);
var addDepositionPointRequest = new AddDepositionPointsRequest()
{
AgentId = long.Parse(agentId),
RequestId = Guid.NewGuid().ToString(),
Points = new DepositionPoint[134]
};
for (int i = 0; i != 134; i++)
{
var row = sheet.GetRow(i + 1);
if (row != null)
{
var depositionPoint = new DepositionPoint()
{
Id = (int)row.GetCell(1).NumericCellValue,
Type = "atm",
Address = parser.Parse(row.GetCell(6).StringCellValue),
Subagent = false
};
addDepositionPointRequest.Points[i] = depositionPoint;
}
}
File.WriteAllText(@"C:\Users\it014\Desktop\request.txt", UTF8Encoding.UTF8.GetString(xmlSerializer.Serialize <AddDepositionPointsRequest>(addDepositionPointRequest)));
Console.ReadLine();
var result = client.AddDepositionPointsRequest(addDepositionPointRequest);
File.AppendAllText("log.txt", result.RequestId + "\r\n");
Console.WriteLine(result.RequestId);
Console.WriteLine(result.Status);
if (result.Error != null)
{
Console.WriteLine(result.Error.Code);
Console.WriteLine(result.Error.PointId);
}
}
else if (command == "balance")
{
var balnceRequest = new BalanceRequest()
{
AgentId = long.Parse(agentId),
ClientOrderId = Guid.NewGuid().ToString(),
RequestDT = DateTime.Now
};
var result = client.BalanceRequest(balnceRequest);
Console.WriteLine(result.Balance);
Console.WriteLine(result.ClientOrderId);
Console.WriteLine(result.ProcessedDt);
Console.WriteLine(result.Status);
Console.WriteLine(result.Error);
}
Console.ReadLine();
}
}
catch (Exception e)
{
Console.WriteLine(e.GetType().FullName);
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.HResult);
Console.ReadLine();
}
}
internal HttpJsonRequest(
CreateHttpJsonRequestParams requestParams,
HttpJsonRequestFactory factory)
{
_credentials = requestParams.DisableAuthentication == false ? requestParams.Credentials : null;
disabledAuthRetries = requestParams.DisableAuthentication;
Url = requestParams.Url;
Method = requestParams.Method;
if (requestParams.Timeout.HasValue)
{
Timeout = requestParams.Timeout.Value;
}
else
{
Timeout = TimeSpan.FromSeconds(100); // default HttpClient timeout
#if DEBUG
if (Debugger.IsAttached)
{
Timeout = TimeSpan.FromMinutes(5);
}
#endif
}
this.factory = factory;
owner = requestParams.Owner;
conventions = requestParams.Convention;
requestTimeMetric = requestParams.RequestTimeMetric;
recreateHandler = factory.httpMessageHandler ?? (
() =>
{
var useDefaultCredentials = _credentials != null && _credentials.HasCredentials() == false;
ICredentials credentialsToUse = null;
if (_credentials != null)
{
var networkCredentials = _credentials.Credentials as NetworkCredential;
if (networkCredentials != null && factory.authenticationScheme != null)
{
var credentialCache = new CredentialCache();
var uri = new Uri(requestParams.Url);
credentialCache.Add(new Uri(string.Format("{0}://{1}:{2}/", uri.Scheme, uri.Host, uri.Port)), factory.authenticationScheme, networkCredentials);
credentialsToUse = credentialCache;
}
else
{
credentialsToUse = _credentials.Credentials;
}
}
#if !DNXCORE50
var handler = new WebRequestHandler
{
AllowAutoRedirect = false,
UseDefaultCredentials = useDefaultCredentials,
Credentials = credentialsToUse
};
#else
var handler = new HttpClientHandler
{
AllowAutoRedirect = false,
UseDefaultCredentials = useDefaultCredentials,
Credentials = credentialsToUse
};
#endif
return(handler);
}
);
httpClient = factory.httpClientCache.GetClient(Timeout, _credentials, recreateHandler);
if (factory.DisableRequestCompression == false && requestParams.DisableRequestCompression == false)
{
if (Method == HttpMethods.Post || Method == HttpMethods.Put || Method == HttpMethods.Patch || Method == HttpMethods.Eval)
{
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Content-Encoding", "gzip");
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", "application/json; charset=utf-8");
}
if (factory.acceptGzipContent)
{
httpClient.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip"));
}
}
headers.Add("Raven-Client-Version", ClientVersion);
WriteMetadata(requestParams.Metadata);
requestParams.UpdateHeaders(headers);
}
public async Task <Action <HttpClient> > DoOAuthRequestAsync(string baseUrl, string oauthSource, string apiKey)
{
if (oauthSource == null)
{
throw new ArgumentNullException("oauthSource");
}
string serverRSAExponent = null;
string serverRSAModulus = null;
string challenge = null;
// Note that at two tries will be needed in the normal case.
// The first try will get back a challenge,
// the second try will try authentication. If something goes wrong server-side though
// (e.g. the server was just rebooted or the challenge timed out for some reason), we
// might get a new challenge back, so we try a third time just in case.
int tries = 0;
while (true)
{
tries++;
#if !DNXCORE50
var handler = new WebRequestHandler();
#else
var handler = new WinHttpHandler();
#endif
using (var httpClient = new HttpClient(handler))
{
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("grant_type", "client_credentials");
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")
{
CharSet = "UTF-8"
});
string data = null;
if (!string.IsNullOrEmpty(serverRSAExponent) && !string.IsNullOrEmpty(serverRSAModulus) && !string.IsNullOrEmpty(challenge))
{
var exponent = OAuthHelper.ParseBytes(serverRSAExponent);
var modulus = OAuthHelper.ParseBytes(serverRSAModulus);
var apiKeyParts = apiKey.Split(new[] { '/' }, StringSplitOptions.None);
if (apiKeyParts.Length > 2)
{
apiKeyParts[1] = string.Join("/", apiKeyParts.Skip(1));
}
if (apiKeyParts.Length < 2)
{
throw new InvalidOperationException("Invalid API key");
}
var apiKeyName = apiKeyParts[0].Trim();
var apiSecret = apiKeyParts[1].Trim();
data = OAuthHelper.DictionaryToString(new Dictionary <string, string> {
{ OAuthHelper.Keys.RSAExponent, serverRSAExponent }, { OAuthHelper.Keys.RSAModulus, serverRSAModulus }, { OAuthHelper.Keys.EncryptedData, OAuthHelper.EncryptAsymmetric(exponent, modulus, OAuthHelper.DictionaryToString(new Dictionary <string, string> {
{ OAuthHelper.Keys.APIKeyName, apiKeyName }, { OAuthHelper.Keys.Challenge, challenge }, { OAuthHelper.Keys.Response, OAuthHelper.Hash(string.Format(OAuthHelper.Keys.ResponseFormat, challenge, apiSecret)) }
})) }
});
}
var requestUri = oauthSource;
var response = await httpClient.PostAsync(requestUri, data != null?(HttpContent) new CompressedStringContent(data, true) : new StringContent("")).AddUrlIfFaulting(new Uri(requestUri)).ConvertSecurityExceptionToServerNotFound();
if (response.IsSuccessStatusCode == false)
{
// We've already tried three times and failed
if (tries >= 3)
{
throw ErrorResponseException.FromResponseMessage(response);
}
if (response.StatusCode != HttpStatusCode.PreconditionFailed)
{
throw ErrorResponseException.FromResponseMessage(response);
}
var header = response.Headers.GetFirstValue("WWW-Authenticate");
if (header == null || header.StartsWith(OAuthHelper.Keys.WWWAuthenticateHeaderKey) == false)
{
throw new ErrorResponseException(response, "Got invalid WWW-Authenticate value");
}
var challengeDictionary = OAuthHelper.ParseDictionary(header.Substring(OAuthHelper.Keys.WWWAuthenticateHeaderKey.Length).Trim());
serverRSAExponent = challengeDictionary.GetOrDefault(OAuthHelper.Keys.RSAExponent);
serverRSAModulus = challengeDictionary.GetOrDefault(OAuthHelper.Keys.RSAModulus);
challenge = challengeDictionary.GetOrDefault(OAuthHelper.Keys.Challenge);
if (string.IsNullOrEmpty(serverRSAExponent) || string.IsNullOrEmpty(serverRSAModulus) || string.IsNullOrEmpty(challenge))
{
throw new InvalidOperationException("Invalid response from server, could not parse raven authentication information: " + header);
}
continue;
}
using (var stream = await response.GetResponseStreamWithHttpDecompression())
using (var reader = new StreamReader(stream))
{
var currentOauthToken = reader.ReadToEnd();
CurrentOauthToken = currentOauthToken;
CurrentOauthTokenWithBearer = "Bearer " + currentOauthToken;
ScheduleTokenRefresh(oauthSource, apiKey);
return((Action <HttpClient>)(SetAuthorization));
}
}
}
}
/// <inheritdoc /> public int UnexceptionWebRequest(UmbracoUrl url) => WebRequestHandler.Unexception(this, url);
void ApplyConfig(ConsulClientConfiguration config, WebRequestHandler handler, HttpClient client)
public async Task <string> GenerateTokenAsync(LoginViewModel context)
{
var jsonString = "";
try
{
var handler = new WebRequestHandler()
{
ServerCertificateValidationCallback = (sender, cert, chain, sslPolicyErrors) => true
};
using (var client = new HttpClient(handler))
{
//client.BaseAddress = new Uri(Request.RequestUri.GetLeftPart(UriPartial.Authority).ToString());
client.BaseAddress = new Uri(HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Authority));
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
// HTTP POST
//if (context.Password == null)
//{
// context.Password = "******";
//}
var body = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("grant_type", "password"),
new KeyValuePair <string, string>("username", context.Username),
new KeyValuePair <string, string>("password", context.Password)
};
//prashant
//
var content = new FormUrlEncodedContent(body);
// var response1 = await client.PostAsJsonAsync("", body);
HttpResponseMessage response = await client.PostAsync("token", content);
if (response.IsSuccessStatusCode)
{
jsonString = await response.Content.ReadAsStringAsync();
jsonString = jsonString.Split(',')[0].ToString().Split(':')[1].ToString();
return(jsonString.Replace("\"", ""));
}
else if (response.StatusCode == System.Net.HttpStatusCode.InternalServerError)
{
return(string.Empty);
}
else
{
return(string.Empty);
}
}
}
catch (Exception ex)
{
Logger.Write(ex.ToString());;
}
return(jsonString);
}
/// <summary>
/// OAuth2-identity-provider based authorization via an HTTP Basic Auth String.
/// The used server-certificate validation is tolerant. Creates an authorized HttpClient instance,
/// following the OAuth2-identity-provider authorization strategy.
/// Just use the returned HttpClient instance for future calls against the platform.
/// </summary>
/// <param name="apiDomain">address to get "auth"</param>
/// <param name="httpBasicAuthString">HTTP Basic Auth String</param>
/// <returns>An authorized HttpClient instance, or null if something went wrong, esp. authorization went wrong.</returns>
public static HttpClient Authorize(string apiDomain, string httpBasicAuthString)
{
WebRequestHandler webRequesthandler = DefaultWebRequestHandler(false);
HttpClient httpClient = new HttpClient(webRequesthandler);
httpClient.Timeout = DefaultRequestTimeout;
httpClient.BaseAddress = new UriBuilder("https", apiDomain).Uri;
/// Authorization procedure:
httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
// Get identity providers:
string rawAuthResult = httpClient.GetStringAsync($"https://{apiDomain}/auth").Result;
dynamic authResult = JObject.Parse(rawAuthResult);
string urlIdentityProviders = authResult.SelectToken("$._links.auth:identity-providers[0].href");
// Select OAuth2 identity provider and retrieve login URL:
string rawIdentityProvidersResult = httpClient.GetStringAsync(urlIdentityProviders).Result;
dynamic identityProvidersResult = JObject.Parse(rawIdentityProvidersResult);
dynamic oAuthLoginHrefObject = identityProvidersResult.SelectToken("$._embedded.auth:identity-provider[?(@.kind == 'oauth')]._links.auth:ropc-default[0].href");
if (null == oAuthLoginHrefObject)
{
// OAuth2 authentication not supported
return(null);
}
string OAuth2EndPoint = oAuthLoginHrefObject.ToString();
// Do the login:
IDictionary <string, string> loginArguments = new Dictionary <string, string>(3)
{
{ "grant_type", "client_credentials" },
{ "scope", "openid" }
};
using (HttpContent content = new FormUrlEncodedContent(loginArguments))
{
using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, OAuth2EndPoint)
{
Content = content
})
{
request.Headers.Add("Accept", "application/json");
request.Headers.Add("Authorization", "Basic " + httpBasicAuthString);
using (HttpResponseMessage result = httpClient.SendAsync(request).Result)
{
if (HttpStatusCode.RedirectMethod == result.StatusCode || result.IsSuccessStatusCode)
{
string rawAuthorizationData = result.Content.ReadAsStringAsync().Result;
dynamic authorizationData = JObject.Parse(rawAuthorizationData);
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Cookie", $"avidAccessToken={authorizationData.access_token}");
HttpClient httpKeepAliveClient = new HttpClient(DefaultWebRequestHandler(false));
httpKeepAliveClient.DefaultRequestHeaders.TryAddWithoutValidation("Cookie", $"avidAccessToken={authorizationData.access_token}");
httpKeepAliveClient.BaseAddress = new Uri($"http://{apiDomain}");
httpKeepAliveClient.DefaultRequestHeaders.Add("Accept", "application/json");
tokenSource = new CancellationTokenSource();
Task sessionRefresher
= Task.Factory.StartNew(
async ignored =>
{
while (!tokenSource.Token.IsCancellationRequested)
{
await Task.Delay(120000, tokenSource.Token).ConfigureAwait(false);
tokenSource.Token.ThrowIfCancellationRequested();
try
{
SessionKeepAlive(httpKeepAliveClient);
}
catch (Exception e)
{
Console.WriteLine($"Platform session refresher error. - {e.Message}");
}
}
}
, null
, tokenSource.Token
, TaskCreationOptions.DenyChildAttach | TaskCreationOptions.LongRunning
, TaskScheduler.Default);
}
else
{
return(null);
}
}
}
}
return(httpClient);
}
public HttpClientHelper(
Uri baseAddress,
IAuthorizationProvider authenticationHeaderProvider,
IDictionary <HttpStatusCode, Func <HttpResponseMessage, Task <Exception> > > defaultErrorMapping,
TimeSpan timeout,
Action <HttpClient> preRequestActionForAllRequests,
X509Certificate2 clientCert,
HttpClientHandler httpClientHandler,
ProductInfo productInfo,
IWebProxy proxy
)
{
this.baseAddress = baseAddress;
this.authenticationHeaderProvider = authenticationHeaderProvider;
this.defaultErrorMapping =
new ReadOnlyDictionary <HttpStatusCode, Func <HttpResponseMessage, Task <Exception> > >(defaultErrorMapping);
#if NET451
WebRequestHandler handler = httpClientHandler as WebRequestHandler;
if (clientCert != null)
{
if (handler == null)
{
handler = new WebRequestHandler();
}
handler.ClientCertificates.Add(clientCert);
this.usingX509ClientCert = true;
}
if (proxy != DefaultWebProxySettings.Instance)
{
if (handler == null)
{
handler = new WebRequestHandler();
}
handler.UseProxy = (proxy != null);
handler.Proxy = proxy;
}
this.httpClientObj = handler != null ? new HttpClient(handler) : new HttpClient();
#else
if (clientCert != null)
{
if (httpClientHandler == null)
{
httpClientHandler = new HttpClientHandler();
}
httpClientHandler.ClientCertificates.Add(clientCert);
this.usingX509ClientCert = true;
}
if (proxy != DefaultWebProxySettings.Instance)
{
if (httpClientHandler == null)
{
httpClientHandler = new HttpClientHandler();
}
httpClientHandler.UseProxy = (proxy != null);
httpClientHandler.Proxy = proxy;
}
this.httpClientObj = httpClientHandler != null ? new HttpClient(httpClientHandler) : new HttpClient();
#endif
this.httpClientObj.BaseAddress = this.baseAddress;
this.httpClientObj.Timeout = timeout;
this.httpClientObj.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(CommonConstants.MediaTypeForDeviceManagementApis));
this.httpClientObj.DefaultRequestHeaders.ExpectContinue = false;
if (preRequestActionForAllRequests != null)
{
preRequestActionForAllRequests(this.httpClientObj);
}
this.productInfo = productInfo;
}
public ConsoleLoggerMessageHandler(WebRequestHandler clientRequest) : base(clientRequest)
{
}
/// <inheritdoc /> public int UnexceptionWebRequest() => WebRequestHandler.Unexception(this);
public async Task HttpsHelloWorldCerts(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, string applicationBaseUrl, ApplicationType applicationType, bool sendClientCert)
{
var logger = new LoggerFactory()
.AddConsole()
.CreateLogger($"HttpsHelloWorldCerts:{serverType}:{runtimeFlavor}:{architecture}");
using (logger.BeginScope("HttpsHelloWorldTest"))
{
var deploymentParameters = new DeploymentParameters(Helpers.GetTestSitesPath(applicationType), serverType, runtimeFlavor, architecture)
{
ApplicationBaseUriHint = applicationBaseUrl,
EnvironmentName = "HttpsHelloWorld", // Will pick the Start class named 'StartupHttpsHelloWorld',
ServerConfigTemplateContent = (serverType == ServerType.IISExpress) ? File.ReadAllText("Https.config") : null,
SiteName = "HttpsTestSite", // This is configured in the Https.config
TargetFramework = runtimeFlavor == RuntimeFlavor.Clr ? "net451" : "netcoreapp1.0",
ApplicationType = applicationType
};
using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, logger))
{
var deploymentResult = deployer.Deploy();
var handler = new WebRequestHandler();
handler.ServerCertificateValidationCallback = (a, b, c, d) => true;
handler.ClientCertificateOptions = ClientCertificateOption.Manual;
if (sendClientCert)
{
X509Certificate2 clientCert = FindClientCert();
Assert.NotNull(clientCert);
handler.ClientCertificates.Add(clientCert);
}
var httpClient = new HttpClient(handler)
{
BaseAddress = new Uri(deploymentResult.ApplicationBaseUri)
};
// Request to base address and check if various parts of the body are rendered & measure the cold startup time.
var response = await RetryHelper.RetryRequest(() =>
{
return(httpClient.GetAsync("checkclientcert"));
}, logger, deploymentResult.HostShutdownToken);
var responseText = await response.Content.ReadAsStringAsync();
try
{
if (sendClientCert)
{
Assert.Equal("Scheme:https; Original:http; has cert? True", responseText);
}
else
{
Assert.Equal("Scheme:https; Original:http; has cert? False", responseText);
}
}
catch (XunitException)
{
logger.LogWarning(response.ToString());
logger.LogWarning(responseText);
throw;
}
}
}
}
/// <inheritdoc />
public int WatchWebRequests(PipeLineStages stage, Regex regex,
int priority, Func <int, HttpApplication, WatchResponse> request) =>
WebRequestHandler.Watch(this, stage, regex, priority, request);
public static async Task <RetornoSiscomex> EnviarSemServico(string xml, string due, string cpfCertificado)
{
try
{
try
{
HttpResponseMessage response = new HttpResponseMessage();
var token = new Token();
token = Autenticar(cpfCertificado);
if (token != null)
{
var headers = ObterHeaders(token);
var url = string.Format("/due/api/ext/due/{0}", due);
using (var handler = new WebRequestHandler())
{
handler.UseProxy = false;
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
handler.ClientCertificates.Add(ObterCertificado(cpfCertificado));
ServicePointManager.ServerCertificateValidationCallback += RemoteCertificateValidate;
using (var client = new HttpClient(handler))
{
// client.Timeout = new TimeSpan(0, 15, 00);
client.Timeout = new TimeSpan(25, 0, 0);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
foreach (var header in headers)
{
client.DefaultRequestHeaders.Add(header.Key, header.Value);
}
client.DefaultRequestHeaders.Add("Cache-Control", "no-cache");
client.DefaultRequestHeaders.Add("Accept-Encoding", "gzip,deflate");
client.DefaultRequestHeaders.Add("Connection", "Keep-Alive");
using (var stringContent = new StringContent(xml, Encoding.UTF8, "application/xml"))
{
HttpResponseMessage retorno = await client
.PutAsync(new Uri(string.Concat(UrlSiscomex, url)), stringContent)
.ConfigureAwait(false);
response = retorno;
}
}
}
}
var retornoSiscomex = new ServicoSiscomex.RetornoSiscomex();
var retornoResponse = response.Content.ReadAsStringAsync().Result;
using (MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(Regex.Unescape(retornoResponse))))
{
var reader = new StreamReader(memoryStream, Encoding.UTF8);
if (response.StatusCode != HttpStatusCode.OK)
{
try
{
var xmlSerializer = new XmlSerializer(typeof(RetornoCriticas));
var criticas = (ServicoSiscomex.RetornoCriticas)xmlSerializer.Deserialize(reader);
retornoSiscomex.Sucesso = false;
retornoSiscomex.Warnings = false;
retornoSiscomex.Message = criticas.message;
retornoSiscomex.Criticas = criticas.detail;
retornoSiscomex.XmlRetorno = retornoResponse;
}
catch (Exception ex)
{
retornoSiscomex.Sucesso = false;
retornoSiscomex.Message = "Erro: " + retornoResponse;
retornoSiscomex.XmlRetorno = retornoResponse;
}
}
else
{
if (retornoResponse.Contains("warnings"))
{
var xmlSerializer = new XmlSerializer(typeof(PucomexReturn));
var warnings = (PucomexReturn)xmlSerializer.Deserialize(reader);
retornoSiscomex.Sucesso = true;
retornoSiscomex.Warnings = true;
retornoSiscomex.Message = string.Join("<br />", warnings.Warnings.Warning);
}
else
{
var xmlSerializer = new XmlSerializer(typeof(RetornoSucesso));
var sucesso = (RetornoSucesso)xmlSerializer.Deserialize(reader);
retornoSiscomex.Sucesso = true;
retornoSiscomex.Warnings = false;
retornoSiscomex.Message = sucesso.Message;
retornoSiscomex.DUE = sucesso.Due;
retornoSiscomex.RUC = sucesso.Ruc;
}
}
}
return(retornoSiscomex);
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception)
{
throw;
}
}
catch (Exception ex)
{
return(new RetornoSiscomex
{
Sucesso = false,
Message = ex.Message
});
}
}
/// <inheritdoc /> public int UnwatchWebRequests(PipeLineStages stage, Regex regex) => WebRequestHandler.Unwatch(this, stage, regex);
public RequestRoute(string path, HttpMethods httpMethod, WebRequestHandler requestHandler)
{
Path = path;
HttpMethod = httpMethod;
RequestHandler = requestHandler;
}
/// <inheritdoc /> public int UnwatchWebRequests(PipeLineStages stage) => WebRequestHandler.Unwatch(this, stage);
static void Main(string[] args)
{
Task.Run(() =>
{
var handler = new WebRequestHandler();
handler.ServerCertificateValidationCallback = (a, b, c, d) =>
{
return(true);
};
using (var client = new TcpClient())
{
client.Connect(MachineName, LldbProxyPort);
Console.WriteLine("Connection made to debug proxy server.");
bool bRunning = true;
ManualResetEvent e = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem((o) =>
{
using (var reader = new StreamReader(client.GetStream()))
{
while (bRunning)
{
try
{
string line = reader.ReadLine();
if (line != null)
{
Console.WriteLine(line);
}
}
catch (IOException)
{
}
}
}
e.Set();
});
using (var writer = new StreamWriter(client.GetStream()))
{
while (bRunning)
{
string line = Console.ReadLine();
writer.WriteLine(line);
writer.Flush();
if (string.Compare(line, "quit", StringComparison.OrdinalIgnoreCase) == 0)
{
bRunning = false;
}
}
}
e.WaitOne();
}
}).Wait();
}
/// <inheritdoc /> public int UnwatchWebRequests() => WebRequestHandler.Unwatch(Environment.Id, App.Id);
private static HttpMessageHandler ResolveHttpMessageHandler(SamlAuthenticationOptions options)
{
HttpMessageHandler handler = new WebRequestHandler();
return(handler);
}
/// <inheritdoc /> public int UnwatchWebRequests(IApp app) => WebRequestHandler.Unwatch(app.Id);
public YandexMoneyClient(GenericXmlSerializer xmlSerializer, PKCS7Coder pkcs7coder, PemPacker pemPacker, Uri baseUri, WebRequestHandler handler) : base(handler)
{
this.xmlSerializer = xmlSerializer;
this.pkcs7coder = pkcs7coder;
this.pemPacker = pemPacker;
this.baseUri = baseUri;
}
/// <inheritdoc /> public int ExceptionWebRequest(UmbracoUrl url) => WebRequestHandler.Exception(this, null, url);
public AsyncRequesterBase(CommandLineOptions options)
{
#if NET452
var requestHandler = new WebRequestHandler()
{
UseCookies = false,
UseDefaultCredentials = true,
ServerCertificateValidationCallback = (sender, certificate, chain, errors) => true
};
#else
var requestHandler = new HttpClientHandler()
{
UseCookies = false,
UseDefaultCredentials = true
};
#endif
if (options.UseProxy)
{
requestHandler.UseProxy = true;
requestHandler.Proxy = WebRequest.GetSystemWebProxy();
}
_client = new HttpClient(requestHandler);
_options = options;
_url = new TokenisedString(options.Url);
if (!string.IsNullOrEmpty(options.Template))
{
_templateParser = new TemplateParser(File.ReadAllText(options.Template));
_randomValueProvider = new RandomValueProvider(
new[] { _url }.Concat(_templateParser.Headers.Select(x => x.Value)).ToArray());
}
else
{
_randomValueProvider = new RandomValueProvider(_url);
}
_valueProvider = new NoValueProvider();
if (!string.IsNullOrEmpty(_options.Plugin)) // plugin
{
var assembly = Assembly.LoadFile(_options.Plugin);
var valueProviderType = assembly.GetExportedTypes().FirstOrDefault(t => typeof(IValueProvider)
.IsAssignableFrom(t));
if (valueProviderType != null)
{
_valueProvider = (IValueProvider)Activator.CreateInstance(valueProviderType);
Console.WriteLine($"Loaded {valueProviderType.FullName} from the plugin as IValueProvider.");
}
var responseOverride = assembly.GetExportedTypes().FirstOrDefault(t => typeof(IResponseStatusOverride)
.IsAssignableFrom(t));
if (responseOverride != null)
{
_responseStatusOverride = (IResponseStatusOverride)Activator.CreateInstance(responseOverride);
Console.WriteLine($"Loaded {responseOverride.FullName} from the plugin as IResponseStatusOverride.");
}
}
else if (!string.IsNullOrEmpty(options.ValuesFile)) // csv values file
{
_valueProvider = new SeparatedFileValueProvider(options.ValuesFile,
options.IsTsv ? '\t' : ',', options.Shuffle);
}
}
/// <inheritdoc /> public int UnexceptionWebRequest(Regex regex) => WebRequestHandler.Unexception(this, regex);
// =================================================================================================================
/// <summary>
/// Install the package
/// </summary>
/// <param name="_uri">URI to send to</param>
/// <param name="_parameters">parameters to be added to the uri</param>
/// <param name="_files">list of filenames to send</param>
/// <returns>response string</returns>
private static string InstallPackage(string _uri, Dictionary <string, string> _parameters, List <string> _files)
{
string originalUri = _uri;
StringBuilder postData = new StringBuilder();
if (_parameters != null)
{
int count = 0;
foreach (KeyValuePair <string, string> kvp in _parameters)
{
if (count > 0)
{
postData.Append("&");
} // en dif
postData.AppendFormat("{0}={1}", HttpUtility.UrlEncode(kvp.Key), HttpUtility.UrlEncode(kvp.Value));
++count;
} // end foreach
} // end if
_uri = _uri + "?" + postData.ToString();
string responseString = "";
try
{
using (var handler = new WebRequestHandler()
{
CookieContainer = CookieContainer,
})
{
handler.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => { return(true); };
using (var client = new HttpClient(handler))
{
client.DefaultRequestHeaders.ExpectContinue = false;
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.ASCII.GetBytes(string.Format("{0}:{1}", Username, Password))));
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("*/*"));
if (!string.IsNullOrEmpty(CSRF))
{
client.DefaultRequestHeaders.Add("X-CSRF-Token", CSRF);
}
if (Credentials == null)
{
if (!string.IsNullOrEmpty(WMID))
{
client.DefaultRequestHeaders.Add("WMID", WMID);
}
} // end if
using (var content = new MultipartFormDataContent())
{
foreach (string f in _files)
{
var streamContent = new StreamContent(new StreamReader(f).BaseStream, 1024);
FileInfo fI = new FileInfo(f);
streamContent.Headers.ContentDisposition = new System.Net.Http.Headers.ContentDispositionHeaderValue("form-data")
{
Name = "\"" + fI.Name + "\"",
FileName = "\"" + fI.Name + "\""
};
streamContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/octet-stream");
content.Add(streamContent);
} // end foreach
// this is the magic bit of code to fix sending the multipart form data properly...
var boundaryValue = content.Headers.ContentType.Parameters.FirstOrDefault(p => p.Name == "boundary");
boundaryValue.Value = boundaryValue.Value.Replace("\"", String.Empty);
Task <HttpResponseMessage> tmessage = client.PostAsync(_uri, content);
tmessage.Wait();
HttpResponseMessage message = tmessage.Result;
message.EnsureSuccessStatusCode();
var input = message.Content.ReadAsStringAsync();
responseString = input.Result;
} // end using
} // end using
}
} // end try
catch (Exception _ex)
{
responseString = _ex.ToString();
}
return(responseString);
} // end InstallPackage
public void update()
{
String bdCustomerApiKey = "73ad7b80-7c4e-11e4-a2d3-b8ca3a6b879d"; //This key is generated by Bluedot Point Access UI when your account is created
String bdApplicationId = "564ecdc0-7e86-11e4-95ff-a0481cdba490"; //This ID is retrieved through the GET Applications call
String bdRestUrl = "https://api.bluedotinnovation.com/1/applications";
String application =
"{" +
"\"security\": {" +
/*
* customerApiKey is generated when customer registers first time. It is also available
* on the PointAccess interface in the Edit Profile section.
*/
"\"customerApiKey\":" + "\"" + bdCustomerApiKey + "\"" +
"}," +
"\"content\": { " +
"\"application\" : {" +
/*This is the id of the application as opposed to the api key.
* This is returned when the application/getAll is called*/
"\"applicationId\":" + "\"" + bdApplicationId + "\"," +
/* Time in Hour:Minute format.*/
"\"nextRuleUpdateIntervalFormatted\": \"00:10\"," +
"\"webhook\": {" +
/*The URL of the server where the webhooks will be received.*/
"\"url\": \"https://api.testapplication.com/webhook/checkinreceiver\"," +
"\"enabled\" : true," +
/*The Security Token Key is the name of the field to be sent in the POST request header.*/
"\"securityTokenKey\" : \"authToken\"," +
/*The Security Token Value field is value of the Security Token Key field sent in the POST request header.*/
"\"securityTokenValue\" : \"f2f7a58c-f0d5-498c-9bad-acbc89923dc5\"" +
"}" +
"}" +
"}" +
"}";
WebRequestHandler handler = new WebRequestHandler();
X509Certificate2 certificate = new X509Certificate2();
handler.ClientCertificates.Add(certificate);
HttpClient httpRestClient = new HttpClient(handler);
//specify to use TLS 1.2 as default connection
System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls;
httpRestClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpContent jsonApplicationContent = new StringContent(@application);
jsonApplicationContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
HttpResponseMessage serverResponse = httpRestClient.PostAsync(new Uri(bdRestUrl), jsonApplicationContent).Result;
if (serverResponse.IsSuccessStatusCode)
{
var result = serverResponse.Content.ReadAsStringAsync().Result;
Console.WriteLine("{0}", result);
}
else
{
Console.WriteLine("{0} ({1})", (int)serverResponse.StatusCode, serverResponse.Content.ReadAsStringAsync().Result);
}
}
/// <summary>
/// Retrieves a list of all Shoutcast stations tagged with
/// the given genre name
/// </summary>
/// <param name="genre">The name of the genre to search for</param>
/// <returns>A List of ShoutcastStation objects</returns>
public List<ShoutcastStation> GetStationsByGenre(string genreName)
{
WebRequestHandler wrh = new WebRequestHandler();
string response = wrh.MakeWebRequest(m_StationsByGenreUrl + genreName);
return ParseStations(response);
}
private static Tuple <HttpStatusCode, string> MakeQrsRequest(string path, HttpMethod method, HTTPContentType contentType = HTTPContentType.json, byte[] body = null)
{
// Fix Path
if (!path.StartsWith("/"))
{
path = '/' + path;
}
if (path.EndsWith("/"))
{
path = path.Substring(0, path.Length - 1);
}
int indexOfSlash = path.LastIndexOf('/');
int indexOfQuery = path.LastIndexOf('?');
if (indexOfQuery <= indexOfSlash)
{
path += "?";
}
else
{
path += "&";
}
string responseString = "";
HttpStatusCode responseCode = 0;
string xrfkey = "0123456789abcdef";
ServicePointManager.ServerCertificateValidationCallback = delegate { return(true); };
ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11;
HttpRequestMessage req = new HttpRequestMessage();
req.RequestUri = new Uri(@"https://" + HOSTNAME.Value + ":4242/qrs" + path + "xrfkey=" + xrfkey);
req.Method = method;
req.Headers.Add("X-Qlik-xrfkey", xrfkey);
req.Headers.Add("X-Qlik-User", @"UserDirectory=internal;UserId=sa_api");
WebRequestHandler handler = new WebRequestHandler();
handler.ClientCertificates.Add(SENSE_CERT.Value);
if (method == HttpMethod.Post || method == HttpMethod.Put)
{
req.Content = new ByteArrayContent(body);
// Set Headers
if (contentType == HTTPContentType.json)
{
req.Content.Headers.Remove("Content-Type");
req.Content.Headers.Add("Content-Type", "application/json");
}
else if (contentType == HTTPContentType.app)
{
req.Content.Headers.Remove("Content-Type");
req.Content.Headers.Add("Content-Type", "application/vnd.qlik.sense.app");
}
else
{
throw new ArgumentException("Content type '" + contentType.ToString() + "' is not supported.");
}
}
using (HttpClient client = new HttpClient(handler))
{
client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
try
{
Task <HttpResponseMessage> responseTask = client.SendAsync(req);
responseTask.Wait();
responseTask.Result.EnsureSuccessStatusCode();
responseCode = responseTask.Result.StatusCode;
Task <string> responseBodyTask = responseTask.Result.Content.ReadAsStringAsync();
responseBodyTask.Wait();
responseString = responseBodyTask.Result;
}
catch (Exception e)
{
if (responseCode != 0)
{
return(new Tuple <HttpStatusCode, string>(responseCode, e.Message));
}
else
{
return(new Tuple <HttpStatusCode, string>(HttpStatusCode.InternalServerError, e.Message));
}
}
}
return(new Tuple <HttpStatusCode, string>(responseCode, responseString));
}
