first commit

Services/ChatService.cs

@@ -0,0 +1,138 @@
+using Fitness_core_BE.Infra.UoW;
+using Fitness_core_BE.Interfaces;
+using Fitness_core_BE.Interfaces.Services;
+using Fitness_core_BE.Models;
+using Fitness_core_BE.Helpers;
+
+namespace Fitness_core_BE.Services.Chat
+{
+    public class ChatService : IChatService
+    {
+        private const int MAX_MESSAGE_LENGTH = 100000;
+
+        private readonly IChatRepo _repository;
+        private readonly IUnitOfWork _uow;
+        private readonly IHttpContextAccessor _httpContextAccessor;
+
+        public ChatService(IChatRepo repository, IUnitOfWork uow, IHttpContextAccessor httpContextAccessor)
+        {
+            _repository = repository;
+            _uow = uow;
+            _httpContextAccessor = httpContextAccessor;
+        }
+
+        public async Task<object> GetOrCreateChatAsync(object payload)
+        {
+            var httpContext = _httpContextAccessor.HttpContext;
+            var data = DeserializePayload.Deserialize(payload);
+            Guid currentUserId= DataExtractor.GetUserIdFromContext(httpContext);
+            Guid otherUserId = DataExtractor.GetRequiredGuid(data, "otherUserId");
+
+            if (currentUserId == otherUserId)
+                throw new InvalidOperationException("Cannot create chat with yourself.");
+
+            await _uow.BeginAsync();
+
+            try
+            {
+                var existingChat =
+                    await _repository.GetChatBetweenUsersAsync(currentUserId, otherUserId);
+
+                if (existingChat != null && existingChat.IsAcitve)
+                {
+                    await _uow.CommitAsync();
+                    return existingChat;
+                }
+
+                var chat = new Models.Chat
+                {
+                    Id = Guid.NewGuid(),
+                    FKSenderId = currentUserId,
+                    FKReceiverId = otherUserId
+                };
+
+                await _repository.CreateChatAsync(chat);
+                await _uow.CommitAsync();
+
+                return chat;
+            }
+            catch
+            {
+                await _uow.RollbackAsync();
+                throw;
+            }
+        }
+
+        public async Task<object> SendMessageAsync(object payload)
+        {
+            var data = DeserializePayload.Deserialize(payload);
+            Guid chatId = DataExtractor.GetRequiredGuid(data, "chatId");
+            Guid senderId = DataExtractor.GetRequiredGuid(data, "senderId");
+            string message = DataExtractor.GetRequiredString(data, "message");
+            string type = DataExtractor.GetRequiredString(data, "type");
+
+            if (string.IsNullOrWhiteSpace(message))
+                throw new ArgumentException("Message cannot be empty.");
+
+            message = message.Trim();
+
+            if (message.Length > MAX_MESSAGE_LENGTH)
+                throw new ArgumentException($"Message exceeds {MAX_MESSAGE_LENGTH} characters.");
+
+            await _uow.BeginAsync();
+
+            try
+            {
+                var chat = await _repository.GetChatByIdAsync(chatId);
+
+                if (chat == null || !chat.IsAcitve)
+                    throw new KeyNotFoundException("Chat not found or inactive.");
+
+                if (senderId != chat.FKSenderId && senderId != chat.FKReceiverId)
+                    throw new UnauthorizedAccessException("User not part of this chat.");
+
+                var chatMessage = new ChatMessages
+                {
+                    Id = Guid.NewGuid(),
+                    FKChatId = chatId,
+                    FKSenderId = senderId,
+                    Message = message,
+                    Type = type,
+                    CreatedAt = DateTime.UtcNow,
+                    IsAcitve = true
+                };
+
+                await _repository.AddMessageAsync(chatMessage);
+                await _uow.CommitAsync();
+
+                return chatMessage;
+            }
+            catch
+            {
+                await _uow.RollbackAsync();
+                throw;
+            }
+        }
+
+        public async Task<object> GetMessagesAsync(object payload)
+        {
+            var data = DeserializePayload.Deserialize(payload);
+            Guid chatId = DataExtractor.GetRequiredGuid(data, "chatId");
+            Guid userId = DataExtractor.GetRequiredGuid(data, "userId");
+            int skip = DataExtractor.GetRequiredInt(data, "skip");
+            int take = DataExtractor.GetRequiredInt(data, "take");
+            if (take <= 0 || take > 100)
+                take = 30;
+
+            if (!await CanUserAccessChatAsync(chatId, userId))
+                throw new UnauthorizedAccessException("User not allowed to view this chat.");
+
+            return await _repository.GetMessagesAsync(chatId, skip, take);
+        }
+
+        public async Task<bool> CanUserAccessChatAsync(Guid chatId, Guid userId)
+        {
+            return await _repository.IsUserInChatAsync(chatId, userId);
+        }
+    }
+}