linkToPDF2.py

import datetime
import hashlib
import os
import smtplib
from dataclasses import dataclass
from email import encoders
from email.mime.base import MIMEBase
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from enum import Enum
from pathlib import Path
from typing import Optional, Dict, List

import requests

NOT_APPROVED_SIGN = "*"
ATTACHEMENT_SIGN = "+"
FACHGRUPPENVOLLVERSAMMLUNG_SIGN = ">"

TEMPLATE_FOLDER = "templates"
DATA_FOLDER = "data"

DEFAULT_GREMIUM = None
LDAP_USER = None
LDAP_PASSWORD = None
LDAP_MAIL = None
LDAP_NAME = None

IGNORED_TOPS = ["Anwesende", "Ständiges", "Termine", "Mitteilungen/Verschiedenes", "Schluss"]

GIT_REPO = None
GIT_REPO_PATH = None
GIT_NAME = None
GIT_EMAIL = None

GRAV_PROTOCOL_PATH = "pages/fachrat/02.protokolle/"

git = None


@dataclass
class Gremium:
    name: str
    fullName: str
    template: str

    def fullTemplate(self):
        return str(Path(os.path.join(TEMPLATE_FOLDER, self.template)).absolute())


GREMIUM_FR = Gremium("finf", "Fachrat Informatik", "pandoc.finf.tex")
GREMIUM_FSR = Gremium("fsr", "Fachschaftsrat Elektrotechnik und Informatik", "pandoc.fsr.tex")


@dataclass
class MailParticipant:
    mail: str
    alias: str = None

    def __post_init__(self):
        self.alias = self.mail

    def __str__(self):
        return f"{self.alias} <{self.mail}>"

    @staticmethod
    def FR_INFO():
        return MailParticipant("fr-info@finf.uni-hannover.de", "FR-Info")

    @staticmethod
    def FR():
        return MailParticipant("fr@finf.uni-hannover.de", "Fachrat Informatik")


# Helper Functions
def sendFRMail(text: str, subject: str, sender: MailParticipant, receivers: List[MailParticipant],
               attachement: "BasePad" = None):
    mail = MIMEMultipart()
    mail['Content-transfer-encoding'] = '8bit'
    mail['From'] = sender.alias
    mail['Subject'] = subject
    receiveralias = ", ".join([r.alias for r in receivers])
    mail['To'] = receiveralias

    msg = MIMEText(text, "plain", "utf-8")
    mail.attach(msg)
    if attachement is not None:
        payload = MIMEBase('application', 'octet-stream')
        with open(attachement.compiledPath, "rb") as d:
            payload.set_payload(d.read())
        encoders.encode_base64(payload)
        payload.add_header('Content-Disposition',
                           f"attachment; filename={attachement.displayName}")
        mail.attach(payload)

    try:
        server = smtplib.SMTP("mail.finf.uni-hannover.de", 587)
        server.starttls()
        server.login(sender.mail, LDAP_PASSWORD)
        server.sendmail(
            sender.mail, [r.mail for r in receivers], mail.as_string())
        server.quit()
        print(f"Email \"{subject}\" an {receivers} erfolgreich versendet")
    except smtplib.SMTPException:
        print(
            f"Fehler beim Senden der Email \"{subject}\" von {sender} an {receivers}")
        raise


# === Git Helper ===
class GitHelper:
    def __init__(self, repository:str, repository_path:str):
        self.repository = repository
        self.repository_path = repository_path

    def clone(self):
        cmd = f'git clone {self.repository} {self.repository_path}'
        os.system(cmd)

    def forcePull(self):
        cmd = f'git -C {self.repository_path} fetch origin master'
        os.system(cmd)
        cmd = f'git -C {self.repository_path} reset --hard origin/master'
        os.system(cmd)

    def update(self):
        if os.path.exists(self.repository_path + "/.git"):
            self.forcePull()
        else:
            self.clone()

    def push(self):
        cmd = f'git -C {self.repository_path} push origin master'
        os.system(cmd)

    def add(self, file: str):
        cmd = f'git -C {self.repository_path} add {file}'
        os.system(cmd)

    def commit(self, msg: str):
        cmd = f'git -C {self.repository_path} commit -m \"{msg}\"'
        os.system(cmd)

    def config(self, email, name):
        cmd = f'git -C {self.repository_path} config user.name {name}'
        os.system(cmd)
        cmd = f'git -C {self.repository_path} config user.email {email}'
        os.system(cmd)


class SemesterPart(Enum):
    Summer = "Sommersemester"
    Winter = "Wintersemester"

    def short(self):
        if self == SemesterPart.Summer:
            return "SS"
        return "WS"


