/*
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with the program; if not, see <http://www.gnu.org/licenses/>
*
*
* Authors:
* Ebby Wiselyn <ebbywiselyn@gmail.com>
* Philip Withnall <philip@tecnocode.co.uk>
*
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <string.h>
#include <glib/gi18n-lib.h>
#include <gtk/gtk.h>
#include <e-util/e-config.h>
#include <e-util/e-plugin.h>
#include <e-util/e-plugin-util.h>
#include <calendar/gui/e-cal-config.h>
#include <calendar/gui/e-cal-event.h>
#include <libedataserver/e-url.h>
#include <libedataserver/e-account-list.h>
#include <libedataserver/e-proxy.h>
#include <libecal/e-cal-client.h>
#include <libedataserverui/e-cell-renderer-color.h>
#include <libedataserverui/e-passwords.h>
#include <gdata/gdata.h>
#include "google-contacts-source.h"
#define CALENDAR_LOCATION "://www.google.com/calendar/feeds/"
#define CALENDAR_DEFAULT_PATH "/private/full"
#define URL_GET_SUBSCRIBED_CALENDARS "://www.google.com/calendar/feeds/default/allcalendars/full"
#define CALENDAR_CALDAV_URI "caldav://%s@www.google.com/calendar/dav/%s/events"
#define d(x)
/*****************************************************************************/
/* prototypes */
gint e_plugin_lib_enable (EPlugin *ep, gint enable);
GtkWidget *plugin_google (EPlugin *epl, EConfigHookItemFactoryData *data);
gpointer plugin_google_check (EPlugin *epl, EConfigHookPageCheckData *data);
void e_calendar_google_migrate (EPlugin *epl, ECalEventTargetBackend *data);
/*****************************************************************************/
/* plugin intialization */
static void
ensure_google_source_group (void)
{
ESourceList *slist;
GError *error = NULL;
e_cal_client_get_sources (
&slist, E_CAL_CLIENT_SOURCE_TYPE_EVENTS, &error);
if (error != NULL) {
g_warning (
"%s: Could not get calendar source list: %s",
G_STRFUNC, error->message);
g_error_free (error);
return;
}
e_source_list_ensure_group (slist, _("Google"), GOOGLE_BASE_URI, FALSE);
g_object_unref (slist);
}
gint
e_plugin_lib_enable (EPlugin *ep,
gint enable)
{
if (enable) {
d(printf ("\n Google Eplugin starting up ...\n"));
ensure_google_source_group ();
ensure_google_contacts_source_group ();
} else {
remove_google_contacts_source_group ();
}
return 0;
}
/********************************************************************************************************************/
static gchar *
decode_at_back (const gchar *user)
{
gchar *res, *at;
g_return_val_if_fail (user != NULL, NULL);
res = g_strdup (user);
while (at = strstr (res, "%40"), at != NULL) {
*at = '@';
memmove (at + 1, at + 3, strlen (at + 3) + 1);
}
return res;
}
static gboolean
is_email (const gchar *address)
{
/* This is supposed to check if the address's domain could be
* an FQDN but alas, it's not worth the pain and suffering. */
const gchar *at;
at = strchr (address, '@');
/* make sure we have an '@' and that it's not the first or last gchar */
if (!at || at == address || *(at + 1) == '\0')
return FALSE;
return TRUE;
}
static gchar *
sanitize_user_mail (const gchar *user)
{
if (!user)
return NULL;
if (strstr (user, "%40") != NULL) {
return g_strdup (user);
} else if (!is_email (user)) {
return g_strconcat (user, "%40gmail.com", NULL);
} else {
gchar *tmp = g_malloc0 (sizeof (gchar) * (1 + strlen (user) + 2));
gchar *at = strchr (user, '@');
strncpy (tmp, user, at - user);
strcat (tmp, "%40");
strcat (tmp, at + 1);
return tmp;
}
}
static gchar *
construct_default_uri (const gchar *username,
gboolean is_ssl)
{
gchar *user, *uri;
user = sanitize_user_mail (username);
uri = g_strconcat (is_ssl ? "https" : "http", CALENDAR_LOCATION, user, CALENDAR_DEFAULT_PATH, NULL);
g_free (user);
return uri;
}
/* checks whether the given_uri is pointing to the default user's calendar or not */
static gboolean
is_default_uri (const gchar *given_uri,
const gchar *username)
{
gchar *uri, *at;
gint ats, i;
gboolean res = FALSE;
if (!given_uri)
return TRUE;
for (i = 0; !res && i < 2; i++) {
/* try both versions here, with and without ssl */
uri = construct_default_uri (username, i == 0);
/* count number of '@' in given_uri to know how much memory will be required */
ats = 0;
for (at = strchr (given_uri, '@'); at; at = strchr (at + 1, '@')) {
ats++;
}
if (!ats)
res = g_ascii_strcasecmp (given_uri, uri) == 0;
else {
const gchar *last;
gchar *tmp = g_malloc0 (sizeof (gchar) * (1 + strlen (given_uri) + (2 * ats)));
last = given_uri;
for (at = strchr (last, '@'); at; at = strchr (at + 1, '@')) {
strncat (tmp, last, at - last);
strcat (tmp, "%40");
last = at + 1;
}
strcat (tmp, last);
res = g_ascii_strcasecmp (tmp, uri) == 0;
g_free (tmp);
}
g_free (uri);
}
return res;
}
static void
update_source_uris (ESource *source,
const gchar *uri)
{
gchar *abs_uri, *tmp, *user_sanitized, *slash;
const gchar *user, *feeds;
g_return_if_fail (source != NULL);
g_return_if_fail (uri != NULL);
/* this also changes an absolute uri */
e_source_set_relative_uri (source, uri);
user = e_source_get_property (source, "username");
if (!user)
return;
feeds = strstr (uri, "/feeds/");
g_return_if_fail (feeds != NULL);
feeds += 7;
user_sanitized = sanitize_user_mail (user);
/* no "%40" in the URL path for caldav, really */
tmp = decode_at_back (feeds);
slash = strchr (tmp, '/');
if (slash)
*slash = '\0';
abs_uri = g_strdup_printf (CALENDAR_CALDAV_URI, user_sanitized, tmp);
e_source_set_absolute_uri (source, abs_uri);
g_free (abs_uri);
g_free (tmp);
g_free (user_sanitized);
}
static void init_combo_values (GtkComboBox *combo, const gchar *deftitle, const gchar *defuri);
static void
update_user_in_source (ESource *source,
const gchar *new_user)
{
gchar *uri, *eml, *user;
const gchar *ssl;
/* to ensure it will not be freed before the work with it is done */
user = g_strdup (new_user);
/* two reasons why set readonly to FALSE:
* a) the e_source_set_relative_uri does nothing for readonly sources
* b) we are going to set default uri, which should be always writeable */
e_source_set_readonly (source, FALSE);
if (user && *user) {
/* store the non-encoded email in the "username" property */
if (strstr (user, "@") == NULL && strstr (user, "%40") == NULL)
eml = g_strconcat (user, "@gmail.com", NULL);
else
eml = decode_at_back (user);
} else {
eml = NULL;
}
/* set username first, as it's used in update_source_uris */
e_source_set_property (source, "username", eml);
ssl = e_source_get_property (source, "ssl");
uri = construct_default_uri (user, !ssl || g_str_equal (ssl, "1"));
update_source_uris (source, uri);
g_free (uri);
/* "setup-username" is used to this plugin only, to keep what user wrote,
* not what uses the backend */
e_source_set_property (source, "setup-username", user);
e_source_set_property (source, "auth", (user && *user) ? "1" : NULL);
e_source_set_property (source, "googlename", NULL);
/* delete obsolete properties */
e_source_set_property (source, "protocol", NULL);
e_source_set_property (source, "auth-domain", NULL);
g_free (eml);
g_free (user);
}
static void
user_changed (GtkEntry *editable,
ESource *source)
{
update_user_in_source (source, gtk_entry_get_text (GTK_ENTRY (editable)));
/* we changed user, thus reset the chosen calendar combo too, because
* other user means other calendars subscribed */
init_combo_values (GTK_COMBO_BOX (g_object_get_data (G_OBJECT (editable), "CalendarCombo")), _("Default"), NULL);
}
enum {
COL_COLOR = 0, /* GDK_TYPE_COLOR */
COL_TITLE, /* G_TYPE_STRING */
COL_URL_PATH, /* G_TYPE_STRING */
COL_READ_ONLY, /* G_TYPE_BOOLEAN */
NUM_COLUMNS
};
static void
init_combo_values (GtkComboBox *combo,
const gchar *deftitle,
const gchar *defuri)
{
GtkTreeIter iter;
GtkListStore *store;
if (!combo)
return;
store = GTK_LIST_STORE (gtk_combo_box_get_model (combo));
gtk_list_store_clear (store);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
COL_COLOR, NULL,
COL_TITLE, deftitle,
COL_URL_PATH, defuri,
COL_READ_ONLY, FALSE,
-1);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
}
static void
cal_combo_changed (GtkComboBox *combo,
ESource *source)
{
GtkListStore *store;
GtkTreeIter iter;
g_return_if_fail (combo != NULL);
g_return_if_fail (source != NULL);
store = GTK_LIST_STORE (gtk_combo_box_get_model (combo));
if (gtk_combo_box_get_active_iter (combo, &iter)) {
gchar *uri = NULL, *title = NULL;
gboolean readonly = FALSE;
gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, COL_TITLE, &title, COL_URL_PATH, &uri, COL_READ_ONLY, &readonly, -1);
if (!uri) {
const gchar *ssl = e_source_get_property (source, "ssl");
uri = construct_default_uri (e_source_get_property (source, "username"), !ssl || g_str_equal (ssl, "1"));
}
if (is_default_uri (uri, e_source_get_property (source, "username"))) {
/* do not store title when we use default uri */
g_free (title);
title = NULL;
}
/* first set readonly to FALSE, otherwise if TRUE, then e_source_set_readonly does nothing */
e_source_set_readonly (source, FALSE);
update_source_uris (source, uri);
e_source_set_readonly (source, readonly);
e_source_set_property (source, "googlename", title);
/* delete obsolete properties */
e_source_set_property (source, "protocol", NULL);
e_source_set_property (source, "auth-domain", NULL);
g_free (title);
g_free (uri);
}
}
static void
claim_error (GtkWindow *parent,
const gchar *error)
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new (parent,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"%s",
error);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
static void
update_proxy_settings (GDataService *service,
const gchar *uri)
{
EProxy *proxy;
SoupURI *proxy_uri = NULL;
proxy = e_proxy_new ();
e_proxy_setup_proxy (proxy);
/* use proxy if necessary */
if (e_proxy_require_proxy_for_uri (proxy, uri)) {
proxy_uri = e_proxy_peek_uri_for (proxy, uri);
}
gdata_service_set_proxy_uri (service, proxy_uri);
g_object_unref (proxy);
}
static void
retrieve_list_clicked (GtkButton *button,
GtkComboBox *combo)
{
ESource *source;
GDataClientLoginAuthorizer *authorizer;
GDataCalendarService *service;
GDataFeed *feed;
gchar *user, *password, *tmp;
const gchar *username;
GError *error = NULL;
GtkWindow *parent;
g_return_if_fail (button != NULL);
g_return_if_fail (combo != NULL);
parent = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (button)));
source = g_object_get_data (G_OBJECT (button), "ESource");
g_return_if_fail (source != NULL);
username = e_source_get_property (source, "username");
g_return_if_fail (username != NULL && *username != '\0');
user = decode_at_back (username);
tmp = g_strdup_printf (_("Enter password for user %s to access list of subscribed calendars."), user);
password = e_passwords_ask_password (_("Enter password"), NULL, "", tmp,
E_PASSWORDS_REMEMBER_NEVER | E_PASSWORDS_REPROMPT | E_PASSWORDS_SECRET | E_PASSWORDS_DISABLE_REMEMBER,
NULL, parent);
g_free (tmp);
if (!password) {
g_free (user);
return;
}
authorizer = gdata_client_login_authorizer_new ("evolution-client-0.1.0", GDATA_TYPE_CALENDAR_SERVICE);
service = gdata_calendar_service_new (GDATA_AUTHORIZER (authorizer));
if (!gdata_client_login_authorizer_authenticate (authorizer, user, password, NULL, &error)) {
/* Error! */
claim_error (parent, error->message);
g_error_free (error);
g_free (password);
g_free (user);
g_object_unref (service);
return;
}
/* privacy... maybe... */
memset (password, 0, strlen (password));
g_free (password);
update_proxy_settings (GDATA_SERVICE (service), URL_GET_SUBSCRIBED_CALENDARS);
feed = gdata_calendar_service_query_all_calendars (service, NULL, NULL, NULL, NULL, &error);
if (feed) {
GList *l;
gchar *old_selected = NULL;
gint idx, active = -1, default_idx = -1;
GtkListStore *store = GTK_LIST_STORE (gtk_combo_box_get_model (combo));
GtkTreeIter iter;
if (gtk_combo_box_get_active_iter (combo, &iter))
gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, COL_URL_PATH, &old_selected, -1);
gtk_list_store_clear (store);
for (l = gdata_feed_get_entries (feed), idx = 1; l != NULL; l = l->next) {
const gchar *uri, *title, *access;
GDataLink *link;
GDataColor color;
GDataEntry *entry = GDATA_ENTRY (l->data);
if (!entry || !GDATA_IS_ENTRY (entry))
continue;
/* skip hidden entries */
if (gdata_calendar_calendar_is_hidden (GDATA_CALENDAR_CALENDAR (entry)))
continue;
/* Find the alternate link; skip the entry if one doesn't exist */
link = gdata_entry_look_up_link (entry, GDATA_LINK_ALTERNATE);
if (!link)
continue;
uri = gdata_link_get_uri (link);
title = gdata_entry_get_title (entry);
gdata_calendar_calendar_get_color (GDATA_CALENDAR_CALENDAR (entry), &color);
access = gdata_calendar_calendar_get_access_level (GDATA_CALENDAR_CALENDAR (entry));
if (uri && title) {
GdkColor gdkcolor;
if (old_selected && g_str_equal (old_selected, uri))
active = idx;
/* Convert the GDataColor to a GdkColor */
gdkcolor.pixel = 0;
gdkcolor.red = color.red * 256;
gdkcolor.green = color.green * 256;
gdkcolor.blue = color.blue * 256;
if (default_idx == -1 && is_default_uri (uri, user)) {
/* have the default uri always NULL and first in the combo */
uri = NULL;
gtk_list_store_insert (store, &iter, 0);
default_idx = idx;
} else {
gtk_list_store_append (store, &iter);
}
gtk_list_store_set (store, &iter,
COL_COLOR, &gdkcolor,
COL_TITLE, title,
COL_URL_PATH, uri,
COL_READ_ONLY, access && !g_str_equal (access, "owner") && !g_str_equal (access, "contributor"),
-1);
idx++;
}
}
if (default_idx == -1) {
/* Hey, why we didn't find the default uri? Did something go so wrong or what? */
gtk_list_store_insert (store, &iter, 0);
gtk_list_store_set (store, &iter,
COL_COLOR, NULL,
COL_TITLE, _("Default"),
COL_URL_PATH, NULL,
COL_READ_ONLY, FALSE,
-1);
}
gtk_combo_box_set_active (combo, active == -1 ? 0 : active);
g_free (old_selected);
g_object_unref (feed);
} else {
tmp = g_strdup_printf (_("Cannot read data from Google server.\n%s"), (error && error->message) ? error->message : _("Unknown error."));
claim_error (parent, tmp);
g_free (tmp);
if (error) {
g_error_free (error);
error = NULL;
}
}
g_object_unref (service);
g_object_unref (authorizer);
g_free (user);
}
static void
retrieve_list_sensitize (GtkEntry *username_entry,
GtkWidget *button)
{
const gchar *text;
gboolean sensitive;
text = gtk_entry_get_text (username_entry);
sensitive = (text != NULL && *text != '\0');
gtk_widget_set_sensitive (button, sensitive);
}
gpointer
plugin_google_check (EPlugin *epl,
EConfigHookPageCheckData *data)
{
ECalConfigTargetSource *t;
g_return_val_if_fail (data != NULL, NULL);
g_return_val_if_fail (data->target != NULL, NULL);
t = (ECalConfigTargetSource *) data->target;
g_return_val_if_fail (t->source != NULL, NULL);
return check_username_filled (t->source);
}
GtkWidget *
plugin_google (EPlugin *epl,
EConfigHookItemFactoryData *data)
{
ECalConfigTargetSource *t = (ECalConfigTargetSource *) data->target;
ESource *source;
ESourceGroup *group;
EUri *euri;
GtkWidget *parent;
GtkWidget *widget;
GtkWidget *user;
GtkWidget *label;
GtkWidget *combo;
gchar *uri;
const gchar *username;
guint row;
GtkCellRenderer *renderer;
GtkListStore *store;
GtkWidget *hbox;
source = t->source;
group = e_source_peek_group (source);
widget = NULL;
if (g_ascii_strncasecmp (GOOGLE_BASE_URI, e_source_group_peek_base_uri (group), strlen (GOOGLE_BASE_URI)) != 0) {
return NULL;
}
uri = e_source_get_uri (source);
euri = e_uri_new (uri);
g_free (uri);
if (euri == NULL) {
return NULL;
}
e_uri_free (euri);
username = e_source_get_property (source, "setup-username");
if (!username)
username = e_source_get_property (source, "username");
/* google's CalDAV requires SSL, thus forcing it here, and no setup for it */
e_source_set_property (source, "ssl", "1");
/* Build up the UI */
parent = data->parent;
user = e_plugin_util_add_entry (parent, _("User_name:"), NULL, NULL);
gtk_entry_set_text (GTK_ENTRY (user), username ? username : "");
g_signal_connect (
user, "changed",
G_CALLBACK (user_changed), source);
e_plugin_util_add_refresh (parent, _("Re_fresh:"), source, "refresh");
g_object_get (parent, "n-rows", &row, NULL);
label = gtk_label_new_with_mnemonic (_("Cal_endar:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (parent), label, 0, 1, row, row + 1, GTK_FILL | GTK_EXPAND, 0, 0, 0);
store = gtk_list_store_new (
NUM_COLUMNS,
GDK_TYPE_COLOR, /* COL_COLOR */
G_TYPE_STRING, /* COL_TITLE */
G_TYPE_STRING, /* COL_URL_PATH */
G_TYPE_BOOLEAN); /* COL_READ_ONLY */
combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
renderer = e_cell_renderer_color_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer, "color", COL_COLOR, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer, "text", COL_TITLE, NULL);
init_combo_values (GTK_COMBO_BOX (combo),
e_source_get_property (source, "googlename") ? e_source_get_property (source, "googlename") : _("Default"),
e_source_get_property (source, "googlename") ? e_source_peek_relative_uri (source) : NULL);
g_signal_connect (combo, "changed", G_CALLBACK (cal_combo_changed), source);
g_object_set_data (G_OBJECT (user), "CalendarCombo", combo);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0);
label = gtk_button_new_with_mnemonic (_("Retrieve _List"));
g_signal_connect (label, "clicked", G_CALLBACK (retrieve_list_clicked), combo);
g_signal_connect (user, "changed", G_CALLBACK (retrieve_list_sensitize), label);
g_object_set_data (G_OBJECT (label), "ESource", source);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_set_sensitive (label, username && *username);
gtk_widget_show_all (hbox);
gtk_table_attach (GTK_TABLE (parent), hbox, 1, 2, row, row + 1, GTK_FILL | GTK_EXPAND, 0, 0, 0);
return widget;
}
void
e_calendar_google_migrate (EPlugin *epl,
ECalEventTargetBackend *data)
{
ESourceList *source_list;
ESourceGroup *google = NULL;
gboolean changed = FALSE;
source_list = data->source_list;
google = e_source_list_peek_group_by_base_uri (source_list, GOOGLE_BASE_URI);
if (google) {
GSList *s;
for (s = e_source_group_peek_sources (google); s; s = s->next) {
ESource *source = E_SOURCE (s->data);
if (!source)
continue;
/* new source through CalDAV uses absolute uri, thus it should be migrated if not set */
if (!e_source_peek_absolute_uri (source)) {
update_user_in_source (source, e_source_get_property (source, "username"));
changed = TRUE;
}
}
}
if (changed)
e_source_list_sync (source_list, NULL);
}
