wbhuman_resources 1.58.4__py2.py3-none-any.whl

wbhuman_resources/viewsets/absence.py

@@ -0,0 +1,312 @@
+from django.contrib.messages import info, warning
+from django.db.models import Case, CharField, F, Q, Sum, Value, When
+from django.db.models.functions import Concat, Extract
+from django.shortcuts import get_object_or_404
+from django.utils import timezone
+from django.utils.functional import cached_property
+from django.utils.translation import gettext
+from rest_framework import filters
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from wbcore import viewsets
+from wbcore.contrib.agenda.models import CalendarItem
+from wbcore.contrib.icons import WBIcon
+from wbcore.filters import DjangoFilterBackend
+from wbcore.utils.strings import format_number
+
+from wbhuman_resources.filters import (
+    AbsenceRequestEmployeeHumanResourceFilterSet,
+    AbsenceRequestFilter,
+    AbsenceTypeCountEmployeeModelFilterSet,
+)
+from wbhuman_resources.models import (
+    AbsenceRequest,
+    AbsenceRequestPeriods,
+    AbsenceRequestType,
+    EmployeeHumanResource,
+)
+from wbhuman_resources.serializers import (
+    AbsenceRequestCrossBorderCountryModelSerializer,
+    AbsenceRequestModelSerializer,
+    AbsenceRequestPeriodsModelSerializer,
+    AbsenceRequestTypeModelSerializer,
+    AbsenceRequestTypeRepresentationSerializer,
+    EmployeeAbsenceDaysModelSerializer,
+)
+from wbhuman_resources.viewsets.buttons import AbsenceRequestButtonConfig
+from wbhuman_resources.viewsets.display import (
+    AbsenceRequestCrossBorderCountryDisplayConfig,
+    AbsenceRequestDisplayConfig,
+    AbsenceRequestEmployeeHumanResourceDisplayConfig,
+    AbsenceRequestPeriodsAbsenceRequestDisplayConfig,
+    AbsenceRequestTypeDisplayConfig,
+    AbsenceTypeCountEmployeeDisplayConfig,
+)
+from wbhuman_resources.viewsets.endpoints import (
+    AbsenceRequestCrossBorderCountryEndpointConfig,
+    AbsenceRequestEmployeeHumanResourceEndpointConfig,
+    AbsenceRequestEndpointConfig,
+    AbsenceRequestPeriodsAbsenceRequestEndpointConfig,
+    AbsenceTypeCountEmployeeEndpointConfig,
+)
+from wbhuman_resources.viewsets.titles import (
+    AbsenceRequestEmployeeBalanceTitleConfig,
+    AbsenceTypeCountEmployeeTitleConfig,
+)
+
+from ..models.absence import can_validate_or_deny_request
+from .mixins import EmployeeViewMixin
+
+
+class AbsenceRequestTypeRepresentationViewSet(viewsets.RepresentationViewSet):
+    IDENTIFIER = "wbhuman_resources:absencerequesttyperepresentation"
+    queryset = AbsenceRequestType.objects.all()
+    serializer_class = AbsenceRequestTypeRepresentationSerializer
+
+
+class AbsenceRequestCrossBorderCountryModelViewSet(viewsets.ModelViewSet):
+    queryset = AbsenceRequestType.crossborder_countries.through.objects.all()
+    serializer_class = AbsenceRequestCrossBorderCountryModelSerializer
+    ordering = ordering_fields = search_fields = ["geography_repr"]
+
+    endpoint_config_class = AbsenceRequestCrossBorderCountryEndpointConfig
+    display_config_class = AbsenceRequestCrossBorderCountryDisplayConfig
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(absencerequesttype=self.kwargs["absencerequesttype_id"])
+            .annotate(geography_repr=F("geography__name"))
+            .select_related("geography")
+        )
+
+
+class AbsenceRequestModelViewSet(EmployeeViewMixin, viewsets.ModelViewSet):
+    queryset = AbsenceRequest.objects.all()
+    serializer_class = AbsenceRequestModelSerializer
+
+    ordering_fields = [
+        "employee__profile__computed_str",
+        "period__startswith",
+        "created",
+        "_total_hours_in_days",
+        "_total_vacation_hours_in_days",
+    ]
+    ordering = ["-period__startswith"]
+    search_fields = ["employee__profile__computed_str", "notes", "reason"]
+
+    filterset_class = AbsenceRequestFilter
+
+    display_config_class = AbsenceRequestDisplayConfig
+    endpoint_config_class = AbsenceRequestEndpointConfig
+    button_config_class = AbsenceRequestButtonConfig
+
+    @cached_property
+    def can_administrate(self) -> bool:
+        if "pk" in self.kwargs and (obj := self.get_object()):
+            return can_validate_or_deny_request(obj, self.request.user)
+        return False
+
+    def add_messages(
+        self,
+        request,
+        queryset=None,
+        paginated_queryset=None,
+        instance=None,
+        initial=False,
+    ):
+        if instance:
+            if instance.status != AbsenceRequest.Status.CANCELLED:
+                qs = CalendarItem.objects.filter(
+                    is_cancelled=False, period__overlap=instance.period, entities=instance.employee.profile
+                ).exclude(id=instance.id)
+                activities_title = qs.values_list("title", flat=True)
+                if len(activities_title) > 0:
+                    message = gettext("<p>During this absence, you already have these events:</p><ul>")
+                    for activity_title in activities_title:
+                        message += f"<li>{activity_title}</li>"
+                    message += "</ul>"
+                    warning(request, message)
+            if instance.type.is_vacation:
+                if instance.status in [
+                    AbsenceRequest.Status.DRAFT,
+                    AbsenceRequest.Status.PENDING,
+                ]:
+                    other_pending_hours = (
+                        AbsenceRequestPeriods.objects.exclude(request__id=instance.id)
+                        .filter(
+                            request__status__in=[AbsenceRequest.Status.PENDING, AbsenceRequest.Status.DRAFT],
+                            request__type__is_vacation=True,
+                            employee=instance.employee,
+                        )
+                        .aggregate(s=Sum("_total_hours"))["s"]
+                        or 0.0
+                    )
+
+                    current_balance = instance.employee.get_or_create_balance(instance.period.lower.year)[0]
+                    available_hourly_balance = current_balance.total_vacation_hourly_balance - instance.total_hours
+                    available_hourly_balance_in_days = (
+                        available_hourly_balance / instance.employee.calendar.get_daily_hours()
+                    )
+                    message = gettext(
+                        "After this request, you will have {} days ({} hours) left for the balance {}</b>"
+                    ).format(available_hourly_balance_in_days, available_hourly_balance, current_balance.year)
+                    if other_pending_hours > 0:
+                        message += gettext(
+                            " (not including <b>{pending_hours}</b> hours from other pending/draft absence requests)"
+                        ).format(pending_hours=other_pending_hours)
+                    if available_hourly_balance < 0:
+                        warning(request, message, extra_tags="auto_close=0")
+                    else:
+                        info(request, message)
+                day_offs = instance.employee.calendar.days_off.filter(
+                    date__gte=instance.period.lower.date(), date__lte=instance.period.upper.date()
+                )
+                if day_offs:
+                    day_offs_messages = [
+                        gettext("{holiday} not counted ({title})").format(
+                            holiday=holiday.date.strftime("%d.%m.%Y"), title=holiday.title
+                        )
+                        for holiday in day_offs
+                    ]
+                    info(request, ", ".join(day_offs_messages))
+
+    def get_queryset(self):
+        qs = AbsenceRequest.objects.none()
+        if self.is_administrator:
+            qs = super().get_queryset()
+        elif employee := getattr(self.request.user.profile, "human_resources", None):
+            qs = super().get_queryset().filter(employee__in=employee.get_managed_employees())
+        when_statements = []
+        for type in AbsenceRequestType.objects.all():
+            try:
+                when_statements.append(When(type=type, then=Value(WBIcon[type.icon].icon)))
+            except KeyError:
+                when_statements.append(When(type=type, then=Value(type.icon)))
+
+        qs = qs.annotate(
+            department=F("employee__position__id"), type_icon=Case(*when_statements, default=Value(None))
+        ).select_related(
+            "type",
+            "employee",
+        )
+        return qs
+
+    def get_aggregates(self, queryset, paginated_queryset):
+        current_year = timezone.now().year
+
+        qs = AbsenceRequestPeriods.objects.filter(request__in=queryset, date__year=current_year)
+
+        qs_vacation = qs.filter(
+            Q(request__type__is_vacation=True) & Q(request__status=AbsenceRequest.Status.APPROVED.name)
+        )
+        return {
+            "_total_hours_in_days": {
+                "Σ": format_number(queryset.aggregate(s=Sum(F("_total_hours_in_days")))["s"]),
+                f"Σ {current_year}": format_number(qs.aggregate(s=Sum(F("_total_hours")))["s"]),
+            },
+            "_total_vacation_hours_in_days": {
+                "Σ": format_number(queryset.aggregate(s=Sum(F("_total_vacation_hours_in_days")))["s"]),
+                f"Σ {current_year}": format_number(qs_vacation.aggregate(s=Sum(F("_total_hours")))["s"]),
+            },
+        }
+
+    @action(detail=True, methods=["PATCH"])
+    def increaseday(self, request, pk=None):
+        absence_request = get_object_or_404(AbsenceRequest, id=pk)
+        if absence_request.type.is_extensible and (number_days := int(request.POST.get("number_days", 1))):
+            for _ in range(number_days):
+                if next_extensible_period := absence_request.next_extensible_period:
+                    absence_request.period = next_extensible_period
+            absence_request.save()
+        return Response({"send": True})
+
+
+class AbsenceRequestTypeModelViewSet(viewsets.ModelViewSet):
+    IDENTIFIER = "wbhuman_resources:absencerequesttype"
+    queryset = AbsenceRequestType.objects.all()
+    serializer_class = AbsenceRequestTypeModelSerializer
+    display_config_class = AbsenceRequestTypeDisplayConfig
+
+
+# Employee Subs Viewsets ####
+
+
+class AbsenceTypeCountEmployeeModelViewSet(viewsets.ModelViewSet):
+    READ_ONLY = True
+    queryset = AbsenceRequestPeriods.objects.all()
+    serializer_class = EmployeeAbsenceDaysModelSerializer
+
+    filter_backends = (filters.OrderingFilter, DjangoFilterBackend)
+    ordering_fields = ["year", "hours_count", "day_count"]
+    ordering = ["-year"]
+
+    filterset_class = AbsenceTypeCountEmployeeModelFilterSet
+    title_config_class = AbsenceTypeCountEmployeeTitleConfig
+    display_config_class = AbsenceTypeCountEmployeeDisplayConfig
+    endpoint_config_class = AbsenceTypeCountEmployeeEndpointConfig
+
+    def get_queryset(self):
+        employee = get_object_or_404(EmployeeHumanResource, pk=self.kwargs["employee_id"])
+        employee_daily_hours = employee.calendar.get_daily_hours()
+        qs = (
+            AbsenceRequestPeriods.objects.filter(
+                request__employee=employee,
+                request__status=AbsenceRequest.Status.APPROVED.name,
+            )
+            .annotate(
+                year=Extract("date", "year"),
+                absence_type=F("request__type__id"),
+            )
+            .values("year", "absence_type")
+            .annotate(
+                hours_count=Sum("_total_hours"),
+                days_count=F("hours_count") / Value(employee_daily_hours),
+                id=Concat(
+                    Value(self.kwargs["employee_id"]),
+                    F("year"),
+                    Value("."),
+                    F("absence_type"),
+                    output_field=CharField(),
+                ),
+            )
+        )
+        return qs
+
+    def get_aggregates(self, queryset, paginated_queryset):
+        return {
+            "days_count": {
+                "Σ": format_number(queryset.aggregate(s=Sum(F("days_count")))["s"], decimal=1),
+            },
+            "hours_count": {
+                "Σ": format_number(queryset.aggregate(s=Sum(F("hours_count")))["s"], decimal=1),
+            },
+        }
+
+
+class AbsenceRequestEmployeeHumanResourceModelViewset(AbsenceRequestModelViewSet):
+    title_config_class = AbsenceRequestEmployeeBalanceTitleConfig
+    display_config_class = AbsenceRequestEmployeeHumanResourceDisplayConfig
+    endpoint_config_class = AbsenceRequestEmployeeHumanResourceEndpointConfig
+    filterset_class = AbsenceRequestEmployeeHumanResourceFilterSet
+
+    ordering = ["-period__startswith"]
+
+    def get_queryset(self):
+        employee = EmployeeHumanResource.objects.get(id=self.kwargs["employee_id"])
+        return super().get_queryset().filter(employee=employee)
+
+
+class AbsenceRequestPeriodsAbsenceRequestModelViewSet(viewsets.ModelViewSet):
+    display_config_class = AbsenceRequestPeriodsAbsenceRequestDisplayConfig
+    endpoint_config_class = AbsenceRequestPeriodsAbsenceRequestEndpointConfig
+    queryset = AbsenceRequestPeriods.objects.all()
+    serializer_class = AbsenceRequestPeriodsModelSerializer
+
+    filter_backends = (filters.OrderingFilter,)
+    ordering_fields = ["date"]
+    ordering = ["date"]
+
+    def get_queryset(self):
+        return super().get_queryset().filter(request__id=self.kwargs["request_id"])

