[CHA-652]: feat(cha-769): support shared locations (#172)

* feat(cha-769): support shared locations

* feat(cha-652): add location sharing support

* fix(cha-652): fix model

* fix(cha-652): fix unit tests

* fix(cha-652): fix unit tests

* fix(cha-652): fix unit tests

* fix(cha-652): fix unit test

* lint(cha-652): lint

* fix warnings

* add lint to the makefile

* fix lint

* fix lint

* refactor

* clean up

---------

Co-authored-by: Rafael Marinho <[email protected]>

Author: rafaelmf3

.stylecop.ruleset

@@ -24,6 +24,10 @@
   </Rules>
   <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.Analyzers.LayoutRules">
     <Rule Id="SA1503" Action="None" />    <!-- Braces should not be omitted -->
+    <Rule Id="SA1505" Action="None" />    <!-- An opening brace should not be followed by a blank line -->
+    <Rule Id="SA1507" Action="None" />    <!-- Code should not contain multiple blank lines in a row -->
+    <Rule Id="SA1508" Action="None" />    <!-- A closing brace should not be preceded by a blank line -->
+    <Rule Id="SA1513" Action="None" />    <!-- A closing brace should be followed by a blank line -->
     <Rule Id="SA1516" Action="None" />    <!-- Elements should be separated by blank line -->
     <Rule Id="CS1591" Action="None" />    <!--  Missing XML comment for publicly visible type or member -->
   </Rules>

Makefile

@@ -49,6 +49,9 @@ clean: ## Clean build artifacts
 	dotnet clean
 	rm -f $(RUNSETTINGS_FILE).tmp
 
+lint: ## Run linting
+	dotnet build --verbosity quiet
+
 test_with_docker: ## Run tests in Docker (set DOTNET_VERSION to change .NET version)
 	$(call generate_runsettings_content,$(RUNSETTINGS_FILE).tmp)
 	docker run -t -i -w /code -v $(PWD):/code --add-host=host.docker.internal:host-gateway \

src/Clients/IUserClient.cs

@@ -264,5 +264,20 @@ public interface IUserClient
         /// </summary>
         /// <remarks>https://getstream.io/chat/docs/javascript/block_user/</remarks>
         Task<ApiResponse> UnblockUserAsync(string targetId, string userID);
+
+        /// <summary>
+        /// Updates a user's live location.
+        /// </summary>
+        /// <param name="userID">The user ID</param>
+        /// <param name="location">The location data to update</param>
+        /// <returns>The server response containing the updated live location share, including channel CID, message ID, user ID, latitude, longitude, device ID, end time, creation and update timestamps, and duration.</returns>
+        Task<SharedLocationResponse> UpdateUserLiveLocationAsync(string userID, SharedLocationRequest location);
+
+        /// <summary>
+        /// Gets all active live location shares for a user.
+        /// </summary>
+        /// <param name="userID">The user ID</param>
+        /// <returns>The server response containing an array of active live location shares with details including channel CID, message ID, coordinates, device ID, and timestamps</returns>
+        Task<ActiveLiveLocationsResponse> GetUserActiveLiveLocationsAsync(string userID);
     }
 }

src/Clients/UserClient.cs

@@ -241,5 +241,34 @@ public async Task<QueryUsersResponse> QueryAsync(QueryUserOptions opts)
                     new KeyValuePair<string, string>("payload", StreamJsonConverter.SerializeObject(payload)),
                 });
         }
+
+        public async Task<SharedLocationResponse> UpdateUserLiveLocationAsync(string userID, SharedLocationRequest location)
+        {
+            if (string.IsNullOrEmpty(userID))
+                throw new ArgumentException("User ID cannot be empty", nameof(userID));
+
+            return await ExecuteRequestAsync<SharedLocationResponse>("users/live_locations",
+                HttpMethod.PUT,
+                HttpStatusCode.Created,
+                location,
+                queryParams: new List<KeyValuePair<string, string>>
+                {
+                    new KeyValuePair<string, string>("user_id", userID),
+                });
+        }
+
+        public async Task<ActiveLiveLocationsResponse> GetUserActiveLiveLocationsAsync(string userID)
+        {
+            if (string.IsNullOrEmpty(userID))
+                throw new ArgumentException("User ID cannot be empty", nameof(userID));
+
+            return await ExecuteRequestAsync<ActiveLiveLocationsResponse>("users/live_locations",
+                HttpMethod.GET,
+                HttpStatusCode.OK,
+                queryParams: new List<KeyValuePair<string, string>>
+                {
+                    new KeyValuePair<string, string>("user_id", userID),
+                });
+        }
     }
 }

src/Models/ChannelConfig.cs

@@ -43,5 +43,6 @@ public class ConfigOverridesRequest
         public ModerationBehaviour BlocklistBehavior { get; set; }
         public List<string> Commands { get; set; }
         public bool? UserMessageReminders { get; set; }
+        public bool? SharedLocations { get; set; }
     }
 }

src/Models/Message.cs

@@ -41,6 +41,7 @@ public class Message : CustomDataBase
         public bool? Shadowed { get; set; }
         public Dictionary<string, List<string>> ImageLabels { get; set; }
         public List<string> RestrictedVisibility { get; set; }
+        public SharedLocationRequest SharedLocation { get; set; }
 
         [JsonProperty("i18n")]
         public Dictionary<string, string> I18n { get; set; }

src/Models/MessageRequest.cs

