wbhuman_resources 2.2.1__py2.py3-none-any.whl

wbhuman_resources/factories/absence.py

@@ -0,0 +1,108 @@
+import random
+
+import factory
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from psycopg.types.range import TimestamptzRange
+from wbcore.contrib.icons import WBIcon
+from wbhuman_resources.models import (
+    AbsenceRequest,
+    AbsenceRequestPeriods,
+    AbsenceRequestType,
+)
+
+from .calendars import DefaultDailyPeriodFactory
+from .employee import EmployeeYearBalanceFactory
+
+fake = Faker()
+
+
+class AbsenceRequestTypeFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = AbsenceRequestType
+        django_get_or_create = ["title"]
+
+    title = factory.Faker("text", max_nb_chars=64)
+    icon = factory.Iterator(WBIcon.values)
+    is_vacation = factory.Faker("boolean")
+    is_timeoff = factory.Faker("boolean")
+    is_extensible = factory.Faker("boolean")
+    auto_approve = False
+    days_in_advance = factory.Faker("pyint", min_value=0, max_value=5)
+
+    @factory.post_generation
+    def crossborder_countries(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for country in extracted:
+                self.crossborder_countries.add(country)
+
+
+def _get_random_period(calendar):
+    lower = Faker().future_datetime() + BDay(0)
+    upper = lower + BDay(random.randint(1, 7))
+    return TimestamptzRange(
+        lower=lower.to_pydatetime().astimezone(calendar.timezone),
+        upper=upper.to_pydatetime().astimezone(calendar.timezone),
+    )
+
+
+class VacationTypeFactory(AbsenceRequestTypeFactory):
+    title = "Vacation"
+    is_vacation = True
+    is_timeoff = True
+    is_extensible = False
+    auto_approve = False
+
+
+class TimeOffTypeFactory(AbsenceRequestTypeFactory):
+    title = "TimeOff"
+    is_vacation = False
+    is_timeoff = True
+    is_extensible = True
+    auto_approve = True
+
+
+class AbsenceRequestFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = AbsenceRequest
+
+    period = factory.LazyAttribute(lambda o: _get_random_period(o.employee.calendar))
+    attachment = factory.django.FileField()
+    type = factory.SubFactory("wbhuman_resources.factories.AbsenceRequestTypeFactory")
+    employee = factory.SubFactory("wbhuman_resources.factories.EmployeeHumanResourceFactory")
+    notes = factory.Faker("text")
+    reason = factory.Faker("text")
+
+
+class VacationRequestFactory(AbsenceRequestFactory):
+    type = factory.SubFactory(VacationTypeFactory)
+    status = AbsenceRequest.Status.APPROVED
+
+
+class TimeOffRequestFactory(AbsenceRequestFactory):
+    type = factory.SubFactory(TimeOffTypeFactory)
+    status = AbsenceRequest.Status.APPROVED
+
+
+class AbsenceRequestPeriodsFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = AbsenceRequestPeriods
+        django_get_or_create = ["employee", "default_period", "date"]
+
+    date = factory.LazyAttribute(lambda o: (fake.date_object() + BDay(0)).date())
+    employee = factory.SubFactory("wbhuman_resources.factories.EmployeeHumanResourceFactory")
+    default_period = factory.LazyAttribute(lambda o: DefaultDailyPeriodFactory.create(calendar=o.employee.calendar))
+    request = factory.LazyAttribute(
+        lambda o: AbsenceRequestFactory.create(
+            status=AbsenceRequest.Status.APPROVED,
+            type=VacationTypeFactory.create(),
+            employee=o.employee,
+            period=TimestamptzRange(
+                lower=o.default_period.get_lower_datetime(o.date), upper=o.default_period.get_upper_datetime(o.date)
+            ),
+        )
+    )
+    balance = factory.LazyAttribute(lambda o: EmployeeYearBalanceFactory.create(year=o.date.year, employee=o.employee))

wbhuman_resources/factories/calendars.py

@@ -0,0 +1,59 @@
+import zoneinfo
+from datetime import time
+
+import factory
+from faker import Faker
+from wbhuman_resources.models.calendars import (
+    DayOff,
+    DayOffCalendar,
+    DefaultDailyPeriod,
+)
+
+fake = Faker()
+
+
+class BaseDayOffCalendarFactory(factory.django.DjangoModelFactory):
+    title = "Default Calendar"
+    resource = "europe.Germany"
+    timezone = zoneinfo.ZoneInfo("UTC")
+
+    class Meta:
+        model = DayOffCalendar
+        django_get_or_create = ["resource"]
+
+
+class DayOffCalendarFactory(BaseDayOffCalendarFactory):
+    @factory.post_generation
+    def post_gen(self, create, extracted, **kwargs):
+        if create:
+            DefaultDailyPeriodFactory.create(calendar=self)
+            DefaultDailyPeriodFactory.create(
+                calendar=self,
+                lower_time=time(
+                    14,
+                    0,
+                    0,
+                ),
+                upper_time=time(18, 0, 0),
+                title="afternoon",
+            )
+
+
+class DefaultDailyPeriodFactory(factory.django.DjangoModelFactory):
+    lower_time = time(9, 0, 0)
+    upper_time = time(13, 0, 0)
+    title = "morning"
+    calendar = factory.SubFactory("wbhuman_resources.factories.BaseDayOffCalendarFactory")
+
+    class Meta:
+        model = DefaultDailyPeriod
+        django_get_or_create = ["lower_time", "upper_time", "calendar"]
+
+
+class DayOffFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = DayOff
+
+    title = factory.Faker("text", max_nb_chars=64)
+    date = factory.Faker("date_object")
+    calendar = factory.SubFactory("wbhuman_resources.factories.DayOffCalendarFactory")

wbhuman_resources/factories/employee.py

@@ -0,0 +1,79 @@
+import factory
+from django.contrib.auth.models import Group
+from django.db.models.signals import post_save
+from faker import Faker
+from wbhuman_resources.models import (
+    BalanceHourlyAllowance,
+    EmployeeHumanResource,
+    EmployeeWeeklyOffPeriods,
+    EmployeeYearBalance,
+    Position,
+)
+
+fake = Faker()
+
+
+class PositionFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Position
+
+    name = factory.Faker("text", max_nb_chars=64)
+    manager = None
+
+    @factory.post_generation
+    def post_gen(self, create, extracted, **kwargs):
+        group = Group.objects.get_or_create(name="Test Group")[0]
+        self.groups.add(group)
+
+
+@factory.django.mute_signals(post_save)
+class EmployeeHumanResourceFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = EmployeeHumanResource
+        django_get_or_create = ["profile"]
+
+    is_active = True
+    profile = factory.SubFactory("wbcore.contrib.authentication.factories.AuthenticatedPersonFactory")
+    direct_manager = factory.SubFactory("wbcore.contrib.directory.factories.PersonFactory")
+    calendar = factory.SubFactory("wbhuman_resources.factories.DayOffCalendarFactory")
+    position = factory.SubFactory(PositionFactory)
+    enrollment_at = factory.Faker("past_date")
+    extra_days_frequency = EmployeeHumanResource.ExtraDaysBalanceFrequency.YEARLY
+
+    contract_type = EmployeeHumanResource.ContractType.INTERNAL
+    occupancy_rate = factory.Faker("pyfloat", min_value=0, max_value=1)
+
+
+class EmployeeYearBalanceFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = EmployeeYearBalance
+        django_get_or_create = ["employee", "year"]
+
+    employee = factory.SubFactory("wbhuman_resources.factories.EmployeeHumanResourceFactory")
+    year = factory.Faker("pyint", min_value=1970, max_value=2022)
+    extra_balance = factory.Faker("pyint", min_value=0, max_value=20)
+
+    @factory.post_generation
+    def post_gen(self, create, extracted, **kwargs):
+        if create:
+            BalanceHourlyAllowanceFactory.create(balance=self)
+
+
+class BalanceHourlyAllowanceFactory(factory.django.DjangoModelFactory):
+    balance = factory.SubFactory("wbhuman_resources.factories.EmployeeYearBalanceFactory")
+    period_index = 1
+    hourly_allowance = factory.Faker("pyint", min_value=160, max_value=200)
+
+    class Meta:
+        model = BalanceHourlyAllowance
+        django_get_or_create = ["balance", "period_index"]
+
+
+class EmployeeWeeklyOffPeriodsFactory(factory.django.DjangoModelFactory):
+    employee = factory.SubFactory("wbhuman_resources.factories.EmployeeHumanResourceFactory")
+    period = factory.LazyAttribute(lambda x: x.employee.calendar.default_periods.order_by("?")[0])
+    weekday = factory.Faker("pyint", min_value=0, max_value=7)
+
+    class Meta:
+        model = EmployeeWeeklyOffPeriods
+        django_get_or_create = ["employee", "period", "weekday"]

wbhuman_resources/factories/kpi.py

@@ -0,0 +1,154 @@
+import random
+from datetime import timedelta
+
+import factory
+import pytz
+from django.utils import timezone
+from faker import Faker
+from psycopg.types.range import DateRange
+from wbcore.contrib.authentication.factories import InternalUserFactory
+from wbcore.contrib.directory.factories.entries import PersonFactory
+from wbhuman_resources.models import (
+    KPI,
+    Evaluation,
+    Review,
+    ReviewAnswer,
+    ReviewGroup,
+    ReviewQuestion,
+    ReviewQuestionCategory,
+)
+
+fake = Faker()
+
+
+class ReviewGroupFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = ReviewGroup
+
+    name = factory.Faker("text", max_nb_chars=64)
+
+    @factory.post_generation
+    def employees(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for employee in extracted:
+                self.employees.add(employee)
+
+
+class ReviewAbstractFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Review
+        django_get_or_create = ["moderator"]
+
+    review_group = factory.SubFactory(ReviewGroupFactory)
+    review = factory.Faker("date_time_between", start_date="+5d", end_date="+6d", tzinfo=pytz.utc)
+    moderator = factory.LazyAttribute(lambda o: InternalUserFactory.create().profile)
+    year = factory.Faker("pyint", min_value=1000, max_value=9999)
+
+
+class ReviewFactory(ReviewAbstractFactory):
+    class Meta:
+        model = Review
+        django_get_or_create = ["moderator", "reviewee", "reviewer"]
+
+    from_date = factory.Faker("date_between", start_date="+2d", end_date="+3d")
+    to_date = factory.Faker("date_between", start_date="+4d", end_date="+5d")
+    review_deadline = factory.Faker("date_between", start_date="+5d", end_date="+6d")
+    reviewee = factory.LazyAttribute(lambda o: InternalUserFactory.create().profile)
+    reviewer = factory.LazyAttribute(lambda o: InternalUserFactory.create().profile)
+    feedback_reviewee = factory.Faker("text")
+    feedback_reviewer = factory.Faker("text")
+
+    signed_reviewee = factory.Faker("date_time", tzinfo=pytz.utc)
+    signed_reviewer = factory.Faker("date_time", tzinfo=pytz.utc)
+    completely_filled_reviewee = factory.Faker("date_time", tzinfo=pytz.utc)
+    completely_filled_reviewer = factory.Faker("date_time", tzinfo=pytz.utc)
+
+
+class CompletedFilledReviewFactory(ReviewFactory):
+    completely_filled_reviewee = factory.Faker("date_time", tzinfo=pytz.utc)
+    completely_filled_reviewer = factory.Faker("date_time", tzinfo=pytz.utc)
+
+
+class SignedReviewFactory(CompletedFilledReviewFactory):
+    signed_reviewee = factory.Faker("date_time", tzinfo=pytz.utc)
+    signed_reviewer = factory.Faker("date_time", tzinfo=pytz.utc)
+
+
+class ReviewTemplateFactory(ReviewAbstractFactory):
+    is_template = True
+
+
+class ReviewQuestionCategoryFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = ReviewQuestionCategory
+
+    name = factory.Faker("text", max_nb_chars=64)
+    order = factory.Faker("pyint", min_value=0, max_value=9999)
+    weight = factory.Faker("pydecimal", right_digits=1, min_value=0, max_value=9999)
+
+
+class ReviewQuestionNoCategoryFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = ReviewQuestion
+
+    review = factory.SubFactory(ReviewFactory)
+    question = factory.Faker("text")
+    order = factory.Faker("pyint", min_value=0, max_value=9999)
+    weight = factory.Faker("pydecimal", right_digits=1, min_value=0, max_value=9999)
+
+
+class ReviewQuestionFactory(ReviewQuestionNoCategoryFactory):
+    category = factory.SubFactory(ReviewQuestionCategoryFactory)
+
+
+class ReviewAnswerFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = ReviewAnswer
+
+    question = factory.SubFactory(ReviewQuestionFactory)
+    answered_by = factory.LazyAttribute(lambda o: InternalUserFactory.create().profile)
+    answered_anonymized = hash(factory.SelfAttribute("answered_by"))
+    answer_number = factory.Faker("pyint", min_value=0, max_value=9999)
+    answer_text = factory.Faker("text")
+
+
+class ReviewAnswerNoCategoryFactory(ReviewAnswerFactory):
+    question = factory.SubFactory(ReviewQuestionNoCategoryFactory)
+
+
+class KPIFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = KPI
+
+    name = factory.Faker("pystr")
+    goal = factory.Faker("pyint", min_value=0, max_value=9999)
+    period = DateRange(timezone.now().date(), timezone.now().date() + timedelta(days=random.randint(4, 5)))
+    handler = "wbcrm.kpi_handlers.activities.NumberOfActivityKPI"
+
+    @factory.post_generation
+    def evaluated_persons(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for person in extracted:
+                self.evaluated_persons.add(person)
+
+
+class DefaultPersonKPIFactory(KPIFactory):
+    @factory.post_generation
+    def evaluated_persons(self, create, extracted, **kwargs):
+        self.evaluated_persons.add(PersonFactory())
+
+
+class EvaluationFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Evaluation
+
+    kpi = factory.SubFactory(KPIFactory)
+    person = factory.SubFactory("wbcore.contrib.directory.factories.PersonFactory")
+    evaluated_period = DateRange(timezone.now().date(), timezone.now().date() + timedelta(days=random.randint(4, 5)))
+    evaluation_date = timezone.now().date()

wbhuman_resources/filters/__init__.py

@@ -0,0 +1,20 @@
+from .absence import (
+    AbsenceRequestEmployeeHumanResourceFilterSet,
+    AbsenceRequestFilter,
+    AbsenceTypeCountEmployeeModelFilterSet,
+)
+from .absence_graphs import AbsenceRequestPlannerFilter, AbsenceTableFilter
+from .calendars import DayOffFilter
+from .employee import EmployeeBalanceFilterSet, EmployeeFilterSet, PositionFilterSet
+from .kpi import KPIFilterSet, KPIEvaluationFilterSet, KPIEvaluationPandasFilter
+from .review import (
+    ReviewGroupFilter,
+    ReviewTemplateFilter,
+    ReviewFilter,
+    ReviewQuestionCategoryFilter,
+    ReviewQuestionFilter,
+    ReviewAnswerFilter,
+    ReviewProgressReviewFilter,
+    RatingReviewAnswerReviewFilter,
+)
+from .signals import *

wbhuman_resources/filters/absence.py

@@ -0,0 +1,108 @@
+from datetime import date, timedelta
+
+import pandas as pd
+from django.utils.timezone import localdate
+from django.utils.translation import gettext_lazy as _
+from psycopg.types.range import TimestamptzRange
+from wbcore import filters as wb_filters
+from wbcore.contrib.agenda.filters import CalendarItemPeriodBaseFilterSet
+from wbhuman_resources.models import (
+    AbsenceRequest,
+    AbsenceRequestPeriods,
+    AbsenceRequestType,
+    Position,
+)
+
+
+def current_year_date_start(*args, **kwargs):
+    d = localdate()
+    return date(d.year, 1, 1)
+
+
+def current_year_date_end(*args, **kwargs):
+    d = localdate()
+    return max((d + pd.tseries.offsets.YearEnd(1)).date(), d + timedelta(days=60))
+
+
+class AbsenceRequestFilter(CalendarItemPeriodBaseFilterSet):
+    conference_room = boolean_conference_room = None
+    department = wb_filters.ModelChoiceFilter(
+        label=_("Department"),
+        queryset=Position.objects.all(),
+        endpoint=Position.get_representation_endpoint(),
+        value_key=Position.get_representation_value_key(),
+        label_key=Position.get_representation_label_key(),
+        method="filter_position",
+    )
+    is_active_employee = wb_filters.BooleanFilter(
+        label=_("Is Employee Active"), method="boolean_is_active_employee", default=True
+    )
+    _total_hours_in_days__gte = wb_filters.NumberFilter(
+        lookup_expr="gte", label="Total hours", field_name="_total_hours_in_days"
+    )
+    _total_vacation_hours_in_days__gte = wb_filters.NumberFilter(
+        lookup_expr="gte", label="Total hours", field_name="_total_vacation_hours_in_days"
+    )
+    _total_hours_in_days__lte = wb_filters.NumberFilter(
+        lookup_expr="lte", label="Total hours", field_name="_total_hours_in_days"
+    )
+    _total_vacation_hours_in_days__lte = wb_filters.NumberFilter(
+        lookup_expr="lte", label="Total hours", field_name="_total_vacation_hours_in_days"
+    )
+
+    def get_default_period(self):
+        return TimestamptzRange(lower=current_year_date_start(), upper=current_year_date_end())
+
+    def boolean_is_active_employee(self, queryset, name, value):
+        if value:
+            return queryset.filter(employee__is_active=True)
+        #     return queryset.filter(employee__in=EmployeeHumanResource.active_internal_employees.all())
+        return queryset
+
+    def filter_position(self, queryset, name, value):
+        if value:
+            return queryset.filter(department__in=value.get_descendants(include_self=True)).distinct()
+        return queryset
+
+    class Meta:
+        model = AbsenceRequest
+        fields = {
+            "employee": ["exact"],
+            "status": ["exact"],
+            "type": ["exact"],
+            "created": ["gte", "exact", "lte"],
+        }
+
+
+class AbsenceTypeCountEmployeeModelFilterSet(wb_filters.FilterSet):
+    year = wb_filters.YearFilter(field_name="year", lookup_expr="exact")
+
+    absence_type = wb_filters.ModelChoiceFilter(
+        label=_("Type"),
+        queryset=AbsenceRequestType.objects.all(),
+        endpoint=AbsenceRequestType.get_representation_endpoint(),
+        value_key=AbsenceRequestType.get_representation_value_key(),
+        label_key=AbsenceRequestType.get_representation_label_key(),
+        method="filter_absence_type",
+    )
+
+    def filter_absence_type(self, queryset, label, value):
+        if value:
+            return queryset.filter(request__type=value)
+        return queryset
+
+    class Meta:
+        model = AbsenceRequestPeriods
+        fields = {}
+
+
+class AbsenceRequestEmployeeHumanResourceFilterSet(AbsenceRequestFilter):
+    department = is_active_employee = None
+
+    class Meta:
+        model = AbsenceRequest
+        fields = {
+            "status": ["exact"],
+            "type": ["exact"],
+            "created": ["gte", "exact", "lte"],
+        }

wbhuman_resources/filters/absence_graphs.py

@@ -0,0 +1,84 @@
+from datetime import timedelta
+
+import pandas as pd
+from django.utils.timezone import localdate
+from django.utils.translation import gettext_lazy as _
+from dynamic_preferences.registries import global_preferences_registry
+from psycopg.types.range import TimestamptzRange
+from wbcore import filters as wb_filters
+from wbhuman_resources.models import AbsenceRequestPeriods, DayOffCalendar, Position
+
+
+def current_year_date_range(*args, **kwargs):
+    d = localdate()
+    return TimestamptzRange(
+        (localdate() - pd.tseries.offsets.Week(weekday=0)).date(),
+        max((d + pd.tseries.offsets.YearEnd(1)).date(), d + timedelta(days=60)),
+    )
+
+
+def monday_of_current_week(*args, **kwargs):
+    today = localdate()
+    return today - timedelta(days=today.weekday())
+
+
+def get_calendar_default(field, request, view, **kwargs) -> int | None:
+    if (profile := request.user.profile) and (employee := getattr(profile, "human_resources", None)):
+        return employee.calendar.id
+    if calendar := global_preferences_registry.manager()["wbhuman_resources__employee_default_calendar"]:
+        return calendar.id
+    try:
+        return DayOffCalendar.objects.first().id
+    except AttributeError:
+        return None
+
+
+class AbsenceRequestPlannerFilter(wb_filters.FilterSet):
+    calendar = wb_filters.ModelChoiceFilter(
+        label=_("Calendar"),
+        required=True,
+        clearable=False,
+        queryset=DayOffCalendar.objects.all(),
+        endpoint=DayOffCalendar.get_representation_endpoint(),
+        value_key=DayOffCalendar.get_representation_value_key(),
+        label_key=DayOffCalendar.get_representation_label_key(),
+        default=get_calendar_default,
+        method=lambda queryset, label, value: queryset,
+    )
+
+    date = wb_filters.DateRangeFilter(
+        label=_("Date Range"),
+        method=lambda queryset, label, value: queryset,
+        required=True,
+        clearable=False,
+        default=current_year_date_range,
+    )
+    only_employee_with_absence_periods = wb_filters.BooleanFilter(
+        default=False,
+        label=_("Only Employee With Absence periods"),
+        method=lambda queryset, label, value: queryset,
+    )
+
+    position = wb_filters.ModelChoiceFilter(
+        label=_("Position"),
+        queryset=Position.objects.all(),
+        endpoint=Position.get_representation_endpoint(),
+        value_key=Position.get_representation_value_key(),
+        label_key=Position.get_representation_label_key(),
+        method=lambda queryset, label, value: queryset,
+    )
+
+    class Meta:
+        model = AbsenceRequestPeriods
+        fields = {}
+
+
+class AbsenceTableFilter(AbsenceRequestPlannerFilter):
+    date_gte = date_lte = None
+    date = wb_filters.DateFilter(
+        label=_("Week Day"),
+        method=lambda queryset, label, value: queryset,
+        default=monday_of_current_week,
+        required=True,
+        help_text="Change this date to any day on the week you are interested in seeing the presence table",
+    )

wbhuman_resources/filters/calendars.py

@@ -0,0 +1,28 @@
+from django.utils.translation import gettext_lazy as _
+from wbcore import filters as wb_filters
+from wbcore.filters.defaults import current_year_date_range
+from wbhuman_resources.models import DayOff
+
+
+class DayOffFilter(wb_filters.FilterSet):
+    date = wb_filters.DateRangeFilter(
+        label=_("Date Range"),
+        required=True,
+        clearable=False,
+        method=wb_filters.DateRangeFilter.base_date_range_filter_method,
+        default=current_year_date_range,
+    )
+
+    def start_filter(self, queryset, name, value):
+        if value:
+            return queryset.filter(date__gte=value)
+        return queryset
+
+    def end_filter(self, queryset, name, value):
+        if value:
+            return queryset.filter(date__lte=value)
+        return queryset
+
+    class Meta:
+        model = DayOff
+        fields = {"count_as_holiday": ["exact"], "calendar": ["exact"]}