1 /* modest-account-mgr.c */
3 /* insert (c)/licensing information) */
6 #include "modest-account-mgr.h"
8 /* 'private'/'protected' functions */
9 static void modest_account_mgr_class_init (ModestAccountMgrClass * klass);
10 static void modest_account_mgr_init (ModestAccountMgr * obj);
11 static void modest_account_mgr_finalize (GObject * obj);
13 static gchar *get_account_keyname (const gchar * accname, const gchar * name);
14 static gchar *get_server_account_keyname (const gchar * accname,
24 typedef struct _ModestAccountMgrPrivate ModestAccountMgrPrivate;
25 struct _ModestAccountMgrPrivate {
26 ModestConf *modest_conf;
29 #define MODEST_ACCOUNT_MGR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), \
30 MODEST_TYPE_ACCOUNT_MGR, \
31 ModestAccountMgrPrivate))
33 static GObjectClass *parent_class = NULL;
35 /* uncomment the following if you have defined any signals */
36 /* static guint signals[LAST_SIGNAL] = {0}; */
39 modest_account_mgr_check_change (ModestConf *conf, const gchar *key,
40 const gchar *new_value, gpointer user_data)
42 ModestAccountMgr *amgr = user_data;
44 g_message ("value changed: %s %s\n", key, new_value);
49 modest_account_mgr_get_type (void)
51 static GType my_type = 0;
54 static const GTypeInfo my_info = {
55 sizeof (ModestAccountMgrClass),
57 NULL, /* base finalize */
58 (GClassInitFunc) modest_account_mgr_class_init,
59 NULL, /* class finalize */
60 NULL, /* class data */
61 sizeof (ModestAccountMgr),
63 (GInstanceInitFunc) modest_account_mgr_init,
66 my_type = g_type_register_static (G_TYPE_OBJECT,
74 modest_account_mgr_class_init (ModestAccountMgrClass * klass)
76 GObjectClass *gobject_class;
78 gobject_class = (GObjectClass *) klass;
80 parent_class = g_type_class_peek_parent (klass);
81 gobject_class->finalize = modest_account_mgr_finalize;
83 g_type_class_add_private (gobject_class,
84 sizeof (ModestAccountMgrPrivate));
86 /* signal definitions go here, e.g.: */
87 /* signals[MY_SIGNAL_1] = */
88 /* g_signal_new ("my_signal_1",....); */
89 /* signals[MY_SIGNAL_2] = */
90 /* g_signal_new ("my_signal_2",....); */
96 modest_account_mgr_init (ModestAccountMgr * obj)
98 ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (obj);
100 priv->modest_conf = NULL;
104 modest_account_mgr_finalize (GObject * obj)
106 ModestAccountMgr *self = MODEST_ACCOUNT_MGR (obj);
107 ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
109 if (priv->modest_conf) {
110 g_object_unref (G_OBJECT(priv->modest_conf));
111 priv->modest_conf = NULL;
116 modest_account_mgr_new (ModestConf * conf)
119 ModestAccountMgrPrivate *priv;
121 g_return_val_if_fail (conf, NULL);
123 obj = G_OBJECT (g_object_new (MODEST_TYPE_ACCOUNT_MGR, NULL));
124 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (obj);
127 * increase the ref count on the modest_conf. Normally, the
128 * ModestConf should outlive the ModestAccountMgr though
130 g_object_ref (G_OBJECT (priv->modest_conf = conf));
132 g_signal_connect (G_OBJECT (conf), "key-changed",
133 G_CALLBACK (modest_account_mgr_check_change), obj);
139 modest_account_mgr_add_account (ModestAccountMgr * self, const gchar * name,
140 const gchar * store_account,
141 const gchar * transport_account,
144 ModestAccountMgrPrivate *priv;
147 g_return_val_if_fail (self, FALSE);
148 g_return_val_if_fail (name, FALSE);
150 if (modest_account_mgr_account_exists (self, name, err)) {
151 g_warning ("account already exists");
155 * we create the account by adding an account 'dir', with the name <name>,
156 * and in that the 'display_name' string key
158 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
160 key = get_account_keyname (name, MODEST_ACCOUNT_DISPLAY_NAME);
161 modest_conf_set_string (priv->modest_conf, key, name, err);
165 key = get_account_keyname (name,
166 MODEST_ACCOUNT_STORE_ACCOUNT);
167 modest_conf_set_string (priv->modest_conf, key, store_account,
172 if (transport_account) {
173 key = get_account_keyname (name,
174 MODEST_ACCOUNT_TRANSPORT_ACCOUNT);
175 modest_conf_set_string (priv->modest_conf, key,
176 transport_account, err);
180 return TRUE; /* TODO: error handling */
185 modest_account_mgr_remove_account (ModestAccountMgr * self,
186 const gchar * name, GError ** err)
188 ModestAccountMgrPrivate *priv;
192 g_return_val_if_fail (self, FALSE);
193 g_return_val_if_fail (name, FALSE);
195 if (!modest_account_mgr_account_exists (self, name, err)) {
196 g_warning ("account doest not exist");
200 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
201 key = get_account_keyname (name, NULL);
203 retval = modest_conf_remove_key (priv->modest_conf, key, NULL);
211 null_means_empty (const gchar * str)
213 return str ? str : "";
218 modest_account_mgr_add_server_account (ModestAccountMgr * self,
220 const gchar * hostname,
221 const gchar * username,
222 const gchar * password,
225 ModestAccountMgrPrivate *priv;
228 g_return_val_if_fail (self, FALSE);
229 g_return_val_if_fail (name, FALSE);
231 /* TODO: check already exists */
233 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
234 acckey = g_strconcat (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
237 if (modest_conf_key_exists (priv->modest_conf, acckey, NULL)) {
238 g_warning ("server account %s already exists", name);
244 key = g_strconcat (acckey, "/", MODEST_ACCOUNT_HOSTNAME, NULL);
245 modest_conf_set_string (priv->modest_conf, key,
246 null_means_empty (hostname), NULL);
250 key = g_strconcat (acckey, "/", MODEST_ACCOUNT_USERNAME, NULL);
251 modest_conf_set_string (priv->modest_conf, key,
252 null_means_empty (username), NULL);
257 key = g_strconcat (acckey, "/", MODEST_ACCOUNT_PASSWORD,
259 modest_conf_set_string (priv->modest_conf, key,
260 null_means_empty (password), NULL);
265 key = g_strconcat (acckey, "/", MODEST_ACCOUNT_PROTO, NULL);
266 modest_conf_set_string (priv->modest_conf, key,
267 null_means_empty (proto), NULL);
271 return TRUE; /* FIXME: better error checking */
275 modest_account_mgr_remove_server_account (ModestAccountMgr * self,
276 const gchar * name, GError ** err)
278 ModestAccountMgrPrivate *priv;
282 g_return_val_if_fail (self, FALSE);
283 g_return_val_if_fail (name, FALSE);
285 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
287 acckey = g_strconcat (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
290 if (!modest_conf_key_exists (priv->modest_conf, acckey, NULL)) {
291 g_warning ("server account %s does not exist exist", name);
296 retval = modest_conf_remove_key (priv->modest_conf, acckey, NULL);
303 /* strip the first /n/ character from each element */
304 /* caller must make sure all elements are strings with
305 * length >= n, and also that data can be freed.
308 strip_prefix_from_elements (GSList * lst, guint n)
310 GSList *cursor = lst;
313 gchar *str = (gchar *) cursor->data;
315 cursor->data = g_strdup (str + n);
317 cursor = cursor->next;
324 modest_account_mgr_server_account_names (ModestAccountMgr * self,
325 const gchar * account_name,
326 ModestProtoType type,
328 gboolean only_enabled)
332 ModestAccountMgrPrivate *priv;
333 const size_t prefix_len =
334 strlen (MODEST_SERVER_ACCOUNT_NAMESPACE "/");
336 g_return_val_if_fail (self, NULL);
338 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
339 accounts = modest_conf_list_subkeys (priv->modest_conf,
340 MODEST_SERVER_ACCOUNT_NAMESPACE,
343 /* no restrictions, return everything */
344 if (type == MODEST_PROTO_TYPE_ANY && !proto)
345 return strip_prefix_from_elements (accounts, prefix_len);
347 /* otherwise, filter out the none-matching ones */
350 gchar *keyspace, *proto_key, *acc_proto;
352 keyspace = (gchar *) cursor->data;
354 g_strconcat (keyspace, "/", MODEST_ACCOUNT_PROTO,
357 modest_conf_get_string (priv->modest_conf, proto_key,
361 if ((!acc_proto) || /* proto not defined? */
362 (type != MODEST_PROTO_TYPE_ANY && /* proto type ... */
363 modest_proto_type (acc_proto) != type) || /* ... matches? */
364 (proto && strcmp (proto, acc_proto) != 0)) { /* proto matches? */
365 /* no match: remove from the list */
366 GSList *nxt = cursor->next;
369 accounts = g_slist_delete_link (accounts, cursor);
372 cursor = cursor->next;
375 return strip_prefix_from_elements (accounts, prefix_len);
380 modest_account_mgr_account_names (ModestAccountMgr * self, GError ** err)
383 ModestAccountMgrPrivate *priv;
384 const size_t prefix_len = strlen (MODEST_ACCOUNT_NAMESPACE "/");
387 g_return_val_if_fail (self, NULL);
389 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
391 accounts = modest_conf_list_subkeys (priv->modest_conf,
392 MODEST_ACCOUNT_NAMESPACE, err);
393 return strip_prefix_from_elements (accounts, prefix_len);
398 get_account_string (ModestAccountMgr * self, const gchar * name,
399 const gchar * key, gboolean server_account, GError ** err)
401 ModestAccountMgrPrivate *priv;
406 g_return_val_if_fail (self, NULL);
407 g_return_val_if_fail (name, NULL);
408 g_return_val_if_fail (key, NULL);
411 keyname = get_server_account_keyname (name, key);
413 keyname = get_account_keyname (name, key);
415 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
416 retval = modest_conf_get_string (priv->modest_conf, keyname, err);
424 modest_account_mgr_get_server_account_string (ModestAccountMgr * self,
429 return get_account_string (self, name, key, TRUE, err);
434 modest_account_mgr_get_account_string (ModestAccountMgr * self,
435 const gchar * name, const gchar * key,
438 return get_account_string (self, name, key, FALSE, err);
443 get_account_int (ModestAccountMgr * self, const gchar * name,
444 const gchar * key, gboolean server_account, GError ** err)
446 ModestAccountMgrPrivate *priv;
451 g_return_val_if_fail (self, -1);
452 g_return_val_if_fail (name, -1);
453 g_return_val_if_fail (key, -1);
456 keyname = get_server_account_keyname (name, key);
458 keyname = get_account_keyname (name, key);
460 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
461 retval = modest_conf_get_int (priv->modest_conf, keyname, err);
469 modest_account_mgr_get_server_account_int (ModestAccountMgr * self,
471 const gchar * key, GError ** err)
473 return get_account_int (self, name, key, TRUE, err);
478 modest_account_mgr_get_account_int (ModestAccountMgr * self,
479 const gchar * name, const gchar * key,
482 return get_account_int (self, name, key, FALSE, err);
487 get_account_bool (ModestAccountMgr * self, const gchar * name,
488 const gchar * key, gboolean server_account, GError ** err)
490 ModestAccountMgrPrivate *priv;
495 g_return_val_if_fail (self, -1);
496 g_return_val_if_fail (name, -1);
497 g_return_val_if_fail (key, -1);
500 keyname = get_server_account_keyname (name, key);
502 keyname = get_account_keyname (name, key);
504 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
505 retval = modest_conf_get_int (priv->modest_conf, keyname, err);
513 modest_account_mgr_get_server_account_bool (ModestAccountMgr * self,
515 const gchar * key, GError ** err)
517 return get_account_bool (self, name, key, TRUE, err);
522 modest_account_mgr_get_account_bool (ModestAccountMgr * self,
523 const gchar * name, const gchar * key,
526 return get_account_bool (self, name, key, FALSE, err);
531 set_account_string (ModestAccountMgr * self, const gchar * name,
532 const gchar * key, const gchar * val,
533 gboolean server_account, GError ** err)
535 ModestAccountMgrPrivate *priv;
540 g_return_val_if_fail (self, FALSE);
541 g_return_val_if_fail (name, FALSE);
542 g_return_val_if_fail (key, FALSE);
545 keyname = get_server_account_keyname (name, key);
547 keyname = get_account_keyname (name, key);
549 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
551 retval = modest_conf_set_string (priv->modest_conf, keyname, val,
560 modest_account_mgr_set_server_account_string (ModestAccountMgr * self,
566 return set_account_string (self, name, key, val, TRUE, err);
571 modest_account_mgr_set_account_string (ModestAccountMgr * self,
572 const gchar * name, const gchar * key,
573 const gchar * val, GError ** err)
575 return set_account_string (self, name, key, val, FALSE, err);
580 set_account_int (ModestAccountMgr * self, const gchar * name,
581 const gchar * key, gboolean server_account, int val,
584 ModestAccountMgrPrivate *priv;
589 g_return_val_if_fail (self, FALSE);
590 g_return_val_if_fail (name, FALSE);
591 g_return_val_if_fail (key, FALSE);
594 keyname = get_server_account_keyname (name, key);
596 keyname = get_account_keyname (name, key);
598 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
600 retval = modest_conf_set_int (priv->modest_conf, keyname, val, err);
608 modest_account_mgr_set_server_account_int (ModestAccountMgr * self,
610 const gchar * key, int val,
613 return set_account_int (self, name, key, val, TRUE, err);
618 modest_account_mgr_set_account_int (ModestAccountMgr * self,
619 const gchar * name, const gchar * key,
620 int val, GError ** err)
622 return set_account_int (self, name, key, val, FALSE, err);
627 set_account_bool (ModestAccountMgr * self, const gchar * name,
628 const gchar * key, gboolean server_account, gboolean val,
631 ModestAccountMgrPrivate *priv;
636 g_return_val_if_fail (self, FALSE);
637 g_return_val_if_fail (name, FALSE);
638 g_return_val_if_fail (key, FALSE);
641 keyname = get_server_account_keyname (name, key);
643 keyname = get_account_keyname (name, key);
645 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
647 retval = modest_conf_set_bool (priv->modest_conf, keyname, val, err);
655 modest_account_mgr_set_server_account_bool (ModestAccountMgr * self,
657 const gchar * key, gboolean val,
660 return set_account_bool (self, name, key, val, TRUE, err);
665 modest_account_mgr_set_account_bool (ModestAccountMgr * self,
666 const gchar * name, const gchar * key,
667 gboolean val, GError ** err)
669 return set_account_bool (self, name, key, val, FALSE, err);
674 account_exists (ModestAccountMgr * self, const gchar * name,
675 gboolean server_account, GError ** err)
677 ModestAccountMgrPrivate *priv;
682 g_return_val_if_fail (self, FALSE);
683 g_return_val_if_fail (name, FALSE);
686 keyname = get_server_account_keyname (name, NULL);
688 keyname = get_account_keyname (name, NULL);
690 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
691 retval = modest_conf_key_exists (priv->modest_conf, keyname, err);
699 modest_account_mgr_server_account_exists (ModestAccountMgr * self,
700 const gchar * name, GError ** err)
702 return account_exists (self, name, TRUE, err);
707 modest_account_mgr_account_exists (ModestAccountMgr * self,
708 const gchar * name, GError ** err)
710 return account_exists (self, name, FALSE, err);
714 /* must be freed by caller */
716 get_account_keyname (const gchar * accname, const gchar * name)
720 (MODEST_ACCOUNT_NAMESPACE, "/",
721 accname, "/", name, NULL);
724 (MODEST_ACCOUNT_NAMESPACE, "/", accname, NULL);
728 /* must be freed by caller */
730 get_server_account_keyname (const gchar * accname, const gchar * name)
734 (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
735 accname, "/", name, NULL);
738 (MODEST_SERVER_ACCOUNT_NAMESPACE, "/", accname, NULL);