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

   1 /* modest-identity-mgr.c */
   2
   3 /* insert (c)/licensing information) */
   4
   5 #include <string.h>
   6 #include "modest-identity-mgr.h"
   7
   8 /* 'private'/'protected' functions */
   9 static void modest_identity_mgr_class_init (ModestIdentityMgrClass * klass);
  10 static void modest_identity_mgr_init (ModestIdentityMgr * obj);
  11 static void modest_identity_mgr_finalize (GObject * obj);
  12
  13 static gchar *get_identity_keyname (const gchar * accname,
  14                                     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 _ModestIdentityMgrPrivate ModestIdentityMgrPrivate;
  24 struct _ModestIdentityMgrPrivate {
  25         ModestConf *modest_conf;
  26 };
  27
  28 #define MODEST_IDENTITY_MGR_GET_PRIVATE(o)      (G_TYPE_INSTANCE_GET_PRIVATE((o), \
  29                                                 MODEST_TYPE_IDENTITY_MGR, \
  30                                                 ModestIdentityMgrPrivate))
  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_identity_mgr_get_type (void)
  39 {
  40         static GType my_type = 0;
  41
  42         if (!my_type) {
  43                 static const GTypeInfo my_info = {
  44                         sizeof (ModestIdentityMgrClass),
  45                         NULL,   /* base init */
  46                         NULL,   /* base finalize */
  47                         (GClassInitFunc) modest_identity_mgr_class_init,
  48                         NULL,   /* class finalize */
  49                         NULL,   /* class data */
  50                         sizeof (ModestIdentityMgr),
  51                         1,      /* n_preallocs */
  52                         (GInstanceInitFunc) modest_identity_mgr_init,
  53                 };
  54
  55                 my_type = g_type_register_static (G_TYPE_OBJECT,
  56                                                   "ModestIdentityMgr",
  57                                                   &my_info, 0);
  58         }
  59         return my_type;
  60 }
  61
  62 static void
  63 modest_identity_mgr_class_init (ModestIdentityMgrClass * klass)
  64 {
  65         GObjectClass *gobject_class;
  66
  67         gobject_class = (GObjectClass *) klass;
  68
  69         parent_class = g_type_class_peek_parent (klass);
  70         gobject_class->finalize = modest_identity_mgr_finalize;
  71
  72         g_type_class_add_private (gobject_class,
  73                                   sizeof (ModestIdentityMgrPrivate));
  74
  75 /* signal definitions go here, e.g.: */
  76 /*      signals[MY_SIGNAL_1] = */
  77 /*              g_signal_new ("my_signal_1",....); */
  78 /*      signals[MY_SIGNAL_2] = */
  79 /*              g_signal_new ("my_signal_2",....); */
  80 /*      etc. */
  81 }
  82
  83
  84 static void
  85 modest_identity_mgr_init (ModestIdentityMgr * obj)
  86 {
  87         ModestIdentityMgrPrivate *priv =
  88                 MODEST_IDENTITY_MGR_GET_PRIVATE (obj);
  89         priv->modest_conf = NULL;
  90 }
  91
  92 static void
  93 modest_identity_mgr_finalize (GObject * obj)
  94 {
  95         ModestIdentityMgr *self = MODEST_IDENTITY_MGR (obj);
  96         ModestIdentityMgrPrivate *priv =
  97                 MODEST_IDENTITY_MGR_GET_PRIVATE (self);
  98
  99         g_object_unref (G_OBJECT (priv->modest_conf));
 100         priv->modest_conf = NULL;
 101 }
 102
 103 GObject *
 104 modest_identity_mgr_new (ModestConf * conf)
 105 {
 106         GObject *obj;
 107         ModestIdentityMgrPrivate *priv;
 108
 109         g_return_val_if_fail (conf, NULL);
 110
 111         obj = G_OBJECT (g_object_new (MODEST_TYPE_IDENTITY_MGR, NULL));
 112         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (obj);
 113
 114         /*
 115          * increase the ref count on the modest_conf. Normally, the
 116          * ModestConf should outlive the ModestIdentityMgr though
 117          */
 118         g_object_ref (G_OBJECT (priv->modest_conf = conf));
 119         return obj;
 120 }
 121
 122
 123 gboolean
 124 modest_identity_mgr_remove_identity (ModestIdentityMgr * self,
 125                                      const gchar * name, GError ** err)
 126 {
 127         ModestIdentityMgrPrivate *priv;
 128         gchar *key;
 129         gboolean retval;
 130
 131         g_return_val_if_fail (self, FALSE);
 132         g_return_val_if_fail (name, FALSE);
 133
 134         if (!modest_identity_mgr_identity_exists (self, name, err)) {
 135                 g_warning ("identity doest not exist");
 136                 return FALSE;
 137         }
 138
 139         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 140         key = get_identity_keyname (name, NULL);
 141
 142         retval = modest_conf_remove_key (priv->modest_conf, key, NULL);
 143
 144         g_free (key);
 145         return retval;
 146 }
 147
 148
 149 static const gchar *
 150 null_means_empty (const gchar * str)
 151 {
 152         return str ? str : "";
 153 }
 154
 155
 156 gboolean
 157 modest_identity_mgr_add_identity (ModestIdentityMgr * self,
 158                                   const gchar    * name,
 159                                   const gchar    * realname,
 160                                   const gchar    * email,
 161                                   const gchar    * replyto,
 162                                   const gchar    * signature,
 163                                   const gboolean use_signature,
 164                                   const gchar    * id_via,
 165                                   const gboolean use_id_via)
 166 {
 167         ModestIdentityMgrPrivate *priv;
 168         gchar *id_key, *key;
 169
 170         g_return_val_if_fail (self, FALSE);
 171         g_return_val_if_fail (name, FALSE);
 172
 173         /* TODO: check already exists */
 174
 175         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 176         id_key = g_strconcat (MODEST_IDENTITY_NAMESPACE, "/", name, NULL);
 177
 178         if (modest_conf_key_exists (priv->modest_conf, id_key, NULL)) {
 179                 g_warning ("identity %s already exists", name);
 180                 //g_free (id_key);
 181                 //return FALSE;
 182         }
 183
 184         /* realname */
 185         key = g_strconcat (id_key, "/", MODEST_IDENTITY_REALNAME, NULL);
 186         modest_conf_set_string (priv->modest_conf, key,
 187                                 null_means_empty (realname), NULL);
 188         g_free (key);
 189
 190         /* email */
 191         key = g_strconcat (id_key, "/", MODEST_IDENTITY_EMAIL, NULL);
 192         modest_conf_set_string (priv->modest_conf, key,
 193                                 null_means_empty (email), NULL);
 194         g_free (key);
 195
 196         /* replyto */
 197         key = g_strconcat (id_key, "/", MODEST_IDENTITY_REPLYTO, NULL);
 198         modest_conf_set_string (priv->modest_conf, key,
 199                                 null_means_empty (replyto), NULL);
 200         g_free (key);
 201
 202         /* signature */
 203         key = g_strconcat (id_key, "/", MODEST_IDENTITY_SIGNATURE, NULL);
 204         modest_conf_set_string (priv->modest_conf, key,
 205                                 null_means_empty (signature), NULL);
 206         g_free (key);
 207
 208         /* use_signature */
 209         key = g_strconcat (id_key, "/", MODEST_IDENTITY_USE_SIGNATURE, NULL);
 210         modest_conf_set_bool (priv->modest_conf, key, use_signature, NULL);
 211         g_free (key);
 212
 213         /* id_via */
 214         key = g_strconcat (id_key, "/", MODEST_IDENTITY_ID_VIA, NULL);
 215         modest_conf_set_string (priv->modest_conf, key,
 216                                 null_means_empty (id_via), NULL);
 217         g_free (key);
 218
 219         /* use_id_via */
 220         key = g_strconcat (id_key, "/", MODEST_IDENTITY_USE_ID_VIA, NULL);
 221         modest_conf_set_bool (priv->modest_conf, key, use_id_via, NULL);
 222         g_free (key);
 223
 224         g_free (id_key);
 225
 226         return TRUE;            /* FIXME: better error checking */
 227 }
 228
 229 /* strip the first /n/ character from each element */
 230 /* caller must make sure all elements are strings with
 231  * length >= n, and also that data can be freed.
 232  */
 233 /* this function is copied from modest-account-mgr. Maybe it should be moved
 234  * to modest-list-utils or the like...
 235  */
 236 static GSList *
 237 strip_prefix_from_elements (GSList * lst, guint n)
 238 {
 239         GSList *cursor = lst;
 240
 241         while (cursor) {
 242                 gchar *str = (gchar *) cursor->data;
 243
 244                 cursor->data = g_strdup (str + n);
 245                 g_free (str);
 246                 cursor = cursor->next;
 247         }
 248         return lst;
 249 }
 250
 251 GSList *
 252 modest_identity_mgr_identity_names (ModestIdentityMgr * self, GError ** err)
 253 {
 254         GSList *identities;
 255         ModestIdentityMgrPrivate *priv;
 256         const size_t prefix_len = strlen (MODEST_IDENTITY_NAMESPACE "/");
 257
 258
 259         g_return_val_if_fail (self, NULL);
 260
 261         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 262
 263         identities = modest_conf_list_subkeys (priv->modest_conf,
 264                                                MODEST_IDENTITY_NAMESPACE,
 265                                                err);
 266         return strip_prefix_from_elements (identities, prefix_len);
 267 }
 268
 269
 270 gchar *
 271 modest_identity_mgr_get_identity_string (ModestIdentityMgr * self,
 272                                          const gchar * name,
 273                                          const gchar * key, GError ** err)
 274 {
 275         ModestIdentityMgrPrivate *priv;
 276
 277         gchar *keyname;
 278         gchar *retval;
 279
 280         g_return_val_if_fail (self, NULL);
 281         g_return_val_if_fail (name, NULL);
 282         g_return_val_if_fail (key, NULL);
 283
 284         keyname = get_identity_keyname (name, key);
 285
 286         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 287         retval = modest_conf_get_string (priv->modest_conf, keyname, err);
 288         g_free (keyname);
 289
 290         return retval;
 291 }
 292
 293
 294 gint
 295 modest_identity_mgr_get_identity_int (ModestIdentityMgr * self,
 296                                       const gchar * name, const gchar * key,
 297                                       GError ** err)
 298 {
 299         ModestIdentityMgrPrivate *priv;
 300
 301         gchar *keyname;
 302         gint retval;
 303
 304         g_return_val_if_fail (self, -1);
 305         g_return_val_if_fail (name, -1);
 306         g_return_val_if_fail (key, -1);
 307
 308         keyname = get_identity_keyname (name, key);
 309         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 310         retval = modest_conf_get_int (priv->modest_conf, keyname, err);
 311         g_free (keyname);
 312
 313         return retval;
 314 }
 315
 316
 317
 318 gboolean
 319 modest_identity_mgr_get_identity_bool (ModestIdentityMgr * self,
 320                                        const gchar * name, const gchar * key,
 321                                        GError ** err)
 322 {
 323         ModestIdentityMgrPrivate *priv;
 324
 325         gchar *keyname;
 326         gboolean retval;
 327
 328         g_return_val_if_fail (self, FALSE);
 329         g_return_val_if_fail (name, FALSE);
 330         g_return_val_if_fail (key, FALSE);
 331
 332         keyname = get_identity_keyname (name, key);
 333
 334         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 335         retval = modest_conf_get_bool (priv->modest_conf, keyname, err);
 336         g_free (keyname);
 337
 338         return retval;
 339 }
 340
 341
 342 gboolean
 343 modest_identity_mgr_set_identity_string (ModestIdentityMgr * self,
 344                                          const gchar * name,
 345                                          const gchar * key, const gchar * val,
 346                                          GError ** err)
 347 {
 348         ModestIdentityMgrPrivate *priv;
 349
 350         gchar *keyname;
 351         gboolean retval;
 352
 353         g_return_val_if_fail (self, FALSE);
 354         g_return_val_if_fail (name, FALSE);
 355         g_return_val_if_fail (key, FALSE);
 356
 357         keyname = get_identity_keyname (name, key);
 358
 359         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 360
 361         retval = modest_conf_set_string (priv->modest_conf, keyname, val,
 362                                          err);
 363
 364         g_free (keyname);
 365         return retval;
 366 }
 367
 368
 369 gboolean
 370 modest_identity_mgr_set_identity_int (ModestIdentityMgr * self,
 371                                       const gchar * name, const gchar * key,
 372                                       const gint val, GError ** err)
 373 {
 374         ModestIdentityMgrPrivate *priv;
 375
 376         gchar *keyname;
 377         gboolean retval;
 378
 379         g_return_val_if_fail (self, FALSE);
 380         g_return_val_if_fail (name, FALSE);
 381         g_return_val_if_fail (key, FALSE);
 382
 383         keyname = get_identity_keyname (name, key);
 384
 385         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 386
 387         retval = modest_conf_set_int (priv->modest_conf, keyname, val, err);
 388
 389         g_free (keyname);
 390         return retval;
 391 }
 392
 393
 394 gboolean
 395 modest_identy_mgr_set_identity_bool (ModestIdentityMgr * self,
 396                                      const gchar * name, const gchar * key,
 397                                      gboolean val, GError ** err)
 398 {
 399         ModestIdentityMgrPrivate *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_identity_keyname (name, key);
 409
 410         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 411
 412         retval = modest_conf_set_bool (priv->modest_conf, keyname, val, err);
 413
 414         g_free (keyname);
 415         return retval;
 416 }
 417
 418
 419 gboolean
 420 modest_identity_mgr_identity_exists (ModestIdentityMgr * self,
 421                                      const gchar * name, GError ** err)
 422 {
 423         ModestIdentityMgrPrivate *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
 431         keyname = get_identity_keyname (name, NULL);
 432
 433         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 434         retval = modest_conf_key_exists (priv->modest_conf, keyname, err);
 435
 436         g_free (keyname);
 437         return retval;
 438 }
 439
 440
 441 /* must be freed by caller */
 442 static gchar *
 443 get_identity_keyname (const gchar * idname, const gchar * name)
 444 {
 445         if (name)
 446                 return g_strconcat
 447                         (MODEST_IDENTITY_NAMESPACE, "/",
 448                          idname, "/", name, NULL);
 449         else
 450                 return g_strconcat
 451                         (MODEST_IDENTITY_NAMESPACE, "/", idname, NULL);
 452 }