feat: small enhancement

src/stream-net-tests/BatchTests.cs

@@ -30,16 +30,15 @@ public void TestGetActivitiesArgumentValidation()
         }
 
         [Test]
-
-        public void TestGetEnrichedFlatActivitiesArgumentValidation()
+        public void TestGetEnrichedActivitiesArgumentValidation()
         {
             Assert.ThrowsAsync<ArgumentException>(async () =>
             {
-                var activities = await this._client.Batch.GetEnrichedFlatActivities();
+                var activities = await this._client.Batch.GetEnrichedActivities(ids: null);
             });
             Assert.ThrowsAsync<ArgumentException>(async () =>
             {
-                var activities = await this._client.Batch.GetEnrichedFlatActivities(new string[1], foreignIDTimes: new Stream.ForeignIDTime[1]);
+                var activities = await this._client.Batch.GetEnrichedActivities(foreignIDTimes: null);
             });
         }
 

src/stream-net-tests/IntegrationTests.cs

@@ -1470,7 +1470,7 @@ public async Task TestGetEnrichedFlatActivitiesByID()
             response = await this._flat3.AddActivity(newActivity3);
             addedActivities.Add(response);
 
-            var activities = await this._client.Batch.GetEnrichedFlatActivities(addedActivities.Select(a => a.Id));
+            var activities = await this._client.Batch.GetEnrichedActivities(addedActivities.Select(a => a.Id));
             Assert.IsNotNull(activities);
             Assert.AreEqual(addedActivities.Count, activities.Count());
 
@@ -1504,9 +1504,9 @@ public async Task TestGetEnrichedFlatActivitiesByIDWithReactions()
 
             await _client.Reactions.Add("upvote", newActivity.Id, user.ID, new Dictionary<string, object> { ["reactionProp"] = "reactionPropValue" });
 
-            var activities = await this._client.Batch.GetEnrichedFlatActivities(
+            var activities = await this._client.Batch.GetEnrichedActivities(
                 new[] { newActivity.Id },
-                reactions: ReactionOption.With().Counts().Recent());
+                new GetOptions().WithReaction(ReactionOption.With().Counts().Recent()));
 
             Assert.IsNotNull(activities);
             Assert.AreEqual(1, activities.Count());

src/stream-net/BatchOperations.cs

@@ -135,30 +135,41 @@ 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)
+        public async Task<IEnumerable<EnrichedActivity>> GetEnrichedActivities(IEnumerable<string> ids, GetOptions options = 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");
+            if (ids == null || ids.Count() == 0)
+                throw new ArgumentException("Activity ids must be provided.", nameof(ids));
+
+            return await GetEnrichedActivities(ids, null, options);
+        }
+
+
+        public async Task<IEnumerable<EnrichedActivity>> GetEnrichedActivities(IEnumerable<ForeignIDTime> foreignIDTimes, GetOptions options = null)
+        {
+            if (foreignIDTimes == null || foreignIDTimes.Count() == 0)
+                throw new ArgumentException("ForeignIDTimes must be provided.", nameof(foreignIDTimes));
 
+            return await GetEnrichedActivities(null, foreignIDTimes, options);
+        }
+
+
+        private async Task<IEnumerable<EnrichedActivity>> GetEnrichedActivities(IEnumerable<string> ids = null, IEnumerable<ForeignIDTime> foreignIDTimes = null, GetOptions options = null)
+        {
             var request = _client.BuildAppRequest("enrich/activities/", HttpMethod.GET);
-            if (ids != null)
+
+            if (ids != null && ids.Any())
             {
                 request.AddQueryParameter("ids", string.Join(",", ids));
             }
 
-            if (foreignIDTimes != null)
+            if (foreignIDTimes != null && foreignIDTimes.Any())
             {
                 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);
-            }
+            options?.Apply(request);
 
             var response = await _client.MakeRequest(request);
 

src/stream-net/IBatchOperations.cs

@@ -9,7 +9,8 @@ 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<IEnumerable<EnrichedActivity>> GetEnrichedActivities(IEnumerable<string> ids, GetOptions options = null);
+        Task<IEnumerable<EnrichedActivity>> GetEnrichedActivities(IEnumerable<ForeignIDTime> foreignIDTimes, GetOptions options = null);
         Task UpdateActivities(IEnumerable<Activity> activities);
         Task UpdateActivity(Activity activity);
         Task ActivitiesPartialUpdate(IEnumerable<ActivityPartialUpdateRequestObject> updates);