#include <widgets/modest-window-mgr.h>
#include <modest-account-settings-dialog.h>
#include <maemo/modest-maemo-utils.h>
-
+#include <modest-signal-mgr.h>
+#include <modest-debug.h>
#include "modest-tny-account-store.h"
#include "modest-tny-platform-factory.h"
TnySessionCamel *session;
TnyDevice *device;
- gulong acc_inserted_handler;
- gulong acc_changed_handler;
- gulong acc_removed_handler;
- gulong volume_mounted_handler;
- gulong volume_unmounted_handler;
+ GSList *sighandlers;
/* We cache the lists of accounts here */
TnyList *store_accounts;
TnyList *transport_accounts;
TnyList *store_accounts_outboxes;
-
+
/* Matches transport accounts and outbox folder */
GHashTable *outbox_of_transport;
};
priv->account_mgr = NULL;
priv->session = NULL;
priv->device = NULL;
+ priv->sighandlers = NULL;
priv->outbox_of_transport = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
/* This is a singleton, so it does not need to be unrefed. */
monitor = gnome_vfs_get_volume_monitor();
- priv->volume_mounted_handler = g_signal_connect (G_OBJECT(monitor),
- "volume-mounted",
- G_CALLBACK(on_vfs_volume_mounted),
- obj);
+ priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
+ G_OBJECT(monitor),
+ "volume-mounted",
+ G_CALLBACK(on_vfs_volume_mounted),
+ obj);
+ priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
+ G_OBJECT(monitor), "volume-unmounted",
+ G_CALLBACK(on_vfs_volume_unmounted),
+ obj);
+}
- priv->volume_unmounted_handler = g_signal_connect (G_OBJECT(monitor), "volume-unmounted",
- G_CALLBACK(on_vfs_volume_unmounted),
- obj);
+/* disconnect the list of TnyAccounts */
+static void
+account_disconnect (TnyAccount *account)
+{
+ g_return_if_fail (account && TNY_IS_ACCOUNT(account));
+ tny_camel_account_set_online (TNY_CAMEL_ACCOUNT(account), FALSE, NULL, NULL);
}
+
/* disconnect the list of TnyAccounts */
static void
-foreach_account_disconnect (gpointer data,
- gpointer user_data)
+account_verify_last_ref (TnyAccount *account, const gchar *str)
{
- tny_camel_account_set_online (TNY_CAMEL_ACCOUNT(data), FALSE, NULL, NULL);
+ gchar *txt;
+
+ g_return_if_fail (account && TNY_IS_ACCOUNT(account));
+
+ txt = g_strdup_printf ("%s: %s", str ? str : "?", tny_account_get_name(account));
+ MODEST_DEBUG_VERIFY_OBJECT_LAST_REF(G_OBJECT(account),txt);
+ g_free (txt);
}
+
+
static void
foreach_account_append_to_list (gpointer data,
gpointer user_data)
{
TnyList *list;
-
+
list = TNY_LIST (user_data);
tny_list_append (list, G_OBJECT (data));
}
if (found) {
/* Remove from the list */
tny_list_remove (priv->store_accounts, G_OBJECT (mmc_account));
-
+
/* Notify observers */
g_signal_emit (G_OBJECT (self),
signals [ACCOUNT_REMOVED_SIGNAL],
}
}
-
-static gboolean
-update_tny_account_for_account (ModestTnyAccountStore *self, ModestAccountMgr *acc_mgr,
- const gchar *account_name, TnyAccountType type)
+static void
+on_account_changed (ModestAccountMgr *acc_mgr,
+ const gchar *account_name,
+ TnyAccountType account_type,
+ gpointer user_data)
{
+ ModestTnyAccountStore *self = MODEST_TNY_ACCOUNT_STORE(user_data);
ModestTnyAccountStorePrivate *priv;
TnyList* account_list;
gboolean found = FALSE;
TnyIterator *iter = NULL;
- g_return_val_if_fail (self, FALSE);
- g_return_val_if_fail (account_name, FALSE);
- g_return_val_if_fail (type == TNY_ACCOUNT_TYPE_STORE ||
- type == TNY_ACCOUNT_TYPE_TRANSPORT,
- FALSE);
-
priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
- account_list = (type == TNY_ACCOUNT_TYPE_STORE ? priv->store_accounts : priv->transport_accounts);
+ account_list = (account_type == TNY_ACCOUNT_TYPE_STORE ?
+ priv->store_accounts :
+ priv->transport_accounts);
iter = tny_list_create_iterator (account_list);
while (!tny_iterator_is_done (iter) && !found) {
TnyAccount *tny_account;
tny_account = TNY_ACCOUNT (tny_iterator_get_current (iter));
if (tny_account) {
- const gchar* parent_name =
- modest_tny_account_get_parent_modest_account_name_for_server_account (tny_account);
- if (parent_name && strcmp (parent_name, account_name) == 0) {
- found = TRUE;
- modest_tny_account_update_from_account (tny_account, acc_mgr, account_name, type);
- g_signal_emit (G_OBJECT(self), signals[ACCOUNT_CHANGED_SIGNAL], 0, tny_account);
+ TnyConnectionStatus conn_status = tny_account_get_connection_status (tny_account);
+
+ if (conn_status != TNY_CONNECTION_STATUS_RECONNECTING &&
+ conn_status != TNY_CONNECTION_STATUS_INIT) {
+ if (!strcmp (tny_account_get_id (tny_account), account_name)) {
+ found = TRUE;
+ modest_tny_account_update_from_account (tny_account);
+ g_signal_emit (G_OBJECT(self), signals[ACCOUNT_CHANGED_SIGNAL], 0, tny_account);
+ }
}
g_object_unref (tny_account);
}
if (iter)
g_object_unref (iter);
-
- return found;
-}
-
-
-static void
-on_account_changed (ModestAccountMgr *acc_mgr,
- const gchar *account_name,
- gpointer user_data)
-{
- ModestTnyAccountStore *self = MODEST_TNY_ACCOUNT_STORE(user_data);
-
- g_debug ("DEBUG: modest: %s\n", __FUNCTION__);
-
- /* Ignore the change if it's a change in the last_updated value */
-// if (key && g_str_has_suffix ((const gchar *) key, MODEST_ACCOUNT_LAST_UPDATED))
-// return;
-
- if (!update_tny_account_for_account (self, acc_mgr, account_name, TNY_ACCOUNT_TYPE_STORE))
- g_warning ("%s: failed to update store account for %s", __FUNCTION__, account_name);
- if (!update_tny_account_for_account (self, acc_mgr, account_name, TNY_ACCOUNT_TYPE_TRANSPORT))
- g_warning ("%s: failed to update transport account for %s", __FUNCTION__, account_name);
}
static void
show_password_warning_only ()
{
ModestWindow *main_window =
- modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ());
-
+ modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (), FALSE); /* don't create */
+
/* Show an explanatory temporary banner: */
- hildon_banner_show_information (
- GTK_WIDGET(main_window), NULL, _("mcen_ib_username_pw_incorrect"));
+ if (main_window)
+ hildon_banner_show_information (
+ GTK_WIDGET(main_window), NULL, _("mcen_ib_username_pw_incorrect"));
+ else
+ g_warning ("%s: %s", __FUNCTION__, _("mcen_ib_username_pw_incorrect"));
}
-
+
+
static void
show_wrong_password_dialog (TnyAccount *account)
{
/* This is easier than using a struct for the user_data: */
ModestTnyAccountStore *self = modest_runtime_get_account_store();
ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
-
- const gchar *modest_account_name =
- modest_tny_account_get_parent_modest_account_name_for_server_account (account);
+ ModestWindow *main_window;
+ const gchar *modest_account_name;
+
+ main_window = modest_window_mgr_get_main_window (modest_runtime_get_window_mgr (),
+ FALSE); /* don't create */
+ if (!main_window) {
+ g_warning ("%s: password was wrong; ignoring because no main window", __FUNCTION__);
+ return;
+ }
+
+ modest_account_name = modest_tny_account_get_parent_modest_account_name_for_server_account (account);
if (!modest_account_name) {
g_warning ("%s: modest_tny_account_get_parent_modest_account_name_for_server_account() failed.\n",
__FUNCTION__);
}
ModestAccountSettingsDialog *dialog = dialog_as_gpointer;
- ModestWindow *main_window =
- modest_window_mgr_get_main_window (modest_runtime_get_window_mgr ());
-
gboolean created_dialog = FALSE;
if (!found || !dialog) {
dialog = modest_account_settings_dialog_new ();
modest_account_settings_dialog_set_account_name (dialog, modest_account_name);
modest_account_settings_dialog_switch_to_user_info (dialog);
+ modest_window_mgr_set_modal (modest_runtime_get_window_mgr (), GTK_WINDOW (dialog));
g_hash_table_insert (priv->account_settings_dialog_hash, g_strdup (modest_account_name), dialog);
}
/* Show an explanatory temporary banner: */
- hildon_banner_show_information (
- GTK_WIDGET(dialog), NULL, _("mcen_ib_username_pw_incorrect"));
+ hildon_banner_show_information (GTK_WIDGET(dialog), NULL, _("mcen_ib_username_pw_incorrect"));
if (created_dialog) {
/* Forget it when it closes: */
gboolean *cancel,
gboolean *remember)
{
- g_signal_emit (G_OBJECT(account_store), signals[PASSWORD_REQUESTED_SIGNAL], 0,
- server_account_id, /* server_account_name */
- username, password, cancel, remember);
+ g_signal_emit (G_OBJECT(account_store), signals[PASSWORD_REQUESTED_SIGNAL], 0,
+ server_account_id, /* server_account_name */
+ username, password, cancel, remember);
}
/* This callback will be called by Tinymail when it needs the password
/* TODO: Settting cancel to FALSE does not actually cancel everything.
* We still get multiple requests afterwards, so we end up showing the
* same dialogs repeatedly.
- */
-
- printf ("DEBUG: modest: %s: prompt (not shown) = %s\n", __FUNCTION__, prompt_not_used);
-
- g_return_val_if_fail (account, NULL);
-
+ */
const TnyAccountStore *account_store = NULL;
ModestTnyAccountStore *self = NULL;
ModestTnyAccountStorePrivate *priv;
gpointer pwd_ptr = NULL;
gboolean already_asked = FALSE;
+ g_return_val_if_fail (account, NULL);
+
+ MODEST_DEBUG_BLOCK(
+ g_debug ("DEBUG: modest: %s: prompt (not shown) = %s\n", __FUNCTION__, prompt_not_used);
+ );
+
/* Initialize the output parameter: */
if (cancel)
*cancel = FALSE;
server_account_name,
NULL,
(gpointer*)&pwd_ptr);
-
- printf ("DEBUG: modest: %s: Already asked = %d\n", __FUNCTION__, already_asked);
-
+ MODEST_DEBUG_BLOCK(
+ g_debug ("DEBUG: modest: %s: Already asked = %d\n", __FUNCTION__, already_asked);
+ );
+
/* If the password is not already there, try ModestConf */
if (!already_asked) {
- pwd = modest_server_account_get_password (priv->account_mgr,
- server_account_name);
+ pwd = modest_account_mgr_get_server_account_password (priv->account_mgr,
+ server_account_name);
g_hash_table_insert (priv->password_hash, g_strdup (server_account_name), g_strdup (pwd));
}
* then show a banner and the account settings dialog so it can be corrected:
*/
const gboolean settings_have_password =
- modest_server_account_get_has_password (priv->account_mgr, server_account_name);
- printf ("DEBUG: modest: %s: settings_have_password=%d\n", __FUNCTION__, settings_have_password);
+ modest_account_mgr_get_server_account_has_password (priv->account_mgr, server_account_name);
+ MODEST_DEBUG_BLOCK(
+ printf ("DEBUG: modest: %s: settings_have_password=%d\n",
+ __FUNCTION__, settings_have_password);
+ );
if (settings_have_password) {
/* The password must be wrong, so show the account settings dialog so it can be corrected: */
show_wrong_password_dialog (account);
* but we need to tell tinymail about the username too: */
tny_account_set_user (account, username);
- /* Do not save the password in gconf,
- * because the UI spec says "The password will never be saved in the account": */
- /*
- if (remember) {
- printf ("%s: Storing username=%s, password=%s\n",
- __FUNCTION__, username, pwd);
- modest_server_account_set_username (priv->account_mgr, server_account_name,
- username);
- modest_server_account_set_password (priv->account_mgr, server_account_name,
- pwd);
- }
- */
+ /* Do not save the password in gconf, because
+ * the UI spec says "The password will never
+ * be saved in the account": */
/* We need to dup the string even knowing that
it's already a dup of the contents of an
g_free (username);
username = NULL;
} else
- *cancel = FALSE;
-
- /* printf(" DEBUG: %s: returning %s\n", __FUNCTION__, pwd); */
-
+ if (cancel)
+ *cancel = FALSE;
return pwd;
}
+void
+modest_tny_account_store_forget_already_asked (ModestTnyAccountStore *self, TnyAccount *account)
+{
+ g_return_if_fail (account);
+
+ ModestTnyAccountStorePrivate *priv;
+ gchar *pwd = NULL;
+ gpointer pwd_ptr = NULL;
+ gboolean already_asked = FALSE;
+
+ const gchar *server_account_name = tny_account_get_id (account);
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ /* This hash map stores passwords, including passwords that are not stored in gconf. */
+ pwd_ptr = (gpointer)&pwd; /* pwd_ptr so the compiler does not complained about
+ * type-punned ptrs...*/
+ already_asked = priv->password_hash &&
+ g_hash_table_lookup_extended (priv->password_hash,
+ server_account_name,
+ NULL,
+ (gpointer*)&pwd_ptr);
+
+ if (already_asked) {
+ g_hash_table_remove (priv->password_hash, server_account_name);
+ g_free (pwd);
+ pwd = NULL;
+ }
+
+ return;
+}
+
/* tinymail calls this if the connection failed due to an incorrect password.
* And it seems to call this for any general connection failure. */
static void
static void
modest_tny_account_store_finalize (GObject *obj)
{
- GnomeVFSVolumeMonitor *volume_monitor;
ModestTnyAccountStore *self = MODEST_TNY_ACCOUNT_STORE(obj);
ModestTnyAccountStorePrivate *priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
priv->outbox_of_transport = NULL;
}
-
- /* Disconnect VFS signals */
- volume_monitor = gnome_vfs_get_volume_monitor ();
- if (g_signal_handler_is_connected (volume_monitor,
- priv->volume_mounted_handler))
- g_signal_handler_disconnect (volume_monitor,
- priv->volume_mounted_handler);
- if (g_signal_handler_is_connected (volume_monitor,
- priv->volume_unmounted_handler))
- g_signal_handler_disconnect (volume_monitor,
- priv->volume_unmounted_handler);
+ modest_signal_mgr_disconnect_all_and_destroy (priv->sighandlers);
+ priv->sighandlers = NULL;
if (priv->account_mgr) {
- /* Disconnect signals */
- if (g_signal_handler_is_connected (priv->account_mgr,
- priv->acc_inserted_handler))
- g_signal_handler_disconnect (priv->account_mgr,
- priv->acc_inserted_handler);
- if (g_signal_handler_is_connected (priv->account_mgr,
- priv->acc_changed_handler))
- g_signal_handler_disconnect (priv->account_mgr,
- priv->acc_changed_handler);
- if (g_signal_handler_is_connected (priv->account_mgr,
- priv->acc_removed_handler))
- g_signal_handler_disconnect (priv->account_mgr,
- priv->acc_removed_handler);
-
g_object_unref (G_OBJECT(priv->account_mgr));
priv->account_mgr = NULL;
}
/* Destroy all accounts. Disconnect all accounts before they are destroyed */
if (priv->store_accounts) {
- tny_list_foreach (priv->store_accounts, foreach_account_disconnect, NULL);
+ tny_list_foreach (priv->store_accounts, (GFunc)account_disconnect, NULL);
+ tny_list_foreach (priv->store_accounts, (GFunc)account_verify_last_ref, "store");
g_object_unref (priv->store_accounts);
priv->store_accounts = NULL;
}
-
+
if (priv->transport_accounts) {
- tny_list_foreach (priv->transport_accounts, foreach_account_disconnect, NULL);
+ tny_list_foreach (priv->transport_accounts, (GFunc)account_disconnect, NULL);
+ tny_list_foreach (priv->transport_accounts, (GFunc)account_verify_last_ref, "transport");
g_object_unref (priv->transport_accounts);
priv->transport_accounts = NULL;
}
/* Set the ui locker */
tny_session_camel_set_ui_locker (priv->session, tny_gtk_lockable_new ());
-
+
/* Connect signals */
- priv->acc_inserted_handler = g_signal_connect (G_OBJECT(account_mgr), "account_inserted",
- G_CALLBACK (on_account_inserted), obj);
- priv->acc_changed_handler = g_signal_connect (G_OBJECT(account_mgr), "account_changed",
- G_CALLBACK (on_account_changed), obj);
- priv->acc_removed_handler = g_signal_connect (G_OBJECT(account_mgr), "account_removed",
- G_CALLBACK (on_account_removed), obj);
+ priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
+ G_OBJECT(account_mgr), "account_inserted",
+ G_CALLBACK (on_account_inserted), obj);
+ priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
+ G_OBJECT(account_mgr), "account_changed",
+ G_CALLBACK (on_account_changed), obj);
+ priv->sighandlers = modest_signal_mgr_connect (priv->sighandlers,
+ G_OBJECT(account_mgr), "account_removed",
+ G_CALLBACK (on_account_removed), obj);
/* Create the lists of accounts */
priv->store_accounts = tny_simple_list_new ();
it will return NULL because there is no outbox folder for
this specific transport accounts, and it's a must that the
send queue returns an outbox */
- if (FALSE)
+ if (TRUE)
/* Add connection-specific transport accounts */
add_connection_specific_transport_accounts (MODEST_TNY_ACCOUNT_STORE(obj));
g_return_val_if_fail (self, NULL);
priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
-
- if (priv->device)
+
+ if (priv->device)
return g_object_ref (G_OBJECT(priv->device));
else
return NULL;
if (error->code == TNY_ACCOUNT_ERROR_TRY_CONNECT_CERTIFICATE)
- retval = modest_platform_run_certificate_conformation_dialog (server_name,
+ retval = modest_platform_run_certificate_confirmation_dialog (server_name,
error->message);
else
retval = modest_platform_run_alert_dialog (prompt, question);
return account;
}
+
TnyAccount*
modest_tny_account_store_get_server_account (ModestTnyAccountStore *self,
const gchar *account_name,
modest_acc_name =
modest_tny_account_get_parent_modest_account_name_for_server_account (tmp_account);
- if (!strcmp (account_name, modest_acc_name)) {
+ if (account_name && modest_acc_name && !strcmp (account_name, modest_acc_name)) {
found = TRUE;
retval = g_object_ref (tmp_account);
}
return retval;
}
-static TnyAccount*
-get_smtp_specific_transport_account_for_open_connection (ModestTnyAccountStore *self,
- const gchar *account_name)
+TnyAccount*
+modest_tny_account_store_get_smtp_specific_transport_account_for_open_connection (ModestTnyAccountStore *self,
+ const gchar *account_name)
{
/* Get the current connection: */
TnyDevice *device = modest_runtime_get_device ();
/* Get the connection-specific transport acccount, if any: */
/* Note: This gives us a reference: */
TnyAccount *account =
- get_smtp_specific_transport_account_for_open_connection (self, account_name);
+ modest_tny_account_store_get_smtp_specific_transport_account_for_open_connection (self, account_name);
/* If there is no connection-specific transport account (the common case),
* just get the regular transport account: */
return account;
}
+TnyAccount*
+modest_tny_account_store_get_mmc_folders_account (ModestTnyAccountStore *self)
+{
+ g_return_val_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (self), NULL);
+
+ return modest_tny_account_store_get_tny_account_by (self, MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
+ MODEST_MMC_ACCOUNT_ID);
+
+}
+
/*********************************************************************************/
static void
add_existing_accounts (ModestTnyAccountStore *self)
g_object_unref (per_account_outbox);
}
-
/*
* This function will be used for both adding new accounts and for the
* initialization. In the initialization we do not want to emit
store_account = create_tny_account (self, account, TNY_ACCOUNT_TYPE_STORE);
transport_account = create_tny_account (self, account, TNY_ACCOUNT_TYPE_TRANSPORT);
- /* Add to the list, and notify the observers */
- if (store_account) {
- tny_list_append (priv->store_accounts, G_OBJECT (store_account));
- if (notify)
- g_signal_emit (G_OBJECT (self), signals [ACCOUNT_INSERTED_SIGNAL], 0, store_account);
- g_object_unref (store_account);
- }
-
- /* Add to the list, and notify the observers */
- if (transport_account) {
- /* Add account to the list */
- tny_list_append (priv->transport_accounts, G_OBJECT (transport_account));
- g_assert (TNY_IS_ACCOUNT (transport_account));
-
- /* Create a new pseudo-account with an outbox for this
- transport account and add it to the global outbox
- in the local account */
- add_outbox_from_transport_account_to_global_outbox (self, account, transport_account);
-
- if (notify) {
- TnyAccount *local_account = NULL;
+ g_assert (store_account);
+ g_assert (transport_account);
- /* Notify that the local account changed */
- local_account = modest_tny_account_store_get_local_folders_account (self);
- g_signal_emit (G_OBJECT (self), signals [ACCOUNT_CHANGED_SIGNAL], 0, local_account);
- g_object_unref (local_account);
-
- /* Notify the observers about the new account */
- g_signal_emit (G_OBJECT (self), signals [ACCOUNT_INSERTED_SIGNAL], 0, transport_account);
- }
-
- g_object_unref (transport_account);
+ /* Add accounts to the lists */
+ tny_list_append (priv->store_accounts, G_OBJECT (store_account));
+ tny_list_append (priv->transport_accounts, G_OBJECT (transport_account));
+
+ /* Create a new pseudo-account with an outbox for this
+ transport account and add it to the global outbox
+ in the local account */
+ add_outbox_from_transport_account_to_global_outbox (self, account, transport_account);
+
+ /* Notify the observers. We do it after everything is
+ created */
+ if (notify) {
+ TnyAccount *local_account = NULL;
+
+ /* Notify the observers about the new server & transport accounts */
+ g_signal_emit (G_OBJECT (self), signals [ACCOUNT_INSERTED_SIGNAL], 0, store_account);
+ g_signal_emit (G_OBJECT (self), signals [ACCOUNT_INSERTED_SIGNAL], 0, transport_account);
+
+ /* Notify that the local account changed */
+ local_account = modest_tny_account_store_get_local_folders_account (self);
+ g_signal_emit (G_OBJECT (self), signals [ACCOUNT_CHANGED_SIGNAL], 0, local_account);
+ g_object_unref (local_account);
}
+
+ /* Frees */
+ g_object_unref (store_account);
+ g_object_unref (transport_account);
}
static void
}
static void
-on_account_removed (ModestAccountMgr *acc_mgr,
- const gchar *account,
+on_account_removed (ModestAccountMgr *acc_mgr, const gchar *account,
gpointer user_data)
{
TnyAccount *store_account = NULL, *transport_account = NULL;
modest_tny_account_store_get_server_account (self, account, TNY_ACCOUNT_TYPE_STORE);
transport_account =
modest_tny_account_store_get_server_account (self, account, TNY_ACCOUNT_TYPE_TRANSPORT);
-
+
/* If there was any problem creating the account, for example,
with the configuration system this could not exist */
if (store_account) {
/* Notify the observers */
g_signal_emit (G_OBJECT (self), signals [ACCOUNT_REMOVED_SIGNAL], 0, store_account);
+ account_disconnect (store_account); /* disconnect the account */
g_object_unref (store_account);
} else {
g_warning ("There is no store account for account %s\n", account);
/* Notify the observers */
g_signal_emit (G_OBJECT (self), signals [ACCOUNT_REMOVED_SIGNAL], 0, transport_account);
+ account_disconnect (transport_account); /* disconnect the account */
g_object_unref (transport_account);
} else {
g_warning ("There is no transport account for account %s\n", account);
}
}
+TnyTransportAccount *
+modest_tny_account_store_new_connection_specific_transport_account (ModestTnyAccountStore *self,
+ const gchar *name)
+{
+ ModestTnyAccountStorePrivate *priv = NULL;
+ TnyAccount * tny_account = NULL;
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ /* Add the account: */
+ tny_account =
+ modest_tny_account_new_from_server_account_name (priv->account_mgr,
+ priv->session,
+ name,
+ get_password,
+ forget_password);
+ if (tny_account) {
+ g_object_set_data (G_OBJECT(tny_account),
+ "account_store",
+ (gpointer)self);
+
+ tny_list_append (priv->transport_accounts, G_OBJECT (tny_account));
+ add_outbox_from_transport_account_to_global_outbox (self,
+ name,
+ tny_account);
+
+ } else
+ g_printerr ("modest: failed to create smtp-specific account for %s\n",
+ name);
+
+ return TNY_TRANSPORT_ACCOUNT (tny_account);
+}
+
+
static void
add_connection_specific_transport_accounts (ModestTnyAccountStore *self)
{
iter = g_slist_next (iter);
if (iter) {
const gchar* transport_account_name = (const gchar*) (iter->data);
- if (transport_account_name) {
- TnyAccount * tny_account = NULL;
- /* Add the account: */
- tny_account =
- modest_tny_account_new_from_server_account_name (priv->account_mgr,
- priv->session,
- transport_account_name);
- if (tny_account) {
- g_object_set_data (G_OBJECT(tny_account),
- "account_store",
- (gpointer)self);
-
- tny_list_append (priv->transport_accounts, G_OBJECT (tny_account));
- g_object_unref (tny_account);
- } else
- g_printerr ("modest: failed to create smtp-specific account for %s\n",
- transport_account_name);
- }
+ TnyTransportAccount * account = NULL;
+ account = modest_tny_account_store_new_connection_specific_transport_account (
+ self, transport_account_name);
+ if (account)
+ g_object_unref (account);
}
iter = g_slist_next (iter);
}
}
+
+TnyMsg *
+modest_tny_account_store_find_msg_in_outboxes (ModestTnyAccountStore *self,
+ const gchar *uri,
+ TnyAccount **ac_out)
+{
+ TnyIterator *acc_iter;
+ ModestTnyAccountStorePrivate *priv;
+ TnyMsg *msg = NULL;
+ TnyAccount *msg_account = NULL;
+
+ g_return_val_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (self), NULL);
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
+
+ acc_iter = tny_list_create_iterator (priv->store_accounts_outboxes);
+ while (!msg && !tny_iterator_is_done (acc_iter)) {
+ TnyList *folders = tny_simple_list_new ();
+ TnyAccount *account = TNY_ACCOUNT (tny_iterator_get_current (acc_iter));
+ TnyIterator *folders_iter = NULL;
+
+ tny_folder_store_get_folders (TNY_FOLDER_STORE (account), folders, NULL, NULL);
+ folders_iter = tny_list_create_iterator (folders);
+
+ while (msg == NULL && !tny_iterator_is_done (folders_iter)) {
+ TnyFolder *folder = TNY_FOLDER (tny_iterator_get_current (folders_iter));
+ msg = tny_folder_find_msg (folder, uri, NULL);
+
+ if (msg)
+ msg_account = g_object_ref (account);
+
+ g_object_unref (folder);
+ tny_iterator_next (folders_iter);
+ }
+
+ g_object_unref (folders);
+ g_object_unref (account);
+ tny_iterator_next (acc_iter);
+ }
+
+ g_object_unref (acc_iter);
+
+ if (ac_out != NULL)
+ *ac_out = msg_account;
+
+ return msg;
+}
+
+TnyTransportAccount *
+modest_tny_account_store_get_transport_account_from_outbox_header(ModestTnyAccountStore *self, TnyHeader *header)
+{
+ TnyIterator *acc_iter;
+ ModestTnyAccountStorePrivate *priv;
+ TnyTransportAccount *header_acc = NULL;
+ const gchar *msg_id;
+
+ g_return_val_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (self), NULL);
+ g_return_val_if_fail (TNY_IS_HEADER (header), NULL);
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE (self);
+
+ msg_id = modest_tny_send_queue_get_msg_id (header);
+ acc_iter = tny_list_create_iterator (priv->transport_accounts);
+ while (!header_acc && !tny_iterator_is_done (acc_iter)) {
+ TnyTransportAccount *account = TNY_TRANSPORT_ACCOUNT (tny_iterator_get_current (acc_iter));
+ ModestTnySendQueue *send_queue;
+ ModestTnySendQueueStatus status;
+ send_queue = modest_runtime_get_send_queue(TNY_TRANSPORT_ACCOUNT(account));
+ status = modest_tny_send_queue_get_msg_status(send_queue, msg_id);
+ if (status != MODEST_TNY_SEND_QUEUE_UNKNOWN) {
+ header_acc = g_object_ref(account);
+ }
+ g_object_unref (account);
+ tny_iterator_next (acc_iter);
+ }
+
+ g_object_unref(acc_iter);
+ return header_acc;
+}
projects / modest / blobdiff