Work entries ¶

_generate_work_entries(date_start, date_stop)[源代码]¶

Compute and post-process the work entry values between two datetimes.

Clips the period to each version’s [date_start, date_end] (whole local days), groups versions sharing the same clipped period, calls _get_work_entries_values() and finally _generate_work_entries_postprocess().

参数

date_start (datetime) – period start, naive UTC, already localized by the caller
date_stop (datetime) – period end, naive UTC

返回

final values, see generate_work_entries()

返回类型

_get_work_entries_values(date_start, date_stop)[源代码]¶

Return the raw work entry values of the versions of self between two dates.

Thin wrapper on _get_version_work_entries_values(). With datetimes, the versions are processed in one batch. With plain dates, the period goes from the start of date_start to the end of date_stop in each version’s timezone.

参数

date_start – period start, datetime (naive is considered UTC) or date
date_stop – period end, datetime (naive is considered UTC) or date (included)

返回

raw values, see _get_version_work_entries_values()

返回类型

_get_version_work_entries_values(date_start, date_stop)[源代码]¶

Compute the raw work entry values of the versions of self over a period.

Core of the generation, batched over versions. For each version:

expected attendances: _get_attendance_intervals();
leaves: _get_resource_calendar_leaves(), clipped to the period and filtered by _get_valid_leave_intervals(), split on the calendar leave’s count_as: absence leaves replace the expected attendances they overlap, working_time leaves (e.g. home working) produce worked leave entries;
real attendances = attendances minus both kinds of leaves (_get_real_attendances()); the leave intervals actually generated depend on the calendar type (fully flexible, flexible, static, or attendance based).

Override it to add or replace values for a localization (l10n_fr_hr_holidays, l10n_uz_hr_payroll) or for a new source of time (hr_holidays_attendance adds the hr.attendance based values). Values must be completed by _generate_work_entries_postprocess() before use.

参数

date_start (datetime) – period start; naive datetimes are considered UTC
date_stop (datetime) – period end; naive datetimes are considered UTC

返回

list of dicts with date_start and date_stop (naive UTC), work_entry_type_id, employee_id, version_id, company_id (recordsets) and the extra keys of the _get_more_vals_* hooks. Alternatively, a value may carry date and duration directly.

返回类型

_generate_work_entries_postprocess(vals_list)[源代码]¶

Turn raw work entry values into final date/duration values.

Steps:

values without date_start/date_stop must already have date and duration (UserError otherwise) and are kept as is;
the others are split at each local midnight (timezone of version_id);
date is the local day of the start; duration is kept if given, otherwise computed from the calendar or from the span, see _generate_work_entries_postprocess_adapt_to_calendar(); date_start and date_stop are removed, then _enrich_work_entry_val() is called;
values with a zero duration (3 digits) are dropped, the others are merged by _get_work_entry_merge_key(), summing duration and trimmed_duration and unioning the _get_work_entry_source_fields() keys.

A raw value providing duration should also provide date, and should not cross local midnight (each split part would keep the full duration).

参数: vals_list (list) – raw values, see _get_version_work_entries_values()
返回: final values, see generate_work_entries()
返回类型: list[dict]
引发: UserError – when a version has no timezone or a value has neither dates nor date and duration

_generate_work_entries_postprocess_adapt_to_calendar(vals)[源代码]¶

Tell whether the duration of a value is computed from the working schedule.

True: duration is the number of hours the version’s calendar plans in the value’s span (_get_work_days_data_batch with compute_leaves=False), so a time off counts the planned hours. False: duration is the real length of the span. Default: True for absence types. hr_holidays also returns True for time off types not requested in hours (but False for time rule outputs); hr_holidays_attendance returns False for attendance values and fully flexible versions. Overrides must not rely on vals keys other than the raw ones.

参数: vals (dict) – raw value (date_start/date_stop still set)
返回类型: bool

