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         key = get_account_keyname (name, MODEST_ACCOUNT_DISPLAY_NAME);
 141         modest_conf_set_string (priv->modest_conf, key, name, err);
 142         g_free (key);
 143
 144         if (store_account) {
 145                 key = get_account_keyname (name, MODEST_ACCOUNT_STORE_ACCOUNT);
 146                 modest_conf_set_string (priv->modest_conf, key, store_account, err);
 147                 g_free (key);
 148         }
 149
 150         if (transport_account) {
 151                 key = get_account_keyname (name, MODEST_ACCOUNT_TRANSPORT_ACCOUNT);
 152                 modest_conf_set_string (priv->modest_conf, key, transport_account, err);
 153                 g_free (key);
 154         }
 155
 156         return TRUE; /* TODO: error handling */
 157 }
 158
 159
 160 gboolean
 161 modest_account_mgr_remove_account (ModestAccountMgr *self, const gchar* name,
 162                            GError **err)
 163 {
 164         ModestAccountMgrPrivate *priv;
 165         gchar *key;
 166         gboolean retval;
 167
 168         g_return_val_if_fail (self, FALSE);
 169         g_return_val_if_fail (name, FALSE);
 170
 171         if (!modest_account_mgr_account_exists (self, name, err)) {
 172                 g_warning ("account doest not exist");
 173                 return FALSE;
 174         }
 175
 176         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 177         key = get_account_keyname (name, NULL);
 178
 179         retval = modest_conf_remove_key (priv->modest_conf, key, NULL);
 180
 181         g_free (key);
 182         return retval;
 183 }
 184
 185
 186 static const gchar*
 187 null_means_empty(const gchar* str)
 188 {
 189         return str ? str : "";
 190 }
 191
 192
 193 gboolean
 194 modest_account_mgr_add_server_account    (ModestAccountMgr *self,
 195                                           const gchar *name,
 196                                           const gchar *hostname,
 197                                           const gchar *username,
 198                                           const gchar *password,
 199                                           const gchar *proto)
 200 {
 201         ModestAccountMgrPrivate *priv;
 202         gchar *acckey, *key;
 203
 204         g_return_val_if_fail (self, FALSE);
 205         g_return_val_if_fail (name, FALSE);
 206
 207         /* TODO: check already exists */
 208
 209         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 210         acckey = g_strconcat (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
 211                               name, NULL);
 212
 213         if (modest_conf_key_exists(priv->modest_conf, acckey, NULL)) {
 214                 g_warning ("server account %s already exists", name);
 215                 g_free (acckey);
 216                 return FALSE;
 217         }
 218
 219         /* hostname */
 220         key = g_strconcat (acckey, "/", MODEST_ACCOUNT_HOSTNAME, NULL);
 221         modest_conf_set_string (priv->modest_conf, key,
 222                                 null_means_empty(hostname), NULL);
 223         g_free (key);
 224
 225         /* username */
 226         key = g_strconcat (acckey, "/", MODEST_ACCOUNT_USERNAME, NULL);
 227         modest_conf_set_string (priv->modest_conf, key,
 228                                 null_means_empty(username), NULL);
 229         g_free (key);
 230
 231         /* password */
 232         key = g_strconcat (acckey, "/", MODEST_ACCOUNT_PASSWORD, NULL);
 233         modest_conf_set_string (priv->modest_conf, key,
 234                                 null_means_empty(password), NULL);
 235         g_free (key);
 236
 237         /* proto */
 238         key = g_strconcat (acckey, "/", MODEST_ACCOUNT_PROTO, NULL);
 239         modest_conf_set_string (priv->modest_conf, key,
 240                                 null_means_empty(proto),
 241                                 NULL);
 242         g_free (key);
 243
 244         return TRUE; /* FIXME: better error checking */
 245 }
 246
 247 gboolean
 248 modest_account_mgr_remove_server_account    (ModestAccountMgr *self,
 249                                              const gchar *name,
 250                                              GError **err)
 251 {
 252         ModestAccountMgrPrivate *priv;
 253         gchar *acckey, *key;
 254         gboolean retval;
 255
 256         g_return_val_if_fail (self, FALSE);
 257         g_return_val_if_fail (name, FALSE);
 258
 259         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 260
 261         acckey = g_strconcat (MODEST_SERVER_ACCOUNT_NAMESPACE, "/",
 262                               name, NULL);
 263
 264         if (!modest_conf_key_exists(priv->modest_conf, acckey, NULL)) {
 265                 g_warning ("server account %s does not exist exist", name);
 266                 g_free (acckey);
 267                 return FALSE;
 268         }
 269
 270         retval = modest_conf_remove_key (priv->modest_conf, acckey, NULL);
 271         g_free (acckey);
 272
 273         return retval;
 274 }
 275
 276
 277
 278
 279 GSList*
 280 modest_account_mgr_server_account_names   (ModestAccountMgr *self,
 281                                            const gchar*    account_name,
 282                                            ModestProtoType type,
 283                                            const gchar*    proto,
 284                                            gboolean only_enabled)
 285 {
 286         GSList *accounts;
 287         GSList *cursor;
 288         ModestAccountMgrPrivate *priv;
 289
 290         g_return_val_if_fail (self, NULL);
 291
 292         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 293         accounts = modest_conf_list_subkeys (priv->modest_conf,
 294                                              MODEST_SERVER_ACCOUNT_NAMESPACE,
 295                                              NULL);
 296
 297         /* no restrictions, return everything */
 298         if (type == MODEST_PROTO_TYPE_ANY && !proto)
 299                 return accounts;
 300
 301         /* otherwise, filter out the none-matching ones */
 302         cursor = accounts;
 303         while (cursor) {
 304                 gchar *keyspace, *proto_key, *acc_proto;
 305
 306                 keyspace  = (gchar*) cursor->data;
 307                 proto_key = g_strconcat (keyspace, "/", MODEST_ACCOUNT_PROTO, NULL);
 308                 acc_proto = modest_conf_get_string (priv->modest_conf, proto_key,
 309                                                     NULL);
 310                 g_free (proto_key);
 311
 312                 if ((!acc_proto) ||                              /* proto not defined? */
 313                     (type != MODEST_PROTO_TYPE_ANY &&            /* proto type ...     */
 314                      modest_proto_type (acc_proto) != type) ||   /* ... matches?       */
 315                     (proto && strcmp(proto,acc_proto) != 0)) {   /* proto matches?     */
 316                         /* no match: remove from the list */
 317                         GSList *nxt = cursor->next;
 318                         g_free (acc_proto);
 319                         accounts = g_slist_delete_link (accounts, cursor);
 320                         cursor = nxt;
 321                 } else
 322                         cursor = cursor->next;
 323         }
 324
 325         return accounts;
 326 }
 327
 328
 329
 330 GSList*
 331 modest_account_mgr_account_names  (ModestAccountMgr *self, GError **err)
 332 {
 333         GSList *accounts, *cursor;
 334         ModestAccountMgrPrivate *priv;
 335
 336         g_return_val_if_fail (self, NULL);
 337
 338         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 339
 340         return  modest_conf_list_subkeys (priv->modest_conf,
 341                                           MODEST_ACCOUNT_NAMESPACE,
 342                                           err);
 343 }
 344
 345
 346 gchar*
 347 modest_account_mgr_get_account_string (ModestAccountMgr *self, const gchar *name,
 348                                        const gchar *key, GError **err)
 349 {
 350         ModestAccountMgrPrivate *priv;
 351
 352         gchar *keyname;
 353         gchar *retval;
 354
 355         g_return_val_if_fail (self, NULL);
 356         g_return_val_if_fail (name, NULL);
 357         g_return_val_if_fail (key, NULL);
 358
 359         keyname = get_account_keyname (name, key);
 360
 361         g_warning ("===> %s", keyname);
 362
 363         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 364
 365         retval = modest_conf_get_string (priv->modest_conf,
 366                                          keyname, err);
 367
 368         g_free (keyname);
 369         return retval;
 370 }
 371
 372
 373
 374 gint
 375 modest_account_mgr_get_account_int (ModestAccountMgr *self, const gchar *name,
 376                                     const gchar *key, GError **err)
 377 {
 378         ModestAccountMgrPrivate *priv;
 379
 380         gchar *keyname;
 381         gint retval;
 382
 383         g_return_val_if_fail (self, -1);
 384         g_return_val_if_fail (name, -1);
 385         g_return_val_if_fail (key, -1);
 386
 387         keyname = get_account_keyname (name, key);
 388         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 389         retval = modest_conf_get_int (priv->modest_conf,keyname,err);
 390
 391         g_free (keyname);
 392         return retval;
 393 }
 394
 395
 396 gboolean modest_account_mgr_get_account_bool (ModestAccountMgr *self, const gchar *name,
 397                                               const gchar *key, GError **err)
 398 {
 399         ModestAccountMgrPrivate *priv;
 400
 401         gchar *keyname;
 402         gboolean retval;
 403
 404         g_return_val_if_fail (self, FALSE);
 405         g_return_val_if_fail (name, FALSE);
 406         g_return_val_if_fail (key, FALSE);
 407
 408         keyname = get_account_keyname (name, key);
 409         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 410         retval = modest_conf_get_bool (priv->modest_conf,keyname,err);
 411
 412         g_free (keyname);
 413         return retval;
 414 }
 415
 416
 417
 418 gboolean
 419 modest_account_mgr_set_account_string  (ModestAccountMgr *self, const gchar *name,
 420                                         const gchar *key, const gchar* val,
 421                                         GError **err)
 422 {
 423         ModestAccountMgrPrivate *priv;
 424
 425         gchar *keyname;
 426         gboolean retval;
 427
 428         g_return_val_if_fail (self, FALSE);
 429         g_return_val_if_fail (name, FALSE);
 430         g_return_val_if_fail (key, FALSE);
 431
 432         keyname = get_account_keyname (name, key);
 433         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 434         retval = modest_conf_set_string (priv->modest_conf,keyname,val,err);
 435
 436         g_free (keyname);
 437         return retval;
 438 }
 439
 440
 441
 442 gboolean
 443 modest_account_mgr_set_account_int  (ModestAccountMgr *self, const gchar *name,
 444                                      const gchar *key, gint val, GError **err)
 445 {
 446         ModestAccountMgrPrivate *priv;
 447
 448         gchar *keyname;
 449         gboolean retval;
 450
 451         g_return_val_if_fail (self, -1);
 452         g_return_val_if_fail (name, -1);
 453         g_return_val_if_fail (key, -1);
 454
 455         keyname = get_account_keyname (name, key);
 456         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 457         retval = modest_conf_set_int (priv->modest_conf,keyname,val,err);
 458
 459         g_free (keyname);
 460         return retval;
 461 }
 462
 463
 464
 465
 466 gboolean
 467 modest_account_mgr_set_account_bool  (ModestAccountMgr *self, const gchar *name,
 468                                       const gchar *key, gboolean val, GError **err)
 469 {
 470         ModestAccountMgrPrivate *priv;
 471
 472         gchar *keyname;
 473         gboolean retval;
 474
 475         g_return_val_if_fail (self, FALSE);
 476         g_return_val_if_fail (name, FALSE);
 477         g_return_val_if_fail (key, FALSE);
 478
 479         keyname = get_account_keyname (name, key);
 480         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 481         retval = modest_conf_set_bool (priv->modest_conf,keyname,val,err);
 482
 483         g_free (keyname);
 484         return retval;
 485 }
 486
 487
 488 gboolean
 489 modest_account_mgr_account_exists (ModestAccountMgr *self, const gchar *name,
 490                                    GError **err)
 491 {
 492         ModestAccountMgrPrivate *priv;
 493
 494         gchar *keyname;
 495         gboolean retval;
 496
 497         g_return_val_if_fail (self, FALSE);
 498         g_return_val_if_fail (name, FALSE);
 499
 500         keyname = get_account_keyname (name, NULL);
 501
 502         priv = MODEST_ACCOUNT_MGR_GET_PRIVATE(self);
 503         retval = modest_conf_key_exists (priv->modest_conf,keyname,err);
 504
 505         g_free (keyname);
 506         return retval;
 507 }
 508
 509
 510
 511 /* must be freed by caller */
 512 static gchar*
 513 get_account_keyname (const gchar *accname, const gchar *name)
 514 {
 515         if (name)
 516                 return g_strconcat
 517                         (accname, "/", name, NULL);
 518         else
 519                 return g_strconcat
 520                         (accname, NULL);
 521 }
 522