rework etherpad functions

fet2020/documents/__init__.py

@@ -1 +0,0 @@
-from .api import create_pad, get_pad_html, set_pad_html

fet2020/documents/api.py

@@ -1,6 +1,5 @@
 import logging
 import os
-from contextlib import contextmanager
 from urllib.parse import urljoin
 
 from django.conf import settings
@@ -9,115 +8,144 @@ from etherpad_lite import EtherpadException, EtherpadLiteClient
 logger = logging.getLogger(__name__)
 
 
-@contextmanager
+def get_ep_client():
-def ignore_ep_exception(msg="", *exceptions):
+    api_key = ""
+    ep_c = None
+
+    # get api key from settings
+    with open(os.path.abspath(settings.ETHERPAD_CLIENT["apikey"]), "r") as f:
+        api_key = f.read()
+        api_key = api_key.rstrip()
+
+    if api_key == "":
+        return None
+
+    # Connection to Etherpad Client
     try:
-        yield
+        ep_c = EtherpadLiteClient(
-    except exceptions as e:
+            base_params={
-        logger.error(msg)
+                "apikey": api_key,
-        logger.error("%s", e)
+            },
+            base_url=urljoin(settings.ETHERPAD_CLIENT["url"], "api"),
+            api_version="1.2.14",
+        )
+    except EtherpadException as e:
+        logger.info("Connection to Etherpad Client failed. Error: %s", e)
+        return None
+
+    return ep_c
 
 
-def get_ep_client(groupName="fet"):
+def get_ep_group(ep_group_name="fet"):
-    epc = None
+    ep_group = None
-    group = None
 
-    with ignore_ep_exception("Error connecting to Etherpad", Exception):
+    ep_c = get_ep_client()
-        with open(os.path.abspath(settings.ETHERPAD_CLIENT["apikey"]), "r") as f:
+    if ep_c is None:
-            apikey = f.read()
+        return None
-            apikey = apikey.rstrip()
-            epc = EtherpadLiteClient(
-                base_params={
-                    "apikey": apikey,
-                },
-                base_url=urljoin(settings.ETHERPAD_CLIENT["url"], "api"),
-                api_version="1.2.14",
-            )
 
-        if settings.ETHERPAD_CLIENT["group"] == "":
+    if settings.ETHERPAD_CLIENT["group"] == "":
-            group = epc.createGroupIfNotExistsFor(groupMapper=groupName)
+        ep_group = ep_c.createGroupIfNotExistsFor(groupMapper=ep_group_name)
-        else:
-            group = {"groupID": settings.ETHERPAD_CLIENT["group"]}
-
-    return epc, group
-
-
-@contextmanager
-def ep_client(groupName="fet"):
-    epc, group = get_ep_client(groupName)
-    if not epc or not group:
-        yield None, None
     else:
-        with ignore_ep_exception("EtherpadException!!", EtherpadException):
+        ep_group = {"groupID": settings.ETHERPAD_CLIENT["group"]}
-            yield epc, group
+
+    return ep_group
 
 
-def __pad_exists(padID=None):
+def ep_pad_exists(pad_id=None):
-    if not padID:
+    if pad_id is None:
-        return False
+        return None
 
-    with ep_client() as (epc, group):
+    ep_c = get_ep_client()
-        if not epc or not group:
+    if ep_c is None:
-            return None
+        return None
 
-        lists = epc.listPads(groupID=group["groupID"])
+    ep_group = get_ep_group()
-        if any(str(padID) in s for s in lists["padIDs"]):
+    if ep_group is None:
-            logger.info("Pad '%s' existiert.", padID)
+        return None
-            return True
 
-    logger.info("Pad '%s' existiert nicht.", padID)
+    lists = ep_c.listPads(groupID=ep_group["groupID"])
+    if any(str(pad_id) in s for s in lists["padIDs"]):
+        logger.info("Etherpad '%s' existiert.", pad_id)
+        return True
+
+    logger.info("Etherpad '%s' existiert nicht.", pad_id)
     return False
 
 