_enrich_work_entry_val(val)[源代码]¶

Hook called on each value once date and duration are set, before merging.

Modify val in place. At this point leave_ids (if any) is still a single record, so field access is safe. hr_payroll sets trimmed_duration, which is summed when values are merged. Default: no-op.

参数: val (dict) – one work entry value

_get_work_entry_merge_key(vals)[源代码]¶

Return the key identifying the work entry values to merge into one.

Values with the same key are merged by summing duration. Default key: (date, work_entry_type_id, employee_id, version_id, company_id). Extend the tuple to keep values apart (hr_payroll adds category_options_ids).

参数: vals (dict) – one work entry value, with date set
返回类型: tuple

_get_work_entry_source_fields()[源代码]¶

Return the keys whose values are unioned when work entry values are merged.

Used by _generate_work_entries_postprocess(): when two values share the same merge key, these recordset keys are combined with |. Extensions add their source keys (leave_ids in hr_holidays, attendance_ids in hr_holidays_attendance).

返回: list of keys to aggregate
返回类型: list[str]

has_static_work_entries()[源代码]¶

Tell whether the work entries of this version come from its working schedule.

True (default): worked time is generated from the calendar attendances. False: worked time comes from another source; hr_holidays_attendance returns not attendance_based, worked time then coming from validated hr.attendance records. See _get_attendance_intervals() for what an override must also do.

返回类型: bool

_get_attendance_intervals(start_dt, end_dt)[源代码]¶

Return the expected working intervals of the calendar based versions of self.

Only versions with has_static_work_entries() are computed, from their working schedule (_attendance_intervals_batch). A fully flexible version gets a single interval covering the whole period with an empty attendance payload (hence 24h per day once split per day).

A module making versions non-static must override this method to still put an (empty) entry for their resources, as _get_version_work_entries_values() indexes the result directly (see hr_holidays_attendance).

参数

start_dt (datetime) – period start, tz-aware (asserted)
end_dt (datetime) – period end, tz-aware (asserted)

返回

{resource_id: Intervals}, intervals being (start, stop, resource.calendar.attendance) in the resource timezone

返回类型

_get_real_attendance_work_entry_vals(intervals)[源代码]¶

Convert attendance intervals into raw work entry values.

Meant for behavior override.

参数: intervals – iterable of (start, stop, payload), tz-aware
返回: one dict per interval with date_start and date_stop (naive UTC), work_entry_type_id (_get_interval_work_entry_type()), employee_id, version_id, company_id (all recordsets), plus the pairs of _get_more_vals_attendance_interval()
返回类型: list[dict]

_get_real_attendances(attendances, leaves, worked_leaves)[源代码]¶

Return the attendance intervals that produce worked time entries.

Default: expected attendances minus absence and worked leaves. hr_holidays_attendance also removes the days where the employee has real hr.attendance records.

参数

attendances (Intervals) – expected attendances
leaves (Intervals) – absence leaves
worked_leaves (Intervals) – working time leaves

返回类型

Intervals

_get_real_leaves_static(leaves, expected_attendances)[源代码]¶

Return the absence intervals to generate for a static (calendar based) version.

Default: the parts of leaves that overlap the expected attendances, i.e. a leave only produces entries where the employee was supposed to work.

返回类型: Intervals

_get_real_leaves_static_attendance(leaves, static_attendances)[源代码]¶

Return the absence intervals to generate for a non-static (attendance based) version.

The expected attendances are empty for such a version, so leaves are intersected with the intervals of its working schedule instead.

返回类型: Intervals

_get_real_worked_leaves(worked_leaves, real_leaves)[源代码]¶

Return the working time leave intervals to generate.

Default: worked leaves minus the absence intervals (an absence wins over a working time leave).

返回类型: Intervals

_get_default_work_entry_type_id()[源代码]¶

Return the id of the work entry type used for worked time without explicit type.

