1 /* Copyright (c) 2006, Nokia Corporation
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * * Neither the name of the Nokia Corporation nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
18 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
20 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
21 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 #include <modest-account-mgr-helpers.h>
31 #include <modest-account-mgr-priv.h>
32 #include <tny-simple-list.h>
33 #include <modest-runtime.h>
34 #include <modest-defs.h>
38 static const gchar * null_means_empty (const gchar * str);
41 null_means_empty (const gchar * str)
43 return str ? str : "";
47 modest_account_mgr_set_enabled (ModestAccountMgr *self, const gchar* name,
50 return modest_account_mgr_set_bool (self, name, MODEST_ACCOUNT_ENABLED, enabled,FALSE);
55 modest_account_mgr_get_enabled (ModestAccountMgr *self, const gchar* name)
57 return modest_account_mgr_get_bool (self, name, MODEST_ACCOUNT_ENABLED, FALSE);
60 gboolean modest_account_mgr_set_signature (ModestAccountMgr *self, const gchar* name,
61 const gchar* signature, gboolean use_signature)
63 gboolean result = modest_account_mgr_set_bool (self, name, MODEST_ACCOUNT_USE_SIGNATURE,
64 use_signature, FALSE);
65 result = result && modest_account_mgr_set_string (self, name, MODEST_ACCOUNT_SIGNATURE,
66 null_means_empty (signature), FALSE);
71 modest_account_mgr_get_signature (ModestAccountMgr *self,
73 gboolean* use_signature)
76 modest_account_mgr_get_bool (self, name, MODEST_ACCOUNT_USE_SIGNATURE, FALSE);
78 return modest_account_mgr_get_string (self, name, MODEST_ACCOUNT_SIGNATURE, FALSE);
81 ModestProtocolType modest_account_mgr_get_store_protocol (ModestAccountMgr *self, const gchar* name)
83 ModestProtocolType result = MODEST_PROTOCOLS_STORE_POP; /* Arbitrary default */
85 gchar *server_account_name = modest_account_mgr_get_string (self, name,
86 MODEST_ACCOUNT_STORE_ACCOUNT,
88 if (server_account_name) {
89 ModestServerAccountSettings* server_settings =
90 modest_account_mgr_load_server_settings (self, server_account_name, FALSE);
91 result = modest_server_account_settings_get_protocol (server_settings);
93 g_object_unref (server_settings);
95 g_free (server_account_name);
103 modest_account_mgr_set_connection_specific_smtp (ModestAccountMgr *self,
104 const gchar* connection_id,
105 const gchar* server_account_name)
107 modest_account_mgr_remove_connection_specific_smtp (self, connection_id);
109 ModestConf *conf = MODEST_ACCOUNT_MGR_GET_PRIVATE (self)->modest_conf;
111 gboolean result = TRUE;
113 GSList *list = modest_conf_get_list (conf, MODEST_CONF_CONNECTION_SPECIFIC_SMTP_LIST,
114 MODEST_CONF_VALUE_STRING, &err);
116 g_printerr ("modest: %s: error getting list: %s.\n", __FUNCTION__, err->message);
121 /* The server account is in the item after the connection name: */
122 list = g_slist_append (list, g_strdup (connection_id));
123 list = g_slist_append (list, g_strdup (server_account_name));
125 /* Reset the changed list: */
126 modest_conf_set_list (conf, MODEST_CONF_CONNECTION_SPECIFIC_SMTP_LIST, list,
127 MODEST_CONF_VALUE_STRING, &err);
129 g_printerr ("modest: %s: error setting list: %s.\n", __FUNCTION__, err->message);
137 g_slist_foreach (list, (GFunc) g_free, NULL);
145 * modest_account_mgr_remove_connection_specific_smtp
146 * @self: a ModestAccountMgr instance
147 * @name: the account name
148 * @connection_id: A libconic IAP connection id
150 * Disassacoiate a server account to use with the specific connection for this account.
152 * Returns: TRUE if it worked, FALSE otherwise
155 modest_account_mgr_remove_connection_specific_smtp (ModestAccountMgr *self,
156 const gchar* connection_id)
158 ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
160 gboolean result = TRUE;
162 GSList *list = modest_conf_get_list (priv->modest_conf,
163 MODEST_CONF_CONNECTION_SPECIFIC_SMTP_LIST,
164 MODEST_CONF_VALUE_STRING, &err);
166 g_printerr ("modest: %s: error getting list: %s.\n", __FUNCTION__, err->message);
175 /* The server account is in the item after the connection name: */
176 GSList *list_connection = g_slist_find_custom (list, connection_id, (GCompareFunc)strcmp);
177 if (list_connection) {
178 GSList *account_node = g_slist_next (list_connection);
179 /* remove both items: */
180 list = g_slist_delete_link(list, list_connection);
181 list = g_slist_delete_link(list, account_node);
184 /* Reset the changed list: */
185 modest_conf_set_list (priv->modest_conf, MODEST_CONF_CONNECTION_SPECIFIC_SMTP_LIST, list,
186 MODEST_CONF_VALUE_STRING, &err);
188 g_printerr ("modest: %s: error setting list: %s.\n", __FUNCTION__, err->message);
195 g_slist_foreach (list, (GFunc) g_free, NULL);
203 gboolean modest_account_mgr_get_use_connection_specific_smtp (ModestAccountMgr *self, const gchar* account_name)
205 return modest_account_mgr_get_bool (self, account_name,
206 MODEST_ACCOUNT_USE_CONNECTION_SPECIFIC_SMTP, FALSE);
209 gboolean modest_account_mgr_set_use_connection_specific_smtp (ModestAccountMgr *self, const gchar* account_name,
212 return modest_account_mgr_set_bool (self, account_name, MODEST_ACCOUNT_USE_CONNECTION_SPECIFIC_SMTP,
217 * modest_account_mgr_get_connection_specific_smtp
218 * @self: a ModestAccountMgr instance
219 * @connection_id: A libconic IAP connection id
221 * Retrieve a server account to use with this specific connection for this account.
223 * Returns: a server account name to use for this connection, or NULL if none is specified.
225 gchar* modest_account_mgr_get_connection_specific_smtp (ModestAccountMgr *self, const gchar* connection_id)
227 gchar *result = NULL;
229 ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
232 GSList *list = modest_conf_get_list (priv->modest_conf, MODEST_CONF_CONNECTION_SPECIFIC_SMTP_LIST,
233 MODEST_CONF_VALUE_STRING, &err);
235 g_printerr ("modest: %s: error getting list: %s.\n", __FUNCTION__, err->message);
243 /* The server account is in the item after the connection name: */
246 const gchar* this_connection_id = (const gchar*)(iter->data);
247 if (strcmp (this_connection_id, connection_id) == 0) {
248 iter = g_slist_next (iter);
251 const gchar* account_name = (const gchar*)(iter->data);
253 result = g_strdup (account_name);
259 /* Skip 2 to go to the next connection in the list: */
260 iter = g_slist_next (iter);
262 iter = g_slist_next (iter);
267 g_slist_foreach (list, (GFunc) g_free, NULL);
275 modest_account_mgr_get_server_account_username (ModestAccountMgr *self, const gchar* account_name)
277 return modest_account_mgr_get_string (self, account_name, MODEST_ACCOUNT_USERNAME,
278 TRUE /* server account */);
282 modest_account_mgr_set_server_account_username (ModestAccountMgr *self, const gchar* account_name,
283 const gchar* username)
285 /* Note that this won't work properly as long as the gconf cache is broken
287 gchar *existing_username = modest_account_mgr_get_server_account_username(self,
290 modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_USERNAME,
291 username, TRUE /* server account */);
293 /* We don't know anything about new usernames: */
294 if (strcmp (existing_username, username) != 0)
295 modest_account_mgr_set_server_account_username_has_succeeded (self, account_name, FALSE);
297 g_free (existing_username);
301 modest_account_mgr_get_server_account_username_has_succeeded (ModestAccountMgr *self, const gchar* account_name)
303 return modest_account_mgr_get_bool (self, account_name, MODEST_ACCOUNT_USERNAME_HAS_SUCCEEDED,
304 TRUE /* server account */);
308 modest_account_mgr_set_server_account_username_has_succeeded (ModestAccountMgr *self,
309 const gchar* account_name,
312 modest_account_mgr_set_bool (self, account_name, MODEST_ACCOUNT_USERNAME_HAS_SUCCEEDED,
313 succeeded, TRUE /* server account */);
317 modest_account_mgr_get_server_account_password (ModestAccountMgr *self, const gchar* account_name)
319 return modest_account_mgr_get_string (self, account_name, MODEST_ACCOUNT_PASSWORD,
320 TRUE /* server account */);
324 modest_account_mgr_get_server_account_has_password (ModestAccountMgr *self, const gchar* account_name)
326 gboolean result = FALSE;
327 gchar *password = modest_account_mgr_get_string (self, account_name, MODEST_ACCOUNT_PASSWORD,
328 TRUE /* server account */);
329 if (password && strlen (password)) {
333 bzero (password, strlen (password));
342 modest_account_mgr_get_server_account_hostname (ModestAccountMgr *self,
343 const gchar* account_name)
345 return modest_account_mgr_get_string (self,
347 MODEST_ACCOUNT_HOSTNAME,
348 TRUE /* server account */);
352 modest_account_mgr_set_server_account_hostname (ModestAccountMgr *self,
353 const gchar *server_account_name,
354 const gchar *hostname)
356 modest_account_mgr_set_string (self,
358 MODEST_ACCOUNT_HOSTNAME,
360 TRUE /* server account */);
366 modest_account_mgr_get_server_account_secure_auth (ModestAccountMgr *self,
367 const gchar* account_name)
369 ModestProtocolRegistry *protocol_registry;
370 ModestProtocolType result = MODEST_PROTOCOLS_AUTH_NONE;
373 protocol_registry = modest_runtime_get_protocol_registry ();
374 value = modest_account_mgr_get_string (self, account_name, MODEST_ACCOUNT_AUTH_MECH,
375 TRUE /* server account */);
377 ModestProtocol *protocol;
379 protocol = modest_protocol_registry_get_protocol_by_name (protocol_registry, MODEST_PROTOCOL_REGISTRY_AUTH_PROTOCOLS, value);
383 result = modest_protocol_get_type_id (protocol);
392 modest_account_mgr_set_server_account_secure_auth (ModestAccountMgr *self,
393 const gchar* account_name, ModestProtocolType secure_auth)
395 const gchar* str_value;
396 ModestProtocolRegistry *protocol_registry;
397 ModestProtocol *protocol;
399 /* Get the conf string for the protocol: */
400 protocol_registry = modest_runtime_get_protocol_registry ();
401 protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, secure_auth);
402 str_value = modest_protocol_get_name (protocol);
404 /* Set it in the configuration: */
405 modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_AUTH_MECH, str_value, TRUE);
409 modest_account_mgr_get_server_account_security (ModestAccountMgr *self,
410 const gchar* account_name)
412 ModestProtocolType result = MODEST_PROTOCOLS_CONNECTION_NONE;
415 value = modest_account_mgr_get_string (self, account_name, MODEST_ACCOUNT_SECURITY,
416 TRUE /* server account */);
418 ModestProtocolRegistry *protocol_registry;
419 ModestProtocol *protocol;
421 protocol_registry = modest_runtime_get_protocol_registry ();
422 protocol = modest_protocol_registry_get_protocol_by_name (protocol_registry,
423 MODEST_PROTOCOL_REGISTRY_CONNECTION_PROTOCOLS,
428 result = modest_protocol_get_type_id (protocol);
435 modest_account_mgr_set_server_account_security (ModestAccountMgr *self,
436 const gchar* account_name,
437 ModestProtocolType security)
439 const gchar* str_value;
440 ModestProtocolRegistry *protocol_registry;
441 ModestProtocol *protocol;
443 /* Get the conf string for the protocol type: */
444 protocol_registry = modest_runtime_get_protocol_registry ();
445 protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry, security);
446 str_value = modest_protocol_get_name (protocol);
448 /* Set it in the configuration: */
449 modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_SECURITY, str_value, TRUE);
452 ModestServerAccountSettings *
453 modest_account_mgr_load_server_settings (ModestAccountMgr *self, const gchar* name, gboolean is_transport_and_not_store)
455 ModestServerAccountSettings *settings = NULL;
456 ModestProtocol *protocol;
457 ModestProtocolRegistry *registry;
458 gchar *hostname, *username, *pwd, *uri, *proto, *auth, *sec;
460 if (!modest_account_mgr_account_exists (self, name, TRUE)) {
461 g_message ("%s account %s does not exist", __FUNCTION__, name);
465 registry = modest_runtime_get_protocol_registry ();
466 settings = modest_server_account_settings_new ();
468 modest_server_account_settings_set_account_name (settings, name);
470 proto = modest_account_mgr_get_string (self, name, MODEST_ACCOUNT_PROTO, TRUE);
473 if (is_transport_and_not_store) {
474 tag = MODEST_PROTOCOL_REGISTRY_TRANSPORT_PROTOCOLS;
476 tag = MODEST_PROTOCOL_REGISTRY_STORE_PROTOCOLS;
478 protocol = modest_protocol_registry_get_protocol_by_name (registry, tag, proto);
480 modest_server_account_settings_set_protocol (settings,
481 modest_protocol_get_type_id (protocol));
487 modest_server_account_settings_set_port (settings,
488 modest_account_mgr_get_int (self, name, MODEST_ACCOUNT_PORT, TRUE));
490 auth = modest_account_mgr_get_string (self, name, MODEST_ACCOUNT_AUTH_MECH, TRUE);
492 protocol = modest_protocol_registry_get_protocol_by_name (registry, MODEST_PROTOCOL_REGISTRY_AUTH_PROTOCOLS, auth);
493 modest_server_account_settings_set_auth_protocol (settings,
494 modest_protocol_get_type_id (protocol));
497 modest_server_account_settings_set_auth_protocol (settings, MODEST_PROTOCOLS_AUTH_NONE);
500 sec = modest_account_mgr_get_string (self, name, MODEST_ACCOUNT_SECURITY, TRUE);
502 protocol = modest_protocol_registry_get_protocol_by_name (registry, MODEST_PROTOCOL_REGISTRY_CONNECTION_PROTOCOLS, sec);
503 modest_server_account_settings_set_security_protocol (settings,
504 modest_protocol_get_type_id (protocol));
507 modest_server_account_settings_set_security_protocol (settings,
508 MODEST_PROTOCOLS_CONNECTION_NONE);
511 /* Username, password and URI. Note that the URI could include
512 the former two, so in this case there is no need to have
514 username = modest_account_mgr_get_string (self, name,
515 MODEST_ACCOUNT_USERNAME,TRUE);
517 modest_server_account_settings_set_username (settings, username);
519 pwd = modest_account_mgr_get_string (self, name,
520 MODEST_ACCOUNT_PASSWORD, TRUE);
522 modest_server_account_settings_set_password (settings, pwd);
526 uri = modest_account_mgr_get_string (self, name,
527 MODEST_ACCOUNT_URI, TRUE);
529 modest_server_account_settings_set_uri (settings, uri);
531 hostname = modest_account_mgr_get_string (self, name,
532 MODEST_ACCOUNT_HOSTNAME,TRUE);
534 modest_server_account_settings_set_hostname (settings, hostname);
537 if (!username || !hostname) {
552 g_object_unref (settings);
557 modest_account_mgr_save_server_settings (ModestAccountMgr *self,
558 ModestServerAccountSettings *settings)
560 gboolean has_errors = FALSE;
561 const gchar *account_name;
562 const gchar *protocol_name;
564 ModestProtocolRegistry *protocol_registry;
565 ModestProtocol *protocol;
567 g_return_val_if_fail (MODEST_IS_SERVER_ACCOUNT_SETTINGS (settings), FALSE);
568 protocol_registry = modest_runtime_get_protocol_registry ();
569 account_name = modest_server_account_settings_get_account_name (settings);
571 /* if we don't have a valid account name we cannot save */
572 g_return_val_if_fail (account_name, FALSE);
574 protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry,
575 modest_server_account_settings_get_protocol (settings));
576 protocol_name = modest_protocol_get_name (protocol);
577 uri = modest_server_account_settings_get_uri (settings);
579 const gchar *hostname;
580 const gchar *username;
581 const gchar *password;
583 const gchar *auth_protocol_name;
584 const gchar *security_name;
586 hostname = null_means_empty (modest_server_account_settings_get_hostname (settings));
587 username = null_means_empty (modest_server_account_settings_get_username (settings));
588 password = null_means_empty (modest_server_account_settings_get_password (settings));
589 port = modest_server_account_settings_get_port (settings);
590 protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry,
591 modest_server_account_settings_get_auth_protocol (settings));
592 auth_protocol_name = modest_protocol_get_name (protocol);
593 protocol = modest_protocol_registry_get_protocol_by_type (protocol_registry,
594 modest_server_account_settings_get_security_protocol (settings));
595 security_name = modest_protocol_get_name (protocol);
597 has_errors = !modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_HOSTNAME,
600 (has_errors = !modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_USERNAME,
603 (has_errors = !modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_PASSWORD,
606 (has_errors = !modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_PROTO,
607 protocol_name, TRUE));
609 (has_errors = !modest_account_mgr_set_int (self, account_name, MODEST_ACCOUNT_PORT,
612 (has_errors = !modest_account_mgr_set_string (self, account_name,
613 MODEST_ACCOUNT_AUTH_MECH,
614 auth_protocol_name, TRUE));
616 (has_errors = !modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_SECURITY,
620 const gchar *uri = modest_server_account_settings_get_uri (settings);
621 has_errors = !modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_URI,
624 (has_errors = !modest_account_mgr_set_string (self, account_name, MODEST_ACCOUNT_PROTO,
625 protocol_name, TRUE));
633 ModestAccountSettings *
634 modest_account_mgr_load_account_settings (ModestAccountMgr *self,
637 ModestAccountSettings *settings;
639 gchar *server_account;
640 gchar *default_account;
641 gboolean use_signature = FALSE;
643 g_return_val_if_fail (self, NULL);
644 g_return_val_if_fail (name, NULL);
646 if (!modest_account_mgr_account_exists (self, name, FALSE)) {
647 /* For instance, maybe you are mistakenly checking for a server account name? */
648 g_warning ("%s: Account %s does not exist.", __FUNCTION__, name);
652 settings = modest_account_settings_new ();
654 modest_account_settings_set_account_name (settings, name);
656 string = modest_account_mgr_get_string (self, name,
657 MODEST_ACCOUNT_DISPLAY_NAME,
659 modest_account_settings_set_display_name (settings, string);
662 string = modest_account_mgr_get_string (self, name,
663 MODEST_ACCOUNT_FULLNAME,
665 modest_account_settings_set_fullname (settings, string);
668 string = modest_account_mgr_get_string (self, name,
669 MODEST_ACCOUNT_EMAIL,
671 modest_account_settings_set_email_address (settings, string);
674 modest_account_settings_set_enabled (settings, modest_account_mgr_get_enabled (self, name));
675 modest_account_settings_set_retrieve_type (settings, modest_account_mgr_get_retrieve_type (self, name));
676 modest_account_settings_set_retrieve_limit (settings, modest_account_mgr_get_retrieve_limit (self, name));
678 default_account = modest_account_mgr_get_default_account (self);
679 modest_account_settings_set_is_default (settings,
680 (default_account && strcmp (default_account, name) == 0));
681 g_free (default_account);
683 string = modest_account_mgr_get_signature (self, name, &use_signature);
684 modest_account_settings_set_use_signature (settings, use_signature);
685 modest_account_settings_set_signature (settings, string);
688 modest_account_settings_set_leave_messages_on_server
689 (settings, modest_account_mgr_get_leave_on_server (self, name));
690 modest_account_settings_set_use_connection_specific_smtp
691 (settings, modest_account_mgr_get_use_connection_specific_smtp (self, name));
694 server_account = modest_account_mgr_get_string (self, name,
695 MODEST_ACCOUNT_STORE_ACCOUNT,
697 if (server_account) {
698 ModestServerAccountSettings *store_settings;
699 store_settings = modest_account_mgr_load_server_settings (self, server_account, FALSE);
700 g_free (server_account);
702 /* It could happen that the account data is corrupted
703 so it's not loaded properly */
704 if (store_settings) {
705 modest_account_settings_set_store_settings (settings,
707 g_object_unref (store_settings);
709 g_message ("%s can not load server settings. Account corrupted?", __FUNCTION__);
710 g_object_unref (settings);
716 server_account = modest_account_mgr_get_string (self, name,
717 MODEST_ACCOUNT_TRANSPORT_ACCOUNT,
719 if (server_account) {
720 ModestServerAccountSettings *transport_settings;
721 transport_settings = modest_account_mgr_load_server_settings (self, server_account, TRUE);
722 g_free (server_account);
724 if (transport_settings) {
725 modest_account_settings_set_transport_settings (settings, transport_settings);
726 g_object_unref (transport_settings);
728 g_message ("%s can not load server settings. Account corrupted?", __FUNCTION__);
729 g_object_unref (settings);
738 modest_account_mgr_save_account_settings (ModestAccountMgr *mgr,
739 ModestAccountSettings *settings)
741 g_return_if_fail (MODEST_IS_ACCOUNT_MGR (mgr));
742 g_return_if_fail (MODEST_IS_ACCOUNT_SETTINGS (settings));
744 const gchar *account_name;
745 const gchar *store_account_name;
746 const gchar *transport_account_name;
747 ModestServerAccountSettings *store_settings;
748 ModestServerAccountSettings *transport_settings;
750 account_name = modest_account_settings_get_account_name (settings);
751 g_return_if_fail (account_name != NULL);
753 modest_account_mgr_set_display_name (mgr, account_name,
754 modest_account_settings_get_display_name (settings));
755 modest_account_mgr_set_user_fullname (mgr, account_name,
756 modest_account_settings_get_fullname (settings));
757 modest_account_mgr_set_user_email (mgr, account_name,
758 modest_account_settings_get_email_address (settings));
759 modest_account_mgr_set_retrieve_type (mgr, account_name,
760 modest_account_settings_get_retrieve_type (settings));
761 modest_account_mgr_set_retrieve_limit (mgr, account_name,
762 modest_account_settings_get_retrieve_limit (settings));
763 modest_account_mgr_set_leave_on_server (mgr, account_name,
764 modest_account_settings_get_leave_messages_on_server (settings));
765 modest_account_mgr_set_signature (mgr, account_name,
766 modest_account_settings_get_signature (settings),
767 modest_account_settings_get_use_signature (settings));
768 modest_account_mgr_set_use_connection_specific_smtp
770 modest_account_settings_get_use_connection_specific_smtp (settings));
772 store_settings = modest_account_settings_get_store_settings (settings);
773 store_account_name = modest_server_account_settings_get_account_name (store_settings);
774 if (store_settings != NULL) {
775 modest_account_mgr_save_server_settings (mgr, store_settings);
777 modest_account_mgr_set_string (mgr, account_name, MODEST_ACCOUNT_STORE_ACCOUNT, store_account_name, FALSE);
778 g_object_unref (store_settings);
780 transport_settings = modest_account_settings_get_transport_settings (settings);
781 transport_account_name = modest_server_account_settings_get_account_name (transport_settings);
782 if (transport_settings != NULL) {
783 modest_account_mgr_save_server_settings (mgr, transport_settings);
785 modest_account_mgr_set_string (mgr, account_name, MODEST_ACCOUNT_TRANSPORT_ACCOUNT, transport_account_name, FALSE);
786 g_object_unref (transport_settings);
787 modest_account_mgr_set_enabled (mgr, account_name, TRUE);
792 on_accounts_list_sort_by_title(gconstpointer a, gconstpointer b)
794 return g_utf8_collate((const gchar*)a, (const gchar*)b);
797 /** Get the first one, alphabetically, by title. */
799 modest_account_mgr_get_first_account_name (ModestAccountMgr *self)
801 const gchar* account_name = NULL;
802 GSList *account_names = modest_account_mgr_account_names (self, TRUE /* only enabled */);
804 /* Return TRUE if there is no account */
808 /* Get the first one, alphabetically, by title: */
809 /* gchar *old_default = modest_account_mgr_get_default_account (self); */
810 GSList* list_sorted = g_slist_sort (account_names, on_accounts_list_sort_by_title);
812 GSList* iter = list_sorted;
813 gboolean found = FALSE;
814 while (iter && !found) {
815 account_name = (const gchar*)list_sorted->data;
821 iter = g_slist_next (iter);
824 gchar* result = NULL;
826 result = g_strdup (account_name);
828 modest_account_mgr_free_account_names (account_names);
829 account_names = NULL;
835 modest_account_mgr_set_first_account_as_default (ModestAccountMgr *self)
837 gboolean result = FALSE;
839 gchar* account_name = modest_account_mgr_get_first_account_name(self);
841 result = modest_account_mgr_set_default_account (self, account_name);
842 g_free (account_name);
845 result = TRUE; /* If there are no accounts then it's not a failure. */
851 modest_account_mgr_get_from_string (ModestAccountMgr *self, const gchar* name)
853 gchar *fullname, *email, *from;
855 g_return_val_if_fail (self, NULL);
856 g_return_val_if_fail (name, NULL);
858 fullname = modest_account_mgr_get_string (self, name,MODEST_ACCOUNT_FULLNAME,
860 email = modest_account_mgr_get_string (self, name, MODEST_ACCOUNT_EMAIL,
862 from = g_strdup_printf ("%s <%s>",
863 fullname ? fullname : "",
871 /* Add a number to the end of the text, or increment a number that is already there.
874 util_increment_name (const gchar* text)
876 g_return_val_if_fail (text, NULL);
878 /* Get the end character,
879 * also doing a UTF-8 validation which is required for using g_utf8_prev_char().
881 const gchar* end = NULL;
882 if (!g_utf8_validate (text, -1, &end))
888 --end; /* Go to before the null-termination. */
890 /* Look at each UTF-8 characer, starting at the end: */
891 const gchar* p = end;
892 const gchar* alpha_end = NULL;
895 /* Stop when we reach the first character that is not a numeric digit: */
896 const gunichar ch = g_utf8_get_char (p);
897 if (!g_unichar_isdigit (ch)) {
902 p = g_utf8_find_prev_char (text, p);
906 /* The text must consist completely of numeric digits. */
912 /* Intepret and increment the number, if any: */
913 gint num = atol (alpha_end);
916 /* Get the name part: */
917 gint name_len = alpha_end - text;
918 gchar *name_without_number = g_malloc(name_len + 1);
919 memcpy (name_without_number, text, name_len);
920 name_without_number[name_len] = 0;\
922 /* Concatenate the text part and the new number: */
923 gchar *result = g_strdup_printf("%s%d", name_without_number, num);
924 g_free (name_without_number);
930 modest_account_mgr_get_unused_account_name (ModestAccountMgr *self, const gchar* starting_name,
931 gboolean server_account)
933 gchar *account_name = g_strdup (starting_name);
935 while (modest_account_mgr_account_exists (self,
936 account_name, server_account /* server_account */)) {
938 gchar * account_name2 = util_increment_name (account_name);
939 g_free (account_name);
940 account_name = account_name2;
947 modest_account_mgr_get_unused_account_display_name (ModestAccountMgr *self, const gchar* starting_name)
949 gchar *account_name = g_strdup (starting_name);
951 while (modest_account_mgr_account_with_display_name_exists (self, account_name)) {
953 gchar * account_name2 = util_increment_name (account_name);
954 g_free (account_name);
955 account_name = account_name2;
962 modest_account_mgr_set_leave_on_server (ModestAccountMgr *self,
963 const gchar *account_name,
964 gboolean leave_on_server)
966 modest_account_mgr_set_bool (self,
968 MODEST_ACCOUNT_LEAVE_ON_SERVER,
974 modest_account_mgr_get_leave_on_server (ModestAccountMgr *self,
975 const gchar* account_name)
977 return modest_account_mgr_get_bool (self,
979 MODEST_ACCOUNT_LEAVE_ON_SERVER,
984 modest_account_mgr_get_last_updated (ModestAccountMgr *self,
985 const gchar* account_name)
987 return modest_account_mgr_get_int (modest_runtime_get_account_mgr (),
989 MODEST_ACCOUNT_LAST_UPDATED,
994 modest_account_mgr_set_last_updated (ModestAccountMgr *self,
995 const gchar* account_name,
998 modest_account_mgr_set_int (self,
1000 MODEST_ACCOUNT_LAST_UPDATED,
1004 /* TODO: notify about changes */
1008 modest_account_mgr_get_retrieve_limit (ModestAccountMgr *self,
1009 const gchar* account_name)
1011 return modest_account_mgr_get_int (self,
1013 MODEST_ACCOUNT_LIMIT_RETRIEVE,
1018 modest_account_mgr_set_retrieve_limit (ModestAccountMgr *self,
1019 const gchar* account_name,
1020 gint limit_retrieve)
1022 modest_account_mgr_set_int (self,
1024 MODEST_ACCOUNT_LIMIT_RETRIEVE,
1026 FALSE /* not server account */);
1030 modest_account_mgr_get_server_account_port (ModestAccountMgr *self,
1031 const gchar* account_name)
1033 return modest_account_mgr_get_int (self,
1035 MODEST_ACCOUNT_PORT,
1040 modest_account_mgr_set_server_account_port (ModestAccountMgr *self,
1041 const gchar *account_name,
1044 modest_account_mgr_set_int (self,
1046 MODEST_ACCOUNT_PORT,
1047 port_num, TRUE /* server account */);
1051 modest_account_mgr_get_server_account_name (ModestAccountMgr *self,
1052 const gchar *account_name,
1053 TnyAccountType account_type)
1055 return modest_account_mgr_get_string (self,
1057 (account_type == TNY_ACCOUNT_TYPE_STORE) ?
1058 MODEST_ACCOUNT_STORE_ACCOUNT :
1059 MODEST_ACCOUNT_TRANSPORT_ACCOUNT,
1063 static const gchar *
1064 get_retrieve_type_name (ModestAccountRetrieveType retrieve_type)
1066 switch(retrieve_type) {
1067 case MODEST_ACCOUNT_RETRIEVE_HEADERS_ONLY:
1068 return MODEST_ACCOUNT_RETRIEVE_VALUE_HEADERS_ONLY;
1070 case MODEST_ACCOUNT_RETRIEVE_MESSAGES:
1071 return MODEST_ACCOUNT_RETRIEVE_VALUE_MESSAGES;
1073 case MODEST_ACCOUNT_RETRIEVE_MESSAGES_AND_ATTACHMENTS:
1074 return MODEST_ACCOUNT_RETRIEVE_VALUE_MESSAGES_AND_ATTACHMENTS;
1077 return MODEST_ACCOUNT_RETRIEVE_VALUE_HEADERS_ONLY;
1081 static ModestAccountRetrieveType
1082 get_retrieve_type (const gchar *name)
1084 if (!name || name[0] == 0)
1085 return MODEST_ACCOUNT_RETRIEVE_HEADERS_ONLY;
1086 if (strcmp (name, MODEST_ACCOUNT_RETRIEVE_VALUE_MESSAGES) == 0) {
1087 return MODEST_ACCOUNT_RETRIEVE_MESSAGES;
1088 } else if (strcmp (name, MODEST_ACCOUNT_RETRIEVE_VALUE_MESSAGES_AND_ATTACHMENTS) == 0) {
1089 return MODEST_ACCOUNT_RETRIEVE_MESSAGES_AND_ATTACHMENTS;
1091 /* we fall back to headers only */
1092 return MODEST_ACCOUNT_RETRIEVE_HEADERS_ONLY;
1096 ModestAccountRetrieveType
1097 modest_account_mgr_get_retrieve_type (ModestAccountMgr *self,
1098 const gchar *account_name)
1101 ModestAccountRetrieveType result;
1103 string = modest_account_mgr_get_string (self,
1105 MODEST_ACCOUNT_RETRIEVE,
1106 FALSE /* not server account */);
1107 result = get_retrieve_type (string);
1114 modest_account_mgr_set_retrieve_type (ModestAccountMgr *self,
1115 const gchar *account_name,
1116 ModestAccountRetrieveType retrieve_type)
1118 modest_account_mgr_set_string (self,
1120 MODEST_ACCOUNT_RETRIEVE,
1121 get_retrieve_type_name (retrieve_type),
1122 FALSE /* not server account */);
1127 modest_account_mgr_set_user_fullname (ModestAccountMgr *self,
1128 const gchar *account_name,
1129 const gchar *fullname)
1131 modest_account_mgr_set_string (self,
1133 MODEST_ACCOUNT_FULLNAME,
1135 FALSE /* not server account */);
1139 modest_account_mgr_set_user_email (ModestAccountMgr *self,
1140 const gchar *account_name,
1143 modest_account_mgr_set_string (self,
1145 MODEST_ACCOUNT_EMAIL,
1147 FALSE /* not server account */);