wbhuman_resources/viewsets/absence_charts.py

@@ -0,0 +1,328 @@
+from calendar import day_name
+from datetime import date, time
+
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from django.db.models import Q
+from django.shortcuts import get_object_or_404
+from django.utils import timezone
+from django.utils.dateparse import parse_date
+from django.utils.translation import gettext as _
+from wbcore import viewsets
+from wbcore.pandas import fields as pf
+from wbcore.pandas.views import PandasAPIViewSet
+from wbcore.utils.date import get_date_interval_from_request
+
+from wbhuman_resources.filters import AbsenceRequestPlannerFilter, AbsenceTableFilter
+from wbhuman_resources.models import (
+    AbsenceRequest,
+    AbsenceRequestPeriods,
+    AbsenceRequestType,
+    DayOffCalendar,
+    EmployeeHumanResource,
+    Position,
+)
+from wbhuman_resources.viewsets.display import AbsenceTablePandasDisplayConfig
+from wbhuman_resources.viewsets.endpoints import (
+    AbsenceRequestPlannerEndpointConfig,
+    AbsenceTablePandasEndpointConfig,
+)
+from wbhuman_resources.viewsets.titles import (
+    AbsenceRequestPlannerTitleConfig,
+    AbsenceTablePandasTitleConfig,
+)
+
+from .utils import (
+    current_day_range,
+    current_month_range,
+    current_week_range,
+    current_year_range,
+)
+
+
+def update_layoute(fig, start, end):
+    fig.layout.xaxis.rangeselector = None
+    fig.update_layout(
+        updatemenus=[
+            dict(
+                type="buttons",
+                direction="left",
+                active=1,
+                x=0.57,
+                y=1.2,
+                buttons=[
+                    dict(
+                        label=_("Current Day"),
+                        method="relayout",
+                        args=[
+                            {
+                                "xaxis.range": current_day_range(),
+                                "xaxis.dtick": 3600000,
+                            },
+                        ],
+                    ),
+                    dict(
+                        label=_("Current Week"),
+                        method="relayout",
+                        args=[
+                            {
+                                "xaxis.range": current_week_range(),
+                                "xaxis.dtick": "D1",
+                            },
+                        ],
+                    ),
+                    dict(
+                        label=_("Current Month"),
+                        method="relayout",
+                        args=[
+                            {
+                                "xaxis.range": current_month_range(),
+                                "xaxis.dtick": "D3",
+                            },
+                        ],
+                    ),
+                    dict(
+                        label=_("Current Year"),
+                        method="relayout",
+                        args=[
+                            {
+                                "xaxis.range": current_year_range(),
+                                "xaxis.dtick": 86400000.0 * 14,
+                                "xaxis.tickformat": "%b %d",
+                            },
+                        ],
+                    ),
+                    dict(
+                        label=_("All"),
+                        method="relayout",
+                        args=[
+                            {"xaxis.range": [start, end]},
+                        ],
+                    ),
+                ],
+            )
+        ],
+        yaxis=dict(
+            title="",
+            titlefont=dict(color="#000000"),
+            tickfont=dict(size=11, family="Courier", color="#000000"),
+            anchor="x",
+            side="left",
+            showline=False,
+            linewidth=0.5,
+            linecolor="black",
+            showgrid=True,
+            gridcolor="lightgray",
+            gridwidth=1,
+            showspikes=True,
+            spikecolor="black",
+            spikethickness=1,
+        ),
+        xaxis=dict(
+            title="",
+            titlefont=dict(color="#000000"),
+            tickfont=dict(color="#000000"),
+            showline=False,
+            linewidth=0.5,
+            linecolor="black",
+            showgrid=True,
+            gridcolor="lightgray",
+            gridwidth=2,
+            rangeslider=dict(visible=True),
+            range=current_week_range(),
+            dtick="D1",
+            type="date",
+            showspikes=True,
+            spikemode="across",
+            spikecolor="black",
+            spikesnap="cursor",
+            spikethickness=1,
+        ),
+        spikedistance=1000,
+        hoverdistance=100,
+    )
+
+    return fig
+
+
+def _get_types_color_map():
+    type_dict = dict(AbsenceRequestType.objects.values_list("title", "color"))
+    type_dict["Day Off"] = "silver"
+    type_dict["Holiday"] = "lightblue"
+    return type_dict
+
+
+def _get_status_pattern_map():
+    return {
+        "APPROVED": "",
+        "DRAFT": ".",
+        "PENDING": "x",
+    }
+
+
+class AbsenceRequestPlanner(viewsets.ChartViewSet):
+    IDENTIFIER = "wbhuman_resources:absenceplanner"
+
+    filterset_class = AbsenceRequestPlannerFilter
+    queryset = AbsenceRequestPeriods.objects.all()
+
+    title_config_class = AbsenceRequestPlannerTitleConfig
+    endpoint_config_class = AbsenceRequestPlannerEndpointConfig
+
+    def get_plotly(self, queryset):
+        start, end = get_date_interval_from_request(self.request)
+        calendar = get_object_or_404(DayOffCalendar, pk=self.request.GET.get("calendar", None))
+        only_employee_with_absence_periods = (
+            self.request.GET.get("only_employee_with_absence_periods", "false") == "true"
+        )
+        employees = EmployeeHumanResource.active_internal_employees.all()
+
+        if position_id := self.request.GET.get("position", None):
+            position = get_object_or_404(Position, pk=position_id)
+            employees = employees.filter(position__in=position.get_descendants(include_self=True))
+
+        if queryset.exists() and start and end and employees.exists():
+            df = EmployeeHumanResource.get_employee_absence_periods_df(
+                calendar, start, end, employees, only_employee_with_absence_periods=only_employee_with_absence_periods
+            )
+
+            employees_map = dict(employees.values_list("id", "computed_str"))
+            df["employee"] = df.employee.map(employees_map)
+            fig = px.timeline(
+                df,
+                x_start="start",
+                x_end="end",
+                y=df.employee,
+                color="type",
+                template="seaborn",
+                color_discrete_map=_get_types_color_map(),
+                pattern_shape="status",
+                pattern_shape_map=_get_status_pattern_map(),
+                hover_name="employee",
+                hover_data={
+                    "start": True,
+                    "end": True,
+                    "employee": False,
+                    "status": False,
+                    "type": False,
+                },
+            )
+            now = timezone.now().astimezone(calendar.timezone)
+            default_calendar_period = calendar.get_default_fullday_period(now.date())
+            valid_now = min(
+                max([now, default_calendar_period.lower]), default_calendar_period.upper
+            )  # we make sure that the "now" vertical line is within the range of a default calendar day
+            fig.add_vline(x=valid_now, line_width=3, line_dash="dash", line_color="red")
+            fig = update_layoute(fig, start, end)
+
+            def _time_to_decimal(ts):
+                return (ts.hour * 60 + ts.minute) / 60
+
+            rangebreaks = [
+                {"pattern": "hour", "bounds": [_time_to_decimal(hours_range[0]), _time_to_decimal(hours_range[1])]}
+                for hours_range in calendar.get_unworked_time_range(start_time=time(4, 0, 1))
+            ]
+            fig.update_xaxes(rangebreaks=rangebreaks)
+
+            return fig
+        return go.Figure()
+
+
+class AbsenceTablePandasViewSet(PandasAPIViewSet):
+    IDENTIFIER = "wbhuman_resources:absence_table"
+
+    queryset = AbsenceRequestPeriods.objects.filter(
+        Q(employee__in=EmployeeHumanResource.active_internal_employees.all())
+        & Q(request__status=AbsenceRequest.Status.APPROVED.name)
+    )
+
+    filterset_class = AbsenceTableFilter
+
+    pandas_fields = pf.PandasFields(
+        fields=(
+            pf.PKField(key="employee", label=_("ID")),
+            pf.PKField(key="employee_repr", label=_("Employee"), help_text=_("Test")),
+            pf.CharField(key="position", label=_("Department")),
+            pf.FloatField(key="monday", label=_("Monday")),
+            pf.FloatField(key="tuesday", label=_("Tuesday")),
+            pf.FloatField(key="wednesday", label=_("Wednesday")),
+            pf.FloatField(key="thursday", label=_("Thursday")),
+            pf.FloatField(key="friday", label=_("Friday")),
+            pf.FloatField(key="saturday", label=_("Saturday")),
+            pf.FloatField(key="sunday", label=_("Sunday")),
+        )
+    )
+    display_config_class = AbsenceTablePandasDisplayConfig
+    title_config_class = AbsenceTablePandasTitleConfig
+    endpoint_config_class = AbsenceTablePandasEndpointConfig
+
+    ordering_fields = [
+        "employee_repr",
+        "position",
+        "monday",
+        "tuesday",
+        "wednesday",
+        "thursday",
+        "friday",
+    ]
+    ordering = ["position"]
+    search_fields = ["employee_repr", "position"]
+
+    @property
+    def start_and_end(self) -> tuple[date, date] | None:
+        if date_repr := self.request.GET.get("date", None):
+            return current_week_range(parse_date(date_repr))
+        return None
+
+    def get_dataframe(self, request, queryset, **kwargs) -> pd.DataFrame:
+        def _rename_columns(df: pd.DataFrame) -> pd.DataFrame:
+            # Rename the columns from datetime.date to the week day name representation (e.g. Monday)
+            rename_map = {col: day_name[col.weekday()].lower() for col in df.columns if not isinstance(col, str)}
+            return df.rename(columns=rename_map)
+
+        def _get_position(employee_id: int) -> Position | None:
+            employee = EmployeeHumanResource.objects.get(id=employee_id)
+            if pos := employee.position:
+                return pos.get_root().name
+            return None
+
+        def _custom_agg(group: pd.DataFrame) -> int:
+            default_periods = calendar.default_periods.count()
+
+            if default_periods:
+                if len(group) == default_periods:
+                    if group["type"].eq("Home Office").sum() == default_periods:
+                        # Remote
+                        return 3
+                    elif group["type"].eq("Home Office").sum() > 0:
+                        # Partially Remote
+                        return 2
+                    else:
+                        # Absent
+                        return -1
+                elif len(group) > 0:
+                    # Partially Present
+                    return 1
+            return 0
+
+        if self.start_and_end:
+            start, end = self.start_and_end
+            calendar = get_object_or_404(DayOffCalendar, pk=self.request.GET.get("calendar", None))
+            employees = EmployeeHumanResource.active_internal_employees.all()
+
+            if position_id := self.request.GET.get("position", None):
+                position = get_object_or_404(Position, pk=position_id)
+                employees = employees.filter(position__in=position.get_descendants(include_self=True))
+
+            df = EmployeeHumanResource.get_employee_absence_periods_df(calendar, start, end, employees)
+            df = df[["date", "employee", "period", "type"]]
+            df = df.groupby(["date", "employee"]).apply(_custom_agg).unstack(fill_value=0)  # Present
+            df.reset_index(inplace=True)
+            df.set_index("date", inplace=True)
+            df = _rename_columns(df.reindex(pd.date_range(start, end), fill_value=0).transpose()).reset_index()
+            df["position"] = df.employee.apply(lambda x: _get_position(x))
+            df["employee_repr"] = df.employee.map(dict(employees.values_list("id", "computed_str")))
+            df = df.sort_values(by="employee_repr", ascending=False)
+            return df.where(pd.notnull(df), None)
+        return pd.DataFrame()