Used for calendar attendances without work_entry_type_id and for attendances without type. Default: the 002.00 type of the version’s country, else the generic hr_work_entry.generic_work_entry_type_attendance. hr_payroll gives precedence to the structure type’s default_work_entry_type_id.

返回: an hr.work.entry.type id, or False if none is found
返回类型: int

_get_interval_work_entry_type(interval)[源代码]¶

Return the work entry type of an interval from its payload.

The payload’s work_entry_type_id (first record) if any, else the version’s default type (_get_default_work_entry_type_id()).

参数: interval (tuple) – (start, stop, payload); payload is usually a resource.calendar.attendance or resource.calendar.leaves recordset
返回类型: hr.work.entry.type

_get_leave_work_entry_type(leave)[源代码]¶

Return the work entry type of a resource.calendar.leaves record.

hr_holidays returns the type of the linked time off (holiday_id) when there is one.

返回类型: hr.work.entry.type

_get_leave_work_entry_type_dates(leave, date_from, date_to, employee)[源代码]¶

Return the work entry type of leave for the slice [date_from, date_to].

Override to make the type depend on the period, e.g. l10n_be_hr_payroll switches a sick leave to another type after 30 days. Default: _get_leave_work_entry_type().

参数

leave – the resource.calendar.leaves record covering the slice
date_from (datetime) – slice start, naive UTC
date_to (datetime) – slice end, naive UTC
employee – the hr.employee of the version

返回类型

hr.work.entry.type

_get_interval_leave_work_entry_type(interval, leaves, bypassing_codes)[源代码]¶

Return the work entry type of a leave interval.

Base version: the type of the first leave of leaves that contains the whole interval (through _get_leave_work_entry_type_dates()). hr_holidays overrides it to arbitrate overlapping leaves: bypassing time off, then global leaves (public holidays), then other time off.

参数

interval (tuple) – (start, stop, payload), tz-aware in the employee timezone
leaves (list) – (start, stop, resource.calendar.leaves) tuples
bypassing_codes (list) – result of _get_bypassing_work_entry_type_codes()

返回

the leave’s type, or hr_work_entry.generic_work_entry_type_leave if no leave contains the interval

返回类型

hr.work.entry.type

_get_bypassing_work_entry_type_codes()[源代码]¶

Return the codes of the leave types that win over public holidays.

When a time off and a global leave (public holiday) overlap, the global leave normally wins. A time off whose type code is listed here wins instead (e.g. long term sick leave in l10n_be_hr_payroll). Used by _get_interval_leave_work_entry_type().

返回: list of hr.work.entry.type codes
返回类型: list[str]

_get_more_vals_attendance_interval(interval)[源代码]¶

Hook to add extra keys to the work entry values generated from an attendance interval.

The result is concatenated to the base (key, value) pairs and passed to dict(), so later pairs override earlier ones. Extensions call super() and append, e.g. hr_holidays_attendance adds ('attendance_ids', attendance) and hr_payroll adds ('category_options_ids', ...). A key that holds records to be unioned on merge must also be listed in _get_work_entry_source_fields().

参数: interval (tuple) – (start, stop, payload), tz-aware datetimes in the employee timezone; payload is a resource.calendar.attendance recordset (calendar based) or an hr.attendance record (attendance based)
返回: list of (key, value) 2-tuples, not a dict
返回类型: list

_get_more_vals_leave_interval(interval, leaves)[源代码]¶

Hook to add extra keys to the work entry values generated from a leave interval.

Same contract as _get_more_vals_attendance_interval(). hr_holidays appends ('leave_ids', holiday) for each leave of leaves that contains interval and is linked to a time off.

参数

interval (tuple) – (start, stop, payload), tz-aware in the employee timezone
leaves (list) – (start, stop, resource.calendar.leaves) tuples that may cover interval

返回

list of (key, value) 2-tuples

返回类型

list

_get_leave_domain(start_dt, end_dt)[源代码]¶

