Debian Codegraph @

src/EWS/common/e-ews-folder.c

raw
1 /*
2 * SPDX-FileCopyrightText: (C) 1999-2008 Novell, Inc. (www.novell.com)
3 * SPDX-License-Identifier: LGPL-2.1-or-later
4 */
5
6 #include "evolution-ews-config.h"
7
8 #include <string.h>
9 #include <glib/gi18n-lib.h>
10
11 #include "e-ews-folder.h"
12 #include "e-ews-request.h"
13 #include "e-ews-enumtypes.h"
14 #include "ews-errors.h"
15 #include "e-source-ews-folder.h"
16 #include "camel-ews-settings.h"
17
18 struct _EEwsFolderPrivate {
19 GError *error;
20 gchar *name;
21 gchar *escaped_name;
22 EwsFolderId *fid;
23 EwsFolderId *parent_fid;
24 EEwsFolderType folder_type;
25 guint32 unread;
26 guint32 total;
27 guint32 child_count;
28 guint64 size;
29 gboolean foreign;
30 gchar *foreign_mail;
31 gboolean is_public;
32 gboolean is_hidden;
33 };
34
35 G_DEFINE_TYPE_WITH_PRIVATE (EEwsFolder, e_ews_folder, G_TYPE_OBJECT)
36
37 static void
38 e_ews_folder_dispose (GObject *object)
39 {
40 EEwsFolder *folder = (EEwsFolder *) object;
41
42 g_return_if_fail (E_IS_EWS_FOLDER (folder));
43
44 G_OBJECT_CLASS (e_ews_folder_parent_class)->dispose (object);
45 }
46
47 static void
48 e_ews_folder_finalize (GObject *object)
49 {
50 EEwsFolder *folder = (EEwsFolder *) object;
51 EEwsFolderPrivate *priv;
52
53 g_return_if_fail (E_IS_EWS_FOLDER (folder));
54
55 priv = folder->priv;
56
57 g_clear_error (&priv->error);
58 g_clear_pointer (&priv->name, g_free);
59 g_clear_pointer (&priv->escaped_name, g_free);
60 g_clear_pointer (&priv->foreign_mail, g_free);
61
62 if (priv->fid) {
63 g_free (priv->fid->id);
64 g_free (priv->fid->change_key);
65 g_free (priv->fid);
66 priv->fid = NULL;
67 }
68
69 if (priv->parent_fid) {
70 g_free (priv->parent_fid->id);
71 g_free (priv->parent_fid->change_key);
72 g_free (priv->parent_fid);
73 priv->parent_fid = NULL;
74 }
75
76 G_OBJECT_CLASS (e_ews_folder_parent_class)->finalize (object);
77 }
78
79 static void
80 e_ews_folder_class_init (EEwsFolderClass *klass)
81 {
82 GObjectClass *object_class = G_OBJECT_CLASS (klass);
83
84 object_class->dispose = e_ews_folder_dispose;
85 object_class->finalize = e_ews_folder_finalize;
86 }
87
88 static void
89 e_ews_folder_init (EEwsFolder *folder)
90 {
91 folder->priv = e_ews_folder_get_instance_private (folder);
92 folder->priv->error = NULL;
93 folder->priv->folder_type = E_EWS_FOLDER_TYPE_UNKNOWN;
94 folder->priv->foreign = FALSE;
95 folder->priv->is_public = FALSE;
96 folder->priv->is_hidden = FALSE;
97 }
98
99 static gboolean
100 e_ews_folder_set_from_soap_parameter (EEwsFolder *folder,
101 ESoapParameter *param)
102 {
103 EEwsFolderPrivate *priv = folder->priv;
104 ESoapParameter *subparam, *node;
105
106 g_return_val_if_fail (param != NULL, FALSE);
107
108 if (g_strcmp0 (e_soap_parameter_get_name (param), "Folder") == 0 ||
109 g_strcmp0 (e_soap_parameter_get_name (param), "SearchFolder") == 0 ) {
110 node = param;
111 priv->folder_type = E_EWS_FOLDER_TYPE_MAILBOX;
112 } else if (g_strcmp0 (e_soap_parameter_get_name (param), "CalendarFolder") == 0) {
113 node = param;
114 priv->folder_type = E_EWS_FOLDER_TYPE_CALENDAR;
115 } else if (g_strcmp0 (e_soap_parameter_get_name (param), "ContactsFolder") == 0) {
116 node = param;
117 priv->folder_type = E_EWS_FOLDER_TYPE_CONTACTS;
118 } else if (g_strcmp0 (e_soap_parameter_get_name (param), "TasksFolder") == 0) {
119 node = param;
120 priv->folder_type = E_EWS_FOLDER_TYPE_TASKS;
121 } else if ((node = e_soap_parameter_get_first_child_by_name (param, "Folder")) ||
122 (node = e_soap_parameter_get_first_child_by_name (param, "SearchFolder")))
123 priv->folder_type = E_EWS_FOLDER_TYPE_MAILBOX;
124 else if ((node = e_soap_parameter_get_first_child_by_name (param, "CalendarFolder")))
125 priv->folder_type = E_EWS_FOLDER_TYPE_CALENDAR;
126 else if ((node = e_soap_parameter_get_first_child_by_name (param, "ContactsFolder")))
127 priv->folder_type = E_EWS_FOLDER_TYPE_CONTACTS;
128 else if ((node = e_soap_parameter_get_first_child_by_name (param, "TasksFolder")))
129 priv->folder_type = E_EWS_FOLDER_TYPE_TASKS;
130 else {
131 g_warning ("Unable to find the Folder node \n");
132 return FALSE;
133 }
134
135 if (priv->folder_type == E_EWS_FOLDER_TYPE_MAILBOX) {
136 subparam = e_soap_parameter_get_first_child_by_name (node, "FolderClass");
137 if (subparam) {
138 EEwsFolderType folder_type;
139 gchar *folder_class = e_soap_parameter_get_string_value (subparam);
140
141 folder_type = E_EWS_FOLDER_TYPE_UNKNOWN;
142
143 if (g_strcmp0 (folder_class, "IPF.Note") == 0 || (folder_class && g_str_has_prefix (folder_class, "IPF.Note."))) {
144 folder_type = E_EWS_FOLDER_TYPE_MAILBOX;
145 } else if (g_strcmp0 (folder_class, "IPF.Contact") == 0) {
146 folder_type = E_EWS_FOLDER_TYPE_CONTACTS;
147 } else if (g_strcmp0 (folder_class, "IPF.Appointment") == 0) {
148 folder_type = E_EWS_FOLDER_TYPE_CALENDAR;
149 } else if (g_strcmp0 (folder_class, "IPF.Task") == 0) {
150 folder_type = E_EWS_FOLDER_TYPE_TASKS;
151 } else if (g_strcmp0 (folder_class, "IPF.StickyNote") == 0) {
152 folder_type = E_EWS_FOLDER_TYPE_MEMOS;
153 }
154
155 priv->folder_type = folder_type;
156
157 g_free (folder_class);
158 }
159 }
160
161 subparam = e_soap_parameter_get_first_child_by_name (node, "FolderId");
162 if (subparam) {
163 priv->fid = g_new0 (EwsFolderId, 1);
164 priv->fid->id = e_soap_parameter_get_property (subparam, "Id");
165 priv->fid->change_key = e_soap_parameter_get_property (subparam, "ChangeKey");
166 }
167
168 subparam = e_soap_parameter_get_first_child_by_name (node, "ParentFolderId");
169 if (subparam) {
170 priv->parent_fid = g_new0 (EwsFolderId, 1);
171 priv->parent_fid->id = e_soap_parameter_get_property (subparam, "Id");
172 priv->parent_fid->change_key = e_soap_parameter_get_property (subparam, "ChangeKey");
173 }
174
175 subparam = e_soap_parameter_get_first_child_by_name (node, "DisplayName");
176 if (subparam) {
177 priv->name = e_soap_parameter_get_string_value (subparam);
178 priv->escaped_name = e_ews_folder_utils_escape_name (priv->name);
179 }
180
181 subparam = e_soap_parameter_get_first_child_by_name (node, "UnreadCount");
182 if (subparam)
183 priv->unread = e_soap_parameter_get_int_value (subparam);
184
185 subparam = e_soap_parameter_get_first_child_by_name (node, "TotalCount");
186 if (subparam)
187 priv->total = e_soap_parameter_get_int_value (subparam);
188
189 subparam = e_soap_parameter_get_first_child_by_name (node, "ChildFolderCount");
190 if (subparam)
191 priv->child_count = e_soap_parameter_get_int_value (subparam);
192
193 subparam = e_soap_parameter_get_first_child_by_name (node, "ExtendedProperty");
194 if (subparam) {
195 ESoapParameter *subparam1;
196 gchar *prop_tag = NULL;
197
198 subparam1 = e_soap_parameter_get_first_child_by_name (subparam, "ExtendedFieldURI");
199 if (subparam1) {
200 prop_tag = e_soap_parameter_get_property (subparam1, "PropertyTag");
201 if (prop_tag && g_ascii_strcasecmp (prop_tag, "0xe08") == 0) {
202 subparam1 = e_soap_parameter_get_first_child_by_name (subparam, "Value");
203 if (subparam1)
204 priv->size = e_soap_parameter_get_uint64_value (subparam1);
205 } else if (prop_tag && g_ascii_strcasecmp (prop_tag, "0x10f4") == 0) { /* PidTagAttributeHidden */
206 subparam1 = e_soap_parameter_get_first_child_by_name (subparam, "Value");
207 if (subparam1) {
208 gchar *value;
209
210 value = e_soap_parameter_get_string_value (subparam1);
211 priv->is_hidden = g_strcmp0 (value, "true") == 0;
212 g_free (value);
213 }
214 }
215 g_free (prop_tag);
216 }
217 }
218
219 return TRUE;
220 }
221
222 const gchar *
223 e_ews_folder_type_to_nick (EEwsFolderType folder_type)
224 {
225 GEnumClass *enum_class;
226 GEnumValue *enum_value;
227 const gchar *folder_type_nick;
228
229 enum_class = g_type_class_ref (E_TYPE_EWS_FOLDER_TYPE);
230 enum_value = g_enum_get_value (enum_class, folder_type);
231
232 if (enum_value == NULL) {
233 folder_type = E_EWS_FOLDER_TYPE_UNKNOWN;
234 enum_value = g_enum_get_value (enum_class, folder_type);
235 }
236
237 g_return_val_if_fail (enum_value != NULL, NULL);
238
239 folder_type_nick = g_intern_string (enum_value->value_nick);
240
241 g_type_class_unref (enum_class);
242
243 return folder_type_nick;
244 }
245
246 EEwsFolderType
247 e_ews_folder_type_from_nick (const gchar *folder_type_nick)
248 {
249 GEnumClass *enum_class;
250 GEnumValue *enum_value;
251 EEwsFolderType folder_type;
252
253 g_return_val_if_fail (
254 folder_type_nick != NULL,
255 E_EWS_FOLDER_TYPE_UNKNOWN);
256
257 enum_class = g_type_class_ref (E_TYPE_EWS_FOLDER_TYPE);
258 enum_value = g_enum_get_value_by_nick (enum_class, folder_type_nick);
259
260 if (enum_value != NULL)
261 folder_type = enum_value->value;
262 else
263 folder_type = E_EWS_FOLDER_TYPE_UNKNOWN;
264
265 g_type_class_unref (enum_class);
266
267 return folder_type;
268 }
269
270 EEwsFolder *
271 e_ews_folder_new_from_soap_parameter (ESoapParameter *param)
272 {
273 EEwsFolder *folder;
274
275 g_return_val_if_fail (param != NULL, NULL);
276
277 folder = g_object_new (E_TYPE_EWS_FOLDER, NULL);
278 if (!e_ews_folder_set_from_soap_parameter (folder, param)) {
279 g_object_unref (folder);
280 return NULL;
281 }
282
283 return folder;
284 }
285
286 EEwsFolder *
287 e_ews_folder_new_from_error (const GError *error)
288 {
289 EEwsFolder *folder;
290
291 g_return_val_if_fail (error != NULL, NULL);
292
293 folder = g_object_new (E_TYPE_EWS_FOLDER, NULL);
294 folder->priv->error = g_error_copy (error);
295
296 return folder;
297 }
298
299 gboolean
300 e_ews_folder_is_error (const EEwsFolder *folder)
301 {
302 g_return_val_if_fail (E_IS_EWS_FOLDER (folder), TRUE);
303
304 return folder->priv->error != NULL;
305 }
306
307 const GError *
308 e_ews_folder_get_error (const EEwsFolder *folder)
309 {
310 g_return_val_if_fail (E_IS_EWS_FOLDER (folder), NULL);
311
312 return folder->priv->error;
313 }
314
315 EwsFolderId *
316 e_ews_folder_id_new (const gchar *id,
317 const gchar *change_key,
318 gboolean is_distinguished_id)
319 {
320 EwsFolderId *fid;
321
322 fid = g_new0 (EwsFolderId, 1);
323 fid->id = g_strdup (id);
324 fid->change_key = g_strdup (change_key);
325 fid->is_distinguished_id = is_distinguished_id;
326
327 return fid;
328 }
329
330 void
331 e_ews_folder_id_free (EwsFolderId *fid)
332 {
333 if (fid) {
334 g_free (fid->id);
335 g_free (fid->change_key);
336 g_free (fid);
337 }
338 }
339
340 gboolean
341 e_ews_folder_id_is_equal (const EwsFolderId *a,
342 const EwsFolderId *b,
343 gboolean check_change_key)
344 {
345 if (a == NULL && b == NULL)
346 return TRUE;
347
348 if (a == NULL || b == NULL)
349 return FALSE;
350
351 if ((a->is_distinguished_id ? 1 : 0) != (b->is_distinguished_id ? 1 : 0))
352 return FALSE;
353
354 if (g_strcmp0 (a->id, b->id) != 0)
355 return FALSE;
356
357 if (check_change_key)
358 if (g_strcmp0 (a->change_key, b->change_key) != 0)
359 return FALSE;
360
361 return TRUE;
362 }
363
364 void
365 e_ews_folder_id_append_to_request (ESoapRequest *request,
366 const gchar *email,
367 const EwsFolderId *fid)
368 {
369 g_return_if_fail (request != NULL);
370 g_return_if_fail (fid != NULL);
371
372 if (fid->is_distinguished_id)
373 e_soap_request_start_element (request, "DistinguishedFolderId", NULL, NULL);
374 else
375 e_soap_request_start_element (request, "FolderId", NULL, NULL);
376
377 e_soap_request_add_attribute (request, "Id", fid->id, NULL, NULL);
378 if (fid->change_key)
379 e_soap_request_add_attribute (request, "ChangeKey", fid->change_key, NULL, NULL);
380
381 if (fid->is_distinguished_id && email) {
382 e_soap_request_start_element (request, "Mailbox", NULL, NULL);
383 e_ews_request_write_string_parameter (request, "EmailAddress", NULL, email);
384 e_soap_request_end_element (request);
385 }
386
387 e_soap_request_end_element (request);
388 }
389
390 const gchar *
391 e_ews_folder_get_name (const EEwsFolder *folder)
392 {
393 g_return_val_if_fail (E_IS_EWS_FOLDER (folder), NULL);
394
395 return (const gchar *) folder->priv->name;
396 }
397
398 void
399 e_ews_folder_set_name (EEwsFolder *folder,
400 const gchar *new_name)
401 {
402 EEwsFolderPrivate *priv;
403
404 g_return_if_fail (E_IS_EWS_FOLDER (folder));
405 g_return_if_fail (new_name != NULL);
406
407 priv = folder->priv;
408
409 g_free (priv->name);
410 g_free (priv->escaped_name);
411
412 priv->name = g_strdup (new_name);
413 priv->escaped_name = e_ews_folder_utils_escape_name (priv->name);
414 }
415
416 const gchar *
417 e_ews_folder_get_escaped_name (const EEwsFolder *folder)
418 {
419 g_return_val_if_fail (E_IS_EWS_FOLDER (folder), NULL);
420
421 return folder->priv->escaped_name;
422 }
423
424 const EwsFolderId *
425 e_ews_folder_get_id (const EEwsFolder *folder)
426 {
427 g_return_val_if_fail (E_IS_EWS_FOLDER (folder), NULL);
428
429 return (const EwsFolderId *) folder->priv->fid;
430 }
431
432 void
433 e_ews_folder_set_id (EEwsFolder *folder,
434 EwsFolderId *fid)
435 {
436 g_return_if_fail (E_IS_EWS_FOLDER (folder));
437
438 e_ews_folder_id_free (folder->priv->fid);
439 folder->priv->fid = fid;
440 }
441
442 const EwsFolderId *
443 e_ews_folder_get_parent_id (const EEwsFolder *folder)
444 {
445 g_return_val_if_fail (E_IS_EWS_FOLDER (folder), NULL);
446
447 return (const EwsFolderId *) folder->priv->parent_fid;
448 }
449
450 void
451 e_ews_folder_set_parent_id (EEwsFolder *folder,
452 EwsFolderId *parent_fid)
453 {
454 EEwsFolderPrivate *priv;
455
456 g_return_if_fail (E_IS_EWS_FOLDER (folder));
457 g_return_if_fail (parent_fid != NULL);
458
459 priv = folder->priv;
460
461 if (priv->parent_fid) {
462 g_free (priv->parent_fid->id);
463 g_free (priv->parent_fid->change_key);
464 g_free (priv->parent_fid);
465 }
466
467 priv->parent_fid = parent_fid;
468 }
469
470 gboolean
471 e_ews_folder_get_is_hidden (EEwsFolder *folder)
472 {
473 g_return_val_if_fail (E_IS_EWS_FOLDER (folder), FALSE);
474
475 return folder->priv->is_hidden;
476 }
477
478 EEwsFolderType
479 e_ews_folder_get_folder_type (const EEwsFolder *folder)
480 {
481 g_return_val_if_fail (E_IS_EWS_FOLDER (folder), -1);
482
483 return folder->priv->folder_type;
484 }
485
486 void
487 e_ews_folder_set_folder_type (EEwsFolder *folder,
488 EEwsFolderType folder_type)
489 {
490 g_return_if_fail (E_IS_EWS_FOLDER (folder));
491
492 folder->priv->folder_type = folder_type;
493 }
494
495 guint32
496 e_ews_folder_get_total_count (const EEwsFolder *folder)
497 {
498 g_return_val_if_fail (E_IS_EWS_FOLDER (folder), -1);
499
500 return folder->priv->total;
501 }
502
503 guint32
504 e_ews_folder_get_unread_count (const EEwsFolder *folder)
505 {
506 g_return_val_if_fail (E_IS_EWS_FOLDER (folder), -1);
507
508 return folder->priv->unread;
509 }
510
511 guint32
512 e_ews_folder_get_child_count (const EEwsFolder *folder)
513 {
514 g_return_val_if_fail (E_IS_EWS_FOLDER (folder), -1);
515
516 return folder->priv->child_count;
517 }
518
519 guint64
520 e_ews_folder_get_size (const EEwsFolder *folder)
521 {
522 g_return_val_if_fail (E_IS_EWS_FOLDER (folder), -1);
523
524 return folder->priv->size;
525 }
526
527 gboolean
528 e_ews_folder_get_foreign (const EEwsFolder *folder)
529 {
530 g_return_val_if_fail (E_IS_EWS_FOLDER (folder), FALSE);
531
532 return folder->priv->foreign;
533 }
534
535 void
536 e_ews_folder_set_foreign (EEwsFolder *folder,
537 gboolean is_foreign)
538 {
539 g_return_if_fail (E_IS_EWS_FOLDER (folder));
540
541 folder->priv->foreign = is_foreign;
542 }
543
544 const gchar *
545 e_ews_folder_get_foreign_mail (const EEwsFolder *folder)
546 {
547 g_return_val_if_fail (E_IS_EWS_FOLDER (folder), NULL);
548
549 return folder->priv->foreign_mail;
550 }
551
552 void
553 e_ews_folder_set_foreign_mail (EEwsFolder *folder,
554 const gchar *foreign_mail)
555 {
556 g_return_if_fail (E_IS_EWS_FOLDER (folder));
557
558 g_free (folder->priv->foreign_mail);
559 folder->priv->foreign_mail = g_strdup (foreign_mail);
560 }
561
562 gboolean
563 e_ews_folder_get_public (const EEwsFolder *folder)
564 {
565 g_return_val_if_fail (E_IS_EWS_FOLDER (folder), FALSE);
566
567 return folder->priv->is_public;
568 }
569
570 void
571 e_ews_folder_set_public (EEwsFolder *folder,
572 gboolean is_public)
573 {
574 g_return_if_fail (E_IS_EWS_FOLDER (folder));
575
576 folder->priv->is_public = is_public;
577 }
578
579 /* escapes backslashes with \5C and forward slashes with \2F */
580 gchar *
581 e_ews_folder_utils_escape_name (const gchar *folder_name)
582 {
583 gint ii, jj, count = 0;
584 gchar *res;
585
586 if (!folder_name)
587 return NULL;
588
589 for (ii = 0; folder_name[ii]; ii++) {
590 if (folder_name[ii] == '\\' || folder_name[ii] == '/')
591 count++;
592 }
593
594 if (!count)
595 return g_strdup (folder_name);
596
597 res = g_malloc0 (sizeof (gchar) * (1 + ii + (2 * count)));
598 for (ii = 0, jj = 0; folder_name[ii]; ii++, jj++) {
599 if (folder_name[ii] == '\\') {
600 res[jj] = '\\';
601 res[jj + 1] = '5';
602 res[jj + 2] = 'C';
603 jj += 2;
604 } else if (folder_name[ii] == '/') {
605 res[jj] = '\\';
606 res[jj + 1] = '2';
607 res[jj + 2] = 'F';
608 jj += 2;
609 } else {
610 res[jj] = folder_name[ii];
611 }
612 }
613
614 res[jj] = '\0';
615
616 return res;
617 }
618
619 /* reverses e_ews_folder_utils_escape_name() processing */
620 gchar *
621 e_ews_folder_utils_unescape_name (const gchar *escaped_folder_name)
622 {
623 gchar *res = g_strdup (escaped_folder_name);
624 gint ii, jj;
625
626 if (!res)
627 return res;
628
629 for (ii = 0, jj = 0; res[ii]; ii++, jj++) {
630 if (res[ii] == '\\' && g_ascii_isxdigit (res[ii + 1]) && g_ascii_isxdigit (res[ii + 2])) {
631 res[jj] = ((g_ascii_xdigit_value (res[ii + 1]) & 0xF) << 4) | (g_ascii_xdigit_value (res[ii + 2]) & 0xF);
632 ii += 2;
633 } else if (ii != jj) {
634 res[jj] = res[ii];
635 }
636 }
637
638 res[jj] = '\0';
639
640 return res;
641 }
642
643 gchar *
644 e_ews_folder_utils_pick_color_spec (gint move_by,
645 gboolean around_middle)
646 {
647 static gint color_mover = 0;
648 static gint color_indexer = -1;
649 const guint32 colors[] = {
650 0x1464ae, /* dark blue */
651 0x14ae64, /* dark green */
652 0xae1464, /* dark red */
653 0
654 };
655 guint32 color;
656
657 if (move_by <= 0)
658 move_by = 1;
659
660 while (move_by > 0) {
661 move_by--;
662
663 color_indexer++;
664 if (colors[color_indexer] == 0) {
665 color_mover += 1;
666 color_indexer = 0;
667 }
668 }
669
670 color = colors[color_indexer];
671 color = (color & ~(0xFF << (color_indexer * 8))) |
672 (((((color >> (color_indexer * 8)) & 0xFF) + (0x33 * color_mover)) % 0xFF) << (color_indexer * 8));
673
674 if (around_middle) {
675 gint rr, gg, bb, diff;
676
677 rr = (0xFF0000 & color) >> 16;
678 gg = (0x00FF00 & color) >> 8;
679 bb = (0x0000FF & color);
680
681 diff = 0x80 - rr;
682 if (diff < 0x80 - gg)
683 diff = 0x80 - gg;
684 if (diff < 0x80 - bb)
685 diff = 0x80 - bb;
686
687 rr = rr + diff < 0 ? 0 : rr + diff > 0xCC ? 0xCC : rr + diff;
688 gg = gg + diff < 0 ? 0 : gg + diff > 0xCC ? 0xCC : gg + diff;
689 bb = bb + diff < 0 ? 0 : bb + diff > 0xCC ? 0xCC : bb + diff;
690
691 color = (rr << 16) + (gg << 8) + bb;
692 }
693
694 return g_strdup_printf ("#%06x", color);
695 }
696
697 gboolean
698 e_ews_folder_utils_populate_esource (ESource *source,
699 const GList *sources,
700 const gchar *master_hosturl,
701 const gchar *master_username,
702 EEwsFolder *folder,
703 EEwsESourceFlags flags,
704 gint color_seed,
705 GCancellable *cancellable,
706 GError **perror)
707 {
708 ESource *master_source;
709 gboolean res = FALSE;
710
711 master_source = e_ews_folder_utils_get_master_source (sources, master_hosturl, master_username);
712
713 if (master_source) {
714 ESourceBackend *backend_ext;
715 EEwsFolderType folder_type;
716 const EwsFolderId *folder_id = e_ews_folder_get_id (folder);
717
718 g_return_val_if_fail (folder_id != NULL, FALSE);
719
720 folder_type = e_ews_folder_get_folder_type (folder);
721
722 e_source_set_parent (source, e_source_get_uid (master_source));
723 e_source_set_display_name (source, e_ews_folder_get_name (folder));
724
725 switch (folder_type) {
726 case E_EWS_FOLDER_TYPE_CALENDAR:
727 backend_ext = e_source_get_extension (source, E_SOURCE_EXTENSION_CALENDAR);
728 break;
729 case E_EWS_FOLDER_TYPE_MEMOS:
730 backend_ext = e_source_get_extension (source, E_SOURCE_EXTENSION_MEMO_LIST);
731 break;
732 case E_EWS_FOLDER_TYPE_TASKS:
733 backend_ext = e_source_get_extension (source, E_SOURCE_EXTENSION_TASK_LIST);
734 break;
735 case E_EWS_FOLDER_TYPE_CONTACTS:
736 backend_ext = e_source_get_extension (source, E_SOURCE_EXTENSION_ADDRESS_BOOK);
737 break;
738 default:
739 backend_ext = NULL;
740 break;
741 }
742
743 if (backend_ext) {
744 ESourceEwsFolder *folder_ext;
745 ESourceOffline *offline_ext;
746
747 e_source_backend_set_backend_name (backend_ext, "ews");
748
749 folder_ext = e_source_get_extension (source, E_SOURCE_EXTENSION_EWS_FOLDER);
750 e_source_ews_folder_set_id (folder_ext, folder_id->id);
751 e_source_ews_folder_set_change_key (folder_ext, NULL);
752 e_source_ews_folder_set_name (folder_ext, e_ews_folder_get_name (folder));
753 e_source_ews_folder_set_foreign (folder_ext, e_ews_folder_get_foreign (folder));
754 e_source_ews_folder_set_foreign_subfolders (folder_ext, (flags & E_EWS_ESOURCE_FLAG_INCLUDE_SUBFOLDERS) != 0);
755 e_source_ews_folder_set_foreign_mail (folder_ext, e_ews_folder_get_foreign_mail (folder));
756 e_source_ews_folder_set_public (folder_ext, (flags & E_EWS_ESOURCE_FLAG_PUBLIC_FOLDER) != 0);
757
758 offline_ext = e_source_get_extension (source, E_SOURCE_EXTENSION_OFFLINE);
759 e_source_offline_set_stay_synchronized (offline_ext, (flags & E_EWS_ESOURCE_FLAG_OFFLINE_SYNC) != 0);
760
761 /* set also color for calendar-like sources */
762 if (folder_type != E_EWS_FOLDER_TYPE_CONTACTS) {
763 ESourceAlarms *alarms;
764 gchar *color_str;
765
766 color_str = e_ews_folder_utils_pick_color_spec (
767 1 + g_list_length ((GList *) sources),
768 folder_type != E_EWS_FOLDER_TYPE_CALENDAR);
769 e_source_selectable_set_color (E_SOURCE_SELECTABLE (backend_ext), color_str);
770 g_free (color_str);
771
772 alarms = e_source_get_extension (source, E_SOURCE_EXTENSION_ALARMS);
773 e_source_alarms_set_include_me (alarms, FALSE);
774 }
775
776 res = TRUE;
777 } else {
778 g_propagate_error (
779 perror, g_error_new_literal (EWS_CONNECTION_ERROR,
780 EWS_CONNECTION_ERROR_NORESPONSE, _("Cannot add folder, unsupported folder type")));
781 }
782 } else {
783 g_propagate_error (
784 perror, g_error_new_literal (EWS_CONNECTION_ERROR,
785 EWS_CONNECTION_ERROR_NORESPONSE, _("Cannot add folder, master source not found")));
786 }
787
788 return res;
789 }
790
791 gboolean
792 e_ews_folder_utils_add_as_esource (ESourceRegistry *pregistry,
793 const gchar *master_hosturl,
794 const gchar *master_username,
795 EEwsFolder *folder,
796 EEwsESourceFlags flags,
797 gint color_seed,
798 GCancellable *cancellable,
799 GError **perror)
800 {
801 ESourceRegistry *registry;
802 GList *sources;
803 ESource *source, *old_source;
804 const EwsFolderId *fid;
805 gboolean res = FALSE;
806
807 registry = pregistry;
808 if (!registry) {
809 registry = e_source_registry_new_sync (cancellable, perror);
810 if (!registry)
811 return FALSE;
812 }
813
814 sources = e_source_registry_list_sources (registry, NULL);
815 source = e_source_new (NULL, NULL, NULL);
816 fid = e_ews_folder_get_id (folder);
817
818 old_source = e_ews_folder_utils_get_source_for_folder (sources, master_hosturl, master_username, fid->id);
819 if (old_source) {
820 res = FALSE;
821
822 g_propagate_error (
823 perror,
824 g_error_new (EWS_CONNECTION_ERROR, EWS_CONNECTION_ERROR_FOLDEREXISTS,
825 _("Cannot add folder, folder already exists as “%s”"), e_source_get_display_name (old_source)));
826 } else if (e_ews_folder_utils_populate_esource (
827 source,
828 sources,
829 master_hosturl,
830 master_username,
831 folder,
832 flags,
833 color_seed,
834 cancellable,
835 perror)) {
836 res = e_source_registry_commit_source_sync (registry, source, cancellable, perror);
837 }
838 g_object_unref (source);
839
840 g_list_free_full (sources, g_object_unref);
841 if (!pregistry)
842 g_object_unref (registry);
843
844 return res;
845 }
846
847 gboolean
848 e_ews_folder_utils_remove_as_esource (const gchar *master_hosturl,
849 const gchar *master_username,
850 const gchar *folder_id,
851 GCancellable *cancellable,
852 GError **perror)
853 {
854 ESourceRegistry *registry;
855 ESource *source;
856 GList *sources;
857 gboolean res = TRUE;
858
859 registry = e_source_registry_new_sync (cancellable, perror);
860 if (!registry)
861 return FALSE;
862
863 sources = e_source_registry_list_sources (registry, NULL);
864 source = e_ews_folder_utils_get_source_for_folder (sources, master_hosturl, master_username, folder_id);
865
866 if (source) {
867 if (e_source_get_removable (source))
868 res = e_source_remove_sync (source, cancellable, perror);
869 else
870 res = e_source_remote_delete_sync (source, cancellable, perror);
871 }
872
873 g_list_free_full (sources, g_object_unref);
874 g_object_unref (registry);
875
876 return res;
877 }
878
879 GList *
880 e_ews_folder_utils_get_esources (const gchar *master_hosturl,
881 const gchar *master_username,
882 GCancellable *cancellable,
883 GError **perror)
884 {
885 ESourceRegistry *registry;
886 GList *all_sources, *esources = NULL;
887
888 registry = e_source_registry_new_sync (cancellable, perror);
889 if (!registry)
890 return NULL;
891
892 all_sources = e_source_registry_list_sources (registry, NULL);
893 esources = e_ews_folder_utils_filter_sources_for_account (all_sources, master_hosturl, master_username);
894
895 g_list_free_full (all_sources, g_object_unref);
896 g_object_unref (registry);
897
898 return esources;
899 }
900
901 gboolean
902 e_ews_folder_utils_is_subscribed_as_esource (const GList *esources,
903 const gchar *master_hosturl,
904 const gchar *master_username,
905 const gchar *folder_id)
906 {
907 return e_ews_folder_utils_get_source_for_folder (esources, master_hosturl, master_username, folder_id) != NULL;
908 }
909
910 static gboolean
911 is_for_account (ESource *source,
912 const gchar *master_hosturl,
913 const gchar *master_username)
914 {
915 ESourceCamel *camel_extension;
916 ESourceAuthentication *auth_extension;
917 CamelEwsSettings *settings;
918 const gchar *extension_name;
919
920 if (!source)
921 return FALSE;
922
923 if (!master_hosturl && !master_username)
924 return TRUE;
925
926 extension_name = e_source_camel_get_extension_name ("ews");
927 if (!e_source_has_extension (source, extension_name))
928 return FALSE;
929
930 camel_extension = e_source_get_extension (source, extension_name);
931 settings = CAMEL_EWS_SETTINGS (e_source_camel_get_settings (camel_extension));
932
933 if (!settings || g_strcmp0 (camel_ews_settings_get_hosturl (settings), master_hosturl) != 0)
934 return FALSE;
935
936 extension_name = E_SOURCE_EXTENSION_AUTHENTICATION;
937 if (!e_source_has_extension (source, extension_name))
938 return FALSE;
939
940 auth_extension = e_source_get_extension (source, extension_name);
941 return g_strcmp0 (e_source_authentication_get_user (auth_extension), master_username) == 0;
942 }
943
944 /* filters @esources thus the resulting list will contain ESource-s only for @profile;
945 * free returned list with g_list_free_full (list, g_object_unref); */
946 GList *
947 e_ews_folder_utils_filter_sources_for_account (const GList *esources,
948 const gchar *master_hosturl,
949 const gchar *master_username)
950 {
951 GList *found = NULL;
952 const GList *iter;
953 ESource *master_source;
954
955 master_source = e_ews_folder_utils_get_master_source (esources, master_hosturl, master_username);
956 if (!master_source)
957 return NULL;
958
959 for (iter = esources; iter; iter = iter->next) {
960 ESource *source = iter->data;
961
962 if (is_for_account (source, master_hosturl, master_username) ||
963 g_strcmp0 (e_source_get_uid (master_source), e_source_get_parent (source)) == 0)
964 found = g_list_prepend (found, g_object_ref (source));
965 }
966
967 return g_list_reverse (found);
968 }
969
970 /* returns (not-reffed) member of @esources, which is for @profile and @folder_id */
971 ESource *
972 e_ews_folder_utils_get_source_for_folder (const GList *esources,
973 const gchar *master_hosturl,
974 const gchar *master_username,
975 const gchar *folder_id)
976 {
977 ESource *master_source;
978 const GList *iter;
979
980 master_source = e_ews_folder_utils_get_master_source (esources, master_hosturl, master_username);
981 if (!master_source)
982 return NULL;
983
984 for (iter = esources; iter; iter = iter->next) {
985 ESource *source = iter->data;
986
987 if ((is_for_account (source, master_hosturl, master_username) ||
988 g_strcmp0 (e_source_get_uid (master_source), e_source_get_parent (source)) == 0) &&
989 e_source_has_extension (source, E_SOURCE_EXTENSION_EWS_FOLDER)) {
990 ESourceEwsFolder *folder_ext = e_source_get_extension (source, E_SOURCE_EXTENSION_EWS_FOLDER);
991
992 g_return_val_if_fail (folder_ext != NULL, NULL);
993
994 if (g_strcmp0 (e_source_ews_folder_get_id (folder_ext), folder_id) == 0)
995 return source;
996 }
997 }
998
999 return NULL;
1000 }
1001
1002 /* returns (not-reffed) member of @esources, which is master (with no parent) source for @profile */
1003 ESource *
1004 e_ews_folder_utils_get_master_source (const GList *esources,
1005 const gchar *master_hosturl,
1006 const gchar *master_username)
1007 {
1008 const GList *iter;
1009
1010 for (iter = esources; iter; iter = iter->next) {
1011 ESource *source = iter->data;
1012
1013 if (!e_source_get_parent (source) &&
1014 is_for_account (source, master_hosturl, master_username))
1015 return source;
1016 }
1017
1018 return NULL;
1019 }