wbhuman_resources/viewsets/buttons/__init__.py

@@ -0,0 +1,7 @@
+from .absence import AbsenceRequestButtonConfig
+from .employee import EmployeeButtonConfig, YearBalanceEmployeeHumanResourceButtonConfig
+from .kpis import KPIButtonConfig
+from .review import (
+    ReviewButtonConfig,
+    ReviewGroupButtonConfig,
+)

wbhuman_resources/viewsets/buttons/absence.py

@@ -0,0 +1,32 @@
+from django.utils.translation import gettext as _
+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 wbhuman_resources.serializers import IncreaseDaySerializer
+
+
+class AbsenceRequestButtonConfig(ButtonViewConfig):
+    def get_custom_instance_buttons(self):
+        return {
+            bt.ActionButton(
+                method=RequestType.PATCH,
+                identifiers=("wbhuman_resources:absencerequest",),
+                key="increase_days",
+                action_label=_("Increasing Days"),
+                label=_("Increase Days"),
+                icon=WBIcon.ADD.icon,
+                title=_("Increase Days"),
+                serializer=IncreaseDaySerializer,
+                description_fields=_(
+                    """
+                    <p>You are about to increase the abscence request by {{number_days}} days</p>
+                """
+                ),
+                instance_display=create_simple_display([["number_days"]]),
+            )
+        }