Add possibility to query enriched activities by ids

src/stream-net-tests/BatchTests.cs

@@ -35,6 +35,20 @@ public void TestGetActivitiesArgumentValidation()
 
         [Test]
 
+        public void TestGetEnrichedFlatActivitiesArgumentValidation()
+        {
+            Assert.ThrowsAsync<ArgumentException>(async () =>
+            {
+                var activities = await this._client.Batch.GetEnrichedFlatActivities();
+            });
+            Assert.ThrowsAsync<ArgumentException>(async () =>
+            {
+                var activities = await this._client.Batch.GetEnrichedFlatActivities(new string[1], foreignIDTimes: new Stream.ForeignIDTime[1]);
+            });
+        }
+
+        [Test]
+
         public void TestFollowManyArgumentValidation()
         {
             Assert.ThrowsAsync<ArgumentOutOfRangeException>(async () =>

src/stream-net-tests/IntegrationTests.cs

@@ -1452,6 +1452,86 @@ public async Task TestGetActivitiesByForeignIDAndTime()
             });
         }
 
+        [Test]
+        public async Task TestGetEnrichedFlatActivitiesByID()
+        {
+            var userId = System.Guid.NewGuid().ToString();
+            const string userName = "user name";
+            var user = await _client.Users.Add(userId, new Dictionary<string, object> { ["name"] = userName });
+            var newActivity1 = new Stream.Activity(user.Ref(), "test", "1");
+            var newActivity2 = new Stream.Activity(user.Ref(), "test", "2");
+            var newActivity3 = new Stream.Activity(user.Ref(), "other", "2");
+            var addedActivities = new List<Stream.Activity>();
+
+            var response = await this._user1.AddActivity(newActivity1);
+            addedActivities.Add(response);
+            response = await this._user2.AddActivity(newActivity2);
+            addedActivities.Add(response);
+            response = await this._flat3.AddActivity(newActivity3);
+            addedActivities.Add(response);
+
+            var activities = await this._client.Batch.GetEnrichedFlatActivities(addedActivities.Select(a => a.Id));
+            Assert.IsNotNull(activities);
+            Assert.AreEqual(addedActivities.Count, activities.Count());
+
+            activities.ForEach(a =>
+            {
+                var found = addedActivities.Find(x => x.Id == a.Id);
+                Assert.NotNull(found);
+
+                Assert.IsTrue(a.Actor.IsEnriched);
+                Assert.AreEqual(userId, a.Actor.Enriched.GetData<string>("id"));
+                var userData = a.Actor.Enriched.GetData<Dictionary<string, object>>("data");
+                Assert.IsNotNull(userData);
+                Assert.IsTrue(userData.ContainsKey("name"));
+                Assert.AreEqual(userName, userData["name"]);
+
+                Assert.IsFalse(a.Object.IsEnriched);
+                Assert.AreEqual(found.Object, a.Object.Raw);
+
+                Assert.IsFalse(a.Verb.IsEnriched);
+                Assert.AreEqual(found.Verb, a.Verb.Raw);
+            });
+        }
+
+        [Test]
+        public async Task TestGetEnrichedFlatActivitiesByIDWithReactions()
+        {
+            var userId = System.Guid.NewGuid().ToString();
+            var user = await _client.Users.Add(userId);
+            var newActivity = new Stream.Activity(user.Ref(), "test", "1");
+            newActivity = await this._user1.AddActivity(newActivity);
+
+            await _client.Reactions.Add("upvote", newActivity.Id, user.ID, new Dictionary<string, object> { ["reactionProp"] = "reactionPropValue" });
+
+            var activities = await this._client.Batch.GetEnrichedFlatActivities(
+                new[] { newActivity.Id },
+                reactions: ReactionOption.With().Counts().Recent());
+
+            Assert.IsNotNull(activities);
+            Assert.AreEqual(1, activities.Count());
+
+            var enrichedActivity = activities.Single();
+            Assert.NotNull(enrichedActivity);
+
+            Assert.IsTrue(enrichedActivity.Actor.IsEnriched);
+            Assert.AreEqual(userId, enrichedActivity.Actor.Enriched.GetData<string>("id"));
+
+            Assert.IsNotNull(enrichedActivity.ReactionCounts);
+            Assert.AreEqual(1, enrichedActivity.ReactionCounts.Count);
+            Assert.AreEqual("upvote", enrichedActivity.ReactionCounts.Keys.Single());
+            Assert.AreEqual(1, enrichedActivity.ReactionCounts["upvote"]);
+
+            Assert.IsNotNull(enrichedActivity.LatestReactions);
+            Assert.AreEqual(1, enrichedActivity.LatestReactions.Count);
+            Assert.AreEqual("upvote", enrichedActivity.LatestReactions.Keys.Single());
+            Assert.AreEqual(1, enrichedActivity.LatestReactions["upvote"].Count());
+
+            var enrichedReaction = enrichedActivity.LatestReactions["upvote"].Single();
+            Assert.IsNotNull(enrichedReaction.Data);
+            Assert.AreEqual("reactionPropValue", enrichedReaction.Data["reactionProp"]);
+        }
+
         [Test]
         public void TestCollectionsUpsert()
         {
@@ -2343,9 +2423,6 @@ public async Task TestEnrich_User_InReaction()
             Assert.AreEqual(true, (bool)ownReaction.User.Enriched?.GetData<Dictionary<string, object>>("data")["is_admin"]);
         }
 
