public async Task <UserClaimDTO> AcquireUserClaim(string identityServerIp, string token)
{
HttpRequestEntity httpRequestEntity = new HttpRequestEntity()
{
Method = Enums.HttpMethod.GET
};
HttpResponseEntity responseEntity = HttpHelper.Get(identityServerIp + "/connect/userinfo", httpRequestEntity, token);
return(await Task.FromResult(JsonHelper.Deserialize <UserClaimDTO>(responseEntity.Bodys.ToString())));
}
public static async void ProcessClicksForGeo(
[QueueTrigger(QueueNames.ProcessClicksGeo)] string queuedHttpRequestString,
[Table(TableNames.Redirects)] CloudTable redirectTable,
[Table(TableNames.Domains)] CloudTable domainTable,
[Table(TableNames.Geos)] CloudTable geoTable,
ILogger log,
ExecutionContext context)
{
HttpRequestEntity queuedHttpRequest = JsonConvert.DeserializeObject <HttpRequestEntity>(queuedHttpRequestString);
var config = new ConfigurationBuilder()
.SetBasePath(context.FunctionAppDirectory)
.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
string ipLookupUrl = $"{config["FREEGEOIP_HOST"] ??= "https://freegeoip.app"}/json/{queuedHttpRequest.RemoteIpAddress}";
log.LogInformation($"Looking up freegeoip: {ipLookupUrl}.");
var client = new HttpClient();
var getResponse = await client.GetAsync(ipLookupUrl);
if (getResponse.StatusCode == HttpStatusCode.OK)
{
List <DomainEntity> domains = await DomainEntity.get(domainTable, queuedHttpRequest.Host);
if (domains == null)
{
throw new Exception($"Unable to process Geo lookup - domain {queuedHttpRequest.Host} wasn't found");
}
string path = queuedHttpRequest.Path.Value.Substring(1);
RedirectEntity redirect = await RedirectEntity.get(redirectTable, domains.First().Account, path);
if (redirect != null)
{
string ipResponseString = await getResponse.Content.ReadAsStringAsync();
dynamic ipResponse = JsonConvert.DeserializeObject <dynamic>(ipResponseString);
GeoEntity geoEntity = new GeoEntity(ipResponse);
await GeoEntity.put(geoTable, geoEntity);
Dictionary <string, int> _geoCount = JsonConvert.DeserializeObject <Dictionary <string, int> >(redirect.GeoCount ??= "{}");
if (_geoCount.ContainsKey(geoEntity.RowKey))
{
log.LogInformation($"Incrementing GeoCount for redirect entity {queuedHttpRequest.Path}");
_geoCount[geoEntity.RowKey] = _geoCount[geoEntity.RowKey] + 1;
}
else
{
log.LogInformation($"Creating GeoCount for redirect entity {queuedHttpRequest.Path}");
_geoCount.Add(geoEntity.RowKey, 1);
}
redirect.GeoCount = JsonConvert.SerializeObject(_geoCount);
await RedirectEntity.put(redirectTable, redirect);
return;
}
log.LogError($"Http request {queuedHttpRequest.Path} for click handling doesn't match handled path");
throw new System.Exception($"Http request {queuedHttpRequest.Path} for click handling doesn't match handled path");
}
log.LogError($"Free geo ip lookup for IP {queuedHttpRequest.RemoteIpAddress} failed with status code {getResponse.StatusCode}");
throw new System.Exception($"Free geo ip lookup for IP {queuedHttpRequest.RemoteIpAddress} failed with status code {getResponse.StatusCode}");
}
public static async void ProcessRedirectClicksForGeo(
[QueueTrigger(QueueNames.ProcessRedirectClicksForGeo)] string queuedHttpRequestString,
[Table(TableNames.RedirectSessions)] CloudTable redirectTable,
ILogger log,
ExecutionContext context)
{
HttpRequestEntity queuedHttpRequest = JsonConvert.DeserializeObject <HttpRequestEntity>(queuedHttpRequestString);
var config = new ConfigurationBuilder()
.SetBasePath(context.FunctionAppDirectory)
.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
string ipLookupUrl = $"{config["FREEGEOIP_HOST"] ??= "https://freegeoip.app"}/json/{queuedHttpRequest.RemoteIpAddress}";
log.LogInformation($"Looking up freegeoip: {ipLookupUrl}.");
var client = new HttpClient();
var getResponse = await client.GetAsync(ipLookupUrl);
if (getResponse.StatusCode == HttpStatusCode.OK)
{
MatchCollection matches = Regex.Matches(queuedHttpRequest.Path, "/redirect/session/(\\d+)/", RegexOptions.IgnoreCase);
if (matches.Count > 0)
{
string ipResponseString = await getResponse.Content.ReadAsStringAsync();
dynamic ipResponse = JsonConvert.DeserializeObject(ipResponseString);
GeoEntity geoEntity = new GeoEntity(ipResponse);
string geoEntityString = JsonConvert.SerializeObject(geoEntity);
RedirectEntity redirectEntity = await RedirectEntity.get(redirectTable, matches[0].Groups[1].Value);
if (redirectEntity != null)
{
if (redirectEntity.GeoCount == null)
{
log.LogInformation($"Adding GeoCount property to redirect entity {queuedHttpRequest.Path}");
// redirectEntity.GeoCount = new Dictionary<string, int>();
}
Dictionary <string, int> _geoCount = JsonConvert.DeserializeObject <Dictionary <string, int> >(redirectEntity.GeoCount ??= "{}");
if (_geoCount.ContainsKey(geoEntityString))
{
log.LogInformation($"Incrementing GeoCount for redirect entity {queuedHttpRequest.Path}");
_geoCount[geoEntityString] = _geoCount[geoEntityString] + 1;
}
else
{
log.LogInformation($"Creating GeoCount for redirect entity {queuedHttpRequest.Path}");
_geoCount.Add(geoEntityString, 1);
}
log.LogInformation($" GeoCount property value: {JsonConvert.SerializeObject(redirectEntity.GeoCount)}");
await RedirectEntity.put(redirectTable, redirectEntity.RowKey, redirectEntity.RedirectTo, redirectEntity.VideoLink, redirectEntity.StartRedirectingMinutes ??= 0, redirectEntity.ClickCount, redirectEntity.CalendarClickCount, redirectEntity.VideoClickCount, JsonConvert.SerializeObject(_geoCount), redirectEntity.CalendarGeoCount, redirectEntity.VideoGeoCount);
log.LogInformation($"Successfully processed geo ip click for redirect query {queuedHttpRequest.Path} from {queuedHttpRequest.RemoteIpAddress}");
return;
}
else
{
log.LogError($"Http request {queuedHttpRequest.Path} for click geo handling failed to match a redirect session");
throw new System.Exception($"Http request {queuedHttpRequest.Path} for click geo handling failed to match a redirect session");
}
}
MatchCollection calendarMatches = Regex.Matches(queuedHttpRequest.Path, "/calendar/session/(\\d+)", RegexOptions.IgnoreCase);
if (calendarMatches.Count > 0)
{
string ipResponseString = await getResponse.Content.ReadAsStringAsync();
dynamic ipResponse = JsonConvert.DeserializeObject(ipResponseString);
GeoEntity geoEntity = new GeoEntity(ipResponse);
string geoEntityString = JsonConvert.SerializeObject(geoEntity);
RedirectEntity redirectEntity = await RedirectEntity.get(redirectTable, calendarMatches[0].Groups[1].Value);
if (redirectEntity != null)
{
Dictionary <string, int> _calendarGeoCount = JsonConvert.DeserializeObject <Dictionary <string, int> >(redirectEntity.CalendarGeoCount ??= "{}");
if (_calendarGeoCount.ContainsKey(geoEntityString))
{
log.LogInformation($"Incrementing CalendarGeoCount for redirect entity {queuedHttpRequest.Path}");
_calendarGeoCount[geoEntityString] = _calendarGeoCount[geoEntityString] + 1;
}
else
{
log.LogInformation($"Creating CalendarGeoCount for redirect entity {queuedHttpRequest.Path}");
_calendarGeoCount.Add(geoEntityString, 1);
}
log.LogInformation($" CalendarGeoCount property value: {JsonConvert.SerializeObject(redirectEntity.GeoCount)}");
await RedirectEntity.put(redirectTable, redirectEntity.RowKey, redirectEntity.RedirectTo, redirectEntity.VideoLink, redirectEntity.StartRedirectingMinutes ??= 0, redirectEntity.ClickCount, redirectEntity.CalendarClickCount, redirectEntity.VideoClickCount, redirectEntity.GeoCount, JsonConvert.SerializeObject(_calendarGeoCount), redirectEntity.VideoGeoCount);
log.LogInformation($"Successfully processed calendar geo ip click for redirect query {queuedHttpRequest.Path} from {queuedHttpRequest.RemoteIpAddress}");
return;
}
else
{
log.LogError($"Http request {queuedHttpRequest.Path} for click geo handling failed to match a redirect session");
throw new System.Exception($"Http request {queuedHttpRequest.Path} for click geo handling failed to match a redirect session");
}
}
MatchCollection videoMatches = Regex.Matches(queuedHttpRequest.Path, "/redirect/video/(\\d+)/", RegexOptions.IgnoreCase);
if (videoMatches.Count > 0)
{
string ipResponseString = await getResponse.Content.ReadAsStringAsync();
dynamic ipResponse = JsonConvert.DeserializeObject(ipResponseString);
GeoEntity geoEntity = new GeoEntity(ipResponse);
string geoEntityString = JsonConvert.SerializeObject(geoEntity);
RedirectEntity redirectEntity = await RedirectEntity.get(redirectTable, videoMatches[0].Groups[1].Value);
if (redirectEntity != null)
{
Dictionary <string, int> _videoGeoCount = JsonConvert.DeserializeObject <Dictionary <string, int> >(redirectEntity.VideoGeoCount ??= "{}");
if (_videoGeoCount.ContainsKey(geoEntityString))
{
log.LogInformation($"Incrementing VideoGeoCount for redirect entity {queuedHttpRequest.Path}");
_videoGeoCount[geoEntityString] = _videoGeoCount[geoEntityString] + 1;
}
else
{
log.LogInformation($"Creating VideoGeoCount for redirect entity {queuedHttpRequest.Path}");
_videoGeoCount.Add(geoEntityString, 1);
}
log.LogInformation($" VideoGeoCount property value: {JsonConvert.SerializeObject(redirectEntity.GeoCount)}");
await RedirectEntity.put(redirectTable, redirectEntity.RowKey, redirectEntity.RedirectTo, redirectEntity.VideoLink, redirectEntity.StartRedirectingMinutes ??= 0, redirectEntity.ClickCount, redirectEntity.CalendarClickCount, redirectEntity.VideoClickCount, redirectEntity.GeoCount, redirectEntity.CalendarGeoCount, JsonConvert.SerializeObject(_videoGeoCount));
log.LogInformation($"Successfully processed video geo ip click for redirect query {queuedHttpRequest.Path} from {queuedHttpRequest.RemoteIpAddress}");
return;
}
else
{
log.LogError($"Http request {queuedHttpRequest.Path} for click geo handling failed to match a redirect session");
throw new System.Exception($"Http request {queuedHttpRequest.Path} for click geo handling failed to match a redirect session");
}
}
log.LogError($"Http request {queuedHttpRequest.Path} for click handling doesn't match handled paths");
throw new System.Exception($"Http request {queuedHttpRequest.Path} for click handling doesn't match handled paths");
}
log.LogError($"Free geo ip lookup for IP {queuedHttpRequest.RemoteIpAddress} failed with status code {getResponse.StatusCode}");
throw new System.Exception($"Free geo ip lookup for IP {queuedHttpRequest.RemoteIpAddress} failed with status code {getResponse.StatusCode}");
}
public static async void ProcessRedirectClicks(
[QueueTrigger(QueueNames.ProcessRedirectClicks)] string queuedHttpRequestString,
[Table(TableNames.RedirectSessions)] CloudTable redirectTable,
[Queue(QueueNames.ProcessRedirectClicksForGeo), StorageAccount("AzureWebJobsStorage")] ICollector <HttpRequestEntity> processRedirectQueueForGeo,
ILogger log,
ExecutionContext context)
{
HttpRequestEntity queuedHttpRequest = JsonConvert.DeserializeObject <HttpRequestEntity>(queuedHttpRequestString);
var config = new ConfigurationBuilder()
.SetBasePath(context.FunctionAppDirectory)
.AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables()
.Build();
string nodeMaster = config["NODE_SYNC_MASTER_CONN"];
if (nodeMaster != null)
{
try {
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(nodeMaster);
CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
CloudQueue destinationProcessClicksQueue = queueClient.GetQueueReference(QueueNames.ProcessRedirectClicks);
await destinationProcessClicksQueue.AddMessageAsync(new CloudQueueMessage(queuedHttpRequestString));
}
catch (Exception ex) {
log.LogError(ex.Message);
throw ex;
}
return;
}
MatchCollection matches = Regex.Matches(queuedHttpRequest.Path, "/redirect/session/(\\d+)/", RegexOptions.IgnoreCase);
if (matches.Count > 0)
{
RedirectEntity redirectEntity = await RedirectEntity.get(redirectTable, matches[0].Groups[1].Value);
if (redirectEntity != null)
{
redirectEntity.ClickCount++;
await RedirectEntity.put(redirectTable, redirectEntity.RowKey, redirectEntity.RedirectTo, redirectEntity.VideoLink, redirectEntity.StartRedirectingMinutes ??= 0, redirectEntity.ClickCount, redirectEntity.CalendarClickCount, redirectEntity.VideoClickCount, redirectEntity.GeoCount, redirectEntity.CalendarGeoCount, redirectEntity.VideoGeoCount);
processRedirectQueueForGeo.Add(queuedHttpRequest);
log.LogInformation($"Successfully processed click for redirect query {queuedHttpRequest.Path} from {queuedHttpRequest.RemoteIpAddress}");
return;
}
else
{
log.LogError($"Http request {queuedHttpRequest.Path} for click handling failed to match a redirect session");
throw new System.Exception($"Http request {queuedHttpRequest.Path} for click handling doesn't match handled paths");
}
}
MatchCollection sessionMatches = Regex.Matches(queuedHttpRequest.Path, "/calendar/session/(\\d+)", RegexOptions.IgnoreCase);
if (sessionMatches.Count > 0)
{
RedirectEntity redirectEntity = await RedirectEntity.get(redirectTable, sessionMatches[0].Groups[1].Value);
if (redirectEntity != null)
{
redirectEntity.CalendarClickCount++;
await RedirectEntity.put(redirectTable, redirectEntity.RowKey, redirectEntity.RedirectTo, redirectEntity.VideoLink, redirectEntity.StartRedirectingMinutes ??= 0, redirectEntity.ClickCount, redirectEntity.CalendarClickCount, redirectEntity.VideoClickCount, redirectEntity.GeoCount, redirectEntity.CalendarGeoCount, redirectEntity.VideoGeoCount);
processRedirectQueueForGeo.Add(queuedHttpRequest);
log.LogInformation($"Successfully processed click for redirect query {queuedHttpRequest.Path} from {queuedHttpRequest.RemoteIpAddress}");
return;
}
else
{
log.LogError($"Http request {queuedHttpRequest.Path} for click handling failed to match a redirect session");
throw new System.Exception($"Http request {queuedHttpRequest.Path} for click handling failed to match a redirect session");
}
}
MatchCollection videoMatches = Regex.Matches(queuedHttpRequest.Path, "/redirect/video/(\\d+)/", RegexOptions.IgnoreCase);
if (videoMatches.Count > 0)
{
RedirectEntity redirectEntity = await RedirectEntity.get(redirectTable, videoMatches[0].Groups[1].Value);
if (redirectEntity != null)
{
redirectEntity.VideoClickCount++;
await RedirectEntity.put(redirectTable, redirectEntity.RowKey, redirectEntity.RedirectTo, redirectEntity.VideoLink, redirectEntity.StartRedirectingMinutes ??= 0, redirectEntity.ClickCount, redirectEntity.CalendarClickCount, redirectEntity.VideoClickCount, redirectEntity.GeoCount, redirectEntity.CalendarGeoCount, redirectEntity.VideoGeoCount);
processRedirectQueueForGeo.Add(queuedHttpRequest);
log.LogInformation($"Successfully processed click for redirect query {queuedHttpRequest.Path} from {queuedHttpRequest.RemoteIpAddress}");
return;
}
else
{
log.LogError($"Http request {queuedHttpRequest.Path} for click handling failed to match a redirect session");
throw new System.Exception($"Http request {queuedHttpRequest.Path} for click handling failed to match a redirect session");
}
}
log.LogError($"Http request {queuedHttpRequest.Path} for click handling doesn't match handled paths");
throw new System.Exception($"Http request {queuedHttpRequest.Path} for click handling doesn't match handled paths");
}
public object Hello(HttpRequestEntity request)
{
request.Response.Content = "Hello World!";
return(null);
}
public object Post(HttpRequestEntity request)
{
request.Response.Content = "OK";
return(null);
}
public void Account(HttpRequestEntity request, string name, int age)
{
request.Response.Content = $"Welcome {name}! Your Age is {age}";
}
/// <summary>
/// Creates a Stump data entity from a Stump contract.
/// </summary>
/// <param name="contract">The <see cref="StumpContract"/> used to create the entity.</param>
/// <returns>
/// A <see cref="StumpEntity"/> created from the specified <paramref name="contract"/>.
/// </returns>
public static StumpEntity CreateEntityFromContract(StumpContract contract)
{
var originalRequest = new HttpRequestEntity
{
BodyResourceName = string.Empty,
Headers = CreateNameValuePairFromHeaders(contract.OriginalRequest.Headers),
HttpMethod = contract.OriginalRequest.HttpMethod,
LocalEndPoint = contract.OriginalRequest.LocalEndPoint.ToString(),
ProtocolVersion = contract.OriginalRequest.ProtocolVersion,
RawUrl = contract.OriginalRequest.RawUrl,
RemoteEndPoint = contract.OriginalRequest.RemoteEndPoint.ToString()
};
var originalResponse = new HttpResponseEntity
{
BodyResourceName = string.Empty,
Headers = CreateNameValuePairFromHeaders(contract.OriginalResponse.Headers),
RedirectAddress = contract.OriginalResponse.RedirectAddress,
ResponseDelay = contract.OriginalResponse.ResponseDelay,
StatusCode = contract.OriginalResponse.StatusCode,
StatusDescription = contract.OriginalResponse.StatusDescription,
TerminateConnection = contract.OriginalResponse.TerminateConnection
};
var response = new HttpResponseEntity
{
BodyResourceName = string.Empty,
Headers = CreateNameValuePairFromHeaders(contract.Response.Headers),
RedirectAddress = contract.Response.RedirectAddress,
ResponseDelay = contract.Response.ResponseDelay,
StatusCode = contract.Response.StatusCode,
StatusDescription = contract.Response.StatusDescription,
TerminateConnection = contract.Response.TerminateConnection
};
var entity = new StumpEntity
{
OriginalRequest = originalRequest,
OriginalResponse = originalResponse,
Response = response,
Rules = new List <RuleEntity>(),
StumpCategory = contract.StumpCategory,
StumpId = contract.StumpId,
StumpName = contract.StumpName,
};
foreach (var rule in contract.Rules)
{
var ruleEntity = new RuleEntity
{
RuleName = rule.RuleName,
Settings = new List <NameValuePairEntity>()
};
var settings = rule.GetRuleSettings();
foreach (var setting in settings)
{
ruleEntity.Settings.Add(
new NameValuePairEntity
{
Name = setting.Name,
Value = setting.Value
});
}
entity.Rules.Add(ruleEntity);
}
return(entity);
}
