#{j2ddlZddlZddlmZmZddlmZmZmZm Z ddl m Z m Z ddl mZejeZdZhdZGdd e j(Zy) N)date timedelta)_apifieldsmodels) UserErrorValidationError)Datetimez"hr_holidays.group_hr_holidays_user> name employee_idrequest_date_torequest_hour_toholiday_status_idrequest_date_fromrequest_hour_fromxeno_request_unitrequest_date_to_periodrequest_date_from_periodceZdZdZej ddZejddZ ejddd Z ej d d d Z ejddd ddZej d d d Zej ddgd dZej$fdZfdZdZfdZdZej0dZdZdZd Zd!Zd"Zd#Zej d$d%Z ejBd&d%Z"ej gd'd(d)d*+Z#ejHd,d-.Z%ejHd,d-.Z&ejHd,d-.Z'ejHd,d-.Z(ejRd/d0d1Z*ejVd2d3Z,ej gd4d5dd67Z-d8d9d:d:d;Z.ejRdZ0ejbd2d?d@dAd/dBZ2ejbd/dCdDdEdFZ3fdGZ4ej0dHZ5ej dIdJdKLZ6dMZ7dNZ8dOZ9ejRdPdQdRZ:dSZ;dTZ<ejdejRdEd/dUdPdQfdVZ=ejdejRdEd/dUdPdQfdWZ>ejdejRdEd/dUdPdQfdXZ?ejdejRdEd/dUdPdQfdYZ@ejdejRdEd/dAdZfd[ZAdsfd\ ZBfd]ZCfd^ZDd_ZEfd`ZFdaZGfdbZHfdcZIgddZJej0deZKej0dfZLej0 dtdgZMfdhZNdiZOdjZPdkdlgZQej0dmZRej0dnZSej0doZTdpZUej0dqZVej0drZWxZXS)uHrLeavehr.leave_compute_xeno_can_edit_contentzWhether the current user may edit this leave's actual content (dates/type/reason/duration). True while the request is still being drafted (no id yet) or for Time Off Officers; false for the requester once it's saved --they can only Cancel it from then on.)computehelpuidc|jjjt}|D]"}|xs|jj |_$yN)envuser has_groupHR_OFFICER_GROUP_originidxeno_can_edit_content)self is_officerleaves xeno_leave/models/hr_leave.pyrz&HrLeave._compute_xeno_can_edit_content%sHXX]],,-=>  ME+5*LEMM_compute_durationrcontextr=number_of_daysrrdaysr resource_calendar_id hours_per_daynumber_of_hours)r&r(rNrP forced_daysrFs r)rKzHrLeave._compute_durationos !# 88     > ? A++0G0GELaLa!11E4K4KKQQTUUD$)$5$5$J$J$X$X$_\_M+/E(,0=,@E)  Ahh&&**+FG  " D % 1 1 F F T T [X[ '2$(3m(C% D #r*c |jjjdry|jdj}|jdj}|D]}|jdk7s |j s|j |j }|j|Dcgc]}|j|d|d|dd c}|j}|s|j|ycc}w) aMaterialize this leave's approval chain from the configured department/employee approver steps (xeno.leave.approver.build_chain), snapshotting it onto xeno.leave.approval.step -- mirrors XENHR creating LeaveApprovalStep rows on submission. Only for leaves that actually need multi-step approval (state == 'confirm'); a leave created directly in another state (e.g. by a data import) gets no chain and falls back to legacy behavior everywhere it's checked. xeno_hr_direct_createNzxeno.leave.approverr+confirm step_orderlabelapprover_user_id)r,rVrWrX) rrLr=sudostater build_chainr?r$_xeno_current_pending_step_xeno_send_step_email)r&ApproverStepr(chainstep first_steps r)rBz"HrLeave._xeno_build_approval_chains 88     7 8 8812779xx2388: 8E{{i'u/@/@(():):;E KK  !  "HH"<0g$();$< ! " 99;J++J7 8!s,!C; c>|jjsb|jjjts9t |t z}|r%|jdrttdt|-|}d|vr|j|S)N locked_fieldszsA submitted leave request can no longer be edited directly. Cancel it and submit a new one, or ask HR to update it.rZ) rsur r!r"set_XENO_LOCKED_LEAVE_FIELDS_xeno_validation_enabledr rr>writerA)r&rDlocked_touchedresrFs r)riz HrLeave.writesxx{{488==#:#:;K#L Y)BBN$"?"?"P$!%&&gmD! d?  0 0 2 r*c |jdj}|jdj}|Dchc]F}|jr8|jr,|jj|jjfH}}|D]a\}}t |j dd|fdd|fdgjd}|j dd|fdd|fgjd|icy cc}w) agKeep xeno.leave.allocation's "Used" column (see the Leave Balance Grid pivot view) in sync with actually-validated leave. Mirrors XENHR's leave_balances.used_days -- a value HR can also manually correct on the allocation, this just keeps it accurate by default rather than requiring HR to update it by hand every time. hr.leave.allocationrr =rrZrnvalidaterMxeno_used_daysN) rrYr rr$sumsearchmappedri)r&AllocLeavelpairsemp_idtype_idtotals r)rAz'HrLeave._xeno_sync_allocation_used_dayss./446$))+EI;MMa&9&9--""A$7$7$:$:;;;$ 0OFG V,$c73*&v&' )E LLV,$c73 u&./ 0;sA C3c|jdjjdd|fdgd}| xs |jS)a0Whether an admin-toggleable leave validation (see the "Leave Validations" page / xeno.leave.validation.rule) is currently on. Fail safe: a missing row, or a rule that isn't a 'toggle' kind, is always enforced -- only an explicitly-disabled toggle rule is skipped. zxeno.leave.validation.rulecodern)kindrntogglerIlimit)rrYrsenabled)r&r}rules r)rhz HrLeave._xeno_validation_enabledsQxx45::<CCc4 "9 :!DE)T\\)r*c|jdsy|jjjdry|jjj t rC|jd}|jjjj}|r||k7ry|jd}|jd}|r|sy|jdjj|}tjj|}tjj|}|jxsd} |j xsd} | dkDr7|t#| z} || kr"t%t'd |j(| | y| dkDr7|t#| z } || kr"t%t'd |j(| | y||kr t%t'd |j(y)aEnforce per-leave-type advance-notice / max-backdate limits. Mirrors XENHR's LeaveApplicationController@store validation exactly (same priority: advance_days, else max_backdate_days, else no past dates at all) -- but only for self-service creation. XENHR's storeForEmployee (HR/admin creating *for someone else*) skips this check entirely, so here it's skipped only when a Time Off Officer is creating a request for a *different* employee than their own -- NOT simply whenever the acting user happens to hold that role. An HR officer requesting their own leave through the normal self-service flow must still be checked like anyone else (bug found in testing: susu, an HR/admin account, could book Annual Leave for tomorrow because the old check bypassed on role alone). The one unconditional bypass is xeno_hr_direct_create: that context is set only by HR-initiated on-behalf creation (the Create Leave (HR) wizard and the holiday-deduction feature), which XENHR's storeForEmployee explicitly exempts from the timing limits -- these are deliberately allowed to backdate, regardless of whose employee record it is (the wizard's target can even coincide with the acting HR user's own employee, which is exactly the case that slipped through the role/target heuristic below). timingNrTr rr hr.leave.typerrNzg%(type)s requires at least %(days)s day(s) advance notice. Earliest allowed start date is %(earliest)s.)typerNearliestz^%(type)s allows backdating up to %(days)s day(s). Earliest allowed start date is %(earliest)s.z7Start date must be today or in the future for %(type)s.)r)rhrrLr=r r!r"r r$rYbrowserDateto_date context_todayxeno_advance_daysxeno_max_backdate_daysrr rr ) r&rDtarget_employee_idown_employee_id leave_type_idr leave_type start_datetoday advance_daysmax_backdate_daysrs r)r9z HrLeave._xeno_check_leave_timings0,,X6  88     7 8  88== " "#3 4!%-!8 "hhmm77::O!&8O&K!45  HH%89$5 XXo.335<<]K [[(():;  ))$/!338q &==B ! yl;;HH$%aK#|h'PQQ%  "y.?@@HH$%aC#/@8'UVV% E!%aM#'*++"r*c|jdsy|jjjds|jdry|jjj t rC|jd}|jjjj}|r||k7ry|jd}|sy|jdxs|}tjj|}tjj|}tdtd d }g} |j|vr(| j|d ||jd ||k7r:|j|vr(| j|d ||jd | r$ttd dj!| y)aThe company is closed Saturday/Sunday -- picking a weekend as the request's start or end date is almost always an accidental mis-click on the date picker, not an intended non-working day (a multi-day request that merely *spans* a weekend in the middle, e.g. Friday to Monday, is untouched -- only the two edges the employee actually picked are checked). Blocks with a clear alert naming the offending date(s) rather than silently letting core's calendar-aware duration computation count it as 0 days. Same bypasses as _xeno_check_leave_timing: HR on-behalf creation (xeno_hr_direct_create), an Officer creating for a different employee, and any system-driven deduction (xeno_is_system_deduction -- e.g. the company-holiday deduction, which deliberately targets specific calendar dates HR chose, not something the employee picked). weekend_datesNrTxeno_is_system_deductionr rrSaturdaySunday) ()zzThe company is closed on weekends. The date you selected -- %s -- falls on a weekend. Please check the date and try again., )rhrrLr=r r!r"r r$rrrrweekdayappendr join) r&rDrrstartendrend_date weekday_namesflaggeds r)r:z!HrLeave._xeno_check_weekend_dates!s ,,_=  88     7 8DHHE_<`  88== " "#3 4!%-!8 "hhmm77::O!&8O&K,- hh()2U[[((/ ;;&&s+jMak:     = 0 NN M*BTBTBV4WX Y z !h&6&6&8M&I NN-@P@P@R2ST U !!"ii0#23 3 r*c |jdsy|jjjds|jdry|jjj t rC|jd}|jjjj}|r||k7ry|jd}|sy|jdxs|}tjj|}tjj|}|h}||k7r|j||jdjjd d d d t|zfd ddt!|zfg} g} t#|D]=} | j%| fddd} | s| j'| d| j(d?| r$t+t-ddj/| y)aA declared public/company holiday is already a non-working, unpaid-leave-exempt day by this company's policy (see _compute_duration's own docstring) -- HR deducts a real leave day for it separately via the Holiday Deduction wizard when that's actually intended, so a self-service request picking a holiday as its own start/end date is (like a weekend pick) almost always an accidental date-picker mis-click, not something the employee meant. Same edges-only semantics as _xeno_check_weekend_dates: a multi-day request that merely spans a holiday in the middle is unaffected, only the two dates the employee actually picked are checked. Same bypasses as the other submission-time checks: HR on-behalf creation (xeno_hr_direct_create -- this is exactly the path the Holiday Deduction wizard itself uses), an Officer creating for a different employee, and any system-driven deduction (xeno_is_system_deduction). holiday_datesNrTrr rrr0) resource_idrnF date_from<=z %s 23:59:59date_to>=z %s 00:00:00c|jj|cxkxr|jjkScSr)rrr)hds r)z3HrLeave._xeno_check_holiday_dates..zs-q{{//1QJ!))..:JJJr*rIrrzThe date you selected -- %s -- is a declared company holiday. Please check the date and try again; if you genuinely need this recorded as a leave day, ask HR.r)rhrrLr=r r!r"r r$rrraddrYrsmaxminsortedfilteredrr r rr) r&rDrrrrrr check_datesholidaysrrholidays r)r;z!HrLeave._xeno_check_holiday_datesMs$,,_=  88     7 8DHHE_<`  88== " "#3 4!%-!8 "hhmm77::O!&8O&K,- hh()2U[[((/ ;;&&s+!l z ! OOH %8867<<>EE ' $ K0@ @ A mc+.>> ?G    $ >A''JLLNQPGAw||<=  > !!G '" #$% % r*c|jdsy|jjjds|jdry|jjj t rC|jd}|jjjj}|r||k7ry|jd}|sy|jdxs|}tjj|}tjj|}|jdjjd d d |fd d |fg}|r-djd|D} tt!d| y)aBlocks a self-service leave request whose date range overlaps a company activity flagged Restrict Leave on These Dates (e.g. a mandatory Guest Visit day -- see xeno.hr.activity in xeno_theme_slate, whose xeno_leave already depends on). This is deliberately NOT an emergency override: there is no in-system way for the employee to bypass this themselves. A genuine emergency has to go through HR directly, who can still create the leave on the employee's behalf via the exact same on-behalf paths this check already exempts (xeno_hr_direct_create / an Officer creating for a different employee) -- the system does not auto-approve emergency overrides, matching the requested design exactly. activity_restricted_datesNrTrr rrzxeno.hr.activity)is_leave_restrictedrnTrrrrrc3nK|]-}|jd|jd|jd/yw)rz to rN)r rr).0as r) z@HrLeave._xeno_check_activity_restricted_dates..s*XGH1661;; BXs35zLeave cannot be requested for this period -- it overlaps a restricted company activity: %s. If this is a genuine emergency, contact HR directly; this cannot be self-submitted or auto-approved.)rhrrLr=r r!r"r r$rrrrYrsrr r) r&rDrrrrrr activitiesnamess r)r<z-HrLeave._xeno_check_activity_restricted_datessb,,-HI  88     7 8DHHE_<`  88== " "#3 4!%-!8 "hhmm77::O!&8O&K,- hh()2U[[((/ ;;&&s+XX01668?? . $ ) j )A  IIXLVXXE!!35: #;< < r*c^|jdsy|jjjds|jjry|jj j t}|jj jj}|jdj}|jdj}|D]L}|j}|j}|r|r |js-|jdvr<|jrI|r|j|k7r[|jxsd}|dkrq|j xs(|j"xr|j"j%} | s| j&} | j(} t%| d d } t%| | t+j,| | d } t/|j1d d |jfd d |jfd gj3d}|dz }|| z}t/|j1dd|jfd d |jfd d |jfddd| fdd| fgj3d}||z }||dzkDs| j5d}|j7||}|r t9d|}n t9d}t;t9d|j<dt?tA|ddz|dt?|dzdt?|dzdt?|dz|y)aBlock a self-service request that exceeds the pro-rated monthly entitlement of a pro-rated leave type (hr.leave.type.xeno_prorated). A pro-rated type's yearly allocation is treated as accruing evenly: per_month = yearly_total / 12, so by the request's month M the employee has accrued per_month * M days. The request is rejected if it would push the total already used/booked this year (up to and including month M) past that accrued amount. When blocked, the error also lists alternative leave types the employee actually has balance in, so it guides rather than dead-ends (see _xeno_prorated_alternatives). Bypassed for the same on-behalf/system paths as the timing check (xeno_hr_direct_create, an Officer creating for someone else, sudo, system deductions) and skipped entirely if the 'prorated_balance' rule is switched off on the Leave Validations page. prorated_balanceNrTrrmcancelrefuserrIr rnrrorMg(@r$!=rZinrU validate1rprrr{Gz?%B %Yz You could use instead: %s.zJ You have no other leave type with remaining balance -- please contact HR.u%(type)s is pro-rated: only %(avail)s day(s) are accrued by %(month)s (%(accrued)s accrued − %(used)s already used/booked this year), but you requested %(req)s.%(alt)s%g)ravailmonthaccruedusedreqalt)!rhrrLr=rer r!r"r r$rYr xeno_proratedrZrrMrrryearrcalendar monthrangerrrsrtstrftime_xeno_prorated_alternativesrr r roundr)r&r'rrvrur(ltemp requestedrr month_num year_start month_end yearly_total per_monthrconsumed available month_label alternativesalt_msgs r)r@z$HrLeave._xeno_check_prorated_balances$,,-?@  88     7 8DHHKK XX]],,-=> ((--3366$))+./446A E((B##CS(8(8{{22--cff7,,3IA~++[0ZEOODXDXDZE::D IdAq)JT9h.A.A$ .RST.UVIu||SVV,$c2551*- v&' )L %t+I)+G 5<<tUXX&SVV,$c2551E$dJ7$dI6 )v&')H (*I9t++#nnW5 $@@YO  =|LG!@AG%aP%Is(;Q"??%!E'1$55x!33i 33 '  mA r*c>|j|j}|jxs|jj j }|j dj}|j dj}|j djjdd|jfg}g}|D]} | js)|jddtd| jf9t|jd d |jfd d | jfd gjd } | dkrt|jd d |jfd d | jfdgjd } | | z } | dkr| |k\rdnd} |j| | td| jdt!| dzf|j#d|ddDcgc]}|d }}dj%|Scc}w)uA human-readable, comma-separated list of other leave types the employee can actually fall back on -- allocation types with real remaining balance (yearly allocated − used/booked this year, NOT pro-rated: the fallback is about what's genuinely available), plus no-allocation types (e.g. Unpaid) shown as unlimited. Ordered so types that fully cover the request come first, then unlimited ones, then partial balances; capped to keep the message readable. rrmrr$rrIrz %s (no limit)r rnrrorMrrrrz%(name)s (%(rem)s left)r)r remc|d|dfS)NrrI)os r)rz5HrLeave._xeno_prorated_alternatives..3sAaD!A$<r*)keyNr) ensure_oner rrrrrrYrsr$requires_allocationrrr rrrtrsortr)r& exclude_typerrrrvrutypesoptionsrr{r remainingrankrlabelss r)rz#HrLeave._xeno_prorated_alternatives s &&?$..*=*=*?EE$))+./446)..077$loo9V8WX ]B))3/277(CDE SVV,$c2551*&v&' )E z5<<SVV,$c2551E)v&' )H (ID !Y.1AD NND9*a)dU9VWEX>X/[\ ]) ],  / 0 ' ,1!A$,,yy  -s; Hz(holiday_status_id.xeno_flexible_duration)relatedreadonlyzholiday_status_id.xeno_detail))full_dayzFull-day Leave) part_timezPart-time Leave)r5zFirst-half Day Leave)r7zSecond-half Day LeavezLeave Type BasisrzOnly used (and editable) when the selected Time Off type has Flexible Duration enabled -- lets the requester pick the leave basis per request, mirroring XENHR's leave_base_types (Full-day/Part-time/First-half/Second-half).)r-r.r_compute_xeno_balance)r)rdigitsr rc F|jdj}|jdj}|D]a}|j}|j}|jj xs |j }|jj xs |j }|r"|r t |trt |tsd|_d|_ d|_ d|_ t|jdd|fdd|fdgjd}t|jdd|fdd|fdgjd} t|jdd|fdd|fd d d d gfgjd} ||_| |_ | |_ || z | z |_ dy) Nrrmrr rnrrorMrZrrUr)rrYr rr#r$ isinstanceintxeno_balance_totalxeno_balance_usedxeno_balance_pendingxeno_balance_remainingrrrsrt) r&rvrur(rrrylt_idr{rpendings r)rzHrLeave._compute_xeno_balanceWs$))+./446 BE##C((B[[^^-svvFJJMM*RUUEj.EZX]_bMc+.(*-'-0*/2, V,$c51*&v&' )E u||V,$c51*%v&' )D %,,V,$c51$K 89(v&' )G (-E $&*E #)0E &+04<'+AE (; Br*rc||jdk(rd|_d|_y|jdk(rd|_d|_yy)Nr5r6r7r8)rrrr&s r)#_onchange_xeno_request_unit_periodsz+HrLeave._onchange_xeno_request_unit_periodszsC  ! !\ 1,0D )*.D '  # #} 4,0D )*.D '5r*))dayDay)half_dayzHalf-Day)hourHours%_compute_xeno_leave_type_request_unitN) selectionrrrrrr)rrr5r7zholiday_status_id.request_unitc|D]k}|jjr8|jr,|jj |jd|_Q|jj |_my)Nr)rxeno_flexible_durationr_XENO_UNIT_MAPr=leave_type_request_unit request_unit)r&r(s r)rz-HrLeave._compute_xeno_leave_type_request_unitsf  UE&&==%BYBY040C0C0G0G++U14-160G0G0T0T-  Ur*cZ|jjr|jsd|_yyy)Nr)rrrrs r) _onchange_xeno_holiday_status_idz(HrLeave._onchange_xeno_holiday_status_ids+  ! ! 8 8AWAW%/D "BX 8r*rrrc j|jdsy|D]}|jdk7s |js |j|jkrt t d|jjxs |jjj}|r |jst|jj|jjfd}|st|jd}t!|jd}|j|dz ks|j|dzkDr~t t d |j#|j|j#|j|jj$|j#||j#| |j&dkst t d |j#|j|j#|j|jj$ y) acPart-time leave lets HR/the requester pick any clock-time range via a plain time widget, with nothing stopping them from picking a range that runs outside the employee's actual scheduled hours for that day (e.g. 15:00-19:00 when the day ends at 18:00). Catch that at save time and say exactly what's wrong. The range only needs to sit within the day's working *span* (earliest attendance start .. latest attendance end); a pick that merely crosses an unpaid lunch break in the middle is fine. The old implementation compared the raw clock span to Odoo's break-excluding number_of_hours, which falsely rejected any range spanning lunch -- e.g. 09:00-14:00 on a 09:00-12:30 / 13:30-18:00 calendar reads as 4 working hours over a 5-hour span, yet is entirely within hours. part_time_hoursNrz"End time must be after start time.c"|jk(Sr) dayofweek)rdows r)rz5HrLeave._check_xeno_part_time_hours..sQ[[TWEWr* hour_fromhour_torz%(start)s-%(end)s is outside %(employee)s's scheduled working hours that day (%(ws)s-%(we)s). Pick a range within their working hours.)rremployeewswez%(start)s-%(end)s falls entirely within a non-working period (e.g. the lunch break) for %(employee)s. Pick a range that includes working time.)rrr')rhrr rrr rrO company_idrstrrattendance_idsrrrtr_xeno_format_hourr rQ)r&r(r attendances day_startday_endr$s @r)_check_xeno_part_time_hoursz#HrLeave._check_xeno_part_time_hourss",,->? ' E&&+5U=N=N$$(?(??%a(L&MNN))>>M ,,77LL 5#:#:e--5578C#11::;WXKK..{;rIrz%(employee)s already has a leave request from %(date_from)s to %(date_to)s (%(state)s) that overlaps with this period. Cancel or wait for that request to be rejected before submitting a new one for the same day(s).rZ)r'rrrZ)rhr rrrZrsr#r$r rr rrrdict_fieldsr)r&r(conflicts r)_check_xeno_no_overlapzHrLeave._check_xeno_no_overlaps<,,Y7  E$$EOO5=={{22{{tU]]--9:U%6%6%9%9:9c5==1C1 $  #H%a #..33$kk11(2D2DE"KK//0@0@Ax//8BBCHNNS '   r*ct||D]R}|js|jjdt djdt d|_Ty)Nz?You've already booked time off which overlaps with this period:z?You've already requested leave which overlaps with this period:zDAn employee already booked time off which overlaps with this period:zDAn employee already requested leave which overlaps with this period:)r>"_compute_dashboard_warning_messagedashboard_warning_messagereplacerr&r(rFs r)r<z*HrLeave._compute_dashboard_warning_message sl 24  E22//UWXZZ\]_  + r*cHt|}t||z dz}d||fzS)N<z %02d:%02d)rr)r& hour_floatrms r)r-zHrLeave._xeno_format_hours-  O :>R' (aV##r* _compute_xeno_is_approver_for_me_search_xeno_is_approver_for_mezI am the configured approver)rrsr-c|j|jjjdj dddS)a)The lowest-step_order pending xeno.leave.approval.step for this leave, or an empty recordset if it has no materialized chain (e.g. a legacy leave from before this feature existed) -- callers must treat "no step" as "fall back to pre-chain behavior", not "blocked". c |jdk(SNrrZss r)rz4HrLeave._xeno_current_pending_step..2sagg*r*rVNrI)rrYxeno_approval_step_idsrrrs r)r\z"HrLeave._xeno_current_pending_step*sE yy{11:: *,,2F<,@!E Er*cp|jj|k(ry|jr|j|k(S|S)aXWhether acting_user may decide `step` on this leave, evaluated against an EXPLICIT user rather than self.env.user. Split out of _xeno_can_act_on_step so the searchable-field path can run this check over sudo()'d records (it has to enumerate every pending leave company-wide) without either of the two traps that come with that: env.is_superuser() is true for any sudo()'d call and would wave everything through, and reading employee_id on a leave the acting user can't see would raise AccessError instead of just excluding it. F)r user_idrX)r&ra acting_useracting_is_officers r)_xeno_step_acting_userzHrLeave._xeno_step_acting_user4s;&    # #{ 2  ((K7 7  r*c|jjry|j||jj|jjj t S)NT)r is_superuserrQr r!r"r&ras r)_xeno_can_act_on_stepzHrLeave._xeno_can_act_on_stepMsM 88 "** $((--!8!89I!JL Lr*zxeno_approval_step_ids.statez'xeno_approval_step_ids.approver_user_idcx|D]5}|j}t|xr|j||_7yr)r\boolrUxeno_is_approver_for_me)r&r(ras r)rDz(HrLeave._compute_xeno_is_approver_for_meSs> ]E335D,0J,\5;V;VW[;\E ) ]r*ct|tr|}nd|v}|dvr| }|jj}|j t }g}|j jdgD]S}|j}t|xr|j|||} | |k(s9|j|jUdd|fgS)NT)rr4z<>)rZr)rUrr$r) rrWrr r!r"rYrsr\rQrr$) r&operatorvaluewantrOrP matching_idsr(rais_mines r)rEz'HrLeave._search_xeno_is_approver_for_meYs eT "D5=D - -8D$hhmm '112BC YY['')R(ST .E335D4j6U%A%Ak#4&6G$##EHH-  . t\*++r*c|j|jjry|jj|jj k(ry|j }|r|j|Sy)aNarrows Odoo's own can_approve/can_validate/can_refuse to the acting user being allowed to act on this leave's *current pending approval-chain step* (xeno.leave.approval.step) -- a specific approver_user_id must match exactly, a blank one requires a Time Off Officer/Administrator, and earlier steps must already be approved (guaranteed by construction: the "current" step is always the lowest-order still-pending one). Never allow approving/ refusing your own leave. A leave with no materialized chain at all (created before this feature existed) falls back to Odoo's own group-based result unchanged, exactly like before this feature. Fixes a real bug found in testing: Odoo's own can_approve/ can_refuse grant any Time Off Officer approval rights over any leave, including their own -- since "My Team Leaves" approvers are Officers too (needed for Odoo's own state machine to permit the transition at all), this let any configured approver, or anyone else with that role, approve/refuse leaves that weren't theirs to decide, including self-approval. TF)rrrSr rNr r\rUrTs r)_xeno_can_approve_or_refusez#HrLeave._xeno_can_approve_or_refuse~se(  88 "    # #txx}} 4..0 --d3 3r* department_idctt||D]$}|js|j|_&yr)r>_compute_can_approve can_approver`r?s r)rczHrLeave._compute_can_approves; $& HE  $)$E$E$G! Hr*ctt||D]$}|js|j|_&yr)r>_compute_can_validate can_validater`r?s r)rfzHrLeave._compute_can_validates; %' IE!!%*%F%F%H" Ir*ctt||D]$}|js|j|_&yr)r>_compute_can_refuse can_refuser`r?s r)rizHrLeave._compute_can_refuses; #% GE#(#D#D#F  Gr*ctt||D]$}|js|j|_&yr)r>_compute_can_back_to_approvecan_back_to_approver`r?s r)rlz$HrLeave._compute_can_back_to_approves; ,. PE((,1,M,M,O) Pr*rct||jjrytj j |}|D]}|jj|jjk7r1|js|jdvrd|_ S|jxr)tj j|j}|xr||k |_ y)aReplaces core's own cancel eligibility for an employee's OWN leave with this company's actual policy: - Core never allows cancelling from 'confirm' (submitted, still awaiting the first approval step) -- only from validate1/ validate/refuse. This company wants a still-pending request to be self-cancellable too, so 'confirm'/'validate1' (pending) and 'validate' (approved) are all allowed here. - Core DOES allow cancelling an already-Refused leave -- this company doesn't want that (a rejection is a closed decision, not something to undo), so 'refuse' is excluded here. - A system deduction (company holiday / late check-in deduction -- xeno_is_system_deduction) was never something the employee asked for, so they can't cancel it themselves; only HR can reverse those (xeno_holidays' automatic reversal on holiday delete / the late-deduction cron). - Only a leave starting today or later can be self-cancelled -- same past/future philosophy as _xeno_check_leave_timing, and with no role-based bypass for the requester's OWN leave either (see that method's docstring for the exact bug this mirrors: susu, an HR/admin account, could sidestep this company's rules on their own leave just by holding the Officer role). An HR officer acting on someone ELSE's leave is untouched -- this override only ever narrows/widens the leave's own requester. NrF)r>_compute_can_cancelrrSrrrr rNr rrZ can_cancelrr)r&rr(rrFs r)rozHrLeave._compute_can_cancels8 #% 88 "  ))$/ =E  ((DHHMM9..{{*NN#( ++\ 0C0CED[D[0\E$)$;eemraction_approve_xeno_send_final_notice)r&r{ to_finalizer(rarrFs r)r~zHrLeave.action_approves;kkm  %E335Du$ 88((*53N3Nt3T#J!KLL IIK  #"hhmm..&lln  88:I""&#zz 0B0B( )0"1 ++I6u$ - %.  '; 6; 6 O  / / 1r*c|jjs'|D]"}|jrtt d|D]}|j }|s<|j jjdjddd}|sT|j jd|jjjtjdt|A}|j#|S)Nz;Only the configured approver can refuse this leave request.c |jdk(S)NrrrIrJs r)rz'HrLeave.action_refuse..'sagg3r*rVrejectedrs)rrSrjr rr\rYrLrrrir r$r r|r> action_refuser)r&r(rarkrFs r)rzHrLeave.action_refusesxx$$& +''#A)%*++ +  E335Dzz|::CC355;VL5I"#O !!'"&((--"2"2"*,,.#% .g#% $$& r*c 4|jd}|rv|jdset|dk(rW|jjj}|r5t ||j hk(rt|}|jdt|(di|S)aSuppress Odoo core's own "Your leave has been accepted/refused" notification to the requestor (hardcoded, unconditional, inside _action_validate()/action_refuse()) so they get exactly one email: our own polished _xeno_send_final_notice(). Core's call is recognizable as partner_ids pointing at nobody but the leave's own employee with no subtype override; any other message_post (our own chatter notes, notifications to other people) is untouched. partner_ids subtype_xmlidrIr) r=lenr rN partner_idrfr$r7popr>r})r&kwargsremployee_partnerrFs r)r}zHrLeave.message_post4sjj/ vzz/:s4yA~#//77BB C $49I9L9L8M$Mf =)w#-f--r*c~|jjjtst t dy)NzROnly Time Off Officers can force-approve, force-reject, or edit a submitted leave.)rr r!r"r rrs r)_xeno_check_hr_officerzHrLeave._xeno_check_hr_officerEs;xx}}&&'78AJKL L9r*cF|j|D]}t|jdjj |j }|j td|jjj||jjjdjd|jjjt!j"dt$t&|Sd }|j+|S) NrZziForce-approved by %(user)s (HR override, bypassing the normal approval chain). Previous status: %(prev)s.)r prevrxc |jdk(SrHrIrJs r)rz3HrLeave.action_xeno_force_approve..Vs!''Y.r*rrrsFrz)rr7r8rr=rZr}rrr r rYrLrrir$r r|r>rr~r)r&r(rrkrFs r)action_xeno_force_approvez!HrLeave.action_xeno_force_approveJs ##% E g.889==ekkJD   AEXX]]''d%4  5 JJL / / 8 8. e#"hhmm..&lln &GT1e1D $$& r*cN|j|jd}|r0ttd|dj|dj |D]=}|j td|jjj?|jS)Nc|jdvS)N)rrrIrws r)rz2HrLeave.action_xeno_force_reject..es!''5I*Ir*z,%s is already %s -- nothing to force-reject.rz)Force-rejected by %(user)s (HR override).)r rx) rrr r display_namerZr}rr r r)r&blockedr(s r)action_xeno_force_rejectz HrLeave.action_xeno_force_rejectcs ##%-- IJ A> '')9)9;< < WE   A;$((--BTBT%V  W W!!##r*cp|D]}|jtdtt|dS)aImmediately validate a batch of leaves created by wizard/leave_hr_create.py (HR creating directly on an employee's behalf) -- no approval chain exists on these (see the xeno_hr_direct_create context guard in _xeno_build_approval_chain), so there's nothing to mark as bypassed, just the real core validate transition, same as action_xeno_force_approve's own bypass call. zAdded by HR/Admin.rxFrz)r}rr>rr~r?s r)_xeno_hr_created_approvez HrLeave._xeno_hr_created_approveos@ =E   A&:$;  < =Wd2u2EEr*cl|D]}|jtdtt|S)aSame bypass as _xeno_hr_created_approve() above, for rejecting instead -- used by the Leave Request Import feature to backfill already-decided historical records without spamming the requestor with a real rejection email for something that was decided in the past (this module's own action_refuse() always sends one via _xeno_send_final_notice(), core's plain action_refuse() does not).z*Recorded as rejected by HR/Admin (import).rx)r}rr>rrr?s r)_xeno_hr_created_rejectzHrLeave._xeno_hr_created_reject|s= UE   A&R$S  T UWd133r*)Annual Leave . ALPersonal Leave . PLzUnpaid Leave . ULc|jd}|j}|jD]6}|jdd|fgd}|st t d|||z}8|S)aOReturns a real hr.leave.type recordset, ordered to match _XENO_HOLIDAY_DEDUCT_CASCADE_NAMES exactly (a 3-record recordset built via ordered |= concatenation, safe to unpack positionally as `annual, personal, unpaid = ...` or use recordset methods like .ids/.mapped() on directly -- unlike a plain list).rr rnrIrzLeave type '%(name)s' is required for the company holiday deduction cascade but no longer exists. Check Time Off > Configuration > Leave Types.r )rr"_XENO_HOLIDAY_DEDUCT_CASCADE_NAMESrsr rr&Typerr rs r)"_xeno_holiday_deduct_cascade_typesz*HrLeave._xeno_holiday_deduct_cascade_typessxx( ;; DvsD&9%:!DJD !  Z E  r*c |jdj}|j}t|jdd|jfdd|jfdgj d}t|jdd|jfdd|jfdgj d}t|jdd|jfdd|jfddd d gfgj d}||z |z S) Nrmr rnrrorMrZrrUr)rrYrrrsr$rt)r&r'rrurvr{rrs r)&_xeno_holiday_deduct_remaining_balancez.HrLeave._xeno_holiday_deduct_remaining_balances./446 ELL C - #z}} 5 &"   6" # % 5<< C - #z}} 5 &!   6" # % ell C - #z}} 5 dY 4 5$   6" # % t|g%%r*c X|s|jS||z jdz}|j\}}} |j} |j} |D]} |j | ||k\r|} n|j | ||k\r|} n| } | j ddj | j| jd|||xs td|r |jndddd }|jtd || j  | |z} | j| S) aCreate + immediately approve one full-day (or date_from-date_to span) leave per employee, cascading Annual -> Personal -> Unpaid per _XENO_HOLIDAY_DEDUCT_CASCADE_NAMES. Runs sudo()'d -- callers (the wizard, or xeno_holidays' automatic hook) are responsible for their own permission checks; this method just does the work. source_holiday, when given (only by xeno_holidays' automatic hook, never the manual wizard -- that one isn't tied to one specific holiday record), links the created leave back to it so deleting that holiday can find and reverse exactly the leaves it caused. rIT)rTrHrzCompany holiday deductionFr2) r rrrrr xeno_source_holiday_idrxeno_system_deduction_typez?Company holiday deduction: %(days)s day(s) charged to %(type)s.)rNrrx) rrNrrYr with_contextr?r$rr}r r)r& employeesrrreasonsource_holiday days_neededannualpersonalunpaidrvcreatedr'rr(s r) _xeno_deduct_for_company_holidayz(HrLeave._xeno_deduct_for_company_holidaysK;;= *0014 #'#J#J#L & ++-! H::8VLP[[# <.s:0Er*NzvAutomatically reversed: the Company Holiday this leave was deducted for has been deleted. The day has been given back.rx)rYrr}rr>rr)r&leavesr(rFs r)_xeno_reverse_holiday_deductionz'HrLeave._xeno_reverse_holiday_deductions]%%&EF  E   A%   gv,.r* irrc|jd}|j}|jD]6}|jdd|fgd}|st t d|||z}8|S)Nrr rnrIrzLeave type '%(name)s' is required for the late check-in deduction cascade but no longer exists. Check Time Off > Configuration > Leave Types.r)rr_XENO_LATE_DEDUCT_CASCADE_NAMESrsr rrs r)_xeno_late_deduct_cascade_typesz'HrLeave._xeno_late_deduct_cascade_typessxx( 88 DvsD&9%:!DJ5;?!ABB Z E  r*c|j\}}|jdj}|jdj}|j}|jdjj||}t ||t j ||d} | jd} t|jdd|fdd|fgjj} d } d } |jd gD]}|jd xsd }||jkr)|jd }|s=|jddt|fgd}|r|j| vrn||jz }||j z }|j#|||k\r|n|}||k(r|n|}d}d}||fD]} |jj$j'5|j)d|j+|j|jd| | t-d| ||jddd}|j/ddd|}}n|s#t4j7d|j8| y|j;t-d|| |j||j8|j+|j|||||j|jd| dz } | |z } | | fS#1swYxYw#t0t2f$r8}t4j7d|j8||j8|Yd}~d}~wwxYw)a|Sums each employee's total late-checkin minutes for the given month (xeno_attendance's own monthly report computation -- xeno.attendance.report.get_month_report, the same figure shown on the Monthly Attendance page's Late column), deducts the excess beyond the monthly grace period as a fractional leave day. Idempotent per (employee, year, month) via the unique constraint on xeno.late.deduction.log -- already-processed employees are silently skipped on a re-run (e.g. cron + manual trigger both firing for the same month). Returns (employee_count, total_days). z hr.employeezxeno.late.deduction.logzxeno.attendance.reportrIrrrnrrrrowslate employee_codexeno_employee_coderNT)rTrJrzcLate check-in deduction for %(month)s: %(minutes)s min over the %(grace)s-min monthly grace period.)rminutesgracer3)r rrrrr rrzZLate check-in deduction: could not charge %s's %.2f day(s) to %s (%s) -- trying next tier.zLate check-in deduction: skipped %s for %s -- neither Annual nor Personal could be charged (likely no valid allocation for this date). Will retry on the next run.zzLate check-in deduction: %(minutes)s min late in %(month)s (%(grace)s min grace) -> %(days).2f day(s) charged to %(type)s.)rrrrNrrx)r rr late_minutes deducted_daysrr,)rrrYget_month_reportrrrrrfrsr idsr=_XENO_LATE_DEDUCT_GRACE_MINUTESr+r$!_XENO_LATE_DEDUCT_WORKDAY_MINUTESrcr savepointrr?rrr r _loggerwarningr r})r&rrrrEmployeeLogrvreportlast_dayralreadyemployee_count total_daysrowrr}r'excess_minutes deduct_days preferredfallbackr(r candidatecandidate_leaveexcs r)_xeno_process_late_deductionsz%HrLeave._xeno_process_late_deductionss ??A88M*//1hh01668 2388:KKDRWXeX%8%8u%Ea%HI''0 cjj S$ '3!6"  ;ss ::fb)R &C776?/aLtCCC77?+D)=sCI(N'OWXYHx{{g5)D,P,PPN(4+Q+QQK;;HfM%- $-#6xFHEJ'2 I I..0C*/*<*<266A+=+!&+3;;1:1;19/7$%!8'2<&*&J&J %L 9=:J"($(@@B'C()8:E/ I<-/7mm[ J    A'%K:: z %8  9 JJ'{{D5 ,{!+EHH  a N + %JeR &hz))gCC,(3IOOF {INNCIIIs1$L*A'L LL LM-MMctjj|}|jdkDry|j dt dz }|j |j|jy)aJRuns daily (like _cron_xeno_welcome_back_from_maternity) but only acts during the first week of the month, processing the just-ended previous month -- deliberately a daily check with a day-of-month guard rather than a strict monthly interval, so a paused/delayed cron still catches up within that window instead of drifting or skipping a month. Safe to run more than once (or every day of the window): the unique constraint on xeno.late.deduction.log means only employees not yet processed for that month are ever touched.NrI)rr) rrrrr>rrrr)r&rprev_month_ends r)"_cron_xeno_process_late_deductionsz*HrLeave._cron_xeno_process_late_deductionss\ ))$/ 99q= 1- q0AA **>+>+>@T@TUr*zMaternity Leave . MLc |jdjdd|jfgd}|sytjj |t dz }|jjdd|jfd d d|fd g}|D]}|j}td |j }|j||jxs$|jr|jjnd}|r}|j!td|j |d}|jdjj#td|j ||ddj%d|_y)aDaily: an employee whose approved Maternity Leave ended yesterday is back at work today -- post a congratulations note on their employee record and email them, once per leave (guarded by xeno_welcome_back_sent). Date-driven rather than tied to their first actual attendance scan, which would depend on GPS/kiosk reliability for a one-off nice-to-have message.rr rnrIrNrrror)xeno_welcome_back_sentrnFzWelcome back, %(name)s! Congratulations on your new baby, and best wishes to your family. We're glad to have you back with the team.rrxFzWelcome back, %(name)s!u👶🎉)titlemessageemojiz mail.mailT)subject body_htmlemail_to auto_delete)rrs"_XENO_WELCOME_BACK_LEAVE_TYPE_NAMErrrrrYr$r rr r} work_emailrNemail_xeno_render_wish_email_htmlr?sendr) r&r yesterdayrr(r'rrhtmls r)&_cron_xeno_welcome_back_from_maternityz.HrLeave._cron_xeno_welcome_back_from_maternitysXXo.55c4BB C DA6O  KK--d3iQ6GG ## #z}} 5 & Y / 2 %    0E((H/5=]]DG  ! !w ! /''G*2*:*:  &&  <<5HMMJ#:=7%**,33 !:O!% %#' 5 46+/E (- 0r*c|jjddgdfdd|fdd|fg}|Dcgc]}|j|jj|jj xsd|jj jxsd|jj|j|j|j|j|jr|jjnd |jr|jjnd |jd }}|j d jjddd d gfdd|fdd|fg}||Dcgc]}d|jz|jj|jj xsd|jj jxsdddd d |j|j"r|j"jnd |j$r|j$jnd |jd k(rdnd d c}z }|Scc}wcc}w)aCompany-wide "who's on approved/pending leave" for one date -- the same data the HR Dashboard's own Employee Attendance Report widget shows (xeno_hr_dashboard), but safe to expose to every internal user (no groups= restriction), for the same widget on the self-service My Profile landing page. Deliberately NOT a raw client-side hr.leave search_read: core's own hr_holidays record rules would silently scope a regular employee down to just their own (+ direct reports') leaves there, the same "looks company-wide, is actually partial" trap already avoided elsewhere in this codebase (My Team Leaves reads xeno.leave.approver, never hr.leave, for exactly this reason). sudo()'d, and only ever returns the same handful of already-public-facing fields the HR widget shows -- no reason, no attachments, nothing sensitive. rZrrrrrr-F) r$ employeeNameposition department leaveTypeName requestUnitrequestHourFrom requestHourTo numberOfDaysrequestDateFrom requestDateTorZzhr.business.triprU acknowledgedrrzbt-%dzBusiness Trip . BTrrp)rYrsr$r r job_titlerarrrrrMr isoformatrrZrrr)r&date_strrr(rtripstrips r)xeno_get_attendance_reportz"HrLeave.xeno_get_attendance_reports? ## d@ A $ 1 h /%  $ ((!--22))33:s++99>>E#"4499 22$66"22!00FKF]F]u66@@BchBGBWBWU22<<>]b[[   0+,113:: dY7 8 $ ) h '<    DGG# ,,11((229c**88==D1%$" //=A^^t~~779QV9=T\\3355#'::#?ZY    W : s DI3CI)T)NN)Y__name__ __module__ __qualname___inheritrBooleanr%rdepends_contextrOne2manyrLrMany2onerr Selectionrmodel_create_multir?rKrBrirAmodelrhr9r:r;r<r@rrHtmlxeno_leave_type_detailrFloatr r r r dependsronchangerrrrr constrainsr1r:r<r-rXr\rQrUrDrEr`rcrfrirlror~rr}rrrrrrrrrrrrrrrrrrr __classcell__)rFs@r)rrsH*FNN05S M  M-V__"J7GI,V^^EGH -V__"+A $67 .v~~EG H"2!1!1 9 - / K "L ."DH8@ 0, YY * *=+~*3X5%n*O(-9898tS^^M; 7C$D$L( YY$$ -fnn2;\- E!2L S[[/1Z[]\] #,J<SS[[-/1Z\H\ H SS[[-/1Z\I\ I SS[[-/1Z\G\ G SS[[-/1Z\P\ P SS[[-)<>XY&=Z &=P$L"H."L 2 $ F 4&*I& YY& YY&&( YYFJ,,\/.')#(+%':rsL$''6 '  H %7 lflllr*