protected EventActivityTrackTests(ActivityDrilldown drilldown)
{
EventActivity = new EventActivity(
new ActivitySettings(1, drilldown));
EventActivity.Reset().Wait();
EventActivity.Track(EventName, Timestamp).Wait();
}
public virtual async Task Track(
string eventName,
ActivityDrilldown drilldown,
DateTime timestamp,
bool publishable,
params long[] users)
{
Validation.ValidateEventName(eventName);
Validation.ValidateUsers(users);
string channel = null;
byte[] payload = null;
var timeframeKeys = GenerateEventTimeframeKeys(
eventName,
drilldown,
timestamp).ToList();
var eventsKey = GenerateKey();
var db = Settings.Db;
var tasks = new List <Task>();
if (publishable)
{
channel = eventsKey +
Settings.KeySeparator +
eventName.ToUpperInvariant();
payload = new UserActivitySubscriptionInfo
{
EventName = eventName,
Timestamp = timestamp,
Users = users
}.Serialize();
}
using (var connection = await ConnectionFactories.Open())
{
foreach (var timeframeKey in timeframeKeys)
{
tasks.AddRange(users.Select(user =>
connection.Strings.SetBit(
db,
timeframeKey,
user,
true)));
}
tasks.Add(connection.Sets.Add(db, eventsKey, eventName));
await Task.WhenAll(tasks);
if (publishable)
{
await connection.Publish(channel, payload);
}
}
}
protected UserActivityTrackTests(ActivityDrilldown drilldown)
{
UserActivity = new UserActivity(
new ActivitySettings(1, drilldown));
UserActivity.Reset().Wait();
UserActivity.Track(EventName, Timestamp, 1, 2, 3).Wait();
}
public virtual async Task <long[]> Counts(
string eventName,
DateTime startTimestamp,
DateTime endTimestamp,
ActivityDrilldown drilldown)
{
Validation.ValidateEventName(eventName);
var dates = startTimestamp.Range(endTimestamp, drilldown);
var key = GenerateKey(eventName, drilldown.ToString());
var fields = dates.Select(d =>
GenerateTimeframeFields(drilldown, d)
.ElementAt((int)drilldown))
.ToArray();
string[] values;
using (var connection = await ConnectionFactories.Open())
{
values = await connection.Hashes.GetString(
Settings.Db,
key,
fields);
}
var result = values.Select(v =>
string.IsNullOrWhiteSpace(v) ? 0L : long.Parse(v))
.ToArray();
return(result);
}
protected UserActivityTrackTests(ActivityDrilldown drilldown)
{
UserActivity = new UserActivity(
new ActivitySettings(1, drilldown));
UserActivity.Reset().Wait();
UserActivity.Track(EventName, Timestamp, 1, 2, 3).Wait();
}
protected EventActivityTrackTests(ActivityDrilldown drilldown)
{
EventActivity = new EventActivity(
new ActivitySettings(1, drilldown));
EventActivity.Reset().Wait();
EventActivity.Track(EventName, Timestamp).Wait();
}
public ActivitySettings(ActivityDrilldown drilldown)
: this(
DefaultDb,
drilldown,
DefaultKeyPrefix,
DefaultKeySeparator)
{
}
public ActivitySettings(ActivityDrilldown drilldown)
: this(
DefaultDb,
drilldown,
DefaultKeyPrefix,
DefaultKeySeparator)
{
}
private static void Test(
int interval,
Func <int, DateTime> func,
ActivityDrilldown drilldown)
{
Assert.Equal(
Math.Abs(interval) + 1,
Now.Range(func(interval), drilldown).Count());
}
public virtual UserActivityReport Report(
string eventName,
ActivityDrilldown drilldown,
DateTime timestamp)
{
Validation.ValidateEventName(eventName);
var eventKey = GenerateEventTimeframeKeys(
eventName, drilldown, timestamp).ElementAt((int)drilldown);
return(new UserActivityReport(Settings.Db, eventKey));
}
public ActivitySettings(
int db,
ActivityDrilldown drilldown,
string keyPrefix,
string keySeparator)
{
Validation.ValidateDb(db);
Db = db;
Drilldown = drilldown;
KeyPrefix = keyPrefix ?? string.Empty;
KeySeparator = keySeparator ?? string.Empty;
}
public ActivitySettings(
int db,
ActivityDrilldown drilldown,
string keyPrefix,
string keySeparator)
{
Validation.ValidateDb(db);
Db = db;
Drilldown = drilldown;
KeyPrefix = keyPrefix ?? string.Empty;
KeySeparator = keySeparator ?? string.Empty;
}
public virtual async Task <long> Track(
string eventName,
ActivityDrilldown drilldown,
DateTime timestamp,
bool publishable)
{
Validation.ValidateEventName(eventName);
var key = GenerateKey(eventName, drilldown.ToString());
var eventsKey = GenerateKey();
var fields = GenerateTimeframeFields(drilldown, timestamp).ToList();
var db = Settings.Db;
using (var connection = await ConnectionFactories.Open())
{
await connection.Sets.Add(db, eventsKey, eventName);
var tasks = fields
.Select(field => connection.Hashes
.Increment(db, key, field))
.ToList();
var counts = await Task.WhenAll(tasks);
var count = counts.ElementAt((int)drilldown);
if (!publishable)
{
return(count);
}
var channel = eventsKey +
Settings.KeySeparator +
eventName.ToUpperInvariant();
var payload = new EventActivitySubscriptionInfo
{
EventName = eventName,
Timestamp = timestamp,
Drilldown = drilldown,
Count = counts.ElementAt((int)drilldown)
}.Serialize();
await connection.Publish(channel, payload);
return(count);
}
}
protected async Task TestExists(ActivityDrilldown drilldown)
{
var key = UserActivity.GenerateEventTimeframeKeys(
EventName,
drilldown,
Timestamp)
.ElementAt((int)drilldown);
using (var connection = await ConnectionFactories.Open())
{
var result = await connection.Strings.Get(
UserActivity.Settings.Db,
key);
Assert.NotNull(result);
}
}
protected async Task TestExists(ActivityDrilldown drilldown)
{
var key = UserActivity.GenerateEventTimeframeKeys(
EventName,
drilldown,
Timestamp)
.ElementAt((int)drilldown);
using (var connection = await ConnectionFactories.Open())
{
var result = await connection.Strings.Get(
UserActivity.Settings.Db,
key);
Assert.NotNull(result);
}
}
public void DayRange()
{
const ActivityDrilldown Drilldown = ActivityDrilldown.Day;
Func <int, DateTime> func = n => Now.AddDays(n);
// Positive
Test(27, func, Drilldown);
Test(7, func, Drilldown);
Test(143, func, Drilldown);
// Negative
Test(-27, func, Drilldown);
Test(-7, func, Drilldown);
Test(-143, func, Drilldown);
// Same
Test(0, func, Drilldown);
}
public void HourRange()
{
const ActivityDrilldown Drilldown = ActivityDrilldown.Hour;
Func <int, DateTime> func = n => Now.AddHours(n);
// Positive
Test(12, func, Drilldown);
Test(3, func, Drilldown);
Test(56, func, Drilldown);
// Negative
Test(-12, func, Drilldown);
Test(-3, func, Drilldown);
Test(-56, func, Drilldown);
// Same
Test(0, func, Drilldown);
}
public void MonthRange()
{
const ActivityDrilldown Drilldown = ActivityDrilldown.Month;
Func <int, DateTime> func = n => Now.AddMonths(n);
// Positive
Test(13, func, Drilldown);
Test(2, func, Drilldown);
Test(23, func, Drilldown);
// Negative
Test(-13, func, Drilldown);
Test(-2, func, Drilldown);
Test(-23, func, Drilldown);
// Same
Test(0, func, Drilldown);
}
protected async Task TestExists(ActivityDrilldown drilldown)
{
var key = EventActivity.GenerateKey(
EventName,
EventActivity.Settings.Drilldown.ToString());
var field = EventActivity.GenerateTimeframeFields(
drilldown,
Timestamp)
.ElementAt((int)drilldown);
using (var connection = await ConnectionFactories.Open())
{
var result = await connection.Hashes
.Exists(EventActivity.Settings.Db, key, field);
Assert.True(result);
}
}
protected async Task TestExists(ActivityDrilldown drilldown)
{
var key = EventActivity.GenerateKey(
EventName,
EventActivity.Settings.Drilldown.ToString());
var field = EventActivity.GenerateTimeframeFields(
drilldown,
Timestamp)
.ElementAt((int)drilldown);
using (var connection = await ConnectionFactories.Open())
{
var result = await connection.Hashes
.Exists(EventActivity.Settings.Db, key, field);
Assert.True(result);
}
}
public static async Task <long> Count(
this IEventActivity instance,
string eventName,
DateTime startTimestamp,
DateTime endTimestamp,
ActivityDrilldown drilldown)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
var result = await instance.Counts(
eventName,
startTimestamp,
endTimestamp,
drilldown);
return(result.First());
}
public void YearRange()
{
const ActivityDrilldown Drilldown = ActivityDrilldown.Year;
Func <int, DateTime> func = n => Now.AddYears(n);
// Positive
Test(2, func, Drilldown);
Test(7, func, Drilldown);
Test(11, func, Drilldown);
Assert.Equal(2, Now.Range(func(1), Drilldown).Count());
Assert.Equal(7, Now.Range(func(6), Drilldown).Count());
Assert.Equal(11, Now.Range(func(10), Drilldown).Count());
// Negative
Test(-2, func, Drilldown);
Test(-7, func, Drilldown);
Test(-11, func, Drilldown);
// Same
Test(0, func, Drilldown);
}
protected EventActivityDayTrackTests(
ActivityDrilldown drilldown)
: base(drilldown)
{
}
private static void Test(
int interval,
Func<int, DateTime> func,
ActivityDrilldown drilldown)
{
Assert.Equal(
Math.Abs(interval) + 1,
Now.Range(func(interval), drilldown).Count());
}
internal IEnumerable <string> GenerateTimeframeFields(
ActivityDrilldown drilldown,
DateTime timestamp)
{
yield return(timestamp.FormatYear());
var separator = Settings.KeySeparator;
var type = (int)drilldown;
if (type > (int)ActivityDrilldown.Year)
{
yield return(timestamp.FormatYear() +
separator +
timestamp.FormatMonth());
}
if (type > (int)ActivityDrilldown.Month)
{
yield return(timestamp.FormatYear() +
separator +
timestamp.FormatMonth() +
separator +
timestamp.FormatDay());
}
if (type > (int)ActivityDrilldown.Day)
{
yield return(timestamp.FormatYear() +
separator +
timestamp.FormatMonth() +
separator +
timestamp.FormatDay() +
separator +
timestamp.FormatHour());
}
if (type > (int)ActivityDrilldown.Hour)
{
yield return(timestamp.FormatYear() +
separator +
timestamp.FormatMonth() +
separator +
timestamp.FormatDay() +
separator +
timestamp.FormatHour() +
separator +
timestamp.FormatMinute());
}
if (type > (int)ActivityDrilldown.Minute)
{
yield return(timestamp.FormatYear() +
separator +
timestamp.FormatMonth() +
separator +
timestamp.FormatDay() +
separator +
timestamp.FormatHour() +
separator +
timestamp.FormatMinute() +
separator +
timestamp.FormatSecond());
}
}
public static async Task<long> Count(
this IEventActivity instance,
string eventName,
DateTime startTimestamp,
DateTime endTimestamp,
ActivityDrilldown drilldown)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
var result = await instance.Counts(
eventName,
startTimestamp,
endTimestamp,
drilldown);
return result.First();
}
protected UserActivityYearTrackTests(
ActivityDrilldown drilldown) : base(drilldown)
{
}
internal IEnumerable <string> GenerateEventTimeframeKeys(
string eventName,
ActivityDrilldown drilldown,
DateTime timestamp)
{
yield return(GenerateKey(
eventName,
timestamp.FormatYear()));
var type = (int)drilldown;
if (type > (int)ActivityDrilldown.Year)
{
yield return(GenerateKey(
eventName,
timestamp.FormatYear(),
timestamp.FormatMonth()));
}
if (type > (int)ActivityDrilldown.Month)
{
yield return(GenerateKey(
eventName,
timestamp.FormatYear(),
timestamp.FormatMonth(),
timestamp.FormatDay()));
}
if (type > (int)ActivityDrilldown.Day)
{
yield return(GenerateKey(
eventName,
timestamp.FormatYear(),
timestamp.FormatMonth(),
timestamp.FormatDay(),
timestamp.FormatHour()));
}
if (type > (int)ActivityDrilldown.Hour)
{
yield return(GenerateKey(
eventName,
timestamp.FormatYear(),
timestamp.FormatMonth(),
timestamp.FormatDay(),
timestamp.FormatHour(),
timestamp.FormatMinute()));
}
if (type > (int)ActivityDrilldown.Minute)
{
yield return(GenerateKey(
eventName,
timestamp.FormatYear(),
timestamp.FormatMonth(),
timestamp.FormatDay(),
timestamp.FormatHour(),
timestamp.FormatMinute(),
timestamp.FormatSecond()));
}
}
public static IEnumerable <DateTime> Range(
this DateTime instance,
DateTime other,
ActivityDrilldown drilldown)
{
var backward = instance > other;
var increment = backward ? -1 : 1;
var outer = backward ? Greater : Lesser;
var inner = backward ? Lesser : Greater;
yield return(instance);
var counter = instance;
while (outer(counter, other))
{
switch (drilldown)
{
case ActivityDrilldown.Hour:
{
counter = counter.AddHours(increment);
break;
}
case ActivityDrilldown.Day:
{
counter = counter.AddDays(increment);
break;
}
case ActivityDrilldown.Month:
{
counter = counter.AddMonths(increment);
break;
}
case ActivityDrilldown.Minute:
{
counter = counter.AddMinutes(increment);
break;
}
case ActivityDrilldown.Year:
{
counter = counter.AddYears(increment);
break;
}
case ActivityDrilldown.Second:
{
counter = counter.AddSeconds(increment);
break;
}
}
if (inner(counter, other))
{
continue;
}
yield return(counter);
}
}
protected UserActivityMinuteTrackTests(
ActivityDrilldown drilldown) : base(drilldown)
{
}
public static IEnumerable<DateTime> Range(
this DateTime instance,
DateTime other,
ActivityDrilldown drilldown)
{
var backward = instance > other;
var increment = backward ? -1 : 1;
var outer = backward ? Greater : Lesser;
var inner = backward ? Lesser : Greater;
yield return instance;
var counter = instance;
while (outer(counter, other))
{
switch (drilldown)
{
case ActivityDrilldown.Hour:
{
counter = counter.AddHours(increment);
break;
}
case ActivityDrilldown.Day:
{
counter = counter.AddDays(increment);
break;
}
case ActivityDrilldown.Month:
{
counter = counter.AddMonths(increment);
break;
}
case ActivityDrilldown.Minute:
{
counter = counter.AddMinutes(increment);
break;
}
case ActivityDrilldown.Year:
{
counter = counter.AddYears(increment);
break;
}
case ActivityDrilldown.Second:
{
counter = counter.AddSeconds(increment);
break;
}
}
if (inner(counter, other))
{
continue;
}
yield return counter;
}
}
