update to targets

Author: Link512

src/stream-net-tests/IntegrationTests.cs

@@ -1746,6 +1746,72 @@ public async Task TestActivityPartialUpdateByForeignIDTime()
             Assert.AreEqual("zyx", updatedAct.GetData<string>("custom_thing"));
         }
 
+        [Test]
+        public async Task TestUpdateToTargets()
+        {
+            var fidTime = new Stream.ForeignIDTime(System.Guid.NewGuid().ToString(), DateTime.UtcNow);
+
+            var targets = new List<string>()
+            {
+                "flat:" + Guid.NewGuid().ToString(),
+                "user:" + Guid.NewGuid().ToString(),
+            };
+
+            var act = new Stream.Activity("upd", "test", "1")
+            {
+                ForeignId = fidTime.ForeignID,
+                Time = fidTime.Time,
+                To = targets
+            };
+
+            var insertedAct = await this._user1.AddActivity(act);
+            Assert.AreEqual(2, insertedAct.To.Count);
+
+            //add 1
+            var add = "user:" + Guid.NewGuid().ToString();
+            var updateResp = await this._user1.UpdateActivityToTargets(fidTime, new string[] { add });
+            Assert.AreEqual(insertedAct.Id, updateResp.Activity.Id);
+            Assert.AreEqual(1, updateResp.Added.Count);
+            Assert.AreEqual(add, updateResp.Added[0]);
+            Assert.AreEqual(3, updateResp.Activity.To.Count);
+            Assert.IsNotNull(updateResp.Activity.To.ToList().Find(t => t == add));
+
+            var updatedAct = (await this._user1.GetActivities(0, 1, FeedFilter.Where().IdLessThanEqual(insertedAct.Id))).FirstOrDefault();
+            Assert.NotNull(updatedAct);
+            Assert.AreEqual(3, updatedAct.To.Count);
+            Assert.IsNotNull(updatedAct.To.ToList().Find(t => t == add));
+
+            //remove 1
+            var remove = targets[0];
+            updateResp = await this._user1.UpdateActivityToTargets(fidTime, null, null, new string[] { remove });
+            Assert.AreEqual(insertedAct.Id, updateResp.Activity.Id);
+            Assert.AreEqual(1, updateResp.Removed.Count);
+            Assert.AreEqual(remove, updateResp.Removed[0]);
+            Assert.AreEqual(2, updateResp.Activity.To.Count);
+            Assert.IsNull(updateResp.Activity.To.ToList().Find(t => t == remove));
+
+            updatedAct = (await this._user1.GetActivities(0, 1, FeedFilter.Where().IdLessThanEqual(insertedAct.Id))).FirstOrDefault();
+            Assert.NotNull(updatedAct);
+            Assert.AreEqual(2, updatedAct.To.Count);
+            Assert.IsNull(updatedAct.To.ToList().Find(t => t == remove));
+
+            //new ones
+            var newOnes = new List<string>()
+            {
+                "flat:" + Guid.NewGuid().ToString(),
+                "user:" + Guid.NewGuid().ToString(),
+            };
+            updateResp = await this._user1.UpdateActivityToTargets(fidTime, null, newOnes);
+            Assert.AreEqual(insertedAct.Id, updateResp.Activity.Id);
+            Assert.AreEqual(2, updateResp.Activity.To.Count);
+            Assert.AreEqual(2, updateResp.Added.Count);
+            Assert.AreEqual(2, updateResp.Added.ToList().FindAll(t => newOnes.Contains(t)).Count);
+            updatedAct = (await this._user1.GetActivities(0, 1, FeedFilter.Where().IdLessThanEqual(insertedAct.Id))).FirstOrDefault();
+            Assert.NotNull(updatedAct);
+            Assert.AreEqual(2, updatedAct.To.Count);
+            Assert.AreEqual(2, updatedAct.To.ToList().FindAll(t => newOnes.Contains(t)).Count);
+        }
+
         [Test]
         public async Task TestBatchPartialUpdate()
         {

src/stream-net/IStreamFeed.cs

@@ -28,5 +28,9 @@ public interface IStreamFeed
         Task UnfollowFeed(string targetFeedSlug, string targetUserId, bool keepHistory = false);
         Task UpdateActivities(IEnumerable<Activity> activities);
         Task UpdateActivity(Activity activity);
+        Task<UpdateToTargetsResponse> UpdateActivityToTargets(ForeignIDTime foreignIDTime,
+            IEnumerable<string> adds = null,
+            IEnumerable<string> newTargets = null,
+            IEnumerable<string> removed = null);
     }
 }

src/stream-net/StreamFeed.cs

@@ -179,6 +179,34 @@ public async Task<IEnumerable<Activity>> GetActivities(int offset = 0, int limit
             throw StreamException.FromResponse(response);
         }
 
+        public async Task<UpdateToTargetsResponse> UpdateActivityToTargets(ForeignIDTime foreignIDTime,
+            IEnumerable<string> adds = null,
+            IEnumerable<string> newTargets = null,
+            IEnumerable<string> removed = null)
+        {
+            var payload = new Dictionary<string, object>()
+            {
+                {"foreign_id" , foreignIDTime.ForeignID},
+                {"time" , foreignIDTime.Time.ToString("s", System.Globalization.CultureInfo.InvariantCulture)}
+            };
+            if (adds != null)
+                payload["added_targets"] = adds.ToList();
+            if (newTargets != null)
+                payload["new_targets"] = newTargets.ToList();
+            if (removed != null)
+                payload["removed_targets"] = removed.ToList();
+
+            var endpoint = string.Format("feed_targets/{0}/{1}/activity_to_targets/", this._feedSlug, this._userId);
+            var request = this._client.BuildJWTAppRequest(endpoint, HttpMethod.POST);
+            request.SetJsonBody(JsonConvert.SerializeObject(payload));
+            var response = await this._client.MakeRequest(request);
+
+            if (response.StatusCode == System.Net.HttpStatusCode.Created)
+                return UpdateToTargetsResponse.FromJson(response.Content);
+
+            throw StreamException.FromResponse(response);
+        }
+
         internal async Task<StreamResponse<T>> GetWithOptions<T>(GetOptions options = null) where T : Activity
         {
             // build request

src/stream-net/UpdateToTargetsResponse.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace Stream
+{
+    public class UpdateToTargetsResponse
+    {
+        public Activity Activity { get; internal set; }
+        public List<string> Added { get; internal set; }
+        public List<string> Removed { get; internal set; }
+
+        public UpdateToTargetsResponse() { }
+
+        internal static UpdateToTargetsResponse FromJson(string json)
+        {
+            return UpdateToTargetsResponse.FromJson(JObject.Parse(json));
+        }
+
+        internal static UpdateToTargetsResponse FromJson(JObject obj)
+        {
+            var result = new UpdateToTargetsResponse();
+            foreach (var jsonProp in obj.Properties())
+            {
+                switch (jsonProp.Name)
+                {
+                    case "added":
+                        result.Added = jsonProp.Value.ToObject<List<string>>();
+                        break;
+                    case "removed":
+                        result.Removed = jsonProp.Value.ToObject<List<string>>();
+                        break;
+                    case "activity":
+                        result.Activity = Activity.FromJson(jsonProp.Value.ToObject<JObject>());
+                        break;
+                }
+            }
+            return result;
+        }
+    }
+}