wbreport 2.2.1__py2.py3-none-any.whl

wbreport/pdf/tables/aggregated_tables.py

@@ -0,0 +1,156 @@
+import numpy as np
+from reportlab.lib.colors import grey
+from reportlab.lib.enums import TA_CENTER
+from reportlab.lib.styles import ParagraphStyle
+from reportlab.platypus import Paragraph, Spacer, Table, TableStyle
+
+
+def get_simple_aggregated_table(
+    df,
+    width,
+    row_height,
+    header_style,
+    row_style,
+    data_style,
+    grid_color,
+    offset=None,
+    debug=False,
+):
+    table_data = list()
+
+    # Generate header column
+    table_row = [Spacer(width=0, height=0)] * 2 if offset else 1
+
+    years = list(df.keys())
+    months = df[years[0]].keys()
+    for column in months:
+        table_row.append(Paragraph(str(column).upper(), style=header_style))
+    table_data.append(table_row)
+    data_style_fake = ParagraphStyle(
+        fontName="customfont", fontSize=6, leading=6, name="s_table_center", alignment=TA_CENTER, textColor=grey
+    )
+    # Generate table
+    for year, row in df.items():
+        table_row = list()
+        if offset:
+            table_row.append(Spacer(width=0, height=0))
+
+        table_row.append(Paragraph(str(year), style=row_style))
+
+        for month, element in row.items():
+            if element.get("performance", None) is None:
+                table_row.append(Spacer(width=0, height=0))
+            else:
+                value = element["performance"]
+                value_str = f"{value:.1%}" if (isinstance(value, float) and not np.isinf(value)) else str(value)
+                if element.get("calculated", False):
+                    table_row.append(Paragraph(value_str, style=data_style_fake))
+                else:
+                    table_row.append(Paragraph(value_str, style=row_style))
+        # else:
+        #     table_row.append(
+        #         Paragraph(f"<strong>{row.iloc[-1]:.1f}%</strong>", style=data_style)
+        #     )
+        table_data.append(table_row)
+
+    num_cols = len(months) + 1
+
+    cols = list()
+    if offset:
+        cols.append(offset)
+
+    cols.extend([(width - offset or 0) / num_cols] * num_cols)
+    rows = [row_height] * (len(years) + 1)
+
+    table = Table(table_data, colWidths=cols, rowHeights=rows)
+
+    table_styles = [
+        ("LINEBEFORE", (2, 0), (2, -1), 0.25, grid_color),
+        ("LINEBEFORE", (-1, 0), (-1, -1), 0.25, grid_color),
+        ("LINEABOVE", (1, 1), (-1, 1), 0.25, grid_color),
+        ("LEFTPADDING", (0, 0), (-1, -1), 0),
+        ("RIGHTPADDING", (0, 0), (-1, -1), 0),
+        ("RIGHTPADDING", (2, 1), (-1, -1), offset / 2),
+    ]
+
+    if debug:
+        table_styles.extend(
+            [
+                ("BOX", (0, 0), (-1, -1), 0.25, grid_color),
+                ("INNERGRID", (0, 0), (-1, -1), 0.25, grid_color),
+            ]
+        )
+
+    table.setStyle(TableStyle(table_styles))
+    return table
+
+
+def get_fund_table(
+    df,
+    width,
+    row_height,
+    header_style,
+    row_style,
+    data_style,
+    grid_color,
+    background_color,
+    offset=None,
+    debug=False,
+):
+    table_data = [
+        [Paragraph("<strong>THE ATONRÂ FUND SHARE CLASSES AND LOADS</strong>", style=header_style)],
+        [Spacer(width=0, height=0)],
+    ]
+
+    # Generate header column
+    table_row = []
+    labels = df.columns
+    for label in labels:
+        table_row.append(Paragraph(f"<strong>{str(label).upper()}</strong>", style=header_style))
+    table_data.append(table_row)
+
+    # Generate table
+    for index, row in df.iterrows():
+        table_row = list()
+
+        for value in row:
+            # value = product_data[label]
+            # if isinstance(value, (Decimal, int, float)):
+            #     value_str = f"{value:.1%}"
+            # else:
+            #     value_str = str(value)
+            value_str = value if value else ""
+            table_row.append(Paragraph(str(value_str), style=row_style))
+        table_data.append(table_row)
+
+    num_cols = len(labels)
+
+    cols = list()
+
+    cols.extend([(width) / num_cols] * num_cols)
+    rows = [row_height] * (df.shape[0] + 3)
+
+    table = Table(table_data, colWidths=cols, rowHeights=rows)
+
+    table_styles = [
+        ("LINEBEFORE", (1, 0), (1, -1), 0.25, grid_color),
+        ("LINEABOVE", (0, 1), (-1, 1), 0.25, grid_color),
+        ("LINEABOVE", (0, 0), (-1, 0), 0.25, grid_color),
+        ("LEFTPADDING", (0, 0), (-1, -1), 0),
+        ("RIGHTPADDING", (0, 0), (-1, -1), 0),
+        ("RIGHTPADDING", (2, 1), (-1, -1), offset / 2),
+        ("BACKGROUND", (0, 0), (-1, 0), background_color),
+        ("SPAN", (0, 0), (-1, 0)),  # Col Span Title
+        ("SPAN", (0, 1), (-1, 1)),
+    ]
+
+    if debug:
+        table_styles.extend(
+            [
+                ("BOX", (0, 0), (-1, -1), 0.25, grid_color),
+                ("INNERGRID", (0, 0), (-1, -1), 0.25, grid_color),
+            ]
+        )
+
+    table.setStyle(TableStyle(table_styles))
+    return table

