wbhuman_resources 1.58.4__py2.py3-none-any.whl

wbhuman_resources/tests/models/test_utils.py

@@ -0,0 +1,110 @@
+from datetime import date, timedelta
+
+import pandas as pd
+import pytest
+from faker import Faker
+
+from wbhuman_resources.models import EmployeeHumanResource
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestUtil:
+    @pytest.mark.parametrize("test_date", [(fake.date_object())])
+    def test_get_employee_absence_periods_df(
+        self,
+        employee_human_resource,
+        absence_request_periods_factory,
+        day_off_factory,
+        employee_weekly_off_periods_factory,
+        test_date,
+    ):
+        # Basic utility coverage test. The underlying functions are already tested.
+        p = absence_request_periods_factory.create(date=test_date, employee=employee_human_resource)
+        w = employee_weekly_off_periods_factory.create(
+            employee=employee_human_resource, weekday=(test_date + timedelta(days=1)).weekday()
+        )
+        day_off_factory.create(calendar=employee_human_resource.calendar, date=test_date + timedelta(days=2))
+        res = EmployeeHumanResource.get_employee_absence_periods_df(
+            employee_human_resource.calendar,
+            (test_date - pd.tseries.offsets.Week(1)).date(),
+            (test_date + pd.tseries.offsets.Week(1)).date(),
+            EmployeeHumanResource.active_employees.all(),
+        ).set_index(["employee", "period", "date", "type"])
+        assert not res.loc[(employee_human_resource.id, p.default_period.id, test_date, "Vacation"), :].empty
+        assert not res.loc[
+            (employee_human_resource.id, w.period.id, test_date + timedelta(days=1), "Day Off"), :
+        ].empty
+        assert not res.loc[
+            (
+                employee_human_resource.id,
+                employee_human_resource.calendar.default_periods.earliest("lower_time").id,
+                test_date + timedelta(days=2),
+                "Holiday",
+            ),
+            :,
+        ].empty
+        assert not res.loc[
+            (
+                employee_human_resource.id,
+                employee_human_resource.calendar.default_periods.latest("lower_time").id,
+                test_date + timedelta(days=2),
+                "Holiday",
+            ),
+            :,
+        ].empty
+        with pytest.raises(KeyError):
+            assert not res.loc[(employee_human_resource.id, 2, test_date + timedelta(days=3), "Holiday"), :].empty
+
+    @pytest.mark.parametrize(
+        "end_of_month_date",
+        [
+            (fake.date_between(date(2021, 1, 1), date(2021, 3, 31))),
+            (fake.date_between(date(2021, 4, 1), date(2021, 12, 31))),
+        ],
+    )
+    def test_get_end_of_month_employee_balance_report_df(
+        self,
+        employee_human_resource,
+        employee_year_balance_factory,
+        balance_hourly_allowance_factory,
+        absence_request_periods_factory,
+        end_of_month_date,
+    ):
+        end_of_month_date = (end_of_month_date + pd.tseries.offsets.MonthEnd(0)).date()
+        previous_balance = employee_year_balance_factory.create(
+            employee=employee_human_resource, year=end_of_month_date.year - 1, extra_balance=0
+        )
+        balance_hourly_allowance_factory.create(balance=previous_balance)
+
+        current_balance = employee_year_balance_factory.create(
+            employee=employee_human_resource, year=end_of_month_date.year, extra_balance=0
+        )
+        balance_hourly_allowance_factory.create(balance=current_balance)
+        previous_period = absence_request_periods_factory.create(
+            balance=previous_balance,
+            employee=employee_human_resource,
+            date=fake.date_between(date(end_of_month_date.year, 1, 1), end_of_month_date - timedelta(days=1)),
+        )
+        current_period = absence_request_periods_factory.create(
+            balance=current_balance,
+            employee=employee_human_resource,
+            date=fake.date_between(previous_period.date, end_of_month_date),
+        )
+
+        res = EmployeeHumanResource.get_end_of_month_employee_balance_report_df(
+            EmployeeHumanResource.active_employees.all(), end_of_month_date
+        ).to_dict("records")[0]
+        expected_total_balance = (
+            current_balance.balance_in_days
+            + previous_balance.total_vacation_hourly_balance_in_days
+            + previous_balance.total_vacation_hourly_usage_in_days
+        )
+        expected_usage = (previous_period.total_hours + current_period.total_hours) / 8
+        assert res == {
+            "Employee": employee_human_resource.computed_str,
+            "Total Balance": expected_total_balance,
+            "End of Month Usage": expected_usage,
+            "Available Balance End of Month": expected_total_balance - expected_usage,
+        }