@@ -38,6 +38,7 @@ public class MessageRequest : CustomDataBase
         public UserRequest PinnedBy { get; set; }
         public DateTimeOffset? PinnedAt { get; set; }
         public IEnumerable<string> RestrictedVisibility { get; set; }
+        public SharedLocationRequest SharedLocation { get; set; }
     }
 }
 

src/Models/SharedLocation.cs

@@ -0,0 +1,31 @@
+using System;
+
+namespace StreamChat.Models
+{
+    public class SharedLocationRequest
+    {
+        public string CreatedByDeviceId { get; set; }
+        public DateTimeOffset? EndAt { get; set; }
+        public double? Latitude { get; set; }
+        public double? Longitude { get; set; }
+        public string MessageId { get; set; }
+    }
+
+    public class SharedLocationResponse : ApiResponse
+    {
+        public string ChannelCid { get; set; }
+        public DateTimeOffset CreatedAt { get; set; }
+        public string CreatedByDeviceId { get; set; }
+        public DateTimeOffset? EndAt { get; set; }
+        public double Latitude { get; set; }
+        public double Longitude { get; set; }
+        public string MessageId { get; set; }
+        public DateTimeOffset UpdatedAt { get; set; }
+        public string UserId { get; set; }
+    }
+
+    public class ActiveLiveLocationsResponse : ApiResponse
+    {
+        public SharedLocationResponse[] ActiveLiveLocations { get; set; }
+    }
+}

tests/UserClientTests.cs

@@ -78,13 +78,16 @@ private byte[] DecodeJwtBase64(string encodedStr)
             switch (encodedStr.Length % 4)
             {
                 case 0:
+
                     // No pad chars
                     break;
                 case 2:
+
                     // Two pad chars
                     encodedStr += "==";
                     break;
                 case 3:
+
                     // One pad char
                     encodedStr += "=";
                     break;
@@ -397,5 +400,107 @@ await WaitForAsync(async () =>
             exportFile.Should().Contain(_user1.Id);
             exportFile.Should().Contain(_user2.Id);
         }
+
+        [Test]
+        public async Task TestLiveLocationAsync()
+        {
+
+            var channel = await CreateChannelAsync(createdByUserId: _user1.Id, members: new[] { _user1.Id });
+
+            await EnableSharedLocationsAsync(channel);
+
+            var longitude = -122.4194;
+            var latitude = 38.999;
+
+            var location = new SharedLocationRequest
+            {
+                Longitude = longitude,
+                Latitude = latitude,
+                EndAt = DateTimeOffset.UtcNow.AddHours(1),
+                CreatedByDeviceId = "test-device",
+            };
+
+            var messageRequest = new MessageRequest
+            {
+                Text = "Test message for shared location",
+                SharedLocation = location,
+            };
+            var messageResp = await _messageClient.SendMessageAsync(
+                channel.Type,
+                channel.Id,
+                messageRequest,
+                _user1.Id);
+
+            var message = messageResp.Message;
+
+            var newLongitude = -122.4194;
+            var newLatitude = 38.999;
+
+            var newLocation = new SharedLocationRequest
+            {
+                MessageId = message.Id,
+                Longitude = newLongitude,
+                Latitude = newLatitude,
+                EndAt = DateTimeOffset.UtcNow.AddHours(10),
+                CreatedByDeviceId = "test-device",
+            };
+
+            SharedLocationResponse updateResp;
+            updateResp = await _userClient.UpdateUserLiveLocationAsync(_user1.Id, newLocation);
+
+            updateResp.Should().NotBeNull();
+            updateResp.Latitude.Should().Be(newLatitude);
+            updateResp.Longitude.Should().Be(newLongitude);
+
+            var getResp = await _userClient.GetUserActiveLiveLocationsAsync(_user1.Id);
+
+            getResp.Should().NotBeNull();
+            getResp.ActiveLiveLocations.Should().NotBeEmpty("Should have active live locations");
+
+            var newLocationResp = getResp.ActiveLiveLocations.FirstOrDefault(loc => loc.MessageId == message.Id);
+            newLocationResp.Should().NotBeNull();
+            newLocationResp.Latitude.Should().Be(newLatitude);
+            newLocationResp.Longitude.Should().Be(newLongitude);
+        }
+
+        /// <summary>
+        /// Enables shared locations for the channel by updating config overrides.
+        /// </summary>
+        private async Task EnableSharedLocationsAsync(ChannelWithConfig channel)
+        {
+            var request = new PartialUpdateChannelRequest
+            {
+                Set = new Dictionary<string, object>
+                {
+                    {
+                        "config_overrides", new Dictionary<string, object>
+                        {
+                            { "shared_locations", true },
+                        }
+                    },
+                },
+            };
+            await _channelClient.PartialUpdateAsync(channel.Type, channel.Id, request);
+        }
+
+        /// <summary>
+        /// Disables shared locations for the channel by updating config overrides.
+        /// </summary>
+        private async Task DisableSharedLocationsAsync(ChannelWithConfig channel)
+        {
+            var request = new PartialUpdateChannelRequest
+            {
+                Set = new Dictionary<string, object>
+                {
+                    {
+                        "config_overrides", new Dictionary<string, object>
+                        {
+                            { "shared_locations", false },
+                        }
+                    },
+                },
+            };
+            await _channelClient.PartialUpdateAsync(channel.Type, channel.Id, request);
+        }
     }
 }