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); }
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 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); } }
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); } }
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; } }