add 'delete etherpad cookie', optimize the 'checkPadExists' function

fet2020/authentications/views.py

@@ -5,6 +5,7 @@ from django.contrib.auth.models import User
 
 from .authentications import authentication
 from .decorators import unauthenticated_user, authenticated_user
+from documents.etherpadlib import del_ep_cookie
 
 
 @unauthenticated_user
@@ -33,4 +34,8 @@ def loginPage(request):
 @authenticated_user
 def logoutUser(request):
     logout(request)
-    return redirect('home')
+
+    response = redirect('home')
+    response = del_ep_cookie(request, response)
+
+    return response

fet2020/documents/__init__.py

@@ -1,19 +0,0 @@
-# from etherpad_lite import EtherpadLiteClient
-# from django.conf import settings
-from datetime import datetime, timedelta
-# from django.utils.text import slugify
-import urllib.parse
-from django.conf import settings
-# import os
-from .api import ep
-# from .etherpadlib import get_ep_sessionid2, add_ep_cookie
-SERVER_URL = settings.ETHERPAD_CLIENT["exturl"]
-t = datetime.now() + timedelta(days=1)
-
-
-def get_pad_link(padID):
-    if padID is None:
-        return "#"
-    if ep.get_epc():
-        return urllib.parse.urljoin(SERVER_URL, 'p/' + ep.group["groupID"] + '$' + str(padID))
-    return ""

fet2020/documents/api.py

@@ -1,93 +1,93 @@
 from django.conf import settings
+
 import os
 import urllib.parse
 
-from datetime import datetime, timedelta
 from etherpad_lite import EtherpadLiteClient, EtherpadException
 
+SERVER_URL = settings.ETHERPAD_CLIENT["exturl"]
 
-class ep_api():
-    def __init__(self):
-        self.group = None
-        self.epc = None
-        return
 
-    def load(self):
+def get_ep_client():
-        try:
+    epc = None
-            with open(os.path.abspath(settings.ETHERPAD_CLIENT["apikey"]), "r") as f:
+    group = None
-                k = f.read()
-                epc = EtherpadLiteClient(
-                    base_params={'apikey': k, },
-                    base_url=urllib.parse.urljoin(settings.ETHERPAD_CLIENT["url"], "api")
-                )
-                g = epc.createGroupIfNotExistsFor(groupMapper="fet")
-                self.group = g
-                self.epc = epc
-        except Exception as e:
-            raise e
-            self.group = None
-            self.epc = None
 
