/// <summary>
/// checks if login to backend specified by <paramref name="bobId"/> works using the token
/// </summary>
/// <param name="token">JWToken</param>
/// <param name="apiKey">hf-api api key</param>
/// <param name="bobId">ID of backend</param>
/// <returns>Tuple containing true/false depending if login was successful and returned status code</returns>
public async Task <Tuple <bool, HttpStatusCode> > CheckLogin(Uri meterMonitorBaseUrl, string token, string apiKey, BOBackendId bobId)
{
if (meterMonitorBaseUrl == null)
{
throw new ArgumentNullException(nameof(meterMonitorBaseUrl), "could not be null.");
}
if (bobId == null)
{
throw new ArgumentNullException(nameof(bobId), "could not be null.");
}
var request = new HttpRequestMessage()
{
Method = HttpMethod.Head,
RequestUri = meterMonitorBaseUrl
};
AddHeaders(ref request, token, apiKey, bobId);
HttpResponseMessage response;
try
{
response = await httpClient.SendAsync(request);
}
catch (Exception e)
{
_logger.LogError($"Request (try login) failed. {nameof(meterMonitorBaseUrl)}: '{meterMonitorBaseUrl}', {nameof(token)}: '{token}', {nameof(bobId)}: '{bobId}'; Exception: {e}.");
_logger.LogInformation($"Returning negative result with status code {HttpStatusCode.BadGateway} / 502");
return(new Tuple <bool, HttpStatusCode>(false, HttpStatusCode.BadGateway));
}
finally
{
request.Dispose();
}
_logger.LogDebug($"Response has status code {response.StatusCode}. See lookup service logs for details.");
return(new Tuple <bool, HttpStatusCode>(response.IsSuccessStatusCode, response.StatusCode));
}
/// <summary>
/// Get MeterMonitor By Id
/// </summary>
/// <param name="internalPodId">internalPodId as a part of key</param>
/// <param name="logikzw">logikzw as a part of key</param>
/// <param name="profile">profile as a part of key</param>
/// <param name="profileRole">profileRole as a part of key</param>
/// <param name="serviceid">serviceid as a part of key</param>
/// <param name="token">token to authenticate</param>
/// <param name="apiKey">API key for gateway</param>
/// <param name="backendId">ID of Backend</param>
/// <param name="withError">with 'toError'?</param>
/// <returns></returns>
///<exception cref="HfException" >if Could not get the MeterMonitor and silentFailure is false</exception>
public async Task <MeterMonitorResult> GetMeterMonitorById(
string internalPodId,
string logikzw,
string profile,
string profileRole,
string serviceid,
string token, string apiKey, BOBackendId backendId, bool withError = true)
{
using (MiniProfiler.Current.Step(nameof(GetMeterMonitorById)))
{
if (string.IsNullOrEmpty(internalPodId))
{
_logger.LogError($"{nameof(internalPodId)} could not be null in {nameof(MeterMonitorHelper)}{nameof(GetMeterMonitorById)}");
throw new ArgumentNullException(internalPodId, $"{nameof(internalPodId)} could not be null in {nameof(MeterMonitorHelper)}{nameof(GetMeterMonitorById)}");
}
if (string.IsNullOrEmpty(logikzw))
{
_logger.LogError($"{nameof(logikzw)} could not be null in {nameof(MeterMonitorHelper)}{nameof(GetMeterMonitorById)}");
throw new ArgumentNullException(logikzw, $"{nameof(logikzw)} could not be null in {nameof(MeterMonitorHelper)}{nameof(GetMeterMonitorById)}");
}
if (string.IsNullOrEmpty(profile))
{
_logger.LogError($"{nameof(profile)} could not be null in {nameof(MeterMonitorHelper)}{nameof(GetMeterMonitorById)}");
throw new ArgumentNullException(profile, $"{nameof(profile)} could not be null in {nameof(MeterMonitorHelper)}{nameof(GetMeterMonitorById)}");
}
if (string.IsNullOrEmpty(profileRole))
{
_logger.LogError($"{nameof(profileRole)} could not be null in {nameof(MeterMonitorHelper)}{nameof(GetMeterMonitorById)}");
throw new ArgumentNullException(profileRole, $"{nameof(profileRole)} could not be null in {nameof(MeterMonitorHelper)}{nameof(GetMeterMonitorById)}");
}
if (string.IsNullOrEmpty(serviceid))
{
_logger.LogError($"{nameof(serviceid)} could not be null in {nameof(MeterMonitorHelper)}{nameof(GetMeterMonitorById)}");
throw new ArgumentNullException(serviceid, $"{nameof(serviceid)} could not be null in {nameof(MeterMonitorHelper)}{nameof(GetMeterMonitorById)}");
}
Dictionary <string, string> queries = new Dictionary <string, string>();
queries.Add(nameof(internalPodId), internalPodId);
queries.Add(nameof(logikzw), logikzw);
queries.Add(nameof(profile), profile);
queries.Add(nameof(profileRole), profileRole);
queries.Add(nameof(serviceid), serviceid);
queries.Add(nameof(withError), withError.ToString());
HttpRequestMessage request = new HttpRequestMessage()
{
Method = HttpMethod.Get,
RequestUri = new Uri(QueryHelpers.AddQueryString("getbyid", queries), UriKind.Relative)
};
AddHeaders(ref request, token, apiKey, backendId);
_logger.LogInformation($"Sending out MeterMonitor GetbyId request with token");
var responseMessage = await httpClient.SendAsync(request);
_logger.LogInformation($"Got response from MeterMonitor GetbyId request with token");
if (!responseMessage.IsSuccessStatusCode)
{
string response = await responseMessage.Content.ReadAsStringAsync();
_logger.LogCritical($"Could not perform MeterMonitor GetbyId: {responseMessage.ReasonPhrase} / {response}; GET to {httpClient.BaseAddress}{request.RequestUri}");
if (_silentFailure)
{
return(null);
}
else
{
throw new HfException(responseMessage);
}
}
_logger.LogDebug($"Successfully retrieved MeterMonitor GetbyId response with status code {responseMessage.StatusCode}");
string responseContent = await responseMessage.Content.ReadAsStringAsync();
var resultObject = DeserializeObjectAndLog <MeterMonitorResult>(responseContent);
return(resultObject);
}
}
/// <summary>
/// set requests headers and removes them prior to adding if they're already present.
/// </summary>
/// <param name="request">request that is modified (pass by ref)</param>
/// <param name="token">access token</param>
/// <param name="apiKey">subscription key for azure</param>
/// <param name="backendId">ID of the backend</param>
/// <returns></returns>
protected void AddHeaders(ref HttpRequestMessage request, string token, string apiKey, BOBackendId backendId)
{
_logger.LogDebug(nameof(AddHeaders));
if (request.Headers.Contains(HeaderNames.Auth.Authorization))
{
_logger.LogDebug($"Removing header '{HeaderNames.Auth.Authorization}'");
request.Headers.Remove(HeaderNames.Auth.Authorization);
}
request.Headers.Add(HeaderNames.Auth.Authorization, "Bearer " + token);
if (request.Headers.Contains(HeaderNames.Auth.HfAuthorization))
{
_logger.LogDebug($"Removing header '{HeaderNames.Auth.HfAuthorization}'");
request.Headers.Remove(HeaderNames.Auth.HfAuthorization);
}
request.Headers.Add(HeaderNames.Auth.HfAuthorization, "Bearer " + token);
if (request.Headers.Contains(HeaderNames.Azure.SUBSCRIPTION_KEY))
{
_logger.LogDebug($"Removing header '{HeaderNames.Azure.SUBSCRIPTION_KEY}'");
request.Headers.Remove(HeaderNames.Azure.SUBSCRIPTION_KEY);
}
if (!string.IsNullOrEmpty(apiKey))
{
_logger.LogDebug($"Adding header '{HeaderNames.Azure.SUBSCRIPTION_KEY}'");
request.Headers.Add(HeaderNames.Azure.SUBSCRIPTION_KEY, apiKey);
}
if (request.Headers.Contains(HeaderNames.BACKEND_ID))
{
_logger.LogDebug($"Removing header '{HeaderNames.BACKEND_ID}'");
request.Headers.Remove(HeaderNames.BACKEND_ID);
}
_logger.LogDebug($"Adding header '{HeaderNames.BACKEND_ID}'");
request.Headers.Add(HeaderNames.BACKEND_ID, backendId.ToString());
_logger.LogDebug($"Adding header 'Accept-Encoding'");
request.Headers.Add("Accept-Encoding", "gzip, deflate");
}
/// <summary>
///
/// </summary>
/// <param name="urls"></param>
/// <param name="lookupURL"></param>
/// <param name="clientCertString"></param>
/// <param name="apiKey"></param>
/// <param name="backendId"></param>
/// <returns></returns>
/// <exception cref="HfException" >if Could not perform lookup and silentFailure is false</exception>
public async Task <GenericLookupResult> RetrieveURLs(IList <Bo4eUri> urls, Uri lookupURL, string clientCertString, string apiKey, BOBackendId backendId, string correlationId = null)
{
if (string.IsNullOrWhiteSpace(clientCertString))
{
_logger.LogWarning($"{nameof(clientCertString)} is initial: '{clientCertString}'");
}
if (lookupURL == null)
{
_logger.LogCritical($"{nameof(lookupURL)} is null!");
}
GenericLookupQuery urlObject = new GenericLookupQuery()
{
Uris = urls
};
string requestBody = JsonConvert.SerializeObject(urlObject, new StringEnumConverter());
var request = new HttpRequestMessage()
{
Content = new StringContent(requestBody, System.Text.UTF8Encoding.UTF8, MIME_TYPE_JSON),
RequestUri = lookupURL,
Method = HttpMethod.Post
};
if (request.Headers.Contains(HeaderNames.Auth.XArrClientCert))
{
_logger.LogDebug($"Removing header '{HeaderNames.Auth.XArrClientCert}'");
request.Headers.Remove(HeaderNames.Auth.XArrClientCert);
}
request.Headers.Add(HeaderNames.Auth.XArrClientCert, clientCertString);
if (request.Headers.Contains(HeaderNames.Azure.SUBSCRIPTION_KEY))
{
_logger.LogDebug($"Removing header '{HeaderNames.Azure.SUBSCRIPTION_KEY}'");
request.Headers.Remove(HeaderNames.Azure.SUBSCRIPTION_KEY);
}
if (!string.IsNullOrEmpty(apiKey))
{
_logger.LogDebug($"Adding {HeaderNames.Azure.SUBSCRIPTION_KEY} header");
request.Headers.Add(HeaderNames.Azure.SUBSCRIPTION_KEY, apiKey);
}
else
{
_logger.LogWarning($"{nameof(apiKey)} is initial: '{apiKey}'");
}
if (request.Headers.Contains(HeaderNames.BACKEND_ID))
{
_logger.LogDebug($"Removing {HeaderNames.BACKEND_ID} header");
request.Headers.Remove(HeaderNames.BACKEND_ID);
}
request.Headers.Add(HeaderNames.BACKEND_ID, backendId.ToString());
if (request.Headers.Contains("x-correlation-id"))
{
_logger.LogDebug($"Removing header 'x-correlation-id'");
request.Headers.Remove("x-correlation-id");
}
if (!string.IsNullOrEmpty(correlationId))
{
_logger.LogDebug($"Adding x-correlation-id header");
request.Headers.Add("x-correlation-id", correlationId);
}
var responseMessage = await httpClient.SendAsync(request);
if (!responseMessage.IsSuccessStatusCode)
{
string responseContentPost = await responseMessage.Content.ReadAsStringAsync();
_logger.LogCritical($"Could not perform lookup: {responseMessage.ReasonPhrase} / {responseContentPost}; The original request was: {requestBody} POSTed to {lookupURL}");
if (_silentFailure)
{
return(null);
}
else
{
throw new HfException(responseMessage);
}
}
string responseContent = await responseMessage.Content.ReadAsStringAsync();
GenericLookupResult resultObject = DeserializeObjectAndLog <GenericLookupResult>(responseContent);
return(resultObject);
}
/// <summary>
/// GetMeterMonitor list
/// Posts the content from <paramref name="json"/> to the URL specified in <paramref name="lookupURL"/> using the token
/// </summary>
/// <param name="token">token to authenticate</param>
/// <param name="apiKey">API key for gateway</param>
/// <param name="backendId">ID of Backend</param>
/// <param name="limit">limit number of results</param>
/// <param name="offset">number of skip results</param>
/// <param name="withError">with 'toError'?</param>
/// <param name="createdDate">specific Date to filter results</param>
/// <returns>a list of MeterMonitorResult <see cref="MeterMonitorResult"/>></returns>
///<exception cref="HfException" >if Could not get the MeterMonitor list and silentFailure is false</exception>
public async Task <IList <MeterMonitorResult> > GetMeterMonitors(string token, string apiKey, BOBackendId backendId,
DateTimeOffset?createdDate = null, uint limit = 0, uint offset = 0, bool withError = true)
{
using (MiniProfiler.Current.Step(nameof(GetMeterMonitors)))
{
Dictionary <string, string> queries = new Dictionary <string, string>();
if (limit > 0)
{
queries.Add(nameof(limit), limit.ToString());
}
if (offset > 0)
{
queries.Add(nameof(offset), offset.ToString());
}
queries.Add(nameof(withError), withError.ToString());
string createdDateString = createdDate.HasValue ? createdDate.Value.ToString("yyyy-MM-dd") : DateTimeOffset.UtcNow.ToString("yyyy-MM-dd");
queries.Add(nameof(createdDate), createdDateString);
_logger.LogInformation($"MeterMonitor List request with createdDate: '{createdDateString}'");
HttpRequestMessage request = new HttpRequestMessage()
{
Method = HttpMethod.Get,
RequestUri = new Uri(QueryHelpers.AddQueryString("", queries), UriKind.Relative)
};
AddHeaders(ref request, token, apiKey, backendId);
_logger.LogInformation($"Sending out MeterMonitor List request with token");
var responseMessage = await httpClient.SendAsync(request);
_logger.LogInformation($"Got response from MeterMonitor List request with token");
if (!responseMessage.IsSuccessStatusCode)
{
string response = await responseMessage.Content.ReadAsStringAsync();
_logger.LogCritical($"Could not perform MeterMonitor List: {responseMessage.ReasonPhrase} / {response}; GET to {httpClient.BaseAddress}");
if (_silentFailure)
{
return(null);
}
else
{
throw new HfException(responseMessage);
}
}
_logger.LogDebug($"Successfully retrieved MeterMonitor List response with status code {responseMessage.StatusCode}");
string responseContent = await responseMessage.Content.ReadAsStringAsync();
var resultObject = DeserializeObjectAndLog <List <MeterMonitorResult> >(responseContent);
return(resultObject);
}
}
/// <summary>
/// set requests headers and removes them prior to adding if they're already present.
/// </summary>
/// <param name="request">request that is modified (pass by ref)</param>
/// <param name="token">access token</param>
/// <param name="apiKey">subscription key for azure</param>
/// <param name="backendId">ID of the backend</param>
/// <returns></returns>
protected void AddHeaders(ref HttpRequestMessage request, string token, string apiKey, BOBackendId backendId, string correlationId)
{
_logger.LogDebug(nameof(AddHeaders));
if (request.Headers.Contains(HeaderNames.Auth.Authorization))
{
_logger.LogDebug($"Removing header '{HeaderNames.Auth.Authorization}'");
request.Headers.Remove(HeaderNames.Auth.Authorization);
}
request.Headers.Add(HeaderNames.Auth.Authorization, "Bearer " + token);
if (request.Headers.Contains(HeaderNames.Auth.HfAuthorization))
{
_logger.LogDebug($"Removing header '{HeaderNames.Auth.HfAuthorization}'");
request.Headers.Remove(HeaderNames.Auth.HfAuthorization);
}
request.Headers.Add(HeaderNames.Auth.HfAuthorization, "Bearer " + token);
if (request.Headers.Contains(HeaderNames.Azure.SUBSCRIPTION_KEY))
{
_logger.LogDebug($"Removing header '{HeaderNames.Azure.SUBSCRIPTION_KEY}'");
request.Headers.Remove(HeaderNames.Azure.SUBSCRIPTION_KEY);
}
if (!string.IsNullOrEmpty(apiKey))
{
_logger.LogDebug($"Adding header '{HeaderNames.Azure.SUBSCRIPTION_KEY}'");
request.Headers.Add(HeaderNames.Azure.SUBSCRIPTION_KEY, apiKey);
}
if (request.Headers.Contains(HeaderNames.BACKEND_ID))
{
_logger.LogDebug($"Removing header '{HeaderNames.BACKEND_ID}'");
request.Headers.Remove(HeaderNames.BACKEND_ID);
}
_logger.LogDebug($"Adding header '{HeaderNames.BACKEND_ID}'");
request.Headers.Add(HeaderNames.BACKEND_ID, backendId.ToString());
if (request.Headers.Contains("x-correlation-id"))
{
_logger.LogDebug($"Removing header 'x-correlation-id'");
request.Headers.Remove("x-correlation-id");
}
if (!string.IsNullOrEmpty(correlationId))
{
_logger.LogDebug($"Adding x-correlation-id header");
request.Headers.Add("x-correlation-id", correlationId);
}
}
/// <summary>
/// Initialise the suggestion cache for Backend <paramref name="bobId"/> with the lookup result of <paramref name="initialisationQuery"/>
/// </summary>
/// <param name="initialisationQuery">query whose result is used to initialise the suggestion cache</param>
/// <param name="lookupUrl">URI of the lookup service</param>
/// <param name="token">auth token</param>
/// <param name="apiKey">api key for azure</param>
/// <param name="bobId">unique ID of the backend</param>
/// <returns>raw lookup response as string in case of success, null in case of failure</returns>
/// <exception cref="HfException" >if Could not perform lookup and silentFailure is false</exception>
public async Task <string> InitialiseSuggestionCache(GenericCachingQuery initialisationQuery, Uri cacheUrl, string token, string apiKey, string encryptionKey, BOBackendId bobId, string correlationId = null)
{
using (MiniProfiler.Current.Step($"{nameof(InitialiseSuggestionCache)} ({nameof(LookupHelper)})"))
{
string serialisedQuery = JsonConvert.SerializeObject(initialisationQuery, new StringEnumConverter());
HttpRequestMessage request = new HttpRequestMessage()
{
Content = new StringContent(serialisedQuery, System.Text.Encoding.UTF8, MIME_TYPE_JSON),
Method = HttpMethod.Put,
RequestUri = cacheUrl
};
AddHeaders(ref request, token, apiKey, bobId, correlationId);
request.Headers.Add(HeaderNames.CacheService.ENCRYPTION_KEY_PUBLIC, encryptionKey);
var responseMessage = await httpClient.SendAsync(request);
if (!responseMessage.IsSuccessStatusCode)
{
string responseContent = await responseMessage.Content.ReadAsStringAsync();
_logger.LogCritical($"Could not perform cache initialisation: {responseMessage.ReasonPhrase}");
if (_silentFailure)
{
return(null);
}
else
{
throw new HfException(responseMessage);
}
}
_logger.LogDebug($"Successfully initialised cache with status code {responseMessage.StatusCode}");
return(await responseMessage.Content.ReadAsStringAsync());
}
}
/// <summary>
/// most generic call of the lookup service.
/// Posts the content from <paramref name="json"/> to the URL specified in <paramref name="lookupURL"/> using the token
/// </summary>
/// <param name="json">serialised lookup request</param>
/// <param name="lookupURL">URL of the lookup service</param>
/// <param name="token">token to authenticate</param>
/// <param name="apiKey">API key for gateway</param>
/// <param name="backendId">ID of Backend</param>
/// <returns></returns>
///<exception cref="HfException" >if Could not perform lookup and silentFailure is false</exception>
public async Task <string> LookupJsonWithUserToken(string json, Uri lookupURL, string token, string apiKey, BOBackendId backendId, string correlationId = null)
{
using (MiniProfiler.Current.Step(nameof(LookupJsonWithUserToken)))
{
HttpRequestMessage request = new HttpRequestMessage()
{
Content = new StringContent(json, System.Text.UTF8Encoding.UTF8, MIME_TYPE_JSON),
Method = HttpMethod.Post,
RequestUri = lookupURL
};
AddHeaders(ref request, token, apiKey, backendId, correlationId);
_logger.LogInformation($"Sending out lookup request with token");
var responseMessage = await httpClient.SendAsync(request);
_logger.LogInformation($"Got response from lookup request with token");
if (!responseMessage.IsSuccessStatusCode)
{
string responseContent = await responseMessage.Content.ReadAsStringAsync();
_logger.LogCritical($"Could not perform lookup: {responseMessage.ReasonPhrase} / {responseContent}; The original request was: {json} POSTed to {lookupURL}");
if (_silentFailure)
{
return(null);
}
else
{
throw new HfException(responseMessage); // todo @hamid put the full object in the exception
}
}
_logger.LogDebug($"Successfully retrieved response with status code {responseMessage.StatusCode}");
return(await responseMessage.Content.ReadAsStringAsync());
}
}
/// <summary>
/// Fetching the list of BusinessObjects as a suggested list in base of <paramref name="suggestion"/> string.
/// </summary>
/// <param name="suggestion"></param>
/// <param name="boe4Type"></param>
/// <param name="lookupURL"></param>
/// <param name="token"></param>
/// <param name="apiKey"></param>
/// <param name="backendId"></param>
/// <param name="anonymizedResultsOnly"></param>
/// <returns>Returns a listof suggested BusinessObject</returns>
/// <exception cref="HfException" >if Could not perform lookup and silentFailure is false</exception>
public async Task <List <BusinessObject> > Suggest(string suggestion, string boe4Type, Uri lookupURL, string token, string apiKey, BOBackendId backendId, bool anonymizedResultsOnly = false, string correlationId = null)
{
var uri = new Uri($"{lookupURL}/suggestion/{boe4Type}/{suggestion}");
_logger.LogDebug($"Suggestion URL is {uri}");
HttpRequestMessage request = new HttpRequestMessage()
{
Method = HttpMethod.Get,
RequestUri = uri
};
AddHeaders(ref request, token, apiKey, backendId, correlationId);
if (request.Headers.Contains(HeaderNames.ANONYMIZED_RESULTS_ONLY))
{
_logger.LogDebug($"Removing {HeaderNames.ANONYMIZED_RESULTS_ONLY} header");
request.Headers.Remove(HeaderNames.ANONYMIZED_RESULTS_ONLY);
}
request.Headers.Add(HeaderNames.ANONYMIZED_RESULTS_ONLY, anonymizedResultsOnly.ToString());
var responseMessage = await httpClient.SendAsync(request);
string responseContent = await responseMessage.Content.ReadAsStringAsync();
if (!responseMessage.IsSuccessStatusCode)
{
_logger.LogCritical($"Could not perform lookup: {responseMessage.ReasonPhrase} / {responseContent}; The original request was: {suggestion} GETed from {lookupURL}");
if (_silentFailure)
{
return(null);
}
else
{
throw new HfException(responseMessage);
}
}
List <BusinessObject> resultObject = DeserializeObjectAndLog <List <BusinessObject> >(responseContent);
return(resultObject);
}
/// <summary>
///
/// </summary>
/// <param name="urls"></param>
/// <param name="lookupURL"></param>
/// <param name="token"></param>
/// <param name="apiKey"></param>
/// <param name="backendId"></param>
/// <returns>todo: insert docstring</returns>
/// <exception cref="HfException" >if Could not perform lookup and silentFailure is false</exception>
public async Task <GenericLookupResult> RetrieveURLsWithUserToken(IList <Bo4eUri> urls, Uri lookupURL, string token, string apiKey, BOBackendId backendId)
{
GenericLookupQuery urlObject = new GenericLookupQuery()
{
Uris = urls
};
string requestBody = JsonConvert.SerializeObject(urlObject);
var request = new HttpRequestMessage()
{
Content = new StringContent(requestBody, System.Text.UTF8Encoding.UTF8, MIME_TYPE_JSON),
Method = HttpMethod.Post,
RequestUri = lookupURL
};
var responseMessage = await httpClient.SendAsync(request);
string responseContent = await responseMessage.Content.ReadAsStringAsync();
if (!responseMessage.IsSuccessStatusCode)
{
_logger.LogCritical($"Could not perform lookup: {responseMessage.ReasonPhrase} / {responseContent}; The original request was: {requestBody} POSTed to {lookupURL}");
_logger.LogDebug($"Returning null from lookup helper because of negative response code '{responseMessage.StatusCode}'");
if (_silentFailure)
{
return(null);
}
else
{
throw new HfException(responseMessage);
}
}
GenericLookupResult resultObject = DeserializeObjectAndLog <GenericLookupResult>(responseContent);
return(resultObject);
}
