Planning & Shift Management in Odoo 19:
Schedule Your Workforce with Precision

# Install via CLI (stop-after-init for non-interactive)
./odoo-bin -c /etc/odoo/odoo.conf \
  -d your_database \
  -i planning \
  --stop-after-init

# Example: seed planning roles via a data file
# my_module/data/planning_roles.xml

<odoo>
  <data noupdate="1">
    <record id="role_cashier" model="planning.role">
      <field name="name">Cashier</field>
      <field name="color">1</field>
    </record>
    <record id="role_floor_manager" model="planning.role">
      <field name="name">Floor Manager</field>
      <field name="color">4</field>
    </record>
    <record id="role_warehouse_picker" model="planning.role">
      <field name="name">Warehouse Picker</field>
      <field name="color">5</field>
    </record>
    <record id="role_delivery_driver" model="planning.role">
      <field name="name">Delivery Driver</field>
      <field name="color">10</field>
    </record>
  </data>
</odoo>

# How Odoo internally checks resource availability
from datetime import datetime

slot_start = datetime(2026, 3, 16, 8, 0)   # Monday 08:00
slot_end = datetime(2026, 3, 16, 16, 0)    # Monday 16:00
role = env.ref('my_module.role_cashier')

# Get employees with the Cashier role
eligible = env['hr.employee'].search([
    ('planning_role_ids', 'in', role.id),
    ('company_id', '=', env.company.id),
])

# Filter by working schedule availability
available = eligible.filtered(
    lambda e: e.resource_id._check_availability(
        slot_start, slot_end
    )
)

# Further filter: no overlapping planning slots
for emp in available:
    conflicts = env['planning.slot'].search([
        ('employee_id', '=', emp.id),
        ('start_datetime', '<', slot_end),
        ('end_datetime', '>', slot_start),
        ('state', '!=', 'cancelled'),
    ])
    if conflicts:
        available -= emp

# Add minimum rest period enforcement (e.g., 11 hours between shifts)
# my_module/models/planning_slot.py

from odoo import models, api
from odoo.exceptions import ValidationError
from datetime import timedelta

class PlanningSlot(models.Model):
    _inherit = 'planning.slot'

    MIN_REST_HOURS = 11  # EU Working Time Directive

    @api.constrains('employee_id', 'start_datetime', 'end_datetime')
    def _check_minimum_rest_period(self):
        for slot in self.filtered('employee_id'):
            # Find the previous shift ending
            prev_slot = self.search([
                ('employee_id', '=', slot.employee_id.id),
                ('end_datetime', '<=', slot.start_datetime),
                ('id', '!=', slot.id),
                ('state', '!=', 'cancelled'),
            ], order='end_datetime desc', limit=1)

            if prev_slot:
                rest = (slot.start_datetime - prev_slot.end_datetime)
                min_rest = timedelta(hours=self.MIN_REST_HOURS)
                if rest < min_rest:
                    raise ValidationError(
                        f"Insufficient rest period for "
                        f"{{slot.employee_id.name}}. "
                        f"Only {{rest.total_seconds() / 3600:.1f}}h "
                        f"between shifts (minimum: "
                        f"{{self.MIN_REST_HOURS}}h)."
                    )

# How to verify an employee is not on leave before assigning
def assign_employee_to_shift(self, employee, slot):
    """Safely assign an employee, checking leave first."""
    leaves = self.env['hr.leave'].search([
        ('employee_id', '=', employee.id),
        ('state', '=', 'validate'),
        ('date_from', '<', slot.end_datetime),
        ('date_to', '>', slot.start_datetime),
    ])
    if leaves:
        return {
            'warning': {
                'title': 'Leave Conflict',
                'message': (
                    f"{{employee.name}} has approved "
                    f"leave from {{leaves[0].date_from}} "
                    f"to {{leaves[0].date_to}}. "
                    f"Cannot assign this shift."
                ),
            }
        }
    slot.write({'employee_id': employee.id})
    return True

# Extend leave approval to handle planning conflicts
# my_module/models/hr_leave.py

from odoo import models

class HrLeave(models.Model):
    _inherit = 'hr.leave'

    def action_validate(self):
        """Override to unassign conflicting planning slots."""
        res = super().action_validate()
        for leave in self:
            conflicting_slots = self.env['planning.slot'].search([
                ('employee_id', '=', leave.employee_id.id),
                ('start_datetime', '<', leave.date_to),
                ('end_datetime', '>', leave.date_from),
                ('state', '!=', 'cancelled'),
            ])
            if conflicting_slots:
                # Convert to open shifts instead of deleting
                conflicting_slots.write({
                    'employee_id': False,
                })
                # Notify the planning manager
                conflicting_slots._notify_planning_manager(
                    reason=f"Leave approved for "
                           f"{{leave.employee_id.name}}"
                )
        return res