pdf.py

from base64 import b64decode

import barcode
import os
import unicodedata

from datetime import timedelta, datetime, date, timezone
from io import BytesIO

from reportlab.lib.enums import TA_CENTER
from reportlab.lib import colors
from reportlab.lib.pagesizes import A4
from reportlab.lib.styles import ParagraphStyle
from reportlab.lib.units import mm
from reportlab.pdfbase.pdfmetrics import registerFont, registerFontFamily
from reportlab.pdfbase.ttfonts import TTFont
from reportlab.pdfgen.canvas import Canvas
from reportlab.platypus import Image, Paragraph, Spacer, HRFlowable, Frame

from .config import PPA_GROUP_IDS
from .config import ESCAPE
from .config import request_type_name


def escape(line: str) -> str:
    """
    XML-Zeichen escapen
    :param line: string
    :return: escaped string
    """
    for key, value in ESCAPE.items():
        line = line.replace(key, value)
    return line


def auslage_bis(data: dict) -> date:
    """
    Formatiert das Datum für Zettel und rechnet Tage dazu.
    :param data: dict
    :return: abholdatum (date)
    """
    value = datetime.strptime(data["requestDate"][:10], "%Y-%m-%d").date() + timedelta(
        days=7
    )
    return value


def bestelldatum(data: dict) -> str:
    """
    Formatiert das Bestelldatum mit Uhrzeit sinnvoll menschenlesbar.

    Bei einem Datum ohne Zeitzone nehmen wir UTC an.
    Als Bonus wird auch die Zeitzone korrekt berechnet.
    :param data:
    :return: bestelldatum (str)
    """
    request_date = datetime.fromisoformat(data["requestDate"])
    # Datum ohne Zeitzone ist wahrscheinlich UTC.
    if not request_date.tzinfo:
        request_date = request_date.replace(tzinfo=timezone.utc)
    value = request_date.astimezone().strftime("%Y-%m-%d %H:%M %Z")
    return value


def print_ppa_group(data: dict) -> str:
    """
    Gibt PPA aus, wenn der Nutzer in einer der PPA-Gruppen ist.
    :param data:
    :return: str
    """
    if data.get("requesterPatronGroupId") in PPA_GROUP_IDS:
        return "PPA"
    return ""


def pre_story_to_story(pre_story: list, style: ParagraphStyle) -> list:
    """
    Erstellt aus Sting-Elementen einen Paragraph mit Stil.

    Nicht-Strings werden übernommen, wie sie sind.
    Möchte man einen anderen ParagraphStyle für den Paragraphen, muss man diesen so abliefern.
    :param pre_story:
    :param style:
    :return:
    """
    story = [
        (
            Paragraph(unicodedata.normalize("NFC", line), style=style)
            if isinstance(line, str)
            else line
        )
        for line in pre_story
    ]
    return story


def watermark(canvas, page_width, page_height, font_size):
    """
    Fügt einem canvas ein Wasserzeichen in der vorgegebenen Schriftgröße hinzu.

    Für die Platzierung wird Seitenbreite- und höhe genutzt. Das Wasserzeichen erscheint in der oberen Hälfte.
    :param canvas:
    :param page_width:
    :param page_height:
    :param font_size:
    :return:
    """
    canvas.setFillColor(colors.grey, alpha=0.4)
    canvas.setFont("dejavu-mono", font_size)
    # Startkoordinaten verschieben (oberes Viertel), anschließend dort drehen
    canvas.translate(page_width / 2, 3 * page_height / 4)
    canvas.rotate(45)
    canvas.drawCentredString(0 * mm, 0 * mm, "Testsystem")
    canvas.rotate(-45)