-
-
-
         [Test]
         public async Task TestEnrich_LatestReactions()
         {

src/stream-net/BatchOperations.cs

@@ -135,6 +135,42 @@ public async Task<IEnumerable<Activity>> GetActivities(IEnumerable<string> ids =
             throw StreamException.FromResponse(response);
         }
 
+        public async Task<IEnumerable<EnrichedActivity>> GetEnrichedFlatActivities(IEnumerable<string> ids = null, ReactionOption reactions = null, IEnumerable<ForeignIDTime> foreignIDTimes = null)
+        {
+            if (ids == null && foreignIDTimes == null)
+                throw new ArgumentException("one of the parameters ids or foreignIdTimes must be provided and not null", "ids, foreignIDTimes");
+            if (ids != null && foreignIDTimes != null)
+                throw new ArgumentException("at most one of the parameters ids or foreignIdTimes must be provided", "ids, foreignIDTimes");
+
+            var request = _client.BuildAppRequest("enrich/activities/", HttpMethod.GET);
+            if (ids != null)
+            {
+                request.AddQueryParameter("ids", string.Join(",", ids));
+            }
+
+            if (foreignIDTimes != null)
+            {
+                request.AddQueryParameter("foreign_ids", string.Join(",", foreignIDTimes.Select(f => f.ForeignID)));
+                request.AddQueryParameter("timestamps", string.Join(",", foreignIDTimes.Select(f =>
+                        f.Time.ToString("s", System.Globalization.CultureInfo.InvariantCulture))));
+            }
+
+            if (reactions != null)
+            {
+                reactions.Apply(request);
+            }
+
+            var response = await _client.MakeRequest(request);
+
+            if (response.StatusCode != System.Net.HttpStatusCode.OK)
+                throw StreamException.FromResponse(response);
+
+            JObject obj = JObject.Parse(response.Content);
+            var array = obj.Value<JArray>("results");
+            var activities = array.Select(a => EnrichedActivity.FromJson((JObject)a)).ToList();
+            return activities;
+        }
+
         public async Task UpdateActivities(IEnumerable<Activity> activities)
         {
             var request = _client.BuildAppRequest("activities/", HttpMethod.POST);
@@ -165,6 +201,5 @@ public async Task UpdateActivity(Activity activity)
         {
             await UpdateActivities(new Activity[] { activity });
         }
-
     }
 }

src/stream-net/IBatchOperations.cs

@@ -9,6 +9,7 @@ public interface IBatchOperations
         Task AddToMany(Activity activity, IEnumerable<string> feedIds);
         Task FollowMany(IEnumerable<Follow> follows, int activityCopyLimit = 300);
         Task<IEnumerable<Activity>> GetActivities(IEnumerable<string> ids = null, IEnumerable<ForeignIDTime> foreignIDTimes = null);
+        Task<IEnumerable<EnrichedActivity>> GetEnrichedFlatActivities(IEnumerable<string> ids = null, ReactionOption reactions = null, IEnumerable<ForeignIDTime> foreignIDTimes = null);
         Task UpdateActivities(IEnumerable<Activity> activities);
         Task UpdateActivity(Activity activity);
         Task ActivitiesPartialUpdate(IEnumerable<ActivityPartialUpdateRequestObject> updates);