wbcrm 1.56.8__py2.py3-none-any.whl

wbcrm/report/activity_report.py

@@ -0,0 +1,110 @@
+from datetime import datetime
+from io import BytesIO
+
+import xlsxwriter
+from celery import shared_task
+from django.conf import settings
+from django.core.mail import EmailMultiAlternatives
+from django.db.models import Q
+from django.template.loader import get_template
+from django.utils import timezone
+from django.utils.html import strip_tags
+from django.utils.translation import gettext as _
+from wbcore.contrib.directory.models import Person
+from wbcrm.models import Activity, ActivityType
+from xlsxwriter.utility import xl_rowcol_to_cell
+
+
+def set_cell(worksheet, row, col, value, width_cols, base_format):
+    cell = xl_rowcol_to_cell(row, col)
+    if value:
+        worksheet.write_string(cell, value, base_format)
+        if len(value) > width_cols[col]:
+            width_cols[col] = len(value)
+
+
+@shared_task
+def create_report_and_send(profile_id, employee_id, start_date=None, end_date=None):
+    employee = Person.all_objects.get(id=employee_id)
+    profile = Person.all_objects.get(id=profile_id)
+    if end_date is None:
+        end_date = timezone.now()
+    if start_date is None:
+        start_date = datetime(year=end_date.year, month=1, day=1, hour=0, minute=0, second=0)
+
+    report = create_report(employee_id, start_date, end_date)
+
+    html = get_template("email/activity_report.html")
+
+    context = {"profile": profile, "employee": employee}
+    html_content = html.render(context)
+
+    msg = EmailMultiAlternatives(
+        _("Report"), strip_tags(html_content), settings.DEFAULT_FROM_EMAIL, [profile.user_account.email]
+    )
+    msg.attach_alternative(html_content, "text/html")
+    title = _("all")
+    if start_date and end_date:
+        title = "{}_{}".format(start_date.strftime("%m/%d/%Y-%H:%M:%S"), end_date.strftime("%m/%d/%Y-%H:%M:%S"))
+    msg.attach(
+        "report_{}_{}.xlsx".format(employee.computed_str, title),
+        report.read(),
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    )
+    msg.send()
+
+
+def create_report(employee, start_date, end_date):
+    output = BytesIO()
+    workbook = xlsxwriter.Workbook(output, {"in_memory": True})
+
+    base_format = workbook.add_format({"font_name": "Liberation Sans", "font_size": 10})
+    bold_format = workbook.add_format({"font_name": "Liberation Sans", "font_size": 10, "bold": True})
+    related_activities = Activity.objects.filter(
+        Q(participants__id=employee) | Q(creator__id=employee) | Q(assigned_to__id=employee)
+    )
+    activities = Activity.get_inrange_activities(related_activities, start_date, end_date)
+    # HERE STARTS THE FIRST WORKSHEET
+    for type in ActivityType.objects.all():
+        width_cols = [5, 5, 16, 8, 7, 11, 12]
+        activities_type = activities.filter(type=type.id)
+        worksheet = workbook.add_worksheet(type.title)
+        worksheet.write_string(0, 0, _("Title"), bold_format)
+        worksheet.write_string(0, 1, _("Start"), bold_format)
+        worksheet.write_string(0, 2, _("Duration (hours)"), bold_format)
+        worksheet.write_string(0, 3, _("Location"), bold_format)
+        worksheet.write_string(0, 4, _("Creator"), bold_format)
+        worksheet.write_string(0, 5, _("Assigned to"), bold_format)
+        worksheet.write_string(0, 6, _("Participants"), bold_format)
+
+        worksheet.write_string(2, 0, _("Total"), bold_format)
+        worksheet.write_string(2, 1, str(len(activities_type.all())), bold_format)
+
+        for row, activity in enumerate(activities_type.all(), start=4):
+            hours = (activity.period.upper - activity.period.lower).total_seconds() / 3600
+            duration = format(hours, ".2f")
+            creator = activity.creator
+            creator_name = ""
+            if creator:
+                creator_name = creator.computed_str
+            assigned_to = activity.assigned_to
+            assigned_to_name = ""
+            if assigned_to:
+                assigned_to_name = assigned_to.computed_str
+            participants = ", ".join([participant.computed_str for participant in activity.participants.all()])
+
+            set_cell(worksheet, row, 0, activity.title, width_cols, base_format)
+            set_cell(worksheet, row, 1, f"{activity.period.lower:%d.%m.%Y}", width_cols, base_format)
+            set_cell(worksheet, row, 2, duration, width_cols, base_format)
+            set_cell(worksheet, row, 2, activity.location, width_cols, base_format)
+            set_cell(worksheet, row, 4, creator_name, width_cols, base_format)
+            set_cell(worksheet, row, 5, assigned_to_name, width_cols, base_format)
+            set_cell(worksheet, row, 6, participants, width_cols, base_format)
+
+        for col, max_width in enumerate(width_cols):
+            if max_width > 300:
+                max_width = 300
+            worksheet.set_column(col, col, max_width)
+    workbook.close()
+    output.seek(0)
+    return output

wbcrm/serializers/__init__.py

