/**
* em_utils_folder_is_drafts:
* @registry: an #ESourceRegistry
* @folder: a #CamelFolder
*
* Decides if @folder is a Drafts folder.
*
* Returns %TRUE if this is a Drafts folder or %FALSE otherwise.
**/
gboolean
em_utils_folder_is_drafts (ESourceRegistry *registry,
CamelFolder *folder)
{
CamelFolder *local_drafts_folder;
CamelSession *session;
CamelStore *store;
GList *list, *iter;
gchar *folder_uri;
gboolean is_drafts = FALSE;
const gchar *extension_name;
g_return_val_if_fail (CAMEL_IS_FOLDER (folder), FALSE);
store = camel_folder_get_parent_store (folder);
session = camel_service_ref_session (CAMEL_SERVICE (store));
local_drafts_folder =
e_mail_session_get_local_folder (
E_MAIL_SESSION (session), E_MAIL_LOCAL_FOLDER_DRAFTS);
if (folder == local_drafts_folder) {
is_drafts = TRUE;
goto exit;
}
folder_uri = e_mail_folder_uri_from_folder (folder);
store = camel_folder_get_parent_store (folder);
extension_name = E_SOURCE_EXTENSION_MAIL_COMPOSITION;
list = e_source_registry_list_sources (registry, extension_name);
for (iter = list; iter != NULL; iter = g_list_next (iter)) {
ESource *source = E_SOURCE (iter->data);
ESourceExtension *extension;
const gchar *drafts_folder_uri;
extension = e_source_get_extension (source, extension_name);
drafts_folder_uri =
e_source_mail_composition_get_drafts_folder (
E_SOURCE_MAIL_COMPOSITION (extension));
if (drafts_folder_uri != NULL)
is_drafts = e_mail_folder_uri_equal (
session, folder_uri, drafts_folder_uri);
if (is_drafts)
break;
}
g_list_free_full (list, (GDestroyNotify) g_object_unref);
g_free (folder_uri);
exit:
g_object_unref (session);
return is_drafts;
}
static GtkWidget *
csv_getwidget (EImport *ei,
EImportTarget *target,
EImportImporter *im)
{
EShell *shell;
GtkWidget *vbox, *selector, *scrolled_window;
ESourceRegistry *registry;
ESource *primary;
const gchar *extension_name;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
shell = e_shell_get_default ();
registry = e_shell_get_registry (shell);
extension_name = E_SOURCE_EXTENSION_ADDRESS_BOOK;
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
g_object_set (G_OBJECT (scrolled_window),
"hscrollbar-policy", GTK_POLICY_AUTOMATIC,
"vscrollbar-policy", GTK_POLICY_AUTOMATIC,
NULL);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_window, TRUE, TRUE, 6);
selector = e_source_selector_new (registry, extension_name);
e_source_selector_set_show_toggles (
E_SOURCE_SELECTOR (selector), FALSE);
gtk_container_add (GTK_CONTAINER (scrolled_window), selector);
primary = g_datalist_get_data (&target->data, "csv-source");
if (primary == NULL) {
GList *list;
list = e_source_registry_list_sources (registry, extension_name);
if (list != NULL) {
primary = g_object_ref (list->data);
g_datalist_set_data_full (
&target->data, "csv-source", primary,
(GDestroyNotify) g_object_unref);
}
g_list_free_full (list, (GDestroyNotify) g_object_unref);
}
e_source_selector_set_primary_selection (
E_SOURCE_SELECTOR (selector), primary);
g_signal_connect (
selector, "primary_selection_changed",
G_CALLBACK (primary_selection_changed_cb), target);
gtk_widget_show_all (vbox);
return vbox;
}
static void
calendar_sources_load_esource_list (ESourceRegistry *registry,
CalendarSourceData *source_data)
{
GList *list, *link;
const gchar *extension_name;
switch (source_data->source_type)
{
case E_CAL_SOURCE_TYPE_EVENT:
extension_name = E_SOURCE_EXTENSION_CALENDAR;
break;
case E_CAL_SOURCE_TYPE_TODO:
extension_name = E_SOURCE_EXTENSION_TASK_LIST;
break;
case E_CAL_SOURCE_TYPE_JOURNAL:
case E_CAL_SOURCE_TYPE_LAST:
default:
g_return_if_reached ();
}
list = e_source_registry_list_sources (registry, extension_name);
for (link = list; link != NULL; link = g_list_next (link))
{
ESource *source = E_SOURCE (link->data);
ESourceSelectable *extension;
gboolean show_source;
extension = e_source_get_extension (source, extension_name);
show_source = e_source_get_enabled (source) && e_source_selectable_get_selected (extension);
if (show_source)
create_client_for_source (source, source_data->source_type, source_data);
}
debug_dump_ecal_list (source_data->clients);
g_list_free_full (list, g_object_unref);
}
ESource *
em_utils_guess_mail_account_with_recipients_and_sort (ESourceRegistry *registry,
CamelMimeMessage *message,
CamelFolder *folder,
const gchar *message_uid,
EMailUtilsSourtSourcesFunc sort_func,
gpointer sort_func_data)
{
ESource *source = NULL;
GHashTable *recipients;
CamelInternetAddress *addr;
GList *list, *iter;
const gchar *extension_name;
const gchar *type;
const gchar *key;
/* This policy is subject to debate and tweaking,
* but please also document the rational here. */
g_return_val_if_fail (E_IS_SOURCE_REGISTRY (registry), NULL);
g_return_val_if_fail (CAMEL_IS_MIME_MESSAGE (message), NULL);
/* Build a set of email addresses in which to test for membership.
* Only the keys matter here; the values just need to be non-NULL. */
recipients = g_hash_table_new (g_str_hash, g_str_equal);
type = CAMEL_RECIPIENT_TYPE_TO;
addr = camel_mime_message_get_recipients (message, type);
if (addr != NULL) {
gint index = 0;
while (camel_internet_address_get (addr, index++, NULL, &key))
g_hash_table_add (recipients, (gpointer) key);
}
type = CAMEL_RECIPIENT_TYPE_CC;
addr = camel_mime_message_get_recipients (message, type);
if (addr != NULL) {
gint index = 0;
while (camel_internet_address_get (addr, index++, NULL, &key))
g_hash_table_add (recipients, (gpointer) key);
}
/* First Preference: We were given a folder that maps to an
* enabled mail account, and that account's address appears
* in the list of To: or Cc: recipients. */
if (folder != NULL)
source = guess_mail_account_from_folder (
registry, folder, message_uid);
if (source == NULL)
goto second_preference;
if (mail_account_in_recipients (registry, source, recipients))
goto exit;
second_preference:
/* Second Preference: Choose any enabled mail account whose
* address appears in the list to To: or Cc: recipients. */
if (source != NULL) {
g_object_unref (source);
source = NULL;
}
extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
list = e_source_registry_list_sources (registry, extension_name);
if (sort_func)
sort_func (&list, sort_func_data);
for (iter = list; iter != NULL; iter = g_list_next (iter)) {
ESource *temp = E_SOURCE (iter->data);
if (e_source_registry_check_enabled (registry, temp) &&
mail_account_in_recipients (registry, temp, recipients)) {
source = g_object_ref (temp);
break;
}
}
g_list_free_full (list, (GDestroyNotify) g_object_unref);
if (source != NULL)
goto exit;
/* Last Preference: Defer to em_utils_guess_mail_account(). */
source = em_utils_guess_mail_account (
registry, message, folder, message_uid);
exit:
g_hash_table_destroy (recipients);
return source;
}
static void
import_contacts (void)
{
EShell *shell;
ESourceRegistry *registry;
EClient *client = NULL;
GList *list;
gchar *name;
GString *line;
FILE *fp;
gsize offset;
const gchar *extension_name;
GError *error = NULL;
printf ("importing pine addressbook\n");
shell = e_shell_get_default ();
registry = e_shell_get_registry (shell);
extension_name = E_SOURCE_EXTENSION_ADDRESS_BOOK;
name = g_build_filename (g_get_home_dir (), ".addressbook", NULL);
fp = fopen (name, "r");
g_free (name);
if (fp == NULL)
return;
list = e_source_registry_list_sources (registry, extension_name);
if (list != NULL) {
ESource *source;
source = E_SOURCE (list->data);
client = e_book_client_connect_sync (source, 30, NULL, &error);
} else {
/* No address books exist. */
g_warning ("%s: No address books exist.", G_STRFUNC);
fclose (fp);
return;
}
g_list_free_full (list, (GDestroyNotify) g_object_unref);
if (error != NULL) {
g_warning (
"%s: Failed to open book client: %s",
G_STRFUNC, error ? error->message : "Unknown error");
g_clear_error (&error);
fclose (fp);
return;
}
line = g_string_new ("");
g_string_set_size (line, 256);
offset = 0;
while (fgets (line->str + offset, 256, fp)) {
gsize len;
len = strlen (line->str + offset) + offset;
if (line->str[len - 1] == '\n')
g_string_truncate (line, len - 1);
else if (!feof (fp)) {
offset = len;
g_string_set_size (line, len + 256);
continue;
} else {
g_string_truncate (line, len);
}
import_contact (E_BOOK_CLIENT (client), line->str);
offset = 0;
}
g_string_free (line, TRUE);
fclose (fp);
g_object_unref (client);
}
static void
mail_to_event (ECalClientSourceType source_type,
gboolean with_attendees,
EMailReader *reader)
{
EShell *shell;
EMailBackend *backend;
ESourceRegistry *registry;
GPtrArray *uids;
ESource *source = NULL;
ESource *default_source;
GList *list, *iter;
GtkWindow *parent;
const gchar *extension_name;
parent = e_mail_reader_get_window (reader);
uids = e_mail_reader_get_selected_uids (reader);
/* Ask before converting 10 or more mails to events. */
if (uids->len > 10) {
gchar *question;
gint response;
question = g_strdup_printf (
get_question_add_all_mails (source_type, uids->len), uids->len);
response = do_ask (question, FALSE);
g_free (question);
if (response == GTK_RESPONSE_NO) {
g_ptr_array_unref (uids);
return;
}
}
backend = e_mail_reader_get_backend (reader);
shell = e_shell_backend_get_shell (E_SHELL_BACKEND (backend));
registry = e_shell_get_registry (shell);
switch (source_type) {
case E_CAL_CLIENT_SOURCE_TYPE_EVENTS:
extension_name = E_SOURCE_EXTENSION_CALENDAR;
default_source = e_source_registry_ref_default_calendar (registry);
break;
case E_CAL_CLIENT_SOURCE_TYPE_MEMOS:
extension_name = E_SOURCE_EXTENSION_MEMO_LIST;
default_source = e_source_registry_ref_default_memo_list (registry);
break;
case E_CAL_CLIENT_SOURCE_TYPE_TASKS:
extension_name = E_SOURCE_EXTENSION_TASK_LIST;
default_source = e_source_registry_ref_default_task_list (registry);
break;
default:
g_return_if_reached ();
}
list = e_source_registry_list_sources (registry, extension_name);
/* If there is only one writable source, no need to prompt the user. */
for (iter = list; iter != NULL; iter = g_list_next (iter)) {
ESource *candidate = E_SOURCE (iter->data);
if (e_source_get_writable (candidate)) {
if (source == NULL)
source = candidate;
else {
source = NULL;
break;
}
}
}
g_list_free_full (list, (GDestroyNotify) g_object_unref);
if (source == NULL) {
GtkWidget *dialog;
ESourceSelector *selector;
/* ask the user which tasks list to save to */
dialog = e_source_selector_dialog_new (
parent, registry, extension_name);
selector = e_source_selector_dialog_get_selector (
E_SOURCE_SELECTOR_DIALOG (dialog));
e_source_selector_set_primary_selection (
selector, default_source);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
source = e_source_selector_dialog_peek_primary_selection (
E_SOURCE_SELECTOR_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
if (source) {
/* if a source has been selected, perform the mail2event operation */
AsyncData *data = NULL;
GThread *thread = NULL;
GError *error = NULL;
/* Fill the elements in AsynData */
data = g_new0 (AsyncData, 1);
data->client_cache = g_object_ref (e_shell_get_client_cache (shell));
data->source = g_object_ref (source);
data->extension_name = extension_name;
data->source_type = source_type;
data->folder = e_mail_reader_ref_folder (reader);
data->uids = g_ptr_array_ref (uids);
data->with_attendees = with_attendees;
if (uids->len == 1)
data->selected_text = get_selected_text (reader);
else
data->selected_text = NULL;
thread = g_thread_try_new (
NULL, (GThreadFunc) do_mail_to_event, data, &error);
if (error != NULL) {
g_warning (G_STRLOC ": %s", error->message);
g_error_free (error);
} else {
g_thread_unref (thread);
}
}
g_object_unref (default_source);
g_ptr_array_unref (uids);
}
static void add_gnome_addressbook(GList **address_list)
{
ESourceRegistry * registry = NULL;
GError *error = NULL;
GList *a;
registry = e_source_registry_new_sync (NULL, &error);
if (!registry || error) {
debug_print("Error: Failed to get access to source registry: %s\n", error->message);
g_error_free(error);
return;
}
// create book accessor if necessary
if(!eds_books) {
GList *list_sources = e_source_registry_list_sources (registry, E_SOURCE_EXTENSION_ADDRESS_BOOK);
for (a = list_sources; a; a = a->next) {
ESource *source = E_SOURCE (a->data);
if (e_source_get_enabled(source)) {
EBook *eds_book = e_book_new(source, &error);
if(!eds_book) {
g_list_free_full(list_sources, g_object_unref);
debug_print("Error: Could not get eds addressbook: %s\n", error->message);
g_error_free(error);
return;
}
eds_books = g_list_append (eds_books, eds_book);
}
}
g_list_free_full(list_sources, g_object_unref);
}
for (a = eds_books; a; a = a->next) {
EBook *eds_book = a->data;
EBookQuery *query;
EBookView *view;
// open book if necessary
if(!e_book_is_opened(eds_book) && !e_book_open(eds_book, TRUE, &error)) {
debug_print("Error: Could not open eds addressbook: %s\n", error->message);
g_error_free(error);
return;
}
// query book
query = e_book_query_field_exists(E_CONTACT_EMAIL);
if(!e_book_get_book_view(eds_book, query, NULL, 0, &view, &error)) {
debug_print("Error: Could not get eds addressbook view: %s\n", error->message);
g_error_free(error);
}
e_book_query_unref(query);
g_signal_connect(G_OBJECT(view), "contacts-added", G_CALLBACK(eds_contacts_added_cb), address_list);
g_signal_connect(G_OBJECT(view), "sequence-complete", G_CALLBACK(eds_sequence_complete_cb), NULL);
eds_waiting = TRUE;
e_book_view_start(view);
while(eds_waiting)
gtk_main_iteration();
e_book_view_stop(view);
g_object_unref(view);
}
}
static gboolean
ews_transport_can_server_side_sent_folder (CamelService *service,
EwsFolderId **folder_id,
GCancellable *cancellable)
{
CamelSession *session;
ESourceRegistry *registry;
ESource *sibling, *source = NULL;
gboolean is_server_side = FALSE;
g_return_val_if_fail (CAMEL_IS_EWS_TRANSPORT (service), FALSE);
g_return_val_if_fail (folder_id != NULL, FALSE);
session = camel_service_ref_session (service);
if (session && E_IS_MAIL_SESSION (session))
registry = g_object_ref (e_mail_session_get_registry (E_MAIL_SESSION (session)));
else
registry = e_source_registry_new_sync (cancellable, NULL);
if (!registry) {
g_clear_object (&session);
return FALSE;
}
sibling = e_source_registry_ref_source (registry, camel_service_get_uid (service));
if (sibling) {
GList *sources, *siter;
sources = e_source_registry_list_sources (registry, E_SOURCE_EXTENSION_MAIL_SUBMISSION);
for (siter = sources; siter; siter = siter->next) {
source = siter->data;
if (!source || g_strcmp0 (e_source_get_parent (source), e_source_get_parent (sibling)) != 0 ||
!e_source_has_extension (source, E_SOURCE_EXTENSION_MAIL_SUBMISSION) ||
!e_source_has_extension (source, E_SOURCE_EXTENSION_MAIL_COMPOSITION))
source = NULL;
else
break;
}
if (source &&
e_source_has_extension (source, E_SOURCE_EXTENSION_MAIL_SUBMISSION) &&
e_source_has_extension (source, E_SOURCE_EXTENSION_MAIL_COMPOSITION)) {
ESourceMailSubmission *subm_extension;
CamelStore *store = NULL;
gchar *folder_name = NULL;
subm_extension = e_source_get_extension (source, E_SOURCE_EXTENSION_MAIL_SUBMISSION);
/* Copy messages on the server side only if the replies
might not be saved to the original folder, which is handled
by the evolution itself. */
if (!e_source_mail_submission_get_replies_to_origin_folder (subm_extension) &&
e_source_mail_submission_get_sent_folder (subm_extension) &&
e_mail_folder_uri_parse (session,
e_source_mail_submission_get_sent_folder (subm_extension),
&store, &folder_name, NULL) & CAMEL_IS_EWS_STORE (store)) {
CamelEwsStore *ews_store = CAMEL_EWS_STORE (store);
gchar *folder_id_str;
folder_id_str = camel_ews_store_summary_get_folder_id_from_name (
ews_store->summary, folder_name);
if (folder_id_str) {
gchar *change_key;
change_key = camel_ews_store_summary_get_change_key (ews_store->summary, folder_name, NULL);
*folder_id = e_ews_folder_id_new (folder_id_str, change_key, FALSE);
g_free (change_key);
is_server_side = *folder_id != NULL;
}
g_free (folder_id_str);
}
g_clear_object (&store);
g_free (folder_name);
}
g_list_free_full (sources, g_object_unref);
g_object_unref (sibling);
}
g_object_unref (registry);
g_clear_object (&session);
return is_server_side;
}
gint
main (gint argc,
gchar *argv[])
{
CamelSession *session;
CamelService *service;
ESourceRegistry *registry;
GList *list, *link;
const gchar *extension_name;
g_type_init ();
system ("rm -rf /tmp/test-map");
camel_init ("/tmp/test-map", TRUE);
e_source_camel_register_types ();
session = g_object_new (
CAMEL_TYPE_SESSION,
"user-data-dir", "/tmp/test-map",
"user-cache-dir", "/tmp/test-map/cache", NULL);
/* Browse through the ESource registry to find out the MAP account */
registry = e_source_registry_new_sync (NULL, NULL);
extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
list = e_source_registry_list_sources (registry, extension_name);
for (link = list; link != NULL; link = g_list_next (link)) {
ESource *source = E_SOURCE (link->data);
const gchar *uid;
const gchar *backend_name = "INVALID";
const gchar *display_name;
ESourceBackend *extension;
if (!e_source_get_enabled (source))
continue;
uid = e_source_get_uid (source);
display_name = e_source_get_display_name (source);
printf("Looking for: %s\n", display_name);
extension = e_source_get_extension (source, extension_name);
backend_name = e_source_backend_get_backend_name (extension);
if (strcmp (backend_name, "map") == 0) {
/* Lets add just map backend to the session. */
CamelFolderInfo *info;
CamelFolder *folder;
GPtrArray *uids;
int i;
GError *error=NULL;
service = camel_session_add_service (
CAMEL_SESSION (session), uid,
backend_name, CAMEL_PROVIDER_STORE, NULL);
e_source_camel_configure_service (source, service);
camel_service_connect_sync (service, NULL, NULL);
info = camel_store_get_folder_info_sync (
CAMEL_STORE (service), "", 0, NULL, NULL);
print_folder_info (info, 0);
folder = camel_store_get_folder_sync (
CAMEL_STORE (service), "inbox", 0, NULL, NULL);
camel_folder_refresh_info_sync (folder, NULL, &error);
if (error)
printf("Refresh info failed: %s\n", error->message);
uids = camel_folder_get_uids (folder);
printf("Length of messages: %p %d\n", folder, uids->len);
for (i=0; i<uids->len; i++)
printf("UID: %s\n", (char *)uids->pdata[i]);
}
}
return 0;
}
