/// <inheritdoc />
public virtual async Task <string> GetTokenAsync(CancellationToken cancellationToken)
{
//get initial access token and refresh token
if (OidcAuthenticationToken.AccessToken == null)
{
BigBrother.Publish(new ClientTokenRequest
{
ClientId = OidcAuthenticationConfig.ClientId,
Authority = OidcAuthenticationConfig.Uri,
Message = "Token is null getting a new one."
});
await EnterSemaphore(cancellationToken, async() =>
{
var httpClient = HttpClientFactory.Get(OidcAuthenticationConfig.Uri);
var response = await GetTokenResponseAsync(httpClient, cancellationToken);
ReportTokenUpdateFailure(OidcAuthenticationConfig, response);
UpdateToken(response);
BigBrother.Publish(new ClientTokenRequest
{
ClientId = OidcAuthenticationConfig.ClientId,
Authority = OidcAuthenticationConfig.Uri,
Message = "Got a new token and updating the http client when token was null"
});
});
}
else if (CheckExpired())
{
await EnterSemaphore(cancellationToken, async() =>
{
if (CheckExpired())
{
var httpClient = HttpClientFactory.Get(OidcAuthenticationConfig.Uri);
var response = await GetTokenResponseAsync(httpClient, cancellationToken);
ReportTokenUpdateFailure(OidcAuthenticationConfig, response);
UpdateToken(response);
BigBrother.Publish(new ClientTokenRequest
{
ClientId = OidcAuthenticationConfig.ClientId,
Authority = OidcAuthenticationConfig.Uri,
Message = "Refreshing token and updating the http client with new token"
});
}
});
}
return($"Bearer {OidcAuthenticationToken.AccessToken}");
}
public async Task <FailableResult <T> > Get <T>(string url)
{
var retry = 0;
while (retry < RETRY_MAX)
{
try
{
var client = _httpClientFactory.Get();
var response = await client.GetAsync(url);
var resultStr = await response.Content.ReadAsStringAsync();
var result = JsonConvert.DeserializeObject <T>(resultStr);
return(new FailableResult <T> {
Result = result
});
}
catch (Exception e)
{
if (retry >= RETRY_MAX)
{
return(new FailableResult <T> {
Error = e.Message + e.StackTrace.ToString()
});
}
}
_httpClientFactory.Recycle();
retry += 1;
}
throw new InvalidProgramException();
}
/// <summary>
///
/// </summary>
/// <typeparam name="TRequest"></typeparam>
/// <param name="request"></param>
/// <param name="metadata"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task CallAsync <TRequest>(TRequest request, IDictionary <string, object> metadata, CancellationToken cancellationToken)
{
try
{
if (!(request is MessageData messageData))
{
throw new Exception("injected wrong implementation");
}
//todo refactor into a single call and a dto
var uri = RequestBuilder.BuildUri(WebhookConfig, messageData.Payload);
var httpMethod = RequestBuilder.SelectHttpMethod(WebhookConfig, messageData.Payload);
var originalPayload = RequestBuilder.BuildPayload(WebhookConfig, messageData.Payload, metadata);
var payload = WebhookConfig.PayloadTransformation == PayloadContractTypeEnum.WrapperContract
? WrapPayload(originalPayload, WebhookConfig, messageData)
: originalPayload;
var config = RequestBuilder.SelectWebhookConfig(WebhookConfig, messageData.Payload);
var headers = RequestBuilder.GetHttpHeaders(WebhookConfig, messageData);
var authenticationConfig = RequestBuilder.GetAuthenticationConfig(WebhookConfig, messageData.Payload);
var httpClient = HttpClientFactory.Get(config);
await AddAuthenticationHeaderAsync(cancellationToken, authenticationConfig, headers);
var response = await httpClient.SendRequestReliablyAsync(httpMethod, uri, headers, payload, cancellationToken);
await _requestLogger.LogAsync(httpClient, response, messageData, uri, httpMethod, headers);
}
catch (Exception e)
{
BigBrother.Publish(e.ToExceptionEvent());
throw;
}
}
public async Task <string> Call(string baseAddress, string relativeAddress)
{
var httpClient = _httpClientFactory.Get(baseAddress);
var responseMessage = await httpClient.GetAsync(relativeAddress);
return((await responseMessage.Content.ReadAsStringAsync()).Length > 0 ? baseAddress + " ok" : baseAddress + " fail");
}
/// <inheritdoc />
public async Task ReceiveMessage(int botId, string senderId, long messageToken, MessageBase message)
{
InMessage inMessage = null;
switch (message.Type)
{
case Viber.Bot.Enums.MessageType.Picture:
inMessage = CreatePictureMessage((PictureMessage)message);
break;
case Viber.Bot.Enums.MessageType.Video:
inMessage = CreateVideoMessage((VideoMessage)message);
break;
case Viber.Bot.Enums.MessageType.Text:
var textMessage = (TextMessage)message;
if (Enum.TryParse <ButtonType>(textMessage.Text, out var buttonType))
{
if (buttonType == ButtonType.OK)
{
await Subscribed(botId, senderId);
return;
}
inMessage = CreateButtonMessage(buttonType, messageToken);
}
else
{
inMessage = CreateTextMessage(textMessage);
}
break;
}
//
var people = await peopleRepository.GetPeopleByViberIdAsync(senderId);
//
var model = new PayloadModel <InMessage>
{
BotId = botId,
AgentId = people.Id,
Message = inMessage
};
var response = httpClientFactory.Get("https://localhost:5001/api/").SendPostAsync <MessageModel <InMessage>, string>("msgbot/change_state", model, "application/xml");
}
public async Task <string> Request(string url, CancellationTokenSource token = null)
{
_currentToken = token ?? new CancellationTokenSource();
var httpClient = _httpClientFactory.Get();
var msg = await httpClient.GetAsync(url, _currentToken.Token);
if (!msg.IsSuccessStatusCode)
{
return("Something derped");
}
var result = await msg.Content.ReadAsStringAsync();
return(result);
}
public async Task <string> Download(string url, CancellationTokenSource token = null)
{
_currentToken = token ?? new CancellationTokenSource();
var handler = _httpClientFactory.GetHandler();
var outerHandler = new RetryHandler(handler, 3);
var client = _httpClientFactory.Get(outerHandler);
var msg = await client.GetAsync(url, _currentToken.Token);
if (!msg.IsSuccessStatusCode)
{
return("Something derped");
}
var result = await msg.Content.ReadAsStringAsync();
return(result);
}
private HttpClient GetHttpClient()
{
var httpClient = _httpClientFactory.Get();
if (string.IsNullOrWhiteSpace(_config?.AuthConfig?.AuthHeaderConfig?.Secret))
{
return(httpClient);
}
if (httpClient.DefaultRequestHeaders.Contains(_config.AuthConfig.AuthHeaderConfig.HeaderName))
{
return(httpClient);
}
httpClient.DefaultRequestHeaders.Add(
_config.AuthConfig.AuthHeaderConfig.HeaderName,
_config.AuthConfig.AuthHeaderConfig.Secret);
return(httpClient);
}
public ClientApiService(IHttpClientFactory factory)
{
HttpClient = factory.Get();
}