wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/authentication/viewsets/users.py

@@ -0,0 +1,328 @@
+import logging
+
+from django.conf import settings
+from django.contrib.auth.models import Group, Permission
+from django.core.mail import EmailMultiAlternatives
+from django.db import IntegrityError
+from django.db.models import Q
+from django.db.models.functions import Coalesce
+from django.db.utils import DataError
+from django.shortcuts import get_object_or_404, redirect, render
+from django.template.loader import render_to_string
+from django.urls import reverse_lazy
+from django.utils.http import urlencode
+from django.utils.translation import gettext as _
+from rest_framework import filters, permissions, status
+from rest_framework.decorators import (
+    action,
+    api_view,
+    authentication_classes,
+    permission_classes,
+    renderer_classes,
+)
+from rest_framework.permissions import AllowAny
+from rest_framework.renderers import JSONRenderer
+from rest_framework.response import Response
+from rest_framework.reverse import reverse
+from rest_framework_simplejwt.views import TokenObtainPairView, TokenRefreshView
+from wbcore import viewsets
+from wbcore.utils.html import convert_html2text
+
+from ..models import User, UserActivity
+from ..serializers import (
+    ChangePasswordSerializer,
+    GroupModelSerializer,
+    GroupRepresentationSerializer,
+    MyTokenObtainPairSerializer,
+    MyTokenRefreshSerializer,
+    PermissionModelSerializer,
+    PermissionRepresentationSerializer,
+    UserModelSerializer,
+    UserProfileModelSerializer,
+    UserRepresentationSerializer,
+)
+from .buttons import UserModelButtonConfig, UserProfileButtonConfig
+from .display import (
+    UserModelDisplay,
+    UserPermissionModelDisplay,
+    UserProfileModelDisplay,
+)
+from .endpoints import (
+    UserPermissionsModelEndpointConfig,
+    UserProfileModelEndpointConfig,
+)
+from .titles import (
+    UserModelTitleConfig,
+    UserPermissionsModelTitleConfig,
+    UserProfileModelTitleConfig,
+)
+
+logger = logging.getLogger()
+
+
+@api_view(("POST",))
+@renderer_classes((JSONRenderer,))
+@permission_classes([AllowAny])
+@authentication_classes([])
+def reset_password_email(request):
+    try:
+        user = User.objects.get(email=request.data["email"])
+        user.reset_password(request)
+    except Exception:
+        pass
+    return Response(
+        {
+            "status": "ok",
+            "msg": _("If the email matches a user, it will receive an email inviting him to reset his password."),
+        },
+        status=status.HTTP_200_OK,
+    )
+
+
+@api_view(("POST",))
+@renderer_classes((JSONRenderer,))
+@permission_classes([AllowAny])
+@authentication_classes([])
+def register_user(request):
+    email = request.POST.get("email", "")
+    first_name = request.POST.get("first_name", "")
+    last_name = request.POST.get("last_name", "")
+    password = request.POST.get("password", "")
+    if len(first_name) > 100 or len(last_name) > 100:
+        return Response(
+            data={"status": "fail", "msg": _("first and last name are too long. please provider a shorter name.")},
+            status=status.HTTP_400_BAD_REQUEST,
+        )
+    if len(password) > 128:
+        return Response(
+            data={
+                "status": "fail",
+                "msg": _("password is too long. please provider a password shorter than 128 characters."),
+            },
+            status=status.HTTP_400_BAD_REQUEST,
+        )
+    if len(email) > 255:
+        return Response(
+            data={
+                "status": "fail",
+                "msg": _("email is too long. please provider an email shorter than 255 characters."),
+            },
+            status=status.HTTP_400_BAD_REQUEST,
+        )
+    if email and first_name and last_name and password:
+        try:
+            user = User.create_with_attributes(email, password, first_name=first_name, last_name=last_name)
+            query_params = {}
+            if success_redirect_url := request.POST.get("success_redirect_url", None):
+                query_params["success_redirect_url"] = success_redirect_url
+            if error_redirect_url := request.POST.get("error_redirect_url", None):
+                query_params["error_redirect_url"] = error_redirect_url
+
+            token = user.generate_temporary_token()
+            url = f'{reverse("wbcore:authentication:activate", args=[user.uuid, token], request=request)}?{urlencode(query_params)}'
+
+            # Construct registration mail and send
+            rendered_message = render_to_string("user_registration_email.html", {"user": user, "url": url})
+            email = EmailMultiAlternatives(
+                _("Activate your account."),
+                convert_html2text(rendered_message),
+                settings.DEFAULT_FROM_EMAIL,
+                to=[email],
+            )
+            email.attach_alternative(rendered_message, "text/html")
+            email.send()
+            return Response(
+                {"status": "success", "msg": _("Please confirm your email address to complete the registration")},
+                status=status.HTTP_200_OK,
+            )
+        except IntegrityError:
+            return Response(
+                {"status": "fail", "msg": _("Your account already exists")}, status=status.HTTP_409_CONFLICT
+            )
+        except DataError:
+            return Response(
+                {"status": "fail", "msg": _("Something went wrong with the submitted data, please try again later")},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+    return Response(
+        {"status": "fail", "msg": _("email, first_name, last_name and password must be provided")},
+        status=status.HTTP_400_BAD_REQUEST,
+    )
+
+
+@api_view(("GET",))
+@permission_classes([AllowAny])
+@authentication_classes([])
+def activate_user(request, uuid, token):
+    user = get_object_or_404(User, uuid=uuid)
+    if user.verify_temporary_token(token):
+        user.is_active = True
+        user.is_register = True
+        user.save()
+        # return redirect('home')
+        if success_redirect_url := request.GET.get("success_redirect_url", None):
+            return redirect(success_redirect_url, status=status.HTTP_200_OK)
+        return render(
+            request,
+            "activate_confirm.html",
+            {
+                "title": _("Activation Successful"),
+                "message": _("You are successfully registered. Please login"),
+                "button_title": _("Login"),
+                "redirect_url": getattr(settings, "AUTHENTICATION_ACTIVATION_REDIRECTION_URL", "/"),
+            },
+            status=status.HTTP_200_OK,
+        )
+    if error_redirect_url := request.GET.get("error_redirect_url", None):
+        return redirect(error_redirect_url)
+    else:
+        return render(
+            request,
+            "activate_confirm.html",
+            {
+                "title": _("Activation Failed"),
+                "message": _(
+                    "The registration link you clicked was probably expired or your account is already activated. Please try to register again."
+                ),
+                "button_title": _("Register"),
+                "redirect_url": reverse_lazy("wbcore:authentication:register"),
+            },
+            status=status.HTTP_400_BAD_REQUEST,
+        )
+
+
+class UserRepresentationViewSet(viewsets.RepresentationViewSet):
+    filter_backends = (filters.OrderingFilter, filters.SearchFilter)
+    queryset = User.objects.none()
+    serializer_class = UserRepresentationSerializer
+
+    def get_queryset(self):
+        if self.request.user.is_superuser or self.request.user.profile.is_internal:
+            return User.objects.all()
+        return User.objects.filter(id=self.request.user.id)
+
+    ordering_fields = ("username", "email", "date_joined")
+    search_fields = ("profile__first_name", "profile__last_name", "email")
+    ordering = ["email"]
+
+
+class GroupRepresentationViewSet(viewsets.RepresentationViewSet):
+    filter_backends = (
+        filters.OrderingFilter,
+        filters.SearchFilter,
+    )
+
+    ordering_fields = ordering = ("name",)
+    search_fields = ("name",)
+    queryset = Group.objects.all()
+    serializer_class = GroupRepresentationSerializer
+    ordering = ["name"]
+
+
+class PermissionRepresentationViewSet(viewsets.RepresentationViewSet):
+    filter_backends = (
+        filters.OrderingFilter,
+        filters.SearchFilter,
+    )
+
+    ordering_fields = ordering = ("name",)
+    search_fields = ("name",)
+    queryset = Permission.objects.all()
+    serializer_class = PermissionRepresentationSerializer
+
+
+class GroupViewSet(viewsets.ModelViewSet):
+    queryset = Group.objects.all()
+    serializer_class = GroupModelSerializer
+
+
+class PermissionViewSet(viewsets.ModelViewSet):
+    queryset = Permission.objects.all()
+    serializer_class = PermissionModelSerializer
+
+
+class UserPermissionsModelViewSet(PermissionViewSet):
+    title_config_class = UserPermissionsModelTitleConfig
+    endpoint_config_class = UserPermissionsModelEndpointConfig
+    display_config_class = UserPermissionModelDisplay
+
+    def get_queryset(self):
+        user = User.objects.get(id=self.kwargs["user_id"])
+        return Permission.objects.filter(Q(user__id=user.id) | Q(group__in=user.groups.all())).distinct()
+
+
+class UserProfileModelViewSet(viewsets.ModelViewSet):
+    title_config_class = UserProfileModelTitleConfig
+    endpoint_config_class = UserProfileModelEndpointConfig
+    button_config_class = UserProfileButtonConfig
+    display_config_class = UserProfileModelDisplay
+
+    serializer_class = UserProfileModelSerializer
+    queryset = User.objects.all()
+
+    def get_queryset(self):
+        return User.objects.filter(id=self.request.user.id)
+
+    @action(detail=True, methods=["PATCH"], permission_classes=[permissions.IsAuthenticated])
+    def change_password(self, request, pk=None):
+        user = get_object_or_404(User, id=pk)
+        data = request.POST.dict()
+        data["user"] = user
+        serializer = ChangePasswordSerializer(data=data, context={"request": request})
+        if serializer.is_valid():
+            user.set_password(request.data["new_password"])
+            user.save()
+            return Response({"__notification": {"title": _("Password changed.")}}, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @action(detail=True, methods=["GET"], permission_classes=[permissions.IsAuthenticated])
+    def reset_settings(self, request, pk=None):
+        return Response(True)
+
+
+class UserModelViewSet(viewsets.ModelViewSet):
+    queryset = User.objects.all()
+    search_fields = ("profile__computed_str", "email", "profile__emails__address", "username")
+    ordering_fields = ordering = ("email", "date_joined", "last_connection")
+
+    serializer_class = UserModelSerializer
+
+    filterset_fields = {
+        "email": ["exact", "icontains"],
+        "is_active": ["exact"],
+        "date_joined": ["gte", "exact", "lte"],
+    }
+    title_config_class = UserModelTitleConfig
+    button_config_class = UserModelButtonConfig
+    display_config_class = UserModelDisplay
+
+    def get_queryset(self):
+        if self.request.user.has_perm("authentication.administrate_user"):
+            qs = User.objects.all()
+        elif self.request.user.profile.is_internal:
+            qs = User.objects.filter(profile__relationship_managers=self.request.user.profile)
+        else:
+            qs = User.objects.filter(id=self.request.user.id)
+
+        return (
+            qs.annotate(last_connection=Coalesce(UserActivity.get_latest_login_datetime_subquery(use_user=True), None))
+            .select_related("profile")
+            .prefetch_related("groups", "user_permissions")
+        )
+
+    @action(detail=True, methods=["GET"], permission_classes=[permissions.IsAuthenticated])
+    def reset_password(self, request, pk=None):
+        user = get_object_or_404(User, id=pk)
+        try:
+            user.reset_password(request)
+            return Response({"detail": _("Reset Password E-Mail sent: Check your mailbox")})
+        except Exception:
+            return Response({"detail": _("Reset Password Failed. Please contact an administrator")}, status=500)
+
+
+class MyTokenObtainPairModelView(TokenObtainPairView):
+    serializer_class = MyTokenObtainPairSerializer
+
+
+class MyTokenRefreshModelView(TokenRefreshView):
+    serializer_class = MyTokenRefreshSerializer

wbcore/contrib/color/migrations/0001_initial.py

@@ -0,0 +1,33 @@
+# Generated by Django 4.2.6 on 2023-11-16 10:09
+
+import colorfield.fields
+import django_better_admin_arrayfield.models.fields
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = [("wbcore", "0013_delete_colorgradient")]
+
+    state_operations = [
+        migrations.CreateModel(
+            name="ColorGradient",
+            fields=[
+                ("id", models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("title", models.CharField(default="", max_length=128)),
+                (
+                    "colors",
+                    django_better_admin_arrayfield.models.fields.ArrayField(
+                        base_field=colorfield.fields.ColorField(
+                            default="#FF0000", image_field=None, max_length=18, samples=None
+                        ),
+                        default=list,
+                        size=None,
+                    ),
+                ),
+            ],
+        ),
+    ]
+
+    operations = state_operations

wbcore/contrib/color/migrations/0002_alter_colorgradient_colors.py

@@ -0,0 +1,25 @@
+# Generated by Django 5.0.3 on 2024-04-11 08:24
+
+import colorfield.fields
+import django_better_admin_arrayfield.models.fields
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("color", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="colorgradient",
+            name="colors",
+            field=django_better_admin_arrayfield.models.fields.ArrayField(
+                base_field=colorfield.fields.ColorField(
+                    default="#FF0000", image_field=None, max_length=25, samples=None
+                ),
+                default=list,
+                size=None,
+            ),
+        ),
+    ]

wbcore/contrib/currency/admin.py

@@ -0,0 +1,32 @@
+from typing import Any
+
+from django.contrib import admin
+from dynamic_preferences.registries import global_preferences_registry
+from wbcore.contrib.io.admin import ProviderGenericInline
+
+from .models import Currency, CurrencyFXRates
+
+
+@admin.register(Currency)
+class CurrencyModelAdmin(admin.ModelAdmin):
+    list_display = (
+        "key",
+        "title",
+    )
+    search_fields = ("key", "title", "symbol")
+    raw_id_fields = ["import_source"]
+
+    def refetch_import_data(self: Any, request: Any, queryset: Any) -> Any:
+        default_start_date = global_preferences_registry.manager()["currency__default_start_date_historical_import"]
+        CurrencyFXRates.import_data(start=default_start_date, queryset=queryset)
+
+    actions = [refetch_import_data]
+    inlines = [ProviderGenericInline]
+
+
+@admin.register(CurrencyFXRates)
+class CurrencyFXRatesModelAdmin(admin.ModelAdmin):
+    list_display = ("currency", "date", "value")
+    search_fields = ("currency__key", "currency__title", "currency__symbol")
+    list_filter = ["currency"]
+    raw_id_fields = ["import_source"]

wbcore/contrib/currency/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class CurrencyConfig(AppConfig):
+    name = "wbcore.contrib.currency"

wbcore/contrib/currency/dynamic_preferences_registry.py

@@ -0,0 +1,39 @@
+from datetime import date
+
+from dynamic_preferences.preferences import Section
+from dynamic_preferences.registries import global_preferences_registry
+from dynamic_preferences.types import (
+    DatePreference,
+    IntegerPreference,
+    StringPreference,
+)
+
+currency_section = Section("currency")
+
+
+@global_preferences_registry.register
+class DefaultCurrency(StringPreference):
+    section = currency_section
+    name = "default_currency"
+    default = "USD"
+
+    verbose_name = "Default Currency Used"
+
+
+@global_preferences_registry.register
+class DefaultStartDateHistoricalImport(DatePreference):
+    section = currency_section
+    name = "default_start_date_historical_import"
+    default = date(2000, 1, 1)
+
+    verbose_name = "Default Start Date"
+    help_text = "Default start date in historical import"
+
+
+@global_preferences_registry.register
+class TimedeltaImportCurrencyFXRate(IntegerPreference):
+    section = currency_section
+    name = "timedelta_import_currency_fx_rates"
+    default = 2
+
+    verbose_name = "The Timedelta for the currency rate import windows"

wbcore/contrib/currency/factories.py

@@ -0,0 +1,39 @@
+import pathlib
+
+import factory
+import yaml
+
+from .models import Currency, CurrencyFXRates
+
+with open(pathlib.Path(__file__).parent.joinpath("fixtures").joinpath("currency.yaml"), "r") as yaml_file:
+    currency_dict = yaml.load(yaml_file, Loader=yaml.CLoader)
+
+
+class CurrencyFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Currency
+        django_get_or_create = ["key"]
+
+    title = factory.Iterator(currency_dict, getter=lambda c: c["fields"]["title"])
+    symbol = factory.Iterator(currency_dict, getter=lambda c: c["fields"]["symbol"])
+    key = factory.Iterator(currency_dict, getter=lambda c: c["fields"]["key"])
+
+    @classmethod
+    def full_db(cls):
+        for _ in range(len(currency_dict)):
+            cls()
+
+
+class CurrencyUSDFactory(CurrencyFactory):
+    title = "US Dollar"
+    symbol = "$"
+    key = "USD"
+
+
+class CurrencyFXRatesFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = CurrencyFXRates
+
+    date = factory.Faker("date_object")
+    currency = factory.SubFactory(CurrencyFactory)
+    value = factory.Faker("pydecimal", min_value=1, max_value=999999, right_digits=6)

wbcore/contrib/currency/import_export/backends/__init__.py

@@ -0,0 +1 @@
+from .fixerio import *

wbcore/contrib/currency/import_export/backends/fixerio/__init__.py

@@ -0,0 +1 @@
+from .currency_fx_rates import DataBackend

wbcore/contrib/currency/import_export/backends/fixerio/currency_fx_rates.py

@@ -0,0 +1,66 @@
+import json
+from datetime import datetime
+from io import BytesIO
+from typing import Generator, Optional
+
+import pandas as pd
+import requests
+from django.db.models import QuerySet
+from dynamic_preferences.registries import global_preferences_registry
+from pandas.tseries.offsets import BDay
+from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.io.backends import AbstractDataBackend, register
+from wbcore.contrib.io.models import ImportCredential
+
+from ..utils import get_timedelta_import_currency_fx_rates
+
+
+@register("Currency FX Rates", provider_key="fixerio", save_data_in_import_source=False, passive_only=False)
+class DataBackend(AbstractDataBackend):
+    ENDPOINT = "https://data.fixer.io/api/"
+    HEADERS = {"user-agent": "stainly", "Content-Type": "application/json", "Accept": "application/json"}
+
+    def get_provider_id(self, obj: Currency) -> str:
+        return obj.key
+
+    def get_default_queryset(self) -> QuerySet[Currency]:
+        return Currency.objects.all()
+
+    def __init__(
+        self,
+        import_credential: Optional[ImportCredential] = None,
+        base_currency: Optional[str] = None,
+        **kwargs,
+    ):
+        if not import_credential or not import_credential.authentication_token:
+            raise ValueError("Fixer IO backend needs a valid import credential object")
+        if not base_currency:
+            base_currency = global_preferences_registry.manager()["currency__default_currency"]
+        self.authentication_token = import_credential.authentication_token
+        self.base_currency = base_currency
+
+    def get_files(
+        self,
+        execution_time: datetime,
+        obj_external_ids: Optional[list[str]] = None,
+        **kwargs,
+    ) -> Generator[tuple[str, BytesIO], None, None]:
+        execution_date = execution_time.date()
+        start = kwargs.get("start", execution_date - BDay(get_timedelta_import_currency_fx_rates() + 1))
+        params = {"access_key": self.authentication_token, "base": self.base_currency}
+        if (
+            obj_external_ids and len(obj_external_ids) < Currency.objects.count()
+        ):  # We add symbols only if the requests objects count is lower than the maximum expected currency
+            params["symbols"] = ",".join(obj_external_ids)
+        res = []
+        for _date in pd.date_range(start, execution_date, freq="B"):
+            r = requests.get(f'{self.ENDPOINT}/{_date.strftime("%Y-%m-%d")}?', params=params, headers=self.HEADERS)
+            if r.status_code == requests.codes.ok:
+                res_json = r.json()
+                if res_json and res_json["success"]:
+                    res.append(res_json)
+        if res:
+            content_file = BytesIO()
+            content_file.write(json.dumps(res).encode())
+            file_name = f"fixerio_currency_fx_rates_{start:%Y-%m-%d}_{execution_date:%Y-%m-%d}_{datetime.timestamp(execution_time)}.json"
+            yield file_name, content_file

wbcore/contrib/currency/import_export/backends/utils.py

@@ -0,0 +1,5 @@
+from dynamic_preferences.registries import global_preferences_registry
+
+
+def get_timedelta_import_currency_fx_rates():
+    return global_preferences_registry.manager()["currency__timedelta_import_currency_fx_rates"]

wbcore/contrib/currency/import_export/handlers/__init__.py

@@ -0,0 +1,2 @@
+from .currency import CurrencyImportHandler
+from .currency_fx_rates import CurrencyFXRatesImportHandler

wbcore/contrib/currency/import_export/handlers/currency.py

@@ -0,0 +1,24 @@
+from typing import Any, Dict
+
+from django.db import models
+from wbcore.contrib.io.imports import ImportExportHandler
+
+
+class CurrencyImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL: str = "currency.Currency"
+
+    def _deserialize(self, data: Dict[str, Any]):
+        if key := data.get("key"):
+            if key == "CNH":  # We switch CNH to CNY because we don't support it
+                data["key"] = "CNY"
+            if key == "GBp":
+                data["key"] = "GBX"
+
+    def _get_instance(self, data: Dict[str, Any], **kwargs) -> models.Model | None:
+        try:
+            if key := data.get("key", None):
+                return self.model.objects.get(key=key)
+            if _id := data.get("id", None):
+                return self.model.objects.get(id=_id)
+        except self.model.DoesNotExist:
+            pass

wbcore/contrib/currency/import_export/handlers/currency_fx_rates.py

@@ -0,0 +1,28 @@
+from datetime import datetime
+from decimal import Decimal
+from typing import Any, Dict, Optional
+
+from django.db import models
+from wbcore.contrib.io.imports import ImportExportHandler
+
+from .currency import CurrencyImportHandler
+
+
+class CurrencyFXRatesImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL: str = "currency.CurrencyFXRates"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.currency_handler = CurrencyImportHandler(self.import_source)
+
+    def _deserialize(self, data: Dict[str, Any]):
+        data["date"] = datetime.strptime(data["date"], "%Y-%m-%d").date()
+        data["currency"] = self.currency_handler.process_object(data["currency"])[0]
+        data["value"] = round(Decimal(data["value"]), 6)
+
+    def _get_instance(self, data: Dict[str, Any], history: Optional[models.QuerySet] = None, **kwargs) -> models.Model:
+        return self.model.objects.filter(currency=data["currency"], date=data["date"]).first()
+
+    def _create_instance(self, data: Dict[str, Any], **kwargs) -> models.Model:
+        self.import_source.log += "\nCreate Fx Rate."
+        return self.model.objects.create(**data, import_source=self.import_source)