wbreport/pdf/tables/data_tables.py

@@ -0,0 +1,75 @@
+from reportlab.lib.units import cm
+from reportlab.platypus import Paragraph, Spacer, Table, TableStyle
+
+
+def get_simple_data_table(
+    headers,
+    data,
+    width,
+    header_row_height,
+    data_row_height,
+    margin,
+    header_style,
+    data_style,
+    grid_color,
+    offset=None,
+    debug=False,
+):
+    table_data = list()
+
+    # Generate Headers
+    table_row = list()
+    if offset:
+        table_row.append(Spacer(width=0, height=0))
+
+    for header in headers[:-1]:
+        table_row.extend([Paragraph(header, style=header_style), Spacer(width=0, height=0)])
+    else:
+        table_row.append(Paragraph(headers[-1], style=header_style))
+
+    table_data.append(table_row)
+    table_data.append([Spacer(width=0, height=0) for _ in range(len(data) + (1 if offset else 0))])
+    for row in data:
+        table_row = list()
+        if offset:
+            table_row.append(Spacer(width=0, height=0))
+
+        for item in row[:-1]:
+            table_row.extend([Paragraph(item, style=data_style), Spacer(width=0, height=0)])
+        else:
+            table_row.append(Paragraph(row[-1], style=data_style))
+
+        table_data.append(table_row)
+
+    rows = [header_row_height, 0.16 * cm]
+    rows.extend([data_row_height] * len(data))
+
+    cols = list()
+    if offset:
+        cols.append(offset)
+
+    col_width = (width - (offset or 0) - (len(headers) - 1) * margin) / len(headers)
+    cols.extend([col_width, margin] * len(headers))
+
+    table = Table(table_data, colWidths=cols, rowHeights=rows)
+    table_styles = [
+        ("LINEABOVE", (1, 0), (1, 0), 0.25, grid_color),
+        ("LINEBELOW", (1, 0), (1, 0), 0.25, grid_color),
+        ("LINEABOVE", (3, 0), (3, 0), 0.25, grid_color),
+        ("LINEBELOW", (3, 0), (3, 0), 0.25, grid_color),
+        ("LINEABOVE", (5, 0), (5, 0), 0.25, grid_color),
+        ("LINEBELOW", (5, 0), (5, 0), 0.25, grid_color),
+        ("VALIGN", (0, 0), (-1, 0), "MIDDLE"),
+        ("LEFTPADDING", (0, 0), (-1, -1), 0),
+    ]
+
+    if debug:
+        table_styles.extend(
+            [
+                ("BOX", (0, 0), (-1, -1), 0.25, grid_color),
+                ("INNERGRID", (0, 0), (-1, -1), 0.25, grid_color),
+            ]
+        )
+
+    table.setStyle(TableStyle(table_styles))
+    return table

wbreport/serializers.py

