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_get_type (void)
41 static GType my_type = 0;
44 static const GTypeInfo my_info = {
45 sizeof (ModestAccountMgrClass),
47 NULL, /* base finalize */
48 (GClassInitFunc) modest_account_mgr_class_init,
49 NULL, /* class finalize */
50 NULL, /* class data */
51 sizeof (ModestAccountMgr),
53 (GInstanceInitFunc) modest_account_mgr_init,
56 my_type = g_type_register_static (G_TYPE_OBJECT,
64 modest_account_mgr_class_init (ModestAccountMgrClass * klass)
66 GObjectClass *gobject_class;
68 gobject_class = (GObjectClass *) klass;
70 parent_class = g_type_class_peek_parent (klass);
71 gobject_class->finalize = modest_account_mgr_finalize;
73 g_type_class_add_private (gobject_class,
74 sizeof (ModestAccountMgrPrivate));
76 /* signal definitions go here, e.g.: */
77 /* signals[MY_SIGNAL_1] = */
78 /* g_signal_new ("my_signal_1",....); */
79 /* signals[MY_SIGNAL_2] = */
80 /* g_signal_new ("my_signal_2",....); */
86 modest_account_mgr_init (ModestAccountMgr * obj)
88 ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (obj);
90 priv->modest_conf = NULL;
94 modest_account_mgr_finalize (GObject * obj)
96 ModestAccountMgr *self = MODEST_ACCOUNT_MGR (obj);
97 ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
99 if (priv->modest_conf) {
100 g_object_unref (G_OBJECT(priv->modest_conf));
101 priv->modest_conf = NULL;
106 modest_account_mgr_new (ModestConf * conf)
109 ModestAccountMgrPrivate *priv;
111 g_return_val_if_fail (conf, NULL);
113 obj = G_OBJECT (g_object_new (MODEST_TYPE_ACCOUNT_MGR, NULL));
114 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (obj);
117 * increase the ref count on the modest_conf. Normally, the
118 * ModestConf should outlive the ModestAccountMgr though
120 g_object_ref (G_OBJECT (priv->modest_conf = conf));
126 modest_account_mgr_add_account (ModestAccountMgr * self, const gchar * name,
127 const gchar * store_account,
128 const gchar * transport_account,
131 ModestAccountMgrPrivate *priv;
134 g_return_val_if_fail (self, FALSE);
135 g_return_val_if_fail (name, FALSE);
137 if (modest_account_mgr_account_exists (self, name, err)) {
138 g_warning ("account already exists");
142 * we create the account by adding an account 'dir', with the name <name>,
143 * and in that the 'display_name' string key
145 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
147 key = get_account_keyname (name, MODEST_ACCOUNT_DISPLAY_NAME);
148 modest_conf_set_string (priv->modest_conf, key, name, err);
152 key = get_account_keyname (name,
153 MODEST_ACCOUNT_STORE_ACCOUNT);
154 modest_conf_set_string (priv->modest_conf, key, store_account,
159 if (transport_account) {
160 key = get_account_keyname (name,
161 MODEST_ACCOUNT_TRANSPORT_ACCOUNT);
162 modest_conf_set_string (priv->modest_conf, key,
163 transport_account, err);
167 return TRUE; /* TODO: error handling */
172 modest_account_mgr_remove_account (ModestAccountMgr * self,
173 const gchar * name, GError ** err)
175 ModestAccountMgrPrivate *priv;
179 g_return_val_if_fail (self, FALSE);
180 g_return_val_if_fail (name, FALSE);
182 if (!modest_account_mgr_account_exists (self, name, err)) {
183 g_warning ("account doest not exist");
187 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
188 key = get_account_keyname (name, NULL);
190 retval = modest_conf_remove_key (priv->modest_conf, key, NULL);
198 null_means_empty (const gchar * str)
200 return str ? str : "";
205 modest_account_mgr_add_server_account (ModestAccountMgr * self,
207 const gchar * hostname,
208 const gchar * username,
209 const gchar * password,
212 ModestAccountMgrPrivate *priv;
215 g_return_val_if_fail (self, FALSE);
216 g_return_val_if_fail (name, FALSE);
218 /* TODO: check already exists */
220 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
221 acckey = g_strconcat (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
224 if (modest_conf_key_exists (priv->modest_conf, acckey, NULL)) {
225 g_warning ("server account %s already exists", name);
231 key = g_strconcat (acckey, "/", MODEST_ACCOUNT_HOSTNAME, NULL);
232 modest_conf_set_string (priv->modest_conf, key,
233 null_means_empty (hostname), NULL);
237 key = g_strconcat (acckey, "/", MODEST_ACCOUNT_USERNAME, NULL);
238 modest_conf_set_string (priv->modest_conf, key,
239 null_means_empty (username), NULL);
244 key = g_strconcat (acckey, "/", MODEST_ACCOUNT_PASSWORD,
246 modest_conf_set_string (priv->modest_conf, key,
247 null_means_empty (password), NULL);
252 key = g_strconcat (acckey, "/", MODEST_ACCOUNT_PROTO, NULL);
253 modest_conf_set_string (priv->modest_conf, key,
254 null_means_empty (proto), NULL);
258 return TRUE; /* FIXME: better error checking */
262 modest_account_mgr_remove_server_account (ModestAccountMgr * self,
263 const gchar * name, GError ** err)
265 ModestAccountMgrPrivate *priv;
269 g_return_val_if_fail (self, FALSE);
270 g_return_val_if_fail (name, FALSE);
272 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
274 acckey = g_strconcat (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
277 if (!modest_conf_key_exists (priv->modest_conf, acckey, NULL)) {
278 g_warning ("server account %s does not exist exist", name);
283 retval = modest_conf_remove_key (priv->modest_conf, acckey, NULL);
290 /* strip the first /n/ character from each element */
291 /* caller must make sure all elements are strings with
292 * length >= n, and also that data can be freed.
295 strip_prefix_from_elements (GSList * lst, guint n)
297 GSList *cursor = lst;
300 gchar *str = (gchar *) cursor->data;
302 cursor->data = g_strdup (str + n);
304 cursor = cursor->next;
311 modest_account_mgr_server_account_names (ModestAccountMgr * self,
312 const gchar * account_name,
313 ModestProtoType type,
315 gboolean only_enabled)
319 ModestAccountMgrPrivate *priv;
320 const size_t prefix_len =
321 strlen (MODEST_SERVER_ACCOUNT_NAMESPACE "/");
323 g_return_val_if_fail (self, NULL);
325 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
326 accounts = modest_conf_list_subkeys (priv->modest_conf,
327 MODEST_SERVER_ACCOUNT_NAMESPACE,
330 /* no restrictions, return everything */
331 if (type == MODEST_PROTO_TYPE_ANY && !proto)
332 return strip_prefix_from_elements (accounts, prefix_len);
334 /* otherwise, filter out the none-matching ones */
337 gchar *keyspace, *proto_key, *acc_proto;
339 keyspace = (gchar *) cursor->data;
341 g_strconcat (keyspace, "/", MODEST_ACCOUNT_PROTO,
344 modest_conf_get_string (priv->modest_conf, proto_key,
348 if ((!acc_proto) || /* proto not defined? */
349 (type != MODEST_PROTO_TYPE_ANY && /* proto type ... */
350 modest_proto_type (acc_proto) != type) || /* ... matches? */
351 (proto && strcmp (proto, acc_proto) != 0)) { /* proto matches? */
352 /* no match: remove from the list */
353 GSList *nxt = cursor->next;
356 accounts = g_slist_delete_link (accounts, cursor);
359 cursor = cursor->next;
362 return strip_prefix_from_elements (accounts, prefix_len);
367 modest_account_mgr_account_names (ModestAccountMgr * self, GError ** err)
370 ModestAccountMgrPrivate *priv;
371 const size_t prefix_len = strlen (MODEST_ACCOUNT_NAMESPACE "/");
374 g_return_val_if_fail (self, NULL);
376 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
378 accounts = modest_conf_list_subkeys (priv->modest_conf,
379 MODEST_ACCOUNT_NAMESPACE, err);
380 return strip_prefix_from_elements (accounts, prefix_len);
385 get_account_string (ModestAccountMgr * self, const gchar * name,
386 const gchar * key, gboolean server_account, GError ** err)
388 ModestAccountMgrPrivate *priv;
393 g_return_val_if_fail (self, NULL);
394 g_return_val_if_fail (name, NULL);
395 g_return_val_if_fail (key, NULL);
398 keyname = get_server_account_keyname (name, key);
400 keyname = get_account_keyname (name, key);
402 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
403 retval = modest_conf_get_string (priv->modest_conf, keyname, err);
411 modest_account_mgr_get_server_account_string (ModestAccountMgr * self,
416 return get_account_string (self, name, key, TRUE, err);
421 modest_account_mgr_get_account_string (ModestAccountMgr * self,
422 const gchar * name, const gchar * key,
425 return get_account_string (self, name, key, FALSE, err);
430 get_account_int (ModestAccountMgr * self, const gchar * name,
431 const gchar * key, gboolean server_account, GError ** err)
433 ModestAccountMgrPrivate *priv;
438 g_return_val_if_fail (self, -1);
439 g_return_val_if_fail (name, -1);
440 g_return_val_if_fail (key, -1);
443 keyname = get_server_account_keyname (name, key);
445 keyname = get_account_keyname (name, key);
447 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
448 retval = modest_conf_get_int (priv->modest_conf, keyname, err);
456 modest_account_mgr_get_server_account_int (ModestAccountMgr * self,
458 const gchar * key, GError ** err)
460 return get_account_int (self, name, key, TRUE, err);
465 modest_account_mgr_get_account_int (ModestAccountMgr * self,
466 const gchar * name, const gchar * key,
469 return get_account_int (self, name, key, FALSE, err);
474 get_account_bool (ModestAccountMgr * self, const gchar * name,
475 const gchar * key, gboolean server_account, GError ** err)
477 ModestAccountMgrPrivate *priv;
482 g_return_val_if_fail (self, -1);
483 g_return_val_if_fail (name, -1);
484 g_return_val_if_fail (key, -1);
487 keyname = get_server_account_keyname (name, key);
489 keyname = get_account_keyname (name, key);
491 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
492 retval = modest_conf_get_int (priv->modest_conf, keyname, err);
500 modest_account_mgr_get_server_account_bool (ModestAccountMgr * self,
502 const gchar * key, GError ** err)
504 return get_account_bool (self, name, key, TRUE, err);
509 modest_account_mgr_get_account_bool (ModestAccountMgr * self,
510 const gchar * name, const gchar * key,
513 return get_account_bool (self, name, key, FALSE, err);
518 set_account_string (ModestAccountMgr * self, const gchar * name,
519 const gchar * key, const gchar * val,
520 gboolean server_account, GError ** err)
522 ModestAccountMgrPrivate *priv;
527 g_return_val_if_fail (self, FALSE);
528 g_return_val_if_fail (name, FALSE);
529 g_return_val_if_fail (key, FALSE);
532 keyname = get_server_account_keyname (name, key);
534 keyname = get_account_keyname (name, key);
536 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
538 retval = modest_conf_set_string (priv->modest_conf, keyname, val,
547 modest_account_mgr_set_server_account_string (ModestAccountMgr * self,
553 return set_account_string (self, name, key, val, TRUE, err);
558 modest_account_mgr_set_account_string (ModestAccountMgr * self,
559 const gchar * name, const gchar * key,
560 const gchar * val, GError ** err)
562 return set_account_string (self, name, key, val, FALSE, err);
567 set_account_int (ModestAccountMgr * self, const gchar * name,
568 const gchar * key, gboolean server_account, int val,
571 ModestAccountMgrPrivate *priv;
576 g_return_val_if_fail (self, FALSE);
577 g_return_val_if_fail (name, FALSE);
578 g_return_val_if_fail (key, FALSE);
581 keyname = get_server_account_keyname (name, key);
583 keyname = get_account_keyname (name, key);
585 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
587 retval = modest_conf_set_int (priv->modest_conf, keyname, val, err);
595 modest_account_mgr_set_server_account_int (ModestAccountMgr * self,
597 const gchar * key, int val,
600 return set_account_int (self, name, key, val, TRUE, err);
605 modest_account_mgr_set_account_int (ModestAccountMgr * self,
606 const gchar * name, const gchar * key,
607 int val, GError ** err)
609 return set_account_int (self, name, key, val, FALSE, err);
614 set_account_bool (ModestAccountMgr * self, const gchar * name,
615 const gchar * key, gboolean server_account, gboolean val,
618 ModestAccountMgrPrivate *priv;
623 g_return_val_if_fail (self, FALSE);
624 g_return_val_if_fail (name, FALSE);
625 g_return_val_if_fail (key, FALSE);
628 keyname = get_server_account_keyname (name, key);
630 keyname = get_account_keyname (name, key);
632 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
634 retval = modest_conf_set_bool (priv->modest_conf, keyname, val, err);
642 modest_account_mgr_set_server_account_bool (ModestAccountMgr * self,
644 const gchar * key, gboolean val,
647 return set_account_bool (self, name, key, val, TRUE, err);
652 modest_account_mgr_set_account_bool (ModestAccountMgr * self,
653 const gchar * name, const gchar * key,
654 gboolean val, GError ** err)
656 return set_account_bool (self, name, key, val, FALSE, err);
661 account_exists (ModestAccountMgr * self, const gchar * name,
662 gboolean server_account, GError ** err)
664 ModestAccountMgrPrivate *priv;
669 g_return_val_if_fail (self, FALSE);
670 g_return_val_if_fail (name, FALSE);
673 keyname = get_account_keyname (name, NULL);
675 keyname = get_server_account_keyname (name, NULL);
677 priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
678 retval = modest_conf_key_exists (priv->modest_conf, keyname, err);
686 modest_account_mgr_server_account_exists (ModestAccountMgr * self,
687 const gchar * name, GError ** err)
689 return account_exists (self, name, TRUE, err);
694 modest_account_mgr_account_exists (ModestAccountMgr * self,
695 const gchar * name, GError ** err)
697 return account_exists (self, name, FALSE, err);
701 /* must be freed by caller */
703 get_account_keyname (const gchar * accname, const gchar * name)
707 (MODEST_ACCOUNT_NAMESPACE, "/",
708 accname, "/", name, NULL);
711 (MODEST_ACCOUNT_NAMESPACE, "/", accname, NULL);
715 /* must be freed by caller */
717 get_server_account_keyname (const gchar * accname, const gchar * name)
721 (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
722 accname, "/", name, NULL);
725 (MODEST_SERVER_ACCOUNT_NAMESPACE, "/", accname, NULL);