@dataclass(unsafe_hash=True)
class Semester:
    year: int
    part: SemesterPart

    def __post_init__(self):
        self.displayName = f"{self.part.value} {self.year}"
        self.gravPath = os.path.join(GIT_REPO_PATH, GRAV_PROTOCOL_PATH,
                                     self._gravName(), "protocol_semester.de.md")

    def _gravName(self):
        return f"{self.year - 2000}{self.part.short()}"

    @classmethod
    def fromDate(cls, date: datetime.datetime) -> "Semester":
        if 4 <= date.month < 10:
            # Summer
            return Semester(date.year, SemesterPart.Summer)
        elif date.month >= 10:
            # Winter
            return Semester(date.year, SemesterPart.Winter)
        else:
            # Winter
            return Semester(date.year - 1, SemesterPart.Winter)

    def uploadToGrav(self):
        if os.path.exists(self.gravPath):
            return

        os.makedirs(str(Path(self.gravPath).parent), exist_ok=True)
        with open(self.gravPath, "w") as d:
            d.write(f"---\ntitle: {self.displayName}\n---")

        git.add(GRAV_PROTOCOL_PATH)
        git.commit(f"Added {self.part.value} {self.year}")
        git.push()


# === Source Types ===
class SourceTypes:
    def __init__(self, url: str):
        self.url: str = url

    def __repr__(self):
        return f"{self.__class__.__name__}({self.url})"

    def retrieveContent(self):
        raise NotImplementedError()


class Etherpad(SourceTypes):
    def retrieveContent(self):
        url = f"{self.url}.txt"
        response = requests.get(url)
        return response.content.decode("utf-8")


class CodiMD(SourceTypes):
    def retrieveContent(self):
        url = f"{self.url}/download"
        response = requests.get(url)
        return response.content.decode("utf-8")


class LocalCache(SourceTypes):
    def retrieveContent(self):
        with open(self.url, "r", encoding="utf-8") as d:
            return d.read()


# === Pad Types ===
class BasePad:
    def __init__(self, source: SourceTypes, *_, displayName: str = None, rawPath=None, **kwargs):
        self.source = source
        self.metadata = kwargs
        self.rawPath = rawPath or hashlib.md5(source.url.encode("utf-8"))
        self.displayName = displayName or self.DEFAULT_DISPLAY_NAME()
        self.compiledPath = None
        self.folder = ""

    def __repr__(self):
        return f"{self.__class__.__name__}({self.source})"

    def DEFAULT_DISPLAY_NAME(self):
        return self.source.url

    def DEFAULT_RAW_PATH(self):
        return os.path.join(DATA_FOLDER, "raw", f"{self.displayName}.md")

    def DEFAULT_COMPILED_PATH(self):
        return os.path.join(DATA_FOLDER, "result", f"{self.displayName}.pdf")

    def download(self, path=None, override=True):
        if path is None:
            path = self.DEFAULT_RAW_PATH()
        content = self.source.retrieveContent()
        if not override and os.path.exists(path):
            raise FileExistsError(f"{path} already exists!")
        os.makedirs(str(Path(path).parent), exist_ok=True)
        with open(path, "w", encoding="utf-8") as d:
            d.write(content)
        self.rawPath = path

    def compile(self, outFilePath: str = None, template: str = None) -> int:
        if outFilePath is None:
            outFilePath = self.DEFAULT_COMPILED_PATH()
        outPath = Path(outFilePath)
        os.makedirs(outPath.parent, exist_ok=True)
        metadataStr = " " + \
                      " ".join([f'-M {key}="{val}"' for key,
                                                        val in self.metadata.items()])
        templateStr = ""
        if template is None and hasattr(self, "gremium"):
            templateStr = f' --template="{getattr(self, "gremium").fullTemplate()}" '
        elif template != "":
            templateStr = f' --template="{template}" '
        cmd = f'pandoc "{self.rawPath}" {metadataStr}{templateStr}-o "{str(outPath.absolute())}"'
        ret = os.system(cmd)
        if ret == 0:
            self.compiledPath = outFilePath
        return ret