-    def getPadHTML(self, padID):
+    try:
-        self.get_epc()
+        with open(os.path.abspath(settings.ETHERPAD_CLIENT["apikey"]), "r") as f:
-        text = self.epc.getHTML(padID=self.group["groupID"] + "$" + padID)["html"]
+            apikey = f.read()
-        return text
+            epc = EtherpadLiteClient(
-
+                base_params={'apikey': apikey, },
-    def setPadHTML(self, padID, html):
+                base_url=urllib.parse.urljoin(settings.ETHERPAD_CLIENT["url"], "api"),
-        self.get_epc()
+                api_version='1.2.14',
-        self.epc.setHTML(padID=self.group["groupID"] + "$" + padID, html=html)
-        return html
-
-    def checkPadExists(self, padID=None):
-        print(self.epc.listPads(groupID=self.group["groupID"]))
-        if not padID:
-            return False
-        try:
-            self.epc.getRevisionsCount(padID=self.group["groupID"] + "$" + padID)
-        except EtherpadException as e:
-            print(e)
-            return False
-        return True
-
-    def createPadifNotExists(self, padid):
-        self.get_epc()
-        if not self.epc:
-            return None
-        if not self.checkPadExists(padID=padid):  # Pad doesn't exist
-            self.epc.createGroupPad(groupID=self.group["groupID"], padName=padid, text="helloworld")
-        return padid
-
-    def get_epc(self):
-        if self.epc:
-            return self.epc
-        self.load()
-        return self.epc
-
-    def get_ep_sessionid2(self, request):
-        if request.user is None:
-            return None, None
-        if not request.user.is_authenticated:
-            return None, None
-    # server = SERVER_URL
-        ep.get_epc()
-        author = self.epc.createAuthorIfNotExistsFor(
-            name=str(request.user),
-            authorMapper=str(request.user)
-        )['authorID']
-        expires = datetime.utcnow() + timedelta(
-            hours=3
-        )
-        try:
-            result = self.epc.createSession(
-                groupID=str(self.group['groupID']),
-                authorID=str(author),
-                validUntil=str(int(expires.timestamp()))
             )
+        group = epc.createGroupIfNotExistsFor(groupMapper="fet")
+    except Exception as e:
+        raise e
+
+    return epc, group
+
+
+def __checkPadExists(padID=None):
+    if not padID:
+        return False
+
+    epc, group = get_ep_client()
+    if not epc:
+        return None
+
+    try:
+        lists = epc.listAllPads()
+    except Exception as e:
+        raise e
+    else:
+        string = group["groupID"] + "$" + str(padID)
+        if string in lists["padIDs"]:
+            return True
+
+    return False
+
+
+def createPadifNotExists(padID):
+    epc, group = get_ep_client()
+    if not epc:
+        return None
+
+    # Pad doesn't exist
+    if not __checkPadExists(padID=padID):
+        try:
+            epc.createGroupPad(groupID=group["groupID"], padName=padID, text="helloworld")
+        except EtherpadException as e:
+            # TODO: change it after Etherpad server is a better one than that because of http 500
+            print(e)
         except Exception as e:
             raise e
-            return None, None
+    return padID
-
-        return result['sessionID'], expires
 
 
-ep = ep_api()
+def getReadOnlyID(padID):
+    epc, group = get_ep_client()
+    url = epc.getReadOnlyID(padID=group["groupID"] + "$" + padID)['readOnlyID']
+    return url
+
+
+def getPadHTML(padID):
+    epc, group = get_ep_client()
+    text = epc.getHTML(padID=group["groupID"] + "$" + padID)["html"]
+    return text
+
+
+def setPadHTML(padID, html):
+    epc, group = get_ep_client()
+    epc.setHTML(padID=group["groupID"] + "$" + padID, html=html)
+    return html
+
+
+def get_pad_link(padID):
+    if padID is None:
+        return "#"
+
+    epc, group = get_ep_client()
+
+    if epc:
+        return urllib.parse.urljoin(SERVER_URL, 'p/' + group["groupID"] + '$' + str(padID))
+    return ""

fet2020/documents/etherpadlib.py

@@ -1,36 +1,59 @@
-# from etherpad_lite import EtherpadLiteClient
+from datetime import datetime, timedelta
 
-# from datetime import datetime, timedelta
+from .api import get_ep_client
-# from django.utils.text import slugify
+from authentications.decorators import authenticated_user
-# import urllib.parse
+
-# from django.conf import settings
+
-from .api import ep
+@authenticated_user
+def __get_ep_sessionid(request):
+    epc, group = get_ep_client()
+
+    author = epc.createAuthorIfNotExistsFor(
+        name=str(request.user),
+        authorMapper=str(request.user)
+    )['authorID']
+
+    expires = datetime.utcnow() + timedelta(hours=3)
+    try:
+        result = epc.createSession(
+            groupID=str(group['groupID']),
+            authorID=str(author),
+            validUntil=str(int(expires.timestamp()))
+        )
+    except Exception as e:
+        raise e
+        return None, None
+
+    return result['sessionID'], expires
 
 
 def add_ep_cookie(request, response):
-    response.set_cookie("HILib", "TestWert", domain="https://andis.2020.fet.at")
+    ep_sessid, expires = __get_ep_sessionid(request)
-    ep_sessid, expires = ep.get_ep_sessionid2(request)
+
-    if ep_sessid is None:
+    if ep_sessid:
         response.set_cookie(
             "sessionID",
-            "NOTAUTHENTICATED",
+            ep_sessid,
             expires=expires,
             domain=".2020.fet.at",
-            path="/",
+            path="/"
         )
-        return response
+
-    response.set_cookie(
+    return response
-        "sessionID",
+
-        ep_sessid,
+
-        expires=expires,
+def del_ep_cookie(request, response):
-        domain=".2020.fet.at",
+
-        path="/"
+    if 'sessionID' in request.COOKIES:
-    )
+        ep_sessionID = request.COOKIES['sessionID']
-    response.set_cookie(
+
-        "sessionID",
+        epc, group = get_ep_client()
-        ep_sessid,
+        epc.deleteSession(sessionID=ep_sessionID)
-        expires=expires,
+
-        domain=".2020.fet.at",
+        response.delete_cookie(
-        path="/p"
+            "sessionID",
-    )
+            domain=".2020.fet.at",
+            path="/"
+        )
+
     return response

fet2020/posts/models.py

@@ -6,7 +6,7 @@ from django.utils import timezone
 from django.utils.text import slugify
 from django.utils.translation import gettext_lazy as _
 from taggit.managers import TaggableManager
-from documents import ep
+from documents.api import getPadHTML, setPadHTML, createPadifNotExists
 
 from .managers import (
     PostManager, ArticleManager, NewsManager, AllEventManager, EventManager, FetMeetingManager
@@ -102,13 +102,14 @@ class Post(models.Model):
     def agenda_html(self):
         if not self.agenda_key:
             return None
-        h = ep.getPadHTML(self.agenda_key)
+
-        return h
+        html = getPadHTML(self.agenda_key)
+        return html
 
     @agenda_html.setter
     def agenda_html(self, value):
         request_logger.info("Accessing etherpad ...")
-        ep.setPadHTML(self.agenda_key, value)
+        setPadHTML(self.agenda_key, value)
         request_logger.info("set etherpad!")
         return value
 
@@ -259,7 +260,7 @@ class FetMeeting(Event):
 
     def __get_agenda_key(self):
         try:
-            self.agenda_key = ep.createPadifNotExists(self.slug + "-agenda")
+            self.agenda_key = createPadifNotExists(self.slug + "-agenda")
         except Exception as e:
             raise ValidationError(
                 _('Die Agenda konnte nicht erstellt werden. Error: %(error)s'),
@@ -268,7 +269,7 @@ class FetMeeting(Event):
 
     def __get_protocol_key(self):
         try:
-            self.protocol_key = ep.createPadifNotExists(self.slug + "-protocol")
+            self.protocol_key = createPadifNotExists(self.slug + "-protocol")
         except Exception as e:
             raise ValidationError(
                 _('Das Protokoll konnte nicht erstellt werden. Error: %(error)s'),

fet2020/posts/views.py

@@ -9,7 +9,7 @@ from rest_framework import viewsets
 from taggit.models import Tag
 
 from .models import Post, PostSerializer, FetMeeting
-from documents import get_pad_link
+from documents.api import get_pad_link
 from documents.etherpadlib import add_ep_cookie
 from members.models import Member, JobMember