wbcommission 2.2.1__py2.py3-none-any.whl

wbcommission/tests/models/test_rebate.py

@@ -0,0 +1,136 @@
+from unittest.mock import patch
+
+import pytest
+from django.contrib.auth import get_user_model
+from django.contrib.auth.models import Permission
+from faker import Faker
+from wbcommission.models import CommissionType, Rebate
+
+from .mixins import AccountManagerFixture
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestRebateModel(AccountManagerFixture):
+    def test_init(self, rebate):
+        assert rebate.id is not None
+
+    def test_rebate_view_permission(self, rebate_factory, user, commission_factory, commission_role_factory):
+        # Here we simply test that if the user can see the underlying commission line, they can see the rebate (i.e. we check that the permission is applied for the queryset)
+        # We do extensive unit testing on what commisison line a user can see on the corresponding test "test_filter_for_user"
+        hidden_commission = commission_factory.create()
+        hidden_rebate = rebate_factory.create(commission=hidden_commission)  # noqa
+
+        commission_with_role = commission_factory.create()
+        commission_role_factory.create(commission=commission_with_role, person=user.profile)
+        visible_rebate = rebate_factory.create(commission=commission_with_role)
+        assert set(Rebate.objects.filter_for_user(user)) == {visible_rebate}
+
+        user.user_permissions.add(
+            Permission.objects.get(content_type__app_label="wbcommission", codename="administrate_commission")
+        )
+        user = get_user_model().objects.get(id=user.id)
+        assert set(Rebate.objects.filter_for_user(user)) == {visible_rebate, hidden_rebate}
+
+    @patch.object(CommissionType, "compute_rebates")
+    @pytest.mark.parametrize("rebate_value", [fake.pydecimal(right_digits=4, min_value=0, max_value=1000000)])
+    def test_manage_rebate(self, mock_fct, commission_factory, fees_factory, rebate_value):
+        fees = fees_factory.create()
+        commission = commission_factory.create()
+        # We check that the method create a rebate if none exists
+        mock_fct.return_value = [
+            (
+                commission.account,
+                fees.transaction_date,
+                commission,
+                fees.linked_product,
+                commission.crm_recipient,
+                rebate_value,
+                dict(),
+            )
+        ]
+        Rebate.manage_rebate(commission.account)
+        new_rebate = Rebate.objects.get(
+            commission=commission,
+            product=fees.linked_product,
+            date=fees.transaction_date,
+            recipient=commission.crm_recipient,
+        )
+        assert new_rebate.value == rebate_value
+
+        # we check that the method update the existing rebate
+        mock_fct.return_value = [
+            (
+                commission.account,
+                fees.transaction_date,
+                commission,
+                fees.linked_product,
+                commission.crm_recipient,
+                rebate_value * 2,
+                dict(),
+            )
+        ]
+        Rebate.manage_rebate(commission.account)
+        new_rebate.refresh_from_db()
+        assert new_rebate.value == rebate_value * 2
+
+        # test that if rebate not valid anymore, a recomputation will automatically remove it
+        new_commission = commission_factory.create(account=commission.account)
+        mock_fct.return_value = [
+            (
+                commission.account,
+                fees.transaction_date,
+                new_commission,
+                fees.linked_product,
+                new_commission.crm_recipient,
+                rebate_value,
+                dict(),
+            )
+        ]
+        Rebate.manage_rebate(commission.account, prune_existing=True)
+        with pytest.raises((Rebate.DoesNotExist,)):
+            new_rebate.refresh_from_db()
+        assert (
+            Rebate.objects.get(
+                commission=new_commission,
+                product=fees.linked_product,
+                date=fees.transaction_date,
+                recipient=new_commission.crm_recipient,
+            ).value
+            == rebate_value
+        )
+
+    def test_account_merging(self, account_factory, rebate_factory):
+        """
+        We want to test that:
+        - Existing rebate for the same unique lookup arg are summed
+        - If not existing rebate, then account are shifted
+        """
+        base_account = account_factory.create()
+        merged_account = account_factory.create()
+        base_rebate = rebate_factory.create(account=base_account)
+        base_rebate.refresh_from_db()
+        base_value = base_rebate.value  # for safekeeping
+
+        # a rebate from the account that is going to be merged but with same date, recipient, product, and type. We expect this rebate to be deleted and its value summed to the base rebate
+        merged_rebate_but_similar = rebate_factory.create(
+            account=merged_account,
+            date=base_rebate.date,
+            recipient=base_rebate.recipient,
+            product=base_rebate.product,
+            commission_type=base_rebate.commission_type,
+        )
+        merged_rebate_but_similar.refresh_from_db()
+        # rebate from the merged account but completly different: there won't be any existing rebate, hence the account will just be shifted.
+        merged_rebate = rebate_factory.create(account=merged_account)
+
+        base_account.merge(merged_account)
+        base_rebate.refresh_from_db()
+        assert base_rebate.value == base_value + merged_rebate_but_similar.value
+
+        # check that the redundant rebate was deleted
+        with pytest.raises(Rebate.DoesNotExist):
+            merged_rebate_but_similar.refresh_from_db()
+        merged_rebate.refresh_from_db()
+        assert merged_rebate.account == base_account

