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
  15 /* list my signals */
  16 enum {
  17         /* MY_SIGNAL_1, */
  18         /* MY_SIGNAL_2, */
  19         LAST_SIGNAL
  20 };
  21
  22 typedef struct _ModestAccountMgrPrivate ModestAccountMgrPrivate;
  23 struct _ModestAccountMgrPrivate {
  24         ModestConf *modest_conf;
  25 };
  26 #define MODEST_ACCOUNT_MGR_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  27                                                 MODEST_TYPE_ACCOUNT_MGR, \
  28                                                 ModestAccountMgrPrivate))
  29 /* globals */
  30 static GObjectClass *parent_class = NULL;
  31
  32 /* uncomment the following if you have defined any signals */
  33 /* static guint signals[LAST_SIGNAL] = {0}; */
  34
  35 GType
  36 modest_account_mgr_get_type (void)
  37 {
  38         static GType my_type = 0;
  39         if (!my_type) {
  40                 static const GTypeInfo my_info = {
  41                         sizeof(ModestAccountMgrClass),
  42                         NULL,           /* base init */
  43                         NULL,           /* base finalize */
  44                         (GClassInitFunc) modest_account_mgr_class_init,
  45                         NULL,           /* class finalize */
  46                         NULL,           /* class data */
  47                         sizeof(ModestAccountMgr),
  48                         1,              /* n_preallocs */
  49                         (GInstanceInitFunc) modest_account_mgr_init,
  50                 };
  51
  52                 my_type = g_type_register_static (G_TYPE_OBJECT,
  53                                                   "ModestAccountMgr",
  54                                                   &my_info, 0);
  55         }
  56         return my_type;
  57 }
  58
  59 static void
  60 modest_account_mgr_class_init (ModestAccountMgrClass *klass)
  61 {
  62         GObjectClass *gobject_class;
  63         gobject_class = (GObjectClass*) klass;
  64
  65         parent_class            = g_type_class_peek_parent (klass);
  66         gobject_class->finalize = modest_account_mgr_finalize;
  67
  68         g_type_class_add_private (gobject_class, sizeof(ModestAccountMgrPrivate));
  69
  70         /* signal definitions go here, e.g.: */
  71 /*      signals[MY_SIGNAL_1] = */
  72 /*              g_signal_new ("my_signal_1",....); */
  73 /*      signals[MY_SIGNAL_2] = */
  74 /*              g_signal_new ("my_signal_2",....); */
  75 /*      etc. */
  76 }
  77
  78
  79 static void
  80 modest_account_mgr_init (ModestAccountMgr *obj)
  81 {
  82         ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(obj);
  83         priv->modest_conf = NULL;
  84 }
  85
  86 static void
  87 modest_account_mgr_finalize (GObject *obj)
  88 {
  89         ModestAccountMgr *self = MODEST_ACCOUNT_MGR(obj);
  90         ModestAccountMgrPrivate *priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
  91
  92         g_object_unref (G_OBJECT(priv->modest_conf));
  93         priv->modest_conf = NULL;
  94 }
  95
  96 GObject*
  97 modest_account_mgr_new (ModestConf *conf)
  98 {
  99         GObject *obj;
 100         ModestAccountMgrPrivate *priv;
 101
 102         g_return_val_if_fail (conf, NULL);
 103
 104         obj  = G_OBJECT(g_object_new(MODEST_TYPE_ACCOUNT_MGR, NULL));
 105         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(obj);
 106
 107         /*
 108          * increase the ref count on the modest_conf. Normally, the
 109          * ModestConf should outlive the ModestAccountMgr though
 110          */
 111         g_object_ref(G_OBJECT(priv->modest_conf = conf));
 112         return obj;
 113 }
 114
 115
 116
 117 gboolean
 118 modest_account_mgr_add_account (ModestAccountMgr *self, const gchar* name,
 119                                 const gchar *store_account,
 120                                 const gchar *transport_account,
 121                                 GError **err)
 122 {
 123         ModestAccountMgrPrivate *priv;
 124         gchar *key;
 125         gboolean retval;
 126
 127         g_return_val_if_fail (self, FALSE);
 128         g_return_val_if_fail (name, FALSE);
 129
 130         if (modest_account_mgr_account_exists (self, name, err)) {
 131                 g_warning ("account already exists");
 132                 //return FALSE;
 133         }
 134         /*
 135          * we create the account by adding an account 'dir', with the name <name>,
 136          * and in that the 'display_name' string key
 137          */
 138         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 139
 140         /* SMF:
 141          * key = get_account_keyname (name, MODEST_ACCOUNT_DISPLAY_NAME);
 142          * doesn't work this way, instead use:
 143          */
 144         key = g_strconcat (MODEST_ACCOUNT_NAMESPACE, "/",
 145                               name, MODEST_ACCOUNT_DISPLAY_NAME, NULL);
 146
 147         modest_conf_set_string (priv->modest_conf, key, name, err);
 148         g_free (key);
 149
 150         if (store_account) {
 151                 /* SMF:
 152                  * key = get_account_keyname (name, MODEST_ACCOUNT_STORE_ACCOUNT);
 153                  * as above, does not work.
 154                  */
 155                 key = g_strconcat (MODEST_ACCOUNT_NAMESPACE, "/",
 156                                    name, MODEST_ACCOUNT_STORE_ACCOUNT, NULL);
 157
 158                 modest_conf_set_string (priv->modest_conf, key, store_account, err);
 159                 g_free (key);
 160         }
 161
 162         if (transport_account) {
 163                 /* SMF:
 164                  * key = get_account_keyname (name, MODEST_ACCOUNT_TRANSPORT_ACCOUNT);
 165                  * ...
 166                  */
 167                 key = g_strconcat (MODEST_ACCOUNT_NAMESPACE, "/",
 168                                    name, MODEST_ACCOUNT_TRANSPORT_ACCOUNT, NULL);
 169                 modest_conf_set_string (priv->modest_conf, key, transport_account, err);
 170                 g_free (key);
 171         }
 172
 173         return TRUE; /* TODO: error handling */
 174 }
 175
 176
 177 gboolean
 178 modest_account_mgr_remove_account (ModestAccountMgr *self, const gchar* name,
 179                            GError **err)
 180 {
 181         ModestAccountMgrPrivate *priv;
 182         gchar *key;
 183         gboolean retval;
 184
 185         g_return_val_if_fail (self, FALSE);
 186         g_return_val_if_fail (name, FALSE);
 187
 188         if (!modest_account_mgr_account_exists (self, name, err)) {
 189                 g_warning ("account doest not exist");
 190                 return FALSE;
 191         }
 192
 193         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 194         key = get_account_keyname (name, NULL);
 195
 196         retval = modest_conf_remove_key (priv->modest_conf, key, NULL);
 197
 198         g_free (key);
 199         return retval;
 200 }
 201
 202
 203 static const gchar*
 204 null_means_empty(const gchar* str)
 205 {
 206         return str ? str : "";
 207 }
 208
 209
 210 gboolean
 211 modest_account_mgr_add_server_account    (ModestAccountMgr *self,
 212                                           const gchar *name,
 213                                           const gchar *hostname,
 214                                           const gchar *username,
 215                                           const gchar *password,
 216                                           const gchar *proto)
 217 {
 218         ModestAccountMgrPrivate *priv;
 219         gchar *acckey, *key;
 220
 221         g_return_val_if_fail (self, FALSE);
 222         g_return_val_if_fail (name, FALSE);
 223
 224         /* TODO: check already exists */
 225
 226         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 227         acckey = g_strconcat (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
 228                               name, NULL);
 229
 230         if (modest_conf_key_exists(priv->modest_conf, acckey, NULL)) {
 231                 g_warning ("server account %s already exists", name);
 232                 g_free (acckey);
 233                 return FALSE;
 234         }
 235
 236         /* hostname */
 237         key = g_strconcat (acckey, "/", MODEST_ACCOUNT_HOSTNAME, NULL);
 238         modest_conf_set_string (priv->modest_conf, key,
 239                                 null_means_empty(hostname), NULL);
 240         g_free (key);
 241
 242         /* username */
 243         key = g_strconcat (acckey, "/", MODEST_ACCOUNT_USERNAME, NULL);
 244         modest_conf_set_string (priv->modest_conf, key,
 245                                 null_means_empty(username), NULL);
 246         g_free (key);
 247
 248         /* password */
 249         key = g_strconcat (acckey, "/", MODEST_ACCOUNT_PASSWORD, NULL);
 250         modest_conf_set_string (priv->modest_conf, key,
 251                                 null_means_empty(password), NULL);
 252         g_free (key);
 253
 254         /* proto */
 255         key = g_strconcat (acckey, "/", MODEST_ACCOUNT_PROTO, NULL);
 256         modest_conf_set_string (priv->modest_conf, key,
 257                                 null_means_empty(proto),
 258                                 NULL);
 259         g_free (key);
 260
 261         return TRUE; /* FIXME: better error checking */
 262 }
 263
 264 gboolean
 265 modest_account_mgr_remove_server_account    (ModestAccountMgr *self,
 266                                              const gchar *name,
 267                                              GError **err)
 268 {
 269         ModestAccountMgrPrivate *priv;
 270         gchar *acckey, *key;
 271         gboolean retval;
 272
 273         g_return_val_if_fail (self, FALSE);
 274         g_return_val_if_fail (name, FALSE);
 275
 276         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 277
 278         acckey = g_strconcat (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
 279                               name, NULL);
 280
 281         if (!modest_conf_key_exists(priv->modest_conf, acckey, NULL)) {
 282                 g_warning ("server account %s does not exist exist", name);
 283                 g_free (acckey);
 284                 return FALSE;
 285         }
 286
 287         retval = modest_conf_remove_key (priv->modest_conf, acckey, NULL);
 288         g_free (acckey);
 289
 290         return retval;
 291 }
 292
 293
 294
 295
 296 GSList*
 297 modest_account_mgr_server_account_names   (ModestAccountMgr *self,
 298                                            const gchar*    account_name,
 299                                            ModestProtoType type,
 300                                            const gchar*    proto,
 301                                            gboolean only_enabled)
 302 {
 303         GSList *accounts;
 304         GSList *cursor;
 305         ModestAccountMgrPrivate *priv;
 306
 307         g_return_val_if_fail (self, NULL);
 308
 309         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 310         accounts = modest_conf_list_subkeys (priv->modest_conf,
 311                                              MODEST_SERVER_ACCOUNT_NAMESPACE,
 312                                              NULL);
 313
 314         /* no restrictions, return everything */
 315         if (type == MODEST_PROTO_TYPE_ANY && !proto)
 316                 return accounts;
 317
 318         /* otherwise, filter out the none-matching ones */
 319         cursor = accounts;
 320         while (cursor) {
 321                 gchar *keyspace, *proto_key, *acc_proto;
 322
 323                 keyspace  = (gchar*) cursor->data;
 324                 proto_key = g_strconcat (keyspace, "/", MODEST_ACCOUNT_PROTO, NULL);
 325                 acc_proto = modest_conf_get_string (priv->modest_conf, proto_key,
 326                                                     NULL);
 327                 g_free (proto_key);
 328
 329                 if ((!acc_proto) ||                              /* proto not defined? */
 330                     (type != MODEST_PROTO_TYPE_ANY &&            /* proto type ...     */
 331                      modest_proto_type (acc_proto) != type) ||   /* ... matches?       */
 332                     (proto && strcmp(proto,acc_proto) != 0)) {   /* proto matches?     */
 333                         /* no match: remove from the list */
 334                         GSList *nxt = cursor->next;
 335                         g_free (acc_proto);
 336                         accounts = g_slist_delete_link (accounts, cursor);
 337                         cursor = nxt;
 338                 } else
 339                         cursor = cursor->next;
 340         }
 341
 342         return accounts;
 343 }
 344
 345
 346
 347 GSList*
 348 modest_account_mgr_account_names  (ModestAccountMgr *self, GError **err)
 349 {
 350         GSList *accounts, *cursor;
 351         ModestAccountMgrPrivate *priv;
 352
 353         g_return_val_if_fail (self, NULL);
 354
 355         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 356
 357         return  modest_conf_list_subkeys (priv->modest_conf,
 358                                           MODEST_ACCOUNT_NAMESPACE,
 359                                           err);
 360 }
 361
 362
 363 gchar*
 364 modest_account_mgr_get_account_string (ModestAccountMgr *self, const gchar *name,
 365                                        const gchar *key, GError **err)
 366 {
 367         ModestAccountMgrPrivate *priv;
 368
 369         gchar *keyname;
 370         gchar *retval;
 371
 372         g_return_val_if_fail (self, NULL);
 373         g_return_val_if_fail (name, NULL);
 374         g_return_val_if_fail (key, NULL);
 375
 376         keyname = get_account_keyname (name, key);
 377
 378         g_warning ("modest_account_mgr_get_account_string > %s", keyname);
 379
 380         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 381
 382         retval = modest_conf_get_string (priv->modest_conf,
 383                                          keyname, err);
 384
 385         g_free (keyname);
 386         return retval;
 387 }
 388
 389
 390
 391 gint
 392 modest_account_mgr_get_account_int (ModestAccountMgr *self, const gchar *name,
 393                                     const gchar *key, GError **err)
 394 {
 395         ModestAccountMgrPrivate *priv;
 396
 397         gchar *keyname;
 398         gint retval;
 399
 400         g_return_val_if_fail (self, -1);
 401         g_return_val_if_fail (name, -1);
 402         g_return_val_if_fail (key, -1);
 403
 404         keyname = get_account_keyname (name, key);
 405         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 406         retval = modest_conf_get_int (priv->modest_conf,keyname,err);
 407
 408         g_free (keyname);
 409         return retval;
 410 }
 411
 412
 413 gboolean modest_account_mgr_get_account_bool (ModestAccountMgr *self, const gchar *name,
 414                                               const gchar *key, GError **err)
 415 {
 416         ModestAccountMgrPrivate *priv;
 417
 418         gchar *keyname;
 419         gboolean retval;
 420
 421         g_return_val_if_fail (self, FALSE);
 422         g_return_val_if_fail (name, FALSE);
 423         g_return_val_if_fail (key, FALSE);
 424
 425         keyname = get_account_keyname (name, key);
 426         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 427         retval = modest_conf_get_bool (priv->modest_conf,keyname,err);
 428
 429         g_free (keyname);
 430         return retval;
 431 }
 432
 433
 434
 435 gboolean
 436 modest_account_mgr_set_account_string  (ModestAccountMgr *self, const gchar *name,
 437                                         const gchar *key, const gchar* val,
 438                                         GError **err)
 439 {
 440         ModestAccountMgrPrivate *priv;
 441
 442         gchar *keyname;
 443         gboolean retval;
 444
 445         g_return_val_if_fail (self, FALSE);
 446         g_return_val_if_fail (name, FALSE);
 447         g_return_val_if_fail (key, FALSE);
 448
 449         keyname = get_account_keyname (name, key);
 450         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 451         retval = modest_conf_set_string (priv->modest_conf,keyname,val,err);
 452
 453         g_free (keyname);
 454         return retval;
 455 }
 456
 457
 458
 459 gboolean
 460 modest_account_mgr_set_account_int  (ModestAccountMgr *self, const gchar *name,
 461                                      const gchar *key, gint val, GError **err)
 462 {
 463         ModestAccountMgrPrivate *priv;
 464
 465         gchar *keyname;
 466         gboolean retval;
 467
 468         g_return_val_if_fail (self, -1);
 469         g_return_val_if_fail (name, -1);
 470         g_return_val_if_fail (key, -1);
 471
 472         keyname = get_account_keyname (name, key);
 473         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 474         retval = modest_conf_set_int (priv->modest_conf,keyname,val,err);
 475
 476         g_free (keyname);
 477         return retval;
 478 }
 479
 480
 481
 482
 483 gboolean
 484 modest_account_mgr_set_account_bool  (ModestAccountMgr *self, const gchar *name,
 485                                       const gchar *key, gboolean val, GError **err)
 486 {
 487         ModestAccountMgrPrivate *priv;
 488
 489         gchar *keyname;
 490         gboolean retval;
 491
 492         g_return_val_if_fail (self, FALSE);
 493         g_return_val_if_fail (name, FALSE);
 494         g_return_val_if_fail (key, FALSE);
 495
 496         keyname = get_account_keyname (name, key);
 497         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 498         retval = modest_conf_set_bool (priv->modest_conf,keyname,val,err);
 499
 500         g_free (keyname);
 501         return retval;
 502 }
 503
 504
 505 gboolean
 506 modest_account_mgr_account_exists (ModestAccountMgr *self, const gchar *name,
 507                                    GError **err)
 508 {
 509         ModestAccountMgrPrivate *priv;
 510
 511         gchar *keyname;
 512         gboolean retval;
 513
 514         g_return_val_if_fail (self, FALSE);
 515         g_return_val_if_fail (name, FALSE);
 516
 517         keyname = get_account_keyname (name, NULL);
 518
 519         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 520         retval = modest_conf_key_exists (priv->modest_conf,keyname,err);
 521
 522         g_free (keyname);
 523         return retval;
 524 }
 525
 526
 527
 528 /* must be freed by caller */
 529 static gchar*
 530 get_account_keyname (const gchar *accname, const gchar *name)
 531 {
 532         if (name)
 533                 return g_strconcat
 534                         (accname, "/", name, NULL);
 535         else
 536                 return g_strconcat
 537                         /* SMF: I think, this has to be done somewhere else. For now it's a quick fix. */
 538                         (MODEST_ACCOUNT_NAMESPACE, "/", accname, NULL);
 539 }
 540