+ g_return_val_if_fail (str, NULL);
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ /* Search in store accounts */
+ account = get_tny_account_by (priv->store_accounts, type, str);
+
+ /* If we already found something, no need to search the transport accounts */
+ if (!account) {
+ account = get_tny_account_by (priv->transport_accounts, type, str);
+
+ /* If we already found something, no need to search the
+ per-account outbox accounts */
+ if (!account)
+ account = get_tny_account_by (priv->store_accounts_outboxes, type, str);
+ }
+
+ /* Warn if nothing was found. This is generally unusual. */
+ if (!account) {
+ g_warning("%s: Failed to find account with %s=%s\n",
+ __FUNCTION__,
+ (type == MODEST_TNY_ACCOUNT_STORE_QUERY_ID) ? "ID" : "URL",
+ str);
+ }
+
+ /* Returns a new reference to the account if found */
+ return account;
+}
+
+
+TnyAccount*
+modest_tny_account_store_get_server_account (ModestTnyAccountStore *self,
+ const gchar *account_name,
+ TnyAccountType type)
+{
+ ModestTnyAccountStorePrivate *priv = NULL;
+ TnyAccount *retval = NULL;
+ TnyList *account_list = NULL;
+ TnyIterator *iter = NULL;
+ gboolean found;
+
+ g_return_val_if_fail (self, NULL);
+ g_return_val_if_fail (account_name, NULL);
+ g_return_val_if_fail (type == TNY_ACCOUNT_TYPE_STORE ||
+ type == TNY_ACCOUNT_TYPE_TRANSPORT,
+ NULL);
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ account_list = (type == TNY_ACCOUNT_TYPE_STORE) ?
+ priv->store_accounts :
+ priv->transport_accounts;
+
+ if (!account_list) {
+ g_printerr ("%s: No server accounts of type %s\n", __FUNCTION__,
+ (type == TNY_ACCOUNT_TYPE_STORE) ? "store" : "transport");
+ return NULL;
+ }
+
+ /* Look for the server account */
+ found = FALSE;
+ iter = tny_list_create_iterator (account_list);
+ while (!tny_iterator_is_done (iter) && !found) {
+ const gchar *modest_acc_name;
+ TnyAccount *tmp_account;
+
+ tmp_account = TNY_ACCOUNT (tny_iterator_get_current (iter));
+ modest_acc_name =
+ modest_tny_account_get_parent_modest_account_name_for_server_account (tmp_account);
+
+ if (account_name && modest_acc_name && !strcmp (account_name, modest_acc_name)) {
+ found = TRUE;
+ retval = g_object_ref (tmp_account);
+ }
+ /* Free and continue */
+ g_object_unref (tmp_account);
+ tny_iterator_next (iter);
+ }
+
+ if (!found) {
+ g_printerr ("modest: %s: could not get tny %s account for %s\n." \
+ "Number of server accounts of this type=%d\n", __FUNCTION__,
+ (type == TNY_ACCOUNT_TYPE_STORE) ? "store" : "transport",
+ account_name, tny_list_get_length (account_list));
+ }
+
+ /* Returns a new reference */
+ return retval;
+}
+
+TnyAccount*
+modest_tny_account_store_get_smtp_specific_transport_account_for_open_connection (ModestTnyAccountStore *self,
+ const gchar *account_name)
+{
+ TnyDevice *device;
+
+ g_return_val_if_fail (self && MODEST_IS_TNY_ACCOUNT_STORE(self), NULL);
+ g_return_val_if_fail (account_name, NULL);
+
+ /* Get the current connection: */
+ device = modest_runtime_get_device ();
+
+ if (!tny_device_is_online (device))
+ return NULL;
+
+#ifdef MODEST_HAVE_CONIC
+ g_return_val_if_fail (TNY_IS_MAEMO_CONIC_DEVICE (device), NULL);
+
+ TnyMaemoConicDevice *maemo_device = TNY_MAEMO_CONIC_DEVICE (device);
+ const gchar* iap_id = tny_maemo_conic_device_get_current_iap_id (maemo_device);
+ /* printf ("DEBUG: %s: iap_id=%s\n", __FUNCTION__, iap_id); */
+ if (!iap_id)
+ return NULL;
+
+ ConIcIap* connection = tny_maemo_conic_device_get_iap (maemo_device, iap_id);
+ if (!connection)
+ return NULL;
+
+ const gchar *connection_name = con_ic_iap_get_name (connection);
+ /* printf ("DEBUG: %s: connection_name=%s\n", __FUNCTION__, connection_name); */
+ if (!connection_name)
+ return NULL;
+
+ /* Get the connection-specific transport acccount, if any: */
+ ModestAccountMgr *account_manager = modest_runtime_get_account_mgr ();
+
+ /* Check if this account has connection-specific SMTP enabled */
+ if (!modest_account_mgr_get_use_connection_specific_smtp (account_manager, account_name)) {
+ return NULL;
+ }
+
+ gchar* server_account_name = modest_account_mgr_get_connection_specific_smtp (account_manager,
+ connection_name);
+
+ /* printf ("DEBUG: %s: server_account_name=%s\n", __FUNCTION__, server_account_name); */
+ if (!server_account_name) {
+ return NULL; /* No connection-specific SMTP server was specified for this connection. */
+ }
+
+ TnyAccount* account = modest_tny_account_store_get_tny_account_by (self,
+ MODEST_TNY_ACCOUNT_STORE_QUERY_ID,
+ server_account_name);
+
+ /* printf ("DEBUG: %s: account=%p\n", __FUNCTION__, account); */
+ g_free (server_account_name);
+
+ /* Unref the get()ed object, as required by the tny_maemo_conic_device_get_iap() documentation. */
+ g_object_unref (connection);
+
+ return account;
+#else
+ return NULL; /* TODO: Implement this for GNOME, instead of just Maemo? */
+#endif /* MODEST_HAVE_CONIC */
+}
+
+
+TnyAccount*
+modest_tny_account_store_get_transport_account_for_open_connection (ModestTnyAccountStore *self,
+ const gchar *account_name)
+{
+ g_return_val_if_fail (self, NULL);
+ g_return_val_if_fail (account_name, NULL);
+
+ if (!account_name || !self)
+ return NULL;
+
+ /* Get the connection-specific transport acccount, if any: */
+ /* Note: This gives us a reference: */
+ TnyAccount *account =
+ 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: */
+ if (!account) {
+ /* The special local folders don't have transport accounts. */
+ if (strcmp (account_name, MODEST_LOCAL_FOLDERS_ACCOUNT_ID) == 0)
+ account = NULL;
+ else {
+ /* Note: This gives us a reference: */
+ account = modest_tny_account_store_get_server_account (self, account_name,
+ TNY_ACCOUNT_TYPE_TRANSPORT);
+ }
+ }
+
+ /* returns a reference. */
+ return account;
+}
+
+TnyAccount*
+modest_tny_account_store_get_local_folders_account (ModestTnyAccountStore *self)
+{
+ TnyAccount *account = NULL;
+ ModestTnyAccountStorePrivate *priv;
+ TnyIterator *iter;
+ gboolean found;
+
+ g_return_val_if_fail (MODEST_IS_TNY_ACCOUNT_STORE (self), NULL);
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ found = FALSE;
+ iter = tny_list_create_iterator (priv->store_accounts);
+ while (!tny_iterator_is_done (iter) && !found) {
+ TnyAccount *tmp_account;
+
+ tmp_account = TNY_ACCOUNT (tny_iterator_get_current (iter));
+ if (modest_tny_account_is_virtual_local_folders (tmp_account)) {
+ account = g_object_ref (tmp_account);
+ found = TRUE;
+ }
+ g_object_unref (tmp_account);
+ tny_iterator_next (iter);
+ }
+ g_object_unref (iter);
+
+ /* Returns a new reference to the 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)
+{
+ GSList *account_names = NULL, *iter = NULL;
+ ModestTnyAccountStorePrivate *priv = NULL;
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ /* These are account names, not server_account names */
+ account_names = modest_account_mgr_account_names (priv->account_mgr, FALSE);
+
+ for (iter = account_names; iter != NULL; iter = g_slist_next (iter)) {
+ const gchar *account_name = (const gchar*) iter->data;
+
+ /* Insert all enabled accounts without notifying */
+ if (modest_account_mgr_get_enabled (priv->account_mgr, account_name))
+ insert_account (self, account_name, FALSE);
+ }
+ modest_account_mgr_free_account_names (account_names);
+}
+
+static TnyAccount*
+create_tny_account (ModestTnyAccountStore *self,
+ const gchar *name,
+ TnyAccountType type)
+{
+ TnyAccount *account = NULL;
+ ModestTnyAccountStorePrivate *priv = NULL;
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ account = modest_tny_account_new_from_account (priv->account_mgr,
+ name, type,
+ priv->session,
+ get_password,
+ forget_password);
+
+ if (account) {
+ /* Forget any cached password for the account, so that
+ we use a new account if any */
+ modest_tny_account_store_forget_password_in_memory (self,
+ tny_account_get_id (account));
+ /* Set the account store */
+ g_object_set_data (G_OBJECT(account), "account_store", self);
+ } else {
+ g_printerr ("modest: failed to create account for %s\n", name);
+ }
+
+ return account;
+}
+
+
+static void
+add_outbox_from_transport_account_to_global_outbox (ModestTnyAccountStore *self,
+ const gchar *account_name,
+ TnyAccount *transport_account)
+{
+ TnyList *folders = NULL;
+ TnyIterator *iter_folders = NULL;
+ TnyAccount *local_account = NULL, *account_outbox = NULL;
+ TnyFolder *per_account_outbox = NULL;
+ ModestTnyAccountStorePrivate *priv = NULL;
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ /* Create per account local outbox */
+ account_outbox =
+ modest_tny_account_new_for_per_account_local_outbox_folder (priv->account_mgr,
+ account_name,
+ priv->session);
+ tny_list_append (priv->store_accounts_outboxes, G_OBJECT (account_outbox));
+
+ /* Get the outbox folder */
+ folders = tny_simple_list_new ();
+ tny_folder_store_get_folders (TNY_FOLDER_STORE (account_outbox), folders, NULL, NULL);
+ if (tny_list_get_length (folders) != 1) {
+ g_warning ("%s: > 1 outbox found (%d)?!", __FUNCTION__,
+ tny_list_get_length (folders));
+ }
+
+ iter_folders = tny_list_create_iterator (folders);
+ per_account_outbox = TNY_FOLDER (tny_iterator_get_current (iter_folders));
+ g_object_unref (iter_folders);
+ g_object_unref (folders);
+ g_object_unref (account_outbox);
+
+ /* Add the outbox of the new per-account-local-outbox account
+ to the global local merged OUTBOX of the local folders
+ account */
+ local_account = modest_tny_account_store_get_local_folders_account (self);
+ modest_tny_local_folders_account_add_folder_to_outbox (MODEST_TNY_LOCAL_FOLDERS_ACCOUNT (local_account),
+ per_account_outbox);
+ /* Add the pair to the hash table */
+ g_hash_table_insert (priv->outbox_of_transport,
+ transport_account,
+ per_account_outbox);
+
+ g_object_unref (local_account);
+ 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
+ * signals so notify will be FALSE, in the case of account additions
+ * we do want to notify the observers
+ */
+static void
+insert_account (ModestTnyAccountStore *self,
+ const gchar *account,
+ gboolean notify)
+{
+ ModestTnyAccountStorePrivate *priv = NULL;
+ TnyAccount *store_account = NULL, *transport_account = NULL;
+
+ priv = MODEST_TNY_ACCOUNT_STORE_GET_PRIVATE(self);
+
+ /* Get the server and the transport account */
+ store_account = create_tny_account (self, account, TNY_ACCOUNT_TYPE_STORE);
+ if (!store_account || !TNY_IS_ACCOUNT(store_account)) {
+ g_warning ("%s: failed to create store account", __FUNCTION__);
+ return;
+ }
+
+ transport_account = create_tny_account (self, account, TNY_ACCOUNT_TYPE_TRANSPORT);
+ if (!transport_account || !TNY_IS_ACCOUNT(transport_account)) {
+ g_warning ("%s: failed to create transport account", __FUNCTION__);
+ g_object_unref (store_account);
+ return;
+ }
+
+ /* 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));