wbhuman_resources/tests/signals.py

@@ -0,0 +1,108 @@
+from django.db import connection
+from django.dispatch import receiver
+from wbcore.test.signals import (
+    custom_update_kwargs,
+    get_custom_factory,
+    get_custom_serializer,
+)
+
+from wbhuman_resources.factories import (
+    DefaultPersonKPIFactory,
+    ReviewQuestionNoCategoryFactory,
+    ReviewTemplateFactory,
+)
+from wbhuman_resources.models import AbsenceRequest, ReviewQuestion
+from wbhuman_resources.serializers import KPIModelSerializer
+from wbhuman_resources.viewsets import (
+    AbsenceTablePandasViewSet,
+    AbsenceTypeCountEmployeeModelViewSet,
+    KPIModelViewSet,
+    ReviewAnswerReviewNoCategoryModelViewSet,
+    ReviewAnswerReviewPandasViewSet,
+    ReviewAnswerReviewQuestionCategoryModelViewSet,
+    ReviewModelViewSet,
+    ReviewProgressReviewPandasViewSet,
+    ReviewQuestionReviewNoCategoryModelViewSet,
+    ReviewReviewGroupModelViewSet,
+    ReviewTemplateModelViewSet,
+)
+
+# =================================================================================================================
+#                                              CUSTOM FACTORY
+# =================================================================================================================
+
+
+@receiver(get_custom_factory, sender=ReviewTemplateModelViewSet)
+def receive_factory_review_template(sender, *args, **kwargs):
+    return ReviewTemplateFactory
+
+
+@receiver(get_custom_factory, sender=ReviewQuestionReviewNoCategoryModelViewSet)
+def receive_factory_review_question_no_category(sender, *args, **kwargs):
+    return ReviewQuestionNoCategoryFactory
+
+
+@receiver(get_custom_factory, sender=KPIModelViewSet)
+def receive_factory_kpi(sender, *args, **kwargs):
+    return DefaultPersonKPIFactory
+
+
+# =================================================================================================================
+#                                              UPDATE KWARGS
+# =================================================================================================================
+
+
+@receiver(custom_update_kwargs, sender=AbsenceTypeCountEmployeeModelViewSet)
+def receive_kwargs_employee_absence(sender, *args, **kwargs):
+    if kwargs.get("obj_factory"):
+        abs_day = kwargs.get("obj_factory")
+        abs_day.request.status = AbsenceRequest.Status.APPROVED
+        abs_day.request.save()
+        abs_day.save()
+        return {"employee_id": abs_day.request.employee.id, "request_id": abs_day.request.id}
+    else:
+        return {}
+
+
+@receiver(custom_update_kwargs, sender=ReviewTemplateModelViewSet)
+@receiver(custom_update_kwargs, sender=ReviewReviewGroupModelViewSet)
+@receiver(custom_update_kwargs, sender=ReviewModelViewSet)
+def receive_kwargs_review(sender, *args, **kwargs):
+    if (review := kwargs.get("obj_factory")) and (user := kwargs.get("user")):
+        review.moderator = user.profile
+        review.save()
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=ReviewProgressReviewPandasViewSet)
+@receiver(custom_update_kwargs, sender=ReviewAnswerReviewPandasViewSet)
+@receiver(custom_update_kwargs, sender=ReviewAnswerReviewNoCategoryModelViewSet)
+@receiver(custom_update_kwargs, sender=ReviewAnswerReviewQuestionCategoryModelViewSet)
+def receive_kwargs_review_answer_question_category(sender, *args, **kwargs):
+    if question_id := kwargs.get("question_id"):
+        question = ReviewQuestion.objects.get(id=question_id)
+        if question.category:
+            return {"review_id": question.review.id, "category_id": question.category.id}
+        else:
+            return {"review_id": question.review.id}
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=AbsenceTablePandasViewSet)
+def receive_kwargs_employee_human_resource_absence(sender, *args, **kwargs):
+    return {"request_id": None, "profile": None, "user": None, "obj_factory": None}
+
+
+# =================================================================================================================
+#                                              UPDATE SERIALIZER
+# =================================================================================================================
+
+
+@receiver(get_custom_serializer, sender=KPIModelViewSet)
+def receive_serializer_kpi(sender, *args, **kwargs):
+    return KPIModelSerializer
+
+
+def app_pre_migration(sender, app_config, **kwargs):
+    cur = connection.cursor()
+    cur.execute("CREATE EXTENSION IF NOT EXISTS btree_gist;")

