diff --git a/radicale/__init__.py b/radicale/__init__.py index 1b81add..7f0b6df 100644 --- a/radicale/__init__.py +++ b/radicale/__init__.py @@ -37,7 +37,7 @@ import re from http import client from urllib.parse import unquote, urlparse -from . import auth, config, ical, log, rights, storage, xmlutils +from . import auth, config, log, rights, storage, xmlutils VERSION = "2.0.0-pre" @@ -167,7 +167,7 @@ class Application(object): def sanitize_uri(uri): """Unquote and make absolute to prevent access to other data.""" uri = unquote(uri) - return ical.sanitize_path(uri) + return storage.sanitize_path(uri) def collect_allowed_items(self, items, user): """Get items from request that user is allowed to access.""" @@ -177,7 +177,7 @@ class Application(object): write_allowed_items = [] for item in items: - if isinstance(item, ical.Collection): + if isinstance(item, storage.Collection): if rights.authorized(user, item, "r"): log.LOGGER.debug( "%s has read access to collection %s" % @@ -294,7 +294,7 @@ class Application(object): is_valid_user = is_authenticated or not user if is_valid_user: - items = ical.Collection.from_path( + items = storage.Collection.from_path( path, environ.get("HTTP_DEPTH", "0")) read_allowed_items, write_allowed_items = ( self.collect_allowed_items(items, user)) @@ -401,7 +401,7 @@ class Application(object): items = [item] if collection.resource_type == "calendar": items.extend(collection.timezones) - answer_text = ical.serialize( + answer_text = storage.serialize( collection.tag, collection.headers, items) etag = item.etag else: @@ -480,7 +480,7 @@ class Application(object): if to_url_parts.netloc == environ["HTTP_HOST"]: to_url = to_url_parts.path to_path, to_name = to_url.rstrip("/").rsplit("/", 1) - to_collection = ical.Collection.from_path( + to_collection = storage.Collection.from_path( to_path, depth="0")[0] if to_collection in write_collections: to_collection.append(to_name, item.text) diff --git a/radicale/ical.py b/radicale/ical.py deleted file mode 100644 index c0cda2f..0000000 --- a/radicale/ical.py +++ /dev/null @@ -1,500 +0,0 @@ -# This file is part of Radicale Server - Calendar Server -# Copyright © 2008 Nicolas Kandel -# Copyright © 2008 Pascal Halter -# Copyright © 2008-2016 Guillaume Ayoub -# -# This library is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# This library 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 General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with Radicale. If not, see . - -""" -Radicale collection classes. - -Define the main classes of a collection as seen from the server. - -""" - -import hashlib -import os -import posixpath -import re -from contextlib import contextmanager -from random import randint -from uuid import uuid4 - -import vobject - - -def serialize(tag, headers=(), items=()): - """Return a text corresponding to given collection ``tag``. - - The text may have the given ``headers`` and ``items`` added around the - items if needed (ie. for calendars). - - """ - items = sorted(items, key=lambda x: x.name) - if tag == "VADDRESSBOOK": - lines = [item.text.strip() for item in items] - else: - lines = ["BEGIN:%s" % tag] - for part in (headers, items): - if part: - lines.append("\r\n".join(item.text.strip() for item in part)) - lines.append("END:%s" % tag) - lines.append("") - return "\r\n".join(lines) - - -def sanitize_path(path): - """Make path absolute with leading slash to prevent access to other data. - - Preserve a potential trailing slash. - - """ - trailing_slash = "/" if path.endswith("/") else "" - path = posixpath.normpath(path) - new_path = "/" - for part in path.split("/"): - if not part or part in (".", ".."): - continue - new_path = posixpath.join(new_path, part) - trailing_slash = "" if new_path.endswith("/") else trailing_slash - return new_path + trailing_slash - - -def clean_name(name): - """Clean an item name by removing slashes and leading/ending brackets.""" - # Remove leading and ending brackets that may have been put by Outlook - name = name.strip("{}") - # Remove slashes, mostly unwanted when saving on filesystems - name = name.replace("/", "_") - return name - - -def unfold(text): - """Unfold multi-lines attributes. - - Read rfc5545-3.1 for info. - - """ - return re.sub('\r\n( |\t)', '', text).splitlines() - - -class Item(object): - """Internal iCal item.""" - def __init__(self, text, name=None): - """Initialize object from ``text`` and different ``kwargs``.""" - self.component = vobject.readOne(text) - self._name = name - - if not self.component.name: - # Header - self._name = next(self.component.lines()).name.lower() - return - - # We must synchronize the name in the text and in the object. - # An item must have a name, determined in order by: - # - # - the ``name`` parameter - # - the ``X-RADICALE-NAME`` iCal property (for Events, Todos, Journals) - # - the ``UID`` iCal property (for Events, Todos, Journals) - # - the ``TZID`` iCal property (for Timezones) - if not self._name: - for line in self.component.lines(): - if line.name in ("X-RADICALE-NAME", "UID", "TZID"): - self._name = line.value - if line.name == "X-RADICALE-NAME": - break - - if self._name: - self._name = clean_name(self._name) - else: - self._name = uuid4().hex - - if not hasattr(self.component, "x_radicale_name"): - self.component.add("X-RADICALE-NAME") - self.component.x_radicale_name.value = self._name - - def __hash__(self): - return hash(self.text) - - def __eq__(self, item): - return isinstance(item, Item) and self.text == item.text - - @property - def etag(self): - """Item etag. - - Etag is mainly used to know if an item has changed. - - """ - md5 = hashlib.md5() - md5.update(self.text.encode("utf-8")) - return '"%s"' % md5.hexdigest() - - @property - def name(self): - """Item name. - - Name is mainly used to give an URL to the item. - - """ - return self._name - - @property - def text(self): - """Item serialized text.""" - return self.component.serialize() - - -class Header(Item): - """Internal header class.""" - - -class Timezone(Item): - """Internal timezone class.""" - tag = "VTIMEZONE" - - -class Component(Item): - """Internal main component of a collection.""" - - -class Event(Component): - """Internal event class.""" - tag = "VEVENT" - mimetype = "text/calendar" - - -class Todo(Component): - """Internal todo class.""" - tag = "VTODO" # pylint: disable=W0511 - mimetype = "text/calendar" - - -class Journal(Component): - """Internal journal class.""" - tag = "VJOURNAL" - mimetype = "text/calendar" - - -class Card(Component): - """Internal card class.""" - tag = "VCARD" - mimetype = "text/vcard" - - -class Collection(object): - """Internal collection item. - - This class must be overridden and replaced by a storage backend. - - """ - def __init__(self, path, principal=False): - """Initialize the collection. - - ``path`` must be the normalized relative path of the collection, using - the slash as the folder delimiter, with no leading nor trailing slash. - - """ - self.encoding = "utf-8" - # path should already be sanitized - self.path = sanitize_path(path).strip("/") - split_path = self.path.split("/") - if principal and split_path and self.is_node(self.path): - # Already existing principal collection - self.owner = split_path[0] - elif len(split_path) > 1: - # URL with at least one folder - self.owner = split_path[0] - else: - self.owner = None - self.is_principal = principal - self._items = None - - @classmethod - def from_path(cls, path, depth="1", include_container=True): - """Return a list of collections and items under the given ``path``. - - If ``depth`` is "0", only the actual object under ``path`` is - returned. - - If ``depth`` is anything but "0", it is considered as "1" and direct - children are included in the result. If ``include_container`` is - ``True`` (the default), the containing object is included in the - result. - - The ``path`` is relative. - - """ - # path == None means wrong URL - if path is None: - return [] - - # path should already be sanitized - sane_path = sanitize_path(path).strip("/") - attributes = sane_path.split("/") - if not attributes: - return [] - - # Try to guess if the path leads to a collection or an item - if cls.is_leaf("/".join(attributes[:-1])): - attributes.pop() - - result = [] - path = "/".join(attributes) - - principal = len(attributes) <= 1 - if cls.is_node(path): - if depth == "0": - result.append(cls(path, principal)) - else: - if include_container: - result.append(cls(path, principal)) - for child in cls.children(path): - result.append(child) - else: - if depth == "0": - result.append(cls(path)) - else: - collection = cls(path, principal) - if include_container: - result.append(collection) - result.extend(collection.components) - return result - - def save(self, text): - """Save the text into the collection.""" - raise NotImplementedError - - def delete(self): - """Delete the collection.""" - raise NotImplementedError - - @property - def text(self): - """Collection as plain text.""" - raise NotImplementedError - - @classmethod - def children(cls, path): - """Yield the children of the collection at local ``path``.""" - raise NotImplementedError - - @classmethod - def is_node(cls, path): - """Return ``True`` if relative ``path`` is a node. - - A node is a WebDAV collection whose members are other collections. - - """ - raise NotImplementedError - - @classmethod - def is_leaf(cls, path): - """Return ``True`` if relative ``path`` is a leaf. - - A leaf is a WebDAV collection whose members are not collections. - - """ - raise NotImplementedError - - @property - def last_modified(self): - """Get the last time the collection has been modified. - - The date is formatted according to rfc1123-5.2.14. - - """ - raise NotImplementedError - - @property - @contextmanager - def props(self): - """Get the collection properties.""" - raise NotImplementedError - - @property - def exists(self): - """``True`` if the collection exists on the storage, else ``False``.""" - return self.is_node(self.path) or self.is_leaf(self.path) - - @staticmethod - def _parse(text, item_types, name=None): - """Find items with type in ``item_types`` in ``text``. - - If ``name`` is given, give this name to new items in ``text``. - - Return a dict of items. - - """ - item_tags = {item_type.tag: item_type for item_type in item_types} - items = {} - root = next(vobject.readComponents(text)) - components = ( - root.components() if root.name in ("VADDRESSBOOK", "VCALENDAR") - else (root,)) - for component in components: - item_name = None if component.name == "VTIMEZONE" else name - item_type = item_tags[component.name] - item = item_type(component.serialize(), item_name) - if item.name in items: - text = "\r\n".join((item.text, items[item.name].text)) - items[item.name] = item_type(text, item.name) - else: - items[item.name] = item - - return items - - def append(self, name, text): - """Append items from ``text`` to collection. - - If ``name`` is given, give this name to new items in ``text``. - - """ - new_items = self._parse( - text, (Timezone, Event, Todo, Journal, Card), name) - for new_item in new_items.values(): - if new_item.name not in self.items: - self.items[new_item.name] = new_item - self.write() - - def remove(self, name): - """Remove object named ``name`` from collection.""" - if name in self.items: - del self.items[name] - self.write() - - def replace(self, name, text): - """Replace content by ``text`` in collection objet called ``name``.""" - self.remove(name) - self.append(name, text) - - def write(self): - """Write collection with given parameters.""" - text = serialize(self.tag, self.headers, self.items.values()) - self.save(text) - - def set_mimetype(self, mimetype): - """Set the mimetype of the collection.""" - with self.props as props: - if "tag" not in props: - if mimetype == "text/vcard": - props["tag"] = "VADDRESSBOOK" - else: - props["tag"] = "VCALENDAR" - - @property - def tag(self): - """Type of the collection.""" - with self.props as props: - if "tag" not in props: - try: - tag = open(self.path).readlines()[0][6:].rstrip() - except IOError: - if self.path.endswith((".vcf", "/carddav")): - props["tag"] = "VADDRESSBOOK" - else: - props["tag"] = "VCALENDAR" - else: - if tag in ("VADDRESSBOOK", "VCARD"): - props["tag"] = "VADDRESSBOOK" - else: - props["tag"] = "VCALENDAR" - return props["tag"] - - @property - def mimetype(self): - """Mimetype of the collection.""" - if self.tag == "VADDRESSBOOK": - return "text/vcard" - elif self.tag == "VCALENDAR": - return "text/calendar" - - @property - def resource_type(self): - """Resource type of the collection.""" - if self.tag == "VADDRESSBOOK": - return "addressbook" - elif self.tag == "VCALENDAR": - return "calendar" - - @property - def etag(self): - """Etag from collection.""" - md5 = hashlib.md5() - md5.update(self.text.encode("utf-8")) - return '"%s"' % md5.hexdigest() - - @property - def name(self): - """Collection name.""" - with self.props as props: - return props.get("D:displayname", self.path.split(os.path.sep)[-1]) - - @property - def color(self): - """Collection color.""" - with self.props as props: - if "ICAL:calendar-color" not in props: - props["ICAL:calendar-color"] = "#%x" % randint(0, 255 ** 3 - 1) - return props["ICAL:calendar-color"] - - @property - def headers(self): - """Find headers items in collection.""" - header_lines = [] - - lines = unfold(self.text)[1:] - for line in lines: - if line.startswith(("BEGIN:", "END:")): - break - header_lines.append(Header(line)) - - return header_lines or ( - Header("PRODID:-//Radicale//NONSGML Radicale Server//EN"), - Header("VERSION:%s" % self.version)) - - @property - def items(self): - """Get list of all items in collection.""" - if self._items is None: - self._items = self._parse( - self.text, (Event, Todo, Journal, Card, Timezone)) - return self._items - - @property - def timezones(self): - """Get list of all timezones in collection.""" - return [ - item for item in self.items.values() if item.tag == Timezone.tag] - - @property - def components(self): - """Get list of all components in collection.""" - tags = [item_type.tag for item_type in (Event, Todo, Journal, Card)] - return [item for item in self.items.values() if item.tag in tags] - - @property - def owner_url(self): - """Get the collection URL according to its owner.""" - return "/%s/" % self.owner if self.owner else None - - @property - def url(self): - """Get the standard collection URL.""" - return "%s/" % self.path - - @property - def version(self): - """Get the version of the collection type.""" - return "3.0" if self.tag == "VADDRESSBOOK" else "2.0" diff --git a/radicale/storage.py b/radicale/storage.py index f6f19e4..ed88144 100644 --- a/radicale/storage.py +++ b/radicale/storage.py @@ -26,6 +26,7 @@ entry. """ +import hashlib import json import os import posixpath @@ -33,8 +34,11 @@ import shutil import sys import time from contextlib import contextmanager +from uuid import uuid4 -from . import config, ical, log +import vobject + +from . import config, log def _load(): @@ -45,12 +49,57 @@ def _load(): else: __import__(storage_type) module = sys.modules[storage_type] - ical.Collection = module.Collection + sys.modules[__name__].Collection = module.Collection FOLDER = os.path.expanduser(config.get("storage", "filesystem_folder")) FILESYSTEM_ENCODING = sys.getfilesystemencoding() +def serialize(tag, headers=(), items=()): + """Return a text corresponding to given collection ``tag``. + + The text may have the given ``headers`` and ``items`` added around the + items if needed (ie. for calendars). + + """ + items = sorted(items, key=lambda x: x.name) + if tag == "VADDRESSBOOK": + lines = [item.text.strip() for item in items] + else: + lines = ["BEGIN:%s" % tag] + for part in (headers, items): + if part: + lines.append("\r\n".join(item.text.strip() for item in part)) + lines.append("END:%s" % tag) + lines.append("") + return "\r\n".join(lines) + + +def sanitize_path(path): + """Make path absolute with leading slash to prevent access to other data. + + Preserve a potential trailing slash. + + """ + trailing_slash = "/" if path.endswith("/") else "" + path = posixpath.normpath(path) + new_path = "/" + for part in path.split("/"): + if not part or part in (".", ".."): + continue + new_path = posixpath.join(new_path, part) + trailing_slash = "" if new_path.endswith("/") else trailing_slash + return new_path + trailing_slash + + +def clean_name(name): + """Clean an item name by removing slashes and leading/ending brackets.""" + # Remove leading and ending brackets that may have been put by Outlook + name = name.strip("{}") + # Remove slashes, mostly unwanted when saving on filesystems + name = name.replace("/", "_") + return name + def is_safe_path_component(path): """Check if path is a single component of a POSIX path. @@ -92,7 +141,7 @@ def path_to_filesystem(path): Conversion is done in a secure manner, or raises ``ValueError``. """ - sane_path = ical.sanitize_path(path).strip("/") + sane_path = sanitize_path(path).strip("/") safe_path = FOLDER if not sane_path: return safe_path @@ -113,8 +162,185 @@ def _open(path, mode="r"): yield fd -class Collection(ical.Collection): +class Item(object): + """Internal iCal item.""" + def __init__(self, text, name=None): + """Initialize object from ``text`` and different ``kwargs``.""" + self.component = vobject.readOne(text) + self._name = name + + if not self.component.name: + # Header + self._name = next(self.component.lines()).name.lower() + return + + # We must synchronize the name in the text and in the object. + # An item must have a name, determined in order by: + # + # - the ``name`` parameter + # - the ``X-RADICALE-NAME`` iCal property (for Events, Todos, Journals) + # - the ``UID`` iCal property (for Events, Todos, Journals) + # - the ``TZID`` iCal property (for Timezones) + if not self._name: + for line in self.component.lines(): + if line.name in ("X-RADICALE-NAME", "UID", "TZID"): + self._name = line.value + if line.name == "X-RADICALE-NAME": + break + + if self._name: + self._name = clean_name(self._name) + else: + self._name = uuid4().hex + + if not hasattr(self.component, "x_radicale_name"): + self.component.add("X-RADICALE-NAME") + self.component.x_radicale_name.value = self._name + + def __hash__(self): + return hash(self.text) + + def __eq__(self, item): + return isinstance(item, Item) and self.text == item.text + + @property + def etag(self): + """Item etag. + + Etag is mainly used to know if an item has changed. + + """ + md5 = hashlib.md5() + md5.update(self.text.encode("utf-8")) + return '"%s"' % md5.hexdigest() + + @property + def name(self): + """Item name. + + Name is mainly used to give an URL to the item. + + """ + return self._name + + @property + def text(self): + """Item serialized text.""" + return self.component.serialize() + + +class Header(Item): + """Internal header class.""" + + +class Timezone(Item): + """Internal timezone class.""" + tag = "VTIMEZONE" + + +class Component(Item): + """Internal main component of a collection.""" + + +class Event(Component): + """Internal event class.""" + tag = "VEVENT" + mimetype = "text/calendar" + + +class Todo(Component): + """Internal todo class.""" + tag = "VTODO" # pylint: disable=W0511 + mimetype = "text/calendar" + + +class Journal(Component): + """Internal journal class.""" + tag = "VJOURNAL" + mimetype = "text/calendar" + + +class Card(Component): + """Internal card class.""" + tag = "VCARD" + mimetype = "text/vcard" + + +class Collection: """Collection stored in several files per calendar.""" + def __init__(self, path, principal=False): + """Initialize the collection. + + ``path`` must be the normalized relative path of the collection, using + the slash as the folder delimiter, with no leading nor trailing slash. + + """ + self.encoding = "utf-8" + # path should already be sanitized + self.path = sanitize_path(path).strip("/") + split_path = self.path.split("/") + if principal and split_path and self.is_node(self.path): + # Already existing principal collection + self.owner = split_path[0] + elif len(split_path) > 1: + # URL with at least one folder + self.owner = split_path[0] + else: + self.owner = None + self.is_principal = principal + self._items = None + + @classmethod + def from_path(cls, path, depth="1", include_container=True): + """Return a list of collections and items under the given ``path``. + + If ``depth`` is "0", only the actual object under ``path`` is + returned. + + If ``depth`` is anything but "0", it is considered as "1" and direct + children are included in the result. If ``include_container`` is + ``True`` (the default), the containing object is included in the + result. + + The ``path`` is relative. + + """ + # path == None means wrong URL + if path is None: + return [] + + # path should already be sanitized + sane_path = sanitize_path(path).strip("/") + attributes = sane_path.split("/") + if not attributes: + return [] + + # Try to guess if the path leads to a collection or an item + if cls.is_leaf("/".join(attributes[:-1])): + attributes.pop() + + result = [] + path = "/".join(attributes) + + principal = len(attributes) <= 1 + if cls.is_node(path): + if depth == "0": + result.append(cls(path, principal)) + else: + if include_container: + result.append(cls(path, principal)) + for child in cls.children(path): + result.append(child) + else: + if depth == "0": + result.append(cls(path)) + else: + collection = cls(path, principal) + if include_container: + result.append(collection) + result.extend(collection.components) + return result + @property def _filesystem_path(self): """Absolute path of the file at local ``path``.""" @@ -132,12 +358,48 @@ class Collection(ical.Collection): def set_mimetype(self, mimetype): self._create_dirs() - return super().set_mimetype(mimetype) + with self.props as props: + if "tag" not in props: + if mimetype == "text/vcard": + props["tag"] = "VADDRESSBOOK" + else: + props["tag"] = "VCALENDAR" + + @property + def exists(self): + """``True`` if the collection exists on the storage, else ``False``.""" + return self.is_node(self.path) or self.is_leaf(self.path) + + @staticmethod + def _parse(text, item_types, name=None): + """Find items with type in ``item_types`` in ``text``. + + If ``name`` is given, give this name to new items in ``text``. + + Return a dict of items. + + """ + item_tags = {item_type.tag: item_type for item_type in item_types} + items = {} + root = next(vobject.readComponents(text)) + components = ( + root.components() if root.name in ("VADDRESSBOOK", "VCALENDAR") + else (root,)) + for component in components: + item_name = None if component.name == "VTIMEZONE" else name + item_type = item_tags[component.name] + item = item_type(component.serialize(), item_name) + if item.name in items: + text = "\r\n".join((item.text, items[item.name].text)) + items[item.name] = item_type(text, item.name) + else: + items[item.name] = item + + return items def save(self, text): self._create_dirs() - item_types = ( - ical.Timezone, ical.Event, ical.Todo, ical.Journal, ical.Card) + item_types = (Timezone, Event, Todo, Journal, Card) for name, component in self._parse(text, item_types).items(): if not is_safe_filesystem_path_component(name): log.LOGGER.debug( @@ -151,8 +413,8 @@ class Collection(ical.Collection): @property def headers(self): return ( - ical.Header("PRODID:-//Radicale//NONSGML Radicale Server//EN"), - ical.Header("VERSION:%s" % self.version)) + Header("PRODID:-//Radicale//NONSGML Radicale Server//EN"), + Header("VERSION:%s" % self.version)) def delete(self): shutil.rmtree(self._filesystem_path) @@ -172,8 +434,7 @@ class Collection(ical.Collection): @property def text(self): - components = ( - ical.Timezone, ical.Event, ical.Todo, ical.Journal, ical.Card) + components = (Timezone, Event, Todo, Journal, Card) items = {} try: filenames = os.listdir(self._filesystem_path) @@ -192,7 +453,7 @@ class Collection(ical.Collection): log.LOGGER.warning( "Error while reading item %r: %r" % (path, e)) - return ical.serialize( + return serialize( self.tag, self.headers, sorted(items.values(), key=lambda x: x.name)) @classmethod @@ -244,3 +505,117 @@ class Collection(ical.Collection): if old_properties != properties: with open(self._props_path, "w") as prop_file: json.dump(properties, prop_file) + + def append(self, name, text): + """Append items from ``text`` to collection. + + If ``name`` is given, give this name to new items in ``text``. + + """ + new_items = self._parse( + text, (Timezone, Event, Todo, Journal, Card), name) + for new_item in new_items.values(): + if new_item.name not in self.items: + self.items[new_item.name] = new_item + self.write() + + def replace(self, name, text): + """Replace content by ``text`` in collection objet called ``name``.""" + self.remove(name) + self.append(name, text) + + def write(self): + """Write collection with given parameters.""" + text = serialize(self.tag, self.headers, self.items.values()) + self.save(text) + + @property + def tag(self): + """Type of the collection.""" + with self.props as props: + if "tag" not in props: + try: + tag = open(self.path).readlines()[0][6:].rstrip() + except IOError: + if self.path.endswith((".vcf", "/carddav")): + props["tag"] = "VADDRESSBOOK" + else: + props["tag"] = "VCALENDAR" + else: + if tag in ("VADDRESSBOOK", "VCARD"): + props["tag"] = "VADDRESSBOOK" + else: + props["tag"] = "VCALENDAR" + return props["tag"] + + @property + def mimetype(self): + """Mimetype of the collection.""" + if self.tag == "VADDRESSBOOK": + return "text/vcard" + elif self.tag == "VCALENDAR": + return "text/calendar" + + @property + def resource_type(self): + """Resource type of the collection.""" + if self.tag == "VADDRESSBOOK": + return "addressbook" + elif self.tag == "VCALENDAR": + return "calendar" + + @property + def etag(self): + """Etag from collection.""" + md5 = hashlib.md5() + md5.update(self.text.encode("utf-8")) + return '"%s"' % md5.hexdigest() + + @property + def name(self): + """Collection name.""" + with self.props as props: + return props.get("D:displayname", self.path.split(os.path.sep)[-1]) + + @property + def color(self): + """Collection color.""" + with self.props as props: + if "ICAL:calendar-color" not in props: + props["ICAL:calendar-color"] = "#%x" % randint(0, 255 ** 3 - 1) + return props["ICAL:calendar-color"] + + @property + def items(self): + """Get list of all items in collection.""" + if self._items is None: + self._items = self._parse( + self.text, (Event, Todo, Journal, Card, Timezone)) + return self._items + + @property + def timezones(self): + """Get list of all timezones in collection.""" + return [ + item for item in self.items.values() if item.tag == Timezone.tag] + + @property + def components(self): + """Get list of all components in collection.""" + tags = [item_type.tag for item_type in (Event, Todo, Journal, Card)] + return [item for item in self.items.values() if item.tag in tags] + + @property + def owner_url(self): + """Get the collection URL according to its owner.""" + return "/%s/" % self.owner if self.owner else None + + @property + def url(self): + """Get the standard collection URL.""" + return "%s/" % self.path + + @property + def version(self): + """Get the version of the collection type.""" + return "3.0" if self.tag == "VADDRESSBOOK" else "2.0" diff --git a/radicale/xmlutils.py b/radicale/xmlutils.py index 72e555f..d7c5dd4 100644 --- a/radicale/xmlutils.py +++ b/radicale/xmlutils.py @@ -30,7 +30,7 @@ import xml.etree.ElementTree as ET from collections import OrderedDict from urllib.parse import unquote, urlparse -from . import client, config, ical +from . import client, config, storage NAMESPACES = { @@ -228,7 +228,7 @@ def propfind(path, xml_request, read_collections, write_collections, user=None): def _propfind_response(path, item, props, user, write=False): """Build and return a PROPFIND response.""" - is_collection = isinstance(item, ical.Collection) + is_collection = isinstance(item, storage.Collection) if is_collection: is_leaf = item.is_leaf(item.path) with item.props as properties: @@ -329,7 +329,7 @@ def _propfind_response(path, item, props, user, write=False): elif tag == _tag("CS", "getctag"): element.text = item.etag elif tag == _tag("C", "calendar-timezone"): - element.text = ical.serialize( + element.text = storage.serialize( item.tag, item.headers, item.timezones) elif tag == _tag("D", "displayname"): element.text = item.name @@ -530,8 +530,8 @@ def report(path, xml_request, collection): found_props.append(element) elif tag in (_tag("C", "calendar-data"), _tag("CR", "address-data")): - if isinstance(item, ical.Component): - element.text = ical.serialize( + if isinstance(item, storage.Component): + element.text = storage.serialize( collection_tag, collection_headers, collection_timezones + [item]) found_props.append(element)