wbcommission/tests/test_permissions.py

@@ -0,0 +1,66 @@
+import pytest
+from django.contrib.auth.models import Permission
+from faker import Faker
+from rest_framework.reverse import reverse
+from rest_framework.test import APIClient
+from wbcommission.permissions import IsCommissionAdmin
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.contrib.authentication.models import User
+from wbcore.tests.test_permissions.test_backend import create_internal_user
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestPermissionClass:
+    @pytest.fixture()
+    def admin_user(self):
+        user = UserFactory.create()
+        user.user_permissions.add(
+            Permission.objects.get(content_type__app_label="wbcommission", codename="administrate_commission")
+        )
+        return User.objects.get(id=user.id)
+
+    def test_normal_user_permission(self, rf, user):
+        rf.user = user
+        assert not IsCommissionAdmin().has_permission(rf, None)
+
+    def test_admin_permission(self, rf, admin_user):
+        rf.user = admin_user
+        assert IsCommissionAdmin().has_permission(rf, None)
+
+    def test_recompute_only_for_admin(self, user, admin_user):
+        client = APIClient()
+        url = reverse("wbcommission:rebate-recompute")
+
+        client.force_authenticate(user=user)
+        response = client.patch(url, data={"start_date": fake.date_object()})
+        assert response.status_code == 403
+
+        client.force_authenticate(user=admin_user)
+        response = client.patch(url, data={"start_date": fake.date_object()})
+        assert response.status_code == 200
+
+    def test_auditreport_only_for_admin(self, user, admin_user, company):
+        client = APIClient()
+        url = reverse("wbcommission:rebate-auditreport")
+
+        client.force_authenticate(user=user)
+        response = client.patch(url + f"?recipient_id={company.id}")
+        assert response.status_code == 403
+
+        client.force_authenticate(user=admin_user)
+        response = client.patch(url + f"?recipient_id={company.id}")
+        assert response.status_code == 200
+
+    def test_customerreport_only_for_internaluser(self, user, admin_user, company):
+        client = APIClient()
+        url = reverse("wbcommission:rebate-customerreport")
+
+        client.force_authenticate(user=user)
+        response = client.patch(url + f"?recipient_id={company.id}")
+        assert response.status_code == 403
+
+        client.force_authenticate(user=create_internal_user())
+        response = client.patch(url + f"?recipient_id={company.id}")
+        assert response.status_code == 200

wbcommission/tests/viewsets/test_rebate.py