Return the resource.calendar.leaves domain used for work entry generation.

Matches the leaves overlapping [start_dt, end_dt] that are global (no resource) or belong to the versions’ employees, in the versions’ companies or without company.

参数

start_dt (datetime) – period start, UTC (tzinfo is dropped)
end_dt (datetime) – period end, UTC (tzinfo is dropped)

返回类型

odoo.fields.Domain

_get_sub_leave_domain()[源代码]¶

Return the calendar part of the domain of _get_leave_domain().

Default: leaves of the versions’ calendars or without calendar. hr_holidays also accepts the leaves linked to time off of the versions’ employees, whatever the calendar.

返回类型: odoo.fields.Domain

_get_resource_calendar_leaves(start_dt, end_dt)[源代码]¶

Return the resource.calendar.leaves to consider between start_dt and end_dt.

Override to exclude leaves from generation (hr_payroll drops time off whose payslip is blocked/deferred).

参数

start_dt (datetime) – period start, UTC
end_dt (datetime) – period end, UTC

返回类型

resource.calendar.leaves

_get_valid_leave_intervals(attendances, interval)[源代码]¶

Filter or cut a leave interval before it is used for generation.

Called for each leave clipped to the period. hr_holidays_attendance removes the parts where the employee actually worked (absence leaves) or where an attendance won (working time leaves).

参数

attendances (Intervals) – expected attendances of the version’s resource
interval (tuple) – (start, stop, resource.calendar.leaves), tz-aware in the employee timezone

返回

list of (start, stop, payload) tuples to keep, possibly empty

返回类型

list

_get_no_wet_or_wet_match(leave, leave_entry_type)[源代码]¶

Tell whether leave is a source of a leave work entry of type leave_entry_type.

True if the calendar leave has no type or the same type. Only the matching leaves are given to _get_more_vals_leave_interval(), so a mismatch means no leave_ids on the generated values.

参数

leave (tuple) – (start, stop, resource.calendar.leaves)
leave_entry_type – the hr.work.entry.type chosen for the interval

返回类型

bool

Original definition from `hr_work_entry`¶

model odoo.addons.hr_work_entry.models.hr_time_rule.HrTimeRule[源代码]¶

_name = hr.time.rule¶

Threshold rule reclassifying worked or absent time (overtime, undertime).

A rule reads: when the time of the types condition_work_entry_type_ids within the timing window (weekdays, public holidays, timing_start-timing_stop) exceeds (threshold_operator = 'exceed') or is less than ('less_than') the expected hours of the period (quantity_period: day or week, from the schedule or expected_hours, see working_hours_mode), the excess or the missing time gets the type work_entry_type_id. employer_tolerance / employee_tolerance are the hours ignored before an excess / a deficit counts.

Rules are evaluated by _evaluate_rules() on hr.attendance and hr.leave records (the sources, see hr.time.rule.source.mixin) and their result is written back on the sources by _apply_output().

sequence: int¶

Name: Sequence
Default: 10

employee_domain: str¶

Name: Employees
Default: []

The rule will automatically apply to all time entries for matching employees.

threshold_operator: str¶

Required
Name: Threshold Operator
Selection: exceed: Exceed less_than: Less than
Default: exceed

working_hours_mode: str¶

Required
Name: Working Hours Mode
Selection: schedule_day: the daily schedule schedule_week: the weekly schedule day: per day week: per week
Default: schedule_day

Define a condition based on the quantity of work made by the employee on a specific period of time.

calendar_source: str¶

Name: Calendar Source
Selection: employee: Employee Schedule reference: Reference Schedule

Which schedule to use as the expected-hours baseline.

resource_calendar_id: int¶

Name: Schedule
Comodel: resource.calendar

expected_hours: float¶

Name: Usual work hours

quantity_period: str¶

Name: Quantity Period
Readonly: this field is not supposed to/cannot be set manually
Selection: day: Day week: Week