wbhuman_resources/tests/test_permission.py

@@ -0,0 +1,64 @@
+import pytest
+from django.contrib.auth import get_user_model
+from dynamic_preferences.registries import global_preferences_registry
+from faker import Faker
+from rest_framework.test import APIRequestFactory
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.permissions.shortcuts import is_internal_user
+
+from wbhuman_resources.factories.employee import EmployeeHumanResourceFactory
+from wbhuman_resources.models.employee import EmployeeHumanResource
+
+User = get_user_model()
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestPermissionTasks:
+    @pytest.fixture
+    def request_user_external(self):
+        request = APIRequestFactory()
+        user = UserFactory()
+        EmployeeHumanResourceFactory.create(
+            profile=user.profile, contract_type=EmployeeHumanResource.ContractType.EXTERNAL
+        )
+        request.user = user
+        return request
+
+    @pytest.fixture
+    def request_user_active_internal(self):
+        request = APIRequestFactory()
+        user = UserFactory()
+        EmployeeHumanResourceFactory.create(
+            profile=user.profile, contract_type=EmployeeHumanResource.ContractType.INTERNAL
+        )
+        request.user = user
+        return request
+
+    @pytest.fixture
+    def request_user_inactive_internal(self):
+        request = APIRequestFactory()
+        user = UserFactory()
+        EmployeeHumanResourceFactory.create(
+            profile=user.profile, contract_type=EmployeeHumanResource.ContractType.INTERNAL, is_active=False
+        )
+        request.user = user
+        return request
+
+    def test_permission_active_internal(self, request_user_active_internal):
+        assert is_internal_user(request_user_active_internal.user) is True
+
+    def test_permission_inactive_internal(self, request_user_inactive_internal):
+        assert is_internal_user(request_user_inactive_internal.user) is False
+
+    def test_permission_external(self, request_user_external):
+        assert is_internal_user(request_user_external.user) is False
+
+    def test_permission_external_but_considered_internal(self, request_user_external):
+        from wbcore.permissions.registry import user_registry
+
+        user = request_user_external.user
+        global_preferences_registry.manager()["wbhuman_resources__is_external_considered_as_internal"] = True
+        user = User.objects.get(id=user.id)  # reload to reset cached property
+        user_registry.reset_cache()
+        assert is_internal_user(user) is True

wbhuman_resources/tests/test_tasks.py

