/// <summary>
/// Execute AliPay API request implementation
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <typeparam name="TResponse"></typeparam>
/// <param name="request"></param>
/// <returns></returns>
public async Task <TResponse> ExecuteAsync <TModel, TResponse>(BaseRequest <TModel, TResponse> request)
{
BuildParams(request);
if (request is AppPayRequest || request is WapPayRequest)
{
return((TResponse)Activator.CreateInstance(typeof(TResponse), request));
}
string result = await _httpHandler.PostAsync(request.RequestUrl, request.ToUrl());
var jObject = JObject.Parse(result);
var jToken = jObject.First.First;
var sign = jObject.Value <string>("sign");
if (!string.IsNullOrEmpty(sign) &&
!CheckSign(jToken.ToString(Formatting.None), sign, _alipayOptions.AlipayPublicKey, _alipayOptions.SignType))
{
_logger.LogError("Signature verification failed:{0}", result);
throw new OmniPayException("Signature verification failed.");
}
var baseResponse = (BaseResponse)(object)jToken.ToObject <TResponse>();
baseResponse.Raw = result;
baseResponse.Sign = sign;
return((TResponse)(object)baseResponse);
}
public async Task SendAsync(IUsageMetric usageMetric)
{
var json = Serialize(usageMetric);
var content = new StringContent(json, Encoding.UTF8, "application/json");
await _httpHandler.PostAsync(new Uri(_baseUri, usageMetric.Product), content);
}
public async Task RunAsync(string[] args)
{
if (args.Length > 1 || args.Length < 1)
{
DisplayInstructions();
}
if (int.TryParse(args[0], out var numberOfItemsToCreate))
{
string json = JsonConvert.SerializeObject(GetFakeRequests(numberOfItemsToCreate));
StringContent stringContent = new StringContent(json, Encoding.UTF8, MediaType.Json);
Logger.Info("Sending request...");
string url = _config.BaseApiAddress + _config.PostRequestsUri;
// This is a candidate for using message queue
HttpResponseMessage response = await _httpHandler.PostAsync(url, stringContent);
response.EnsureSuccessStatusCode();
Logger.Info(await response.Content.ReadAsStringAsync());
}
else
{
DisplayInstructions();
}
}
public async Task <bool> Upload(string fileName)
{
using (var form = new MultipartFormDataContent())
{
using (var fs = File.OpenRead(fileName))
{
using (var streamContent = new StreamContent(fs))
{
using (var fileContent = new ByteArrayContent(await streamContent.ReadAsByteArrayAsync()))
{
fileContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
form.Add(fileContent, "file", Path.GetFileName(fileName));
HttpResponseMessage response =
await client.PostAsync($"{baseUrl}{fileServiceName}", form);
if (!response.IsSuccessStatusCode)
{
return(false);
}
}
}
}
}
return(true);
}
/// <summary>
/// Sets request, http method(post/put), uri string, version, client id, client secret and access token.
/// </summary>
/// <returns>
/// Gets the respective result.
/// </returns>
public string PostRequestResolver(string request, HttpMethod httpMethod, string version, string clientId, string clientSecret, string uriPath, AccessToken accessToken, DateTime dateTime)
{
GetRefreshToken(version, clientId, clientSecret, accessToken, dateTime);
var response = _httpHandler.PostAsync(request, httpMethod, version, uriPath, accessToken.Type, accessToken.Token);
var content = response.Content.ReadAsStringAsync().Result;
return(content);
}
public async Task <HttpResponseMessage> SendAsync(PushoverMessage message, string userKey)
{
var parameters = new List <KeyValuePair <string, string> >();
parameters.Add(new KeyValuePair <string, string>("token", _appToken));
parameters.Add(new KeyValuePair <string, string>("user", userKey));
parameters.AddRange(message.ToKeyValuePairs());
var content = new System.Net.Http.FormUrlEncodedContent(parameters);
var response = await HttpHandler.PostAsync(RequestUri, content);
if (response.StatusCode != HttpStatusCode.OK)
{
throw new Exception(await response.Content.ReadAsStringAsync());
}
return(response);
}
public async Task LoginAsync(string username, string password, string token)
{
var content = new LoginHttpContent(username, password, token);
var response = await http.PostAsync(LoginUrl, content);
if (response.IsSuccessStatusCode)
{
var xml = await response.Content.ReadAsStringAsync();
var result = DeserializeLoginResponse(xml);
ServerUrl = result.ServerUrl;
SessionId = result.SessionId;
}
else
{
throw new Exception($"HTTP Error: {response.StatusCode}");
}
}
/// <summary>
/// A Delivery Quote provides an estimate for a potential delivery. This includes the amount the delivery is expected to cost as well as an estimated delivery window. As demand on our platform changes over time, the fee amount and ETA may increase beyond what your use-case can support.
/// A Delivery Quote can only be used once and is only valid for a limited duration.
/// </summary>
/// <param name="pickupAddress">The pickup address for a potential delivery.</param>
/// <param name="dropoffAddress">The dropoff address for a potential delivery.</param>
/// <returns>if sucessful DeliveryQuote else error</returns>
public async Task <IResponse> GetQuoteAsync(Address pickupAddress, Address dropoffAddress)
{
if (pickupAddress == null)
{
throw new ArgumentNullException(nameof(pickupAddress));
}
if (dropoffAddress == null)
{
throw new ArgumentNullException(nameof(dropoffAddress));
}
using (var quoteResponse = await _httpClient.PostAsync($"/v1/customers/{_customer_Id}/delivery_quotes",
new FormUrlEncodedContent(new[] {
new KeyValuePair <string, string>("pickup_address", $"{pickupAddress.StreetNumber},{pickupAddress.City},{pickupAddress.State}"),
new KeyValuePair <string, string>("dropoff_address", $"{dropoffAddress.StreetNumber},{dropoffAddress.City},{dropoffAddress.State}")
})).ConfigureAwait(false)) {
return(await GetResponseAsync <DeliveryQuote>(quoteResponse, ResponseKinds.delivery_quote).ConfigureAwait(false));
}
}
public async Task <TokenModel> Login(LoginModel model)
{
var baseUrl = AppSettingsProvider.IdentityBaseUrl;
var api = AppSettingsProvider.Login;
var messageBody = JsonConvert.SerializeObject(model);
var result = await _httpHandler.PostAsync <TokenModel>(baseUrl, api, messageBody);
return(result);
}
/// <summary>
/// Get movie detail of Lotte vendor
/// </summary>
/// <param name="movieId">ID of the movie</param>
/// <returns></returns>
public async Task <Movie> GetMovieDetail(string movieId)
{
Movie movie = null;
var param = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("paramList", string.Format(PARAM_MOVIE_DETAIL, movieId))
});
var reqResult = await _httpHandler.PostAsync(URL_MOVIES, param);
string content = await reqResult.Content.ReadAsStringAsync();
JObject responseObj = JObject.Parse(content);
JToken entry = responseObj["Movie"];
if (entry != null)
{
movie = new Movie();
movie.MovieId = entry["RepresentationMovieCode"] != null ? entry["RepresentationMovieCode"].ToString() : string.Empty;
movie.EnglishName = entry["MovieNameUS"] != null ? entry["MovieNameUS"].ToString() : string.Empty;
movie.VietNameseName = entry["MovieName"] != null ? entry["MovieName"].ToString() : movie.EnglishName;
movie.PosterUrl = entry["PosterURL"] != null ? entry["PosterURL"].ToString() : string.Empty;
movie.ViewGradeNameEN = entry["ViewGradeNameUS"] != null ? entry["ViewGradeNameUS"].ToString() : string.Empty;
movie.ViewGradeCode = entry["ViewGradeCode"] != null ? entry["ViewGradeCode"].ToString() : movie.ViewGradeNameEN;
DateTime tmpReleaseDate = DateTime.MinValue;
if (entry["ReleaseDate"] != null && DateTime.TryParse(entry["ReleaseDate"].ToString(), out tmpReleaseDate))
{
movie.ReleaseDate = tmpReleaseDate;
}
movie.PlayTime = entry["PlayTime"] != null ? (int)entry["PlayTime"] : 0;
movie.Rating = entry["ViewEvaluation"] != null ? (double)entry["ViewEvaluation"] : 0;
movie.DescriptionEN = entry["SynopsisUS"] != null ? entry["SynopsisUS"].ToString() : string.Empty;
movie.Description = entry["Synopsis"] != null ? entry["Synopsis"].ToString() : movie.DescriptionEN;
movie.TotalViewCount = entry["TotalViewCount"] != null ? (int)entry["TotalViewCount"] : 0;
movie.MovieGenreNameEN = entry["MovieGenreNameUS"] != null ? entry["MovieGenreNameUS"].ToString() : string.Empty;
movie.MovieGenreName = entry["MovieGenreName"] != null ? entry["MovieGenreName"].ToString() : movie.MovieGenreNameEN;
}
return(movie);
}
private void ArrangeHttpRequest(HttpStatusCode code)
{
HttpContent respContent = new StringContent(SuccessMessage.PostSuccess(_argument));
_config.BaseApiAddress.Returns("http://localhost:12345");
_config.PostRequestsUri.Returns("someAddress");
_httpHandler.PostAsync(Arg.Any <string>(), Arg.Any <HttpContent>()).Returns(new HttpResponseMessage
{
StatusCode = code,
Content = respContent
});
}
/// <summary>
/// Method convert request object to JSON, make POST request and convert response to JSON
/// </summary>
/// <typeparam name="TRequest">type of request json object</typeparam>
/// <typeparam name="TResponse">type of response json object</typeparam>
/// <param name="url">part of url like "/kkt/receipt"</param>
/// <param name="request">request contract object</param>
/// <param name="requestId">parameter for idempotent requests</param>
/// <param name="token">cancellation token</param>
/// <returns>response contract object</returns>
public async Task <TResponse> PostAsync <TRequest, TResponse>(string url, TRequest request, string requestId = null, CancellationToken token = default(CancellationToken))
where TRequest : class
where TResponse : class
{
_logger.LogTrace($"make request to {url}");
_client.SetupIdempotent(requestId);
using (var stringContent = await ToJsonStringContent(request))
using (var response = await _client.PostAsync(url, stringContent, token))
using (var content = response.Content)
{
var result = FromJsonStream <TResponse>(await content.ReadAsStreamAsync());
_logger.LogTrace($"response successfully received");
return(result);
}
}
public void VerifyOtp()
{
var request = new VerifyOtp
{
PhoneNumber = "+6597398077",
Code = "321252",
LspId = "0add4ba4-2e62-417b-984f-183f3d11baf7",
RefCode = "AOAX",
LockerStationId = "87471edc-37d6-41ef-8521-b96116e707a5"
};
var json = JsonConvert.SerializeObject(request, new JsonSerializerSettings()
{
DefaultValueHandling = DefaultValueHandling.Ignore
});
var response = httpHandler.PostAsync(json, HttpMethod.Post, version, uriPath, type, token);
}
/// <summary>
/// Execute WeChatPay API request implementation
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <typeparam name="TResponse"></typeparam>
/// <param name="request"></param>
/// <returns></returns>
public async Task <TResponse> ExecuteAsync <TModel, TResponse>(BaseRequest <TModel, TResponse> request)
{
BuildParams(request);
var result = await _httpHandler.PostAsync(request.RequestUrl, request.ToXml(), _weChatPayOptions.HttpClientName, null);
request.FromXml(result);
var baseResponse = (BaseResponse)(object)request.ToObject <TResponse>();
baseResponse.Raw = result;
var repSign = request.GetStringValue("sign");
if (string.IsNullOrEmpty(repSign) && !CheckSign(request, repSign, _weChatPayOptions.Key))
{
_logger.LogError("Signature verification failed:{0}", result);
throw new OmniPayException("Signature verification failed.");
}
return((TResponse)(object)baseResponse);
}
public async Task <Pagamento> RequisitaPagamento(Pagamento pagamento)
{
_client.SetBaseAddress(_urlBase);
var request = JsonConvert.SerializeObject(pagamento.ToPagamentoCreate());
var httpContent = new StringContent(request, Encoding.UTF8, MEDIA_TYPE);
var gatewayResponse = await _client.PostAsync(ProjectConsts.PAGAMENTO_URI, httpContent);
if (gatewayResponse.IsSuccessStatusCode)
{
var response = await gatewayResponse.Content.ReadAsStringAsync();
return(JSONHelper.DeserializeJsonToObject <Pagamento>(response));
}
else
{
throw new Exception("Falha no pagamento");
}
}
private async Task <HttpResponseMessage> PostSyncNoException(string url, HttpContent content)
{
HttpResponseMessage response;
try
{
response = HttpClient.PostAsync(url, content).Result;
return(response);
}
catch (Exception e)
{
var response2 = new HttpResponseMessage
{
StatusCode = System.Net.HttpStatusCode.Gone,
Content = new StringContent(e.Message, Encoding.UTF8)
};
return(response2);
}
}
public async Task <TResponse> PostAsync <TResponse, TRequest>(string queryPath, TRequest @object)
{
Uri requestUri = new Uri(_uri, queryPath);
string jsonRequest = JsonConvert.SerializeObject(@object);
Console.WriteLine($"POST: {queryPath}");
Console.WriteLine(jsonRequest);
StringContent stringContent = GetHttpContent(jsonRequest);
HttpResponseMessage response = await _httpHandler.PostAsync(requestUri, stringContent);
response.EnsureSuccessStatusCode();
string jsonResponse = await response.Content.ReadAsStringAsync();
Console.WriteLine("Response:");
Console.WriteLine(jsonResponse);
TResponse responseT = JsonConvert.DeserializeObject <TResponse>(jsonResponse);
return(responseT);
}