week_start: str¶

Name: Week Starts On
Selection: 0: Monday 1: Tuesday 2: Wednesday 3: Thursday 4: Friday 5: Saturday 6: Sunday
Default: 0

timing_start: float¶

Name: From
Default: 0

timing_stop: float¶

Name: To
Default: 24

employer_tolerance: float¶

Name: Employer Tolerance

employee_tolerance: float¶

Name: Employee Tolerance

condition_work_entry_type_ids: Sequence[odoo.orm.commands.Command]¶

Required
Name: Time Type
Comodel: hr.work.entry.type

If set, only the selected types will be considered by this rule.

work_entry_type_id: int¶

Name: Set Excess to
Comodel: hr.work.entry.type

Define a time type that will be created to count the amount of time in excess or missing.

amount_rate: float¶

Name: Salary Rate

_evaluate_rules(records, start_dt, end_dt)[源代码]¶

Run the rules of self in sequence on source records; nothing is written.

The sources are turned into a pipeline of _Iv intervals (naive local datetimes, see _get_pipeline_intervals_local). Each applicable rule, in sequence, id order, takes the intervals whose current type is in its condition_work_entry_type_ids and inside its timing window, evaluates each period (_evaluate_period()) and reclassifies the excess in the pipeline, so later rules see the output of earlier ones (e.g. a > 9h rule then a > 8h rule on the remaining attendance type). Rules without output type and without threshold just tag the matching intervals. Pass the result to _apply_output().

参数

records – source records (hr.attendance or hr.leave)
start_dt (datetime) – evaluated period start (only the date is used, as a day of the employees’ timezone)
end_dt (datetime) – evaluated period end (only the date is used)

返回

(excess, deficit, active_iv): excess is {employee: {source: [_Iv]}} with the intervals classified by a rule (pp not filled yet), deficit is {employee: {source: [(start, stop, rule)]}}, active_iv is {employee: {source: Intervals}} of the pipeline segments of each source

返回类型

_evaluate_period(start, stop, record_intervals, schedule)[源代码]¶

Compare the time worked in one period (day or week) with the rule’s threshold.

Expected hours: the schedule in the period if calendar_source is set, else expected_hours. Worked hours: union of the source intervals minus their breaks (prorated to the part of the source in the period).

exceed: when the excess is above employer_tolerance, the expected hours are consumed in chronological order and what remains is the excess, taken from the end of the source intervals.
less_than: when the deficit is above employee_tolerance, the gaps of the schedule (or of the period) not covered by worked time form the deficit, all attached to the source ending last.

参数

start (datetime) – period start, naive local
stop (datetime) – period end, naive local
record_intervals (list) – (start, stop, source) tuples of the period
schedule (Intervals) – schedule restricted to the rule window and the period

返回

(excess_by_source, deficit_by_source), each {source: [(start, stop, rule)]}; at most one of them is non-empty

返回类型

_apply_output(excess, deficit, active_iv=None)[源代码]¶

Write the result of _evaluate_rules() on the source records.

Shared by attendances and leaves (called by _apply_attendance_output / _apply_leave_output). Writes use the source’s _time_rule_write_ctx, so they do not trigger the rules again.

Excess: if the first output interval starts with the source, the source itself is reclassified (type, time_rule_id, end); otherwise the source is cut at the first output start. Each other output interval becomes a new record (_get_time_rule_output_vals) and the uncovered parts of the source a remainder record keeping the source type (_get_time_rule_remainder_vals). Rules without output type only annotate the source (_get_source_annotation_vals()).
Deficit: per period, only the lowest sequence rule is kept; the missing hours are placed as new output records in the free slots after the deficit start (not covered by other records of the model), minus what earlier runs already created.

参数