@@ -0,0 +1,74 @@
+from datetime import date
+from unittest.mock import patch
+
+import pandas as pd
+import pytest
+from django.contrib.auth.models import Permission
+from django.contrib.contenttypes.models import ContentType
+from django.core import mail
+from dynamic_preferences.registries import global_preferences_registry
+from faker import Faker
+
+from wbhuman_resources.models import AbsenceRequest
+from wbhuman_resources.models.employee import EmployeeHumanResource
+from wbhuman_resources.tasks import assign_balance, send_mail_to_accounting
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestHumanResourceTasks:
+    @pytest.mark.parametrize("accounting_email_1,accounting_email_2", [(fake.email(), fake.email())])
+    @patch.object(EmployeeHumanResource, "get_end_of_month_employee_balance_report_df")
+    def test_send_mail_to_accounting_recipient(self, mock_fct, user_factory, accounting_email_1, accounting_email_2):
+        global_preferences_registry.manager()["wbhuman_resources__accounting_company_emails"] = (
+            f"{accounting_email_1};{accounting_email_2}"
+        )
+        mock_fct.return_value = pd.DataFrame(data=["a", "b"])
+
+        admin_user = user_factory.create(is_superuser=True)
+        content_type = ContentType.objects.get_for_model(AbsenceRequest)
+        permission = Permission.objects.get(
+            codename="administrate_absencerequest",
+            content_type=content_type,
+        )
+        admin_user.user_permissions.add(permission)
+        user_factory.create(
+            is_superuser=True
+        )  # we create another superuser to check if administirators don't contain it
+
+        send_mail_to_accounting()
+        assert len(mail.outbox) == 1
+        last_mail = mail.outbox[-1]
+
+        assert set(last_mail.to) == {accounting_email_2, accounting_email_1}
+        assert set(last_mail.cc) == {admin_user.email}
+
+    @pytest.mark.parametrize("year_str", [(fake.year())])
+    def test_assign_yearly_balance(self, year_str, employee_human_resource_factory):
+        year = int(year_str)
+        test_date = date(year, 1, 1)
+        active_employee = employee_human_resource_factory.create(
+            enrollment_at=test_date,
+            is_active=True,
+            occupancy_rate=1,
+            extra_days_frequency=EmployeeHumanResource.ExtraDaysBalanceFrequency.YEARLY,
+        )
+        unactive_employee = employee_human_resource_factory.create(
+            enrollment_at=test_date,
+            is_active=False,
+            occupancy_rate=1,
+            extra_days_frequency=EmployeeHumanResource.ExtraDaysBalanceFrequency.YEARLY,
+        )
+        assert not active_employee.balances.exists()
+        assign_balance(test_date)
+        assert not unactive_employee.balances.exists()
+        assert active_employee.balances.count() == 1  # check that we get only this year balance
+        employee_balance = active_employee.balances.get(year=test_date.year)
+        allowance = employee_balance.monthly_allowances.first()
+        assert (
+            employee_balance.monthly_allowances.count() == 1
+        )  # check that a unique allowance was granted to the employee
+        assert (
+            allowance.hourly_allowance == 25 * 8
+        )  # check the the hourly amount correspond ot the base 25 days per year in hours

