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 * email,
 160                                   const gchar * replyto,
 161                                   const gchar * signature,
 162                                   const gboolean use_signature,
 163                                   const gchar * id_via,
 164                                   const gboolean use_id_via)
 165 {
 166         ModestIdentityMgrPrivate *priv;
 167         gchar *id_key, *key;
 168
 169         g_return_val_if_fail (self, FALSE);
 170         g_return_val_if_fail (name, FALSE);
 171
 172         /* TODO: check already exists */
 173
 174         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 175         id_key = g_strconcat (MODEST_IDENTITY_NAMESPACE, "/", name, NULL);
 176
 177         if (modest_conf_key_exists (priv->modest_conf, id_key, NULL)) {
 178                 g_warning ("identity %s already exists", name);
 179                 //g_free (id_key);
 180                 //return FALSE;
 181         }
 182
 183         /* email */
 184         key = g_strconcat (id_key, "/", MODEST_IDENTITY_EMAIL, NULL);
 185         modest_conf_set_string (priv->modest_conf, key,
 186                                 null_means_empty (email), NULL);
 187         g_free (key);
 188
 189         /* replyto */
 190         key = g_strconcat (id_key, "/", MODEST_IDENTITY_REPLYTO, NULL);
 191         modest_conf_set_string (priv->modest_conf, key,
 192                                 null_means_empty (replyto), NULL);
 193         g_free (key);
 194
 195         /* signature */
 196         key = g_strconcat (id_key, "/", MODEST_IDENTITY_SIGNATURE, NULL);
 197         modest_conf_set_string (priv->modest_conf, key,
 198                                 null_means_empty (signature), NULL);
 199         g_free (key);
 200
 201         /* use_signature */
 202         key = g_strconcat (id_key, "/", MODEST_IDENTITY_USE_SIGNATURE, NULL);
 203         modest_conf_set_bool (priv->modest_conf, key, use_signature, NULL);
 204         g_free (key);
 205
 206         /* signature */
 207         key = g_strconcat (id_key, "/", MODEST_IDENTITY_ID_VIA, NULL);
 208         modest_conf_set_string (priv->modest_conf, key,
 209                                 null_means_empty (id_via), NULL);
 210         g_free (key);
 211
 212         /* use_signature */
 213         key = g_strconcat (id_key, "/", MODEST_IDENTITY_USE_ID_VIA, NULL);
 214         modest_conf_set_bool (priv->modest_conf, key, use_id_via, NULL);
 215         g_free (key);
 216         g_free (id_key);
 217
 218         return TRUE;            /* FIXME: better error checking */
 219 }
 220
 221 /* strip the first /n/ character from each element */
 222 /* caller must make sure all elements are strings with
 223  * length >= n, and also that data can be freed.
 224  */
 225 /* this function is copied from modest-account-mgr. Maybe it should be moved
 226  * to modest-list-utils or the like...
 227  */
 228 static GSList *
 229 strip_prefix_from_elements (GSList * lst, guint n)
 230 {
 231         GSList *cursor = lst;
 232
 233         while (cursor) {
 234                 gchar *str = (gchar *) cursor->data;
 235
 236                 cursor->data = g_strdup (str + n);
 237                 g_free (str);
 238                 cursor = cursor->next;
 239         }
 240         return lst;
 241 }
 242
 243 GSList *
 244 modest_identity_mgr_identity_names (ModestIdentityMgr * self, GError ** err)
 245 {
 246         GSList *identities;
 247         ModestIdentityMgrPrivate *priv;
 248         const size_t prefix_len = strlen (MODEST_IDENTITY_NAMESPACE "/");
 249
 250
 251         g_return_val_if_fail (self, NULL);
 252
 253         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 254
 255         identities = modest_conf_list_subkeys (priv->modest_conf,
 256                                                MODEST_IDENTITY_NAMESPACE,
 257                                                err);
 258         return strip_prefix_from_elements (identities, prefix_len);
 259 }
 260
 261
 262 gchar *
 263 modest_identity_mgr_get_identity_string (ModestIdentityMgr * self,
 264                                          const gchar * name,
 265                                          const gchar * key, GError ** err)
 266 {
 267         ModestIdentityMgrPrivate *priv;
 268
 269         gchar *keyname;
 270         gchar *retval;
 271
 272         g_return_val_if_fail (self, NULL);
 273         g_return_val_if_fail (name, NULL);
 274         g_return_val_if_fail (key, NULL);
 275
 276         keyname = get_identity_keyname (name, key);
 277
 278         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 279         retval = modest_conf_get_string (priv->modest_conf, keyname, err);
 280         g_free (keyname);
 281
 282         return retval;
 283 }
 284
 285
 286 gint
 287 modest_identity_mgr_get_identity_int (ModestIdentityMgr * self,
 288                                       const gchar * name, const gchar * key,
 289                                       GError ** err)
 290 {
 291         ModestIdentityMgrPrivate *priv;
 292
 293         gchar *keyname;
 294         gint retval;
 295
 296         g_return_val_if_fail (self, -1);
 297         g_return_val_if_fail (name, -1);
 298         g_return_val_if_fail (key, -1);
 299
 300         keyname = get_identity_keyname (name, key);
 301         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 302         retval = modest_conf_get_int (priv->modest_conf, keyname, err);
 303         g_free (keyname);
 304
 305         return retval;
 306 }
 307
 308
 309
 310 gboolean
 311 modest_identity_mgr_get_identity_bool (ModestIdentityMgr * self,
 312                                        const gchar * name, const gchar * key,
 313                                        GError ** err)
 314 {
 315         ModestIdentityMgrPrivate *priv;
 316
 317         gchar *keyname;
 318         gboolean retval;
 319
 320         g_return_val_if_fail (self, -1);
 321         g_return_val_if_fail (name, -1);
 322         g_return_val_if_fail (key, -1);
 323
 324         keyname = get_identity_keyname (name, key);
 325
 326         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 327         retval = modest_conf_get_int (priv->modest_conf, keyname, err);
 328         g_free (keyname);
 329
 330         return retval;
 331 }
 332
 333
 334 gboolean
 335 modest_identity_mgr_set_identity_string (ModestIdentityMgr * self,
 336                                          const gchar * name,
 337                                          const gchar * key, const gchar * val,
 338                                          GError ** err)
 339 {
 340         ModestIdentityMgrPrivate *priv;
 341
 342         gchar *keyname;
 343         gboolean retval;
 344
 345         g_return_val_if_fail (self, FALSE);
 346         g_return_val_if_fail (name, FALSE);
 347         g_return_val_if_fail (key, FALSE);
 348
 349         keyname = get_identity_keyname (name, key);
 350
 351         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 352
 353         retval = modest_conf_set_string (priv->modest_conf, keyname, val,
 354                                          err);
 355
 356         g_free (keyname);
 357         return retval;
 358 }
 359
 360
 361 gboolean
 362 modest_identity_mgr_set_identity_int (ModestIdentityMgr * self,
 363                                       const gchar * name, const gchar * key,
 364                                       const gint val, GError ** err)
 365 {
 366         ModestIdentityMgrPrivate *priv;
 367
 368         gchar *keyname;
 369         gboolean retval;
 370
 371         g_return_val_if_fail (self, FALSE);
 372         g_return_val_if_fail (name, FALSE);
 373         g_return_val_if_fail (key, FALSE);
 374
 375         keyname = get_identity_keyname (name, key);
 376
 377         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 378
 379         retval = modest_conf_set_int (priv->modest_conf, keyname, val, err);
 380
 381         g_free (keyname);
 382         return retval;
 383 }
 384
 385
 386 gboolean
 387 modest_identy_mgr_set_identity_bool (ModestIdentityMgr * self,
 388                                      const gchar * name, const gchar * key,
 389                                      gboolean val, GError ** err)
 390 {
 391         ModestIdentityMgrPrivate *priv;
 392
 393         gchar *keyname;
 394         gboolean retval;
 395
 396         g_return_val_if_fail (self, FALSE);
 397         g_return_val_if_fail (name, FALSE);
 398         g_return_val_if_fail (key, FALSE);
 399
 400         keyname = get_identity_keyname (name, key);
 401
 402         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 403
 404         retval = modest_conf_set_bool (priv->modest_conf, keyname, val, err);
 405
 406         g_free (keyname);
 407         return retval;
 408 }
 409
 410
 411 gboolean
 412 modest_identity_mgr_identity_exists (ModestIdentityMgr * self,
 413                                      const gchar * name, GError ** err)
 414 {
 415         ModestIdentityMgrPrivate *priv;
 416
 417         gchar *keyname;
 418         gboolean retval;
 419
 420         g_return_val_if_fail (self, FALSE);
 421         g_return_val_if_fail (name, FALSE);
 422
 423         keyname = get_identity_keyname (name, NULL);
 424
 425         priv = MODEST_IDENTITY_MGR_GET_PRIVATE (self);
 426         retval = modest_conf_key_exists (priv->modest_conf, keyname, err);
 427
 428         g_free (keyname);
 429         return retval;
 430 }
 431
 432
 433 /* must be freed by caller */
 434 static gchar *
 435 get_identity_keyname (const gchar * idname, const gchar * name)
 436 {
 437         if (name)
 438                 return g_strconcat
 439                         (MODEST_IDENTITY_NAMESPACE, "/",
 440                          idname, "/", name, NULL);
 441         else
 442                 return g_strconcat
 443                         (MODEST_IDENTITY_NAMESPACE, "/", idname, NULL);
 444 }