# Definition der Schrift
registerFont(TTFont("dejavu-mono", "DejaVuSansMono.ttf"))
registerFont(TTFont("dejavu-mono-bold", "DejaVuSansMono-Bold.ttf"))
registerFontFamily(
    "dejavu-mono",
    normal="dejavu-mono",
    bold="dejavu-mono-bold",
    italic="",
    boldItalic="",
)
registerFont(TTFont("dejavu-sans", "DejaVuSans.ttf"))
registerFont(TTFont("dejavu-sans-bold", "DejaVuSans-Bold.ttf"))
registerFontFamily(
    "dejavu-sans",
    normal="dejavu-sans",
    bold="dejavu-sans-bold",
    italic="",
    boldItalic="",
)


def reservation_order_a4(data: dict) -> BytesIO:
    """
    Erstellt einen UB-Standardzettel für A4.

    Man beachte, dass nur die obere Hälfte des Zettels belegt sein darf, da halbe Zettel im Drucker genutzt werden.
    :param data: dict
    :return: BytesIO
    """
    # Wir schreiben das PDF in ein BytesIO
    buffer = BytesIO()

    canvas = Canvas(buffer)
    canvas.line(0, A4[1] / 2, A4[0], A4[1] / 2)

    frame = Frame(
        0,
        0,
        *A4,
        leftPadding=5 * mm,
        topPadding=5 * mm,
        bottomPadding=5 * mm,
        rightPadding=5 * mm,
    )

    font_name = "dejavu-mono"
    font_size = 10.5
    spacer_size = 0.75 * font_size

    default_style = ParagraphStyle(
        "default",
        fontName=font_name,
        fontSize=font_size,
        spaceBefore=1,
        justifyLastLine=1,
        justifyBreak=1,
    )

    pre_story = [
        f"Bestelltyp: {request_type_name(data)} / Bestelldatum {bestelldatum(data)}",
        f"Bestellstatus: {data['requestStatus']}",
        Spacer(0, spacer_size),
        f"Signatur: <b>{data.get('itemCallNumber', '-')}</b>",
        f"Band: {data.get('itemVolume', '-')}, Heftzählung: {data.get('itemEnumeration', '-')}, Jahr: {data.get('itemChronology', '-')}",
        HRFlowable(
            width="99%",
            lineCap="square",
            spaceBefore=spacer_size,
            spaceAfter=spacer_size,
            vAlign="CENTER",
            color="black",
            dash=(5, 10),
        ),
        "Bibliothekssystem der JLU Gießen",
        f"Bibliothek: {data['itemLocationLibraryName']}",
        f"Standort: <b>{data['effectiveLocationName']}</b>",
        HRFlowable(
            width="99%",
            lineCap="square",
            spaceBefore=spacer_size,
            spaceAfter=spacer_size,
            vAlign="CENTER",
            color="black",
            dash=(5, 10),
        ),
        f"Titel: {escape(data.get('instanceTitle', '-')[:82])}",
        f"Autor*innen: {escape(data.get('instanceContributorName', '-'))}",
        f"Buchnummer: <b>{data.get('itemBarcode', '')}</b>",
        HRFlowable(
            width="99%",
            lineCap="square",
            spaceBefore=spacer_size,
            spaceAfter=spacer_size,
            vAlign="CENTER",
            color="black",
            dash=(5, 10),
        ),
        f"Ausgabetheke: {data['pickupServicePointName']}",
        f"Ausleihtyp: {data['itemPermanentLoanTypeName']}",
        HRFlowable(
            width="99%",
            lineCap="square",
            spaceBefore=spacer_size,
            spaceAfter=spacer_size,
            vAlign="CENTER",
            color="black",
            dash=(5, 10),
        ),
        f"{request_type_name(data)} für:",
        f"{data.get('requesterBarcode', '-')} // <b>{data['requesterPatronGroupDescription']}</b>",
        Spacer(0, spacer_size),
        f"<b>{data['requesterLastName']}</b>, {data.get('requesterFirstName', '-')}",
        Spacer(0, spacer_size),
        f"c/o: {escape(data.get('requesterAddressLine1', ''))}",
        f"Str./Nr.: {escape(data.get('requesterAddressLine2', '-'))}",
        f"PLZ/Ort: {data.get('requesterAddressPostalCode', '-')} {data.get('requesterAddressCity', '-')}",
        f"Lieferung an: <b>{data.get('customFieldsLieferungAn', '-')}</b>",
        HRFlowable(
            width="99%",
            lineCap="square",
            spaceBefore=15,
            spaceAfter=10,
            vAlign="CENTER",
            color="black",
            dash=(5, 10),
        ),
        f"Auslage bis: <b>{auslage_bis(data)}</b>",
    ]
    frame.addFromList(pre_story_to_story(pre_story, default_style), canvas)

    # Handelt es sich um das Testsystem, fügen wir ein Wasserzeichen ein
    if os.environ.get("TESTSYSTEM"):
        watermark(canvas, *A4, 70)

    canvas.save()

    return buffer


