/// <summary>
/// FanIn
/// </summary>
public IEnumerable <Activity> Load(ActivityStream stream, ActivityStreamOptions feedOptions)
{
// At this point we have all the streams with their timestamp
Dictionary <byte[], long> streamsToLoad = new StreamCrawler(streamStore).StreamsToLoad(stream, feedOptions.Paging.Timestamp);
Dictionary <string, DateTime> debug = streamsToLoad.ToDictionary(key => Encoding.UTF8.GetString(key.Key), val => DateTime.FromFileTimeUtc(val.Value));
feedOptions = feedOptions ?? ActivityStreamOptions.Default;
var snapshot = GetSnapshot(streamsToLoad, feedOptions);
SortedSet <Activity> buffer = new SortedSet <Activity>(Activity.ComparerDesc);
// Init
foreach (var str in streamsToLoad)
{
var streamId = str.Key;
FetchNextActivity(snapshot, streamId, buffer);
}
while (buffer.Count > 0)
{
Activity nextActivity = buffer.First();
buffer.Remove(nextActivity);
yield return(nextActivity);
FetchNextActivity(snapshot, nextActivity.StreamId, buffer);
}
}
public ActivityStream Get(byte[] streamId)
{
ActivityStream stream = null;
activityFeedStore.TryGetValue(streamId, out stream);
return(stream);
}
/// <summary>
/// FanIn
/// </summary>
public IEnumerable<Activity> Load(ActivityStream stream, ActivityStreamOptions feedOptions)
{
// At this point we have all the streams with their timestamp
Dictionary<byte[], long> streamsToLoad = new StreamCrawler(streamStore).StreamsToLoad(stream, feedOptions.Paging.Timestamp);
Dictionary<string, DateTime> debug = streamsToLoad.ToDictionary(key => Encoding.UTF8.GetString(key.Key), val => DateTime.FromFileTimeUtc(val.Value));
feedOptions = feedOptions ?? ActivityStreamOptions.Default;
var snapshot = GetSnapshot(streamsToLoad, feedOptions);
SortedSet<Activity> buffer = new SortedSet<Activity>(Activity.ComparerDesc);
// Init
foreach (var str in streamsToLoad)
{
var streamId = str.Key;
FetchNextActivity(snapshot, streamId, buffer);
}
while (buffer.Count > 0)
{
Activity nextActivity = buffer.First();
buffer.Remove(nextActivity);
yield return nextActivity;
FetchNextActivity(snapshot, nextActivity.StreamId, buffer);
}
}
private static ActivityStream Stream(params Activity[] activities)
{
var activityStream = new ActivityStream(WindowSpan);
activityStream.AddAll(activities);
return(activityStream);
}
public Dictionary<byte[], long> StreamsToLoad(ActivityStream stream, long timestamp = 0)
{
AddOrUpdateStreamsToLoadWith(streamsToLoad, stream, timestamp);
Stack<byte[]> streamsToCrawl = new Stack<byte[]>();
streamsToCrawl.Push(stream.StreamId);
while (streamsToCrawl.Count > 0)
{
Guard_AgainstStupidity();
// Load next stream.
var currentId = streamsToCrawl.Pop();
var current = streamStore.Get(currentId) ?? ActivityStream.Empty;
long currentExpiresAt = current.ExpiresAt;
streamsToLoad.TryGetValue(current.StreamId, out currentExpiresAt);
if (ActivityStream.IsEmpty(current)) continue;
// Crawl only first level attached streams.
foreach (var nested in current.AttachedStreams)
{
if (IsCrawled(nested)) continue;
streamsToCrawl.Push(nested.StreamId);
var nestedShouldExpireAt = currentExpiresAt < nested.ExpiresAt ? currentExpiresAt : nested.ExpiresAt;
AddOrUpdateStreamsToLoadWith(streamsToLoad, nested, nestedShouldExpireAt);
}
}
return streamsToLoad;
}
public ActivityStream Load(byte[] streamId)
{
var result = store.Get(streamId);
if (ReferenceEquals(null, result))
result = new ActivityStream(streamId);
return result;
}
public void IsIterable()
{
var uut = new ActivityStream(TimeSpan.FromSeconds(1))
{
Activity.Any, Activity.Development
};
CollectionAssert.AreEqual(new[] { Activity.Any, Activity.Development }, uut);
}
public void ActivityStreamSerializer_should_serialize_activitystream_object()
{
var serializer = new ActivityStreamSerializer();
var activityStream = new ActivityStream {
Items = new[] { new Activity(), new Activity() }, TotalItems = 2
};
var result = serializer.SerializeStream(activityStream);
result.ShouldEqual("{\"totalItems\":2,\"items\":[{\"published\":\"0001-01-01T05:00:00Z\"},{\"published\":\"0001-01-01T05:00:00Z\"}]}");
}
void MarkAsCrowled(ActivityStream stream)
{
if (crawledStreams.ContainsKey(stream.StreamId))
{
if (crawledStreams[stream.StreamId] < stream.ExpiresAt)
crawledStreams[stream.StreamId] = stream.ExpiresAt;
}
else
crawledStreams.Add(stream.StreamId, stream.ExpiresAt);
}
public void Attach(byte[] sourceStreamId, byte[] streamIdToAttach, long expiresAt)
{
ActivityStream stream;
if (activityFeedStore.TryGetValue(sourceStreamId, out stream) == false)
{
stream = new ActivityStream(sourceStreamId);
activityFeedStore.TryAdd(sourceStreamId, stream);
}
var streamToAttach = new ActivityStream(streamIdToAttach, expiresAt);
stream.AttachedStreams.Add(streamToAttach);
}
public ActivityStream Load(byte[] streamId)
{
var result = store.Get(streamId);
if (ReferenceEquals(null, result))
{
result = new ActivityStream(streamId);
}
return(result);
}
void AddOrUpdateStreamsToLoadWith(Dictionary<byte[], long> streamsToLoad, ActivityStream stream, long timestamp = 0)
{
if (streamsToLoad.ContainsKey(stream.StreamId))
{
if (streamsToLoad[stream.StreamId] < timestamp)
streamsToLoad[stream.StreamId] = timestamp;
}
else
streamsToLoad.Add(stream.StreamId, timestamp);
MarkAsCrowled(stream);
}
public void Attach(byte[] sourceStreamId, byte[] streamIdToAttach, long expiresAt)
{
ActivityStream stream;
if (activityFeedStore.TryGetValue(sourceStreamId, out stream) == false)
{
stream = new ActivityStream(sourceStreamId);
activityFeedStore.TryAdd(sourceStreamId, stream);
}
var streamToAttach = new ActivityStream(streamIdToAttach, expiresAt);
stream.AttachedStreams.Add(streamToAttach);
}
void MarkAsCrowled(ActivityStream stream)
{
if (crawledStreams.ContainsKey(stream.StreamId))
{
if (crawledStreams[stream.StreamId] < stream.ExpiresAt)
{
crawledStreams[stream.StreamId] = stream.ExpiresAt;
}
}
else
{
crawledStreams.Add(stream.StreamId, stream.ExpiresAt);
}
}
void AddOrUpdateStreamsToLoadWith(Dictionary <byte[], long> streamsToLoad, ActivityStream stream, long timestamp = 0)
{
if (streamsToLoad.ContainsKey(stream.StreamId))
{
if (streamsToLoad[stream.StreamId] < timestamp)
{
streamsToLoad[stream.StreamId] = timestamp;
}
}
else
{
streamsToLoad.Add(stream.StreamId, timestamp);
}
MarkAsCrowled(stream);
}
public static void ValideActivityStream(Manager M, Browser Br, string Url, string Name, string club)
{
string PostName;
switch (club.ToUpper())
{
case "CUSTOMER":
Br.NavigateTo(Url + "/Customer/", true);
break;
case "DEVELOPER":
Br.NavigateTo(Url + "/Developer/", true);
break;
case "TECHNICAL":
Br.NavigateTo(Url + "/Technical/", true);
break;
case "PARLIAMENT":
Br.NavigateTo(Url + "/The-Parliament/", true);
//It takes a lot of time to update parliament activity stream for some unknown reason
Thread.Sleep(50000);
break;
}
Br.Refresh();
Thread.Sleep(10000); //Activity stream takes a lot of time to load the post
//Br.WaitUntilReady();
Br.RefreshDomTree();
ActivityStream objActivity = new ActivityStream(M);
//Identify the first post if the activity feed and selecting the first entry div Class= "activity-text-wrapper"
HtmlDiv FirstBlog = objActivity.validateActivityFeed.As <HtmlDiv>();
System.Collections.ObjectModel.ReadOnlyCollection <HtmlAnchor> links = FirstBlog.Find.AllByTagName <HtmlAnchor>("a");
HtmlAnchor blogURL = FirstBlog.Find.AllByTagName <HtmlAnchor>("a")[1];
PostName = blogURL.InnerText;
Assert.AreEqual(PostName, Name, "Activity stream validation failed");
blogURL.Click();
Thread.Sleep(3000);
Br.WaitUntilReady();
Br.RefreshDomTree();
}
public static void ActivityStreamCommentsValidator(Manager M, Browser Br, string Url, string Comment, string club)
{
string PostName = "";
Thread.Sleep(5000);
switch (club.ToUpper())
{
case "CUSTOMER":
Br.NavigateTo(Url + "/Customer/", true);
break;
case "DEVELOPER":
Br.NavigateTo(Url + "/Developer/", true);
break;
case "TECHNICAL":
Br.NavigateTo(Url + "/Technical/", true);
break;
case "PARLIAMENT":
Br.NavigateTo(Url + "/The-Parliament/", true);
break;
}
//It takes atleast 1minute to load the comments to the activity stream
Thread.Sleep(5000);
Br.Refresh();
Thread.Sleep(5000);
Br.Refresh();
Br.WaitUntilReady();
Br.RefreshDomTree();
ActivityStream objActivity = new ActivityStream(M);
//Identify the first post if the activity feed and selecting the first entry div Class= "activity-text-wrapper"
HtmlDiv FirstBlog = objActivity.validateActivityFeed.As <HtmlDiv>();
System.Collections.ObjectModel.ReadOnlyCollection <HtmlSpan> links = FirstBlog.Find.AllByTagName <HtmlSpan>("Span");
HtmlSpan blogComment = FirstBlog.Find.AllByTagName <HtmlSpan>("Span")[4];
PostName = blogComment.InnerText;
//Assert.IsTrue(PostName.Contains(Comment), "Activity stream comment validation failed");
Thread.Sleep(3000);
Br.WaitUntilReady();
Br.RefreshDomTree();
}
public static ulong Add(ActivityStream newActivityStream)
{
return(DbUtils.ConnectAndExecute(conn => {
var query = "INSERT INTO engine4_activity_streams(target_type,target_id,subject_type,subject_id,object_type,object_id,type,action_id) " +
"VALUES (@target_type,@target_id,@subject_type,@subject_id,@object_type,@object_id,@type,@action_id)";
var cmd = new MySqlCommand(query, conn);
cmd.Parameters.AddWithValue("target_type", newActivityStream.target_type);
cmd.Parameters.AddWithValue("target_id", newActivityStream.target_id);
cmd.Parameters.AddWithValue("subject_type", newActivityStream.subject_type);
cmd.Parameters.AddWithValue("subject_id", newActivityStream.subject_id);
cmd.Parameters.AddWithValue("object_type", newActivityStream.object_type);
cmd.Parameters.AddWithValue("object_id", newActivityStream.object_id);
cmd.Parameters.AddWithValue("type", newActivityStream.type);
cmd.Parameters.AddWithValue("action_id", newActivityStream.action_id);
cmd.ExecuteNonQuery();
return 0;
}));
}
public Dictionary <byte[], long> StreamsToLoad(ActivityStream stream, long timestamp = 0)
{
AddOrUpdateStreamsToLoadWith(streamsToLoad, stream, timestamp);
Stack <byte[]> streamsToCrawl = new Stack <byte[]>();
streamsToCrawl.Push(stream.StreamId);
while (streamsToCrawl.Count > 0)
{
Guard_AgainstStupidity();
// Load next stream.
var currentId = streamsToCrawl.Pop();
var current = streamStore.Get(currentId) ?? ActivityStream.Empty;
long currentExpiresAt = current.ExpiresAt;
streamsToLoad.TryGetValue(current.StreamId, out currentExpiresAt);
if (ActivityStream.IsEmpty(current))
{
continue;
}
// Crawl only first level attached streams.
foreach (var nested in current.AttachedStreams)
{
if (IsCrawled(nested))
{
continue;
}
streamsToCrawl.Push(nested.StreamId);
var nestedShouldExpireAt = currentExpiresAt < nested.ExpiresAt ? currentExpiresAt : nested.ExpiresAt;
AddOrUpdateStreamsToLoadWith(streamsToLoad, nested, nestedShouldExpireAt);
}
}
return(streamsToLoad);
}
public ActivityStream Get(byte[] streamId)
{
var sid = Convert.ToBase64String(streamId);
var prepared = session
.Prepare(LoadFeedStreamQueryTemplate)
.Bind(sid);
var rowSet = session.Execute(prepared);
var result = new ActivityStream(streamId);
List<byte[]> feedStreams = new List<byte[]>();
bool isLoaded = false;
foreach (var row in rowSet.GetRows())
{
isLoaded = true;
var asid = Convert.FromBase64String(row.GetValue<string>("asid"));
var ts = row.GetValue<long>("ts");
long expiresAt = ts == 0 ? ActivityStream.DefaultExpirationTimestamp : ts;
result.Attach(asid, expiresAt);
}
return isLoaded ? result : null;
}
public ActivityStream Get(byte[] streamId)
{
var sid = Convert.ToBase64String(streamId);
var prepared = session
.Prepare(LoadFeedStreamQueryTemplate)
.Bind(sid);
var rowSet = session.Execute(prepared);
var result = new ActivityStream(streamId);
List <byte[]> feedStreams = new List <byte[]>();
bool isLoaded = false;
foreach (var row in rowSet.GetRows())
{
isLoaded = true;
var asid = Convert.FromBase64String(row.GetValue <string>("asid"));
var ts = row.GetValue <long>("ts");
long expiresAt = ts == 0 ? ActivityStream.DefaultExpirationTimestamp : ts;
result.Attach(asid, expiresAt);
}
return(isLoaded ? result : null);
}
public void AddActivityStream(ActivityStream activityStream)
{
this.activityStreamController.Add(activityStream);
}
public void TestResolution()
{
ActivityStream stream = Unmarshaller <ActivityStream> .Unmarshal(_json);
Assert.AreEqual(stream.Resolution, "low");
}
public void TestDataCount()
{
ActivityStream stream = Unmarshaller <ActivityStream> .Unmarshal(_json);
Assert.AreEqual(stream.Data.Count, 8);
}
public void TestOriginalSize()
{
ActivityStream stream = Unmarshaller <ActivityStream> .Unmarshal(_json);
Assert.AreEqual(stream.OriginalSize, 512);
}
public void TestSeriesType()
{
ActivityStream stream = Unmarshaller <ActivityStream> .Unmarshal(_json);
Assert.AreEqual(stream.SeriesType, "distance");
}
public void TestStreamType()
{
ActivityStream stream = Unmarshaller <ActivityStream> .Unmarshal(_json);
Assert.AreEqual(stream.StreamType, StreamType.LatLng);
}
public void TestStreamUnmarshalling()
{
ActivityStream stream = Unmarshaller <ActivityStream> .Unmarshal(_json);
Assert.IsNotNull(stream);
}
bool IsCrawled(ActivityStream stream)
{
return crawledStreams.ContainsKey(stream.StreamId) && crawledStreams[stream.StreamId] >= stream.ExpiresAt;
}
public void Add(ActivityStream activityStream)
{
this._context.ActivityStream.Add(activityStream);
this._context.SaveChanges();
}
bool IsCrawled(ActivityStream stream)
{
return(crawledStreams.ContainsKey(stream.StreamId) && crawledStreams[stream.StreamId] >= stream.ExpiresAt);
}