2013-02-17 [colin] 3.9.0cvs75
[claws.git] / src / plugins / gdata / cm_gdata_contacts.c
1 /* GData plugin for Claws-Mail
2  * Copyright (C) 2011 Holger Berndt
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program. If not, see <http://www.gnu.org/licenses/>.
16  */
17
18
19 #ifdef HAVE_CONFIG_H
20 #  include "config.h"
21 #  include "claws-features.h"
22 #endif
23
24 #include <glib.h>
25 #include <glib/gi18n.h>
26
27 #include "cm_gdata_contacts.h"
28 #include "cm_gdata_prefs.h"
29
30 #include <gtk/gtk.h>
31 #include "addr_compl.h"
32 #include "main.h"
33 #include "prefs_common.h"
34 #include "common/log.h"
35 #include "common/xml.h"
36
37 #include <gdata/gdata.h>
38
39 #define GDATA_CONTACTS_FILENAME "gdata_cache.xml"
40
41 typedef struct
42 {
43   const gchar *family_name;
44   const gchar *given_name;
45   const gchar *full_name;
46   const gchar *address;
47 } Contact;
48
49 typedef struct
50 {
51   GSList *contacts;
52 } CmGDataContactsCache;
53
54
55 CmGDataContactsCache contacts_cache;
56 gboolean cm_gdata_contacts_query_running = FALSE;
57 gchar *contacts_group_id = NULL;
58
59 static void write_cache_to_file(void)
60 {
61   gchar *path;
62   PrefFile *pfile;
63   XMLTag *tag;
64   XMLNode *xmlnode;
65   GNode *rootnode;
66   GNode *contactsnode;
67   GSList *walk;
68
69   path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, GDATA_CONTACTS_FILENAME, NULL);
70   pfile = prefs_write_open(path);
71   g_free(path);
72   if(pfile == NULL) {
73     debug_print("GData plugin error: Cannot open file " GDATA_CONTACTS_FILENAME " for writing\n");
74     return;
75   }
76
77   /* XML declarations */
78   xml_file_put_xml_decl(pfile->fp);
79
80   /* Build up XML tree */
81
82   /* root node */
83   tag = xml_tag_new("gdata");
84   xmlnode = xml_node_new(tag, NULL);
85   rootnode = g_node_new(xmlnode);
86
87   /* contacts node */
88   tag = xml_tag_new("contacts");
89   xmlnode = xml_node_new(tag, NULL);
90   contactsnode = g_node_new(xmlnode);
91   g_node_append(rootnode, contactsnode);
92
93   /* walk contacts cache */
94   for(walk = contacts_cache.contacts; walk; walk = walk->next)
95   {
96     GNode *contactnode;
97     Contact *contact = walk->data;
98     tag = xml_tag_new("contact");
99     xml_tag_add_attr(tag, xml_attr_new("family_name",contact->family_name));
100     xml_tag_add_attr(tag, xml_attr_new("given_name",contact->given_name));
101     xml_tag_add_attr(tag, xml_attr_new("full_name",contact->full_name));
102     xml_tag_add_attr(tag, xml_attr_new("address",contact->address));
103     xmlnode = xml_node_new(tag, NULL);
104     contactnode = g_node_new(xmlnode);
105     g_node_append(contactsnode, contactnode);
106   }
107
108   /* Actual writing and cleanup */
109   xml_write_tree(rootnode, pfile->fp);
110   if(prefs_file_close(pfile) < 0)
111     debug_print("GData plugin error: Failed to write file " GDATA_CONTACTS_FILENAME "\n");
112
113   debug_print("GData plugin error: Wrote cache to file " GDATA_CONTACTS_FILENAME "\n");
114
115   /* Free XML tree */
116   xml_free_tree(rootnode);
117 }
118
119 static int add_gdata_contact_to_cache(GDataContactsContact *contact)
120 {
121   GList *walk;
122   int retval;
123
124   retval = 0;
125   for(walk = gdata_contacts_contact_get_email_addresses(contact); walk; walk = walk->next) {
126     const gchar *email_address;
127     GDataGDEmailAddress *address = GDATA_GD_EMAIL_ADDRESS(walk->data);
128
129     email_address = gdata_gd_email_address_get_address(address);
130     if(email_address && (*email_address != '\0')) {
131       GDataGDName *name;
132       Contact *cached_contact;
133
134       name = gdata_contacts_contact_get_name(contact);
135
136       cached_contact = g_new0(Contact, 1);
137       cached_contact->full_name = g_strdup(gdata_gd_name_get_full_name(name));
138       cached_contact->given_name = g_strdup(gdata_gd_name_get_given_name(name));
139       cached_contact->family_name = g_strdup(gdata_gd_name_get_family_name(name));
140       cached_contact->address = g_strdup(email_address);
141
142       contacts_cache.contacts = g_slist_prepend(contacts_cache.contacts, cached_contact);
143
144       debug_print("GData plugin: Added %s <%s>\n", cached_contact->full_name, cached_contact->address);
145       retval = 1;
146     }
147   }
148   if(retval == 0)
149   {
150     debug_print("GData plugin: Skipped received contact \"%s\" because it doesn't have an email address\n",
151         gdata_gd_name_get_full_name(gdata_contacts_contact_get_name(contact)));
152   }
153   return retval;
154 }
155
156 static void free_contact(Contact *contact)
157 {
158   g_free((gpointer)contact->full_name);
159   g_free((gpointer)contact->family_name);
160   g_free((gpointer)contact->given_name);
161   g_free((gpointer)contact->address);
162   g_free(contact);
163 }
164
165 static void clear_contacts_cache(void)
166 {
167   GSList *walk;
168   for(walk = contacts_cache.contacts; walk; walk = walk->next)
169     free_contact(walk->data);
170   g_slist_free(contacts_cache.contacts);
171   contacts_cache.contacts = NULL;
172 }
173
174 static void cm_gdata_query_contacts_ready(GDataContactsService *service, GAsyncResult *res, gpointer data)
175 {
176   GDataFeed *feed;
177   GList *walk;
178   GError *error = NULL;
179   guint num_contacts = 0;
180   guint num_contacts_added = 0;
181         gchar *tmpstr1, *tmpstr2;
182
183   feed = gdata_service_query_finish(GDATA_SERVICE(service), res, &error);
184   cm_gdata_contacts_query_running = FALSE;
185   if(error)
186   {
187     g_object_unref(feed);
188     log_error(LOG_PROTOCOL, _("GData plugin: Error querying for contacts: %s\n"), error->message);
189     g_error_free(error);
190     return;
191   }
192
193   /* clear cache */
194   clear_contacts_cache();
195
196   /* Iterate through the returned contacts and fill the cache */
197   for(walk = gdata_feed_get_entries(feed); walk; walk = walk->next) {
198     num_contacts_added += add_gdata_contact_to_cache(GDATA_CONTACTS_CONTACT(walk->data));
199     num_contacts++;
200   }
201   g_object_unref(feed);
202   contacts_cache.contacts = g_slist_reverse(contacts_cache.contacts);
203         /* i18n: First part of "Added X of Y contacts to cache" */
204   tmpstr1 = g_strdup_printf(ngettext("Added %d of", "Added %d of", num_contacts_added), num_contacts_added);
205         /* i18n: Second part of "Added X of Y contacts to cache" */
206   tmpstr2 = g_strdup_printf(ngettext("1 contact to the cache", "%d contacts to the cache", num_contacts), num_contacts);
207   log_message(LOG_PROTOCOL, "%s %s\n", tmpstr1, tmpstr2);
208         g_free(tmpstr1);
209         g_free(tmpstr2);
210 }
211
212 static void query_after_auth(GDataContactsService *service)
213 {
214   GDataContactsQuery *query;
215
216   log_message(LOG_PROTOCOL, _("GData plugin: Starting async contacts query\n"));
217
218   query = gdata_contacts_query_new(NULL);
219   gdata_contacts_query_set_group(query, contacts_group_id);
220   gdata_query_set_max_results(GDATA_QUERY(query), cm_gdata_config.max_num_results);
221   gdata_contacts_service_query_contacts_async(service, GDATA_QUERY(query), NULL, NULL, NULL,
222 #ifdef HAVE_GDATA_VERSION_0_9_1
223   NULL,
224 #endif
225   (GAsyncReadyCallback)cm_gdata_query_contacts_ready, NULL);
226
227   g_object_unref(query);
228 }
229
230 #ifdef HAVE_GDATA_VERSION_0_9_1
231 static void cm_gdata_query_groups_ready(GDataContactsService *service, GAsyncResult *res, gpointer data)
232 {
233   GDataFeed *feed;
234   GList *walk;
235   GError *error = NULL;
236
237   feed = gdata_service_query_finish(GDATA_SERVICE(service), res, &error);
238   if(error)
239   {
240     g_object_unref(feed);
241     log_error(LOG_PROTOCOL, _("GData plugin: Error querying for groups: %s\n"), error->message);
242     g_error_free(error);
243     return;
244   }
245
246   /* Iterate through the returned groups and search for Contacts group id */
247   for(walk = gdata_feed_get_entries(feed); walk; walk = walk->next) {
248     const gchar *system_group_id;
249     GDataContactsGroup *group = GDATA_CONTACTS_GROUP(walk->data);
250
251     system_group_id = gdata_contacts_group_get_system_group_id(group);
252     if(system_group_id && !strcmp(system_group_id, GDATA_CONTACTS_GROUP_CONTACTS)) {
253       gchar *pos;
254       const gchar *id;
255
256       id = gdata_entry_get_id(GDATA_ENTRY(group));
257
258       /* possibly replace projection "full" by "base" */
259       pos = g_strrstr(id, "/full/");
260       if(pos) {
261         GString *str = g_string_new("\0");
262         int off = pos-id;
263
264         g_string_append_len(str, id, off);
265         g_string_append(str, "/base/");
266         g_string_append(str, id+off+strlen("/full/"));
267         g_string_append_c(str, '\0');
268         contacts_group_id = str->str;
269         g_string_free(str, FALSE);
270       }
271       else
272         contacts_group_id = g_strdup(id);
273       break;
274     }
275   }
276   g_object_unref(feed);
277
278   log_message(LOG_PROTOCOL, _("GData plugin: Groups received\n"));
279
280   query_after_auth(service);
281 }
282 #endif
283
284 #ifdef HAVE_GDATA_VERSION_0_9
285 static void query_for_contacts_group_id(GDataClientLoginAuthorizer *authorizer)
286 {
287   GDataContactsService *service;
288 #ifdef HAVE_GDATA_VERSION_0_9_1
289
290   log_message(LOG_PROTOCOL, _("GData plugin: Starting async groups query\n"));
291
292   service = gdata_contacts_service_new(GDATA_AUTHORIZER(authorizer));
293   gdata_contacts_service_query_groups_async(service, NULL, NULL, NULL, NULL, NULL,
294       (GAsyncReadyCallback)cm_gdata_query_groups_ready, NULL);
295 #else
296   service = gdata_contacts_service_new(GDATA_AUTHORIZER(authorizer));
297   query_after_auth(service);
298 #endif
299   g_object_unref(service);
300 }
301
302 static void cm_gdata_auth_ready(GDataClientLoginAuthorizer *authorizer, GAsyncResult *res, gpointer data)
303 {
304   GError *error = NULL;
305
306   if(gdata_client_login_authorizer_authenticate_finish(authorizer, res, &error) == FALSE)
307   {
308     log_error(LOG_PROTOCOL, _("GData plugin: Authentication error: %s\n"), error->message);
309     g_error_free(error);
310     cm_gdata_contacts_query_running = FALSE;
311     return;
312   }
313
314   log_message(LOG_PROTOCOL, _("GData plugin: Authenticated\n"));
315
316   if(!contacts_group_id)
317   {
318     query_for_contacts_group_id(authorizer);
319   }
320   else {
321     GDataContactsService *service;
322     service = gdata_contacts_service_new(GDATA_AUTHORIZER(authorizer));
323     query_after_auth(service);
324     g_object_unref(service);
325   }
326 }
327 #else
328 static void cm_gdata_auth_ready(GDataContactsService *service, GAsyncResult *res, gpointer data)
329 {
330   GError *error = NULL;
331
332   if(!gdata_service_authenticate_finish(GDATA_SERVICE(service), res, &error))
333   {
334     log_error(LOG_PROTOCOL, _("GData plugin: Authentication error: %s\n"), error->message);
335     g_error_free(error);
336     cm_gdata_contacts_query_running = FALSE;
337     return;
338   }
339
340   log_message(LOG_PROTOCOL, _("GData plugin: Authenticated\n"));
341
342   query_after_auth(service);
343 }
344 #endif
345 static void query()
346 {
347
348 #ifdef HAVE_GDATA_VERSION_0_9
349   GDataClientLoginAuthorizer *authorizer;
350 #else
351   GDataContactsService *service;
352 #endif
353
354   if(cm_gdata_contacts_query_running)
355   {
356     debug_print("GData plugin: Network query already in progress");
357     return;
358   }
359
360   log_message(LOG_PROTOCOL, _("GData plugin: Starting async authentication\n"));
361
362 #ifdef HAVE_GDATA_VERSION_0_9
363   authorizer = gdata_client_login_authorizer_new(CM_GDATA_CLIENT_ID, GDATA_TYPE_CONTACTS_SERVICE);
364   gdata_client_login_authorizer_authenticate_async(authorizer, cm_gdata_config.username, cm_gdata_config.password, NULL, (GAsyncReadyCallback)cm_gdata_auth_ready, NULL);
365   cm_gdata_contacts_query_running = TRUE;
366 #else
367   service = gdata_contacts_service_new(CM_GDATA_CLIENT_ID);
368   cm_gdata_contacts_query_running = TRUE;
369   gdata_service_authenticate_async(GDATA_SERVICE(service), cm_gdata_config.username, cm_gdata_config.password, NULL,
370       (GAsyncReadyCallback)cm_gdata_auth_ready, NULL);
371 #endif
372
373
374 #ifdef HAVE_GDATA_VERSION_0_9
375   g_object_unref(authorizer);
376 #else
377   g_object_unref(service);
378 #endif
379
380 }
381
382
383 static void add_contacts_to_list(GList **address_list, GSList *contacts)
384 {
385   GSList *walk;
386
387   for(walk = contacts; walk; walk = walk->next)
388   {
389     address_entry *ae;
390     Contact *contact = walk->data;
391
392     ae = g_new0(address_entry, 1);
393     ae->name = g_strdup(contact->full_name);
394     ae->address = g_strdup(contact->address);
395     ae->grp_emails = NULL;
396
397     *address_list = g_list_prepend(*address_list, ae);
398     addr_compl_add_address1(ae->address, ae);
399
400     if(contact->given_name && *(contact->given_name) != '\0')
401       addr_compl_add_address1(contact->given_name, ae);
402
403     if(contact->family_name && *(contact->family_name) != '\0')
404       addr_compl_add_address1(contact->family_name, ae);
405   }
406 }
407
408 void cm_gdata_add_contacts(GList **address_list)
409 {
410   add_contacts_to_list(address_list, contacts_cache.contacts);
411 }
412
413 gboolean cm_gdata_update_contacts_cache(void)
414 {
415   if(prefs_common.work_offline)
416   {
417     debug_print("GData plugin: Offline mode\n");
418   }
419   else if(!cm_gdata_config.username || *(cm_gdata_config.username) == '\0' || !cm_gdata_config.password)
420   {
421     /* noop if no credentials are given */
422     debug_print("GData plugin: Empty username or password\n");
423   }
424   else
425   {
426     debug_print("GData plugin: Querying contacts");
427     query();
428   }
429   return TRUE;
430 }
431
432 void cm_gdata_contacts_done(void)
433 {
434   g_free(contacts_group_id);
435   contacts_group_id = NULL;
436
437   write_cache_to_file();
438   if(contacts_cache.contacts && !claws_is_exiting())
439     clear_contacts_cache();
440 }
441
442 void cm_gdata_load_contacts_cache_from_file(void)
443 {
444   gchar *path;
445   GNode *rootnode, *childnode, *contactnode;
446   XMLNode *xmlnode;
447
448   path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, GDATA_CONTACTS_FILENAME, NULL);
449   if(!is_file_exist(path)) {
450     g_free(path);
451     return;
452   }
453
454   /* no merging; make sure the cache is empty (this should be a noop, but just to be safe...) */
455   clear_contacts_cache();
456
457   rootnode = xml_parse_file(path);
458   g_free(path);
459   if(!rootnode)
460     return;
461   xmlnode = rootnode->data;
462
463   /* Check that root entry is "gdata" */
464   if(strcmp2(xmlnode->tag->tag, "gdata") != 0) {
465     g_warning("wrong gdata cache file\n");
466     xml_free_tree(rootnode);
467     return;
468   }
469
470   for(childnode = rootnode->children; childnode; childnode = childnode->next) {
471     GList *attributes;
472     xmlnode = childnode->data;
473
474     if(strcmp2(xmlnode->tag->tag, "contacts") != 0)
475       continue;
476
477     for(contactnode = childnode->children; contactnode; contactnode = contactnode->next)
478     {
479       Contact *cached_contact;
480
481       xmlnode = contactnode->data;
482
483       cached_contact = g_new0(Contact, 1);
484       /* Attributes of the branch nodes */
485       for(attributes = xmlnode->tag->attr; attributes; attributes = attributes->next) {
486         XMLAttr *attr = attributes->data;
487
488         if(attr && attr->name && attr->value) {
489           if(!strcmp2(attr->name, "full_name"))
490             cached_contact->full_name = g_strdup(attr->value);
491           else if(!strcmp2(attr->name, "given_name"))
492             cached_contact->given_name = g_strdup(attr->value);
493           else if(!strcmp2(attr->name, "family_name"))
494             cached_contact->family_name = g_strdup(attr->value);
495           else if(!strcmp2(attr->name, "address"))
496             cached_contact->address = g_strdup(attr->value);
497         }
498       }
499       contacts_cache.contacts = g_slist_prepend(contacts_cache.contacts, cached_contact);
500       debug_print("Read contact from cache: %s\n", cached_contact->full_name);
501     }
502   }
503
504   /* Free XML tree */
505   xml_free_tree(rootnode);
506
507   contacts_cache.contacts = g_slist_reverse(contacts_cache.contacts);
508 }