def reservation_bon(data: dict) -> BytesIO:
    buffer = BytesIO()

    pagesize = (72 * mm, 150 * mm)

    canvas = Canvas(buffer, pagesize=pagesize)
    frame = Frame(
        0,
        0,
        *pagesize,
        leftPadding=0 * mm,
        topPadding=0 * mm,
        bottomPadding=0 * mm,
        rightPadding=0 * mm,
    )

    font_name = "dejavu-mono"
    font_size = 9
    spacer_size = 0.75 * font_size

    default_style = ParagraphStyle(
        "default",
        fontName=font_name,
        fontSize=font_size,
        spaceBefore=1,
        justifyLastLine=1,
        justifyBreak=1,
    )
    center_style = ParagraphStyle(
        "default",
        fontName=font_name,
        fontSize=font_size + 1,
        spaceBefore=1,
        justifyLastLine=1,
        justifyBreak=1,
        alignment=TA_CENTER,
    )

    volume_barcode = BytesIO()
    barcode.Code39(
        data["itemBarcode"], writer=barcode.writer.ImageWriter(), add_checksum=False
    ).write(volume_barcode, text="")

    pre_story = [
        Paragraph("Bibliothekssystem", style=center_style),
        Paragraph("JLU Gießen", style=center_style),
        Spacer(0, 3 * spacer_size),
        "Zweigbibliothek Philosophikum II",
        "Karl-Glöckner-Straße 21 F" "35394 Gießen",
        Spacer(0, 3 * spacer_size),
        f'<b><font size="12">{data["itemCallNumber"]}</font></b>',
        Spacer(0, 4 * spacer_size),
        escape(data.get("instanceContributorName", "-")[:32]),
        escape(data.get("instanceTitle", "-")[: 2 * 32]),
        Spacer(0, 3 * spacer_size),
        Image(volume_barcode, width=72 * mm, height=25 * mm, kind="proportional"),
        Paragraph(data["itemBarcode"], style=center_style),
        Spacer(0, 3 * spacer_size),
        f'Auslage bis: <b><font size="12">{auslage_bis(data)}</font></b>',
        Spacer(0, 3 * spacer_size),
        f'Benutzernummer: xxxx<b><font size="12">{data.get("requesterBarcode", "")[-4:]}</font></b> {print_ppa_group(data)}',
    ]

    frame.addFromList(pre_story_to_story(pre_story, default_style), canvas)

    # Handelt es sich um das Testsystem, fügen wir ein Wasserzeichen ein
    if os.environ.get("TESTSYSTEM"):
        watermark(canvas, *pagesize, 30)

    canvas.save()
    return buffer