@@ -0,0 +1,76 @@
+import pytest
+from django.db.models import Sum
+from faker import Faker
+from rest_framework.test import APIRequestFactory
+from wbcommission.factories import (
+    AccountTypeRoleCommissionFactory,
+    CommissionFactory,
+    RebateFactory,
+)
+from wbcommission.models.rebate import Rebate
+from wbcommission.viewsets.rebate import RebateModelViewSet, RebatePandasView
+from wbcore.contrib.authentication.factories.users import UserFactory
+from wbcore.contrib.directory.models import Entry
+from wbcore.utils.strings import format_number
+from wbcrm.factories.accounts import AccountFactory, AccountRoleFactory
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestRebateModelViewSet:
+    @pytest.fixture
+    def account_user(self):
+        # True, we create a superuser
+
+        # if fake.pybool():
+        #     user = UserFactory.create(is_superuser=True)
+        # else:
+        user = UserFactory.create(is_superuser=False)
+        entry = Entry.objects.get(id=user.profile.id)
+
+        # Create a bunch of account and roles
+        public_account = AccountFactory.create(is_public=True)
+        role = AccountRoleFactory.create(account=public_account, entry=entry)
+        RebateFactory.create(
+            account=public_account,
+            commission=AccountTypeRoleCommissionFactory.create(account_role_type_recipient=role.role_type),
+        )  # shown rebate
+
+        RebateFactory.create(commission=CommissionFactory.create(crm_recipient=entry))  # shown rebate
+        RebateFactory.create()  # hidden rebate
+        return user
+
+    def test_ensure_permission_on_rebatetable(self, account_user):
+        """
+        We ensure that all claims viewset doesn't show more that what the user is allowed to see.
+        For claim, the allowed claim are all the claims where the account is among the account they is allowed to see
+        """
+        allowed_rebates = Rebate.objects.filter_for_user(account_user)
+
+        request = APIRequestFactory().get("")
+        request.query_params = {}
+        request.user = account_user
+        viewset = RebatePandasView(request=request)
+        assert allowed_rebates.exists()
+        assert allowed_rebates.count() < Rebate.objects.count()  # Ensure that the filtering works
+        assert set(allowed_rebates) == set(viewset.get_queryset())
+        assert not viewset._get_dataframe().empty
+
+    def test_ensure_permission_on_rebatemodelview(self, account_user):
+        """
+        We ensure that all claims viewset doesn't show more that what the user is allowed to see.
+        For claim, the allowed claim are all the claims where the account is among the account they is allowed to see
+        """
+        allowed_rebates = Rebate.objects.filter_for_user(account_user)
+
+        request = APIRequestFactory().get("")
+        request.user = account_user
+        viewset = RebateModelViewSet(request=request)
+        queryset = viewset.get_queryset()
+        assert allowed_rebates.exists()
+        assert allowed_rebates.count() < Rebate.objects.count()  # Ensure that the filtering works
+        assert set(allowed_rebates) == set(queryset)
+        assert viewset.get_aggregates(queryset, queryset)["value_usd"]["Σ"] == float(
+            format_number(allowed_rebates.aggregate(s=Sum("value"))["s"])
+        )

wbcommission/urls.py

@@ -0,0 +1,42 @@
+from django.apps import apps
+from django.urls import include, path
+from wbcommission import viewsets
+from wbcore.routers import WBCoreRouter
+
+router = WBCoreRouter()
+
+router.register(
+    r"rebatemarginalitytable",
+    viewsets.RebateProductMarginalityViewSet,
+    basename="rebatemarginalitytable",
+)
+router.register(
+    r"rebatetable",
+    viewsets.RebatePandasView,
+    basename="rebatetable",
+)
+router.register(
+    r"rebate",
+    viewsets.RebateModelViewSet,
+    basename="rebate",
+)
+router.register(
+    r"commissiontype",
+    viewsets.CommissionTypeModelViewSet,
+    basename="commissiontype",
+)
+router.register(
+    r"commissiontyperepresentation",
+    viewsets.CommissionTypeRepresentationModelViewSet,
+    basename="commissiontyperepresentation",
+)
+
+if apps.is_installed("wbportfolio"):
+    from wbportfolio.viewsets.transactions.claim import ClaimAPIModelViewSet
+
+    router.register(r"claim-api", ClaimAPIModelViewSet, basename="claim-api")
+
+account_router = WBCoreRouter()
+
+
+urlpatterns = [path("", include(router.urls)), path("account/<int:account_id>/", include(account_router.urls))]

