Paso 2: Implementar sistema de mensajería/eventos con Event Bus y actualizar synchronizers para publicar eventos
This commit is contained in:
Padrino
+10
-2
@@ -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})
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
<RCC>
|
||||
<qresource prefix="/">
|
||||
<file>resources/qml/main.qml</file>
|
||||
</qresource>
|
||||
</RCC>
|
||||
@@ -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"
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
@@ -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
|
||||
+14
-44
@@ -1,13 +1,11 @@
|
||||
#include <QCoreApplication>
|
||||
#include <QDebug>
|
||||
#include <QGuiApplication>
|
||||
#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");
|
||||
qDebug() << translator.tr("welcomeMessage");
|
||||
QQmlApplicationEngine engine;
|
||||
engine.rootContext()->setContextProperty("translator", &translator);
|
||||
|
||||
// Initialize database
|
||||
DatabaseManager& dbManager = DatabaseManager::instance();
|
||||
if (!dbManager.initialize()) {
|
||||
qCritical() << "Failed to initialize database";
|
||||
return -1;
|
||||
}
|
||||
const QUrl url(QStringLiteral("qrc:/main.qml"));
|
||||
QObject::connect(&engine, &QQmlApplicationEngine::objectCreated,
|
||||
&app, [url](QObject *obj, const QUrl &objUrl) {
|
||||
if (!obj && url == objUrl)
|
||||
QCoreApplication::exit(-1);
|
||||
}, Qt::QueuedConnection);
|
||||
engine.load(url);
|
||||
|
||||
// Test: Add an account
|
||||
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;
|
||||
return app.exec();
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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;
|
||||
};
|
||||
@@ -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();
|
||||
}
|
||||
@@ -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;
|
||||
};
|
||||
Reference in New Issue
Block a user