Server/SourceFiles/Services/ChatService.cpp - master - Shymer123/LumenServer

Server/SourceFiles/Services/ChatService.cpp
145 строк5 KB
Shymer123
Initial commit: LumenServer
20 июн 2026, 12:43
20 июн 2026, 12:43173f14c
#include "ChatService.h"
#include "Core/Utils/UuidGenerator.h"
#include <chrono>
#include <algorithm>
#include <iostream>

namespace Services {

    ChatService::ChatService(Storage::Db::Repositories::ChatRepository& chatRepo,
                             Services::MessageService& messageService)
        : m_chatRepo(chatRepo), m_messageService(messageService)
    {}

    std::vector<Data::Models::Chat> ChatService::getUserChats(const std::string& userId)
    {
        auto chats = m_chatRepo.getChatsForUser(userId);

        for(auto& chat : chats)
        {
            auto lastMsg = m_messageService.getLastMessage(chat.id);
            if(lastMsg.has_value())
            {
                chat.lastMessage = lastMsg;
            }
        }
        return chats;
    }

    std::optional<Data::Models::Chat> ChatService::createDialog(const std::string& userId,
                                                                const std::string& targetUserId)
    {
        if(userId.empty() || targetUserId.empty() || userId == targetUserId)
        {
            return std::nullopt;
        }

        if(auto existing = m_chatRepo.findDialogBetween(userId, targetUserId))
        {
            Chat chat;
            chat.id = *existing;
            chat.type = Core::Types::ChatType::Dialog;
            chat.title = "";
            chat.peerId = targetUserId;
            if(auto lastMessage = m_messageService.getLastMessage(*existing))
            {
                chat.lastMessage = lastMessage;
            }
            else
            {
                Data::Models::Message msg;
                msg.type = Core::Types::MessageType::Text;
                msg.text = "";
                msg.timestamp = std::chrono::system_clock::now();

                chat.lastMessage = msg;
            }
            return chat;
        }

        const std::string chatId = Core::Utils::generate_uuid();
        if(!m_chatRepo.createChat(chatId, "", Core::Types::ChatType::Dialog))
        {
            return std::nullopt;
        }

        std::vector<MemberInfo> members {
            MemberInfo{ userId, Core::Types::MemberRole::Member },
            MemberInfo{ targetUserId, Core::Types::MemberRole::Member }
        };
        if(!m_chatRepo.addMembers(chatId, members))
        {
            return std::nullopt;
        }

        Chat chat;
        chat.id = chatId;
        chat.type = Core::Types::ChatType::Dialog;
        chat.title = "";
        chat.peerId = targetUserId;

        Data::Models::Message msg;
        msg.type = Core::Types::MessageType::Text;
        msg.text = "";
        msg.timestamp = std::chrono::system_clock::now();
        chat.lastMessage = msg;

        return chat;
    }

    std::optional<Data::Models::Chat> ChatService::createGroup(const std::string& ownerId,
                                                               const std::string& groupName,
                                                               const std::vector<MemberInfo>& members)
    {
        if(ownerId.empty() || groupName.empty())
        {
            return std::nullopt;
        }

        const std::string chatId = Core::Utils::generate_uuid();
        if(!m_chatRepo.createChat(chatId, groupName, Core::Types::ChatType::Group))
        {
            return std::nullopt;
        }

        std::vector<MemberInfo> all = members;
        all.push_back(MemberInfo{ ownerId, Core::Types::MemberRole::Owner });

        std::sort(all.begin(), all.end(),
                  [](auto& a, auto& b){ return a.id < b.id; });
        all.erase(std::unique(all.begin(), all.end(),
                              [](auto& a, auto& b){ return a.id == b.id; }), all.end());

        if(!m_chatRepo.addMembers(chatId, all))
        {
            return std::nullopt;
        }

        auto lastMessage = m_messageService.sendSystemMessage(chatId, ownerId + " created the group " + groupName);

        Chat chat;
        chat.id = chatId;
        chat.type = Core::Types::ChatType::Group;
        chat.title = groupName;
        chat.lastMessage = lastMessage;

        return chat;
    }

    std::optional<std::vector<Data::Models::GroupMemberModel>> ChatService::addChatMembers(const std::string& chatId,
                                                                                           const std::vector<MemberInfo>& members)
    {
        auto type = m_chatRepo.getChatType(chatId);
        if(!type || *type != Core::Types::ChatType::Group) return std::nullopt;

        if(members.empty()) return std::vector<MemberInfo>{};

        if(!m_chatRepo.addMembers(chatId, members))
        {
            return std::nullopt;
        }

        return members;
    }

} // namespace Services