add proxy for the first part and try to develop the second part

2025-12-03 12:08:56 +00:00
parent 6c34d510e5
commit 460f18d85a
1095 changed files with 358799 additions and 5 deletions
@@ -0,0 +1,92 @@
+import warnings
+from typing import Dict, List
+
+from ics.grammar.parse import ContentLine
+from ics.parsers.attendee_parser import AttendeeParser, PersonParser
+from ics.serializers.attendee_serializer import AttendeeSerializer, PersonSerializer
+from ics.utils import escape_string, unescape_string
+
+
+class Person(object):
+    class Meta:
+        name = "ABSTRACT-PERSON"
+        parser = PersonParser
+        serializer = PersonSerializer
+
+    def __init__(self, email: str, common_name: str = None, dir: str = None, sent_by: str = None) -> None:
+        self.email = email
+        self.common_name = common_name or email
+        self.dir = dir
+        self.sent_by = sent_by
+        self.extra: Dict[str, List[str]] = {}
+
+    @classmethod
+    def parse(cls, line: ContentLine) -> "Person":
+        email = unescape_string(line.value)
+        if email.lower().startswith("mailto:"):
+            email = email[len("mailto:"):]
+        val = cls(email)
+        val.populate(line)
+        return val
+
+    def populate(self, line: ContentLine) -> None:
+        if line.name != self.Meta.name:
+            raise ValueError("line isn't an {}".format(self.Meta.name))
+
+        params = dict(line.params)
+        for param_name, (parser, options) in self.Meta.parser.get_parsers().items():
+            values = params.pop(param_name, [])
+            if not values and options.required:
+                if options.default:
+                    values = options.default
+                    default_str = "\\n".join(map(str, options.default))
+                    message = ("The %s property was not found and is required by the RFC." +
+                               " A default value of \"%s\" has been used instead") % (param_name, default_str)
+                    warnings.warn(message)
+                else:
+                    raise ValueError('A {} must have at least one {}'.format(line.name, param_name))
+
+            if not options.multiple and len(values) > 1:
+                raise ValueError('A {} must have at most one {}'.format(line.name, param_name))
+
+            if options.multiple:
+                parser(self, values)  # Send a list or empty list
+            else:
+                if len(values) == 1:
+                    parser(self, values[0])  # Send the element
+                else:
+                    parser(self, None)  # Send None
+
+        self.extra = params  # Store unused lines
+
+    def serialize(self) -> ContentLine:
+        line = ContentLine(self.Meta.name, params=self.extra, value=escape_string('mailto:%s' % self.email))
+        for output in self.Meta.serializer.get_serializers():
+            output(self, line)
+        return line
+
+    def __str__(self) -> str:
+        """Returns the attendee in an ContentLine format."""
+        return str(self.serialize())
+
+
+class Organizer(Person):
+    class Meta:
+        name = 'ORGANIZER'
+        parser = PersonParser
+        serializer = PersonSerializer
+
+
+class Attendee(Person):
+    def __init__(self, email: str, common_name: str = None, dir: str = None, sent_by: str = None,
+                 rsvp: bool = None, role: str = None, partstat: str = None, cutype: str = None) -> None:
+        super().__init__(email, common_name, dir, sent_by)
+        self.rsvp = rsvp
+        self.role = role
+        self.partstat = partstat
+        self.cutype = cutype
+
+    class Meta:
+        name = 'ATTENDEE'
+        parser = AttendeeParser
+        serializer = AttendeeSerializer