linkToPDF2.py

import datetime
import hashlib
import os
from dataclasses import dataclass
from pathlib import Path
from typing import Optional, Dict, List, Iterator, Tuple

import requests

import config
from pterClasses import Gremium, GREMIUM_FR, GREMIUM_FSR, MailParticipant, sendFRMail, SemesterPart

opt = config.Config()


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

    def __post_init__(self):
        self.displayName = f"{self.part.value} {self.year}"
        self.gravPath = Path(opt.GIT_REPO_PATH) / opt.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 self.gravPath.exists():
            return

        git = opt.git
        self.gravPath.parent.mkdir(parents=True, exist_ok=True)
        with self.gravPath.open("w") as d:
            d.write(f"---\ntitle: {self.displayName}\n---")

        git.add(opt.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")

    @classmethod
    def fitUrl(cls, url: str) -> bool:
        # TODO: Maybe improve filter
        return "/p/" in url


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

    @classmethod
    def fitUrl(cls, url: str) -> bool:
        # TODO: Maybe improve filter
        return "/p/" not in url


class LocalCache(SourceTypes):
    def __init__(self, url: str, localPath: str = None):
        super().__init__(url)
        self.localPath = localPath or hashlib.md5(url.encode("utf-8"))

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

    def asOnlinePad(self) -> SourceTypes:
        if Etherpad.fitUrl(self.url):
            return Etherpad(self.url)
        if CodiMD.fitUrl(self.url):
            return CodiMD(self.url)


class CachedEtherPad(Etherpad):
    def __init__(self, url: str):
        super().__init__(url)
        self._cache = None

    def retrieveContent(self):
        if self._cache is None:
            self._cache = super().retrieveContent()
        return self._cache


class CachedCodiMD(CodiMD):
    def __init__(self, url: str):
        super().__init__(url)
        self._cache = None

    def retrieveContent(self):
        if self._cache is None:
            self._cache = super().retrieveContent()
        return self._cache


# === Pad Types ===
class BasePad:
    def __init__(self, source: SourceTypes, *_, displayName: str = None, date: datetime.datetime, isApproved: bool,
                 **kwargs):
        self.source = source
        self.metadata = kwargs
        self.folder = ""
        self.date = date
        self.isApproved = isApproved

        self.displayName = displayName or self.DEFAULT_DISPLAY_NAME()

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

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

    @property
    def rawPath(self) -> Path:
        return Path(opt.DATA_FOLDER).absolute() / "raw" / f"{self.displayName}.md"

    @property
    def compiledPath(self) -> Path:
        return Path(opt.DATA_FOLDER).absolute() / "result" / f"{self.displayName}.pdf"

    def download(self, override=True):
        content = self.source.retrieveContent()
        if not override and self.rawPath.exists():
            raise FileExistsError(f"{self.rawPath} already exists!")
        self.rawPath.parent.mkdir(parents=True, exist_ok=True)
        with self.rawPath.open("w", encoding="utf-8") as d:
            d.write(content)
        self.source = LocalCache(self.source.url, str(self.rawPath))

    def compile(self, template: str = None) -> int:
        self.compiledPath.parent.mkdir(parents=True, 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(self.compiledPath)}"'
        ret = os.system(cmd)
        if ret != 0:
            raise RuntimeWarning(f"Non-Zero Returncode ({ret})")
        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 opt.GREMIUM
        self.isFachgruppenvollversammlung = isFachgruppenvollversammlung
        self.semester = None

        super().__init__(source, date=date, isApproved=isApproved)

    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

    @property
    def gravPath(self) -> Path:
        return Path(
            opt.GIT_REPO_PATH).absolute() / opt.GRAV_PROTOCOL_PATH / self.semester._gravName() / self.date.strftime(
            "%Y-%m-%d") / str("-fgvv" * self.isFachgruppenvollversammlung) / "default.de.md"

    def parseTops(self):
        # TODO: better top filter?
        lines = self.source.retrieveContent().split("\n")
        tops = []
        for l in lines:
            # TODO: 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 opt.IGNORED_TOPS):
                    continue
                tops.append(top)
        return tops

    def cleanedRaw(self):
        linesNew = []
        ignore = False
        for l in self.source.retrieveContent().split("\n"):
            if l.startswith("######"):  # tags 'fr'
                continue
            if l == "---":
                ignore = True
                continue
            if l == "...":
                ignore = False
                continue
            if ignore:
                continue
            linesNew.append(l)
        return "\n".join(linesNew)

    def sendMailAsPreliminary(self) -> bool:
        sender = MailParticipant(opt.LDAP_MAIL, opt.MAIL_DISPLAY_NAME)
        receivers = opt.PRELIMINARY_MAIL_RECEIVER
        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"Falls es Probleme mit dieser Mail gibt, meldet euch bitte bei mir. Diese Mail wurde automatisch erstellt.\n\n"
                f"Viele Grüße\n"
                f"{opt.MAIL_DISPLAY_NAME}\n")
        subject = f"Vorläufiges Protokoll der FR-Sitzung vom {self.date.strftime('%d.%m.%Y')}"
        try:
            sendFRMail(text, subject, sender, receivers, attachment=self, ldapPassword=opt.LDAP_PASSWORD)
        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(opt.LDAP_MAIL, opt.MAIL_DISPLAY_NAME)
        receivers = opt.APPROVED_MAIL_RECEIVER
        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"{opt.MAIL_DISPLAY_NAME}\n")
        subject = f"Protokoll der FR-Sitzung vom {self.date.strftime('%d.%m.%Y')}"
        try:
            sendFRMail(text, subject, sender, receivers, attachment=self, ldapPassword=opt.LDAP_PASSWORD)
        except Exception:
            return False
        return True

    def uploadToCloud(self):
        pass

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

        # TODO: move conversion to another method?
        # 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")
        # Upload
        self.gravPath.parent.mkdir(parents=True, exist_ok=True)
        with self.gravPath.open("w", encoding="utf-8") as f:
            f.write(header + self.cleanedRaw())

        git = opt.git
        git.add(opt.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, date=date, isApproved=isApproved)
        self.name = name
        self.version = version


