", so the abbreviation is the trailing
dotted segment; anything without one falls back to the full name."""
if type_name and "." in type_name:
return type_name.rsplit(".", 1)[-1].strip()
return (type_name or "").strip()
def _xeno_odoo_leaves(self, date_from, date_to, restrict_codes=None,
employee_code=None):
"""(employee_code, 'YYYY-MM-DD') -> {abbr, unit, hf, ht} for every
approved Odoo hr.leave overlapping the month. Unlike HRSystem's
frozen leave_applications (full-day only), these carry the
flexible-duration unit (part_time/first_half/second_half/full_day)
and, for part-time, the requested hour range -- which the report
needs to colour the day's pills and pick the right on-time
threshold."""
Leave = self.env["hr.leave"].sudo()
domain = [
("state", "=", "validate"),
("request_date_from", "<=", date_to),
("request_date_to", ">=", date_from),
]
if restrict_codes is not None:
domain.append(("employee_id.xeno_employee_code", "in",
[str(c) for c in restrict_codes]))
elif employee_code:
domain.append(("employee_id.xeno_employee_code", "=", str(employee_code)))
odoo_leaves = {}
for lv in Leave.search(domain):
code = lv.employee_id.xeno_employee_code
if not code:
continue
info = {
"abbr": self._xeno_leave_abbr(lv.holiday_status_id.name),
"unit": lv.xeno_request_unit or "full_day",
"hf": lv.request_hour_from,
"ht": lv.request_hour_to,
}
d, end = lv.request_date_from, lv.request_date_to
while d <= end:
ds = d.strftime("%Y-%m-%d")
if date_from <= ds <= date_to:
odoo_leaves[(str(code), ds)] = info
d += datetime.timedelta(days=1)
return odoo_leaves
def _xeno_calendar_sessions(self, codes):
"""employee_code -> {weekday '0'..'6': sorted [(hour_from, hour_to)]}
from each employee's resource.calendar, so the report can tell where
the morning session ends / the afternoon session starts (needed for
first-half / second-half leave on-time thresholds)."""
Employee = self.env["hr.employee"].sudo()
employees = Employee.search([("xeno_employee_code", "in", [str(c) for c in codes])])
sessions = {}
for emp in employees:
cal = emp.resource_calendar_id
by_dow = {}
for att in cal.attendance_ids:
by_dow.setdefault(att.dayofweek, []).append((att.hour_from, att.hour_to))
for dow in by_dow:
by_dow[dow].sort()
sessions[str(emp.xeno_employee_code)] = by_dow
return sessions
def _xeno_leave_info(self, emp_id, code, datestr, leaves, odoo_leaves):
"""Unified leave lookup for one (employee, day): the richer Odoo
record if present (carries unit + hours), else HRSystem's full-day
leave code. Returns {abbr, unit, hf, ht} or None."""
info = odoo_leaves.get((code, datestr))
if info:
return info
for lv in leaves:
if lv["employee_id"] == emp_id and lv["start"] <= datestr <= lv["end"]:
return {"abbr": lv["code"], "unit": "full_day", "hf": None, "ht": None}
return None
def _xeno_recompute_late(self, rows, days, year, month, holidays, leaves,
overrides, odoo_leaves, sessions, dayoffs=None,
business_trips=None):
"""Set each row's `late` to the sum of per-working-day lateness:
max(0, first-scan - expected start). Expected start is leave-aware
(part-time end / afternoon start for first-half / etc). A full-day
leave day is skipped (no scan expected); weekends, holidays,
HR-granted days off, and acknowledged business trips too."""
dayoffs = dayoffs or {}
business_trips = business_trips or {}
def is_weekend(d):
return datetime.date(year, month, d).weekday() >= 5
for r in rows:
emp_id = r.get("employee_id")
code = str(r.get("employee_code") or "")
sstart = (r.get("shift_start") or "09:00")[:5]
send = (r.get("shift_end") or "18:00")[:5]
emp_sessions = sessions.get(code, {})
total = 0
for d in range(1, days + 1):
datestr = "%04d-%02d-%02d" % (year, month, d)
if (is_weekend(d) or datestr in holidays
or (code, datestr) in dayoffs or (code, datestr) in business_trips):
continue
ov = overrides.get((code, datestr))
tin = (ov["time_in"] if (ov and ov["time_in"])
else self._fmt(r.get("%s.In" % datestr)))
if not tin:
continue
leave = self._xeno_leave_info(emp_id, code, datestr, leaves, odoo_leaves)
dow = str(datetime.date(year, month, d).weekday())
exp_start, _exp_end = self._xeno_expected_window(
sstart, send, emp_sessions.get(dow), leave)
if exp_start is None: # full-day leave -> no late
continue
tin_min, exp_min = self._to_minutes(tin), self._to_minutes(exp_start)
if tin_min is not None and exp_min is not None and tin_min > exp_min:
total += tin_min - exp_min
r["late"] = total
def _xeno_local_tz(self):
return timezone(
self.env.context.get("tz") or self.env.user.tz
or self.env.company.resource_calendar_id.tz or "UTC")
@api.model
def get_today_status(self, employee_code):
"""Today's merged first-in/last-out for one employee, from either
source (the biometric scanner via HRSystem, or Odoo's own
hr.attendance -- see _xeno_merge_native_attendance, which already
combines both into the same "%s.In"/"%s.Out" cells). Used by the
"My Attendance" widget to detect a fingerprint check-in that Odoo's
own hr_attendance module has no record of yet, so it can still show
Present/Check Out instead of Absent/Check In.
"""
if not employee_code:
return {"in": None, "out": None}
tz = self._xeno_local_tz()
today = datetime.datetime.now(tz).date()
data = self.get_month_report(
today.year, today.month, employee_code=employee_code,
restrict_codes=[employee_code])
datestr = today.strftime("%Y-%m-%d")
row = next(
(r for r in data["rows"] if str(r.get("employee_code")) == str(employee_code)),
None)
if not row:
return {"in": None, "out": None}
in_v = self._fmt(row.get("%s.In" % datestr))
out_v = self._fmt(row.get("%s.Out" % datestr))
# In = first scan, Out = last scan. With only one scan so far today
# (the common "checked in this morning, not out yet" case), both
# collapse to the same time -- that's a check-in with no check-out,
# so report out as empty. A real check-out is a later, distinct scan.
if in_v and out_v and in_v == out_v:
out_v = None
return {"in": in_v, "out": out_v}
def get_month_present_count(self, employee_code, year, month):
"""Distinct calendar days this month with at least one recorded
check-in for one employee, from the SAME merged source (biometric
scanner via HRSystem's vw_attendance_combined + Odoo's own native
hr.attendance, see _xeno_merge_native_attendance) as the My
Attendance report -- NOT a raw hr.attendance count. An employee who
only ever scans the physical biometric machine has zero
hr.attendance rows in Odoo, so counting hr.attendance alone (the
bug this method replaces, in xeno_mobile's own "This Month / Days
Present" card) silently showed 0 for them even with a full month of
real attendance on the desktop report.
"""
if not employee_code:
return 0
data = self.get_month_report(
year, month, employee_code=employee_code,
restrict_codes=[employee_code])
row = next(
(r for r in data["rows"] if str(r.get("employee_code")) == str(employee_code)),
None)
if not row:
return 0
suffix = ".In"
return sum(1 for k, v in row.items() if k.endswith(suffix) and v)
@api.model
def close_fingerprint_day(self, employee_id):
"""Create the Odoo-native hr.attendance record that closes out a day
that started with a fingerprint-only check-in (no hr.attendance row
yet): check_in = the fingerprint's first scan time today, check_out
= now. Everything is re-verified server-side (no open native
attendance already exists; a fingerprint "in" with no "out" really
is there today) rather than trusting the client's cached state.
"""
employee = self.env["hr.employee"].sudo().browse(employee_id)
if not employee.exists() or not employee.xeno_employee_code:
raise UserError(_("No linked employee/HRSystem code found."))
code = employee.xeno_employee_code
open_native = self._xeno_open_attendance(employee.id)
if open_native:
if self._xeno_attendance_age_hours(open_native) > STALE_CHECKIN_HOURS:
# A forgotten checkout from an earlier day, not a real
# conflict -- clean it up the same way close_stale_checkin
# does, then proceed.
self._xeno_close_stale(open_native)
else:
raise UserError(_(
"An attendance check-in already exists in Odoo -- use the "
"normal Check Out button instead."))
status = self.get_today_status(code)
if not status["in"] or status["out"]:
raise UserError(_("No open fingerprint check-in found for today."))
tz = self._xeno_local_tz()
today = datetime.datetime.now(tz).date()
hour, minute = (int(x) for x in status["in"].split(":"))
local_in = tz.localize(datetime.datetime.combine(today, datetime.time(hour, minute)))
check_in_utc = local_in.astimezone(utc).replace(tzinfo=None)
check_out_utc = datetime.datetime.utcnow()
if check_out_utc <= check_in_utc:
raise UserError(_(
"Check-out time must be after the fingerprint check-in time."))
attendance = self.env["hr.attendance"].sudo().create({
"employee_id": employee.id,
"check_in": check_in_utc,
"check_out": check_out_utc,
})
return {
"attendance_state": "checked_out",
"last_check_in": fields.Datetime.to_string(attendance.check_in),
"last_check_out": fields.Datetime.to_string(attendance.check_out),
}
def _xeno_open_attendance(self, employee_id):
return self.env["hr.attendance"].sudo().search(
[("employee_id", "=", employee_id), ("check_out", "=", False)],
limit=1, order="check_in desc")
@staticmethod
def _xeno_attendance_age_hours(attendance):
return (datetime.datetime.utcnow() - attendance.check_in).total_seconds() / 3600.0
def _xeno_close_stale(self, attendance):
"""Close a forgotten open check-in at 23:59:59 on its own calendar
day (local tz) -- a conservative marker that doesn't bleed hours
into the following day."""
tz = self._xeno_local_tz()
local_in = utc.localize(attendance.check_in).astimezone(tz)
local_end_of_day = tz.localize(
datetime.datetime.combine(local_in.date(), datetime.time(23, 59, 59)))
attendance.write({"check_out": local_end_of_day.astimezone(utc).replace(tzinfo=None)})
@api.model
def get_native_checkin_status(self, employee_id):
"""Whether the employee currently has an open (no check_out) native
hr.attendance record, and whether it's stale (see STALE_CHECKIN_HOURS)
-- Odoo's own attendance_state has no per-day boundary at all, so
this lets the My Attendance widget tell a genuinely still-open shift
from one that was simply never checked out."""
att = self._xeno_open_attendance(employee_id)
if not att:
return {"open": False, "stale": False}
return {"open": True, "stale": self._xeno_attendance_age_hours(att) > STALE_CHECKIN_HOURS}
@api.model
def close_stale_checkin(self, employee_id):
"""Auto-close a forgotten open check-in (re-verified stale
server-side) so the employee can check in fresh today."""
att = self._xeno_open_attendance(employee_id)
if not att:
return {"closed": False}
if self._xeno_attendance_age_hours(att) <= STALE_CHECKIN_HOURS:
raise UserError(_(
"This check-in isn't stale yet -- use the normal Check Out button."))
self._xeno_close_stale(att)
return {"closed": True}
def _xeno_merge_native_attendance(self, rows, year, month, days,
employee_directory, restrict_codes=None,
employee_code=None):
"""Now that XENHR is frozen (employees can no longer reach it),
check-ins happen two ways: the biometric scanners (still writing
straight to HRSystem's vw_attendance_combined, untouched) and
Odoo's own GPS/systray widget (hr.attendance, which HRSystem has
no knowledge of at all). Without this, any native Odoo check-in
silently never appears on Monthly/My/My Team Attendance -- mutates
`rows` in place: fills a blank HRSystem cell from the native scan,
or appends a whole new row for an employee HRSystem has nothing
for this month (mirrors the auto-fill append pattern below).
"""
Employee = self.env["hr.employee"].sudo()
domain = [("xeno_employee_code", "!=", False)]
if restrict_codes is not None:
domain.append(("xeno_employee_code", "in", [str(c) for c in restrict_codes]))
if employee_code:
domain.append(("xeno_employee_code", "=", str(employee_code)))
employees = Employee.search(domain)
if not employees:
return
emp_by_code = {e.xeno_employee_code: e for e in employees}
tz = self._xeno_local_tz()
# Padded a day either side in UTC to safely catch local-day
# boundary punches for a positive-offset timezone (e.g. Bangkok).
range_from = datetime.datetime(year, month, 1) - datetime.timedelta(days=1)
range_to = datetime.datetime(year, month, days) + datetime.timedelta(days=2)
atts = self.env["hr.attendance"].sudo().search([
("employee_id", "in", employees.ids),
("check_in", ">=", range_from),
("check_in", "<", range_to),
])
# (employee_code, "YYYY-MM-DD") -> {"in": [...], "out": [...]}
by_day = {}
for att in atts:
emp = att.employee_id
code = emp.xeno_employee_code
local_in = utc.localize(att.check_in).astimezone(tz)
datestr = local_in.strftime("%Y-%m-%d")
key = (code, datestr)
by_day.setdefault(key, {"in": [], "out": []})
by_day[key]["in"].append(local_in.time())
if att.check_out:
local_out = utc.localize(att.check_out).astimezone(tz)
by_day[key]["out"].append(local_out.time())
if not by_day:
return
rows_by_code = {}
for r in rows:
rows_by_code.setdefault(str(r.get("employee_code")), r)
for (code, datestr), scans in by_day.items():
first_in = min(scans["in"]) if scans["in"] else None
last_out = max(scans["out"]) if scans["out"] else None
row = rows_by_code.get(code)
if row is None:
emp = emp_by_code.get(code)
if not emp:
continue
row = {"employee_id": emp.id, "employee_code": code,
"employee_name": emp.name, "late": 0}
rows.append(row)
rows_by_code[code] = row
in_key, out_key = "%s.In" % datestr, "%s.Out" % datestr
if not row.get(in_key) and first_in:
row[in_key] = first_in
if not row.get(out_key) and last_out:
row[out_key] = last_out
# -------------------------------------------------------------- helpers
@api.model
def _esc(self, s):
return _html.escape("" if s is None else str(s))
@staticmethod
def _leave_chip_style(code):
bg, ink = LEAVE_TYPE_COLORS.get(code, LEAVE_TYPE_COLOR_DEFAULT)
return "background:%s;color:%s" % (bg, ink)
@staticmethod
def _pill_style(bg, color):
"""Inline style attr for an attendance pill: an optional leave-colour
background and/or an explicit font colour (red for late/early, the
leave ink otherwise). Empty when neither applies, so plain scans
keep the stylesheet's default look."""
parts = []
if bg:
parts.append("background:%s" % bg)
if color:
parts.append("color:%s" % color)
return ' style="%s"' % ";".join(parts) if parts else ""
@staticmethod
def _fmt(t):
"""datetime.time / str / None -> 'HH:MM' or None."""
if t is None:
return None
if isinstance(t, str):
return t[:5]
if isinstance(t, (datetime.time, datetime.datetime)):
return t.strftime("%H:%M")
return str(t)[:5]
@staticmethod
def _to_minutes(hhmm):
"""'HH:MM' -> minutes since midnight, or None."""
if not hhmm or len(hhmm) < 5:
return None
try:
return int(hhmm[:2]) * 60 + int(hhmm[3:5])
except ValueError:
return None
@staticmethod
def _hour_float_to_hhmm(hour_float):
"""9.0 -> '09:00', 14.5 -> '14:30' (part-time leave hours are floats)."""
h = int(hour_float)
m = int(round((hour_float - h) * 60))
if m == 60:
h, m = h + 1, 0
return "%02d:%02d" % (h, m)
def _xeno_expected_window(self, sstart, send, day_sessions, leave):
"""The (expected_start, expected_end) 'HH:MM' pair used to decide
late-in / early-out for one day, adjusted for any leave:
- no leave -> (shift start, shift end)
- full_day -> (None, None) (no scan expected)
- part_time (off hf..ht) -> due in at ht, out at shift end
- first_half (morning off)-> due in at the afternoon session start
- second_half (arvo off) -> in at shift start, out at morning end
day_sessions is the sorted [(hour_from, hour_to), ...] for that
weekday; when it's missing we fall back to plain shift start/end.
"""
if not leave:
return sstart, send
unit = leave.get("unit") or "full_day"
if unit == "full_day":
return None, None
if not day_sessions:
if unit == "part_time" and leave.get("ht") is not None:
return self._hour_float_to_hhmm(leave["ht"]), send
return sstart, send
morning_end = day_sessions[0][1]
afternoon_start = day_sessions[1][0] if len(day_sessions) > 1 else day_sessions[0][0]
if unit == "part_time":
es = (self._hour_float_to_hhmm(leave["ht"])
if leave.get("ht") is not None else sstart)
return es, send
if unit == "first_half":
return self._hour_float_to_hhmm(afternoon_start), send
if unit == "second_half":
return sstart, self._hour_float_to_hhmm(morning_end)
return sstart, send
# ------------------------------------------------------------- rendering
@api.model
def render_html(self, year, month, employee_code=None, restrict_codes=None,
base_url="/odoo/attendances/bymonth", team_mode=False,
my_mode=False, can_edit=False,
department_id=None, category_id=None, job_id=None):
data = self.get_month_report(year, month, employee_code, restrict_codes)
rows, days = data["rows"], data["days"]
holidays, leaves = data["holidays"], data["leaves"]
unmapped_codes = data.get("unmapped_codes") or []
overrides = data.get("overrides") or {}
odoo_leaves = data.get("odoo_leaves") or {}
sessions = data.get("sessions") or {}
dayoffs = data.get("dayoffs") or {}
business_trips = data.get("business_trips") or {}
E = self._esc
RED = "#ff2323"
def is_weekend(d):
return datetime.date(year, month, d).weekday() >= 5
# ----- header rows
h1, h2 = [], []
for d in range(1, days + 1):
datestr = "%04d-%02d-%02d" % (year, month, d)
wknd, hol = is_weekend(d), datestr in holidays
dow = datetime.date(year, month, d).strftime("%a")
klass = "hol" if hol else ("wknd" if wknd else "")
title = ' title="%s"' % E(holidays[datestr]) if hol else ""
h1.append('%d'
'%s ' % (klass, title, d, dow))
h2.append('In Out '
% (klass, klass))
# ----- body rows
auto_fill_codes = self.env["xeno.attendance.auto.rule"].sudo().get_auto_fill_codes()
body = []
for i, r in enumerate(rows):
rc = "even" if i % 2 == 0 else "odd"
emp_id = r.get("employee_id")
emp_code = str(r.get("employee_code") or "")
sstart = (r.get("shift_start") or "09:00")[:5]
send = (r.get("shift_end") or "18:00")[:5]
emp_sessions = sessions.get(emp_code, {})
cells = []
for d in range(1, days + 1):
datestr = "%04d-%02d-%02d" % (year, month, d)
wknd, hol = is_weekend(d), datestr in holidays
off = (emp_code, datestr) in dayoffs
bt = (emp_code, datestr) in business_trips
klass = "bt" if bt else ("off" if off else ("hol" if hol else ("wknd" if wknd else "")))
raw_tin = self._fmt(r.get("%s.In" % datestr))
raw_tout = self._fmt(r.get("%s.Out" % datestr))
ov = overrides.get((emp_code, datestr))
tin = (ov["time_in"] if ov and ov["time_in"] else raw_tin)
tout = (ov["time_out"] if ov and ov["time_out"] else raw_tout)
in_edited = bool(ov and ov["time_in"])
out_edited = bool(ov and ov["time_out"])
leave = (self._xeno_leave_info(emp_id, emp_code, datestr, leaves, odoo_leaves)
if not wknd and not hol and not off and not bt else None)
is_full_leave = bool(leave) and leave.get("unit") == "full_day"
lv_bg = lv_ink = None
if leave:
lv_bg, lv_ink = LEAVE_TYPE_COLORS.get(
leave["abbr"], LEAVE_TYPE_COLOR_DEFAULT)
# Late-in / early-out against the leave-aware expected window
# (a part-time / half-day leave shifts the on-time threshold).
in_late = out_early = False
if not wknd and not hol and not off and not bt and not is_full_leave:
dow = str(datetime.date(year, month, d).weekday())
exp_start, exp_end = self._xeno_expected_window(
sstart, send, emp_sessions.get(dow), leave)
if tin and exp_start and self._to_minutes(tin) > self._to_minutes(exp_start):
in_late = True
if tout and exp_end and self._to_minutes(tout) < self._to_minutes(exp_end):
out_early = True
# Auto-fill (ported from XENHR's AttendanceAutoRule/
# auto_fill): a working day with no scan at all for an
# exempted employee/department reads as Present, not blank
# (implicitly Absent) -- never overrides a real scan.
auto_filled = (not tin and not wknd and not hol and not off and not bt
and not leave and emp_code in auto_fill_codes)
in_title = out_title = ""
if bt:
bt_label = business_trips.get((emp_code, datestr))
in_title = out_title = ' title="Business Trip%s"' % (
(": " + E(bt_label)) if bt_label else "")
elif off and dayoffs.get((emp_code, datestr)):
in_title = out_title = ' title="Day off: %s"' % E(dayoffs[(emp_code, datestr)])
if in_edited:
in_title = ' title="Edited by %s on %s — source: %s%s"' % (
E(ov["editor"]), E(ov["edited_at"]), E(raw_tin or "—"),
(" — " + E(ov["note"])) if ov["note"] else "")
if out_edited:
out_title = ' title="Edited by %s on %s — source: %s%s"' % (
E(ov["editor"]), E(ov["edited_at"]), E(raw_tout or "—"),
(" — " + E(ov["note"])) if ov["note"] else "")
edit_attrs = ' data-ec="%s" data-date="%s"' % (E(emp_code), datestr) \
if can_edit else ""
# Cell contents + pill styling:
# - full-day leave: the leave abbreviation in BOTH columns,
# pill background in the leave colour.
# - part-time / half-day leave: the real scan times, pill
# background still in the leave colour.
# - late-in / early-out: red font, no background of its own.
if bt:
in_text = out_text = "BT"
elif off:
in_text = out_text = "Off"
elif is_full_leave:
in_text = out_text = E(leave["abbr"])
elif auto_filled:
in_text, out_text = "Present", (tout or "–")
else:
in_text = tin or "–"
out_text = tout or "–"
# Times keep the default (normal) font unless late/early
# (then red); only a full-day leave's abbreviation is drawn
# in the leave's own ink. The leave background applies either
# way.
in_color = RED if in_late else (lv_ink if is_full_leave else None)
out_color = RED if out_early else (lv_ink if is_full_leave else None)
in_cls = "edited" if in_edited else ("autofill" if auto_filled else "")
out_cls = "edited" if out_edited else ""
cells.append(
'%s '
% (klass, in_cls, self._pill_style(lv_bg, in_color),
in_title, edit_attrs, in_text))
cells.append(
'%s '
% (klass, out_cls, self._pill_style(lv_bg, out_color),
out_title, edit_attrs, out_text))
late = r.get("late") or 0
late_cls = "has" if late else ""
body.append(
'%s'
'%s '
'%s %s— '
'No attendance records for this month. %(title_plain)s · Xenoptics HR
%(eyebrow)s
%(title)s
Merged source: app/GPS punches + biometric machine
vw_attendance_combined → sp_get_attendance_month_V3
%(banner)s
Employee Late
(min) %(head1)s%(head2)s
%(body)s
%(nrows)s employees · %(ndays)s days · In = first scan, Out = last scan (MIN/MAX per day)
Orange = late in · Red = early out · Green = holiday · Grey = weekend · Blue dot = HR-edited · "Present" = auto-filled (no scan required)
%(edit_script)s"""
_EDIT_SCRIPT = """"""