Attendance Tracking in
Odoo 19

from odoo import models, fields, api
from odoo.exceptions import ValidationError
import math


class HrWorkLocation(models.Model):
    _inherit = 'hr.work.location'

    latitude = fields.Float('Latitude', digits=(10, 7))
    longitude = fields.Float('Longitude', digits=(10, 7))
    geofence_radius = fields.Integer(
        'Geofence Radius (m)',
        default=200,
        help="Maximum distance in meters from this location "
             "for a valid check-in.",
    )
    geofence_enabled = fields.Boolean(
        'Enforce Geofencing',
        default=False,
    )

    @api.constrains('geofence_radius')
    def _check_radius(self):
        for loc in self:
            if loc.geofence_enabled and loc.geofence_radius <= 0:
                raise ValidationError(
                    "Geofence radius must be greater than 0 meters."
                )

class HrAttendance(models.Model):
    _inherit = 'hr.attendance'

    check_in_latitude = fields.Float('Check-In Latitude', digits=(10, 7))
    check_in_longitude = fields.Float('Check-In Longitude', digits=(10, 7))
    check_in_distance = fields.Integer(
        'Distance from Location (m)',
        compute='_compute_distance',
        store=True,
    )
    geofence_violation = fields.Boolean(
        'Geofence Violation',
        default=False,
    )

    @api.depends('check_in_latitude', 'check_in_longitude')
    def _compute_distance(self):
        for att in self:
            loc = att.employee_id.work_location_id
            if not (loc and loc.geofence_enabled
                    and att.check_in_latitude):
                att.check_in_distance = 0
                continue
            att.check_in_distance = self._haversine(
                att.check_in_latitude,
                att.check_in_longitude,
                loc.latitude,
                loc.longitude,
            )

    @staticmethod
    def _haversine(lat1, lon1, lat2, lon2):
        """Return distance in meters between two GPS points."""
        R = 6_371_000  # Earth radius in meters
        phi1 = math.radians(lat1)
        phi2 = math.radians(lat2)
        d_phi = math.radians(lat2 - lat1)
        d_lambda = math.radians(lon2 - lon1)
        a = (math.sin(d_phi / 2) ** 2
             + math.cos(phi1) * math.cos(phi2)
             * math.sin(d_lambda / 2) ** 2)
        return int(R * 2 * math.atan2(
            math.sqrt(a), math.sqrt(1 - a)
        ))

    @api.model_create_multi
    def create(self, vals_list):
        records = super().create(vals_list)
        for att in records:
            loc = att.employee_id.work_location_id
            if (loc and loc.geofence_enabled
                    and att.check_in_distance > loc.geofence_radius):
                att.geofence_violation = True
                # Notify HR manager
                att._notify_geofence_violation()
        return records

    def _notify_geofence_violation(self):
        """Send an activity to the HR responsible."""
        for att in self:
            manager = att.employee_id.parent_id.user_id
            if manager:
                att.activity_schedule(
                    'mail.mail_activity_data_warning',
                    user_id=manager.id,
                    summary=f"Geofence violation: "
                            f"{{att.employee_id.name}}",
                    note=f"Checked in {{att.check_in_distance}}m "
                         f"from {{att.employee_id.work_location_id.name}} "
                         f"(limit: {{att.employee_id.work_location_id.geofence_radius}}m).",
                )

class HrAttendanceOvertime(models.Model):
    _inherit = 'hr.attendance.overtime'

    def _generate_work_entries(self):
        """Create payroll work entries from overtime tiers."""
        WorkEntry = self.env['hr.work.entry']
        entry_types = {
            'tier1': self.env.ref(
                'my_module.work_entry_overtime_tier1'
            ),
            'tier2': self.env.ref(
                'my_module.work_entry_overtime_tier2'
            ),
            'holiday': self.env.ref(
                'my_module.work_entry_overtime_holiday'
            ),
        }

        for ot in self.filtered(lambda o: o.duration > 0):
            base_dt = fields.Datetime.from_string(
                f"{{ot.date}} 17:00:00"
            )
            tiers = [
                ('tier1', ot.overtime_tier1_hours),
                ('tier2', ot.overtime_tier2_hours),
                ('holiday', ot.overtime_holiday_hours),
            ]
            offset = 0.0
            for tier_key, hours in tiers:
                if hours <= 0:
                    continue
                from datetime import timedelta
                start = base_dt + timedelta(hours=offset)
                end = start + timedelta(hours=hours)
                WorkEntry.create({
                    'name': f"{{entry_types[tier_key].name}} - "
                            f"{{ot.employee_id.name}}",
                    'employee_id': ot.employee_id.id,
                    'work_entry_type_id': entry_types[tier_key].id,
                    'date_start': start,
                    'date_stop': end,
                    'duration': hours,
                    'state': 'draft',
                })
                offset += hours