private async Task <IDictionary <string, Card> > GetCardInventoryAsync(string authToken)
{
var cards = new Dictionary <string, Card>(StringComparer.OrdinalIgnoreCase);
using (var httpClient = HttpClientProvider.GetHttpClient(authToken))
{
string endpoint = this.configuration[Constants.CardsServiceEndpoint];
Uri uri = new Uri(FormattableString.Invariant($"{endpoint}/api/cards"));
string result = await httpClient.GetStringAsync(uri);
if (string.IsNullOrWhiteSpace(result))
{
return(null);
}
CardInventory cardInventory = JsonConvert.DeserializeObject <CardInventory>(result);
if (cardInventory?.Cards != null)
{
foreach (var card in cardInventory.Cards)
{
cards[card.CardId] = card;
}
}
}
return(cards);
}
/// <summary>
/// 获取公共的键值对配置
/// </summary>
public async static Task <string> GetRedisConfig()
{
foreach (var url in oauthUrls)
{
using (var client = HttpClientProvider.CreateHttpClient(url))
{
try
{
if (!await PrepareAccessToken(client))
{
continue;
}
var resp = await client.GetAsync("/api/Config/GetRedisConfig");
if (resp.IsSuccessStatusCode)
{
var result = await resp.Content.ReadAsStringAsync();
if (!string.IsNullOrWhiteSpace(result))
{
return(result);
}
}
}
catch
{
continue;
}
}
}
return(null);
}
public FullListUsersWindow(HttpClientProvider httpClientProvider)
{
InitializeComponent();
this.httpClientProvider = httpClientProvider;
ReloadDataGridUsersItemsSource();
}
/// <summary>
/// Sends a DELETE request and deserialises the JSON response.
/// </summary>
/// <typeparam name="T">The class to use to deserialise the JSON response.</typeparam>
/// <param name="resource">The resource.</param>
/// <param name="parameters">The parameters.</param>
/// <returns></returns>
public async Task <T> DeleteAsync <T>(string resource, HttpParams parameters = null)
{
using (var client = HttpClientProvider.Create())
{
return(await SendAsync <T>(client, HttpMethod.Delete, ApiUrl, resource, parameters));
}
}
/// <summary>
/// 获取公共的键值对配置
/// </summary>
public async static Task <Dictionary <string, string> > GetKeyValues()
{
foreach (var url in oauthUrls)
{
using (var client = HttpClientProvider.CreateHttpClient(url))
{
try
{
if (!await PrepareAccessToken(client))
{
continue;
}
var resp = await client.GetAsync("/api/Config/GetKeyValues");
if (resp.IsSuccessStatusCode)
{
var result = await resp.Content.ReadAsAsync <Dictionary <string, string> >();
if (result != null && result.Count > 0)
{
return(result);
}
}
}
catch
{
continue;
}
}
}
return(new Dictionary <string, string>());
}
/// <summary>
/// Sends a POST request.
/// </summary>
/// <param name="resource">The resource.</param>
/// <param name="parameters">The parameters.</param>
/// <param name="content">The payload for the content of the HTTP request.</param>
/// <returns></returns>
public async Task <HttpResponseMessage> PostAsync(string resource, HttpParams parameters = null, object content = null)
{
using (var client = HttpClientProvider.Create())
{
return(await SendAsync(client, HttpMethod.Post, ApiUrl, resource, parameters, content));
}
}
/// <summary>
/// Sends a PUT request and deserialises the JSON response.
/// </summary>
/// <typeparam name="T">The class to use to deserialise the JSON response.</typeparam>
/// <param name="resource">The resource.</param>
/// <param name="parameters">The parameters.</param>
/// <param name="content">The content.</param>
/// <returns></returns>
public async Task <T> PutAsync <T>(string resource, HttpParams parameters = null, object content = null)
{
using (var client = HttpClientProvider.Create())
{
return(await SendAsync <T>(client, HttpMethod.Put, ApiUrl, resource, parameters, content));
}
}
public void TestSetup()
{
log = new ConsoleLog();
settings = new NativeTransportSettings();
provider = new HttpClientProvider(settings, log);
}
public void Should_cache_handler_between_multiple_instances()
{
var handler1 = provider.Obtain(connectionTimeout);
var handler2 = new HttpClientProvider(settings, log).Obtain(connectionTimeout);
handler2.Should().BeSameAs(handler1);
}
private async void Login()
{
bool isServerLocal = false;
if (LocalWork.IsChecked.HasValue && LocalWork.IsChecked.Value)
{
isServerLocal = true;
}
HttpClientProvider.SetHttpClientUri(isServerLocal);
var commandQueryDispatcher = new CommandQueryDispatcher();
var login = new Login(LoginTextBox.Text, PasswordTextBox.Password);
var response = await commandQueryDispatcher.SendAsync(login, "api/user-management/users/login", HttpOperationType.POST);
if (response.StatusCode == HttpStatusCode.OK)
{
await SetUpCurrentUser(commandQueryDispatcher, LoginTextBox.Text);
var projectsWindow = new MainWindow();
projectsWindow.Top = this.Top;
projectsWindow.Left = this.Left;
projectsWindow.Show();
Close();
}
else
{
ResponseExtensions.ToMessageBox(response.ResponseContent);
}
}
static void Main(string[] args)
{
var username = "";
var password = "";
var url = "";
var httpProvider = new HttpClientProvider(url, username, password);
var categoryService = new CategoryService(httpProvider);
var categories = categoryService.Get().Result;
foreach (var category in categories.Data)
{
Console.WriteLine("Category {0}# {1}", category.Id, category.Title);
}
var contactService = new ContactService(httpProvider);
var contacts = contactService.Get().Result;
foreach (var contact in contacts.Data)
{
Console.WriteLine(contact.Id);
}
var emailService = new EmailService(httpProvider);
var emails = emailService.Get().Result;
foreach (var email in emails.Data)
{
Console.WriteLine(email.Name);
}
Console.Read();
}
public SettingsWindow(HttpClientProvider httpClientProvider)
{
InitializeComponent();
this.httpClientProvider = httpClientProvider;
clientConfiguration = LoadClientConfiguration();
}
public BoardControl(HttpClientProvider httpClientProvider)
{
this.httpClientProvider = httpClientProvider;
InitializeComponent();
AddColumn += (sender, args) => LoadBoard(thisBoard?.Name);
}
public object CreateFor(Type type, Uri host)
{
var client = HttpClientProvider.GetClient(this.HttpClientSettings, this.HttpClientSettings.DelegatingHandlers.Select(i => i()).ToArray());
var proxyClass = new HttpClientWrapper(type, client, host, this.HttpClientSettings);
return(proxyClass.GetTransparentProxy());
}
public static async Task <List <Movie> > GetMoviesAsync()
{
var httpClientProvider = new HttpClientProvider <List <Movie> >();
var movies = await httpClientProvider.GetAsync(Config.MoviesUrl);
return(movies);
}
public async Task LogoutFromAppAsync()
{
using (var _clientProvider = new HttpClientProvider())
{
var uniquePartOfUri = "logout";
await AddAuthCookieAsync(_clientProvider.clientHandler);
await GetCsrfToken(_clientProvider);
await PostAsync($"{_uri}{uniquePartOfUri}", null, _clientProvider);
if (localSettings.Values.ContainsKey(DefaultCookieName))
{
var cookieObj = await DecryptCookieValueAsync(localSettings.Values[DefaultCookieName].ToString());
if (cookieObj != null)
{
var authCookie = new Cookie(DefaultCookieName, cookieObj.ToString());
authCookie.Expires = DateTime.Now.Subtract(TimeSpan.FromDays(1));
localSettings.Values.Remove(DefaultCookieName);
}
}
}
}
public async Task LoggedInUserIdAndUserType()
{
using (var _clientProvider = new HttpClientProvider())
{
var uniquePartOfUri = "currentUserIdAndRole";
await AddAuthCookieAsync(_clientProvider.clientHandler);
try
{
var user = await GetAsync <User>($"{_uri}{uniquePartOfUri}", _clientProvider);
IdOfLoggedInUser = user.Id;
UserTypeOfLoggedInUser = user.UserType;
AlreadyFetchedLoggedInUser = true;
IsLoggedIn = true;
}
catch
{
}
}
}
public async Task <BulkResponse> ExecuteAsync(RescheduleBulkExecuteContext context, BulkRequest bodyObject)
{
using (var client = HttpClientProvider.GetHttpClient(configuration))
{
NameValueCollection queryParameters = HttpUtility.ParseQueryString(string.Empty);
SetQueryParamIfNotNull(queryParameters, "bulkId", context.BulkId);
string queryString = queryParameters.ToString();
string endpoint = path + "?" + queryString;
string requestJson = JsonConvert.SerializeObject(bodyObject, Settings);
HttpContent content = new StringContent(requestJson, Encoding.UTF8, "application/json");
var response = await client.PutAsync(endpoint, content);
string contents = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <BulkResponse>(contents, Settings));
}
else
{
throw new InfobipApiException(
response.StatusCode,
JsonConvert.DeserializeObject <ApiErrorResponse>(contents, Settings)
);
}
}
}
private async Task <Deck> GetDeckAsync(string deckId, string authToken)
{
using (var httpClient = HttpClientProvider.GetHttpClient(authToken))
{
string decksServiceEndpoint = this.configuration["DecksServiceEndpoint"];
string decksServiceUrl = FormattableString.Invariant($"{decksServiceEndpoint}/api/decks/{deckId}");
HttpResponseMessage response = await httpClient.GetAsync(decksServiceUrl);
if (!response.IsSuccessStatusCode)
{
return(null);
}
string deckJson = await response.Content.ReadAsStringAsync();
if (string.IsNullOrWhiteSpace(deckJson))
{
return(null);
}
try
{
Deck deck = JsonConvert.DeserializeObject <Deck>(deckJson);
return(deck);
}
catch (Exception ex)
{
return(null);
}
}
}
public async Task <Campaign> ExecuteAsync(string campaignKey, Destinations bodyObject)
{
using (var client = HttpClientProvider.GetHttpClient(configuration))
{
string endpoint = path;
endpoint = endpoint.Replace("{campaignKey}", HttpUtility.UrlEncode(campaignKey));
string requestJson = JsonConvert.SerializeObject(bodyObject, Settings);
HttpContent content = new StringContent(requestJson, Encoding.UTF8, "application/json");
var response = await client.PutAsync(endpoint, content);
string contents = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <Campaign>(contents, Settings));
}
else
{
throw new InfobipApiException(
response.StatusCode,
JsonConvert.DeserializeObject <ApiErrorResponse>(contents, Settings)
);
}
}
}
public async Task <OMNIReportsResponse> ExecuteAsync(GetOMNIReportsExecuteContext context)
{
using (var client = HttpClientProvider.GetHttpClient(configuration))
{
NameValueCollection queryParameters = HttpUtility.ParseQueryString(string.Empty);
SetQueryParamIfNotNull(queryParameters, "bulkId", context.BulkId);
SetQueryParamIfNotNull(queryParameters, "messageId", context.MessageId);
SetQueryParamIfNotNull(queryParameters, "limit", context.Limit);
SetQueryParamIfNotNull(queryParameters, "channel", context.Channel);
string queryString = queryParameters.ToString();
string endpoint = path + "?" + queryString;
var response = await client.GetAsync(endpoint);
string contents = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <OMNIReportsResponse>(contents, Settings));
}
else
{
throw new InfobipApiException(
response.StatusCode,
JsonConvert.DeserializeObject <ApiErrorResponse>(contents, Settings)
);
}
}
}
public async Task <PreviewResponse> ExecuteAsync(PreviewRequest bodyObject)
{
using (var client = HttpClientProvider.GetHttpClient(configuration))
{
string endpoint = path;
string requestJson = JsonConvert.SerializeObject(bodyObject, Settings);
HttpContent content = new StringContent(requestJson, Encoding.UTF8, "application/json");
var response = await client.PostAsync(endpoint, content);
string contents = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <PreviewResponse>(contents, Settings));
}
else
{
throw new InfobipApiException(
response.StatusCode,
JsonConvert.DeserializeObject <ApiErrorResponse>(contents, Settings)
);
}
}
}
public void SetupHttpClient_Returns_HttpClient()
{
var provider = new HttpClientProvider();
HttpClient client = provider.SetupHttpClient();
Assert.That(client, Is.Not.Null);
}
async System.Threading.Tasks.Task <Document> DownloadAndOpenFileAsync(StackFrame frame, int line, SourceLink sourceLink)
{
var pm = IdeApp.Workbench.ProgressMonitors.GetStatusProgressMonitor(
GettextCatalog.GetString("Downloading {0}", sourceLink.Uri),
Stock.StatusDownload,
true
);
Document doc = null;
try {
var downloadLocation = sourceLink.GetDownloadLocation(symbolCachePath);
Directory.CreateDirectory(Path.GetDirectoryName(downloadLocation));
DocumentRegistry.SkipNextChange(downloadLocation);
var client = HttpClientProvider.CreateHttpClient(sourceLink.Uri);
using (var stream = await client.GetStreamAsync(sourceLink.Uri).ConfigureAwait(false))
using (var fs = new FileStream(downloadLocation, FileMode.Create)) {
await stream.CopyToAsync(fs).ConfigureAwait(false);
}
frame.UpdateSourceFile(downloadLocation);
doc = await Runtime.RunInMainThread(() => IdeApp.Workbench.OpenDocument(downloadLocation, null, line, 1, OpenDocumentOptions.Debugger));
} catch (Exception ex) {
LoggingService.LogInternalError("Error downloading SourceLink file", ex);
} finally {
pm.Dispose();
}
return(doc);
}
public async Task <MOLogsResponse> ExecuteAsync(GetReceivedSmsLogsExecuteContext context)
{
using (var client = HttpClientProvider.GetHttpClient(configuration))
{
NameValueCollection queryParameters = HttpUtility.ParseQueryString(string.Empty);
SetQueryParamIfNotNull(queryParameters, "to", context.To);
SetQueryParamIfNotNull(queryParameters, "receivedSince", context.ReceivedSince);
SetQueryParamIfNotNull(queryParameters, "receivedUntil", context.ReceivedUntil);
SetQueryParamIfNotNull(queryParameters, "limit", context.Limit);
SetQueryParamIfNotNull(queryParameters, "keyword", context.Keyword);
string queryString = queryParameters.ToString();
string endpoint = path + "?" + queryString;
var response = await client.GetAsync(endpoint);
string contents = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <MOLogsResponse>(contents, Settings));
}
else
{
throw new InfobipApiException(
response.StatusCode,
JsonConvert.DeserializeObject <ApiErrorResponse>(contents, Settings)
);
}
}
}
/// <summary>
/// Requests an access and refresh token from the code provided by the mercado libre callback.
/// </summary>
/// <param name="code">The code.</param>
/// <param name="redirectUri">The redirect URI.</param>
/// <returns>
/// Return True when the operation is successful.
/// </returns>
public async Task <bool> AuthorizeAsync(string code, string redirectUri)
{
if (Credentials == null)
{
throw new ApplicationException("Credentials property not initalised.");
}
var success = false;
var parameters = new HttpParams().Add("grant_type", "authorization_code")
.Add("client_id", Credentials.ClientId)
.Add("client_secret", Credentials.ClientSecret)
.Add("code", code)
.Add("redirect_uri", redirectUri);
using (var client = HttpClientProvider.Create(false))
{
var tokens = await SendAsync <TokenResponse>(client, HttpMethod.Post, ApiUrl, "/oauth/token", parameters);
if (tokens != null)
{
Credentials.SetTokens(tokens);
success = true;
}
}
return(success);
}
public async Task <NumberContextLogsResponse> ExecuteAsync(GetNumberContextLogsExecuteContext context)
{
using (var client = HttpClientProvider.GetHttpClient(configuration))
{
NameValueCollection queryParameters = new NameValueCollection();
SetQueryParamIfNotNull(queryParameters, "to", context.To);
SetQueryParamIfNotNull(queryParameters, "bulkId", context.BulkId);
SetQueryParamIfNotNull(queryParameters, "messageId", context.MessageId);
SetQueryParamIfNotNull(queryParameters, "generalStatus", context.GeneralStatus);
SetQueryParamIfNotNull(queryParameters, "sentSince", context.SentSince);
SetQueryParamIfNotNull(queryParameters, "sentUntil", context.SentUntil);
SetQueryParamIfNotNull(queryParameters, "limit", context.Limit);
SetQueryParamIfNotNull(queryParameters, "mcc", context.Mcc);
SetQueryParamIfNotNull(queryParameters, "mnc", context.Mnc);
string queryString = queryParameters.ToQueryString();
string endpoint = path + "?" + queryString;
var response = await client.GetAsync(endpoint);
string contents = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <NumberContextLogsResponse>(contents, Settings));
}
else
{
throw new InfobipApiException(
response.StatusCode,
JsonConvert.DeserializeObject <ApiErrorResponse>(contents, Settings)
);
}
}
}
protected override SmartSubtransportStream Action(string url, GitSmartSubtransportAction action)
{
string postContentType = null;
string serviceUri;
switch (action)
{
case GitSmartSubtransportAction.UploadPackList:
serviceUri = url + "/info/refs?service=git-upload-pack";
break;
case GitSmartSubtransportAction.UploadPack:
serviceUri = url + "/git-upload-pack";
postContentType = "application/x-git-upload-pack-request";
break;
case GitSmartSubtransportAction.ReceivePackList:
serviceUri = url + "/info/refs?service=git-receive-pack";
break;
case GitSmartSubtransportAction.ReceivePack:
serviceUri = url + "/git-receive-pack";
postContentType = "application/x-git-receive-pack-request";
break;
default:
throw new InvalidOperationException();
}
// Grab the credentials from the user.
var httpClient = HttpClientProvider.CreateHttpClient(serviceUri);
httpClient.Timeout = TimeSpan.FromMinutes(1.0);
var res = httpClient.GetAsync(serviceUri).Result;
if (res.StatusCode == System.Net.HttpStatusCode.Unauthorized)
{
var cred = (UsernamePasswordCredentials)GitCredentials.TryGet(url, "", SupportedCredentialTypes.UsernamePassword, GitCredentialsType.Tfs);
httpClient = new HttpClient(new HttpClientHandler {
Credentials = new System.Net.NetworkCredential(cred.Username, cred.Password)
})
{
Timeout = TimeSpan.FromMinutes(1.0),
};
res = httpClient.GetAsync(serviceUri).Result;
if (res.StatusCode == System.Net.HttpStatusCode.OK)
{
GitCredentials.StoreCredentials(GitCredentialsType.Tfs);
}
}
return(new TfsSmartSubtransportStream(this)
{
HttpClient = httpClient,
ServiceUri = new Uri(serviceUri),
PostContentType = postContentType,
});
}
public async Task <ScenariosResponse> ExecuteAsync(GetScenariosExecuteContext context)
{
using (var client = HttpClientProvider.GetHttpClient(configuration))
{
NameValueCollection queryParameters = new NameValueCollection();
SetQueryParamIfNotNull(queryParameters, "isDefault", context.IsDefault);
SetQueryParamIfNotNull(queryParameters, "limit", context.Limit);
SetQueryParamIfNotNull(queryParameters, "page", context.Page);
string queryString = queryParameters.ToQueryString();
string endpoint = path + "?" + queryString;
var response = await client.GetAsync(endpoint);
string contents = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
return(JsonConvert.DeserializeObject <ScenariosResponse>(contents, Settings));
}
else
{
throw new InfobipApiException(
response.StatusCode,
JsonConvert.DeserializeObject <ApiErrorResponse>(contents, Settings)
);
}
}
}
public static async Task<List<Movie>> GetMoviesAsync()
{
var httpClientProvider = new HttpClientProvider<List<Movie>>();
var movies = await httpClientProvider.GetAsync(Config.MoviesUrl);
return movies;
}
public void HttpClientProvider_ConstructedWithNullWebCfgReader_ShouldThrow()
{
// Arrange
HttpClientProvider client = new HttpClientProvider(null);
// Act
var returnedValue = client.GetHttpClientInstance();
}
public void CanAuthenticateDocFlock()
{
// var handler = new NativeMessageHandler();
var context = new HttpContext();
context.HostAddress = new Uri("http://api-shs-dev.docflock.com/");
//context.HostAddress = new Uri("http://shs-dev.docflock.com/");
var credentials = new DocFlockCredentials("*****@*****.**", "Password");
var client = new HttpClientProvider(context, new CancellationToken());
var authProvider = new DocFlockAuthProvider(client);
var response = authProvider.AuthenticateAsync(credentials).Result;
Assert.IsTrue(response.Principal.Identity.IsAuthenticated);
}