class ProtocolPad(BasePad):
    def __init__(self, source: SourceTypes, *_, date: datetime.datetime = None,
                 isFachgruppenvollversammlung: bool = False, isApproved: bool = False, gremium: Gremium = None):
        self.gremium = gremium or DEFAULT_GREMIUM
        self.date = date
        self.isApproved = isApproved
        self.isFachgruppenvollversammlung = isFachgruppenvollversammlung
        self.semester = None
        super().__init__(source)

    def __repr__(self):
        return super(ProtocolPad, self).__repr__()[:-1] + f", {self.date})"

    def DEFAULT_DISPLAY_NAME(self):
        return f"Protokoll {self.gremium.name} {self.date.strftime('%Y-%m-%d')}" + " - Fachgruppenvollversammlung" * self.isFachgruppenvollversammlung

    def DEFAULT_GRAV_PATH(self):
        return os.path.join(GIT_REPO_PATH, GRAV_PROTOCOL_PATH,
                            self.semester._gravName(),
                            self.date.strftime("%Y-%m-%d") + "-fgvv" * self.isFachgruppenvollversammlung,
                            "default.de.md")

    def parseTops(self):
        # TODO: better top filter?
        lines = self.source.retrieveContent().split("\n")
        # with open(self.rawPath, "r", encoding="utf-8") as f:
        #     lines = f.read().split("\n")
        tops = []
        for l in lines:
            # Change to regex?
            # import re
            # res = re.match("^## ([\w\d &!\"'§$%/\-+äöüß]+)\w*(\(\d\d:\d\d Uhr\))?", l)
            # if res is not None:
            #     top = res.group(1)

            if l.startswith("## "):
                top = l.strip("#").rsplit("(")[0].strip()
                if any(top in t or t in top for t in IGNORED_TOPS):
                    continue
                tops.append(top)
        return tops

    def sendMailAsUnapproved(self) -> bool:
        sender = MailParticipant(LDAP_MAIL, LDAP_NAME)
        receiver = [
            MailParticipant.FR()
        ]
        text = (f"Hallo zusammen,\n\n"
                f"anbei das vorläufige Protokoll der Fachrats-Sitzung vom {self.date.strftime('%d.%m.%Y')}.\n\n"
                f"Änderungswünsche bitte direkt an mich, bzw. mir kurz Bescheid geben, wenn ihr was im Pad geändert habt.\n\n"
                f"Viele Grüße\n"
                f"{LDAP_NAME}\n")
        subject = f"Vorläufiges Protokoll der FR-Sitzung vom {self.date.strftime('%d.%m.%Y')}"
        try:
            sendFRMail(text, subject, sender, receiver, attachement=self)
        except Exception:
            return False
        return True

    def sendMailAsApproved(self) -> bool:
        if not self.isApproved:
            print("Protocol is not approved yet!")
            raise PermissionError("Protocol is not approved yet!")
        sender = MailParticipant(LDAP_MAIL, LDAP_NAME)
        receiver = [
            MailParticipant.FR_INFO()
        ]
        text = (f"Hallo zusammen,\n\n"
                f"anbei das Protokoll der Fachrats-Sitzung vom {self.date.strftime('%d.%m.%Y')}.\n\n"
                f"Alle Protokolle sind zu finden unter:\n"
                f"https://cloud.finf.uni-hannover.de/index.php/s/Erw9Cbta0PruqZI\n\n"
                f"Viele Grüße\n"
                f"{LDAP_NAME}\n")
        subject = f"Protokoll der FR-Sitzung vom {self.date.strftime('%d.%m.%Y')}"
        try:
            sendFRMail(text, subject, sender, receiver, attachement=self)
        except Exception:
            return False
        return True

    def uploadToCloud(self):
        pass

    def uploadToGrav(self):
        # Init semester
        # TODO: better file management
        self.semester.uploadToGrav()
        if not os.path.exists(self.rawPath):
            raise FileNotFoundError(f"{self.rawPath} doesn't exist")

        # TODO: move conversion to another method?
        with open(self.rawPath, "r", encoding="utf-8") as f:
            lines = f.read().split("\n")

        # Tops
        tops = self.parseTops()
        tops_text = ", ".join(tops)

        # Header
        if self.isFachgruppenvollversammlung:
            name = "der Fachgruppenvollversammlung"
        else:
            name = f"des {self.gremium.fullName}"
        header = ("---\n"
                  f"title: Protokoll {name} am {self.date.strftime('%d.%m.%Y')}\n"
                  f"date: {self.date.strftime('%d.%m.%Y')}\n"
                  f"tops: {tops_text}\n"
                  "---\n\n"
                  "[MINITOC]\n\n")
        # Lines
        lines_new = [header]
        ignore = False
        for l in lines:
            if l.startswith("######"):  # tags 'fr'
                continue
            if l == "---":
                ignore = True
                continue
            if l == "...":
                ignore = False
                continue
            if ignore:
                continue
            lines_new.append(l)

        # Upload
        os.makedirs(str(Path(self.DEFAULT_GRAV_PATH()).parent), exist_ok=True)
        with open(self.DEFAULT_GRAV_PATH(), "w", encoding="utf-8") as f:
            f.write("\n".join(lines_new))

        git.add(GRAV_PROTOCOL_PATH)
        git.commit(f"Added protocol {self.displayName}")
        git.push()


class AttachementPad(BasePad):
    def __init__(self, source: SourceTypes, name: str, date: datetime.datetime = None, version=0, isApproved=False):
        super().__init__(source)
        self.name = name
        self.date = date
        self.version = version
        self.isApproved = isApproved


