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