@@ -0,0 +1,191 @@
+from rest_framework.reverse import reverse
+from wbcore import serializers as wb_serializers
+from wbcore.content_type.serializers import (
+    ContentTypeRepresentationSerializer,
+    DynamicObjectIDRepresentationSerializer,
+)
+from wbcore.contrib.authentication.authentication import inject_short_lived_token
+from wbmailing.serializers import MailingListRepresentationSerializer
+
+from .models import Report, ReportCategory, ReportClass, ReportVersion
+
+
+class ReportVersionRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    class Meta:
+        model = ReportVersion
+        fields = (
+            "id",
+            "title",
+        )
+
+
+class ReportClassRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    class Meta:
+        model = ReportClass
+        fields = ("id", "title")
+
+
+class ReportCategoryRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    class Meta:
+        model = ReportCategory
+        fields = ("id", "title")
+
+
+class ReportRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="report:report-detail")
+
+    class Meta:
+        model = Report
+        fields = ("id", "title", "_detail")
+
+
+class ReportCategoryModelSerializer(wb_serializers.ModelSerializer):
+    class Meta:
+        model = ReportCategory
+        fields = ("id", "title")
+
+
+class ReportVersionModelSerializer(wb_serializers.ModelSerializer):
+    _report = ReportRepresentationSerializer(source="report")
+    parameters = wb_serializers.JSONTableField()
+
+    @wb_serializers.register_resource()
+    def version_resources(self, instance, request, user):
+        res = {}
+        if instance.report.is_accessible(user) and instance.report.is_active and not instance.disabled:
+            if user.is_superuser:
+                res["update_context"] = reverse(
+                    "wbreport:reportversion-updatecontext", args=[instance.id], request=request
+                )
+            if not instance.report.file_disabled:
+                res["file"] = reverse("report:reportversion-file", args=[instance.id], request=request)
+
+            res["html"] = reverse("report:reportversion-html", args=[instance.id], request=request)
+            if instance.report.mailing_list:
+                res["send_email"] = reverse("report:reportversion-sendemail", args=[instance.id], request=request)
+        return res
+
+    from wbcore.contrib.authentication.authentication import TokenAuthentication
+
+    @wb_serializers.register_resource()
+    @inject_short_lived_token(view_name="public_report:report_version")
+    def public_html_resources(self, instance, request, user):
+        res = {}
+        if instance.report.is_accessible(user) and instance.report.is_active and not instance.disabled:
+            res["public_html"] = reverse("public_report:report_version", args=[instance.lookup], request=request)
+        return res
+
+    class Meta:
+        model = ReportVersion
+        fields = (
+            "id",
+            "uuid",
+            "title",
+            "creation_date",
+            "version_date",
+            "update_date",
+            "is_primary",
+            "disabled",
+            "lookup",
+            "parameters",
+            "comment",
+            "report",
+            "_report",
+            "parameters",
+            "_additional_resources",
+        )
+
+
+class ReportModelSerializer(wb_serializers.ModelSerializer):
+    _mailing_list = MailingListRepresentationSerializer(many=False, source="mailing_list")
+    _category = ReportCategoryRepresentationSerializer(source="category")
+    _report_class = ReportClassRepresentationSerializer(source="report_class")
+    _parent_report = ReportRepresentationSerializer(source="parent_report")
+    _content_type = ContentTypeRepresentationSerializer(source="content_type")
+    _object_id = DynamicObjectIDRepresentationSerializer(
+        source="object_id",
+        optional_get_parameters={"content_type": "content_type"},
+        depends_on=[{"field": "content_type", "options": {}}],
+    )
+    _group_key = wb_serializers.CharField(read_only=True)
+
+    @wb_serializers.register_resource()
+    def versions_resources(self, instance, request, user):
+        res = {}
+        if instance.is_accessible(user):
+            res["versions"] = reverse("wbreport:report-version-list", args=[instance.id], request=request)
+            res["reports"] = f'{reverse("wbreport:report-list", args=[], request=request)}?parent_report={instance.id}'
+            if instance.child_reports.exists():
+                res["bundle_versions"] = reverse("wbreport:report-bundletreport", args=[instance.id], request=request)
+
+            if user.is_superuser:
+                res.update(
+                    {
+                        "bulk_create_reports": reverse(
+                            "wbreport:report-bulkcreatereport", args=[instance.id], request=request
+                        ),
+                        "generate_next_reports": reverse(
+                            "wbreport:report-generatenextreports", args=[instance.id], request=request
+                        ),
+                        "switch_primary_versions": reverse(
+                            "wbreport:report-switchprimaryversions", args=[instance.id], request=request
+                        ),
+                        "update_versions_context": reverse(
+                            "wbreport:report-updatecontext", args=[instance.id], request=request
+                        ),
+                    }
+                )
+        return res
+
+    @wb_serializers.register_resource()
+    @inject_short_lived_token(view_name="public_report:report_version")
+    def public_resources(self, instance, request, user):
+        res = {}
+        if instance.is_accessible(user) and (
+            primary_snap := instance.versions.filter(is_primary=True, disabled=False).first()
+        ):
+            res["primary_version"] = reverse(
+                "public_report:report_version", args=[primary_snap.lookup], request=request
+            )
+
+            if (
+                (last_version := instance.versions.latest("creation_date"))
+                and not last_version.disabled
+                and last_version != primary_snap
+            ):
+                res["last_version"] = reverse(
+                    "public_report:report_version", args=[last_version.lookup], request=request
+                )
+        return res
+
+    class Meta:
+        model = Report
+        dependency_map = {
+            "object_id": ["content_type"],
+        }
+        fields = (
+            "id",
+            "title",
+            "namespace",
+            "_mailing_list",
+            "mailing_list",
+            "category",
+            "_category",
+            "report_class",
+            "_report_class",
+            "is_active",
+            "base_color",
+            "permission_type",
+            "file_disabled",
+            "file_content_type",
+            "title",
+            "logo_file",
+            "_parent_report",
+            "parent_report",
+            "_content_type",
+            "object_id",
+            "_object_id",
+            "content_type",
+            "_additional_resources",
+            "_group_key",
+        )