wbhuman_resources/urls.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+
+from django.urls import include, path
+from wbcore.routers import WBCoreRouter
+
+from wbhuman_resources import viewsets
+
+router = WBCoreRouter()
+
+
+# Calendar viewsets
+
+router.register(
+    "defaultdailyperiodrepresentation",
+    viewsets.DefaultDailyPeriodRepresentationViewSet,
+    basename="defaultdailyperiodrepresentation",
+)
+router.register(
+    "employeeweeklyoffperiodrepresentation",
+    viewsets.EmployeeWeeklyOffPeriodsRepresentationViewSet,
+    basename="employeeweeklyoffperiodrepresentation",
+)
+router.register("dayoffrepresentation", viewsets.DayOffRepresentationViewSet, basename="dayoffrepresentation")
+router.register(
+    "dayoffcalendarrepresentation",
+    viewsets.DayOffCalendarRepresentationViewSet,
+    basename="dayoffcalendarrepresentation",
+)
+
+router.register("dayoffcalendar", viewsets.DayOffCalendarModelViewSet, basename="dayoffcalendar")
+router.register("dayoff", viewsets.DayOffModelViewSet, basename="dayoff")
+
+calendar_router = WBCoreRouter()
+calendar_router.register("dayoff", viewsets.DayOffDayOffCalendarModelViewSet, basename="calendar-dayoff")
+calendar_router.register(
+    "defaultperiod", viewsets.DefaultDailyPeriodDayOffCalendarModelViewSet, basename="calendar-defaultperiod"
+)
+
+# absence request type router
+absencerequesttype_router = WBCoreRouter()
+absencerequesttype_router.register(
+    "crossbordercountry",
+    viewsets.AbsenceRequestCrossBorderCountryModelViewSet,
+    basename="absencerequesttype-crossbordercountry",
+)
+
+
+# Employee routers
+router.register(
+    r"employeehumanresourcerepresentation",
+    viewsets.EmployeeHumanResourceRepresentationViewSet,
+    basename="employeehumanresourcerepresentation",
+)
+router.register(r"positionrepresentation", viewsets.PositionRepresentationViewSet, basename="positionrepresentation")
+router.register(
+    "employeeyearbalancerepresentation",
+    viewsets.EmployeeYearBalanceRepresentationViewSet,
+    basename="employeeyearbalancerepresentation",
+)
+
+router.register(r"employeebalance", viewsets.EmployeeBalanceModelViewSet, basename="employeebalance")
+router.register(r"employee", viewsets.EmployeeModelViewSet, basename="employee")
+router.register(r"position", viewsets.PositionModelViewSet, basename="position")
+
+
+employee_router = WBCoreRouter()
+employee_router.register(
+    r"weeklyoffperiod",
+    viewsets.WeeklyOffPeriodEmployeeHumanResourceModelViewSet,
+    basename="employee-weeklyoffperiod",
+)
+employee_router.register(
+    r"absence",
+    viewsets.AbsenceTypeCountEmployeeModelViewSet,
+    basename="employee-absencecount",
+)
+
+employee_router.register(
+    r"absencerequest",
+    viewsets.AbsenceRequestEmployeeHumanResourceModelViewset,
+    basename="employee-absencerequest",
+)
+employee_router.register(
+    r"employeeyearbalance",
+    viewsets.YearBalanceEmployeeHumanResourceModelViewset,
+    basename="employee-employeeyearbalance",
+)
+
+# Absence routers
+router.register(
+    r"absencerequesttyperepresentation",
+    viewsets.AbsenceRequestTypeRepresentationViewSet,
+    basename="absencerequesttyperepresentation",
+)
+
+
+router.register(r"absenceplanner", viewsets.AbsenceRequestPlanner, basename="absenceplanner")
+router.register(r"absencerequest", viewsets.AbsenceRequestModelViewSet)
+router.register(r"absencerequesttype", viewsets.AbsenceRequestTypeModelViewSet, basename="absencerequesttype")
+
+absence_request_router = WBCoreRouter()
+absence_request_router.register(
+    r"periods",
+    viewsets.AbsenceRequestPeriodsAbsenceRequestModelViewSet,
+    basename="request-periods",
+)
+
+# Review Routers
+router.register(r"reviewrepresentation", viewsets.ReviewRepresentationViewSet, basename="reviewrepresentation")
+router.register(
+    r"reviewgrouprepresentation", viewsets.ReviewGroupRepresentationViewSet, basename="reviewgrouprepresentation"
+)
+router.register(
+    r"reviewquestioncategoryrepresentation",
+    viewsets.ReviewQuestionCategoryRepresentationViewSet,
+    basename="reviewquestioncategoryrepresentation",
+)
+router.register(
+    r"reviewquestionrepresentation",
+    viewsets.ReviewQuestionRepresentationViewSet,
+    basename="reviewquestionrepresentation",
+)
+
+router.register(r"reviewgroup", viewsets.ReviewGroupModelViewSet, basename="reviewgroup")
+
+router.register(r"review", viewsets.ReviewModelViewSet, basename="review")
+router.register(r"reviewtemplate", viewsets.ReviewTemplateModelViewSet, basename="reviewtemplate")
+
+router.register(
+    r"reviewquestioncategory", viewsets.ReviewQuestionCategoryModelViewSet, basename="reviewquestioncategory"
+)
+
+router.register(r"reviewquestion", viewsets.ReviewQuestionModelViewSet, basename="reviewquestion")
+router.register(r"reviewanswer", viewsets.ReviewAnswerModelViewSet, basename="reviewanswer")
+router.register(r"absencetable", viewsets.AbsenceTablePandasViewSet, basename="absencetable")
+
+reviewgroup_router = WBCoreRouter()
+reviewgroup_router.register(r"review", viewsets.ReviewReviewGroupModelViewSet, basename="reviewgroup-review")
+
+review_router = WBCoreRouter()
+review_router.register(r"reviewquestion", viewsets.ReviewQuestionReviewModelViewSet, basename="review-reviewquestion")
+review_router.register(
+    r"reviewquestionnocategory",
+    viewsets.ReviewQuestionReviewNoCategoryModelViewSet,
+    basename="review-reviewquestionnocategory",
+)
+review_router.register(
+    r"reviewanswerquestionnocategory",
+    viewsets.ReviewAnswerReviewNoCategoryModelViewSet,
+    basename="review-reviewanswerquestionnocategory",
+)
+
+
+review_category_router = WBCoreRouter()
+review_category_router.register(
+    r"reviewquestioncategory",
+    viewsets.ReviewQuestionReviewCategoryModelViewSet,
+    basename="review-reviewquestioncategory",
+)
+review_category_router.register(
+    r"reviewanswerquestioncategory",
+    viewsets.ReviewAnswerReviewQuestionCategoryModelViewSet,
+    basename="review-reviewanswerquestioncategory",
+)
+
+review_question_category_router = WBCoreRouter()
+review_question_category_router.register(
+    r"reviewquestion",
+    viewsets.ReviewQuestionReviewQuestionCategoryModelViewSet,
+    basename="reviewquestioncategory-reviewquestion",
+)
+
+# KPI routers
+router.register(r"kpi", viewsets.KPIModelViewSet, basename="kpi")
+router.register(r"kpirepresentation", viewsets.KPIRepresentationViewSet, basename="kpirepresentation")
+router.register(
+    r"evaluationrepresentation", viewsets.EvaluationRepresentationViewSet, basename="evaluationrepresentation"
+)
+
+kpi_router = WBCoreRouter()
+
+kpi_router.register(
+    r"evaluation",
+    viewsets.KPIEvaluationModelViewSet,
+    basename="kpi-evaluation",
+)
+kpi_router.register(r"evaluationgraph", viewsets.EvaluationGraphChartViewset, basename="kpi-evaluationgraph")
+
+
+# Review pandas views
+router.register("reviewprogress", viewsets.ReviewProgressPandasViewSet, basename="reviewprogress")
+router.register("kpievaluationpandas", viewsets.KPIEvaluationPandasViewSet, basename="kpievaluationpandas")
+review_router.register(r"progress", viewsets.ReviewProgressReviewPandasViewSet, basename="review-progress")
+review_router.register(
+    r"reviewanswerpandasview", viewsets.ReviewAnswerReviewPandasViewSet, basename="review-reviewanswerpandasview"
+)
+
+urlpatterns = [
+    path("", include(router.urls)),
+    path(
+        "absencerequesttype/<int:absencerequesttype_id>/",
+        include(absencerequesttype_router.urls),
+    ),
+    path(
+        "employee/<int:employee_id>/",
+        include(employee_router.urls),
+    ),
+    path(
+        "request/<int:request_id>/",
+        include(absence_request_router.urls),
+    ),
+    path(
+        "calendar/<int:calendar_id>/",
+        include(calendar_router.urls),
+    ),
+    path("reviewgroup/<int:review_group_id>/", include(reviewgroup_router.urls)),
+    path("review/<int:review_id>/", include(review_router.urls)),
+    path("review/<int:review_id>/category/<int:category_id>/", include(review_category_router.urls)),
+    path("reviewquestioncategory/<int:category_id>/", include(review_question_category_router.urls)),
+    path("kpi/<int:kpi_id>/", include(kpi_router.urls)),
+]