wbcommission/viewsets/__init__.py

@@ -0,0 +1,7 @@
+from .buttons import *  # noqa
+from .rebate import (
+    RebateModelViewSet,
+    RebatePandasView,
+    RebateProductMarginalityViewSet,
+)
+from .commissions import CommissionTypeRepresentationModelViewSet, CommissionTypeModelViewSet

wbcommission/viewsets/buttons/__init__.py

@@ -0,0 +1,2 @@
+from .signals import *
+from .rebate import RebateTableButtonConfig

wbcommission/viewsets/buttons/rebate.py

@@ -0,0 +1,46 @@
+from django.utils.translation import gettext as _
+from rest_framework.reverse import reverse
+from wbcore import serializers as wb_serializers
+from wbcore.contrib.icons import WBIcon
+from wbcore.enums import RequestType
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    create_simple_display,
+)
+from wbcore.utils.date import current_quarter_date_start
+from wbcrm.models.accounts import Account
+from wbcrm.serializers.accounts import AccountRepresentationSerializer
+
+
+class RebateTableButtonConfig(ButtonViewConfig):
+    def get_custom_buttons(self):
+        class RecomputeRebateSerializer(wb_serializers.Serializer):
+            start_date = wb_serializers.DateField(label=_("Start"), default=current_quarter_date_start)
+            only_accounts = wb_serializers.PrimaryKeyRelatedField(queryset=Account.objects.filter(level=0))
+            _only_accounts = AccountRepresentationSerializer(
+                source="only_accounts", filter_params={"level": 0}, many=True
+            )
+            prune_existing = wb_serializers.BooleanField(
+                default=False,
+                help_text="If true, existing rebate for the specified accounts and start date will be deleted before regenerated. Usually necessary if commission rule were lowered or claim removed from account",
+            )
+
+        if self.request.user.has_perm("wbcommission.administrate_commission"):
+            return {
+                bt.ActionButton(
+                    method=RequestType.PATCH,
+                    identifiers=("wbcommission:rebates",),
+                    action_label="Trigger Rebate computation",
+                    endpoint=reverse("wbcommission:rebate-recompute", args=[], request=self.request),
+                    description_fields="<p>Trigger Rebate computation</p>",
+                    serializer=RecomputeRebateSerializer,
+                    icon=WBIcon.REGENERATE.icon,
+                    title="Trigger Rebate computation",
+                    label="Trigger Rebate computation",
+                    instance_display=create_simple_display(
+                        [["start_date", "prune_existing"], ["only_accounts", "only_accounts"]]
+                    ),
+                ),
+            }
+        return {}

wbcommission/viewsets/buttons/signals.py

@@ -0,0 +1,53 @@
+from django.dispatch import receiver
+from wbcore.contrib.directory.viewsets import (
+    CompanyModelViewSet,
+    EntryModelViewSet,
+    PersonModelViewSet,
+)
+from wbcore.contrib.icons import WBIcon
+from wbcore.enums import RequestType
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    create_simple_display,
+)
+from wbcore.signals.instance_buttons import add_instance_button
+from wbcore.utils.serializers import StartEndDateSerializer
+
+
+@receiver(add_instance_button, sender=PersonModelViewSet)
+@receiver(add_instance_button, sender=EntryModelViewSet)
+@receiver(add_instance_button, sender=CompanyModelViewSet)
+def crm_adding_instance_buttons(sender, many, *args, **kwargs):
+    if many:
+        return
+    return bt.DropDownButton(
+        label="Commission",
+        icon=WBIcon.UNFOLD.icon,
+        buttons=(
+            bt.WidgetButton(key="rebates", label="Rebates", icon=WBIcon.DEAL_MONEY.icon),
+            bt.ActionButton(
+                method=RequestType.PATCH,
+                identifiers=("wbcommission:rebates",),
+                action_label="Send Customer Report",
+                key="generate_customer_commission_report",
+                description_fields="<p>Generate Commission Report</p>",
+                serializer=StartEndDateSerializer,
+                icon=WBIcon.CHART_SWITCHES.icon,
+                title="Generate Commission reports",
+                label="Generate Commission reports",
+                instance_display=create_simple_display([["start"], ["end"]]),
+            ),
+            bt.ActionButton(
+                method=RequestType.PATCH,
+                identifiers=("wbcommission:rebates",),
+                action_label="Send Audit Report",
+                key="generate_audit_commission_report",
+                description_fields="<p>Generate Audit Commission Report</p>",
+                serializer=StartEndDateSerializer,
+                icon=WBIcon.NOTEBOOK.icon,
+                title="Generate Audit Commission reports",
+                label="Generate Audit Commission reports",
+                instance_display=create_simple_display([["start"], ["end"]]),
+            ),
+        ),
+    )

