bofh/fet2020
8
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

rework etherpad functions

Browse Source
This commit is contained in:
Patrick Mayr
2023-11-23 11:14:22 +00:00
parent c01d4bb4a4
commit 48f36b54f7
6 changed files with 169 additions and 137 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
fet2020/documents/__init__.py
View File

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

200
fet2020/documents/api.py
View File

@@ -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 ignore_ep_exception(msg="", *exceptions):
def get_ep_client():
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
except exceptions as e:
logger.error(msg)
logger.error("%s", e)
ep_c = EtherpadLiteClient(
base_params={
"apikey": api_key,
},
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"):
epc = None
group = None
def get_ep_group(ep_group_name="fet"):
ep_group = None
with ignore_ep_exception("Error connecting to Etherpad", Exception):
with open(os.path.abspath(settings.ETHERPAD_CLIENT["apikey"]), "r") as f:
apikey = f.read()
apikey = apikey.rstrip()
epc = EtherpadLiteClient(
base_params={
"apikey": apikey,
},
base_url=urljoin(settings.ETHERPAD_CLIENT["url"], "api"),
api_version="1.2.14",
)
ep_c = get_ep_client()
if ep_c is None:
return None
if settings.ETHERPAD_CLIENT["group"] == "":
group = epc.createGroupIfNotExistsFor(groupMapper=groupName)
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
if settings.ETHERPAD_CLIENT["group"] == "":
ep_group = ep_c.createGroupIfNotExistsFor(groupMapper=ep_group_name)
else:
with ignore_ep_exception("EtherpadException!!", EtherpadException):
yield epc, group
ep_group = {"groupID": settings.ETHERPAD_CLIENT["group"]}
return ep_group
def __pad_exists(padID=None):
if not padID:
return False
def ep_pad_exists(pad_id=None):
if pad_id is None:
return None
with ep_client() as (epc, group):
if not epc or not group:
return None
ep_c = get_ep_client()
if ep_c is None:
return None
lists = epc.listPads(groupID=group["groupID"])
if any(str(padID) in s for s in lists["padIDs"]):
logger.info("Pad '%s' existiert.", padID)
return True
ep_group = get_ep_group()
if ep_group is None:
return None
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):
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:
if pad_id is None:
return None
epc.setHTML(padID=group["groupID"] + "$" + padID, html=html)
return 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
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):
if not padID:
return "#"
def ep_get_html(pad_id):
ep_c = get_ep_client()
if ep_c is None:
return None
with ep_client() as (epc, group):
if not epc or not group:
return "#"
ep_group = get_ep_group()
if ep_group is None:
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 "#"

42
fet2020/documents/etherpadlib.py
View File

@@ -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):
epc, group = get_ep_client()
if not epc or not group:
def _create_ep_session(request, expires):
ep_c = get_ep_client()
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(
groupID=str(group["groupID"]),
result = ep_c.createSession(
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"]
epc, group = get_ep_client()
epc.deleteSession(sessionID=ep_sessionID)
ep_c = get_ep_client()
ep_c.deleteSession(sessionID=request.COOKIES["sessionID"])
response.delete_cookie("sessionID", domain=settings.HOST_NAME, path="/")
return response

21
fet2020/intern/models.py
View File

@@ -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 get_pad_link
from documents.api import ep_create_new_pad, ep_get_html, ep_get_url
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:
self.etherpad_key = create_pad(pad_name)
if self.etherpad_key is None:
raise ValidationError(
f"Etherpad '{pad_name}' konnte nicht erstellt werden. This should never happen!"
)
if self.etherpad_key == "":
if ep_create_new_pad(pad_name):
self.etherpad_key = pad_name
else:
raise ValidationError(
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

6
fet2020/posts/admin.py
View File

@@ -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,

36
fet2020/posts/models.py
View File

@@ -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 get_pad_link
from documents.api import ep_create_new_pad, ep_get_html, ep_get_url, ep_set_html
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 padID
return pad_id
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):