-def create_pad(padID, text="helloworld"):
+def ep_create_new_pad(pad_id, text="helloworld"):
     """
     Create a pad if it doesn't exist.
 
-    Return a padID if new pad is created. Otherwise None (when the padID exists already).
+    Return a pad_id if new pad is created. Otherwise None (when the padID exists already).
     """
-    if not __pad_exists(padID=padID):
+    if pad_id is None:
-        with ep_client() as (epc, group):
-            if not epc or not group:
-                return None
-
-            epc.createGroupPad(groupID=group["groupID"], padName=padID, text=text)
-            logger.info("neues Pad erzeugt: %s", padID)
-
-        return padID
-    if __pad_exists(padID=padID):
-        return padID
-    else:
-        raise Exception("Tried to create pad but failed!")
-
-
-def get_pad_html(padID):
-    text = None
-    with ep_client() as (epc, group):
-        if not epc or not group:
-            return None
-
-        text = epc.getHTML(padID=group["groupID"] + "$" + padID)["html"]
-    return text
-
-
-def set_pad_html(padID, html):
-    epc, group = get_ep_client()
-    if not epc or not group:
         return None
 
-    epc.setHTML(padID=group["groupID"] + "$" + padID, html=html)
+    ep_c = get_ep_client()
-    return html
+    if ep_c is None:
+        return None
+
+    ep_group = get_ep_group()
+    if ep_group is None:
+        return None
+
+    pad_id_status = ep_pad_exists(pad_id)
+    print(f"Status: {pad_id_status}")
+    if pad_id_status is None:
+        return None
+    elif pad_id_status is True:
+        return None
+    else:
+        ep_c.createGroupPad(groupID=ep_group["groupID"], padName=pad_id, text=text)
+        logger.info("Neues Etherpad '%s' erzeugt.", pad_id)
+
+    return pad_id
 
 
-def get_pad_link(padID):
+def ep_get_html(pad_id):
-    if not padID:
+    ep_c = get_ep_client()
-        return "#"
+    if ep_c is None:
+        return None
 
-    with ep_client() as (epc, group):
+    ep_group = get_ep_group()
-        if not epc or not group:
+    if ep_group is None:
-            return "#"
+        return None
 
+    if ep_pad_exists(pad_id):
+        return ep_c.getHTML(padID=ep_group["groupID"] + "$" + pad_id)["html"]
+
+    return ""
+
+
+def ep_set_html(pad_id, html):
+    ep_c = get_ep_client()
+    if ep_c is None:
+        return None
+
+    ep_group = get_ep_group()
+    if ep_group is None:
+        return None
+
+    if ep_pad_exists(pad_id):
+        ep_c.setHTML(padID=ep_group["groupID"] + "$" + pad_id, html=html)
+        return True
+
+    return None
+
+
+def ep_get_url(pad_id):
+    ep_c = get_ep_client()
+    if ep_c is None:
+        return None
+
+    ep_group = get_ep_group()
+    if ep_group is None:
+        return None
+
+    if ep_pad_exists(pad_id):
         return urljoin(
             settings.ETHERPAD_CLIENT["exturl"],
-            "p/" + group["groupID"] + "$" + str(padID),
+            "p/" + ep_group["groupID"] + "$" + str(pad_id),
         )
+
+    return "#"

fet2020/documents/etherpadlib.py

@@ -5,49 +5,57 @@ from django.utils import timezone
 
 from authentications.decorators import ep_authenticated_user
 
-from .api import get_ep_client
+from .api import get_ep_client, get_ep_group
 
 
 @ep_authenticated_user
-def __get_ep_sessionid(request):
+def _create_ep_session(request, expires):
-    epc, group = get_ep_client()
+    ep_c = get_ep_client()
-    if not epc or not group:
+    if ep_c is None:
+        return None
+
+    ep_group = get_ep_group()
+    if ep_group is None:
         return None, None
 