wbcommission/viewsets/commissions.py

@@ -0,0 +1,21 @@
+from wbcommission.models import CommissionType
+from wbcore import viewsets
+
+from ..serializers import (
+    CommissionTypeModelSerializer,
+    CommissionTypeRepresentationSerializer,
+)
+from .display import CommissionTypeDisplayConfigClass
+
+
+class CommissionTypeRepresentationModelViewSet(viewsets.RepresentationViewSet):
+    serializer_class = CommissionTypeRepresentationSerializer
+    queryset = CommissionType.objects.all()
+    ordering_fields = search_fields = ordering = ["name"]
+
+
+class CommissionTypeModelViewSet(viewsets.ModelViewSet):
+    serializer_class = CommissionTypeModelSerializer
+    queryset = CommissionType.objects.all()
+    ordering_fields = search_fields = ordering = ["name"]
+    display_config_class = CommissionTypeDisplayConfigClass

wbcommission/viewsets/display/__init__.py

@@ -0,0 +1,5 @@
+from .rebate import (
+    RebatePandasViewDisplayConfig,
+    RebateProductMarginalityDisplayConfig,
+)
+from .commissions import CommissionTypeDisplayConfigClass

wbcommission/viewsets/display/commissions.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+)
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class CommissionTypeDisplayConfigClass(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="name", label="Name"),
+                dp.Field(key="key", label="Key"),
+            ]
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display([["name", "key"]])

wbcommission/viewsets/display/rebate.py