wbhuman_resources/utils.py

@@ -0,0 +1,43 @@
+from collections import OrderedDict, defaultdict
+from datetime import datetime
+
+from dateutil import rrule
+from django.utils import timezone
+
+
+def get_number_of_hours_between_dates(
+    d1, d2, list_employee_dayoffs, list_public_holidays=False, hours_range=None, granularity=12
+):
+    if hours_range is None:
+        hours_range = range(0, 23)
+
+    def convert_days_from_hours(hours, granularity, hours_per_day):
+        return int(hours / granularity) * granularity / hours_per_day
+
+    rules = rrule.rruleset()
+
+    byweekday_list = [rrule.MO, rrule.TU, rrule.WE, rrule.TH, rrule.FR, rrule.SA, rrule.SU]
+
+    rules.rrule(
+        rrule.rrule(
+            freq=rrule.HOURLY,
+            byweekday=byweekday_list,
+            byhour=hours_range,
+            dtstart=d1,
+            until=d2,
+        )
+    )
+    if list_public_holidays:
+        list_employee_dayoffs.extend(list_public_holidays)
+    current_tz = timezone.get_current_timezone()
+    for holiday in sorted(list_employee_dayoffs):
+        s1 = datetime(holiday.year, holiday.month, holiday.day, 0, 0, 0, tzinfo=current_tz)
+        s2 = datetime(holiday.year, holiday.month, holiday.day, 23, 59, 59, tzinfo=current_tz)
+        rules.exrule(rrule.rrule(rrule.HOURLY, dtstart=s1, until=s2))
+    dates = defaultdict(int)
+    for r in list(rules):
+        dates[r.date()] += 1
+    final = OrderedDict()
+    for k, v in dates.items():
+        final[k] = convert_days_from_hours(v, granularity, len(hours_range))
+    return final