-    author = epc.createAuthorIfNotExistsFor(
+    author = ep_c.createAuthorIfNotExistsFor(
         name=str(request.user), authorMapper=str(request.user)
     )
-    expires = timezone.now() + timedelta(hours=3)
 
     try:
-        result = epc.createSession(
+        result = ep_c.createSession(
-            groupID=str(group["groupID"]),
+            groupID=str(ep_group["groupID"]),
             authorID=str(author["authorID"]),
             validUntil=str(int(expires.timestamp())),
         )
     except Exception as e:
         raise e
 
-    return result["sessionID"], expires
+    return result["sessionID"]
 
 
 def add_ep_cookie(request, response):
-    ep_sessid, expires = __get_ep_sessionid(request)
+    expires = timezone.now() + timedelta(hours=3)
 
-    if ep_sessid:
+    ep_session = _create_ep_session(request, expires)
+    if ep_session:
         response.set_cookie(
-            "sessionID", ep_sessid, expires=expires, domain=settings.HOST_NAME, path="/"
+            "sessionID",
+            ep_session,
+            expires=expires,
+            domain=settings.HOST_NAME,
+            path="/",
         )
-        response.set_cookie("sessionID", ep_sessid, expires=expires, path="/etherpad")
+        response.set_cookie("sessionID", ep_session, expires=expires, path="/etherpad")
+
     return response
 
 
 def del_ep_cookie(request, response):
     if "sessionID" in request.COOKIES:
-        ep_sessionID = request.COOKIES["sessionID"]
+        ep_c = get_ep_client()
-
+        ep_c.deleteSession(sessionID=request.COOKIES["sessionID"])
-        epc, group = get_ep_client()
-        epc.deleteSession(sessionID=ep_sessionID)
 
         response.delete_cookie("sessionID", domain=settings.HOST_NAME, path="/")
+
     return response

fet2020/intern/models.py

@@ -8,8 +8,7 @@ from django.db.models.constraints import UniqueConstraint
 from django.urls import reverse
 from django.utils.text import slugify
 
-from documents import create_pad, get_pad_html
+from documents.api import ep_create_new_pad, ep_get_html, ep_get_url
-from documents.api import get_pad_link
 from fet2020.utils import create_random_id
 
 logger = logging.getLogger(__name__)
@@ -152,7 +151,7 @@ class Etherpad(models.Model):
         return self.title
 
     def get_absolute_url(self):
-        return get_pad_link(self.etherpad_key)
+        return ep_get_url(self.etherpad_key)
 
     def clean(self):
         pad_name = slugify(str(self.slug_id) + "-" + self.title[:40])
@@ -165,17 +164,17 @@ class Etherpad(models.Model):
                 params={"length": len(pad_name), "pad_name": pad_name},
             )
 
-        if self.etherpad_key is None:
+        if self.etherpad_key == "":
-            self.etherpad_key = create_pad(pad_name)
+            if ep_create_new_pad(pad_name):
-
+                self.etherpad_key = pad_name
-        if self.etherpad_key is None:
+            else:
-            raise ValidationError(
+                raise ValidationError(
-                f"Etherpad '{pad_name}' konnte nicht erstellt werden. This should never happen!"
+                    f"Etherpad '{pad_name}' konnte nicht erstellt werden. This should never happen!"
-            )
+                )
 
     @property
     def etherpad_html(self):
-        return get_pad_html(self.etherpad_key)
+        return ep_get_html(self.etherpad_key)
 
     def get_model_name(self):
         return self._meta.model_name

fet2020/posts/admin.py

@@ -1,6 +1,6 @@
 from django.contrib import admin, messages
 
-from documents.api import create_pad
+from documents.api import ep_create_new_pad
 
 from .forms import EventForm, FetMeetingForm, NewsForm, PostForm
 from .models import Event, FetMeeting, FileUpload, News, Post
@@ -10,7 +10,7 @@ from .models import Event, FetMeeting, FileUpload, News, Post
 def make_fetmeeting(self, request, queryset):
     qs = self.get_queryset(request).filter(id=request.POST["_selected_action"]).first()
 
-    agenda_key = create_pad(qs.slug + "-agenda")
+    agenda_key = ep_create_new_pad(qs.slug + "-agenda")
     if not agenda_key:
         self.message_user(
             request,
@@ -19,7 +19,7 @@ def make_fetmeeting(self, request, queryset):
         )
         return
 
-    protocol_key = create_pad(qs.slug + "-protocol")
+    protocol_key = ep_create_new_pad(qs.slug + "-protocol")
     if not protocol_key:
         self.message_user(
             request,

fet2020/posts/models.py

@@ -12,8 +12,7 @@ from django.utils.translation import gettext_lazy as _
 from taggit.managers import TaggableManager
 
 from core.models import CustomFlatPage
-from documents import create_pad, get_pad_html, set_pad_html
+from documents.api import ep_create_new_pad, ep_get_html, ep_get_url, ep_set_html
-from documents.api import get_pad_link
 
 from .managers import (
     AllEventManager,
@@ -35,18 +34,18 @@ def create_pad_for_post(slug, item="agenda"):
     Return a Etherpad key.
     """
     logger.info(f"Pad-Type: {item}")
-    padID = create_pad(slug + "-" + item)
+
-    if padID:
+    pad_id = slug + "-" + item
+    if ep_create_new_pad(pad_id):
         # set template into the newly created pad if it exists
         page = CustomFlatPage.objects.filter(title__iexact=item).first()
         if page:
-            set_pad_html(padID, page.content)
+            ep_set_html(pad_id, page.content)
             logger.info(f"Template gesetzt von: {page.title}")
-    else:
-        padID = f"{slug}-{item}"
 
-    logger.info(f"PadID: {padID}")
+        return pad_id
-    return padID
+
+    return "#"
 
 
 class Category(models.Model):
@@ -154,7 +153,7 @@ class Post(models.Model):
         if not self.agenda_key:
             return None
 
-        return get_pad_html(self.agenda_key)
+        return ep_get_html(self.agenda_key)
 
     @property
     def protocol_html(self):
@@ -162,7 +161,7 @@ class Post(models.Model):
         if not self.protocol_key:
             return None
 
-        return get_pad_html(self.protocol_key)
+        return ep_get_html(self.protocol_key)
 
     @agenda_html.setter
     def agenda_html(self, value):
@@ -171,7 +170,7 @@ class Post(models.Model):
         if not value or not self.agenda_key:
             return None
 
-        set_pad_html(self.agenda_key, value)
+        ep_set_html(self.agenda_key, value)
 
         request_logger.info(
             "set etherpad for post %s id: %s", self.slug, self.agenda_key
@@ -185,7 +184,7 @@ class Post(models.Model):
         if not value or not self.protocol_key:
             return None
 
-        set_pad_html(self.protocol_key, value)
+        ep_set_html(self.protocol_key, value)
 
         request_logger.info(
             "set etherpad for post %s id: %s", self.slug, self.protocol_key
@@ -194,19 +193,18 @@ class Post(models.Model):
 
     @property
     def agenda_link(self):
-        agenda_link = "#"
         if self.has_agenda:
-            agenda_link = get_pad_link(self.agenda_key)
+            print(f"Has Agenda Key: {self.agenda_key}")
+            return ep_get_url(self.agenda_key)
 
-        return agenda_link
+        return "#"
 
     @property
     def protocol_link(self):
-        protocol_link = "#"
         if self.has_protocol:
-            protocol_link = get_pad_link(self.protocol_key)
+            return ep_get_url(self.protocol_key)
 
-        return protocol_link
+        return "#"
 
     @property
     def filename_agenda(self):