@@ -0,0 +1,117 @@
+from typing import Optional
+
+from wbcore.enums import Unit
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class RebatePandasViewDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="title", label="Title"),
+                *[dp.Field(key="rebate_" + k, label=v) for k, v in self.view.rebate_types.items()],
+                dp.Field(key="rebate_total", label="Total Rebate"),
+            ]
+        )
+
+
+class RebateProductMarginalityDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="title", label="Product", width=Unit.PIXEL(400)),
+                dp.Field(
+                    label="Management",
+                    open_by_default=False,
+                    key=None,
+                    children=[
+                        dp.Field(key="base_management_fees_percent", label="Base Fees", width=Unit.PIXEL(400)),
+                        dp.Field(key="management_fees", label="Fees", width=Unit.PIXEL(120)),
+                        dp.Field(key="management_rebates", label="Rebates", width=Unit.PIXEL(120)),
+                        dp.Field(key="management_marginality", label="Marginality", width=Unit.PIXEL(120)),
+                        dp.Field(
+                            key="net_management_marginality",
+                            label="Net Marginality",
+                            width=Unit.PIXEL(150),
+                            formatting_rules=[
+                                dp.FormattingRule(
+                                    style={
+                                        "fontWeight": "bold",
+                                    },
+                                ),
+                            ],
+                        ),
+                    ],
+                ),
+                dp.Field(
+                    label="Performance",
+                    open_by_default=False,
+                    key=None,
+                    children=[
+                        dp.Field(key="base_performance_fees_percent", label="Base Fees", width=Unit.PIXEL(120)),
+                        dp.Field(key="performance_fees", label="Fees", width=Unit.PIXEL(120)),
+                        dp.Field(key="performance_rebates", label="Rebates", width=Unit.PIXEL(120)),
+                        dp.Field(key="performance_marginality", label="Marginality", width=Unit.PIXEL(120)),
+                        dp.Field(
+                            key="net_performance_marginality",
+                            label="Net Marginality",
+                            width=Unit.PIXEL(150),
+                            formatting_rules=[
+                                dp.FormattingRule(
+                                    style={
+                                        "fontWeight": "bold",
+                                    },
+                                ),
+                            ],
+                        ),
+                    ],
+                ),
+                dp.Field(
+                    label="Total",
+                    open_by_default=False,
+                    key=None,
+                    children=[
+                        dp.Field(key="total_fees", label="Fees", width=Unit.PIXEL(120)),
+                        dp.Field(key="total_rebates", label="Rebates", width=Unit.PIXEL(120)),
+                        dp.Field(key="total_marginality_percent", label="Marginality", width=Unit.PIXEL(120)),
+                        dp.Field(
+                            key="total_fees_usd",
+                            label="Fees ($)",
+                            width=Unit.PIXEL(120),
+                            formatting_rules=[
+                                dp.FormattingRule(
+                                    style={
+                                        "fontWeight": "bold",
+                                    },
+                                ),
+                            ],
+                        ),
+                        dp.Field(
+                            key="total_rebates_usd",
+                            label="Rebates ($)",
+                            width=Unit.PIXEL(120),
+                            formatting_rules=[
+                                dp.FormattingRule(
+                                    style={
+                                        "fontWeight": "bold",
+                                    },
+                                ),
+                            ],
+                        ),
+                        dp.Field(
+                            key="total_marginality_usd",
+                            label="Net Marginality ($)",
+                            width=Unit.PIXEL(120),
+                            formatting_rules=[
+                                dp.FormattingRule(
+                                    style={
+                                        "fontWeight": "bold",
+                                    },
+                                ),
+                            ],
+                        ),
+                    ],
+                ),
+            ]
+        )

wbcommission/viewsets/endpoints/__init__.py

@@ -0,0 +1,4 @@
+from wbcommission.viewsets.endpoints.rebate import (
+    RebatePandasViewEndpointConfig,
+    RebateProductMarginalityEndpointConfig,
+)

wbcommission/viewsets/endpoints/rebate.py

@@ -0,0 +1,21 @@
+from rest_framework.reverse import reverse
+from wbcore.metadata.configs.endpoints import EndpointViewConfig
+
+
+class RebatePandasViewEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        return None
+
+    def get_list_endpoint(self, **kwargs):
+        return reverse("wbcommission:rebatetable-list", request=self.request)
+
+
+class RebateProductMarginalityEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        return None
+
+    def get_list_endpoint(self, **kwargs):
+        return reverse("wbcommission:rebatemarginalitytable-list", request=self.request)
+
+    def get_instance_endpoint(self, **kwargs):
+        return reverse("wbportfolio:product-list", request=self.request)

wbcommission/viewsets/menu/__init__.py

@@ -0,0 +1 @@
+from .rebate import REBATE_MARGINALITY_MENUITEM, REBATE_MENUITEM

wbcommission/viewsets/menu/rebate.py

@@ -0,0 +1,13 @@
+from wbcore.menus import ItemPermission, MenuItem
+from wbportfolio.permissions import is_manager
+
+REBATE_MENUITEM = MenuItem(
+    label="Rebates",
+    endpoint="wbcommission:rebatetable-list",
+    permission=ItemPermission(permissions=["wbcommission.view_rebate"]),
+)
+REBATE_MARGINALITY_MENUITEM = MenuItem(
+    label="Marginality",
+    endpoint="wbcommission:rebatemarginalitytable-list",
+    permission=ItemPermission(permissions=["wbcommission.view_rebate"], method=is_manager),
+)