excess (dict) – {employee: {source: [_Iv]}}
deficit (dict) – {employee: {source: [(start, stop, rule)]}}
active_iv (dict) – {employee: {source: Intervals}} pipeline segments of the sources, used to compute the remainders

返回

(new_records, all_source_ids, excess_alloc, deficit_alloc): created records, ids of the processed sources, and allocation rows [employee, rule, hours, source, log_source] (log_source = record the credit is logged on, used by hr_holidays for compensatory allocations). Returns (None, frozenset(), [], []) when there is no source.

返回类型

_resolve_output_intervals(intervals)[源代码]¶

Return the excess intervals of a source in their final output form.

Sorts by start, drops empty intervals and intervals without type, sets wet to the rule’s work_entry_type_id (else the current type) and pp to the premium pay ids of the classifying rule and of the rules it displaced (acc). hr_holidays also merges consecutive slices with the same output.

参数: intervals (list) – _Iv excess intervals of one source
返回类型: list

_get_applicable_employees(employees)[源代码]¶

Return the employees of employees the rule applies to.

Filters on the rule’s company (or else country), then on employee_domain (evaluated as superuser). hr_attendance also drops employees without calendar for rules based on the employee schedule.

参数: employees – hr.employee recordset
返回类型: hr.employee
引发: ValidationError – if employee_domain cannot be evaluated

_get_schedule_calendar()[源代码]¶

Return the reference calendar of the rule.

返回: resource_calendar_id, else the company’s or the current company’s calendar when calendar_source is 'reference'; an empty recordset otherwise
返回类型: resource.calendar

_get_work_intervals(employees, start_dt, end_dt, schedule_calendar=None)[源代码]¶

Return the schedule data the rules compare worked time with, per employee.

Computed per version period of each employee, with naive datetimes in the employee’s timezone (as all the pipeline).

参数

employees – hr.employee recordset
start_dt (datetime) – period start (only the date is used)
end_dt (datetime) – period end (only the date is used)
schedule_calendar – reference resource.calendar replacing the versions’ calendars for the 'schedule' and 'public_leave' keys

返回

{key: {employee: Intervals}} with keys 'schedule' (planned attendances), 'public_leave' (global leaves of the calendar), 'leave' (absence leaves of the employee) and 'fully_flexible' (version periods with a fully flexible calendar)

返回类型

_build_work_intervals_by_calendar(employees, start_dt, end_dt)[源代码]¶

Compute _get_work_intervals() once per baseline calendar used by the rules of self.

返回: {calendar_id: work_intervals}, key False for the employees’ own schedules
返回类型: dict

_build_rule_day_intervals(min_date, max_date, employees, work_intervals_by_type)[源代码]¶

Return the timing window of the rule, per employee.

The days of [min_date, max_date] enabled by the apply_<weekday> flags, plus or minus the employee’s public holidays (apply_on_public_holidays), restricted to the rule’s hours (_build_hour_window_intervals()).

参数: work_intervals_by_type – result of _get_work_intervals()
返回: {employee: Intervals} of naive local datetimes
返回类型: dict

_build_hour_window_intervals(employees, day_intervals_by_employee)[源代码]¶

Restrict whole-day intervals to the rule’s timing_start-timing_stop hours.

参数: day_intervals_by_employee – {employee: Intervals} of whole days
返回: {employee: Intervals} of naive local datetimes
返回类型: dict

_dates_to_day_intervals(intervals)[源代码]¶

Return one whole-day interval (00:00 to 23:59:59.999999) per day touched by intervals.

返回类型: Intervals

_get_pp_frozenset()[源代码]¶

Return the premium pay ids attached to the intervals this rule classifies.

Hook for localizations (l10n_be); default: empty.

返回类型: frozenset

_get_source_annotation_vals(accumulated_pp=frozenset({}))[源代码]¶

Return extra values written on a source record reused as the first output.

When the output starts with the source, the source itself is reclassified (written) instead of creating a new record. Override to write the fields the _get_output_*_vals methods set on new output records (e.g. l10n_be_premium_pay_rule_ids).

