public void ToAlphanumeric_WithDecimal_ShouldMatchIdEncoderResult(decimal id)
{
var expectedResult = IdEncoder.GetAlphanumeric(id);
var result = id.ToAlphanumeric();
Assert.Equal(expectedResult, result);
}
public void GetAlphanumeric_Regularly_ShouldReturnSameResultAsForUlong(long id)
{
var expectedResult = IdEncoder.GetAlphanumeric((ulong)id);
var result = IdEncoder.GetAlphanumeric(id);
Assert.Equal(expectedResult, result);
}
[InlineData("1234567890_")] // Invalid char
public void GetLongOrDefault_Regularly_ShouldReturnSameResultAsTryGetLong(string input)
{
var expectedResult = IdEncoder.TryGetLong(input, out var expectedId)
? expectedId
: (long?)null;
var result = IdEncoder.GetLongOrDefault(input);
Assert.Equal(expectedResult, result);
}
[InlineData("1234567890_")] // Invalid char
public void TryGetLong_Regularly_ShouldReturnSameResultAsTryGetUlong(string input)
{
var expectedSuccess = IdEncoder.TryGetUlong(input, out var expectedResult);
var success = IdEncoder.TryGetLong(input, out var result);
Assert.Equal(expectedSuccess, success);
Assert.True(result >= 0L);
Assert.Equal(expectedResult, (ulong)result);
}
public void ToAlphanumeric_WithUlongAndByteOutput_ShouldMatchIdEncoderResult(ulong id)
{
Span <byte> expectedOutput = stackalloc byte[11];
IdEncoder.GetAlphanumeric(id, expectedOutput);
Span <byte> output = stackalloc byte[11];
id.ToAlphanumeric(output);
Assert.True(output.SequenceEqual(expectedOutput));
}
public void Encode_Decode_Results_Consistent()
{
int before = 8645;
int after = IdEncoder.Decode(IdEncoder.Encode(before));
Assert.AreEqual(before, after);
before = int.MaxValue;
after = IdEncoder.Decode(IdEncoder.Encode(before));
Assert.AreEqual(before, after);
}
public string ResolveUrlIdentifier(string urlShort)
{
var id = IdEncoder.Decode(urlShort);
var urlEntity = (from u in repository.Urls
where u.Id == id
select u
).FirstOrDefault();
if (urlEntity == null)
{
throw new Exception("Id not found");
}
return(urlEntity.Value);
}
[InlineData("1234567890_")] // Invalid char
public void GetLongOrDefault_WithByteInput_ShouldReturnSameResultAsWithStringInput(string inputString)
{
var expectedResult = IdEncoder.GetLongOrDefault(inputString);
Span <byte> input = stackalloc byte[inputString.Length];
for (var i = 0; i < input.Length; i++)
{
input[i] = (byte)inputString[i];
}
var result = IdEncoder.GetLongOrDefault(input);
Assert.Equal(expectedResult, result);
}
private static bool[] CheckIfThrowsForAllEncodings(ulong id, byte[] bytes)
{
Span <char> chars = stackalloc char[bytes.Length];
for (var i = 0; i < chars.Length; i++)
{
chars[i] = (char)bytes[i];
}
return(new[]
{
Throws(() => IdEncoder.GetAlphanumeric(id, bytes)),
Throws(() => IdEncoder.GetAlphanumeric(id)),
});
}
public void GetAlphanumeric_WithByteOutput_ShouldReturnSameResultAsWithStringOutput(long id)
{
Span <byte> expectedResult = stackalloc byte[11];
var expectedResultString = IdEncoder.GetAlphanumeric(id);
for (var i = 0; i < expectedResult.Length; i++)
{
expectedResult[i] = (byte)expectedResultString[i];
}
Span <byte> result = stackalloc byte[11];
IdEncoder.GetAlphanumeric(id, result);
Assert.True(result.SequenceEqual(expectedResult));
}
[InlineData("1234567890_")] // Invalid char
public void TryGetLong_WithByteInput_ShouldReturnSameResultAsWithStringInput(string inputString)
{
var expectedSuccess = IdEncoder.TryGetLong(inputString, out var expectedResult);
Span <byte> input = stackalloc byte[inputString.Length];
for (var i = 0; i < input.Length; i++)
{
input[i] = (byte)inputString[i];
}
var success = IdEncoder.TryGetLong(input, out var result);
Assert.Equal(expectedSuccess, success);
Assert.Equal(expectedResult, result);
}
public string CreateUrlIdentifier(string url)
{
var urlEntity = (from u in repository.Urls
where u.Value == url
select u
).FirstOrDefault();
if (urlEntity == null)
{
urlEntity = new Url()
{
Value = url
};
repository.InsertUrl(urlEntity);
}
return(IdEncoder.Encode(urlEntity.Id));
}
public void UpdateUrlStatistics(string encodedId, System.Collections.Specialized.NameValueCollection nameValueCollection)
{
repository.IncreaseUrlHitCount(IdEncoder.Decode(encodedId));
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = "push")]
HttpRequestMessage req,
TraceWriter log,
CancellationToken ct)
{
try
{
var verifyCode = req
.GetQueryNameValuePairs()
.FirstOrDefault(q => q.Key.Equals("verify", StringComparison.Ordinal))
.Value;
if (verifyCode.HasValue())
{
return(verifyCode.Equals(Constants.FitbitVerificationCode, StringComparison.Ordinal)
? new HttpResponseMessage(HttpStatusCode.NoContent)
: new HttpResponseMessage(HttpStatusCode.NotFound));
}
var notificationsContent = await req.Content.ReadAsStringAsync();
var notifications = JsonConvert.DeserializeObject <Notification[]>(notificationsContent);
var notificationsForwarding = notifications
.GroupBy(notif => notif.SubscriptionId?.Substring(1), StringComparer.Ordinal)
.Select(notifs =>
{
string accessToken, locationId;
var parts = notifs.Key?.Split(new[] { '~' }, StringSplitOptions.RemoveEmptyEntries) ?? new string[0];
if (parts.Length == 2)
{
try
{
accessToken = IdEncoder.Decode(parts[0]).ToString("D");
locationId = IdEncoder.Decode(parts[1]).ToString("D");
}
catch (Exception e)
{
log.Error($"Invalid subscription id: {notifs.Key}", e);
accessToken = locationId = null;
}
}
else
{
log.Error("Invalid number of parts, don't forward the notifications.");
accessToken = locationId = null;
}
return(new { accessToken, locationId, notifs });
})
.Where(x => x.accessToken.HasValue() && x.locationId.HasValue())
.Select(x => Send(ct, log, x.accessToken, x.locationId, x.notifs));
// TODO: Run async
await Task.WhenAll(notificationsForwarding);
return(req.CreateResponse(HttpStatusCode.NoContent));
}
catch (Exception e)
{
log.Error("Failed", e);
throw;
}
}