wbreport/tasks.py

@@ -0,0 +1,60 @@
+import zipfile
+from io import BytesIO
+
+from celery import shared_task
+from django.conf import settings
+from django.core.mail import EmailMultiAlternatives
+from django.template.loader import get_template
+from slugify import slugify
+from wbcore.contrib.authentication.models import User
+from wbcore.utils.html import convert_html2text
+from wbreport.models import Report, ReportVersion
+
+
+@shared_task()
+def generate_and_send_current_report_file(user_id, parent_report_id, parameters=None):
+    zip_buffer = BytesIO()
+    parent_report = Report.objects.get(id=parent_report_id)
+    if not parameters:
+        parameters = parent_report.last_version.parameters
+    report_date = parent_report.report_class.get_version_date(parameters)
+    with zipfile.ZipFile(zip_buffer, "a", zipfile.ZIP_DEFLATED, False) as zip_file:
+        summary = ""
+        for version in ReportVersion.objects.filter(
+            parameters=parameters,
+            report__parent_report=parent_report,
+            report__is_active=True,
+            report__file_disabled=False,
+            disabled=False,
+        ):
+            basename = f"report_{slugify(version.title)}"
+            try:
+                output = version.generate_file()
+                zip_file.writestr(output.name, output.getvalue())
+                msg = f"VALID: Report {basename} generated with success"
+            except Exception as e:
+                msg = f"ERROR: Could not generate Report {basename} (error: {e})"
+            print(msg)  # noqa: T201
+            summary += f"{msg}\n"
+
+        zip_file.writestr("summary.txt", summary)
+
+    html = get_template("notifications/email_template.html")
+    notification = {
+        "message": f"Please find all the reports you requested for {parent_report.title}",
+        "title": "Your Report bundle",
+    }
+    html_content = html.render({"notification": notification})
+
+    msg = EmailMultiAlternatives(
+        "Your Report bundle",
+        body=convert_html2text(html_content),
+        from_email=settings.DEFAULT_FROM_EMAIL,
+        to=[User.objects.get(id=user_id).email],
+    )
+    msg.attach_alternative(html_content, "text/html")
+
+    zip_buffer.seek(0)
+
+    msg.attach(f"reports_bundle_{report_date}.zip", zip_buffer.read(), "application/zip")
+    msg.send()

wbreport/templatetags/portfolio_tags.py

@@ -0,0 +1,35 @@
+from datetime import date, datetime
+from decimal import Decimal
+
+from django import template
+
+register = template.Library()
+
+
+@register.filter
+def percent_filter(value, precision=2):
+    if value is not None:
+        if isinstance(value, float) or isinstance(value, Decimal):
+            return f"{value:,.{precision}%}"
+        else:
+            return value
+    return ""
+
+
+@register.filter
+def value_filter(value, precision=1):
+    if value is not None:
+        if isinstance(value, float) or isinstance(value, Decimal):
+            return "%.*f" % (precision, value)
+        elif isinstance(value, datetime) or isinstance(value, date):
+            return value.strftime("%d-%b-%y")
+        else:
+            return value
+    return ""
+
+
+@register.filter
+def parse_title_date(value):
+    if value is not None and not isinstance(value, str):
+        return value.strftime("%B %Y")
+    return value

wbreport/tests/conftest.py

@@ -0,0 +1,24 @@
+from django.apps import apps
+from django.db.models.signals import pre_migrate
+from pytest_factoryboy import register
+from wbcore.contrib.color.factories import ColorGradientFactory
+from wbcore.contrib.geography.tests.signals import app_pre_migration
+from wbmailing.factories import MailTemplateFactory
+from wbreport.factories import (
+    ReportAssetFactory,
+    ReportCategoryFactory,
+    ReportClassFactory,
+    ReportFactory,
+    ReportVersionFactory,
+)
+
+register(ColorGradientFactory)
+register(ReportAssetFactory)
+register(ReportCategoryFactory)
+register(ReportClassFactory)
+register(ReportFactory)
+register(ReportVersionFactory)
+register(MailTemplateFactory)
+
+
+pre_migrate.connect(app_pre_migration, sender=apps.get_app_config("wbreport"))