wbhuman_resources/viewsets/__init__.py

@@ -0,0 +1,61 @@
+from .absence import (
+    AbsenceRequestCrossBorderCountryModelViewSet,
+    AbsenceRequestEmployeeHumanResourceModelViewset,
+    AbsenceRequestModelViewSet,
+    AbsenceRequestPeriodsAbsenceRequestModelViewSet,
+    AbsenceRequestTypeModelViewSet,
+    AbsenceRequestTypeRepresentationViewSet,
+    AbsenceTypeCountEmployeeModelViewSet,
+)
+from .absence_charts import AbsenceRequestPlanner, AbsenceTablePandasViewSet
+from .calendars import (
+    DayOffCalendarModelViewSet,
+    DayOffCalendarRepresentationViewSet,
+    DayOffDayOffCalendarModelViewSet,
+    DayOffModelViewSet,
+    DayOffRepresentationViewSet,
+    DefaultDailyPeriodDayOffCalendarModelViewSet,
+    DefaultDailyPeriodRepresentationViewSet,
+    EmployeeWeeklyOffPeriodsRepresentationViewSet,
+)
+from .employee import (
+    EmployeeBalanceModelViewSet,
+    EmployeeHumanResourceRepresentationViewSet,
+    EmployeeModelViewSet,
+    EmployeeYearBalanceRepresentationViewSet,
+    PositionModelViewSet,
+    PositionRepresentationViewSet,
+    WeeklyOffPeriodEmployeeHumanResourceModelViewSet,
+    YearBalanceEmployeeHumanResourceModelViewset,
+)
+from .kpi import (
+    EvaluationGraphChartViewset,
+    EvaluationRepresentationViewSet,
+    KPIEvaluationModelViewSet,
+    KPIEvaluationPandasViewSet,
+    KPIModelViewSet,
+    KPIRepresentationViewSet,
+)
+from .review import (
+    ReviewAnswerReviewPandasViewSet,
+    ReviewAnswerModelViewSet,
+    ReviewAnswerRepresentationViewSet,
+    ReviewAnswerReviewNoCategoryModelViewSet,
+    ReviewAnswerReviewQuestionCategoryModelViewSet,
+    ReviewGroupModelViewSet,
+    ReviewGroupRepresentationViewSet,
+    ReviewModelViewSet,
+    ReviewProgressPandasViewSet,
+    ReviewProgressReviewPandasViewSet,
+    ReviewQuestionCategoryModelViewSet,
+    ReviewQuestionCategoryRepresentationViewSet,
+    ReviewQuestionModelViewSet,
+    ReviewQuestionRepresentationViewSet,
+    ReviewQuestionReviewCategoryModelViewSet,
+    ReviewQuestionReviewModelViewSet,
+    ReviewQuestionReviewNoCategoryModelViewSet,
+    ReviewQuestionReviewQuestionCategoryModelViewSet,
+    ReviewRepresentationViewSet,
+    ReviewReviewGroupModelViewSet,
+    ReviewTemplateModelViewSet,
+)