class PadCollection(BasePad):
    def __init__(self, source: SourceTypes):
        super().__init__(source, isApproved=False, date=datetime.datetime.now())
        self._pads: Dict[str, List[BasePad]] = dict()
        self.__retrieved = False

    def __iter__(self) -> Iterator[Tuple[str, BasePad]]:
        """ Iter (folder, pad) """
        pads = self.pads
        for folder in pads:
            for pad in pads[folder]:
                yield folder, pad

    def DEFAULT_DISPLAY_NAME(self):
        return f"PadCollection"

    def addPads(self, folder: str, pads: List[BasePad]):
        self._pads[folder] = pads

    def clearAllPads(self):
        self._pads = dict()

    @property
    def pads(self):
        if not self.__retrieved:
            self._pads.update(self.getPads())
            self.__retrieved = True

        return self._pads

    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

    @classmethod
    def parsePad(cls, line: str, prefixes=None) -> Optional[BasePad]:
        url, *comment = line.split("#")
        if not url.strip():  # Only whitespace
            return None
        allPrefixes, url = url.split("https://")
        if prefixes is not None:
            allPrefixes += prefixes
        url = f"https://{url}".strip()

        if Etherpad.fitUrl(url):
            retrieveClass = CachedEtherPad
        elif CodiMD.fitUrl(url):
            retrieveClass = CachedCodiMD
        else:
            raise ValueError("Cannot retrieve SourceType class")
        src = retrieveClass(url)

        isAttachement = opt.ATTACHMENT_SIGN in allPrefixes
        isFachgrupenvollversammlung = opt.FACHGRUPPENVOLLVERSAMMLUNG_SIGN in allPrefixes
        isApproved = opt.NOT_APPROVED_SIGN not in allPrefixes

        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 removeApproved(self):
        oldPads = self.pads
        self.clearAllPads()
        for folder in oldPads:
            folderPads = list()
            for pad in oldPads[folder]:
                if not pad.isApproved:
                    folderPads.append(pad)
            if folderPads:
                self.addPads(folder, folderPads)

    def removeOld(self):
        oldPads = self.pads
        self.clearAllPads()
        for folder in oldPads:
            folderPads = list()
            for pad in oldPads[folder]:
                if not isinstance(pad, Etherpad):
                    folderPads.append(pad)
            if folderPads:
                self.addPads(folder, folderPads)
        return self.pads

    def downloadPads(self, forceDownload=False):
        for folder, pad in self:
            pad.download(forceDownload)

    def compilePads(self, template: str = None):
        for folder, pad in self:
            pad.compile(template)

    def createTopics(self):
        raise NotImplementedError()


if __name__ == '__main__':
    import argparse

    opt = config.Config()
    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: {ATTACHMENT_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("--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:
        opt.GREMIUM = GREMIUM_FR
    if parsed.fsr:
        opt.GREMIUM = GREMIUM_FSR

    if parsed.override:
        opt.OVERRIDE_ACCEPTED = True

    pads = PadCollection(CodiMD(parsed.pad))
    pads.addPads("unsorted", [PadCollection.parsePad(url, prefixes=parsed.prefixes) for url in urls])

    if parsed.newOnly:
        pads.removeApproved()
    if parsed.ignoreOld:
        pads.removeOld()

    if parsed.download:
        pads.downloadPads(opt.OVERRIDE_ACCEPTED)

    if parsed.topics:
        pads.createTopics()

    if parsed.compile:
        pads.compilePads()