参数: accumulated_pp (frozenset) – premium pay ids of the output interval(s)
返回类型: dict

Original definition from `hr_work_entry`¶

model odoo.addons.hr_work_entry.models.hr_time_rule_source_mixin.HrTimeRuleSourceMixin[源代码]¶

_name = hr.time.rule.source.mixin¶

Make a model a source of the time rule pipeline (hr.time.rule).

Inherited by hr.attendance and hr.leave. Creating a source, or writing its employee, span or the fields of _get_write_source_extra_source_fields(), triggers the rules (_trigger_time_rules()) unless the context has skip_time_rules. The rules then reclassify the source in place and/or create output records of the same model, linked to the source.

The inheriting model must have employee_id, work_entry_type_id and time_rule_id fields, set the class attributes below and implement the hooks raising NotImplementedError:

_time_rule_source_field: many2one from an output record to its source (source_attendance_id, source_leave_id);
_time_rule_output_field: the inverse one2many (overtime_attendance_ids, output_leave_ids);
_time_rule_span_start_field / _time_rule_span_end_field: datetime fields (UTC) holding the span (check_in/check_out, date_from/date_to);
_time_rule_write_ctx: context used for the pipeline’s own writes.

_trigger_time_rules()[源代码]¶

Run the rules for the records of self that are valid sources.

Called on create and on write of a trigger field. Records without span or not matching _get_source_extra_fields_domain() are ignored. See _trigger_time_rules_for_affected() for which rules run.

_trigger_time_rules_for_affected(affected)[源代码]¶

Run the rules that can already be decided for the given periods.

periods ending before today: all daily rules;
periods ending today or later: daily exceed rules only;
periods ending before the current week (started on the earliest week_start of the active weekly rules): weekly exceed rules.

Weekly undertime only runs from _cron_process_week_time_rules(). The end of a period is its date in the employee’s timezone; today is the server’s (UTC) date, as for the crons.

参数: affected (list) – (employee, date_from, date_to) tuples

_process_time_rules_for(affected, rule_period=None, rule_operator=None, rule_week_start=None)[源代码]¶

Evaluate and apply the active rules for the given employees and periods.

Rules are those of the current companies (or without company), filtered by rule_operator and period. Daily rules are evaluated on each employee’s covering date range, weekly rules on that range widened to whole weeks; both results are applied together through _apply_record_output().

参数

affected (list) – (employee, date_from, date_to) tuples: dates in the employee’s timezone, or UTC datetimes (naive or aware), evaluated on their dates in the employee’s timezone
rule_period (str) – 'day' or 'week' to only process that kind of rule; both if None
rule_operator (str) – 'exceed' or 'less_than' to only process that operator
rule_week_start (str) – only process the weekly rules with this week_start

_collect_time_rule_outputs(rules, ranges_by_employee)[源代码]¶

Evaluate rules on the sources of each employee’s date range; nothing is written.

Employees sharing the same range are evaluated in one _evaluate_rules call, after _on_sources_collected().

参数

rules – hr.time.rule records
ranges_by_employee (dict) – {employee: (date_from, date_to)}, dates in the employee’s timezone

返回

merged (excess, deficit, active_iv), see hr.time.rule._evaluate_rules

返回类型

_cron_process_day_undertime_rules()[源代码]¶

Cron: evaluate the daily less_than (undertime) rules on yesterday’s records.

Undertime of the current day cannot be known while the day runs, so it is not evaluated on write. A day without any source record produces no deficit.

_cron_process_week_time_rules()[源代码]¶

Cron: evaluate the weekly rules (both operators) on the week that ended yesterday.

On day X, yesterday was the last day of every week starting on X: only the rules whose week_start is X are processed, on the records ending in [X-7, X-1]. This assumes a daily run.

