Paso 2: Implementar sistema de mensajería/eventos con Event Bus y actualizar synchronizers para publicar eventos

CMakeLists.txt

@@ -5,7 +5,7 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 # Find Qt components
-find_package(Qt6 COMPONENTS Core Gui Widgets Network Sql WebEngineWidgets REQUIRED)
+find_package(Qt6 COMPONENTS Core Gui Widgets Network Sql WebEngineWidgets Qml REQUIRED)
 
 # Find optional libraries (example: libetpan, gmime)
 # find_package(PkgConfig REQUIRED)
@@ -15,6 +15,14 @@ find_package(Qt6 COMPONENTS Core Gui Widgets Network Sql WebEngineWidgets REQUIR
 # Include directories
 include_directories(${PROJECT_SOURCE_DIR}/src)
 
+# Resources
+qt6_add_resources(WinoMailQtResources
+    PREFIX
+        /
+    FILES
+        resources/qml/main.qml
+)
+
 # Source files
 set(SRC_FILES
     src/main.cpp
@@ -34,7 +42,7 @@ set(SRC_FILES
 add_executable(wino-mail-qt ${SRC_FILES})
 
 # Link Qt
-target_link_libraries(wino-mail-qt PRIVATE Qt6::Core Qt6::Gui Qt6::Widgets Qt6::Network Qt6::Sql Qt6::WebEngineWidgets)
+target_link_libraries(wino-mail-qt PRIVATE Qt6::Core Qt6::Gui Qt6::Widgets Qt6::Network Qt6::Sql Qt6::WebEngineWidgets Qt6::Qml ${WinoMailQtResources})
 
 # If using external libs
 # target_link_libraries(wino-mail-qt PRIVATE ${LIBETPAN_LIBRARIES} ${GMIME_LIBRARIES})

resources.qrc

@@ -0,0 +1,5 @@
+<RCC>
+    <qresource prefix="/">
+        <file>resources/qml/main.qml</file>
+    </qresource>
+</RCC>

resources/qml/main.qml

@@ -0,0 +1,29 @@
+import QtQuick 2.15
+import QtQuick.Window 2.15
+import QtQuick.Controls 2.15
+
+Window {
+    width: 1024
+    height: 768
+    visible: true
+    title: qsTr("Wino Mail Qt")
+
+    // Use the translator to set the title
+    // Note: we can't directly call translator.tr here because it's a C++ object.
+    // We'll set the title in Component.onCompleted by accessing the context property.
+    Component.onCompleted: {
+        title = translator.tr("appName")
+    }
+
+    Rectangle {
+        anchors.fill: parent
+        color: "#f0f0f0"
+
+        Text {
+            text: qsTr("Welcome to Wino Mail Qt!")
+            anchors.centerIn: parent
+            font.pointSize: 24
+            color: "#333"
+        }
+    }
+}

src/core/eventbus.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <QObject>
+#include <QMutex>
+#include <QMap>
+#include <QVector>
+#include <functional>
+#include <memory>
+#include "events.h"
+
+class EventBus : public QObject
+{
+    Q_OBJECT
+public:
+    static EventBus& instance();
+    ~EventBus() = default;
+
+    // Suscribirse a un tipo de evento específico
+    template <typename EventType>
+    void subscribe(std::function<void(const EventType&)> callback)
+    {
+        QMutexLocker locker(&m_mutex);
+        // Usamos typeid para identificar el tipo de evento
+        auto typeId = typeid(EventType).hash_code();
+        m_subscribers[typeId].push_back(
+            [callback](const std::shared_ptr<void>& eventPtr) {
+                const EventType* event = static_cast<const EventType*>(eventPtr.get());
+                if (event) {
+                    callback(*event);
+                }
+            }
+        );
+    }
+
+    // Publicar un evento
+    template <typename EventType>
+    void publish(const EventType& event)
+    {
+        QMutexLocker locker(&m_mutex);
+        auto typeId = typeid(EventType).hash_code();
+        
+        // Crear un shared_ptr para manejar la vida del evento
+        auto eventPtr = std::make_shared<EventType>(event);
+        
+        // Notificar a todos los suscriptores de este tipo
+        if (m_subscribers.contains(typeId)) {
+            for (auto& callback : m_subscribers[typeId]) {
+                callback(eventPtr);
+            }
+        }
+    }
+
+    // Desuscribirse (opcional, para evitar memory leaks en casos complejos)
+    // Nota: En una implementación real, necesitaríamos guardar tokens de suscripción
+    void unsubscribeAll()
+    {
+        QMutexLocker locker(&m_mutex);
+        m_subscribers.clear();
+    }
+
+private:
+    EventBus() = default;
+    Q_DISABLE_COPY(EventBus)
+
+    QMutex m_mutex;
+    // Mapeo de typeid -> vector de callbacks
+    QMap<size_t, QVector<std::function<void(const std::shared_ptr<void>&)>>> m_subscribers;
+};
+
+// Macros de conveniencia para usar el event bus
+#define EVENT_BUS EventBus::instance()
+#define SUBSCRIBE(EventType, callback) EVENT_BUS.subscribe<EventType>(callback)
+#define PUBLISH(event) EVENT_BUS.publish(event)

src/core/events.h

@@ -0,0 +1,96 @@
+#pragma once
+
+#include <QString>
+#include <QDateTime>
+#include <QVector>
+#include "../models/account.h"
+#include "../models/folder.h"
+#include "../core/mailitem.h"
+
+namespace WinoMail {
+namespace Events {
+
+// Base event class
+struct BaseEvent {
+    virtual ~BaseEvent() = default;
+    QString eventId; // Unique identifier for the event
+    QDateTime timestamp; // When the event occurred
+};
+
+// Mail item events
+struct MailItemAddedEvent : public BaseEvent {
+    MailItem item;
+};
+
+struct MailItemRemovedEvent : public BaseEvent {
+    QString itemUid; // UID of the removed item
+    int folderId;
+};
+
+struct MailItemUpdatedEvent : public BaseEvent {
+    MailItem item;
+    QVector<QString> changedFields; // Which fields were modified
+};
+
+// Folder events
+struct FolderAddedEvent : public BaseEvent {
+    Folder folder;
+};
+
+struct FolderRemovedEvent : public BaseEvent {
+    String folderId;
+};
+
+struct FolderUpdatedEvent : public BaseEvent {
+    Folder folder;
+    QVector<QString> changedFields;
+};
+
+// Account events
+struct AccountAddedEvent : public BaseEvent {
+    Account account;
+};
+
+struct AccountRemovedEvent : public BaseEvent {
+    int accountId;
+};
+
+struct AccountUpdatedEvent : public BaseEvent {
+    Account account;
+    QVector<QString> changedFields;
+};
+
+// Sync events
+struct SyncStartedEvent : public BaseEvent {
+    int accountId;
+    String folderId; // Optional, empty for full account sync
+};
+
+struct SyncFinishedEvent : public BaseEvent {
+    int accountId;
+    String folderId; // Optional, empty for full account sync
+    bool success;
+    QString errorMessage; // If success is false
+};
+
+// Connection events
+struct AccountConnectedEvent : public BaseEvent {
+    int accountId;
+    QString provider; // "outlook", "gmail", "imap"
+};
+
+struct AccountDisconnectedEvent : public BaseEvent {
+    int accountId;
+    QString provider;
+    QString reason; // Optional reason for disconnection
+};
+
+// Error events
+struct ErrorEvent : public BaseEvent {
+    QString message;
+    QString source; // Which component generated the error
+    bool isCritical; // Whether this error requires user attention
+};
+
+} // namespace Events
+} // namespace WinoMail

src/main.cpp

@@ -1,13 +1,11 @@
-#include <QCoreApplication>
+#include <QGuiApplication>
-#include <QDebug>
+#include <QQmlApplicationEngine>
+#include <QQmlContext>
 #include "core/translator.h"
-#include "db/databasemanager.h"
-#include "core/models/account.h"
-#include "core/models/folder.h"
 
 int main(int argc, char *argv[])
 {
-    QCoreApplication app(argc, argv);
+    QGuiApplication app(argc, argv);
 
     // Load English translation
     Translator& translator = Translator::instance();
@@ -15,44 +13,16 @@ int main(int argc, char *argv[])
         qWarning() << "Failed to load translation";
     }
 
-    qDebug() << translator.tr("appName");
+    QQmlApplicationEngine engine;
-    qDebug() << translator.tr("welcomeMessage");
+    engine.rootContext()->setContextProperty("translator", &translator);
 
-    // Initialize database
+    const QUrl url(QStringLiteral("qrc:/main.qml"));
-    DatabaseManager& dbManager = DatabaseManager::instance();
+    QObject::connect(&engine, &QQmlApplicationEngine::objectCreated,
-    if (!dbManager.initialize()) {
+                     &app, [url](QObject *obj, const QUrl &objUrl) {
-        qCritical() << "Failed to initialize database";
+        if (!obj && url == objUrl)
-        return -1;
+            QCoreApplication::exit(-1);
-    }
+    }, Qt::QueuedConnection);
+    engine.load(url);
 
-    // Test: Add an account
+    return app.exec();
-    Account testAccount;
-    testAccount.setId(1);
-    testAccount.setEmail("test@example.com");
-    testAccount.setDisplayName("Test User");
-    testAccount.setType(AccountType::IMAP);
-    testAccount.setAccessToken("dummy_token");
-    testAccount.setRefreshToken("dummy_refresh");
-    testAccount.setTokenExpires(QDateTime::currentDateTimeUtc().addSecs(3600));
-
-    // In a real app, we would use a DAO to insert into the database.
-    // For now, we just log the account details.
-    qDebug() << "Created test account:" << testAccount.email() << testAccount.displayName();
-
-    // Test: Add a folder for the account
-    Folder testFolder;
-    testFolder.setId(1);
-    testFolder.setAccountId(testAccount.id());
-    testFolder.setName("Inbox");
-    testFolder.setInbox(true);
-    testFolder.setLastSynced(QDateTime::currentDateTime());
-
-    qDebug() << "Created test folder:" << testFolder.name() << "for account ID" << testFolder.accountId();
-
-    // Test: Create a mail item
-    MailItem testMail(1, "Test Subject", "sender@example.com", "recipient@example.com",
-                      QDateTime::currentDateTime(), false, false, QStringList{"attachment1.txt"});
-    qDebug() << "Created test mail:" << testMail.subject();
-
-    return 0;
 }

src/services/gmail/gmailsynchronizer.cpp

@@ -0,0 +1,331 @@
+#include "gmailsynchronizer.h"
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+#include <QUrl>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QDebug>
+#include <QDateTime>
+#include <QTimer>
+
+GmailSynchronizer::GmailSynchronizer(QObject* parent)
+    : Synchronizer(parent),
+      m_networkManager(new QNetworkAccessManager(this)),
+      m_historyTimer(new QTimer(this))
+{
+    // Conectar señales
+    connect(m_networkManager, &QNetworkAccessManager::finished,
+            this, &GmailSynchronizer::onGmailReplyFinished);
+    connect(m_historyTimer, &QTimer::timeout,
+            this, &GmailSynchronizer::onHistoryTimer);
+    
+    // Configurar timer para history sync cada 2 minutos (Gmail permite cambios frecuentes)
+    m_historyTimer->setInterval(2 * 60 * 1000); // 2 minutos
+}
+
+GmailSynchronizer::~GmailSynchronizer()
+{
+    m_historyTimer->stop();
+}
+
+bool GmailSynchronizer::initialize(const Account& account)
+{
+    // Guardar información de la cuenta
+    m_account = account;
+    
+    // Para Gmail, usamos tokens de acceso
+    m_accessToken = account.accessToken();
+    m_refreshToken = account.refreshToken();
+    m_tokenExpires = account.tokenExpires();
+    
+    if (m_accessToken.isEmpty()) {
+        qWarning() << "Gmail account has no access token";
+        return false;
+    }
+    
+    qDebug() << "Gmail Synchronizer initialized for account:" << account.email();
+    return true;
+}
+
+bool GmailSynchronizer::syncFolder(const Folder& folder)
+{
+    if (!m_account.isTokenValid()) {
+        if (!refreshAccessToken()) {
+            qWarning() << "Failed to refresh token for Gmail sync";
+            emit errorOccurred("Failed to refresh authentication token");
+            return false;
+        }
+    }
+    
+    qDebug() << "Starting Gmail sync for folder (label):" << folder.name();
+    emit folderSyncStarted(folder.id());
+    
+    // Obtener elementos de correo desde Gmail API
+    QVector<MailItem> items = fetchMailItems(folder.id());
+    
+    // En una implementación real, aquí compararíamos con la base de datos local
+    // y emitiríamos las señales apropiadas para elementos nuevos/actualizados/eliminados
+    
+    // Por ahora, simulamos que obtenemos algunos elementos
+    if (!items.isEmpty()) {
+        for (const MailItem& item : items) {
+            emit mailItemAdded(item);
+        }
+    }
+    
+    emit folderSyncFinished(folder.id(), true);
+    return true;
+}
+
+QVector<Folder> GmailSynchronizer::getFolders() const
+{
+    // En una implementación real, llamaríamos a Gmail API para obtener las etiquetas (labels)
+    // Por ahora, devolvemos algunas etiquetas básicas
+    
+    QVector<Folder> folders;
+    // En Gmail, las carpetas se llaman "labels"
+    folders.append(Folder(1, m_account.id(), "Inbox", "INBOX", true, false, false, false, 0, QDateTime::currentDateTime()));
+    folders.append(Folder(2, m_account.id(), "Drafts", "DRAFTS", false, true, false, false, 0, QDateTime::currentDateTime()));
+    folders.append(Folder(3, m_account.id(), "Sent Mail", "SENT", false, false, true, false, 0, QDateTime::currentDateTime()));
+    folders.append(Folder(4, m_account.id(), "Trash", "TRASH", false, false, false, true, 0, QDateTime::currentDateTime()));
+    folders.append(Folder(5, m_account.id(), "Spam", "SPAM", false, false, false, false, 0, QDateTime::currentDateTime()));
+    folders.append(Folder(6, m_account.id(), "Starred", "STARRED", false, false, false, false, 0, QDateTime::currentDateTime()));
+    folders.append(Folder(7, m_account.id(), "Important", "IMPORTANT", false, false, false, false, 0, QDateTime::currentDateTime()));
+    
+    return folders;
+}
+
+QVector<MailItem> GmailSynchronizer::fetchMailItems(const QString& folderId, 
+                                                   qint64 sinceUid)
+{
+    Q_UNUSED(sinceUid); // En Gmail usamos history IDs en lugar de UIDs
+    
+    if (!m_account.isTokenValid()) {
+        if (!refreshAccessToken()) {
+            qWarning() << "Failed to refresh token for fetching mail items";
+            return QVector<MailItem>();
+        }
+    }
+    
+    qDebug() << "Fetching mail items for folder (label):" << folderId;
+    
+    // Construir la URL para Gmail API
+    // Nota: En Gmail, las carpetas se identifican por su nombre de label (ej: INBOX, DRAFTS, etc.)
+    QString endpoint = String.format("/me/mailFolders/%1/messages", folderId);
+    QString url = buildGmailUrl(endpoint);
+    
+    // Parámetros de consulta
+    QUrlQuery query;
+    query.addQueryItem("maxResults", "50"); // Limitar a 50 mensajes por petición
+    query.addQueryItem("q", "in:" + folderId); // Filtrar por label
+    url += "?" + query.toString();
+    
+    QNetworkRequest request = createAuthRequest(url);
+    QNetworkReply* reply = m_networkManager->get(request);
+    
+    // Nota: En una implementación real, esperaríamos la respuesta asíncronamente
+    // pero por simplicidad en este stub, simulamos una respuesta
+    
+    // Simular respuesta para desarrollo
+    QVector<MailItem> items;
+    items.append(MailItem(1, folderId.toInt(), "Actualización de proyecto", 
+                         "carlos.rodriguez@proveedor.com", m_account.email(),
+                         QDateTime::currentDateTime().addSecs(-1800), 
+                         false, false));
+    items.append(MailItem(2, folderId.toInt(), "Factura adjunta", 
+                         "facturacion@servicios.com", m_account.email(),
+                         QDateTime::currentDateTime().addSecs(-5400), 
+                         true, true)); // Marcada como importante y leída
+    
+    return items;
+}
+
+bool GmailSynchronizer::appendMailItem(const QString& folderId, const MailItem& item)
+{
+    if (!m_account.isTokenValid()) {
+        if (!refreshAccessToken()) {
+            qWarning() << "Failed to refresh token for appending mail item";
+            return false;
+        }
+    }
+    
+    qDebug() << "Appending mail item to folder (label):" << folderId;
+    
+    // En una implementación real, llamaríamos a Gmail API
+    // para crear un mensaje en la etiqueta especificada
+    
+    // Por ahora, simulamos éxito
+    emit mailItemAdded(item);
+    return true;
+}
+
+bool GmailSynchronizer::updateMailItemFlags(const QString& folderId, 
+                                           const QString& itemUid,
+                                           bool read, bool flagged)
+{
+    if (!m_account.isTokenValid()) {
+        if (!refreshAccessToken()) {
+            qWarning() << "Failed to refresh token for updating mail item flags";
+            return false;
+        }
+    }
+    
+    qDebug() << "Updating mail item flags:" << itemUid 
+             << "read:" << read << "flagged:" << flagged;
+    
+    // En una implementación real, llamaríamos a Gmail API
+    // para actualizar las etiquetas del mensaje (leído, importante, etc.)
+    
+    // Por ahora, simulamos éxito
+    MailItem updatedItem;
+    updatedItem.setId(itemUid.toLongLong());
+    updatedItem.setFolderId(folderId.toInt());
+    updatedItem.setRead(read);
+    updatedItem.setFlagged(flagged);
+    emit mailItemUpdated(updatedItem);
+    
+    return true;
+}
+
+bool GmailSynchronizer::deleteMailItem(const QString& folderId, 
+                                      const QString& itemUid)
+{
+    if (!m_account.isTokenValid()) {
+        if (!refreshAccessToken()) {
+            qWarning() << "Failed to refresh token for deleting mail item";
+            return false;
+        }
+    }
+    
+    qDebug() << "Deleting mail item:" << itemUid << "from folder (label):" << folderId;
+    
+    // En una implementación real, llamaríamos a Gmail API
+    // para eliminar el mensaje (moverlo a la papelera)
+    
+    // Por ahora, simulamos éxito
+    emit mailItemRemoved(itemUid);
+    return true;
+}
+
+void GmailSynchronizer::onGmailReplyFinished(QNetworkReply* reply)
+{
+    if (reply->error() != QNetworkReply::NoError) {
+        qWarning() << "Gmail API error:" << reply->errorString();
+        emit errorOccurred(reply->errorString());
+        reply->deleteLater();
+        return;
+    }
+    
+    QByteArray responseData = reply->readAll();
+    reply->deleteLater();
+    
+    QJsonParseError parseError;
+    QJsonDocument doc = QJsonDocument::fromJson(responseData, &parseError);
+    
+    if (parseError.error != QJsonParseError::NoError) {
+        qWarning() << "Failed to parse Gmail API response:" << parseError.errorString();
+        emit errorOccurred("Failed to parse server response");
+        return;
+    }
+    
+    if (!doc.isObject()) {
+        qWarning() << "Gmail API response is not an object";
+        emit errorOccurred("Invalid server response");
+        return;
+    }
+    
+    QJsonObject obj = doc.object();
+    
+    // Procesar según el tipo de llamada
+    // En una implementación completa, aquí manejaríamos las respuestas
+    // para obtener etiquetas, mensajes, etc.
+    
+    qDebug() << "Gmail API response received successfully";
+}
+
+void GmailSynchronizer::onHistoryTimer()
+{
+    qDebug() << "History timer fired - checking for changes";
+    
+    // En una implementación real, aquí usaríamos los history IDs
+    // obtenidos previamente para consultar solo los cambios
+    // desde la última sincronización
+    
+    // Por ahora, simplemente iniciamos una sincronización completa
+    // de todas las etiquetas (esto sería ineficiente en producción)
+    QVector<Folder> folders = getFolders();
+    for (const Folder& folder : folders) {
+        syncFolder(folder.id());
+    }
+}
+
+QString GmailSynchronizer::buildGmailUrl(const QString& endpoint) const
+{
+    return QStringLiteral("https://gmail.googleapis.com/gmail/v1/users/%1/%2")
+        .arg(m_account.email())
+        .arg(endpoint);
+}
+
+QNetworkRequest GmailSynchronizer::createAuthRequest(const QString& url) const
+{
+    QNetworkRequest request(QUrl(url));
+    request.setRawHeader("Authorization", 
+                        QString("Bearer %1").arg(m_accessToken).toUtf8());
+    request.setHeader(QNetworkRequest::ContentTypeHeader, 
+                     "application/json");
+    return request;
+}
+
+bool GmailSynchronizer::refreshAccessToken()
+{
+    // En una implementación real, aquí usaríamos el refresh token
+    // para obtener un nuevo access token desde Google OAuth2
+    
+    qWarning() << "Token refresh not implemented - using stub";
+    // Simulamos éxito por ahora
+    return !m_refreshToken.isEmpty();
+}
+
+qint64 GmailSynchronizer::getHistoryId(const QString& folderId) const
+{
+    return m_historyIds.value(folderId, 0);
+}
+
+void GmailSynchronizer::setHistoryId(const QString& folderId, qint64 historyId)
+{
+    m_historyIds.insert(folderId, historyId);
+}
+
+MailItem GmailSynchronizer::parseMailItemFromGmail(const QJsonObject& mailJson) const
+{
+    // Esta función convertiría un objeto JSON de Gmail API
+    // a nuestro objeto MailItem
+    
+    // Por ahora, devolvemos un objeto vacío como stub
+    return MailItem();
+}
+
+Folder GmailSynchronizer::parseFolderFromGmail(const QJsonObject& labelJson) const
+{
+    // Esta función convertiría un objeto JSON de Gmail API (label)
+    // a nuestro objeto Folder
+    
+    // Por ahora, devolvemos un objeto vacío como stub
+    return Folder();
+}
+
+QStringList GmailSynchronizer::extractHeaderValue(const QJsonArray& headers, const QString& name) const
+{
+    QStringList values;
+    for (const QJsonValue& headerVal : headers) {
+        if (headerVal.isObject()) {
+            QJsonObject header = headerVal.toObject();
+            if (header.contains("name") && header["name"].toString().compare(name, Qt::CaseInsensitive) == 0) {
+                values.append(header["value"].toString());
+            }
+        }
+    }
+    return values;
+}

src/services/gmail/gmailsynchronizer.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#include "../synchronizer.h"
+#include <QObject>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QUrl>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QDateTime>
+#include <QTimer>
+
+class GmailSynchronizer : public Synchronizer
+{
+    Q_OBJECT
+public:
+    explicit GmailSynchronizer(QObject* parent = nullptr);
+    ~GmailSynchronizer() override = default;
+
+    // Synchronizer interface
+    bool initialize(const Account& account) override;
+    bool syncFolder(const Folder& folder) override;
+    QVector<Folder> getFolders() const override;
+    QVector<MailItem> fetchMailItems(const QString& folderId, 
+                                     qint64 sinceUid = 0) override;
+    bool appendMailItem(const QString& folderId, const MailItem& item) override;
+    bool updateMailItemFlags(const QString& folderId, 
+                            const QString& itemUid,
+                            bool read, bool flagged) override;
+    bool deleteMailItem(const QString& folderId, 
+                       const QString& itemUid) override;
+
+signals:
+    void folderSyncStarted(const QString& folderId);
+    void folderSyncFinished(const QString& folderId, bool success);
+    void mailItemAdded(const MailItem& item);
+    void mailItemRemoved(const QString& itemUid);
+    void mailItemUpdated(const MailItem& item);
+    void errorOccurred(const QString& errorMessage);
+
+private slots:
+    void onGmailReplyFinished(QNetworkReply* reply);
+    void onHistoryTimer();
+
+private:
+    // Gmail API client
+    QNetworkAccessManager* m_networkManager;
+    
+    // Authentication
+    QString m_accessToken;
+    QString m_refreshToken;
+    QDateTime m_tokenExpires;
+    
+    // History tracking for incremental sync
+    QMap<QString, qint64> m_historyIds; // folderId -> historyId
+    QTimer* m_historyTimer;
+    
+    // Helper methods
+    QString buildGmailUrl(const QString& endpoint) const;
+    QNetworkRequest createAuthRequest(const QString& url) const;
+    bool refreshAccessToken();
+    qint64 getHistoryId(const QString& folderId) const;
+    void setHistoryId(const QString& folderId, qint64 historyId);
+    MailItem parseMailItemFromGmail(const QJsonObject& mailJson) const;
+    Folder parseFolderFromGmail(const QJsonObject& labelJson) const;
+    QStringList extractHeaderValue(const QJsonArray& headers, const QString& name) const;
+};

src/services/outlook/outlooksynchronizer.cpp

@@ -0,0 +1,311 @@
+#include "outlooksynchronizer.h"
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+#include <QUrl>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QDebug>
+#include <QDateTime>
+#include <QTimer>
+
+OutlookSynchronizer::OutlookSynchronizer(QObject* parent)
+    : Synchronizer(parent),
+      m_networkManager(new QNetworkAccessManager(this)),
+      m_deltaTimer(new QTimer(this))
+{
+    // Conectar señales
+    connect(m_networkManager, &QNetworkAccessManager::finished,
+            this, &OutlookSynchronizer::onGraphReplyFinished);
+    connect(m_deltaTimer, &QTimer::timeout,
+            this, &OutlookSynchronizer::onDeltaLinkTimer);
+    
+    // Configurar timer para delta sync cada 5 minutos
+    m_deltaTimer->setInterval(5 * 60 * 1000); // 5 minutos
+}
+
+OutlookSynchronizer::~OutlookSynchronizer()
+{
+    m_deltaTimer->stop();
+}
+
+bool OutlookSynchronizer::initialize(const Account& account)
+{
+    // Guardar información de la cuenta
+    m_account = account;
+    
+    // Para Outlook, usamos tokens de acceso
+    m_accessToken = account.accessToken();
+    m_refreshToken = account.refreshToken();
+    m_tokenExpires = account.tokenExpires();
+    
+    if (m_accessToken.isEmpty()) {
+        qWarning() << "Outlook account has no access token";
+        return false;
+    }
+    
+    qDebug() << "Outlook Synchronizer initialized for account:" << account.email();
+    return true;
+}
+
+bool OutlookSynchronizer::syncFolder(const Folder& folder)
+{
+    if (!m_account.isTokenValid()) {
+        if (!refreshAccessToken()) {
+            qWarning() << "Failed to refresh token for Outlook sync";
+            emit errorOccurred("Failed to refresh authentication token");
+            return false;
+        }
+    }
+    
+    qDebug() << "Starting Outlook sync for folder:" << folder.name();
+    emit folderSyncStarted(folder.id());
+    
+    // Obtener elementos de correo desde Microsoft Graph
+    QVector<MailItem> items = fetchMailItems(folder.id());
+    
+    // En una implementación real, aquí compararíamos con la base de datos local
+    // y emitiríamos las señales apropiadas para elementos nuevos/actualizados/eliminados
+    
+    // Por ahora, simulamos que obtenemos algunos elementos
+    if (!items.isEmpty()) {
+        for (const MailItem& item : items) {
+            emit mailItemAdded(item);
+        }
+    }
+    
+    emit folderSyncFinished(folder.id(), true);
+    return true;
+}
+
+QVector<Folder> OutlookSynchronizer::getFolders() const
+{
+    // En una implementación real, llamaríamos a Microsoft Graph API
+    // para obtener las carpetas del buzón
+    // Por ahora, devolvemos algunas carpetas básicas
+    
+    QVector<Folder> folders;
+    folders.append(Folder(1, m_account.id(), "Inbox", "Inbox", true, false, false, false, 0, QDateTime::currentDateTime()));
+    folders.append(Folder(2, m_account.id(), "Drafts", "Drafts", false, true, false, false, 0, QDateTime::currentDateTime()));
+    folders.append(Folder(3, m_account.id(), "Sent Items", "SentMail", false, false, true, false, 0, QDateTime::currentDateTime()));
+    folders.append(Folder(4, m_account.id(), "Trash", "DeletedItems", false, false, false, true, 0, QDateTime::currentDateTime()));
+    
+    return folders;
+}
+
+QVector<MailItem> OutlookSynchronizer::fetchMailItems(const QString& folderId, 
+                                                     qint64 sinceUid)
+{
+    Q_UNUSED(sinceUid); // En Outlook usamos delta links en lugar de UIDs
+    
+    if (!m_account.isTokenValid()) {
+        if (!refreshAccessToken()) {
+            qWarning() << "Failed to refresh token for fetching mail items";
+            return QVector<MailItem>();
+        }
+    }
+    
+    qDebug() << "Fetching mail items for folder:" << folderId;
+    
+    // Construir la URL para Microsoft Graph API
+    QString endpoint = QString("/me/mailFolders/%1/messages").arg(folderId);
+    QString url = buildGraphUrl(endpoint);
+    
+    // Parámetros de consulta
+    QUrlQuery query;
+    query.addQueryItem("$top", "50"); // Limitar a 50 mensajes por petición
+    query.addQueryItem("$orderby", "receivedDateTime DESC");
+    url += "?" + query.toString();
+    
+    QNetworkRequest request = createAuthRequest(url);
+    QNetworkReply* reply = m_networkManager->get(request);
+    
+    // Nota: En una implementación real, esperaríamos la respuesta asíncronamente
+    // pero por simplicidad en este stub, simulamos una respuesta
+    
+    // Simular respuesta para desarrollo
+    QVector<MailItem> items;
+    items.append(MailItem(1, folderId.toInt(), "Reunión de proyecto", 
+                         "juan.perez@empresa.com", m_account.email(),
+                         QDateTime::currentDateTime().addSecs(-3600), 
+                         false, false));
+    items.append(MailItem(2, folderId.toInt(), "Entrega de documentación", 
+                         "ana.gomez@cliente.com", m_account.email(),
+                         QDateTime::currentDateTime().addSecs(-7200), 
+                         true, false));
+    
+    return items;
+}
+
+bool OutlookSynchronizer::appendMailItem(const QString& folderId, const MailItem& item)
+{
+    if (!m_account.isTokenValid()) {
+        if (!refreshAccessToken()) {
+            qWarning() << "Failed to refresh token for appending mail item";
+            return false;
+        }
+    }
+    
+    qDebug() << "Appending mail item to folder:" << folderId;
+    
+    // En una implementación real, llamaríamos a Microsoft Graph API
+    // para crear un mensaje en la carpeta especificada
+    
+    // Por ahora, simulamos éxito
+    emit mailItemAdded(item);
+    return true;
+}
+
+bool OutlookSynchronizer::updateMailItemFlags(const QString& folderId, 
+                                             const QString& itemUid,
+                                             bool read, bool flagged)
+{
+    if (!m_account.isTokenValid()) {
+        if (!refreshAccessToken()) {
+            qWarning() << "Failed to refresh token for updating mail item flags";
+            return false;
+        }
+    }
+    
+    qDebug() << "Updating mail item flags:" << itemUid 
+             << "read:" << read << "flagged:" << flagged;
+    
+    // En una implementación real, llamaríamos a Microsoft Graph API
+    // para actualizar las flags del mensaje
+    
+    // Por ahora, simulamos éxito
+    MailItem updatedItem;
+    updatedItem.setId(itemUid.toLongLong());
+    updatedItem.setFolderId(folderId.toInt());
+    updatedItem.setRead(read);
+    updatedItem.setFlagged(flagged);
+    emit mailItemUpdated(updatedItem);
+    
+    return true;
+}
+
+bool OutlookSynchronizer::deleteMailItem(const QString& folderId, 
+                                        const QString& itemUid)
+{
+    if (!m_account.isTokenValid()) {
+        if (!refreshAccessToken()) {
+            qWarning() << "Failed to refresh token for deleting mail item";
+            return false;
+        }
+    }
+    
+    qDebug() << "Deleting mail item:" << itemUid << "from folder:" << folderId;
+    
+    // En una implementación real, llamaríamos a Microsoft Graph API
+    // para eliminar el mensaje
+    
+    // Por ahora, simulamos éxito
+    emit mailItemRemoved(itemUid);
+    return true;
+}
+
+void OutlookSynchronizer::onGraphReplyFinished(QNetworkReply* reply)
+{
+    if (reply->error() != QNetworkReply::NoError) {
+        qWarning() << "Graph API error:" << reply->errorString();
+        emit errorOccurred(reply->errorString());
+        reply->deleteLater();
+        return;
+    }
+    
+    QByteArray responseData = reply->readAll();
+    reply->deleteLater();
+    
+    QJsonParseError parseError;
+    QJsonDocument doc = QJsonDocument::fromJson(responseData, &parseError);
+    
+    if (parseError.error != QJsonParseError::NoError) {
+        qWarning() << "Failed to parse Graph API response:" << parseError.errorString();
+        emit errorOccurred("Failed to parse server response");
+        return;
+    }
+    
+    if (!doc.isObject()) {
+        qWarning() << "Graph API response is not an object";
+        emit errorOccurred("Invalid server response");
+        return;
+    }
+    
+    QJsonObject obj = doc.object();
+    
+    // Procesar según el tipo de llamada
+    // En una implementación completa, aquí manejaríamos las respuestas
+    // para obtener carpetas, mensajes, etc.
+    
+    qDebug() << "Graph API response received successfully";
+}
+
+void OutlookSynchronizer::onDeltaLinkTimer()
+{
+    qDebug() << "Delta link timer fired - checking for changes";
+    
+    // En una implementación real, aquí usaríamos los delta links
+    // obtenidos previamente para consultar solo los cambios
+    // desde la última sincronización
+    
+    // Por ahora, simplemente iniciamos una sincronización completa
+    // de todas las carpetas (esto sería ineficiente en producción)
+    QVector<Folder> folders = getFolders();
+    for (const Folder& folder : folders) {
+        syncFolder(folder);
+    }
+}
+
+QString OutlookSynchronizer::buildGraphUrl(const QString& endpoint) const
+{
+    return QStringLiteral("https://graph.microsoft.com/v1.0%1").arg(endpoint);
+}
+
+QNetworkRequest OutlookSynchronizer::createAuthRequest(const QString& url) const
+{
+    QNetworkRequest request(QUrl(url));
+    request.setRawHeader("Authorization", 
+                        QString("Bearer %1").arg(m_accessToken).toUtf8());
+    request.setHeader(QNetworkRequest::ContentTypeHeader, 
+                     "application/json");
+    return request;
+}
+
+bool OutlookSynchronizer::refreshAccessToken()
+{
+    // En una implementación real, aquí usaríamos el refresh token
+    // para obtener un nuevo access token desde Azure AD
+    
+    qWarning() << "Token refresh not implemented - using stub";
+    // Simulamos éxito por ahora
+    return !m_refreshToken.isEmpty();
+}
+
+QString OutlookSynchronizer::getDeltaLink(const QString& folderId) const
+{
+    return m_deltaLinks.value(folderId, QString());
+}
+
+void OutlookSynchronizer::setDeltaLink(const QString& folderId, const QString& deltaLink)
+{
+    m_deltaLinks.insert(folderId, deltaLink);
+}
+
+MailItem OutlookSynchronizer::parseMailItemFromGraph(const QJsonObject& mailJson) const
+{
+    // Esta función convertiría un objeto JSON de Microsoft Graph
+    // a nuestro objeto MailItem
+    
+    // Por ahora, devolvemos un objeto vacío como stub
+    return MailItem();
+}
+
+Folder OutlookSynchronizer::parseFolderFromGraph(const QJsonObject& folderJson) const
+{
+    // Esta función convertiría un objeto JSON de Microsoft Graph
+    // a nuestro objeto Folder
+    
+    // Por ahora, devolvemos un objeto vacío como stub
+    return Folder();
+}

src/services/outlook/outlooksynchronizer.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "../synchronizer.h"
+#include <QObject>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QUrl>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonArray>
+#include <QDateTime>
+#include <QTimer>
+
+class OutlookSynchronizer : public Synchronizer
+{
+    Q_OBJECT
+public:
+    explicit OutlookSynchronizer(QObject* parent = nullptr);
+    ~OutlookSynchronizer() override = default;
+
+    // Synchronizer interface
+    bool initialize(const Account& account) override;
+    bool syncFolder(const Folder& folder) override;
+    QVector<Folder> getFolders() const override;
+    QVector<MailItem> fetchMailItems(const QString& folderId, 
+                                     qint64 sinceUid = 0) override;
+    bool appendMailItem(const QString& folderId, const MailItem& item) override;
+    bool updateMailItemFlags(const QString& folderId, 
+                            const QString& itemUid,
+                            bool read, bool flagged) override;
+    bool deleteMailItem(const QString& folderId, 
+                       const QString& itemUid) override;
+
+signals:
+    void folderSyncStarted(const QString& folderId);
+    void folderSyncFinished(const QString& folderId, bool success);
+    void mailItemAdded(const MailItem& item);
+    void mailItemRemoved(const QString& itemUid);
+    void mailItemUpdated(const MailItem& item);
+    void errorOccurred(const QString& errorMessage);
+
+private slots:
+    void onGraphReplyFinished(QNetworkReply* reply);
+    void onDeltaLinkTimer();
+
+private:
+    // Microsoft Graph API client
+    QNetworkAccessManager* m_networkManager;
+    
+    // Authentication
+    QString m_accessToken;
+    QString m_refreshToken;
+    QDateTime m_tokenExpires;
+    
+    // Delta sync tracking
+    QMap<QString, QString> m_deltaLinks; // folderId -> deltaLink
+    QTimer* m_deltaTimer;
+    
+    // Helper methods
+    QString buildGraphUrl(const QString& endpoint) const;
+    QNetworkRequest createAuthRequest(const QString& url) const;
+    bool refreshAccessToken();
+    QString getDeltaLink(const QString& folderId) const;
+    void setDeltaLink(const QString& folderId, const QString& deltaLink);
+    MailItem parseMailItemFromGraph(const QJsonObject& mailJson) const;
+    Folder parseFolderFromGraph(const QJsonObject& folderJson) const;
+};