public async Task <bool> ValidateBearerToken(string authToken)
{
try
{
// Fetch AccountConfiguration stored in DB to validate the user
AccountConfiguration accountConfiguration;
var accountConfigurationCache = InvitationsMemoryCache.GetInstance().GetFromMemoryCache("accountconfig");
if (accountConfigurationCache == null)
{
accountConfiguration = await ViaMongoDB.GetAccountConfiguration();
InvitationsMemoryCache.GetInstance().SetToMemoryCache("accountconfig", JsonConvert.SerializeObject(accountConfiguration));
}
else
{
accountConfiguration = JsonConvert.DeserializeObject <AccountConfiguration>(accountConfigurationCache);
}
return(ValidateBearerToken(authToken, accountConfiguration));
}
catch (Exception)
{
return(false);
}
}
public bool ValidateBearerToken(string authToken, AccountConfiguration accConfiguration)
{
try
{
if (accConfiguration == null)
{
return(false);
}
if (string.IsNullOrWhiteSpace(authToken))
{
return(false);
}
if (!(authToken.StartsWith("Bearer ") || authToken.StartsWith("Basic ")))
{
return(false);
}
if (InvitationsMemoryCache.GetInstance().GetFromMemoryCache(authToken) != null)
{
return(true);
}
else
{
lock (authTokenLock) {
if (InvitationsMemoryCache.GetInstance().GetFromMemoryCache(authToken) != null)
{
return(true);
}
var settings = new HTTPWrapper().GetSettings(authToken).GetAwaiter().GetResult();
if (string.IsNullOrWhiteSpace(settings))
{
return(false);
}
Settings settingsRes = JsonConvert.DeserializeObject <Settings>(settings);
if (!settingsRes.user.Equals(accConfiguration?.WXMAdminUser, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
InvitationsMemoryCache.GetInstance().SetToMemoryCache("settings", settings);
InvitationsMemoryCache.GetInstance().SetAuthTokenToMemoryCache(authToken);
}
return(true);
}
}
catch (Exception)
{
return(false);
}
}
public bool GetAllInfoForDispatch()
{
try
{
DispatchData = InvitationsMemoryCache.GetInstance().GetDispatchDataFromMemoryCache(FinalToken, hTTPWrapper);
DeliveryPlanData = InvitationsMemoryCache.GetInstance().GetDeliveryPlanFromMemoryCache(FinalToken, hTTPWrapper);
ActiveQuestions = InvitationsMemoryCache.GetInstance().GetActiveQuestionsFromMemoryCache(FinalToken, hTTPWrapper);
DispatchSettings = InvitationsMemoryCache.GetInstance().GetSettingsFromMemoryCache(FinalToken, hTTPWrapper);
if (DispatchData == null)
{
EventLogList.AddEventByLevel(2, SharedSettings.NoDispatchFound, BatchId);
return(false);
}
if (DeliveryPlanData == null)
{
EventLogList.AddEventByLevel(2, SharedSettings.NoDeliveryPlanFound, BatchId);
return(false);
}
if (ActiveQuestions == null)
{
EventLogList.AddEventByLevel(2, SharedSettings.NoActiveQuestionsFound, BatchId);
return(false);
}
if (DispatchSettings == null)
{
EventLogList.AddEventByLevel(2, SharedSettings.NoSettingsFound, BatchId);
return(false);
}
else
{
Settings settingsRes = JsonConvert.DeserializeObject <Settings>(DispatchSettings);
if (settingsRes.locationDataMigrated)
{
SurverQuestionnaires = InvitationsMemoryCache.GetInstance().GetQuestionnaireFromMemoryCache(FinalToken, hTTPWrapper);
if (string.IsNullOrEmpty(SurverQuestionnaires))
{
EventLogList.AddEventByLevel(2, SharedSettings.NoSurveyQuestionnaireFound, BatchId);
return(false);
}
islocationMigrated = true;
}
}
return(true);
}
catch (Exception ex)
{
EventLogList.AddExceptionEvent(ex, null, null, null, null, "Getting API details from MemoryCache failed");
return(false);
}
}
/// <summary>
/// To send async api request
/// </summary>
/// <param name="url">API url</param>
/// <param name="bearerToken">Token for authorization</param>
/// <param name="jsonBody">Json body to be send in request.</param>
/// <returns>API response</returns>
internal async Task <string> SendAsync(string url, string bearerToken, string jsonBody = null)
{
try
{
//To check whether url is not null or empty
if (string.IsNullOrEmpty(url))
{
throw new Exception("API url is either null or empty");
}
if (string.IsNullOrEmpty(bearerToken))
{
throw new Exception("Authorization Token is either null or empty");
}
//Varible declarations.
string responseBody = string.Empty;
#pragma warning disable IDE0067 // Dispose objects before losing scope
HttpClient httpClient = new HttpClient();
#pragma warning restore IDE0067 // Dispose objects before losing scope
HttpRequestMessage requestMessage;
HttpResponseMessage responseMessage;
//To check whether the request is Post or Get
if (!string.IsNullOrEmpty(jsonBody))
{
requestMessage = new HttpRequestMessage(HttpMethod.Post, url)
{
Content = new StringContent(jsonBody, Encoding.UTF8, "application/json")
};
}
else
{
requestMessage = new HttpRequestMessage(HttpMethod.Get, url);
}
requestMessage.Headers.Add("Authorization", bearerToken);
//Sending api request to CC.
responseMessage = await httpClient.SendAsync(requestMessage);
//Check whether the request is successfull.
if (responseMessage != null)
{
responseBody = await responseMessage.Content.ReadAsStringAsync();
if (responseMessage.IsSuccessStatusCode)
{
return(responseBody);
}
else if (responseMessage.StatusCode == System.Net.HttpStatusCode.Unauthorized)
{
//Throw exception in case of authorization denied
InvitationsMemoryCache.GetInstance().RemoveFromMemoryCache(bearerToken);
throw new Exception(SharedSettings.AuthorizationDenied);
}
else
{
if (_EventLogList != null)
{
_EventLogList.AddEventByLevel(2, $"StatusCode: {responseMessage.StatusCode} " +
$"ResponseMessage: {responseBody} Url: {url}", _batchID);
}
return(null);
}
}
else
{
return(null);
}
}
catch (Exception ex)
{
if (_EventLogList != null)
{
_EventLogList.AddExceptionEvent(ex, null, null, null, null, "HTTP Send failed for HTTPWrapper sendAsync");
return(null);
}
else
{
throw ex;
}
}
}
public async Task ReadQueue(CancellationToken cancellationToken)
{
EventLogList eventLog = new EventLogList();
try
{
DateTime stopTime = DateTime.Now.AddSeconds(30);
Dictionary <string, RequestBulkToken> finalBulkStorage = new
Dictionary <string, RequestBulkToken>();
while (DateTime.Now < stopTime)
{
RequestBulkToken requestBulkToken;
if (!SingletonConcurrentQueue <RequestBulkToken> .Instance.TryPeek(out requestBulkToken))
{
break;
}
else if (SingletonConcurrentQueue <RequestBulkToken> .Instance.TryDequeue(out requestBulkToken))
{
if (finalBulkStorage.ContainsKey(requestBulkToken.DispatchId))
{
finalBulkStorage[requestBulkToken.DispatchId].PrefillReponse.AddRange(requestBulkToken.PrefillReponse);
}
else
{
finalBulkStorage.Add(requestBulkToken.DispatchId, new RequestBulkToken()
{
DispatchId = requestBulkToken.DispatchId,
UUID = requestBulkToken.UUID,
Batchid = requestBulkToken.Batchid,
PrefillReponse = requestBulkToken.PrefillReponse
});
}
}
}
if (finalBulkStorage.Count != 0)
{
HTTPWrapper hTTPWrapper = new HTTPWrapper(string.Empty, eventLog);
string authToken = InvitationsMemoryCache.GetInstance().GetFromMemoryCache("AuthToken");
if (authToken == null)
{
AccountConfiguration accountConfiguration;
string accountConfigurationCache = InvitationsMemoryCache.GetInstance().GetFromMemoryCache("accountconfig");
if (accountConfigurationCache == null)
{
accountConfiguration = await viaMongoDB.GetAccountConfiguration();
}
else
{
accountConfiguration = Newtonsoft.Json.JsonConvert.DeserializeObject <AccountConfiguration>(accountConfigurationCache);
}
string username = accountConfiguration.WXMAdminUser;
string apikey = accountConfiguration.WXMAPIKey;
string responseBody = await hTTPWrapper.GetLoginToken(username, apikey);
if (!string.IsNullOrEmpty(responseBody))
{
BearerToken loginToken = Newtonsoft.Json.JsonConvert.DeserializeObject <BearerToken>(responseBody);
authToken = "Bearer " + loginToken.AccessToken;
var Expirationtime = loginToken.ExpiresIn - 300; // Expire 5 min before for uninterrupted token creation
InvitationsMemoryCache.GetInstance().SetBulkTokenAuthToMemoryCache("AuthToken", authToken, Expirationtime);
}
else
{
//when login token api failed.
eventLog.AddEventByLevel(1, SharedSettings.BearerTokenNotGenerated, null);
await eventLog.AddEventLogs(viaMongoDB);
}
}
// Calling bulk token api sequentially
if (!string.IsNullOrWhiteSpace(authToken))
{
List <(string, List <BulkTokenResult>)> status = new List <(string, List <BulkTokenResult>)>();
foreach (var request in finalBulkStorage)
{
var response = await hTTPWrapper.BulkTokenAPI(authToken, request.Value);
status.Add(response);
Thread.Sleep(1000); // Sleep for 1 second before making another call
}
/*
* var bulkTokenAPITasks = finalBulkStorage.Values.ToList().Select(v =>
* {
* return hTTPWrapper.BulkTokenAPI(authToken, v);
* });
*
* (string, List<BulkTokenResult>)[] status = await Task.WhenAll(bulkTokenAPITasks);
*
*/
Dictionary <LogEvent, InvitationLogEvent> events = new Dictionary <LogEvent, InvitationLogEvent>();
DateTime utcNow = DateTime.UtcNow;
//Update tokens in DB
foreach (var item in status)
{
if (item.Item2 != null)
{
foreach (var perinvite in item.Item2)
{
var logEvent = new LogEvent()
{
DispatchId = item.Item1,
BatchId = perinvite.Batchid,
Updated = utcNow,
TokenId = perinvite.Token,
TargetHashed = perinvite.UUID
};
var invitationEvent = new InvitationLogEvent()
{
Action = InvitationLogEvent.EventAction.TokenCreated,
Channel = InvitationLogEvent.EventChannel.DispatchAPI,
TimeStamp = utcNow,
TargetId = perinvite.UUID
};
events.Add(logEvent, invitationEvent);
}
}
}
if (events.Count() > 0)
{
await viaMongoDB.UpdateBulkEventLog(events);
}
eventLog.AddEventByLevel(5, $"{SharedSettings.DBUpdateCompleted} {events.Count()}", null);
await eventLog.AddEventLogs(viaMongoDB);
}
}
}
catch (Exception ex)
{
eventLog.AddExceptionEvent(ex, null, null, null, null, SharedSettings.BulkTokenException);
await eventLog.AddEventLogs(viaMongoDB);
return;
}
}