class PadCollection(BasePad):
    def __init__(self, source: SourceTypes):
        super().__init__(source)

    def DEFAULT_DISPLAY_NAME(self):
        return f"PadCollection"

    def getPads(self) -> Dict[str, List[BasePad]]:
        """
        Parsing the protocollink-Pad for urls.
        """
        pads = dict()
        semesters = dict()
        currentFolder = ""
        for line in self.source.retrieveContent().split("\n"):
            if line.startswith("# "):
                currentFolder = line.split("#")[1].strip()
                continue
            pad = self.parsePad(line)
            if pad is None:
                continue
            if currentFolder not in pads:
                pads[currentFolder] = list()
            if isinstance(pad, ProtocolPad) and pad.date is not None:
                semester = Semester.fromDate(pad.date)
                if semester not in semesters:
                    semesters[semester] = semester
                pad.semester = semester
            pad.folder = currentFolder
            pads[currentFolder].append(pad)

        return pads

    def parsePad(self, line) -> Optional[BasePad]:
        url, *comment = line.split("#")
        if not url.strip():
            return None
        prefixes, url = url.split("https://")
        url = f"https://{url}"
        url = url.strip()

        if "/p/" in url:
            retrieveClass = Etherpad
        else:
            retrieveClass = CodiMD
        src = retrieveClass(url.strip())

        isAttachement = ATTACHEMENT_SIGN in prefixes
        isFachgrupenvollversammlung = FACHGRUPPENVOLLVERSAMMLUNG_SIGN in prefixes
        isApproved = NOT_APPROVED_SIGN not in prefixes

        kwargs = dict()
        if isAttachement:
            padType = AttachementPad
            kwargs["date"] = None
            kwargs["name"] = None
            kwargs["version"] = None
            kwargs["isApproved"] = isApproved
        else:
            padType = ProtocolPad
            kwargs["isApproved"] = isApproved
            try:
                date = datetime.datetime.strptime(
                    comment[0].strip(), "%d.%m.%Y")
            except Exception:
                dateStr = url.split("protokoll")[-1][:8]
                date = datetime.datetime.strptime(dateStr, "%Y%m%d")

            kwargs["date"] = date
            kwargs["isFachgruppenvollversammlung"] = isFachgrupenvollversammlung

        return padType(src, **kwargs)


def initGit():
    global git
    if any(o is None for o in [GIT_REPO, GIT_REPO_PATH, GIT_EMAIL, GIT_NAME]):
        raise RuntimeError("Git is not configured correctly")
    git = GitHelper(GIT_REPO, GIT_REPO_PATH)
    git.config(GIT_EMAIL, GIT_NAME)
    git.update()


if __name__ == '__main__':
    import argparse

    parser = argparse.ArgumentParser(
        description="Download and convert finf/fsr-protocols using pandoc")
    parser.add_argument("-urls", nargs="+", type=str, default=[])
    parser.add_argument("-pad", type=str, default=None)
    # parser.add_argument("--prefixes", type=str, default="",
    #                     help=f"Add additional information to pad:\n"
    #                          f"Not approved: {NOT_APPROVED_SIGN}\n"
    #                          f"Fachschaftenvollversammlung: {FACHSCHAFTENVERSAMMLUNG_SIGN}\n"
    #                          f"Attachement: {ATTACHEMENT_SIGN}\n")
    parser.add_argument("--finf", action="store_true")
    parser.add_argument("--topics", action="store_true")
    parser.add_argument("--fsr", action="store_true")
    parser.add_argument("--download", action="store_true")
    parser.add_argument("--ignoreOld", action="store_true")
    parser.add_argument("--compile", action="store_true")
    parser.add_argument("--attachementsOnly", action="store_true")
    parser.add_argument("--newOnly", action="store_true")
    parser.add_argument("--override", action="store_true")
    parser.add_argument("--mail", action="store_true")

    parsed = parser.parse_args()

    urls = parsed.urls
    if not urls and parsed.pad is None:
        parser.print_usage()
        exit()

    if parsed.finf and parsed.fsr:
        raise AttributeError("Cannot have --finf AND --fsr")

    if parsed.finf:
        DEFAULT_GREMIUM = GREMIUM_FR
    if parsed.fsr:
        DEFAULT_GREMIUM = GREMIUM_FSR

    if parsed.override:
        OVERRIDE_ACCEPTED = True

    pads = getPadsFromCollectionPad(parsed.pad)
    pads += [PadOld.fromURL(url, prefixes=parsed.prefixes) for url in urls]

    if parsed.newOnly:
        pads = [pad for pad in pads if not pad.approved]
    if parsed.ignoreOld:
        pads = [pad for pad in pads if not pad.isOldPad()]
    if parsed.attachementsOnly:
        pads = [pad for pad in pads if pad.isAttachement()]

    if parsed.download:
        downloadPads(pads)

    # if parsed.topics:
    #     allPads(pads)

    if parsed.compile:
        compilePads(pads)