@@ -0,0 +1,23 @@
+from .accounts import (
+    AccountModelSerializer,
+    AccountRepresentationSerializer,
+    TerminalAccountRepresentationSerializer,
+    AccountRoleModelSerializer,
+    AccountRoleTypeRepresentationSerializer,
+)
+from .activities import (
+    ActivityModelListSerializer,
+    ActivityModelSerializer,
+    ReadOnlyActivityModelSerializer,
+    ActivityParticipantModelSerializer,
+    ActivityRepresentationSerializer,
+    ActivityTypeModelSerializer,
+    ActivityTypeRepresentationSerializer,
+)
+from .groups import GroupModelSerializer, GroupRepresentationSerializer
+from .products import (
+    ProductCompanyRelationshipModelSerializer,
+    ProductModelSerializer,
+    ProductRepresentationSerializer,
+)
+from .signals import *

wbcrm/serializers/accounts.py

@@ -0,0 +1,141 @@
+from django.apps import apps
+from django.contrib.messages import warning
+from django.utils.translation import gettext_lazy as _
+from rest_framework.reverse import reverse
+from rest_framework.validators import UniqueValidator
+from wbcore import serializers as wb_serializers
+from wbcore.contrib.authentication.models import User
+from wbcore.contrib.authentication.serializers import UserRepresentationSerializer
+from wbcore.contrib.directory.serializers import EntryRepresentationSerializer
+
+from wbcrm.models.accounts import Account, AccountRole, AccountRoleType
+
+
+class AccountRoleTypeRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    class Meta:
+        model = AccountRoleType
+        fields = ("id", "title")
+
+
+class AccountRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbcrm:account-detail")
+
+    def get_filter_params(self, request):
+        return {"is_active": True}
+
+    class Meta:
+        model = Account
+        fields = ("id", "computed_str", "_detail")
+
+
+class TerminalAccountRepresentationSerializer(AccountRepresentationSerializer):
+    def get_filter_params(self, request):
+        filter_params = {"is_terminal_account": True, "status": "OPEN", "is_active": True}
+        if view := request.parser_context.get("view", None):
+            if entry_id := view.kwargs.get("entry_id", None):
+                filter_params["customer"] = entry_id
+            if account_id := view.kwargs.get("account_id", None):
+                filter_params["account"] = account_id
+        return filter_params
+
+
+class AccountModelSerializer(wb_serializers.ModelSerializer):
+    _parent = AccountRepresentationSerializer(source="parent")
+    _owner = EntryRepresentationSerializer(source="owner")
+    _group_key = wb_serializers.CharField(read_only=True)
+    reference_id = wb_serializers.IntegerField(
+        label="Reference ID",
+        default=lambda: Account.get_next_available_reference_id(),
+        read_only=lambda view: not view.new_mode,
+        validators=[UniqueValidator(queryset=Account.objects.all())],
+    )
+
+    @wb_serializers.register_resource()
+    def additional_resources(self, instance, request, user):
+        request = self.context["request"]
+
+        custom_buttons = {
+            "childaccounts": reverse("wbcrm:account-childaccount-list", args=[instance.id], request=request),
+            "accountroles": reverse("wbcrm:account-accountrole-list", args=[instance.id], request=request),
+            "inheritedaccountroles": reverse("wbcrm:account-inheritedrole-list", args=[instance.id], request=request),
+        }
+        if apps.is_installed("wbportfolio"):  # TODO move as signal
+            custom_buttons["claims"] = reverse("wbportfolio:account-claim-list", args=[instance.id], request=request)
+
+        return custom_buttons
+
+    relationship_status = wb_serializers.RangeSelectField(
+        color="rgb(220,20,60)",
+        label="Relationship Status",
+        start=1,
+        end=5,
+        step_size=1,
+        read_only=True,
+        required=False,
+    )
+
+    class Meta:
+        model = Account
+        fields = (
+            "id",
+            "_group_key",
+            "title",
+            "status",
+            "is_active",
+            "is_terminal_account",
+            "is_public",
+            "_parent",
+            "parent",
+            "_owner",
+            "owner",
+            "reference_id",
+            "computed_str",
+            "relationship_status",
+            "relationship_summary",
+            "action_plan",
+            "_additional_resources",
+        )
+
+
+class AccountRoleModelSerializer(wb_serializers.ModelSerializer):
+    _entry = EntryRepresentationSerializer(source="entry")
+    _account = AccountRepresentationSerializer(source="account")
+    _role_type = AccountRoleTypeRepresentationSerializer(source="role_type")
+    is_currently_valid = wb_serializers.BooleanField(read_only=True, default=False)
+
+    _authorized_hidden_users = UserRepresentationSerializer(source="authorized_hidden_users", many=True)
+
+    def create(self, validated_data):
+        # We return a get or create role because we don't want to leak information on already existing role that the user might not be able to see
+        # this way, the account role (even if already existing) will be returned and the permission mixin will take over
+        authorized_hidden_users = validated_data.pop("authorized_hidden_users", [])
+        instance, created = AccountRole.objects.get_or_create(
+            entry=validated_data.pop("entry"), account=validated_data.pop("account"), defaults=validated_data
+        )
+        if authorized_hidden_users:
+            instance.authorized_hidden_users.set(authorized_hidden_users)
+        if request := self.context.get("request"):
+            if not User.objects.filter(profile_id=instance.entry.id).exists():
+                warning(
+                    request,
+                    _(
+                        "The selected entry does not have an associated user account. Note: Notifications cannot be sent to users without an account."
+                    ),
+                )
+        return instance
+
+    class Meta:
+        model = AccountRole
+        fields = (
+            "id",
+            "role_type",
+            "_role_type",
+            "entry",
+            "_entry",
+            "account",
+            "_account",
+            "is_currently_valid",
+            "is_hidden",
+            "authorized_hidden_users",
+            "_authorized_hidden_users",
+        )