def retro_a4(data: dict) -> BytesIO:
    """
    Erzeugt einen Retro-Bestellzettel.

    :param data:
    :return:
    """
    buffer = BytesIO()
    canvas = Canvas(buffer)
    canvas.line(0, A4[1] / 2, A4[0], A4[1] / 2)

    font_name = "dejavu-sans"
    font_size = 10
    spacer_size = 0.75 * font_size

    default_style = ParagraphStyle(
        "default",
        fontName=font_name,
        fontSize=font_size,
        bulletFontName=font_name,
        spaceBefore=1,
        justifyLastLine=1,
        justifyBreak=1,
    )
    center_style = ParagraphStyle(
        "default",
        fontName=font_name,
        fontSize=font_size,
        spaceBefore=1,
        justifyLastLine=1,
        justifyBreak=1,
        alignment=TA_CENTER,
    )

    frame_left = Frame(
        0,
        A4[1] / 2,
        50 * mm,
        A4[1] / 2 - 20 * mm,
        leftPadding=5 * mm,
        topPadding=5 * mm,
        bottomPadding=5 * mm,
        rightPadding=0 * mm,
    )
    frame_middle = Frame(
        50 * mm,
        A4[1] / 2,
        A4[0] - 100 * mm,
        A4[1] / 2 - 5 * mm,
        leftPadding=5 * mm,
        topPadding=5 * mm,
        bottomPadding=5 * mm,
        rightPadding=5 * mm,
    )

    frame_right = Frame(
        A4[0] - 50 * mm,
        A4[1] / 2,
        50 * mm,
        A4[1] / 2 - 20 * mm,
        leftPadding=0 * mm,
        topPadding=5 * mm,
        bottomPadding=5 * mm,
        rightPadding=5 * mm,
    )

    story_left = [
        "Besteller/in",
        f"<b>{data['requesterLastName']},</b>",
        f"<b>{data.get('requesterFirstName', '-')}</b>",
        f"<font size=\"8\">{escape(data.get('requesterAddressLine1', ''))}</font>",
        f"<font size=\"8\">{escape(data.get('requesterAddressLine2', '-'))}</font>",
        Spacer(0, spacer_size),
        "Lieferung an",
        f"{data.get('customFieldLieferungAn', '-')}",
        Spacer(0, spacer_size),
        "Nutzergruppe",
        f"{data.get('requesterPatronGroupName')}",
        Spacer(0, spacer_size),
        "Nutzernummer",
        f"<b>{data.get('requesterBarcode', '-')}</b>",
        Spacer(0, spacer_size),
        "Theke",
        f"<b>{data['pickupServicePointName']}</b>",
        Spacer(0, spacer_size),
        "Bestelldatum",
        f"{bestelldatum(data)}",
        Spacer(0, spacer_size),
        "Auslage bis",
        f"<b>{auslage_bis(data)}</b>",
    ]

    story_middle = [
        Paragraph('<font size="16"><b>Bestellschein</b></font>', style=center_style),
        Spacer(0, 2 * spacer_size),
        Image(
            BytesIO(b64decode(data.get("itemRetroCard"))),
            width=A4[0] - 100 * mm,
            height=500 * mm,
            kind="proportional",
        ),
        Spacer(0, 2 * spacer_size),
        Paragraph(f"hebis Retro ID: <b>{data['itemRetroId']}</b>", style=center_style),
    ]

    standorte = [
        "Freihandbereich / Lesesaal",
        "Zweigbibliothek ZNL",
        "Zweigbibliothek Re/Wi",
        "Zweigbibliothek Zeughaus",
        "Zweigbibliothek Phil II",
        "dezentrale Fachbibliothek",
    ]

    def vorhanden_in():
        for item in standorte:
            yield Spacer(0, spacer_size)
            yield Paragraph(
                f'<font size="8"><bullet>\u25cb</bullet> {item}</font>',
                style=default_style,
            )

    story_right = [
        "<b>Universitätsbibliothek</b>",
        "<b>Otto-Behagel-Str. 8</b>",
        "<b>34394 Gießen</b>",
        Spacer(0, spacer_size),
        "Vorhanden",
        *vorhanden_in(),
    ]

    frame_middle.addFromList(pre_story_to_story(story_middle, default_style), canvas)
    frame_left.addFromList(pre_story_to_story(story_left, default_style), canvas)
    frame_right.addFromList(pre_story_to_story(story_right, default_style), canvas)

    # Handelt es sich um das Testsystem, fügen wir ein Wasserzeichen ein
    if os.environ.get("TESTSYSTEM"):
        watermark(canvas, *A4, 70)

    canvas.save()

    return buffer