git.maemo.org Git - modest/blob - src/modest-account-mgr.c

   1 /* modest-account-mgr.c */
   2
   3 /* insert (c)/licensing information) */
   4
   5 #include <string.h>
   6 #include "modest-account-mgr.h"
   7
   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);
  12
  13 static gchar*   get_account_keyname (const gchar *accname, const gchar *name);
  14 static gchar*   get_server_account_keyname (const gchar *accname, const gchar *name);
  15 static gchar*   get_identity_keyname (const gchar *accname, const gchar *name);
  16
  17 /* list my signals */
  18 enum {
  19         /* MY_SIGNAL_1, */
  20         /* MY_SIGNAL_2, */
  21         LAST_SIGNAL
  22 };
  23
  24 typedef struct _ModestAccountMgrPrivate ModestAccountMgrPrivate;
  25 struct _ModestAccountMgrPrivate {
  26         ModestConf *modest_conf;
  27 };
  28 #define MODEST_ACCOUNT_MGR_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  29                                                 MODEST_TYPE_ACCOUNT_MGR, \
  30                                                 ModestAccountMgrPrivate))
  31 /* globals */
  32 static GObjectClass *parent_class = NULL;
  33
  34 /* uncomment the following if you have defined any signals */
  35 /* static guint signals[LAST_SIGNAL] = {0}; */
  36
  37 GType
  38 modest_account_mgr_get_type (void)
  39 {
  40         static GType my_type = 0;
  41         if (!my_type) {
  42                 static const GTypeInfo my_info = {
  43                         sizeof(ModestAccountMgrClass),
  44                         NULL,           /* base init */
  45                         NULL,           /* base finalize */
  46                         (GClassInitFunc) modest_account_mgr_class_init,
  47                         NULL,           /* class finalize */
  48                         NULL,           /* class data */
  49                         sizeof(ModestAccountMgr),
  50                         1,              /* n_preallocs */
  51                         (GInstanceInitFunc) modest_account_mgr_init,
  52                 };
  53
  54                 my_type = g_type_register_static (G_TYPE_OBJECT,
  55                                                   "ModestAccountMgr",
  56                                                   &my_info, 0);
  57         }
  58         return my_type;
  59 }
  60
  61 static void
  62 modest_account_mgr_class_init (ModestAccountMgrClass *klass)
  63 {
  64         GObjectClass *gobject_class;
  65         gobject_class = (GObjectClass*) klass;
  66
  67         parent_class            = g_type_class_peek_parent (klass);
  68         gobject_class->finalize = modest_account_mgr_finalize;
  69
  70         g_type_class_add_private (gobject_class, sizeof(ModestAccountMgrPrivate));
  71
  72         /* signal definitions go here, e.g.: */
  73 /*      signals[MY_SIGNAL_1] = */
  74 /*              g_signal_new ("my_signal_1",....); */
  75 /*      signals[MY_SIGNAL_2] = */
  76 /*              g_signal_new ("my_signal_2",....); */
  77 /*      etc. */
  78 }
  79
  80
  81 static void
  82 modest_account_mgr_init (ModestAccountMgr *obj)
  83 {
  84         ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(obj);
  85         priv->modest_conf = NULL;
  86 }
  87
  88 static void
  89 modest_account_mgr_finalize (GObject *obj)
  90 {
  91         ModestAccountMgr *self = MODEST_ACCOUNT_MGR(obj);
  92         ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
  93
  94         g_object_unref (G_OBJECT(priv->modest_conf));
  95         priv->modest_conf = NULL;
  96 }
  97
  98 GObject*
  99 modest_account_mgr_new (ModestConf *conf)
 100 {
 101         GObject *obj;
 102         ModestAccountMgrPrivate *priv;
 103
 104         g_return_val_if_fail (conf, NULL);
 105
 106         obj  = G_OBJECT(g_object_new(MODEST_TYPE_ACCOUNT_MGR, NULL));
 107         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(obj);
 108
 109         /*
 110          * increase the ref count on the modest_conf. Normally, the
 111          * ModestConf should outlive the ModestAccountMgr though
 112          */
 113         g_object_ref(G_OBJECT(priv->modest_conf = conf));
 114         return obj;
 115 }
 116
 117
 118
 119 gboolean
 120 modest_account_mgr_add_account (ModestAccountMgr *self, const gchar* name,
 121                                 const gchar *store_account,
 122                                 const gchar *transport_account,
 123                                 GError **err)
 124 {
 125         ModestAccountMgrPrivate *priv;
 126         gchar *key;
 127         gboolean retval;
 128
 129         g_return_val_if_fail (self, FALSE);
 130         g_return_val_if_fail (name, FALSE);
 131
 132         if (modest_account_mgr_account_exists (self, name, err)) {
 133                 g_warning ("account already exists");
 134                 //return FALSE;
 135         }
 136         /*
 137          * we create the account by adding an account 'dir', with the name <name>,
 138          * and in that the 'display_name' string key
 139          */
 140         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 141
 142         key = get_account_keyname (name, MODEST_ACCOUNT_DISPLAY_NAME);
 143         modest_conf_set_string (priv->modest_conf, key, name, err);
 144         g_free (key);
 145
 146         if (store_account) {
 147                 key = get_account_keyname (name, MODEST_ACCOUNT_STORE_ACCOUNT);
 148                 modest_conf_set_string (priv->modest_conf, key, store_account, err);
 149                 g_free (key);
 150         }
 151
 152         if (transport_account) {
 153                 key = get_account_keyname (name, MODEST_ACCOUNT_TRANSPORT_ACCOUNT);
 154                 modest_conf_set_string (priv->modest_conf, key, transport_account, err);
 155                 g_free (key);
 156         }
 157
 158         return TRUE; /* TODO: error handling */
 159 }
 160
 161
 162 gboolean
 163 modest_account_mgr_remove_account (ModestAccountMgr *self, const gchar* name,
 164                            GError **err)
 165 {
 166         ModestAccountMgrPrivate *priv;
 167         gchar *key;
 168         gboolean retval;
 169
 170         g_return_val_if_fail (self, FALSE);
 171         g_return_val_if_fail (name, FALSE);
 172
 173         if (!modest_account_mgr_account_exists (self, name, err)) {
 174                 g_warning ("account doest not exist");
 175                 return FALSE;
 176         }
 177
 178         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 179         key = get_account_keyname (name, NULL);
 180
 181         retval = modest_conf_remove_key (priv->modest_conf, key, NULL);
 182
 183         g_free (key);
 184         return retval;
 185 }
 186
 187
 188 static const gchar*
 189 null_means_empty(const gchar* str)
 190 {
 191         return str ? str : "";
 192 }
 193
 194
 195 gboolean
 196 modest_account_mgr_add_server_account    (ModestAccountMgr *self,
 197                                           const gchar *name,
 198                                           const gchar *hostname,
 199                                           const gchar *username,
 200                                           const gchar *password,
 201                                           const gchar *proto)
 202 {
 203         ModestAccountMgrPrivate *priv;
 204         gchar *acckey, *key;
 205
 206         g_return_val_if_fail (self, FALSE);
 207         g_return_val_if_fail (name, FALSE);
 208
 209         /* TODO: check already exists */
 210
 211         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 212         acckey = g_strconcat (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
 213                               name, NULL);
 214
 215         if (modest_conf_key_exists(priv->modest_conf, acckey, NULL)) {
 216                 g_warning ("server account %s already exists", name);
 217                 g_free (acckey);
 218                 return FALSE;
 219         }
 220
 221         /* hostname */
 222         key = g_strconcat (acckey, "/", MODEST_ACCOUNT_HOSTNAME, NULL);
 223         modest_conf_set_string (priv->modest_conf, key,
 224                                 null_means_empty(hostname), NULL);
 225         g_free (key);
 226
 227         /* username */
 228         key = g_strconcat (acckey, "/", MODEST_ACCOUNT_USERNAME, NULL);
 229         modest_conf_set_string (priv->modest_conf, key,
 230                                 null_means_empty(username), NULL);
 231         g_free (key);
 232
 233         /* password */
 234         if (password)
 235         {
 236                 key = g_strconcat (acckey, "/", MODEST_ACCOUNT_PASSWORD, NULL);
 237                 modest_conf_set_string (priv->modest_conf, key,
 238                                         null_means_empty(password), NULL);
 239                 g_free (key);
 240         }
 241
 242         /* proto */
 243         key = g_strconcat (acckey, "/", MODEST_ACCOUNT_PROTO, NULL);
 244         modest_conf_set_string (priv->modest_conf, key,
 245                                 null_means_empty(proto),
 246                                 NULL);
 247         g_free (key);
 248         g_free (acckey);
 249
 250         return TRUE; /* FIXME: better error checking */
 251 }
 252
 253 gboolean
 254 modest_account_mgr_remove_server_account    (ModestAccountMgr *self,
 255                                              const gchar *name,
 256                                              GError **err)
 257 {
 258         ModestAccountMgrPrivate *priv;
 259         gchar *acckey, *key;
 260         gboolean retval;
 261
 262         g_return_val_if_fail (self, FALSE);
 263         g_return_val_if_fail (name, FALSE);
 264
 265         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 266
 267         acckey = g_strconcat (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
 268                               name, NULL);
 269
 270         if (!modest_conf_key_exists(priv->modest_conf, acckey, NULL)) {
 271                 g_warning ("server account %s does not exist exist", name);
 272                 g_free (acckey);
 273                 return FALSE;
 274         }
 275
 276         retval = modest_conf_remove_key (priv->modest_conf, acckey, NULL);
 277         g_free (acckey);
 278
 279         return retval;
 280 }
 281
 282 gboolean
 283 modest_account_mgr_remove_identity    (ModestAccountMgr *self,
 284                                              const gchar *name,
 285                                              GError **err)
 286 {
 287         ModestAccountMgrPrivate *priv;
 288         gchar *acckey, *key;
 289         gboolean retval;
 290
 291         g_return_val_if_fail (self, FALSE);
 292         g_return_val_if_fail (name, FALSE);
 293
 294         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 295
 296         acckey = g_strconcat (MODEST_IDENTITY_NAMESPACE, "/",
 297                               name, NULL);
 298
 299         if (!modest_conf_key_exists(priv->modest_conf, acckey, NULL)) {
 300                 g_warning ("server account %s does not exist exist", name);
 301                 g_free (acckey);
 302                 return FALSE;
 303         }
 304
 305         retval = modest_conf_remove_key (priv->modest_conf, acckey, NULL);
 306         g_free (acckey);
 307
 308         return retval;
 309 }
 310
 311
 312
 313 gboolean
 314 modest_account_mgr_add_identity (ModestAccountMgr *self,
 315                       const gchar *name,
 316                                           const gchar *email,
 317                                           const gchar *replyto,
 318                                           const gchar *signature,
 319                       const gboolean use_signature,
 320                       const gchar *id_via,
 321                       const gboolean use_id_via)
 322 {
 323         ModestAccountMgrPrivate *priv;
 324         gchar *id_key, *key;
 325
 326         g_return_val_if_fail (self, FALSE);
 327         g_return_val_if_fail (name, FALSE);
 328
 329         /* TODO: check already exists */
 330
 331         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 332         id_key = g_strconcat (MODEST_IDENTITY_NAMESPACE, "/",
 333                               name, NULL);
 334
 335         if (modest_conf_key_exists(priv->modest_conf, id_key, NULL)) {
 336                 g_warning ("identity %s already exists", name);
 337                 g_free (id_key);
 338                 return FALSE;
 339         }
 340
 341         /* email */
 342         key = g_strconcat (id_key, "/", MODEST_ACCOUNT_EMAIL, NULL);
 343         modest_conf_set_string (priv->modest_conf, key,
 344                                 null_means_empty(email), NULL);
 345         g_free (key);
 346
 347         /* replyto */
 348         key = g_strconcat (id_key, "/", MODEST_ACCOUNT_REPLYTO, NULL);
 349         modest_conf_set_string (priv->modest_conf, key,
 350                                 null_means_empty(replyto), NULL);
 351         g_free (key);
 352
 353         /* signature */
 354         key = g_strconcat (id_key, "/", MODEST_ACCOUNT_SIGNATURE, NULL);
 355         modest_conf_set_string (priv->modest_conf, key,
 356                                 null_means_empty(signature), NULL);
 357         g_free (key);
 358
 359         /* use_signature */
 360         key = g_strconcat (id_key, "/", MODEST_ACCOUNT_USE_SIGNATURE, NULL);
 361         modest_conf_set_bool (priv->modest_conf, key,
 362                                 use_signature, NULL);
 363         g_free (key);
 364
 365         /* signature */
 366         key = g_strconcat (id_key, "/", MODEST_ACCOUNT_ID_VIA, NULL);
 367         modest_conf_set_string (priv->modest_conf, key,
 368                                 null_means_empty(id_via), NULL);
 369         g_free (key);
 370
 371         /* use_signature */
 372         key = g_strconcat (id_key, "/", MODEST_ACCOUNT_USE_ID_VIA, NULL);
 373         modest_conf_set_bool (priv->modest_conf, key,
 374                                 use_id_via, NULL);
 375         g_free (key);
 376         g_free (id_key);
 377
 378         return TRUE; /* FIXME: better error checking */
 379 }
 380
 381 /* strip the first /n/ character from each element */
 382 /* caller must make sure all elements are strings with
 383  * length >= n, and also that data can be freed.
 384  */
 385 static GSList*
 386 strip_prefix_from_elements (GSList *lst, guint n)
 387 {
 388         GSList *cursor = lst;
 389         while (cursor) {
 390                 gchar *str = (gchar*)cursor->data;
 391                 cursor->data = g_strdup (str + n);
 392                 g_free (str);
 393                 cursor = cursor->next;
 394         }
 395         return lst;
 396 }
 397
 398
 399
 400 GSList*
 401 modest_account_mgr_server_account_names   (ModestAccountMgr *self,
 402                                            const gchar*    account_name,
 403                                            ModestProtoType type,
 404                                            const gchar*    proto,
 405                                            gboolean only_enabled)
 406 {
 407         GSList *accounts;
 408         GSList *cursor;
 409         ModestAccountMgrPrivate *priv;
 410         const size_t prefix_len =
 411                 strlen (MODEST_SERVER_ACCOUNT_NAMESPACE "/");
 412
 413         g_return_val_if_fail (self, NULL);
 414
 415         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 416         accounts = modest_conf_list_subkeys (priv->modest_conf,
 417                                              MODEST_SERVER_ACCOUNT_NAMESPACE,
 418                                              NULL);
 419
 420         /* no restrictions, return everything */
 421         if (type == MODEST_PROTO_TYPE_ANY && !proto)
 422                 return strip_prefix_from_elements (accounts,prefix_len);
 423
 424         /* otherwise, filter out the none-matching ones */
 425         cursor = accounts;
 426         while (cursor) {
 427                 gchar *keyspace, *proto_key, *acc_proto;
 428
 429                 keyspace  = (gchar*) cursor->data;
 430                 proto_key = g_strconcat (keyspace, "/", MODEST_ACCOUNT_PROTO, NULL);
 431                 acc_proto = modest_conf_get_string (priv->modest_conf, proto_key,
 432                                                     NULL);
 433                 g_free (proto_key);
 434
 435                 if ((!acc_proto) ||                              /* proto not defined? */
 436                     (type != MODEST_PROTO_TYPE_ANY &&            /* proto type ...     */
 437                      modest_proto_type (acc_proto) != type) ||   /* ... matches?       */
 438                     (proto && strcmp(proto,acc_proto) != 0)) {   /* proto matches?     */
 439                         /* no match: remove from the list */
 440                         GSList *nxt = cursor->next;
 441                         g_free (acc_proto);
 442                         accounts = g_slist_delete_link (accounts, cursor);
 443                         cursor = nxt;
 444                 } else
 445                         cursor = cursor->next;
 446         }
 447
 448         return strip_prefix_from_elements (accounts, prefix_len);
 449 }
 450
 451
 452
 453 GSList*
 454 modest_account_mgr_account_names  (ModestAccountMgr *self, GError **err)
 455 {
 456         GSList *accounts, *cursor;
 457         ModestAccountMgrPrivate *priv;
 458         const size_t prefix_len =
 459                 strlen (MODEST_ACCOUNT_NAMESPACE "/");
 460
 461
 462         g_return_val_if_fail (self, NULL);
 463
 464         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 465
 466         accounts = modest_conf_list_subkeys (priv->modest_conf,
 467                                              MODEST_ACCOUNT_NAMESPACE,
 468                                              err);
 469         return strip_prefix_from_elements (accounts, prefix_len);
 470 }
 471
 472
 473
 474 static gchar*
 475 get_account_string (ModestAccountMgr *self, const gchar *name,
 476                     const gchar *key, gboolean server_account,
 477                     GError **err)
 478 {
 479         ModestAccountMgrPrivate *priv;
 480
 481         gchar *keyname;
 482         gchar * retval;
 483
 484         g_return_val_if_fail (self, NULL);
 485         g_return_val_if_fail (name, NULL);
 486         g_return_val_if_fail (key, NULL);
 487
 488         if (server_account)
 489                 keyname = get_server_account_keyname (name, key);
 490         else
 491                 keyname = get_account_keyname (name, key);
 492
 493         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 494         retval = modest_conf_get_string (priv->modest_conf,keyname,err);
 495         g_free (keyname);
 496
 497         return retval;
 498 }
 499
 500
 501 gchar*
 502 modest_account_mgr_get_server_account_string (ModestAccountMgr *self, const gchar *name,
 503                                            const gchar *key, GError **err)
 504 {
 505         return get_account_string (self, name, key, TRUE, err);
 506 }
 507
 508 gchar*
 509 modest_account_mgr_get_account_string (ModestAccountMgr *self, const gchar *name,
 510                                     const gchar *key, GError **err)
 511 {
 512         return get_account_string (self, name, key, FALSE, err);
 513 }
 514
 515 gchar*
 516 modest_account_mgr_get_identity_string (ModestAccountMgr *self, const gchar *name,
 517                     const gchar *key, GError **err)
 518 {
 519         ModestAccountMgrPrivate *priv;
 520
 521         gchar *keyname;
 522         gchar * retval;
 523
 524         g_return_val_if_fail (self, NULL);
 525         g_return_val_if_fail (name, NULL);
 526         g_return_val_if_fail (key, NULL);
 527
 528         keyname = get_identity_keyname (name, key);
 529
 530         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 531         retval = modest_conf_get_string (priv->modest_conf,keyname,err);
 532         g_free (keyname);
 533
 534         return retval;
 535 }
 536
 537
 538 static gint
 539 get_account_int (ModestAccountMgr *self, const gchar *name,
 540                  const gchar *key, gboolean server_account,
 541                  GError **err)
 542 {
 543         ModestAccountMgrPrivate *priv;
 544
 545         gchar *keyname;
 546         gint retval;
 547
 548         g_return_val_if_fail (self, -1);
 549         g_return_val_if_fail (name, -1);
 550         g_return_val_if_fail (key, -1);
 551
 552         if (server_account)
 553                 keyname = get_server_account_keyname (name, key);
 554         else
 555                 keyname = get_account_keyname (name, key);
 556
 557         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 558         retval = modest_conf_get_int (priv->modest_conf,keyname,err);
 559         g_free (keyname);
 560
 561         return retval;
 562 }
 563
 564
 565 gint
 566 modest_account_mgr_get_server_account_int (ModestAccountMgr *self, const gchar *name,
 567                                            const gchar *key, GError **err)
 568 {
 569         return get_account_int (self, name, key, TRUE, err);
 570 }
 571
 572 gint
 573 modest_account_mgr_get_account_int (ModestAccountMgr *self, const gchar *name,
 574                                     const gchar *key, GError **err)
 575 {
 576         return get_account_int (self, name, key, FALSE, err);
 577 }
 578
 579
 580
 581 static gboolean
 582 get_account_bool (ModestAccountMgr *self, const gchar *name,
 583                   const gchar *key, gboolean server_account,
 584                   GError **err)
 585 {
 586         ModestAccountMgrPrivate *priv;
 587
 588         gchar *keyname;
 589         gboolean retval;
 590
 591         g_return_val_if_fail (self, -1);
 592         g_return_val_if_fail (name, -1);
 593         g_return_val_if_fail (key, -1);
 594
 595         if (server_account)
 596                 keyname = get_server_account_keyname (name, key);
 597         else
 598                 keyname = get_account_keyname (name, key);
 599
 600         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 601         retval = modest_conf_get_int (priv->modest_conf,keyname,err);
 602         g_free (keyname);
 603
 604         return retval;
 605 }
 606
 607
 608
 609 gint
 610 modest_account_mgr_get_server_account_bool (ModestAccountMgr *self, const gchar *name,
 611                                            const gchar *key, GError **err)
 612 {
 613         return get_account_bool (self, name, key, TRUE, err);
 614 }
 615
 616 gint
 617 modest_account_mgr_get_account_bool (ModestAccountMgr *self, const gchar *name,
 618                                     const gchar *key, GError **err)
 619 {
 620         return get_account_bool (self, name, key, FALSE, err);
 621 }
 622
 623
 624
 625
 626
 627 static gboolean
 628 set_account_string  (ModestAccountMgr *self, const gchar *name,
 629                      const gchar *key, const gchar* val, gboolean server_account,
 630                      GError **err)
 631 {
 632         ModestAccountMgrPrivate *priv;
 633
 634         gchar *keyname;
 635         gboolean retval;
 636
 637         g_return_val_if_fail (self, FALSE);
 638         g_return_val_if_fail (name, FALSE);
 639         g_return_val_if_fail (key, FALSE);
 640
 641         if (server_account)
 642                 keyname = get_server_account_keyname (name, key);
 643         else
 644                 keyname = get_account_keyname (name, key);
 645
 646         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 647
 648         retval = modest_conf_set_string (priv->modest_conf,keyname,val,err);
 649
 650         g_free (keyname);
 651         return retval;
 652 }
 653
 654
 655
 656
 657
 658 gboolean
 659 modest_account_mgr_set_server_account_string  (ModestAccountMgr *self, const gchar *name,
 660                                                const gchar *key, const gchar* val,
 661                                                GError **err)
 662 {
 663         return set_account_string (self, name, key, val, TRUE, err);
 664 }
 665
 666
 667
 668 gboolean
 669 modest_account_mgr_set_account_string  (ModestAccountMgr *self, const gchar *name,
 670                                         const gchar *key, const gchar* val,
 671                                         GError **err)
 672 {
 673         return set_account_string (self, name, key, val, FALSE, err);
 674 }
 675
 676
 677 static gboolean
 678 set_account_int  (ModestAccountMgr *self, const gchar *name,
 679                   const gchar *key, gboolean server_account, int val,
 680                   GError **err)
 681 {
 682         ModestAccountMgrPrivate *priv;
 683
 684         gchar *keyname;
 685         gboolean retval;
 686
 687         g_return_val_if_fail (self, FALSE);
 688         g_return_val_if_fail (name, FALSE);
 689         g_return_val_if_fail (key, FALSE);
 690
 691         if (server_account)
 692                 keyname = get_server_account_keyname (name, key);
 693         else
 694                 keyname = get_account_keyname (name, key);
 695
 696         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 697
 698         retval = modest_conf_set_int (priv->modest_conf,keyname,val,err);
 699
 700         g_free (keyname);
 701         return retval;
 702 }
 703
 704
 705
 706 gboolean
 707 modest_account_mgr_set_server_account_int (ModestAccountMgr *self, const gchar *name,
 708                                            const gchar *key, int val,
 709                                            GError **err)
 710 {
 711         return set_account_int (self, name, key, val, TRUE, err);
 712 }
 713
 714
 715 gboolean
 716 modest_account_mgr_set_account_int  (ModestAccountMgr *self, const gchar *name,
 717                                      const gchar *key, int val,
 718                                      GError **err)
 719 {
 720         return set_account_int (self, name, key, val, FALSE, err);
 721 }
 722
 723
 724
 725
 726 static gboolean
 727 set_account_bool  (ModestAccountMgr *self, const gchar *name,
 728                    const gchar *key, gboolean server_account, gboolean val,
 729                    GError **err)
 730 {
 731         ModestAccountMgrPrivate *priv;
 732
 733         gchar *keyname;
 734         gboolean retval;
 735
 736         g_return_val_if_fail (self, FALSE);
 737         g_return_val_if_fail (name, FALSE);
 738         g_return_val_if_fail (key, FALSE);
 739
 740         if (server_account)
 741                 keyname = get_server_account_keyname (name, key);
 742         else
 743                 keyname = get_account_keyname (name, key);
 744
 745         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 746
 747         retval = modest_conf_set_bool (priv->modest_conf,keyname,val,err);
 748
 749         g_free (keyname);
 750         return retval;
 751 }
 752
 753
 754 gboolean
 755 modest_account_mgr_set_server_account_bool  (ModestAccountMgr *self, const gchar *name,
 756                                              const gchar *key, gboolean val,
 757                                              GError **err)
 758 {
 759         return set_account_bool (self, name, key, val, TRUE, err);
 760 }
 761
 762
 763
 764 gboolean
 765 modest_account_mgr_set_account_bool  (ModestAccountMgr *self, const gchar *name,
 766                                         const gchar *key, gboolean val,
 767                                         GError **err)
 768 {
 769         return set_account_bool (self, name, key, val, FALSE, err);
 770 }
 771
 772
 773
 774
 775
 776 gboolean
 777 account_exists (ModestAccountMgr *self, const gchar *name, gboolean server_account,
 778                 GError **err)
 779 {
 780         ModestAccountMgrPrivate *priv;
 781
 782         gchar *keyname;
 783         gboolean retval;
 784
 785         g_return_val_if_fail (self, FALSE);
 786         g_return_val_if_fail (name, FALSE);
 787
 788         if (server_account)
 789                 keyname = get_account_keyname (name, NULL);
 790         else
 791                 keyname = get_server_account_keyname (name, NULL);
 792
 793         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 794         retval = modest_conf_key_exists (priv->modest_conf,keyname,err);
 795
 796         g_free (keyname);
 797         return retval;
 798 }
 799
 800
 801 gboolean
 802 modest_account_mgr_server_account_exists (ModestAccountMgr *self, const gchar *name,
 803                                    GError **err)
 804 {
 805         return account_exists (self, name, TRUE, err);
 806 }
 807
 808
 809 gboolean
 810 modest_account_mgr_account_exists (ModestAccountMgr *self, const gchar *name,
 811                                    GError **err)
 812 {
 813         return account_exists (self, name, FALSE, err);
 814 }
 815
 816 gboolean
 817 modest_account_mgr_identity_exists (ModestAccountMgr *self, const gchar *name,
 818                                    GError **err)
 819 {
 820         return account_exists (self, name, TRUE, err);
 821 }
 822
 823
 824
 825 /* must be freed by caller */
 826 static gchar*
 827 get_account_keyname (const gchar *accname, const gchar *name)
 828 {
 829         if (name)
 830                 return g_strconcat
 831                         (MODEST_ACCOUNT_NAMESPACE, "/",
 832                          accname, "/", name, NULL);
 833         else
 834                 return g_strconcat
 835                         (MODEST_ACCOUNT_NAMESPACE, "/",
 836                          accname, NULL);
 837 }
 838
 839
 840 /* must be freed by caller */
 841 static gchar*
 842 get_server_account_keyname (const gchar *accname, const gchar *name)
 843 {
 844         if (name)
 845                 return g_strconcat
 846                         (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
 847                          accname, "/", name, NULL);
 848         else
 849                 return g_strconcat
 850                         (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
 851                          accname, NULL);
 852 }
 853
 854 /* must be freed by caller */
 855 static gchar*
 856 get_identity_keyname (const gchar *accname, const gchar *name)
 857 {
 858         if (name)
 859                 return g_strconcat
 860                         (MODEST_IDENTITY_NAMESPACE "/",
 861                          accname, "/", name, NULL);
 862         else
 863                 return g_strconcat
 864                         (MODEST_IDENTITY_NAMESPACE, "/",
 865                          accname, NULL);
 866 }