_get_source_records_for_time_rules(start_dt, end_dt, employees=None, check_end=False)[源代码]¶

Return the source records (as superuser) overlapping a period.

参数

start_dt (datetime) – period start, UTC (tzinfo is dropped)
end_dt (datetime) – period end, UTC (tzinfo is dropped), excluded for the overlapping records
employees – restrict to these hr.employee
check_end (bool) – select the records ending in the period instead of overlapping it

返回类型

recordset of this model

_on_sources_collected(sources)[源代码]¶

Hook called with the sources of a batch before the rules are evaluated on them.

hr_holidays reverses the allocation credits previously logged on these sources, so the evaluation starts from a clean state.

参数: sources – records of this model

_apply_record_output(rules, excess, deficit, active_iv=None)[源代码]¶

Write the pipeline result on the records; must be implemented.

Implementations delegate to a hr.time.rule method built on hr.time.rule._apply_output (_apply_attendance_output, _apply_leave_output), adding model specific effects such as allocations.

参数

rules – the hr.time.rule records that were evaluated
excess (dict) – {employee: {source: [_Iv]}}
deficit (dict) – {employee: {source: [(start, stop, rule)]}}
active_iv (dict) – {employee: {source: Intervals}}

_get_pipeline_intervals_local(schedule)[源代码]¶

Return the segments of the record that enter the pipeline.

Default: the whole span. hr.leave clips absence leaves to the schedule, so nights, breaks and days off of a leave do not count.

参数: schedule (Intervals) – schedule of the employee (naive local)
返回: list of (start, stop) naive datetimes in the employee’s timezone
返回类型: list

_get_source_extra_fields_domain()[源代码]¶

Return the domain a record must match to be a source, e.g. being validated.

返回类型: list

_get_write_source_extra_source_fields()[源代码]¶

Return the fields, besides the employee and the span, whose write triggers the rules.

返回类型: set[str]

_get_time_rule_break_hours()[源代码]¶

Return the break hours of the record, not counted as worked time by the rules.

返回类型: float

_get_time_rule_end_write_vals(end_utc, stop_local)[源代码]¶

Return the values to write to move the end of the record.

hr.leave also writes request_date_to and the request hours.

参数

end_utc (datetime) – new end, naive UTC
stop_local (datetime) – the same instant, naive in the employee’s timezone

返回类型

_get_time_rule_deficit_occupied(employee_id, start_utc, period_end_utc)[源代码]¶

Return the time already occupied by records of the employee; must be implemented.

Deficit outputs are only placed in the free slots of [start_utc, period_end_utc].

参数

employee_id (int) – employee id
start_utc (datetime) – naive UTC
period_end_utc (datetime) – naive UTC

返回

intervals of naive UTC datetimes

返回类型

Intervals

_get_time_rule_deficit_already_covered(rule, start_utc, end_utc)[源代码]¶

Return the hours already covered by outputs of the rule’s type in [start_utc, end_utc].

Makes deficit outputs idempotent: the hours placed by a previous run are deducted, so no duplicate records are created.

参数

rule – the hr.time.rule
start_utc (datetime) – naive UTC
end_utc (datetime) – naive UTC

返回类型

float

_get_time_rule_output_vals(rule, df, dt, pp)[源代码]¶

Return the creation values of an output record of rule; must be implemented.

参数

rule – the hr.time.rule producing the output
df (datetime) – start, naive UTC
dt (datetime) – end, naive UTC
pp (frozenset) – premium pay ids

返回

values with at least the employee, the span, the rule’s type, time_rule_id and the link to the source

返回类型

_get_time_rule_remainder_vals(df, dt)[源代码]¶

Return the creation values of a remainder record; must be implemented.

A remainder is a part of the source not covered by any output, when the source is cut. work_entry_type_id must be left out: the caller sets the source’s original type.

参数

df (datetime) – start, naive UTC
dt (datetime) – end, naive UTC

返回类型